Struct EngineArgs 

pub struct EngineArgs {

    pub persistence_threshold: u64,
    pub persistence_backpressure_threshold: Option<u64>,
    pub num_state_masking_blocks: u64,
    pub memory_block_buffer_target: Option<u64>,
    pub backfill_run_threshold: u64,
    pub invalid_header_hit_eviction_threshold: u8,
    pub state_cache_disabled: bool,
    pub prewarming_disabled: bool,
    pub txpool_prewarming_enabled: bool,
    pub sender_recovery_cache_enabled: bool,
    pub state_provider_metrics: bool,
    pub cross_block_cache_size: usize,
    pub accept_execution_requests_hash: bool,
    pub multiproof_chunk_size: usize,
    pub reserved_cpu_cores: usize,
    pub cpu_cores: Option<NonZero<usize>>,
    pub precompile_cache_disabled: bool,
    pub state_root_fallback: bool,
    pub always_process_payload_attributes_on_canonical_head: bool,
    pub allow_unwind_canonical_header: bool,
    pub storage_worker_count: Option<usize>,
    pub account_worker_count: Option<usize>,
    pub prewarming_threads: Option<usize>,
    pub cache_metrics_disabled: bool,
    pub slow_block_threshold: Option<Duration>,
    pub disable_sparse_trie_cache_pruning: bool,
    pub state_root_task_timeout: Option<Duration>,
    pub share_execution_cache_with_payload_builder: bool,
    pub share_sparse_trie_with_payload_builder: bool,
    pub suppress_persistence_during_build: bool,
    pub bal_parallel_execution_disabled: bool,
    pub bal_parallel_state_root_disabled: bool,
    pub disable_bal_batch_io: bool,
    pub prewarm_reuse: bool,
    pub proof_jitter: Option<Duration>,
}

Parameters for configuring the engine driver.

Fields

persistence_threshold: u64

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 disables state masking and causes more frequent DB writes.

persistence_backpressure_threshold: Option<u64>

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 minimum backpressure threshold and twice --engine.persistence-threshold.

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

num_state_masking_blocks: u64

Configure how many of the blocks being persisted should only mask state/trie writes instead of durably persisting their state/trie updates in the current cycle.

memory_block_buffer_target: Option<u64>

Configure how many of the most recent canonical blocks persistence leaves in memory.

When more than --engine.persistence-threshold canonical blocks are held in memory, the engine writes the canonical chain to disk up to head - memory-block-buffer-target. The blocks above that height are kept only in memory, so a reorg of them does not unwind the database. With state masking enabled, the --engine.num-state-masking-blocks blocks below that height also stay in memory until a later cycle persists their state/trie updates.

This is also the in-memory buffer that --engine.persistence-backpressure-threshold is measured from.

If omitted, this defaults to the lesser of --engine.persistence-threshold and the configured default memory block buffer target. The value must not exceed --engine.persistence-threshold, and with state masking enabled, its sum with --engine.num-state-masking-blocks must be less than --engine.persistence-threshold.

backfill_run_threshold: u64

Configure the largest gap, in blocks, between the local head and the forkchoice head that is closed by downloading the missing blocks directly. Larger gaps trigger a full pipeline (backfill) run instead.

On chains with short block times a pipeline run may take longer than it takes the chain to produce another gap of this size, in which case raising this value lets the node catch up via live sync. Values above 1024 are clamped to the peer header response limit.

invalid_header_hit_eviction_threshold: u8

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.

state_cache_disabled: bool

Disable state cache

prewarming_disabled: bool

Disable parallel prewarming

txpool_prewarming_enabled: bool

Enable best-effort txpool transaction prewarming between payloads.

sender_recovery_cache_enabled: bool

Cache recovered transaction senders across transaction ingress and payload execution.

Enabled by default, use --engine.sender-recovery-cache=false to disable it.

state_provider_metrics: bool

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.

cross_block_cache_size: usize

Configure the size of cross-block cache in megabytes

accept_execution_requests_hash: bool

Enables accepting requests hash instead of an array of requests in engine_newPayloadV4.

multiproof_chunk_size: usize

Multiproof task chunk size for proof targets.

reserved_cpu_cores: usize

Configure the number of reserved CPU cores for non-reth processes

cpu_cores: Option<NonZero<usize>>

Override the available CPU count for node thread pools and parallel execution decisions. Does not change CPU affinity. Explicit thread counts take precedence.

precompile_cache_disabled: bool

Disable precompile cache

state_root_fallback: bool

Enable state root fallback, useful for testing

always_process_payload_attributes_on_canonical_head: bool

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.

allow_unwind_canonical_header: bool

Allow unwinding canonical header to ancestor during forkchoice updates. See TreeConfig::unwind_canonical_header for more details.

storage_worker_count: Option<usize>

Configure the number of storage proof workers spawned for each block. If not specified or zero, the count is derived from the block: 2x available parallelism, halved for blocks with few transactions and doubled for blocks at or above 100M gas.

account_worker_count: Option<usize>

Configure the number of account proof workers spawned for each block. If not specified or zero, the count is derived from the block the same way as for storage workers.

prewarming_threads: Option<usize>

Configure the number of prewarming threads. If not specified, defaults to available parallelism.

cache_metrics_disabled: bool

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

slow_block_threshold: Option<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).

disable_sparse_trie_cache_pruning: bool

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.

state_root_task_timeout: Option<Duration>

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.

share_execution_cache_with_payload_builder: bool

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.

share_sparse_trie_with_payload_builder: bool

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.

suppress_persistence_during_build: bool

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.

bal_parallel_execution_disabled: bool

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

bal_parallel_state_root_disabled: bool

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

disable_bal_batch_io: bool

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

prewarm_reuse: bool

Reuse transaction prewarming results during block execution instead of executing transactions again when their prewarm reads are still valid.

proof_jitter: Option<Duration>

Available on crate feature trie-debug only.

Add random jitter before each proof computation (trie-debug only). Each proof worker sleeps for a random duration up to this value before starting work. Useful for stress-testing timing-sensitive proof logic.

–engine.proof-jitter 100ms –engine.proof-jitter 1s

Implementations

impl EngineArgs

pub const fn num_state_masking_blocks(&self) -> u64

Returns the effective state masking window, disabled when persistence is immediate.

pub fn memory_block_buffer_target(&self) -> u64

Returns the effective memory block buffer target.

pub fn persistence_backpressure_threshold(&self) -> u64

Returns the effective persistence backpressure threshold.

pub fn validate(&self) -> Result<(), Report>

Validates cross-field engine arguments.

pub fn tree_config(&self) -> TreeConfig

Creates a TreeConfig from the engine arguments.

Trait Implementations

impl Args for EngineArgs

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

impl Clone for EngineArgs

fn clone(&self) -> EngineArgs

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EngineArgs

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for EngineArgs

fn default() -> EngineArgs

Returns the “default value” for a type.

impl Eq for EngineArgs

impl FromArgMatches for EngineArgs

fn from_arg_matches( __clap_arg_matches: &ArgMatches, ) -> Result<EngineArgs, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<EngineArgs, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl PartialEq for EngineArgs

fn eq(&self, other: &EngineArgs) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for EngineArgs

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 208 bytes