diff --git a/docs/fundamentals/configuration.md b/docs/fundamentals/configuration.md index 341d69e3e2..dfd39bd0e4 100644 --- a/docs/fundamentals/configuration.md +++ b/docs/fundamentals/configuration.md @@ -260,6 +260,33 @@ The configuration options are case-sensitive and can be defined only once unless ### Blocks +- #### `Blocks.BlockProductionBlobLimit` \{#blocks-blockproductionbloblimit\} + + + + ``` + --blocks-blockproductionbloblimit + --Blocks.BlockProductionBlobLimit + ``` + + + ``` + NETHERMIND_BLOCKSCONFIG_BLOCKPRODUCTIONBLOBLIMIT= + ``` + + + ```json + { + "Blocks": { + "BlockProductionBlobLimit": + } + } + ``` + + + + The max blob count after which the block producer should stop adding blobs. Minimum value is `0`. Defaults to `null`. + - #### `Blocks.BlockProductionMaxTxKilobytes` \{#blocks-blockproductionmaxtxkilobytes\} @@ -285,7 +312,7 @@ The configuration options are case-sensitive and can be defined only once unless - The max transaction bytes to add in block production, in kilobytes. Defaults to `9728`. + The max transaction bytes to add in block production, in kilobytes. Defaults to `7936`. - #### `Blocks.BlockProductionTimeoutMs` \{#blocks-blockproductiontimeoutms\} @@ -1639,6 +1666,33 @@ The configuration options are case-sensitive and can be defined only once unless Defaults to `Disabled`. +- #### `History.PruningInterval` \{#history-pruninginterval\} + + + + ``` + --history-pruninginterval + --History.PruningInterval + ``` + + + ``` + NETHERMIND_HISTORYCONFIG_PRUNINGINTERVAL= + ``` + + + ```json + { + "History": { + "PruningInterval": + } + } + ``` + + + + Number of epochs to wait between each history pruning. Defaults to `8`. + - #### `History.RetentionEpochs` \{#history-retentionepochs\} @@ -2048,33 +2102,6 @@ The configuration options are case-sensitive and can be defined only once unless The hash of the genesis block. If not specified, the genesis block validity is not checked which is useful in the case of ad hoc test/private networks. Defaults to `null`. -- #### `Init.IsMining` \{#init-ismining\} - - - - ``` - --init-ismining [true|false] - --Init.IsMining [true|false] - ``` - - - ``` - NETHERMIND_INITCONFIG_ISMINING=true|false - ``` - - - ```json - { - "Init": { - "IsMining": true|false - } - } - ``` - - - - Whether to seal/mine new blocks. Allowed values: `true` `false`. Defaults to `false`. - - #### `Init.KeepDevWalletInMemory` \{#init-keepdevwalletinmemory\} @@ -2343,7 +2370,7 @@ The configuration options are case-sensitive and can be defined only once unless - The path to the static nodes file. Defaults to `Data/static-nodes.json`. + The path to the static nodes file. Defaults to `static-nodes.json`. - #### `Init.TrustedNodesPath` \{#init-trustednodespath\} @@ -2370,7 +2397,7 @@ The configuration options are case-sensitive and can be defined only once unless - The path to the trusted nodes file. Defaults to `Data/trusted-nodes.json`. + The path to the trusted nodes file. Defaults to `trusted-nodes.json`. - #### `Init.WebSocketsEnabled` \{#init-websocketsenabled\} @@ -3316,6 +3343,33 @@ The configuration options are case-sensitive and can be defined only once unless Defaults to `None`. +- #### `JsonRpc.StrictHexFormat` \{#jsonrpc-stricthexformat\} + + + + ``` + --jsonrpc-stricthexformat [true|false] + --JsonRpc.StrictHexFormat [true|false] + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_STRICTHEXFORMAT=true|false + ``` + + + ```json + { + "JsonRpc": { + "StrictHexFormat": true|false + } + } + ``` + + + + Enable strict parsing rules for Block Params and Hashas in RPC requests. this will decrease compatibility but increase compliance with the spec. Allowed values: `true` `false`. Defaults to `true`. + - #### `JsonRpc.Timeout` \{#jsonrpc-timeout\} @@ -5359,7 +5413,7 @@ The configuration options are case-sensitive and can be defined only once unless - Maximimum number of block worth of unpersisted state in memory. Default is 297, which is number of mainnet block per hour. Defaults to `297`. + Maximum number of blocks worth of unpersisted state in memory. Default is 297, which is the number of mainnet blocks per hour. Defaults to `297`. - #### `Pruning.MinUnpersistedBlockCount` \{#pruning-minunpersistedblockcount\} @@ -6438,6 +6492,33 @@ The configuration options are case-sensitive and can be defined only once unless Number of recent L2 batches to consider for computing the moving average of gas usage. Defaults to `20`. +- #### `Surge.MaxGasLimitRatio` \{#surge-maxgaslimitratio\} + + + + ``` + --surge-maxgaslimitratio + --Surge.MaxGasLimitRatio + ``` + + + ``` + NETHERMIND_SURGECONFIG_MAXGASLIMITRATIO= + ``` + + + ```json + { + "Surge": { + "MaxGasLimitRatio": + } + } + ``` + + + + Filter transactions exceeding the max allowed ratio of gas limit to the actual gas used (e.g. 1, 2 etc.). Set to 0 to disable. Defaults to `0`. + - #### `Surge.ProofPostingGas` \{#surge-proofpostinggas\} @@ -7100,6 +7181,33 @@ The configuration options are case-sensitive and can be defined only once unless The total difficulty of the pivot block for the Fast sync mode. Defaults to `null`. +- #### `Sync.SnapServingMaxDepth` \{#sync-snapservingmaxdepth\} + + + + ``` + --sync-snapservingmaxdepth + --Sync.SnapServingMaxDepth + ``` + + + ``` + NETHERMIND_SYNCCONFIG_SNAPSERVINGMAXDEPTH= + ``` + + + ```json + { + "Sync": { + "SnapServingMaxDepth": + } + } + ``` + + + + The maximum depth (in blocks) for serving snap sync requests. Higher values allow serving requests for older blocks, useful for networks with fast block times like Arbitrum. Defaults to `128`. + - #### `Sync.SnapSync` \{#sync-snapsync\} @@ -7450,6 +7558,33 @@ The configuration options are case-sensitive and can be defined only once unless Defaults to `StorageWithReorgs`. +- #### `TxPool.CurrentBlobBaseFeeRequired` \{#txpool-currentblobbasefeerequired\} + + + + ``` + --txpool-currentblobbasefeerequired [true|false] + --TxPool.CurrentBlobBaseFeeRequired [true|false] + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_CURRENTBLOBBASEFEEREQUIRED=true|false + ``` + + + ```json + { + "TxPool": { + "CurrentBlobBaseFeeRequired": true|false + } + } + ``` + + + + Whether to require the max fee per blob gas to be greater than or equal to the current blob base fee when adding a blob transaction to the pool. Allowed values: `true` `false`. Defaults to `true`. + - #### `TxPool.GasLimit` \{#txpool-gaslimit\} @@ -7666,6 +7801,33 @@ The configuration options are case-sensitive and can be defined only once unless The minimal percentage of the current base fee that must be surpassed by the max fee (`max_fee_per_gas`) for the transaction to be broadcasted. Defaults to `70`. +- #### `TxPool.MinBlobTxPriorityFee` \{#txpool-minblobtxpriorityfee\} + + + + ``` + --txpool-minblobtxpriorityfee + --TxPool.MinBlobTxPriorityFee + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_MINBLOBTXPRIORITYFEE= + ``` + + + ```json + { + "TxPool": { + "MinBlobTxPriorityFee": + } + } + ``` + + + + The minimum priority fee in wei for blob transactions to be accepted into the transaction pool. Defaults to `0`. + - #### `TxPool.PeerNotificationThreshold` \{#txpool-peernotificationthreshold\} diff --git a/docs/interacting/json-rpc-ns/admin.md b/docs/interacting/json-rpc-ns/admin.md index 4258b5bf37..387448c606 100644 --- a/docs/interacting/json-rpc-ns/admin.md +++ b/docs/interacting/json-rpc-ns/admin.md @@ -352,6 +352,7 @@ Information about this node - `eip2929Transition`: _string_ (hex integer) - `eip2930Transition`: _string_ (hex integer) - `eip2935ContractAddress`: _string_ (address) + - `eip2935RingBufferSize`: _string_ (hex integer) - `eip2935TransitionTimestamp`: _string_ (hex integer) - `eip3198Transition`: _string_ (hex integer) - `eip3529Transition`: _string_ (hex integer) diff --git a/docs/interacting/json-rpc-ns/eth.md b/docs/interacting/json-rpc-ns/eth.md index d3bc0348cc..90af5c6e74 100644 --- a/docs/interacting/json-rpc-ns/eth.md +++ b/docs/interacting/json-rpc-ns/eth.md @@ -264,6 +264,7 @@ curl localhost:8545 \ `result`: _object_ - `accessList`: _object_ + - `error`: _string_ - `gasUsed`: _string_ (hex integer) @@ -1014,10 +1015,11 @@ Reads logs 1. `filter`: _object_ - - `address`: _object_ + - `address`: array of _object_ + - `value`: _string_ (address) - `fromBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) - `toBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) - - `topics`: array of _object_ + - `topics`: array of array of _string_ (hash) @@ -1070,7 +1072,7 @@ https://github.com/ethereum/EIPs/issues/1186 1. `accountAddress`: _string_ (address) -2. `hashRate`: array of _string_ (hex integer) +2. `storageKeys`: array of _string_ (hex integer) 3. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) @@ -1086,7 +1088,7 @@ curl localhost:8545 \ "jsonrpc": "2.0", "id": 0, "method": "eth_getProof", - "params": [accountAddress, hashRate, blockParameter] + "params": [accountAddress, storageKeys, blockParameter] }' ``` @@ -1108,7 +1110,7 @@ curl localhost:8545 \ - `nonce`: _string_ (hex integer) - `proof`: array of _string_ (hex data) - `storageProofs`: array of _object_ - - `key`: _string_ (hex data) + - `key`: _string_ - `proof`: array of _string_ (hex data) - `value`: _object_ - `hasValue`: _boolean_ @@ -1748,10 +1750,11 @@ Creates an update filter 1. `filter`: _object_ - - `address`: _object_ + - `address`: array of _object_ + - `value`: _string_ (address) - `fromBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) - `toBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) - - `topics`: array of _object_ + - `topics`: array of array of _string_ (hash) @@ -2053,7 +2056,8 @@ curl localhost:8545 \ - `calls`: array of _object_ - `error`: _object_ - `code`: _string_ (hex integer) - - `data`: _string_ + - `data`: _string_ (hex data) + - `evmException`: _integer_ - `message`: _string_ - `gasUsed`: _string_ (hex integer) - `logs`: array of _object_ @@ -2072,7 +2076,8 @@ curl localhost:8545 \ - `traces`: array of _object_ - `error`: _object_ - `code`: _string_ (hex integer) - - `data`: _string_ + - `data`: _string_ (hex data) + - `evmException`: _integer_ - `message`: _string_ - `gasUsed`: _string_ (hex integer) - `logs`: array of _object_ diff --git a/docs/monitoring/metrics/metrics.md b/docs/monitoring/metrics/metrics.md index d56d6357a6..1c5b02bcd4 100644 --- a/docs/monitoring/metrics/metrics.md +++ b/docs/monitoring/metrics/metrics.md @@ -59,7 +59,7 @@ Currently, Nethermind provides the following options to monitor and collect metr - #### `nethermind_block_processing_time_micros` \{#block_processing_time_micros\} - Histogram of block prorcessing time + Histogram of block processing time - #### `nethermind_blockchain_height` \{#blockchain_height\} @@ -447,9 +447,9 @@ Currently, Nethermind provides the following options to monitor and collect metr ### Merge -- #### `nethermind_forkchoice_upded_execution_time` \{#forkchoice_upded_execution_time\} +- #### `nethermind_forkchoice_updated_execution_time` \{#forkchoice_updated_execution_time\} - ForkchoiceUpded request execution time + ForkchoiceUpdated request execution time - #### `nethermind_get_blobs_request_duration_seconds` \{#get_blobs_request_duration_seconds\} @@ -645,7 +645,7 @@ Currently, Nethermind provides the following options to monitor and collect metr - #### `nethermind_allocator_allocations` \{#allocator_allocations\} - Allocatioons + Allocations - #### `nethermind_allocator_arena_count` \{#allocator_arena_count\} @@ -851,6 +851,10 @@ Currently, Nethermind provides the following options to monitor and collect metr Number of pending transactions received that were ignored because of fee lower than the lowest fee in transaction pool. +- #### `nethermind_pending_transactions_too_low_fee_per_blob_gas` \{#pending_transactions_too_low_fee_per_blob_gas\} + + Number of pending transactions received that were ignored because of fee per blob gas lower than minimal requirement. + - #### `nethermind_pending_transactions_too_low_priority_fee` \{#pending_transactions_too_low_priority_fee\} Number of pending transactions received that were ignored because of priority fee lower than minimal requirement. diff --git a/redirects.js b/redirects.js index e50bb22374..7f8f93318b 100644 --- a/redirects.js +++ b/redirects.js @@ -182,7 +182,7 @@ const redirects = { }, { from: '/nethermind/guides-and-helpers/how-to-reduce-database-size/full-pruning', - to: '/fundamentals/pruning' + to: '/fundamentals/state-pruning' }, { from: '/nethermind/guides-and-helpers/known-issues', diff --git a/versioned_docs/version-1.36.0/developers/_category_.json b/versioned_docs/version-1.36.0/developers/_category_.json new file mode 100644 index 0000000000..2af7339f93 --- /dev/null +++ b/versioned_docs/version-1.36.0/developers/_category_.json @@ -0,0 +1,4 @@ +{ + "position": 6, + "label": "Developers" +} diff --git a/versioned_docs/version-1.36.0/developers/building-from-source.md b/versioned_docs/version-1.36.0/developers/building-from-source.md new file mode 100644 index 0000000000..348e9f91ec --- /dev/null +++ b/versioned_docs/version-1.36.0/developers/building-from-source.md @@ -0,0 +1,123 @@ +--- +title: Building from source +sidebar_position: 0 +--- + +The Nethermind's source code can be obtained from [our repository](https://github.com/NethermindEth/nethermind) on +GitHub: + +```bash +git clone --recursive https://github.com/nethermindeth/nethermind.git +``` + +There are two options building Nethermind from source code: + +- [Standalone binaries](#building-standalone-binaries) +- [Docker image](#building-docker-image) + +:::tip +For reproducible builds, the following conditions must be met: + +- Environment variable `CI` must be set to `true`. +- Environment variable [`SOURCE_DATE_EPOCH`](https://reproducible-builds.org/docs/source-date-epoch/) must be set to the same Unix epoch for each build. +- The `SourceRevisionId` MSBuild property must be set to the same Git commit hash for each build. This is handled automatically if the `.git` directory is available in the project root. + +::: + +## Building standalone binaries + +### Prerequisites + +To build Nethermind from source, install [.NET SDK](https://aka.ms/dotnet/download) 10 or later. + +### Building + +To build both the client and tests, run the following command from the project's root directory: + +```bash +dotnet build src/Nethermind/Nethermind.slnx -c release +``` + +To simply run the client with a specific configuration without building tests, see below. + +:::info +Before running the client or tests, ensure the +platform-specific [prerequisites](../get-started/installing-nethermind#prerequisites) are met. +::: + +#### Running + +Nethermind can be launched immediately without compiling explicitly (thus, the previous step can be skipped). The following command builds Nethermind if needed and runs it: + +```bash +cd src/Nethermind/Nethermind.Runner +dotnet run -c release -- -c mainnet +``` + +All Nethermind-specific parameters can be specified after `--`. For instance, the command above specifies the Mainnet +configuration only. + +The build artifacts can be found in the `src/Nethermind/artifacts/bin/Nethermind.Runner/release` directory. By default, the logs and database directories are located here as well. + +For more info, see [Running a node](../get-started/running-node/running-node.md). + +#### Testing + +There are two test suites — Nethermind and Ethereum Foundation. Tests can be run with the following commands (the +initial step of the build is not required): + +```bash +cd src/Nethermind + +# Run Nethermind tests +dotnet test --solution Nethermind.slnx -c release + +# Run Ethereum Foundation tests +dotnet test --solution EthereumTests.slnx -c release +``` + +## Building Docker image + +:::tip +Building a Nethermind Docker image does not require cloning the Nethermind source code since Docker can build it directly from the repository. For more information, see the [Docker Docs](https://docs.docker.com/build/concepts/context/#remote-context). +::: + +Currently, there are three Docker images available in the project's root directory: + +- `Dockerfile`: the default Nethermind Docker image. +- `Dockerfile.chiseled`: the rootless and [chiseled](https://ubuntu.com/engage/chiselled-ubuntu-images-for-containers) version of the Nethermind Docker image. +- `Dockerfile.diag`: an image with pre-installed .NET diagnostics and tracing tools. This image is intended for internal use and is not distributed via public channels. + +All Docker images have the following optional arguments: + +- `BUILD_CONFIG`: the build configuration that is either `release` or `debug`. Defaults to `release`. +- `CI`: this is mostly used for CI builds determining whether the build is deterministic. Must be either `true` or `false`. Defaults to `true`. +- `COMMIT_HASH`: the Git commit hash to use as a part of the version string. +- `SOURCE_DATE_EPOCH`: the build time as a Unix timestamp. Defaults to the current time. + +Given the above, the following command builds the Nethermind chiseled Docker image from the project's root directory: + +```bash +docker build . \ + -f Dockerfile.chiseled \ + -t nethermind-chiseled \ + --build-arg COMMIT_HASH=$(git rev-parse HEAD) \ + --build-arg SOURCE_DATE_EPOCH=$(git log -1 --format=%ct) +``` + +For quick testing images, the above arguments can be omitted if not needed: + +```bash +docker build . -t nethermind +``` + +An even faster approach is to build the image directly from the repository. The following command builds the version 1.27.0: + +```bash +docker build "https://github.com/nethermindeth/nethermind.git#1.27.0" -t nethermind +``` + +The above optional arguments can be specified as well if needed. + +For more info about running Docker containers, +see [Installing Nethermind](../get-started/installing-nethermind#docker-container). diff --git a/versioned_docs/version-1.36.0/developers/plugins/_category_.json b/versioned_docs/version-1.36.0/developers/plugins/_category_.json new file mode 100644 index 0000000000..307bd30f1d --- /dev/null +++ b/versioned_docs/version-1.36.0/developers/plugins/_category_.json @@ -0,0 +1,4 @@ +{ + "position": 0, + "label": "Plugins" +} diff --git a/versioned_docs/version-1.36.0/developers/plugins/plugins.md b/versioned_docs/version-1.36.0/developers/plugins/plugins.md new file mode 100644 index 0000000000..3538e308ea --- /dev/null +++ b/versioned_docs/version-1.36.0/developers/plugins/plugins.md @@ -0,0 +1,406 @@ +--- +title: Plugins +sidebar_position: 1 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +Nethermind plugins are a powerful way of extending its capabilities by adding new features and functionalities. If you need a functionality missing in Nethermind, you can add it yourself as a plugin! Actually, many Nethermind features are implemented as plugins, like L2 network support such as Optimism and Taiko, health checks, and Shutter, to name a few. The sky is the limit. Almost. + +:::info +Nethermind plugins are .NET assemblies (.dll) that Nethermind's process loads on startup. By default, they are located in the `plugins` directory. To set a different location for plugins, use the [`--plugins-dir`](../../fundamentals/configuration.md#plugins-dir) command line option. In that case, move the bundled plugins to the new location to ensure the correct functionality of Nethermind. +::: + +:::tip +We have a dedicated [Discord channel](https://discord.gg/K8MdZT3keK) for plugin development. Please get in touch with us if you have any issues or need functionality that is not provided by the current plugin API. +::: + +This guide will walk you through writing a simple plugin to better understand the Nethermind plugin API and its capabilities. + +## Creating a basic plugin + +:::info Before you begin +Ensure you have installed the required version of the .NET SDK. See [Building from source](../building-from-source.md#prerequisites) for the details. +::: + +To write a Nethermind plugin, you need the Nethermind API to be available to your code. There are two ways of achieving that: + +- Using the [Nethermind.ReferenceAssemblies](https://www.nuget.org/packages/Nethermind.ReferenceAssemblies) NuGet package. This package is updated with each Nethermind release and is versioned the same. Thus, when choosing this approach, ensure the package version is lower than or equal to your target Nethermind version. +- Checking out the Nethermind source code and reference the required projects from the plugin. While this approach seems better for debugging your code, some setups had assembly version mismatch issues after upgrading Nethermind. + +In this guide, we will use the first approach. So, let's pick a working directory for the plugin and create a library project as follows: + +```bash +dotnet new classlib -n DemoPlugin -o . +``` + +Now, we need to add the NuGet package to get access to the Nethermind API: + +```bash +dotnet add package Nethermind.ReferenceAssemblies +``` + +As the package name implies, it provides [reference assemblies](https://learn.microsoft.com/en-us/dotnet/standard/assembly/reference-assemblies) that are only enough to compile the project. To see the plugin in action, put the library assembly (.dll) in the Nethermind's plugins directory and then run Nethermind. We will get to that soon. + +Now, we have everything we need to begin with the actual implementation. For the sake of simplicity, we will create a basic plugin, a classic example, that simply prints the famous "Hello, world!" message. + +All Nethermind plugins must implement the [`INethermindPlugin`][inethermindplugin] interface. That's how Nethermind recognizes its plugins. So, let's create a `DemoPlugin` class implementing that interface: + +```csharp title="DemoPlugin.cs" showLineNumbers +using Nethermind.Api; +using Nethermind.Api.Extensions; + +namespace DemoPlugin; + +public class DemoPlugin : INethermindPlugin +{ + public string Name => "Demo plugin"; + public string Description => "A sample plugin for demo"; + public string Author => "Anonymous"; + + // The entry point of the plugin + public Task Init(INethermindApi nethermindApi) + { + var logger = nethermindApi.LogManager.GetClassLogger(); + logger.Warn("Hello, world!"); + + return Task.CompletedTask; + } + + // Initializes the network stack + public Task InitNetworkProtocol() => Task.CompletedTask; + // Initializes the JSON-RPC stuff + public Task InitRpcModules() => Task.CompletedTask; + // Initializes the transaction-related stuff + public void InitTxTypesAndRlpDecoders(INethermindApi api) { } + // Cleans up resources + public ValueTask DisposeAsync() => default; +} +``` + +Let's examine the code above. The properties at lines 8-10 are required and self-explanatory. They are displayed on Nethermind startup for each loaded plugin. Next is the `Init()` method at line 13, which is the main entry point of any plugin where initialization begins. Its only argument of type [`INethermindApi`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Api/INethermindApi.cs) → [`IApiWithNetwork`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Api/IApiWithNetwork.cs) → [`IApiWithBlockchain`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Api/IApiWithBlockchain.cs) → [`IApiWithStores`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Api/IApiWithStores.cs) → [`IBasicApi`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Api/IBasicApi.cs) is the main gateway to the Nethermind API, as its name implies. The `INethermindApi` interface provides a rich functionality set essential for plugin development and is widely used in the Nethermind codebase. + +In line 15, we get the logger instance we need to print our message. Usually, that instance is stored in a private field to be available to other class members, but in our example, we don't need that. Once we have the instance, we log the message as a warning so you can spot it easily in the logs. + +The methods in lines 22-28 are irrelevant for this example, so they are left empty. We will get to them in later examples. + +To see our plugin in action, let's build it first: + +```bash +dotnet build +``` + +Once built, we need to copy the `DemoPlugin.dll` to Nethermind's `plugins` directory and run Nethermind. The output should be similar to the one below: + +```text +24 Jan 18:01:37 | Nethermind is starting up +... +24 Jan 18:01:37 | Loading 14 assemblies from ... +# highlight-start +24 Jan 18:01:37 | Loading assembly DemoPlugin +24 Jan 18:01:37 | Found plugin type DemoPlugin +# highlight-end +24 Jan 18:01:37 | Loading assembly Nethermind.Api +... +24 Jan 18:01:39 | Initializing 17 plugins +... +24 Jan 18:01:39 | EthStats by Nethermind +24 Jan 18:01:39 | EthStats by Nethermind initialized in 0ms +# highlight-start +24 Jan 18:01:39 | Demo plugin by Anonymous +24 Jan 18:01:39 | Hello, world! +24 Jan 18:01:39 | Demo plugin by Anonymous initialized in 0ms +# highlight-end +... +``` + +That's it! We created our very first Nethermind plugin. + +## Configuration + +As Nethermind is highly configurable, so may its plugins. The same flexible configuration features that Nethermind uses internally are also available to its plugins. That means a plugin can be configured with command line options, environment variables, and configuration files by simply implementing a single interface. + +Nethermind loads and runs all the plugins it finds on startup. This behavior may be undesirable for resource-hungry plugins or incompatible with those requiring a specific network (chain) to run on. Thus, a typical scenario for almost any plugin is to be turned on or off by a configuration setting. Let's implement that feature for our Demo plugin. + +All Nethermind configurations must implement the [`IConfig`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Config/IConfig.cs) interface. It's a 2 step process. + +First, we derive a new interface from the `IConfig` and add all the required configuration options as properties. In our case, it's a single boolean property `Enabled`: + +```csharp title="IDemoConfig.cs" showLineNumbers +using Nethermind.Config; + +namespace DemoPlugin; + +public interface IDemoConfig : IConfig +{ + // The attribute below is optional and serves as documentation + [ConfigItem(Description = "Whether to enable the Demo plugin.", DefaultValue = "false")] + bool Enabled { get; set; } +} +``` + +Second, we implement the interface above as follows: + +```csharp title="DemoConfig.cs" showLineNumbers +namespace DemoPlugin; + +public class DemoConfig : IDemoConfig +{ + public bool Enabled { get; set; } +} +``` + +That's it for the configuration. Now, let's check for the value of `Enabled` in the `Init()` method and only log the message if it's `true`: + +```csharp +public Task Init(INethermindApi nethermindApi) +{ + var logger = nethermindApi.LogManager.GetClassLogger(); + // highlight-start + var config = nethermindApi.Config(); + // highlight-end + + if (config.Enabled) + logger.Warn("Hello, world!"); + + return Task.CompletedTask; +} +``` + +The highlighted line shows how to get the configuration instance. Note that we get it by its interface type, not the implementing class. That's an important detail. + +:::warning Important +The configuration interface name must be in the `I{PluginName}Config` format. In our case, it's `IDemoConfig`. +::: + +The naming convention is crucial for mapping the configuration options. For instance, `IDemoConfig.Enabled` turns into the following configuration options: + +- `--demo-enabled` or `--Demo.Enabled` as a command line option +- `NETHERMIND_DEMOCONFIG_ENABLED` as an environment variable +- `{ "Demo": { "Enabled": true|false } }` as a JSON in a configuration file + +Since now we know what our configuration options are, let's build the project, copy the library to Nethermind's plugins directory, and run Nethermind as we did previously: + +```text +24 Jan 18:01:37 | Nethermind is starting up +... +24 Jan 18:01:37 | Loading 14 assemblies from ... +# highlight-start +24 Jan 18:01:37 | Loading assembly DemoPlugin +24 Jan 18:01:37 | Found plugin type DemoPlugin +# highlight-end +24 Jan 18:01:37 | Loading assembly Nethermind.Api +... +24 Jan 18:01:39 | Initializing 17 plugins +... +24 Jan 18:01:39 | EthStats by Nethermind +24 Jan 18:01:39 | EthStats by Nethermind initialized in 0ms +# highlight-start +24 Jan 18:01:39 | Demo plugin by Anonymous +24 Jan 18:01:39 | Demo plugin by Anonymous initialized in 0ms +# highlight-end +... +``` + +There's a slight difference compared to the previous run -- the "Hello, world!" message is gone. The reason is that we put it under an `if` condition which has not been entered because of the `IDemoConfig.Enabled` is `false` by default. Let's set it to `true` using the command line option as follows: + +```bash +nethermind --demo-enabled +``` + +Now we see that our message is back, and the configuration option works as intended! That is how to turn plugins on or off in Nethermind and provide other configuration options. + +Last, let's test our plugin configuration documentation defined at line 8 in `IDemoConfig.cs`: + +```bash +nethermind -h +``` + +The output should be similar to the following: + +```text +Description: + +Usage: + nethermind [options] + +Options: + -?, -h, --help Show help and usage information + --version Show version information +... +# highlight-start + --demo-enabled, --Demo.Enabled Whether to enable the Demo plugin. +# highlight-end + --era-exportdirectory, --Era.ExportDirectory Directory of archive export. + --era-from, --Era.From Block number to import/export from. +... +``` + +## Debugging + +As your code grows more complex and sophisticated, you may want to debug it at some point. These are the two ways to do that: + +- [Attaching the debugger to the Nethermind process](#debug-attach) +- [Debugging the plugin together with the Nethermind codebase](#debug-codebase) + +### Attaching to process \{#debug-attach\} + +This approach is preferable if you focus on your plugin only and don't need to debug the Nethermind codebase. + +:::info +This guide assumes you already have installed Nethermind. If you haven't, [install](../../get-started/installing-nethermind.md) it before moving on. +::: + +We recommend using Visual Studio or JetBrains Rider as a debugger on Windows. On Linux and macOS, we recommend JetBrains Rider. While Visual Studio Code can also attach to and debug processes, it [does not support](https://github.com/dotnet/vscode-csharp/wiki/Troubleshoot-loading-the-.NET-Debug-Services#error-cause-1-net-debugging-services-library-file-is-missing) debugging the "SingleFile" .NET distributions that Nethermind distributives are. + +:::tip +You may want to check out the following before moving on: + +- [Attach to process with Visual Studio](https://learn.microsoft.com/en-us/visualstudio/debugger/attach-to-running-processes-with-the-visual-studio-debugger) +- [Attach to process with JetBrains Rider](https://www.jetbrains.com/help/rider/attach-to-process.html) + ::: + +Before attaching the debugger to the Nethermind process, we need to ensure Nethermind will pick up our plugin. There are two ways: + +- Run Nethermind with the [`--plugins-dir`](../../fundamentals/configuration.md#plugins-dir) command line option set to the output directory of the plugin project. We recommend copying the other bundled plugins from the original `plugins` directory to the new destination as you may be required depending on your use case. +- Set the plugin project output to the Nethermind's `plugins` directory. + +Either of the above approaches will ensure Nethermind loads our plugin with the latest changes automatically. The following video demonstrates what the debugging process looks like: + +

+ +

+ +### Debugging with Nethermind codebase \{#debug-codebase\} + +Another way to debug plugins is to debug them along with the Nethermind codebase. That requires obtaining the Nethermind source code and debugging it with the IDE of your choice. Visual Studio and JetBrains Rider are the most popular choices. Let's try that with our `DemoPlugin` example. + +#### Step 1: Clone the Nethermind repo \{#debug-codebase-step-1\} + +We highly recommend cloning a stable version of the codebase to avoid any unwanted behavior on debugging. Usually, it's the [latest](https://github.com/NethermindEth/nethermind/releases/latest) released version of Nethermind. For example, the command below clones Nethermind v1.30.0: + +```bash +git clone -b "1.30.0" --depth 1 https://github.com/nethermindeth/nethermind.git +``` + +#### Step 2: Configure the startup project \{#debug-codebase-step-2\} + +In the repo's root directory, open the `src/Nethermind/Nethermind.slnx` and set the `Nethermind.Runner` as a startup project. That is the Nethermind's executable that handles everything, including plugins. + +#### Step 3: Add the plugin project to the solution \{#debug-codebase-step-3\} + +Add the `DemoPlugin` project to the solution to have everything in one place. Then, let's set the `DemoPlugin` project output to Nethermind's `plugins` directory so the latest changes are always available for `Nethermind.Runner` to pick up. Add the following to the `DemoPlugin.csproj`: + +```xml + + false + $(SolutionDir)/artifacts/bin/Nethermind.Runner/debug/plugins + +``` + +#### Step 4: Configure build dependencies \{#debug-codebase-step-4\} + +Last, let's configure build dependencies so that launching `Nethermind.Runner` automatically builds our `DemoPlugin` with its latest changes, so you don't need to build the plugin separately each time before launching the debugger. With this said, we need to make the `Nethermind.Runner` project depend on the `DemoPlugin` project. See how to configure project dependencies below: + +- [Project dependencies in Visual Studio](https://learn.microsoft.com/en-us/visualstudio/ide/how-to-create-and-remove-project-dependencies#to-assign-dependencies-to-projects) +- [Project dependencies in JetBrains Rider](https://www.jetbrains.com/help/rider/Architecture__Project_Dependencies_Exploration.html) + +
+IDE-agnostic workaround + +If your IDE doesn't provide project dependency configuration, you can achieve that functionality by referencing the `DemoPlugin` project from the `Nethermind.Runner` project. Run the following from `src/Nethermind`: + +```bash +dotnet add ./Nethermind.Runner reference path/to/DemoPlugin.csproj +``` + +Then, in the `Nethermind.Runner.csproj`, find the reference to `DemoPlugin` and disable the reference output as follows: + +```xml title="Nethermind.Runner.csproj" +... + + + false + + +... +``` + +Thus, the `DemoPlugin` won't be included in the output of `Nethermind.Runner`. This is important to avoid dependency conflicts. + +
+ +#### Launching the debugger \{#debug-codebase-launch\} + +Now, we're ready to launch the debugger and check the Nethermind logs for our plugin. You may notice that the "Hello, world!" message is missing, although Nethermind logs show the plugin is loaded. That's because we made it configurable with the `Demo.Enabled` option, which is `false` by default. Let's set it to `true`. + +The launch configurations of `Nethermind.Runner` are defined in [`launchSettings.json`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Runner/Properties/launchSettings.json). For instance, if we launch it with Hoodi, we set our `Demo.Enabled` configuration option as follows: + + + + ```json title="launchSettings.json" + ... + "Hoodi": { + "commandName": "Project", + // highlight-start + "commandLineArgs": "-c hoodi --data-dir .data --demo-enabled", + // highlight-end + "environmentVariables": { + "ASPNETCORE_ENVIRONMENT": "Development" + } + }, + ... + ``` + + + ```json title="launchSettings.json" + ... + "Hoodi": { + "commandName": "Project", + "commandLineArgs": "-c hoodi --data-dir .data", + "environmentVariables": { + "ASPNETCORE_ENVIRONMENT": "Development", + // highlight-start + "NETHERMIND_DEMOCONFIG_ENABLED": "true" + // highlight-end + } + }, + ... + ``` + + + +Now, if we launch the debugger with Hoodi, we will see our "Hello, world!" message again! + +## Plugin types + +Nethermind defines the following plugin types derived from [`INethermindPlugin`][inethermindplugin] intended for specific functionality: + +- #### [`IConsensusPlugin`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Api/Extensions/IConsensusPlugin.cs) + + Plugins of this type provide support for consensus algorithms. For example, see the [`OptimismPlugin`][optimismplugin] or [`EthashPlugin`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Consensus.Ethash/EthashPlugin.cs). + +- #### [`IConsensusWrapperPlugin`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Api/Extensions/IConsensusWrapperPlugin.cs) + + Plugins of this type extend or change the handling of the Ethereum PoS consensus algorithm. For example, see the [`MergePlugin`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Merge.Plugin/MergePlugin.cs) or [`ShutterPlugin`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Shutter/ShutterPlugin.cs). + +- #### [`IInitializationPlugin`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Api/Extensions/IInitializationPlugin.cs) + + Plugins of this type define _steps_ required to complete during Nethermind initialization. For example, see the [`SnapshotPlugin`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Init.Snapshot/SnapshotPlugin.cs). + +- #### [`ISynchronizationPlugin`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Api/Extensions/ISynchronizationPlugin.cs) + + Plugins of this type implement a custom sync logic. For example, see the [`OptimismPlugin`][optimismplugin] or [`TaikoPlugin`][taikoplugin]. + +## Samples + +- [JSON-RPC handler](./samples/json-rpc-handler.md) +- _More to be added later_ + +[inethermindplugin]: https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Api/Extensions/INethermindPlugin.cs +[optimismplugin]: https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Optimism/OptimismPlugin.cs +[taikoplugin]: https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Taiko/TaikoPlugin.cs diff --git a/versioned_docs/version-1.36.0/developers/plugins/samples/_category_.json b/versioned_docs/version-1.36.0/developers/plugins/samples/_category_.json new file mode 100644 index 0000000000..d571b6d311 --- /dev/null +++ b/versioned_docs/version-1.36.0/developers/plugins/samples/_category_.json @@ -0,0 +1,4 @@ +{ + "position": 0, + "label": "Samples" +} diff --git a/versioned_docs/version-1.36.0/developers/plugins/samples/json-rpc-handler.md b/versioned_docs/version-1.36.0/developers/plugins/samples/json-rpc-handler.md new file mode 100644 index 0000000000..b6b47164c7 --- /dev/null +++ b/versioned_docs/version-1.36.0/developers/plugins/samples/json-rpc-handler.md @@ -0,0 +1,204 @@ +--- +title: JSON-RPC handler +sidebar_position: 0 +--- + +In this guide we're going to create a plugin that adds a new JSON-RPC method to Nethermind and handles all the requests with that method. + +:::info Before you begin +This guide assumes you have read the [introduction](../plugins.md) to plugins. +::: + +In Nethermind, JSON-RPC functionality is an extensible combination of various modules grouped by their responsibilities. For instance, the `eth_`-prefixed methods, well known by all RPC users, are handled by the `IEthRpcModule`. By design, RPC modules must have their respective interface derived from the [`IRpcModule`][irpcmodule] and a class implementing that interface. + +Let's create our `IDemoRpcModule` interface and implement it in `DemoRpcModule` class: + +```csharp title="IDemoRpcModule.cs" showLineNumbers +using Nethermind.JsonRpc; +using Nethermind.JsonRpc.Modules; + +namespace DemoRpcPlugin; + +//highlight-start +[RpcModule("Demo")] +//highlight-end +public interface IDemoRpcModule : IRpcModule +{ + ResultWrapper demo_divide(int x, int y); +} +``` + +Although the interface above is straightforward, it needs some explanation. Since the [`IRpcModule`][irpcmodule] is an empty interface, there's nothing specific to implement besides our RPC methods. Each RPC method is a regular interface method with the same name in the code. So, if we want to have `demo_divide` RPC method, we declare a method (function) named the same. If we need to pass parameters with our RPC call, we define those parameters as function arguments with their respective types. In this example, we create a method that takes two integer parameters, `x` (dividend) and `y` (divisor), divides one to another, and returns their quotient, as a string. All RPC methods' return type is [`ResultWrapper`][resultwrapper], where the `T` is the actual data type we intend to return in the response. If a method is async, the return type must be `Task>`. We will showcase that in later examples. Last but not least, in line 6, the interface is decorated with [`RpcModule`][rpcmoduleattr] attribute that sets the name of our module used in configuration settings. We will see its importance later when we try to make a request. + +Now, let's begin with the actual implementation: + +```csharp title="DemoRpcModule.cs" showLineNumbers +using Nethermind.JsonRpc; + +namespace DemoRpcPlugin; + +public class DemoRpcModule : IDemoRpcModule +{ + public ResultWrapper demo_divide(int x, int y) + { + if (y == 0) +//highlight-start + return ResultWrapper.Fail("Divisor cannot be zero", float.NaN.ToString()); +//highlight-end + + var result = (float)x / y; + +//highlight-start + return ResultWrapper.Success(result.ToString()); +//highlight-end + } +} +``` + +The [`ResultWrapper`][resultwrapper] provides two statuses -- success and failure. We use the latter when the divisor is zero to show a meaningful error message to the user and some data if needed, `NaN` in our case. + +Now when we have all we need, we should let Nethermind know about our RPC module by registering it with [`IRpcModuleProvider`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.JsonRpc/Modules/IRpcModuleProvider.cs) in the dedicated `InitRpcModules()` method as follows: + +```csharp title="DemoRpcPlugin.cs" showLineNumbers +using Nethermind.Api; +using Nethermind.Api.Extensions; +using Nethermind.JsonRpc.Modules; + +namespace DemoRpcPlugin; + +public class DemoRpcPlugin : INethermindPlugin +{ + private INethermindApi? _api; + + public string Name => "Demo JSON-RPC plugin"; + public string Description => "A sample plugin for demo"; + public string Author => "Anonymous"; + + public Task Init(INethermindApi nethermindApi) + { + _api = nethermindApi; + + return Task.CompletedTask; + } + + public Task InitNetworkProtocol() => Task.CompletedTask; + +// highlight-start + public Task InitRpcModules() + { + _api?.RpcModuleProvider?.RegisterSingle(new DemoRpcModule()); + + return Task.CompletedTask; + } +// highlight-end + + public void InitTxTypesAndRlpDecoders(INethermindApi api) { } + public ValueTask DisposeAsync() => default; +} +``` + +Although the highlighted code is mainly self-explanatory, there's a caveat. The `RegisterSingle()` method expects the `T` to be an interface, not a class. The following snippet demonstrates that: + +```csharp +// Error: Module factory type should be an interface... +_api.RpcModuleProvider.RegisterSingle(new DemoRpcModule()); + +// Error: Module factory type should be an interface... +var module = new DemoRpcModule(); +_api.RpcModuleProvider.RegisterSingle(module); + +// OK +IDemoRpcModule module = new DemoRpcModule(); +_api.RpcModuleProvider.RegisterSingle(module); + +// OK +var module = new DemoRpcModule(); +_api.RpcModuleProvider.RegisterSingle((IDemoRpcModule)module); +// or +_api.RpcModuleProvider.RegisterSingle(module); +``` + +We're ready to test our plugin with Nethermind. Let's build it, copy it to the `plugins` folder, and launch Nethermind. It takes a few moments for Nethermind to initialize and start the JSON-RPC server. Once you see the following message, you can start making requests: + +```text +======================== Nethermind initialization completed ======================== +... +JSON RPC : http://127.0.0.1:8545 ; http://127.0.0.1:8551 +... +===================================================================================== +``` + +Now let's check how our `demo_divide` method divides 32 by 2 as follows: + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "demo_divide", + "params": [ + 32, 2 + ] + }' +``` + +:::tip +Nethermind also allows numeric parameters to be passed as strings and supports hex encoding. +::: + +The response should look like the following: + +```json +{ + "jsonrpc": "2.0", + "error": { + "code": -32600, + "message": "The method 'demo_divide' is found but the namespace 'Demo' is disabled for http://127.0.0.1:8545. Consider adding the namespace 'Demo' to JsonRpc.AdditionalRpcUrls for an additional URL, or to JsonRpc.EnabledModules for the default URL." + }, + "id": 0 +} +``` + +This is because not all RPC modules are enabled by default for security and performance reasons. The bundled Nethermind configurations enable some widely used ones for convenience, but any additional modules, including third-party ones, must be enabled explicitly. We'll follow the instructions in the error message to enable our module for the default RPC URL. Remember the [`RpcModule`][rpcmoduleattr] attribute in line 6 of `IDemoRpcModule` interface? Now, it comes in handy. We will use its name of `Demo` to pass it to [`JsonRpc.EnabledModules`](../../../fundamentals/configuration.md#jsonrpc-enabledmodules) as follows: + +```bash +nethermind \ + -c hoodi \ + --jsonrpc-enabledmodules eth,demo +``` + +We enabled just two modules for demo purposes, but you may enable as many as needed. Note that the module names are case-insensitive here. + +Now, our method should work as expected by returning 16 as a result: + +```json +{ + "jsonrpc": "2.0", + "result": "16", + "id": 0 +} +``` + +If we try to divide 32 by 0, the response should be an error like this: + +```json +{ + "jsonrpc": "2.0", + "error": { + "code": -32603, + "message": "Divisor cannot be zero", + "data": "NaN" + }, + "id": 0 +} +``` + +That's it. We added our custom JSON-RPC handler to Nethermind. + +_To be continued_ + +[irpcmodule]: https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.JsonRpc/Modules/IRpcModule.cs +[resultwrapper]: https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.JsonRpc/ResultWrapper.cs +[rpcmoduleattr]: https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.JsonRpc/Modules/RpcModuleAttribute.cs diff --git a/versioned_docs/version-1.36.0/fundamentals/_category_.json b/versioned_docs/version-1.36.0/fundamentals/_category_.json new file mode 100644 index 0000000000..d0b3a51dc8 --- /dev/null +++ b/versioned_docs/version-1.36.0/fundamentals/_category_.json @@ -0,0 +1,4 @@ +{ + "position": 2, + "label": "Fundamentals" +} diff --git a/versioned_docs/version-1.36.0/fundamentals/configuration.md b/versioned_docs/version-1.36.0/fundamentals/configuration.md new file mode 100644 index 0000000000..dfd39bd0e4 --- /dev/null +++ b/versioned_docs/version-1.36.0/fundamentals/configuration.md @@ -0,0 +1,8013 @@ +--- +title: Configuration +sidebar_position: 1 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +Nethermind is highly configurable. There are 3 ways of configuring it, listed by priority: + +- [Command line options](#basic-command-line-options) (aka arguments or flags) +- [Environment variables](#environment-variables) +- [Configuration file](#configuration-file) + +:::note +Given the above priority list, an option defined in a more priority way overrides the same option defined elsewhere if any. +::: + +The full list of configuration options can be displayed by running: + +```bash +nethermind -h +``` + +Below is the list of the basic command line options followed by an exhaustive list of configuration options by namespace. + +:::warning +The configuration options are case-sensitive and can be defined only once unless stated otherwise. +::: + +## Basic command line options + +- #### `-c, --config ` \{#config\} + + The path to the [configuration file](#configuration-file) or the file name (also without extension) of any of the configuration files in the configuration files directory. Defaults to `mainnet`. + +
+ Available configurations + + Nethermind provides the following pre-built configurations named as the networks they are for. Their respective versions for archive nodes are suffixed `_archive`. + + - `base-mainnet` `base-mainnet_archive` + - `base-sepolia` `base-sepolia_archive` + - `chiado` `chiado_archive` + - `energyweb` `energyweb_archive` + - `gnosis` `gnosis_archive` + - `hoodi` `hoodi_archive` + - `linea-mainnet` `linea-mainnet_archive` + - `linea-sepolia` `linea-sepolia_archive` + - `mainnet` `mainnet_archive` + - `op-mainnet` `op-mainnet_archive` + - `op-sepolia` `op-sepolia_archive` + - `sepolia` `sepolia_archive` + - `taiko-alethia` + - `taiko-hekla` + - `volta` `volta_archive` + - `worldchain-mainnet` `worldchain-mainnet_archive` + - `worldchain-sepolia` `worldchain-sepolia_archive` + +
+ + Alternatively, the configuration file can also be set by the `NETHERMIND_CONFIG` environment variable. + +- #### `--configs-dir ` \{#configs-dir\} + + The path to the configuration files directory. Defaults to `configs`.\ + Deprecates `--configsDirectory` `-cd`. + + :::note + This option is ignored if the [`-c, --config`](#config) option is set to a path: + + ```bash + # Ignored for + -c ./mainnet.json + -c path/to/mainnet.json + # Respected for + -c mainnet + -c mainnet.json + ``` + + ::: + +- #### `--data-dir ` \{#data-dir\} + + The path to the Nethermind data directory. Defaults to Nethermind's current directory.\ + Deprecates `--datadir` `-dd`. + + :::warning + The absolute paths set by [`Init.BaseDbPath`](#init-basedbpath), [`Init.LogDirectory`](#init-logdirectory), or [`KeyStore.KeyStoreDirectory`](#keystore-keystoredirectory) options in a configuration file are not overridden by `--data-dir`. + ::: + +- #### `--db-dir ` \{#db-dir\} + + The path to the Nethermind database directory. Defaults to `db`.\ + Deprecates `--baseDbPath` `-d`. + +- #### `-?, -h, --help` \{#help\} + + Shows the full list of available command line options. + +- #### `-l, --log ` \{#log\} + + Log level (severity). Allowed values: `off` `trace` `debug` `info` `warn` `error`. Defaults to `info`. + +- #### `--logger-config ` \{#logger-config\} + + The path to the logging configuration file. Defaults to `NLog.config`.\ + Deprecates `--loggerConfigSource` `-lcs`. + +- #### `--plugins-dir ` \{#plugins-dir\} + + The path to the Nethermind plugins directory. Defaults to `plugins`.\ + Deprecates `--pluginsDirectory` `-pd`. + +- #### `--version` \{#version\} + + Shows the Nethermind version information. + +## Options by namespaces + + + +### Aura + +- #### `Aura.AllowAuRaPrivateChains` \{#aura-allowauraprivatechains\} + + + + ``` + --aura-allowauraprivatechains [true|false] + --Aura.AllowAuRaPrivateChains [true|false] + ``` + + + ``` + NETHERMIND_AURACONFIG_ALLOWAURAPRIVATECHAINS=true|false + ``` + + + ```json + { + "Aura": { + "AllowAuRaPrivateChains": true|false + } + } + ``` + + + + Whether to allow private Aura-based chains only. Do not use with existing Aura-based chains. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Aura.ForceSealing` \{#aura-forcesealing\} + + + + ``` + --aura-forcesealing [true|false] + --Aura.ForceSealing [true|false] + ``` + + + ``` + NETHERMIND_AURACONFIG_FORCESEALING=true|false + ``` + + + ```json + { + "Aura": { + "ForceSealing": true|false + } + } + ``` + + + + Whether to seal empty blocks if mining. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Aura.Minimum2MlnGasPerBlockWhenUsingBlockGasLimitContract` \{#aura-minimum2mlngasperblockwhenusingblockgaslimitcontract\} + + + + ``` + --aura-minimum2mlngasperblockwhenusingblockgaslimitcontract [true|false] + --Aura.Minimum2MlnGasPerBlockWhenUsingBlockGasLimitContract [true|false] + ``` + + + ``` + NETHERMIND_AURACONFIG_MINIMUM2MLNGASPERBLOCKWHENUSINGBLOCKGASLIMITCONTRACT=true|false + ``` + + + ```json + { + "Aura": { + "Minimum2MlnGasPerBlockWhenUsingBlockGasLimitContract": true|false + } + } + ``` + + + + Whether to use 2M gas if the contract returns less than that when using `BlockGasLimitContractTransitions`. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Aura.TxPriorityConfigFilePath` \{#aura-txpriorityconfigfilepath\} + + + + ``` + --aura-txpriorityconfigfilepath + --Aura.TxPriorityConfigFilePath + ``` + + + ``` + NETHERMIND_AURACONFIG_TXPRIORITYCONFIGFILEPATH= + ``` + + + ```json + { + "Aura": { + "TxPriorityConfigFilePath": + } + } + ``` + + + + The path to the transaction priority rules file to use when selecting transactions from the transaction pool. Defaults to `null`. + +- #### `Aura.TxPriorityContractAddress` \{#aura-txprioritycontractaddress\} + + + + ``` + --aura-txprioritycontractaddress + --Aura.TxPriorityContractAddress + ``` + + + ``` + NETHERMIND_AURACONFIG_TXPRIORITYCONTRACTADDRESS= + ``` + + + ```json + { + "Aura": { + "TxPriorityContractAddress": + } + } + ``` + + + + The address of the transaction priority contract to use when selecting transactions from the transaction pool. Defaults to `null`. + + +### Blocks + +- #### `Blocks.BlockProductionBlobLimit` \{#blocks-blockproductionbloblimit\} + + + + ``` + --blocks-blockproductionbloblimit + --Blocks.BlockProductionBlobLimit + ``` + + + ``` + NETHERMIND_BLOCKSCONFIG_BLOCKPRODUCTIONBLOBLIMIT= + ``` + + + ```json + { + "Blocks": { + "BlockProductionBlobLimit": + } + } + ``` + + + + The max blob count after which the block producer should stop adding blobs. Minimum value is `0`. Defaults to `null`. + +- #### `Blocks.BlockProductionMaxTxKilobytes` \{#blocks-blockproductionmaxtxkilobytes\} + + + + ``` + --blocks-blockproductionmaxtxkilobytes + --Blocks.BlockProductionMaxTxKilobytes + ``` + + + ``` + NETHERMIND_BLOCKSCONFIG_BLOCKPRODUCTIONMAXTXKILOBYTES= + ``` + + + ```json + { + "Blocks": { + "BlockProductionMaxTxKilobytes": + } + } + ``` + + + + The max transaction bytes to add in block production, in kilobytes. Defaults to `7936`. + +- #### `Blocks.BlockProductionTimeoutMs` \{#blocks-blockproductiontimeoutms\} + + + + ``` + --blocks-blockproductiontimeoutms + --Blocks.BlockProductionTimeoutMs + ``` + + + ``` + NETHERMIND_BLOCKSCONFIG_BLOCKPRODUCTIONTIMEOUTMS= + ``` + + + ```json + { + "Blocks": { + "BlockProductionTimeoutMs": + } + } + ``` + + + + The block production timeout, in milliseconds. Defaults to `4000`. + +- #### `Blocks.ExtraData` \{#blocks-extradata\} + + + + ``` + --blocks-extradata + --Blocks.ExtraData + ``` + + + ``` + NETHERMIND_BLOCKSCONFIG_EXTRADATA= + ``` + + + ```json + { + "Blocks": { + "ExtraData": + } + } + ``` + + + + The block header extra data up to 32 bytes in length. Defaults to `Nethermind`. + +- #### `Blocks.GenesisTimeoutMs` \{#blocks-genesistimeoutms\} + + + + ``` + --blocks-genesistimeoutms + --Blocks.GenesisTimeoutMs + ``` + + + ``` + NETHERMIND_BLOCKSCONFIG_GENESISTIMEOUTMS= + ``` + + + ```json + { + "Blocks": { + "GenesisTimeoutMs": + } + } + ``` + + + + The genesis block load timeout, in milliseconds. Defaults to `40000`. + +- #### `Blocks.MinGasPrice` \{#blocks-mingasprice\} + + + + ``` + --blocks-mingasprice + --Blocks.MinGasPrice + ``` + + + ``` + NETHERMIND_BLOCKSCONFIG_MINGASPRICE= + ``` + + + ```json + { + "Blocks": { + "MinGasPrice": + } + } + ``` + + + + The minimum gas premium (or the gas price before the London hard fork) for transactions accepted by the block producer. Defaults to `1`. + +- #### `Blocks.PreWarmStateOnBlockProcessing` \{#blocks-prewarmstateonblockprocessing\} + + + + ``` + --blocks-prewarmstateonblockprocessing [true|false] + --Blocks.PreWarmStateOnBlockProcessing [true|false] + ``` + + + ``` + NETHERMIND_BLOCKSCONFIG_PREWARMSTATEONBLOCKPROCESSING=true|false + ``` + + + ```json + { + "Blocks": { + "PreWarmStateOnBlockProcessing": true|false + } + } + ``` + + + + Whether to pre-warm the state when processing blocks. This can lead to an up to 2x speed-up in the main loop block processing. Allowed values: `true` `false`. Defaults to `True`. + +- #### `Blocks.RandomizedBlocks` \{#blocks-randomizedblocks\} + + + + ``` + --blocks-randomizedblocks [true|false] + --Blocks.RandomizedBlocks [true|false] + ``` + + + ``` + NETHERMIND_BLOCKSCONFIG_RANDOMIZEDBLOCKS=true|false + ``` + + + ```json + { + "Blocks": { + "RandomizedBlocks": true|false + } + } + ``` + + + + Whether to change the difficulty of the block randomly within the constraints. Used in NethDev only. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Blocks.SecondsPerSlot` \{#blocks-secondsperslot\} + + + + ``` + --blocks-secondsperslot + --Blocks.SecondsPerSlot + ``` + + + ``` + NETHERMIND_BLOCKSCONFIG_SECONDSPERSLOT= + ``` + + + ```json + { + "Blocks": { + "SecondsPerSlot": + } + } + ``` + + + + The block time slot, in seconds. Defaults to `12`. + +- #### `Blocks.TargetBlockGasLimit` \{#blocks-targetblockgaslimit\} + + + + ``` + --blocks-targetblockgaslimit + --Blocks.TargetBlockGasLimit + ``` + + + ``` + NETHERMIND_BLOCKSCONFIG_TARGETBLOCKGASLIMIT= + ``` + + + ```json + { + "Blocks": { + "TargetBlockGasLimit": + } + } + ``` + + + + The block gas limit that the block producer should try to reach in the fastest possible way based on the protocol rules. If not specified, then the block producer should follow others. Defaults to `null`. + + +### Bloom + +- #### `Bloom.Index` \{#bloom-index\} + + + + ``` + --bloom-index [true|false] + --Bloom.Index [true|false] + ``` + + + ``` + NETHERMIND_BLOOMCONFIG_INDEX=true|false + ``` + + + ```json + { + "Bloom": { + "Index": true|false + } + } + ``` + + + + Whether to use the Bloom index. The Bloom index speeds up the RPC log searches. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Bloom.IndexLevelBucketSizes` \{#bloom-indexlevelbucketsizes\} + + + + ``` + --bloom-indexlevelbucketsizes + --Bloom.IndexLevelBucketSizes + ``` + + + ``` + NETHERMIND_BLOOMCONFIG_INDEXLEVELBUCKETSIZES= + ``` + + + ```json + { + "Bloom": { + "IndexLevelBucketSizes": + } + } + ``` + + + + An array of multipliers for index levels. Can be tweaked per chain to boost performance. Defaults to `[4, 8, 8]`. + +- #### `Bloom.Migration` \{#bloom-migration\} + + + + ``` + --bloom-migration [true|false] + --Bloom.Migration [true|false] + ``` + + + ``` + NETHERMIND_BLOOMCONFIG_MIGRATION=true|false + ``` + + + ```json + { + "Bloom": { + "Migration": true|false + } + } + ``` + + + + Whether to migrate the previously downloaded blocks to the Bloom index. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Bloom.MigrationStatistics` \{#bloom-migrationstatistics\} + + + + ``` + --bloom-migrationstatistics [true|false] + --Bloom.MigrationStatistics [true|false] + ``` + + + ``` + NETHERMIND_BLOOMCONFIG_MIGRATIONSTATISTICS=true|false + ``` + + + ```json + { + "Bloom": { + "MigrationStatistics": true|false + } + } + ``` + + + + Whether the migration statistics should be calculated and output. Allowed values: `true` `false`. Defaults to `false`. + + +### CensorshipDetector + +- #### `CensorshipDetector.AddressesForCensorshipDetection` \{#censorshipdetector-addressesforcensorshipdetection\} + + + + ``` + --censorshipdetector-addressesforcensorshipdetection + --CensorshipDetector.AddressesForCensorshipDetection + ``` + + + ``` + NETHERMIND_CENSORSHIPDETECTORCONFIG_ADDRESSESFORCENSORSHIPDETECTION= + ``` + + + ```json + { + "CensorshipDetector": { + "AddressesForCensorshipDetection": + } + } + ``` + + + + The addresses to detect censorship for. Defaults to `null`. + +- #### `CensorshipDetector.BlockCensorshipThreshold` \{#censorshipdetector-blockcensorshipthreshold\} + + + + ``` + --censorshipdetector-blockcensorshipthreshold + --CensorshipDetector.BlockCensorshipThreshold + ``` + + + ``` + NETHERMIND_CENSORSHIPDETECTORCONFIG_BLOCKCENSORSHIPTHRESHOLD= + ``` + + + ```json + { + "CensorshipDetector": { + "BlockCensorshipThreshold": + } + } + ``` + + + + The number of the consecutive blocks with detected potential censorship to report. Defaults to `2`. + +- #### `CensorshipDetector.Enabled` \{#censorshipdetector-enabled\} + + + + ``` + --censorshipdetector-enabled [true|false] + --CensorshipDetector.Enabled [true|false] + ``` + + + ``` + NETHERMIND_CENSORSHIPDETECTORCONFIG_ENABLED=true|false + ``` + + + ```json + { + "CensorshipDetector": { + "Enabled": true|false + } + } + ``` + + + + Whether to enable censorship detection. Allowed values: `true` `false`. Defaults to `false`. + + +### Clique + + +### Era + +- #### `Era.ExportDirectory` \{#era-exportdirectory\} + + + + ``` + --era-exportdirectory + --Era.ExportDirectory + ``` + + + ``` + NETHERMIND_ERACONFIG_EXPORTDIRECTORY= + ``` + + + ```json + { + "Era": { + "ExportDirectory": + } + } + ``` + + + + Directory of archive export. + +- #### `Era.From` \{#era-from\} + + + + ``` + --era-from + --Era.From + ``` + + + ``` + NETHERMIND_ERACONFIG_FROM= + ``` + + + ```json + { + "Era": { + "From": + } + } + ``` + + + + Block number to import/export from. Defaults to `0`. + +- #### `Era.ImportDirectory` \{#era-importdirectory\} + + + + ``` + --era-importdirectory + --Era.ImportDirectory + ``` + + + ``` + NETHERMIND_ERACONFIG_IMPORTDIRECTORY= + ``` + + + ```json + { + "Era": { + "ImportDirectory": + } + } + ``` + + + + Directory of era1 archives to be imported. + +- #### `Era.To` \{#era-to\} + + + + ``` + --era-to + --Era.To + ``` + + + ``` + NETHERMIND_ERACONFIG_TO= + ``` + + + ```json + { + "Era": { + "To": + } + } + ``` + + + + Block number to import/export to. Defaults to `0`. + +- #### `Era.TrustedAccumulatorFile` \{#era-trustedaccumulatorfile\} + + + + ``` + --era-trustedaccumulatorfile + --Era.TrustedAccumulatorFile + ``` + + + ``` + NETHERMIND_ERACONFIG_TRUSTEDACCUMULATORFILE= + ``` + + + ```json + { + "Era": { + "TrustedAccumulatorFile": + } + } + ``` + + + + Accumulator file to be used for trusting era files. Defaults to `null`. + + +### EthStats + +- #### `EthStats.Contact` \{#ethstats-contact\} + + + + ``` + --ethstats-contact + --EthStats.Contact + ``` + + + ``` + NETHERMIND_ETHSTATSCONFIG_CONTACT= + ``` + + + ```json + { + "EthStats": { + "Contact": + } + } + ``` + + + + The node owner contact details displayed on Ethstats. Defaults to `hello@nethermind.io`. + +- #### `EthStats.Enabled` \{#ethstats-enabled\} + + + + ``` + --ethstats-enabled [true|false] + --EthStats.Enabled [true|false] + ``` + + + ``` + NETHERMIND_ETHSTATSCONFIG_ENABLED=true|false + ``` + + + ```json + { + "EthStats": { + "Enabled": true|false + } + } + ``` + + + + Whether to use Ethstats publishing. Allowed values: `true` `false`. Defaults to `false`. + +- #### `EthStats.Name` \{#ethstats-name\} + + + + ``` + --ethstats-name + --EthStats.Name + ``` + + + ``` + NETHERMIND_ETHSTATSCONFIG_NAME= + ``` + + + ```json + { + "EthStats": { + "Name": + } + } + ``` + + + + The node name displayed on Ethstats. Defaults to `Nethermind`. + +- #### `EthStats.Secret` \{#ethstats-secret\} + + + + ``` + --ethstats-secret + --EthStats.Secret + ``` + + + ``` + NETHERMIND_ETHSTATSCONFIG_SECRET= + ``` + + + ```json + { + "EthStats": { + "Secret": + } + } + ``` + + + + The Ethstats secret. Defaults to `secret`. + +- #### `EthStats.SendInterval` \{#ethstats-sendinterval\} + + + + ``` + --ethstats-sendinterval + --EthStats.SendInterval + ``` + + + ``` + NETHERMIND_ETHSTATSCONFIG_SENDINTERVAL= + ``` + + + ```json + { + "EthStats": { + "SendInterval": + } + } + ``` + + + + The stats update interval, in seconds. Defaults to `15`. + +- #### `EthStats.Server` \{#ethstats-server\} + + + + ``` + --ethstats-server + --EthStats.Server + ``` + + + ``` + NETHERMIND_ETHSTATSCONFIG_SERVER= + ``` + + + ```json + { + "EthStats": { + "Server": + } + } + ``` + + + + The Ethstats server URL. Defaults to `ws://localhost:3000/api`. + + +### Flashbots + +- #### `Flashbots.EnablePreWarmer` \{#flashbots-enableprewarmer\} + + + + ``` + --flashbots-enableprewarmer [true|false] + --Flashbots.EnablePreWarmer [true|false] + ``` + + + ``` + NETHERMIND_FLASHBOTSCONFIG_ENABLEPREWARMER=true|false + ``` + + + ```json + { + "Flashbots": { + "EnablePreWarmer": true|false + } + } + ``` + + + + Whether to enable the pre-warmer. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Flashbots.EnableValidation` \{#flashbots-enablevalidation\} + + + + ``` + --flashbots-enablevalidation [true|false] + --Flashbots.EnableValidation [true|false] + ``` + + + ``` + NETHERMIND_FLASHBOTSCONFIG_ENABLEVALIDATION=true|false + ``` + + + ```json + { + "Flashbots": { + "EnableValidation": true|false + } + } + ``` + + + + Whether to enable validation. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Flashbots.Enabled` \{#flashbots-enabled\} + + + + ``` + --flashbots-enabled [true|false] + --Flashbots.Enabled [true|false] + ``` + + + ``` + NETHERMIND_FLASHBOTSCONFIG_ENABLED=true|false + ``` + + + ```json + { + "Flashbots": { + "Enabled": true|false + } + } + ``` + + + + Whether to enable the Flashbots endpoints. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Flashbots.ExcludeWithdrawals` \{#flashbots-excludewithdrawals\} + + + + ``` + --flashbots-excludewithdrawals [true|false] + --Flashbots.ExcludeWithdrawals [true|false] + ``` + + + ``` + NETHERMIND_FLASHBOTSCONFIG_EXCLUDEWITHDRAWALS=true|false + ``` + + + ```json + { + "Flashbots": { + "ExcludeWithdrawals": true|false + } + } + ``` + + + + Whether to exclude the withdrawals to the fee recipient from the balance difference. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Flashbots.FlashbotsModuleConcurrentInstances` \{#flashbots-flashbotsmoduleconcurrentinstances\} + + + + ``` + --flashbots-flashbotsmoduleconcurrentinstances + --Flashbots.FlashbotsModuleConcurrentInstances + ``` + + + ``` + NETHERMIND_FLASHBOTSCONFIG_FLASHBOTSMODULECONCURRENTINSTANCES= + ``` + + + ```json + { + "Flashbots": { + "FlashbotsModuleConcurrentInstances": + } + } + ``` + + + + The number of concurrent instances for non-sharable calls for `flashbots_validateBuilderSubmissionV3` + This limits the load on the CPU and I/O to reasonable levels. If the limit is exceeded, HTTP 503 is returned along with the JSON-RPC error. Defaults to the number of logical processors. + +- #### `Flashbots.UseBalanceDiffProfit` \{#flashbots-usebalancediffprofit\} + + + + ``` + --flashbots-usebalancediffprofit [true|false] + --Flashbots.UseBalanceDiffProfit [true|false] + ``` + + + ``` + NETHERMIND_FLASHBOTSCONFIG_USEBALANCEDIFFPROFIT=true|false + ``` + + + ```json + { + "Flashbots": { + "UseBalanceDiffProfit": true|false + } + } + ``` + + + + Whether to calculate the proposer payment as a balance difference of the fee recipient. Allowed values: `true` `false`. Defaults to `false`. + + +### HealthChecks + +- #### `HealthChecks.Enabled` \{#healthchecks-enabled\} + + + + ``` + --healthchecks-enabled [true|false] + --HealthChecks.Enabled [true|false] + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_ENABLED=true|false + ``` + + + ```json + { + "HealthChecks": { + "Enabled": true|false + } + } + ``` + + + + Whether to enable the health check. Allowed values: `true` `false`. Defaults to `false`. + +- #### `HealthChecks.LowStorageCheckAwaitOnStartup` \{#healthchecks-lowstoragecheckawaitonstartup\} + + + + ``` + --healthchecks-lowstoragecheckawaitonstartup [true|false] + --HealthChecks.LowStorageCheckAwaitOnStartup [true|false] + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_LOWSTORAGECHECKAWAITONSTARTUP=true|false + ``` + + + ```json + { + "HealthChecks": { + "LowStorageCheckAwaitOnStartup": true|false + } + } + ``` + + + + Whether to check for low disk space on startup and suspend until enough space is available. Allowed values: `true` `false`. Defaults to `false`. + +- #### `HealthChecks.LowStorageSpaceShutdownThreshold` \{#healthchecks-lowstoragespaceshutdownthreshold\} + + + + ``` + --healthchecks-lowstoragespaceshutdownthreshold + --HealthChecks.LowStorageSpaceShutdownThreshold + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_LOWSTORAGESPACESHUTDOWNTHRESHOLD= + ``` + + + ```json + { + "HealthChecks": { + "LowStorageSpaceShutdownThreshold": + } + } + ``` + + + + The percentage of available disk space below which Nethermind shuts down. `0` to disable. Defaults to `1`. + +- #### `HealthChecks.LowStorageSpaceWarningThreshold` \{#healthchecks-lowstoragespacewarningthreshold\} + + + + ``` + --healthchecks-lowstoragespacewarningthreshold + --HealthChecks.LowStorageSpaceWarningThreshold + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_LOWSTORAGESPACEWARNINGTHRESHOLD= + ``` + + + ```json + { + "HealthChecks": { + "LowStorageSpaceWarningThreshold": + } + } + ``` + + + + The percentage of available disk space below which a warning is displayed. `0` to disable. Defaults to `5`. + +- #### `HealthChecks.MaxIntervalClRequestTime` \{#healthchecks-maxintervalclrequesttime\} + + + + ``` + --healthchecks-maxintervalclrequesttime + --HealthChecks.MaxIntervalClRequestTime + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_MAXINTERVALCLREQUESTTIME= + ``` + + + ```json + { + "HealthChecks": { + "MaxIntervalClRequestTime": + } + } + ``` + + + + The max request interval, in seconds, in which the consensus client is assumed healthy. Defaults to `300`. + +- #### `HealthChecks.MaxIntervalWithoutProcessedBlock` \{#healthchecks-maxintervalwithoutprocessedblock\} + + + + ``` + --healthchecks-maxintervalwithoutprocessedblock + --HealthChecks.MaxIntervalWithoutProcessedBlock + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_MAXINTERVALWITHOUTPROCESSEDBLOCK= + ``` + + + ```json + { + "HealthChecks": { + "MaxIntervalWithoutProcessedBlock": + } + } + ``` + + + + The max interval, in seconds, in which the block processing is assumed healthy. Defaults to `null`. + +- #### `HealthChecks.MaxIntervalWithoutProducedBlock` \{#healthchecks-maxintervalwithoutproducedblock\} + + + + ``` + --healthchecks-maxintervalwithoutproducedblock + --HealthChecks.MaxIntervalWithoutProducedBlock + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_MAXINTERVALWITHOUTPRODUCEDBLOCK= + ``` + + + ```json + { + "HealthChecks": { + "MaxIntervalWithoutProducedBlock": + } + } + ``` + + + + The max interval, in seconds, in which the block production is assumed healthy. Defaults to `null`. + +- #### `HealthChecks.PollingInterval` \{#healthchecks-pollinginterval\} + + + + ``` + --healthchecks-pollinginterval + --HealthChecks.PollingInterval + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_POLLINGINTERVAL= + ``` + + + ```json + { + "HealthChecks": { + "PollingInterval": + } + } + ``` + + + + The health check updates polling interval, in seconds. Defaults to `5`. + +- #### `HealthChecks.Slug` \{#healthchecks-slug\} + + + + ``` + --healthchecks-slug + --HealthChecks.Slug + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_SLUG= + ``` + + + ```json + { + "HealthChecks": { + "Slug": + } + } + ``` + + + + The URL slug the health checks service is exposed at. Defaults to `/health`. + +- #### `HealthChecks.UIEnabled` \{#healthchecks-uienabled\} + + + + ``` + --healthchecks-uienabled [true|false] + --HealthChecks.UIEnabled [true|false] + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_UIENABLED=true|false + ``` + + + ```json + { + "HealthChecks": { + "UIEnabled": true|false + } + } + ``` + + + + Whether to enable the health checks UI. Allowed values: `true` `false`. Defaults to `false`. + +- #### `HealthChecks.WebhooksEnabled` \{#healthchecks-webhooksenabled\} + + + + ``` + --healthchecks-webhooksenabled [true|false] + --HealthChecks.WebhooksEnabled [true|false] + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_WEBHOOKSENABLED=true|false + ``` + + + ```json + { + "HealthChecks": { + "WebhooksEnabled": true|false + } + } + ``` + + + + Whether to enable web hooks. Allowed values: `true` `false`. Defaults to `false`. + +- #### `HealthChecks.WebhooksPayload` \{#healthchecks-webhookspayload\} + + + + ``` + --healthchecks-webhookspayload + --HealthChecks.WebhooksPayload + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_WEBHOOKSPAYLOAD= + ``` + + + ```json + { + "HealthChecks": { + "WebhooksPayload": + } + } + ``` + + + + An escaped JSON paylod to be sent to the web hook on failure. + Defaults to: + + ```json + { + "attachments": [ + { + "color": "#FFCC00", + "pretext": "Health Check Status :warning:", + "fields": [ + { + "title": "Details", + "value": "More details available at /healthchecks-ui", + "short": false + }, + { + "title": "Description", + "value": "[[DESCRIPTIONS]]", + "short": false + } + ] + } + ] + } + ``` + + +- #### `HealthChecks.WebhooksRestorePayload` \{#healthchecks-webhooksrestorepayload\} + + + + ``` + --healthchecks-webhooksrestorepayload + --HealthChecks.WebhooksRestorePayload + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_WEBHOOKSRESTOREPAYLOAD= + ``` + + + ```json + { + "HealthChecks": { + "WebhooksRestorePayload": + } + } + ``` + + + + An escaped JSON paylod to be sent to the web hook on recovery. + Defaults to: + + ```json + { + "attachments": [ + { + "color": "#36a64f", + "pretext": "Health Check Status :+1:", + "fields": [ + { + "title": "Details", + "value": "More details available at /healthchecks-ui", + "short": false + }, + { + "title": "description", + "value": "The HealthCheck `[[LIVENESS]]` is recovered. Everything is up and running.", + "short": false + } + ] + } + ] + } + ``` + + +- #### `HealthChecks.WebhooksUri` \{#healthchecks-webhooksuri\} + + + + ``` + --healthchecks-webhooksuri + --HealthChecks.WebhooksUri + ``` + + + ``` + NETHERMIND_HEALTHCHECKSCONFIG_WEBHOOKSURI= + ``` + + + ```json + { + "HealthChecks": { + "WebhooksUri": + } + } + ``` + + + + The web hook URL. Defaults to `null`. + + +### History + +- #### `History.Pruning` \{#history-pruning\} + + + + ``` + --history-pruning + --History.Pruning + ``` + + + ``` + NETHERMIND_HISTORYCONFIG_PRUNING= + ``` + + + ```json + { + "History": { + "Pruning": + } + } + ``` + + + + Pruning mode. + + Allowed values: + + - `Disabled`: No history pruning. + - `Rolling`: Prune outside of rolling window. + - `UseAncientBarriers`: Prune up to ancient barriers. + + Defaults to `Disabled`. + +- #### `History.PruningInterval` \{#history-pruninginterval\} + + + + ``` + --history-pruninginterval + --History.PruningInterval + ``` + + + ``` + NETHERMIND_HISTORYCONFIG_PRUNINGINTERVAL= + ``` + + + ```json + { + "History": { + "PruningInterval": + } + } + ``` + + + + Number of epochs to wait between each history pruning. Defaults to `8`. + +- #### `History.RetentionEpochs` \{#history-retentionepochs\} + + + + ``` + --history-retentionepochs + --History.RetentionEpochs + ``` + + + ``` + NETHERMIND_HISTORYCONFIG_RETENTIONEPOCHS= + ``` + + + ```json + { + "History": { + "RetentionEpochs": + } + } + ``` + + + + The number of epochs to retain historical blocks and receipts when using 'Rolling' pruning mode. For mainnet this must be at least 82125. Defaults to `82125`. + + +### Hive + +- #### `Hive.BlocksDir` \{#hive-blocksdir\} + + + + ``` + --hive-blocksdir + --Hive.BlocksDir + ``` + + + ``` + NETHERMIND_HIVECONFIG_BLOCKSDIR= + ``` + + + ```json + { + "Hive": { + "BlocksDir": + } + } + ``` + + + + The path to the directory with additional blocks. Defaults to `/blocks`. + +- #### `Hive.ChainFile` \{#hive-chainfile\} + + + + ``` + --hive-chainfile + --Hive.ChainFile + ``` + + + ``` + NETHERMIND_HIVECONFIG_CHAINFILE= + ``` + + + ```json + { + "Hive": { + "ChainFile": + } + } + ``` + + + + The path to the chain definition should be specified as an RLP-encoded block sequence. Defaults to `/chain.rlp`. + +- #### `Hive.Enabled` \{#hive-enabled\} + + + + ``` + --hive-enabled [true|false] + --Hive.Enabled [true|false] + ``` + + + ``` + NETHERMIND_HIVECONFIG_ENABLED=true|false + ``` + + + ```json + { + "Hive": { + "Enabled": true|false + } + } + ``` + + + + Whether to enable Hive for debugging. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Hive.GenesisFilePath` \{#hive-genesisfilepath\} + + + + ``` + --hive-genesisfilepath + --Hive.GenesisFilePath + ``` + + + ``` + NETHERMIND_HIVECONFIG_GENESISFILEPATH= + ``` + + + ```json + { + "Hive": { + "GenesisFilePath": + } + } + ``` + + + + The path to the genesis block file. Defaults to `/genesis.json`. + +- #### `Hive.KeysDir` \{#hive-keysdir\} + + + + ``` + --hive-keysdir + --Hive.KeysDir + ``` + + + ``` + NETHERMIND_HIVECONFIG_KEYSDIR= + ``` + + + ```json + { + "Hive": { + "KeysDir": + } + } + ``` + + + + The path to the keystore directory. Defaults to `/keys`. + + +### Init + +- #### `Init.AutoDump` \{#init-autodump\} + + + + ``` + --init-autodump + --Init.AutoDump + ``` + + + ``` + NETHERMIND_INITCONFIG_AUTODUMP= + ``` + + + ```json + { + "Init": { + "AutoDump": + } + } + ``` + + + + Auto-dump on bad blocks for diagnostics. + + Allowed values: + + - `None`: None. + - `Receipts`: Dumps block receipts traces. + - `Parity`: Dumps Parity-like traces. + - `Geth`: Dumps Geth-like traces. + - `Rlp`: Dumps RLP data to a `.rlp` file with the block hash in the file name. + - `RlpLog`: Dumps RLP data to the log output. + - `Default`: Combines the `Receipts` `Rlp` options. + - `All`: Combines the `Geth` `Parity` `Receipts` `Rlp` options. + + Defaults to `Default`. + +- #### `Init.BadBlocksStored` \{#init-badblocksstored\} + + + + ``` + --init-badblocksstored + --Init.BadBlocksStored + ``` + + + ``` + NETHERMIND_INITCONFIG_BADBLOCKSSTORED= + ``` + + + ```json + { + "Init": { + "BadBlocksStored": + } + } + ``` + + + + The maximum number of bad blocks observed on the network that will be stored on disk. Defaults to `100`. + +- #### `Init.BaseDbPath` \{#init-basedbpath\} + + + + ``` + --init-basedbpath + --Init.BaseDbPath + ``` + + + ``` + NETHERMIND_INITCONFIG_BASEDBPATH= + ``` + + + ```json + { + "Init": { + "BaseDbPath": + } + } + ``` + + + + The base path for all Nethermind databases. Defaults to `db`. + +- #### `Init.ChainSpecPath` \{#init-chainspecpath\} + + + + ``` + --init-chainspecpath + --Init.ChainSpecPath + ``` + + + ``` + NETHERMIND_INITCONFIG_CHAINSPECPATH= + ``` + + + ```json + { + "Init": { + "ChainSpecPath": + } + } + ``` + + + + The path to the chain spec file. Defaults to `chainspec/foundation.json`. + +- #### `Init.DiagnosticMode` \{#init-diagnosticmode\} + + + + ``` + --init-diagnosticmode + --Init.DiagnosticMode + ``` + + + ``` + NETHERMIND_INITCONFIG_DIAGNOSTICMODE= + ``` + + + ```json + { + "Init": { + "DiagnosticMode": + } + } + ``` + + + + The diagnostic mode. + + Allowed values: + + - `None`: None. + - `MemDb`: Uses an in-memory DB. + - `RpcDb`: Uses a remote DB. + - `ReadOnlyDb`: Uses a read-only DB. + - `VerifyRewards`: Scans rewards for blocks and genesis. + - `VerifySupply`: Scans and sums supply on all accounts. + - `VerifyTrie`: Verifies if full state trie is stored. + + Defaults to `None`. + +- #### `Init.DiscoveryEnabled` \{#init-discoveryenabled\} + + + + ``` + --init-discoveryenabled [true|false] + --Init.DiscoveryEnabled [true|false] + ``` + + + ``` + NETHERMIND_INITCONFIG_DISCOVERYENABLED=true|false + ``` + + + ```json + { + "Init": { + "DiscoveryEnabled": true|false + } + } + ``` + + + + Whether to enable the node discovery. If disabled, Nethermind doesn't look for other nodes beyond the bootnodes specified. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Init.EnableUnsecuredDevWallet` \{#init-enableunsecureddevwallet\} + + + + ``` + --init-enableunsecureddevwallet [true|false] + --Init.EnableUnsecuredDevWallet [true|false] + ``` + + + ``` + NETHERMIND_INITCONFIG_ENABLEUNSECUREDDEVWALLET=true|false + ``` + + + ```json + { + "Init": { + "EnableUnsecuredDevWallet": true|false + } + } + ``` + + + + Whether to enable the in-app wallet/keystore. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Init.GenesisHash` \{#init-genesishash\} + + + + ``` + --init-genesishash + --Init.GenesisHash + ``` + + + ``` + NETHERMIND_INITCONFIG_GENESISHASH= + ``` + + + ```json + { + "Init": { + "GenesisHash": + } + } + ``` + + + + The hash of the genesis block. If not specified, the genesis block validity is not checked which is useful in the case of ad hoc test/private networks. Defaults to `null`. + +- #### `Init.KeepDevWalletInMemory` \{#init-keepdevwalletinmemory\} + + + + ``` + --init-keepdevwalletinmemory [true|false] + --Init.KeepDevWalletInMemory [true|false] + ``` + + + ``` + NETHERMIND_INITCONFIG_KEEPDEVWALLETINMEMORY=true|false + ``` + + + ```json + { + "Init": { + "KeepDevWalletInMemory": true|false + } + } + ``` + + + + Whether to create session-only accounts and delete them on shutdown. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Init.KzgSetupPath` \{#init-kzgsetuppath\} + + + + ``` + --init-kzgsetuppath + --Init.KzgSetupPath + ``` + + + ``` + NETHERMIND_INITCONFIG_KZGSETUPPATH= + ``` + + + ```json + { + "Init": { + "KzgSetupPath": + } + } + ``` + + + + The path to KZG trusted setup file. Defaults to `null`. + +- #### `Init.LogDirectory` \{#init-logdirectory\} + + + + ``` + --init-logdirectory + --Init.LogDirectory + ``` + + + ``` + NETHERMIND_INITCONFIG_LOGDIRECTORY= + ``` + + + ```json + { + "Init": { + "LogDirectory": + } + } + ``` + + + + The path to the Nethermind logs directory. Defaults to `logs`. + +- #### `Init.LogFileName` \{#init-logfilename\} + + + + ``` + --init-logfilename + --Init.LogFileName + ``` + + + ``` + NETHERMIND_INITCONFIG_LOGFILENAME= + ``` + + + ```json + { + "Init": { + "LogFileName": + } + } + ``` + + + + The name of the log file. Defaults to `log.txt`. + +- #### `Init.LogRules` \{#init-logrules\} + + + + ``` + --init-logrules + --Init.LogRules + ``` + + + ``` + NETHERMIND_INITCONFIG_LOGRULES= + ``` + + + ```json + { + "Init": { + "LogRules": + } + } + ``` + + + + The logs format as `LogPath:LogLevel;*` Defaults to `null`. + +- #### `Init.MemoryHint` \{#init-memoryhint\} + + + + ``` + --init-memoryhint + --Init.MemoryHint + ``` + + + ``` + NETHERMIND_INITCONFIG_MEMORYHINT= + ``` + + + ```json + { + "Init": { + "MemoryHint": + } + } + ``` + + + + The hint on the max memory limit, in bytes, to configure the database and networking memory allocations. Defaults to `null`. + +- #### `Init.PeerManagerEnabled` \{#init-peermanagerenabled\} + + + + ``` + --init-peermanagerenabled [true|false] + --Init.PeerManagerEnabled [true|false] + ``` + + + ``` + NETHERMIND_INITCONFIG_PEERMANAGERENABLED=true|false + ``` + + + ```json + { + "Init": { + "PeerManagerEnabled": true|false + } + } + ``` + + + + Whether to connect to newly discovered peers. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Init.ProcessingEnabled` \{#init-processingenabled\} + + + + ``` + --init-processingenabled [true|false] + --Init.ProcessingEnabled [true|false] + ``` + + + ``` + NETHERMIND_INITCONFIG_PROCESSINGENABLED=true|false + ``` + + + ```json + { + "Init": { + "ProcessingEnabled": true|false + } + } + ``` + + + + Whether to download/process new blocks. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Init.RpcDbUrl` \{#init-rpcdburl\} + + + + ``` + --init-rpcdburl + --Init.RpcDbUrl + ``` + + + ``` + NETHERMIND_INITCONFIG_RPCDBURL= + ``` + + + ```json + { + "Init": { + "RpcDbUrl": + } + } + ``` + + + + The URL of the remote node used as a database source when `DiagnosticMode` is set to `RpcDb`. + +- #### `Init.StaticNodesPath` \{#init-staticnodespath\} + + + + ``` + --init-staticnodespath + --Init.StaticNodesPath + ``` + + + ``` + NETHERMIND_INITCONFIG_STATICNODESPATH= + ``` + + + ```json + { + "Init": { + "StaticNodesPath": + } + } + ``` + + + + The path to the static nodes file. Defaults to `static-nodes.json`. + +- #### `Init.TrustedNodesPath` \{#init-trustednodespath\} + + + + ``` + --init-trustednodespath + --Init.TrustedNodesPath + ``` + + + ``` + NETHERMIND_INITCONFIG_TRUSTEDNODESPATH= + ``` + + + ```json + { + "Init": { + "TrustedNodesPath": + } + } + ``` + + + + The path to the trusted nodes file. Defaults to `trusted-nodes.json`. + +- #### `Init.WebSocketsEnabled` \{#init-websocketsenabled\} + + + + ``` + --init-websocketsenabled [true|false] + --Init.WebSocketsEnabled [true|false] + ``` + + + ``` + NETHERMIND_INITCONFIG_WEBSOCKETSENABLED=true|false + ``` + + + ```json + { + "Init": { + "WebSocketsEnabled": true|false + } + } + ``` + + + + Whether to enable WebSocket service for the default JSON-RPC port on startup. Allowed values: `true` `false`. Defaults to `true`. + + +### JsonRpc + +- #### `JsonRpc.AdditionalRpcUrls` \{#jsonrpc-additionalrpcurls\} + + + + ``` + --jsonrpc-additionalrpcurls + --JsonRpc.AdditionalRpcUrls + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_ADDITIONALRPCURLS= + ``` + + + ```json + { + "JsonRpc": { + "AdditionalRpcUrls": + } + } + ``` + + + + An array of additional JSON-RPC URLs to listen at with protocol and JSON-RPC namespace list. For instance, `[http://localhost:8546|http;ws|eth;web3]`. Defaults to `[]`. + +- #### `JsonRpc.BufferResponses` \{#jsonrpc-bufferresponses\} + + + + ``` + --jsonrpc-bufferresponses [true|false] + --JsonRpc.BufferResponses [true|false] + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_BUFFERRESPONSES=true|false + ``` + + + ```json + { + "JsonRpc": { + "BufferResponses": true|false + } + } + ``` + + + + Whether to buffer responses before sending them. This allows using of `Content-Length` instead of `Transfer-Encoding: chunked`. Note that it may degrade performance on large responses. The max buffered response length is 2GB. Chunked responses can be larger. Allowed values: `true` `false`. Defaults to `false`. + +- #### `JsonRpc.CallsFilterFilePath` \{#jsonrpc-callsfilterfilepath\} + + + + ``` + --jsonrpc-callsfilterfilepath + --JsonRpc.CallsFilterFilePath + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_CALLSFILTERFILEPATH= + ``` + + + ```json + { + "JsonRpc": { + "CallsFilterFilePath": + } + } + ``` + + + + The path to a file with the list of new-line-separated JSON-RPC calls. If specified, only the calls from that file are allowed. Defaults to `Data/jsonrpc.filter`. + +- #### `JsonRpc.CorsOrigins` \{#jsonrpc-corsorigins\} + + + + ``` + --jsonrpc-corsorigins + --JsonRpc.CorsOrigins + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_CORSORIGINS= + ``` + + + ```json + { + "JsonRpc": { + "CorsOrigins": + } + } + ``` + + + + The JSON-RPC server CORS origins. Defaults to `*`. + +- #### `JsonRpc.EnablePerMethodMetrics` \{#jsonrpc-enablepermethodmetrics\} + + + + ``` + --jsonrpc-enablepermethodmetrics [true|false] + --JsonRpc.EnablePerMethodMetrics [true|false] + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_ENABLEPERMETHODMETRICS=true|false + ``` + + + ```json + { + "JsonRpc": { + "EnablePerMethodMetrics": true|false + } + } + ``` + + + + Enable per-method call metric Allowed values: `true` `false`. Defaults to `false`. + +- #### `JsonRpc.Enabled` \{#jsonrpc-enabled\} + + + + ``` + --jsonrpc-enabled [true|false] + --JsonRpc.Enabled [true|false] + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_ENABLED=true|false + ``` + + + ```json + { + "JsonRpc": { + "Enabled": true|false + } + } + ``` + + + + Whether to enable the JSON-RPC service. Allowed values: `true` `false`. Defaults to `false`. + +- #### `JsonRpc.EnabledModules` \{#jsonrpc-enabledmodules\} + + + + ``` + --jsonrpc-enabledmodules + --JsonRpc.EnabledModules + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_ENABLEDMODULES= + ``` + + + ```json + { + "JsonRpc": { + "EnabledModules": + } + } + ``` + + + + An array of JSON-RPC namespaces to enable. For instance, `[debug,eth]`. + + Built-in namespaces: + + - `admin` + - `client` + - `debug` + - `engine` + - `eth` + - `evm` + - `health` + - `net` + - `parity` + - `personal` + - `proof` + - `rpc` + - `subscribe` + - `trace` + - `txpool` + - `web3` + + Defaults to `[Eth,Subscribe,Trace,TxPool,Web3,Personal,Proof,Net,Parity,Health,Rpc]`. + +- #### `JsonRpc.EngineEnabledModules` \{#jsonrpc-engineenabledmodules\} + + + + ``` + --jsonrpc-engineenabledmodules + --JsonRpc.EngineEnabledModules + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_ENGINEENABLEDMODULES= + ``` + + + ```json + { + "JsonRpc": { + "EngineEnabledModules": + } + } + ``` + + + + An array of additional JSON-RPC URLs to listen at with protocol and JSON-RPC namespace list for Engine API. Defaults to `[Net,Eth,Subscribe,Web3]`. + +- #### `JsonRpc.EngineHost` \{#jsonrpc-enginehost\} + + + + ``` + --jsonrpc-enginehost + --JsonRpc.EngineHost + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_ENGINEHOST= + ``` + + + ```json + { + "JsonRpc": { + "EngineHost": + } + } + ``` + + + + The Engine API host. Defaults to `127.0.0.1`. + +- #### `JsonRpc.EnginePort` \{#jsonrpc-engineport\} + + + + ``` + --jsonrpc-engineport + --JsonRpc.EnginePort + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_ENGINEPORT= + ``` + + + ```json + { + "JsonRpc": { + "EnginePort": + } + } + ``` + + + + The Engine API port. Defaults to `null`. + +- #### `JsonRpc.EstimateErrorMargin` \{#jsonrpc-estimateerrormargin\} + + + + ``` + --jsonrpc-estimateerrormargin + --JsonRpc.EstimateErrorMargin + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_ESTIMATEERRORMARGIN= + ``` + + + ```json + { + "JsonRpc": { + "EstimateErrorMargin": + } + } + ``` + + + + The error margin used in the `eth_estimateGas` JSON-RPC method, in basis points. Defaults to `150`. + +- #### `JsonRpc.EthModuleConcurrentInstances` \{#jsonrpc-ethmoduleconcurrentinstances\} + + + + ``` + --jsonrpc-ethmoduleconcurrentinstances + --JsonRpc.EthModuleConcurrentInstances + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_ETHMODULECONCURRENTINSTANCES= + ``` + + + ```json + { + "JsonRpc": { + "EthModuleConcurrentInstances": + } + } + ``` + + + + The number of concurrent instances for non-sharable calls: + + - `eth_call` + - `eth_estimateGas` + - `eth_getLogs` + - `eth_newBlockFilter` + - `eth_newFilter` + - `eth_newPendingTransactionFilter` + - `eth_uninstallFilter` + + This limits the load on the CPU and I/O to reasonable levels. If the limit is exceeded, HTTP 503 is returned along with the JSON-RPC error. Defaults to the number of logical processors. + +- #### `JsonRpc.FiltersTimeout` \{#jsonrpc-filterstimeout\} + + + + ``` + --jsonrpc-filterstimeout + --JsonRpc.FiltersTimeout + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_FILTERSTIMEOUT= + ``` + + + ```json + { + "JsonRpc": { + "FiltersTimeout": + } + } + ``` + + + + The eth_filters timeout, in milliseconds. Defaults to `900000`. + +- #### `JsonRpc.GasCap` \{#jsonrpc-gascap\} + + + + ``` + --jsonrpc-gascap + --JsonRpc.GasCap + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_GASCAP= + ``` + + + ```json + { + "JsonRpc": { + "GasCap": + } + } + ``` + + + + The maximum gas limit for `eth_call` and `eth_estimateGas`. Defaults to `100000000`. + +- #### `JsonRpc.Host` \{#jsonrpc-host\} + + + + ``` + --jsonrpc-host + --JsonRpc.Host + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_HOST= + ``` + + + ```json + { + "JsonRpc": { + "Host": + } + } + ``` + + + + The JSON-RPC service host. Defaults to `127.0.0.1`. + +- #### `JsonRpc.IpcProcessingConcurrency` \{#jsonrpc-ipcprocessingconcurrency\} + + + + ``` + --jsonrpc-ipcprocessingconcurrency + --JsonRpc.IpcProcessingConcurrency + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_IPCPROCESSINGCONCURRENCY= + ``` + + + ```json + { + "JsonRpc": { + "IpcProcessingConcurrency": + } + } + ``` + + + + Concurrency level of IPC connection. Defaults to `1`. + +- #### `JsonRpc.IpcUnixDomainSocketPath` \{#jsonrpc-ipcunixdomainsocketpath\} + + + + ``` + --jsonrpc-ipcunixdomainsocketpath + --JsonRpc.IpcUnixDomainSocketPath + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_IPCUNIXDOMAINSOCKETPATH= + ``` + + + ```json + { + "JsonRpc": { + "IpcUnixDomainSocketPath": + } + } + ``` + + + + The path to connect a UNIX domain socket over. + +- #### `JsonRpc.JsonSerializationMaxDepth` \{#jsonrpc-jsonserializationmaxdepth\} + + + + ``` + --jsonrpc-jsonserializationmaxdepth + --JsonRpc.JsonSerializationMaxDepth + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_JSONSERIALIZATIONMAXDEPTH= + ``` + + + ```json + { + "JsonRpc": { + "JsonSerializationMaxDepth": + } + } + ``` + + + + The maximum depth of JSON response object tree. Defaults to `128`. + +- #### `JsonRpc.JwtSecretFile` \{#jsonrpc-jwtsecretfile\} + + + + ``` + --jsonrpc-jwtsecretfile + --JsonRpc.JwtSecretFile + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_JWTSECRETFILE= + ``` + + + ```json + { + "JsonRpc": { + "JwtSecretFile": + } + } + ``` + + + + The path to the JWT secret file required for the Engine API authentication. Defaults to `null`. + +- #### `JsonRpc.MaxBatchResponseBodySize` \{#jsonrpc-maxbatchresponsebodysize\} + + + + ``` + --jsonrpc-maxbatchresponsebodysize + --JsonRpc.MaxBatchResponseBodySize + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_MAXBATCHRESPONSEBODYSIZE= + ``` + + + ```json + { + "JsonRpc": { + "MaxBatchResponseBodySize": + } + } + ``` + + + + The max batch size limit for batched JSON-RPC calls. Defaults to `33554432`. + +- #### `JsonRpc.MaxBatchSize` \{#jsonrpc-maxbatchsize\} + + + + ``` + --jsonrpc-maxbatchsize + --JsonRpc.MaxBatchSize + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_MAXBATCHSIZE= + ``` + + + ```json + { + "JsonRpc": { + "MaxBatchSize": + } + } + ``` + + + + The max number of JSON-RPC requests in a batch. Defaults to `1024`. + +- #### `JsonRpc.MaxLoggedRequestParametersCharacters` \{#jsonrpc-maxloggedrequestparameterscharacters\} + + + + ``` + --jsonrpc-maxloggedrequestparameterscharacters + --JsonRpc.MaxLoggedRequestParametersCharacters + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_MAXLOGGEDREQUESTPARAMETERSCHARACTERS= + ``` + + + ```json + { + "JsonRpc": { + "MaxLoggedRequestParametersCharacters": + } + } + ``` + + + + The max number of characters of a JSON-RPC request parameter printing to the log. Defaults to `null`. + +- #### `JsonRpc.MaxLogsPerResponse` \{#jsonrpc-maxlogsperresponse\} + + + + ``` + --jsonrpc-maxlogsperresponse + --JsonRpc.MaxLogsPerResponse + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_MAXLOGSPERRESPONSE= + ``` + + + ```json + { + "JsonRpc": { + "MaxLogsPerResponse": + } + } + ``` + + + + The max number of logs per response for the `eth_getLogs` JSON-RPC method. `0` to lift the limit. Defaults to `20000`. + +- #### `JsonRpc.MaxRequestBodySize` \{#jsonrpc-maxrequestbodysize\} + + + + ``` + --jsonrpc-maxrequestbodysize + --JsonRpc.MaxRequestBodySize + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_MAXREQUESTBODYSIZE= + ``` + + + ```json + { + "JsonRpc": { + "MaxRequestBodySize": + } + } + ``` + + + + The max length of HTTP request body, in bytes. Defaults to `30000000`. + +- #### `JsonRpc.MaxSimulateBlocksCap` \{#jsonrpc-maxsimulateblockscap\} + + + + ``` + --jsonrpc-maxsimulateblockscap + --JsonRpc.MaxSimulateBlocksCap + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_MAXSIMULATEBLOCKSCAP= + ``` + + + ```json + { + "JsonRpc": { + "MaxSimulateBlocksCap": + } + } + ``` + + + + The max block count limit for the `eth_simulate` JSON-RPC method. Defaults to `256`. + +- #### `JsonRpc.MethodsLoggingFiltering` \{#jsonrpc-methodsloggingfiltering\} + + + + ``` + --jsonrpc-methodsloggingfiltering + --JsonRpc.MethodsLoggingFiltering + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_METHODSLOGGINGFILTERING= + ``` + + + ```json + { + "JsonRpc": { + "MethodsLoggingFiltering": + } + } + ``` + + + + An array of the method names not to log. Defaults to `[engine_newPayloadV1,engine_newPayloadV2,engine_newPayloadV3,engine_forkchoiceUpdatedV1,engine_forkchoiceUpdatedV2,flashbots_validateBuilderSubmissionV3]`. + +- #### `JsonRpc.Port` \{#jsonrpc-port\} + + + + ``` + --jsonrpc-port + --JsonRpc.Port + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_PORT= + ``` + + + ```json + { + "JsonRpc": { + "Port": + } + } + ``` + + + + The JSON-RPC service HTTP port. Defaults to `8545`. + +- #### `JsonRpc.PreloadRpcModules` \{#jsonrpc-preloadrpcmodules\} + + + + ``` + --jsonrpc-preloadrpcmodules [true|false] + --JsonRpc.PreloadRpcModules [true|false] + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_PRELOADRPCMODULES=true|false + ``` + + + ```json + { + "JsonRpc": { + "PreloadRpcModules": true|false + } + } + ``` + + + + Preload rpc modules. Useful in rpc provider to reduce latency on first request. Allowed values: `true` `false`. Defaults to `false`. + +- #### `JsonRpc.ReportIntervalSeconds` \{#jsonrpc-reportintervalseconds\} + + + + ``` + --jsonrpc-reportintervalseconds + --JsonRpc.ReportIntervalSeconds + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_REPORTINTERVALSECONDS= + ``` + + + ```json + { + "JsonRpc": { + "ReportIntervalSeconds": + } + } + ``` + + + + The interval, in seconds, between the JSON-RPC stats report log. Defaults to `300`. + +- #### `JsonRpc.RequestQueueLimit` \{#jsonrpc-requestqueuelimit\} + + + + ``` + --jsonrpc-requestqueuelimit + --JsonRpc.RequestQueueLimit + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_REQUESTQUEUELIMIT= + ``` + + + ```json + { + "JsonRpc": { + "RequestQueueLimit": + } + } + ``` + + + + The max number of concurrent requests in the queue for: + + - `eth_call` + - `eth_estimateGas` + - `eth_getLogs` + - `eth_newFilter` + - `eth_newBlockFilter` + - `eth_newPendingTransactionFilter` + - `eth_uninstallFilter` + + `0` to lift the limit. Defaults to `500`. + +- #### `JsonRpc.RpcRecorderBaseFilePath` \{#jsonrpc-rpcrecorderbasefilepath\} + + + + ``` + --jsonrpc-rpcrecorderbasefilepath + --JsonRpc.RpcRecorderBaseFilePath + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_RPCRECORDERBASEFILEPATH= + ``` + + + ```json + { + "JsonRpc": { + "RpcRecorderBaseFilePath": + } + } + ``` + + + + The path to the base file for diagnostic recording. Defaults to `logs/rpc.{counter}.txt`. + +- #### `JsonRpc.RpcRecorderState` \{#jsonrpc-rpcrecorderstate\} + + + + ``` + --jsonrpc-rpcrecorderstate + --JsonRpc.RpcRecorderState + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_RPCRECORDERSTATE= + ``` + + + ```json + { + "JsonRpc": { + "RpcRecorderState": + } + } + ``` + + + + The diagnostic recording mode. + + Allowed values: + + - `None`: None. + - `Request`: Records requests. + - `Response`: Records responses. + - `All`: Records both requests and responses. + + Defaults to `None`. + +- #### `JsonRpc.StrictHexFormat` \{#jsonrpc-stricthexformat\} + + + + ``` + --jsonrpc-stricthexformat [true|false] + --JsonRpc.StrictHexFormat [true|false] + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_STRICTHEXFORMAT=true|false + ``` + + + ```json + { + "JsonRpc": { + "StrictHexFormat": true|false + } + } + ``` + + + + Enable strict parsing rules for Block Params and Hashas in RPC requests. this will decrease compatibility but increase compliance with the spec. Allowed values: `true` `false`. Defaults to `true`. + +- #### `JsonRpc.Timeout` \{#jsonrpc-timeout\} + + + + ``` + --jsonrpc-timeout + --JsonRpc.Timeout + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_TIMEOUT= + ``` + + + ```json + { + "JsonRpc": { + "Timeout": + } + } + ``` + + + + The request timeout, in milliseconds. Defaults to `20000`. + +- #### `JsonRpc.WebSocketsPort` \{#jsonrpc-websocketsport\} + + + + ``` + --jsonrpc-websocketsport + --JsonRpc.WebSocketsPort + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_WEBSOCKETSPORT= + ``` + + + ```json + { + "JsonRpc": { + "WebSocketsPort": + } + } + ``` + + + + The JSON-RPC service WebSockets port. Defaults to `8545`. + +- #### `JsonRpc.WebSocketsProcessingConcurrency` \{#jsonrpc-websocketsprocessingconcurrency\} + + + + ``` + --jsonrpc-websocketsprocessingconcurrency + --JsonRpc.WebSocketsProcessingConcurrency + ``` + + + ``` + NETHERMIND_JSONRPCCONFIG_WEBSOCKETSPROCESSINGCONCURRENCY= + ``` + + + ```json + { + "JsonRpc": { + "WebSocketsProcessingConcurrency": + } + } + ``` + + + + Concurrency level of websocket connection. Defaults to `1`. + + +### KeyStore + +- #### `KeyStore.BlockAuthorAccount` \{#keystore-blockauthoraccount\} + + + + ``` + --keystore-blockauthoraccount + --KeyStore.BlockAuthorAccount + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_BLOCKAUTHORACCOUNT= + ``` + + + ```json + { + "KeyStore": { + "BlockAuthorAccount": + } + } + ``` + + + + An account to use as the block author (coinbase). + +- #### `KeyStore.Cipher` \{#keystore-cipher\} + + + + ``` + --keystore-cipher + --KeyStore.Cipher + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_CIPHER= + ``` + + + ```json + { + "KeyStore": { + "Cipher": + } + } + ``` + + + + See [Web3 secret storage definition][web3-secret-storage]. Defaults to `aes-128-ctr`. + +- #### `KeyStore.EnodeAccount` \{#keystore-enodeaccount\} + + + + ``` + --keystore-enodeaccount + --KeyStore.EnodeAccount + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_ENODEACCOUNT= + ``` + + + ```json + { + "KeyStore": { + "EnodeAccount": + } + } + ``` + + + + An account to use for networking (enode). If neither this nor the `EnodeKeyFile` option is specified, the key is autogenerated in `node.key.plain` file. + +- #### `KeyStore.EnodeKeyFile` \{#keystore-enodekeyfile\} + + + + ``` + --keystore-enodekeyfile + --KeyStore.EnodeKeyFile + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_ENODEKEYFILE= + ``` + + + ```json + { + "KeyStore": { + "EnodeKeyFile": + } + } + ``` + + + + The path to the key file to use by for networking (enode). If neither this nor the `EnodeAccount` is specified, the key is autogenerated in `node.key.plain` file. + +- #### `KeyStore.IVSize` \{#keystore-ivsize\} + + + + ``` + --keystore-ivsize + --KeyStore.IVSize + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_IVSIZE= + ``` + + + ```json + { + "KeyStore": { + "IVSize": + } + } + ``` + + + + See [Web3 secret storage definition][web3-secret-storage]. Defaults to `16`. + +- #### `KeyStore.Kdf` \{#keystore-kdf\} + + + + ``` + --keystore-kdf + --KeyStore.Kdf + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_KDF= + ``` + + + ```json + { + "KeyStore": { + "Kdf": + } + } + ``` + + + + See [Web3 secret storage definition][web3-secret-storage]. Defaults to `scrypt`. + +- #### `KeyStore.KdfparamsDklen` \{#keystore-kdfparamsdklen\} + + + + ``` + --keystore-kdfparamsdklen + --KeyStore.KdfparamsDklen + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_KDFPARAMSDKLEN= + ``` + + + ```json + { + "KeyStore": { + "KdfparamsDklen": + } + } + ``` + + + + See [Web3 secret storage definition][web3-secret-storage]. Defaults to `32`. + +- #### `KeyStore.KdfparamsN` \{#keystore-kdfparamsn\} + + + + ``` + --keystore-kdfparamsn + --KeyStore.KdfparamsN + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_KDFPARAMSN= + ``` + + + ```json + { + "KeyStore": { + "KdfparamsN": + } + } + ``` + + + + See [Web3 secret storage definition][web3-secret-storage]. Defaults to `262144`. + +- #### `KeyStore.KdfparamsP` \{#keystore-kdfparamsp\} + + + + ``` + --keystore-kdfparamsp + --KeyStore.KdfparamsP + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_KDFPARAMSP= + ``` + + + ```json + { + "KeyStore": { + "KdfparamsP": + } + } + ``` + + + + See [Web3 secret storage definition][web3-secret-storage]. Defaults to `1`. + +- #### `KeyStore.KdfparamsR` \{#keystore-kdfparamsr\} + + + + ``` + --keystore-kdfparamsr + --KeyStore.KdfparamsR + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_KDFPARAMSR= + ``` + + + ```json + { + "KeyStore": { + "KdfparamsR": + } + } + ``` + + + + See [Web3 secret storage definition][web3-secret-storage]. Defaults to `8`. + +- #### `KeyStore.KdfparamsSaltLen` \{#keystore-kdfparamssaltlen\} + + + + ``` + --keystore-kdfparamssaltlen + --KeyStore.KdfparamsSaltLen + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_KDFPARAMSSALTLEN= + ``` + + + ```json + { + "KeyStore": { + "KdfparamsSaltLen": + } + } + ``` + + + + See [Web3 secret storage definition][web3-secret-storage]. Defaults to `32`. + +- #### `KeyStore.KeyStoreDirectory` \{#keystore-keystoredirectory\} + + + + ``` + --keystore-keystoredirectory + --KeyStore.KeyStoreDirectory + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_KEYSTOREDIRECTORY= + ``` + + + ```json + { + "KeyStore": { + "KeyStoreDirectory": + } + } + ``` + + + + The path to the keystore directory. Defaults to `keystore`. + +- #### `KeyStore.KeyStoreEncoding` \{#keystore-keystoreencoding\} + + + + ``` + --keystore-keystoreencoding + --KeyStore.KeyStoreEncoding + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_KEYSTOREENCODING= + ``` + + + ```json + { + "KeyStore": { + "KeyStoreEncoding": + } + } + ``` + + + + See [Web3 secret storage definition][web3-secret-storage]. Defaults to `UTF-8`. + +- #### `KeyStore.PasswordFiles` \{#keystore-passwordfiles\} + + + + ``` + --keystore-passwordfiles + --KeyStore.PasswordFiles + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_PASSWORDFILES= + ``` + + + ```json + { + "KeyStore": { + "PasswordFiles": + } + } + ``` + + + + An array of password files paths used to unlock the accounts set with `UnlockAccounts`. Defaults to `[]`. + +- #### `KeyStore.Passwords` \{#keystore-passwords\} + + + + ``` + --keystore-passwords + --KeyStore.Passwords + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_PASSWORDS= + ``` + + + ```json + { + "KeyStore": { + "Passwords": + } + } + ``` + + + + An array of passwords used to unlock the accounts set with `UnlockAccounts`. Defaults to `[]`. + +- #### `KeyStore.SymmetricEncrypterBlockSize` \{#keystore-symmetricencrypterblocksize\} + + + + ``` + --keystore-symmetricencrypterblocksize + --KeyStore.SymmetricEncrypterBlockSize + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_SYMMETRICENCRYPTERBLOCKSIZE= + ``` + + + ```json + { + "KeyStore": { + "SymmetricEncrypterBlockSize": + } + } + ``` + + + + See [Web3 secret storage definition][web3-secret-storage]. Defaults to `128`. + +- #### `KeyStore.SymmetricEncrypterKeySize` \{#keystore-symmetricencrypterkeysize\} + + + + ``` + --keystore-symmetricencrypterkeysize + --KeyStore.SymmetricEncrypterKeySize + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_SYMMETRICENCRYPTERKEYSIZE= + ``` + + + ```json + { + "KeyStore": { + "SymmetricEncrypterKeySize": + } + } + ``` + + + + See [Web3 secret storage definition][web3-secret-storage]. Defaults to `128`. + +- #### `KeyStore.TestNodeKey` \{#keystore-testnodekey\} + + + + ``` + --keystore-testnodekey + --KeyStore.TestNodeKey + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_TESTNODEKEY= + ``` + + + ```json + { + "KeyStore": { + "TestNodeKey": + } + } + ``` + + + + A plaintext private key to use for testing purposes. + +- #### `KeyStore.UnlockAccounts` \{#keystore-unlockaccounts\} + + + + ``` + --keystore-unlockaccounts + --KeyStore.UnlockAccounts + ``` + + + ``` + NETHERMIND_KEYSTORECONFIG_UNLOCKACCOUNTS= + ``` + + + ```json + { + "KeyStore": { + "UnlockAccounts": + } + } + ``` + + + + An array of accounts to unlock on startup using passwords either in `PasswordFiles` and `Passwords`. Defaults to `[]`. + + +### Merge + +- #### `Merge.BuilderRelayUrl` \{#merge-builderrelayurl\} + + + + ``` + --merge-builderrelayurl + --Merge.BuilderRelayUrl + ``` + + + ``` + NETHERMIND_MERGECONFIG_BUILDERRELAYURL= + ``` + + + ```json + { + "Merge": { + "BuilderRelayUrl": + } + } + ``` + + + + The URL of a builder relay. If specified, blocks are sent to the relay. Defaults to `null`. + +- #### `Merge.CollectionsPerDecommit` \{#merge-collectionsperdecommit\} + + + + ``` + --merge-collectionsperdecommit + --Merge.CollectionsPerDecommit + ``` + + + ``` + NETHERMIND_MERGECONFIG_COLLECTIONSPERDECOMMIT= + ``` + + + ```json + { + "Merge": { + "CollectionsPerDecommit": + } + } + ``` + + + + The number of requests to the garbage collector (GC) to release the process memory. + + Allowed values: + + - `-1`: No requests. + - `0`: Requests every time. + - A positive number: Requests after that many Engine API calls. + + Defaults to `25`. + +- #### `Merge.CompactMemory` \{#merge-compactmemory\} + + + + ``` + --merge-compactmemory + --Merge.CompactMemory + ``` + + + ``` + NETHERMIND_MERGECONFIG_COMPACTMEMORY= + ``` + + + ```json + { + "Merge": { + "CompactMemory": + } + } + ``` + + + + The memory compaction mode. When set to `Full`, compacts the large object heap (LOH) if `SweepMemory` is set to `Gen2`. + + Allowed values: + + - `No`: Disables memory compaction. + - `Yes`: Enables memory compaction. + - `Full`: Enables memory compaction with the large object heap (LOH) if `SweepMemory` is set to `Gen2`. + + Defaults to `Yes`. + +- #### `Merge.Enabled` \{#merge-enabled\} + + + + ``` + --merge-enabled [true|false] + --Merge.Enabled [true|false] + ``` + + + ``` + NETHERMIND_MERGECONFIG_ENABLED=true|false + ``` + + + ```json + { + "Merge": { + "Enabled": true|false + } + } + ``` + + + + Whether to enable the Merge hard fork. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Merge.FinalTotalDifficulty` \{#merge-finaltotaldifficulty\} + + + + ``` + --merge-finaltotaldifficulty + --Merge.FinalTotalDifficulty + ``` + + + ``` + NETHERMIND_MERGECONFIG_FINALTOTALDIFFICULTY= + ``` + + + ```json + { + "Merge": { + "FinalTotalDifficulty": + } + } + ``` + + + + The total difficulty of the last PoW block. Must be greater than or equal to the terminal total difficulty (TTD). Defaults to `null`. + +- #### `Merge.PrioritizeBlockLatency` \{#merge-prioritizeblocklatency\} + + + + ``` + --merge-prioritizeblocklatency [true|false] + --Merge.PrioritizeBlockLatency [true|false] + ``` + + + ``` + NETHERMIND_MERGECONFIG_PRIORITIZEBLOCKLATENCY=true|false + ``` + + + ```json + { + "Merge": { + "PrioritizeBlockLatency": true|false + } + } + ``` + + + + Whether to reduce block latency by disabling garbage collection during Engine API calls. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Merge.SweepMemory` \{#merge-sweepmemory\} + + + + ``` + --merge-sweepmemory + --Merge.SweepMemory + ``` + + + ``` + NETHERMIND_MERGECONFIG_SWEEPMEMORY= + ``` + + + ```json + { + "Merge": { + "SweepMemory": + } + } + ``` + + + + The garbage collection (GC) mode between Engine API calls. + + Allowed values: + + - `NoGC`: Disables garbage collection. + - `Gen0`: Enables garbage collection of generation 0. + - `Gen1`: Enables garbage collection of generation 1. + - `Gen2`: Enables garbage collection of generation 2. + + Defaults to `Gen1`. + +- #### `Merge.TerminalBlockHash` \{#merge-terminalblockhash\} + + + + ``` + --merge-terminalblockhash + --Merge.TerminalBlockHash + ``` + + + ``` + NETHERMIND_MERGECONFIG_TERMINALBLOCKHASH= + ``` + + + ```json + { + "Merge": { + "TerminalBlockHash": + } + } + ``` + + + + The terminal PoW block hash used for the transition. Defaults to `null`. + +- #### `Merge.TerminalBlockNumber` \{#merge-terminalblocknumber\} + + + + ``` + --merge-terminalblocknumber + --Merge.TerminalBlockNumber + ``` + + + ``` + NETHERMIND_MERGECONFIG_TERMINALBLOCKNUMBER= + ``` + + + ```json + { + "Merge": { + "TerminalBlockNumber": + } + } + ``` + + + + The terminal PoW block number used for the transition. + +- #### `Merge.TerminalTotalDifficulty` \{#merge-terminaltotaldifficulty\} + + + + ``` + --merge-terminaltotaldifficulty + --Merge.TerminalTotalDifficulty + ``` + + + ``` + NETHERMIND_MERGECONFIG_TERMINALTOTALDIFFICULTY= + ``` + + + ```json + { + "Merge": { + "TerminalTotalDifficulty": + } + } + ``` + + + + The terminal total difficulty (TTD) used for the transition. Defaults to `null`. + + +### Metrics + +- #### `Metrics.CountersEnabled` \{#metrics-countersenabled\} + + + + ``` + --metrics-countersenabled [true|false] + --Metrics.CountersEnabled [true|false] + ``` + + + ``` + NETHERMIND_METRICSCONFIG_COUNTERSENABLED=true|false + ``` + + + ```json + { + "Metrics": { + "CountersEnabled": true|false + } + } + ``` + + + + Whether to publish metrics using .NET diagnostics that can be collected with dotnet-counters. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Metrics.EnableDbSizeMetrics` \{#metrics-enabledbsizemetrics\} + + + + ``` + --metrics-enabledbsizemetrics [true|false] + --Metrics.EnableDbSizeMetrics [true|false] + ``` + + + ``` + NETHERMIND_METRICSCONFIG_ENABLEDBSIZEMETRICS=true|false + ``` + + + ```json + { + "Metrics": { + "EnableDbSizeMetrics": true|false + } + } + ``` + + + + Whether to publish database size metrics. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Metrics.EnableDetailedMetric` \{#metrics-enabledetailedmetric\} + + + + ``` + --metrics-enabledetailedmetric [true|false] + --Metrics.EnableDetailedMetric [true|false] + ``` + + + ``` + NETHERMIND_METRICSCONFIG_ENABLEDETAILEDMETRIC=true|false + ``` + + + ```json + { + "Metrics": { + "EnableDetailedMetric": true|false + } + } + ``` + + + + Enable detailed metric Allowed values: `true` `false`. Defaults to `false`. + +- #### `Metrics.Enabled` \{#metrics-enabled\} + + + + ``` + --metrics-enabled [true|false] + --Metrics.Enabled [true|false] + ``` + + + ``` + NETHERMIND_METRICSCONFIG_ENABLED=true|false + ``` + + + ```json + { + "Metrics": { + "Enabled": true|false + } + } + ``` + + + + Whether to publish various metrics to Prometheus Pushgateway at a given interval. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Metrics.ExposeHost` \{#metrics-exposehost\} + + + + ``` + --metrics-exposehost + --Metrics.ExposeHost + ``` + + + ``` + NETHERMIND_METRICSCONFIG_EXPOSEHOST= + ``` + + + ```json + { + "Metrics": { + "ExposeHost": + } + } + ``` + + + + The IP address to expose Prometheus metrics at. The value of `+` means listening on all available hostnames. Setting this to `localhost` prevents remote access. Defaults to `+`. + +- #### `Metrics.ExposePort` \{#metrics-exposeport\} + + + + ``` + --metrics-exposeport + --Metrics.ExposePort + ``` + + + ``` + NETHERMIND_METRICSCONFIG_EXPOSEPORT= + ``` + + + ```json + { + "Metrics": { + "ExposePort": + } + } + ``` + + + + The port to expose Prometheus metrics at. + +- #### `Metrics.IntervalSeconds` \{#metrics-intervalseconds\} + + + + ``` + --metrics-intervalseconds + --Metrics.IntervalSeconds + ``` + + + ``` + NETHERMIND_METRICSCONFIG_INTERVALSECONDS= + ``` + + + ```json + { + "Metrics": { + "IntervalSeconds": + } + } + ``` + + + + The frequency of pushing metrics to Prometheus, in seconds. Defaults to `5`. + +- #### `Metrics.MonitoringGroup` \{#metrics-monitoringgroup\} + + + + ``` + --metrics-monitoringgroup + --Metrics.MonitoringGroup + ``` + + + ``` + NETHERMIND_METRICSCONFIG_MONITORINGGROUP= + ``` + + + ```json + { + "Metrics": { + "MonitoringGroup": + } + } + ``` + + + + The Prometheus metrics group name. Defaults to `nethermind`. + +- #### `Metrics.MonitoringJob` \{#metrics-monitoringjob\} + + + + ``` + --metrics-monitoringjob + --Metrics.MonitoringJob + ``` + + + ``` + NETHERMIND_METRICSCONFIG_MONITORINGJOB= + ``` + + + ```json + { + "Metrics": { + "MonitoringJob": + } + } + ``` + + + + The Prometheus metrics job name. Defaults to `nethermind`. + +- #### `Metrics.NodeName` \{#metrics-nodename\} + + + + ``` + --metrics-nodename + --Metrics.NodeName + ``` + + + ``` + NETHERMIND_METRICSCONFIG_NODENAME= + ``` + + + ```json + { + "Metrics": { + "NodeName": + } + } + ``` + + + + The name to display on the Grafana dashboard. Defaults to `Nethermind`. + +- #### `Metrics.PushGatewayUrl` \{#metrics-pushgatewayurl\} + + + + ``` + --metrics-pushgatewayurl + --Metrics.PushGatewayUrl + ``` + + + ``` + NETHERMIND_METRICSCONFIG_PUSHGATEWAYURL= + ``` + + + ```json + { + "Metrics": { + "PushGatewayUrl": + } + } + ``` + + + + The Prometheus Pushgateway instance URL. + + +### Mining + +- #### `Mining.Enabled` \{#mining-enabled\} + + + + ``` + --mining-enabled [true|false] + --Mining.Enabled [true|false] + ``` + + + ``` + NETHERMIND_MININGCONFIG_ENABLED=true|false + ``` + + + ```json + { + "Mining": { + "Enabled": true|false + } + } + ``` + + + + Whether to produce blocks. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Mining.Signer` \{#mining-signer\} + + + + ``` + --mining-signer + --Mining.Signer + ``` + + + ``` + NETHERMIND_MININGCONFIG_SIGNER= + ``` + + + ```json + { + "Mining": { + "Signer": + } + } + ``` + + + + The URL of an external signer like [Clef](https://github.com/ethereum/go-ethereum/blob/master/cmd/clef/tutorial.md). Defaults to `null`. + + +### Network + +- #### `Network.Bootnodes` \{#network-bootnodes\} + + + + ``` + --network-bootnodes + --Network.Bootnodes + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_BOOTNODES= + ``` + + + ```json + { + "Network": { + "Bootnodes": + } + } + ``` + + + + A comma-separated enode list to be used as boot nodes. + +- #### `Network.DiagTracerEnabled` \{#network-diagtracerenabled\} + + + + ``` + --network-diagtracerenabled [true|false] + --Network.DiagTracerEnabled [true|false] + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_DIAGTRACERENABLED=true|false + ``` + + + ```json + { + "Network": { + "DiagTracerEnabled": true|false + } + } + ``` + + + + Whether to enable a verbose diagnostic tracing. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Network.DiscoveryDns` \{#network-discoverydns\} + + + + ``` + --network-discoverydns + --Network.DiscoveryDns + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_DISCOVERYDNS= + ``` + + + ```json + { + "Network": { + "DiscoveryDns": + } + } + ``` + + + + Use tree is available through a DNS name. For the default of `.ethdisco.net`, leave unspecified. Defaults to `null`. + +- #### `Network.DiscoveryPort` \{#network-discoveryport\} + + + + ``` + --network-discoveryport + --Network.DiscoveryPort + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_DISCOVERYPORT= + ``` + + + ```json + { + "Network": { + "DiscoveryPort": + } + } + ``` + + + + The UDP port number for incoming discovery connections. It's recommended to keep it the same as the TCP port (`P2PPort`) because other values have not been tested yet. Defaults to `30303`. + +- #### `Network.EnableUPnP` \{#network-enableupnp\} + + + + ``` + --network-enableupnp [true|false] + --Network.EnableUPnP [true|false] + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_ENABLEUPNP=true|false + ``` + + + ```json + { + "Network": { + "EnableUPnP": true|false + } + } + ``` + + + + Whether to enable automatic port forwarding via UPnP. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Network.ExternalIp` \{#network-externalip\} + + + + ``` + --network-externalip + --Network.ExternalIp + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_EXTERNALIP= + ``` + + + ```json + { + "Network": { + "ExternalIp": + } + } + ``` + + + + The external IP. Use only when the external IP cannot be resolved automatically. Defaults to `null`. + +- #### `Network.LocalIp` \{#network-localip\} + + + + ``` + --network-localip + --Network.LocalIp + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_LOCALIP= + ``` + + + ```json + { + "Network": { + "LocalIp": + } + } + ``` + + + + The local IP. Use only when the local IP cannot be resolved automatically. Defaults to `null`. + +- #### `Network.MaxActivePeers` \{#network-maxactivepeers\} + + + + ``` + --network-maxactivepeers + --Network.MaxActivePeers + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_MAXACTIVEPEERS= + ``` + + + ```json + { + "Network": { + "MaxActivePeers": + } + } + ``` + + + + The max allowed number of connected peers. Defaults to `50`. + +- #### `Network.MaxNettyArenaCount` \{#network-maxnettyarenacount\} + + + + ``` + --network-maxnettyarenacount + --Network.MaxNettyArenaCount + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_MAXNETTYARENACOUNT= + ``` + + + ```json + { + "Network": { + "MaxNettyArenaCount": + } + } + ``` + + + + The maximum DotNetty arena count. Increasing this on a high-core CPU without increasing the memory budget may reduce chunk size so much that it causes a huge memory allocation. Defaults to `8`. + +- #### `Network.NettyArenaOrder` \{#network-nettyarenaorder\} + + + + ``` + --network-nettyarenaorder + --Network.NettyArenaOrder + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_NETTYARENAORDER= + ``` + + + ```json + { + "Network": { + "NettyArenaOrder": + } + } + ``` + + + + The size of the DotNetty arena order. `-1` to depend on the memory hint. Defaults to `-1`. + +- #### `Network.OnlyStaticPeers` \{#network-onlystaticpeers\} + + + + ``` + --network-onlystaticpeers [true|false] + --Network.OnlyStaticPeers [true|false] + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_ONLYSTATICPEERS=true|false + ``` + + + ```json + { + "Network": { + "OnlyStaticPeers": true|false + } + } + ``` + + + + Whether to use static peers only. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Network.P2PPort` \{#network-p2pport\} + + + + ``` + --network-p2pport + --Network.P2PPort + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_P2PPORT= + ``` + + + ```json + { + "Network": { + "P2PPort": + } + } + ``` + + + + The TCP port for incoming P2P connections. Defaults to `30303`. + +- #### `Network.PriorityPeersMaxCount` \{#network-prioritypeersmaxcount\} + + + + ``` + --network-prioritypeersmaxcount + --Network.PriorityPeersMaxCount + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_PRIORITYPEERSMAXCOUNT= + ``` + + + ```json + { + "Network": { + "PriorityPeersMaxCount": + } + } + ``` + + + + The max number of priority peers. Can be overridden by a plugin. Defaults to `0`. + +- #### `Network.PublicClientIdFormat` \{#network-publicclientidformat\} + + + + ``` + --network-publicclientidformat + --Network.PublicClientIdFormat + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_PUBLICCLIENTIDFORMAT= + ``` + + + ```json + { + "Network": { + "PublicClientIdFormat": + } + } + ``` + + + + A template string for the public client id provided to external clients. Allowed placeholders: `{name}` `{version}` `{os}` `{runtime}`. Defaults to `{name}/{version}/{os}/{runtime}`. + +- #### `Network.StaticPeers` \{#network-staticpeers\} + + + + ``` + --network-staticpeers + --Network.StaticPeers + ``` + + + ``` + NETHERMIND_NETWORKCONFIG_STATICPEERS= + ``` + + + ```json + { + "Network": { + "StaticPeers": + } + } + ``` + + + + A list of peers to keep connection for. Static peers are affected by `MaxActivePeers`. Defaults to `null`. + + +### Optimism + +- #### `Optimism.SequencerUrl` \{#optimism-sequencerurl\} + + + + ``` + --optimism-sequencerurl + --Optimism.SequencerUrl + ``` + + + ``` + NETHERMIND_OPTIMISMCONFIG_SEQUENCERURL= + ``` + + + ```json + { + "Optimism": { + "SequencerUrl": + } + } + ``` + + + + The Optimism sequencer URL. Defaults to `null`. + + +### Pruning + +- #### `Pruning.AvailableSpaceCheckEnabled` \{#pruning-availablespacecheckenabled\} + + + + ``` + --pruning-availablespacecheckenabled [true|false] + --Pruning.AvailableSpaceCheckEnabled [true|false] + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_AVAILABLESPACECHECKENABLED=true|false + ``` + + + ```json + { + "Pruning": { + "AvailableSpaceCheckEnabled": true|false + } + } + ``` + + + + Whether to enables available disk space check. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Pruning.CacheMb` \{#pruning-cachemb\} + + + + ``` + --pruning-cachemb + --Pruning.CacheMb + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_CACHEMB= + ``` + + + ```json + { + "Pruning": { + "CacheMb": + } + } + ``` + + + + The in-memory cache size, in MB. Bigger size tend to improve performance. Defaults to `1280`. + +- #### `Pruning.DirtyCacheMb` \{#pruning-dirtycachemb\} + + + + ``` + --pruning-dirtycachemb + --Pruning.DirtyCacheMb + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_DIRTYCACHEMB= + ``` + + + ```json + { + "Pruning": { + "DirtyCacheMb": + } + } + ``` + + + + The in-memory cache size for dirty nodes, in MB. Increasing this reduces pruning interval but cause increased pruning time. Defaults to `1024`. + +- #### `Pruning.DirtyNodeShardBit` \{#pruning-dirtynodeshardbit\} + + + + ``` + --pruning-dirtynodeshardbit + --Pruning.DirtyNodeShardBit + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_DIRTYNODESHARDBIT= + ``` + + + ```json + { + "Pruning": { + "DirtyNodeShardBit": + } + } + ``` + + + + Dirty node shard count Defaults to `8`. + +- #### `Pruning.FullPruningCompletionBehavior` \{#pruning-fullpruningcompletionbehavior\} + + + + ``` + --pruning-fullpruningcompletionbehavior + --Pruning.FullPruningCompletionBehavior + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_FULLPRUNINGCOMPLETIONBEHAVIOR= + ``` + + + ```json + { + "Pruning": { + "FullPruningCompletionBehavior": + } + } + ``` + + + + The action to take on pruning completion. + + Allowed values: + + - `None`: No action. + - `ShutdownOnSuccess`: Shuts Nethermind down when pruning succeeds but leaves it running when fails. + - `AlwaysShutdown`: Shuts Nethermind down when pruning completes, regardless of its status. + + Defaults to `None`. + +- #### `Pruning.FullPruningDisableLowPriorityWrites` \{#pruning-fullpruningdisablelowprioritywrites\} + + + + ``` + --pruning-fullpruningdisablelowprioritywrites [true|false] + --Pruning.FullPruningDisableLowPriorityWrites [true|false] + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_FULLPRUNINGDISABLELOWPRIORITYWRITES=true|false + ``` + + + ```json + { + "Pruning": { + "FullPruningDisableLowPriorityWrites": true|false + } + } + ``` + + + + Whether to disable low-priority for pruning writes. Full pruning uses low-priority write operations to prevent blocking block processing. If block processing is not high-priority, set this option to `true` for faster pruning. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Pruning.FullPruningMaxDegreeOfParallelism` \{#pruning-fullpruningmaxdegreeofparallelism\} + + + + ``` + --pruning-fullpruningmaxdegreeofparallelism + --Pruning.FullPruningMaxDegreeOfParallelism + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_FULLPRUNINGMAXDEGREEOFPARALLELISM= + ``` + + + ```json + { + "Pruning": { + "FullPruningMaxDegreeOfParallelism": + } + } + ``` + + + + The max number of parallel tasks that can be used by full pruning. + + Allowed values: + + - `-1`: Uses the number of logical processors. + - `0`: Uses 25% of logical processors. + - `1`: Runs on a single thread. + + The recommended value depends on the type of the node: + + - If the node needs to be responsive (serves for RPC or validator), then the recommended value is `0` or `-1`. + - If the node doesn't have many other responsibilities but needs to be able to follow the chain reliably without any delays and produce live logs, the `0` or `1` is recommended. + - If the node doesn't have to be responsive, has very fast I/O (like NVMe) and the shortest pruning time is to be achieved, then `-1` is recommended. Defaults to `0`. + +- #### `Pruning.FullPruningMemoryBudgetMb` \{#pruning-fullpruningmemorybudgetmb\} + + + + ``` + --pruning-fullpruningmemorybudgetmb + --Pruning.FullPruningMemoryBudgetMb + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_FULLPRUNINGMEMORYBUDGETMB= + ``` + + + ```json + { + "Pruning": { + "FullPruningMemoryBudgetMb": + } + } + ``` + + + + The memory budget, in MB, used for the trie visit. Increasing this value significantly reduces the IOPS requirement at the expense of memory usage. `0` to disable. Defaults to `4000`. + +- #### `Pruning.FullPruningMinimumDelayHours` \{#pruning-fullpruningminimumdelayhours\} + + + + ``` + --pruning-fullpruningminimumdelayhours + --Pruning.FullPruningMinimumDelayHours + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_FULLPRUNINGMINIMUMDELAYHOURS= + ``` + + + ```json + { + "Pruning": { + "FullPruningMinimumDelayHours": + } + } + ``` + + + + The minimum delay, in hours, between full pruning operations not to exhaust disk writes. Defaults to `240`. + +- #### `Pruning.FullPruningThresholdMb` \{#pruning-fullpruningthresholdmb\} + + + + ``` + --pruning-fullpruningthresholdmb + --Pruning.FullPruningThresholdMb + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_FULLPRUNINGTHRESHOLDMB= + ``` + + + ```json + { + "Pruning": { + "FullPruningThresholdMb": + } + } + ``` + + + + The threshold, in MB, to trigger full pruning. Depends on `Mode` and `FullPruningTrigger`. Defaults to `256000`. + +- #### `Pruning.FullPruningTrigger` \{#pruning-fullpruningtrigger\} + + + + ``` + --pruning-fullpruningtrigger + --Pruning.FullPruningTrigger + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_FULLPRUNINGTRIGGER= + ``` + + + ```json + { + "Pruning": { + "FullPruningTrigger": + } + } + ``` + + + + The full pruning trigger. + + Allowed values: + + - `Manual`: Does not trigger. Pruning can be triggered manually. + - `StateDbSize`: Triggers when the state DB size is above the specified threshold. + - `VolumeFreeSpace`: Triggers when the free disk space where the state DB is stored is below the specified threshold. + + Defaults to `Manual`. + +- #### `Pruning.MaxUnpersistedBlockCount` \{#pruning-maxunpersistedblockcount\} + + + + ``` + --pruning-maxunpersistedblockcount + --Pruning.MaxUnpersistedBlockCount + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_MAXUNPERSISTEDBLOCKCOUNT= + ``` + + + ```json + { + "Pruning": { + "MaxUnpersistedBlockCount": + } + } + ``` + + + + Maximum number of blocks worth of unpersisted state in memory. Default is 297, which is the number of mainnet blocks per hour. Defaults to `297`. + +- #### `Pruning.MinUnpersistedBlockCount` \{#pruning-minunpersistedblockcount\} + + + + ``` + --pruning-minunpersistedblockcount + --Pruning.MinUnpersistedBlockCount + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_MINUNPERSISTEDBLOCKCOUNT= + ``` + + + ```json + { + "Pruning": { + "MinUnpersistedBlockCount": + } + } + ``` + + + + Minimum number of block worth of unpersisted state in memory. Prevent memory pruning too often due to insufficient dirty cache memory. Defaults to `8`. + +- #### `Pruning.Mode` \{#pruning-mode\} + + + + ``` + --pruning-mode + --Pruning.Mode + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_MODE= + ``` + + + ```json + { + "Pruning": { + "Mode": + } + } + ``` + + + + The pruning mode. + + Allowed values: + + - `None`: No pruning (archive). + - `Memory`: In-memory pruning. + - `Full`: Full pruning. + - `Hybrid`: Combined in-memory and full pruning. + + Defaults to `Hybrid`. + +- #### `Pruning.PersistenceInterval` \{#pruning-persistenceinterval\} + + + + ``` + --pruning-persistenceinterval + --Pruning.PersistenceInterval + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_PERSISTENCEINTERVAL= + ``` + + + ```json + { + "Pruning": { + "PersistenceInterval": + } + } + ``` + + + + The block persistence frequency. Only applied with archive node. Defaults to `1`. + +- #### `Pruning.PrunePersistedNodeMinimumTarget` \{#pruning-prunepersistednodeminimumtarget\} + + + + ``` + --pruning-prunepersistednodeminimumtarget + --Pruning.PrunePersistedNodeMinimumTarget + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_PRUNEPERSISTEDNODEMINIMUMTARGET= + ``` + + + ```json + { + "Pruning": { + "PrunePersistedNodeMinimumTarget": + } + } + ``` + + + + Minimum persisted cache prune target Defaults to `50000000`. + +- #### `Pruning.PrunePersistedNodePortion` \{#pruning-prunepersistednodeportion\} + + + + ``` + --pruning-prunepersistednodeportion + --Pruning.PrunePersistedNodePortion + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_PRUNEPERSISTEDNODEPORTION= + ``` + + + ```json + { + "Pruning": { + "PrunePersistedNodePortion": + } + } + ``` + + + + Portion of persisted node to be prune at a time Defaults to `0.05`. + +- #### `Pruning.PruningBoundary` \{#pruning-pruningboundary\} + + + + ``` + --pruning-pruningboundary + --Pruning.PruningBoundary + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_PRUNINGBOUNDARY= + ``` + + + ```json + { + "Pruning": { + "PruningBoundary": + } + } + ``` + + + + The number of past states before the state gets pruned. Used to determine how old of a state to keep from the head. Defaults to `64`. + +- #### `Pruning.TrackPastKeys` \{#pruning-trackpastkeys\} + + + + ``` + --pruning-trackpastkeys [true|false] + --Pruning.TrackPastKeys [true|false] + ``` + + + ``` + NETHERMIND_PRUNINGCONFIG_TRACKPASTKEYS=true|false + ``` + + + ```json + { + "Pruning": { + "TrackPastKeys": true|false + } + } + ``` + + + + Enable tracking of past key to reduce database and pruning cache growth Allowed values: `true` `false`. Defaults to `true`. + + +### Receipt + +- #### `Receipt.CompactReceiptStore` \{#receipt-compactreceiptstore\} + + + + ``` + --receipt-compactreceiptstore [true|false] + --Receipt.CompactReceiptStore [true|false] + ``` + + + ``` + NETHERMIND_RECEIPTCONFIG_COMPACTRECEIPTSTORE=true|false + ``` + + + ```json + { + "Receipt": { + "CompactReceiptStore": true|false + } + } + ``` + + + + Whether to compact receipts database size at the expense of RPC performance. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Receipt.CompactTxIndex` \{#receipt-compacttxindex\} + + + + ``` + --receipt-compacttxindex [true|false] + --Receipt.CompactTxIndex [true|false] + ``` + + + ``` + NETHERMIND_RECEIPTCONFIG_COMPACTTXINDEX=true|false + ``` + + + ```json + { + "Receipt": { + "CompactTxIndex": true|false + } + } + ``` + + + + Whether to compact receipts transaction index database size at the expense of RPC performance. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Receipt.ReceiptsMigration` \{#receipt-receiptsmigration\} + + + + ``` + --receipt-receiptsmigration [true|false] + --Receipt.ReceiptsMigration [true|false] + ``` + + + ``` + NETHERMIND_RECEIPTCONFIG_RECEIPTSMIGRATION=true|false + ``` + + + ```json + { + "Receipt": { + "ReceiptsMigration": true|false + } + } + ``` + + + + Whether to migrate the receipts database to the new schema. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Receipt.StoreReceipts` \{#receipt-storereceipts\} + + + + ``` + --receipt-storereceipts [true|false] + --Receipt.StoreReceipts [true|false] + ``` + + + ``` + NETHERMIND_RECEIPTCONFIG_STORERECEIPTS=true|false + ``` + + + ```json + { + "Receipt": { + "StoreReceipts": true|false + } + } + ``` + + + + Whether to store receipts after a new block is processed. This setting is independent from downloading receipts in fast sync mode. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Receipt.TxLookupLimit` \{#receipt-txlookuplimit\} + + + + ``` + --receipt-txlookuplimit + --Receipt.TxLookupLimit + ``` + + + ``` + NETHERMIND_RECEIPTCONFIG_TXLOOKUPLIMIT= + ``` + + + ```json + { + "Receipt": { + "TxLookupLimit": + } + } + ``` + + + + The number of recent blocks to maintain transaction index for. `0` to never remove indices, `-1` to never index. Defaults to `2350000`. + + +### Seq + +- #### `Seq.ApiKey` \{#seq-apikey\} + + + + ``` + --seq-apikey + --Seq.ApiKey + ``` + + + ``` + NETHERMIND_SEQCONFIG_APIKEY= + ``` + + + ```json + { + "Seq": { + "ApiKey": + } + } + ``` + + + + The Seq API key. + +- #### `Seq.MinLevel` \{#seq-minlevel\} + + + + ``` + --seq-minlevel + --Seq.MinLevel + ``` + + + ``` + NETHERMIND_SEQCONFIG_MINLEVEL= + ``` + + + ```json + { + "Seq": { + "MinLevel": + } + } + ``` + + + + The min log level to sent to Seq. Defaults to `Off`. + +- #### `Seq.ServerUrl` \{#seq-serverurl\} + + + + ``` + --seq-serverurl + --Seq.ServerUrl + ``` + + + ``` + NETHERMIND_SEQCONFIG_SERVERURL= + ``` + + + ```json + { + "Seq": { + "ServerUrl": + } + } + ``` + + + + The Seq instance URL. Defaults to `http://localhost:5341`. + + +### Shutter + +- #### `Shutter.BootnodeP2PAddresses` \{#shutter-bootnodep2paddresses\} + + + + ``` + --shutter-bootnodep2paddresses + --Shutter.BootnodeP2PAddresses + ``` + + + ``` + NETHERMIND_SHUTTERCONFIG_BOOTNODEP2PADDRESSES= + ``` + + + ```json + { + "Shutter": { + "BootnodeP2PAddresses": + } + } + ``` + + + + The p2p addresses of the Shutter Keyper network bootnodes. + +- #### `Shutter.Enabled` \{#shutter-enabled\} + + + + ``` + --shutter-enabled [true|false] + --Shutter.Enabled [true|false] + ``` + + + ``` + NETHERMIND_SHUTTERCONFIG_ENABLED=true|false + ``` + + + ```json + { + "Shutter": { + "Enabled": true|false + } + } + ``` + + + + Whether to enable Shutter. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Shutter.InstanceID` \{#shutter-instanceid\} + + + + ``` + --shutter-instanceid + --Shutter.InstanceID + ``` + + + ``` + NETHERMIND_SHUTTERCONFIG_INSTANCEID= + ``` + + + ```json + { + "Shutter": { + "InstanceID": + } + } + ``` + + + + Instance ID of Shutter keyper set. Defaults to `0`. + +- #### `Shutter.KeyBroadcastContractAddress` \{#shutter-keybroadcastcontractaddress\} + + + + ``` + --shutter-keybroadcastcontractaddress + --Shutter.KeyBroadcastContractAddress + ``` + + + ``` + NETHERMIND_SHUTTERCONFIG_KEYBROADCASTCONTRACTADDRESS= + ``` + + + ```json + { + "Shutter": { + "KeyBroadcastContractAddress": + } + } + ``` + + + + The address of the Shutter key broadcast contract. Defaults to `null`. + +- #### `Shutter.KeyperSetManagerContractAddress` \{#shutter-keypersetmanagercontractaddress\} + + + + ``` + --shutter-keypersetmanagercontractaddress + --Shutter.KeyperSetManagerContractAddress + ``` + + + ``` + NETHERMIND_SHUTTERCONFIG_KEYPERSETMANAGERCONTRACTADDRESS= + ``` + + + ```json + { + "Shutter": { + "KeyperSetManagerContractAddress": + } + } + ``` + + + + The address of the Shutter keyper set manager contract. Defaults to `null`. + +- #### `Shutter.P2PPort` \{#shutter-p2pport\} + + + + ``` + --shutter-p2pport + --Shutter.P2PPort + ``` + + + ``` + NETHERMIND_SHUTTERCONFIG_P2PPORT= + ``` + + + ```json + { + "Shutter": { + "P2PPort": + } + } + ``` + + + + The port to connect to Shutter P2P network with. Defaults to `23102`. + +- #### `Shutter.SequencerContractAddress` \{#shutter-sequencercontractaddress\} + + + + ``` + --shutter-sequencercontractaddress + --Shutter.SequencerContractAddress + ``` + + + ``` + NETHERMIND_SHUTTERCONFIG_SEQUENCERCONTRACTADDRESS= + ``` + + + ```json + { + "Shutter": { + "SequencerContractAddress": + } + } + ``` + + + + The address of the Shutter sequencer contract. Defaults to `null`. + +- #### `Shutter.ShutterKeyFile` \{#shutter-shutterkeyfile\} + + + + ``` + --shutter-shutterkeyfile + --Shutter.ShutterKeyFile + ``` + + + ``` + NETHERMIND_SHUTTERCONFIG_SHUTTERKEYFILE= + ``` + + + ```json + { + "Shutter": { + "ShutterKeyFile": + } + } + ``` + + + + The filename to use for the Shutter P2P key. If this not specified, the key is autogenerated in `shutter.key.plain` file. + +- #### `Shutter.ValidatorInfoFile` \{#shutter-validatorinfofile\} + + + + ``` + --shutter-validatorinfofile + --Shutter.ValidatorInfoFile + ``` + + + ``` + NETHERMIND_SHUTTERCONFIG_VALIDATORINFOFILE= + ``` + + + ```json + { + "Shutter": { + "ValidatorInfoFile": + } + } + ``` + + + + The filepath of the validator info json file. Defaults to `null`. + +- #### `Shutter.ValidatorRegistryContractAddress` \{#shutter-validatorregistrycontractaddress\} + + + + ``` + --shutter-validatorregistrycontractaddress + --Shutter.ValidatorRegistryContractAddress + ``` + + + ``` + NETHERMIND_SHUTTERCONFIG_VALIDATORREGISTRYCONTRACTADDRESS= + ``` + + + ```json + { + "Shutter": { + "ValidatorRegistryContractAddress": + } + } + ``` + + + + The address of the Shutter validator registry contract. Defaults to `null`. + + +### Snapshot + +- #### `Snapshot.Checksum` \{#snapshot-checksum\} + + + + ``` + --snapshot-checksum + --Snapshot.Checksum + ``` + + + ``` + NETHERMIND_SNAPSHOTCONFIG_CHECKSUM= + ``` + + + ```json + { + "Snapshot": { + "Checksum": + } + } + ``` + + + + The SHA-256 checksum of the snapshot file. Defaults to `null`. + +- #### `Snapshot.DownloadUrl` \{#snapshot-downloadurl\} + + + + ``` + --snapshot-downloadurl + --Snapshot.DownloadUrl + ``` + + + ``` + NETHERMIND_SNAPSHOTCONFIG_DOWNLOADURL= + ``` + + + ```json + { + "Snapshot": { + "DownloadUrl": + } + } + ``` + + + + The URL of the snapshot file. Defaults to `null`. + +- #### `Snapshot.Enabled` \{#snapshot-enabled\} + + + + ``` + --snapshot-enabled [true|false] + --Snapshot.Enabled [true|false] + ``` + + + ``` + NETHERMIND_SNAPSHOTCONFIG_ENABLED=true|false + ``` + + + ```json + { + "Snapshot": { + "Enabled": true|false + } + } + ``` + + + + Whether to enable the Snapshot plugin. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Snapshot.SnapshotDirectory` \{#snapshot-snapshotdirectory\} + + + + ``` + --snapshot-snapshotdirectory + --Snapshot.SnapshotDirectory + ``` + + + ``` + NETHERMIND_SNAPSHOTCONFIG_SNAPSHOTDIRECTORY= + ``` + + + ```json + { + "Snapshot": { + "SnapshotDirectory": + } + } + ``` + + + + The path to the directory to store the snapshot file. Defaults to `snapshot`. + +- #### `Snapshot.SnapshotFileName` \{#snapshot-snapshotfilename\} + + + + ``` + --snapshot-snapshotfilename + --Snapshot.SnapshotFileName + ``` + + + ``` + NETHERMIND_SNAPSHOTCONFIG_SNAPSHOTFILENAME= + ``` + + + ```json + { + "Snapshot": { + "SnapshotFileName": + } + } + ``` + + + + The name of the snapshot file. Defaults to `snapshot.zip`. + + +### Surge + +- #### `Surge.AverageGasUsagePercentage` \{#surge-averagegasusagepercentage\} + + + + ``` + --surge-averagegasusagepercentage + --Surge.AverageGasUsagePercentage + ``` + + + ``` + NETHERMIND_SURGECONFIG_AVERAGEGASUSAGEPERCENTAGE= + ``` + + + ```json + { + "Surge": { + "AverageGasUsagePercentage": + } + } + ``` + + + + Percentage of the average gas usage to be used for gas price calculation. Defaults to `80`. + +- #### `Surge.BatchPostingGasWithCallData` \{#surge-batchpostinggaswithcalldata\} + + + + ``` + --surge-batchpostinggaswithcalldata + --Surge.BatchPostingGasWithCallData + ``` + + + ``` + NETHERMIND_SURGECONFIG_BATCHPOSTINGGASWITHCALLDATA= + ``` + + + ```json + { + "Surge": { + "BatchPostingGasWithCallData": + } + } + ``` + + + + L1 gas needed for posting a batch as calldata. Defaults to `260000`. + +- #### `Surge.BatchPostingGasWithoutCallData` \{#surge-batchpostinggaswithoutcalldata\} + + + + ``` + --surge-batchpostinggaswithoutcalldata + --Surge.BatchPostingGasWithoutCallData + ``` + + + ``` + NETHERMIND_SURGECONFIG_BATCHPOSTINGGASWITHOUTCALLDATA= + ``` + + + ```json + { + "Surge": { + "BatchPostingGasWithoutCallData": + } + } + ``` + + + + L1 gas needed for posting a batch as a blob. Defaults to `180000`. + +- #### `Surge.BoostBaseFeePercentage` \{#surge-boostbasefeepercentage\} + + + + ``` + --surge-boostbasefeepercentage + --Surge.BoostBaseFeePercentage + ``` + + + ``` + NETHERMIND_SURGECONFIG_BOOSTBASEFEEPERCENTAGE= + ``` + + + ```json + { + "Surge": { + "BoostBaseFeePercentage": + } + } + ``` + + + + Percentage of the base fee that is used for boosting. Defaults to `5`. + +- #### `Surge.FeeHistoryBlockCount` \{#surge-feehistoryblockcount\} + + + + ``` + --surge-feehistoryblockcount + --Surge.FeeHistoryBlockCount + ``` + + + ``` + NETHERMIND_SURGECONFIG_FEEHISTORYBLOCKCOUNT= + ``` + + + ```json + { + "Surge": { + "FeeHistoryBlockCount": + } + } + ``` + + + + Number of blocks to consider for computing the L1 average base fee. Defaults to `200`. + +- #### `Surge.GasPriceRefreshTimeoutSeconds` \{#surge-gaspricerefreshtimeoutseconds\} + + + + ``` + --surge-gaspricerefreshtimeoutseconds + --Surge.GasPriceRefreshTimeoutSeconds + ``` + + + ``` + NETHERMIND_SURGECONFIG_GASPRICEREFRESHTIMEOUTSECONDS= + ``` + + + ```json + { + "Surge": { + "GasPriceRefreshTimeoutSeconds": + } + } + ``` + + + + Maximum time in seconds to use cached gas price estimates before forcing a refresh. Defaults to `12`. + +- #### `Surge.L1EthApiEndpoint` \{#surge-l1ethapiendpoint\} + + + + ``` + --surge-l1ethapiendpoint + --Surge.L1EthApiEndpoint + ``` + + + ``` + NETHERMIND_SURGECONFIG_L1ETHAPIENDPOINT= + ``` + + + ```json + { + "Surge": { + "L1EthApiEndpoint": + } + } + ``` + + + + The URL of the L1 execution node JSON-RPC API. Defaults to `null`. + +- #### `Surge.L2GasPerL2Batch` \{#surge-l2gasperl2batch\} + + + + ``` + --surge-l2gasperl2batch + --Surge.L2GasPerL2Batch + ``` + + + ``` + NETHERMIND_SURGECONFIG_L2GASPERL2BATCH= + ``` + + + ```json + { + "Surge": { + "L2GasPerL2Batch": + } + } + ``` + + + + L2 gas per L2 batch for gas price calculation. Defaults to `1000000`. + +- #### `Surge.L2GasUsageWindowSize` \{#surge-l2gasusagewindowsize\} + + + + ``` + --surge-l2gasusagewindowsize + --Surge.L2GasUsageWindowSize + ``` + + + ``` + NETHERMIND_SURGECONFIG_L2GASUSAGEWINDOWSIZE= + ``` + + + ```json + { + "Surge": { + "L2GasUsageWindowSize": + } + } + ``` + + + + Number of recent L2 batches to consider for computing the moving average of gas usage. Defaults to `20`. + +- #### `Surge.MaxGasLimitRatio` \{#surge-maxgaslimitratio\} + + + + ``` + --surge-maxgaslimitratio + --Surge.MaxGasLimitRatio + ``` + + + ``` + NETHERMIND_SURGECONFIG_MAXGASLIMITRATIO= + ``` + + + ```json + { + "Surge": { + "MaxGasLimitRatio": + } + } + ``` + + + + Filter transactions exceeding the max allowed ratio of gas limit to the actual gas used (e.g. 1, 2 etc.). Set to 0 to disable. Defaults to `0`. + +- #### `Surge.ProofPostingGas` \{#surge-proofpostinggas\} + + + + ``` + --surge-proofpostinggas + --Surge.ProofPostingGas + ``` + + + ``` + NETHERMIND_SURGECONFIG_PROOFPOSTINGGAS= + ``` + + + ```json + { + "Surge": { + "ProofPostingGas": + } + } + ``` + + + + L1 gas needed to post and verify proof. Defaults to `750000`. + +- #### `Surge.ProvingCostPerL2Batch` \{#surge-provingcostperl2batch\} + + + + ``` + --surge-provingcostperl2batch + --Surge.ProvingCostPerL2Batch + ``` + + + ``` + NETHERMIND_SURGECONFIG_PROVINGCOSTPERL2BATCH= + ``` + + + ```json + { + "Surge": { + "ProvingCostPerL2Batch": + } + } + ``` + + + + Proving cost per L2 batch in wei. Defaults to `800000000000000`. + +- #### `Surge.SharingPercentage` \{#surge-sharingpercentage\} + + + + ``` + --surge-sharingpercentage + --Surge.SharingPercentage + ``` + + + ``` + NETHERMIND_SURGECONFIG_SHARINGPERCENTAGE= + ``` + + + ```json + { + "Surge": { + "SharingPercentage": + } + } + ``` + + + + Percentage of the base fee that is shared with the L2 batch submitter. Defaults to `75`. + +- #### `Surge.TaikoInboxAddress` \{#surge-taikoinboxaddress\} + + + + ``` + --surge-taikoinboxaddress + --Surge.TaikoInboxAddress + ``` + + + ``` + NETHERMIND_SURGECONFIG_TAIKOINBOXADDRESS= + ``` + + + ```json + { + "Surge": { + "TaikoInboxAddress": + } + } + ``` + + + + The address of the TaikoInbox contract. Defaults to `null`. + + +### Sync + +- #### `Sync.AncientBodiesBarrier` \{#sync-ancientbodiesbarrier\} + + + + ``` + --sync-ancientbodiesbarrier + --Sync.AncientBodiesBarrier + ``` + + + ``` + NETHERMIND_SYNCCONFIG_ANCIENTBODIESBARRIER= + ``` + + + ```json + { + "Sync": { + "AncientBodiesBarrier": + } + } + ``` + + + + The earliest body downloaded with fast sync when `DownloadBodiesInFastSync` is set to `true`. The actual value is determined as follows: + + ``` + max{ 1, min{ PivotNumber, AncientBodiesBarrier } } + ``` + Defaults to `0`. + +- #### `Sync.AncientReceiptsBarrier` \{#sync-ancientreceiptsbarrier\} + + + + ``` + --sync-ancientreceiptsbarrier + --Sync.AncientReceiptsBarrier + ``` + + + ``` + NETHERMIND_SYNCCONFIG_ANCIENTRECEIPTSBARRIER= + ``` + + + ```json + { + "Sync": { + "AncientReceiptsBarrier": + } + } + ``` + + + + The earliest receipt downloaded with fast sync when `DownloadReceiptsInFastSync` is set to `true`. The actual value is determined as follows: + + ``` + max{ 1, min{ PivotNumber, max{ AncientBodiesBarrier, AncientReceiptsBarrier } } } + ``` + Defaults to `0`. + +- #### `Sync.DownloadBodiesInFastSync` \{#sync-downloadbodiesinfastsync\} + + + + ``` + --sync-downloadbodiesinfastsync [true|false] + --Sync.DownloadBodiesInFastSync [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_DOWNLOADBODIESINFASTSYNC=true|false + ``` + + + ```json + { + "Sync": { + "DownloadBodiesInFastSync": true|false + } + } + ``` + + + + Whether to download the block bodies in the Fast sync mode. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Sync.DownloadHeadersInFastSync` \{#sync-downloadheadersinfastsync\} + + + + ``` + --sync-downloadheadersinfastsync [true|false] + --Sync.DownloadHeadersInFastSync [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_DOWNLOADHEADERSINFASTSYNC=true|false + ``` + + + ```json + { + "Sync": { + "DownloadHeadersInFastSync": true|false + } + } + ``` + + + + Whether to download the old block headers in the Fast sync mode. If `false`, Nethermind downloads only recent blocks headers. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Sync.DownloadReceiptsInFastSync` \{#sync-downloadreceiptsinfastsync\} + + + + ``` + --sync-downloadreceiptsinfastsync [true|false] + --Sync.DownloadReceiptsInFastSync [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_DOWNLOADRECEIPTSINFASTSYNC=true|false + ``` + + + ```json + { + "Sync": { + "DownloadReceiptsInFastSync": true|false + } + } + ``` + + + + Whether to download receipts in the Fast sync mode. This slows down the process by a few hours but allows to interact with dApps that perform extensive historical logs searches. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Sync.ExitOnSynced` \{#sync-exitonsynced\} + + + + ``` + --sync-exitonsynced [true|false] + --Sync.ExitOnSynced [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_EXITONSYNCED=true|false + ``` + + + ```json + { + "Sync": { + "ExitOnSynced": true|false + } + } + ``` + + + + Whether to shut down Nethermind once sync is finished. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Sync.ExitOnSyncedWaitTimeSec` \{#sync-exitonsyncedwaittimesec\} + + + + ``` + --sync-exitonsyncedwaittimesec + --Sync.ExitOnSyncedWaitTimeSec + ``` + + + ``` + NETHERMIND_SYNCCONFIG_EXITONSYNCEDWAITTIMESEC= + ``` + + + ```json + { + "Sync": { + "ExitOnSyncedWaitTimeSec": + } + } + ``` + + + + The time, in seconds, to wait before shutting down Nethermind once sync is finished. Defaults to `60`. + +- #### `Sync.FastSync` \{#sync-fastsync\} + + + + ``` + --sync-fastsync [true|false] + --Sync.FastSync [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_FASTSYNC=true|false + ``` + + + ```json + { + "Sync": { + "FastSync": true|false + } + } + ``` + + + + Whether to use the Fast sync mode (the eth/63 synchronization algorithm). Allowed values: `true` `false`. Defaults to `false`. + +- #### `Sync.FastSyncCatchUpHeightDelta` \{#sync-fastsynccatchupheightdelta\} + + + + ``` + --sync-fastsynccatchupheightdelta + --Sync.FastSyncCatchUpHeightDelta + ``` + + + ``` + NETHERMIND_SYNCCONFIG_FASTSYNCCATCHUPHEIGHTDELTA= + ``` + + + ```json + { + "Sync": { + "FastSyncCatchUpHeightDelta": + } + } + ``` + + + + In Fast sync mode, the min height threshold limit up to which the Full sync, if already on, stays on when the chain is behind the network head. If the limit is exceeded, it switches back to Fast sync. For regular usage scenarios, setting this value lower than 32 is not recommended as this can cause issues with chain reorgs. Note that the last 2 blocks are always processed in Full sync, so setting it lower than 2 has no effect. Defaults to `8192`. + +- #### `Sync.FixReceipts` \{#sync-fixreceipts\} + + + + ``` + --sync-fixreceipts [true|false] + --Sync.FixReceipts [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_FIXRECEIPTS=true|false + ``` + + + ```json + { + "Sync": { + "FixReceipts": true|false + } + } + ``` + + + + Whether to enable receipts validation that checks for receipts that might be missing because of a bug. If needed, receipts are downloaded from the network. If `true`, the pivot number must be same one used originally as it's used as a cut-off point. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Sync.FixTotalDifficulty` \{#sync-fixtotaldifficulty\} + + + + ``` + --sync-fixtotaldifficulty [true|false] + --Sync.FixTotalDifficulty [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_FIXTOTALDIFFICULTY=true|false + ``` + + + ```json + { + "Sync": { + "FixTotalDifficulty": true|false + } + } + ``` + + + + Whether to recalculate the total difficulty from `FixTotalDifficultyStartingBlock` to `FixTotalDifficultyLastBlock`. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Sync.FixTotalDifficultyLastBlock` \{#sync-fixtotaldifficultylastblock\} + + + + ``` + --sync-fixtotaldifficultylastblock + --Sync.FixTotalDifficultyLastBlock + ``` + + + ``` + NETHERMIND_SYNCCONFIG_FIXTOTALDIFFICULTYLASTBLOCK= + ``` + + + ```json + { + "Sync": { + "FixTotalDifficultyLastBlock": + } + } + ``` + + + + The last block to recalculate the total difficulty for. If not specified, the best known block is used. + Defaults to `null`. + +- #### `Sync.FixTotalDifficultyStartingBlock` \{#sync-fixtotaldifficultystartingblock\} + + + + ``` + --sync-fixtotaldifficultystartingblock + --Sync.FixTotalDifficultyStartingBlock + ``` + + + ``` + NETHERMIND_SYNCCONFIG_FIXTOTALDIFFICULTYSTARTINGBLOCK= + ``` + + + ```json + { + "Sync": { + "FixTotalDifficultyStartingBlock": + } + } + ``` + + + + The first block to recalculate the total difficulty for. Defaults to `1`. + +- #### `Sync.MaxAttemptsToUpdatePivot` \{#sync-maxattemptstoupdatepivot\} + + + + ``` + --sync-maxattemptstoupdatepivot + --Sync.MaxAttemptsToUpdatePivot + ``` + + + ``` + NETHERMIND_SYNCCONFIG_MAXATTEMPTSTOUPDATEPIVOT= + ``` + + + ```json + { + "Sync": { + "MaxAttemptsToUpdatePivot": + } + } + ``` + + + + The max number of attempts to update the pivot block based on the FCU message from the consensus client. Defaults to `2147483647`. + +- #### `Sync.MaxProcessingThreads` \{#sync-maxprocessingthreads\} + + + + ``` + --sync-maxprocessingthreads + --Sync.MaxProcessingThreads + ``` + + + ``` + NETHERMIND_SYNCCONFIG_MAXPROCESSINGTHREADS= + ``` + + + ```json + { + "Sync": { + "MaxProcessingThreads": + } + } + ``` + + + + The max number of threads used for syncing. `0` to use the number of logical processors. Defaults to `0`. + +- #### `Sync.NetworkingEnabled` \{#sync-networkingenabled\} + + + + ``` + --sync-networkingenabled [true|false] + --Sync.NetworkingEnabled [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_NETWORKINGENABLED=true|false + ``` + + + ```json + { + "Sync": { + "NetworkingEnabled": true|false + } + } + ``` + + + + Whether to connect to peers and sync. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Sync.NonValidatorNode` \{#sync-nonvalidatornode\} + + + + ``` + --sync-nonvalidatornode [true|false] + --Sync.NonValidatorNode [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_NONVALIDATORNODE=true|false + ``` + + + ```json + { + "Sync": { + "NonValidatorNode": true|false + } + } + ``` + + + + Whether to operate as a non-validator. If `true`, the `DownloadReceiptsInFastSync` and `DownloadBodiesInFastSync` can be set to `false`. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Sync.PivotHash` \{#sync-pivothash\} + + + + ``` + --sync-pivothash + --Sync.PivotHash + ``` + + + ``` + NETHERMIND_SYNCCONFIG_PIVOTHASH= + ``` + + + ```json + { + "Sync": { + "PivotHash": + } + } + ``` + + + + The hash of the pivot block for the Fast sync mode. Defaults to `null`. + +- #### `Sync.PivotNumber` \{#sync-pivotnumber\} + + + + ``` + --sync-pivotnumber + --Sync.PivotNumber + ``` + + + ``` + NETHERMIND_SYNCCONFIG_PIVOTNUMBER= + ``` + + + ```json + { + "Sync": { + "PivotNumber": + } + } + ``` + + + + The number of the pivot block for the Fast sync mode. Defaults to `0`. + +- #### `Sync.PivotTotalDifficulty` \{#sync-pivottotaldifficulty\} + + + + ``` + --sync-pivottotaldifficulty + --Sync.PivotTotalDifficulty + ``` + + + ``` + NETHERMIND_SYNCCONFIG_PIVOTTOTALDIFFICULTY= + ``` + + + ```json + { + "Sync": { + "PivotTotalDifficulty": + } + } + ``` + + + + The total difficulty of the pivot block for the Fast sync mode. Defaults to `null`. + +- #### `Sync.SnapServingMaxDepth` \{#sync-snapservingmaxdepth\} + + + + ``` + --sync-snapservingmaxdepth + --Sync.SnapServingMaxDepth + ``` + + + ``` + NETHERMIND_SYNCCONFIG_SNAPSERVINGMAXDEPTH= + ``` + + + ```json + { + "Sync": { + "SnapServingMaxDepth": + } + } + ``` + + + + The maximum depth (in blocks) for serving snap sync requests. Higher values allow serving requests for older blocks, useful for networks with fast block times like Arbitrum. Defaults to `128`. + +- #### `Sync.SnapSync` \{#sync-snapsync\} + + + + ``` + --sync-snapsync [true|false] + --Sync.SnapSync [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_SNAPSYNC=true|false + ``` + + + ```json + { + "Sync": { + "SnapSync": true|false + } + } + ``` + + + + Whether to use the Snap sync mode. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Sync.SnapSyncAccountRangePartitionCount` \{#sync-snapsyncaccountrangepartitioncount\} + + + + ``` + --sync-snapsyncaccountrangepartitioncount + --Sync.SnapSyncAccountRangePartitionCount + ``` + + + ``` + NETHERMIND_SYNCCONFIG_SNAPSYNCACCOUNTRANGEPARTITIONCOUNT= + ``` + + + ```json + { + "Sync": { + "SnapSyncAccountRangePartitionCount": + } + } + ``` + + + + The number of account range partitions to create. Increases the Snap sync request concurrency. Allowed values are between between 1 and 256. Defaults to `8`. + +- #### `Sync.StrictMode` \{#sync-strictmode\} + + + + ``` + --sync-strictmode [true|false] + --Sync.StrictMode [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_STRICTMODE=true|false + ``` + + + ```json + { + "Sync": { + "StrictMode": true|false + } + } + ``` + + + + Whether to disable some optimizations and do a more extensive sync. Useful when sync state is corrupted. Allowed values: `true` `false`. Defaults to `false`. + +- #### `Sync.SynchronizationEnabled` \{#sync-synchronizationenabled\} + + + + ``` + --sync-synchronizationenabled [true|false] + --Sync.SynchronizationEnabled [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_SYNCHRONIZATIONENABLED=true|false + ``` + + + ```json + { + "Sync": { + "SynchronizationEnabled": true|false + } + } + ``` + + + + Whether to download and process new blocks. Allowed values: `true` `false`. Defaults to `true`. + +- #### `Sync.UseGethLimitsInFastBlocks` \{#sync-usegethlimitsinfastblocks\} + + + + ``` + --sync-usegethlimitsinfastblocks [true|false] + --Sync.UseGethLimitsInFastBlocks [true|false] + ``` + + + ``` + NETHERMIND_SYNCCONFIG_USEGETHLIMITSINFASTBLOCKS=true|false + ``` + + + ```json + { + "Sync": { + "UseGethLimitsInFastBlocks": true|false + } + } + ``` + + + + Whether to make smaller requests, in Fast Blocks mode, to avoid Geth from disconnecting. On the Geth-heavy networks (e.g., Mainnet), it's a desired behavior while on Nethermind- or OpenEthereum-heavy networks (Aura), it slows down the sync by a factor of ~4. Allowed values: `true` `false`. Defaults to `true`. + + +### TraceStore + +- #### `TraceStore.BlocksToKeep` \{#tracestore-blockstokeep\} + + + + ``` + --tracestore-blockstokeep + --TraceStore.BlocksToKeep + ``` + + + ``` + NETHERMIND_TRACESTORECONFIG_BLOCKSTOKEEP= + ``` + + + ```json + { + "TraceStore": { + "BlocksToKeep": + } + } + ``` + + + + The number of blocks to store, counting from the head. If `0`, all traces of the processed blocks are stored. Defaults to `10000`. + +- #### `TraceStore.DeserializationParallelization` \{#tracestore-deserializationparallelization\} + + + + ``` + --tracestore-deserializationparallelization + --TraceStore.DeserializationParallelization + ``` + + + ``` + NETHERMIND_TRACESTORECONFIG_DESERIALIZATIONPARALLELIZATION= + ``` + + + ```json + { + "TraceStore": { + "DeserializationParallelization": + } + } + ``` + + + + The max parallelization when deserialization requests the `trace_filter` method. `0` to use the number of logical processors. If you experience a resource shortage, set to a low number. Defaults to `0`. + +- #### `TraceStore.Enabled` \{#tracestore-enabled\} + + + + ``` + --tracestore-enabled [true|false] + --TraceStore.Enabled [true|false] + ``` + + + ``` + NETHERMIND_TRACESTORECONFIG_ENABLED=true|false + ``` + + + ```json + { + "TraceStore": { + "Enabled": true|false + } + } + ``` + + + + Whether to enable the TraceStore plugin. If enabled, traces come from the database whenever possible. Allowed values: `true` `false`. Defaults to `false`. + +- #### `TraceStore.TraceTypes` \{#tracestore-tracetypes\} + + + + ``` + --tracestore-tracetypes + --TraceStore.TraceTypes + ``` + + + ``` + NETHERMIND_TRACESTORECONFIG_TRACETYPES= + ``` + + + ```json + { + "TraceStore": { + "TraceTypes": + } + } + ``` + + + + The type of traces to store. + + Allowed values: + + - `None`: None. + - `VmTrace`: Provides a full trace of the EVM state throughout the execution of transactions at each op-code, including subcalls. + - `StateDiff`: Provides Ethereum state difference detailing all altered portions of the state made due to the execution of transactions. + - `Trace`: Provides transaction trace, including subcalls. + - `Rewards`: Includes block rewards in the trace when tracing full blocks. + - `All`: Combines the `Rewards` `StateDiff` `Trace` `VmTrace` options. + + Defaults to `Trace, Rewards`. + + +### TxPool + +- #### `TxPool.AcceptTxWhenNotSynced` \{#txpool-accepttxwhennotsynced\} + + + + ``` + --txpool-accepttxwhennotsynced [true|false] + --TxPool.AcceptTxWhenNotSynced [true|false] + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_ACCEPTTXWHENNOTSYNCED=true|false + ``` + + + ```json + { + "TxPool": { + "AcceptTxWhenNotSynced": true|false + } + } + ``` + + + + Accept transactions when not synced. Allowed values: `true` `false`. Defaults to `false`. + +- #### `TxPool.BlobCacheSize` \{#txpool-blobcachesize\} + + + + ``` + --txpool-blobcachesize + --TxPool.BlobCacheSize + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_BLOBCACHESIZE= + ``` + + + ```json + { + "TxPool": { + "BlobCacheSize": + } + } + ``` + + + + The max number of full blob transactions cached in memory. The default value uses max 200MB for 6 blobs where one blob is 33MB (256 * 128KB) Defaults to `256`. + +- #### `TxPool.BlobsSupport` \{#txpool-blobssupport\} + + + + ``` + --txpool-blobssupport + --TxPool.BlobsSupport + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_BLOBSSUPPORT= + ``` + + + ```json + { + "TxPool": { + "BlobsSupport": + } + } + ``` + + + + The blobs support mode. + + Allowed values: + + - `Disabled`: Disables support for blob transactions. + - `InMemory`: Stores the blob transactions in memory only. + - `Storage`: Stores the blob transactions in the permanent storage. + - `StorageWithReorgs`: Stores the blob transactions in the permanent storage with support for restoring reorganized transactions to the blob pool. + + Defaults to `StorageWithReorgs`. + +- #### `TxPool.CurrentBlobBaseFeeRequired` \{#txpool-currentblobbasefeerequired\} + + + + ``` + --txpool-currentblobbasefeerequired [true|false] + --TxPool.CurrentBlobBaseFeeRequired [true|false] + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_CURRENTBLOBBASEFEEREQUIRED=true|false + ``` + + + ```json + { + "TxPool": { + "CurrentBlobBaseFeeRequired": true|false + } + } + ``` + + + + Whether to require the max fee per blob gas to be greater than or equal to the current blob base fee when adding a blob transaction to the pool. Allowed values: `true` `false`. Defaults to `true`. + +- #### `TxPool.GasLimit` \{#txpool-gaslimit\} + + + + ``` + --txpool-gaslimit + --TxPool.GasLimit + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_GASLIMIT= + ``` + + + ```json + { + "TxPool": { + "GasLimit": + } + } + ``` + + + + The max transaction gas allowed. Defaults to `null`. + +- #### `TxPool.HashCacheSize` \{#txpool-hashcachesize\} + + + + ``` + --txpool-hashcachesize + --TxPool.HashCacheSize + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_HASHCACHESIZE= + ``` + + + ```json + { + "TxPool": { + "HashCacheSize": + } + } + ``` + + + + The max number of cached hashes of already known transactions. Set automatically by the memory hint. Defaults to `524288`. + +- #### `TxPool.InMemoryBlobPoolSize` \{#txpool-inmemoryblobpoolsize\} + + + + ``` + --txpool-inmemoryblobpoolsize + --TxPool.InMemoryBlobPoolSize + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_INMEMORYBLOBPOOLSIZE= + ``` + + + ```json + { + "TxPool": { + "InMemoryBlobPoolSize": + } + } + ``` + + + + The max number of full blob transactions stored in memory. Used only if persistent storage is disabled. Defaults to `512`. + +- #### `TxPool.MaxBlobTxSize` \{#txpool-maxblobtxsize\} + + + + ``` + --txpool-maxblobtxsize + --TxPool.MaxBlobTxSize + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_MAXBLOBTXSIZE= + ``` + + + ```json + { + "TxPool": { + "MaxBlobTxSize": + } + } + ``` + + + + The max blob transaction size allowed, excluding blobs, in bytes. Defaults to `1048576`. + +- #### `TxPool.MaxPendingBlobTxsPerSender` \{#txpool-maxpendingblobtxspersender\} + + + + ``` + --txpool-maxpendingblobtxspersender + --TxPool.MaxPendingBlobTxsPerSender + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_MAXPENDINGBLOBTXSPERSENDER= + ``` + + + ```json + { + "TxPool": { + "MaxPendingBlobTxsPerSender": + } + } + ``` + + + + The max number of pending blob transactions per single sender. `0` to lift the limit. Defaults to `16`. + +- #### `TxPool.MaxPendingTxsPerSender` \{#txpool-maxpendingtxspersender\} + + + + ``` + --txpool-maxpendingtxspersender + --TxPool.MaxPendingTxsPerSender + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_MAXPENDINGTXSPERSENDER= + ``` + + + ```json + { + "TxPool": { + "MaxPendingTxsPerSender": + } + } + ``` + + + + The max number of pending transactions per single sender. `0` to lift the limit. Defaults to `0`. + +- #### `TxPool.MaxTxSize` \{#txpool-maxtxsize\} + + + + ``` + --txpool-maxtxsize + --TxPool.MaxTxSize + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_MAXTXSIZE= + ``` + + + ```json + { + "TxPool": { + "MaxTxSize": + } + } + ``` + + + + The max transaction size allowed, in bytes. Defaults to `131072`. + +- #### `TxPool.MinBaseFeeThreshold` \{#txpool-minbasefeethreshold\} + + + + ``` + --txpool-minbasefeethreshold + --TxPool.MinBaseFeeThreshold + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_MINBASEFEETHRESHOLD= + ``` + + + ```json + { + "TxPool": { + "MinBaseFeeThreshold": + } + } + ``` + + + + The minimal percentage of the current base fee that must be surpassed by the max fee (`max_fee_per_gas`) for the transaction to be broadcasted. Defaults to `70`. + +- #### `TxPool.MinBlobTxPriorityFee` \{#txpool-minblobtxpriorityfee\} + + + + ``` + --txpool-minblobtxpriorityfee + --TxPool.MinBlobTxPriorityFee + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_MINBLOBTXPRIORITYFEE= + ``` + + + ```json + { + "TxPool": { + "MinBlobTxPriorityFee": + } + } + ``` + + + + The minimum priority fee in wei for blob transactions to be accepted into the transaction pool. Defaults to `0`. + +- #### `TxPool.PeerNotificationThreshold` \{#txpool-peernotificationthreshold\} + + + + ``` + --txpool-peernotificationthreshold + --TxPool.PeerNotificationThreshold + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_PEERNOTIFICATIONTHRESHOLD= + ``` + + + ```json + { + "TxPool": { + "PeerNotificationThreshold": + } + } + ``` + + + + The average percentage of transaction hashes from persistent broadcast sent to a peer together with hashes of the last added transactions. Defaults to `5`. + +- #### `TxPool.PersistentBlobStorageSize` \{#txpool-persistentblobstoragesize\} + + + + ``` + --txpool-persistentblobstoragesize + --TxPool.PersistentBlobStorageSize + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_PERSISTENTBLOBSTORAGESIZE= + ``` + + + ```json + { + "TxPool": { + "PersistentBlobStorageSize": + } + } + ``` + + + + The max number of full blob transactions stored in the database (increasing the number of transactions in the blob pool also results in higher memory usage). The default value uses max 13GB for 6 blobs where one blob is 2GB (16386 * 128KB). Defaults to `16384`. + +- #### `TxPool.PersistentBroadcastEnabled` \{#txpool-persistentbroadcastenabled\} + + + + ``` + --txpool-persistentbroadcastenabled [true|false] + --TxPool.PersistentBroadcastEnabled [true|false] + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_PERSISTENTBROADCASTENABLED=true|false + ``` + + + ```json + { + "TxPool": { + "PersistentBroadcastEnabled": true|false + } + } + ``` + + + + Add local transactions to persistent broadcast. Allowed values: `true` `false`. Defaults to `true`. + +- #### `TxPool.ReportMinutes` \{#txpool-reportminutes\} + + + + ``` + --txpool-reportminutes + --TxPool.ReportMinutes + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_REPORTMINUTES= + ``` + + + ```json + { + "TxPool": { + "ReportMinutes": + } + } + ``` + + + + The current transaction pool state reporting interval, in minutes. Defaults to `null`. + +- #### `TxPool.Size` \{#txpool-size\} + + + + ``` + --txpool-size + --TxPool.Size + ``` + + + ``` + NETHERMIND_TXPOOLCONFIG_SIZE= + ``` + + + ```json + { + "TxPool": { + "Size": + } + } + ``` + + + + The max number of transactions held in the mempool (the more transactions in the mempool, the more memory used). Defaults to `2048`. + + +### Wallet + +- #### `Wallet.DevAccounts` \{#wallet-devaccounts\} + + + + ``` + --wallet-devaccounts + --Wallet.DevAccounts + ``` + + + ``` + NETHERMIND_WALLETCONFIG_DEVACCOUNTS= + ``` + + + ```json + { + "Wallet": { + "DevAccounts": + } + } + ``` + + + + The number of autogenerated developer accounts to work with. Developer accounts have private keys from `00...01` to `00...n`. Defaults to `10`. + + + + +## Environment variables + +All configuration options have their environment variable counterparts, so Nethermind can be configured with environment variables the same way as with command line options. The environment variables follow this naming convention: + +```text +NETHERMIND_{NAMESPACE}CONFIG_{OPTION} +``` + +For instance, the environment variable equivalent of the `JsonRpc.JwtSecretFile` option is `NETHERMIND_JSONRPCCONFIG_JWTSECRETFILE`. For the full list of the available environment variables, see [Options by namespaces](#options-by-namespaces). + +## Configuration file + +The configuration files use JSON format. The bundled configuration files are located in the `configs` directory and named after the network they are used for. For instance, see the Mainnet configuration file [`mainnet.json`](https://github.com/NethermindEth/nethermind/blob/master/src/Nethermind/Nethermind.Runner/configs/mainnet.json). + +[web3-secret-storage]: https://ethereum.org/en/developers/docs/data-structures-and-encoding/web3-secret-storage diff --git a/versioned_docs/version-1.36.0/fundamentals/database.md b/versioned_docs/version-1.36.0/fundamentals/database.md new file mode 100644 index 0000000000..46d1cc878f --- /dev/null +++ b/versioned_docs/version-1.36.0/fundamentals/database.md @@ -0,0 +1,154 @@ +--- +title: Database +sidebar_position: 5 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +Nethermind uses the [RocksDB](https://rocksdb.org) database to store the state. By default, the database is located in the +same directory where the Nethermind executable is. You can change the database location using the [`--db-dir`](configuration.md#db-dir) command line option. + +## Database directory structure + +| Directory | Description | +| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | +| blockInfos | Information about blocks at each level of the block tree (canonical chain and branches) | +| blocks | Block bodies (block transactions and uncles) | +| bloom | Bloom indices for fast log searches | +| canonicalHashTrie | LES protocol related data | +| code | Contract bytecodes | +| discoveryNodes | Peers discovered via discovery protocol - used for quick peering after restarts (you can copy this DB between nodes to speed up peering) | +| headers | Block headers only | +| pendingTx | The second level cache of pending transactions/mempool (the first level is in memory). Wiped out on each restart. | +| peers | Additional sync peers information (like peer reputation) - you can copy this DB between nodes to speed up peering on fresh sync | +| receipts | Transaction receipts | +| state | Blockchain state including accounts and contract storage (Patricia trie nodes) | + +You can use `rsync` between your nodes to clone the database (One of our users copied the entire 4.5TB archive state this +way while the node was running and only stopped the node for the very last stage of `rsync` ). You can also copy +the database between Linux, Windows, and macOS. + +## Database size + +Below is a comprehensive list of the supported chains, along with a detailed breakdown of their respective database directories. For reference, the database sizes listed have been determined using the standard configurations provided. + + + + + + +- `state`: 161 GB +- `receipts`: 217 GB +- `blocks`: 607 GB +- `bloom`: 6.5 GB +- `headers`: 9.1 GB +- `code`: 4.9 GB +- `blobTransactions`: 917 MB +- ... +- **Total: 1007 GB** + + + + +- `state`: 45 GB +- `receipts`: 42 GB +- `blocks`: 311 GB +- `bloom`: 2.2 GB +- `headers`: 2.5 GB +- `code`: 7.0 GB +- `blobTransactions`: 178 MB +- ... +- **Total: 409 GB** + + + + +- `state`: 66 GB +- `receipts`: 218 GB +- `blocks`: 202 GB +- `bloom`: 9.4 GB +- `headers`: 11 GB +- `code`: 683 MB +- `blobTransactions`: 75 MB +- ... +- **Total: 509 GB** + + + + +- `state`: 2.6 GB +- `receipts`: 1.5 GB +- `blocks`: 9.7 GB +- `bloom`: 3.3 GB +- `headers`: 2.5 GB +- `code`: 72 MB +- `blobTransactions`: 407 MB +- ... +- **Total: 22 GB** + + + + +- `state`: 27 GB +- `receipts`: 4.6 GB +- `blocks`: 25 GB +- `bloom`: 11 GB +- `headers`: 7.2 GB +- `code`: 14 MB +- `blobTransactions`: +- ... +- **Total: 76 GB** + + + + +- `state`: 34 GB +- `receipts`: 8.5 GB +- `blocks`: 33 GB +- `bloom`: 9.2 GB +- `headers`: 7.0 GB +- `code`: 96 MB +- `blobTransactions`: +- ... +- **Total: 95 GB** + + + + + + +## Reducing database size + +The Nethermind database can experience substantial growth over time, starting from an initial size of approximately 650 +GB. As a result, many node setups are configured to run on 1 TB disks. However, even with settings +designed to slow the growth rate, these disks may eventually run out of free space. + +The current options to reduce the database size are as follows: + +- [Resyncing database from scratch](./sync.md#resync) +- [Pruning](./state-pruning.md) + +The table below presents a short comparison of these methods including possible fine-tuning of each method. Data was +fetched from a node running on a machine with the below specifications: + +- **Nethermind**: v1.18.0 +- **Consensus client**: Lighthouse +- **CPU**: AMD EPYC 7713 (16 cores allocated for the VM) +- **RAM**: 64 GB +- **Disk size**: 1.2 TB +- **Disk IOPS**: 70,000 to 80,000 + +| Metric | Resync | Pruning | Pruning and memory budget (4 GB) | +| ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------- | -------------------------------------------------------------- | +| **Execution time** | ~4h | ~24h | ~12h | +| **Minimum free disk space** | N/A. You can execute resync even if there is 0 free space (avoid such a case). | 250 GB | 250 GB | +| **Attestation rate drop** | 100%. No attestation rewards during that time or highly reduced. | 5–10% during that time | N/A | +| **Average block processing time of new blocks during the process** | N/A. New blocks are processed after state but are significantly slower until old bodies/receipts are downloaded. Afterward, average about 0.35s. | 0.7s | 1.0s | +| **Is the node online during the process?** | No, unless the state is synced. | Yes. The node follows the chain, and all modules are still enabled. | Yes. The node follows chain and all modules are still enabled. | + +The command used for testing disk IOPS was as follows: + +```bash +fio --randrepeat=1 --ioengine=libaio --direct=1 --gtod_reduce=1 --name=test --filename=test --bs=4k --iodepth=64 --size=4G --readwrite=randrw +``` diff --git a/versioned_docs/version-1.36.0/fundamentals/history-pruning.md b/versioned_docs/version-1.36.0/fundamentals/history-pruning.md new file mode 100644 index 0000000000..68ea8977c3 --- /dev/null +++ b/versioned_docs/version-1.36.0/fundamentals/history-pruning.md @@ -0,0 +1,57 @@ +--- +title: History pruning +sidebar_position: 7 +--- + +History pruning is a feature set that aims to reduce storage space requirements for a node by removing old historical data. The goal is to remove the requirement from nodes to store all the historical data but ensure the old data is preserved and accessible for anyone who needs it. For details, see [EIP-4444][eip444]. + +:::info +History pruning is enabled by default for the networks supporting it. To disable, set [`Sync.AncientBodiesBarrier`](./configuration.md#sync-ancientbodiesbarrier) and [`Sync.AncientReceiptsBarrier`](./configuration.md#sync-ancientreceiptsbarrier) to `0`. +::: + +## Era1 format + +The pre-Merge historical data is serviced in [Era1](https://github.com/status-im/nimbus-eth2/blob/stable/docs/e2store.md#era-files) format, which is an archival format initially designed for the consensus layer by Nimbus. + +An Era1 archive can be expressed as follows: + +``` +era1 := Version | block-tuple* | other-entries* | Accumulator | BlockIndex +block-tuple := CompressedHeader | CompressedBody | CompressedReceipts | TotalDifficulty +block-index := starting-number | index | index | index ... | count +``` + +Block headers, bodies, and receipts are compressed using the [Snappy framing format](https://github.com/google/snappy/blob/main/framing_format.txt). Each file contains a block index for fast lookup and an [epoch accumulator](https://github.com/ethereum/portal-network-specs/blob/master/history/history-network.md#the-historical-hashes-accumulator) for verification. The epoch accumulator can verify the entire archive with accumulators from a trusted source. It also allows a node to download a block header with a Merkle proof, proving it belongs to a particular epoch. + +## Import + +Nethermind allows importing of a historical block range from a specified location to the database. During import, the block range before the head will be inserted in parallel like old bodies, and after the head will be "suggested" like forward sync. So, it will process a new imported block. + +- Import will not complete until the blocks are processed and will pause adding them if the processing queue reaches 2000 blocks. +- An exception to this is if fast sync is enabled and the head is 0, in which case, it will only insert blocks like old bodies. +- Accumulator and content are always verified/checksummed. + +The data can be imported using the following configuration options on Nethermind startup. Note that this is a blocking operation and puts other activities on hold until it is completed: + +- [`Era.ImportDirectory`](./configuration.md#era-importdirectory) +- [`Era.From`](./configuration.md#era-from) (optional) +- [`Era.To`](./configuration.md#era-to) (optional) +- [`Era.TrustedAccumulatorFile`](./configuration.md#era-trustedaccumulatorfile) (optional). If not specified, it trusts the import directory. + +If both `Era.From` and `Era.To` are set to 0, it imports all blocks. + +Alternatively, the data can be imported using the [`admin_importHistory`](../interacting/json-rpc-ns/admin.md#admin_importhistory) JSON-RPC method. This is a non-blocking operation. However, it can be run only one at a time, making it slower than the configuration option. + +## Export + +Nethermind allows exporting a block range from the database to a specified location. It can be done using the following configuration options on Nethermind startup. Note that this is a blocking operation and puts other activities on hold until it is completed: + +- [`Era.ExportDirectory`](./configuration.md#era-exportdirectory) +- [`Era.From`](./configuration.md#era-from) (optional) +- [`Era.To`](./configuration.md#era-to) (optional) + +If both `Era.From` and `Era.To` are set to 0, it exports all blocks. It also always creates the `accumulators.txt` and `checksums.txt` files. + +Alternatively, the data can be exported using the [`admin_exportHistory`](../interacting/json-rpc-ns/admin.md#admin_exporthistory) JSON-RPC method. This is a non-blocking operation. However, it can be run only one at a time, making it slower than the configuration option. + +[eip444]: https://eips.ethereum.org/EIPS/eip-4444 diff --git a/versioned_docs/version-1.36.0/fundamentals/logs.md b/versioned_docs/version-1.36.0/fundamentals/logs.md new file mode 100644 index 0000000000..7b61080bb3 --- /dev/null +++ b/versioned_docs/version-1.36.0/fundamentals/logs.md @@ -0,0 +1,113 @@ +--- +title: Logs +sidebar_position: 4 +--- + +## Processing logs + +The Nethermind processing logs are a comprehensive resource for understanding Ethereum block processing. They provide real-time insights into block data, performance metrics, and the state of the blockchain. + +![Nethermind Processing Logs](/images/log_processing.png) + +#### Block metadata + +- **Block number**: Current block being processed, e.g., `21288004` +- **Block hash**: Unique block identifier, e.g., `0xf42e2a...8c5d7b` +- **Extra data**: Metadata given by the block builders; either interpreted utf8 string, hex data, or address if none provided + +#### Block execution details + +- **Block reward**: and whether it is a PBS `mev` reward, e.g., `mev 0.0339 ETH` +- **Total gas**: consumed by block, e.g., `16.08 MGas` +- **Total transactions**: in a block, e.g., `162 txs` +- **Calls**: Total number of calls (including to EOAs), e.g., `585 (13)` +- **`sload`**: Number of storage reads, e.g., `1,865` +- **`sstore`**: Number of storage writes, e.g., `618` +- **`create`**: Number of contract deployments (and self-destructs), e.g., `10 (-2)` +- **Gas prices**: minimum, median, (mean), and maximum gas prices in gwei for block. + - Example: `14.65 gwei .. 14.65 (17.04) .. 55.00 gwei` +- **Smart contracts**: + - Run from code cache, e.g., `exec code from cache 1,480` + - Non-cached smart contracts loaded, e.g., `new 2` + +#### Processing metrics + +- **Processing time**: Time taken to validate a block, e.g., `17.1 ms` +- **Slot time**: Time between blocks, e.g., `12,318 ms` +- **MGas/s**: Processing speed in Millions of Gas per second, e.g., `696.39 MGas/s` +- **Transactions per second (TPS)**: Speed of transaction processing, e.g., `9,457.6 tps` +- **Blocks per second** The number of these blocks that could be processed per second, e.g., `28.53 Blk/s` + +#### Fork and sync events + +- **Received New Block**: Block received with number, hash and extra data `21288296 (0xb61f74...cbfbe7), Extra Data: Titan (titanbuilder.xyz)` +- **Processed**: Block or block range processed, e.g., or `x4 21288291 .. 21288295` or `21288296` +- **Received ForkChoice**: Updates on the blockchain's canonical chain; with safe and finalized block, e.g., `21288296 (0xb61f74...cbfbe7), Safe: 21288252 (0x46906d...7777b8), Finalized: 21288221 (0x22a7d2...ebeae9)` +- **Synced Chain Head**: Latest synced block number and hash on the chain, e.g., `21288296 (0xb61f74...cbfbe7)` + +## Configuring logs + +Alongside console logging, Nethermind also logs into a `.log` file named after the respective network configuration and located in the `logs` directory by default. The file name and location can be configured with the [`Init.LogFileName`](./configuration.md#init-logfilename) and [`Init.LogDirectory`](./configuration.md#init-logdirectory) configuration options respectively. + +### Log levels + +Nethermind uses the following log levels in descending by severity: + +- `error`: Indicates error conditions that impair some operation. +- `warning`: Signifies potential issues that may lead to errors or unexpected behavior in the future if not addressed. +- `info`: Includes messages with all the necessary information that a node operator may need. +- `debug`: Intended for logging detailed information for debugging purposes. Not recommended for production workloads for performance reasons. +- `trace`: The most verbose log level. As the name suggests, it's used for tracing and diagnostics purposes. Not recommended for production workloads for performance reasons. +- `off`: Turns off logging. + +:::info +Not that setting a specific log level turns off messages with less severity while keeping messages with higher severity. For example, the `info` level logs the `info` `warning` `error` messages while ignoring the `debug` `trace` ones. +::: + +The log level can be configured with the [`-l, --log`](./configuration.md#log) command line option. For instance: + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + -l debug +``` + +The above approach affects all of the Nethermind logs. For more fine-grained control, the [`Init.LogRules`](./configuration.md#init-logrules) confuguration option comes at help. The example below sets the `debug` level for the `BlockTree` of the `Blockchain` module, and the `trace` level for any logger in the `Synchronization` module. + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + --init-logrules Blockchain.BlockTree:debug;Synchronization.*:trace +``` + +For even more control over logging, see the next section. + +### Advanced logging + +Logging in Nethermind is highly configurable and uses the [NLog](https://nlog-project.org) library under the hood. The default location of the logging configuration file `NLog.config` is the Nethermind installation directory. For more information about the `NLog.config`, see the NLog [configuration options](https://nlog-project.org/config/). + +The location of the `NLog.config` can be configured with the [`--logger-config`](./configuration.md#logger-config) command line options as follows: + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + --logger-config path/to/NLog.config +``` + +## Enterprise-grade logging + +Nethermind provides enterprise-grade logging out of the box using [Seq](https://datalust.co/seq). It's off by default and can be easily turned on, as in the following example: + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + --seq-apikey 9fs9V80bjlkgau9adsjH \ + --seq-minlevel info \ + --seq-serverurl https://seq.example.com +``` + +See the [`Seq`](./configuration.md#seq) configuration options. diff --git a/versioned_docs/version-1.36.0/fundamentals/performance-tuning.md b/versioned_docs/version-1.36.0/fundamentals/performance-tuning.md new file mode 100644 index 0000000000..9599904aca --- /dev/null +++ b/versioned_docs/version-1.36.0/fundamentals/performance-tuning.md @@ -0,0 +1,112 @@ +--- +title: Performance tuning +sidebar_position: 8 +--- + +By default, Nethermind is configured for general use cases that fit well for most users. However, to improve various aspects of Nethermind performance, there are options for different subsystems that can be configured for your specific needs. + +:::info +This guide uses some undocumented configuration options that are not intended for the general public and may change in future releases. +::: + +## Peer discovery + +To connect to the Ethereum network, Nethermind needs to maintain connections to other clients. The number of connections can be configured with [`Network.MaxActivePeers`](./configuration.md#network-maxactivepeers) configuration option. The default value depends on the network. Increasing this number may reduce syncing time, while reducing this number may help with attestation performance. +Also, you can increase the rate at which a new connection is established with `Network.MaxOutgoingConnectPerSec`. The default value is 20 while 50 would be a reasonable higher value. This tends to reduce the snap sync time; however, some ISPs may throttle your Internet connection if you set this value too high. Also, some Wi-Fi routers may hang if the value is set too high. + +## Port forwarding + +While port forwarding is not strictly required, it helps significantly with finding peers and is essential for the network's overall health. The exact steps for port forwarding highly depend on your environment, router, and ISP. For most home configurations, automatic port forwarding can be turned on with [`Network.EnableUPnP`](./configuration.md#network-enableupnp). +Some ISPs are more restrictive and do not support port forwarding and/or utilize provider-level NAT. In such cases, your best option is to use a VPN that supports port forwarding. Keep in mind that consensus clients need a separate port forwarding. + +## Sync time + +On the Ethereum mainnet, most of the syncing time is split into three phases: snap sync, old bodies, and old receipts. Strictly speaking, there are also fast sync, full sync, and state sync phases. However, they usually complete in less than a minute, with state sync usually taking up to 3 minutes. + +At the moment, the best test case sync time is 1 hour 50 minutes for all phases with the following configuration: + +- CPU: AMD Ryzen 9 7950X +- Memory: 128GB RAM +- Storage: Intel Optane SSD 905P Series 900GB +- Network: 1 Gbps Internet with TorGuard VPN with WireGuard protocol. Both execution and consensus clients port forwarding are set up manually. +- Command line options: + + ``` + --network-enableupnp + --network-maxoutgoingconnectpersec 50 + --network-processingthreadcount 32 + --sync-tunedbmode HeavyWrite + ``` + +## Snap sync + +Snap sync is the process of downloading the Ethereum state tree. After it is complete, and after the state sync phase, Nethermind can process and follow the chain. The fastest tested snap sync and state sync time is 25 minutes. +This phase is the most I/O-intensive sync phase, and therefore, assuming a fast internet, the sync time highly depends on your SSD's write speed. Remember that most SSDs only advertise peak write speed, usually above 5GB/s. However, they tend to slow down significantly to around 0.5GB/s (or even less for a QLC SSD) after a few seconds. Therefore, look for SSDs with high sustained write speed. + +Also, ensuring your SSD is sufficiently cooled to prevent thermal throttling is essential. This is often overlooked as most workloads rarely stress SSD as much; however, to reduce sync time, Nethermind will utilize your SSD to its limit. + +Nethermind temporarily changes the database configuration during sync to optimize it for writing, notably the option `Sync.TuneDbMode` is set to `HeavyWrite` by default. On some systems with slow SSDs, the setting the `Sync.TuneDbMode` to `AggressiveHeavyWrite` may give some boost. Also, the compaction can be disabled altogether by setting the `Sync.TuneDbMode` to `DisableCompaction`. This is likely faster for systems using entry-level NVMe SSDs and is also useful to extend the lifespan of your SSD as it provides the lowest total writes possible. However, it uses about 3GB of extra memory during snap sync. The state sync phase may appear to hang for about 10 minutes as the whole database compacts for the first time after snap sync. + +## Old bodies and receipts + +Old bodies and old receipts are the process of downloading block bodies and receipts. This is required for some RPC methods, such as `eth_getLogs`, and for consensus clients to work correctly. If you don't need them, skip this phase by setting the [`Sync.DownloadBodiesInFastSync`](../fundamentals/configuration.md#sync-downloadbodiesinfastsync) to `false`, [`Sync.DownloadReceiptsInFastSync`](../fundamentals/configuration.md#sync-downloadreceiptsinfastsync) to `false`, and [`Sync.NonValidatorNode`](../fundamentals/configuration.md#sync-nonvalidatornode) to `true`. + +Old bodies and receipts are mainly limited by your Internet connection. With a 1Gbps connection, they consume around 250MB/s and 500MB/s of writes, respectively, which is generally reasonable for most PCIE SSDs. On older systems or VPS with low single thread performance and high Internet speed, the block body deserialization may be a bottleneck, in which case, you can increase the number of network processing threads by setting `Network.ProcessingThreadCount` to `32`. However, this may impact block processing time. + +## Block processing time and attestation + +Block processing time is primarily limited by SSD performance. In practice, it is the SSD's _response time_, not just its IOPS, that matters. However, since most SSDs don't advertise response times, IOPS often serves as a useful approximation. + +Nethermind includes a _prewarming_ feature that parallelizes state reads by executing transactions concurrently, warming up state reads for the main block processing. This effectively hides SSD latency, although it increases CPU usage. For non-validator nodes, where RPC throughput is more important, you can turn off this optimization by setting the [`Blocks.PreWarmStateOnBlockProcessing`](../fundamentals/configuration.md#blocks-prewarmstateonblockprocessing) option to `false`. While disabling prewarming may conserve CPU resources, the benefits are typically minor. + +## Memory + +Ethereum aims to be maximally decentralized, so the default Nethermind configuration minimizes system resource usage. However, several tunable parameters are available if your system has large enough memory. + +### At least 32 GB + +For systems with at least 32 GB of memory, the following configuration is recommended: + +- `Pruning.CacheMb: 2000` + + The [pruning cache](../fundamentals/state-pruning.md#in-memory-cache-size) increased from 1 GB to 2 GB, reducing total SSD writes by roughly a factor of 3 (note that ~500 MB of cache is retained for snap serving). + +- `Db.StateDbWriteBufferSize: 100000000` + + The write buffer size should be increased proportionally with the pruning cache to avoid extended pruning times that might block attestation. + +- `Db.StateDbAdditionalRocksDbOptions: "block_based_table_factory={index_type=kBinarySearch;partition_filters=0;};"` + + Changes the database index not to use the partitioned index, improving latency at the cost of ~500 MB of additional memory. + +### At least 128 GB + +For systems with at least 128 GB of memory, the following configuration is recommended: + +- `Pruning.CacheMb: 4000` + + The [pruning cache](../fundamentals/state-pruning.md#in-memory-cache-size) is increased to 4 GB, and the write buffer size to 200 MB. + +- `Db.StateDbWriteBufferSize: 200000000` +- `Db.StateDbAdditionalRocksDbOptions: "block_based_table_factory={index_type=kBinarySearch;partition_filters=0;};"` +- `Db.StateDbEnableFileWarmer: true` + + Enabling the file warmer primes the OS cache by reading the database files at startup. Without this option, the OS cache can take several weeks to warm up naturally. + +### At least 350 GB + +For systems with at least 350 GB of memory, where the entire state can be loaded into memory, beneficial for RPC providers, the following configuration is recommended: + +- `Pruning.CacheMb: 4000` + + The [pruning cache](../fundamentals/state-pruning.md#in-memory-cache-size) is increased to 4 GB, and the write buffer size to 200 MB. + +- `Db.StateDbWriteBufferSize: 200000000` + +- `Db.StateDbAdditionalRocksDbOptions: "block_based_table_factory={index_type=kBinarySearch;block_size=4092;block_restart_interval=2;partition_filters=0};compression=kNoCompression;allow_mmap_reads=1;"` + + Turning off the database compression and using a less compact encoding increases the database size (approximately 280 GB compared to the standard 160 GB) but offers a more CPU-efficient encoding for block processing. It also enables memory-mapped (MMAP) reads, which skip RocksDB's internal block cache and the memory allocator. Note, however, that to enable MMAP verification, checksum needs to be disabled. + +- `Db.StateDbVerifyChecksum: false` + + In addition to prewarming, state access typically accounts for less than 10% of block processing time. This is notable, especially with server CPU, where the low frequency tends to result in higher block processing latency. diff --git a/versioned_docs/version-1.36.0/fundamentals/private-networks.md b/versioned_docs/version-1.36.0/fundamentals/private-networks.md new file mode 100644 index 0000000000..586b5c9eda --- /dev/null +++ b/versioned_docs/version-1.36.0/fundamentals/private-networks.md @@ -0,0 +1,158 @@ +--- +title: Private networks +description: Use Kurtosis to deploy a private Ethereum devnet with Nethermind and any consensus client at any scale you need, wherever you need it. +sidebar_position: 9 +--- + +This guide will walk you through using [Kurtosis `ethereum-package`](https://github.com/ethpandaops/ethereum-package) to spin up a private, proof-of-stake (PoS) Ethereum devnet with three full Ethereum nodes locally over Docker. At the end of the guide, you will learn how to scale up your testnet on Kubernetes as well as enable optional services for your local testnet, such as network observability tools (e.g., Grafana, Prometheus) and Flashbot's `mev-boost` infrastructure to simulate MEV workflows. + +## Step 1: Prerequisites + +Before you begin, ensure you have [Kurtosis CLI](https://docs.kurtosis.com/install) and [Docker](https://docs.docker.com/get-docker) installed. The [`ethereum-package`](https://github.com/ethpandaops/ethereum-package) is a Kurtosis environment definition known as a [package](https://docs.kurtosis.com/concepts-reference/packages). For more info about Kurtosis, see the [Kurtosis docs](https://docs.kurtosis.com). + +## Step 2: Configure your network + +Next, in your home directory, create a file with the name `network_params.json` and populate it with the following contents: + +```json title="network_params.json" +{ + "participants": [ + { + "el_client_type": "nethermind", + "el_client_image": "nethermind/nethermind:latest", + "cl_client_type": "lighthouse", + "cl_client_image": "sigp/lighthouse:latest", + "count": 1 + }, + { + "el_client_type": "nethermind", + "el_client_image": "nethermind/nethermind:latest", + "cl_client_type": "teku", + "cl_client_image": "consensys/teku:latest", + "count": 1 + }, + { + "el_client_type": "nethermind", + "el_client_image": "nethermind/nethermind:latest", + "cl_client_type": "lodestar", + "cl_client_image": "chainsafe/lodestar:next", + "count": 1 + } + ], + "mev_type": "None", + "launch_additional_services": false +} +``` + +As you can see above, you have effectively created a network configuration file that Kurtosis will use to pass in the necessary parameters at runtime for your network. Notice that the `participant` key describes the execution and consensus client pairing desired for each full node and how many nodes of that type to instantiate. + +There are many other configurations and flags you can use, including metrics and observability tools (e.g., Grafana, Prometheus, etc). For all supported options, see the `ethereum-package` [configuration](https://github.com/ethpandaops/ethereum-package#configuration). + +## Step 3: Deploy + +Finally, once you have saved the `network_params.json` file, it is time to deploy the private net: + +```bash +kurtosis run github.com/ethpandaops/ethereum-package "$(cat ~/network_params.json)" +``` + +Kurtosis will use the `ethereum-package` environment definition and your custom network configuration (defined in `network_params.json`) to spin up your network. Kurtosis will first spin up an [enclave][enclaves] (i.e., an ephemeral, isolated environment) and begin to configure and instantiate the nodes in your network. In the end, Kurtosis will print the services running in your enclave that form your private testnet alongside all the container ports and files that were generated and used to start up the private testnet. + +Here is a sample output: + +``` +INFO[2023-09-01T16:10:45-04:00] ==================================================== +INFO[2023-09-01T16:10:45-04:00] || Created enclave: timid-knoll || +INFO[2023-09-01T16:10:45-04:00] ==================================================== +Name: timid-knoll +UUID: 939dfb5d59b0 +Status: RUNNING +Creation Time: Fri, 01 Sep 2023 16:08:57 EDT + +========================================= Files Artifacts ========================================= +UUID Name +a876b06035b7 1-lighthouse-nethermind-0-63 +87955ef69845 2-teku-nethermind-64-127 +4f77377da494 3-lodestar-nethermind-128-191 +9734313101e3 cl-genesis-data +4164ed5c594c el-genesis-data +a49a3d2774b5 genesis-generation-config-cl +16fcc4f96236 genesis-generation-config-el +5fc72346f646 geth-prefunded-keys +96ae153a0b51 prysm-password + +========================================== User Services ========================================== +UUID Name Ports Status +f369802ad2ae cl-1-lighthouse-nethermind http: 4000/tcp -> http://127.0.0.1:49894 RUNNING + metrics: 5054/tcp -> http://127.0.0.1:49892 + tcp-discovery: 9000/tcp -> 127.0.0.1:49893 + udp-discovery: 9000/udp -> 127.0.0.1:64949 +5e14eb26ef45 cl-1-lighthouse-nethermind-validator http: 5042/tcp -> 127.0.0.1:49895 RUNNING + metrics: 5064/tcp -> http://127.0.0.1:49896 +fed533d0e143 cl-2-teku-nethermind http: 4000/tcp -> 127.0.0.1:49899 RUNNING + metrics: 8008/tcp -> 127.0.0.1:49897 + tcp-discovery: 9000/tcp -> 127.0.0.1:49898 + udp-discovery: 9000/udp -> 127.0.0.1:55521 +69cd832de246 cl-3-lodestar-nethermind http: 4000/tcp -> 127.0.0.1:49903 RUNNING + metrics: 8008/tcp -> 127.0.0.1:49901 + tcp-discovery: 9000/tcp -> 127.0.0.1:49902 + udp-discovery: 9000/udp -> 127.0.0.1:50507 +75e3eec0c7d1 cl-3-lodestar-nethermind-validator metrics: 8008/tcp -> 127.0.0.1:49904 RUNNING +e10c3f07e0e0 el-1-nethermind-lighthouse engine-rpc: 8551/tcp -> 127.0.0.1:49872 RUNNING + rpc: 8545/tcp -> 127.0.0.1:49870 + tcp-discovery: 30303/tcp -> 127.0.0.1:49869 + udp-discovery: 30303/udp -> 127.0.0.1:64508 + ws: 8546/tcp -> 127.0.0.1:49871 +c6a28d3136fe el-2-nethermind-teku engine-rpc: 8551/tcp -> 127.0.0.1:49873 RUNNING + rpc: 8545/tcp -> 127.0.0.1:49875 + tcp-discovery: 30303/tcp -> 127.0.0.1:49874 + udp-discovery: 30303/udp -> 127.0.0.1:52495 + ws: 8546/tcp -> 127.0.0.1:49876 +2fae3b3c41d3 el-3-nethermind-lodestar engine-rpc: 8551/tcp -> 127.0.0.1:49890 RUNNING + rpc: 8545/tcp -> 127.0.0.1:49888 + tcp-discovery: 30303/tcp -> 127.0.0.1:49891 + udp-discovery: 30303/udp -> 127.0.0.1:62119 + ws: 8546/tcp -> 127.0.0.1:49889 +403cafe8416e prelaunch-data-generator-cl-genesis-data RUNNING +ebea71008cf4 prelaunch-data-generator-el-genesis-data RUNNING +``` + +And that is it! You now have a 3-node, private Ethereum devnet with Nethermind/Lodestar, Nethermind/Teku, and Nethermind/Lighthouse execution and consensus client combinations. + +Notice how, at the end, Kurtosis will print out the contents of your enclave, which includes both the various [files artifacts](https://docs.kurtosis.com/concepts-reference/files-artifacts) and services that form your network. Kurtosis also maps the container ports to ephemeral local ports on your machine. + +Genesis data was generated using this [genesis-generator](https://github.com/ethpandaops/ethereum-genesis-generator) to bootstrap the execution and consensus clients for each node. The end result will be a private testnet with nodes deployed as Docker containers in an ephemeral, isolated environment on your machine called an [enclave][enclaves]. + +Kurtosis packages are modular, reproducible, and will work over Docker or Kubernetes. Read on to learn about additional services and configurations you may want to add to your private network. + +## Step 4: Optional workflows + +This section briefly covers some optional configurations for your private devnet that are commonly used for validating and testing node-level behavior. + +### Simulating MEV workflows with `mev-boost` + +The `ethereum-package` can simulate out-of-protocol Proposer Builder Separation (PBS) workflows using Flashbot's `mev-boost` infrastructure. With a single flag, you can configure your network's validators to be instantiated with `mev-boost` and be registered with a relayer to receive payloads from builders. + +To enable this in your `network_params.json` file, set `"mev_type":` to `"full"` or `"mock"`. + +To learn more about how the `mev-boost` infrastructure works with your private network, check out [this guide](https://docs.kurtosis.com/how-to-full-mev-with-ethereum-package). + +### Observability tools + +The `ethereum-package` comes out of the box with a few observability tools, including: + +- A Grafana and Prometheus instance +- A [beacon metrics gazer service](https://github.com/dapplion/beacon-metrics-gazer) to collect network-wide participation metrics +- A [JSON-RPC Snooper](https://github.com/ethDreamer/json_rpc_snoop) to log responses & requests between the execution engine API and the consensus client + +To add your own custom Grafana dashboard template, fork the `ethereum-package` repository and add your configuration [here](https://github.com/ethpandaops/ethereum-package/tree/main/static_files/grafana-config/dashboards). + +### Deploying on Kubernetes + +As mentioned earlier, Kurtosis packages (i.e. environment definitions) are portable and will work the same way over Docker or on Kubernetes. Should you require a larger scale devnet, Kurtosis can deploy any package, including the `ethereum-package` on Kubernetes, see [Running Kurtosis in Kubernetes](https://docs.kurtosis.com/k8s). + +## Questions and feedback + +If you need help with your Nethermind full node in the private devnet, please don't hesitate to contact the Kurtosis team on [GitHub](https://github.com/ethpandaops/ethereum-package) or [Discord](https://discord.gg/jJFG7XBqcY). + +[enclaves]: https://docs.kurtosis.com/concepts-reference/enclaves diff --git a/versioned_docs/version-1.36.0/fundamentals/security.md b/versioned_docs/version-1.36.0/fundamentals/security.md new file mode 100644 index 0000000000..9bef9f1351 --- /dev/null +++ b/versioned_docs/version-1.36.0/fundamentals/security.md @@ -0,0 +1,27 @@ +--- +title: Security +sidebar_position: 3 +--- + +## General security considerations + +:::tip +Although Nethermind is thoroughly tested, the more popular it becomes, the more likely it will be a target of client-specific attacks. Generally, we recommend you always consider running backup client nodes from another developer for any critical operations. +::: + +:::warning +Enable only the [JSON-RPC namespaces](../interacting/json-rpc-server.md) you absolutely need. This is particularly important for namespaces like `admin` and `debug`, as they can be exploited to get elevated access to your node or for DOS attacks. +::: + +:::danger +The private key the node id is derived from is stored on the disk as plaintext. +::: + +## Networking security + +These rules are **highly recommended** to be applied to your firewall: + +- Block all traffic to the port `8545`, or whatever port is defined for JSON-RPC interface, except for traffic from explicitly defined trusted sources. +- Allow traffic to the TCP port `30303` or whatever port is defined for P2P communication. This allows the node to connect to peers. +- Allow traffic to the UDP port `30303` or whatever port ia defined for P2P communication. This allows node discovery. + diff --git a/versioned_docs/version-1.36.0/fundamentals/state-pruning.md b/versioned_docs/version-1.36.0/fundamentals/state-pruning.md new file mode 100644 index 0000000000..9dc2598736 --- /dev/null +++ b/versioned_docs/version-1.36.0/fundamentals/state-pruning.md @@ -0,0 +1,174 @@ +--- +title: State pruning +sidebar_position: 6 +--- + +## Overview + +Pruning pertains to eliminating or cleaning obsolete historical data to optimize disk space. Clients are responsible for maintaining the world state, which comprises a database that portrays the current Ethereum network status. The world state encompasses accounts, contracts, and other information. + +Pruning aims to reduce disk requirements by storing only the current world state and removing historical data. This differs from archive nodes that retain complete transaction and state history. Pruning is helpful for users who don't require historical data and prefer to interact solely with the current state of the network. However, pruning may limit the client's ability to fulfill requests that depend on historical information. Nethermind provides two kinds of pruning – _full pruning_ and _in-memory pruning_; both are enabled by default, also called _hybrid pruning_. + +## How it works + +During synchronization using the snap sync method, Nethermind produces a local copy of the Ethereum network state. Although this size increases by around 30 GB each week, specific historical data is retained that is not necessary for node operation or to maintain the current Ethereum state. For a detailed description of the disk usage usage, check out the [database size](./database.md#database-size). + +When full pruning is activated and initiated, a thorough examination of the entire state tree is conducted to determine which data is no longer required and can be treated as historical. It then determines which information corresponds to the current state and duplicates it alongside the existing version. During verification of each node in the state, the new pruned state replaces the previous one. Once the verifier confirms everything is functioning correctly, the old state database is eliminated, resulting in significant savings in disk space. As a result, the size of the database will be close to its initial size again. + +In-memory pruning is a continuous process that occurs under regular operation. Instead of saving a new state on each block, Nethermind will keep it in memory until a certain threshold is reached. At that point, Nethermind will only store data required by the newer state and discard unnecessary ones. This significantly reduces the total amount of data written while improving block processing performance. In-memory pruning is independent of full pruning. + +## Preparation for full pruning + +Because full pruning is executed while the node is connected to the network, it can affect the node's performance. +The process can consume significant memory, CPU, and disk resources, impacting block processing time. +This, in turn, can lead to reduced rewards for validator setups, particularly for proof-of-stake chains. + +Currently, full pruning takes between 20 to 30 hours to complete, although the duration may vary based on the hardware configuration. At least 200 GB of storage is required to ensure pruning runs smoothly. Nevertheless, it's recommended to have 300 GB or more. + +:::warning Important +Do not turn on full pruning on an archive node, as these are two opposing features. Archive nodes are designed to store +complete historical data, whereas full pruning eliminates it. Set the [`Pruning.Mode`](../fundamentals/configuration.md#pruning-mode) configuration options to `None` to ensure that pruning is turned off completely. +::: + +## Configuring full pruning + +As a very first point, check out the [pruning configuration options](./configuration.md#pruning). + +To activate full pruning, set either the [`Pruning.Mode`](../fundamentals/configuration.md#pruning-mode) configuration option to `Hybrid` or `Full`. + +:::info +Setting the `Pruning.Mode` to `Hybrid` enables both `InMemory` and `Full` modes. The `InMemory` mode helps the node storage grow slower than the `Full` mode. Because of this, full pruning is executed less frequently, promoting +healthier disk operation. Since full pruning is hardware-intensive, this configuration also benefits attestation results. +::: + +The next step is to determine the trigger conditions for full pruning. Currently, there are 3 options available: + +- [Manual](#manual) +- [State database size threshold](#state-db-threshold) +- [Remaining storage space threshold](#storage-left-threshold) + +### Manual + +Manual mode triggers full pruning only upon request, providing complete control. To configure this mode, set the the `Pruning.Mode` to `Hybrid` and the [`Pruning.FullPruningTrigger`](../fundamentals/configuration.md#pruning-fullpruningtrigger) to `Manual`. + +Pruning can also be triggered using the [`admin_prune`](../interacting/json-rpc-ns/admin.md#admin_prune) JSON-RPC method. Here's how to configure it: + +- Add the `admin` namespace to [`JsonRpc.EnabledModules`](./configuration.md#jsonrpc-enabledmodules). For instance,\ + `--jsonrpc-enabledmodules [eth,net,...,admin]` +- Create a separate port for `admin` namespace only:\ + `--jsonrpc-additionalrpcurls http://localhost:8555|http|admin` + +Restart the client, and if everything is configured correctly, you should be able to call the `admin_prune` method, and full pruning should start. + +:::info +One potential disadvantage of the manual mode is that if full pruning is not triggered on time, it cannot be performed later because of insufficient disk space. In such cases, the only option to free up the disk space is to resync the node from scratch. +::: + +### State database size threshold {#state-db-threshold} + +This mode triggers full pruning automatically when the state database reaches the specified size. +To enable this mode, set the `Pruning.Mode` to `Hybrid`, `Pruning.FullPruningTrigger` to `StateDbSize`, and [`Pruning.FullPruningThresholdMb`](../fundamentals/configuration.md#pruning-fullpruningthresholdmb) to `256000` or to something that better suits your needs. + +The above configuration triggers full pruning automatically whenever the state database size exceeds 256,000 +MB (250 GB). Assuming the state database has initially around 160 GB, pruning will be triggered when the database size grows by more than 90 GB. + +:::tip +To avoid unexpected behavior and ensure that full pruning can be completed in full, it's recommended to set the threshold value to trigger pruning before the free disk space drops below 250 GB as a minimum. This ensures that sufficient free disk space is available for the pruning process. +::: + +### Remaining storage space threshold {#storage-left-threshold} + +:::note +This is the recommended approach as it ensures that pruning is executed on time. +::: + +This mode triggers full pruning when the storage space reaches the specified minimum. To enable this mode, set the `Pruning.Mode` to `Hybrid`, `Pruning.FullPruningTrigger` to `VolumeFreeSpace`, and `Pruning.FullPruningThresholdMb` to `256000` or a higher value if needed. + +The above configuration triggers full pruning whenever free disk space drops to 256,000 MB (250 GB) or below. This ensures that pruning is invoked as infrequently as possible while also ensuring that sufficient free storage is always available to trigger it. + +:::warning +It's recommended not to set the value below 250 GB for stability reasons. In reality, full pruning should require approximately the same amount of storage as a fresh state database (around 160 GB). Still, it also needs a threshold for processing and other operations since it creates a copy of the existing state database. Therefore, it's essential to maintain a minimum amount of storage to ensure a robust pruning performance. +::: + +## Monitoring progress + +When full pruning is triggered correctly, the corresponding messages appear in the Nethermind logs. + +The very first ones should be: + +``` +Full Pruning Ready to start: pruning garbage before state with root . +WARN: Full Pruning Started on root hash : do not close the node until finished or progress will be lost. +``` + +From that moment, ensure that no restarts will be performed on Nethermind to ensure that full pruning runs correctly. +After a few minutes first logs with progress would start to appear. For instance: + +``` +Full Pruning In Progress: 00:00:57.0603307 1.00 mln nodes mirrored. +Full Pruning In Progress: 00:01:40.3677103 2.00 mln nodes mirrored. +Full Pruning In Progress: 00:02:25.6437030 3.00 mln nodes mirrored. +``` + +Pruning may take even _more than 30 hours_, depending on hardware configuration. + +When pruning is completed, there is a log message similar the following: + +``` +Full Pruning Finished: 15:25:59.1620756 1,560.29 mln nodes mirrored. +``` + +As you may notice, it took around 15 hours in this example. + +:::info +Since the amount of mirrored nodes is not a static value, providing a simple progress indicator in percentage is impossible. Therefore, the approximate value given should be used to determine when full pruning is expected to be completed. +::: + +## Additional settings + +### Memory budget + +The [`Pruning.FullPruningMemoryBudgetMb`](./configuration.md#pruning-fullpruningmemorybudgetmb) configuration option controls the memory budget allocated for the trie visit during +the full pruning process. During pruning, pending nodes are queued to a pool of nodes whose size is determined by this value. This allows multiple nodes to share a single I/O. By increasing this value, the required read IOP per second can be significantly reduced, resulting in a faster full pruning operation. However, this improvement comes at the expense of increased memory usage. + +Assuming your system has 64GB of RAM, with Nethermind, the consensus client, and system expenses consuming 20GB, +you need to determine the maximum value for `Pruning.FullPruningMemoryBudgetMb` while ensuring the system remains stable and respects the given limit. In this case, you have 44 GB (64 GB - 20 GB) of available memory for increasing the `Pruning.FullPruningMemoryBudgetMb` value. To calculate the maximum value in MB, multiply the available memory by 1024: `44 GB * 1024 = 45,056 MB` + +:::info +Because of the workload on Ethereum Mainnet, setting the value of `Pruning.FullPruningMemoryBudgetMb` higher than 16 GB may not provide any additional performance benefits. +::: + +Please note that this example assumes the remaining 44 GB of memory is sufficient for the full pruning memory budget. +Depending on the specific use case and system requirements, it may be necessary to adjust the value further to optimize performance and resource usage. + +### Pruning completion behavior + +The [`Pruning.FullPruningCompletionBehavior`](./configuration.md#pruning-fullpruningcompletionbehavior) configuration option determines Nethermind's behavior after full pruning is completed. By default, Nethermind will continue to progress as usual. However, if a user wishes to shut down the node after pruning, there are three options available: + +- `None`: No action taken +- `ShutdownOnSuccess`: Nethermind shuts down if pruning succeeds +- `AlwaysShutdown`: Nethermind shuts down once pruning completes, regardless of whether it succeeds or fails + +### Number of pruning concurrent tasks + +The [`Pruning.FullPruningMaxDegreeOfParallelism`](./configuration.md#pruning-fullpruningmaxdegreeofparallelism) configuration option determines the number of parallel tasks/threads that can be used by pruning: + +- `-1`: uses the number of logical processors +- `0`: uses 25% of logical processors +- `1`: runs on a single thread + +The recommended value depends on the type of node being used. If the node needs to be responsive (e.g., RPC or validator), using a value below the number of logical processors is recommended. The default value is recommended if the node doesn't have many other responsibilities but needs to follow the chain without delays and produce live logs reliably. If the node doesn't need to be responsive, has very fast I/O (such as NVMe), and the shortest pruning time +is desired, this can be set to 2–3 times the number of logical processors. + +### In-memory cache size + +The [`Pruning.CacheMb`](./configuration.md#pruning-cachemb) configuration option determines the size, in MB, of the memory pool of nodes used for in-memory pruning. The default value is 1024. Increasing this value can help reduce the rate at which the state database grows. + +## Side notes + +For pruning, keep in mind the following: + +- Full pruning is a cumbersome task, but it's performed in the background, so the node continues progressing and following the chain. +- The process' heaviness may affect the effectiveness of the validator rewards. Still, since it's executed only once every few months, it shouldn't have a significant impact on overall results (we've xperienced approximately 5–10% loss of rewards during full pruning). +- Ensure that your storage has at least 250 GB of free space after syncing the node. Otherwise, full pruning will never complete successfully. +- Several things can be done to reduce the size of the database after syncing: setting [`Sync.AncientBodiesBarrier`](./configuration.md#sync-ancientbodiesbarrier) and [`Sync.AncientReceiptsBarrier`](./configuration.md#sync-ancientreceiptsbarrier) to a proper value higher than 0, using a consensus client that requires less storage, and setting logs to the lowest level to avoid log spamming. diff --git a/versioned_docs/version-1.36.0/fundamentals/sync.md b/versioned_docs/version-1.36.0/fundamentals/sync.md new file mode 100644 index 0000000000..98134b5727 --- /dev/null +++ b/versioned_docs/version-1.36.0/fundamentals/sync.md @@ -0,0 +1,377 @@ +--- +title: Sync +sidebar_position: 2 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +Syncing is the process by which Nethermind updates itself to the latest block and current network state. There are several ways (sync modes) to sync a Nethermind node, each differing in speed, storage requirements, and trust assumptions. + +## Snap sync + +Snap sync allows a node to perform the initial synchronization and download of network state up to 10 times faster +than using fast sync. This mode is enabled by default for most of networks that support it, and can be configured with the [`Sync.SnapSync`](./configuration.md#sync-snapsync) configuration option. + +:::warning +Do not enable snap sync on a previously synced node. Only do so when syncing to the network for the first time. +::: + +The sync speed and download size has to do with the specific way in which network's state is stored in a node—[Merkle trees](https://ethereum.org/en/developers/docs/data-structures-and-encoding/patricia-merkle-trie/). + +![]() + +With fast sync, a node downloads the headers of each block and retrieves all the nodes beneath it until it reaches the +leaves. By contrast, snap sync only downloads the leaf nodes, generating the remaining nodes locally which saves time +and packets downloaded. + +## Fast sync + +After completing the fast sync, Nethermind can answer questions like "What is my account balance now?" or "How many XYZ tokens does a particular exchange hold at the moment?". This mode can be configured with the following configuration options: + +- [`Sync.FastSync`](./configuration.md#sync-fastsync) +- [`Sync.AncientBodiesBarrier`](./configuration.md#sync-ancientbodiesbarrier) +- [`Sync.AncientReceiptsBarrier`](./configuration.md#sync-ancientreceiptsbarrier) +- [`Sync.DownloadBodiesInFastSync`](./configuration.md#sync-downloadbodiesinfastsync) +- [`Sync.DownloadHeadersInFastSync`](./configuration.md#sync-downloadheadersinfastsync) +- [`Sync.FastSyncCatchUpHeightDelta`](./configuration.md#sync-fastsynccatchupheightdelta) +- [`Sync.PivotHash`](./configuration.md#sync-pivothash) +- [`Sync.PivotNumber`](./configuration.md#sync-pivotnumber) +- [`Sync.PivotTotalDifficulty`](./configuration.md#sync-pivottotaldifficulty) + +Fast sync has multiple stages. Nethermind uses a _pivot block_ number to improve fast sync performance. The pivot block data is automatically updated after initialization of the client and consists of the block number, block hash, and block total difficulty if any. Before synchronizing state data, Nethermind synchronizes in two directions—backward from the pivot block to 0 for headers and forward to the head of the chain for headers, blocks, and receipts. Forward sync might be very slow (5 to 50 blocks per second), so having a fresh pivot block is crucial. + +After downloading the block data, Nethermind will start state sync (downloading the latest state tree nodes). It provides an estimate for the download size and progress, but the real value may be different from the estimation. Because of this, sometimes sync may continue even when it shows ~100% finished. The other important component is sync speed—if the network or file system causes the state sync to go much slower than ~1.5 Mbps on average, Nethermind will start downloading some parts of the tree repeatedly. You may be surprised to see something like `58000MB / 53000MB (100%)` in such cases. This means it has downloaded around 5GB of data no longer needed. If sync is very slow (extended beyond 2 days), your setup will likely not catch up with the chain progress. After the state sync finishes, you will see the `Processed...` messages like in archive sync, which means that Nethermind is in sync and is processing the latest blocks. + +At the last stages of the sync, the node will repeatedly display the branch sync progress and change the block number to which it tries to catch up. This stage should take from 30 minutes up to 2 hours. If it lasts much longer, you may be unable to catch up with the network progress. One of the best indicators that you are close to being synced is combined ~100% state size progress and nearly 100% branch sync progress. + +:::warning +A single restart of Nethermind during the fast sync may extend the sync time by up to 2 hours because Nethermind has to rebuild the caches by reading millions of values from the database. +::: + +## Archive sync + +Archive sync is the heaviest and slowest sync mode but can answer questions like "What was my account balance 2 years ago?" or 'How many XYZ tokens were held in the custody of a particular exchange in 2022?". Archive sync can be enabled by choosing the respective [archive configuration](./configuration.md#config) for the network you want to sync. By convention, such configurations suffixed `_archive`. + +While archive sync can be completed very quickly (in minutes or hours) for some small networks, the Ethereum Mainnet sync would take several days, depending on the speed of your disk and network connection. The database size in archive sync is the biggest of all sync modes, as it stores all the historical data. + +Explanation of some logs during archive sync: + +- At the beginning, you may see the `Waiting for peers...` messages while Nethermind tries to discover nodes it can sync with. +- `Downloaded 1234/8000000` shows the number of unprocessed blocks (with transactions) downloaded from the network. For the Ethereum Mainnet, this value may be slower than processing at first, but very quickly, you will see blocks being downloaded much faster than processed. Empty blocks can be as small as 512 bytes (just headers without transactions), and full blocks with heavy transactions can reach a few hundred KB. Nethermind shows the current download speed (calculated in the last second) and average (total) speed since start. +- `Processed ...` shows the blocks that the EVM has processed. The first number shows the current head block number; then you can see `MGas/s` (megagas per second)—current and total, then `tps` (transactions per second)-current and total, and `blk/s` (blocks per second). Then `recv` queue (transactions signature public key recovery queue), `proc` queue (processor queue). Both the recovery and processor queues are designed so that when too many blocks are waiting for processing, only their hashes are kept in memory, and the remaining data are stored in the database. Thus, the queues numbers that you can see will be capped by some number. +- `Cache for epoch...` shows Ethash cache needed for block seal verification (Ethereum Mainnet only). Caches will be calculated every 30k blocks (length of an epoch) and can also be calculated for the latest blocks broadcast on the network. After the archive sync finishes, you will see the `Processed...` message appearing on average every 15 seconds when the new block is processed. + +`MGas/s`, `tps`, and `bps` values should not be treated as comparable as they may differ massively on different parts of the chain. For example, when blocks are empty, you may see very high `bps` values with very low (or even zero) `tps` and `MGas/s` values as there are no transactions and no gas for EVM processing, and blocks are very light. On the other hand, when blocks are filled with heavy transactions, `bps` might be very low while `MGas/s` will be very high. It is even possible that you will see a lot of very light transactions where `tps` will be high while `bps` and `MGas/s` will be average. + +## Sync time + +Sync time heavily depends on the hardware used for the node, network speed, and peering. We are constantly pursuing to make it as fast as possible. Below is a brief on how the sync time looks on different machines and various chains (tested with Nethermind v1.21.0). + + + + +Hardware configuration: + +- Cloud provider: Akamai (formerly Linode) +- CPU: AMD EPYC 7601, 16 vCPU +- Memory: 64 GB +- Storage: 1.2 TB, ~40k IOPS + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 2h 3m +- **Full sync time:** 7h 3m + +The detailed breakdown of sync stages: + +- **Snap sync phase 1:** 1h 58m +- **State sync:** 4m +- **Old headers:** 1h 27m +- **Old bodies:** 1h 55m +- **Old receipts:** 3h 2m + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 2h 49m +- **Full sync time:** 4h 58m + +The detailed breakdown of sync stages: + +- **Snap sync phase 1:** 2h 49m +- **State sync:** 0.5m +- **Old headers:** 11m +- **Old bodies:** 1h 2m +- **Old receipts:** 1h 5m + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 8m +- **Full sync time:** 1h 9m + +The detailed breakdown of sync stages: + +- **Snap sync phase 1:** 8m +- **State sync:** 0.3m +- **Old headers:** 12m +- **Old bodies:** 21m +- **Old receipts:** 22m + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 13h 40m +- **Full sync time:** 17h 17m + +The detailed breakdown of sync stages: + +- **State sync:** 13h 40m +- **Old headers:** 1h 46m +- **Old bodies:** 1h 31m +- **Old receipts:** 2h 3m + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 20m +- **Full sync time:** 40m + +The detailed breakdown of sync stages: + +- **State sync:** 20m +- **Old headers:** 11m +- **Old bodies:** 8m +- **Old receipts:** 10m + + + + + + +Hardware configuration: + +- Cloud provider: AWS +- [c7g.2xlarge](https://aws.amazon.com/ec2/instance-types/c7g/): 8 vCPU, 16 GiB memory +- Storage: 1 TB, ~10k IOPS + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 5h 55m +- **Full sync time:** 12h 37m + +The detailed breakdown of sync stages: + +- **Snap sync phase 1:** 4h 35m +- **State sync:** 1h 20m +- **Old headers:** 1h 43m +- **Old bodies:** 2h 13m +- **Old receipts:** 4h 28m + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 1h 32m +- **Full sync time:** 4h 10m + +The detailed breakdown of sync stages: + +- **Snap sync phase 1:** 1h 19m +- **State sync:** 12m +- **Old headers:** 23m +- **Old bodies:** 49m +- **Old receipts:** 1h 35m + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 17m +- **Full sync time:** 1h 3m + +The detailed breakdown of sync stages: + +- **Snap sync phase 1:** 13m +- **State sync:** 4m +- **Old headers:** 15m +- **Old bodies:** 19m +- **Old receipts:** 29m + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 15h 54m +- **Full sync time:** 18h 28m + +The detailed breakdown of sync stages: + +- **State sync:** 15h 54m +- **Old headers:** 1h 4m +- **Old bodies:** 40m +- **Old receipts:** 1h 52m + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 13m +- **Full sync time:** 25m + +The detailed breakdown of sync stages: + +- **State sync:** 13m +- **Old headers:** 12m +- **Old bodies:** 5m +- **Old receipts:** 5m + + + + + + +Hardware configuration: + +- Cloud provider: Scaleway +- CPU: Intel Xeon Processor E5-2620 v2, 2 vCPU +- Memory: 192 GB +- Storage: 1 TB, ~44k IOPS + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 5h 55m +- **Full sync time:** 17h 1m + +The detailed breakdown of sync stages: + +- **Snap sync phase 1:** 4h 29m +- **State sync:** 25m +- **Old headers:** 1h 27m +- **Old bodies:** 3h 39m +- **Old receipts:** 8h 3m + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 1h 51m +- **Full sync time:** 5h 55m + +The detailed breakdown of sync stages: + +- **Snap sync phase 1:** 1h 40m +- **State sync:** 11m +- **Old headers:** 50m +- **Old bodies:** 1h 34m +- **Old receipts:** 2h 14m + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 16m +- **Full sync time:** 2h 9m + +The detailed breakdown of sync stages: + +- **Snap sync phase 1:** 15m +- **State sync:** 1m +- **Old headers:** 26m +- **Old bodies:** 45m +- **Old receipts:** 56m + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 15h 13m +- **Full sync time:** 17h 30m + +The detailed breakdown of sync stages: + +- **State sync:** 15h 13m +- **Old headers:** 3h 8m +- **Old bodies:** 50m +- **Old receipts:** 1h 25m + + + + +The high-level data on major sync milestones: + +- **Attestation time:** 20m +- **Full sync time:** 40m + +The detailed breakdown of sync stages: + +- **State sync:** 4m +- **Old headers:** 1h 27m +- **Old bodies:** 1h 55m +- **Old receipts:** 3h 2m + + + + +The detailed breakdown of sync stages: + +- **State sync:** 13h 7m +- **Old headers:** 2h 32m +- **Old bodies:** 51m +- **Old receipts:** 1h 11m +- **Full sync time:** 15h 20m + + + + +The detailed breakdown of sync stages: + +- **State sync:** 14h 27m +- **Old headers:** 2h 42m +- **Old bodies:** 40m +- **Old receipts:** 58m +- **Full sync time:** 16h 10m + + + + + + +## Resync from scratch \{#resync\} + +:::info +Note that resyncing a Nethermind node can take a considerable amount of time. It depends on your hardware, +network connection, and the size of the chain. +::: + +- Stop Nethermind if it's running. +- In the Nethermind database directory, `nethermind_db`, by default, look for a directory named after the network you want to resync and _delete that directory_. For instance, it's `mainnet` for the Ethereum Mainnet. Normally, the database directory can be found at one of the following locations: + - `nethermind_db` in the Nethermind's directory (by default) + - `nethermind_db` in the Nethermind data directory specified by [`--data-dir`](./configuration.md#data-dir) command line option (recommended approach) + - The directory specified by [`--db-dir`](./configuration.md#db-dir) command line option +- Start Nethermind again and monitor its logs to ensure sync is progressing. diff --git a/versioned_docs/version-1.36.0/get-started/_category_.json b/versioned_docs/version-1.36.0/get-started/_category_.json new file mode 100644 index 0000000000..64f7e51772 --- /dev/null +++ b/versioned_docs/version-1.36.0/get-started/_category_.json @@ -0,0 +1,4 @@ +{ + "position": 1, + "label": "Get started" +} diff --git a/versioned_docs/version-1.36.0/get-started/installing-nethermind.md b/versioned_docs/version-1.36.0/get-started/installing-nethermind.md new file mode 100644 index 0000000000..24698fa1a3 --- /dev/null +++ b/versioned_docs/version-1.36.0/get-started/installing-nethermind.md @@ -0,0 +1,263 @@ +--- +title: Installing Nethermind +sidebar_position: 2 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +Nethermind can be installed in several ways: + +- [Via a package manager](#package-managers) +- [As a standalone download](#standalone-downloads) +- [As a Docker container](#docker-container) +- [By building from source code](../developers/building-from-source.md) + +## Prerequisites + +:::info +Does not apply to Docker distributions. +::: + +Before installing Nethermind, your specific platform might need the following prerequisites. + + +None + + +Although the modern versions of Windows are bundled with a recent version of [Microsoft Visual C++ Redistributable](https://aka.ms/vcredist), in some cases, it may need an update: + +```powershell +winget install --id Microsoft.VCRedist.2015+.x64 +``` + + +None + + +## Package managers + +Package managers are the easiest and fastest way of installing Nethermind. + + + + +On Ubuntu and other Linux distros supporting PPA, Nethermind can be installed via Launchpad PPA. + +First, add the Nethermind repository: + +```bash +sudo add-apt-repository ppa:nethermindeth/nethermind + +# If the command is not found, run +# sudo apt-get install software-properties-common +``` + +Then, install Nethermind as follows: + +```bash +sudo apt-get update +sudo apt-get install nethermind +``` + + + + +On Windows, Nethermind can be installed via Windows Package Manager as follows: + +```powershell +winget install --id Nethermind.Nethermind +``` + + + + +On macOS, Nethermind can be installed via Homebrew. + +First, add the Nethermind repository: + +```bash +brew tap nethermindeth/nethermind +``` + +Then, install Nethermind as follows: + +```bash +brew install nethermind +``` + + + + +For further instructions, see [Running a node](running-node/running-node.md). + +## Standalone downloads + +Standalone downloads give users more flexibility by allowing them to install a specific version of Nethermind, choose the installation location, and prevent automatic updates. + +Standalone downloads are available on [GitHub Releases](https://github.com/NethermindEth/nethermind/releases) as ZIP archives for x86-64 and AArch64 (ARM64) CPU architectures for Linux, Windows, and macOS. + +### Signatures + +For security guarantees, Nethermind provides an OpenPGP signature for each package as a separate .asc file (detached signature), signed with the following key: [`AD12 7976 5093 C675 9CD8 A400 24A7 7461 6F1E 617E`](https://keyserver.ubuntu.com/pks/lookup?search=24A774616F1E617E&fingerprint=on&op=index) + +To begin with verification, import the above signing key as follows: + +```bash +gpg --keyserver keyserver.ubuntu.com --recv-keys 24A774616F1E617E +``` + +Then, download the corresponding .asc file to verify the package of your choice. For instance: + +```bash +gpg --verify nethermind-1.35.8-c066aee2-linux-x64.zip.asc nethermind-1.35.8-c066aee2-linux-x64.zip +``` + +### Configuring as a Linux service + +Installing Nethermind as a Linux `systemd` service takes just a few simple steps: + +1. Create a separate user and group for Nethermind and configure them as follows: + + ```bash + # Create a new user and group + sudo useradd -m -s /bin/bash nethermind + + # Increase the maximum number of open files + sudo bash -c 'echo "nethermind soft nofile 100000" > /etc/security/limits.d/nethermind.conf' + sudo bash -c 'echo "nethermind hard nofile 100000" >> /etc/security/limits.d/nethermind.conf' + + # Switch to the nethermind user + sudo su -l nethermind + + # Create required directories + # Note that the home directory (~) is now /home/nethermind + mkdir ~/bin + mkdir ~/data + ``` + +2. [Download Nethermind](#standalone-downloads) and extract the package contents to the `~/bin` directory created in the previous step. +3. Configure Nethermind options in the `~/.env` file: + + ```bash title="~/.env" + # Required + NETHERMIND_CONFIG="mainnet" + + # Optional + NETHERMIND_HEALTHCHECKSCONFIG_ENABLED="true" + ``` + + For available options, see [Configuration](../fundamentals/configuration.md). + +4. Create the `~/nethermind.service` unit file: + + ```ini title="~/nethermind.service" + [Unit] + Description=Nethermind node + Documentation=https://docs.nethermind.io + After=network.target + + [Service] + User=nethermind + Group=nethermind + EnvironmentFile=/home/nethermind/.env + WorkingDirectory=/home/nethermind + ExecStart=/home/nethermind/bin/nethermind --data-dir /home/nethermind/data + Restart=on-failure + LimitNOFILE=1000000 + + [Install] + WantedBy=default.target + ``` + +5. Finally, set up the Linux service: + + ```bash + # Move the unit file to the systemd directory + sudo mv nethermind.service /etc/systemd/system + + # Reload the systemd daemon + sudo systemctl daemon-reload + + # Start the service + sudo systemctl start nethermind + + # Optionally, enable the service to start on boot + sudo systemctl enable nethermind + ``` + +Done! To ensure the service is up and running, check its status as follows: + +```bash +sudo systemctl status nethermind +``` + +To monitor the Nethermind output, run: + +```bash +journalctl -u nethermind -f +``` + +For further instructions, see [Running a node](running-node/running-node.md). + +## Docker container + +The Docker images of Nethermind are available on [Docker Hub](https://hub.docker.com/r/nethermind/nethermind). + +The Docker images are based on Ubuntu 24.04 and support x86-64 and AArch64 (ARM64) CPU architectures. They are tagged as follows: + +- `latest`: the latest version of Nethermind (the default tag). +- `latest-chiseled`: a _rootless_ and [chiseled](https://ubuntu.com/engage/chiselled-ubuntu-images-for-containers) image of the latest version of Nethermind.\ + For security reasons, this image contains only the absolutely necessary components and is intended to run as a non-root `app` user with UID/GID of `64198`. +- `x.x.x`: a specific version of Nethermind. For instance, `1.27.0`. +- `x.x.x-chiseled`: a rootless and chiseled image of the specific version of Nethermind. For instance, `1.27.0-chiseled`. + +For example, to download the latest chiseled image from the registry, run: + +```bash +docker pull nethermind/nethermind:latest-chiseled +``` + +Starting the container is achieved by: + +```bash +docker run -it nethermind/nethermind:latest-chiseled +``` + +The following ports are exposed by default: + +- `8545`: TCP, for the JSON-RPC interface +- `8551`: TCP, for the consensus client JSON-RPC interface +- `30303`: TCP and UDP, for P2P networking + +:::tip +It's highly recommended to mount data volumes as the Nethermind's data directories to ensure the synced data is preserved between the container restarts. +::: + +The following volume mount points are available by default: + +- `/nethermind/nethermind_db`: used to store the database +- `/nethermind/logs`: used to store the logs +- `/nethermind/keystore`: used to store the keys + +To mount separate volumes for each directory listed above, run: + +```bash +docker run -it \ + --mount type=bind,source=path/to/db,target=/nethermind/nethermind_db \ + --mount type=bind,source=path/to/logs,target=/nethermind/logs \ + --mount type=bind,source=path/to/keystore,target=/nethermind/keystore \ + nethermind/nethermind +``` + +Alternatively, a single volume can be specified as the Nethermind data directory as follows: + +```bash +docker run -it \ + --mount type=bind,source=path/to/data_dir,target=/nethermind/data_dir \ + nethermind/nethermind --data-dir /nethermind/data_dir +``` + +Note that any Nethermind-specific configuration option can be specified at the end. For instance, the `--data-dir` option in this case. For further instructions, see [Running a node](running-node/running-node.md). + +To build the Docker image yourself, see [Building Docker image](../developers/building-from-source.md#building-docker-image). diff --git a/versioned_docs/version-1.36.0/get-started/intro.md b/versioned_docs/version-1.36.0/get-started/intro.md new file mode 100644 index 0000000000..025df59a63 --- /dev/null +++ b/versioned_docs/version-1.36.0/get-started/intro.md @@ -0,0 +1,14 @@ +--- +title: Introduction and overview +sidebar_label: Introduction +sidebar_position: 0 +slug: / +--- + +Nethermind is a high-performance, highly configurable Ethereum execution client built on [.NET](https://dotnet.microsoft.com/en-us/) that runs on Linux, Windows, and macOS and supports Clique, Aura, and Ethash. With breakneck sync speeds and support for external plugins, it provides reliable access to rich on-chain data thanks to a high-performance JSON-RPC interface and node health monitoring with [Grafana](https://grafana.com) and [Seq](https://datalust.co/seq). + +Founded in 2017 and boosted by a grant from the Ethereum Foundation in 2018, we focus on delivering a robust Ethereum client, ensuring outstanding performance and flexibility for node operators. + +Here, you'll find instructions on installing, configuring, and using Nethermind and its features. We've organized the information by topic and included examples and visuals for better understanding. + +We hope you find this documentation helpful and welcome your feedback and suggestions! diff --git a/versioned_docs/version-1.36.0/get-started/migrating-from-geth.md b/versioned_docs/version-1.36.0/get-started/migrating-from-geth.md new file mode 100644 index 0000000000..68b1b49698 --- /dev/null +++ b/versioned_docs/version-1.36.0/get-started/migrating-from-geth.md @@ -0,0 +1,60 @@ +--- +title: Migrating from Geth +sidebar_position: 4 +--- + +This guide will walk you through all the steps required for a seamless and quick transition. + +First, ensure _the disk has enough space_. The most secure way is having a Nethermind synced on the same machine as Geth without shutting Geth down. That allows you to check whether Nethermind is syncing properly, verify whether everything works as expected, and reduce node downtime to a bare minimum. This is a recommended approach for any public JSON-RPC provider or a validator. + +- If the disk has enough space, [option 1](#option-1) or [option 2](#option-2) are the recommended choices. +- If there is not enough disk space, and downtime is not an option, we recommend either extending the disk or, if not possible, hosting Nethermind on another machine, syncing it, and whenever it completes, moving everything validator-related to that machine, and abandoning the first one. +- If downtime of around 12 hours or more is not a problem, see the [option 3](#option-3). + +## Option 1: Sync Nethermind next to Geth {#option-1} + +First, [install Nethermind](./installing-nethermind.md) and a [consensus client](running-node/consensus-clients.md) of your choice. + +:::warning +- If you choose the same consensus client for Nethermind that is already being used with Geth, ensure their settings, such as data directories, do not interfere. +- Ensure the network ports of the consensus client paired with Nethermind and the one paired with Geth do not interfere with each other. +- Ensure the JSON-RPC port, Engine API port, and the P2P networking ports of Nethermind are different from the ones used by Geth. These ports are set using the following command line options: + - [`--jsonrpc-port `](../fundamentals/configuration.md#jsonrpc-port) + - [`--jsonrpc-engineport `](../fundamentals/configuration.md#jsonrpc-engineport) + - [`--network-discoveryport `](../fundamentals/configuration.md#network-discoveryport) + - [`--network-p2pport `](../fundamentals/configuration.md#network-p2pport) +::: + +Once you fulfill the above requirements, you can start syncing Nethermind. To check the sync status, use the [`eth_syncing`](../interacting/json-rpc-ns/eth.md#eth_syncing) JSON-RPC method. When it returns `false`, Nethermind is considered fully synced with all block bodies and receipts needed to work properly as a validator. Another option to monitor the sync is a [health check](../monitoring/health-check.md). + +Once Nethermind is synced, shut down both Geth and Nethermind, along with its paired consensus client. Then, restart Nethermind using the ports assigned for and the JWT secret used by Geth before. Ensure no warnings or errors are present in the logs of both Nethermind and the consensus client. Also, check if Nethermind is following the chain properly. If everything is alright, you can remove Geth and the consensus client paired with Nethermind previously along with their data. + +## Option 2: Sync Nethermind using Sedge next to Geth {#option-2} + +[Sedge](https://docs.sedge.nethermind.io) is a setup tool for PoS validators and nodes that runs on Linux and macOS. + +This option is similar to the [option 1](#option-1), but Sedge automatically takes care of conflicting settings making the entire process much easier. + +:::tip +You can add a flag to Sedge as follows. For instance: + +- For the execution client, `--el-extra-flag jsonrpc-port=8546` +- For the consensus client, `--cl-extra-flag rpc-port=4001` +::: + +Once Nethermind is synced, you can remove extra flags if any from the `docker-compose.yml` and restart the node as follows: + +```bash +docker compose stop execution +docker compose up -d execution +``` + +## Option 3: Remove Geth and sync Nethermind {#option-3} + +This is the simplest option as it doesn't require configuration adjustments. However, the node will be down until Nethermind is syncing. + +- Shut down and remove Geth along with its data. +- [Install Nethermind](./installing-nethermind.md) +- Ensure Nethermind uses the same network ports as Geth before and the same JWT secret. Otherwise, you must reconfigure the consensus client to the Nethermind settings. + +Once you fulfill the above requirements, you can start syncing Nethermind. While Nethermid is syncing, ensure no errors are present in the logs of both Nethermind and the consensus client. Note that sync may take a while, depending on the chain. Also, you can periodically check the [`eth_syncing`](../interacting/json-rpc-ns/eth.md#eth_syncing) JSON-RPC method or the [health check](../monitoring/health-check.md). diff --git a/versioned_docs/version-1.36.0/get-started/running-node/_category_.json b/versioned_docs/version-1.36.0/get-started/running-node/_category_.json new file mode 100644 index 0000000000..fba3d60c8d --- /dev/null +++ b/versioned_docs/version-1.36.0/get-started/running-node/_category_.json @@ -0,0 +1,4 @@ +{ + "position": 3, + "label": "Running a node" +} diff --git a/versioned_docs/version-1.36.0/get-started/running-node/consensus-clients.md b/versioned_docs/version-1.36.0/get-started/running-node/consensus-clients.md new file mode 100644 index 0000000000..bd6e500209 --- /dev/null +++ b/versioned_docs/version-1.36.0/get-started/running-node/consensus-clients.md @@ -0,0 +1,141 @@ +--- +title: Consensus clients +sidebar_position: 1 +--- + +Ethereum's long-awaited shift from proof-of-work (PoW) to proof-of-stake (PoS) known as [The Merge](https://ethereum.org/en/roadmap/merge/) happened on September 15, 2022, and came with fundamental changes to the network. The most notable change is the addition of the consensus layer (aka Beacon Chain) which replaced the PoW mining. It is coordinating and pseudorandomly selecting block producers from the pool of stakers/validators in a way that makes it extremely difficult for validators to coordinate attacks on the network. +The Merge changed how operators run nodes on the Ethereum blockchain. A node now needs two clients that work together as a pair. In addition to the [execution client](https://ethereum.org/en/glossary/#execution-client) (e.g., Nethermind), you need a [consensus client](https://ethereum.org/en/glossary/#consensus-client) that connects to the consensus layer and runs the PoS algorithm. This guide shows how to run an Ethereum node with Nethermind and a consensus client of your choice. + +:::tip +An easy way to run both consensus and execution clients is with [Sedge](https://docs.sedge.nethermind.io). Sedge is a setup tool for PoS validators and nodes that runs on Linux and macOS. +::: + +## Choosing a consensus client + +On the consensus layer, there are 5 client implementations to choose from. Though all consensus clients are great, check them out yourself to find the one best suited to your needs. + +- [Grandine][grandine] +- [Lighthouse][lighthouse] +- [Lodestar][lodestar] +- [Nimbus][nimbus] +- [Prysm][prysm] +- [Teku][teku] + +:::warning Important +We urge you to take [client diversity](https://ethereum.org/en/developers/docs/nodes-and-clients/client-diversity) into consideration when choosing your consensus client and avoid the majority clients. +::: + +## Configuring JSON-RPC interface + +Execution and consensus clients communicate via an authenticated endpoint specified in Engine JSON-RPC API. In order to connect to a consensus client, the execution client must generate a [JWT](https://jwt.io) secret at a known path. Although the secret is generated automatically by Nethermind on startup at `keystore/jwt-secret` path in its root directory, in some cases, you might need to do it yourself. You can generate one using [OpenSSL](https://www.openssl.org): + +```bash +openssl rand -hex 32 > path/to/jwt.hex +``` +:::note +Since the JWT secret is simply a 64-character hex value, there are many other ways of generating it, including online resources. However, for security reasons, we recommend using OpenSSL. +::: + +The generated JWT secret can be specified with the [`JsonRpc.JwtSecretFile`](../../fundamentals/configuration.md#jsonrpc-jwtsecretfile) configuration option. For more configuration options, see [Engine API](../../interacting/json-rpc-server.md#engine-api). + +## Running the consensus client + +This step assumes that you have already [installed](../../get-started/installing-nethermind.md) Nethermind, the [consensus client](#choosing-a-consensus-client) of your choice, and, optionally, created the [JWT secret](#configuring-json-rpc-interface). + +:::info +As syncing from the scratch can take a very long time on some networks (up to several days), the commands below optionally use [checkpoint sync](https://ethereum.org/en/developers/docs/nodes-and-clients/#checkpoint-sync) to speed up the process. +::: + +### Grandine + +```bash +grandine \ + --network mainnet \ + --eth1-rpc-urls http://localhost:8551 \ + --jwt-secret path/to/jwt.hex \ + --checkpoint-sync-url https://beaconstate.ethstaker.cc +``` + +The command above runs Grandine on Mainnet. For other networks, set the `--network` and `--checkpoint-sync-url` options accordingly. See the [Grandine documentation][grandine] and [public checkpoint sync endpoints][checkpoint-sync-endpoints]. + +### Lighthouse + +```bash +lighthouse bn \ + --network mainnet \ + --execution-endpoint http://localhost:8551 \ + --execution-jwt path/to/jwt.hex \ + --checkpoint-sync-url https://mainnet.checkpoint.sigp.io \ + --http +``` + +The command above runs Lighthouse on Mainnet. For other networks, set the `--network` and `--checkpoint-sync-url` options accordingly. See the [Lighthouse documentation][lighthouse] and [public checkpoint sync endpoints][checkpoint-sync-endpoints]. + +### Lodestar + +```bash +lodestar beacon \ + --network mainnet \ + --jwt-secret path/to/jwt.hex \ + --checkpointSyncUrl https://beaconstate-mainnet.chainsafe.io +``` + +The command above runs Lodestar on Mainnet. For other networks, set the `--network` and `--checkpointSyncUrl` options accordingly. See the [Lodestar documentation][lodestar] and [public checkpoint sync endpoints][checkpoint-sync-endpoints]. + +### Nimbus + +```bash +./run-mainnet-beacon-node.sh \ + --web3-url=http://127.0.0.1:8551 \ + --jwt-secret=path/to/jwt.hex +``` + +The command above runs Numbus on Mainnet without checkpoint sync. For checkpoint sync, see [Sync from a trusted node](https://nimbus.guide/trusted-node-sync.html). For other networks, see the [Nimbus documentation][nimbus]. + +### Prysm + +```bash +./prysm.sh beacon-chain \ + --mainnet \ + --execution-endpoint=http://localhost:8551 \ + --jwt-secret=path/to/jwt.hex \ + --checkpoint-sync-url=https://beaconstate.ethstaker.cc \ + --genesis-beacon-api-url=https://beaconstate.ethstaker.cc +``` + +The command above runs Prysm on Mainnet. For other networks, replace the `--mainnet` and set `--checkpoint-sync-url` and `--genesis-beacon-api-url` options accordingly. See the [Prysm documentation][prysm] and [public checkpoint sync endpoints][checkpoint-sync-endpoints]. + +### Teku + +```bash +teku \ + --network=mainnet \ + --ee-endpoint=http://localhost:8551 \ + --ee-jwt-secret-file=path/to/jwt.hex \ + --metrics-enabled=true \ + --rest-api-enabled=true \ + --initial-state=https://beaconstate.ethstaker.cc +``` + +The command above runs Teku on Mainnet. For other networks, set the `--network` and `--initial-state` options accordingly. See the [Teku documentation][teku] and [public checkpoint sync endpoints][checkpoint-sync-endpoints]. + +## Running Nethermind + +Once your consensus client is up and running, you can start Nethermind with the _same_ JWT secret provided to the consensus client: + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + --jsonrpc-jwtsecretfile path/to/jwt.hex +``` + +For more info about running a node with Nethermind, see [Running a node](running-node.md). + +[checkpoint-sync-endpoints]: https://eth-clients.github.io/checkpoint-sync-endpoints +[grandine]: https://docs.grandine.io +[lighthouse]: https://lighthouse-book.sigmaprime.io +[lodestar]: https://chainsafe.github.io/lodestar +[nimbus]: https://nimbus.guide +[prysm]: https://docs.prylabs.network +[teku]: https://docs.teku.consensys.net diff --git a/versioned_docs/version-1.36.0/get-started/running-node/l2-networks.md b/versioned_docs/version-1.36.0/get-started/running-node/l2-networks.md new file mode 100644 index 0000000000..9ae8b4aca8 --- /dev/null +++ b/versioned_docs/version-1.36.0/get-started/running-node/l2-networks.md @@ -0,0 +1,234 @@ +--- +title: Layer 2 networks +sidebar_position: 2 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +:::info Before you begin + +- Running a Layer 2 (L2) node requires access to a Layer (L1) node—either on-premises or an external RPC provider. If you also plan to [run an L1 node with Nethermind](running-node.md#ethereum), note that you will need two Nethermind instances—one for the L1 node and another for the L2 node. +- If both the L1 and L2 nodes run on the same machine, ensure they use different ports and data directories. + +::: + +## OP Stack + +An [Optimism node](https://docs.optimism.io/builders/node-operators/architecture) consists of two parts: a Rollup node, analogous to a consensus client in Ethereum, paired with an L2 execution client. The official Rollup node is `op-node`, developed and maintained by the Optimism Collective. Alternatively, Nethermind is also bundled with its own Rollup node, developed and maintained by the Nethermind team. + +### Running Nethermind with `op-node` + +:::warning Important +Similar to the L1 node, the L2 instance of Nethermind also requires a [properly configured](consensus-clients.md#configuring-json-rpc-interface) Engine API to communicate to `op-node`. + +::: + + + + +:::info Note +For OP Mainnet, the L1 node must be running on Ethereum Mainnet. +::: + +To run Nethermind on the OP Mainnet, use the following command: + +```bash +nethermind \ + -c op-mainnet \ + --data-dir path/to/data/dir \ + --jsonrpc-jwtsecretfile path/to/jwt.hex +``` + +Below is a sample command to run `op-node` paired with Nethermind, assuming they both are running on the same machine: + +```bash +export L1_RPC_URL=... # The URL of the L1 node RPC interface +export L1_BEACON_URL=... # The URL of the L1 node Beacon interface + +op-node \ + --l1=$L1_RPC_URL \ + --l1.rpckind=standard \ + --l1.beacon=$L1_BEACON_URL \ + --l2=http://localhost:8551 \ + --l2.jwt-secret=path/to/jwt.hex \ + --syncmode=execution-layer \ + --network=op-mainnet +``` + + + + +:::info Note +For OP Sepolia, the L1 node must be running on Sepolia. +::: + +To run Nethermind on the OP Sepolia, use the following command: + +```bash +nethermind \ + -c op-sepolia \ + --data-dir path/to/data/dir \ + --jsonrpc-jwtsecretfile path/to/jwt.hex +``` + +Below is a sample command to run `op-node` paired with Nethermind, assuming they both are running on the same machine: + +```bash +export L1_RPC_URL=... # The URL of the L1 node RPC interface +export L1_BEACON_URL=... # The URL of the L1 node Beacon interface + +op-node \ + --l1=$L1_RPC_URL \ + --l1.rpckind=standard \ + --l1.beacon=$L1_BEACON_URL \ + --l2=http://localhost:8551 \ + --l2.jwt-secret=path/to/jwt.hex \ + --syncmode=execution-layer \ + --network=op-sepolia +``` + + + + +For available settings, see [`op-node` configuration options](https://docs.optimism.io/builders/node-operators/configuration/consensus-config). + +### Running Nethermind with the built-in Rollup node + +Instead of running a separate `op-node` instance alongside Nethermind, it's enough to run only Nethermind with Rollup node enabled. That simplifies the setup and configuration, and just like the `op-node`, Nethermind will need to know about an L1 RPC and Beacon nodes. + + + + +:::info Note +For OP Mainnet, the L1 node must be running on Ethereum Mainnet. +::: + +To run Nethermind on the OP Mainnet using the built-in Rollup node, use the following command: + +```bash +export L1_RPC_URL=... # The URL of the L1 node RPC interface +export L1_BEACON_URL=... # The URL of the L1 node Beacon interface + +nethermind \ + -c op-mainnet \ + --data-dir path/to/data/dir \ + --jsonrpc-jwtsecretfile path/to/jwt.hex \ + --optimism-clenabled \ + --optimism-l1ethapiendpoint $L1_RPC_URL \ + --optimism-l1beaconapiendpoint $L1_BEACON_URL +``` + + + + +:::info Note +For OP Sepolia, the L1 node must be running on Sepolia. +::: + +To run Nethermind on the OP Sepolia using the built-in Rollup node, use the following command: + +```bash +nethermind \ + -c op-sepolia \ + --data-dir path/to/data/dir \ + --jsonrpc-jwtsecretfile path/to/jwt.hex \ + --optimism-clenabled \ + --optimism-l1ethapiendpoint $L1_RPC_URL \ + --optimism-l1beaconapiendpoint $L1_BEACON_URL +``` + + + + +**See also** + +- [Optimism configuration](../../fundamentals/configuration.md#optimism) +- [Run a node in the Superchain](https://docs.optimism.io/builders/node-operators/rollup-node) + +## Taiko + +A [Taiko node](https://docs.taiko.xyz/taiko-alethia-protocol/protocol-architecture/taiko-alethia-nodes) consists of two parts: [taiko-client](https://github.com/taikoxyz/taiko-mono/tree/main/packages/taiko-client#readme), analogous to a consensus client in Ethereum paired with an L2 execution client. + +:::warning Important +Similar to the L1 node, the L2 instance of Nethermind also requires a [properly configured](consensus-clients.md#configuring-json-rpc-interface) Engine API to communicate to taiko-client. +::: + + + + +:::info Note +For Taiko Alethia, the L1 node must be running on Ethereum Mainnet. +::: + +To run Nethermind on Taiko Alethia, use the following command: + +```bash +nethermind \ + -c taiko-alethia \ + --data-dir path/to/data/dir \ + --jsonrpc-jwtsecretfile path/to/jwt.hex +``` + +Below is a sample command to run taiko-client paired with Nethermind, assuming they both are running on the same machine: + +```bash +export L1_WS_URL=... # The URL of the L1 node WebSocket interface +export L1_BEACON_URL=... # The URL of the L1 node Beacon interface + +taiko-client driver \ + --l1.ws $L1_WS_URL \ + --l1.beacon $L1_BEACON_URL \ + --l2.ws ws://localhost:8545 \ + --l2.auth http://localhost:8551 \ + --taikoInbox 0x06a9Ab27c7e2255df1815E6CC0168d7755Feb19a \ + --taikoAnchor 0x1670000000000000000000000000000000010001 \ + --jwtSecret path/to/jwt.hex \ + --p2p.sync \ + --p2p.checkPointSyncUrl https://rpc.mainnet.taiko.xyz +``` + +For more information, see [Run a node for Taiko Alethia](https://docs.taiko.xyz/guides/node-operators/run-a-node-for-taiko-alethia/). + + + + +:::info Note +For Taiko Hoodi, the L1 node must be running on Hoodi. +::: + +To run Nethermind on Taiko Hoodi, use the following command: + +```bash +nethermind \ + -c taiko-hoodi \ + --data-dir path/to/data/dir \ + --jsonrpc-jwtsecretfile path/to/jwt.hex +``` + +Below is a sample command to run taiko-client paired with Nethermind, assuming they both are running on the same machine: + +```bash +export L1_WS_URL=... # The URL of the L1 node WebSocket interface +export L1_BEACON_URL=... # The URL of the L1 node Beacon interface + +taiko-client driver \ + --l1.ws $L1_WS_URL \ + --l1.beacon $L1_BEACON_URL \ + --l2.ws ws://localhost:8545 \ + --l2.auth http://localhost:8551 \ + --taikoInbox 0x50A576435E2D9c179124D657d804eb56A10b6999 \ + --taikoAnchor 0x1670130000000000000000000000000000010001 \ + --jwtSecret path/to/jwt.hex \ + --p2p.sync \ + --p2p.checkPointSyncUrl https://rpc.hoodi.taiko.xyz +``` + +For more information, see [Run a node for Taiko Hoodi](https://docs.taiko.xyz/guides/node-operators/run-a-node-for-taiko-hoodi/). + + + + +**See also** + +- [Enable a prover](https://docs.taiko.xyz/guides/node-operators/enable-a-prover/) diff --git a/versioned_docs/version-1.36.0/get-started/running-node/running-node.md b/versioned_docs/version-1.36.0/get-started/running-node/running-node.md new file mode 100644 index 0000000000..199001c324 --- /dev/null +++ b/versioned_docs/version-1.36.0/get-started/running-node/running-node.md @@ -0,0 +1,119 @@ +--- +title: Running a node +sidebar_position: 0 +--- + +:::info Before you begin + +- Ensure Nethermind is installed according to the [installation guide](../../get-started/installing-nethermind.md). +- Check out the [security considerations](../../fundamentals/security.md) before using Nethermind for critical operations. + +::: + +In addition to the foundational Layer 1 networks, Nethermind supports various Layer 2 networks and sidechains out of the box. Running Nethermind on a supported network is as simple as specifying the respective [configuration file](../../fundamentals/configuration.md#configuration-file) with the [`-c, --config`](../../fundamentals/configuration.md#config) option. + +:::tip +We urge you to always [explicitly specify](../../fundamentals/configuration.md#data-dir) Nethermind's data directory outside of the Nethermind installation directory to avoid data loss during upgrades or reinstallation. The data directory must be on a disk with sufficient space and read/write permissions. +::: + +## Ethereum + +**Supported networks** + +- [Mainnet](https://ethereum.org/en/developers/docs/networks/#ethereum-mainnet) - configurations: `mainnet` `mainnet_archive` +- [Hoodi](https://hoodi.ethpandaops.io) (testnet) - configurations: `hoodi` `hoodi_archive` +- [Sepolia](https://sepolia.ethpandaops.io) (testnet) - configurations: `sepolia` `sepolia_archive` + +:::tip +We highly recommend checking out the [Spin up your own Ethereum node](https://ethereum.org/en/developers/docs/nodes-and-clients/run-a-node/) guide by the Ethereum Foundation. +::: + +:::warning Important +A [consensus client](consensus-clients.md) of your choice must be running before you start Nethermind. +::: + +For instance, to launch the client with the default configuration for the Mainnet and custom data directory, run: + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + --jsonrpc-jwtsecretfile path/to/jwt.hex +``` + +For more info about configuring the JWT secret, see [Configuring JSON-RPC interface](./consensus-clients.md#configuring-json-rpc-interface). + +For archive (aka full) nodes, Nethermind provides separate configuration files prefixed with `_archive`. Thus, to run Nethermind on the Mainnet as an archive node, simply change `mainnet` to `mainnet_archive` in the above command as follows: + +```bash +nethermind \ + -c mainnet_archive \ + --data-dir path/to/data/dir \ + --jsonrpc-jwtsecretfile path/to/jwt.hex +``` + +Archive nodes are generally more resource-demanding. If you intend to run one, we recommend checking out the [hardware requirements](../system-requirements.md#hardware-requirements). + +## Gnosis Chain + +**Supported networks** + +- [Gnosis](https://docs.gnosischain.com/about/networks/mainnet) - configurations: `gnosis` `gnosis_archive` +- [Chiado](https://docs.gnosischain.com/about/networks/chiado) (testnet) - configurations: `chiado` `chiado_archive` + +To run Nethermind on the Gnosis Chain, see the [Gnosis Chain documentation](https://docs.gnosischain.com/node). + +## OP Stack + +**Supported networks** + +- Optimism + - [OP Mainnet](https://docs.optimism.io/chain/networks#op-mainnet) - configurations: `op-mainnet` `op-mainnet_archive` + - [OP Sepolia](https://docs.optimism.io/chain/networks#op-sepolia) (testnet) - configurations: `op-sepolia` `op-sepolia_archive` +- Base + - [Base Mainnet](https://docs.base.org/network-information/#base-mainnet) - configurations: `base-mainnet` `base-mainnet_archive` + - [Base Sepolia](https://docs.base.org/network-information/#base-testnet-sepolia) (testnet) - configurations: `base-sepolia` `base-sepolia_archive` +- World Chain + - [World Chain Mainnet](https://docs.world.org/world-chain/quick-start/info#world-chain-mainnet) - configurations: `worldchain-mainnet` `worldchain-mainnet_archive` + - [World Chain Sepolia](https://docs.world.org/world-chain/quick-start/info#world-chain-sepolia-testnet) (testnet) - configurations: `worldchain-sepolia` `worldchain-sepolia_archive` + +To run Nethermind on an OP Stack network, see [Layer 2 networks](l2-networks.md#op-stack). + +## Taiko + +**Supported networks** + +- [Taiko Alethia](https://docs.taiko.xyz/network-reference/rpc-configuration#taiko-alethia) - configurations: `taiko-alethia` +- [Taiko Hoodi](https://docs.taiko.xyz/network-reference/rpc-configuration#taiko-hoodi) (testnet) - configurations: `taiko-hoodi` + +To run Nethermind on Taiko, see [Layer 2 networks](l2-networks.md#taiko). + +## Linea + +**Supported networks** + +- [Linea Mainnet](https://docs.linea.build/get-started/build/network-info) - configurations: `linea-mainnet` `linea-mainnet_archive` +- [Linea Sepolia](https://docs.linea.build/get-started/build/network-info) (testnet) - configurations: `linea-sepolia` `linea-sepolia_archive` + +To run Nethermind on Linea, use the respective network configuration. For instance: + +```bash +nethermind \ + -c linea-mainnet \ + --data-dir path/to/data/dir +``` + +For more info about running a Linea node, see the [Linea documentation](https://docs.linea.build/get-started/how-to/run-a-node). + +## Energy Web Chain + +**Supported networks** + +- [Energy Web](https://docs-launchpad.energyweb.org/ewc-ecosystem/ewc-guides-and-tutorials/developing-on-the-volta-test-network-and-main-network-energy-web-chain#developing-on-energy-web-main-network) - configurations: `energyweb` `energyweb_archive` +- [Volta](https://docs-launchpad.energyweb.org/ewc-ecosystem/ewc-guides-and-tutorials/developing-on-the-volta-test-network-and-main-network-energy-web-chain#developing-on-volta-test-network) (testnet) - configurations: `volta` `volta_archive` + +:::info +As the Energy Web Chain is an Aura-based network, running a node does not require a consensus client. +::: + +To run Nethermind on the Energy Web Chain, see the [Energy Web Chain documentation](https://energy-web-foundation.gitbook.io/energy-web/ew-dos-technology-components-2023/trust-layer-energy-web-chain/ewc-guides-and-tutorials/running-a-local-node). diff --git a/versioned_docs/version-1.36.0/get-started/system-requirements.md b/versioned_docs/version-1.36.0/get-started/system-requirements.md new file mode 100644 index 0000000000..dff389a307 --- /dev/null +++ b/versioned_docs/version-1.36.0/get-started/system-requirements.md @@ -0,0 +1,63 @@ +--- +title: System requirements +sidebar_position: 1 +--- + +## Supported operating systems + +Nethermind supports a broad range of modern operating systems (64-bit-only) including but not limited to: + +- **Linux** + - Alpine 3.19+ + - CentOS Stream 9+ + - Debian 12+ + - Fedora 40+ + - openSUSE 15+ + - RHEL 8+ + - SLES 15+ + - Ubuntu 22.04+ +- **Windows** + - Windows 10+ + - Windows Server 2012+ +- **macOS** 13+ + +## Hardware requirements + +Suggested requirements can be found below. + +| Network | Memory | CPU cores | +| ------------------- | :----: | :-------: | +| **Mainnet** | 16 GB | 4 | +| **Mainnet archive** | 128 GB | 8 | +| **Gnosis** | 16 GB | 2 | +| **Energy Web** | 8 GB | 2 | +| **Volta** | 8 GB | 2 | + +### Disk requirements + +As of October 2024, running an Ethereum Mainnet node with Nethermind's default configuration requires at least 2 TB of storage space. Nethermind itself takes around 1 TB, leaving the rest for the needs of the consensus client. Choosing a 2 TB disk is a comfortable option for most common Mainnet node usage patterns, including staking. Nonetheless, we recommend delving further into the topic to gain a comprehensive understanding of disk growth and usage. + +#### Database growth + +The database size increases over time as the Ethereum chain grows. The database is in its most optimal state immediately after a sync or full pruning. To maintain this process, occasional resyncing or pruning of the node is necessary to bring it back to its optimal database size. For more info on managing node disk usage growth, see [how to reduce database size](../fundamentals/database.md#reducing-database-size).\ +A larger disk space allocation reduces the need for frequent maintenance and alleviates concerns about the chain outgrowing the available space. It's worth noting that the only drawback of running a smaller disk is the requirement for more regular resyncing or pruning. + +For more up-to-date details about storage requirements for a specific network, see [Database size](../fundamentals/database.md#database-size). + +#### Disk speed + +The speed of the disk often acts as a bottleneck for the node's performance. It is crucial for optimizing your validator's performance rewards and the syncing process. We highly recommend a disk with a minimum of 10,000 IOPS for both write and read operations. Slower disks may hinder your ability to synchronize the blockchain successfully. + +:::tip +Choosing SSD over spinning disks is essential for running a node. To choose a specific disk model, check out [Great and less great SSDs for Ethereum nodes](https://gist.github.com/yorickdowne/f3a3e79a573bf35767cd002cc977b038#the-good). +::: + +#### Sync modes and disk usage + +A node can be run using different syncing options, and each option has different characteristics of disk space usage. + +- **Archive node.** This mode stores the full historical state for all blocks. As of July 2023, an archive node requires at least 14 TB of disk space, and it grows by approximately 60 GB per week. +- **Ancient barriers.** Nethermind allows you to specify how many old block bodies and receipts you want to store. By default, Nethermind sets the ancient barrier at block 11052984. This block is significant because it marks the deployment of the deposit contract required for consensus client deposit scanning for validators. Peers and JSON-RPC requests will not have access to block bodies and receipts older than the ancient barrier. +- **Non-validator mode.** This mode drops all historical receipts and bodies, but it cannot be used for validation. + +For more details, see [sync modes](../fundamentals/sync.md). diff --git a/versioned_docs/version-1.36.0/interacting/_category_.json b/versioned_docs/version-1.36.0/interacting/_category_.json new file mode 100644 index 0000000000..50750ee5ef --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/_category_.json @@ -0,0 +1,4 @@ +{ + "position": 3, + "label": "Interacting with Nethermind" +} diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/_category_.json b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/_category_.json new file mode 100644 index 0000000000..7b79762df6 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/_category_.json @@ -0,0 +1,4 @@ +{ + "position": 1, + "label": "JSON-RPC namespaces" +} diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/admin.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/admin.md new file mode 100644 index 0000000000..387448c606 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/admin.md @@ -0,0 +1,769 @@ +--- +title: admin namespace +sidebar_label: admin +sidebar_position: 0 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### admin_addPeer + +Adds given node. + + + + +1. `enode`: _string_ + +2. `addToStaticNodes`: _boolean_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_addPeer", + "params": [enode, addToStaticNodes] + }' +``` + + + + +Added node + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### admin_addTrustedPeer + +Adds given node as a trusted peer, allowing the node to always connect even if slots are full. + + + + +1. `enode`: _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_addTrustedPeer", + "params": [enode] + }' +``` + + + + +Boolean indicating success + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### admin_dataDir + +Returns the absolute path to the node's data directory. + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_dataDir", + "params": [] + }' +``` + + + + +The data directory path as a string. + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### admin_exportHistory + +Exports a range of historic block in era1 format. + + + + +1. `destinationPath`: _string_ + +2. `from`: _string_ (hex integer) + +3. `to`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_exportHistory", + "params": [destinationPath, from, to] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### admin_importHistory + +Import a range of historic block from era1 directory. + + + + +1. `sourcePath`: _string_ + +2. `from`: _string_ (hex integer) + +3. `to`: _string_ (hex integer) + +4. `accumulatorFile`: _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_importHistory", + "params": [sourcePath, from, to, accumulatorFile] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### admin_isStateRootAvailable + +True if state root for the block is available + + + + +1. `block`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_isStateRootAvailable", + "params": [block] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### admin_nodeInfo + +Displays relevant information about this node. + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_nodeInfo", + "params": [] + }' +``` + + + + +Information about this node + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `enode`: _string_ + - `id`: _string_ + - `ip`: _string_ + - `listenAddress`: _string_ + - `name`: _string_ + - `ports`: _object_ + - `discovery`: _string_ (hex integer) + - `listener`: _string_ (hex integer) + - `protocols`: map of _object_ + - `chainId`: _string_ (hex integer) + - `config`: _object_ + - `beaconChainGenesisTimestamp`: _string_ (hex integer) + - `blobSchedule`: array of _object_ + - `baseFeeUpdateFraction`: _string_ (hex integer) + - `max`: _string_ (hex integer) + - `target`: _string_ (hex integer) + - `timestamp`: _string_ (hex integer) + - `depositContractAddress`: _string_ (address) + - `eip1014Transition`: _string_ (hex integer) + - `eip1052Transition`: _string_ (hex integer) + - `eip1108Transition`: _string_ (hex integer) + - `eip1153TransitionTimestamp`: _string_ (hex integer) + - `eip1283DisableTransition`: _string_ (hex integer) + - `eip1283ReenableTransition`: _string_ (hex integer) + - `eip1283Transition`: _string_ (hex integer) + - `eip1344Transition`: _string_ (hex integer) + - `eip140Transition`: _string_ (hex integer) + - `eip145Transition`: _string_ (hex integer) + - `eip150Transition`: _string_ (hex integer) + - `eip152Transition`: _string_ (hex integer) + - `eip1559BaseFeeInitialValue`: _string_ (hex integer) + - `eip1559BaseFeeMaxChangeDenominator`: _string_ (hex integer) + - `eip1559BaseFeeMinValue`: _string_ (hex integer) + - `eip1559BaseFeeMinValueTransition`: _string_ (hex integer) + - `eip1559ElasticityMultiplier`: _string_ (hex integer) + - `eip1559FeeCollectorTransition`: _string_ (hex integer) + - `eip1559Transition`: _string_ (hex integer) + - `eip155Transition`: _string_ (hex integer) + - `eip160Transition`: _string_ (hex integer) + - `eip161abcTransition`: _string_ (hex integer) + - `eip161dTransition`: _string_ (hex integer) + - `eip1706Transition`: _string_ (hex integer) + - `eip1884Transition`: _string_ (hex integer) + - `eip2028Transition`: _string_ (hex integer) + - `eip211Transition`: _string_ (hex integer) + - `eip214Transition`: _string_ (hex integer) + - `eip2200Transition`: _string_ (hex integer) + - `eip2315Transition`: _string_ (hex integer) + - `eip2537Transition`: _string_ (hex integer) + - `eip2537TransitionTimestamp`: _string_ (hex integer) + - `eip2565Transition`: _string_ (hex integer) + - `eip2929Transition`: _string_ (hex integer) + - `eip2930Transition`: _string_ (hex integer) + - `eip2935ContractAddress`: _string_ (address) + - `eip2935RingBufferSize`: _string_ (hex integer) + - `eip2935TransitionTimestamp`: _string_ (hex integer) + - `eip3198Transition`: _string_ (hex integer) + - `eip3529Transition`: _string_ (hex integer) + - `eip3541Transition`: _string_ (hex integer) + - `eip3607Transition`: _string_ (hex integer) + - `eip3651TransitionTimestamp`: _string_ (hex integer) + - `eip3855TransitionTimestamp`: _string_ (hex integer) + - `eip3860TransitionTimestamp`: _string_ (hex integer) + - `eip4788ContractAddress`: _string_ (address) + - `eip4788TransitionTimestamp`: _string_ (hex integer) + - `eip4844BlobGasPriceUpdateFraction`: _string_ (hex integer) + - `eip4844FeeCollectorTransitionTimestamp`: _string_ (hex integer) + - `eip4844MinBlobGasPrice`: _string_ (hex integer) + - `eip4844TransitionTimestamp`: _string_ (hex integer) + - `eip4895TransitionTimestamp`: _string_ (hex integer) + - `eip5656TransitionTimestamp`: _string_ (hex integer) + - `eip6110TransitionTimestamp`: _string_ (hex integer) + - `eip658Transition`: _string_ (hex integer) + - `eip6780TransitionTimestamp`: _string_ (hex integer) + - `eip7002ContractAddress`: _string_ (address) + - `eip7002TransitionTimestamp`: _string_ (hex integer) + - `eip7251ContractAddress`: _string_ (address) + - `eip7251TransitionTimestamp`: _string_ (hex integer) + - `eip7594TransitionTimestamp`: _string_ (hex integer) + - `eip7623TransitionTimestamp`: _string_ (hex integer) + - `eip7692TransitionTimestamp`: _string_ (hex integer) + - `eip7702TransitionTimestamp`: _string_ (hex integer) + - `eip7823TransitionTimestamp`: _string_ (hex integer) + - `eip7825TransitionTimestamp`: _string_ (hex integer) + - `eip7883TransitionTimestamp`: _string_ (hex integer) + - `eip7907TransitionTimestamp`: _string_ (hex integer) + - `eip7918TransitionTimestamp`: _string_ (hex integer) + - `eip7934MaxRlpBlockSize`: _string_ (hex integer) + - `eip7934TransitionTimestamp`: _string_ (hex integer) + - `eip7939TransitionTimestamp`: _string_ (hex integer) + - `eip7951TransitionTimestamp`: _string_ (hex integer) + - `eip7Transition`: _string_ (hex integer) + - `feeCollector`: _string_ (address) + - `forkBlock`: _string_ (hex integer) + - `forkCanonHash`: _string_ (hash) + - `gasLimitBoundDivisor`: _string_ (hex integer) + - `maxCodeSize`: _string_ (hex integer) + - `maxCodeSizeTransition`: _string_ (hex integer) + - `maxCodeSizeTransitionTimestamp`: _string_ (hex integer) + - `maximumExtraDataSize`: _string_ (hex integer) + - `mergeForkIdTransition`: _string_ (hex integer) + - `minGasLimit`: _string_ (hex integer) + - `minHistoryRetentionEpochs`: _string_ (hex integer) + - `opGraniteTransitionTimestamp`: _string_ (hex integer) + - `opHoloceneTransitionTimestamp`: _string_ (hex integer) + - `opIsthmusTransitionTimestamp`: _string_ (hex integer) + - `registrar`: _string_ (address) + - `rip7212TransitionTimestamp`: _string_ (hex integer) + - `rip7728TransitionTimestamp`: _string_ (hex integer) + - `terminalPoWBlockNumber`: _string_ (hex integer) + - `terminalTotalDifficulty`: _string_ (hex integer) + - `transactionPermissionContract`: _string_ (address) + - `transactionPermissionContractTransition`: _string_ (hex integer) + - `validateChainIdTransition`: _string_ (hex integer) + - `validateReceiptsTransition`: _string_ (hex integer) + - `difficulty`: _string_ (hex integer) + - `genesisHash`: _string_ (hash) + - `headHash`: _string_ (hash) + - `networkId`: _string_ (hex integer) + + + + +### admin_peers + +Displays a list of connected peers including information about them (`clientId`, `host`, `port`, `address`, `isBootnode`, `isStatic`, `enode`). + + + + +1. `includeDetails`: _boolean_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_peers", + "params": [includeDetails] + }' +``` + + + + +List of connected peers including information + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `caps`: array of _object_ + - `protocolCode`: _string_ + - `version`: _string_ (hex integer) + - `clientType`: _integer_ + - `enode`: _string_ + - `enr`: _string_ + - `ethDetails`: _string_ + - `id`: _object_ + - `address`: _string_ (address) + - `bytes`: _string_ (hex data) + - `hash`: _string_ (hash) + - `prefixedBytes`: _string_ (hex data) + - `lastSignal`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `date`: _object_ + + - `day`: _string_ (hex integer) + - `dayOfWeek`: _integer_ + - `dayOfYear`: _string_ (hex integer) + - `hour`: _string_ (hex integer) + - `kind`: _integer_ + - `microsecond`: _string_ (hex integer) + - `millisecond`: _string_ (hex integer) + - `minute`: _string_ (hex integer) + - `month`: _string_ (hex integer) + - `nanosecond`: _string_ (hex integer) + - `second`: _string_ (hex integer) + - `ticks`: _string_ (hex integer) + - `timeOfDay`: _object_ + - `days`: _string_ (hex integer) + - `hours`: _string_ (hex integer) + - `microseconds`: _string_ (hex integer) + - `milliseconds`: _string_ (hex integer) + - `minutes`: _string_ (hex integer) + - `nanoseconds`: _string_ (hex integer) + - `seconds`: _string_ (hex integer) + - `ticks`: _string_ (hex integer) + - `totalDays`: _object_ + - `totalHours`: _object_ + - `totalMicroseconds`: _object_ + - `totalMilliseconds`: _object_ + - `totalMinutes`: _object_ + - `totalNanoseconds`: _object_ + - `totalSeconds`: _object_ + - `year`: _string_ (hex integer) + - `name`: _string_ + - `network`: _object_ + - `inbound`: _boolean_ + - `localAddress`: _string_ + - `localHost`: _string_ + - `remoteAddress`: _string_ + - `static`: _boolean_ + - `trusted`: _boolean_ + - `protocols`: map of _object_ + + + + +### admin_prune + +Runs full pruning if enabled. + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_prune", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _integer_ + + + + +### admin_removePeer + +Removes given node. + + + + +1. `enode`: _string_ + +2. `removeFromStaticNodes`: _boolean_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_removePeer", + "params": [enode, removeFromStaticNodes] + }' +``` + + + + +Removed node + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### admin_removeTrustedPeer + +Removes the given node from the trusted peers list. + + + + +1. `enode`: _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_removeTrustedPeer", + "params": [enode] + }' +``` + + + + +Boolean indicating success + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### admin_subscribe + +Subscribes to a particular event over WebSocket. For every event that matches the subscription, a notification with event details and subscription id is sent to a client. + + + + +1. `subscriptionName`: _string_ + +2. `args`: _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_subscribe", + "params": [subscriptionName, args] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### admin_unsubscribe + +Unsubscribes from a subscription. + + + + +1. `subscriptionId`: _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_unsubscribe", + "params": [subscriptionId] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### admin_verifyTrie + +Runs VerifyTrie. + + + + +1. `block`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "admin_verifyTrie", + "params": [block] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/clique.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/clique.md new file mode 100644 index 0000000000..757d97e2ea --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/clique.md @@ -0,0 +1,509 @@ +--- +title: clique namespace +sidebar_label: clique +sidebar_position: 1 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### clique_discard + +This method drops a currently running proposal. The signer will not cast further votes (either for or against) the address. + + + + +1. `signer`: _string_ (address) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "clique_discard", + "params": [signer] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### clique_getBlockSigner + +Retrieves the signer of the block with the given hash. Returns error of a block with the given hash does not exist. + + + + +1. `hash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "clique_getBlockSigner", + "params": [hash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (address) + + + + +### clique_getSigners + +Retrieves the list of authorized signers. + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "clique_getSigners", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _string_ (address) + + + + +### clique_getSignersAnnotated + +Retrieves the list of authorized signers but with signer names instead of addresses + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "clique_getSignersAnnotated", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _string_ + + + + +### clique_getSignersAtHash + +Retrieves the list of authorized signers at the specified block by hash. + + + + +1. `hash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "clique_getSignersAtHash", + "params": [hash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _string_ (address) + + + + +### clique_getSignersAtHashAnnotated + +Retrieves the list of authorized signers at the specified block by hash but with signer names instead of addresses + + + + +1. `hash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "clique_getSignersAtHashAnnotated", + "params": [hash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _string_ + + + + +### clique_getSignersAtNumber + +Retrieves the list of authorized signers at the specified block by block number. + + + + +1. `number`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "clique_getSignersAtNumber", + "params": [number] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _string_ (address) + + + + +### clique_getSnapshot + +Retrieves a snapshot of all clique state at a given block. + + + + +1. `number`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "clique_getSnapshot", + "params": [number] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `hash`: _string_ (hash) + - `number`: _string_ (hex integer) + - `signerLimit`: _string_ (hex integer) + - `signers`: map of _string_ (hex integer) + - `tally`: map of _object_ + - `authorize`: _boolean_ + - `votes`: _string_ (hex integer) + - `votes`: array of _object_ + - `address`: _string_ (address) + - `authorize`: _boolean_ + - `block`: _string_ (hex integer) + - `signer`: _string_ (address) + + + + +### clique_getSnapshotAtHash + +Retrieves the state snapshot at a given block. + + + + +1. `hash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "clique_getSnapshotAtHash", + "params": [hash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `hash`: _string_ (hash) + - `number`: _string_ (hex integer) + - `signerLimit`: _string_ (hex integer) + - `signers`: map of _string_ (hex integer) + - `tally`: map of _object_ + - `authorize`: _boolean_ + - `votes`: _string_ (hex integer) + - `votes`: array of _object_ + - `address`: _string_ (address) + - `authorize`: _boolean_ + - `block`: _string_ (hex integer) + - `signer`: _string_ (address) + + + + +### clique_produceBlock + +Forces Clique block producer to produce a new block + + + + +1. `parentHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "clique_produceBlock", + "params": [parentHash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### clique_proposals + +Retrieves the current proposals the node is voting on. + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "clique_proposals", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _boolean_ + + + + +### clique_propose + +Adds a new authorization proposal that the signer will attempt to push through. If the `vote` parameter is true, the local signer votes for the given address to be included in the set of authorized signers. With `vote` set to false, the signer is against the address. + + + + +1. `signer`: _string_ (address) + +2. `vote`: _boolean_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "clique_propose", + "params": [signer, vote] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/debug.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/debug.md new file mode 100644 index 0000000000..316cc76260 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/debug.md @@ -0,0 +1,1738 @@ +--- +title: debug namespace +sidebar_label: debug +sidebar_position: 2 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### debug_deleteChainSlice + +Deletes a slice of a chain from the tree on all branches (Nethermind specific). + + + + +1. `startNumber`: _string_ (hex integer) + +2. `force`: _boolean_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_deleteChainSlice", + "params": [startNumber, force] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### debug_getBadBlocks + +Return list of invalid blocks. + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_getBadBlocks", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `block`: _object_ + - `author`: _string_ (address) + - `baseFeePerGas`: _string_ (hex integer) + - `blobGasUsed`: _string_ (hex integer) + - `difficulty`: _string_ (hex integer) + - `excessBlobGas`: _string_ (hex integer) + - `extraData`: _string_ (hex data) + - `gasLimit`: _string_ (hex integer) + - `gasUsed`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `logsBloom`: _string_ (hex data) + - `miner`: _string_ (address) + - `mixHash`: _string_ (hash) + - `nonce`: _string_ (hex data) + - `number`: _string_ (hex integer) + - `parentBeaconBlockRoot`: _string_ (hash) + - `parentHash`: _string_ (hash) + - `receiptsRoot`: _string_ (hash) + - `requestsHash`: _string_ (hash) + - `sha3Uncles`: _string_ (hash) + - `signature`: _string_ (hex data) + - `size`: _string_ (hex integer) + - `stateRoot`: _string_ (hash) + - `step`: _string_ (hex integer) + - `timestamp`: _string_ (hex integer) + - `totalDifficulty`: _string_ (hex integer) + - `transactions`: array of _object_ + - `transactionsRoot`: _string_ (hash) + - `uncles`: array of _string_ (hash) + - `withdrawals`: array of _object_ + - `address`: _string_ (address) + - `amountInGwei`: _string_ (hex integer) + - `amountInWei`: _string_ (hex integer) + - `index`: _string_ (hex integer) + - `validatorIndex`: _string_ (hex integer) + - `withdrawalsRoot`: _string_ (hash) + - `hash`: _string_ (hash) + - `rlp`: _string_ (hex data) + + + + +### debug_getBlockRlp + +Retrieves a block in the RLP-serialized form. + + + + +1. `number`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_getBlockRlp", + "params": [number] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex data) + + + + +### debug_getBlockRlpByHash + +Retrieves a block in the RLP-serialized form. + + + + +1. `hash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_getBlockRlpByHash", + "params": [hash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex data) + + + + +### debug_getChainLevel + +Retrieves a representation of tree branches on a given chain level (Nethermind specific). + + + + +1. `number`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_getChainLevel", + "params": [number] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `blockInfos`: array of _object_ + - `blockHash`: _string_ (hash) + - `isFinalized`: _boolean_ + - `totalDifficulty`: _string_ (hex integer) + - `wasProcessed`: _boolean_ + - `hasBlockOnMainChain`: _boolean_ + + + + +### debug_getConfigValue + +Retrieves the Nethermind configuration value, e.g. JsonRpc.Enabled + + + + +1. `category`: _string_ + +2. `name`: _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_getConfigValue", + "params": [category, name] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + + + + +### debug_getRawBlock + +Get Raw Block format. + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_getRawBlock", + "params": [blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex data) + + + + +### debug_getRawHeader + +Get Raw Header format. + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_getRawHeader", + "params": [blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex data) + + + + +### debug_getRawReceipts + +Get Raw Receipt format. + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_getRawReceipts", + "params": [blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _string_ (hex data) + + + + +### debug_getRawTransaction + +Get Raw Transaction format. + + + + +1. `transactionHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_getRawTransaction", + "params": [transactionHash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### debug_getSyncStage + +Retrives Nethermind Sync Stage, With extra Metadata + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_getSyncStage", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `currentStage`: _string_ + + + + +### debug_insertReceipts + +Insert receipts for the block after verifying receipts root correctness. + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +2. `receiptForRpc`: array of _object_ + - `blobGasPrice`: _string_ (hex integer) + - `blobGasUsed`: _string_ (hex integer) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `contractAddress`: _string_ (address) + - `cumulativeGasUsed`: _string_ (hex integer) + - `effectiveGasPrice`: _string_ (hex integer) + - `error`: _string_ + - `from`: _string_ (address) + - `gasUsed`: _string_ (hex integer) + - `logs`: array of _object_ + - `address`: _string_ (address) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `blockTimestamp`: _string_ (hex integer) + - `data`: _string_ (hex data) + - `logIndex`: _string_ (hex integer) + - `removed`: _boolean_ + - `topics`: array of _string_ (hash) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `logsBloom`: _string_ (hex data) + - `root`: _string_ (hash) + - `status`: _string_ (hex integer) + - `to`: _string_ (address) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_insertReceipts", + "params": [blockParameter, receiptForRpc] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### debug_migrateReceipts + +Sets the block number up to which receipts will be migrated to (Nethermind specific). + + + + +1. `from`: _string_ (hex integer) + +2. `to`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_migrateReceipts", + "params": [from, to] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### debug_resetHead + +Updates / resets head block - use only when the node got stuck due to DB / memory corruption (Nethermind specific). + + + + +1. `blockHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_resetHead", + "params": [blockHash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### debug_simulateV1 + +Retrieves geth like traces of the simulated blocks + + + + +1. `payload`: _object_ + - `blockStateCalls`: array of _object_ + - `blockOverrides`: _object_ + - `baseFeePerGas`: _string_ (hex integer) + - `blobBaseFee`: _string_ (hex integer) + - `feeRecipient`: _string_ (address) + - `gasLimit`: _string_ (hex integer) + - `number`: _string_ (hex integer) + - `prevRandao`: _string_ (hash) + - `time`: _string_ (hex integer) + - `calls`: array of _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `returnFullTransactionObjects`: _boolean_ + - `returnFullTransactions`: _boolean_ + - `traceTransfers`: _boolean_ + - `validation`: _boolean_ + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +3. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_simulateV1", + "params": [payload, blockParameter, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `calls`: array of _object_ + - `customTracerResult`: _object_ + - `value`: _object_ + - `entries`: array of _object_ + - `depth`: _string_ (hex integer) + - `error`: _string_ + - `gas`: _string_ (hex integer) + - `gasCost`: _string_ (hex integer) + - `memory`: array of _string_ + - `opcode`: _string_ + - `programCounter`: _string_ (hex integer) + - `stack`: array of _string_ + - `storage`: map of _string_ + - `failed`: _boolean_ + - `gas`: _string_ (hex integer) + - `returnValue`: _string_ (hex data) + - `storagesByDepth`: array of map of _string_ + - `txHash`: _string_ (hash) + - `traces`: array of _object_ + - `customTracerResult`: _object_ + - `value`: _object_ + - `entries`: array of _object_ + - `depth`: _string_ (hex integer) + - `error`: _string_ + - `gas`: _string_ (hex integer) + - `gasCost`: _string_ (hex integer) + - `memory`: array of _string_ + - `opcode`: _string_ + - `programCounter`: _string_ (hex integer) + - `stack`: array of _string_ + - `storage`: map of _string_ + - `failed`: _boolean_ + - `gas`: _string_ (hex integer) + - `returnValue`: _string_ (hex data) + - `storagesByDepth`: array of map of _string_ + - `txHash`: _string_ (hash) + + + + +### debug_standardTraceBadBlockToFile + +This method is similar to the `debug_standardTraceBlockToFile` method, but can be used to obtain information about a block that has been rejected as invalid. + + + + +1. `blockHash`: _string_ (hash) + +2. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_standardTraceBadBlockToFile", + "params": [blockHash, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _string_ + + + + +### debug_standardTraceBlockToFile + +Writes to a file the full stack trace of all invoked opcodes of the transaction specified (or all transactions if not specified) that was included in the block specified. The parent of the block must be present or it will fail. + + + + +1. `blockHash`: _string_ (hash) + +2. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_standardTraceBlockToFile", + "params": [blockHash, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _string_ + + + + +### debug_traceBlock + +Returns the full stack trace of all invoked opcodes of all transactions that were included in the block specified. The parent of the block must be present or it will fail. + + + + +1. `blockRlp`: _string_ (hex data) + +2. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_traceBlock", + "params": [blockRlp, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `customTracerResult`: _object_ + - `value`: _object_ + - `entries`: array of _object_ + - `depth`: _string_ (hex integer) + - `error`: _string_ + - `gas`: _string_ (hex integer) + - `gasCost`: _string_ (hex integer) + - `memory`: array of _string_ + - `opcode`: _string_ + - `programCounter`: _string_ (hex integer) + - `stack`: array of _string_ + - `storage`: map of _string_ + - `failed`: _boolean_ + - `gas`: _string_ (hex integer) + - `returnValue`: _string_ (hex data) + - `storagesByDepth`: array of map of _string_ + - `txHash`: _string_ (hash) + + + + +### debug_traceBlockByHash + +Similar to debug_traceBlock, this method accepts a block hash and replays the block that is already present in the database. + + + + +1. `blockHash`: _string_ (hash) + +2. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_traceBlockByHash", + "params": [blockHash, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `customTracerResult`: _object_ + - `value`: _object_ + - `entries`: array of _object_ + - `depth`: _string_ (hex integer) + - `error`: _string_ + - `gas`: _string_ (hex integer) + - `gasCost`: _string_ (hex integer) + - `memory`: array of _string_ + - `opcode`: _string_ + - `programCounter`: _string_ (hex integer) + - `stack`: array of _string_ + - `storage`: map of _string_ + - `failed`: _boolean_ + - `gas`: _string_ (hex integer) + - `returnValue`: _string_ (hex data) + - `storagesByDepth`: array of map of _string_ + - `txHash`: _string_ (hash) + + + + +### debug_traceBlockByNumber + +Similar to debug_traceBlock, this method accepts a block number as well as "latest" or "finalized" and replays the block that is already present in the database. + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +2. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_traceBlockByNumber", + "params": [blockParameter, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `customTracerResult`: _object_ + - `value`: _object_ + - `entries`: array of _object_ + - `depth`: _string_ (hex integer) + - `error`: _string_ + - `gas`: _string_ (hex integer) + - `gasCost`: _string_ (hex integer) + - `memory`: array of _string_ + - `opcode`: _string_ + - `programCounter`: _string_ (hex integer) + - `stack`: array of _string_ + - `storage`: map of _string_ + - `failed`: _boolean_ + - `gas`: _string_ (hex integer) + - `returnValue`: _string_ (hex data) + - `storagesByDepth`: array of map of _string_ + - `txHash`: _string_ (hash) + + + + +### debug_traceCall + +This method lets you run an eth_call within the context of the given block execution using the final state of parent block as the base. The block can be specified either by hash or by number. It takes the same input object as a eth_call. It returns the same output as debug_traceTransaction. + + + + +1. `call`: _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +3. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_traceCall", + "params": [call, blockParameter, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `customTracerResult`: _object_ + - `value`: _object_ + - `entries`: array of _object_ + - `depth`: _string_ (hex integer) + - `error`: _string_ + - `gas`: _string_ (hex integer) + - `gasCost`: _string_ (hex integer) + - `memory`: array of _string_ + - `opcode`: _string_ + - `programCounter`: _string_ (hex integer) + - `stack`: array of _string_ + - `storage`: map of _string_ + - `failed`: _boolean_ + - `gas`: _string_ (hex integer) + - `returnValue`: _string_ (hex data) + - `storagesByDepth`: array of map of _string_ + - `txHash`: _string_ (hash) + + + + +### debug_traceCallMany + +Executes a list of bundles of transactions without creating transactions on the blockchain and returns their traces + + + + +1. `bundles`: array of _object_ + - `blockOverride`: _object_ + - `baseFeePerGas`: _string_ (hex integer) + - `blobBaseFee`: _string_ (hex integer) + - `feeRecipient`: _string_ (address) + - `gasLimit`: _string_ (hex integer) + - `number`: _string_ (hex integer) + - `prevRandao`: _string_ (hash) + - `time`: _string_ (hex integer) + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `transactions`: array of _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +3. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_traceCallMany", + "params": [bundles, blockParameter, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of array of _object_ + - `customTracerResult`: _object_ + - `value`: _object_ + - `entries`: array of _object_ + - `depth`: _string_ (hex integer) + - `error`: _string_ + - `gas`: _string_ (hex integer) + - `gasCost`: _string_ (hex integer) + - `memory`: array of _string_ + - `opcode`: _string_ + - `programCounter`: _string_ (hex integer) + - `stack`: array of _string_ + - `storage`: map of _string_ + - `failed`: _boolean_ + - `gas`: _string_ (hex integer) + - `returnValue`: _string_ (hex data) + - `storagesByDepth`: array of map of _string_ + - `txHash`: _string_ (hash) + + + + +### debug_traceTransaction + +This method will attempt to run the transaction in the exact same manner as it was executed on the network. It will replay any transaction that may have been executed prior to this one before it will finally attempt to execute the transaction that corresponds to the given hash. + + + + +1. `transactionHash`: _string_ (hash) + +2. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_traceTransaction", + "params": [transactionHash, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `customTracerResult`: _object_ + - `value`: _object_ + - `entries`: array of _object_ + - `depth`: _string_ (hex integer) + - `error`: _string_ + - `gas`: _string_ (hex integer) + - `gasCost`: _string_ (hex integer) + - `memory`: array of _string_ + - `opcode`: _string_ + - `programCounter`: _string_ (hex integer) + - `stack`: array of _string_ + - `storage`: map of _string_ + - `failed`: _boolean_ + - `gas`: _string_ (hex integer) + - `returnValue`: _string_ (hex data) + - `storagesByDepth`: array of map of _string_ + - `txHash`: _string_ (hash) + + + + +### debug_traceTransactionByBlockAndIndex + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +2. `txIndex`: _string_ (hex integer) + +3. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_traceTransactionByBlockAndIndex", + "params": [blockParameter, txIndex, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `customTracerResult`: _object_ + - `value`: _object_ + - `entries`: array of _object_ + - `depth`: _string_ (hex integer) + - `error`: _string_ + - `gas`: _string_ (hex integer) + - `gasCost`: _string_ (hex integer) + - `memory`: array of _string_ + - `opcode`: _string_ + - `programCounter`: _string_ (hex integer) + - `stack`: array of _string_ + - `storage`: map of _string_ + - `failed`: _boolean_ + - `gas`: _string_ (hex integer) + - `returnValue`: _string_ (hex data) + - `storagesByDepth`: array of map of _string_ + - `txHash`: _string_ (hash) + + + + +### debug_traceTransactionByBlockhashAndIndex + + + + +1. `blockHash`: _string_ (hash) + +2. `txIndex`: _string_ (hex integer) + +3. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_traceTransactionByBlockhashAndIndex", + "params": [blockHash, txIndex, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `customTracerResult`: _object_ + - `value`: _object_ + - `entries`: array of _object_ + - `depth`: _string_ (hex integer) + - `error`: _string_ + - `gas`: _string_ (hex integer) + - `gasCost`: _string_ (hex integer) + - `memory`: array of _string_ + - `opcode`: _string_ + - `programCounter`: _string_ (hex integer) + - `stack`: array of _string_ + - `storage`: map of _string_ + - `failed`: _boolean_ + - `gas`: _string_ (hex integer) + - `returnValue`: _string_ (hex data) + - `storagesByDepth`: array of map of _string_ + - `txHash`: _string_ (hash) + + + + +### debug_traceTransactionInBlockByHash + + + + +1. `blockRlp`: _string_ (hex data) + +2. `transactionHash`: _string_ (hash) + +3. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_traceTransactionInBlockByHash", + "params": [blockRlp, transactionHash, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `customTracerResult`: _object_ + - `value`: _object_ + - `entries`: array of _object_ + - `depth`: _string_ (hex integer) + - `error`: _string_ + - `gas`: _string_ (hex integer) + - `gasCost`: _string_ (hex integer) + - `memory`: array of _string_ + - `opcode`: _string_ + - `programCounter`: _string_ (hex integer) + - `stack`: array of _string_ + - `storage`: map of _string_ + - `failed`: _boolean_ + - `gas`: _string_ (hex integer) + - `returnValue`: _string_ (hex data) + - `storagesByDepth`: array of map of _string_ + - `txHash`: _string_ (hash) + + + + +### debug_traceTransactionInBlockByIndex + + + + +1. `blockRlp`: _string_ (hex data) + +2. `txIndex`: _string_ (hex integer) + +3. `options`: _object_ + - `disableMemory`: _boolean_ + - `disableStack`: _boolean_ + - `disableStorage`: _boolean_ + - `enableMemory`: _boolean_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `timeout`: _string_ + - `tracer`: _string_ + - `tracerConfig`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `item`: _object_ + + - `valueKind`: _integer_ + - `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "debug_traceTransactionInBlockByIndex", + "params": [blockRlp, txIndex, options] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `customTracerResult`: _object_ + - `value`: _object_ + - `entries`: array of _object_ + - `depth`: _string_ (hex integer) + - `error`: _string_ + - `gas`: _string_ (hex integer) + - `gasCost`: _string_ (hex integer) + - `memory`: array of _string_ + - `opcode`: _string_ + - `programCounter`: _string_ (hex integer) + - `stack`: array of _string_ + - `storage`: map of _string_ + - `failed`: _boolean_ + - `gas`: _string_ (hex integer) + - `returnValue`: _string_ (hex data) + - `storagesByDepth`: array of map of _string_ + - `txHash`: _string_ (hash) + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/eth.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/eth.md new file mode 100644 index 0000000000..90af5c6e74 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/eth.md @@ -0,0 +1,2410 @@ +--- +title: eth namespace +sidebar_label: eth +sidebar_position: 3 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### eth_blobBaseFee + +Returns the base fee per blob gas in wei + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_blobBaseFee", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_blockNumber + +Returns current block number + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_blockNumber", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_call + +Executes a tx call (does not create a transaction) + + + + +1. `transactionCall`: _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +3. `stateOverride`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_call", + "params": [transactionCall, blockParameter, stateOverride] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### eth_chainId + +Returns ChainID + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_chainId", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_config + +Provides configuration data for the current and next fork + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_config", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `item`: _object_ + + - `item`: _object_ + + - `options`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `propertyNameCaseInsensitive`: _boolean_ + - `parent`: _object_ + + - `root`: _object_ + + + + + +### eth_createAccessList + +Creates an [EIP2930](https://eips.ethereum.org/EIPS/eip-2930) type AccessList for the given transaction + + + + +1. `transactionCall`: _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +3. `optimize`: _boolean_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_createAccessList", + "params": [transactionCall, blockParameter, optimize] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `accessList`: _object_ + - `error`: _string_ + - `gasUsed`: _string_ (hex integer) + + + + +### eth_estimateGas + +Executes a tx call and returns gas used (does not create a transaction) + + + + +1. `transactionCall`: _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +3. `stateOverride`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_estimateGas", + "params": [transactionCall, blockParameter, stateOverride] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_feeHistory + +Returns block fee history. + + + + +1. `blockCount`: _string_ (hex integer) + +2. `newestBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +3. `rewardPercentiles`: array of _object_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_feeHistory", + "params": [blockCount, newestBlock, rewardPercentiles] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `baseFeePerBlobGas`: array of _string_ (hex integer) + - `baseFeePerGas`: array of _string_ (hex integer) + - `blobGasUsedRatio`: array of _object_ + - `gasUsedRatio`: array of _object_ + - `oldestBlock`: _string_ (hex integer) + - `reward`: array of array of _string_ (hex integer) + + + + +### eth_gasPrice + +Returns miner's gas price + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_gasPrice", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_getAccount + +Retrieves Accounts via Address and Blocknumber + + + + +1. `accountAddress`: _string_ (address) + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getAccount", + "params": [accountAddress, blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `balance`: _string_ (hex integer) + - `codeHash`: _object_ + - `bytes`: _object_ + - `isEmpty`: _boolean_ + - `item`: _object_ + - `length`: _string_ (hex integer) + - `bytesAsSpan`: _object_ + - `isEmpty`: _boolean_ + - `item`: _object_ + - `length`: _string_ (hex integer) + - `nonce`: _string_ (hex integer) + - `storageRoot`: _object_ + - `bytes`: _object_ + - `isEmpty`: _boolean_ + - `item`: _object_ + - `length`: _string_ (hex integer) + - `bytesAsSpan`: _object_ + - `isEmpty`: _boolean_ + - `item`: _object_ + - `length`: _string_ (hex integer) + + + + +### eth_getAccountInfo + +Retrieves Account with code and no storageRoot via Address and Blocknumber + + + + +1. `accountAddress`: _string_ (address) + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getAccountInfo", + "params": [accountAddress, blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `nonce`: _string_ (hex integer) + + + + +### eth_getBalance + +Returns account balance + + + + +1. `address`: _string_ (address) + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getBalance", + "params": [address, blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_getBlockByHash + +Retrieves a block by hash + + + + +1. `blockHash`: _string_ (hash) + +2. `returnFullTransactionObjects`: _boolean_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getBlockByHash", + "params": [blockHash, returnFullTransactionObjects] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `author`: _string_ (address) + - `baseFeePerGas`: _string_ (hex integer) + - `blobGasUsed`: _string_ (hex integer) + - `difficulty`: _string_ (hex integer) + - `excessBlobGas`: _string_ (hex integer) + - `extraData`: _string_ (hex data) + - `gasLimit`: _string_ (hex integer) + - `gasUsed`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `logsBloom`: _string_ (hex data) + - `miner`: _string_ (address) + - `mixHash`: _string_ (hash) + - `nonce`: _string_ (hex data) + - `number`: _string_ (hex integer) + - `parentBeaconBlockRoot`: _string_ (hash) + - `parentHash`: _string_ (hash) + - `receiptsRoot`: _string_ (hash) + - `requestsHash`: _string_ (hash) + - `sha3Uncles`: _string_ (hash) + - `signature`: _string_ (hex data) + - `size`: _string_ (hex integer) + - `stateRoot`: _string_ (hash) + - `step`: _string_ (hex integer) + - `timestamp`: _string_ (hex integer) + - `totalDifficulty`: _string_ (hex integer) + - `transactions`: array of _object_ + - `transactionsRoot`: _string_ (hash) + - `uncles`: array of _string_ (hash) + - `withdrawals`: array of _object_ + - `address`: _string_ (address) + - `amountInGwei`: _string_ (hex integer) + - `amountInWei`: _string_ (hex integer) + - `index`: _string_ (hex integer) + - `validatorIndex`: _string_ (hex integer) + - `withdrawalsRoot`: _string_ (hash) + + + + +### eth_getBlockByNumber + +Retrieves a block by number + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +2. `returnFullTransactionObjects`: _boolean_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getBlockByNumber", + "params": [blockParameter, returnFullTransactionObjects] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `author`: _string_ (address) + - `baseFeePerGas`: _string_ (hex integer) + - `blobGasUsed`: _string_ (hex integer) + - `difficulty`: _string_ (hex integer) + - `excessBlobGas`: _string_ (hex integer) + - `extraData`: _string_ (hex data) + - `gasLimit`: _string_ (hex integer) + - `gasUsed`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `logsBloom`: _string_ (hex data) + - `miner`: _string_ (address) + - `mixHash`: _string_ (hash) + - `nonce`: _string_ (hex data) + - `number`: _string_ (hex integer) + - `parentBeaconBlockRoot`: _string_ (hash) + - `parentHash`: _string_ (hash) + - `receiptsRoot`: _string_ (hash) + - `requestsHash`: _string_ (hash) + - `sha3Uncles`: _string_ (hash) + - `signature`: _string_ (hex data) + - `size`: _string_ (hex integer) + - `stateRoot`: _string_ (hash) + - `step`: _string_ (hex integer) + - `timestamp`: _string_ (hex integer) + - `totalDifficulty`: _string_ (hex integer) + - `transactions`: array of _object_ + - `transactionsRoot`: _string_ (hash) + - `uncles`: array of _string_ (hash) + - `withdrawals`: array of _object_ + - `address`: _string_ (address) + - `amountInGwei`: _string_ (hex integer) + - `amountInWei`: _string_ (hex integer) + - `index`: _string_ (hex integer) + - `validatorIndex`: _string_ (hex integer) + - `withdrawalsRoot`: _string_ (hash) + + + + +### eth_getBlockReceipts + +Get receipts from all transactions from particular block, more efficient than fetching the receipts one-by-one. + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getBlockReceipts", + "params": [blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `blobGasPrice`: _string_ (hex integer) + - `blobGasUsed`: _string_ (hex integer) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `contractAddress`: _string_ (address) + - `cumulativeGasUsed`: _string_ (hex integer) + - `effectiveGasPrice`: _string_ (hex integer) + - `error`: _string_ + - `from`: _string_ (address) + - `gasUsed`: _string_ (hex integer) + - `logs`: array of _object_ + - `address`: _string_ (address) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `blockTimestamp`: _string_ (hex integer) + - `data`: _string_ (hex data) + - `logIndex`: _string_ (hex integer) + - `removed`: _boolean_ + - `topics`: array of _string_ (hash) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `logsBloom`: _string_ (hex data) + - `root`: _string_ (hash) + - `status`: _string_ (hex integer) + - `to`: _string_ (address) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + + + + +### eth_getBlockTransactionCountByHash + +Returns number of transactions in the block block hash + + + + +1. `blockHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getBlockTransactionCountByHash", + "params": [blockHash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_getBlockTransactionCountByNumber + +Returns number of transactions in the block by block number + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getBlockTransactionCountByNumber", + "params": [blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_getCode + +Returns account code at given address and block + + + + +1. `address`: _string_ (address) + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getCode", + "params": [address, blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex data) + + + + +### eth_getFilterChanges + +Reads filter changes + + + + +1. `filterId`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getFilterChanges", + "params": [filterId] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + + + + +### eth_getFilterLogs + +Reads filter changes + + + + +1. `filterId`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getFilterLogs", + "params": [filterId] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `address`: _string_ (address) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `blockTimestamp`: _string_ (hex integer) + - `data`: _string_ (hex data) + - `logIndex`: _string_ (hex integer) + - `removed`: _boolean_ + - `topics`: array of _string_ (hash) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + + + + +### eth_getLogs + +Reads logs + + + + +1. `filter`: _object_ + - `address`: array of _object_ + - `value`: _string_ (address) + - `fromBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + - `toBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + - `topics`: array of array of _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getLogs", + "params": [filter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `address`: _string_ (address) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `blockTimestamp`: _string_ (hex integer) + - `data`: _string_ (hex data) + - `logIndex`: _string_ (hex integer) + - `removed`: _boolean_ + - `topics`: array of _string_ (hash) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + + + + +### eth_getProof + +https://github.com/ethereum/EIPs/issues/1186 + + + + +1. `accountAddress`: _string_ (address) + +2. `storageKeys`: array of _string_ (hex integer) + +3. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getProof", + "params": [accountAddress, storageKeys, blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `address`: _string_ (address) + - `balance`: _string_ (hex integer) + - `codeHash`: _string_ (hash) + - `nonce`: _string_ (hex integer) + - `proof`: array of _string_ (hex data) + - `storageProofs`: array of _object_ + - `key`: _string_ + - `proof`: array of _string_ (hex data) + - `value`: _object_ + - `hasValue`: _boolean_ + - `value`: _object_ + - `isEmpty`: _boolean_ + - `length`: _string_ (hex integer) + - `span`: _object_ + - `isEmpty`: _boolean_ + - `item`: _object_ + - `length`: _string_ (hex integer) + - `storageRoot`: _string_ (hash) + + + + +### eth_getRawTransactionByHash + +Retrieves a transaction RLP by hash + + + + +1. `transactionHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getRawTransactionByHash", + "params": [transactionHash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### eth_getStorageAt + +Returns storage data at address. storage_index + + + + +1. `address`: _string_ (address) + +2. `positionIndex`: _string_ (hex integer) + +3. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getStorageAt", + "params": [address, positionIndex, blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex data) + + + + +### eth_getTransactionByBlockHashAndIndex + +Retrieves a transaction by block hash and index + + + + +1. `blockHash`: _string_ (hash) + +2. `positionIndex`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getTransactionByBlockHashAndIndex", + "params": [blockHash, positionIndex] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + + + + +### eth_getTransactionByBlockNumberAndIndex + +Retrieves a transaction by block number and index + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +2. `positionIndex`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getTransactionByBlockNumberAndIndex", + "params": [blockParameter, positionIndex] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + + + + +### eth_getTransactionByHash + +Retrieves a transaction by hash + + + + +1. `transactionHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getTransactionByHash", + "params": [transactionHash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + + + + +### eth_getTransactionCount + +Returns account nonce (number of trnsactions from the account since genesis) at the given block number + + + + +1. `address`: _string_ (address) + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getTransactionCount", + "params": [address, blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_getTransactionReceipt + +Retrieves a transaction receipt by tx hash + + + + +1. `txHashData`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getTransactionReceipt", + "params": [txHashData] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `blobGasPrice`: _string_ (hex integer) + - `blobGasUsed`: _string_ (hex integer) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `contractAddress`: _string_ (address) + - `cumulativeGasUsed`: _string_ (hex integer) + - `effectiveGasPrice`: _string_ (hex integer) + - `error`: _string_ + - `from`: _string_ (address) + - `gasUsed`: _string_ (hex integer) + - `logs`: array of _object_ + - `address`: _string_ (address) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `blockTimestamp`: _string_ (hex integer) + - `data`: _string_ (hex data) + - `logIndex`: _string_ (hex integer) + - `removed`: _boolean_ + - `topics`: array of _string_ (hash) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `logsBloom`: _string_ (hex data) + - `root`: _string_ (hash) + - `status`: _string_ (hex integer) + - `to`: _string_ (address) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + + + + +### eth_getUncleByBlockHashAndIndex + +Retrieves an uncle block header by block hash and uncle index + + + + +1. `blockHashData`: _string_ (hash) + +2. `positionIndex`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getUncleByBlockHashAndIndex", + "params": [blockHashData, positionIndex] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `author`: _string_ (address) + - `baseFeePerGas`: _string_ (hex integer) + - `blobGasUsed`: _string_ (hex integer) + - `difficulty`: _string_ (hex integer) + - `excessBlobGas`: _string_ (hex integer) + - `extraData`: _string_ (hex data) + - `gasLimit`: _string_ (hex integer) + - `gasUsed`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `logsBloom`: _string_ (hex data) + - `miner`: _string_ (address) + - `mixHash`: _string_ (hash) + - `nonce`: _string_ (hex data) + - `number`: _string_ (hex integer) + - `parentBeaconBlockRoot`: _string_ (hash) + - `parentHash`: _string_ (hash) + - `receiptsRoot`: _string_ (hash) + - `requestsHash`: _string_ (hash) + - `sha3Uncles`: _string_ (hash) + - `signature`: _string_ (hex data) + - `size`: _string_ (hex integer) + - `stateRoot`: _string_ (hash) + - `step`: _string_ (hex integer) + - `timestamp`: _string_ (hex integer) + - `totalDifficulty`: _string_ (hex integer) + - `transactions`: array of _object_ + - `transactionsRoot`: _string_ (hash) + - `uncles`: array of _string_ (hash) + - `withdrawals`: array of _object_ + - `address`: _string_ (address) + - `amountInGwei`: _string_ (hex integer) + - `amountInWei`: _string_ (hex integer) + - `index`: _string_ (hex integer) + - `validatorIndex`: _string_ (hex integer) + - `withdrawalsRoot`: _string_ (hash) + + + + +### eth_getUncleByBlockNumberAndIndex + +Retrieves an uncle block header by block number and uncle index + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +2. `positionIndex`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getUncleByBlockNumberAndIndex", + "params": [blockParameter, positionIndex] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `author`: _string_ (address) + - `baseFeePerGas`: _string_ (hex integer) + - `blobGasUsed`: _string_ (hex integer) + - `difficulty`: _string_ (hex integer) + - `excessBlobGas`: _string_ (hex integer) + - `extraData`: _string_ (hex data) + - `gasLimit`: _string_ (hex integer) + - `gasUsed`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `logsBloom`: _string_ (hex data) + - `miner`: _string_ (address) + - `mixHash`: _string_ (hash) + - `nonce`: _string_ (hex data) + - `number`: _string_ (hex integer) + - `parentBeaconBlockRoot`: _string_ (hash) + - `parentHash`: _string_ (hash) + - `receiptsRoot`: _string_ (hash) + - `requestsHash`: _string_ (hash) + - `sha3Uncles`: _string_ (hash) + - `signature`: _string_ (hex data) + - `size`: _string_ (hex integer) + - `stateRoot`: _string_ (hash) + - `step`: _string_ (hex integer) + - `timestamp`: _string_ (hex integer) + - `totalDifficulty`: _string_ (hex integer) + - `transactions`: array of _object_ + - `transactionsRoot`: _string_ (hash) + - `uncles`: array of _string_ (hash) + - `withdrawals`: array of _object_ + - `address`: _string_ (address) + - `amountInGwei`: _string_ (hex integer) + - `amountInWei`: _string_ (hex integer) + - `index`: _string_ (hex integer) + - `validatorIndex`: _string_ (hex integer) + - `withdrawalsRoot`: _string_ (hash) + + + + +### eth_getUncleCountByBlockHash + +Returns number of uncles in the block by block hash + + + + +1. `blockHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getUncleCountByBlockHash", + "params": [blockHash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_getUncleCountByBlockNumber + +Returns number of uncles in the block by block number + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_getUncleCountByBlockNumber", + "params": [blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_newBlockFilter + +Creates an update filter + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_newBlockFilter", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_newFilter + +Creates an update filter + + + + +1. `filter`: _object_ + - `address`: array of _object_ + - `value`: _string_ (address) + - `fromBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + - `toBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + - `topics`: array of array of _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_newFilter", + "params": [filter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_newPendingTransactionFilter + +Creates an update filter + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_newPendingTransactionFilter", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### eth_pendingTransactions + +Returns the pending transactions list + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_pendingTransactions", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + + + + +### eth_protocolVersion + +Returns ETH protocol version + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_protocolVersion", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### eth_sendRawTransaction + +Send a raw transaction to the tx pool and broadcasting + + + + +1. `transaction`: _string_ (hex data) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_sendRawTransaction", + "params": [transaction] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hash) + + + + +### eth_sendTransaction + +Send a transaction to the tx pool and broadcasting + + + + +1. `rpcTx`: _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_sendTransaction", + "params": [rpcTx] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hash) + + + + +### eth_simulateV1 + +Executes a simulation across multiple blocks (does not create a transaction or block) + + + + +1. `payload`: _object_ + - `blockStateCalls`: array of _object_ + - `blockOverrides`: _object_ + - `baseFeePerGas`: _string_ (hex integer) + - `blobBaseFee`: _string_ (hex integer) + - `feeRecipient`: _string_ (address) + - `gasLimit`: _string_ (hex integer) + - `number`: _string_ (hex integer) + - `prevRandao`: _string_ (hash) + - `time`: _string_ (hex integer) + - `calls`: array of _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `returnFullTransactionObjects`: _boolean_ + - `returnFullTransactions`: _boolean_ + - `traceTransfers`: _boolean_ + - `validation`: _boolean_ + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_simulateV1", + "params": [payload, blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `calls`: array of _object_ + - `error`: _object_ + - `code`: _string_ (hex integer) + - `data`: _string_ (hex data) + - `evmException`: _integer_ + - `message`: _string_ + - `gasUsed`: _string_ (hex integer) + - `logs`: array of _object_ + - `address`: _string_ (address) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `blockTimestamp`: _string_ (hex integer) + - `data`: _string_ (hex data) + - `logIndex`: _string_ (hex integer) + - `removed`: _boolean_ + - `topics`: array of _string_ (hash) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `returnData`: _string_ (hex data) + - `status`: _string_ (hex integer) + - `traces`: array of _object_ + - `error`: _object_ + - `code`: _string_ (hex integer) + - `data`: _string_ (hex data) + - `evmException`: _integer_ + - `message`: _string_ + - `gasUsed`: _string_ (hex integer) + - `logs`: array of _object_ + - `address`: _string_ (address) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `blockTimestamp`: _string_ (hex integer) + - `data`: _string_ (hex data) + - `logIndex`: _string_ (hex integer) + - `removed`: _boolean_ + - `topics`: array of _string_ (hash) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `returnData`: _string_ (hex data) + - `status`: _string_ (hex integer) + + + + +### eth_subscribe + +Starts a subscription to a particular event over WebSockets. A JSON-RPC notification with event payload and subscription id is sent to a client for every event matching the subscription topic. + +:::info +This method is enabled by adding `subscribe` to [`JsonRpc.EnabledModules`](../../fundamentals/configuration.md#jsonrpc-enabledmodules). +::: + + + + +1. `subscriptionName`: _string_ + +2. `filter`: _object_ + - `address`: _string_ (address) + - `fromBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + - `toBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + - `topics`: array of _string_ (hex data) + + + + +```bash +wscat -c localhost:8545 +``` + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_subscribe", + "params": [subscriptionName, args] +} +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": "0x..." // subscription id +} +``` + +`result`: _string_ + + + + +```json +{ + "jsonrpc": "2.0", + "method": "eth_subscription", + "params": { + "subscription": "0x...", // subscription id + "result": payload + } +} +``` + +See specific subcription topic below for `payload` details. + + + + +#### Subscription topics + +
+ + +##### newHeads + + + +Subscribes to incoming block headers. Fires a notification each time a new header is appended to the chain, including chain reorganizations. + +Notification `payload`: _object_ + +- `author`: _string_ (address) +- `baseFeePerGas`: _string_ (hex integer) +- `blobGasUsed`: _string_ (hex integer) +- `difficulty`: _string_ (hex integer) +- `excessBlobGas`: _string_ (hex integer) +- `extraData`: _string_ (hex data) +- `gasLimit`: _string_ (hex integer) +- `gasUsed`: _string_ (hex integer) +- `hash`: _string_ (hash) +- `logsBloom`: _string_ (hex data) +- `miner`: _string_ (address) +- `mixHash`: _string_ (hash) +- `nonce`: _string_ (hex data) +- `number`: _string_ (hex integer) +- `parentBeaconBlockRoot`: _string_ (hash) +- `parentHash`: _string_ (hash) +- `receiptsRoot`: _string_ (hash) +- `sha3Uncles`: _string_ (hash) +- `signature`: _string_ (hex data) +- `size`: _string_ (hex integer) +- `stateRoot`: _string_ (hash) +- `step`: _string_ (hex integer) +- `timestamp`: _string_ (hex integer) +- `totalDifficulty`: _string_ (hex integer) +- `transactions`: array of _object_ +- `transactionsRoot`: _string_ (hash) +- `uncles`: array of _string_ (hash) +- `withdrawals`: array of _object_ + - `address`: _string_ (address) + - `amount`: _string_ (hex integer) + - `index`: _string_ (hex integer) + - `validatorIndex`: _string_ (hex integer) +- `withdrawalsRoot`: _string_ (hash) + +
+ +
+ + +##### logs + + + +Subscribes to incoming logs filtered by the given options. In case of a chain reorganization, previously sent logs on the old chain will be re-sent with the `removed` field set to `true`. + +Notification `payload`: _object_ + +- `address`: _string_ (address) +- `blockHash`: _string_ (hash) +- `blockNumber`: _string_ (hex integer) +- `data`: _string_ (hex data) +- `logIndex`: _string_ (hex integer) +- `removed`: _boolean_ +- `topics`: array of _string_ (hash) +- `transactionHash`: _string_ (hash) +- `transactionIndex`: _string_ (hex integer) +- `transactionLogIndex`: _string_ (hex integer) + +
+ +
+ + +##### newPendingTransactions + + + +Subscribes to incoming pending transactions. Returns the transaction hash. + +Notification `payload`: _string_ (hash) + +
+ +
+ + +##### droppedPendingTransactions + + + +Subscribes to transactions evicted from the transaction pool. Returns the transaction hash. + +Notification `payload`: _string_ (hash) + +
+ +
+ + +##### syncing + + + +Subscribes to syncing events. Returns `false` (once) if the node is synced or an object with statistics (once) when the node starts syncing. + +Notification `payload`: + +- if synced: _boolean_ +- if syncing: _object_ + - `currentBlock`: _string_ (hex integer) + - `highestBlock`: _string_ (hex integer) + - `isSyncing`: _boolean_ + - `startingBlock`: _string_ (hex integer) + +
+### eth_syncing + +Returns syncing status + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_syncing", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `currentBlock`: _string_ (hex integer) + - `highestBlock`: _string_ (hex integer) + - `isSyncing`: _boolean_ + - `startingBlock`: _string_ (hex integer) + - `syncMode`: _integer_ + + + + +### eth_uninstallFilter + +Creates an update filter + + + + +1. `filterId`: _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_uninstallFilter", + "params": [filterId] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### eth_unsubscribe + +Unsubscribes from a subscription. + +:::info +This method is enabled by adding `subscribe` to [`JsonRpc.EnabledModules`](../../fundamentals/configuration.md#jsonrpc-enabledmodules). +::: + + + + +1. `subscriptionId`: *string* + + + + + +```bash +wscat -c localhost:8545 +``` + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_unsubscribe", + "params": [subscriptionId] +} +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: *boolean* (`true` if unsubscribed successfully; otherwise, `false`) + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/eth_subscribe.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/eth_subscribe.md new file mode 100644 index 0000000000..7eb969989f --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/eth_subscribe.md @@ -0,0 +1,185 @@ +### eth_subscribe + +Starts a subscription to a particular event over WebSockets. A JSON-RPC notification with event payload and subscription id is sent to a client for every event matching the subscription topic. + +:::info +This method is enabled by adding `subscribe` to [`JsonRpc.EnabledModules`](../../fundamentals/configuration.md#jsonrpc-enabledmodules). +::: + + + + +1. `subscriptionName`: _string_ + +2. `filter`: _object_ + - `address`: _string_ (address) + - `fromBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + - `toBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + - `topics`: array of _string_ (hex data) + + + + +```bash +wscat -c localhost:8545 +``` + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_subscribe", + "params": [subscriptionName, args] +} +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": "0x..." // subscription id +} +``` + +`result`: _string_ + + + + +```json +{ + "jsonrpc": "2.0", + "method": "eth_subscription", + "params": { + "subscription": "0x...", // subscription id + "result": payload + } +} +``` + +See specific subcription topic below for `payload` details. + + + + +#### Subscription topics + +
+ + +##### newHeads + + + +Subscribes to incoming block headers. Fires a notification each time a new header is appended to the chain, including chain reorganizations. + +Notification `payload`: _object_ + +- `author`: _string_ (address) +- `baseFeePerGas`: _string_ (hex integer) +- `blobGasUsed`: _string_ (hex integer) +- `difficulty`: _string_ (hex integer) +- `excessBlobGas`: _string_ (hex integer) +- `extraData`: _string_ (hex data) +- `gasLimit`: _string_ (hex integer) +- `gasUsed`: _string_ (hex integer) +- `hash`: _string_ (hash) +- `logsBloom`: _string_ (hex data) +- `miner`: _string_ (address) +- `mixHash`: _string_ (hash) +- `nonce`: _string_ (hex data) +- `number`: _string_ (hex integer) +- `parentBeaconBlockRoot`: _string_ (hash) +- `parentHash`: _string_ (hash) +- `receiptsRoot`: _string_ (hash) +- `sha3Uncles`: _string_ (hash) +- `signature`: _string_ (hex data) +- `size`: _string_ (hex integer) +- `stateRoot`: _string_ (hash) +- `step`: _string_ (hex integer) +- `timestamp`: _string_ (hex integer) +- `totalDifficulty`: _string_ (hex integer) +- `transactions`: array of _object_ +- `transactionsRoot`: _string_ (hash) +- `uncles`: array of _string_ (hash) +- `withdrawals`: array of _object_ + - `address`: _string_ (address) + - `amount`: _string_ (hex integer) + - `index`: _string_ (hex integer) + - `validatorIndex`: _string_ (hex integer) +- `withdrawalsRoot`: _string_ (hash) + +
+ +
+ + +##### logs + + + +Subscribes to incoming logs filtered by the given options. In case of a chain reorganization, previously sent logs on the old chain will be re-sent with the `removed` field set to `true`. + +Notification `payload`: _object_ + +- `address`: _string_ (address) +- `blockHash`: _string_ (hash) +- `blockNumber`: _string_ (hex integer) +- `data`: _string_ (hex data) +- `logIndex`: _string_ (hex integer) +- `removed`: _boolean_ +- `topics`: array of _string_ (hash) +- `transactionHash`: _string_ (hash) +- `transactionIndex`: _string_ (hex integer) +- `transactionLogIndex`: _string_ (hex integer) + +
+ +
+ + +##### newPendingTransactions + + + +Subscribes to incoming pending transactions. Returns the transaction hash. + +Notification `payload`: _string_ (hash) + +
+ +
+ + +##### droppedPendingTransactions + + + +Subscribes to transactions evicted from the transaction pool. Returns the transaction hash. + +Notification `payload`: _string_ (hash) + +
+ +
+ + +##### syncing + + + +Subscribes to syncing events. Returns `false` (once) if the node is synced or an object with statistics (once) when the node starts syncing. + +Notification `payload`: + +- if synced: _boolean_ +- if syncing: _object_ + - `currentBlock`: _string_ (hex integer) + - `highestBlock`: _string_ (hex integer) + - `isSyncing`: _boolean_ + - `startingBlock`: _string_ (hex integer) + +
diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/eth_unsubscribe.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/eth_unsubscribe.md new file mode 100644 index 0000000000..68c767a264 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/eth_unsubscribe.md @@ -0,0 +1,45 @@ +### eth_unsubscribe + +Unsubscribes from a subscription. + +:::info +This method is enabled by adding `subscribe` to [`JsonRpc.EnabledModules`](../../fundamentals/configuration.md#jsonrpc-enabledmodules). +::: + + + + +1. `subscriptionId`: *string* + + + + + +```bash +wscat -c localhost:8545 +``` + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "method": "eth_unsubscribe", + "params": [subscriptionId] +} +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: *boolean* (`true` if unsubscribed successfully; otherwise, `false`) + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/flashbots.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/flashbots.md new file mode 100644 index 0000000000..661d5db509 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/flashbots.md @@ -0,0 +1,99 @@ +--- +title: flashbots namespace +sidebar_label: flashbots +sidebar_position: 4 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### flashbots_validateBuilderSubmissionV3 + + validate the builder submissions as received by a relay + + + + +1. `params`: _object_ + - `blobsBundle`: _object_ + - `blobs`: array of _string_ (hex data) + - `commitments`: array of _string_ (hex data) + - `proofs`: array of _string_ (hex data) + - `executionPayload`: _object_ + - `base_fee_per_gas`: _string_ (hex integer) + - `blob_gas_used`: _string_ (hex integer) + - `block_hash`: _string_ (hash) + - `block_number`: _string_ (hex integer) + - `excess_blob_gas`: _string_ (hex integer) + - `extra_data`: _string_ (hex data) + - `fee_recipient`: _string_ (address) + - `gas_limit`: _string_ (hex integer) + - `gas_used`: _string_ (hex integer) + - `logs_bloom`: _string_ (hex data) + - `parent_hash`: _string_ (hash) + - `prev_randao`: _string_ (hash) + - `receipts_root`: _string_ (hash) + - `state_root`: _string_ (hash) + - `timestamp`: _string_ (hex integer) + - `transactions`: array of _string_ (hex data) + - `withdrawals`: array of _object_ + - `address`: _string_ (address) + - `amount_in_gwei`: _string_ (hex integer) + - `index`: _string_ (hex integer) + - `validator_index`: _string_ (hex integer) + - `message`: _object_ + - `blockHash`: _string_ (hash) + - `builderPublicKey`: _object_ + - `address`: _string_ (address) + - `bytes`: _string_ (hex data) + - `hash`: _string_ (hash) + - `prefixedBytes`: _string_ (hex data) + - `gasLimit`: _string_ (hex integer) + - `gasUsed`: _string_ (hex integer) + - `parentHash`: _string_ (hash) + - `proposerFeeRecipient`: _string_ (address) + - `proposerPublicKey`: _object_ + - `address`: _string_ (address) + - `bytes`: _string_ (hex data) + - `hash`: _string_ (hash) + - `prefixedBytes`: _string_ (hex data) + - `slot`: _string_ (hex integer) + - `value`: _string_ (hex integer) + - `parentBeaconBlockRoot`: _string_ (hash) + - `registeredGasLimit`: _string_ (hex integer) + - `signature`: _string_ (hex data) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "flashbots_validateBuilderSubmissionV3", + "params": [params] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `status`: _string_ + - `validationError`: _string_ + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/health.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/health.md new file mode 100644 index 0000000000..f28ea30ac9 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/health.md @@ -0,0 +1,48 @@ +--- +title: health namespace +sidebar_label: health +sidebar_position: 5 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### health_nodeStatus + +Check health status of the node + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "health_nodeStatus", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `errors`: array of _string_ + - `healthy`: _boolean_ + - `isSyncing`: _boolean_ + - `messages`: array of _string_ + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/net.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/net.md new file mode 100644 index 0000000000..5d95c77933 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/net.md @@ -0,0 +1,174 @@ +--- +title: net namespace +sidebar_label: net +sidebar_position: 6 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### net_listening + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "net_listening", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### net_localAddress + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "net_localAddress", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (address) + + + + +### net_localEnode + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "net_localEnode", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### net_peerCount + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "net_peerCount", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex integer) + + + + +### net_version + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "net_version", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/parity.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/parity.md new file mode 100644 index 0000000000..ae8f19d11c --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/parity.md @@ -0,0 +1,352 @@ +--- +title: parity namespace +sidebar_label: parity +sidebar_position: 7 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### parity_clearEngineSigner + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "parity_clearEngineSigner", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### parity_enode + +Returns the node enode URI. + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "parity_enode", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### parity_getBlockReceipts + +Get receipts from all transactions from particular block, more efficient than fetching the receipts one-by-one. + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "parity_getBlockReceipts", + "params": [blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `blobGasPrice`: _string_ (hex integer) + - `blobGasUsed`: _string_ (hex integer) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `contractAddress`: _string_ (address) + - `cumulativeGasUsed`: _string_ (hex integer) + - `effectiveGasPrice`: _string_ (hex integer) + - `error`: _string_ + - `from`: _string_ (address) + - `gasUsed`: _string_ (hex integer) + - `logs`: array of _object_ + - `address`: _string_ (address) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `blockTimestamp`: _string_ (hex integer) + - `data`: _string_ (hex data) + - `logIndex`: _string_ (hex integer) + - `removed`: _boolean_ + - `topics`: array of _string_ (hash) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `logsBloom`: _string_ (hex data) + - `root`: _string_ (hash) + - `status`: _string_ (hex integer) + - `to`: _string_ (address) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + + + + +### parity_netPeers + +Returns connected peers. Peers with non-empty protocols have completed handshake. + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "parity_netPeers", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `active`: _string_ (hex integer) + - `connected`: _string_ (hex integer) + - `max`: _string_ (hex integer) + - `peers`: array of _object_ + - `caps`: array of _string_ + - `id`: _string_ + - `name`: _string_ + - `network`: _object_ + - `localAddress`: _string_ + - `remoteAddress`: _string_ + - `protocols`: map of _object_ + - `difficulty`: _string_ (hex integer) + - `headHash`: _string_ (hash) + - `version`: _string_ (hex data) + + + + +### parity_pendingTransactions + +Returns a list of transactions currently in the queue. If address is provided, returns transactions only with given sender address. + + + + +1. `address`: _string_ (address) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "parity_pendingTransactions", + "params": [address] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `chainId`: _string_ (hex integer) + - `condition`: _object_ + - `creates`: _string_ (address) + - `from`: _string_ (address) + - `gas`: _string_ (hex integer) + - `gasPrice`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `input`: _string_ (hex data) + - `nonce`: _string_ (hex integer) + - `publicKey`: _object_ + - `address`: _string_ (address) + - `bytes`: _string_ (hex data) + - `hash`: _string_ (hash) + - `prefixedBytes`: _string_ (hex data) + - `r`: _object_ + - `isEmpty`: _boolean_ + - `length`: _string_ (hex integer) + - `span`: _object_ + - `isEmpty`: _boolean_ + - `item`: _object_ + - `length`: _string_ (hex integer) + - `raw`: _string_ (hex data) + - `s`: _object_ + - `isEmpty`: _boolean_ + - `length`: _string_ (hex integer) + - `span`: _object_ + - `isEmpty`: _boolean_ + - `item`: _object_ + - `length`: _string_ (hex integer) + - `standardV`: _string_ (hex integer) + - `to`: _string_ (address) + - `transactionIndex`: _string_ (hex integer) + - `v`: _string_ (hex integer) + - `value`: _string_ (hex integer) + + + + +### parity_setEngineSigner + + + + +1. `address`: _string_ (address) + +2. `password`: _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "parity_setEngineSigner", + "params": [address, password] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### parity_setEngineSignerSecret + + + + +1. `privateKey`: _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "parity_setEngineSignerSecret", + "params": [privateKey] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/personal.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/personal.md new file mode 100644 index 0000000000..e4999b06d9 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/personal.md @@ -0,0 +1,202 @@ +--- +title: personal namespace +sidebar_label: personal +sidebar_position: 8 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### personal_importRawKey + + + + +1. `keyData`: _string_ (hex data) + +2. `passphrase`: _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "personal_importRawKey", + "params": [keyData, passphrase] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (address) + + + + +### personal_listAccounts + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "personal_listAccounts", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _string_ (address) + + + + +### personal_lockAccount + + + + +1. `address`: _string_ (address) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "personal_lockAccount", + "params": [address] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + +### personal_newAccount + + + + +1. `passphrase`: _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "personal_newAccount", + "params": [passphrase] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (address) + + + + +### personal_unlockAccount + + + + +1. `address`: _string_ (address) + +2. `passphrase`: _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "personal_unlockAccount", + "params": [address, passphrase] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _boolean_ + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/proof.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/proof.md new file mode 100644 index 0000000000..01be941e88 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/proof.md @@ -0,0 +1,136 @@ +--- +title: proof namespace +sidebar_label: proof +sidebar_position: 9 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### proof_getTransactionByHash + +This function returns the same result as `eth_getTransactionReceipt` and also a tx proof, receipt proof and serialized block headers. + + + + +1. `txHash`: _string_ (hash) + +2. `includeHeader`: _boolean_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "proof_getTransactionByHash", + "params": [txHash, includeHeader] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `blockHeader`: _string_ (hex data) + - `transaction`: _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + - `txProof`: array of _string_ (hex data) + + + + +### proof_getTransactionReceipt + +This function should return the same result as `eth_call` and also proofs of all used accounts and their storages and serialized block headers. + + + + +1. `txHash`: _string_ (hash) + +2. `includeHeader`: _boolean_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "proof_getTransactionReceipt", + "params": [txHash, includeHeader] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `blockHeader`: _string_ (hex data) + - `receipt`: _object_ + - `blobGasPrice`: _string_ (hex integer) + - `blobGasUsed`: _string_ (hex integer) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `contractAddress`: _string_ (address) + - `cumulativeGasUsed`: _string_ (hex integer) + - `effectiveGasPrice`: _string_ (hex integer) + - `error`: _string_ + - `from`: _string_ (address) + - `gasUsed`: _string_ (hex integer) + - `logs`: array of _object_ + - `address`: _string_ (address) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `blockTimestamp`: _string_ (hex integer) + - `data`: _string_ (hex data) + - `logIndex`: _string_ (hex integer) + - `removed`: _boolean_ + - `topics`: array of _string_ (hash) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `logsBloom`: _string_ (hex data) + - `root`: _string_ (hash) + - `status`: _string_ (hex integer) + - `to`: _string_ (address) + - `transactionHash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + - `receiptProof`: array of _string_ (hex data) + - `txProof`: array of _string_ (hex data) + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/rbuilder.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/rbuilder.md new file mode 100644 index 0000000000..5c703802de --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/rbuilder.md @@ -0,0 +1,185 @@ +--- +title: rbuilder namespace +sidebar_label: rbuilder +sidebar_position: 10 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### rbuilder_calculateStateRoot + +Calculate the state root on top of the state trie at specified block given a set of change. + + + + +1. `block`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +2. `accountDiff`: map of _object_ + - `balance`: _string_ (hex integer) + - `changedSlots`: map of _string_ (hex integer) + - `codeHash`: _string_ (hash) + - `nonce`: _string_ (hex integer) + - `selfDestructed`: _boolean_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "rbuilder_calculateStateRoot", + "params": [block, accountDiff] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hash) + + + + +### rbuilder_getAccount + +Get account data + + + + +1. `address`: _string_ (address) + +2. `block`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "rbuilder_getAccount", + "params": [address, block] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `balance`: _string_ (hex integer) + - `codeHash`: _string_ (hash) + - `nonce`: _string_ (hex integer) + + + + +### rbuilder_getBlockHash + +Gets block hash + + + + +1. `block`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "rbuilder_getBlockHash", + "params": [block] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hash) + + + + +### rbuilder_getCodeByHash + +Returns bytecode based on hash. + + + + +1. `hash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "rbuilder_getCodeByHash", + "params": [hash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hex data) + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/trace.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/trace.md new file mode 100644 index 0000000000..13595d05c4 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/trace.md @@ -0,0 +1,992 @@ +--- +title: trace namespace +sidebar_label: trace +sidebar_position: 11 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### trace_block + + + + +1. `numberOrTag`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "trace_block", + "params": [numberOrTag] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `action`: _object_ + - `author`: _string_ (address) + - `callType`: _string_ + - `creationMethod`: _string_ + - `error`: _string_ + - `from`: _string_ (address) + - `gas`: _string_ (hex integer) + - `includeInTrace`: _boolean_ + - `input`: _string_ (hex data) + - `isPrecompiled`: _boolean_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `rewardType`: _string_ + - `subtraces`: array of _object_ + + - `to`: _string_ (address) + - `traceAddress`: array of _string_ (hex integer) + - `type`: _string_ + - `value`: _string_ (hex integer) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `error`: _string_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `subtraces`: _string_ (hex integer) + - `traceAddress`: array of _string_ (hex integer) + - `transactionHash`: _string_ (hash) + - `transactionPosition`: _string_ (hex integer) + - `type`: _string_ + + + + +### trace_call + + + + +1. `call`: _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + +2. `traceTypes`: array of _string_ + +3. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +4. `stateOverride`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "trace_call", + "params": [call, traceTypes, blockParameter, stateOverride] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `action`: _object_ + - `author`: _string_ (address) + - `callType`: _string_ + - `creationMethod`: _string_ + - `error`: _string_ + - `from`: _string_ (address) + - `gas`: _string_ (hex integer) + - `includeInTrace`: _boolean_ + - `input`: _string_ (hex data) + - `isPrecompiled`: _boolean_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `rewardType`: _string_ + - `subtraces`: array of _object_ + + - `to`: _string_ (address) + - `traceAddress`: array of _string_ (hex integer) + - `type`: _string_ + - `value`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `stateChanges`: map of _object_ + - `balance`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `code`: _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `nonce`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `storage`: map of _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `transactionHash`: _string_ (hash) + - `vmTrace`: _object_ + - `code`: _string_ (hex data) + - `operations`: array of _object_ + - `cost`: _string_ (hex integer) + - `memory`: _object_ + - `data`: _string_ (hex data) + - `offset`: _string_ (hex integer) + - `pc`: _string_ (hex integer) + - `push`: array of _string_ (hex data) + - `store`: _object_ + - `key`: _string_ (hex data) + - `value`: _string_ (hex data) + - `sub`: _object_ + + - `used`: _string_ (hex integer) + + + + +### trace_callMany + +Performs multiple traces on top of a block + + + + +1. `calls`: array of _object_ + - `traceTypes`: array of _string_ + - `transaction`: _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "trace_callMany", + "params": [calls, blockParameter] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `action`: _object_ + - `author`: _string_ (address) + - `callType`: _string_ + - `creationMethod`: _string_ + - `error`: _string_ + - `from`: _string_ (address) + - `gas`: _string_ (hex integer) + - `includeInTrace`: _boolean_ + - `input`: _string_ (hex data) + - `isPrecompiled`: _boolean_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `rewardType`: _string_ + - `subtraces`: array of _object_ + + - `to`: _string_ (address) + - `traceAddress`: array of _string_ (hex integer) + - `type`: _string_ + - `value`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `stateChanges`: map of _object_ + - `balance`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `code`: _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `nonce`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `storage`: map of _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `transactionHash`: _string_ (hash) + - `vmTrace`: _object_ + - `code`: _string_ (hex data) + - `operations`: array of _object_ + - `cost`: _string_ (hex integer) + - `memory`: _object_ + - `data`: _string_ (hex data) + - `offset`: _string_ (hex integer) + - `pc`: _string_ (hex integer) + - `push`: array of _string_ (hex data) + - `store`: _object_ + - `key`: _string_ (hex data) + - `value`: _string_ (hex data) + - `sub`: _object_ + + - `used`: _string_ (hex integer) + + + + +### trace_filter + + + + +1. `traceFilterForRpc`: _object_ + - `after`: _string_ (hex integer) + - `count`: _string_ (hex integer) + - `fromAddress`: array of _string_ (address) + - `fromBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + - `toAddress`: array of _string_ (address) + - `toBlock`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "trace_filter", + "params": [traceFilterForRpc] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `action`: _object_ + - `author`: _string_ (address) + - `callType`: _string_ + - `creationMethod`: _string_ + - `error`: _string_ + - `from`: _string_ (address) + - `gas`: _string_ (hex integer) + - `includeInTrace`: _boolean_ + - `input`: _string_ (hex data) + - `isPrecompiled`: _boolean_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `rewardType`: _string_ + - `subtraces`: array of _object_ + + - `to`: _string_ (address) + - `traceAddress`: array of _string_ (hex integer) + - `type`: _string_ + - `value`: _string_ (hex integer) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `error`: _string_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `subtraces`: _string_ (hex integer) + - `traceAddress`: array of _string_ (hex integer) + - `transactionHash`: _string_ (hash) + - `transactionPosition`: _string_ (hex integer) + - `type`: _string_ + + + + +### trace_get + +Returns trace at given position. + + + + +1. `txHash`: _string_ (hash) + +2. `positions`: array of _string_ (hex integer) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "trace_get", + "params": [txHash, positions] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `action`: _object_ + - `author`: _string_ (address) + - `callType`: _string_ + - `creationMethod`: _string_ + - `error`: _string_ + - `from`: _string_ (address) + - `gas`: _string_ (hex integer) + - `includeInTrace`: _boolean_ + - `input`: _string_ (hex data) + - `isPrecompiled`: _boolean_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `rewardType`: _string_ + - `subtraces`: array of _object_ + + - `to`: _string_ (address) + - `traceAddress`: array of _string_ (hex integer) + - `type`: _string_ + - `value`: _string_ (hex integer) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `error`: _string_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `subtraces`: _string_ (hex integer) + - `traceAddress`: array of _string_ (hex integer) + - `transactionHash`: _string_ (hash) + - `transactionPosition`: _string_ (hex integer) + - `type`: _string_ + + + + +### trace_rawTransaction + +Traces a call to eth_sendRawTransaction without making the call, returning the traces + + + + +1. `data`: _string_ (hex data) + +2. `traceTypes`: array of _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "trace_rawTransaction", + "params": [data, traceTypes] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `action`: _object_ + - `author`: _string_ (address) + - `callType`: _string_ + - `creationMethod`: _string_ + - `error`: _string_ + - `from`: _string_ (address) + - `gas`: _string_ (hex integer) + - `includeInTrace`: _boolean_ + - `input`: _string_ (hex data) + - `isPrecompiled`: _boolean_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `rewardType`: _string_ + - `subtraces`: array of _object_ + + - `to`: _string_ (address) + - `traceAddress`: array of _string_ (hex integer) + - `type`: _string_ + - `value`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `stateChanges`: map of _object_ + - `balance`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `code`: _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `nonce`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `storage`: map of _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `transactionHash`: _string_ (hash) + - `vmTrace`: _object_ + - `code`: _string_ (hex data) + - `operations`: array of _object_ + - `cost`: _string_ (hex integer) + - `memory`: _object_ + - `data`: _string_ (hex data) + - `offset`: _string_ (hex integer) + - `pc`: _string_ (hex integer) + - `push`: array of _string_ (hex data) + - `store`: _object_ + - `key`: _string_ (hex data) + - `value`: _string_ (hex data) + - `sub`: _object_ + + - `used`: _string_ (hex integer) + + + + +### trace_replayBlockTransactions + + + + +1. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +2. `traceTypes`: array of _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "trace_replayBlockTransactions", + "params": [blockParameter, traceTypes] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `action`: _object_ + - `author`: _string_ (address) + - `callType`: _string_ + - `creationMethod`: _string_ + - `error`: _string_ + - `from`: _string_ (address) + - `gas`: _string_ (hex integer) + - `includeInTrace`: _boolean_ + - `input`: _string_ (hex data) + - `isPrecompiled`: _boolean_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `rewardType`: _string_ + - `subtraces`: array of _object_ + + - `to`: _string_ (address) + - `traceAddress`: array of _string_ (hex integer) + - `type`: _string_ + - `value`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `stateChanges`: map of _object_ + - `balance`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `code`: _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `nonce`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `storage`: map of _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `transactionHash`: _string_ (hash) + - `vmTrace`: _object_ + - `code`: _string_ (hex data) + - `operations`: array of _object_ + - `cost`: _string_ (hex integer) + - `memory`: _object_ + - `data`: _string_ (hex data) + - `offset`: _string_ (hex integer) + - `pc`: _string_ (hex integer) + - `push`: array of _string_ (hex data) + - `store`: _object_ + - `key`: _string_ (hex data) + - `value`: _string_ (hex data) + - `sub`: _object_ + + - `used`: _string_ (hex integer) + + + + +### trace_replayTransaction + + + + +1. `txHash`: _string_ (hash) + +2. `traceTypes`: array of _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "trace_replayTransaction", + "params": [txHash, traceTypes] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `action`: _object_ + - `author`: _string_ (address) + - `callType`: _string_ + - `creationMethod`: _string_ + - `error`: _string_ + - `from`: _string_ (address) + - `gas`: _string_ (hex integer) + - `includeInTrace`: _boolean_ + - `input`: _string_ (hex data) + - `isPrecompiled`: _boolean_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `rewardType`: _string_ + - `subtraces`: array of _object_ + + - `to`: _string_ (address) + - `traceAddress`: array of _string_ (hex integer) + - `type`: _string_ + - `value`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `stateChanges`: map of _object_ + - `balance`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `code`: _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `nonce`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `storage`: map of _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `transactionHash`: _string_ (hash) + - `vmTrace`: _object_ + - `code`: _string_ (hex data) + - `operations`: array of _object_ + - `cost`: _string_ (hex integer) + - `memory`: _object_ + - `data`: _string_ (hex data) + - `offset`: _string_ (hex integer) + - `pc`: _string_ (hex integer) + - `push`: array of _string_ (hex data) + - `store`: _object_ + - `key`: _string_ (hex data) + - `value`: _string_ (hex data) + - `sub`: _object_ + + - `used`: _string_ (hex integer) + + + + +### trace_simulateV1 + +Returns parity like traces for simulated blocks + + + + +1. `payload`: _object_ + - `blockStateCalls`: array of _object_ + - `blockOverrides`: _object_ + - `baseFeePerGas`: _string_ (hex integer) + - `blobBaseFee`: _string_ (hex integer) + - `feeRecipient`: _string_ (address) + - `gasLimit`: _string_ (hex integer) + - `number`: _string_ (hex integer) + - `prevRandao`: _string_ (hash) + - `time`: _string_ (hex integer) + - `calls`: array of _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + - `stateOverrides`: map of _object_ + - `balance`: _string_ (hex integer) + - `code`: _string_ (hex data) + - `movePrecompileToAddress`: _string_ (address) + - `nonce`: _string_ (hex integer) + - `state`: map of _string_ (hash) + - `stateDiff`: map of _string_ (hash) + - `returnFullTransactionObjects`: _boolean_ + - `returnFullTransactions`: _boolean_ + - `traceTransfers`: _boolean_ + - `validation`: _boolean_ + +2. `blockParameter`: _string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`) + +3. `traceTypes`: array of _string_ + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "trace_simulateV1", + "params": [payload, blockParameter, traceTypes] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `calls`: array of _object_ + - `action`: _object_ + - `author`: _string_ (address) + - `callType`: _string_ + - `creationMethod`: _string_ + - `error`: _string_ + - `from`: _string_ (address) + - `gas`: _string_ (hex integer) + - `includeInTrace`: _boolean_ + - `input`: _string_ (hex data) + - `isPrecompiled`: _boolean_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `rewardType`: _string_ + - `subtraces`: array of _object_ + + - `to`: _string_ (address) + - `traceAddress`: array of _string_ (hex integer) + - `type`: _string_ + - `value`: _string_ (hex integer) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `stateChanges`: map of _object_ + - `balance`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `code`: _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `nonce`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `storage`: map of _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `transactionHash`: _string_ (hash) + - `transactionPosition`: _string_ (hex integer) + - `vmTrace`: _object_ + - `code`: _string_ (hex data) + - `operations`: array of _object_ + - `cost`: _string_ (hex integer) + - `memory`: _object_ + - `data`: _string_ (hex data) + - `offset`: _string_ (hex integer) + - `pc`: _string_ (hex integer) + - `push`: array of _string_ (hex data) + - `store`: _object_ + - `key`: _string_ (hex data) + - `value`: _string_ (hex data) + - `sub`: _object_ + + - `used`: _string_ (hex integer) + - `traces`: array of _object_ + - `action`: _object_ + - `author`: _string_ (address) + - `callType`: _string_ + - `creationMethod`: _string_ + - `error`: _string_ + - `from`: _string_ (address) + - `gas`: _string_ (hex integer) + - `includeInTrace`: _boolean_ + - `input`: _string_ (hex data) + - `isPrecompiled`: _boolean_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `rewardType`: _string_ + - `subtraces`: array of _object_ + + - `to`: _string_ (address) + - `traceAddress`: array of _string_ (hex integer) + - `type`: _string_ + - `value`: _string_ (hex integer) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `stateChanges`: map of _object_ + - `balance`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `code`: _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `nonce`: _object_ + - `after`: _string_ (hex integer) + - `before`: _string_ (hex integer) + - `storage`: map of _object_ + - `after`: _string_ (hex data) + - `before`: _string_ (hex data) + - `transactionHash`: _string_ (hash) + - `transactionPosition`: _string_ (hex integer) + - `vmTrace`: _object_ + - `code`: _string_ (hex data) + - `operations`: array of _object_ + - `cost`: _string_ (hex integer) + - `memory`: _object_ + - `data`: _string_ (hex data) + - `offset`: _string_ (hex integer) + - `pc`: _string_ (hex integer) + - `push`: array of _string_ (hex data) + - `store`: _object_ + - `key`: _string_ (hex data) + - `value`: _string_ (hex data) + - `sub`: _object_ + + - `used`: _string_ (hex integer) + + + + +### trace_transaction + + + + +1. `txHash`: _string_ (hash) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "trace_transaction", + "params": [txHash] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: array of _object_ + - `action`: _object_ + - `author`: _string_ (address) + - `callType`: _string_ + - `creationMethod`: _string_ + - `error`: _string_ + - `from`: _string_ (address) + - `gas`: _string_ (hex integer) + - `includeInTrace`: _boolean_ + - `input`: _string_ (hex data) + - `isPrecompiled`: _boolean_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `rewardType`: _string_ + - `subtraces`: array of _object_ + + - `to`: _string_ (address) + - `traceAddress`: array of _string_ (hex integer) + - `type`: _string_ + - `value`: _string_ (hex integer) + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `error`: _string_ + - `result`: _object_ + - `address`: _string_ (address) + - `code`: _string_ (hex data) + - `gasUsed`: _string_ (hex integer) + - `output`: _string_ (hex data) + - `subtraces`: _string_ (hex integer) + - `traceAddress`: array of _string_ (hex integer) + - `transactionHash`: _string_ (hash) + - `transactionPosition`: _string_ (hex integer) + - `type`: _string_ + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/txpool.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/txpool.md new file mode 100644 index 0000000000..ea8bda1710 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/txpool.md @@ -0,0 +1,134 @@ +--- +title: txpool namespace +sidebar_label: txpool +sidebar_position: 12 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### txpool_content + +Returns tx pool content. + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "txpool_content", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `pending`: map of map of _object_ +map of _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + - `queued`: map of map of _object_ +map of _object_ + - `blockHash`: _string_ (hash) + - `blockNumber`: _string_ (hex integer) + - `gas`: _string_ (hex integer) + - `hash`: _string_ (hash) + - `transactionIndex`: _string_ (hex integer) + - `type`: _integer_ + + + + +### txpool_inspect + +Returns a detailed info on tx pool transactions. + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "txpool_inspect", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `pending`: map of map of _string_ + - `queued`: map of map of _string_ + + + + +### txpool_status + +Returns a tx pool status. + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "txpool_status", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _object_ + - `pending`: _string_ (hex integer) + - `queued`: _string_ (hex integer) + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-ns/web3.md b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/web3.md new file mode 100644 index 0000000000..5b68703674 --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-ns/web3.md @@ -0,0 +1,85 @@ +--- +title: web3 namespace +sidebar_label: web3 +sidebar_position: 13 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +### web3_clientVersion + +Returns the current client version. + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "web3_clientVersion", + "params": [] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ + + + + +### web3_sha3 + +Returns Keccak of the given data. + + + + +1. `data`: _string_ (hex data) + + + + + +```bash +curl localhost:8545 \ + -X POST \ + -H "Content-Type: application/json" \ + --data '{ + "jsonrpc": "2.0", + "id": 0, + "method": "web3_sha3", + "params": [data] + }' +``` + + + + +```json +{ + "jsonrpc": "2.0", + "id": 0, + "result": result +} +``` + +`result`: _string_ (hash) + + + + diff --git a/versioned_docs/version-1.36.0/interacting/json-rpc-server.md b/versioned_docs/version-1.36.0/interacting/json-rpc-server.md new file mode 100644 index 0000000000..21c7ef6e0b --- /dev/null +++ b/versioned_docs/version-1.36.0/interacting/json-rpc-server.md @@ -0,0 +1,213 @@ +--- +title: JSON-RPC server +sidebar_position: 0 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +Interacting with Nethermind requires using the JSON-RPC 2.0 protocol. Nethermind provides JSON-RPC over [HTTP](#http), [WebSocket](#websocket), and [IPC socket](#ipc-socket) transports. Each transport must be enabled with the respective configuration option, as shown below. For more details, see the [JSON-RPC configuration options](../fundamentals/configuration.md#jsonrpc). + +The JSON-RPC API methods are grouped into several categories (namespaces) depending on their purpose. All API method names are composed of the namespace and the actual method name in that namespace. For instance, the `eth_call` method belongs to the `eth` namespace. See the sidebar for all supported namespaces and methods. + +:::note +Not all of the JSON-RPC namespaces are enabled by default. Instead, they must be enabled explicitly with the [`JsonRpc.EnabledModules`](../fundamentals/configuration.md#jsonrpc-enabledmodules) command line option. Otherwise, error code `-32600` is returned. The enabled namespaces can be found in the configuration file specified with the [`-c, --config`](../fundamentals/configuration.md#config) command line option. +::: + +## Transports + +:::tip +The right choice of transport depends on the specific use case. + +- HTTP is a familiar and idempotent transport that closes connections between requests and can, therefore, have lower overall overhead for a relatively low number of requests. +- WebSocket provides a continuous open channel that enables event subscriptions and streaming and handles large volumes of requests with more negligible per-message overhead. +- IPC is generally the most secure as it is limited to local interactions and cannot be exposed to external traffic. It can also be used for event subscriptions. + ::: + +### HTTP + +HTTP is the most widely used transport for Nethermind. To enable the HTTP server, set the [`JsonRpc.Enabled`](../fundamentals/configuration.md#jsonrpc-enabled) configuration option to `true`. By default, Nethermind uses local loopback (127.0.0.1 or `localhost`) and 8545 port. To use a different host or port, set the [`JsonRpc.Host`](../fundamentals/configuration.md#jsonrpc-host) and [`JsonRpc.Port`](../fundamentals/configuration.md#jsonrpc-port) configuration options, respectively. + +### WebSocket + +The configuration of the WebSocket server follows the same pattern as the HTTP server. The WebSocket server is enabled automatically when the HTTP server is enabled and uses the same host and port. To disable the WebSocket server, set the [`Init.WebSocketsEnabled`](../fundamentals/configuration.md#init-websocketsenabled) configuration option to `false`. To use a different a port, set the [`JsonRpc.WebSocketsPort`](../fundamentals/configuration.md#jsonrpc-websocketsport) configuration option. + +### IPC socket + +Nethermind uses IPC based on Unix domain socket. To enable the IPC server, use the [`JsonRpc.IpcUnixDomainSocketPath`](../fundamentals/configuration.md#jsonrpc-ipcunixdomainsocketpath) configuration option. For example: + +``` +--jsonrpc-ipcunixdomainsocketpath path/to/ipc +``` + +If the `path/to/ipc` doesn't exist, Nethermind creates one. + +## Engine API + +The Engine API is a set of RPC methods that enable communication between an execution and consensus client. The clients call these methods automatically when they need to exchange information. Engine API is enabled automatically by default and is not designed to be exposed to the user. + +By default, the Engine API uses local loopback (127.0.0.1 or `localhost`) and 8551 port. To use a different host or port, set the [`JsonRpc.EngineHost`](../fundamentals/configuration.md#jsonrpc-enginehost) and [`JsonRpc.EnginePort`](../fundamentals/configuration.md#jsonrpc-engineport) configuration options, respectively. For example, this can be useful when execution and consensus clients are on different machines. + +:::warning Important +When the `JsonRpc.EngineHost` option is specified, the `JsonRpc.EnginePort` option must be specified as well. +::: + +The Engine API uses JWT authentication and requires a JWT secret. By default, Nethermind creates one at `keystore/jwt-secret` path in its root directory. To use a different path, specify the [`JsonRpc.JwtSecretFile`](../fundamentals/configuration.md#jsonrpc-jwtsecretfile) configuration option. + +## Requests + +:::info +As per the JSON-RPC 2.0 specification, Nethermind supports batch requests. Specifics depend on the JSON-RPC client used. +::: + +Multiple options are available for JSON-RPC interaction from generic utilities like [curl](https://curl.se) and [Postman](https://www.postman.com) for raw requests to tailored tools like [Cast](https://book.getfoundry.sh/cast), to dedicated libraries such as [Ethers.js](https://ethers.org) and [Viem](https://viem.sh), to name a few. + +The following examples demonstrate how to make JSON-RPC requests with some of the abovementioned options. + + + + +The following example uses the [`eth_getBalance`](./json-rpc-ns/eth.md#eth_getbalance) method to check the balance of the specified account: + +```bash +# Assuming Nethermind is running locally using the default port of 8545 +cast rpc --rpc-url http://localhost:8545 eth_getBalance 0x00000000219ab540356cbb839cbe05303d7705fa latest + +# Alternatively, use the dedicated balance command. +# Note that the output format differs from the one above. +cast balance 0x00000000219ab540356cbb839cbe05303d7705fa --ether --rpc-url http://localhost:8545 +``` + +Similarly, we can use the [`eth_getBlockByNumber`](./json-rpc-ns/eth.md#eth_getblockbynumber) method to fetch the specified block data, including transactions: + +```bash +# Assuming Nethermind is running locally using the default port of 8545 +cast rpc --rpc-url http://localhost:8545 eth_getBlockByNumber latest true + +# Alternatively, use the dedicated block command +cast block latest --rpc-url http://localhost:8545 +``` + +For more information, see [Cast documentation](https://book.getfoundry.sh/reference/cast/). + + + + +:::note +Examples are based on Ethers.js v6. +::: + +The following example uses the [`eth_getBalance`](./json-rpc-ns/eth.md#eth_getbalance) method to check the balance of the specified account: + +```js +import { JsonRpcProvider, formatEther } from 'ethers'; + +// Assuming Nethermind is running locally using the default port of 8545 +const provider = new JsonRpcProvider('http://localhost:8545'); + +// Use the low-level API to send the request +let balance = await provider.send('eth_getBalance', [ + '0x00000000219ab540356cbb839cbe05303d7705fa', + 'latest' +]); +console.log('Balance:', formatEther(balance)); + +// Use the high-level API to send the request. +// Note that the return type may differ from the one of the low-level API. +balance = await provider.getBalance( + '0x00000000219ab540356cbb839cbe05303d7705fa', + 'latest' +); +console.log('Balance:', formatEther(balance)); +``` + +Similarly, we can use the [`eth_getBlockByNumber`](./json-rpc-ns/eth.md#eth_getblockbynumber) method to fetch the specified block data, including transactions: + +```js +import { JsonRpcProvider } from 'ethers'; + +// Assuming Nethermind is running locally using the default port of 8545 +const provider = new JsonRpcProvider('http://localhost:8545'); + +// Use the low-level API to send the request +let block = await provider.send('eth_getBlockByNumber', ['latest', true]); +console.log('Block:', block); + +// Use the high-level API to send the request. +// Note that the return type may differ from the one of the low-level API. +// Not all JSON-RPC methods have their respective high-level API. +block = await provider.getBlock('latest', true); +console.log('Block:', block); +``` + +For more information, see [Ethers.js documentation](https://docs.ethers.org/v6/). + + + + +:::note +Examples are based on Viem v2. +::: + +The following example uses the [`eth_getBalance`](./json-rpc-ns/eth.md#eth_getbalance) method to check the balance of the specified account: + +```js +import { createPublicClient, http, formatEther, hexToNumber } from 'viem'; +import { localhost } from 'viem/chains'; + +// Assuming Nethermind is running locally using the default port of 8545 +const client = createPublicClient({ + chain: localhost, + transport: http('http://localhost:8545') +}); + +// Use the low-level API to send the request +let balance = await client.request({ + method: 'eth_getBalance', + params: ['0x00000000219ab540356cbb839cbe05303d7705fa', 'latest'] +}); +console.log('Balance:', formatEther(hexToNumber(balance))); + +// Use the high-level API to send the request. +// Note that the return type may differ from the one of the low-level API. +// Not all JSON-RPC methods have their respective high-level API. +balance = await client.getBalance({ + address: '0x00000000219ab540356cbb839cbe05303d7705fa', + blockTag: 'latest' +}); +console.log('Balance:', formatEther(balance)); +``` + +Similarly, we can use the [`eth_getBlockByNumber`](./json-rpc-ns/eth.md#eth_getblockbynumber) method to fetch the specified block data, including transactions: + +```js +import { createPublicClient, http } from 'viem'; +import { localhost } from 'viem/chains'; + +// Assuming Nethermind is running locally using the default port of 8545 +const client = createPublicClient({ + chain: localhost, + transport: http('http://localhost:8545') +}); + +// Use the low-level API to send the request +let block = await client.request({ + method: 'eth_getBlockByNumber', + params: ['latest', true] +}); +console.log('Block:', block); + +// Use the high-level API to send the request +block = await client.getBlock({ + blockTag: 'latest', + includeTransactions: true +}); +console.log('Block:', block); +``` + +For more information, see [Viem documentation](https://viem.sh/docs/getting-started). + + + + +The exhaustive list of supported JSON-RPC methods can be found under the JSON-RPC namespaces. diff --git a/versioned_docs/version-1.36.0/monitoring/_category_.json b/versioned_docs/version-1.36.0/monitoring/_category_.json new file mode 100644 index 0000000000..bc81ee11d7 --- /dev/null +++ b/versioned_docs/version-1.36.0/monitoring/_category_.json @@ -0,0 +1,4 @@ +{ + "position": 4, + "label": "Monitoring" +} diff --git a/versioned_docs/version-1.36.0/monitoring/health-check.md b/versioned_docs/version-1.36.0/monitoring/health-check.md new file mode 100644 index 0000000000..b26fe7541a --- /dev/null +++ b/versioned_docs/version-1.36.0/monitoring/health-check.md @@ -0,0 +1,125 @@ +--- +title: Health check +sidebar_position: 1 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +To monitor liveness and readiness of your node, Nethermind provides a simple yet powerful health check feature. It is available at the default `/health` endpoint of the [JSON-RPC server](../interacting/json-rpc-server.md). + +## Basic configuration + +:::warning Important +The health check service requires the [JSON-RPC API](../interacting/json-rpc-server.md#http) to be enabled. +::: + +The health check service is disabled by default. To enable it, set the [`HealthChecks.Enabled`](../fundamentals/configuration.md#healthchecks-enabled) configuration option as follows: + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + # highlight-start + --healthchecks-enabled + # highlight-end +``` + +Once Nethermind is up and running, the health check service can be accessed at the `/health` endpoint: + +```bash +curl localhost:8545/health +``` + +with a response similar to the following if healthy: + +```json title="HTTP 200 OK" +{ + "status": "Healthy", + "totalDuration": "00:00:00.0006931", + "entries": { + "node-health": { + "data": { + "IsSyncing": false, + "Errors": [] + }, + "description": "The node is now fully synced with a network. Peers: 89.", + "duration": "00:00:00.0003797", + "status": "Healthy", + "tags": [] + } + } +} +``` + +or similar to the following if unhealthy: + +```json title="HTTP 503 Service Unavailable" +{ + "status": "Unhealthy", + "totalDuration": "00:00:00.0009477", + "entries": { + "node-health": { + "data": { + "IsSyncing": false, + "Errors": [ "NoPeers" ] + }, + "description": "The node is now fully synced with a network. Node is not connected to any peers.", + "duration": "00:00:00.0001356", + "status": "Unhealthy", + "tags": [] + } + } +} +``` + +It is also possible to replace the default `/health` endpoint with a custom one using the [`HealthChecks.Slug`](../fundamentals/configuration.md#healthchecks-slug) configuration option. For example: + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + --healthchecks-enabled \ + # highlight-start + --healthchecks-slug /my/custom/endpoint + # highlight-end +``` + +## Configuring a webhook {#webhook} + +The health check service can be configured to send notifications to a webhook on node failure or recovery. This is achieved with the [`HealthChecks.UIEnabled`](../fundamentals/configuration.md#healthchecks-uienabled), [`HealthChecks.WebhooksEnabled`](../fundamentals/configuration.md#healthchecks-webhooksenabled), and [`HealthChecks.WebhooksUri`](../fundamentals/configuration.md#healthchecks-webhooksuri) configuration options. Optionally, the webhook payload data can be customized with the [`HealthChecks.WebhooksPayload`](../fundamentals/configuration.md#healthchecks-webhookspayload) and [`HealthChecks.WebhooksRestorePayload`](../fundamentals/configuration.md#healthchecks-webhooksrestorepayload) configuration options for failure and recovery events respectively. + +The following example demonstrates how to configure a basic Slack webhook: + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + --healthchecks-enabled \ + # highlight-start + --healthchecks-uienabled \ + --healthchecks-webhooksenabled \ + --healthchecks-webhooksuri https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX \ + --healthchecks-webhookspayload '{"text": "Node is unhealthy"}' \ + --healthchecks-webhooksrestorepayload '{"text": "Node is healthy"}' + # highlight-end +``` + +## Monitoring storage space {#storage-space} + +Monitoring the available storage space is a crucial aspect of running a node. Nethermind provides a feature to track the free storage space and take action when the available space falls below a certain threshold. The following options are available: + +- [`HealthChecks.LowStorageCheckAwaitOnStartup`](../fundamentals/configuration.md#healthchecks-lowstoragecheckawaitonstartup) to check for low disk space on startup and suspend Nethermind until enough space is available +- [`HealthChecks.LowStorageSpaceShutdownThreshold`](../fundamentals/configuration.md#healthchecks-lowstoragespaceshutdownthreshold) to shut down Nethermind when the percentage of available disk space falls below the specified threshold +- [`HealthChecks.LowStorageSpaceWarningThreshold`](../fundamentals/configuration.md#healthchecks-lowstoragespacewarningthreshold) to issue a warning when the percentage of available disk space falls below the specified threshold + +## Monitoring blocks {#blocks} + +Another critical aspect of running a node is monitoring the production and processing of blocks. For that, Nethermind provides the following options: + +- [`HealthChecks.MaxIntervalWithoutProcessedBlock`](../fundamentals/configuration.md#healthchecks-maxintervalwithoutprocessedblock) to specify the max interval without processing a block before the node is considered unhealthy +- [`HealthChecks.MaxIntervalWithoutProducedBlock`](../fundamentals/configuration.md#healthchecks-maxintervalwithoutproducedblock) to specify the max interval without producing a block before the node is considered unhealthy + +## Monitoring consensus client {#consensus-client} + +The health check service can also monitor the communication between Nethermind and the consensus client which can be configured by the [`HealthChecks.MaxIntervalClRequestTime`](../fundamentals/configuration.md#healthchecks-maxintervalclrequesttime) configuration option. diff --git a/versioned_docs/version-1.36.0/monitoring/metrics/_category_.json b/versioned_docs/version-1.36.0/monitoring/metrics/_category_.json new file mode 100644 index 0000000000..e11d71b276 --- /dev/null +++ b/versioned_docs/version-1.36.0/monitoring/metrics/_category_.json @@ -0,0 +1,7 @@ +{ + "position": 0, + "label": "Metrics", + "link": { + "type": "doc", "id": "metrics" + } +} diff --git a/versioned_docs/version-1.36.0/monitoring/metrics/dotnet-counters.md b/versioned_docs/version-1.36.0/monitoring/metrics/dotnet-counters.md new file mode 100644 index 0000000000..45b3cf7ee1 --- /dev/null +++ b/versioned_docs/version-1.36.0/monitoring/metrics/dotnet-counters.md @@ -0,0 +1,122 @@ +--- +title: dotnet-counters +sidebar_position: 1 +--- + +This guide will walk you through setting up performance counters using the [dotnet-counters](https://learn.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-counters) performance monitoring tool that observes counters published via the [EventCounters API](https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.tracing.eventcounter). + +## Step 1: Install dotnet-counters + +dotnet-counters can be either installed locally or in a Docker container. + +### Installing locally + +Use the dotnet tool install command as follows: + +```bash +dotnet tool install -g dotnet-counters +``` + +Once installed, you can run the tool from the command line by typing `dotnet-counters`. + +### Installing in a Docker container + +To install dotnet-counters in a Docker container, create a Dockerfile with the following content: + +```docker title="Dockerfile" +FROM mcr.microsoft.com/dotnet/sdk:10.0 + +RUN dotnet tool install -g dotnet-counters + +ENV PATH="$PATH:/root/.dotnet/tools" + +ENTRYPOINT ["/bin/bash"] +``` + +Then, build the Docker image: + +```bash +docker build -t dotnet-counters . +``` + +## Step 2: Run Nethermind + +To enable performance counters in Nethermind, set the [`Metrics.CountersEnabled`](../../fundamentals/configuration.md#metrics-countersenabled) configuration option to `true`. For more options, see the [Metrics](../../fundamentals/configuration.md#metrics) configuration section. + +:::tip +See [Running a node](../../get-started/running-node/running-node.md) for more information on how to run Nethermind. +::: + +### Running locally + +Run Nethermind as follows: + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + --metrics-countersenabled +``` + +### Running in a Docker container + +The easiest way of collecting metrics in a Docker container is to use Docker Compose. Below, we use the Nethermind official Docker image and the `dotnet-counters` image we created earlier: + +```yaml title="docker-compose.yml" +services: + + dotnet-counters: + image: dotnet-counters + container_name: dotnet-counters + stdin_open: true + tty: true + pid: service:nethermind + volumes: + - metrics:/tmp + depends_on: + - nethermind + + nethermind: + image: nethermind/nethermind:latest + container_name: nethermind + restart: unless-stopped + ports: + - 8545:8545 + - 8551:8551 + - 30303:30303 + command: -c mainnet --metrics-countersenabled + volumes: + - ./keystore:/nethermind/keystore + - ./logs:/nethermind/logs + - ./nethermind_db:/nethermind/nethermind_db + - metrics:/tmp + +volumes: + metrics: +``` + +:::info +dotnet-counters uses IPC socket communication to monitor the target process. For this, we use the `metrics` volume to share the IPC socket directory with the `nethermind` and `dotnet-counter` services. The `pid` option in the `dotnet-counters` service is used to share the PID namespace with the `nethermind` service. This is necessary for `dotnet-counters` to be able to see the Nethermind process. +::: + +We can run the above file as follows: + +```bash +docker compose up +``` + +## Step 3: Collect metrics + +Once dotnet-counters is installed and Nethermind is running, we can start collecting the metrics. If you chose to collect metrics in the containers, run the following command in the `dotnet-counters` container: + +```bash +dotnet-counters collect -n nethermind +``` + +By default, dotnet-counters stores the collected metrics in the current directory in CSV format. However, you may also store them in JSON format and another directory. For instance: + +```bash +dotnet-counters collect -n nethermind -f json -o /tmp/counters.json +``` + +For more info about dotnet-counters, see its [official docs](https://learn.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-counters). diff --git a/versioned_docs/version-1.36.0/monitoring/metrics/grafana-and-prometheus.md b/versioned_docs/version-1.36.0/monitoring/metrics/grafana-and-prometheus.md new file mode 100644 index 0000000000..6ce4e1070e --- /dev/null +++ b/versioned_docs/version-1.36.0/monitoring/metrics/grafana-and-prometheus.md @@ -0,0 +1,78 @@ +--- +title: Grafana and Prometheus +sidebar_position: 0 +--- + +This guide will walk you through setting up a local metrics infrastructure using [Grafana](https://grafana.com) and [Prometheus](https://prometheus.io). + +## Step 1: Set up Grafana and Prometheus + +To simplify the process, we will use the [metrics-infrastructure](https://github.com/NethermindEth/metrics-infrastructure) repository, which contains the necessary configuration files to run Grafana and Prometheus in a Docker container. However, you can also set up Grafana and Prometheus manually the way it fits your specific needs. + +```bash +git clone https://github.com/NethermindEth/metrics-infrastructure.git +``` + +## Step 2: Run the stack + +After cloning the repository, navigate to its root directory and run the containers using Docker Compose as follows: + +```bash +docker compose up +``` + +Once the stack is running, you can access the following services: + +- **Grafana**: [localhost:3000](http://localhost:3000)\ + Use `admin` for both the username and password. When asked for a password change, you may skip it. Then, navigate to Dashboards > Nethermind Dashboard. +- **Prometheus**: [localhost:9090](http://localhost:9090) +- **Pushgateway**: [localhost:9091](http://localhost:9091)\ + To specify another endpoint for the Pushgateway, use the [`Metrics.PushGatewayUrl`](../../fundamentals/configuration.md#metrics-pushgatewayurl) configuration option. + +## Step 3: Run Nethermind + +To enable metrics in Nethermind, set the [`Metrics.Enabled`](../../fundamentals/configuration.md#metrics-enabled) configuration option to `true`. For more options, see the [Metrics](../../fundamentals/configuration.md#metrics) configuration section. + +:::tip +See [Running a node](../../get-started/running-node/running-node.md) for more information on how to run Nethermind. +::: + +Run Nethermind as follows: + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + --metrics-enabled \ + --metrics-pushgatewayurl http://localhost:9091 +``` + +Alternatively, you may add the `nethermind` service to the `docker-compose.yml` file in the repository root to run everything altogether: + +```yaml title="docker-compose.yml" +nethermind: + image: nethermind/nethermind:latest + container_name: nethermind + restart: unless-stopped + links: + - pushgateway + depends_on: + - pushgateway + ports: + - 8545:8545 + - 8551:8551 + - 30303:30303 + ulimits: + nofile: + soft: 1000000 + hard: 1000000 + command: -c mainnet --metrics-enabled --metrics-pushgatewayurl http://pushgateway:9091 + volumes: + - ./keystore:/nethermind/keystore + - ./logs:/nethermind/logs + - ./nethermind_db:/nethermind/nethermind_db + networks: + - metrics +``` + +In this case, you may want to configure your consensus client similarly. diff --git a/versioned_docs/version-1.36.0/monitoring/metrics/metrics.md b/versioned_docs/version-1.36.0/monitoring/metrics/metrics.md new file mode 100644 index 0000000000..1c5b02bcd4 --- /dev/null +++ b/versioned_docs/version-1.36.0/monitoring/metrics/metrics.md @@ -0,0 +1,891 @@ +--- +title: Metrics +sidebar_position: 0 +--- + +Currently, Nethermind provides the following options to monitor and collect metrics about itself: + +- [Grafana and Prometheus](grafana-and-prometheus.md) +- [dotnet-counters](dotnet-counters.md) + +## Parameters by namespace + + + +### Aura + +- #### `nethermind_au_ra_step` \{#au_ra_step\} + + Current AuRa step + +- #### `nethermind_commit_hash_transaction` \{#commit_hash_transaction\} + + RANDAO number of commit hash transactions + +- #### `nethermind_emit_initiate_change` \{#emit_initiate_change\} + + POSDAO number of emit init change transactions + +- #### `nethermind_reported_benign_misbehaviour` \{#reported_benign_misbehaviour\} + + Number of reported benign misbehaviour validators + +- #### `nethermind_reported_malicious_misbehaviour` \{#reported_malicious_misbehaviour\} + + Number of reported malicious misbehaviour validators + +- #### `nethermind_reveal_number` \{#reveal_number\} + + RANDAO number of reveal number transactions + +- #### `nethermind_sealed_transactions` \{#sealed_transactions\} + + Number of sealed transactions generated by engine + +- #### `nethermind_validators_count` \{#validators_count\} + + Number of current AuRa validators + + +### Blockchain + +- #### `nethermind_best_known_block_number` \{#best_known_block_number\} + + The estimated highest block available. + +- #### `nethermind_block_m_gas_per_sec` \{#block_m_gas_per_sec\} + + Histogram of block MGas per second + +- #### `nethermind_block_processing_time_micros` \{#block_processing_time_micros\} + + Histogram of block processing time + +- #### `nethermind_blockchain_height` \{#blockchain_height\} + + The current height of the canonical chain. + +- #### `nethermind_blocks` \{#blocks\} + + Total number of blocks processed + +- #### `nethermind_blocks_sealed` \{#blocks_sealed\} + + Total number of sealed blocks + +- #### `nethermind_failed_block_seals` \{#failed_block_seals\} + + Total number of failed block seals + +- #### `nethermind_gas_limit` \{#gas_limit\} + + Gas Limit for processed blocks + +- #### `nethermind_gas_used` \{#gas_used\} + + Gas Used in processed blocks + +- #### `nethermind_last_difficulty` \{#last_difficulty\} + + Difficulty of the last block + +- #### `nethermind_mgas` \{#mgas\} + + Total MGas processed + +- #### `nethermind_mgas_per_sec` \{#mgas_per_sec\} + + MGas processed per second + +- #### `nethermind_processing_queue_size` \{#processing_queue_size\} + + Number of blocks awaiting for processing. + +- #### `nethermind_recovery_queue_size` \{#recovery_queue_size\} + + Number of blocks awaiting for recovery of public keys from signatures. + +- #### `nethermind_reorganizations` \{#reorganizations\} + + Total number of chain reorganizations + +- #### `nethermind_state_merkleization_time` \{#state_merkleization_time\} + + State root calculation time + +- #### `nethermind_total_difficulty` \{#total_difficulty\} + + Total difficulty on the chain + +- #### `nethermind_transactions` \{#transactions\} + + Total number of transactions processed + + +### Db + +- #### `nethermind_db_block_cache_size` \{#db_block_cache_size\} + + Database block cache size per database + +- #### `nethermind_db_compaction_stats` \{#db_compaction_stats\} + + Metrics extracted from RocksDB Compaction Stats + +- #### `nethermind_db_index_filter_size` \{#db_index_filter_size\} + + Database index and filter size per database + +- #### `nethermind_db_memtable_size` \{#db_memtable_size\} + + Database memtable per database + +- #### `nethermind_db_reads` \{#db_reads\} + + Database reads per database + +- #### `nethermind_db_size` \{#db_size\} + + Database size per database + +- #### `nethermind_db_stats` \{#db_stats\} + + Metrics extracted from RocksDB Compaction Stats and DB Statistics + +- #### `nethermind_db_writes` \{#db_writes\} + + Database writes per database + +- #### `nethermind_state_db_pruning` \{#state_db_pruning\} + + Indicator if StadeDb is being pruned. + +- #### `nethermind_state_reader_reads` \{#state_reader_reads\} + + Number of State Reader reads. + +- #### `nethermind_state_skipped_writes` \{#state_skipped_writes\} + + Number of state trie writes skipped in net. + +- #### `nethermind_state_tree_cache` \{#state_tree_cache\} + + Number of State Trie cache hits. + +- #### `nethermind_state_tree_reads` \{#state_tree_reads\} + + Number of State Trie reads. + +- #### `nethermind_state_tree_writes` \{#state_tree_writes\} + + Number of state trie writes. + +- #### `nethermind_storage_reader_reads` \{#storage_reader_reads\} + + Number of storage reader reads. + +- #### `nethermind_storage_skipped_writes` \{#storage_skipped_writes\} + + Number of storage trie writes skipped in net. + +- #### `nethermind_storage_tree_cache` \{#storage_tree_cache\} + + Number of storage trie cache hits. + +- #### `nethermind_storage_tree_reads` \{#storage_tree_reads\} + + Number of storage trie reads. + +- #### `nethermind_storage_tree_writes` \{#storage_tree_writes\} + + Number of storage trie writes. + + +### Evm + +- #### `nethermind_calls` \{#calls\} + + Number of calls to other contracts. + +- #### `nethermind_code_db_cache` \{#code_db_cache\} + + Number of Code DB cache reads. + +- #### `nethermind_contracts_analysed` \{#contracts_analysed\} + + Number of contracts' code analysed for jump destinations. + +- #### `nethermind_creates` \{#creates\} + + Number of contract create calls. + +- #### `nethermind_empty_calls` \{#empty_calls\} + + Number of calls made to addresses without code. + +- #### `nethermind_evm_exceptions` \{#evm_exceptions\} + + Number of EVM exceptions thrown by contracts. + +- #### `nethermind_exp_opcode` \{#exp_opcode\} + + Number of EXP opcodes executed. + +- #### `nethermind_gas_price_ave` \{#gas_price_ave\} + + Mean tx gas price in block + +- #### `nethermind_gas_price_max` \{#gas_price_max\} + + Maximum tx gas price in block + +- #### `nethermind_gas_price_median` \{#gas_price_median\} + + Median tx gas price in block + +- #### `nethermind_gas_price_min` \{#gas_price_min\} + + Minimum tx gas price in block + +- #### `nethermind_m_copy_opcode` \{#m_copy_opcode\} + + Number of MCOPY opcodes executed. + +- #### `nethermind_number_of_background_tasks_scheduled` \{#number_of_background_tasks_scheduled\} + + The number of tasks currently scheduled in the background. + +- #### `nethermind_op_codes` \{#op_codes\} + + Number of opcodes executed. + +- #### `nethermind_self_destructs` \{#self_destructs\} + + Number of SELFDESTRUCT calls. + +- #### `nethermind_sload_opcode` \{#sload_opcode\} + + Number of SLOAD opcodes executed. + +- #### `nethermind_sstore_opcode` \{#sstore_opcode\} + + Number of SSTORE opcodes executed. + +- #### `nethermind_thread_local_calls` \{#thread_local_calls\} + + Number of calls to other contracts on thread. + +- #### `nethermind_thread_local_contracts_analysed` \{#thread_local_contracts_analysed\} + + Number of contracts' code analysed for jump destinations on thread. + +- #### `nethermind_thread_local_creates` \{#thread_local_creates\} + + Number of contract create calls on thread. + +- #### `nethermind_thread_local_empty_calls` \{#thread_local_empty_calls\} + + Number of calls made to addresses without code on thread. + +- #### `nethermind_thread_local_op_codes` \{#thread_local_op_codes\} + + Number of opcodes executed on thread. + +- #### `nethermind_thread_local_s_load_opcode` \{#thread_local_s_load_opcode\} + + Number of SLOAD opcodes executed on thread. + +- #### `nethermind_thread_local_s_store_opcode` \{#thread_local_s_store_opcode\} + + Number of SSTORE opcodes executed on thread. + +- #### `nethermind_thread_local_self_destructs` \{#thread_local_self_destructs\} + + Number of calls to other contracts on thread. + +- #### `nethermind_tload_opcode` \{#tload_opcode\} + + Number of TLOAD opcodes executed. + +- #### `nethermind_total_background_tasks_queued` \{#total_background_tasks_queued\} + + Total number of tasks queued for background execution. + +- #### `nethermind_tstore_opcode` \{#tstore_opcode\} + + Number of TSTORE opcodes executed. + + +### Evm.Precompiles + +- #### `nethermind_bls_g1_add_precompile` \{#bls_g1_add_precompile\} + + Number of BLS12_G1ADD precompile calls. + +- #### `nethermind_bls_g1_m_s_m_precompile` \{#bls_g1_m_s_m_precompile\} + + Number of BLS12_G1MSM precompile calls. + +- #### `nethermind_bls_g1_mul_precompile` \{#bls_g1_mul_precompile\} + + Number of BLS12_G1MUL precompile calls. + +- #### `nethermind_bls_g2_add_precompile` \{#bls_g2_add_precompile\} + + Number of BLS12_G2ADD precompile calls. + +- #### `nethermind_bls_g2_m_s_m_precompile` \{#bls_g2_m_s_m_precompile\} + + Number of BLS12_G2MSM precompile calls. + +- #### `nethermind_bls_g2_mul_precompile` \{#bls_g2_mul_precompile\} + + Number of BLS12_G2MUL precompile calls. + +- #### `nethermind_bls_map_fp2_to_g2_precompile` \{#bls_map_fp2_to_g2_precompile\} + + Number of BLS12_MAP_FP2_TO_G2 precompile calls. + +- #### `nethermind_bls_map_fp_to_g1_precompile` \{#bls_map_fp_to_g1_precompile\} + + Number of BLS12_MAP_FP_TO_G1 precompile calls. + +- #### `nethermind_bls_pairing_check_precompile` \{#bls_pairing_check_precompile\} + + Number of BLS12_PAIRING_CHECK precompile calls. + +- #### `nethermind_bn254_add_precompile` \{#bn254_add_precompile\} + + Number of BN254_ADD precompile calls. + +- #### `nethermind_bn254_mul_precompile` \{#bn254_mul_precompile\} + + Number of BN254_MUL precompile calls. + +- #### `nethermind_bn254_pairing_precompile` \{#bn254_pairing_precompile\} + + Number of BN254_PAIRING precompile calls. + +- #### `nethermind_ec_recover_precompile` \{#ec_recover_precompile\} + + Number of EC_RECOVERY precompile calls. + +- #### `nethermind_l1_sload_precompile` \{#l1_sload_precompile\} + + Number of L1SLOAD precompile calls. + +- #### `nethermind_mod_exp_precompile` \{#mod_exp_precompile\} + + Number of MODEXP precompile calls. + +- #### `nethermind_point_evaluation_precompile` \{#point_evaluation_precompile\} + + Number of Point Evaluation precompile calls. + +- #### `nethermind_ripemd160_precompile` \{#ripemd160_precompile\} + + Number of RIPEMD160 precompile calls. + +- #### `nethermind_secp256r1_precompile` \{#secp256r1_precompile\} + + Number of Secp256r1 precompile calls. + +- #### `nethermind_sha256_precompile` \{#sha256_precompile\} + + Number of SHA256 precompile calls. + + +### History + +- #### `nethermind_blocks_pruned` \{#blocks_pruned\} + + The number of the historical blocks that have been pruned (since restart). + +- #### `nethermind_oldest_stored_block_number` \{#oldest_stored_block_number\} + + The number of the oldest block stored. + +- #### `nethermind_pruning_cutoff_blocknumber` \{#pruning_cutoff_blocknumber\} + + The cutoff block number from which historical blocks will be pruned. + +- #### `nethermind_pruning_cutoff_timestamp` \{#pruning_cutoff_timestamp\} + + The cutoff timestamp from which historical blocks will be pruned. + + +### JsonRpc + +- #### `nethermind_json_rpc_bytes_received` \{#json_rpc_bytes_received\} + + Number of JSON RPC bytes received. + +- #### `nethermind_json_rpc_bytes_sent` \{#json_rpc_bytes_sent\} + + Number of JSON RPC bytes sent. + +- #### `nethermind_json_rpc_errors` \{#json_rpc_errors\} + + Number of JSON RPC requests processed with errors. + +- #### `nethermind_json_rpc_invalid_requests` \{#json_rpc_invalid_requests\} + + Number of JSON RPC requests that were invalid. + +- #### `nethermind_json_rpc_request_deserialization_failures` \{#json_rpc_request_deserialization_failures\} + + Number of JSON RPC requests that failed JSON deserialization. + +- #### `nethermind_json_rpc_requests` \{#json_rpc_requests\} + + Total number of JSON RPC requests received by the node. + +- #### `nethermind_json_rpc_successes` \{#json_rpc_successes\} + + Number of JSON RPC requests processed successfully. + + +### Merge + +- #### `nethermind_forkchoice_updated_execution_time` \{#forkchoice_updated_execution_time\} + + ForkchoiceUpdated request execution time + +- #### `nethermind_get_blobs_request_duration_seconds` \{#get_blobs_request_duration_seconds\} + + Time taken to return the blobs from engine_getBlobsV2 request + +- #### `nethermind_get_blobs_requests_failure_total` \{#get_blobs_requests_failure_total\} + + Number of responses to engine_getBlobsVX without all requested blobs + +- #### `nethermind_get_blobs_requests_in_blobpool_total` \{#get_blobs_requests_in_blobpool_total\} + + Number of Blobs requested by engine_getBlobsV2 that are present in the blobpool + +- #### `nethermind_get_blobs_requests_success_total` \{#get_blobs_requests_success_total\} + + Number of responses to engine_getBlobsV1 and engine_getBlobsV2 with all requested blobs + +- #### `nethermind_get_blobs_requests_total` \{#get_blobs_requests_total\} + + Number of Blobs requested by engine_getBlobsV2 + +- #### `nethermind_get_payload_requests` \{#get_payload_requests\} + + Number of GetPayload Requests + +- #### `nethermind_new_payload_execution_time` \{#new_payload_execution_time\} + + NewPayload request execution time + +- #### `nethermind_number_of_requested_blobs` \{#number_of_requested_blobs\} + + Number of Blobs requested by engine_getBlobsV1 + +- #### `nethermind_number_of_sent_blobs` \{#number_of_sent_blobs\} + + Number of Blobs sent by engine_getBlobsV1 + +- #### `nethermind_number_of_transactions_in_get_payload` \{#number_of_transactions_in_get_payload\} + + Number of Transactions included in the Last GetPayload Request + + +### Network + +- #### `nethermind_discovery_messages_received` \{#discovery_messages_received\} + + Number of sent discovery message + +- #### `nethermind_discovery_messages_sent` \{#discovery_messages_sent\} + + Number of sent discovery message + +- #### `nethermind_handshake_timeouts` \{#handshake_timeouts\} + + Number of devp2p handshake timeouts + +- #### `nethermind_handshakes` \{#handshakes\} + + Number of devp2p handshakes + +- #### `nethermind_incoming_connections` \{#incoming_connections\} + + Number of incoming connection. + +- #### `nethermind_incoming_p2_p_message_bytes` \{#incoming_p2_p_message_bytes\} + + Bytes of incoming p2p packets. + +- #### `nethermind_incoming_p2_p_messages` \{#incoming_p2_p_messages\} + + Number of incoming p2p packets. + +- #### `nethermind_local_disconnects_total` \{#local_disconnects_total\} + + Number of local disconnects + +- #### `nethermind_outgoing_connections` \{#outgoing_connections\} + + Number of outgoing connection. + +- #### `nethermind_outgoing_p2_p_message_bytes` \{#outgoing_p2_p_message_bytes\} + + Bytes of outgoing p2p packets. + +- #### `nethermind_outgoing_p2_p_messages` \{#outgoing_p2_p_messages\} + + Number of outgoing p2p packets. + +- #### `nethermind_peer_candidate_count` \{#peer_candidate_count\} + + Number of candidate peers in peer manager + +- #### `nethermind_peer_candidate_filter` \{#peer_candidate_filter\} + + Number of filter reason per peer candidate + +- #### `nethermind_peer_limit` \{#peer_limit\} + + The maximum number of peers this node allows to connect. + +- #### `nethermind_remote_disconnects_total` \{#remote_disconnects_total\} + + Number of remote disconnects + + +### Pruning + +- #### `nethermind_cached_nodes_count` \{#cached_nodes_count\} + + Nodes that are currently kept in cache (either persisted or not) + +- #### `nethermind_committed_nodes_count` \{#committed_nodes_count\} + + Nodes that have been committed since the session start. These nodes may have been pruned, persisted or replaced. + +- #### `nethermind_deep_pruning_time` \{#deep_pruning_time\} + + Time taken by the last deep pruning. + +- #### `nethermind_dirty_memory_used_by_cache` \{#dirty_memory_used_by_cache\} + + Estimated memory used by cache. + +- #### `nethermind_dirty_nodes_count` \{#dirty_nodes_count\} + + Nodes that are currently kept in cache (either persisted or not) + +- #### `nethermind_last_persisted_block_number` \{#last_persisted_block_number\} + + Last persisted block number (snapshot). + +- #### `nethermind_loaded_from_cache_nodes_count` \{#loaded_from_cache_nodes_count\} + + Number of reads from the node cache. + +- #### `nethermind_loaded_from_db_nodes_count` \{#loaded_from_db_nodes_count\} + + Number of DB reads. + +- #### `nethermind_loaded_from_rlp_cache_nodes_count` \{#loaded_from_rlp_cache_nodes_count\} + + Number of reads from the RLP cache. + +- #### `nethermind_memory_used_by_cache` \{#memory_used_by_cache\} + + Estimated memory used by cache. + +- #### `nethermind_persisted_node_count` \{#persisted_node_count\} + + Nodes that have been persisted since the session start. + +- #### `nethermind_persisted_node_pruning_time` \{#persisted_node_pruning_time\} + + Time taken by the last persisted node pruning. + +- #### `nethermind_pruned_transient_nodes_count` \{#pruned_transient_nodes_count\} + + Nodes that have been removed from the cache during pruning because they were no longer needed. + +- #### `nethermind_pruning_time` \{#pruning_time\} + + Time taken by the last pruning. + +- #### `nethermind_removed_node_count` \{#removed_node_count\} + + Nodes that was removed via live pruning. + +- #### `nethermind_replaced_nodes_count` \{#replaced_nodes_count\} + + Number of nodes that have been exactly the same as other nodes in the cache when committing. + +- #### `nethermind_snapshot_persistence_time` \{#snapshot_persistence_time\} + + Time taken by the last snapshot persistence. + + +### Runner + +- #### `nethermind_version` \{#version\} + + Version number + + +### Serialization.Rlp + +- #### `nethermind_allocator_active_allocation_bytes` \{#allocator_active_allocation_bytes\} + + Active allocation bytes + +- #### `nethermind_allocator_active_allocations` \{#allocator_active_allocations\} + + Active allocation count + +- #### `nethermind_allocator_allocations` \{#allocator_allocations\} + + Allocations + +- #### `nethermind_allocator_arena_count` \{#allocator_arena_count\} + + Arena count + +- #### `nethermind_allocator_chunk_size` \{#allocator_chunk_size\} + + Chunk size of the allocator + +- #### `nethermind_allocator_used_direct_memory` \{#allocator_used_direct_memory\} + + Used direct memory + +- #### `nethermind_allocator_used_heap_memory` \{#allocator_used_heap_memory\} + + Used heap memory + + +### Shutter + +- #### `nethermind_shutter_bad_transactions` \{#shutter_bad_transactions\} + + Number of invalid transactions that could not be included. + +- #### `nethermind_shutter_encrypted_gas_used` \{#shutter_encrypted_gas_used\} + + Amount of encrypted gas used. + +- #### `nethermind_shutter_eon` \{#shutter_eon\} + + Eon of the latest block. + +- #### `nethermind_shutter_keypers` \{#shutter_keypers\} + + Size of keyper set in current eon. + +- #### `nethermind_shutter_keys_missed` \{#shutter_keys_missed\} + + Number of keys not received. + +- #### `nethermind_shutter_keys_received_time_offset` \{#shutter_keys_received_time_offset\} + + Relative time offset (ms) from slot boundary that keys were received. + +- #### `nethermind_shutter_threshold` \{#shutter_threshold\} + + Number of keypers assumed to be honest and online for current eon. + +- #### `nethermind_shutter_transactions` \{#shutter_transactions\} + + Number of transactions included. + +- #### `nethermind_shutter_tx_pointer` \{#shutter_tx_pointer\} + + Number of transactions since Shutter genesis. + + +### Synchronization + +- #### `nethermind_snap_range_result` \{#snap_range_result\} + + Snap range result + +- #### `nethermind_sync_peers` \{#sync_peers\} + + Number of sync peers. + + +### Trie + +- #### `nethermind_tree_node_hash_calculations` \{#tree_node_hash_calculations\} + + Number of trie node hash calculations. + +- #### `nethermind_tree_node_rlp_decodings` \{#tree_node_rlp_decodings\} + + Number of trie node RLP decodings. + +- #### `nethermind_tree_node_rlp_encodings` \{#tree_node_rlp_encodings\} + + Number of trie node RLP encodings. + + +### TxPool + +- #### `nethermind_blob_transaction_count` \{#blob_transaction_count\} + + Number of blob transactions in pool. + +- #### `nethermind_blob_transactions_in_block` \{#blob_transactions_in_block\} + + Number of blob transactions in the block. + +- #### `nethermind_blobs_in_block` \{#blobs_in_block\} + + Number of blobs in the block. + +- #### `nethermind_dark_pool_ratio_level1` \{#dark_pool_ratio_level1\} + + Ratio of transactions in the block absent in hashCache. + +- #### `nethermind_dark_pool_ratio_level2` \{#dark_pool_ratio_level2\} + + Ratio of transactions in the block absent in pending transactions. + +- #### `nethermind_eip1559_transactions_ratio` \{#eip1559_transactions_ratio\} + + Ratio of 1559-type transactions in the block. + +- #### `nethermind_eip7702_transactions_in_block` \{#eip7702_transactions_in_block\} + + Number of 7702-type transactions in the block. + +- #### `nethermind_pending1559_transactions_added` \{#pending1559_transactions_added\} + + Number of pending 1559-type transactions added to transaction pool. + +- #### `nethermind_pending_blob_transactions_added` \{#pending_blob_transactions_added\} + + Number of pending blob-type transactions added to transaction pool. + +- #### `nethermind_pending_transactions_balance_below_value` \{#pending_transactions_balance_below_value\} + + Number of pending transactions received that were ignored because balance is less than txn value. + +- #### `nethermind_pending_transactions_conflicting_tx_type` \{#pending_transactions_conflicting_tx_type\} + + Number of transactions rejected because of already pending tx of other type (allowed blob txs or others, not both at once). + +- #### `nethermind_pending_transactions_discarded` \{#pending_transactions_discarded\} + + Number of pending transactions received that were ignored. + +- #### `nethermind_pending_transactions_evicted` \{#pending_transactions_evicted\} + + Number of pending transactions evicted from transaction pool. + +- #### `nethermind_pending_transactions_gas_limit_too_high` \{#pending_transactions_gas_limit_too_high\} + + Number of pending transactions received that were ignored because the gas limit was to high for the block. + +- #### `nethermind_pending_transactions_hashes_received` \{#pending_transactions_hashes_received\} + + Number of hashes of pending transactions received from peers. + +- #### `nethermind_pending_transactions_hashes_sent` \{#pending_transactions_hashes_sent\} + + Number of hashes of pending transactions broadcasted to peers. + +- #### `nethermind_pending_transactions_known` \{#pending_transactions_known\} + + Number of already known pending transactions. + +- #### `nethermind_pending_transactions_low_nonce` \{#pending_transactions_low_nonce\} + + Number of transactions with already used nonce. + +- #### `nethermind_pending_transactions_malformed` \{#pending_transactions_malformed\} + + Number of malformed transactions. + +- #### `nethermind_pending_transactions_nonce_gap` \{#pending_transactions_nonce_gap\} + + Number of pending transactions received that were ignored because of not having preceding nonce of this sender in TxPool. + +- #### `nethermind_pending_transactions_nonce_too_far_in_future` \{#pending_transactions_nonce_too_far_in_future\} + + Number of transactions with nonce too far in future. + +- #### `nethermind_pending_transactions_not_supported_tx_type` \{#pending_transactions_not_supported_tx_type\} + + Number of pending transactions received that were ignored because of not supported transaction type. + +- #### `nethermind_pending_transactions_null_hash` \{#pending_transactions_null_hash\} + + Number of pending transactions rejected with a null hash. + +- #### `nethermind_pending_transactions_passed_filters_but_cannot_compete_on_fees` \{#pending_transactions_passed_filters_but_cannot_compete_on_fees\} + + Number of pending transactions received that were ignored after passing early rejections as balance is too low to compete with lowest effective fee in transaction pool. + +- #### `nethermind_pending_transactions_passed_filters_but_cannot_replace` \{#pending_transactions_passed_filters_but_cannot_replace\} + + Number of pending transactions received that were trying to replace tx with the same sender and nonce and failed. + +- #### `nethermind_pending_transactions_received` \{#pending_transactions_received\} + + Number of pending transactions received from peers. + +- #### `nethermind_pending_transactions_sent` \{#pending_transactions_sent\} + + Number of pending transactions broadcasted to peers. + +- #### `nethermind_pending_transactions_size_too_large` \{#pending_transactions_size_too_large\} + + Number of pending transactions rejected due to excessive size. + +- #### `nethermind_pending_transactions_too_low_balance` \{#pending_transactions_too_low_balance\} + + Number of pending transactions received that were ignored because balance too low for fee to be higher than the lowest fee in transaction pool. + +- #### `nethermind_pending_transactions_too_low_fee` \{#pending_transactions_too_low_fee\} + + Number of pending transactions received that were ignored because of fee lower than the lowest fee in transaction pool. + +- #### `nethermind_pending_transactions_too_low_fee_per_blob_gas` \{#pending_transactions_too_low_fee_per_blob_gas\} + + Number of pending transactions received that were ignored because of fee per blob gas lower than minimal requirement. + +- #### `nethermind_pending_transactions_too_low_priority_fee` \{#pending_transactions_too_low_priority_fee\} + + Number of pending transactions received that were ignored because of priority fee lower than minimal requirement. + +- #### `nethermind_pending_transactions_unresolvable_sender` \{#pending_transactions_unresolvable_sender\} + + Number of pending transactions received that were ignored because the sender couldn't be resolved. + +- #### `nethermind_pending_transactions_with_expensive_filtering` \{#pending_transactions_with_expensive_filtering\} + + Number of pending transactions that reached filters which are resource expensive + +- #### `nethermind_pending_transactions_zero_balance` \{#pending_transactions_zero_balance\} + + Number of pending transactions received that were ignored because balance is zero and cannot pay gas. + +- #### `nethermind_transaction_count` \{#transaction_count\} + + Number of transactions in pool. + +- #### `nethermind_transactions_reorged` \{#transactions_reorged\} + + Number of transactions reorganized during chain reorg. + +- #### `nethermind_transactions_sourced_mem_pool` \{#transactions_sourced_mem_pool\} + + Number of transactions sourced from the mempool. + +- #### `nethermind_transactions_sourced_private_order_flow` \{#transactions_sourced_private_order_flow\} + + Number of transactions sourced from private order flow. + + + diff --git a/versioned_docs/version-1.36.0/monitoring/ui.md b/versioned_docs/version-1.36.0/monitoring/ui.md new file mode 100644 index 0000000000..2cd972cd40 --- /dev/null +++ b/versioned_docs/version-1.36.0/monitoring/ui.md @@ -0,0 +1,31 @@ +--- +title: User interface +sidebar_position: 2 +--- + +To provide a richer and more user-friendly experience, Nethermind is bundled with an integrated user interface (UI) to monitor your node. + +![Nethermind UI](/images/ui.png) + +By default, the UI is available on the same host and port as the JSON-RPC interface—namely, the local loopback interface (127.0.0.1 or `localhost`) on port 8545. The UI is disabled by default and can be enabled together with the [health check](./health-check.md) using the [`HealthChecks.Enabled`](../fundamentals/configuration.md#healthchecks-enabled) configuration option as follows: + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + # highlight-start + --healthchecks-enabled + # highlight-end +``` + +If you need to expose the UI to the public while keeping the JSON-RPC interface behind the curtain, you can achieve that by using the [`JsonRpc.AdditionalRpcUrls`](../fundamentals/configuration.md#jsonrpc-additionalrpcurls) configuration option. The following example demonstrates how to expose only the UI to the public IP address while still having JSON-RPC capabilities accessible to local use cases such as consensus client communications: + +```bash +nethermind \ + -c mainnet \ + --data-dir path/to/data/dir \ + # highlight-start + --jsonrpc-additionalrpcurls "http://203.0.113.5:80|http|health" \ + # highlight-end + --healthchecks-enabled +``` diff --git a/versioned_docs/version-1.36.0/resources/_category_.json b/versioned_docs/version-1.36.0/resources/_category_.json new file mode 100644 index 0000000000..3bd533c6b5 --- /dev/null +++ b/versioned_docs/version-1.36.0/resources/_category_.json @@ -0,0 +1,4 @@ +{ + "position": 8, + "label": "Resources" +} diff --git a/versioned_docs/version-1.36.0/troubleshooting.md b/versioned_docs/version-1.36.0/troubleshooting.md new file mode 100644 index 0000000000..14ad133fa8 --- /dev/null +++ b/versioned_docs/version-1.36.0/troubleshooting.md @@ -0,0 +1,89 @@ +--- +title: Troubleshooting +sidebar_position: 8 +--- + +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + +## File descriptor limits + +In some cases, file descriptor limits may cause errors like "Too many open files". To solve that, see the instructions for your platform below. + + + + +To increase the limits for the user running Nethermind (given the process name of `nethermind`), run: + +```bash +sudo echo "nethermind soft nofile 100000" > /etc/security/limits.d/nethermind.conf +sudo echo "nethermind hard nofile 100000" >> /etc/security/limits.d/nethermind.conf +``` + + + + +To increase the limits, run: + +```bash +ulimit -n 10000 +``` + +If you run into issues with the above command, see the [workaround](https://developer.apple.com/forums/thread/735798?answerId=762679022#762679022). + +Note that the changes above are temporary and will be reset after the system reboot. To make them permanent, you can add them to your `~/.bashrc` or `~/.bash_profile` shell configuration file. + + + + +## Database corruption issues + +Database corruption is one of the issues that happen now and then; it has many possible causes among them: + +- Hardware failures: disk failures, memory errors, hardware overheating, etc. +- Power cuts and abrupt shutdowns + +There's no shortcut in such situations, and [resyncing Nethermind from scratch](./fundamentals/sync.md#resync) is the recommended remedy. + +## TrieNodeException errors + +If Nethermind reports `Nethermind.Trie.TrieNodeException` or `Nethermind.Trie.MissingTrieNodeException` errors, that usually indicates database corruption or missing data. The following steps may help: + +- If the node is still syncing, wait until it has been fully synced and observe for errors +- Restart the node and observe for errors +- Update to the latest version of Nethermind +- If the above steps fail, a [resync](./fundamentals/sync.md#resync) may be required + +## Issues with lock files + +If Nethermind complains about the lock files, it perhaps because of one of the following: + +- Another Nethermind process is running using the same database +- The database has not been appropriately closed on the last run.\ + In this case, run the following command from the Nethermind database directory: + + ```bash + find . -type f -name 'LOCK' -delete + ``` + +## Block checksum mismatch + +Sometimes Nethermind may fail with an error similar the following: + +``` +Corruption: block checksum mismatch: expected 2087346143, got 2983326672 in... +``` + +This tends to happen on XFS file systems under very high memory pressure. The issue can be mitigated by using the `--Db.UseDirectIoForFlushAndCompactions true` option although at the cost of performance. + +However, quite often, this is because of memory module issues. + +## Plugin loading failure + +If Nethermind fails to start with a message like `Failed to load plugin...`, this is most likely due to a missing or incompatible plugin. Reinstalling Nethermind usually fixes the issue. + +:::tip +If you install Nethermind over an existing installation, remove the old installation first, particularly the `plugins` directory. Package managers do this automatically. + +Watch out not to accidentally delete the database directory with the sync data, if any. +::: diff --git a/versioned_docs/version-1.36.0/validators/_category_.json b/versioned_docs/version-1.36.0/validators/_category_.json new file mode 100644 index 0000000000..63f915204d --- /dev/null +++ b/versioned_docs/version-1.36.0/validators/_category_.json @@ -0,0 +1,7 @@ +{ + "position": 5, + "label": "Validators", + "link": { + "type": "doc", "id": "validators" + } +} diff --git a/versioned_docs/version-1.36.0/validators/aura.md b/versioned_docs/version-1.36.0/validators/aura.md new file mode 100644 index 0000000000..9439b09482 --- /dev/null +++ b/versioned_docs/version-1.36.0/validators/aura.md @@ -0,0 +1,118 @@ +--- +title: Aura-based validators +sidebar_position: 0 +--- + +This guide will walk you through configuring an Aura-based validator with Nethermind in a Docker container using the Energy Web chain as an example. + +:::info +Your machine's clock has to be synchronized. Otherwise, you might miss block sealing. By default, the block time is set to 5 seconds. +::: + +## Configuring a Docker container + +The example below shows how to configure a Docker container for an Aura-based validator on the Energy Web chain: + +```yaml title="docker-compose.yml" +services: + nethermind-validator: + image: nethermind/nethermind:latest + container_name: nethermind-validator + restart: unless-stopped + ports: + - 8545:8545 + - 30303:30303 + ulimits: + nofile: + soft: 1000000 + hard: 1000000 + environment: + - NETHERMIND_CONFIG=energyweb + volumes: + - ./keystore:/nethermind/keystore + - ./logs:/nethermind/logs + - ./nethermind_db:/nethermind/nethermind_db +``` + +## Configuring keyfile + +Make sure that the keyfile name contains the public key (address). Otherwise, Nethermind doesn't recognize it as such. +For instance, a keyfile can be named `key-0x1234567890123456789012345678901234567890`. + +The keyfile must be stored in the `keystore` directory located in the Nethermind base data directory. + +## Configuration settings + +Here is an example of recommended settings for a validator. The most convenient way to configure these settings is either defining them in the configuration file or passing them as environment variables. + +- `Init.IsMining`: `true` +- `Init.MemoryHint`: Can be left unspecified. It's recommended to configure it accordingly to the machine specification(for Eneergy Web, 768000000 is enough). +- `EthStats` namespace parameters if you want to report node status to Ethstats for your network. +- `Metrics` namespace parameters to enable node monitoring. +- `KeyStore.PasswordFiles`: The path to the file containing the password for the mining private key. +- `KeyStore.UnlockAccounts`: An array of accounts. Provide the miner public address here. +- `KeyStore.BlockAuthorAccount`: The miner public address should be provided here as well. +- `Aura.ForceSealing`: `true` +- `Merge.Enabled`: `false` + +Here's an example of above settings in the Energy Web configuration file: + +```json title="energyweb.json" +{ + "Init": { + "ChainSpecPath": "chainspec/energyweb.json", + "GenesisHash": "0x0b6d3e680af2fc525392c720666cce58e3d8e6fe75ba4b48cb36bcc69039229b", + "BaseDbPath": "nethermind_db/energyweb", + "LogFileName": "energyweb.log", + "MemoryHint": 768000000 + }, + "Sync": { + "FastSync": true, + "PivotNumber": 26940000, + "PivotHash": "0x8835983de9578a4355313afd2a43d8eada6f2a4ddbd9c51da103e0d5f53c4d8b", + "PivotTotalDifficulty": "9167206964850082205703311924211835616257898274", + "FastBlocks": true, + "UseGethLimitsInFastBlocks": false, + "FastSyncCatchUpHeightDelta": 10000000000 + }, + "EthStats": { + "Enabled": true, + "Name": "Nethermind Energy Web", + "Secret": "secret...", + "Url": "ws://localhost:3000/api" + }, + "Metrics": { + "Enabled": true, + "NodeName": "Energy Web", + "PushGatewayUrl": "http://localhost:9091/metrics" + }, + "Mining": { + "MinGasPrice": 1 + }, + "Merge": { + "Enabled": false + }, + "Aura": { + "ForceSealing": true + }, + "KeyStore": { + "PasswordFiles": ["keystore/password"], + "UnlockAccounts": ["0x..."], + "BlockAuthorAccount": "0x..." + }, +} +``` + +## Running the validator + +The above Docker Compose file can be run from the directory the `docker-compose.yml` is located in as follows: + +```bash +docker compose up -d +``` + +To check the logs and verify the sealing of blocks, run: + +```bash +docker compose logs -f nethermind-validator +``` diff --git a/versioned_docs/version-1.36.0/validators/validators.md b/versioned_docs/version-1.36.0/validators/validators.md new file mode 100644 index 0000000000..059171cc97 --- /dev/null +++ b/versioned_docs/version-1.36.0/validators/validators.md @@ -0,0 +1,57 @@ +--- +title: Validators +sidebar_position: 0 +--- + +## General considerations + +:::warning Important +Please check out the [security considerations](../fundamentals/security.md) before using Nethermind as a validator. +::: + +For Ethereum validators, we highly recommend checking out [Staking with Ethereum](https://ethereum.org/staking) and [Validator checklist](https://launchpad.ethereum.org/en/checklist). + +## Hardware configurations + +The following hardware configurations for Ethereum Mainnet validators have been battle-tested by us and our users. We have observed excellent validator performance and stability with these configurations. + +:::note +Before setting up your infrastructure, check out [Nethermind hardware requirements](../get-started/system-requirements.md#hardware-requirements). +::: + +### On-premises + +A single validator on Intel NUC 11: + +- CPU: Intel Core i7-1165G7 +- Memory: Crucial 32GB DDR4-3200 SODIMM +- Storage: Samsung 980 PRO PCIe NVMe SSD 2TB +- Internet speed: 620 Mbps download, 160 Mbps upload + +### AWS + +Multiple validators on the following EC2 instances: + +- [m6i.2xlarge](https://aws.amazon.com/ec2/instance-types/m6i/): 8 vCPU, 32 GiB memory +- [m7g.2xlarge](https://aws.amazon.com/ec2/instance-types/m7g/): 8 vCPU, 32 GiB memory + +These configurations have proven to work well for 1000-1500 validators and haven't been tested for more validators. Also, the validator clients have been separated from the consensus and execution clients and running on [t4g.small](https://aws.amazon.com/ec2/instance-types/t4/) instances. + +### Azure + +Multiple validators on the following VM instances: + +- [Standard_D8_v5](https://learn.microsoft.com/en-us/azure/virtual-machines/dv5-dsv5-series#dv5-series): 8 vCPU, 32 GiB memory +- [Standard_D8ps_v5](https://learn.microsoft.com/en-us/azure/virtual-machines/dpsv5-dpdsv5-series#dpsv5-series): 8 vCPU, 32 GiB memory + +These configurations have proven to work well for 1000-1500 validators and haven't been tested for more validators. Also, the validator clients have been separated from the consensus and execution clients and running on [Standard_D2pls_v5](https://learn.microsoft.com/en-us/azure/virtual-machines/dplsv5-dpldsv5-series#dplsv5-series) instances. + +### GCP + +Multiple validators on the [c2d-highmem-4](https://cloud.google.com/compute/docs/compute-optimized-machines#c2d-high-mem) instance: 4 vCPU, 32 GB memory + +These configurations have proven to work well for 1000-1500 validators and haven't been tested for more validators. Also, the validator clients have been separated from the consensus and execution clients and running on [e2-small](https://cloud.google.com/compute/docs/general-purpose-machines#sharedcore) instances. + +## Gnosis validators + +To set up a Gnosis Chain validator, see the [Gnosis Chain documentation](https://docs.gnosischain.com/node). diff --git a/versioned_sidebars/version-1.36.0-sidebars.json b/versioned_sidebars/version-1.36.0-sidebars.json new file mode 100644 index 0000000000..caea0c03ba --- /dev/null +++ b/versioned_sidebars/version-1.36.0-sidebars.json @@ -0,0 +1,8 @@ +{ + "tutorialSidebar": [ + { + "type": "autogenerated", + "dirName": "." + } + ] +} diff --git a/versions.json b/versions.json index 68f1890609..5f59c76aa4 100644 --- a/versions.json +++ b/versions.json @@ -1,4 +1,5 @@ [ + "1.36.0", "1.35.0", "1.34.0", "1.33.0",