From 758086e3edcd82dac1feb7289a657d39a2d63fb5 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Mon, 25 Nov 2024 11:24:28 -0800 Subject: [PATCH 01/13] document lazy loading --- node-operators/networks/run-a-node/flags.md | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/node-operators/networks/run-a-node/flags.md b/node-operators/networks/run-a-node/flags.md index b7554ae06..8e5043888 100644 --- a/node-operators/networks/run-a-node/flags.md +++ b/node-operators/networks/run-a-node/flags.md @@ -43,6 +43,19 @@ This guide will cover some of the most common flags and show you how to access a - **`warp`** - downloads the latest state and proof - **`--prometheus-port`** - specifies a custom Prometheus port +## Lazy Loading Flags {: #lazy-loading-flags } + +Lazy loading lets a blockchain node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. + +- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until node is fully synchronized e.g. `--fork-chain-from-rpc 'wss://moonbeam-rpc.dwellir.com'` + +You can further customize the lazy loading with the following optional parameters: + +- **`block`** - specifies the block number from which to start forking the chain +- **`fork-state-overrides`** - path to a JSON file containing state overrides to be applied when forking +- **`runtime-override`** - path to a WASM file to override the runtime when forking + + ## Flags for Configuring a SQL Backend {: #flags-for-sql-backend } - **`--frontier-backend-type`** - sets the Frontier backend type to one of the following options: From f4cefa4c2fa2afab3d336b5e41d289ad68e0b40e Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Mon, 25 Nov 2024 11:44:12 -0800 Subject: [PATCH 02/13] lazy loading --- .../run-a-node/terminal/lazy-loading.md | 13 +++++++++ node-operators/networks/run-a-node/flags.md | 7 ++--- .../networks/run-a-node/overview.md | 28 +++++++++++++++++++ 3 files changed, 44 insertions(+), 4 deletions(-) create mode 100644 .snippets/code/node-operators/networks/run-a-node/terminal/lazy-loading.md diff --git a/.snippets/code/node-operators/networks/run-a-node/terminal/lazy-loading.md b/.snippets/code/node-operators/networks/run-a-node/terminal/lazy-loading.md new file mode 100644 index 000000000..2d575aff8 --- /dev/null +++ b/.snippets/code/node-operators/networks/run-a-node/terminal/lazy-loading.md @@ -0,0 +1,13 @@ +
+ [Lazy loading 🌗] +
You are now running the Moonbeam client in lazy loading mode, where data is retrieved +
from a live RPC node on demand. +
Using remote state from: https://moonbeam.public.blastapi.io +
Forking from block: 8482853 +
To ensure the client works properly, please note the following: +
1. *Avoid Throttling*: Ensure that the backing RPC node is not limiting the number of +
requests, as this can prevent the lazy loading client from functioning correctly; +
2. *Be Patient*: As the client may take approximately 20 times longer than normal to +
retrieve and process the necessary data for the requested operation. +
The service will start in 10 seconds... +
\ No newline at end of file diff --git a/node-operators/networks/run-a-node/flags.md b/node-operators/networks/run-a-node/flags.md index 8e5043888..ca81a08e7 100644 --- a/node-operators/networks/run-a-node/flags.md +++ b/node-operators/networks/run-a-node/flags.md @@ -45,17 +45,16 @@ This guide will cover some of the most common flags and show you how to access a ## Lazy Loading Flags {: #lazy-loading-flags } -Lazy loading lets a blockchain node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. +Lazy loading lets a Moonbeam node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. -- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until node is fully synchronized e.g. `--fork-chain-from-rpc 'wss://moonbeam-rpc.dwellir.com'` +- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until node is fully synchronized e.g. `--fork-chain-from-rpc 'https://moonbeam.public.blastapi.io'` -You can further customize the lazy loading with the following optional parameters: +You can further customize your use of the lazy loading functionality with the following optional parameters: - **`block`** - specifies the block number from which to start forking the chain - **`fork-state-overrides`** - path to a JSON file containing state overrides to be applied when forking - **`runtime-override`** - path to a WASM file to override the runtime when forking - ## Flags for Configuring a SQL Backend {: #flags-for-sql-backend } - **`--frontier-backend-type`** - sets the Frontier backend type to one of the following options: diff --git a/node-operators/networks/run-a-node/overview.md b/node-operators/networks/run-a-node/overview.md index 22028302c..edfc2ed9e 100644 --- a/node-operators/networks/run-a-node/overview.md +++ b/node-operators/networks/run-a-node/overview.md @@ -88,6 +88,34 @@ There are a couple different guides to help you get started running a Moonbeam-b You can also gain access to some non-standard RPC methods by running a tracing node, which allow developers to inspect and debug transactions during runtime. Tracing nodes use a different Docker image than a standard Moonbase Alpha, Moonriver, or Moonbeam node. Check out the [Run a Tracing Node](/node-operators/networks/tracing-node/) guide and be sure to switch to the right network tab throughout the instructions. Then to interact with your tracing node, check out the [Debug & Trace](/builders/ethereum/json-rpc/debug-trace/) guide. +## Lazy Loading {: #lazy-loading } + +Lazy loading lets a Moonbeam node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. You can activate lazy loading with the following flag: + +- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until node is fully synchronized e.g. `--fork-chain-from-rpc 'https://moonbeam.public.blastapi.io'` + +Upon spooling up a node with this feature, you'll see output like the following: + +--8<-- 'code/node-operators/networks/run-a-node/terminal/lazy-loading.md' + +You can further customize your use of the lazy loading functionality with the following optional parameters: + +- **`block`** - specifies the block number from which to start forking the chain +- **`runtime-override`** - path to a WASM file to override the runtime when forking +- **`fork-state-overrides`** - path to a JSON file containing state overrides to be applied when forking + +The state overrides file should define the respective pallet, storage item, and value that you seek to override as follows: + +```json +[ + { + "pallet": "System", + "storage": "SelectedCandidates", + "value": "0x04f24ff3a9cf04c71dbc94d0b566f7a27b94566cac" + } +] +``` + ## Logs and Troubleshooting {: #logs-and-troubleshooting } You will see logs from both the relay chain and the parachain. The relay chain will be prefixed by `[Relaychain]`, while the parachain has no prefix. From 662a9cd2f3635b67cac2d0bae67ac07f7d880259 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Mon, 25 Nov 2024 11:46:13 -0800 Subject: [PATCH 03/13] grammarly --- node-operators/networks/run-a-node/flags.md | 2 +- node-operators/networks/run-a-node/overview.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/node-operators/networks/run-a-node/flags.md b/node-operators/networks/run-a-node/flags.md index ca81a08e7..2104356ae 100644 --- a/node-operators/networks/run-a-node/flags.md +++ b/node-operators/networks/run-a-node/flags.md @@ -47,7 +47,7 @@ This guide will cover some of the most common flags and show you how to access a Lazy loading lets a Moonbeam node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. -- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until node is fully synchronized e.g. `--fork-chain-from-rpc 'https://moonbeam.public.blastapi.io'` +- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until the node is fully synchronized e.g. `--fork-chain-from-rpc 'https://moonbeam.public.blastapi.io'` You can further customize your use of the lazy loading functionality with the following optional parameters: diff --git a/node-operators/networks/run-a-node/overview.md b/node-operators/networks/run-a-node/overview.md index edfc2ed9e..af00cfa9d 100644 --- a/node-operators/networks/run-a-node/overview.md +++ b/node-operators/networks/run-a-node/overview.md @@ -92,7 +92,7 @@ You can also gain access to some non-standard RPC methods by running a tracing n Lazy loading lets a Moonbeam node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. You can activate lazy loading with the following flag: -- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until node is fully synchronized e.g. `--fork-chain-from-rpc 'https://moonbeam.public.blastapi.io'` +- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until the node is fully synchronized e.g. `--fork-chain-from-rpc 'https://moonbeam.public.blastapi.io'` Upon spooling up a node with this feature, you'll see output like the following: From 312a58a88922fc0a4d389a2aebec04f850b83745 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Tue, 26 Nov 2024 13:33:58 -0800 Subject: [PATCH 04/13] rev --- node-operators/networks/run-a-node/flags.md | 8 -------- node-operators/networks/run-a-node/overview.md | 3 +++ 2 files changed, 3 insertions(+), 8 deletions(-) diff --git a/node-operators/networks/run-a-node/flags.md b/node-operators/networks/run-a-node/flags.md index 2104356ae..209bd1310 100644 --- a/node-operators/networks/run-a-node/flags.md +++ b/node-operators/networks/run-a-node/flags.md @@ -42,15 +42,7 @@ This guide will cover some of the most common flags and show you how to access a - **`fast-unsafe`** - same as `fast`, but skips downloading the state proofs - **`warp`** - downloads the latest state and proof - **`--prometheus-port`** - specifies a custom Prometheus port - -## Lazy Loading Flags {: #lazy-loading-flags } - -Lazy loading lets a Moonbeam node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. - - **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until the node is fully synchronized e.g. `--fork-chain-from-rpc 'https://moonbeam.public.blastapi.io'` - -You can further customize your use of the lazy loading functionality with the following optional parameters: - - **`block`** - specifies the block number from which to start forking the chain - **`fork-state-overrides`** - path to a JSON file containing state overrides to be applied when forking - **`runtime-override`** - path to a WASM file to override the runtime when forking diff --git a/node-operators/networks/run-a-node/overview.md b/node-operators/networks/run-a-node/overview.md index af00cfa9d..6dadae299 100644 --- a/node-operators/networks/run-a-node/overview.md +++ b/node-operators/networks/run-a-node/overview.md @@ -98,6 +98,9 @@ Upon spooling up a node with this feature, you'll see output like the following: --8<-- 'code/node-operators/networks/run-a-node/terminal/lazy-loading.md' +!!! note + Lazy loading is resource-intensive. Ensure your node meets the minimum [System Requirements](#requirements). + You can further customize your use of the lazy loading functionality with the following optional parameters: - **`block`** - specifies the block number from which to start forking the chain From f7cac5fd266b2ec12e651fa1feb43126f61764de Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Wed, 27 Nov 2024 18:48:37 -0500 Subject: [PATCH 05/13] Update node-operators/networks/run-a-node/flags.md Co-authored-by: albertov19 <64150856+albertov19@users.noreply.github.com> --- node-operators/networks/run-a-node/flags.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/node-operators/networks/run-a-node/flags.md b/node-operators/networks/run-a-node/flags.md index 209bd1310..a30698170 100644 --- a/node-operators/networks/run-a-node/flags.md +++ b/node-operators/networks/run-a-node/flags.md @@ -43,9 +43,9 @@ This guide will cover some of the most common flags and show you how to access a - **`warp`** - downloads the latest state and proof - **`--prometheus-port`** - specifies a custom Prometheus port - **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until the node is fully synchronized e.g. `--fork-chain-from-rpc 'https://moonbeam.public.blastapi.io'` -- **`block`** - specifies the block number from which to start forking the chain -- **`fork-state-overrides`** - path to a JSON file containing state overrides to be applied when forking -- **`runtime-override`** - path to a WASM file to override the runtime when forking +- **`block`** - related to lazy loading, specifies the block number from which to start forking the chain +- **`fork-state-overrides`** - related to lazy loading, path to a JSON file containing state overrides to be applied when forking +- **`runtime-override`** - related to lazy loading, path to a WASM file to override the runtime when forking ## Flags for Configuring a SQL Backend {: #flags-for-sql-backend } From 00cc34213cef4d3cff2e5d35cb3d4662e9be80f1 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Wed, 27 Nov 2024 18:48:53 -0500 Subject: [PATCH 06/13] Update node-operators/networks/run-a-node/flags.md Co-authored-by: albertov19 <64150856+albertov19@users.noreply.github.com> --- node-operators/networks/run-a-node/flags.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node-operators/networks/run-a-node/flags.md b/node-operators/networks/run-a-node/flags.md index a30698170..01729ab12 100644 --- a/node-operators/networks/run-a-node/flags.md +++ b/node-operators/networks/run-a-node/flags.md @@ -42,7 +42,7 @@ This guide will cover some of the most common flags and show you how to access a - **`fast-unsafe`** - same as `fast`, but skips downloading the state proofs - **`warp`** - downloads the latest state and proof - **`--prometheus-port`** - specifies a custom Prometheus port -- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until the node is fully synchronized e.g. `--fork-chain-from-rpc 'https://moonbeam.public.blastapi.io'` +- **`fork-chain-from-rpc`** - allows [lazy loading](/node-operators/networks/run-a-node/overview/#lazy-loading){target=\_blank} by relying on a specified RPC for network state until the node is fully synchronized e.g. `--fork-chain-from-rpc 'https://moonbeam.public.blastapi.io'` - **`block`** - related to lazy loading, specifies the block number from which to start forking the chain - **`fork-state-overrides`** - related to lazy loading, path to a JSON file containing state overrides to be applied when forking - **`runtime-override`** - related to lazy loading, path to a WASM file to override the runtime when forking From 9c7c73d7e78b30acfc1607c1950b695f14d721c7 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Wed, 27 Nov 2024 19:17:33 -0500 Subject: [PATCH 07/13] revise --- builders/get-started/endpoints.md | 36 +++++++++++++++++++ .../networks/run-a-node/overview.md | 2 +- 2 files changed, 37 insertions(+), 1 deletion(-) diff --git a/builders/get-started/endpoints.md b/builders/get-started/endpoints.md index 19c30a561..06ba975f8 100644 --- a/builders/get-started/endpoints.md +++ b/builders/get-started/endpoints.md @@ -156,6 +156,42 @@ To get started, head to the [Ankr Protocol](https://www.ankr.com/protocol){targe ![Ankr](/images/builders/get-started/endpoints/endpoints-5.webp)--> +## Lazy Loading with RPC Endpoint Providers {: #lazy-loading-with-RPC-Endpoint-Providers } + +Lazy loading lets a Moonbeam node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. + +To spin up a Moonbeam node with lazy loading, you'll need to either clone the Moonbeam release binary or use Docker. You can activate lazy loading with the following flag: + +- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until the node is fully synchronized e.g. `--fork-chain-from-rpc 'INSERT-RPC-URL'` + +Lazy loading is highly-resource intensive, requiring a large number of RPC requests to function. To avoid being throttled, it's highly recommended that you use a [dedicated endpoint](#endpoint-providers) (i.e. an endpoint with an API key) rather than a public endpoint. It's likely that that you be rate limited if you attempt to use lazy loading with a public endpoint. + +Upon spooling up a node with this feature, you'll see output like the following: + +--8<-- 'code/node-operators/networks/run-a-node/terminal/lazy-loading.md' + + +By default, you won't see detailed logging in the terminal. To override this setting and show lazy loading logs, you can add the following flag to your command to start the Moonbeam node: `-l debug` + +You can further customize your use of the lazy loading functionality with the following optional parameters: + +- **`block`** - specifies the block number from which to start forking the chain +- **`runtime-override`** - path to a WASM file to override the runtime when forking +- **`fork-state-overrides`** - path to a JSON file containing state overrides to be applied when forking + +The state overrides file should define the respective pallet, storage item, and value that you seek to override as follows: + +```json +[ + { + "pallet": "System", + "storage": "SelectedCandidates", + "value": "0x04f24ff3a9cf04c71dbc94d0b566f7a27b94566cac" + } +] +``` + + ## Tracing RPC Endpoint Providers {: #tracing-providers } Tracing RPC endpoints allow you to access non-standard RPC methods, such as those that belong to Geth's `debug` and `txpool` APIs and OpenEthereum's `trace` module. To see a list of the supported non-standard RPC methods on Moonbeam for debugging and tracing, please refer to the [Debug API & Trace Module](/builders/ethereum/json-rpc/debug-trace/){target=\_blank} guide. diff --git a/node-operators/networks/run-a-node/overview.md b/node-operators/networks/run-a-node/overview.md index 6dadae299..b77566057 100644 --- a/node-operators/networks/run-a-node/overview.md +++ b/node-operators/networks/run-a-node/overview.md @@ -99,7 +99,7 @@ Upon spooling up a node with this feature, you'll see output like the following: --8<-- 'code/node-operators/networks/run-a-node/terminal/lazy-loading.md' !!! note - Lazy loading is resource-intensive. Ensure your node meets the minimum [System Requirements](#requirements). + Lazy loading a Moonbeam requires a large number of RPC requests. To avoid being rate-limited by a public endpoint, it's highly recommended to use a [dedicated endpoint](/builders/get-started/endpoints#endpoint-providers) You can further customize your use of the lazy loading functionality with the following optional parameters: From 2caaf34142b2f4ec75dc7f2bdbf718b248ea98e6 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Wed, 27 Nov 2024 19:22:29 -0500 Subject: [PATCH 08/13] revise --- builders/get-started/endpoints.md | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/builders/get-started/endpoints.md b/builders/get-started/endpoints.md index 06ba975f8..4cfc2e62b 100644 --- a/builders/get-started/endpoints.md +++ b/builders/get-started/endpoints.md @@ -158,11 +158,9 @@ To get started, head to the [Ankr Protocol](https://www.ankr.com/protocol){targe ## Lazy Loading with RPC Endpoint Providers {: #lazy-loading-with-RPC-Endpoint-Providers } -Lazy loading lets a Moonbeam node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. +Lazy loading lets a Moonbeam node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. To spin up a Moonbeam node with lazy loading, you'll need to either clone the Moonbeam release binary or use [Docker](/node-operators/networks/run-a-node/docker/){target=_blank}. You can activate lazy loading with the following flag: -To spin up a Moonbeam node with lazy loading, you'll need to either clone the Moonbeam release binary or use Docker. You can activate lazy loading with the following flag: - -- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until the node is fully synchronized e.g. `--fork-chain-from-rpc 'INSERT-RPC-URL'` +`--fork-chain-from-rpc 'INSERT-RPC-URL'` Lazy loading is highly-resource intensive, requiring a large number of RPC requests to function. To avoid being throttled, it's highly recommended that you use a [dedicated endpoint](#endpoint-providers) (i.e. an endpoint with an API key) rather than a public endpoint. It's likely that that you be rate limited if you attempt to use lazy loading with a public endpoint. @@ -170,7 +168,6 @@ Upon spooling up a node with this feature, you'll see output like the following: --8<-- 'code/node-operators/networks/run-a-node/terminal/lazy-loading.md' - By default, you won't see detailed logging in the terminal. To override this setting and show lazy loading logs, you can add the following flag to your command to start the Moonbeam node: `-l debug` You can further customize your use of the lazy loading functionality with the following optional parameters: From 70e73cdc5a83ad8a85f8da4416d1ca8c27673734 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Wed, 27 Nov 2024 19:25:42 -0500 Subject: [PATCH 09/13] revise --- builders/get-started/endpoints.md | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/builders/get-started/endpoints.md b/builders/get-started/endpoints.md index 4cfc2e62b..32827f1c2 100644 --- a/builders/get-started/endpoints.md +++ b/builders/get-started/endpoints.md @@ -158,7 +158,7 @@ To get started, head to the [Ankr Protocol](https://www.ankr.com/protocol){targe ## Lazy Loading with RPC Endpoint Providers {: #lazy-loading-with-RPC-Endpoint-Providers } -Lazy loading lets a Moonbeam node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. To spin up a Moonbeam node with lazy loading, you'll need to either clone the Moonbeam release binary or use [Docker](/node-operators/networks/run-a-node/docker/){target=_blank}. You can activate lazy loading with the following flag: +Lazy loading lets a Moonbeam node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. To spin up a Moonbeam node with lazy loading, you'll need to either [download the Moonbeam release binary](/node-operators/networks/run-a-node/systemd/#the-release-binary){target=_blank} or use [Docker](/node-operators/networks/run-a-node/docker/){target=_blank}. You can activate lazy loading with the following flag: `--fork-chain-from-rpc 'INSERT-RPC-URL'` @@ -168,9 +168,7 @@ Upon spooling up a node with this feature, you'll see output like the following: --8<-- 'code/node-operators/networks/run-a-node/terminal/lazy-loading.md' -By default, you won't see detailed logging in the terminal. To override this setting and show lazy loading logs, you can add the following flag to your command to start the Moonbeam node: `-l debug` - -You can further customize your use of the lazy loading functionality with the following optional parameters: +By default, you won't see detailed logging in the terminal. To override this setting and show lazy loading logs, you can add the following flag to your command to start the Moonbeam node: `-l debug`. You can further customize your use of the lazy loading functionality with the following optional parameters: - **`block`** - specifies the block number from which to start forking the chain - **`runtime-override`** - path to a WASM file to override the runtime when forking From 41e6d644a0885baf4e8e64e54c5b6821c4a88ff9 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Wed, 27 Nov 2024 19:29:00 -0500 Subject: [PATCH 10/13] run grammarly --- builders/get-started/endpoints.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/builders/get-started/endpoints.md b/builders/get-started/endpoints.md index 32827f1c2..4e779454b 100644 --- a/builders/get-started/endpoints.md +++ b/builders/get-started/endpoints.md @@ -162,7 +162,7 @@ Lazy loading lets a Moonbeam node operate while downloading network state in the `--fork-chain-from-rpc 'INSERT-RPC-URL'` -Lazy loading is highly-resource intensive, requiring a large number of RPC requests to function. To avoid being throttled, it's highly recommended that you use a [dedicated endpoint](#endpoint-providers) (i.e. an endpoint with an API key) rather than a public endpoint. It's likely that that you be rate limited if you attempt to use lazy loading with a public endpoint. +Lazy loading is highly resource-intensive, requiring many RPC requests to function. To avoid being throttled, it's recommended that you use a [dedicated endpoint](#endpoint-providers) (i.e., an endpoint with an API key) rather than a public endpoint. It's likely that you will be rate-limited if you attempt to use lazy loading with a public endpoint. Upon spooling up a node with this feature, you'll see output like the following: @@ -186,7 +186,6 @@ The state overrides file should define the respective pallet, storage item, and ] ``` - ## Tracing RPC Endpoint Providers {: #tracing-providers } Tracing RPC endpoints allow you to access non-standard RPC methods, such as those that belong to Geth's `debug` and `txpool` APIs and OpenEthereum's `trace` module. To see a list of the supported non-standard RPC methods on Moonbeam for debugging and tracing, please refer to the [Debug API & Trace Module](/builders/ethereum/json-rpc/debug-trace/){target=\_blank} guide. From ac22de0e427cb5726cd5a09e8b8a41da99767298 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Wed, 27 Nov 2024 19:30:00 -0500 Subject: [PATCH 11/13] revisions --- builders/get-started/endpoints.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/builders/get-started/endpoints.md b/builders/get-started/endpoints.md index 4e779454b..f6e0bd961 100644 --- a/builders/get-started/endpoints.md +++ b/builders/get-started/endpoints.md @@ -162,7 +162,7 @@ Lazy loading lets a Moonbeam node operate while downloading network state in the `--fork-chain-from-rpc 'INSERT-RPC-URL'` -Lazy loading is highly resource-intensive, requiring many RPC requests to function. To avoid being throttled, it's recommended that you use a [dedicated endpoint](#endpoint-providers) (i.e., an endpoint with an API key) rather than a public endpoint. It's likely that you will be rate-limited if you attempt to use lazy loading with a public endpoint. +Lazy loading is highly resource-intensive, requiring many RPC requests to function. To avoid being throttled, it's recommended that you use a [dedicated endpoint](#endpoint-providers) (i.e., an endpoint with an API key) rather than a public endpoint. You will likely be rate-limited if you use lazy loading with a public endpoint. Upon spooling up a node with this feature, you'll see output like the following: From 47007eef89014f698b7dbc8fb7c7c62923eb4ad0 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Wed, 27 Nov 2024 19:33:40 -0500 Subject: [PATCH 12/13] revisions --- node-operators/networks/run-a-node/overview.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/node-operators/networks/run-a-node/overview.md b/node-operators/networks/run-a-node/overview.md index b77566057..8a5ad11e8 100644 --- a/node-operators/networks/run-a-node/overview.md +++ b/node-operators/networks/run-a-node/overview.md @@ -92,14 +92,14 @@ You can also gain access to some non-standard RPC methods by running a tracing n Lazy loading lets a Moonbeam node operate while downloading network state in the background, eliminating the need to wait for full synchronization before use. You can activate lazy loading with the following flag: -- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until the node is fully synchronized e.g. `--fork-chain-from-rpc 'https://moonbeam.public.blastapi.io'` +- **`fork-chain-from-rpc`** - allows lazy loading by relying on a specified RPC for network state until the node is fully synchronized e.g. `--fork-chain-from-rpc 'INSERT-RPC-URL'` Upon spooling up a node with this feature, you'll see output like the following: --8<-- 'code/node-operators/networks/run-a-node/terminal/lazy-loading.md' !!! note - Lazy loading a Moonbeam requires a large number of RPC requests. To avoid being rate-limited by a public endpoint, it's highly recommended to use a [dedicated endpoint](/builders/get-started/endpoints#endpoint-providers) + Lazy loading a Moonbeam requires a large number of RPC requests. To avoid being rate-limited by a public endpoint, it's highly recommended to use a [dedicated endpoint](/builders/get-started/endpoints#endpoint-providers). You can further customize your use of the lazy loading functionality with the following optional parameters: From 6eb10df10c5b2bea24894dcaeff452ef439867a1 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Wed, 27 Nov 2024 19:36:35 -0500 Subject: [PATCH 13/13] rev --- builders/get-started/endpoints.md | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/builders/get-started/endpoints.md b/builders/get-started/endpoints.md index f6e0bd961..d3017039c 100644 --- a/builders/get-started/endpoints.md +++ b/builders/get-started/endpoints.md @@ -162,9 +162,7 @@ Lazy loading lets a Moonbeam node operate while downloading network state in the `--fork-chain-from-rpc 'INSERT-RPC-URL'` -Lazy loading is highly resource-intensive, requiring many RPC requests to function. To avoid being throttled, it's recommended that you use a [dedicated endpoint](#endpoint-providers) (i.e., an endpoint with an API key) rather than a public endpoint. You will likely be rate-limited if you use lazy loading with a public endpoint. - -Upon spooling up a node with this feature, you'll see output like the following: +Lazy loading is highly resource-intensive, requiring many RPC requests to function. To avoid being throttled, it's recommended that you use a [dedicated endpoint](#endpoint-providers) (i.e., an endpoint with an API key) rather than a public endpoint. You will likely be rate-limited if you use lazy loading with a public endpoint. Upon spooling up a node with this feature, you'll see output like the following: --8<-- 'code/node-operators/networks/run-a-node/terminal/lazy-loading.md'