# reth node

Start the node

```bash
$ reth node --help
```
```txt
Usage: reth node [OPTIONS]

Options:
      --config <FILE>
          The path to the configuration file to use.

      --chain <CHAIN_OR_PATH>
          The chain this node is running.
          Possible values are either a built-in chain or the path to a chain specification file.

          Built-in chains:
              mainnet, sepolia, holesky, hoodi, dev

          [default: mainnet]

      --instance <INSTANCE>
          Add a new instance of a node.

          Configures the ports of the node to avoid conflicts with the defaults. This is useful for running multiple nodes on the same machine.

          Max number of instances is 200. It is chosen in a way so that it's not possible to have port numbers that conflict with each other.

          Changes to the following port numbers: - `DISCOVERY_PORT`: default + `instance` - 1 - `AUTH_PORT`: default + `instance` * 100 - 100 - `HTTP_RPC_PORT`: default - `instance` + 1 - `WS_RPC_PORT`: default + `instance` * 2 - 2 - `IPC_PATH`: default + `-instance`

      --with-unused-ports
          Sets all ports to unused, allowing the OS to choose random unused ports when sockets are bound.

          Mutually exclusive with `--instance`.

  -h, --help
          Print help (see a summary with '-h')

Metrics:
      --metrics <PROMETHEUS>
          Enable Prometheus metrics.

          The metrics will be served at the given interface and port.

      --metrics.prometheus.push.url <PUSH_GATEWAY_URL>
          URL for pushing Prometheus metrics to a push gateway.

          If set, the node will periodically push metrics to the specified push gateway URL.

      --metrics.prometheus.push.interval <SECONDS>
          Interval in seconds for pushing metrics to push gateway.

          Default: 5 seconds

          [default: 5]

Datadir:
      --datadir <DATA_DIR>
          The path to the data dir for all reth files and subdirectories.

          Defaults to the OS-specific data directory:

          - Linux: `$XDG_DATA_HOME/reth/` or `$HOME/.local/share/reth/`
          - Windows: `{FOLDERID_RoamingAppData}/reth/`
          - macOS: `$HOME/Library/Application Support/reth/`

          [default: default]

      --datadir.static-files <PATH>
          The absolute path to store static files in.

      --datadir.rocksdb <PATH>
          The absolute path to store `RocksDB` database in.

      --datadir.pprof-dumps <PATH>
          The absolute path to store pprof dumps in.

Networking:
  -d, --disable-discovery
          Disable the discovery service

      --disable-dns-discovery
          Disable the DNS discovery

      --disable-discv4-discovery
          Disable Discv4 discovery

      --disable-discv5-discovery
          Disable Discv5 discovery

      --disable-nat
          Disable Nat discovery

      --discovery.addr <DISCOVERY_ADDR>
          The UDP address to use for devp2p peer discovery version 4.

          If unset and `--net-if.experimental` is used, discv4 binds to the resolved interface address.

          [default: 0.0.0.0]

      --discovery.port <DISCOVERY_PORT>
          The UDP port to use for devp2p peer discovery version 4

          [default: 30303]

      --discovery.v5.addr <DISCOVERY_V5_ADDR>
          The UDP IPv4 address to use for devp2p peer discovery version 5. Overwritten by `RLPx` address, if it's also IPv4

      --discovery.v5.addr.ipv6 <DISCOVERY_V5_ADDR_IPV6>
          The UDP IPv6 address to use for devp2p peer discovery version 5. Overwritten by `RLPx` address, if it's also IPv6

      --discovery.v5.port <DISCOVERY_V5_PORT>
          The UDP IPv4 port to use for devp2p peer discovery version 5. Not used unless `--addr` is IPv4, or `--discovery.v5.addr` is set

          [default: 9200]

      --discovery.v5.port.ipv6 <DISCOVERY_V5_PORT_IPV6>
          The UDP IPv6 port to use for devp2p peer discovery version 5. Not used unless `--addr` is IPv6, or `--discovery.addr.ipv6` is set.

          If not provided, discovery V5 defaults to same port as discovery V4 (--discovery.port).

          [default: 9200]

      --discovery.v5.lookup-interval <DISCOVERY_V5_LOOKUP_INTERVAL>
          The interval in seconds at which to carry out periodic lookup queries, for the whole run of the program

          [default: 20]

      --discovery.v5.bootstrap.lookup-interval <DISCOVERY_V5_BOOTSTRAP_LOOKUP_INTERVAL>
          The interval in seconds at which to carry out boost lookup queries, for a fixed number of times, at bootstrap

          [default: 5]

      --discovery.v5.bootstrap.lookup-countdown <DISCOVERY_V5_BOOTSTRAP_LOOKUP_COUNTDOWN>
          The number of times to carry out boost lookup queries at bootstrap

          [default: 200]

      --trusted-peers <TRUSTED_PEERS>
          Comma separated enode URLs or ENRs of trusted peers for P2P connections.

          --trusted-peers enode://abcd@192.168.0.1:30303

      --trusted-only
          Connect to or accept from trusted peers only

      --bootnodes <BOOTNODES>
          Comma separated enode URLs or ENRs for P2P discovery bootstrap.

          Will fall back to a network-specific default if not specified.

      --dns-retries <DNS_RETRIES>
          Amount of DNS resolution requests retries to perform when peering

          [default: 0]

      --peers-file <FILE>
          The path to the known peers file. Connected peers are dumped to this file on nodes
          shutdown, and read on startup. Cannot be used with `--no-persist-peers`.

      --identity <IDENTITY>
          Custom node identity

          [default: reth/<VERSION>-<SHA>/<ARCH>]

      --p2p-secret-key <PATH>
          Secret key to use for this node.

          This will also deterministically set the peer ID. If not specified, it will be set in the data dir for the chain being used.

      --p2p-secret-key-hex <HEX>
          Hex encoded secret key to use for this node.

          This will also deterministically set the peer ID. Cannot be used together with `--p2p-secret-key`.

      --no-persist-peers
          Do not persist peers.

      --nat <NAT>
          NAT resolution method (any|none|upnp|publicip|extip:\<IP\>)

          [default: any]

      --addr <ADDR>
          Network listening address

          [default: 0.0.0.0]

      --port <PORT>
          Network listening port

          [default: 30303]

      --max-outbound-peers <MAX_OUTBOUND_PEERS>
          Maximum number of outbound peers. default: 100

      --max-inbound-peers <MAX_INBOUND_PEERS>
          Maximum number of inbound peers. default: 30

      --max-peers <COUNT>
          Maximum number of total peers (inbound + outbound).

          Splits peers using approximately 2:1 inbound:outbound ratio. Cannot be used together with `--max-outbound-peers` or `--max-inbound-peers`.

      --max-tx-reqs <COUNT>
          Max concurrent `GetPooledTransactions` requests.

          [default: 130]

      --max-tx-reqs-peer <COUNT>
          Max concurrent `GetPooledTransactions` requests per peer.

          [default: 1]

      --max-seen-tx-history <COUNT>
          Max number of seen transactions to remember per peer.

          Default is 320 transaction hashes.

          [default: 320]

      --max-pending-imports <COUNT>
          Max number of transactions to import concurrently.

          [default: 4096]

      --pooled-tx-response-soft-limit <BYTES>
          Experimental, for usage in research. Sets the max accumulated byte size of transactions
          to pack in one response.
          Spec'd at 2MiB.

          [default: 2097152]

      --pooled-tx-pack-soft-limit <BYTES>
          Experimental, for usage in research. Sets the max accumulated byte size of transactions to
          request in one request.

          Since `RLPx` protocol version 68, the byte size of a transaction is shared as metadata in a
          transaction announcement (see `RLPx` specs). This allows a node to request a specific size
          response.

          By default, nodes request only 128 KiB worth of transactions, but should a peer request
          more, up to 2 MiB, a node will answer with more than 128 KiB.

          Default is 128 KiB.

          [default: 131072]

      --max-tx-pending-fetch <COUNT>
          Max capacity of cache of hashes for transactions pending fetch.

          [default: 25600]

      --tx-channel-memory-limit <BYTES>
          Memory limit (in bytes) for the channel that buffers transaction events flowing
          from the network manager to the transactions manager.

          When the budget is exhausted, new events are dropped (see metric
          `total_dropped_tx_events_at_full_capacity`). Acts as a backstop against unbounded
          memory growth under sustained P2P transaction flooding.

          [default: 1073741824]

      --net-if.experimental <IF_NAME>
          Name of network interface used to communicate with peers.

          If flag is set, but no value is passed, the default interface for docker `eth0` is tried. If `--discovery.addr` is left at its default, discv4 will also bind to the resolved interface address.

      --tx-propagation-policy <TX_PROPAGATION_POLICY>
          Transaction Propagation Policy

          The policy determines which peers transactions are gossiped to.

          [default: All]

      --tx-ingress-policy <TX_INGRESS_POLICY>
          Transaction ingress policy

          Determines which peers' transactions are accepted over P2P.

          [default: All]

      --disable-tx-gossip
          Disable transaction pool gossip

          Disables gossiping of transactions in the mempool to peers. This can be omitted for personal nodes, though providers should always opt to enable this flag.

      --tx-propagation-mode <PROPAGATION_MODE>
          Sets the transaction propagation mode by determining how new pending transactions are propagated to other peers in full.

          Examples: sqrt, all, max:10

          [default: sqrt]

      --required-block-hashes <REQUIRED_BLOCK_HASHES>
          Comma separated list of required block hashes or block number=hash pairs. Peers that don't have these blocks will be filtered out. Format: hash or `block_number=hash` (e.g., 23115201=0x1234...)

      --network-id <NETWORK_ID>
          Optional network ID to override the chain specification's network ID for P2P connections

      --eth-max-message-size <BYTES>
          Maximum allowed ETH message size in bytes. Default is 10 MiB

      --netrestrict <NETRESTRICT>
          Restrict network communication to the given IP networks (CIDR masks).

          Comma separated list of CIDR network specifications. Only peers with IP addresses within these ranges will be allowed to connect.

          Example: --netrestrict "192.168.0.0/16,10.0.0.0/8"

      --enforce-enr-fork-id
          Enforce EIP-868 ENR fork ID validation for discovered peers.

          When enabled, peers discovered without a confirmed fork ID are not added to the peer set until their fork ID is verified via EIP-868 ENR request. This filters out peers from other networks that pollute the discovery table.

RPC:
      --http
          Enable the HTTP-RPC server

      --http.addr <HTTP_ADDR>
          Http server address to listen on

          [default: 127.0.0.1]

      --http.port <HTTP_PORT>
          Http server port to listen on

          [default: 8545]

      --http.disable-compression
          Disable compression for HTTP responses

      --http.api <HTTP_API>
          Rpc Modules to be configured for the HTTP server

          [possible values: admin, debug, eth, net, trace, txpool, web3, rpc, reth, ots, flashbots, miner, mev, testing]

      --http.corsdomain <HTTP_CORSDOMAIN>
          Http Corsdomain to allow request from

      --ws
          Enable the WS-RPC server

      --ws.addr <WS_ADDR>
          Ws server address to listen on

          [default: 127.0.0.1]

      --ws.port <WS_PORT>
          Ws server port to listen on

          [default: 8546]

      --ws.origins <ws.origins>
          Origins from which to accept `WebSocket` requests

      --ws.api <WS_API>
          Rpc Modules to be configured for the WS server

          [possible values: admin, debug, eth, net, trace, txpool, web3, rpc, reth, ots, flashbots, miner, mev, testing]

      --ipcdisable
          Disable the IPC-RPC server

      --ipcpath <IPCPATH>
          Filename for IPC socket/pipe within the datadir

          [default: <CACHE_DIR>.ipc]

      --ipc.permissions <IPC_SOCKET_PERMISSIONS>
          Set the permissions for the IPC socket file, in octal format.

          If not specified, the permissions will be set by the system's umask.

      --authrpc.addr <AUTH_ADDR>
          Auth server address to listen on

          [default: 127.0.0.1]

      --authrpc.port <AUTH_PORT>
          Auth server port to listen on

          [default: 8551]

      --authrpc.jwtsecret <PATH>
          Path to a JWT secret to use for the authenticated engine-API RPC server.

          This will enforce JWT authentication for all requests coming from the consensus layer.

          If no path is provided, a secret will be generated and stored in the datadir under `<DIR>/<CHAIN_ID>/jwt.hex`. For mainnet this would be `~/.local/share/reth/mainnet/jwt.hex` by default.

      --auth-ipc
          Enable auth engine API over IPC

      --auth-ipc.path <AUTH_IPC_PATH>
          Filename for auth IPC socket/pipe within the datadir

          [default: <CACHE_DIR>_engine_api.ipc]

      --disable-auth-server
          Disable the auth/engine API server.

          This will prevent the authenticated engine-API server from starting. Use this if you're running a node that doesn't need to serve engine API requests.

      --rpc.jwtsecret <HEX>
          Hex encoded JWT secret to authenticate the regular RPC server(s), see `--http.api` and `--ws.api`.

          This is __not__ used for the authenticated engine-API RPC server, see `--authrpc.jwtsecret`.

      --rpc.disable-metrics
          Disable built-in RPC request metrics

      --rpc.max-request-size <RPC_MAX_REQUEST_SIZE>
          Set the maximum RPC request payload size for both HTTP and WS in megabytes

          [default: 15]

      --rpc.max-response-size <RPC_MAX_RESPONSE_SIZE>
          Set the maximum RPC response payload size for both HTTP and WS in megabytes

          [default: 160]
          [aliases: --rpc.returndata.limit]

      --rpc.max-subscriptions-per-connection <RPC_MAX_SUBSCRIPTIONS_PER_CONNECTION>
          Set the maximum concurrent subscriptions per connection

          [default: 1024]

      --rpc.max-connections <COUNT>
          Maximum number of RPC server connections

          [default: 500]

      --rpc.max-tracing-requests <COUNT>
          Maximum number of concurrent tracing requests.

          By default this chooses a sensible value based on the number of available cores. Tracing requests are generally CPU bound. Choosing a value that is higher than the available CPU cores can have a negative impact on the performance of the node and affect the node's ability to maintain sync.

          [default: <NUM CPU CORES-2>]

      --rpc.max-blocking-io-requests <COUNT>
          Maximum number of concurrent blocking IO requests.

          Blocking IO requests include `eth_call`, `eth_estimateGas`, and similar methods that require EVM execution. These are spawned as blocking tasks to avoid blocking the async runtime.

          [default: 256]

      --rpc.max-trace-filter-blocks <COUNT>
          Maximum number of blocks for `trace_filter` requests

          [default: 100]

      --rpc.max-blocks-per-filter <COUNT>
          Maximum number of blocks that could be scanned per filter request. (0 = entire chain)

          [default: 100000]

      --rpc.max-logs-per-response <COUNT>
          Maximum number of logs that can be returned in a single response. (0 = no limit)

          [default: 20000]

      --rpc.gascap <GAS_CAP>
          Maximum gas limit for `eth_call` and call tracing RPC methods

          [default: 50000000]

      --rpc.evm-memory-limit <MEMORY_LIMIT>
          Maximum memory the EVM can allocate per RPC request

          [default: 4294967295]

      --rpc.txfeecap <TX_FEE_CAP>
          Maximum eth transaction fee (in ether) that can be sent via the RPC APIs (0 = no cap)

          [default: 1.0]

      --rpc.max-simulate-blocks <BLOCKS_COUNT>
          Maximum number of blocks for `eth_simulateV1` call

          [default: 256]

      --rpc.compute-state-root-for-eth-simulate
          Compute state roots for `eth_simulateV1` responses

          [env: RETH_RPC_COMPUTE_STATE_ROOT_FOR_ETH_SIMULATE=]

      --rpc.eth-proof-window <RPC_ETH_PROOF_WINDOW>
          The maximum proof window for historical proof generation. This value allows for generating historical proofs up to configured number of blocks from current tip (up to `tip - window`)

          [default: 0]

      --rpc.proof-permits <COUNT>
          Maximum number of concurrent getproof requests

          [default: 25]

      --rpc.pending-block <KIND>
          Configures the pending block behavior for RPC responses.

          Options: full (include all transactions), empty (header only), none (disable pending blocks).

          [default: full]

      --rpc.forwarder <FORWARDER>
          Endpoint to forward transactions to

      --builder.disallow <PATH>
          Path to file containing disallowed addresses, json-encoded list of strings. Block validation API will reject blocks containing transactions from these addresses

RPC State Cache:
      --rpc-cache.max-blocks <MAX_BLOCKS>
          Max number of blocks in cache

          [default: 5000]

      --rpc-cache.max-receipts <MAX_RECEIPTS>
          Max number receipts in cache

          [default: 2000]

      --rpc-cache.max-headers <MAX_HEADERS>
          Max number of headers in cache

          [default: 1000]

      --rpc-cache.max-bals <MAX_BALS>
          Max number of block access lists in cache

          [default: 1000]

      --rpc-cache.max-concurrent-db-requests <MAX_CONCURRENT_DB_REQUESTS>
          Max number of concurrent database requests

          [default: 512]

      --rpc-cache.max-cached-tx-hashes <MAX_CACHED_TX_HASHES>
          Maximum number of transaction hashes to cache for transaction lookups

          [default: 30000]

Gas Price Oracle:
      --gpo.blocks <BLOCKS>
          Number of recent blocks to check for gas price

          [default: 20]

      --gpo.ignoreprice <IGNORE_PRICE>
          Gas Price below which gpo will ignore transactions

          [default: 0]

      --gpo.maxprice <MAX_PRICE>
          Maximum transaction priority fee(or gasprice before London Fork) to be recommended by gpo

          [default: 500000000000]

      --gpo.percentile <PERCENTILE>
          The percentile of gas prices to use for the estimate

          [default: 60]

      --gpo.default-suggested-fee <DEFAULT_SUGGESTED_FEE>
          The default gas price to use if there are no blocks to use

      --rpc.send-raw-transaction-sync-timeout <SECONDS>
          Timeout for `send_raw_transaction_sync` RPC method

          [default: 30s]

      --testing.skip-invalid-transactions
          Skip invalid transactions in `testing_buildBlockV1` instead of failing.

          When enabled, transactions that fail execution will be skipped, and all subsequent transactions from the same sender will also be skipped.

      --rpc.force-blob-sidecar-upcasting
          Force upcasting EIP-4844 blob sidecars to EIP-7594 format when Osaka is active.

          When enabled, blob transactions submitted via `eth_sendRawTransaction` with EIP-4844 sidecars will be automatically converted to EIP-7594 format if the next block is Osaka. By default this is disabled, meaning transactions are submitted as-is.

TxPool:
      --txpool.pending-max-count <PENDING_MAX_COUNT>
          Max number of transactions in the pending sub-pool

          [default: 10000]

      --txpool.pending-max-size <PENDING_MAX_SIZE>
          Max size of the pending sub-pool in megabytes

          [default: 20]

      --txpool.basefee-max-count <BASEFEE_MAX_COUNT>
          Max number of transactions in the basefee sub-pool

          [default: 10000]

      --txpool.basefee-max-size <BASEFEE_MAX_SIZE>
          Max size of the basefee sub-pool in megabytes

          [default: 20]

      --txpool.queued-max-count <QUEUED_MAX_COUNT>
          Max number of transactions in the queued sub-pool

          [default: 10000]

      --txpool.queued-max-size <QUEUED_MAX_SIZE>
          Max size of the queued sub-pool in megabytes

          [default: 20]

      --txpool.blobpool-max-count <BLOBPOOL_MAX_COUNT>
          Max number of transactions in the blobpool

          [default: 10000]

      --txpool.blobpool-max-size <BLOBPOOL_MAX_SIZE>
          Max size of the blobpool in megabytes

          [default: 20]

      --txpool.blob-cache-size <BLOB_CACHE_SIZE>
          Max number of entries for the in memory cache of the blob store

      --txpool.disable-blobs-support
          Disable EIP-4844 blob transaction support

      --txpool.max-account-slots <MAX_ACCOUNT_SLOTS>
          Max number of executable transaction slots guaranteed per account

          [default: 16]

      --txpool.pricebump <PRICE_BUMP>
          Price bump (in %) for the transaction pool underpriced check

          [default: 10]

      --txpool.minimal-protocol-fee <MINIMAL_PROTOCOL_BASEFEE>
          Minimum base fee required by the protocol

          [default: 7]

      --txpool.minimum-priority-fee <MINIMUM_PRIORITY_FEE>
          Minimum priority fee required for transaction acceptance into the pool. Transactions with priority fee below this value will be rejected

      --txpool.gas-limit <ENFORCED_GAS_LIMIT>
          The default enforced gas limit for transactions entering the pool

          [default: 30000000]

      --txpool.max-tx-gas <MAX_TX_GAS_LIMIT>
          Maximum gas limit for individual transactions. Transactions exceeding this limit will be rejected by the transaction pool

      --blobpool.pricebump <BLOB_TRANSACTION_PRICE_BUMP>
          Price bump percentage to replace an already existing blob transaction

          [default: 100]

      --txpool.max-tx-input-bytes <MAX_TX_INPUT_BYTES>
          Max size in bytes of a single transaction allowed to enter the pool

          [default: 131072]

      --txpool.max-cached-entries <MAX_CACHED_ENTRIES>
          The maximum number of blobs to keep in the in memory blob cache

          [default: 100]

      --txpool.nolocals
          Flag to disable local transaction exemptions

      --txpool.locals <LOCALS>
          Flag to allow certain addresses as local

      --txpool.no-local-transactions-propagation
          Flag to toggle local transaction propagation

      --txpool.additional-validation-tasks <ADDITIONAL_VALIDATION_TASKS>
          Number of additional transaction validation tasks to spawn

          [default: 1]

      --txpool.max-pending-txns <PENDING_TX_LISTENER_BUFFER_SIZE>
          Maximum number of pending transactions from the network to buffer

          [default: 2048]

      --txpool.max-new-txns <NEW_TX_LISTENER_BUFFER_SIZE>
          Maximum number of new transactions to buffer

          [default: 1024]

      --txpool.max-new-pending-txs-notifications <MAX_NEW_PENDING_TXS_NOTIFICATIONS>
          How many new pending transactions to buffer and send to in progress pending transaction iterators

          [default: 200]

      --txpool.lifetime <DURATION>
          Maximum amount of time non-executable transaction are queued

          [default: 10800]

      --txpool.transactions-backup <PATH>
          Path to store the local transaction backup at, to survive node restarts

      --txpool.disable-transactions-backup
          Disables transaction backup to disk on node shutdown

      --txpool.max-batch-size <MAX_BATCH_SIZE>
          Max batch size for transaction pool insertions

          [default: 1]

Builder:
      --builder.extradata <EXTRA_DATA>
          Block extra data set by the payload builder.

          If the value is a `0x`-prefixed hex string, it is decoded into raw bytes. Otherwise, the raw UTF-8 bytes of the string are used.

          [default: reth/<VERSION>/<OS>]

      --builder.gaslimit <GAS_LIMIT>
          Target gas limit for built blocks

      --builder.interval <DURATION>
          The interval at which the job should build a new payload after the last.

          Interval is specified in seconds or in milliseconds if the value ends with `ms`: * `50ms` -> 50 milliseconds * `1` -> 1 second

          [default: 1]

      --builder.deadline <SECONDS>
          The deadline for when the payload builder job should resolve

          [default: 12]

      --builder.max-tasks <MAX_PAYLOAD_TASKS>
          Maximum number of tasks to spawn for building a payload

          [default: 3]

      --builder.max-blobs <COUNT>
          Maximum number of blobs to include per block

Debug:
      --debug.terminate
          Flag indicating whether the node should be terminated after the pipeline sync

      --debug.tip <TIP>
          Set the chain tip manually for testing purposes.

          NOTE: This is a temporary flag

      --debug.max-block <MAX_BLOCK>
          Runs the sync only up to the specified block

      --debug.etherscan [<ETHERSCAN_API_URL>]
          Runs a fake consensus client that advances the chain using recent block hashes on Etherscan. If specified, requires an `ETHERSCAN_API_KEY` environment variable

      --debug.rpc-consensus-url <RPC_URL>
          Runs a fake consensus client using blocks fetched from an RPC endpoint. Supports both HTTP and `WebSocket` endpoints - `WebSocket` endpoints will use subscriptions, while HTTP endpoints will poll for new blocks

      --debug.skip-fcu <SKIP_FCU>
          If provided, the engine will skip `n` consecutive FCUs

      --debug.skip-new-payload <SKIP_NEW_PAYLOAD>
          If provided, the engine will skip `n` consecutive new payloads

      --debug.skip-genesis-validation
          If set, bypasses genesis hash validation during init. Intended for tools that direct-write the database (e.g. snapshot importers, state-actor) and want reth to trust the DB-resident genesis state instead of recomputing it from the chainspec's alloc. When the bypass fires, a structured `tracing::warn!` is emitted so the divergence stays observable in operator logs

      --debug.reorg-frequency <REORG_FREQUENCY>
          If provided, the chain will be reorged at specified frequency

      --debug.reorg-depth <REORG_DEPTH>
          The reorg depth for chain reorgs

      --debug.engine-api-store <PATH>
          The path to store engine API messages at. If specified, all of the intercepted engine API messages will be written to specified location

      --debug.invalid-block-hook <INVALID_BLOCK_HOOK>
          Determines which type of invalid block hook to install

          Example: `witness,prestate`

          [default: witness]
          [possible values: witness, pre-state, opcode]

      --debug.healthy-node-rpc-url <URL>
          The RPC URL of a healthy node to use for comparing invalid block hook results against.

          Debug setting that enables execution witness comparison for troubleshooting bad blocks.
          When enabled, the node will collect execution witnesses from the specified source and
          compare them against local execution when a bad block is encountered, helping identify
          discrepancies in state execution.

      --ethstats <ETHSTATS>
          The URL of the ethstats server to connect to. Example: `nodename:secret@host:port`

      --debug.startup-sync-state-idle
          Set the node to idle state when the backfill is not running.

          This makes the `eth_syncing` RPC return "Idle" when the node has just started or finished the backfill, but did not yet receive any new blocks.

Database:
      --db.log-level <LOG_LEVEL>
          Database logging level. Levels higher than "notice" require a debug build

          Possible values:
          - fatal:   Enables logging for critical conditions, i.e. assertion failures
          - error:   Enables logging for error conditions
          - warn:    Enables logging for warning conditions
          - notice:  Enables logging for normal but significant condition
          - verbose: Enables logging for verbose informational
          - debug:   Enables logging for debug-level messages
          - trace:   Enables logging for trace debug-level messages
          - extra:   Enables logging for extra debug-level messages

      --db.exclusive <EXCLUSIVE>
          Open environment in exclusive/monopolistic mode. Makes it possible to open a database on an NFS volume

          [possible values: true, false]

      --db.max-size <MAX_SIZE>
          Maximum database size (e.g., 4TB, 8TB).

          This sets the "map size" of the database. If the database grows beyond this limit, the node will stop with an "environment map size limit reached" error.

          The default value is 8TB.

      --db.page-size <PAGE_SIZE>
          Database page size (e.g., 4KB, 8KB, 16KB).

          Specifies the page size used by the MDBX database.

          The page size determines the maximum database size. MDBX supports up to 2^31 pages, so with the default 4KB page size, the maximum database size is 8TB. To allow larger databases, increase this value to 8KB or higher.

          WARNING: This setting is only configurable at database creation; changing it later requires re-syncing.

      --db.growth-step <GROWTH_STEP>
          Database growth step (e.g., 4GB, 4KB)

      --db.read-transaction-timeout <READ_TRANSACTION_TIMEOUT>
          Read transaction timeout in seconds, 0 means no timeout

      --db.max-readers <MAX_READERS>
          Maximum number of readers allowed to access the database concurrently

      --db.sync-mode <SYNC_MODE>
          Controls how aggressively the database synchronizes data to disk

      --db.rocksdb-block-cache-size <ROCKSDB_BLOCK_CACHE_SIZE>
          `RocksDB` block cache size (e.g., 512MB, 4GB).

          Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.

      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
          Number of recent blocks to keep in the in-memory BAL store cache

      --db.disable-metrics
          Disable built-in database metrics

Dev testnet:
      --dev
          Start the node in dev mode

          This mode uses a local proof-of-authority consensus engine with either fixed block times
          or automatically mined blocks.
          Disables network discovery and enables local http server.
          Prefunds 20 accounts derived by mnemonic "test test test test test test test test test test
          test junk" with 10 000 ETH each.

      --dev.block-max-transactions <BLOCK_MAX_TRANSACTIONS>
          How many transactions to mine per block

      --dev.block-time <BLOCK_TIME>
          Interval between blocks.

          Parses strings using [`humantime::parse_duration`]
          --dev.block-time 12s

      --dev.finality-depth <FINALITY_DEPTH>
          Number of confirmations required before a block is finalized.

          A depth of `1` finalizes the canonical head immediately.

          [default: 64]

      --dev.payload-wait-time <PAYLOAD_WAIT_TIME>
          Time to wait after initiating payload building before resolving.

          Introduces a sleep between `fork_choice_updated` and `resolve_kind` in the
          local miner, giving the payload job time for multiple rebuild attempts with
          new transactions from the pool.

          Parses strings using [`humantime::parse_duration`]
          --dev.payload-wait-time 450ms

      --dev.mnemonic <MNEMONIC>
          Derive dev accounts from a fixed mnemonic instead of random ones.

          [default: "test test test test test test test test test test test junk"]

Pruning:
      --full
          Run full node. Only the most recent [`MINIMUM_UNWIND_SAFE_DISTANCE`] block states are stored

      --minimal
          Run minimal storage mode with maximum pruning and smaller static files.

          This mode configures the node to use minimal disk space by: - Fully pruning sender recovery, transaction lookup, receipts - Leaving 10,064 blocks for account, storage history and block bodies - Using 10,000 blocks per static file segment

      --prune.block-interval <BLOCK_INTERVAL>
          Minimum pruning interval measured in blocks

      --prune.sender-recovery.full
          Prunes all sender recovery data

      --prune.sender-recovery.distance <BLOCKS>
          Prune sender recovery data before the `head-N` block number. In other words, keep last N + 1 blocks

      --prune.sender-recovery.before <BLOCK_NUMBER>
          Prune sender recovery data before the specified block number. The specified block number is not pruned

      --prune.transaction-lookup.full
          Prunes all transaction lookup data

      --prune.transaction-lookup.distance <BLOCKS>
          Prune transaction lookup data before the `head-N` block number. In other words, keep last N + 1 blocks

      --prune.transaction-lookup.before <BLOCK_NUMBER>
          Prune transaction lookup data before the specified block number. The specified block number is not pruned

      --prune.receipts.full
          Prunes all receipt data

      --prune.receipts.pre-merge
          Prune receipts before the merge block

      --prune.receipts.distance <BLOCKS>
          Prune receipts before the `head-N` block number. In other words, keep last N + 1 blocks

      --prune.receipts.before <BLOCK_NUMBER>
          Prune receipts before the specified block number. The specified block number is not pruned

      --prune.receiptslogfilter <FILTER_CONFIG>
          Configure receipts log filter. Format: <`address`>:<`prune_mode`>... where <`prune_mode`> can be 'full', 'distance:<`blocks`>', or 'before:<`block_number`>'

      --prune.account-history.full
          Prunes all account history

      --prune.account-history.distance <BLOCKS>
          Prune account before the `head-N` block number. In other words, keep last N + 1 blocks

      --prune.account-history.before <BLOCK_NUMBER>
          Prune account history before the specified block number. The specified block number is not pruned

      --prune.storage-history.full
          Prunes all storage history data

      --prune.storage-history.distance <BLOCKS>
          Prune storage history before the `head-N` block number. In other words, keep last N + 1 blocks

      --prune.storage-history.before <BLOCK_NUMBER>
          Prune storage history before the specified block number. The specified block number is not pruned

      --prune.bodies.pre-merge
          Prune bodies before the merge block

      --prune.bodies.distance <BLOCKS>
          Prune bodies before the `head-N` block number. In other words, keep last N + 1 blocks

      --prune.bodies.before <BLOCK_NUMBER>
          Prune storage history before the specified block number. The specified block number is not pruned

      --prune.minimum-distance <BLOCKS>
          Minimum pruning distance from the tip. This controls the safety margin for reorgs and manual unwinds

Engine:
      --engine.persistence-threshold <PERSISTENCE_THRESHOLD>
          Configure persistence threshold for the engine. This determines how many canonical blocks must be in-memory, ahead of the last persisted block, before flushing canonical blocks to disk again.

          To persist blocks as fast as the node receives them, set this value to zero. This will cause more frequent DB writes.

          [default: 7]

      --engine.persistence-backpressure-threshold <PERSISTENCE_BACKPRESSURE_THRESHOLD>
          Configure the maximum number of blocks beyond the in-memory buffer target that may await persistence before engine API processing stalls.

          If omitted, this defaults to the larger of the default backpressure threshold and twice `--engine.persistence-threshold`.

          This value must be greater than `--engine.persistence-threshold`.

      --engine.memory-block-buffer-target <MEMORY_BLOCK_BUFFER_TARGET>
          Configure the target number of blocks to keep in memory.

          If omitted, this defaults to the lesser of `--engine.persistence-threshold` and the configured default memory block buffer target.

      --engine.invalid-header-cache-hit-eviction-threshold <INVALID_HEADER_HIT_EVICTION_THRESHOLD>
          Configure how many cache hits an invalid header can accumulate before it is evicted and reprocessed.

          Set to `0` to effectively disable the cache because entries are evicted on the first lookup.

          [default: 128]

      --engine.disable-state-cache
          Disable state cache

      --engine.disable-prewarming
          Disable parallel prewarming

      --engine.txpool-prewarming
          Enable best-effort txpool transaction prewarming between payloads

          [env: RETH_ENGINE_TXPOOL_PREWARMING=]

      --engine.sender-recovery-cache
          Enable caching recovered transaction senders across transaction ingress and payload execution

          [env: RETH_ENGINE_SENDER_RECOVERY_CACHE=]

      --engine.state-provider-metrics
          Enable state provider latency metrics. This allows the engine to collect and report stats about how long state provider calls took during execution, but this does introduce slight overhead to state provider calls

      --engine.cross-block-cache-size <CROSS_BLOCK_CACHE_SIZE>
          Configure the size of cross-block cache in megabytes

          [default: 4096]

      --engine.state-root-task-compare-updates
          Enable comparing trie updates from the state root task to the trie updates from the regular state root calculation

      --engine.accept-execution-requests-hash
          Enables accepting requests hash instead of an array of requests in `engine_newPayloadV4`

      --engine.multiproof-chunk-size <MULTIPROOF_CHUNK_SIZE>
          Multiproof task chunk size for proof targets

          [default: 5]

      --engine.reserved-cpu-cores <RESERVED_CPU_CORES>
          Configure the number of reserved CPU cores for non-reth processes

          [default: 1]

      --engine.disable-precompile-cache
          Disable precompile cache

      --engine.state-root-fallback
          Enable state root fallback, useful for testing

      --engine.always-process-payload-attributes-on-canonical-head
          Always process payload attributes and begin a payload build process even if `forkchoiceState.headBlockHash` is already the canonical head or an ancestor. See `TreeConfig::always_process_payload_attributes_on_canonical_head` for more details.

          Note: This is a no-op on OP Stack.

      --engine.allow-unwind-canonical-header
          Allow unwinding canonical header to ancestor during forkchoice updates. See `TreeConfig::unwind_canonical_header` for more details

      --engine.storage-worker-count <STORAGE_WORKER_COUNT>
          Configure the number of storage proof workers in the Tokio blocking pool. If not specified, defaults to 2x available parallelism

      --engine.account-worker-count <ACCOUNT_WORKER_COUNT>
          Configure the number of account proof workers in the Tokio blocking pool. If not specified, defaults to the same count as storage workers

      --engine.prewarming-threads <PREWARMING_THREADS>
          Configure the number of prewarming threads. If not specified, defaults to available parallelism

      --engine.disable-cache-metrics
          Disable cache metrics recording, which can take up to 50ms with large cached state

      --engine.slow-block-threshold <DURATION>
          Configure the slow block logging threshold in milliseconds.

          When set, blocks that take longer than this threshold to execute will be logged with detailed metrics including timing, state operations, and cache statistics.

          Set to 0 to log all blocks (useful for debugging/profiling).

          When not set, slow block logging is disabled (default).

      --engine.disable-sparse-trie-cache-pruning
          Fully disable sparse trie cache pruning. When set, the cached sparse trie is preserved without any node pruning or storage trie eviction between blocks. Useful for benchmarking the effects of retaining the full trie cache

      --engine.state-root-task-timeout <STATE_ROOT_TASK_TIMEOUT>
          Configure the timeout for the state root task before spawning a sequential fallback. If the state root task takes longer than this, a sequential computation starts in parallel and whichever finishes first is used.

          --engine.state-root-task-timeout 4s --engine.state-root-task-timeout 400ms

          Set to 0s to disable.

          [default: 4s]

      --engine.share-execution-cache-with-payload-builder
          Whether to share execution cache with the payload builder.

          When enabled, each payload job will get an instance of cross-block execution cache from the engine.

          Note: this should only be enabled if node would not be requested to process any payloads in parallel with payload building.

      --engine.share-sparse-trie-with-payload-builder
          Whether to share the sparse trie with the payload builder.

          Replaces the payload builder's blocking `state_root_with_updates()` call with the sparse trie, computing the state root concurrently with transaction execution.

          The engine and payload builder contend for the same trie — if a builder task is still running when `newPayload` arrives, the engine will block until the trie is stored back.

          The builder also anchors the trie at the built block's state root, so if the next `newPayload` is not on top of that block, the trie cache is invalidated and cleared.

      --engine.suppress-persistence-during-build
          Suppress persistence while building a payload.

          When enabled, persistence cycles are deferred while a payload build is active. Useful on chains with short block times where persistence I/O can interfere with block building latency.

      --engine.disable-bal-parallel-execution
          Disable BAL (Block Access List, EIP-7928) based parallel execution

      --engine.disable-bal-parallel-state-root
          Disable BAL-driven parallel state root computation. This is only valid together with `--engine.disable-bal-parallel-execution`

      --engine.disable-bal-batch-io
          Disable BAL (Block Access List) storage prefetch IO during prewarming. When set, BAL storage slots are not read into the execution cache

ERA:
      --era.enable
          Enable import from ERA1 files

      --era.path <ERA_PATH>
          The path to a directory for import.

          The ERA1 files are read from the local directory parsing headers and bodies.

      --era.url <ERA_URL>
          The URL to a remote host where the ERA1 files are hosted.

          The ERA1 files are read from the remote host using HTTP GET requests parsing headers
          and bodies.

Static Files:
      --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
          Number of blocks per file for the headers segment

      --static-files.blocks-per-file.transactions <BLOCKS_PER_FILE_TRANSACTIONS>
          Number of blocks per file for the transactions segment

      --static-files.blocks-per-file.receipts <BLOCKS_PER_FILE_RECEIPTS>
          Number of blocks per file for the receipts segment

      --static-files.blocks-per-file.transaction-senders <BLOCKS_PER_FILE_TRANSACTION_SENDERS>
          Number of blocks per file for the transaction senders segment

      --static-files.blocks-per-file.account-change-sets <BLOCKS_PER_FILE_ACCOUNT_CHANGE_SETS>
          Number of blocks per file for the account changesets segment

      --static-files.blocks-per-file.storage-change-sets <BLOCKS_PER_FILE_STORAGE_CHANGE_SETS>
          Number of blocks per file for the storage changesets segment

Storage:
      --storage.v2 [<V2>]
          Enable V2 (hot/cold) storage layout for new databases.

          When set, new databases will be initialized with the V2 storage layout that separates hot and cold data. Existing databases always use the settings persisted in their metadata regardless of this flag.

          [default: true]
          [possible values: true, false]

JIT:
      --jit
          Enable JIT compilation of EVM bytecode

      --jit.hot-threshold <HOT_THRESHOLD>
          Number of observed misses before a bytecode is promoted to JIT compilation

          [default: 8]

      --jit.worker-count <WORKER_COUNT>
          Number of JIT compilation worker threads

      --jit.channel-capacity <CHANNEL_CAPACITY>
          Capacity of the lookup-observed event channel. Events are silently dropped when the channel is full

          [default: 4096]

      --jit.max-pending-jobs <MAX_PENDING_JOBS>
          Maximum number of pending JIT compilation jobs

          [default: 2048]

      --jit.max-bytecode-len <MAX_BYTECODE_LEN>
          Maximum bytecode length eligible for JIT compilation. Contracts with bytecode larger than this are never promoted to JIT. 0 means no limit

          [default: 0]

      --jit.code-cache-bytes <CODE_CACHE_BYTES>
          Maximum total resident compiled code size in bytes. When exceeded, the backend evicts least-recently-used entries. 0 means no limit

          [default: 1073741824]

      --jit.idle-evict-duration <IDLE_EVICT_DURATION>
          Duration after which a compiled program with no lookup hits is evicted

          [default: 1h]

      --jit.debug
          Enable compiler debug dumps.

          IR, assembly, and bytecode are written to `<datadir>/jit/<spec_id>/<code_hash>/` for each compiled contract. Note that this is not ever cleaned up, and has a non negligible performance overhead.

Logging:
      --log.stdout.format <FORMAT>
          The format to use for logs written to stdout

          Possible values:
          - json:     Represents JSON formatting for logs. This format outputs log records as JSON objects, making it suitable for structured logging
          - log-fmt:  Represents logfmt (key=value) formatting for logs. This format is concise and human-readable, typically used in command-line applications
          - terminal: Represents terminal-friendly formatting for logs

          [default: terminal]

      --log.stdout.filter <FILTER>
          The filter to use for logs written to stdout

          [default: ""]

      --log.file.format <FORMAT>
          The format to use for logs written to the log file

          Possible values:
          - json:     Represents JSON formatting for logs. This format outputs log records as JSON objects, making it suitable for structured logging
          - log-fmt:  Represents logfmt (key=value) formatting for logs. This format is concise and human-readable, typically used in command-line applications
          - terminal: Represents terminal-friendly formatting for logs

          [default: terminal]

      --log.file.filter <FILTER>
          The filter to use for logs written to the log file

          [default: debug]

      --log.file.directory <PATH>
          The path to put log files in

          [default: <CACHE_DIR>/logs]

      --log.file.name <NAME>
          The prefix name of the log files

          [default: reth.log]

      --log.file.max-size <SIZE>
          The maximum size (in MB) of one log file

          [default: 200]

      --log.file.max-files <COUNT>
          The maximum amount of log files that will be stored. If set to 0, background file logging is disabled.

          Default: 5 for `node` command, 0 for non-node utility subcommands.

      --log.journald
          Write logs to journald

      --log.journald.filter <FILTER>
          The filter to use for logs written to journald

          [default: error]

      --color <COLOR>
          Sets whether or not the formatter emits ANSI terminal escape codes for colors and other text formatting

          Possible values:
          - always: Colors on
          - auto:   Auto-detect
          - never:  Colors off

          [default: always]

      --logs-otlp[=<URL>]
          Enable `Opentelemetry` logs export to an OTLP endpoint.

          If no value provided, defaults based on protocol: - HTTP: `http://localhost:4318/v1/logs` - gRPC: `http://localhost:4317`

          Example: --logs-otlp=http://collector:4318/v1/logs

          [env: OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=]

      --logs-otlp.filter <FILTER>
          Set a filter directive for the OTLP logs exporter. This controls the verbosity of logs sent to the OTLP endpoint. It follows the same syntax as the `RUST_LOG` environment variable.

          Example: --logs-otlp.filter=info,reth=debug

          Defaults to INFO if not specified.

          [default: info]

Display:
  -v, --verbosity...
          Set the minimum log level.

          -v      Errors
          -vv     Warnings
          -vvv    Info
          -vvvv   Debug
          -vvvvv  Traces (warning: very verbose!)

  -q, --quiet
          Silence all log output

Tracing:
      --tracing-otlp[=<URL>]
          Enable `Opentelemetry` tracing export to an OTLP endpoint.

          If no value provided, defaults based on protocol: - HTTP: `http://localhost:4318/v1/traces` - gRPC: `http://localhost:4317`

          Example: --tracing-otlp=http://collector:4318/v1/traces

          [env: OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=]

      --tracing-otlp-protocol <PROTOCOL>
          OTLP transport protocol to use for exporting traces and logs.

          - `http`: expects endpoint path to end with `/v1/traces` or `/v1/logs` - `grpc`: expects endpoint without a path

          Defaults to HTTP if not specified.

          Possible values:
          - http: HTTP/Protobuf transport, port 4318, requires `/v1/traces` path
          - grpc: gRPC transport, port 4317

          [env: OTEL_EXPORTER_OTLP_PROTOCOL=]
          [default: http]

      --tracing-otlp.filter <FILTER>
          Set a filter directive for the OTLP tracer. This controls the verbosity of spans and events sent to the OTLP endpoint. It follows the same syntax as the `RUST_LOG` environment variable.

          Example: --tracing-otlp.filter=info,reth=debug,hyper_util=off

          Defaults to TRACE if not specified.

          [default: debug]

      --tracing-otlp.sample-ratio <RATIO>
          Trace sampling ratio to control the percentage of traces to export.

          Valid range: 0.0 to 1.0 - 1.0, default: Sample all traces - 0.01: Sample 1% of traces - 0.0: Disable sampling

          Example: --tracing-otlp.sample-ratio=0.0.

          [env: OTEL_TRACES_SAMPLER_ARG=]
```