feat(snap-sync): add retry with exponential backoff for snap requests

Snap requests can fail due to timeouts when peers are slow to respond
or not yet connected. Add retry logic (up to 10 attempts) with
exponential backoff to all snap protocol requests.

Amp-Thread-ID: https://ampcode.com/threads/T-019c67ba-663f-742b-84bc-dcb07606544d
Co-authored-by: Amp <amp@ampcode.com>

.changelog/fast-seals-play.md

@@ -0,0 +1,5 @@
+---
+reth-transaction-pool: minor
+---
+
+Added `consensus_ref` method to `PoolTransaction` trait for borrowing consensus transactions without cloning.

.changelog/fast-waves-smile.md

@@ -0,0 +1,4 @@
+---
+---
+
+Improved nightly Docker build failure Slack notification with more detailed formatting and context.

.changelog/lively-clouds-bake.md

@@ -0,0 +1,4 @@
+---
+---
+
+Improved documentation overview page with better structure and clarity.

.changelog/lively-foxes-play.md

@@ -0,0 +1,5 @@
+---
+reth-node-events: patch
+---
+
+Updated consensus engine log message to be more accurate about received updates.

.changelog/merry-koalas-nod.md

@@ -0,0 +1,6 @@
+---
+reth-rpc-eth-api: minor
+reth-rpc-server-types: minor
+---
+
+Added `eth_getStorageValues` RPC method for batch storage slot retrieval across multiple addresses.

.changelog/nice-trees-drink.md

@@ -0,0 +1,9 @@
+---
+reth-network-api: minor
+reth-network-types: minor
+reth-network: minor
+reth-node-core: minor
+reth: minor
+---
+
+Added optional ENR fork ID enforcement to filter out peers from incompatible networks during peer discovery, controlled by the `--enforce-enr-fork-id` CLI flag.

.changelog/proud-wolves-spin.md

@@ -0,0 +1,5 @@
+---
+reth-storage-api: patch
+---
+
+Added `Arc` to `auto_impl` derive for storage-api traits to support automatic `Arc` wrapper implementations.

.config/nextest.toml

@@ -1,6 +1,6 @@
 [profile.default]
 retries = { backoff = "exponential", count = 2, delay = "2s", jitter = true }
-slow-timeout = { period = "30s", terminate-after = 4 }
+slow-timeout = { period = "30s", terminate-after = 2 }
 
 [[profile.default.overrides]]
 filter = "test(general_state_tests)"

.github/CODEOWNERS

@@ -38,7 +38,7 @@ crates/storage/libmdbx-rs/  @shekhirin
 crates/storage/nippy-jar/   @joshieDo @shekhirin
 crates/storage/provider/    @joshieDo @shekhirin @yongkangc
 crates/storage/storage-api/ @joshieDo
-crates/tasks/               @mattsse
+crates/tasks/               @mattsse @DaniPopes
 crates/tokio-util/          @mattsse 
 crates/tracing/             @mattsse @shekhirin
 crates/tracing-otlp/        @mattsse @Rjected 

.github/workflows/docker.yml

@@ -70,18 +70,27 @@ jobs:
             # Add 'latest' tag for non-RC releases
             if [[ ! "$VERSION" =~ -rc ]]; then
               echo "ethereum_tags=${REGISTRY}/reth:${VERSION},${REGISTRY}/reth:latest" >> "$GITHUB_OUTPUT"
+              {
+                echo "ethereum_set<<EOF"
+                echo "ethereum.tags=${REGISTRY}/reth:${VERSION}"
+                echo "ethereum.tags=${REGISTRY}/reth:latest"
+                echo "EOF"
+              } >> "$GITHUB_OUTPUT"
             else
               echo "ethereum_tags=${REGISTRY}/reth:${VERSION}" >> "$GITHUB_OUTPUT"
+              echo "ethereum_set=ethereum.tags=${REGISTRY}/reth:${VERSION}" >> "$GITHUB_OUTPUT"
             fi
 
           elif [[ "${{ github.event_name }}" == "schedule" ]] || [[ "${{ inputs.build_type }}" == "nightly" ]]; then
             echo "targets=nightly" >> "$GITHUB_OUTPUT"
             echo "ethereum_tags=${REGISTRY}/reth:nightly" >> "$GITHUB_OUTPUT"
+            echo "ethereum_set=ethereum.tags=${REGISTRY}/reth:nightly" >> "$GITHUB_OUTPUT"
 
           else
             # git-sha build
             echo "targets=ethereum" >> "$GITHUB_OUTPUT"
             echo "ethereum_tags=${REGISTRY}/reth:${{ github.sha }}" >> "$GITHUB_OUTPUT"
+            echo "ethereum_set=ethereum.tags=${REGISTRY}/reth:${{ github.sha }}" >> "$GITHUB_OUTPUT"
           fi
 
       - name: Build and push images
@@ -97,7 +106,7 @@ jobs:
           targets: ${{ steps.params.outputs.targets }}
           push: ${{ !(github.event_name == 'workflow_dispatch' && inputs.dry_run) }}
           set: |
-            ethereum.tags=${{ steps.params.outputs.ethereum_tags }}
+            ${{ steps.params.outputs.ethereum_set }}
 
       - name: Verify image architectures
         env:
@@ -117,6 +126,18 @@ jobs:
       - name: Slack Webhook Action
         uses: rtCamp/action-slack-notify@v2
         env:
-          SLACK_COLOR: ${{ job.status }}
-          SLACK_MESSAGE: "Failed run: https://github.com/paradigmxyz/reth/actions/runs/${{ github.run_id }}"
+          SLACK_COLOR: danger
+          SLACK_ICON_EMOJI: ":rotating_light:"
+          SLACK_USERNAME: "GitHub Actions"
+          SLACK_TITLE: ":rotating_light: Nightly Docker Build Failed"
+          SLACK_MESSAGE: |
+            The scheduled nightly Docker build failed.
+
+            *Commit:* `${{ github.sha }}`
+            *Branch:* `${{ github.ref_name }}`
+            *Run:* <https://github.com/paradigmxyz/reth/actions/runs/${{ github.run_id }}|View logs>
+
+            *Action required:* Re-run the workflow or investigate the build failure.
+          SLACK_FOOTER: "paradigmxyz/reth · docker.yml"
+          MSG_MINIMAL: true
           SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }}

.github/workflows/lint.yml

@@ -124,7 +124,7 @@ jobs:
       - uses: rui314/setup-mold@v1
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: "1.88" # MSRV
+          toolchain: "1.93" # MSRV
       - uses: mozilla-actions/sccache-action@v0.0.9
       - uses: Swatinem/rust-cache@v2
         with:

.github/workflows/release.yml

@@ -102,7 +102,7 @@ jobs:
       - name: Install cross main
         id: cross_main
         run: |
-          cargo install cross --git https://github.com/cross-rs/cross
+          cargo install cross --locked --git https://github.com/cross-rs/cross
       - uses: Swatinem/rust-cache@v2
         with:
           cache-on-failure: true

.github/workflows/stage.yml

@@ -38,7 +38,7 @@ jobs:
           cache-on-failure: true
       - name: Build reth
         run: |
-          cargo install --path bin/reth
+          cargo install --locked --path bin/reth
       - name: Run headers stage
         run: |
           reth stage run headers --from ${{ env.FROM_BLOCK }} --to ${{ env.TO_BLOCK }} --commit --checkpoints

CLAUDE.md

@@ -313,6 +313,74 @@ GLOBAL_COUNTER.fetch_add(1, Ordering::SeqCst);
 Before adding a comment, ask: Would someone reading just the current code (no PR, no history) find this helpful?
 
 
+#### Rust Style Guides
+
+##### Type Ordering in Files
+
+When defining structs, traits, and functions in a file, follow this ordering convention. The file's primary type (matching the file name) comes first, followed by supporting public types, then private types and helpers.
+
+```rust
+use ...;
+
+/// The primary type of this file (matches filename).
+pub struct PayloadProcessor { ... }
+
+impl PayloadProcessor { ... }
+
+// Followed by public auxiliary types that support the primary type
+
+/// Configuration for the processor.
+pub struct PayloadProcessorConfig { ... }
+
+/// Result type returned by processor operations.
+pub struct ProcessorResult { ... }
+
+// Followed by public traits related to the primary type
+
+pub trait ProcessorExt { ... }
+
+// Followed by private helper types
+
+struct InternalState { ... }
+
+// Followed by private helper functions
+
+fn validate_input() { ... }
+```
+
+❌ **Bad**: Adding new traits and auxiliary types **above** the file's primary type (see [#22133](https://github.com/paradigmxyz/reth/pull/22133)):
+
+```rust
+use ...;
+
+// ❌ BAD - new auxiliary struct added before the file's main type
+pub struct CacheWaitDurations { ... }
+
+// ❌ BAD - new trait added before the file's main type  
+pub trait WaitForCaches { ... }
+
+// The file's primary type is buried below unrelated additions
+pub struct PayloadProcessor { ... }
+```
+
+✅ **Good**: New types go **after** the primary type:
+
+```rust
+use ...;
+
+// ✅ The file's primary type stays at the top
+pub struct PayloadProcessor { ... }
+
+impl PayloadProcessor { ... }
+
+// ✅ Auxiliary types follow the primary type
+pub struct CacheWaitDurations { ... }
+
+pub trait WaitForCaches { ... }
+
+impl WaitForCaches for PayloadProcessor { ... }
+```
+
 ### Example Contribution Workflow
 
 Let's say you want to fix a bug where external IP resolution fails on startup:

Cargo.toml

@@ -1,7 +1,7 @@
 [workspace.package]
-version = "1.10.2"
+version = "1.11.0"
 edition = "2024"
-rust-version = "1.88"
+rust-version = "1.93"
 license = "MIT OR Apache-2.0"
 homepage = "https://paradigmxyz.github.io/reth"
 repository = "https://github.com/paradigmxyz/reth"
@@ -27,7 +27,6 @@ members = [
     "crates/engine/invalid-block-hooks/",
     "crates/engine/local",
     "crates/engine/primitives/",
-    "crates/engine/service",
     "crates/engine/tree/",
     "crates/engine/util/",
     "crates/era",
@@ -56,6 +55,7 @@ members = [
     "crates/net/discv5/",
     "crates/net/dns/",
     "crates/net/downloaders/",
+    "crates/net/snap-sync/",
     "crates/net/ecies/",
     "crates/net/eth-wire-types",
     "crates/net/eth-wire/",
@@ -344,12 +344,12 @@ reth-discv4 = { path = "crates/net/discv4" }
 reth-discv5 = { path = "crates/net/discv5" }
 reth-dns-discovery = { path = "crates/net/dns" }
 reth-downloaders = { path = "crates/net/downloaders" }
+reth-snap-sync = { path = "crates/net/snap-sync" }
 reth-e2e-test-utils = { path = "crates/e2e-test-utils" }
 reth-ecies = { path = "crates/net/ecies" }
 reth-engine-local = { path = "crates/engine/local" }
 reth-engine-primitives = { path = "crates/engine/primitives", default-features = false }
 reth-engine-tree = { path = "crates/engine/tree" }
-reth-engine-service = { path = "crates/engine/service" }
 reth-engine-util = { path = "crates/engine/util" }
 reth-era = { path = "crates/era" }
 reth-era-downloader = { path = "crates/era-downloader" }
@@ -530,6 +530,7 @@ notify = { version = "8.0.0", default-features = false, features = ["macos_fseve
 nybbles = { version = "0.4.8", default-features = false }
 once_cell = { version = "1.19", default-features = false, features = ["critical-section"] }
 parking_lot = "0.12"
+quanta = "0.12"
 paste = "1.0"
 rand = "0.9"
 rayon = "1.7"
@@ -665,6 +666,7 @@ cipher = "0.4.3"
 comfy-table = "7.0"
 concat-kdf = "0.1.0"
 crossbeam-channel = "0.5.13"
+crossbeam-utils = "0.8"
 crossterm = "0.29.0"
 csv = "1.3.0"
 ctrlc = "3.4"

Cross.toml

@@ -19,10 +19,11 @@ pre-build = [
 image = "ubuntu:24.04"
 pre-build = [
     "apt update",
-    "apt install --yes gcc gcc-riscv64-linux-gnu libclang-dev make",
+    "apt install --yes gcc gcc-riscv64-linux-gnu g++-riscv64-linux-gnu libclang-dev make",
 ]
 env.passthrough = [
     "CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER=riscv64-linux-gnu-gcc",
+    "CXX_riscv64gc_unknown_linux_gnu=riscv64-linux-gnu-g++",
 ]
 
 [build.env]

Makefile

@@ -80,7 +80,7 @@ build-native-%:
 #
 # These commands require that:
 #
-# - `cross` is installed (`cargo install cross`).
+# - `cross` is installed (`cargo install --locked cross`).
 # - Docker is running.
 # - The current user is in the `docker` group.
 #
@@ -261,7 +261,7 @@ lint-typos: ensure-typos
 
 ensure-typos:
 	@if ! command -v typos &> /dev/null; then \
-		echo "typos not found. Please install it by running the command 'cargo install typos-cli' or refer to the following link for more information: https://github.com/crate-ci/typos"; \
+		echo "typos not found. Please install it by running the command 'cargo install --locked typos-cli' or refer to the following link for more information: https://github.com/crate-ci/typos"; \
 		exit 1; \
     fi
 

README.md

@@ -93,7 +93,7 @@ When updating this, also update:
 - .github/workflows/lint.yml
 -->
 
-The Minimum Supported Rust Version (MSRV) of this project is [1.88.0](https://blog.rust-lang.org/2025/06/26/Rust-1.88.0/).
+The Minimum Supported Rust Version (MSRV) of this project is [1.93.0](https://blog.rust-lang.org/2026/01/22/Rust-1.93.0/).
 
 See the docs for detailed instructions on how to [build from source](https://reth.rs/installation/source/).
 

bin/reth-bench/src/bench/context.rs

@@ -29,6 +29,8 @@ pub(crate) struct BenchContext {
     pub(crate) next_block: u64,
     /// Whether the chain is an OP rollup.
     pub(crate) is_optimism: bool,
+    /// Whether to use `reth_newPayload` endpoint instead of `engine_newPayload*`.
+    pub(crate) use_reth_namespace: bool,
 }
 
 impl BenchContext {
@@ -140,6 +142,14 @@ impl BenchContext {
         };
 
         let next_block = first_block.header.number + 1;
-        Ok(Self { auth_provider, block_provider, benchmark_mode, next_block, is_optimism })
+        let use_reth_namespace = bench_args.reth_new_payload;
+        Ok(Self {
+            auth_provider,
+            block_provider,
+            benchmark_mode,
+            next_block,
+            is_optimism,
+            use_reth_namespace,
+        })
     }
 }

bin/reth-bench/src/bench/gas_limit_ramp.rs

@@ -6,7 +6,7 @@ use crate::{
         helpers::{build_payload, parse_gas_limit, prepare_payload_request, rpc_block_to_header},
         output::GasRampPayloadFile,
     },
-    valid_payload::{call_forkchoice_updated, call_new_payload, payload_to_new_payload},
+    valid_payload::{call_forkchoice_updated, call_new_payload_with_reth, payload_to_new_payload},
 };
 use alloy_eips::BlockNumberOrTag;
 use alloy_provider::{network::AnyNetwork, Provider, RootProvider};
@@ -47,6 +47,14 @@ pub struct Command {
     /// Output directory for benchmark results and generated payloads.
     #[arg(long, value_name = "OUTPUT")]
     output: PathBuf,
+
+    /// Use `reth_newPayload` endpoint instead of `engine_newPayload*`.
+    ///
+    /// The `reth_newPayload` endpoint is a reth-specific extension that takes `ExecutionData`
+    /// directly, waits for persistence and cache updates to complete before processing,
+    /// and returns server-side timing breakdowns (latency, persistence wait, cache wait).
+    #[arg(long, default_value = "false", verbatim_doc_comment)]
+    reth_new_payload: bool,
 }
 
 /// Mode for determining when to stop ramping.
@@ -138,6 +146,9 @@ impl Command {
                 );
             }
         }
+        if self.reth_new_payload {
+            info!("Using reth_newPayload endpoint");
+        }
 
         let mut blocks_processed = 0u64;
         let total_benchmark_duration = Instant::now();
@@ -163,7 +174,7 @@ impl Command {
             // Regenerate the payload from the modified block, but keep the original sidecar
             // which contains the actual execution requests data (not just the hash)
             let (payload, _) = ExecutionPayload::from_block_unchecked(block_hash, &block);
-            let (version, params) = payload_to_new_payload(
+            let (version, params, execution_data) = payload_to_new_payload(
                 payload,
                 sidecar,
                 false,
@@ -174,13 +185,18 @@ impl Command {
             // Save payload to file with version info for replay
             let payload_path =
                 self.output.join(format!("payload_block_{}.json", block.header.number));
-            let file =
-                GasRampPayloadFile { version: version as u8, block_hash, params: params.clone() };
+            let file = GasRampPayloadFile {
+                version: version as u8,
+                block_hash,
+                params: params.clone(),
+                execution_data: Some(execution_data.clone()),
+            };
             let payload_json = serde_json::to_string_pretty(&file)?;
             std::fs::write(&payload_path, &payload_json)?;
             info!(target: "reth-bench", block_number = block.header.number, path = %payload_path.display(), "Saved payload");
 
-            call_new_payload(&provider, version, params).await?;
+            let reth_data = self.reth_new_payload.then_some(execution_data);
+            let _ = call_new_payload_with_reth(&provider, version, params, reth_data).await?;
 
             let forkchoice_state = ForkchoiceState {
                 head_block_hash: block_hash,
@@ -192,6 +208,15 @@ impl Command {
             parent_header = block.header;
             parent_hash = block_hash;
             blocks_processed += 1;
+
+            let progress = match mode {
+                RampMode::Blocks(total) => format!("{blocks_processed}/{total}"),
+                RampMode::TargetGasLimit(target) => {
+                    let pct = (parent_header.gas_limit as f64 / target as f64 * 100.0).min(100.0);
+                    format!("{pct:.1}%")
+                }
+            };
+            info!(target: "reth-bench", progress, block_number = parent_header.number, gas_limit = parent_header.gas_limit, "Block processed");
         }
 
         let final_gas_limit = parent_header.gas_limit;

bin/reth-bench/src/bench/new_payload_fcu.rs

@@ -20,7 +20,7 @@ use crate::{
             derive_ws_rpc_url, setup_persistence_subscription, PersistenceWaiter,
         },
     },
-    valid_payload::{block_to_new_payload, call_forkchoice_updated, call_new_payload},
+    valid_payload::{block_to_new_payload, call_forkchoice_updated, call_new_payload_with_reth},
 };
 use alloy_provider::Provider;
 use alloy_rpc_types_engine::ForkchoiceState;
@@ -150,9 +150,15 @@ impl Command {
             auth_provider,
             mut next_block,
             is_optimism,
-            ..
+            use_reth_namespace,
         } = BenchContext::new(&self.benchmark, self.rpc_url).await?;
 
+        let total_blocks = benchmark_mode.total_blocks();
+
+        if use_reth_namespace {
+            info!("Using reth_newPayload endpoint");
+        }
+
         let buffer_size = self.rpc_block_buffer_size;
 
         // Use a oneshot channel to propagate errors from the spawned task
@@ -206,6 +212,7 @@ impl Command {
         });
 
         let mut results = Vec::new();
+        let mut blocks_processed = 0u64;
         let total_benchmark_duration = Instant::now();
         let mut total_wait_time = Duration::ZERO;
 
@@ -228,16 +235,40 @@ impl Command {
                 finalized_block_hash: finalized,
             };
 
-            let (version, params) = block_to_new_payload(block, is_optimism)?;
+            let (version, params, execution_data) = block_to_new_payload(block, is_optimism)?;
             let start = Instant::now();
-            call_new_payload(&auth_provider, version, params).await?;
+            let reth_data = use_reth_namespace.then_some(execution_data);
+            let server_timings =
+                call_new_payload_with_reth(&auth_provider, version, params, reth_data).await?;
 
-            let new_payload_result = NewPayloadResult { gas_used, latency: start.elapsed() };
+            let np_latency =
+                server_timings.as_ref().map(|t| t.latency).unwrap_or_else(|| start.elapsed());
+            let new_payload_result = NewPayloadResult {
+                gas_used,
+                latency: np_latency,
+                persistence_wait: server_timings.as_ref().and_then(|t| t.persistence_wait),
+                execution_cache_wait: server_timings
+                    .as_ref()
+                    .map(|t| t.execution_cache_wait)
+                    .unwrap_or_default(),
+                sparse_trie_wait: server_timings
+                    .as_ref()
+                    .map(|t| t.sparse_trie_wait)
+                    .unwrap_or_default(),
+            };
 
+            let fcu_start = Instant::now();
             call_forkchoice_updated(&auth_provider, version, forkchoice_state, None).await?;
+            let fcu_latency = fcu_start.elapsed();
 
-            let total_latency = start.elapsed();
-            let fcu_latency = total_latency - new_payload_result.latency;
+            let total_latency = if server_timings.is_some() {
+                // When using server-side latency for newPayload, derive total from the
+                // independently measured components to avoid mixing server-side and
+                // client-side (network-inclusive) timings.
+                np_latency + fcu_latency
+            } else {
+                start.elapsed()
+            };
             let combined_result = CombinedResult {
                 block_number,
                 gas_limit,
@@ -249,8 +280,13 @@ impl Command {
 
             // Exclude time spent waiting on the block prefetch channel from the benchmark duration.
             // We want to measure engine throughput, not RPC fetch latency.
+            blocks_processed += 1;
             let current_duration = total_benchmark_duration.elapsed() - total_wait_time;
-            info!(target: "reth-bench", %combined_result);
+            let progress = match total_blocks {
+                Some(total) => format!("{blocks_processed}/{total}"),
+                None => format!("{blocks_processed}"),
+            };
+            info!(target: "reth-bench", progress, %combined_result);
 
             if let Some(w) = &mut waiter {
                 w.on_block(block_number).await?;

bin/reth-bench/src/bench/new_payload_only.rs

@@ -8,7 +8,7 @@ use crate::{
             NEW_PAYLOAD_OUTPUT_SUFFIX,
         },
     },
-    valid_payload::{block_to_new_payload, call_new_payload},
+    valid_payload::{block_to_new_payload, call_new_payload_with_reth},
 };
 use alloy_provider::Provider;
 use clap::Parser;
@@ -49,9 +49,15 @@ impl Command {
             auth_provider,
             mut next_block,
             is_optimism,
-            ..
+            use_reth_namespace,
         } = BenchContext::new(&self.benchmark, self.rpc_url).await?;
 
+        let total_blocks = benchmark_mode.total_blocks();
+
+        if use_reth_namespace {
+            info!("Using reth_newPayload endpoint");
+        }
+
         let buffer_size = self.rpc_block_buffer_size;
 
         // Use a oneshot channel to propagate errors from the spawned task
@@ -82,8 +88,8 @@ impl Command {
             }
         });
 
-        // put results in a summary vec so they can be printed at the end
         let mut results = Vec::new();
+        let mut blocks_processed = 0u64;
         let total_benchmark_duration = Instant::now();
         let mut total_wait_time = Duration::ZERO;
 
@@ -99,13 +105,34 @@ impl Command {
 
             debug!(target: "reth-bench", number=?block.header.number, "Sending payload to engine");
 
-            let (version, params) = block_to_new_payload(block, is_optimism)?;
+            let (version, params, execution_data) = block_to_new_payload(block, is_optimism)?;
 
             let start = Instant::now();
-            call_new_payload(&auth_provider, version, params).await?;
+            let reth_data = use_reth_namespace.then_some(execution_data);
+            let server_timings =
+                call_new_payload_with_reth(&auth_provider, version, params, reth_data).await?;
 
-            let new_payload_result = NewPayloadResult { gas_used, latency: start.elapsed() };
-            info!(target: "reth-bench", %new_payload_result);
+            let latency =
+                server_timings.as_ref().map(|t| t.latency).unwrap_or_else(|| start.elapsed());
+            let new_payload_result = NewPayloadResult {
+                gas_used,
+                latency,
+                persistence_wait: server_timings.as_ref().and_then(|t| t.persistence_wait),
+                execution_cache_wait: server_timings
+                    .as_ref()
+                    .map(|t| t.execution_cache_wait)
+                    .unwrap_or_default(),
+                sparse_trie_wait: server_timings
+                    .as_ref()
+                    .map(|t| t.sparse_trie_wait)
+                    .unwrap_or_default(),
+            };
+            blocks_processed += 1;
+            let progress = match total_blocks {
+                Some(total) => format!("{blocks_processed}/{total}"),
+                None => format!("{blocks_processed}"),
+            };
+            info!(target: "reth-bench", progress, %new_payload_result);
 
             // current duration since the start of the benchmark minus the time
             // waiting for blocks

bin/reth-bench/src/bench/output.rs

@@ -27,6 +27,9 @@ pub(crate) struct GasRampPayloadFile {
     pub(crate) block_hash: B256,
     /// The params to pass to newPayload.
     pub(crate) params: serde_json::Value,
+    /// The execution data for `reth_newPayload`.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub(crate) execution_data: Option<alloy_rpc_types_engine::ExecutionData>,
 }
 
 /// This represents the results of a single `newPayload` call in the benchmark, containing the gas
@@ -37,6 +40,12 @@ pub(crate) struct NewPayloadResult {
     pub(crate) gas_used: u64,
     /// The latency of the `newPayload` call.
     pub(crate) latency: Duration,
+    /// Time spent waiting for persistence. `None` when no persistence was in-flight.
+    pub(crate) persistence_wait: Option<Duration>,
+    /// Time spent waiting for execution cache lock.
+    pub(crate) execution_cache_wait: Duration,
+    /// Time spent waiting for sparse trie lock.
+    pub(crate) sparse_trie_wait: Duration,
 }
 
 impl NewPayloadResult {
@@ -67,9 +76,12 @@ impl Serialize for NewPayloadResult {
     {
         // convert the time to microseconds
         let time = self.latency.as_micros();
-        let mut state = serializer.serialize_struct("NewPayloadResult", 2)?;
+        let mut state = serializer.serialize_struct("NewPayloadResult", 5)?;
         state.serialize_field("gas_used", &self.gas_used)?;
         state.serialize_field("latency", &time)?;
+        state.serialize_field("persistence_wait", &self.persistence_wait.map(|d| d.as_micros()))?;
+        state.serialize_field("execution_cache_wait", &self.execution_cache_wait.as_micros())?;
+        state.serialize_field("sparse_trie_wait", &self.sparse_trie_wait.as_micros())?;
         state.end()
     }
 }
@@ -126,7 +138,7 @@ impl Serialize for CombinedResult {
         let fcu_latency = self.fcu_latency.as_micros();
         let new_payload_latency = self.new_payload_result.latency.as_micros();
         let total_latency = self.total_latency.as_micros();
-        let mut state = serializer.serialize_struct("CombinedResult", 7)?;
+        let mut state = serializer.serialize_struct("CombinedResult", 10)?;
 
         // flatten the new payload result because this is meant for CSV writing
         state.serialize_field("block_number", &self.block_number)?;
@@ -136,6 +148,18 @@ impl Serialize for CombinedResult {
         state.serialize_field("new_payload_latency", &new_payload_latency)?;
         state.serialize_field("fcu_latency", &fcu_latency)?;
         state.serialize_field("total_latency", &total_latency)?;
+        state.serialize_field(
+            "persistence_wait",
+            &self.new_payload_result.persistence_wait.map(|d| d.as_micros()),
+        )?;
+        state.serialize_field(
+            "execution_cache_wait",
+            &self.new_payload_result.execution_cache_wait.as_micros(),
+        )?;
+        state.serialize_field(
+            "sparse_trie_wait",
+            &self.new_payload_result.sparse_trie_wait.as_micros(),
+        )?;
         state.end()
     }
 }

bin/reth-bench/src/bench/replay_payloads.rs

@@ -23,12 +23,15 @@ use crate::{
             derive_ws_rpc_url, setup_persistence_subscription, PersistenceWaiter,
         },
     },
-    valid_payload::{call_forkchoice_updated, call_new_payload},
+    valid_payload::{call_forkchoice_updated, call_new_payload_with_reth},
 };
 use alloy_primitives::B256;
 use alloy_provider::{ext::EngineApi, network::AnyNetwork, Provider, RootProvider};
 use alloy_rpc_client::ClientBuilder;
-use alloy_rpc_types_engine::{ExecutionPayloadEnvelopeV4, ForkchoiceState, JwtSecret};
+use alloy_rpc_types_engine::{
+    CancunPayloadFields, ExecutionData, ExecutionPayloadEnvelopeV4, ExecutionPayloadSidecar,
+    ForkchoiceState, JwtSecret, PraguePayloadFields,
+};
 use clap::Parser;
 use eyre::Context;
 use reth_cli_runner::CliContext;
@@ -124,6 +127,14 @@ pub struct Command {
     /// If not provided, derives from engine RPC URL by changing scheme to ws and port to 8546.
     #[arg(long, value_name = "WS_RPC_URL", verbatim_doc_comment)]
     ws_rpc_url: Option<String>,
+
+    /// Use `reth_newPayload` endpoint instead of `engine_newPayload*`.
+    ///
+    /// The `reth_newPayload` endpoint is a reth-specific extension that takes `ExecutionData`
+    /// directly, waits for persistence and cache updates to complete before processing,
+    /// and returns server-side timing breakdowns (latency, persistence wait, cache wait).
+    #[arg(long, default_value = "false", verbatim_doc_comment)]
+    reth_new_payload: bool,
 }
 
 /// A loaded payload ready for execution.
@@ -163,6 +174,9 @@ impl Command {
                 self.persistence_threshold
             );
         }
+        if self.reth_new_payload {
+            info!("Using reth_newPayload endpoint");
+        }
 
         // Set up waiter based on configured options
         // When both are set: wait at least wait_time, and also wait for persistence if needed
@@ -248,7 +262,15 @@ impl Command {
                 "Executing gas ramp payload (newPayload + FCU)"
             );
 
-            call_new_payload(&auth_provider, payload.version, payload.file.params.clone()).await?;
+            let reth_data =
+                if self.reth_new_payload { payload.file.execution_data.clone() } else { None };
+            let _ = call_new_payload_with_reth(
+                &auth_provider,
+                payload.version,
+                payload.file.params.clone(),
+                reth_data,
+            )
+            .await?;
 
             let fcu_state = ForkchoiceState {
                 head_block_hash: payload.file.block_hash,
@@ -303,20 +325,47 @@ impl Command {
                 "Sending newPayload"
             );
 
-            let status = auth_provider
-                .new_payload_v4(
-                    execution_payload.clone(),
-                    vec![],
-                    B256::ZERO,
-                    envelope.execution_requests.to_vec(),
-                )
-                .await?;
+            let params = serde_json::to_value((
+                execution_payload.clone(),
+                Vec::<B256>::new(),
+                B256::ZERO,
+                envelope.execution_requests.to_vec(),
+            ))?;
 
-            let new_payload_result = NewPayloadResult { gas_used, latency: start.elapsed() };
+            let reth_data = self.reth_new_payload.then(|| ExecutionData {
+                payload: execution_payload.clone().into(),
+                sidecar: ExecutionPayloadSidecar::v4(
+                    CancunPayloadFields {
+                        versioned_hashes: Vec::new(),
+                        parent_beacon_block_root: B256::ZERO,
+                    },
+                    PraguePayloadFields { requests: envelope.execution_requests.clone().into() },
+                ),
+            });
 
-            if !status.is_valid() {
-                return Err(eyre::eyre!("Payload rejected: {:?}", status));
-            }
+            let server_timings = call_new_payload_with_reth(
+                &auth_provider,
+                EngineApiMessageVersion::V4,
+                params,
+                reth_data,
+            )
+            .await?;
+
+            let np_latency =
+                server_timings.as_ref().map(|t| t.latency).unwrap_or_else(|| start.elapsed());
+            let new_payload_result = NewPayloadResult {
+                gas_used,
+                latency: np_latency,
+                persistence_wait: server_timings.as_ref().and_then(|t| t.persistence_wait),
+                execution_cache_wait: server_timings
+                    .as_ref()
+                    .map(|t| t.execution_cache_wait)
+                    .unwrap_or_default(),
+                sparse_trie_wait: server_timings
+                    .as_ref()
+                    .map(|t| t.sparse_trie_wait)
+                    .unwrap_or_default(),
+            };
 
             let fcu_state = ForkchoiceState {
                 head_block_hash: block_hash,
@@ -326,10 +375,12 @@ impl Command {
 
             debug!(target: "reth-bench", method = "engine_forkchoiceUpdatedV3", ?fcu_state, "Sending forkchoiceUpdated");
 
+            let fcu_start = Instant::now();
             let fcu_result = auth_provider.fork_choice_updated_v3(fcu_state, None).await?;
+            let fcu_latency = fcu_start.elapsed();
 
-            let total_latency = start.elapsed();
-            let fcu_latency = total_latency - new_payload_result.latency;
+            let total_latency =
+                if server_timings.is_some() { np_latency + fcu_latency } else { start.elapsed() };
 
             let combined_result = CombinedResult {
                 block_number,
@@ -341,7 +392,8 @@ impl Command {
             };
 
             let current_duration = total_benchmark_duration.elapsed();
-            info!(target: "reth-bench", %combined_result);
+            let progress = format!("{}/{}", i + 1, payloads.len());
+            info!(target: "reth-bench", progress, %combined_result);
 
             if let Some(w) = &mut waiter {
                 w.on_block(block_number).await?;
@@ -351,7 +403,7 @@ impl Command {
                 TotalGasRow { block_number, transaction_count, gas_used, time: current_duration };
             results.push((gas_row, combined_result));
 
-            debug!(target: "reth-bench", ?status, ?fcu_result, "Payload executed successfully");
+            debug!(target: "reth-bench", ?fcu_result, "Payload executed successfully");
             parent_hash = block_hash;
         }
 

bin/reth-bench/src/bench_mode.rs

@@ -20,6 +20,19 @@ impl BenchMode {
         }
     }
 
+    /// Returns the total number of blocks in the benchmark, if known.
+    ///
+    /// For [`BenchMode::Range`] this is the length of the range.
+    /// For [`BenchMode::Continuous`] the total is unbounded, so `None` is returned.
+    pub const fn total_blocks(&self) -> Option<u64> {
+        match self {
+            Self::Continuous(_) => None,
+            Self::Range(range) => {
+                Some(range.end().saturating_sub(*range.start()).saturating_add(1))
+            }
+        }
+    }
+
     /// Create a [`BenchMode`] from optional `from` and `to` fields.
     pub fn new(from: Option<u64>, to: Option<u64>, latest_block: u64) -> Result<Self, eyre::Error> {
         // If neither `--from` nor `--to` are provided, we will run the benchmark continuously,

bin/reth-bench/src/valid_payload.rs

@@ -6,12 +6,14 @@ use alloy_eips::eip7685::Requests;
 use alloy_primitives::B256;
 use alloy_provider::{ext::EngineApi, network::AnyRpcBlock, Network, Provider};
 use alloy_rpc_types_engine::{
-    ExecutionPayload, ExecutionPayloadInputV2, ExecutionPayloadSidecar, ForkchoiceState,
-    ForkchoiceUpdated, PayloadAttributes, PayloadStatus,
+    ExecutionData, ExecutionPayload, ExecutionPayloadInputV2, ExecutionPayloadSidecar,
+    ForkchoiceState, ForkchoiceUpdated, PayloadAttributes, PayloadStatus,
 };
 use alloy_transport::TransportResult;
 use op_alloy_rpc_types_engine::OpExecutionPayloadV4;
 use reth_node_api::EngineApiMessageVersion;
+use serde::Deserialize;
+use std::time::Duration;
 use tracing::{debug, error};
 
 /// An extension trait for providers that implement the engine API, to wait for a VALID response.
@@ -161,10 +163,13 @@ where
     }
 }
 
+/// Converts an RPC block into versioned engine API params and an [`ExecutionData`].
+///
+/// Returns `(version, versioned_params, execution_data)`.
 pub(crate) fn block_to_new_payload(
     block: AnyRpcBlock,
     is_optimism: bool,
-) -> eyre::Result<(EngineApiMessageVersion, serde_json::Value)> {
+) -> eyre::Result<(EngineApiMessageVersion, serde_json::Value, ExecutionData)> {
     let block = block
         .into_inner()
         .map_header(|header| header.map(|h| h.into_header_with_defaults()))
@@ -179,13 +184,19 @@ pub(crate) fn block_to_new_payload(
     payload_to_new_payload(payload, sidecar, is_optimism, block.withdrawals_root, None)
 }
 
+/// Converts an execution payload and sidecar into versioned engine API params and an
+/// [`ExecutionData`].
+///
+/// Returns `(version, versioned_params, execution_data)`.
 pub(crate) fn payload_to_new_payload(
     payload: ExecutionPayload,
     sidecar: ExecutionPayloadSidecar,
     is_optimism: bool,
     withdrawals_root: Option<B256>,
     target_version: Option<EngineApiMessageVersion>,
-) -> eyre::Result<(EngineApiMessageVersion, serde_json::Value)> {
+) -> eyre::Result<(EngineApiMessageVersion, serde_json::Value, ExecutionData)> {
+    let execution_data = ExecutionData { payload: payload.clone(), sidecar: sidecar.clone() };
+
     let (version, params) = match payload {
         ExecutionPayload::V3(payload) => {
             let cancun = sidecar.cancun().unwrap();
@@ -244,7 +255,7 @@ pub(crate) fn payload_to_new_payload(
         }
     };
 
-    Ok((version, params))
+    Ok((version, params, execution_data))
 }
 
 /// Calls the correct `engine_newPayload` method depending on the given [`ExecutionPayload`] and its
@@ -252,32 +263,109 @@ pub(crate) fn payload_to_new_payload(
 ///
 /// # Panics
 /// If the given payload is a V3 payload, but a parent beacon block root is provided as `None`.
+#[allow(dead_code)]
 pub(crate) async fn call_new_payload<N: Network, P: Provider<N>>(
     provider: P,
     version: EngineApiMessageVersion,
     params: serde_json::Value,
-) -> TransportResult<()> {
-    let method = version.method_name();
+) -> TransportResult<Option<NewPayloadTimingBreakdown>> {
+    call_new_payload_with_reth(provider, version, params, None).await
+}
 
-    debug!(target: "reth-bench", method, "Sending newPayload");
+/// Response from `reth_newPayload` endpoint, which includes server-measured latency.
+#[derive(Debug, Deserialize)]
+struct RethPayloadStatus {
+    #[serde(flatten)]
+    status: PayloadStatus,
+    latency_us: u64,
+    #[serde(default)]
+    persistence_wait_us: Option<u64>,
+    #[serde(default)]
+    execution_cache_wait_us: u64,
+    #[serde(default)]
+    sparse_trie_wait_us: u64,
+}
 
-    let mut status: PayloadStatus = provider.client().request(method, &params).await?;
+/// Server-side timing breakdown from `reth_newPayload` endpoint.
+#[derive(Debug, Clone, Copy, Default)]
+pub(crate) struct NewPayloadTimingBreakdown {
+    /// Server-side execution latency.
+    pub(crate) latency: Duration,
+    /// Time spent waiting for persistence. `None` when no persistence was in-flight.
+    pub(crate) persistence_wait: Option<Duration>,
+    /// Time spent waiting for execution cache lock.
+    pub(crate) execution_cache_wait: Duration,
+    /// Time spent waiting for sparse trie lock.
+    pub(crate) sparse_trie_wait: Duration,
+}
 
-    while !status.is_valid() {
-        if status.is_invalid() {
-            error!(target: "reth-bench", ?status, ?params, "Invalid {method}",);
-            return Err(alloy_json_rpc::RpcError::LocalUsageError(Box::new(std::io::Error::other(
-                format!("Invalid {method}: {status:?}"),
-            ))))
+/// Calls either `engine_newPayload*` or `reth_newPayload` depending on whether
+/// `reth_execution_data` is provided.
+///
+/// When `reth_execution_data` is `Some`, uses the `reth_newPayload` endpoint which takes
+/// `ExecutionData` directly and waits for persistence and cache updates to complete.
+///
+/// Returns the server-reported timing breakdown when using the reth namespace, or `None` for
+/// the standard engine namespace.
+pub(crate) async fn call_new_payload_with_reth<N: Network, P: Provider<N>>(
+    provider: P,
+    version: EngineApiMessageVersion,
+    params: serde_json::Value,
+    reth_execution_data: Option<ExecutionData>,
+) -> TransportResult<Option<NewPayloadTimingBreakdown>> {
+    if let Some(execution_data) = reth_execution_data {
+        let method = "reth_newPayload";
+        let reth_params = serde_json::to_value((execution_data.clone(),))
+            .expect("ExecutionData serialization cannot fail");
+
+        debug!(target: "reth-bench", method, "Sending newPayload");
+
+        let mut resp: RethPayloadStatus = provider.client().request(method, &reth_params).await?;
+
+        while !resp.status.is_valid() {
+            if resp.status.is_invalid() {
+                error!(target: "reth-bench", status=?resp.status, "Invalid {method}");
+                return Err(alloy_json_rpc::RpcError::LocalUsageError(Box::new(
+                    std::io::Error::other(format!("Invalid {method}: {:?}", resp.status)),
+                )))
+            }
+            if resp.status.is_syncing() {
+                return Err(alloy_json_rpc::RpcError::UnsupportedFeature(
+                    "invalid range: no canonical state found for parent of requested block",
+                ))
+            }
+            resp = provider.client().request(method, &reth_params).await?;
         }
-        if status.is_syncing() {
-            return Err(alloy_json_rpc::RpcError::UnsupportedFeature(
-                "invalid range: no canonical state found for parent of requested block",
-            ))
+
+        Ok(Some(NewPayloadTimingBreakdown {
+            latency: Duration::from_micros(resp.latency_us),
+            persistence_wait: resp.persistence_wait_us.map(Duration::from_micros),
+            execution_cache_wait: Duration::from_micros(resp.execution_cache_wait_us),
+            sparse_trie_wait: Duration::from_micros(resp.sparse_trie_wait_us),
+        }))
+    } else {
+        let method = version.method_name();
+
+        debug!(target: "reth-bench", method, "Sending newPayload");
+
+        let mut status: PayloadStatus = provider.client().request(method, &params).await?;
+
+        while !status.is_valid() {
+            if status.is_invalid() {
+                error!(target: "reth-bench", ?status, ?params, "Invalid {method}",);
+                return Err(alloy_json_rpc::RpcError::LocalUsageError(Box::new(
+                    std::io::Error::other(format!("Invalid {method}: {status:?}")),
+                )))
+            }
+            if status.is_syncing() {
+                return Err(alloy_json_rpc::RpcError::UnsupportedFeature(
+                    "invalid range: no canonical state found for parent of requested block",
+                ))
+            }
+            status = provider.client().request(method, &params).await?;
         }
-        status = provider.client().request(method, &params).await?;
+        Ok(None)
     }
-    Ok(())
 }
 
 /// Calls the correct `engine_forkchoiceUpdated` method depending on the given

crates/chain-state/src/in_memory.rs

@@ -1061,6 +1061,14 @@ mod tests {
         ) -> ProviderResult<Option<StorageValue>> {
             Ok(None)
         }
+
+        fn storage_by_hashed_key(
+            &self,
+            _address: Address,
+            _hashed_storage_key: StorageKey,
+        ) -> ProviderResult<Option<StorageValue>> {
+            Ok(None)
+        }
     }
 
     impl BytecodeReader for MockStateProvider {

crates/chain-state/src/memory_overlay.rs

@@ -223,6 +223,26 @@ impl<N: NodePrimitives> StateProvider for MemoryOverlayStateProviderRef<'_, N> {
 
         self.historical.storage(address, storage_key)
     }
+
+    fn storage_by_hashed_key(
+        &self,
+        address: Address,
+        hashed_storage_key: StorageKey,
+    ) -> ProviderResult<Option<StorageValue>> {
+        let hashed_address = keccak256(address);
+        let state = &self.trie_input().state;
+
+        if let Some(hs) = state.storages.get(&hashed_address) {
+            if let Some(value) = hs.storage.get(&hashed_storage_key) {
+                return Ok(Some(*value));
+            }
+            if hs.wiped {
+                return Ok(Some(StorageValue::ZERO));
+            }
+        }
+
+        self.historical.storage_by_hashed_key(address, hashed_storage_key)
+    }
 }
 
 impl<N: NodePrimitives> BytecodeReader for MemoryOverlayStateProviderRef<'_, N> {

crates/cli/commands/src/common.rs

@@ -19,7 +19,7 @@ use reth_node_builder::{
     Node, NodeComponents, NodeComponentsBuilder, NodeTypes, NodeTypesWithDBAdapter,
 };
 use reth_node_core::{
-    args::{DatabaseArgs, DatadirArgs, RocksDbArgs, StaticFilesArgs, StorageArgs},
+    args::{DatabaseArgs, DatadirArgs, StaticFilesArgs, StorageArgs},
     dirs::{ChainPath, DataDirPath},
 };
 use reth_provider::{
@@ -67,62 +67,23 @@ pub struct EnvironmentArgs<C: ChainSpecParser> {
     #[command(flatten)]
     pub static_files: StaticFilesArgs,
 
-    /// All `RocksDB` related arguments
-    #[command(flatten)]
-    pub rocksdb: RocksDbArgs,
-
     /// Storage mode configuration (v2 vs v1/legacy)
     #[command(flatten)]
     pub storage: StorageArgs,
 }
 
 impl<C: ChainSpecParser> EnvironmentArgs<C> {
-    /// Returns the effective storage settings derived from `--storage.v2`, static-file, and
-    /// `RocksDB` CLI args.
+    /// Returns the effective storage settings derived from `--storage.v2`.
     ///
     /// The base storage mode is determined by `--storage.v2`:
     /// - When `--storage.v2` is set: uses [`StorageSettings::v2()`] defaults
-    /// - Otherwise: uses [`StorageSettings::v1()`] defaults
-    ///
-    /// Individual `--static-files.*` and `--rocksdb.*` flags override the base when explicitly set.
+    /// - Otherwise: uses [`StorageSettings::base()`] defaults
     pub fn storage_settings(&self) -> StorageSettings {
-        let mut s = if self.storage.v2 { StorageSettings::v2() } else { StorageSettings::base() };
-
-        // Apply static files overrides (only when explicitly set)
-        if let Some(v) = self.static_files.receipts {
-            s = s.with_receipts_in_static_files(v);
+        if self.storage.v2 {
+            StorageSettings::v2()
+        } else {
+            StorageSettings::base()
         }
-        if let Some(v) = self.static_files.transaction_senders {
-            s = s.with_transaction_senders_in_static_files(v);
-        }
-        if let Some(v) = self.static_files.account_changesets {
-            s = s.with_account_changesets_in_static_files(v);
-        }
-        if let Some(v) = self.static_files.storage_changesets {
-            s = s.with_storage_changesets_in_static_files(v);
-        }
-
-        // Apply rocksdb overrides
-        // --rocksdb.all sets all rocksdb flags to true
-        if self.rocksdb.all {
-            s = s
-                .with_transaction_hash_numbers_in_rocksdb(true)
-                .with_storages_history_in_rocksdb(true)
-                .with_account_history_in_rocksdb(true);
-        }
-
-        // Individual rocksdb flags override --rocksdb.all when explicitly set
-        if let Some(v) = self.rocksdb.tx_hash {
-            s = s.with_transaction_hash_numbers_in_rocksdb(v);
-        }
-        if let Some(v) = self.rocksdb.storages_history {
-            s = s.with_storages_history_in_rocksdb(v);
-        }
-        if let Some(v) = self.rocksdb.account_history {
-            s = s.with_account_history_in_rocksdb(v);
-        }
-
-        s
     }
 
     /// Initializes environment according to [`AccessRights`] and returns an instance of

crates/cli/commands/src/db/account_storage.rs

@@ -5,6 +5,7 @@ use reth_codecs::Compact;
 use reth_db_api::{cursor::DbDupCursorRO, database::Database, tables, transaction::DbTx};
 use reth_db_common::DbTool;
 use reth_node_builder::NodeTypesWithDB;
+use reth_storage_api::StorageSettingsCache;
 use std::time::{Duration, Instant};
 use tracing::info;
 
@@ -22,52 +23,94 @@ impl Command {
     /// Execute `db account-storage` command
     pub fn execute<N: NodeTypesWithDB>(self, tool: &DbTool<N>) -> eyre::Result<()> {
         let address = self.address;
-        let (slot_count, plain_size) = tool.provider_factory.db_ref().view(|tx| {
-            let mut cursor = tx.cursor_dup_read::<tables::PlainStorageState>()?;
-            let mut count = 0usize;
-            let mut total_value_bytes = 0usize;
-            let mut last_log = Instant::now();
+        let use_hashed_state = tool.provider_factory.cached_storage_settings().use_hashed_state();
 
-            // Walk all storage entries for this address
-            let walker = cursor.walk_dup(Some(address), None)?;
-            for entry in walker {
-                let (_, storage_entry) = entry?;
-                count += 1;
-                // StorageEntry encodes as: 32 bytes (key/subkey uncompressed) + compressed U256
-                let mut buf = Vec::new();
-                let entry_len = storage_entry.to_compact(&mut buf);
-                total_value_bytes += entry_len;
+        let (slot_count, storage_size) = if use_hashed_state {
+            let hashed_address = keccak256(address);
+            tool.provider_factory.db_ref().view(|tx| {
+                let mut cursor = tx.cursor_dup_read::<tables::HashedStorages>()?;
+                let mut count = 0usize;
+                let mut total_value_bytes = 0usize;
+                let mut last_log = Instant::now();
 
-                if last_log.elapsed() >= LOG_INTERVAL {
-                    info!(
-                        target: "reth::cli",
-                        address = %address,
-                        slots = count,
-                        key = %storage_entry.key,
-                        "Processing storage slots"
-                    );
-                    last_log = Instant::now();
+                let walker = cursor.walk_dup(Some(hashed_address), None)?;
+                for entry in walker {
+                    let (_, storage_entry) = entry?;
+                    count += 1;
+                    let mut buf = Vec::new();
+                    let entry_len = storage_entry.to_compact(&mut buf);
+                    total_value_bytes += entry_len;
+
+                    if last_log.elapsed() >= LOG_INTERVAL {
+                        info!(
+                            target: "reth::cli",
+                            address = %address,
+                            slots = count,
+                            key = %storage_entry.key,
+                            "Processing hashed storage slots"
+                        );
+                        last_log = Instant::now();
+                    }
                 }
-            }
 
-            // Add 20 bytes for the Address key (stored once per account in dupsort)
-            let total_size = if count > 0 { 20 + total_value_bytes } else { 0 };
+                let total_size = if count > 0 { 32 + total_value_bytes } else { 0 };
 
-            Ok::<_, eyre::Report>((count, total_size))
-        })??;
+                Ok::<_, eyre::Report>((count, total_size))
+            })??
+        } else {
+            tool.provider_factory.db_ref().view(|tx| {
+                let mut cursor = tx.cursor_dup_read::<tables::PlainStorageState>()?;
+                let mut count = 0usize;
+                let mut total_value_bytes = 0usize;
+                let mut last_log = Instant::now();
 
-        // Estimate hashed storage size: 32-byte B256 key instead of 20-byte Address
-        let hashed_size_estimate = if slot_count > 0 { plain_size + 12 } else { 0 };
-        let total_estimate = plain_size + hashed_size_estimate;
+                // Walk all storage entries for this address
+                let walker = cursor.walk_dup(Some(address), None)?;
+                for entry in walker {
+                    let (_, storage_entry) = entry?;
+                    count += 1;
+                    let mut buf = Vec::new();
+                    // StorageEntry encodes as: 32 bytes (key/subkey uncompressed) + compressed U256
+                    let entry_len = storage_entry.to_compact(&mut buf);
+                    total_value_bytes += entry_len;
+
+                    if last_log.elapsed() >= LOG_INTERVAL {
+                        info!(
+                            target: "reth::cli",
+                            address = %address,
+                            slots = count,
+                            key = %storage_entry.key,
+                            "Processing storage slots"
+                        );
+                        last_log = Instant::now();
+                    }
+                }
+
+                // Add 20 bytes for the Address key (stored once per account in dupsort)
+                let total_size = if count > 0 { 20 + total_value_bytes } else { 0 };
+
+                Ok::<_, eyre::Report>((count, total_size))
+            })??
+        };
 
         let hashed_address = keccak256(address);
 
         println!("Account: {address}");
         println!("Hashed address: {hashed_address}");
         println!("Storage slots: {slot_count}");
-        println!("Plain storage size: {} (estimated)", human_bytes(plain_size as f64));
-        println!("Hashed storage size: {} (estimated)", human_bytes(hashed_size_estimate as f64));
-        println!("Total estimated size: {}", human_bytes(total_estimate as f64));
+        if use_hashed_state {
+            println!("Hashed storage size: {} (estimated)", human_bytes(storage_size as f64));
+        } else {
+            // Estimate hashed storage size: 32-byte B256 key instead of 20-byte Address
+            let hashed_size_estimate = if slot_count > 0 { storage_size + 12 } else { 0 };
+            let total_estimate = storage_size + hashed_size_estimate;
+            println!("Plain storage size: {} (estimated)", human_bytes(storage_size as f64));
+            println!(
+                "Hashed storage size: {} (estimated)",
+                human_bytes(hashed_size_estimate as f64)
+            );
+            println!("Total estimated size: {}", human_bytes(total_estimate as f64));
+        }
 
         Ok(())
     }

crates/cli/commands/src/db/copy.rs

@@ -0,0 +1,61 @@
+use clap::Parser;
+use reth_db::mdbx::{self, ffi};
+use std::path::PathBuf;
+
+/// Copies the MDBX database to a new location.
+///
+/// Equivalent to the standalone `mdbx_copy` tool but bundled into reth.
+#[derive(Parser, Debug)]
+pub struct Command {
+    /// Destination path for the database copy.
+    dest: PathBuf,
+
+    /// Compact the database while copying (reclaims free space).
+    #[arg(short, long)]
+    compact: bool,
+
+    /// Force dynamic size for the destination database.
+    #[arg(short = 'd', long)]
+    force_dynamic_size: bool,
+
+    /// Throttle to avoid MVCC pressure on writers.
+    #[arg(short = 'p', long)]
+    throttle_mvcc: bool,
+}
+
+impl Command {
+    /// Execute `db copy` command
+    pub fn execute(self, db: &mdbx::DatabaseEnv) -> eyre::Result<()> {
+        let mut flags: ffi::MDBX_copy_flags_t = ffi::MDBX_CP_DEFAULTS;
+        if self.compact {
+            flags |= ffi::MDBX_CP_COMPACT;
+        }
+        if self.force_dynamic_size {
+            flags |= ffi::MDBX_CP_FORCE_DYNAMIC_SIZE;
+        }
+        if self.throttle_mvcc {
+            flags |= ffi::MDBX_CP_THROTTLE_MVCC;
+        }
+
+        let dest = self
+            .dest
+            .to_str()
+            .ok_or_else(|| eyre::eyre!("destination path must be valid UTF-8"))?;
+        let dest_cstr = std::ffi::CString::new(dest)?;
+
+        println!("Copying database to {} ...", self.dest.display());
+
+        let rc = db.with_raw_env_ptr(|env_ptr| unsafe {
+            ffi::mdbx_env_copy(env_ptr, dest_cstr.as_ptr(), flags)
+        });
+
+        if rc != 0 {
+            eyre::bail!("mdbx_env_copy failed with error code {rc}: {}", unsafe {
+                std::ffi::CStr::from_ptr(ffi::mdbx_strerror(rc)).to_string_lossy()
+            });
+        }
+
+        println!("Done.");
+        Ok(())
+    }
+}

crates/cli/commands/src/db/get.rs

@@ -98,7 +98,8 @@ impl Command {
                         )?;
 
                         if let Some(entry) = entry {
-                            println!("{}", serde_json::to_string_pretty(&entry)?);
+                            let se: reth_primitives_traits::StorageEntry = entry.into();
+                            println!("{}", serde_json::to_string_pretty(&se)?);
                         } else {
                             error!(target: "reth::cli", "No content for the given table key.");
                         }
@@ -106,7 +107,14 @@ impl Command {
                     }
 
                     let changesets = provider.storage_changeset(key.block_number())?;
-                    println!("{}", serde_json::to_string_pretty(&changesets)?);
+                    let serializable: Vec<_> = changesets
+                        .into_iter()
+                        .map(|(addr, entry)| {
+                            let se: reth_primitives_traits::StorageEntry = entry.into();
+                            (addr, se)
+                        })
+                        .collect();
+                    println!("{}", serde_json::to_string_pretty(&serializable)?);
                     return Ok(());
                 }
 

crates/cli/commands/src/db/mod.rs

@@ -12,6 +12,7 @@ use std::{
 mod account_storage;
 mod checksum;
 mod clear;
+mod copy;
 mod diff;
 mod get;
 mod list;
@@ -42,6 +43,8 @@ pub enum Subcommands {
     List(list::Command),
     /// Calculates the content checksum of a table or static file segment
     Checksum(checksum::Command),
+    /// Copies the MDBX database to a new location (bundled mdbx_copy)
+    Copy(copy::Command),
     /// Create a diff between two database tables or two entire databases.
     Diff(diff::Command),
     /// Gets the content of a table for the given key
@@ -124,6 +127,11 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> Command<C>
                     command.execute(&tool)?;
                 });
             }
+            Subcommands::Copy(command) => {
+                db_exec!(self.env, tool, N, AccessRights::RO, {
+                    command.execute(tool.provider_factory.db_ref())?;
+                });
+            }
             Subcommands::Diff(command) => {
                 db_exec!(self.env, tool, N, AccessRights::RO, {
                     command.execute(&tool)?;

crates/cli/commands/src/db/repair_trie.rs

@@ -285,7 +285,6 @@ fn verify_and_repair<N: ProviderNodeTypes>(tool: &DbTool<N>) -> eyre::Result<()>
                 // (We can't just use `upsert` method with a dup cursor, it's not properly
                 // supported)
                 let nibbles = StoredNibblesSubKey(path);
-                let entry = StorageTrieEntry { nibbles: nibbles.clone(), node };
                 if storage_trie_cursor
                     .seek_by_key_subkey(account, nibbles.clone())?
                     .filter(|v| v.nibbles == nibbles)
@@ -293,6 +292,7 @@ fn verify_and_repair<N: ProviderNodeTypes>(tool: &DbTool<N>) -> eyre::Result<()>
                 {
                     storage_trie_cursor.delete_current()?;
                 }
+                let entry = StorageTrieEntry { nibbles, node };
                 storage_trie_cursor.upsert(account, &entry)?;
             }
             Output::Progress(path) => {

crates/cli/commands/src/db/settings.rs

@@ -39,50 +39,12 @@ enum Subcommands {
 #[derive(Debug, Clone, Copy, Subcommand)]
 #[clap(rename_all = "snake_case")]
 pub enum SetCommand {
-    /// Store receipts in static files instead of the database
-    Receipts {
-        #[clap(action(ArgAction::Set))]
-        value: bool,
-    },
-    /// Store transaction senders in static files instead of the database
-    TransactionSenders {
-        #[clap(action(ArgAction::Set))]
-        value: bool,
-    },
-    /// Store account changesets in static files instead of the database
-    AccountChangesets {
-        #[clap(action(ArgAction::Set))]
-        value: bool,
-    },
-    /// Store storage history in rocksdb instead of MDBX
-    StoragesHistory {
-        #[clap(action(ArgAction::Set))]
-        value: bool,
-    },
-    /// Store transaction hash to number mapping in rocksdb instead of MDBX
-    TransactionHashNumbers {
-        #[clap(action(ArgAction::Set))]
-        value: bool,
-    },
-    /// Store account history in rocksdb instead of MDBX
-    AccountHistory {
-        #[clap(action(ArgAction::Set))]
-        value: bool,
-    },
-    /// Store storage changesets in static files instead of the database
-    StorageChangesets {
-        #[clap(action(ArgAction::Set))]
-        value: bool,
-    },
-    /// Use hashed state tables (HashedAccounts/HashedStorages) as canonical state
+    /// Enable or disable v2 storage layout
     ///
-    /// When enabled, execution writes directly to hashed tables, eliminating need for
-    /// separate hashing stages. State reads come from hashed tables.
-    ///
-    /// WARNING: Changing this setting in either direction requires re-syncing the database.
-    /// Enabling on an existing plain-state database leaves hashed tables empty.
-    /// Disabling on an existing hashed-state database leaves plain tables empty.
-    UseHashedState {
+    /// When enabled, uses static files for receipts/senders/changesets and RocksDB for
+    /// history indices and transaction hashes. When disabled, uses v1/legacy layout (everything in
+    /// MDBX).
+    V2 {
         #[clap(action(ArgAction::Set))]
         value: bool,
     },
@@ -125,87 +87,18 @@ impl Command {
             println!("No storage settings found, creating new settings.");
         }
 
-        let mut settings @ StorageSettings {
-            receipts_in_static_files: _,
-            transaction_senders_in_static_files: _,
-            storages_history_in_rocksdb: _,
-            transaction_hash_numbers_in_rocksdb: _,
-            account_history_in_rocksdb: _,
-            account_changesets_in_static_files: _,
-            storage_changesets_in_static_files: _,
-            use_hashed_state: _,
-        } = settings.unwrap_or_else(StorageSettings::v1);
+        let mut settings @ StorageSettings { storage_v2: _ } =
+            settings.unwrap_or_else(StorageSettings::v1);
 
         // Update the setting based on the key
         match cmd {
-            SetCommand::Receipts { value } => {
-                if settings.receipts_in_static_files == value {
-                    println!("receipts_in_static_files is already set to {}", value);
+            SetCommand::V2 { value } => {
+                if settings.storage_v2 == value {
+                    println!("storage_v2 is already set to {}", value);
                     return Ok(());
                 }
-                settings.receipts_in_static_files = value;
-                println!("Set receipts_in_static_files = {}", value);
-            }
-            SetCommand::TransactionSenders { value } => {
-                if settings.transaction_senders_in_static_files == value {
-                    println!("transaction_senders_in_static_files is already set to {}", value);
-                    return Ok(());
-                }
-                settings.transaction_senders_in_static_files = value;
-                println!("Set transaction_senders_in_static_files = {}", value);
-            }
-            SetCommand::AccountChangesets { value } => {
-                if settings.account_changesets_in_static_files == value {
-                    println!("account_changesets_in_static_files is already set to {}", value);
-                    return Ok(());
-                }
-                settings.account_changesets_in_static_files = value;
-                println!("Set account_changesets_in_static_files = {}", value);
-            }
-            SetCommand::StoragesHistory { value } => {
-                if settings.storages_history_in_rocksdb == value {
-                    println!("storages_history_in_rocksdb is already set to {}", value);
-                    return Ok(());
-                }
-                settings.storages_history_in_rocksdb = value;
-                println!("Set storages_history_in_rocksdb = {}", value);
-            }
-            SetCommand::TransactionHashNumbers { value } => {
-                if settings.transaction_hash_numbers_in_rocksdb == value {
-                    println!("transaction_hash_numbers_in_rocksdb is already set to {}", value);
-                    return Ok(());
-                }
-                settings.transaction_hash_numbers_in_rocksdb = value;
-                println!("Set transaction_hash_numbers_in_rocksdb = {}", value);
-            }
-            SetCommand::AccountHistory { value } => {
-                if settings.account_history_in_rocksdb == value {
-                    println!("account_history_in_rocksdb is already set to {}", value);
-                    return Ok(());
-                }
-                settings.account_history_in_rocksdb = value;
-                println!("Set account_history_in_rocksdb = {}", value);
-            }
-            SetCommand::StorageChangesets { value } => {
-                if settings.storage_changesets_in_static_files == value {
-                    println!("storage_changesets_in_static_files is already set to {}", value);
-                    return Ok(());
-                }
-                settings.storage_changesets_in_static_files = value;
-                println!("Set storage_changesets_in_static_files = {}", value);
-            }
-            SetCommand::UseHashedState { value } => {
-                if settings.use_hashed_state == value {
-                    println!("use_hashed_state is already set to {}", value);
-                    return Ok(());
-                }
-                if settings.use_hashed_state && !value {
-                    println!("WARNING: Disabling use_hashed_state on an existing hashed-state database requires a full resync.");
-                } else {
-                    println!("WARNING: Enabling use_hashed_state on an existing plain-state database requires a full resync.");
-                }
-                settings.use_hashed_state = value;
-                println!("Set use_hashed_state = {}", value);
+                settings.storage_v2 = value;
+                println!("Set storage_v2 = {}", value);
             }
         }
 

crates/cli/commands/src/db/state.rs

@@ -1,4 +1,4 @@
-use alloy_primitives::{Address, BlockNumber, B256, U256};
+use alloy_primitives::{keccak256, Address, BlockNumber, B256, U256};
 use clap::Parser;
 use parking_lot::Mutex;
 use reth_db_api::{
@@ -63,39 +63,65 @@ impl Command {
         address: Address,
         limit: usize,
     ) -> eyre::Result<()> {
+        let use_hashed_state = tool.provider_factory.cached_storage_settings().use_hashed_state();
+
         let entries = tool.provider_factory.db_ref().view(|tx| {
-            // Get account info
-            let account = tx.get::<tables::PlainAccountState>(address)?;
-
-            // Get storage entries
-            let mut cursor = tx.cursor_dup_read::<tables::PlainStorageState>()?;
-            let mut entries = Vec::new();
-            let mut last_log = Instant::now();
-
-            let walker = cursor.walk_dup(Some(address), None)?;
-            for (idx, entry) in walker.enumerate() {
-                let (_, storage_entry) = entry?;
-
-                if storage_entry.value != U256::ZERO {
-                    entries.push((storage_entry.key, storage_entry.value));
+            let (account, walker_entries) = if use_hashed_state {
+                let hashed_address = keccak256(address);
+                let account = tx.get::<tables::HashedAccounts>(hashed_address)?;
+                let mut cursor = tx.cursor_dup_read::<tables::HashedStorages>()?;
+                let walker = cursor.walk_dup(Some(hashed_address), None)?;
+                let mut entries = Vec::new();
+                let mut last_log = Instant::now();
+                for (idx, entry) in walker.enumerate() {
+                    let (_, storage_entry) = entry?;
+                    if storage_entry.value != U256::ZERO {
+                        entries.push((storage_entry.key, storage_entry.value));
+                    }
+                    if entries.len() >= limit {
+                        break;
+                    }
+                    if last_log.elapsed() >= LOG_INTERVAL {
+                        info!(
+                            target: "reth::cli",
+                            address = %address,
+                            slots_scanned = idx,
+                            "Scanning storage slots"
+                        );
+                        last_log = Instant::now();
+                    }
                 }
-
-                if entries.len() >= limit {
-                    break;
+                (account, entries)
+            } else {
+                // Get account info
+                let account = tx.get::<tables::PlainAccountState>(address)?;
+                // Get storage entries
+                let mut cursor = tx.cursor_dup_read::<tables::PlainStorageState>()?;
+                let walker = cursor.walk_dup(Some(address), None)?;
+                let mut entries = Vec::new();
+                let mut last_log = Instant::now();
+                for (idx, entry) in walker.enumerate() {
+                    let (_, storage_entry) = entry?;
+                    if storage_entry.value != U256::ZERO {
+                        entries.push((storage_entry.key, storage_entry.value));
+                    }
+                    if entries.len() >= limit {
+                        break;
+                    }
+                    if last_log.elapsed() >= LOG_INTERVAL {
+                        info!(
+                            target: "reth::cli",
+                            address = %address,
+                            slots_scanned = idx,
+                            "Scanning storage slots"
+                        );
+                        last_log = Instant::now();
+                    }
                 }
+                (account, entries)
+            };
 
-                if last_log.elapsed() >= LOG_INTERVAL {
-                    info!(
-                        target: "reth::cli",
-                        address = %address,
-                        slots_scanned = idx,
-                        "Scanning storage slots"
-                    );
-                    last_log = Instant::now();
-                }
-            }
-
-            Ok::<_, eyre::Report>((account, entries))
+            Ok::<_, eyre::Report>((account, walker_entries))
         })??;
 
         let (account, storage_entries) = entries;
@@ -119,7 +145,7 @@ impl Command {
 
         // Check storage settings to determine where history is stored
         let storage_settings = tool.provider_factory.cached_storage_settings();
-        let history_in_rocksdb = storage_settings.storages_history_in_rocksdb;
+        let history_in_rocksdb = storage_settings.storage_v2;
 
         // For historical queries, enumerate keys from history indices only
         // (not PlainStorageState, which reflects current state)

crates/cli/commands/src/download.rs

@@ -37,6 +37,14 @@ pub struct DownloadDefaults {
     pub available_snapshots: Vec<Cow<'static, str>>,
     /// Default base URL for snapshots
     pub default_base_url: Cow<'static, str>,
+    /// Default base URL for chain-aware snapshots.
+    ///
+    /// When set, the chain ID is appended to form the full URL: `{base_url}/{chain_id}`.
+    /// For example, given a base URL of `https://snapshots.example.com` and chain ID `1`,
+    /// the resulting URL would be `https://snapshots.example.com/1`.
+    ///
+    /// Falls back to [`default_base_url`](Self::default_base_url) when `None`.
+    pub default_chain_aware_base_url: Option<Cow<'static, str>>,
     /// Optional custom long help text that overrides the generated help
     pub long_help: Option<String>,
 }
@@ -60,6 +68,7 @@ impl DownloadDefaults {
                 Cow::Borrowed("https://publicnode.com/snapshots (full nodes & testnets)"),
             ],
             default_base_url: Cow::Borrowed(MERKLE_BASE_URL),
+            default_chain_aware_base_url: None,
             long_help: None,
         }
     }
@@ -84,9 +93,11 @@ impl DownloadDefaults {
         }
 
         help.push_str(
-            "\nIf no URL is provided, the latest mainnet archive snapshot\nwill be proposed for download from ",
+            "\nIf no URL is provided, the latest archive snapshot for the selected chain\nwill be proposed for download from ",
+        );
+        help.push_str(
+            self.default_chain_aware_base_url.as_deref().unwrap_or(&self.default_base_url),
         );
-        help.push_str(self.default_base_url.as_ref());
         help.push_str(
             ".\n\nLocal file:// URLs are also supported for extracting snapshots from disk.",
         );
@@ -111,6 +122,12 @@ impl DownloadDefaults {
         self
     }
 
+    /// Set the default chain-aware base URL.
+    pub fn with_chain_aware_base_url(mut self, url: impl Into<Cow<'static, str>>) -> Self {
+        self.default_chain_aware_base_url = Some(url.into());
+        self
+    }
+
     /// Builder: Set custom long help text, overriding the generated help
     pub fn with_long_help(mut self, help: impl Into<String>) -> Self {
         self.long_help = Some(help.into());
@@ -142,7 +159,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> DownloadCo
         let url = match self.url {
             Some(url) => url,
             None => {
-                let url = get_latest_snapshot_url().await?;
+                let url = get_latest_snapshot_url(self.env.chain.chain().id()).await?;
                 info!(target: "reth::cli", "Using default snapshot URL: {}", url);
                 url
             }
@@ -367,15 +384,19 @@ fn resumable_download(url: &str, target_dir: &Path) -> Result<(PathBuf, u64)> {
     let mut total_size: Option<u64> = None;
     let mut last_error: Option<eyre::Error> = None;
 
+    let finalize_download = |size: u64| -> Result<(PathBuf, u64)> {
+        fs::rename(&part_path, &final_path)?;
+        info!(target: "reth::cli", "Download complete: {}", final_path.display());
+        Ok((final_path.clone(), size))
+    };
+
     for attempt in 1..=MAX_DOWNLOAD_RETRIES {
         let existing_size = fs::metadata(&part_path).map(|m| m.len()).unwrap_or(0);
 
         if let Some(total) = total_size &&
             existing_size >= total
         {
-            fs::rename(&part_path, &final_path)?;
-            info!(target: "reth::cli", "Download complete: {}", final_path.display());
-            return Ok((final_path, total));
+            return finalize_download(total);
         }
 
         if attempt > 1 {
@@ -459,9 +480,7 @@ fn resumable_download(url: &str, target_dir: &Path) -> Result<(PathBuf, u64)> {
             continue;
         }
 
-        fs::rename(&part_path, &final_path)?;
-        info!(target: "reth::cli", "Download complete: {}", final_path.display());
-        return Ok((final_path, current_total));
+        return finalize_download(current_total);
     }
 
     Err(last_error
@@ -509,8 +528,12 @@ async fn stream_and_extract(url: &str, target_dir: &Path) -> Result<()> {
 }
 
 // Builds default URL for latest mainnet archive snapshot using configured defaults
-async fn get_latest_snapshot_url() -> Result<String> {
-    let base_url = &DownloadDefaults::get_global().default_base_url;
+async fn get_latest_snapshot_url(chain_id: u64) -> Result<String> {
+    let defaults = DownloadDefaults::get_global();
+    let base_url = match &defaults.default_chain_aware_base_url {
+        Some(url) => format!("{url}/{chain_id}"),
+        None => defaults.default_base_url.to_string(),
+    };
     let latest_url = format!("{base_url}/latest.txt");
     let filename = Client::new()
         .get(latest_url)

crates/cli/commands/src/import_core.rs

@@ -139,7 +139,7 @@ where
         total_decoded_blocks += file_client.headers_len();
         total_decoded_txns += file_client.total_transactions();
 
-        let (mut pipeline, events) = build_import_pipeline_impl(
+        let (mut pipeline, events, _runtime) = build_import_pipeline_impl(
             config,
             provider_factory.clone(),
             &consensus,
@@ -265,7 +265,11 @@ pub fn build_import_pipeline_impl<N, C, E>(
     static_file_producer: StaticFileProducer<ProviderFactory<N>>,
     disable_exec: bool,
     evm_config: E,
-) -> eyre::Result<(Pipeline<N>, impl futures::Stream<Item = NodeEvent<N::Primitives>> + use<N, C, E>)>
+) -> eyre::Result<(
+    Pipeline<N>,
+    impl futures::Stream<Item = NodeEvent<N::Primitives>> + use<N, C, E>,
+    reth_tasks::Runtime,
+)>
 where
     N: ProviderNodeTypes,
     C: FullConsensus<N::Primitives> + 'static,
@@ -281,9 +285,12 @@ where
         .sealed_header(last_block_number)?
         .ok_or_else(|| ProviderError::HeaderNotFound(last_block_number.into()))?;
 
+    let runtime = reth_tasks::Runtime::with_existing_handle(tokio::runtime::Handle::current())
+        .expect("failed to create runtime");
+
     let mut header_downloader = ReverseHeadersDownloaderBuilder::new(config.stages.headers)
         .build(file_client.clone(), consensus.clone())
-        .into_task();
+        .into_task_with(&runtime);
     // TODO: The pipeline should correctly configure the downloader on its own.
     // Find the possibility to remove unnecessary pre-configuration.
     header_downloader.update_local_head(local_head);
@@ -291,7 +298,7 @@ where
 
     let mut body_downloader = BodiesDownloaderBuilder::new(config.stages.bodies)
         .build(file_client.clone(), consensus.clone(), provider_factory.clone())
-        .into_task();
+        .into_task_with(&runtime);
     // TODO: The pipeline should correctly configure the downloader on its own.
     // Find the possibility to remove unnecessary pre-configuration.
     body_downloader
@@ -326,5 +333,5 @@ where
 
     let events = pipeline.events().map(Into::into);
 
-    Ok((pipeline, events))
+    Ok((pipeline, events, runtime))
 }

crates/cli/commands/src/node.rs

@@ -10,8 +10,8 @@ use reth_node_builder::NodeBuilder;
 use reth_node_core::{
     args::{
         DatabaseArgs, DatadirArgs, DebugArgs, DevArgs, EngineArgs, EraArgs, MetricArgs,
-        NetworkArgs, PayloadBuilderArgs, PruningArgs, RocksDbArgs, RpcServerArgs, StaticFilesArgs,
-        StorageArgs, TxPoolArgs,
+        NetworkArgs, PayloadBuilderArgs, PruningArgs, RpcServerArgs, StaticFilesArgs, StorageArgs,
+        TxPoolArgs,
     },
     node_config::NodeConfig,
     version,
@@ -103,10 +103,6 @@ pub struct NodeCommand<C: ChainSpecParser, Ext: clap::Args + fmt::Debug = NoArgs
     #[command(flatten)]
     pub pruning: PruningArgs,
 
-    /// All `RocksDB` table routing arguments
-    #[command(flatten)]
-    pub rocksdb: RocksDbArgs,
-
     /// Engine cli arguments
     #[command(flatten, next_help_heading = "Engine")]
     pub engine: EngineArgs,
@@ -119,8 +115,8 @@ pub struct NodeCommand<C: ChainSpecParser, Ext: clap::Args + fmt::Debug = NoArgs
     #[command(flatten, next_help_heading = "Static Files")]
     pub static_files: StaticFilesArgs,
 
-    /// Storage mode configuration (v2 vs v1/legacy)
-    #[command(flatten)]
+    /// All storage related arguments with --storage prefix
+    #[command(flatten, next_help_heading = "Storage")]
     pub storage: StorageArgs,
 
     /// Additional cli arguments
@@ -175,7 +171,6 @@ where
             db,
             dev,
             pruning,
-            rocksdb,
             engine,
             era,
             static_files,
@@ -183,9 +178,6 @@ where
             ext,
         } = self;
 
-        // Validate RocksDB arguments
-        rocksdb.validate()?;
-
         // set up node config
         let mut node_config = NodeConfig {
             datadir,
@@ -201,7 +193,6 @@ where
             db,
             dev,
             pruning,
-            rocksdb,
             engine,
             era,
             static_files,

crates/cli/commands/src/stage/drop.rs

@@ -45,12 +45,16 @@ impl<C: ChainSpecParser> Command<C> {
 
         let tool = DbTool::new(provider_factory)?;
 
-        let static_file_segment = match self.stage {
-            StageEnum::Headers => Some(StaticFileSegment::Headers),
-            StageEnum::Bodies => Some(StaticFileSegment::Transactions),
-            StageEnum::Execution => Some(StaticFileSegment::Receipts),
-            StageEnum::Senders => Some(StaticFileSegment::TransactionSenders),
-            _ => None,
+        let static_file_segments = match self.stage {
+            StageEnum::Headers => vec![StaticFileSegment::Headers],
+            StageEnum::Bodies => vec![StaticFileSegment::Transactions],
+            StageEnum::Execution => vec![
+                StaticFileSegment::Receipts,
+                StaticFileSegment::AccountChangeSets,
+                StaticFileSegment::StorageChangeSets,
+            ],
+            StageEnum::Senders => vec![StaticFileSegment::TransactionSenders],
+            _ => vec![],
         };
 
         // Calling `StaticFileProviderRW::prune_*` will instruct the writer to prune rows only
@@ -58,35 +62,33 @@ impl<C: ChainSpecParser> Command<C> {
         // deleting the jar files, otherwise if the task were to be interrupted after we
         // have deleted them, BUT before we have committed the checkpoints to the database, we'd
         // lose essential data.
-        if let Some(static_file_segment) = static_file_segment {
-            let static_file_provider = tool.provider_factory.static_file_provider();
-            if let Some(highest_block) =
-                static_file_provider.get_highest_static_file_block(static_file_segment)
+        let static_file_provider = tool.provider_factory.static_file_provider();
+        for segment in static_file_segments {
+            if let Some(highest_block) = static_file_provider.get_highest_static_file_block(segment)
             {
-                let mut writer = static_file_provider.latest_writer(static_file_segment)?;
+                let mut writer = static_file_provider.latest_writer(segment)?;
 
-                match static_file_segment {
+                match segment {
                     StaticFileSegment::Headers => {
-                        // Prune all headers leaving genesis intact.
                         writer.prune_headers(highest_block)?;
                     }
                     StaticFileSegment::Transactions => {
                         let to_delete = static_file_provider
-                            .get_highest_static_file_tx(static_file_segment)
+                            .get_highest_static_file_tx(segment)
                             .map(|tx_num| tx_num + 1)
                             .unwrap_or_default();
                         writer.prune_transactions(to_delete, 0)?;
                     }
                     StaticFileSegment::Receipts => {
                         let to_delete = static_file_provider
-                            .get_highest_static_file_tx(static_file_segment)
+                            .get_highest_static_file_tx(segment)
                             .map(|tx_num| tx_num + 1)
                             .unwrap_or_default();
                         writer.prune_receipts(to_delete, 0)?;
                     }
                     StaticFileSegment::TransactionSenders => {
                         let to_delete = static_file_provider
-                            .get_highest_static_file_tx(static_file_segment)
+                            .get_highest_static_file_tx(segment)
                             .map(|tx_num| tx_num + 1)
                             .unwrap_or_default();
                         writer.prune_transaction_senders(to_delete, 0)?;
@@ -131,8 +133,15 @@ impl<C: ChainSpecParser> Command<C> {
                 reset_stage_checkpoint(tx, StageId::SenderRecovery)?;
             }
             StageEnum::Execution => {
-                tx.clear::<tables::PlainAccountState>()?;
-                tx.clear::<tables::PlainStorageState>()?;
+                if provider_rw.cached_storage_settings().use_hashed_state() {
+                    tx.clear::<tables::HashedAccounts>()?;
+                    tx.clear::<tables::HashedStorages>()?;
+                    reset_stage_checkpoint(tx, StageId::AccountHashing)?;
+                    reset_stage_checkpoint(tx, StageId::StorageHashing)?;
+                } else {
+                    tx.clear::<tables::PlainAccountState>()?;
+                    tx.clear::<tables::PlainStorageState>()?;
+                }
                 tx.clear::<tables::AccountChangeSets>()?;
                 tx.clear::<tables::StorageChangeSets>()?;
                 tx.clear::<tables::Bytecodes>()?;
@@ -178,7 +187,7 @@ impl<C: ChainSpecParser> Command<C> {
                 let settings = provider_rw.cached_storage_settings();
                 let rocksdb = tool.provider_factory.rocksdb_provider();
 
-                if settings.account_history_in_rocksdb {
+                if settings.storage_v2 {
                     rocksdb.clear::<tables::AccountsHistory>()?;
                 } else {
                     tx.clear::<tables::AccountsHistory>()?;
@@ -195,7 +204,7 @@ impl<C: ChainSpecParser> Command<C> {
                 let settings = provider_rw.cached_storage_settings();
                 let rocksdb = tool.provider_factory.rocksdb_provider();
 
-                if settings.storages_history_in_rocksdb {
+                if settings.storage_v2 {
                     rocksdb.clear::<tables::StoragesHistory>()?;
                 } else {
                     tx.clear::<tables::StoragesHistory>()?;
@@ -209,7 +218,7 @@ impl<C: ChainSpecParser> Command<C> {
                 )?;
             }
             StageEnum::TxLookup => {
-                if provider_rw.cached_storage_settings().transaction_hash_numbers_in_rocksdb {
+                if provider_rw.cached_storage_settings().storage_v2 {
                     tool.provider_factory
                         .rocksdb_provider()
                         .clear::<tables::TransactionHashNumbers>()?;

crates/e2e-test-utils/src/payload.rs

@@ -54,12 +54,20 @@ impl<T: PayloadTypes> PayloadTestContext<T> {
         Ok(())
     }
 
-    /// Wait until the best built payload is ready
+    /// Wait until the best built payload is ready.
+    ///
+    /// Panics if the payload builder does not produce a non-empty payload within 30 seconds.
     pub async fn wait_for_built_payload(&self, payload_id: PayloadId) {
+        let start = std::time::Instant::now();
         loop {
             let payload =
                 self.payload_builder.best_payload(payload_id).await.transpose().ok().flatten();
             if payload.is_none_or(|p| p.block().body().transactions().is_empty()) {
+                assert!(
+                    start.elapsed() < std::time::Duration::from_secs(30),
+                    "timed out waiting for a non-empty payload for {payload_id} — \
+                     check that the chain spec supports all generated tx types"
+                );
                 tokio::time::sleep(std::time::Duration::from_millis(20)).await;
                 continue
             }

crates/e2e-test-utils/src/testsuite/setup.rs

@@ -1,6 +1,6 @@
 //! Test setup utilities for configuring the initial state.
 
-use crate::{setup_engine_with_connection, testsuite::Environment, NodeBuilderHelper};
+use crate::{testsuite::Environment, E2ETestSetupBuilder, NodeBuilderHelper};
 use alloy_eips::BlockNumberOrTag;
 use alloy_primitives::B256;
 use alloy_rpc_types_engine::{ForkchoiceState, PayloadAttributes};
@@ -38,6 +38,8 @@ pub struct Setup<I> {
     shutdown_tx: Option<mpsc::Sender<()>>,
     /// Is this setup in dev mode
     pub is_dev: bool,
+    /// Whether to use v2 storage mode (hashed keys, static file changesets, rocksdb history)
+    pub storage_v2: bool,
     /// Tracks instance generic.
     _phantom: PhantomData<I>,
     /// Holds the import result to keep nodes alive when using imported chain
@@ -58,6 +60,7 @@ impl<I> Default for Setup<I> {
             tree_config: TreeConfig::default(),
             shutdown_tx: None,
             is_dev: true,
+            storage_v2: false,
             _phantom: Default::default(),
             import_result_holder: None,
             import_rlp_path: None,
@@ -126,6 +129,12 @@ where
         self
     }
 
+    /// Enable v2 storage mode (hashed keys, static file changesets, rocksdb history)
+    pub const fn with_storage_v2(mut self) -> Self {
+        self.storage_v2 = true;
+        self
+    }
+
     /// Apply setup using pre-imported chain data from RLP file
     pub async fn apply_with_import<N>(
         &mut self,
@@ -194,19 +203,28 @@ where
         self.shutdown_tx = Some(shutdown_tx);
 
         let is_dev = self.is_dev;
+        let storage_v2 = self.storage_v2;
         let node_count = self.network.node_count;
+        let tree_config = self.tree_config.clone();
 
         let attributes_generator = Self::create_static_attributes_generator::<N>();
 
-        let result = setup_engine_with_connection::<N>(
+        let mut builder = E2ETestSetupBuilder::<N, _>::new(
             node_count,
             Arc::<N::ChainSpec>::new((*chain_spec).clone().into()),
-            is_dev,
-            self.tree_config.clone(),
             attributes_generator,
-            self.network.connect_nodes,
         )
-        .await;
+        .with_tree_config_modifier(move |base| {
+            tree_config.clone().with_cross_block_cache_size(base.cross_block_cache_size())
+        })
+        .with_node_config_modifier(move |config| config.set_dev(is_dev))
+        .with_connect_nodes(self.network.connect_nodes);
+
+        if storage_v2 {
+            builder = builder.with_storage_v2();
+        }
+
+        let result = builder.build().await;
 
         let mut node_clients = Vec::new();
         match result {

crates/e2e-test-utils/tests/rocksdb/main.rs

@@ -10,7 +10,6 @@ use jsonrpsee::core::client::ClientT;
 use reth_chainspec::{ChainSpec, ChainSpecBuilder, MAINNET};
 use reth_db::tables;
 use reth_e2e_test_utils::{transaction::TransactionTestContext, wallet, E2ETestSetupBuilder};
-use reth_node_core::args::RocksDbArgs;
 use reth_node_ethereum::EthereumNode;
 use reth_payload_builder::EthPayloadBuilderAttributes;
 use reth_provider::RocksDBProviderFactory;
@@ -96,22 +95,6 @@ fn test_attributes_generator(timestamp: u64) -> EthPayloadBuilderAttributes {
     EthPayloadBuilderAttributes::new(B256::ZERO, attributes)
 }
 
-/// Verifies that `RocksDB` CLI defaults are `None` (deferred to storage mode).
-#[test]
-fn test_rocksdb_defaults_are_none() {
-    let args = RocksDbArgs::default();
-
-    assert!(args.tx_hash.is_none(), "tx_hash default should be None (deferred to --storage.v2)");
-    assert!(
-        args.storages_history.is_none(),
-        "storages_history default should be None (deferred to --storage.v2)"
-    );
-    assert!(
-        args.account_history.is_none(),
-        "account_history default should be None (deferred to --storage.v2)"
-    );
-}
-
 /// Smoke test: node boots with `RocksDB` routing enabled.
 #[tokio::test]
 async fn test_rocksdb_node_startup() -> Result<()> {
@@ -477,7 +460,7 @@ async fn test_rocksdb_pending_tx_not_in_storage() -> Result<()> {
 ///
 /// This test exercises `unwind_trie_state_from` which previously failed with
 /// `UnsortedInput` errors because it read changesets directly from MDBX tables
-/// instead of using storage-aware methods that check `storage_changesets_in_static_files`.
+/// instead of using storage-aware methods that check `is_v2()`.
 #[tokio::test]
 async fn test_rocksdb_reorg_unwind() -> Result<()> {
     reth_tracing::init_test_tracing();

crates/engine/primitives/src/config.rs

@@ -32,6 +32,13 @@ fn default_account_worker_count() -> usize {
 /// The size of proof targets chunk to spawn in one multiproof calculation.
 pub const DEFAULT_MULTIPROOF_TASK_CHUNK_SIZE: usize = 60;
 
+/// The size of proof targets chunk optimized for small blocks (≤20M gas used).
+/// Benchmarks: <https://gist.github.com/yongkangc/fda9c24846f0ba891376bcf81b002008>
+pub const SMALL_BLOCK_MULTIPROOF_CHUNK_SIZE: usize = 30;
+
+/// Gas threshold below which the small block chunk size is used.
+pub const SMALL_BLOCK_GAS_THRESHOLD: u64 = 20_000_000;
+
 /// The size of proof targets chunk to spawn in one multiproof calculation when V2 proofs are
 /// enabled. This is 4x the default chunk size to take advantage of more efficient V2 proof
 /// computation.
@@ -42,18 +49,6 @@ pub const DEFAULT_MULTIPROOF_TASK_CHUNK_SIZE_V2: usize = DEFAULT_MULTIPROOF_TASK
 /// This will be deducted from the thread count of main reth global threadpool.
 pub const DEFAULT_RESERVED_CPU_CORES: usize = 1;
 
-/// Returns the default maximum concurrency for prewarm task based on available parallelism.
-fn default_prewarm_max_concurrency() -> usize {
-    #[cfg(feature = "std")]
-    {
-        std::thread::available_parallelism().map_or(16, |n| n.get())
-    }
-    #[cfg(not(feature = "std"))]
-    {
-        16
-    }
-}
-
 /// Default depth for sparse trie pruning.
 ///
 /// Nodes at this depth and below are converted to hash stubs to reduce memory.
@@ -161,8 +156,6 @@ pub struct TreeConfig {
     /// where immediate payload regeneration is desired despite the head not changing or moving to
     /// an ancestor.
     always_process_payload_attributes_on_canonical_head: bool,
-    /// Maximum concurrency for the prewarm task.
-    prewarm_max_concurrency: usize,
     /// Whether to unwind canonical header to ancestor during forkchoice updates.
     allow_unwind_canonical_header: bool,
     /// Number of storage proof worker threads.
@@ -179,6 +172,8 @@ pub struct TreeConfig {
     sparse_trie_prune_depth: usize,
     /// Maximum number of storage tries to retain after pruning.
     sparse_trie_max_storage_tries: usize,
+    /// Whether to fully disable sparse trie cache pruning between blocks.
+    disable_sparse_trie_cache_pruning: bool,
     /// Timeout for the state root task before spawning a sequential fallback computation.
     /// If `Some`, after waiting this duration for the state root task, a sequential state root
     /// computation is spawned in parallel and whichever finishes first is used.
@@ -207,7 +202,6 @@ impl Default for TreeConfig {
             precompile_cache_disabled: false,
             state_root_fallback: false,
             always_process_payload_attributes_on_canonical_head: false,
-            prewarm_max_concurrency: default_prewarm_max_concurrency(),
             allow_unwind_canonical_header: false,
             storage_worker_count: default_storage_worker_count(),
             account_worker_count: default_account_worker_count(),
@@ -216,6 +210,7 @@ impl Default for TreeConfig {
             disable_trie_cache: false,
             sparse_trie_prune_depth: DEFAULT_SPARSE_TRIE_PRUNE_DEPTH,
             sparse_trie_max_storage_tries: DEFAULT_SPARSE_TRIE_MAX_STORAGE_TRIES,
+            disable_sparse_trie_cache_pruning: false,
             state_root_task_timeout: Some(DEFAULT_STATE_ROOT_TASK_TIMEOUT),
         }
     }
@@ -243,7 +238,6 @@ impl TreeConfig {
         precompile_cache_disabled: bool,
         state_root_fallback: bool,
         always_process_payload_attributes_on_canonical_head: bool,
-        prewarm_max_concurrency: usize,
         allow_unwind_canonical_header: bool,
         storage_worker_count: usize,
         account_worker_count: usize,
@@ -272,7 +266,6 @@ impl TreeConfig {
             precompile_cache_disabled,
             state_root_fallback,
             always_process_payload_attributes_on_canonical_head,
-            prewarm_max_concurrency,
             allow_unwind_canonical_header,
             storage_worker_count,
             account_worker_count,
@@ -281,6 +274,7 @@ impl TreeConfig {
             disable_trie_cache: false,
             sparse_trie_prune_depth,
             sparse_trie_max_storage_tries,
+            disable_sparse_trie_cache_pruning: false,
             state_root_task_timeout,
         }
     }
@@ -529,17 +523,6 @@ impl TreeConfig {
         self.has_enough_parallelism && !self.legacy_state_root
     }
 
-    /// Setter for prewarm max concurrency.
-    pub const fn with_prewarm_max_concurrency(mut self, prewarm_max_concurrency: usize) -> Self {
-        self.prewarm_max_concurrency = prewarm_max_concurrency;
-        self
-    }
-
-    /// Return the prewarm max concurrency.
-    pub const fn prewarm_max_concurrency(&self) -> usize {
-        self.prewarm_max_concurrency
-    }
-
     /// Return the number of storage proof worker threads.
     pub const fn storage_worker_count(&self) -> usize {
         self.storage_worker_count
@@ -631,6 +614,17 @@ impl TreeConfig {
         self
     }
 
+    /// Returns whether sparse trie cache pruning is disabled.
+    pub const fn disable_sparse_trie_cache_pruning(&self) -> bool {
+        self.disable_sparse_trie_cache_pruning
+    }
+
+    /// Setter for whether to disable sparse trie cache pruning.
+    pub const fn with_disable_sparse_trie_cache_pruning(mut self, value: bool) -> Self {
+        self.disable_sparse_trie_cache_pruning = value;
+        self
+    }
+
     /// Returns the state root task timeout.
     pub const fn state_root_task_timeout(&self) -> Option<Duration> {
         self.state_root_task_timeout

crates/engine/primitives/src/message.rs

@@ -15,6 +15,7 @@ use futures::{future::Either, FutureExt, TryFutureExt};
 use reth_errors::RethResult;
 use reth_payload_builder_primitives::PayloadBuilderError;
 use reth_payload_primitives::{EngineApiMessageVersion, PayloadTypes};
+use std::time::Duration;
 use tokio::sync::{mpsc::UnboundedSender, oneshot};
 
 /// Type alias for backwards compat
@@ -142,6 +143,20 @@ impl Future for PendingPayloadId {
     }
 }
 
+/// Timing breakdown for `reth_newPayload` responses.
+#[derive(Debug, Clone, Copy)]
+pub struct NewPayloadTimings {
+    /// Server-side execution latency.
+    pub latency: Duration,
+    /// Time spent waiting for persistence to complete.
+    /// `None` when no persistence was in-flight.
+    pub persistence_wait: Option<Duration>,
+    /// Time spent waiting for the execution cache lock.
+    pub execution_cache_wait: Duration,
+    /// Time spent waiting for the sparse trie lock.
+    pub sparse_trie_wait: Duration,
+}
+
 /// A message for the beacon engine from other components of the node (engine RPC API invoked by the
 /// consensus layer).
 #[derive(Debug)]
@@ -153,6 +168,16 @@ pub enum BeaconEngineMessage<Payload: PayloadTypes> {
         /// The sender for returning payload status result.
         tx: oneshot::Sender<Result<PayloadStatus, BeaconOnNewPayloadError>>,
     },
+    /// Message with new payload used by `reth_newPayload` endpoint.
+    ///
+    /// Waits for persistence, execution cache, and sparse trie locks before processing,
+    /// and returns detailed timing breakdown alongside the payload status.
+    RethNewPayload {
+        /// The execution payload received by Engine API.
+        payload: Payload::ExecutionData,
+        /// The sender for returning payload status result and timing breakdown.
+        tx: oneshot::Sender<Result<(PayloadStatus, NewPayloadTimings), BeaconOnNewPayloadError>>,
+    },
     /// Message with updated forkchoice state.
     ForkchoiceUpdated {
         /// The updated forkchoice state.
@@ -178,6 +203,15 @@ impl<Payload: PayloadTypes> Display for BeaconEngineMessage<Payload> {
                     payload.block_hash()
                 )
             }
+            Self::RethNewPayload { payload, .. } => {
+                write!(
+                    f,
+                    "RethNewPayload(parent: {}, number: {}, hash: {})",
+                    payload.parent_hash(),
+                    payload.block_number(),
+                    payload.block_hash()
+                )
+            }
             Self::ForkchoiceUpdated { state, payload_attrs, .. } => {
                 // we don't want to print the entire payload attributes, because for OP this
                 // includes all txs
@@ -223,6 +257,19 @@ where
         rx.await.map_err(|_| BeaconOnNewPayloadError::EngineUnavailable)?
     }
 
+    /// Sends a new payload message used by `reth_newPayload` endpoint.
+    ///
+    /// Waits for persistence, execution cache, and sparse trie locks before processing,
+    /// and returns detailed timing breakdown alongside the payload status.
+    pub async fn reth_new_payload(
+        &self,
+        payload: Payload::ExecutionData,
+    ) -> Result<(PayloadStatus, NewPayloadTimings), BeaconOnNewPayloadError> {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.to_engine.send(BeaconEngineMessage::RethNewPayload { payload, tx });
+        rx.await.map_err(|_| BeaconOnNewPayloadError::EngineUnavailable)?
+    }
+
     /// Sends a forkchoice update message to the beacon consensus engine and waits for a response.
     ///
     /// See also <https://github.com/ethereum/execution-apis/blob/3d627c95a4d3510a8187dd02e0250ecb4331d27e/src/engine/shanghai.md#engine_forkchoiceupdatedv2>

crates/engine/service/Cargo.toml

@@ -1,47 +0,0 @@
-[package]
-name = "reth-engine-service"
-version.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-homepage.workspace = true
-repository.workspace = true
-
-[lints]
-workspace = true
-
-[dependencies]
-# reth
-reth-consensus.workspace = true
-reth-engine-tree.workspace = true
-reth-evm.workspace = true
-reth-network-p2p.workspace = true
-reth-payload-builder.workspace = true
-reth-provider.workspace = true
-reth-prune.workspace = true
-reth-stages-api.workspace = true
-reth-tasks.workspace = true
-reth-node-types.workspace = true
-reth-chainspec.workspace = true
-reth-engine-primitives.workspace = true
-reth-trie-db.workspace = true
-
-# async
-futures.workspace = true
-pin-project.workspace = true
-
-# misc
-
-[dev-dependencies]
-reth-engine-tree = { workspace = true, features = ["test-utils"] }
-reth-ethereum-consensus.workspace = true
-reth-ethereum-engine-primitives.workspace = true
-reth-evm-ethereum.workspace = true
-reth-exex-types.workspace = true
-reth-primitives-traits.workspace = true
-reth-node-ethereum.workspace = true
-reth-trie-db.workspace = true
-
-alloy-eips.workspace = true
-tokio = { workspace = true, features = ["sync"] }
-tokio-stream.workspace = true

crates/engine/service/src/lib.rs

@@ -1,12 +0,0 @@
-//! Engine service implementation.
-
-#![doc(
-    html_logo_url = "https://raw.githubusercontent.com/paradigmxyz/reth/main/assets/reth-docs.png",
-    html_favicon_url = "https://avatars0.githubusercontent.com/u/97369466?s=256",
-    issue_tracker_base_url = "https://github.com/paradigmxyz/reth/issues/"
-)]
-#![cfg_attr(docsrs, feature(doc_cfg))]
-#![cfg_attr(not(test), warn(unused_crate_dependencies))]
-
-/// Engine Service
-pub mod service;

crates/engine/service/src/service.rs

@@ -1,227 +0,0 @@
-use futures::{Stream, StreamExt};
-use pin_project::pin_project;
-use reth_chainspec::EthChainSpec;
-use reth_consensus::FullConsensus;
-use reth_engine_primitives::{BeaconEngineMessage, ConsensusEngineEvent};
-use reth_engine_tree::{
-    backfill::PipelineSync,
-    download::BasicBlockDownloader,
-    engine::{EngineApiKind, EngineApiRequest, EngineApiRequestHandler, EngineHandler},
-    persistence::PersistenceHandle,
-    tree::{EngineApiTreeHandler, EngineValidator, TreeConfig},
-};
-pub use reth_engine_tree::{
-    chain::{ChainEvent, ChainOrchestrator},
-    engine::EngineApiEvent,
-};
-use reth_evm::ConfigureEvm;
-use reth_network_p2p::BlockClient;
-use reth_node_types::{BlockTy, NodeTypes};
-use reth_payload_builder::PayloadBuilderHandle;
-use reth_provider::{
-    providers::{BlockchainProvider, ProviderNodeTypes},
-    ProviderFactory,
-};
-use reth_prune::PrunerWithFactory;
-use reth_stages_api::{MetricEventsSender, Pipeline};
-use reth_tasks::TaskSpawner;
-use reth_trie_db::ChangesetCache;
-use std::{
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll},
-};
-
-/// Alias for consensus engine stream.
-pub type EngineMessageStream<T> = Pin<Box<dyn Stream<Item = BeaconEngineMessage<T>> + Send + Sync>>;
-
-/// Alias for chain orchestrator.
-type EngineServiceType<N, Client> = ChainOrchestrator<
-    EngineHandler<
-        EngineApiRequestHandler<
-            EngineApiRequest<<N as NodeTypes>::Payload, <N as NodeTypes>::Primitives>,
-            <N as NodeTypes>::Primitives,
-        >,
-        EngineMessageStream<<N as NodeTypes>::Payload>,
-        BasicBlockDownloader<Client, BlockTy<N>>,
-    >,
-    PipelineSync<N>,
->;
-
-/// The type that drives the chain forward and communicates progress.
-#[pin_project]
-#[expect(missing_debug_implementations)]
-// TODO(mattsse): remove hidden once fixed : <https://github.com/rust-lang/rust/issues/135363>
-//  otherwise rustdoc fails to resolve the alias
-#[doc(hidden)]
-pub struct EngineService<N, Client>
-where
-    N: ProviderNodeTypes,
-    Client: BlockClient<Block = BlockTy<N>> + 'static,
-{
-    orchestrator: EngineServiceType<N, Client>,
-}
-
-impl<N, Client> EngineService<N, Client>
-where
-    N: ProviderNodeTypes,
-    Client: BlockClient<Block = BlockTy<N>> + 'static,
-{
-    /// Constructor for `EngineService`.
-    #[expect(clippy::too_many_arguments)]
-    pub fn new<V, C>(
-        consensus: Arc<dyn FullConsensus<N::Primitives>>,
-        chain_spec: Arc<N::ChainSpec>,
-        client: Client,
-        incoming_requests: EngineMessageStream<N::Payload>,
-        pipeline: Pipeline<N>,
-        pipeline_task_spawner: Box<dyn TaskSpawner>,
-        provider: ProviderFactory<N>,
-        blockchain_db: BlockchainProvider<N>,
-        pruner: PrunerWithFactory<ProviderFactory<N>>,
-        payload_builder: PayloadBuilderHandle<N::Payload>,
-        payload_validator: V,
-        tree_config: TreeConfig,
-        sync_metrics_tx: MetricEventsSender,
-        evm_config: C,
-        changeset_cache: ChangesetCache,
-    ) -> Self
-    where
-        V: EngineValidator<N::Payload>,
-        C: ConfigureEvm<Primitives = N::Primitives> + 'static,
-    {
-        let engine_kind =
-            if chain_spec.is_optimism() { EngineApiKind::OpStack } else { EngineApiKind::Ethereum };
-
-        let downloader = BasicBlockDownloader::new(client, consensus.clone());
-
-        let persistence_handle =
-            PersistenceHandle::<N::Primitives>::spawn_service(provider, pruner, sync_metrics_tx);
-
-        let canonical_in_memory_state = blockchain_db.canonical_in_memory_state();
-
-        let (to_tree_tx, from_tree) = EngineApiTreeHandler::spawn_new(
-            blockchain_db,
-            consensus,
-            payload_validator,
-            persistence_handle,
-            payload_builder,
-            canonical_in_memory_state,
-            tree_config,
-            engine_kind,
-            evm_config,
-            changeset_cache,
-        );
-
-        let engine_handler = EngineApiRequestHandler::new(to_tree_tx, from_tree);
-        let handler = EngineHandler::new(engine_handler, downloader, incoming_requests);
-
-        let backfill_sync = PipelineSync::new(pipeline, pipeline_task_spawner);
-
-        Self { orchestrator: ChainOrchestrator::new(handler, backfill_sync) }
-    }
-
-    /// Returns a mutable reference to the orchestrator.
-    pub fn orchestrator_mut(&mut self) -> &mut EngineServiceType<N, Client> {
-        &mut self.orchestrator
-    }
-}
-
-impl<N, Client> Stream for EngineService<N, Client>
-where
-    N: ProviderNodeTypes,
-    Client: BlockClient<Block = BlockTy<N>> + 'static,
-{
-    type Item = ChainEvent<ConsensusEngineEvent<N::Primitives>>;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let mut orchestrator = self.project().orchestrator;
-        StreamExt::poll_next_unpin(&mut orchestrator, cx)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use reth_chainspec::{ChainSpecBuilder, MAINNET};
-    use reth_engine_primitives::{BeaconEngineMessage, NoopInvalidBlockHook};
-    use reth_engine_tree::{test_utils::TestPipelineBuilder, tree::BasicEngineValidator};
-    use reth_ethereum_consensus::EthBeaconConsensus;
-    use reth_ethereum_engine_primitives::EthEngineTypes;
-    use reth_evm_ethereum::EthEvmConfig;
-    use reth_exex_types::FinishedExExHeight;
-    use reth_network_p2p::test_utils::TestFullBlockClient;
-    use reth_node_ethereum::EthereumEngineValidator;
-    use reth_primitives_traits::SealedHeader;
-    use reth_provider::{
-        providers::BlockchainProvider, test_utils::create_test_provider_factory_with_chain_spec,
-    };
-    use reth_prune::Pruner;
-    use reth_tasks::TokioTaskExecutor;
-    use reth_trie_db::ChangesetCache;
-    use std::sync::Arc;
-    use tokio::sync::{mpsc::unbounded_channel, watch};
-    use tokio_stream::wrappers::UnboundedReceiverStream;
-
-    #[test]
-    fn eth_chain_orchestrator_build() {
-        let chain_spec = Arc::new(
-            ChainSpecBuilder::default()
-                .chain(MAINNET.chain)
-                .genesis(MAINNET.genesis.clone())
-                .paris_activated()
-                .build(),
-        );
-        let consensus = Arc::new(EthBeaconConsensus::new(chain_spec.clone()));
-
-        let client = TestFullBlockClient::default();
-
-        let (_tx, rx) = unbounded_channel::<BeaconEngineMessage<EthEngineTypes>>();
-        let incoming_requests = UnboundedReceiverStream::new(rx);
-
-        let pipeline = TestPipelineBuilder::new().build(chain_spec.clone());
-        let pipeline_task_spawner = Box::<TokioTaskExecutor>::default();
-        let provider_factory = create_test_provider_factory_with_chain_spec(chain_spec.clone());
-
-        let blockchain_db =
-            BlockchainProvider::with_latest(provider_factory.clone(), SealedHeader::default())
-                .unwrap();
-        let engine_payload_validator = EthereumEngineValidator::new(chain_spec.clone());
-        let (_tx, rx) = watch::channel(FinishedExExHeight::NoExExs);
-        let pruner = Pruner::new_with_factory(provider_factory.clone(), vec![], 0, 0, None, rx);
-        let evm_config = EthEvmConfig::new(chain_spec.clone());
-
-        let changeset_cache = ChangesetCache::new();
-
-        let engine_validator = BasicEngineValidator::new(
-            blockchain_db.clone(),
-            consensus.clone(),
-            evm_config.clone(),
-            engine_payload_validator,
-            TreeConfig::default(),
-            Box::new(NoopInvalidBlockHook::default()),
-            changeset_cache.clone(),
-            reth_tasks::Runtime::test(),
-        );
-
-        let (sync_metrics_tx, _sync_metrics_rx) = unbounded_channel();
-        let (tx, _rx) = unbounded_channel();
-        let _eth_service = EngineService::new(
-            consensus,
-            chain_spec,
-            client,
-            Box::pin(incoming_requests),
-            pipeline,
-            pipeline_task_spawner,
-            provider_factory,
-            blockchain_db,
-            pruner,
-            PayloadBuilderHandle::new(tx),
-            engine_validator,
-            TreeConfig::default(),
-            sync_metrics_tx,
-            evm_config,
-            changeset_cache,
-        );
-    }
-}

crates/engine/tree/Cargo.toml

@@ -29,7 +29,7 @@ reth-provider.workspace = true
 reth-prune.workspace = true
 reth-revm = { workspace = true, features = ["optional-balance-check"] }
 reth-stages-api.workspace = true
-reth-tasks.workspace = true
+reth-tasks = { workspace = true, features = ["rayon"] }
 reth-trie-parallel.workspace = true
 reth-trie-sparse = { workspace = true, features = ["std", "metrics"] }
 reth-trie.workspace = true
@@ -143,6 +143,13 @@ test-utils = [
     "reth-evm-ethereum/test-utils",
     "reth-tasks/test-utils",
 ]
+rocksdb = [
+    "reth-provider/rocksdb",
+    "reth-prune/rocksdb",
+    "reth-stages?/rocksdb",
+    "reth-e2e-test-utils/rocksdb",
+]
+edge = ["rocksdb"]
 
 [[test]]
 name = "e2e_testsuite"

crates/engine/tree/src/backfill.rs

@@ -10,7 +10,7 @@
 use futures::FutureExt;
 use reth_provider::providers::ProviderNodeTypes;
 use reth_stages_api::{ControlFlow, Pipeline, PipelineError, PipelineTarget, PipelineWithResult};
-use reth_tasks::TaskSpawner;
+use reth_tasks::Runtime;
 use std::task::{ready, Context, Poll};
 use tokio::sync::oneshot;
 use tracing::trace;
@@ -80,7 +80,7 @@ pub enum BackfillEvent {
 #[derive(Debug)]
 pub struct PipelineSync<N: ProviderNodeTypes> {
     /// The type that can spawn the pipeline task.
-    pipeline_task_spawner: Box<dyn TaskSpawner>,
+    pipeline_task_spawner: Runtime,
     /// The current state of the pipeline.
     /// The pipeline is used for large ranges.
     pipeline_state: PipelineState<N>,
@@ -90,7 +90,7 @@ pub struct PipelineSync<N: ProviderNodeTypes> {
 
 impl<N: ProviderNodeTypes> PipelineSync<N> {
     /// Create a new instance.
-    pub fn new(pipeline: Pipeline<N>, pipeline_task_spawner: Box<dyn TaskSpawner>) -> Self {
+    pub fn new(pipeline: Pipeline<N>, pipeline_task_spawner: Runtime) -> Self {
         Self {
             pipeline_task_spawner,
             pipeline_state: PipelineState::Idle(Some(Box::new(pipeline))),
@@ -140,10 +140,10 @@ impl<N: ProviderNodeTypes> PipelineSync<N> {
                 let pipeline = pipeline.take().expect("exists");
                 self.pipeline_task_spawner.spawn_critical_blocking_task(
                     "pipeline task",
-                    Box::pin(async move {
+                    async move {
                         let result = pipeline.run_as_fut(Some(target)).await;
                         let _ = tx.send(result);
-                    }),
+                    },
                 );
                 self.pipeline_state = PipelineState::Running(rx);
 
@@ -241,7 +241,7 @@ mod tests {
     use reth_provider::test_utils::MockNodeTypesWithDB;
     use reth_stages::ExecOutput;
     use reth_stages_api::StageCheckpoint;
-    use reth_tasks::TokioTaskExecutor;
+    use reth_tasks::Runtime;
     use std::{collections::VecDeque, future::poll_fn, sync::Arc};
 
     struct TestHarness {
@@ -267,7 +267,7 @@ mod tests {
                 })]))
                 .build(chain_spec);
 
-            let pipeline_sync = PipelineSync::new(pipeline, Box::<TokioTaskExecutor>::default());
+            let pipeline_sync = PipelineSync::new(pipeline, Runtime::test());
             let client = TestFullBlockClient::default();
             let header = Header {
                 base_fee_per_gas: Some(7),

crates/engine/tree/src/launch.rs

@@ -0,0 +1,110 @@
+//! Engine orchestrator launch helper.
+//!
+//! Provides [`build_engine_orchestrator`](crate::launch::build_engine_orchestrator) which wires
+//! together all engine components and returns a
+//! [`ChainOrchestrator`](crate::chain::ChainOrchestrator) ready to be polled as a `Stream`.
+
+use crate::{
+    backfill::PipelineSync,
+    chain::ChainOrchestrator,
+    download::BasicBlockDownloader,
+    engine::{EngineApiKind, EngineApiRequest, EngineApiRequestHandler, EngineHandler},
+    persistence::PersistenceHandle,
+    tree::{EngineApiTreeHandler, EngineValidator, TreeConfig, WaitForCaches},
+};
+use futures::Stream;
+use reth_consensus::FullConsensus;
+use reth_engine_primitives::BeaconEngineMessage;
+use reth_evm::ConfigureEvm;
+use reth_network_p2p::BlockClient;
+use reth_payload_builder::PayloadBuilderHandle;
+use reth_primitives_traits::NodePrimitives;
+use reth_provider::{
+    providers::{BlockchainProvider, ProviderNodeTypes},
+    ProviderFactory, StorageSettingsCache,
+};
+use reth_prune::PrunerWithFactory;
+use reth_stages_api::{MetricEventsSender, Pipeline};
+use reth_tasks::Runtime;
+use reth_trie_db::ChangesetCache;
+use std::sync::Arc;
+
+/// Builds the engine [`ChainOrchestrator`] that drives the chain forward.
+///
+/// This spawns and wires together the following components:
+///
+/// - **[`BasicBlockDownloader`]** — downloads blocks on demand from the network during live sync.
+/// - **[`PersistenceHandle`]** — spawns the persistence service on a background thread for writing
+///   blocks and performing pruning outside the critical consensus path.
+/// - **[`EngineApiTreeHandler`]** — spawns the tree handler that processes engine API requests
+///   (`newPayload`, `forkchoiceUpdated`) and maintains the in-memory chain state.
+/// - **[`EngineApiRequestHandler`]** + **[`EngineHandler`]** — glue that routes incoming CL
+///   messages to the tree handler and manages download requests.
+/// - **[`PipelineSync`]** — wraps the staged sync [`Pipeline`] for backfill sync when the node
+///   needs to catch up over large block ranges.
+///
+/// The returned orchestrator implements [`Stream`] and yields
+/// [`ChainEvent`]s.
+///
+/// [`ChainEvent`]: crate::chain::ChainEvent
+#[expect(clippy::too_many_arguments, clippy::type_complexity)]
+pub fn build_engine_orchestrator<N, Client, S, V, C>(
+    engine_kind: EngineApiKind,
+    consensus: Arc<dyn FullConsensus<N::Primitives>>,
+    client: Client,
+    incoming_requests: S,
+    pipeline: Pipeline<N>,
+    pipeline_task_spawner: Runtime,
+    provider: ProviderFactory<N>,
+    blockchain_db: BlockchainProvider<N>,
+    pruner: PrunerWithFactory<ProviderFactory<N>>,
+    payload_builder: PayloadBuilderHandle<N::Payload>,
+    payload_validator: V,
+    tree_config: TreeConfig,
+    sync_metrics_tx: MetricEventsSender,
+    evm_config: C,
+    changeset_cache: ChangesetCache,
+) -> ChainOrchestrator<
+    EngineHandler<
+        EngineApiRequestHandler<EngineApiRequest<N::Payload, N::Primitives>, N::Primitives>,
+        S,
+        BasicBlockDownloader<Client, <N::Primitives as NodePrimitives>::Block>,
+    >,
+    PipelineSync<N>,
+>
+where
+    N: ProviderNodeTypes,
+    Client: BlockClient<Block = <N::Primitives as NodePrimitives>::Block> + 'static,
+    S: Stream<Item = BeaconEngineMessage<N::Payload>> + Send + Sync + Unpin + 'static,
+    V: EngineValidator<N::Payload> + WaitForCaches,
+    C: ConfigureEvm<Primitives = N::Primitives> + 'static,
+{
+    let downloader = BasicBlockDownloader::new(client, consensus.clone());
+    let use_hashed_state = provider.cached_storage_settings().use_hashed_state();
+
+    let persistence_handle =
+        PersistenceHandle::<N::Primitives>::spawn_service(provider, pruner, sync_metrics_tx);
+
+    let canonical_in_memory_state = blockchain_db.canonical_in_memory_state();
+
+    let (to_tree_tx, from_tree) = EngineApiTreeHandler::spawn_new(
+        blockchain_db,
+        consensus,
+        payload_validator,
+        persistence_handle,
+        payload_builder,
+        canonical_in_memory_state,
+        tree_config,
+        engine_kind,
+        evm_config,
+        changeset_cache,
+        use_hashed_state,
+    );
+
+    let engine_handler = EngineApiRequestHandler::new(to_tree_tx, from_tree);
+    let handler = EngineHandler::new(engine_handler, downloader, incoming_requests);
+
+    let backfill_sync = PipelineSync::new(pipeline, pipeline_task_spawner);
+
+    ChainOrchestrator::new(handler, backfill_sync)
+}

crates/engine/tree/src/lib.rs

@@ -100,6 +100,8 @@ pub mod chain;
 pub mod download;
 /// Engine Api chain handler support.
 pub mod engine;
+/// Engine orchestrator launch helper.
+pub mod launch;
 /// Metrics support.
 pub mod metrics;
 /// The background writer service, coordinating write operations on static files and the database.

crates/engine/tree/src/persistence.rs

@@ -4,7 +4,7 @@ use crossbeam_channel::Sender as CrossbeamSender;
 use reth_chain_state::ExecutedBlock;
 use reth_errors::ProviderError;
 use reth_ethereum_primitives::EthPrimitives;
-use reth_primitives_traits::NodePrimitives;
+use reth_primitives_traits::{FastInstant as Instant, NodePrimitives};
 use reth_provider::{
     providers::ProviderNodeTypes, BlockExecutionWriter, BlockHashReader, ChainStateBlockWriter,
     DBProvider, DatabaseProviderFactory, ProviderFactory, SaveBlocksMode,
@@ -18,7 +18,6 @@ use std::{
         Arc,
     },
     thread::JoinHandle,
-    time::Instant,
 };
 use thiserror::Error;
 use tracing::{debug, error, instrument};
@@ -119,7 +118,7 @@ where
         Ok(())
     }
 
-    #[instrument(level = "debug", target = "engine::persistence", skip_all, fields(new_tip_num))]
+    #[instrument(level = "debug", target = "engine::persistence", skip_all, fields(%new_tip_num))]
     fn on_remove_blocks_above(
         &self,
         new_tip_num: u64,

crates/engine/tree/src/tree/cached_state.rs

@@ -351,6 +351,14 @@ impl<S: StateProvider, const PREWARM: bool> StateProvider for CachedStateProvide
             self.state_provider.storage(account, storage_key)
         }
     }
+
+    fn storage_by_hashed_key(
+        &self,
+        address: Address,
+        hashed_storage_key: StorageKey,
+    ) -> ProviderResult<Option<StorageValue>> {
+        self.state_provider.storage_by_hashed_key(address, hashed_storage_key)
+    }
 }
 
 impl<S: BytecodeReader, const PREWARM: bool> BytecodeReader for CachedStateProvider<S, PREWARM> {

crates/engine/tree/src/tree/instrumented_state.rs

@@ -3,7 +3,7 @@ use alloy_primitives::{Address, StorageKey, StorageValue, B256};
 use metrics::{Gauge, Histogram};
 use reth_errors::ProviderResult;
 use reth_metrics::Metrics;
-use reth_primitives_traits::{Account, Bytecode};
+use reth_primitives_traits::{Account, Bytecode, FastInstant as Instant};
 use reth_provider::{
     AccountReader, BlockHashReader, BytecodeReader, HashedPostStateProvider, StateProofProvider,
     StateProvider, StateRootProvider, StorageRootProvider,
@@ -14,7 +14,7 @@ use reth_trie::{
 };
 use std::{
     sync::atomic::{AtomicU64, Ordering},
-    time::{Duration, Instant},
+    time::Duration,
 };
 
 /// Nanoseconds per second
@@ -199,6 +199,17 @@ impl<S: StateProvider> StateProvider for InstrumentedStateProvider<S> {
         self.record_storage_fetch(start.elapsed());
         res
     }
+
+    fn storage_by_hashed_key(
+        &self,
+        address: Address,
+        hashed_storage_key: StorageKey,
+    ) -> ProviderResult<Option<StorageValue>> {
+        let start = Instant::now();
+        let res = self.state_provider.storage_by_hashed_key(address, hashed_storage_key);
+        self.record_storage_fetch(start.elapsed());
+        res
+    }
 }
 
 impl<S: BytecodeReader> BytecodeReader for InstrumentedStateProvider<S> {

crates/engine/tree/src/tree/metrics.rs

@@ -8,16 +8,17 @@ use reth_metrics::{
     metrics::{Counter, Gauge, Histogram},
     Metrics,
 };
-use reth_primitives_traits::constants::gas_units::MEGAGAS;
+use reth_primitives_traits::{constants::gas_units::MEGAGAS, FastInstant as Instant};
 use reth_trie::updates::TrieUpdates;
-use std::time::{Duration, Instant};
+use std::time::Duration;
 
-/// Width of each gas bucket in gas units (10 Mgas).
-const GAS_BUCKET_SIZE: u64 = 10 * MEGAGAS;
+/// Upper bounds for each gas bucket. The last bucket is a catch-all for
+/// everything above the final threshold: <5M, 5-10M, 10-20M, 20-30M, 30-40M, >40M.
+const GAS_BUCKET_THRESHOLDS: [u64; 5] =
+    [5 * MEGAGAS, 10 * MEGAGAS, 20 * MEGAGAS, 30 * MEGAGAS, 40 * MEGAGAS];
 
-/// Number of gas buckets. The last bucket is a catch-all for everything above
-/// `(NUM_GAS_BUCKETS - 1) * GAS_BUCKET_SIZE`.
-const NUM_GAS_BUCKETS: usize = 5;
+/// Total number of gas buckets (thresholds + 1 catch-all).
+const NUM_GAS_BUCKETS: usize = GAS_BUCKET_THRESHOLDS.len() + 1;
 
 /// Metrics for the `EngineApi`.
 #[derive(Debug, Default)]
@@ -33,6 +34,10 @@ pub struct EngineApiMetrics {
     /// Metrics for EIP-7928 Block-Level Access Lists (BAL).
     #[allow(dead_code)]
     pub(crate) bal: BalMetrics,
+    /// Gas-bucketed execution sub-phase metrics.
+    pub(crate) execution_gas_buckets: ExecutionGasBucketMetrics,
+    /// Gas-bucketed block validation sub-phase metrics.
+    pub(crate) block_validation_gas_buckets: BlockValidationGasBucketMetrics,
 }
 
 impl EngineApiMetrics {
@@ -81,6 +86,22 @@ impl EngineApiMetrics {
         self.executor.post_execution_histogram.record(elapsed);
     }
 
+    /// Records execution duration into the gas-bucketed execution histogram.
+    pub fn record_block_execution_gas_bucket(&self, gas_used: u64, elapsed: Duration) {
+        let idx = GasBucketMetrics::bucket_index(gas_used);
+        self.execution_gas_buckets.buckets[idx]
+            .execution_gas_bucket_histogram
+            .record(elapsed.as_secs_f64());
+    }
+
+    /// Records state root duration into the gas-bucketed block validation histogram.
+    pub fn record_state_root_gas_bucket(&self, gas_used: u64, elapsed_secs: f64) {
+        let idx = GasBucketMetrics::bucket_index(gas_used);
+        self.block_validation_gas_buckets.buckets[idx]
+            .state_root_gas_bucket_histogram
+            .record(elapsed_secs);
+    }
+
     /// Records the time spent waiting for the next transaction from the iterator.
     pub fn record_transaction_wait(&self, elapsed: Duration) {
         self.executor.transaction_wait_histogram.record(elapsed);
@@ -279,27 +300,80 @@ impl GasBucketMetrics {
             .record(gas_used as f64 / elapsed.as_secs_f64());
     }
 
-    fn bucket_index(gas_used: u64) -> usize {
-        let idx = gas_used / GAS_BUCKET_SIZE;
-        (idx as usize).min(NUM_GAS_BUCKETS - 1)
+    /// Returns the bucket index for a given gas value.
+    pub(crate) fn bucket_index(gas_used: u64) -> usize {
+        GAS_BUCKET_THRESHOLDS
+            .iter()
+            .position(|&threshold| gas_used < threshold)
+            .unwrap_or(GAS_BUCKET_THRESHOLDS.len())
     }
 
-    /// Returns a human-readable label like `<10M`, `10-20M`, … `>40M`.
-    fn bucket_label(index: usize) -> String {
-        let m = GAS_BUCKET_SIZE / 1_000_000;
+    /// Returns a human-readable label like `<5M`, `5-10M`, … `>40M`.
+    pub(crate) fn bucket_label(index: usize) -> String {
         if index == 0 {
-            format!("<{m}M")
-        } else if index < NUM_GAS_BUCKETS - 1 {
-            let lo = m * index as u64;
-            let hi = lo + m;
+            let hi = GAS_BUCKET_THRESHOLDS[0] / MEGAGAS;
+            format!("<{hi}M")
+        } else if index < GAS_BUCKET_THRESHOLDS.len() {
+            let lo = GAS_BUCKET_THRESHOLDS[index - 1] / MEGAGAS;
+            let hi = GAS_BUCKET_THRESHOLDS[index] / MEGAGAS;
             format!("{lo}-{hi}M")
         } else {
-            let lo = m * index as u64;
+            let lo = GAS_BUCKET_THRESHOLDS[GAS_BUCKET_THRESHOLDS.len() - 1] / MEGAGAS;
             format!(">{lo}M")
         }
     }
 }
 
+/// Per-gas-bucket execution duration metric.
+#[derive(Clone, Metrics)]
+#[metrics(scope = "sync.execution")]
+pub(crate) struct ExecutionGasBucketSeries {
+    /// Gas-bucketed EVM execution duration.
+    pub(crate) execution_gas_bucket_histogram: Histogram,
+}
+
+/// Holds pre-initialized [`ExecutionGasBucketSeries`] instances, one per gas bucket.
+#[derive(Debug)]
+pub(crate) struct ExecutionGasBucketMetrics {
+    buckets: [ExecutionGasBucketSeries; NUM_GAS_BUCKETS],
+}
+
+impl Default for ExecutionGasBucketMetrics {
+    fn default() -> Self {
+        Self {
+            buckets: std::array::from_fn(|i| {
+                let label = GasBucketMetrics::bucket_label(i);
+                ExecutionGasBucketSeries::new_with_labels(&[("gas_bucket", label)])
+            }),
+        }
+    }
+}
+
+/// Per-gas-bucket block validation metrics (state root).
+#[derive(Clone, Metrics)]
+#[metrics(scope = "sync.block_validation")]
+pub(crate) struct BlockValidationGasBucketSeries {
+    /// Gas-bucketed state root computation duration.
+    pub(crate) state_root_gas_bucket_histogram: Histogram,
+}
+
+/// Holds pre-initialized [`BlockValidationGasBucketSeries`] instances, one per gas bucket.
+#[derive(Debug)]
+pub(crate) struct BlockValidationGasBucketMetrics {
+    buckets: [BlockValidationGasBucketSeries; NUM_GAS_BUCKETS],
+}
+
+impl Default for BlockValidationGasBucketMetrics {
+    fn default() -> Self {
+        Self {
+            buckets: std::array::from_fn(|i| {
+                let label = GasBucketMetrics::bucket_label(i);
+                BlockValidationGasBucketSeries::new_with_labels(&[("gas_bucket", label)])
+            }),
+        }
+    }
+}
+
 /// Metrics for engine newPayload responses.
 #[derive(Metrics)]
 #[metrics(scope = "consensus.engine.beacon")]

crates/engine/tree/src/tree/mod.rs

@@ -19,7 +19,7 @@ use reth_chain_state::{
 use reth_consensus::{Consensus, FullConsensus};
 use reth_engine_primitives::{
     BeaconEngineMessage, BeaconOnNewPayloadError, ConsensusEngineEvent, ExecutionPayload,
-    ForkchoiceStateTracker, OnForkChoiceUpdated,
+    ForkchoiceStateTracker, NewPayloadTimings, OnForkChoiceUpdated,
 };
 use reth_errors::{ConsensusError, ProviderResult};
 use reth_evm::ConfigureEvm;
@@ -27,12 +27,14 @@ use reth_payload_builder::PayloadBuilderHandle;
 use reth_payload_primitives::{
     BuiltPayload, EngineApiMessageVersion, NewPayloadError, PayloadBuilderAttributes, PayloadTypes,
 };
-use reth_primitives_traits::{NodePrimitives, RecoveredBlock, SealedBlock, SealedHeader};
+use reth_primitives_traits::{
+    FastInstant as Instant, NodePrimitives, RecoveredBlock, SealedBlock, SealedHeader,
+};
 use reth_provider::{
     BlockExecutionOutput, BlockExecutionResult, BlockReader, ChangeSetReader,
     DatabaseProviderFactory, HashedPostStateProvider, ProviderError, StageCheckpointReader,
     StateProviderBox, StateProviderFactory, StateReader, StorageChangeSetReader,
-    TransactionVariant,
+    StorageSettingsCache, TransactionVariant,
 };
 use reth_revm::database::StateProviderDatabase;
 use reth_stages_api::ControlFlow;
@@ -40,7 +42,7 @@ use reth_tasks::spawn_os_thread;
 use reth_trie_db::ChangesetCache;
 use revm::interpreter::debug_unreachable;
 use state::TreeState;
-use std::{fmt::Debug, ops, sync::Arc, time::Instant};
+use std::{fmt::Debug, ops, sync::Arc, time::Duration};
 
 use crossbeam_channel::{Receiver, Sender};
 use tokio::sync::{
@@ -271,6 +273,9 @@ where
     evm_config: C,
     /// Changeset cache for in-memory trie changesets
     changeset_cache: ChangesetCache,
+    /// Whether the node uses hashed state as canonical storage (v2 mode).
+    /// Cached at construction to avoid threading `StorageSettingsCache` bounds everywhere.
+    use_hashed_state: bool,
 }
 
 impl<N, P: Debug, T: PayloadTypes + Debug, V: Debug, C> std::fmt::Debug
@@ -296,6 +301,7 @@ where
             .field("engine_kind", &self.engine_kind)
             .field("evm_config", &self.evm_config)
             .field("changeset_cache", &self.changeset_cache)
+            .field("use_hashed_state", &self.use_hashed_state)
             .finish()
     }
 }
@@ -313,10 +319,11 @@ where
     P::Provider: BlockReader<Block = N::Block, Header = N::BlockHeader>
         + StageCheckpointReader
         + ChangeSetReader
-        + StorageChangeSetReader,
+        + StorageChangeSetReader
+        + StorageSettingsCache,
     C: ConfigureEvm<Primitives = N> + 'static,
     T: PayloadTypes<BuiltPayload: BuiltPayload<Primitives = N>>,
-    V: EngineValidator<T>,
+    V: EngineValidator<T> + WaitForCaches,
 {
     /// Creates a new [`EngineApiTreeHandler`].
     #[expect(clippy::too_many_arguments)]
@@ -334,6 +341,7 @@ where
         engine_kind: EngineApiKind,
         evm_config: C,
         changeset_cache: ChangesetCache,
+        use_hashed_state: bool,
     ) -> Self {
         let (incoming_tx, incoming) = crossbeam_channel::unbounded();
 
@@ -355,6 +363,7 @@ where
             engine_kind,
             evm_config,
             changeset_cache,
+            use_hashed_state,
         }
     }
 
@@ -375,6 +384,7 @@ where
         kind: EngineApiKind,
         evm_config: C,
         changeset_cache: ChangesetCache,
+        use_hashed_state: bool,
     ) -> (Sender<FromEngine<EngineApiRequest<T, N>, N::Block>>, UnboundedReceiver<EngineApiEvent<N>>)
     {
         let best_block_number = provider.best_block_number().unwrap_or(0);
@@ -407,6 +417,7 @@ where
             kind,
             evm_config,
             changeset_cache,
+            use_hashed_state,
         );
         let incoming = task.incoming_tx.clone();
         spawn_os_thread("engine", || task.run());
@@ -1544,6 +1555,94 @@ where
                                 // handle the event if any
                                 self.on_maybe_tree_event(maybe_event)?;
                             }
+                            BeaconEngineMessage::RethNewPayload { payload, tx } => {
+                                // Before processing the new payload, we wait for persistence and
+                                // cache updates to complete. We do it in parallel, spawning
+                                // persistence and cache update wait tasks with Tokio, so that we
+                                // can get an unbiased breakdown on how long did every step take.
+                                //
+                                // If we first wait for persistence, and only then for cache
+                                // updates, we will offset the cache update waits by the duration of
+                                // persistence, which is incorrect.
+                                debug!(target: "engine::tree", "Waiting for persistence and caches in parallel before processing reth_newPayload");
+
+                                let pending_persistence = self.persistence_state.rx.take();
+                                let persistence_rx = if let Some((rx, start_time, _action)) =
+                                    pending_persistence
+                                {
+                                    let (persistence_tx, persistence_rx) =
+                                        std::sync::mpsc::channel();
+                                    tokio::task::spawn_blocking(move || {
+                                        let start = Instant::now();
+                                        let result =
+                                            rx.recv().expect("persistence state channel closed");
+                                        let _ = persistence_tx.send((
+                                            result,
+                                            start_time,
+                                            start.elapsed(),
+                                        ));
+                                    });
+                                    Some(persistence_rx)
+                                } else {
+                                    None
+                                };
+
+                                let cache_wait = self.payload_validator.wait_for_caches();
+
+                                let persistence_wait = if let Some(persistence_rx) = persistence_rx
+                                {
+                                    let (result, start_time, wait_duration) = persistence_rx
+                                        .recv()
+                                        .expect("persistence result channel closed");
+                                    let _ = self.on_persistence_complete(result, start_time);
+                                    Some(wait_duration)
+                                } else {
+                                    None
+                                };
+
+                                debug!(
+                                    target: "engine::tree",
+                                    ?persistence_wait,
+                                    execution_cache_wait = ?cache_wait.execution_cache,
+                                    sparse_trie_wait = ?cache_wait.sparse_trie,
+                                    "Persistence finished and caches updated for reth_newPayload"
+                                );
+
+                                let start = Instant::now();
+                                let gas_used = payload.gas_used();
+                                let num_hash = payload.num_hash();
+                                let mut output = self.on_new_payload(payload);
+                                let latency = start.elapsed();
+                                self.metrics.engine.new_payload.update_response_metrics(
+                                    start,
+                                    &mut self.metrics.engine.forkchoice_updated.latest_finish_at,
+                                    &output,
+                                    gas_used,
+                                );
+
+                                let maybe_event =
+                                    output.as_mut().ok().and_then(|out| out.event.take());
+
+                                let timings = NewPayloadTimings {
+                                    latency,
+                                    persistence_wait,
+                                    execution_cache_wait: cache_wait.execution_cache,
+                                    sparse_trie_wait: cache_wait.sparse_trie,
+                                };
+                                if let Err(err) =
+                                    tx.send(output.map(|o| (o.outcome, timings)).map_err(|e| {
+                                        BeaconOnNewPayloadError::Internal(Box::new(e))
+                                    }))
+                                {
+                                    error!(target: "engine::tree", payload=?num_hash, elapsed=?start.elapsed(), "Failed to send event: {err:?}");
+                                    self.metrics
+                                        .engine
+                                        .failed_new_payload_response_deliveries
+                                        .increment(1);
+                                }
+
+                                self.on_maybe_tree_event(maybe_event)?;
+                            }
                         }
                     }
                 }
@@ -2379,7 +2478,12 @@ where
 
             self.update_reorg_metrics(old.len(), old_first);
             self.reinsert_reorged_blocks(new.clone());
-            self.reinsert_reorged_blocks(old.clone());
+
+            // When use_hashed_state is enabled, skip reinserting the old chain — the
+            // bundle state references plain state reverts which don't exist.
+            if !self.use_hashed_state {
+                self.reinsert_reorged_blocks(old.clone());
+            }
         }
 
         // update the tracked in-memory state with the new chain
@@ -2588,7 +2692,7 @@ where
     /// Returns `InsertPayloadOk::Inserted(BlockStatus::Valid)` on successful execution,
     /// `InsertPayloadOk::AlreadySeen` if the block already exists, or
     /// `InsertPayloadOk::Inserted(BlockStatus::Disconnected)` if parent state is missing.
-    #[instrument(level = "debug", target = "engine::tree", skip_all, fields(block_id))]
+    #[instrument(level = "debug", target = "engine::tree", skip_all, fields(?block_id))]
     fn insert_block_or_payload<Input, Err>(
         &mut self,
         block_id: BlockWithParent,
@@ -3032,3 +3136,23 @@ enum PersistTarget {
     /// Persist all blocks up to and including the canonical head.
     Head,
 }
+
+/// Result of waiting for caches to become available.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct CacheWaitDurations {
+    /// Time spent waiting for the execution cache lock.
+    pub execution_cache: Duration,
+    /// Time spent waiting for the sparse trie lock.
+    pub sparse_trie: Duration,
+}
+
+/// Trait for types that can wait for caches to become available.
+///
+/// This is used by `reth_newPayload` endpoint to ensure that payload processing
+/// waits for any ongoing operations to complete before starting.
+pub trait WaitForCaches {
+    /// Waits for cache updates to complete.
+    ///
+    /// Returns the time spent waiting for each cache separately.
+    fn wait_for_caches(&self) -> CacheWaitDurations;
+}

crates/engine/tree/src/tree/payload_processor/mod.rs

@@ -8,7 +8,7 @@ use crate::tree::{
         sparse_trie::StateRootComputeOutcome,
     },
     sparse_trie::{SparseTrieCacheTask, SparseTrieTask, SpawnedSparseTrieTask},
-    StateProviderBuilder, TreeConfig,
+    CacheWaitDurations, StateProviderBuilder, TreeConfig, WaitForCaches,
 };
 use alloy_eip7928::BlockAccessList;
 use alloy_eips::{eip1898::BlockWithParent, eip4895::Withdrawal};
@@ -20,6 +20,7 @@ use multiproof::{SparseTrieUpdate, *};
 use parking_lot::RwLock;
 use prewarm::PrewarmMetrics;
 use rayon::prelude::*;
+use reth_engine_primitives::{SMALL_BLOCK_GAS_THRESHOLD, SMALL_BLOCK_MULTIPROOF_CHUNK_SIZE};
 use reth_evm::{
     block::ExecutableTxParts,
     execute::{ExecutableTxFor, WithTxEnv},
@@ -27,13 +28,13 @@ use reth_evm::{
     SpecFor, TxEnvFor,
 };
 use reth_metrics::Metrics;
-use reth_primitives_traits::NodePrimitives;
+use reth_primitives_traits::{FastInstant as Instant, NodePrimitives};
 use reth_provider::{
     BlockExecutionOutput, BlockReader, DatabaseProviderROFactory, StateProvider,
     StateProviderFactory, StateReader,
 };
 use reth_revm::{db::BundleState, state::EvmState};
-use reth_tasks::Runtime;
+use reth_tasks::{ForEachOrdered, Runtime};
 use reth_trie::{hashed_cursor::HashedCursorFactory, trie_cursor::TrieCursorFactory};
 use reth_trie_parallel::{
     proof_task::{ProofTaskCtx, ProofWorkerHandle},
@@ -43,14 +44,13 @@ use reth_trie_sparse::{
     ParallelSparseTrie, ParallelismThresholds, RevealableSparseTrie, SparseStateTrie,
 };
 use std::{
-    collections::BTreeMap,
     ops::Not,
     sync::{
         atomic::AtomicBool,
         mpsc::{self, channel},
         Arc,
     },
-    time::Instant,
+    time::Duration,
 };
 use tracing::{debug, debug_span, instrument, warn, Span};
 
@@ -94,6 +94,10 @@ pub const SPARSE_TRIE_MAX_NODES_SHRINK_CAPACITY: usize = 1_000_000;
 /// 144MB.
 pub const SPARSE_TRIE_MAX_VALUES_SHRINK_CAPACITY: usize = 1_000_000;
 
+/// Blocks with fewer transactions than this skip prewarming, since the fixed overhead of spawning
+/// prewarm workers exceeds the execution time saved.
+pub const SMALL_BLOCK_TX_THRESHOLD: usize = 5;
+
 /// Type alias for [`PayloadHandle`] returned by payload processor spawn methods.
 type IteratorPayloadHandle<Evm, I, N> = PayloadHandle<
     WithTxEnv<TxEnvFor<Evm>, <I as ExecutableTxIterator<Evm>>::Recovered>,
@@ -129,12 +133,12 @@ where
     /// re-use allocated memory. Stored with the block hash it was computed for to enable trie
     /// preservation across sequential payload validations.
     sparse_state_trie: SharedPreservedSparseTrie,
-    /// Maximum concurrency for prewarm task.
-    prewarm_max_concurrency: usize,
     /// Sparse trie prune depth.
     sparse_trie_prune_depth: usize,
     /// Maximum storage tries to retain after pruning.
     sparse_trie_max_storage_tries: usize,
+    /// Whether sparse trie cache pruning is fully disabled.
+    disable_sparse_trie_cache_pruning: bool,
     /// Whether to disable cache metrics recording.
     disable_cache_metrics: bool,
 }
@@ -167,14 +171,54 @@ where
             precompile_cache_disabled: config.precompile_cache_disabled(),
             precompile_cache_map,
             sparse_state_trie: SharedPreservedSparseTrie::default(),
-            prewarm_max_concurrency: config.prewarm_max_concurrency(),
             sparse_trie_prune_depth: config.sparse_trie_prune_depth(),
             sparse_trie_max_storage_tries: config.sparse_trie_max_storage_tries(),
+            disable_sparse_trie_cache_pruning: config.disable_sparse_trie_cache_pruning(),
             disable_cache_metrics: config.disable_cache_metrics(),
         }
     }
 }
 
+impl<Evm> WaitForCaches for PayloadProcessor<Evm>
+where
+    Evm: ConfigureEvm,
+{
+    fn wait_for_caches(&self) -> CacheWaitDurations {
+        debug!(target: "engine::tree::payload_processor", "Waiting for execution cache and sparse trie locks");
+
+        // Wait for both caches in parallel using std threads
+        let execution_cache = self.execution_cache.clone();
+        let sparse_trie = self.sparse_state_trie.clone();
+
+        // Use channels and spawn_blocking instead of std::thread::spawn
+        let (execution_tx, execution_rx) = std::sync::mpsc::channel();
+        let (sparse_trie_tx, sparse_trie_rx) = std::sync::mpsc::channel();
+
+        self.executor.spawn_blocking(move || {
+            let _ = execution_tx.send(execution_cache.wait_for_availability());
+        });
+        self.executor.spawn_blocking(move || {
+            let _ = sparse_trie_tx.send(sparse_trie.wait_for_availability());
+        });
+
+        let execution_cache_duration =
+            execution_rx.recv().expect("execution cache wait task failed to send result");
+        let sparse_trie_duration =
+            sparse_trie_rx.recv().expect("sparse trie wait task failed to send result");
+
+        debug!(
+            target: "engine::tree::payload_processor",
+            ?execution_cache_duration,
+            ?sparse_trie_duration,
+            "Execution cache and sparse trie locks acquired"
+        );
+        CacheWaitDurations {
+            execution_cache: execution_cache_duration,
+            sparse_trie: sparse_trie_duration,
+        }
+    }
+}
+
 impl<N, Evm> PayloadProcessor<Evm>
 where
     N: NodePrimitives,
@@ -242,48 +286,30 @@ where
         let (to_sparse_trie, sparse_trie_rx) = channel();
         let (to_multi_proof, from_multi_proof) = crossbeam_channel::unbounded();
 
-        // Extract V2 proofs flag early so we can pass it to prewarm
         let v2_proofs_enabled = !config.disable_proof_v2();
-
-        // Capture parent_state_root before env is moved into spawn_caching_with
         let parent_state_root = env.parent_state_root;
+        let transaction_count = env.transaction_count;
+        let chunk_size = Self::adaptive_chunk_size(config, env.gas_used);
+        let prewarm_handle = self.spawn_caching_with(
+            env,
+            prewarm_rx,
+            provider_builder.clone(),
+            Some(to_multi_proof.clone()),
+            bal,
+            v2_proofs_enabled,
+        );
 
-        // Handle BAL-based optimization if available
-        let prewarm_handle = if let Some(bal) = bal {
-            // When BAL is present, use BAL prewarming and send BAL to multiproof
-            debug!(target: "engine::tree::payload_processor", "BAL present, using BAL prewarming");
-
-            // The prewarm task converts the BAL to HashedPostState and sends it on
-            // to_multi_proof after slot prefetching completes.
-            self.spawn_caching_with(
-                env,
-                prewarm_rx,
-                provider_builder.clone(),
-                Some(to_multi_proof.clone()),
-                Some(bal),
-                v2_proofs_enabled,
-            )
-        } else {
-            // Normal path: spawn with transaction prewarming
-            self.spawn_caching_with(
-                env,
-                prewarm_rx,
-                provider_builder.clone(),
-                Some(to_multi_proof.clone()),
-                None,
-                v2_proofs_enabled,
-            )
-        };
-
-        // Create and spawn the storage proof task
+        // Create and spawn the storage proof task.
         let task_ctx = ProofTaskCtx::new(multiproof_provider_factory);
-        let proof_handle = ProofWorkerHandle::new(&self.executor, task_ctx, v2_proofs_enabled);
+        let halve_workers = transaction_count <= Self::SMALL_BLOCK_PROOF_WORKER_TX_THRESHOLD;
+        let proof_handle =
+            ProofWorkerHandle::new(&self.executor, task_ctx, halve_workers, v2_proofs_enabled);
 
         if config.disable_trie_cache() {
             let multi_proof_task = MultiProofTask::new(
                 proof_handle.clone(),
                 to_sparse_trie,
-                config.multiproof_chunking_enabled().then_some(config.multiproof_chunk_size()),
+                chunk_size,
                 to_multi_proof.clone(),
                 from_multi_proof.clone(),
             )
@@ -318,6 +344,7 @@ where
             from_multi_proof,
             config,
             parent_state_root,
+            chunk_size,
         );
 
         PayloadHandle {
@@ -357,6 +384,10 @@ where
         }
     }
 
+    /// Transaction count threshold below which proof workers are halved, since fewer transactions
+    /// produce fewer state changes and most workers would be idle overhead.
+    const SMALL_BLOCK_PROOF_WORKER_TX_THRESHOLD: usize = 30;
+
     /// Transaction count threshold below which sequential signature recovery is used.
     ///
     /// For blocks with fewer than this many transactions, the rayon parallel iterator overhead
@@ -365,22 +396,42 @@ where
     /// for small blocks.
     const SMALL_BLOCK_TX_THRESHOLD: usize = 30;
 
+    /// Returns the multiproof chunk size adapted to the block's gas usage.
+    ///
+    /// For blocks with ≤20M gas used, a smaller chunk size (30) yields better throughput.
+    /// For larger blocks, the configured default chunk size is used.
+    const fn adaptive_chunk_size(config: &TreeConfig, gas_used: u64) -> Option<usize> {
+        if !config.multiproof_chunking_enabled() {
+            return None;
+        }
+
+        let size = if gas_used > 0 && gas_used <= SMALL_BLOCK_GAS_THRESHOLD {
+            SMALL_BLOCK_MULTIPROOF_CHUNK_SIZE
+        } else {
+            config.multiproof_chunk_size()
+        };
+
+        Some(size)
+    }
+
     /// Spawns a task advancing transaction env iterator and streaming updates through a channel.
     ///
     /// For blocks with fewer than [`Self::SMALL_BLOCK_TX_THRESHOLD`] transactions, uses
-    /// sequential iteration to avoid rayon overhead.
+    /// sequential iteration to avoid rayon overhead. For larger blocks, uses rayon parallel
+    /// iteration with [`ForEachOrdered`] to recover signatures in parallel while streaming
+    /// results to execution in the original transaction order.
     #[expect(clippy::type_complexity)]
+    #[instrument(level = "debug", target = "engine::tree::payload_processor", skip_all)]
     fn spawn_tx_iterator<I: ExecutableTxIterator<Evm>>(
         &self,
         transactions: I,
         transaction_count: usize,
     ) -> (
-        mpsc::Receiver<WithTxEnv<TxEnvFor<Evm>, I::Recovered>>,
+        mpsc::Receiver<(usize, WithTxEnv<TxEnvFor<Evm>, I::Recovered>)>,
         mpsc::Receiver<Result<WithTxEnv<TxEnvFor<Evm>, I::Recovered>, I::Error>>,
     ) {
-        let (ooo_tx, ooo_rx) = mpsc::channel();
-        let (prewarm_tx, prewarm_rx) = mpsc::channel();
-        let (execute_tx, execute_rx) = mpsc::channel();
+        let (prewarm_tx, prewarm_rx) = mpsc::sync_channel(transaction_count);
+        let (execute_tx, execute_rx) = mpsc::sync_channel(transaction_count);
 
         if transaction_count == 0 {
             // Empty block — nothing to do.
@@ -401,63 +452,49 @@ where
                         WithTxEnv { tx_env, tx: Arc::new(tx) }
                     });
                     if let Ok(tx) = &tx {
-                        let _ = prewarm_tx.send(tx.clone());
+                        let _ = prewarm_tx.send((idx, tx.clone()));
                     }
-                    let _ = ooo_tx.send((idx, tx));
+                    let _ = execute_tx.send(tx);
                 }
             });
         } else {
-            // Parallel path — spawn on rayon for parallel signature recovery.
+            // Parallel path — recover signatures in parallel on rayon, stream results
+            // to execution in order via `for_each_ordered`.
             rayon::spawn(move || {
                 let (transactions, convert) = transactions.into_parts();
-                transactions.into_par_iter().enumerate().for_each_with(
-                    ooo_tx,
-                    |ooo_tx, (idx, tx)| {
+                transactions
+                    .into_par_iter()
+                    .enumerate()
+                    .map(|(idx, tx)| {
                         let tx = convert.convert(tx);
-                        let tx = tx.map(|tx| {
+                        tx.map(|tx| {
                             let (tx_env, tx) = tx.into_parts();
-                            WithTxEnv { tx_env, tx: Arc::new(tx) }
-                        });
-                        // Only send Ok(_) variants to prewarming task.
-                        if let Ok(tx) = &tx {
-                            let _ = prewarm_tx.send(tx.clone());
-                        }
-                        let _ = ooo_tx.send((idx, tx));
-                    },
-                );
+                            let tx = WithTxEnv { tx_env, tx: Arc::new(tx) };
+                            // Send to prewarming out of order with the original index.
+                            let _ = prewarm_tx.send((idx, tx.clone()));
+                            tx
+                        })
+                    })
+                    .for_each_ordered(|tx| {
+                        let _ = execute_tx.send(tx);
+                    });
             });
         }
 
-        // Spawn a task that processes out-of-order transactions from the task above and sends them
-        // to the execution task in order.
-        self.executor.spawn_blocking(move || {
-            let mut next_for_execution = 0;
-            let mut queue = BTreeMap::new();
-            while let Ok((idx, tx)) = ooo_rx.recv() {
-                if next_for_execution == idx {
-                    let _ = execute_tx.send(tx);
-                    next_for_execution += 1;
-
-                    while let Some(entry) = queue.first_entry() &&
-                        *entry.key() == next_for_execution
-                    {
-                        let _ = execute_tx.send(entry.remove());
-                        next_for_execution += 1;
-                    }
-                } else {
-                    queue.insert(idx, tx);
-                }
-            }
-        });
-
         (prewarm_rx, execute_rx)
     }
 
     /// Spawn prewarming optionally wired to the multiproof task for target updates.
+    #[instrument(
+        level = "debug",
+        target = "engine::tree::payload_processor",
+        skip_all,
+        fields(bal=%bal.is_some(), %v2_proofs_enabled)
+    )]
     fn spawn_caching_with<P>(
         &self,
         env: ExecutionEnv<Evm>,
-        transactions: mpsc::Receiver<impl ExecutableTxFor<Evm> + Clone + Send + 'static>,
+        transactions: mpsc::Receiver<(usize, impl ExecutableTxFor<Evm> + Clone + Send + 'static)>,
         provider_builder: StateProviderBuilder<N, P>,
         to_multi_proof: Option<CrossbeamSender<MultiProofMessage>>,
         bal: Option<Arc<BlockAccessList>>,
@@ -466,7 +503,8 @@ where
     where
         P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
     {
-        let skip_prewarm = self.disable_transaction_prewarming;
+        let skip_prewarm =
+            self.disable_transaction_prewarming || env.transaction_count < SMALL_BLOCK_TX_THRESHOLD;
 
         let saved_cache = self.disable_state_cache.not().then(|| self.cache_for(env.parent_hash));
 
@@ -488,10 +526,8 @@ where
             self.execution_cache.clone(),
             prewarm_ctx,
             to_multi_proof,
-            self.prewarm_max_concurrency,
         );
 
-        // spawn pre-warm task
         {
             let to_prewarm_task = to_prewarm_task.clone();
             self.executor.spawn_blocking(move || {
@@ -532,6 +568,7 @@ where
     /// Spawns the [`SparseTrieTask`] for this payload processor.
     ///
     /// The trie is preserved when the new payload is a child of the previous one.
+    #[expect(clippy::too_many_arguments)]
     fn spawn_sparse_trie_task(
         &self,
         sparse_trie_rx: mpsc::Receiver<SparseTrieUpdate>,
@@ -540,14 +577,14 @@ where
         from_multi_proof: CrossbeamReceiver<MultiProofMessage>,
         config: &TreeConfig,
         parent_state_root: B256,
+        chunk_size: Option<usize>,
     ) {
         let preserved_sparse_trie = self.sparse_state_trie.clone();
         let trie_metrics = self.trie_metrics.clone();
         let disable_trie_cache = config.disable_trie_cache();
         let prune_depth = self.sparse_trie_prune_depth;
         let max_storage_tries = self.sparse_trie_max_storage_tries;
-        let chunk_size =
-            config.multiproof_chunking_enabled().then_some(config.multiproof_chunk_size());
+        let disable_cache_pruning = self.disable_sparse_trie_cache_pruning;
         let executor = self.executor.clone();
 
         let parent_span = Span::current();
@@ -636,12 +673,13 @@ where
             let _enter =
                 debug_span!(target: "engine::tree::payload_processor", "preserve").entered();
             let deferred = if let Some(state_root) = computed_state_root {
-                let start = std::time::Instant::now();
+                let start = Instant::now();
                 let (trie, deferred) = task.into_trie_for_reuse(
                     prune_depth,
                     max_storage_tries,
                     SPARSE_TRIE_MAX_NODES_SHRINK_CAPACITY,
                     SPARSE_TRIE_MAX_VALUES_SHRINK_CAPACITY,
+                    disable_cache_pruning,
                 );
                 trie_metrics
                     .into_trie_for_reuse_duration_histogram
@@ -969,6 +1007,27 @@ impl PayloadExecutionCache {
         self.inner.write().take();
     }
 
+    /// Waits until the execution cache becomes available for use.
+    ///
+    /// This acquires a write lock to ensure exclusive access, then immediately releases it.
+    /// This is useful for synchronization before starting payload processing.
+    ///
+    /// Returns the time spent waiting for the lock.
+    pub fn wait_for_availability(&self) -> Duration {
+        let start = Instant::now();
+        // Acquire write lock to wait for any current holders to finish
+        let _guard = self.inner.write();
+        let elapsed = start.elapsed();
+        if elapsed.as_millis() > 5 {
+            debug!(
+                target: "engine::tree::payload_processor",
+                blocked_for=?elapsed,
+                "Waited for execution cache to become available"
+            );
+        }
+        elapsed
+    }
+
     /// Updates the cache with a closure that has exclusive access to the guard.
     /// This ensures that all cache operations happen atomically.
     ///
@@ -1019,6 +1078,9 @@ pub struct ExecutionEnv<Evm: ConfigureEvm> {
     /// Used to determine parallel worker count for prewarming.
     /// A value of 0 indicates the count is unknown.
     pub transaction_count: usize,
+    /// Total gas used by all transactions in the block.
+    /// Used to adaptively select multiproof chunk size for optimal throughput.
+    pub gas_used: u64,
     /// Withdrawals included in the block.
     /// Used to generate prefetch targets for withdrawal addresses.
     pub withdrawals: Option<Vec<Withdrawal>>,
@@ -1035,6 +1097,7 @@ where
             parent_hash: Default::default(),
             parent_state_root: Default::default(),
             transaction_count: 0,
+            gas_used: 0,
             withdrawals: None,
         }
     }

crates/engine/tree/src/tree/payload_processor/multiproof.rs

@@ -8,6 +8,7 @@ use crossbeam_channel::{unbounded, Receiver as CrossbeamReceiver, Sender as Cros
 use derive_more::derive::Deref;
 use metrics::{Gauge, Histogram};
 use reth_metrics::Metrics;
+use reth_primitives_traits::FastInstant as Instant;
 use reth_provider::AccountReader;
 use reth_revm::state::EvmState;
 use reth_trie::{
@@ -25,7 +26,7 @@ use reth_trie_parallel::{
     targets_v2::MultiProofTargetsV2,
 };
 use revm_primitives::map::{hash_map, B256Map};
-use std::{collections::BTreeMap, sync::Arc, time::Instant};
+use std::{collections::BTreeMap, sync::Arc};
 use tracing::{debug, error, instrument, trace};
 
 /// Source of state changes, either from EVM execution or from a Block Access List.
@@ -771,6 +772,11 @@ impl MultiProofTask {
     fn on_prefetch_proof(&mut self, mut targets: VersionedMultiProofTargets) -> u64 {
         // Remove already fetched proof targets to avoid redundant work.
         targets.retain_difference(&self.fetched_proof_targets);
+
+        if targets.is_empty() {
+            return 0;
+        }
+
         extend_multiproof_targets(&mut self.fetched_proof_targets, &targets);
 
         // For Legacy multiproofs, make sure all target accounts have an `AddedRemovedKeySet` in the
@@ -889,6 +895,10 @@ impl MultiProofTask {
             state_updates += 1;
         }
 
+        if not_fetched_state_update.is_empty() {
+            return state_updates;
+        }
+
         // Clone+Arc MultiAddedRemovedKeys for sharing with the dispatched multiproof tasks
         let multi_added_removed_keys = Arc::new(MultiAddedRemovedKeys {
             account: self.multi_added_removed_keys.account.clone(),
@@ -1541,6 +1551,7 @@ mod tests {
         providers::OverlayStateProviderFactory, test_utils::create_test_provider_factory,
         BlockNumReader, BlockReader, ChangeSetReader, DatabaseProviderFactory, LatestStateProvider,
         PruneCheckpointReader, StageCheckpointReader, StateProviderBox, StorageChangeSetReader,
+        StorageSettingsCache,
     };
     use reth_trie::MultiProof;
     use reth_trie_db::ChangesetCache;
@@ -1562,6 +1573,7 @@ mod tests {
                               + PruneCheckpointReader
                               + ChangeSetReader
                               + StorageChangeSetReader
+                              + StorageSettingsCache
                               + BlockNumReader,
             > + Clone
             + Send
@@ -1571,7 +1583,7 @@ mod tests {
         let changeset_cache = ChangesetCache::new();
         let overlay_factory = OverlayStateProviderFactory::new(factory, changeset_cache);
         let task_ctx = ProofTaskCtx::new(overlay_factory);
-        let proof_handle = ProofWorkerHandle::new(runtime, task_ctx, false);
+        let proof_handle = ProofWorkerHandle::new(runtime, task_ctx, false, false);
         let (to_sparse_trie, _receiver) = std::sync::mpsc::channel();
         let (tx, rx) = crossbeam_channel::unbounded();
 
@@ -1581,7 +1593,10 @@ mod tests {
     fn create_cached_provider<F>(factory: F) -> CachedStateProvider<StateProviderBox>
     where
         F: DatabaseProviderFactory<
-                Provider: BlockReader + StageCheckpointReader + PruneCheckpointReader,
+                Provider: BlockReader
+                              + StageCheckpointReader
+                              + PruneCheckpointReader
+                              + reth_provider::StorageSettingsCache,
             > + Clone
             + Send
             + 'static,
@@ -2051,7 +2066,7 @@ mod tests {
                 panic!("Expected PrefetchProofs message");
             };
 
-        assert_eq!(proofs_requested, 1);
+        assert!(proofs_requested >= 1);
     }
 
     /// Verifies that different message types arriving mid-batch are not lost and preserve order.

crates/engine/tree/src/tree/payload_processor/preserved_sparse_trie.rs

@@ -3,7 +3,7 @@
 use alloy_primitives::B256;
 use parking_lot::Mutex;
 use reth_trie_sparse::SparseStateTrie;
-use std::sync::Arc;
+use std::{sync::Arc, time::Instant};
 use tracing::debug;
 
 /// Type alias for the sparse trie type used in preservation.
@@ -28,6 +28,27 @@ impl SharedPreservedSparseTrie {
     pub(super) fn lock(&self) -> PreservedTrieGuard<'_> {
         PreservedTrieGuard(self.0.lock())
     }
+
+    /// Waits until the sparse trie lock becomes available.
+    ///
+    /// This acquires and immediately releases the lock, ensuring that any
+    /// ongoing operations complete before returning. Useful for synchronization
+    /// before starting payload processing.
+    ///
+    /// Returns the time spent waiting for the lock.
+    pub(super) fn wait_for_availability(&self) -> std::time::Duration {
+        let start = Instant::now();
+        let _guard = self.0.lock();
+        let elapsed = start.elapsed();
+        if elapsed.as_millis() > 5 {
+            debug!(
+                target: "engine::tree::payload_processor",
+                blocked_for=?elapsed,
+                "Waited for preserved sparse trie to become available"
+            );
+        }
+        elapsed
+    }
 }
 
 /// Guard that holds the lock on the preserved trie.

crates/engine/tree/src/tree/payload_processor/prewarm.rs

@@ -14,7 +14,7 @@
 use crate::tree::{
     cached_state::{CachedStateProvider, SavedCache},
     payload_processor::{
-        bal::{self, total_slots, BALSlotIter},
+        bal,
         multiproof::{MultiProofMessage, VersionedMultiProofTargets},
         PayloadExecutionCache,
     },
@@ -25,12 +25,13 @@ use alloy_consensus::transaction::TxHashRef;
 use alloy_eip7928::BlockAccessList;
 use alloy_eips::eip4895::Withdrawal;
 use alloy_evm::Database;
-use alloy_primitives::{keccak256, map::B256Set, B256};
+use alloy_primitives::{keccak256, map::B256Set, StorageKey, B256};
 use crossbeam_channel::{Receiver as CrossbeamReceiver, Sender as CrossbeamSender};
 use metrics::{Counter, Gauge, Histogram};
+use rayon::prelude::*;
 use reth_evm::{execute::ExecutableTxFor, ConfigureEvm, Evm, EvmFor, RecoveredTx, SpecFor};
 use reth_metrics::Metrics;
-use reth_primitives_traits::NodePrimitives;
+use reth_primitives_traits::{FastInstant as Instant, NodePrimitives};
 use reth_provider::{
     AccountReader, BlockExecutionOutput, BlockReader, StateProvider, StateProviderFactory,
     StateReader,
@@ -38,22 +39,18 @@ use reth_provider::{
 use reth_revm::{database::StateProviderDatabase, state::EvmState};
 use reth_tasks::Runtime;
 use reth_trie::MultiProofTargets;
-use std::{
-    ops::Range,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        mpsc::{self, channel, Receiver, Sender},
-        Arc,
-    },
-    time::Instant,
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    mpsc::{self, channel, Receiver, Sender, SyncSender},
+    Arc,
 };
 use tracing::{debug, debug_span, instrument, trace, warn, Span};
 
 /// Determines the prewarming mode: transaction-based, BAL-based, or skipped.
 #[derive(Debug)]
 pub enum PrewarmMode<Tx> {
-    /// Prewarm by executing transactions from a stream.
-    Transactions(Receiver<Tx>),
+    /// Prewarm by executing transactions from a stream, each paired with its block index.
+    Transactions(Receiver<(usize, Tx)>),
     /// Prewarm by prefetching slots from a Block Access List.
     BlockAccessList(Arc<BlockAccessList>),
     /// Transaction prewarming is skipped (e.g. small blocks where the overhead exceeds the
@@ -86,8 +83,6 @@ where
     execution_cache: PayloadExecutionCache,
     /// Context provided to execution tasks
     ctx: PrewarmContext<N, P, Evm>,
-    /// How many transactions should be executed in parallel
-    max_concurrency: usize,
     /// Sender to emit evm state outcome messages, if any.
     to_multi_proof: Option<CrossbeamSender<MultiProofMessage>>,
     /// Receiver for events produced by tx execution
@@ -108,13 +103,12 @@ where
         execution_cache: PayloadExecutionCache,
         ctx: PrewarmContext<N, P, Evm>,
         to_multi_proof: Option<CrossbeamSender<MultiProofMessage>>,
-        max_concurrency: usize,
     ) -> (Self, Sender<PrewarmTaskEvent<N::Receipt>>) {
         let (actions_tx, actions_rx) = channel();
 
         trace!(
             target: "engine::tree::payload_processor::prewarm",
-            max_concurrency,
+            prewarming_threads = executor.prewarming_pool().current_num_threads(),
             transaction_count = ctx.env.transaction_count,
             "Initialized prewarm task"
         );
@@ -124,7 +118,6 @@ where
                 executor,
                 execution_cache,
                 ctx,
-                max_concurrency,
                 to_multi_proof,
                 actions_rx,
                 parent_span: Span::current(),
@@ -140,7 +133,7 @@ where
     /// subsequent transactions in the block.
     fn spawn_all<Tx>(
         &self,
-        pending: mpsc::Receiver<Tx>,
+        pending: mpsc::Receiver<(usize, Tx)>,
         actions_tx: Sender<PrewarmTaskEvent<N::Receipt>>,
         to_multi_proof: Option<CrossbeamSender<MultiProofMessage>>,
     ) where
@@ -148,30 +141,28 @@ where
     {
         let executor = self.executor.clone();
         let ctx = self.ctx.clone();
-        let max_concurrency = self.max_concurrency;
         let span = Span::current();
 
         self.executor.spawn_blocking(move || {
             let _enter = debug_span!(target: "engine::tree::payload_processor::prewarm", parent: span, "spawn_all").entered();
 
-            let (done_tx, done_rx) = mpsc::channel();
-
-            // When transaction_count is 0, it means the count is unknown. In this case, spawn
-            // max workers to handle potentially many transactions in parallel rather
-            // than bottlenecking on a single worker.
-            let transaction_count = ctx.env.transaction_count;
-            let workers_needed = if transaction_count == 0 {
-                max_concurrency
+            let pool_threads = executor.prewarming_pool().current_num_threads();
+            // Don't spawn more workers than transactions. When transaction_count is 0
+            // (unknown), use all pool threads.
+            let workers_needed = if ctx.env.transaction_count > 0 {
+                ctx.env.transaction_count.min(pool_threads)
             } else {
-                transaction_count.min(max_concurrency)
+                pool_threads
             };
 
+            let (done_tx, done_rx) = mpsc::sync_channel(workers_needed);
+
             // Spawn workers
             let tx_sender = ctx.clone().spawn_workers(workers_needed, &executor,  to_multi_proof.clone(), done_tx.clone());
 
             // Distribute transactions to workers
-            let mut tx_index = 0usize;
-            while let Ok(tx) = pending.recv() {
+            let mut tx_count = 0usize;
+            while let Ok((tx_index, tx)) = pending.recv() {
                 // Stop distributing if termination was requested
                 if ctx.terminate_execution.load(Ordering::Relaxed) {
                     trace!(
@@ -188,7 +179,7 @@ where
                 // exit early when signaled.
                 let _ = tx_sender.send(indexed_tx);
 
-                tx_index += 1;
+                tx_count += 1;
             }
 
             // Send withdrawal prefetch targets after all transactions have been distributed
@@ -207,7 +198,7 @@ where
             while done_rx.recv().is_ok() {}
 
             let _ = actions_tx
-                .send(PrewarmTaskEvent::FinishedTxExecution { executed_transactions: tx_index });
+                .send(PrewarmTaskEvent::FinishedTxExecution { executed_transactions: tx_count });
         });
     }
 
@@ -274,10 +265,8 @@ where
         }
     }
 
-    /// Runs BAL-based prewarming by spawning workers to prefetch storage slots.
-    ///
-    /// Divides the total slots across `max_concurrency` workers, each responsible for
-    /// prefetching a range of slots from the BAL.
+    /// Runs BAL-based prewarming by using the prewarming pool's parallel iterator to prefetch
+    /// accounts and storage slots.
     #[instrument(level = "debug", target = "engine::tree::payload_processor::prewarm", skip_all)]
     fn run_bal_prewarm(
         &self,
@@ -296,59 +285,35 @@ where
             return;
         }
 
-        let total_slots = total_slots(&bal);
-
-        trace!(
-            target: "engine::tree::payload_processor::prewarm",
-            total_slots,
-            max_concurrency = self.max_concurrency,
-            "Starting BAL prewarm"
-        );
-
-        if total_slots == 0 {
+        if bal.is_empty() {
             self.send_bal_hashed_state(&bal);
             let _ =
                 actions_tx.send(PrewarmTaskEvent::FinishedTxExecution { executed_transactions: 0 });
             return;
         }
 
-        let (done_tx, done_rx) = mpsc::channel();
+        trace!(
+            target: "engine::tree::payload_processor::prewarm",
+            accounts = bal.len(),
+            "Starting BAL prewarm"
+        );
 
-        // Calculate number of workers needed (at most max_concurrency)
-        let workers_needed = total_slots.min(self.max_concurrency);
-
-        // Calculate slots per worker
-        let slots_per_worker = total_slots / workers_needed;
-        let remainder = total_slots % workers_needed;
-
-        // Spawn workers with their assigned ranges
-        for i in 0..workers_needed {
-            let start = i * slots_per_worker + i.min(remainder);
-            let extra = if i < remainder { 1 } else { 0 };
-            let end = start + slots_per_worker + extra;
-
-            self.ctx.spawn_bal_worker(
-                i,
-                &self.executor,
-                Arc::clone(&bal),
-                start..end,
-                done_tx.clone(),
+        let ctx = self.ctx.clone();
+        self.executor.prewarming_pool().install(|| {
+            bal.par_iter().for_each_init(
+                || (ctx.clone(), None::<CachedStateProvider<reth_provider::StateProviderBox>>),
+                |(ctx, provider), account| {
+                    if ctx.terminate_execution.load(Ordering::Relaxed) {
+                        return;
+                    }
+                    ctx.prefetch_bal_account(provider, account);
+                },
             );
-        }
-
-        // Drop our handle to done_tx so we can detect completion
-        drop(done_tx);
-
-        // Wait for all workers to complete
-        let mut completed_workers = 0;
-        while done_rx.recv().is_ok() {
-            completed_workers += 1;
-        }
+        });
 
         trace!(
             target: "engine::tree::payload_processor::prewarm",
-            completed_workers,
-            "All BAL prewarm workers completed"
+            "All BAL prewarm accounts completed"
         );
 
         // Convert BAL to HashedPostState and send to multiproof task
@@ -585,7 +550,7 @@ where
         self,
         txs: CrossbeamReceiver<IndexedTransaction<Tx>>,
         to_multi_proof: Option<CrossbeamSender<MultiProofMessage>>,
-        done_tx: Sender<()>,
+        done_tx: SyncSender<()>,
     ) where
         Tx: ExecutableTxFor<Evm>,
     {
@@ -660,7 +625,7 @@ where
         workers_needed: usize,
         task_executor: &Runtime,
         to_multi_proof: Option<CrossbeamSender<MultiProofMessage>>,
-        done_tx: Sender<()>,
+        done_tx: SyncSender<()>,
     ) -> CrossbeamSender<IndexedTransaction<Tx>>
     where
         Tx: ExecutableTxFor<Evm> + Send + 'static,
@@ -668,115 +633,65 @@ where
         let (tx_sender, tx_receiver) = crossbeam_channel::unbounded();
 
         // Spawn workers that all pull from the shared receiver
-        let executor = task_executor.clone();
         let span = Span::current();
-        task_executor.spawn_blocking(move || {
-            let _enter = span.entered();
-            for idx in 0..workers_needed {
-                let ctx = self.clone();
-                let to_multi_proof = to_multi_proof.clone();
-                let done_tx = done_tx.clone();
-                let rx = tx_receiver.clone();
-                let span = debug_span!(target: "engine::tree::payload_processor::prewarm", "prewarm worker", idx);
-                executor.spawn_blocking(move || {
-                    let _enter = span.entered();
-                    ctx.transact_batch(rx, to_multi_proof, done_tx);
-                });
-            }
-        });
+        for idx in 0..workers_needed {
+            let ctx = self.clone();
+            let to_multi_proof = to_multi_proof.clone();
+            let done_tx = done_tx.clone();
+            let rx = tx_receiver.clone();
+            let span = debug_span!(target: "engine::tree::payload_processor::prewarm", parent: &span, "prewarm worker", idx);
+            task_executor.prewarming_pool().spawn(move || {
+                let _enter = span.entered();
+                ctx.transact_batch(rx, to_multi_proof, done_tx);
+            });
+        }
 
         tx_sender
     }
 
-    /// Spawns a worker task for BAL slot prefetching.
+    /// Prefetches a single account and all its storage slots from the BAL into the cache.
     ///
-    /// The worker iterates over the specified range of slots in the BAL and ensures
-    /// each slot is loaded into the cache by accessing it through the state provider.
-    fn spawn_bal_worker(
+    /// The `provider` is lazily initialized on first call and reused across accounts on the same
+    /// thread.
+    fn prefetch_bal_account(
         &self,
-        idx: usize,
-        executor: &Runtime,
-        bal: Arc<BlockAccessList>,
-        range: Range<usize>,
-        done_tx: Sender<()>,
+        provider: &mut Option<CachedStateProvider<reth_provider::StateProviderBox>>,
+        account: &alloy_eip7928::AccountChanges,
     ) {
-        let ctx = self.clone();
-        let span = debug_span!(
-            target: "engine::tree::payload_processor::prewarm",
-            "bal prewarm worker",
-            idx,
-            range_start = range.start,
-            range_end = range.end
-        );
-
-        executor.spawn_blocking(move || {
-            let _enter = span.entered();
-            ctx.prefetch_bal_slots(bal, range, done_tx);
-        });
-    }
-
-    /// Prefetches storage slots from a BAL range into the cache.
-    ///
-    /// This iterates through the specified range of slots and accesses them via the state
-    /// provider to populate the cache.
-    #[instrument(level = "debug", target = "engine::tree::payload_processor::prewarm", skip_all)]
-    fn prefetch_bal_slots(
-        self,
-        bal: Arc<BlockAccessList>,
-        range: Range<usize>,
-        done_tx: Sender<()>,
-    ) {
-        let Self { saved_cache, provider, metrics, .. } = self;
-
-        // Build state provider
-        let state_provider = match provider.build() {
-            Ok(provider) => provider,
-            Err(err) => {
-                trace!(
-                    target: "engine::tree::payload_processor::prewarm",
-                    %err,
-                    "Failed to build state provider in BAL prewarm thread"
-                );
-                let _ = done_tx.send(());
-                return;
+        let state_provider = match provider {
+            Some(p) => p,
+            slot @ None => {
+                let built = match self.provider.build() {
+                    Ok(p) => p,
+                    Err(err) => {
+                        trace!(
+                            target: "engine::tree::payload_processor::prewarm",
+                            %err,
+                            "Failed to build state provider in BAL prewarm thread"
+                        );
+                        return;
+                    }
+                };
+                let saved_cache =
+                    self.saved_cache.as_ref().expect("BAL prewarm should only run with cache");
+                let caches = saved_cache.cache().clone();
+                let cache_metrics = saved_cache.metrics().clone();
+                slot.insert(CachedStateProvider::new(built, caches, cache_metrics))
             }
         };
 
-        // Wrap with cache (guaranteed to be Some since run_bal_prewarm checks)
-        let saved_cache = saved_cache.expect("BAL prewarm should only run with cache");
-        let caches = saved_cache.cache().clone();
-        let cache_metrics = saved_cache.metrics().clone();
-        let state_provider = CachedStateProvider::new(state_provider, caches, cache_metrics);
-
         let start = Instant::now();
 
-        // Track last seen address to avoid fetching the same account multiple times.
-        let mut last_address = None;
+        let _ = state_provider.basic_account(&account.address);
 
-        // Iterate through the assigned range of slots
-        for (address, slot) in BALSlotIter::new(&bal, range.clone()) {
-            // Fetch the account if this is a different address than the last one
-            if last_address != Some(address) {
-                let _ = state_provider.basic_account(&address);
-                last_address = Some(address);
-            }
-
-            // Access the slot to populate the cache
-            let _ = state_provider.storage(address, slot);
+        for slot in &account.storage_changes {
+            let _ = state_provider.storage(account.address, StorageKey::from(slot.slot));
+        }
+        for &slot in &account.storage_reads {
+            let _ = state_provider.storage(account.address, StorageKey::from(slot));
         }
 
-        let elapsed = start.elapsed();
-
-        trace!(
-            target: "engine::tree::payload_processor::prewarm",
-            ?range,
-            elapsed_ms = elapsed.as_millis(),
-            "BAL prewarm worker completed"
-        );
-
-        // Signal completion
-        let _ = done_tx.send(());
-        metrics.bal_slot_iteration_duration.record(elapsed.as_secs_f64());
+        self.metrics.bal_slot_iteration_duration.record(start.elapsed().as_secs_f64());
     }
 }
 

crates/engine/tree/src/tree/payload_processor/sparse_trie.rs

@@ -11,7 +11,7 @@ use alloy_primitives::B256;
 use alloy_rlp::{Decodable, Encodable};
 use crossbeam_channel::{Receiver as CrossbeamReceiver, Sender as CrossbeamSender};
 use rayon::iter::ParallelIterator;
-use reth_primitives_traits::{Account, ParallelBridgeBuffered};
+use reth_primitives_traits::{Account, FastInstant as Instant, ParallelBridgeBuffered};
 use reth_tasks::Runtime;
 use reth_trie::{
     proof_v2::Target, updates::TrieUpdates, DecodedMultiProofV2, HashedPostState, Nibbles,
@@ -32,10 +32,7 @@ use reth_trie_sparse::{
 };
 use revm_primitives::{hash_map::Entry, B256Map};
 use smallvec::SmallVec;
-use std::{
-    sync::mpsc,
-    time::{Duration, Instant},
-};
+use std::{sync::mpsc, time::Duration};
 use tracing::{debug, debug_span, error, instrument, trace};
 
 #[expect(clippy::large_enum_variant)]
@@ -72,6 +69,7 @@ where
         max_storage_tries: usize,
         max_nodes_capacity: usize,
         max_values_capacity: usize,
+        disable_pruning: bool,
     ) -> (SparseStateTrie<A, S>, DeferredDrops) {
         match self {
             Self::Cleared(task) => task.into_cleared_trie(max_nodes_capacity, max_values_capacity),
@@ -80,6 +78,7 @@ where
                 max_storage_tries,
                 max_nodes_capacity,
                 max_values_capacity,
+                disable_pruning,
             ),
         }
     }
@@ -356,16 +355,23 @@ where
     /// Prunes and shrinks the trie for reuse in the next payload built on top of this one.
     ///
     /// Should be called after the state root result has been sent.
+    ///
+    /// When `disable_pruning` is true, the trie is preserved without any node pruning,
+    /// storage trie eviction, or capacity shrinking, keeping the full cache intact for
+    /// benchmarking purposes.
     pub(super) fn into_trie_for_reuse(
         self,
         prune_depth: usize,
         max_storage_tries: usize,
         max_nodes_capacity: usize,
         max_values_capacity: usize,
+        disable_pruning: bool,
     ) -> (SparseStateTrie<A, S>, DeferredDrops) {
         let Self { mut trie, .. } = self;
-        trie.prune(prune_depth, max_storage_tries);
-        trie.shrink_to(max_nodes_capacity, max_values_capacity);
+        if !disable_pruning {
+            trie.prune(prune_depth, max_storage_tries);
+            trie.shrink_to(max_nodes_capacity, max_values_capacity);
+        }
         let deferred = trie.take_deferred_drops();
         (trie, deferred)
     }
@@ -407,7 +413,9 @@ where
                     let update = match message {
                         Ok(m) => m,
                         Err(_) => {
-                            break
+                            return Err(ParallelStateRootError::Other(
+                                "updates channel disconnected before state root calculation".to_string(),
+                            ))
                         }
                     };
 
@@ -582,18 +590,24 @@ where
         self.process_leaf_updates(true)?;
 
         for (address, mut new) in self.new_storage_updates.drain() {
-            let updates = self.storage_updates.entry(address).or_default();
-            for (slot, new) in new.drain() {
-                match updates.entry(slot) {
-                    Entry::Occupied(mut entry) => {
-                        // Only overwrite existing entries with new values
-                        if new.is_changed() {
-                            entry.insert(new);
+            match self.storage_updates.entry(address) {
+                Entry::Vacant(entry) => {
+                    entry.insert(new); // insert the whole map at once, no per-slot loop
+                }
+                Entry::Occupied(mut entry) => {
+                    let updates = entry.get_mut();
+                    for (slot, new) in new.drain() {
+                        match updates.entry(slot) {
+                            Entry::Occupied(mut slot_entry) => {
+                                if new.is_changed() {
+                                    slot_entry.insert(new);
+                                }
+                            }
+                            Entry::Vacant(slot_entry) => {
+                                slot_entry.insert(new);
+                            }
                         }
                     }
-                    Entry::Vacant(entry) => {
-                        entry.insert(new);
-                    }
                 }
             }
         }

crates/engine/tree/src/tree/payload_validator.rs

@@ -7,8 +7,8 @@ use crate::tree::{
     payload_processor::PayloadProcessor,
     precompile_cache::{CachedPrecompile, CachedPrecompileMetrics, PrecompileCacheMap},
     sparse_trie::StateRootComputeOutcome,
-    EngineApiMetrics, EngineApiTreeState, ExecutionEnv, PayloadHandle, StateProviderBuilder,
-    StateProviderDatabase, TreeConfig,
+    CacheWaitDurations, EngineApiMetrics, EngineApiTreeState, ExecutionEnv, PayloadHandle,
+    StateProviderBuilder, StateProviderDatabase, TreeConfig, WaitForCaches,
 };
 use alloy_consensus::transaction::{Either, TxHashRef};
 use alloy_eip7928::BlockAccessList;
@@ -31,14 +31,14 @@ use reth_payload_primitives::{
     BuiltPayload, InvalidPayloadAttributesError, NewPayloadError, PayloadTypes,
 };
 use reth_primitives_traits::{
-    AlloyBlockHeader, BlockBody, BlockTy, GotExpected, NodePrimitives, RecoveredBlock, SealedBlock,
-    SealedHeader, SignerRecoverable,
+    AlloyBlockHeader, BlockBody, BlockTy, FastInstant as Instant, GotExpected, NodePrimitives,
+    RecoveredBlock, SealedBlock, SealedHeader, SignerRecoverable,
 };
 use reth_provider::{
     providers::OverlayStateProviderFactory, BlockExecutionOutput, BlockNumReader, BlockReader,
     ChangeSetReader, DatabaseProviderFactory, DatabaseProviderROFactory, HashedPostStateProvider,
     ProviderError, PruneCheckpointReader, StageCheckpointReader, StateProvider,
-    StateProviderFactory, StateReader, StorageChangeSetReader,
+    StateProviderFactory, StateReader, StorageChangeSetReader, StorageSettingsCache,
 };
 use reth_revm::db::{states::bundle_state::BundleRetention, State};
 use reth_trie::{updates::TrieUpdates, HashedPostState, StateRoot};
@@ -49,7 +49,6 @@ use std::{
     collections::HashMap,
     panic::{self, AssertUnwindSafe},
     sync::{mpsc::RecvTimeoutError, Arc},
-    time::Instant,
 };
 use tracing::{debug, debug_span, error, info, instrument, trace, warn};
 
@@ -146,7 +145,8 @@ where
                           + PruneCheckpointReader
                           + ChangeSetReader
                           + StorageChangeSetReader
-                          + BlockNumReader,
+                          + BlockNumReader
+                          + StorageSettingsCache,
         > + BlockReader<Header = N::BlockHeader>
         + ChangeSetReader
         + BlockNumReader
@@ -396,6 +396,7 @@ where
             parent_hash: input.parent_hash(),
             parent_state_root: parent_block.state_root(),
             transaction_count: input.transaction_count(),
+            gas_used: input.gas_used(),
             withdrawals: input.withdrawals().map(|w| w.to_vec()),
         };
 
@@ -596,6 +597,8 @@ where
         };
 
         self.metrics.block_validation.record_state_root(&trie_output, root_elapsed.as_secs_f64());
+        self.metrics
+            .record_state_root_gas_bucket(block.header().gas_used(), root_elapsed.as_secs_f64());
         debug!(target: "engine::tree::payload_validator", ?root_elapsed, "Calculated state root");
 
         // ensure state root matches
@@ -764,6 +767,7 @@ where
 
         let execution_duration = execution_start.elapsed();
         self.metrics.record_block_execution(&output, execution_duration);
+        self.metrics.record_block_execution_gas_bucket(output.result.gas_used, execution_duration);
 
         debug!(target: "engine::tree::payload_validator", elapsed = ?execution_duration, "Executed block");
         Ok((output, senders, result_rx))
@@ -1141,7 +1145,7 @@ where
         level = "debug",
         target = "engine::tree::payload_validator",
         skip_all,
-        fields(strategy)
+        fields(?strategy)
     )]
     fn spawn_payload_processor<T: ExecutableTxIterator<Evm>>(
         &mut self,
@@ -1526,7 +1530,8 @@ where
                           + PruneCheckpointReader
                           + ChangeSetReader
                           + StorageChangeSetReader
-                          + BlockNumReader,
+                          + BlockNumReader
+                          + StorageSettingsCache,
         > + BlockReader<Header = N::BlockHeader>
         + StateProviderFactory
         + StateReader
@@ -1580,6 +1585,15 @@ where
     }
 }
 
+impl<P, Evm, V> WaitForCaches for BasicEngineValidator<P, Evm, V>
+where
+    Evm: ConfigureEvm,
+{
+    fn wait_for_caches(&self) -> CacheWaitDurations {
+        self.payload_processor.wait_for_caches()
+    }
+}
+
 /// Enum representing either block or payload being validated.
 #[derive(Debug)]
 pub enum BlockOrPayload<T: PayloadTypes> {
@@ -1657,4 +1671,15 @@ impl<T: PayloadTypes> BlockOrPayload<T> {
             Self::Block(block) => block.body().withdrawals().map(|w| w.as_slice()),
         }
     }
+
+    /// Returns the total gas used by the block.
+    pub fn gas_used(&self) -> u64
+    where
+        T::ExecutionData: ExecutionPayload,
+    {
+        match self {
+            Self::Payload(payload) => payload.gas_used(),
+            Self::Block(block) => block.gas_used(),
+        }
+    }
 }

crates/engine/tree/src/tree/persistence_state.rs

@@ -23,7 +23,7 @@
 use alloy_eips::BlockNumHash;
 use alloy_primitives::B256;
 use crossbeam_channel::Receiver as CrossbeamReceiver;
-use std::time::Instant;
+use reth_primitives_traits::FastInstant as Instant;
 use tracing::trace;
 
 /// The state of the persistence task.

crates/engine/tree/src/tree/tests.rs

@@ -221,6 +221,7 @@ impl TestHarness {
             EngineApiKind::Ethereum,
             evm_config,
             changeset_cache,
+            provider.cached_storage_settings().use_hashed_state(),
         );
 
         let block_builder = TestBlockBuilder::default().with_chain_spec((*chain_spec).clone());

crates/engine/tree/tests/e2e-testsuite/main.rs

@@ -2,13 +2,15 @@
 
 mod fcu_finalized_blocks;
 
+use alloy_rpc_types_engine::PayloadStatusEnum;
 use eyre::Result;
 use reth_chainspec::{ChainSpecBuilder, MAINNET};
 use reth_e2e_test_utils::testsuite::{
     actions::{
-        CaptureBlock, CompareNodeChainTips, CreateFork, ExpectFcuStatus, MakeCanonical,
-        ProduceBlocks, ProduceBlocksLocally, ProduceInvalidBlocks, ReorgTo, SelectActiveNode,
-        SendNewPayloads, UpdateBlockInfo, ValidateCanonicalTag, WaitForSync,
+        BlockReference, CaptureBlock, CompareNodeChainTips, CreateFork, ExpectFcuStatus,
+        MakeCanonical, ProduceBlocks, ProduceBlocksLocally, ProduceInvalidBlocks, ReorgTo,
+        SelectActiveNode, SendForkchoiceUpdate, SendNewPayloads, SetForkBase, UpdateBlockInfo,
+        ValidateCanonicalTag, WaitForSync,
     },
     setup::{NetworkSetup, Setup},
     TestBuilder,
@@ -39,6 +41,14 @@ fn default_engine_tree_setup() -> Setup<EthEngineTypes> {
         )
 }
 
+/// Creates a v2 storage mode setup for engine tree e2e tests.
+///
+/// v2 mode uses keccak256-hashed slot keys in static file changesets and rocksdb history
+/// instead of plain keys in MDBX.
+fn v2_engine_tree_setup() -> Setup<EthEngineTypes> {
+    default_engine_tree_setup().with_storage_v2()
+}
+
 /// Test that verifies forkchoice update and canonical chain insertion functionality.
 #[tokio::test]
 async fn test_engine_tree_fcu_canon_chain_insertion_e2e() -> Result<()> {
@@ -334,3 +344,152 @@ async fn test_engine_tree_live_sync_transition_eventually_canonical_e2e() -> Res
 
     Ok(())
 }
+
+// ==================== v2 storage mode variants ====================
+
+/// v2 variant: Verifies forkchoice update and canonical chain insertion in v2 storage mode.
+///
+/// Exercises the full `save_blocks` → `write_state` → static file changeset path with hashed keys.
+#[tokio::test]
+async fn test_engine_tree_fcu_canon_chain_insertion_v2_e2e() -> Result<()> {
+    reth_tracing::init_test_tracing();
+
+    let test = TestBuilder::new()
+        .with_setup(v2_engine_tree_setup())
+        .with_action(ProduceBlocks::<EthEngineTypes>::new(1))
+        .with_action(MakeCanonical::new())
+        .with_action(ProduceBlocks::<EthEngineTypes>::new(3))
+        .with_action(MakeCanonical::new());
+
+    test.run::<EthereumNode>().await?;
+
+    Ok(())
+}
+
+/// v2 variant: Verifies forkchoice update with a reorg where all blocks are already available.
+///
+/// Exercises `write_state_reverts` path with hashed changeset keys during CL-driven reorgs.
+#[tokio::test]
+async fn test_engine_tree_fcu_reorg_with_all_blocks_v2_e2e() -> Result<()> {
+    reth_tracing::init_test_tracing();
+
+    let test = TestBuilder::new()
+        .with_setup(v2_engine_tree_setup())
+        .with_action(ProduceBlocks::<EthEngineTypes>::new(5))
+        .with_action(MakeCanonical::new())
+        .with_action(CreateFork::<EthEngineTypes>::new(2, 3))
+        .with_action(CaptureBlock::new("fork_tip"))
+        .with_action(ReorgTo::<EthEngineTypes>::new_from_tag("fork_tip"));
+
+    test.run::<EthereumNode>().await?;
+
+    Ok(())
+}
+
+/// v2 variant: Verifies progressive canonical chain extension in v2 storage mode.
+#[tokio::test]
+async fn test_engine_tree_fcu_extends_canon_chain_v2_e2e() -> Result<()> {
+    reth_tracing::init_test_tracing();
+
+    let test = TestBuilder::new()
+        .with_setup(v2_engine_tree_setup())
+        .with_action(ProduceBlocks::<EthEngineTypes>::new(1))
+        .with_action(MakeCanonical::new())
+        .with_action(ProduceBlocks::<EthEngineTypes>::new(10))
+        .with_action(CaptureBlock::new("target_block"))
+        .with_action(ReorgTo::<EthEngineTypes>::new_from_tag("target_block"))
+        .with_action(MakeCanonical::new());
+
+    test.run::<EthereumNode>().await?;
+
+    Ok(())
+}
+
+/// Creates a 2-node setup for disk-level reorg testing.
+///
+/// Uses unconnected nodes so fork blocks can be produced independently on Node 1 and then
+/// sent to Node 0 via newPayload only (no FCU), keeping Node 0's persisted chain intact
+/// until the final `ReorgTo` triggers `find_disk_reorg`.
+fn disk_reorg_setup(storage_v2: bool) -> Setup<EthEngineTypes> {
+    let mut setup = Setup::default()
+        .with_chain_spec(Arc::new(
+            ChainSpecBuilder::default()
+                .chain(MAINNET.chain)
+                .genesis(
+                    serde_json::from_str(include_str!(
+                        "../../../../e2e-test-utils/src/testsuite/assets/genesis.json"
+                    ))
+                    .unwrap(),
+                )
+                .cancun_activated()
+                .build(),
+        ))
+        .with_network(NetworkSetup::multi_node_unconnected(2))
+        .with_tree_config(
+            TreeConfig::default().with_legacy_state_root(false).with_has_enough_parallelism(true),
+        );
+    if storage_v2 {
+        setup = setup.with_storage_v2();
+    }
+    setup
+}
+
+/// Builds a disk-level reorg test scenario.
+///
+/// 1. Both nodes receive 3 shared blocks
+/// 2. Node 0 extends to 10 blocks locally (persisted to disk)
+/// 3. Node 1 builds an 8-block fork from block 3 (its canonical head)
+/// 4. Fork blocks are sent to Node 0 via newPayload (no FCU, old chain stays on disk)
+/// 5. FCU to fork tip on Node 0 triggers `find_disk_reorg` → `RemoveBlocksAbove(3)`
+fn disk_reorg_test(storage_v2: bool) -> TestBuilder<EthEngineTypes> {
+    TestBuilder::new()
+        .with_setup(disk_reorg_setup(storage_v2))
+        .with_action(SelectActiveNode::new(0))
+        .with_action(ProduceBlocks::<EthEngineTypes>::new(3))
+        .with_action(MakeCanonical::new())
+        .with_action(ProduceBlocksLocally::<EthEngineTypes>::new(7))
+        .with_action(MakeCanonical::with_active_node())
+        .with_action(SelectActiveNode::new(1))
+        .with_action(SetForkBase::new(3))
+        .with_action(ProduceBlocksLocally::<EthEngineTypes>::new(8))
+        .with_action(MakeCanonical::with_active_node())
+        .with_action(CaptureBlock::new("fork_tip"))
+        .with_action(
+            SendNewPayloads::<EthEngineTypes>::new()
+                .with_source_node(1)
+                .with_target_node(0)
+                .with_start_block(4)
+                .with_total_blocks(8),
+        )
+        .with_action(
+            SendForkchoiceUpdate::<EthEngineTypes>::new(
+                BlockReference::Tag("fork_tip".into()),
+                BlockReference::Tag("fork_tip".into()),
+                BlockReference::Tag("fork_tip".into()),
+            )
+            .with_expected_status(PayloadStatusEnum::Valid)
+            .with_node_idx(0),
+        )
+}
+
+/// Verifies disk-level reorg in v1 (plain key) storage mode.
+///
+/// Confirms `find_disk_reorg()` detects persisted blocks on the wrong fork and calls
+/// `RemoveBlocksAbove` to truncate, then re-persists the correct fork chain.
+#[tokio::test]
+async fn test_engine_tree_disk_reorg_v1_e2e() -> Result<()> {
+    reth_tracing::init_test_tracing();
+    disk_reorg_test(false).run::<EthereumNode>().await?;
+    Ok(())
+}
+
+/// v2 variant: Verifies disk-level reorg in v2 storage mode.
+///
+/// Same scenario as v1 but with hashed changeset keys in static files and rocksdb history.
+/// Exercises `find_disk_reorg()` → `RemoveBlocksAbove` with v2 hashed key format.
+#[tokio::test]
+async fn test_engine_tree_disk_reorg_v2_e2e() -> Result<()> {
+    reth_tracing::init_test_tracing();
+    disk_reorg_test(true).run::<EthereumNode>().await?;
+    Ok(())
+}

crates/engine/util/src/engine_store.rs

@@ -77,7 +77,8 @@ impl EngineMessageStore {
                     })?,
                 )?;
             }
-            BeaconEngineMessage::NewPayload { payload, tx: _tx } => {
+            BeaconEngineMessage::NewPayload { payload, .. } |
+            BeaconEngineMessage::RethNewPayload { payload, .. } => {
                 let filename = format!("{}-new_payload-{}.json", timestamp, payload.block_hash());
                 fs::write(
                     self.path.join(filename),

crates/era/src/era1/types/execution.rs

@@ -425,17 +425,9 @@ impl TotalDifficulty {
 
     /// Convert to an [`Entry`]
     pub fn to_entry(&self) -> Entry {
-        let mut data = [0u8; 32];
-
-        let be_bytes = self.value.to_be_bytes_vec();
-
-        if be_bytes.len() <= 32 {
-            data[32 - be_bytes.len()..].copy_from_slice(&be_bytes);
-        } else {
-            data.copy_from_slice(&be_bytes[be_bytes.len() - 32..]);
-        }
-
-        Entry::new(TOTAL_DIFFICULTY, data.to_vec())
+        // era1 spec: `total-difficulty = { type: 0x0600, data: SSZ uint256 }` (little-endian)
+        let data = self.value.to_le_bytes::<32>().to_vec();
+        Entry::new(TOTAL_DIFFICULTY, data)
     }
 
     /// Create from an [`Entry`]
@@ -454,8 +446,8 @@ impl TotalDifficulty {
             )));
         }
 
-        // Convert 32-byte array to U256
-        let value = U256::from_be_slice(&entry.data);
+        // era1 spec: `total-difficulty = { type: 0x0600, data: SSZ uint256 }` (little-endian)
+        let value = U256::from_le_slice(&entry.data);
 
         Ok(Self { value })
     }
@@ -608,6 +600,19 @@ mod tests {
         assert_eq!(recovered.value, value);
     }
 
+    #[test]
+    fn test_total_difficulty_ssz_le_encoding() {
+        // Verify that total-difficulty is encoded as SSZ uint256 (little-endian).
+        // See https://github.com/eth-clients/e2store-format-specs/blob/main/formats/era1.md
+        let value = U256::from(1u64);
+        let td = TotalDifficulty::new(value);
+        let entry = td.to_entry();
+
+        // Little-endian: least significant byte first [1, 0, 0, ..., 0]
+        assert_eq!(entry.data[0], 1, "First byte must be 1 (little-endian)");
+        assert_eq!(entry.data[31], 0, "Last byte must be 0 (little-endian)");
+    }
+
     #[test]
     fn test_compression_roundtrip() {
         let rlp_data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

crates/ethereum/cli/src/app.rs

@@ -158,6 +158,7 @@ where
                 reserved_cpu_cores: command.engine.reserved_cpu_cores,
                 proof_storage_worker_threads: command.engine.storage_worker_count,
                 proof_account_worker_threads: command.engine.account_worker_count,
+                prewarming_threads: command.engine.prewarming_threads,
                 ..Default::default()
             };
             let runner = CliRunner::try_with_runtime_config(

crates/ethereum/engine-primitives/src/lib.rs

@@ -53,9 +53,7 @@ impl<
             <<Self::BuiltPayload as BuiltPayload>::Primitives as NodePrimitives>::Block,
         >,
     ) -> Self::ExecutionData {
-        let (payload, sidecar) =
-            ExecutionPayload::from_block_unchecked(block.hash(), &block.into_block());
-        ExecutionData { payload, sidecar }
+        T::block_to_payload(block)
     }
 }
 

crates/ethereum/node/src/node.rs

@@ -285,7 +285,7 @@ where
             Arc::new(ctx.node.consensus().clone()),
             ctx.node.evm_config().clone(),
             ctx.config.rpc.flashbots_config(),
-            Box::new(ctx.node.task_executor().clone()),
+            ctx.node.task_executor().clone(),
             Arc::new(EthereumEngineValidator::new(ctx.config.chain.clone())),
         );
 

crates/ethereum/node/tests/e2e/blobs.rs

@@ -214,7 +214,7 @@ async fn blob_conversion_at_osaka() -> eyre::Result<()> {
     TransactionTestContext::validate_sidecar(envelope);
 
     // build last Prague payload
-    node.payload.timestamp = current_timestamp + 11;
+    node.payload.timestamp = current_timestamp + 1;
     let prague_payload = node.new_payload().await?;
     assert!(matches!(prague_payload.sidecars(), BlobSidecars::Eip4844(_)));
 
@@ -227,7 +227,7 @@ async fn blob_conversion_at_osaka() -> eyre::Result<()> {
     // validate sidecar
     TransactionTestContext::validate_sidecar(envelope);
 
-    tokio::time::sleep(Duration::from_secs(11)).await;
+    tokio::time::sleep(Duration::from_secs(6)).await;
 
     // fetch second blob tx from rpc again
     let envelope = node.rpc.envelope_by_hash(blob_tx_hash).await?;

crates/ethereum/node/tests/e2e/eth.rs

@@ -282,6 +282,7 @@ async fn test_sparse_trie_reuse_across_blocks() -> eyre::Result<()> {
                 .chain(MAINNET.chain)
                 .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap())
                 .cancun_activated()
+                .prague_activated()
                 .build(),
         ),
         false,

crates/ethereum/node/tests/e2e/rpc.rs

@@ -90,8 +90,8 @@ async fn test_fee_history() -> eyre::Result<()> {
     assert_eq!(block.header.gas_used, receipt.gas_used,);
     assert_eq!(block.header.base_fee_per_gas.unwrap(), expected_first_base_fee as u64);
 
-    for _ in 0..100 {
-        let _ = GasWaster::deploy_builder(&provider, U256::from(rng.random_range(0..1000)))
+    for _ in 0..20 {
+        let _ = GasWaster::deploy_builder(&provider, U256::from(rng.random_range(0..100)))
             .send()
             .await?;
 
@@ -100,7 +100,7 @@ async fn test_fee_history() -> eyre::Result<()> {
 
     let latest_block = provider.get_block_number().await?;
 
-    for _ in 0..100 {
+    for _ in 0..20 {
         let latest_block = rng.random_range(0..=latest_block);
         let block_count = rng.random_range(1..=(latest_block + 1));
 

crates/evm/evm/src/metrics.rs

@@ -2,8 +2,7 @@
 use alloy_consensus::BlockHeader;
 use metrics::{Counter, Gauge, Histogram};
 use reth_metrics::Metrics;
-use reth_primitives_traits::{Block, RecoveredBlock};
-use std::time::Instant;
+use reth_primitives_traits::{Block, FastInstant as Instant, RecoveredBlock};
 
 /// Executor metrics.
 #[derive(Metrics, Clone)]

crates/evm/execution-types/src/execute.rs

@@ -1,6 +1,6 @@
 use alloy_primitives::{Address, B256, U256};
 use reth_primitives_traits::{Account, Bytecode};
-use revm::database::BundleState;
+use revm::database::{states::BundleState, BundleAccount};
 
 pub use alloy_evm::block::BlockExecutionResult;
 
@@ -37,6 +37,11 @@ impl<T> BlockExecutionOutput<T> {
         self.state.account(address).map(|a| a.info.as_ref().map(Into::into))
     }
 
+    /// Returns the state [`BundleAccount`] for the given address.
+    pub fn account_state(&self, address: &Address) -> Option<&BundleAccount> {
+        self.state.account(address)
+    }
+
     /// Get storage if value is known.
     ///
     /// This means that depending on status we can potentially return `U256::ZERO`.

crates/exex/exex/src/backfill/test_utils.rs

@@ -18,6 +18,7 @@ use reth_provider::{
 };
 use reth_revm::database::StateProviderDatabase;
 use reth_testing_utils::generators::sign_tx_with_key_pair;
+use reth_trie_common::KeccakKeyHasher;
 use secp256k1::Keypair;
 
 pub(crate) fn to_execution_outcome(
@@ -77,12 +78,9 @@ where
     let execution_outcome = to_execution_outcome(block.number(), &block_execution_output);
 
     // Commit the block's execution outcome to the database
+    let hashed_state = execution_outcome.hash_state_slow::<KeccakKeyHasher>().into_sorted();
     let provider_rw = provider_factory.provider_rw()?;
-    provider_rw.append_blocks_with_state(
-        vec![block.clone()],
-        &execution_outcome,
-        Default::default(),
-    )?;
+    provider_rw.append_blocks_with_state(vec![block.clone()], &execution_outcome, hashed_state)?;
     provider_rw.commit()?;
 
     Ok(block_execution_output)
@@ -210,11 +208,12 @@ where
     execution_outcome.state_mut().reverts.sort();
 
     // Commit the block's execution outcome to the database
+    let hashed_state = execution_outcome.hash_state_slow::<KeccakKeyHasher>().into_sorted();
     let provider_rw = provider_factory.provider_rw()?;
     provider_rw.append_blocks_with_state(
         vec![block1.clone(), block2.clone()],
         &execution_outcome,
-        Default::default(),
+        hashed_state,
     )?;
     provider_rw.commit()?;
 

crates/exex/exex/src/notifications.rs

@@ -10,6 +10,7 @@ use reth_provider::{BlockReader, Chain, HeaderProvider, StateProviderFactory};
 use reth_stages_api::ExecutionStageThresholds;
 use reth_tracing::tracing::debug;
 use std::{
+    collections::VecDeque,
     fmt::Debug,
     pin::Pin,
     sync::Arc,
@@ -286,6 +287,9 @@ where
     backfill_job: Option<StreamBackfillJob<E, P, Chain<E::Primitives>>>,
     /// Custom thresholds for the backfill job, if set.
     backfill_thresholds: Option<ExecutionStageThresholds>,
+    /// Notifications that arrived during backfill and need to be delivered after it completes.
+    /// These are notifications for blocks beyond the backfill range that we must not drop.
+    pending_notifications: VecDeque<ExExNotification<E::Primitives>>,
 }
 
 impl<P, E> ExExNotificationsWithHead<P, E>
@@ -312,6 +316,7 @@ where
             pending_check_backfill: true,
             backfill_job: None,
             backfill_thresholds: None,
+            pending_notifications: VecDeque::new(),
         }
     }
 
@@ -448,6 +453,34 @@ where
         // 3. If backfill is in progress yield new notifications
         if let Some(backfill_job) = &mut this.backfill_job {
             debug!(target: "exex::notifications", "Polling backfill job");
+
+            // Drain the notification channel to prevent backpressure from stalling the
+            // ExExManager. During backfill, the ExEx is not consuming from the channel,
+            // so the capacity-1 channel fills up, which blocks the manager's PollSender,
+            // which fills the manager's 1024-entry buffer, which blocks all upstream
+            // senders. Notifications for blocks covered by the backfill range are
+            // discarded (they'll be re-delivered by the backfill job), while
+            // notifications beyond the backfill range are buffered for delivery after the
+            // backfill completes.
+            while let Poll::Ready(Some(notification)) = this.notifications.poll_recv(cx) {
+                // Always buffer revert-containing notifications (ChainReverted,
+                // ChainReorged) because the backfill job only re-delivers
+                // ChainCommitted from the database. Discarding a reorg here would
+                // leave the ExEx unaware of the fork switch.
+                if notification.reverted_chain().is_some() {
+                    this.pending_notifications.push_back(notification);
+                    continue;
+                }
+                if let Some(committed) = notification.committed_chain() &&
+                    committed.tip().number() <= this.initial_local_head.number
+                {
+                    // Covered by backfill range, safe to discard
+                    continue;
+                }
+                // Beyond the backfill range — buffer for delivery after backfill
+                this.pending_notifications.push_back(notification);
+            }
+
             if let Some(chain) = ready!(backfill_job.poll_next_unpin(cx)).transpose()? {
                 debug!(target: "exex::notifications", range = ?chain.range(), "Backfill job returned a chain");
                 return Poll::Ready(Some(Ok(ExExNotification::ChainCommitted {
@@ -459,13 +492,18 @@ where
             this.backfill_job = None;
         }
 
-        // 4. Otherwise advance the regular event stream
+        // 4. Deliver any notifications that were buffered during backfill
+        if let Some(notification) = this.pending_notifications.pop_front() {
+            return Poll::Ready(Some(Ok(notification)))
+        }
+
+        // 5. Otherwise advance the regular event stream
         loop {
             let Some(notification) = ready!(this.notifications.poll_recv(cx)) else {
                 return Poll::Ready(None)
             };
 
-            // 5. In case the exex is ahead of the new tip, we must skip it
+            // 6. In case the exex is ahead of the new tip, we must skip it
             if let Some(committed) = notification.committed_chain() {
                 // inclusive check because we should start with `exex.head + 1`
                 if this.initial_exex_head.block.number >= committed.tip().number() {
@@ -789,4 +827,135 @@ mod tests {
 
         Ok(())
     }
+
+    /// Regression test for <https://github.com/paradigmxyz/reth/issues/19665>.
+    ///
+    /// During backfill, `poll_next` must drain the notification channel so that
+    /// the upstream `ExExManager` is never blocked by a full channel. Without
+    /// the drain loop the capacity-1 channel stays full for the entire backfill
+    /// duration, which stalls the manager's `PollSender` and eventually blocks
+    /// all upstream senders once the 1024-entry buffer fills up.
+    ///
+    /// The key assertion is the `try_send` after the first `poll_next`: it
+    /// proves the channel was drained during the backfill poll. Without the
+    /// fix this `try_send` fails because the notification is still sitting in
+    /// the channel.
+    #[tokio::test]
+    async fn exex_notifications_backfill_drains_channel() -> eyre::Result<()> {
+        let mut rng = generators::rng();
+
+        let temp_dir = tempfile::tempdir().unwrap();
+        let wal = Wal::new(temp_dir.path()).unwrap();
+
+        let provider_factory = create_test_provider_factory();
+        let genesis_hash = init_genesis(&provider_factory)?;
+        let genesis_block = provider_factory
+            .block(genesis_hash.into())?
+            .ok_or_else(|| eyre::eyre!("genesis block not found"))?;
+
+        let provider = BlockchainProvider::new(provider_factory.clone())?;
+
+        // Insert block 1 into the DB so there's something to backfill
+        let node_head_block = random_block(
+            &mut rng,
+            genesis_block.number + 1,
+            BlockParams { parent: Some(genesis_hash), tx_count: Some(0), ..Default::default() },
+        )
+        .try_recover()?;
+        let node_head = node_head_block.num_hash();
+        let provider_rw = provider_factory.provider_rw()?;
+        provider_rw.insert_block(&node_head_block)?;
+        provider_rw.commit()?;
+
+        // ExEx head is at genesis — backfill will run for block 1
+        let exex_head =
+            ExExHead { block: BlockNumHash { number: genesis_block.number, hash: genesis_hash } };
+
+        // Notification for a block AFTER the backfill range (block 2).
+        let post_backfill_notification = ExExNotification::ChainCommitted {
+            new: Arc::new(Chain::new(
+                vec![random_block(
+                    &mut rng,
+                    node_head.number + 1,
+                    BlockParams { parent: Some(node_head.hash), ..Default::default() },
+                )
+                .try_recover()?],
+                Default::default(),
+                BTreeMap::new(),
+            )),
+        };
+
+        // Another notification (block 3) used to probe channel capacity.
+        let probe_notification = ExExNotification::ChainCommitted {
+            new: Arc::new(Chain::new(
+                vec![random_block(
+                    &mut rng,
+                    node_head.number + 2,
+                    BlockParams { parent: None, ..Default::default() },
+                )
+                .try_recover()?],
+                Default::default(),
+                BTreeMap::new(),
+            )),
+        };
+
+        let (notifications_tx, notifications_rx) = mpsc::channel(1);
+
+        // Fill the capacity-1 channel.
+        notifications_tx.send(post_backfill_notification.clone()).await?;
+
+        // Confirm the channel is full — this is the precondition that causes the
+        // stall in production: the ExExManager's PollSender would block here.
+        assert!(
+            notifications_tx.try_send(probe_notification.clone()).is_err(),
+            "channel should be full before backfill poll"
+        );
+
+        let mut notifications = ExExNotificationsWithoutHead::new(
+            node_head,
+            provider,
+            EthEvmConfig::mainnet(),
+            notifications_rx,
+            wal.handle(),
+        )
+        .with_head(exex_head);
+
+        // Poll once — this returns the backfill result for block 1. Crucially,
+        // the drain loop in poll_next runs in this same call, consuming the
+        // notification from the channel and buffering it.
+        let backfill_result = notifications.next().await.transpose()?;
+        assert_eq!(
+            backfill_result,
+            Some(ExExNotification::ChainCommitted {
+                new: Arc::new(
+                    BackfillJobFactory::new(
+                        notifications.evm_config.clone(),
+                        notifications.provider.clone()
+                    )
+                    .backfill(1..=1)
+                    .next()
+                    .ok_or_eyre("failed to backfill")??
+                )
+            })
+        );
+
+        // KEY ASSERTION: the channel was drained during the backfill poll above.
+        // Without the drain loop this try_send fails because the original
+        // notification is still occupying the capacity-1 channel.
+        assert!(
+            notifications_tx.try_send(probe_notification.clone()).is_ok(),
+            "channel should have been drained during backfill poll"
+        );
+
+        // The first buffered notification (block 2) was drained from the channel
+        // during backfill and is delivered now.
+        let buffered = notifications.next().await.transpose()?;
+        assert_eq!(buffered, Some(post_backfill_notification));
+
+        // The probe notification (block 3) that we just sent is delivered next.
+        let probe = notifications.next().await.transpose()?;
+        assert_eq!(probe, Some(probe_notification));
+
+        Ok(())
+    }
 }

crates/net/downloaders/src/bodies/bodies.rs

@@ -16,7 +16,7 @@ use reth_network_p2p::{
 };
 use reth_primitives_traits::{size::InMemorySize, Block, SealedHeader};
 use reth_storage_api::HeaderProvider;
-use reth_tasks::{TaskSpawner, TokioTaskExecutor};
+use reth_tasks::Runtime;
 use std::{
     cmp::Ordering,
     collections::BinaryHeap,
@@ -285,17 +285,9 @@ where
     C: BodiesClient<Body = B::Body> + 'static,
     Provider: HeaderProvider<Header = B::Header> + Unpin + 'static,
 {
-    /// Spawns the downloader task via [`tokio::task::spawn`]
-    pub fn into_task(self) -> TaskDownloader<B> {
-        self.into_task_with(&TokioTaskExecutor::default())
-    }
-
-    /// Convert the downloader into a [`TaskDownloader`] by spawning it via the given spawner.
-    pub fn into_task_with<S>(self, spawner: &S) -> TaskDownloader<B>
-    where
-        S: TaskSpawner,
-    {
-        TaskDownloader::spawn_with(self, spawner)
+    /// Convert the downloader into a [`TaskDownloader`] by spawning it via the given [`Runtime`].
+    pub fn into_task_with(self, runtime: &Runtime) -> TaskDownloader<B> {
+        TaskDownloader::spawn_with(self, runtime)
     }
 }
 

crates/net/downloaders/src/bodies/task.rs

@@ -1,13 +1,13 @@
 use alloy_primitives::BlockNumber;
 use futures::Stream;
-use futures_util::{FutureExt, StreamExt};
+use futures_util::StreamExt;
 use pin_project::pin_project;
 use reth_network_p2p::{
     bodies::downloader::{BodyDownloader, BodyDownloaderResult},
     error::DownloadResult,
 };
 use reth_primitives_traits::Block;
-use reth_tasks::{TaskSpawner, TokioTaskExecutor};
+use reth_tasks::Runtime;
 use std::{
     fmt::Debug,
     future::Future,
@@ -32,50 +32,11 @@ pub struct TaskDownloader<B: Block> {
 }
 
 impl<B: Block + 'static> TaskDownloader<B> {
-    /// Spawns the given `downloader` via [`tokio::task::spawn`] returns a [`TaskDownloader`] that's
-    /// connected to that task.
-    ///
-    /// # Panics
-    ///
-    /// This method panics if called outside of a Tokio runtime
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use reth_consensus::Consensus;
-    /// use reth_downloaders::bodies::{bodies::BodiesDownloaderBuilder, task::TaskDownloader};
-    /// use reth_network_p2p::bodies::client::BodiesClient;
-    /// use reth_primitives_traits::{Block, InMemorySize};
-    /// use reth_storage_api::HeaderProvider;
-    /// use std::{fmt::Debug, sync::Arc};
-    ///
-    /// fn t<
-    ///     B: Block + 'static,
-    ///     C: BodiesClient<Body = B::Body> + 'static,
-    ///     Provider: HeaderProvider<Header = B::Header> + Unpin + 'static,
-    /// >(
-    ///     client: Arc<C>,
-    ///     consensus: Arc<dyn Consensus<B>>,
-    ///     provider: Provider,
-    /// ) {
-    ///     let downloader =
-    ///         BodiesDownloaderBuilder::default().build::<B, _, _>(client, consensus, provider);
-    ///     let downloader = TaskDownloader::spawn(downloader);
-    /// }
-    /// ```
-    pub fn spawn<T>(downloader: T) -> Self
-    where
-        T: BodyDownloader<Block = B> + 'static,
-    {
-        Self::spawn_with(downloader, &TokioTaskExecutor::default())
-    }
-
-    /// Spawns the given `downloader` via the given [`TaskSpawner`] returns a [`TaskDownloader`]
+    /// Spawns the given `downloader` via the given [`Runtime`] and returns a [`TaskDownloader`]
     /// that's connected to that task.
-    pub fn spawn_with<T, S>(downloader: T, spawner: &S) -> Self
+    pub fn spawn_with<T>(downloader: T, runtime: &Runtime) -> Self
     where
         T: BodyDownloader<Block = B> + 'static,
-        S: TaskSpawner,
     {
         let (bodies_tx, bodies_rx) = mpsc::channel(BODIES_TASK_BUFFER_SIZE);
         let (to_downloader, updates_rx) = mpsc::unbounded_channel();
@@ -86,7 +47,7 @@ impl<B: Block + 'static> TaskDownloader<B> {
             downloader,
         };
 
-        spawner.spawn_task(downloader.boxed());
+        runtime.spawn_task(downloader);
 
         Self { from_downloader: ReceiverStream::new(bodies_rx), to_downloader }
     }
@@ -201,7 +162,8 @@ mod tests {
                 Arc::new(TestConsensus::default()),
                 factory,
             );
-        let mut downloader = TaskDownloader::spawn(downloader);
+        let runtime = Runtime::test();
+        let mut downloader = TaskDownloader::spawn_with(downloader, &runtime);
 
         downloader.set_download_range(0..=19).expect("failed to set download range");
 
@@ -224,7 +186,8 @@ mod tests {
                 Arc::new(TestConsensus::default()),
                 factory,
             );
-        let mut downloader = TaskDownloader::spawn(downloader);
+        let runtime = Runtime::test();
+        let mut downloader = TaskDownloader::spawn_with(downloader, &runtime);
 
         downloader.set_download_range(1..=0).expect("failed to set download range");
         assert_matches!(downloader.next().await, Some(Err(DownloadError::InvalidBodyRange { .. })));

crates/net/downloaders/src/headers/reverse_headers.rs

@@ -21,7 +21,7 @@ use reth_network_p2p::{
 };
 use reth_network_peers::PeerId;
 use reth_primitives_traits::{GotExpected, SealedHeader};
-use reth_tasks::{TaskSpawner, TokioTaskExecutor};
+use reth_tasks::Runtime;
 use std::{
     cmp::{Ordering, Reverse},
     collections::{binary_heap::PeekMut, BinaryHeap},
@@ -660,20 +660,12 @@ where
     H: HeadersClient,
     Self: HeaderDownloader + 'static,
 {
-    /// Spawns the downloader task via [`tokio::task::spawn`]
-    pub fn into_task(self) -> TaskDownloader<<Self as HeaderDownloader>::Header> {
-        self.into_task_with(&TokioTaskExecutor::default())
-    }
-
-    /// Convert the downloader into a [`TaskDownloader`] by spawning it via the given `spawner`.
-    pub fn into_task_with<S>(
+    /// Convert the downloader into a [`TaskDownloader`] by spawning it via the given [`Runtime`].
+    pub fn into_task_with(
         self,
-        spawner: &S,
-    ) -> TaskDownloader<<Self as HeaderDownloader>::Header>
-    where
-        S: TaskSpawner,
-    {
-        TaskDownloader::spawn_with(self, spawner)
+        runtime: &Runtime,
+    ) -> TaskDownloader<<Self as HeaderDownloader>::Header> {
+        TaskDownloader::spawn_with(self, runtime)
     }
 }
 

crates/net/downloaders/src/headers/task.rs

@@ -1,5 +1,5 @@
 use alloy_primitives::Sealable;
-use futures::{FutureExt, Stream};
+use futures::Stream;
 use futures_util::StreamExt;
 use pin_project::pin_project;
 use reth_network_p2p::headers::{
@@ -7,7 +7,7 @@ use reth_network_p2p::headers::{
     error::HeadersDownloaderResult,
 };
 use reth_primitives_traits::SealedHeader;
-use reth_tasks::{TaskSpawner, TokioTaskExecutor};
+use reth_tasks::Runtime;
 use std::{
     fmt::Debug,
     future::Future,
@@ -33,42 +33,11 @@ pub struct TaskDownloader<H: Sealable> {
 // === impl TaskDownloader ===
 
 impl<H: Sealable + Send + Sync + Unpin + 'static> TaskDownloader<H> {
-    /// Spawns the given `downloader` via [`tokio::task::spawn`] and returns a [`TaskDownloader`]
+    /// Spawns the given `downloader` via the given [`Runtime`] and returns a [`TaskDownloader`]
     /// that's connected to that task.
-    ///
-    /// # Panics
-    ///
-    /// This method panics if called outside of a Tokio runtime
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use std::sync::Arc;
-    /// # use reth_downloaders::headers::reverse_headers::ReverseHeadersDownloader;
-    /// # use reth_downloaders::headers::task::TaskDownloader;
-    /// # use reth_consensus::HeaderValidator;
-    /// # use reth_network_p2p::headers::client::HeadersClient;
-    /// # use reth_primitives_traits::BlockHeader;
-    /// # fn t<H: HeadersClient<Header: BlockHeader> + 'static>(consensus:Arc<dyn HeaderValidator<H::Header>>, client: Arc<H>) {
-    ///    let downloader = ReverseHeadersDownloader::<H>::builder().build(
-    ///        client,
-    ///        consensus
-    ///     );
-    ///   let downloader = TaskDownloader::spawn(downloader);
-    /// # }
-    pub fn spawn<T>(downloader: T) -> Self
+    pub fn spawn_with<T>(downloader: T, runtime: &Runtime) -> Self
     where
         T: HeaderDownloader<Header = H> + 'static,
-    {
-        Self::spawn_with(downloader, &TokioTaskExecutor::default())
-    }
-
-    /// Spawns the given `downloader` via the given [`TaskSpawner`] returns a [`TaskDownloader`]
-    /// that's connected to that task.
-    pub fn spawn_with<T, S>(downloader: T, spawner: &S) -> Self
-    where
-        T: HeaderDownloader<Header = H> + 'static,
-        S: TaskSpawner,
     {
         let (headers_tx, headers_rx) = mpsc::channel(HEADERS_TASK_BUFFER_SIZE);
         let (to_downloader, updates_rx) = mpsc::unbounded_channel();
@@ -78,7 +47,7 @@ impl<H: Sealable + Send + Sync + Unpin + 'static> TaskDownloader<H> {
             updates: UnboundedReceiverStream::new(updates_rx),
             downloader,
         };
-        spawner.spawn_task(downloader.boxed());
+        runtime.spawn_task(downloader);
 
         Self { from_downloader: ReceiverStream::new(headers_rx), to_downloader }
     }
@@ -209,7 +178,8 @@ mod tests {
             .request_limit(1)
             .build(Arc::clone(&client), Arc::new(TestConsensus::default()));
 
-        let mut downloader = TaskDownloader::spawn(downloader);
+        let runtime = Runtime::test();
+        let mut downloader = TaskDownloader::spawn_with(downloader, &runtime);
         downloader.update_local_head(p3.clone());
         downloader.update_sync_target(SyncTarget::Tip(p0.hash()));
 

crates/net/eth-wire-types/src/block_access_lists.rs

@@ -0,0 +1,27 @@
+//! Implements the `GetBlockAccessLists` and `BlockAccessLists` message types.
+
+use alloc::vec::Vec;
+use alloy_primitives::{Bytes, B256};
+use alloy_rlp::{RlpDecodableWrapper, RlpEncodableWrapper};
+use reth_codecs_derive::add_arbitrary_tests;
+
+/// A request for block access lists from the given block hashes.
+#[derive(Clone, Debug, PartialEq, Eq, RlpEncodableWrapper, RlpDecodableWrapper, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(any(test, feature = "arbitrary"), derive(arbitrary::Arbitrary))]
+#[add_arbitrary_tests(rlp)]
+pub struct GetBlockAccessLists(
+    /// The block hashes to request block access lists for.
+    pub Vec<B256>,
+);
+
+/// Response for [`GetBlockAccessLists`] containing one BAL per requested block hash.
+#[derive(Clone, Debug, PartialEq, Eq, RlpEncodableWrapper, RlpDecodableWrapper, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(any(test, feature = "arbitrary"), derive(arbitrary::Arbitrary))]
+#[add_arbitrary_tests(rlp)]
+pub struct BlockAccessLists(
+    /// The requested block access lists as opaque bytes. Unavailable entries are represented by
+    /// empty byte slices.
+    pub Vec<Bytes>,
+);

crates/net/eth-wire-types/src/broadcast.rs

@@ -169,7 +169,10 @@ impl NewPooledTransactionHashes {
                 matches!(version, EthVersion::Eth67 | EthVersion::Eth66)
             }
             Self::Eth68(_) => {
-                matches!(version, EthVersion::Eth68 | EthVersion::Eth69 | EthVersion::Eth70)
+                matches!(
+                    version,
+                    EthVersion::Eth68 | EthVersion::Eth69 | EthVersion::Eth70 | EthVersion::Eth71
+                )
             }
         }
     }

crates/net/eth-wire-types/src/capability.rs

@@ -110,6 +110,11 @@ impl Capability {
         Self::eth(EthVersion::Eth70)
     }
 
+    /// Returns the [`EthVersion::Eth71`] capability.
+    pub const fn eth_71() -> Self {
+        Self::eth(EthVersion::Eth71)
+    }
+
     /// Whether this is eth v66 protocol.
     #[inline]
     pub fn is_eth_v66(&self) -> bool {
@@ -140,6 +145,12 @@ impl Capability {
         self.name == "eth" && self.version == 70
     }
 
+    /// Whether this is eth v71.
+    #[inline]
+    pub fn is_eth_v71(&self) -> bool {
+        self.name == "eth" && self.version == 71
+    }
+
     /// Whether this is any eth version.
     #[inline]
     pub fn is_eth(&self) -> bool {
@@ -147,7 +158,8 @@ impl Capability {
             self.is_eth_v67() ||
             self.is_eth_v68() ||
             self.is_eth_v69() ||
-            self.is_eth_v70()
+            self.is_eth_v70() ||
+            self.is_eth_v71()
     }
 }
 
@@ -167,7 +179,7 @@ impl From<EthVersion> for Capability {
 #[cfg(any(test, feature = "arbitrary"))]
 impl<'a> arbitrary::Arbitrary<'a> for Capability {
     fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
-        let version = u.int_in_range(66..=70)?; // Valid eth protocol versions are 66-70
+        let version = u.int_in_range(66..=71)?; // Valid eth protocol versions are 66-71
                                                 // Only generate valid eth protocol name for now since it's the only supported protocol
         Ok(Self::new_static("eth", version))
     }
@@ -183,6 +195,7 @@ pub struct Capabilities {
     eth_68: bool,
     eth_69: bool,
     eth_70: bool,
+    eth_71: bool,
 }
 
 impl Capabilities {
@@ -194,6 +207,7 @@ impl Capabilities {
             eth_68: value.iter().any(Capability::is_eth_v68),
             eth_69: value.iter().any(Capability::is_eth_v69),
             eth_70: value.iter().any(Capability::is_eth_v70),
+            eth_71: value.iter().any(Capability::is_eth_v71),
             inner: value,
         }
     }
@@ -212,7 +226,7 @@ impl Capabilities {
     /// Whether the peer supports `eth` sub-protocol.
     #[inline]
     pub const fn supports_eth(&self) -> bool {
-        self.eth_70 || self.eth_69 || self.eth_68 || self.eth_67 || self.eth_66
+        self.eth_71 || self.eth_70 || self.eth_69 || self.eth_68 || self.eth_67 || self.eth_66
     }
 
     /// Whether this peer supports eth v66 protocol.
@@ -244,6 +258,12 @@ impl Capabilities {
     pub const fn supports_eth_v70(&self) -> bool {
         self.eth_70
     }
+
+    /// Whether this peer supports eth v71 protocol.
+    #[inline]
+    pub const fn supports_eth_v71(&self) -> bool {
+        self.eth_71
+    }
 }
 
 impl From<Vec<Capability>> for Capabilities {
@@ -268,6 +288,7 @@ impl Decodable for Capabilities {
             eth_68: inner.iter().any(Capability::is_eth_v68),
             eth_69: inner.iter().any(Capability::is_eth_v69),
             eth_70: inner.iter().any(Capability::is_eth_v70),
+            eth_71: inner.iter().any(Capability::is_eth_v71),
             inner,
         })
     }

crates/net/eth-wire-types/src/lib.rs

@@ -38,6 +38,9 @@ pub use state::*;
 pub mod receipts;
 pub use receipts::*;
 
+pub mod block_access_lists;
+pub use block_access_lists::*;
+
 pub mod disconnect_reason;
 pub use disconnect_reason::*;
 

crates/net/eth-wire-types/src/message.rs

@@ -1,4 +1,4 @@
-//! Implements Ethereum wire protocol for versions 66 through 70.
+//! Implements Ethereum wire protocol for versions 66 through 71.
 //! Defines structs/enums for messages, request-response pairs, and broadcasts.
 //! Handles compatibility with [`EthVersion`].
 //!
@@ -7,10 +7,10 @@
 //! Reference: [Ethereum Wire Protocol](https://github.com/ethereum/devp2p/blob/master/caps/eth.md).
 
 use super::{
-    broadcast::NewBlockHashes, BlockBodies, BlockHeaders, GetBlockBodies, GetBlockHeaders,
-    GetNodeData, GetPooledTransactions, GetReceipts, GetReceipts70, NewPooledTransactionHashes66,
-    NewPooledTransactionHashes68, NodeData, PooledTransactions, Receipts, Status, StatusEth69,
-    Transactions,
+    broadcast::NewBlockHashes, BlockAccessLists, BlockBodies, BlockHeaders, GetBlockAccessLists,
+    GetBlockBodies, GetBlockHeaders, GetNodeData, GetPooledTransactions, GetReceipts,
+    GetReceipts70, NewPooledTransactionHashes66, NewPooledTransactionHashes68, NodeData,
+    PooledTransactions, Receipts, Status, StatusEth69, Transactions,
 };
 use crate::{
     status::StatusMessage, BlockRangeUpdate, EthNetworkPrimitives, EthVersion, NetworkPrimitives,
@@ -168,6 +168,32 @@ impl<N: NetworkPrimitives> ProtocolMessage<N> {
                 }
                 EthMessage::BlockRangeUpdate(BlockRangeUpdate::decode(buf)?)
             }
+            EthMessageID::GetBlockAccessLists => {
+                if version < EthVersion::Eth71 {
+                    // Beyond the max ID for this version — treat as raw capability message
+                    // (e.g. a snap protocol message in the multiplexed ID space).
+                    let raw_payload = Bytes::copy_from_slice(buf);
+                    buf.advance(raw_payload.len());
+                    EthMessage::Other(RawCapabilityMessage::new(
+                        message_type.to_u8() as usize,
+                        raw_payload.into(),
+                    ))
+                } else {
+                    EthMessage::GetBlockAccessLists(RequestPair::decode(buf)?)
+                }
+            }
+            EthMessageID::BlockAccessLists => {
+                if version < EthVersion::Eth71 {
+                    let raw_payload = Bytes::copy_from_slice(buf);
+                    buf.advance(raw_payload.len());
+                    EthMessage::Other(RawCapabilityMessage::new(
+                        message_type.to_u8() as usize,
+                        raw_payload.into(),
+                    ))
+                } else {
+                    EthMessage::BlockAccessLists(RequestPair::decode(buf)?)
+                }
+            }
             EthMessageID::Other(_) => {
                 let raw_payload = Bytes::copy_from_slice(buf);
                 buf.advance(raw_payload.len());
@@ -250,6 +276,8 @@ impl<N: NetworkPrimitives> From<EthBroadcastMessage<N>> for ProtocolBroadcastMes
 ///
 /// The `eth/70` (EIP-7975) keeps the eth/69 status format and introduces partial receipts.
 /// requests/responses.
+///
+/// The `eth/71` draft extends eth/70 with block access list request/response messages.
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum EthMessage<N: NetworkPrimitives = EthNetworkPrimitives> {
@@ -310,6 +338,8 @@ pub enum EthMessage<N: NetworkPrimitives = EthNetworkPrimitives> {
     /// `GetReceipts` in EIP-7975 inlines the request id. The type still wraps
     /// a [`RequestPair`], but with a custom inline encoding.
     GetReceipts70(RequestPair<GetReceipts70>),
+    /// Represents a `GetBlockAccessLists` request-response pair for eth/71.
+    GetBlockAccessLists(RequestPair<GetBlockAccessLists>),
     /// Represents a Receipts request-response pair.
     #[cfg_attr(
         feature = "serde",
@@ -332,6 +362,8 @@ pub enum EthMessage<N: NetworkPrimitives = EthNetworkPrimitives> {
     /// request id. The type still wraps a [`RequestPair`], but with a custom
     /// inline encoding.
     Receipts70(RequestPair<Receipts70<N::Receipt>>),
+    /// Represents a `BlockAccessLists` request-response pair for eth/71.
+    BlockAccessLists(RequestPair<BlockAccessLists>),
     /// Represents a `BlockRangeUpdate` message broadcast to the network.
     #[cfg_attr(
         feature = "serde",
@@ -364,6 +396,8 @@ impl<N: NetworkPrimitives> EthMessage<N> {
             Self::GetReceipts(_) | Self::GetReceipts70(_) => EthMessageID::GetReceipts,
             Self::Receipts(_) | Self::Receipts69(_) | Self::Receipts70(_) => EthMessageID::Receipts,
             Self::BlockRangeUpdate(_) => EthMessageID::BlockRangeUpdate,
+            Self::GetBlockAccessLists(_) => EthMessageID::GetBlockAccessLists,
+            Self::BlockAccessLists(_) => EthMessageID::BlockAccessLists,
             Self::Other(msg) => EthMessageID::Other(msg.id as u8),
         }
     }
@@ -376,6 +410,7 @@ impl<N: NetworkPrimitives> EthMessage<N> {
                 Self::GetBlockHeaders(_) |
                 Self::GetReceipts(_) |
                 Self::GetReceipts70(_) |
+                Self::GetBlockAccessLists(_) |
                 Self::GetPooledTransactions(_) |
                 Self::GetNodeData(_)
         )
@@ -389,6 +424,7 @@ impl<N: NetworkPrimitives> EthMessage<N> {
                 Self::Receipts(_) |
                 Self::Receipts69(_) |
                 Self::Receipts70(_) |
+                Self::BlockAccessLists(_) |
                 Self::BlockHeaders(_) |
                 Self::BlockBodies(_) |
                 Self::NodeData(_)
@@ -443,9 +479,11 @@ impl<N: NetworkPrimitives> Encodable for EthMessage<N> {
             Self::NodeData(data) => data.encode(out),
             Self::GetReceipts(request) => request.encode(out),
             Self::GetReceipts70(request) => request.encode(out),
+            Self::GetBlockAccessLists(request) => request.encode(out),
             Self::Receipts(receipts) => receipts.encode(out),
             Self::Receipts69(receipt69) => receipt69.encode(out),
             Self::Receipts70(receipt70) => receipt70.encode(out),
+            Self::BlockAccessLists(block_access_lists) => block_access_lists.encode(out),
             Self::BlockRangeUpdate(block_range_update) => block_range_update.encode(out),
             Self::Other(unknown) => out.put_slice(&unknown.payload),
         }
@@ -468,9 +506,11 @@ impl<N: NetworkPrimitives> Encodable for EthMessage<N> {
             Self::NodeData(data) => data.length(),
             Self::GetReceipts(request) => request.length(),
             Self::GetReceipts70(request) => request.length(),
+            Self::GetBlockAccessLists(request) => request.length(),
             Self::Receipts(receipts) => receipts.length(),
             Self::Receipts69(receipt69) => receipt69.length(),
             Self::Receipts70(receipt70) => receipt70.length(),
+            Self::BlockAccessLists(block_access_lists) => block_access_lists.length(),
             Self::BlockRangeUpdate(block_range_update) => block_range_update.length(),
             Self::Other(unknown) => unknown.length(),
         }
@@ -559,6 +599,14 @@ pub enum EthMessageID {
     ///
     /// Introduced in Eth69
     BlockRangeUpdate = 0x11,
+    /// Requests block access lists.
+    ///
+    /// Introduced in Eth71
+    GetBlockAccessLists = 0x12,
+    /// Represents block access lists.
+    ///
+    /// Introduced in Eth71
+    BlockAccessLists = 0x13,
     /// Represents unknown message types.
     Other(u8),
 }
@@ -583,13 +631,17 @@ impl EthMessageID {
             Self::GetReceipts => 0x0f,
             Self::Receipts => 0x10,
             Self::BlockRangeUpdate => 0x11,
+            Self::GetBlockAccessLists => 0x12,
+            Self::BlockAccessLists => 0x13,
             Self::Other(value) => *value, // Return the stored `u8`
         }
     }
 
     /// Returns the max value for the given version.
     pub const fn max(version: EthVersion) -> u8 {
-        if version.is_eth69() {
+        if version.is_eth71() {
+            Self::BlockAccessLists.to_u8()
+        } else if version.is_eth69_or_newer() {
             Self::BlockRangeUpdate.to_u8()
         } else {
             Self::Receipts.to_u8()
@@ -634,6 +686,8 @@ impl Decodable for EthMessageID {
             0x0f => Self::GetReceipts,
             0x10 => Self::Receipts,
             0x11 => Self::BlockRangeUpdate,
+            0x12 => Self::GetBlockAccessLists,
+            0x13 => Self::BlockAccessLists,
             unknown => Self::Other(*unknown),
         };
         buf.advance(1);
@@ -662,6 +716,8 @@ impl TryFrom<usize> for EthMessageID {
             0x0f => Ok(Self::GetReceipts),
             0x10 => Ok(Self::Receipts),
             0x11 => Ok(Self::BlockRangeUpdate),
+            0x12 => Ok(Self::GetBlockAccessLists),
+            0x13 => Ok(Self::BlockAccessLists),
             _ => Err("Invalid message ID"),
         }
     }
@@ -742,8 +798,9 @@ where
 mod tests {
     use super::MessageError;
     use crate::{
-        message::RequestPair, EthMessage, EthMessageID, EthNetworkPrimitives, EthVersion,
-        GetNodeData, NodeData, ProtocolMessage, RawCapabilityMessage,
+        message::RequestPair, BlockAccessLists, EthMessage, EthMessageID, EthNetworkPrimitives,
+        EthVersion, GetBlockAccessLists, GetNodeData, NodeData, ProtocolMessage,
+        RawCapabilityMessage,
     };
     use alloy_primitives::hex;
     use alloy_rlp::{Decodable, Encodable, Error};
@@ -784,6 +841,57 @@ mod tests {
         assert!(matches!(msg, Err(MessageError::Invalid(..))));
     }
 
+    #[test]
+    fn test_bal_message_version_gating() {
+        // On versions < Eth71, GetBlockAccessLists and BlockAccessLists IDs are treated as
+        // raw capability messages (Other) since they fall beyond the eth range and may
+        // belong to another sub-protocol (e.g. snap).
+        let get_block_access_lists =
+            EthMessage::<EthNetworkPrimitives>::GetBlockAccessLists(RequestPair {
+                request_id: 1337,
+                message: GetBlockAccessLists(vec![]),
+            });
+        let buf = encode(ProtocolMessage {
+            message_type: EthMessageID::GetBlockAccessLists,
+            message: get_block_access_lists,
+        });
+        let msg = ProtocolMessage::<EthNetworkPrimitives>::decode_message(
+            EthVersion::Eth70,
+            &mut &buf[..],
+        );
+        assert!(matches!(msg, Ok(ProtocolMessage { message: EthMessage::Other(_), .. })));
+
+        let block_access_lists =
+            EthMessage::<EthNetworkPrimitives>::BlockAccessLists(RequestPair {
+                request_id: 1337,
+                message: BlockAccessLists(vec![]),
+            });
+        let buf = encode(ProtocolMessage {
+            message_type: EthMessageID::BlockAccessLists,
+            message: block_access_lists,
+        });
+        let msg = ProtocolMessage::<EthNetworkPrimitives>::decode_message(
+            EthVersion::Eth70,
+            &mut &buf[..],
+        );
+        assert!(matches!(msg, Ok(ProtocolMessage { message: EthMessage::Other(_), .. })));
+    }
+
+    #[test]
+    fn test_bal_message_eth71_roundtrip() {
+        let msg = ProtocolMessage::from(EthMessage::<EthNetworkPrimitives>::GetBlockAccessLists(
+            RequestPair { request_id: 42, message: GetBlockAccessLists(vec![]) },
+        ));
+        let encoded = encode(msg.clone());
+        let decoded = ProtocolMessage::<EthNetworkPrimitives>::decode_message(
+            EthVersion::Eth71,
+            &mut &encoded[..],
+        )
+        .unwrap();
+
+        assert_eq!(decoded, msg);
+    }
+
     #[test]
     fn request_pair_encode() {
         let request_pair = RequestPair { request_id: 1337, message: vec![5u8] };
@@ -937,6 +1045,13 @@ mod tests {
         assert!(matches!(decoded, StatusMessage::Legacy(s) if s == status));
     }
 
+    #[test]
+    fn eth_message_id_max_includes_block_range_update() {
+        assert_eq!(EthMessageID::max(EthVersion::Eth69), EthMessageID::BlockRangeUpdate.to_u8(),);
+        assert_eq!(EthMessageID::max(EthVersion::Eth70), EthMessageID::BlockRangeUpdate.to_u8(),);
+        assert_eq!(EthMessageID::max(EthVersion::Eth68), EthMessageID::Receipts.to_u8());
+    }
+
     #[test]
     fn decode_status_rejects_non_status() {
         let msg = EthMessage::<EthNetworkPrimitives>::GetBlockBodies(RequestPair {

crates/net/eth-wire-types/src/version.rs

@@ -29,6 +29,8 @@ pub enum EthVersion {
     Eth69 = 69,
     /// The `eth` protocol version 70.
     Eth70 = 70,
+    /// The `eth` protocol version 71.
+    Eth71 = 71,
 }
 
 impl EthVersion {
@@ -62,9 +64,19 @@ impl EthVersion {
     pub const fn is_eth70(&self) -> bool {
         matches!(self, Self::Eth70)
     }
+
+    /// Returns true if the version is eth/71
+    pub const fn is_eth71(&self) -> bool {
+        matches!(self, Self::Eth71)
+    }
+
+    /// Returns true if the version is eth/69 or newer.
+    pub const fn is_eth69_or_newer(&self) -> bool {
+        matches!(self, Self::Eth69 | Self::Eth70 | Self::Eth71)
+    }
 }
 
-/// RLP encodes `EthVersion` as a single byte (66-69).
+/// RLP encodes `EthVersion` as a single byte (66-71).
 impl Encodable for EthVersion {
     fn encode(&self, out: &mut dyn BufMut) {
         (*self as u8).encode(out)
@@ -76,7 +88,7 @@ impl Encodable for EthVersion {
 }
 
 /// RLP decodes a single byte into `EthVersion`.
-/// Returns error if byte is not a valid version (66-69).
+/// Returns error if byte is not a valid version (66-71).
 impl Decodable for EthVersion {
     fn decode(buf: &mut &[u8]) -> alloy_rlp::Result<Self> {
         let version = u8::decode(buf)?;
@@ -104,6 +116,7 @@ impl TryFrom<&str> for EthVersion {
             "68" => Ok(Self::Eth68),
             "69" => Ok(Self::Eth69),
             "70" => Ok(Self::Eth70),
+            "71" => Ok(Self::Eth71),
             _ => Err(ParseVersionError(s.to_string())),
         }
     }
@@ -129,6 +142,7 @@ impl TryFrom<u8> for EthVersion {
             68 => Ok(Self::Eth68),
             69 => Ok(Self::Eth69),
             70 => Ok(Self::Eth70),
+            71 => Ok(Self::Eth71),
             _ => Err(ParseVersionError(u.to_string())),
         }
     }
@@ -159,6 +173,7 @@ impl From<EthVersion> for &'static str {
             EthVersion::Eth68 => "68",
             EthVersion::Eth69 => "69",
             EthVersion::Eth70 => "70",
+            EthVersion::Eth71 => "71",
         }
     }
 }
@@ -216,6 +231,7 @@ mod tests {
         assert_eq!(EthVersion::Eth68, EthVersion::try_from("68").unwrap());
         assert_eq!(EthVersion::Eth69, EthVersion::try_from("69").unwrap());
         assert_eq!(EthVersion::Eth70, EthVersion::try_from("70").unwrap());
+        assert_eq!(EthVersion::Eth71, EthVersion::try_from("71").unwrap());
     }
 
     #[test]
@@ -225,6 +241,7 @@ mod tests {
         assert_eq!(EthVersion::Eth68, "68".parse().unwrap());
         assert_eq!(EthVersion::Eth69, "69".parse().unwrap());
         assert_eq!(EthVersion::Eth70, "70".parse().unwrap());
+        assert_eq!(EthVersion::Eth71, "71".parse().unwrap());
     }
 
     #[test]
@@ -235,6 +252,7 @@ mod tests {
             EthVersion::Eth68,
             EthVersion::Eth69,
             EthVersion::Eth70,
+            EthVersion::Eth71,
         ];
 
         for version in versions {
@@ -253,6 +271,7 @@ mod tests {
             (68_u8, Ok(EthVersion::Eth68)),
             (69_u8, Ok(EthVersion::Eth69)),
             (70_u8, Ok(EthVersion::Eth70)),
+            (71_u8, Ok(EthVersion::Eth71)),
             (65_u8, Err(RlpError::Custom("invalid eth version"))),
         ];
 

crates/net/eth-wire/src/eth_snap_stream.rs

@@ -294,7 +294,8 @@ mod tests {
     use alloy_primitives::B256;
     use alloy_rlp::Encodable;
     use reth_eth_wire_types::{
-        message::RequestPair, GetAccountRangeMessage, GetBlockHeaders, HeadersDirection,
+        message::RequestPair, GetAccountRangeMessage, GetBlockAccessLists, GetBlockHeaders,
+        HeadersDirection,
     };
 
     // Helper to create eth message and its bytes
@@ -419,4 +420,40 @@ mod tests {
         let snap_boundary_result = inner.decode_message(snap_boundary_bytes);
         assert!(snap_boundary_result.is_err());
     }
+
+    #[test]
+    fn test_eth70_message_id_0x12_is_snap() {
+        let inner = EthSnapStreamInner::<EthNetworkPrimitives>::new(EthVersion::Eth70);
+        let snap_msg = SnapProtocolMessage::GetAccountRange(GetAccountRangeMessage {
+            request_id: 1,
+            root_hash: B256::default(),
+            starting_hash: B256::default(),
+            limit_hash: B256::default(),
+            response_bytes: 1000,
+        });
+
+        let encoded = inner.encode_snap_message(snap_msg);
+        assert_eq!(encoded[0], EthMessageID::message_count(EthVersion::Eth70));
+
+        let decoded = inner.decode_message(BytesMut::from(&encoded[..])).unwrap();
+        assert!(matches!(decoded, EthSnapMessage::Snap(_)));
+    }
+
+    #[test]
+    fn test_eth71_message_id_0x12_is_eth() {
+        let inner = EthSnapStreamInner::<EthNetworkPrimitives>::new(EthVersion::Eth71);
+        let eth_msg = EthMessage::<EthNetworkPrimitives>::GetBlockAccessLists(RequestPair {
+            request_id: 1,
+            message: GetBlockAccessLists(vec![B256::ZERO]),
+        });
+        let protocol_msg = ProtocolMessage::from(eth_msg.clone());
+        let mut buf = Vec::new();
+        protocol_msg.encode(&mut buf);
+
+        let decoded = inner.decode_message(BytesMut::from(&buf[..])).unwrap();
+        let EthSnapMessage::Eth(decoded_eth) = decoded else {
+            panic!("expected eth message");
+        };
+        assert_eq!(decoded_eth, eth_msg);
+    }
 }

crates/net/eth-wire/src/hello.rs

@@ -205,7 +205,10 @@ impl HelloMessageBuilder {
             protocol_version: protocol_version.unwrap_or_default(),
             client_version: client_version.unwrap_or_else(|| RETH_CLIENT_VERSION.to_string()),
             protocols: protocols.unwrap_or_else(|| {
-                EthVersion::ALL_VERSIONS.iter().copied().map(Into::into).collect()
+                let mut protos: Vec<Protocol> =
+                    EthVersion::ALL_VERSIONS.iter().copied().map(Into::into).collect();
+                protos.push(Protocol::snap_1());
+                protos
             }),
             port: port.unwrap_or(DEFAULT_TCP_PORT),
             id,

crates/net/eth-wire/src/multiplex.rs

@@ -610,12 +610,20 @@ where
                                 let _ = this.primary.to_primary.send(msg);
                             } else {
                                 // delegate to installed satellite if any
+                                let mut handled = false;
                                 for proto in &this.inner.protocols {
                                     if proto.shared_cap == *cap {
-                                        proto.send_raw(msg);
+                                        proto.send_raw(msg.clone());
+                                        handled = true;
                                         break
                                     }
                                 }
+                                if !handled {
+                                    // No satellite handler for this capability (e.g. snap/1
+                                    // handled inline). Route to primary so the session can
+                                    // handle it via RawCapabilityMessage.
+                                    let _ = this.primary.to_primary.send(msg);
+                                }
                             }
                         } else {
                             return Poll::Ready(Some(Err(P2PStreamError::UnknownReservedMessageId(

crates/net/eth-wire/src/protocol.rs

@@ -45,6 +45,13 @@ impl Protocol {
         Self::eth(EthVersion::Eth68)
     }
 
+    /// Returns the `snap/1` capability.
+    ///
+    /// The snap protocol defines 8 message types (0x00..0x07).
+    pub const fn snap_1() -> Self {
+        Self::new(Capability::new_static("snap", 1), 8)
+    }
+
     /// Consumes the type and returns a tuple of the [Capability] and number of messages.
     #[inline]
     pub(crate) fn split(self) -> (Capability, u8) {
@@ -84,5 +91,7 @@ mod tests {
         assert_eq!(Protocol::eth(EthVersion::Eth67).messages(), 17);
         assert_eq!(Protocol::eth(EthVersion::Eth68).messages(), 17);
         assert_eq!(Protocol::eth(EthVersion::Eth69).messages(), 18);
+        assert_eq!(Protocol::eth(EthVersion::Eth70).messages(), 18);
+        assert_eq!(Protocol::eth(EthVersion::Eth71).messages(), 20);
     }
 }

crates/net/network-api/src/events.rs

@@ -1,14 +1,21 @@
 //! API related to listening for network events.
 
 use reth_eth_wire_types::{
-    message::RequestPair, BlockBodies, BlockHeaders, Capabilities, DisconnectReason, EthMessage,
-    EthNetworkPrimitives, EthVersion, GetBlockBodies, GetBlockHeaders, GetNodeData,
-    GetPooledTransactions, GetReceipts, GetReceipts70, NetworkPrimitives, NodeData,
+    message::RequestPair,
+    snap::{
+        GetAccountRangeMessage, GetByteCodesMessage, GetStorageRangesMessage, GetTrieNodesMessage,
+    },
+    BlockAccessLists, BlockBodies, BlockHeaders, Capabilities, DisconnectReason, EthMessage,
+    EthNetworkPrimitives, EthVersion, GetBlockAccessLists, GetBlockBodies, GetBlockHeaders,
+    GetNodeData, GetPooledTransactions, GetReceipts, GetReceipts70, NetworkPrimitives, NodeData,
     PooledTransactions, Receipts, Receipts69, Receipts70, UnifiedStatus,
 };
 use reth_ethereum_forks::ForkId;
-use reth_network_p2p::error::{RequestError, RequestResult};
-use reth_network_peers::PeerId;
+use reth_network_p2p::{
+    error::{RequestError, RequestResult},
+    snap::client::SnapResponse,
+};
+use reth_network_peers::{NodeRecord, PeerId};
 use reth_network_types::{PeerAddr, PeerKind};
 use reth_tokio_util::EventStream;
 use std::{
@@ -152,8 +159,13 @@ pub trait NetworkEventListenerProvider: NetworkPeersEvents {
 pub enum DiscoveryEvent {
     /// Discovered a node
     NewNode(DiscoveredEvent),
-    /// Retrieved a [`ForkId`] from the peer via ENR request, See <https://eips.ethereum.org/EIPS/eip-868>
-    EnrForkId(PeerId, ForkId),
+    /// Retrieved a [`ForkId`] from the peer via ENR request.
+    ///
+    /// Contains the full [`NodeRecord`] (peer ID + address) and the reported [`ForkId`].
+    /// Used to verify fork compatibility before admitting the peer.
+    ///
+    /// See also <https://eips.ethereum.org/EIPS/eip-868>
+    EnrForkId(NodeRecord, ForkId),
 }
 
 /// Represents events related to peer discovery in the network.
@@ -247,6 +259,51 @@ pub enum PeerRequest<N: NetworkPrimitives = EthNetworkPrimitives> {
         /// The channel to send the response for receipts.
         response: oneshot::Sender<RequestResult<Receipts70<N::Receipt>>>,
     },
+    /// Requests block access lists from the peer.
+    ///
+    /// The response should be sent through the channel.
+    GetBlockAccessLists {
+        /// The request for block access lists.
+        request: GetBlockAccessLists,
+        /// The channel to send the response for block access lists.
+        response: oneshot::Sender<RequestResult<BlockAccessLists>>,
+    },
+    /// Requests an account range from the peer (snap protocol).
+    ///
+    /// The response should be sent through the channel.
+    GetAccountRange {
+        /// The request for an account range.
+        request: GetAccountRangeMessage,
+        /// The channel to send the response for the account range.
+        response: oneshot::Sender<RequestResult<SnapResponse>>,
+    },
+    /// Requests storage ranges from the peer (snap protocol).
+    ///
+    /// The response should be sent through the channel.
+    GetStorageRanges {
+        /// The request for storage ranges.
+        request: GetStorageRangesMessage,
+        /// The channel to send the response for storage ranges.
+        response: oneshot::Sender<RequestResult<SnapResponse>>,
+    },
+    /// Requests bytecodes from the peer (snap protocol).
+    ///
+    /// The response should be sent through the channel.
+    GetByteCodes {
+        /// The request for bytecodes.
+        request: GetByteCodesMessage,
+        /// The channel to send the response for bytecodes.
+        response: oneshot::Sender<RequestResult<SnapResponse>>,
+    },
+    /// Requests trie nodes from the peer (snap protocol).
+    ///
+    /// The response should be sent through the channel.
+    GetTrieNodes {
+        /// The request for trie nodes.
+        request: GetTrieNodesMessage,
+        /// The channel to send the response for trie nodes.
+        response: oneshot::Sender<RequestResult<SnapResponse>>,
+    },
 }
 
 // === impl PeerRequest ===
@@ -267,10 +324,41 @@ impl<N: NetworkPrimitives> PeerRequest<N> {
             Self::GetReceipts { response, .. } => response.send(Err(err)).ok(),
             Self::GetReceipts69 { response, .. } => response.send(Err(err)).ok(),
             Self::GetReceipts70 { response, .. } => response.send(Err(err)).ok(),
+            Self::GetBlockAccessLists { response, .. } => response.send(Err(err)).ok(),
+            Self::GetAccountRange { response, .. } |
+            Self::GetStorageRanges { response, .. } |
+            Self::GetByteCodes { response, .. } |
+            Self::GetTrieNodes { response, .. } => response.send(Err(err)).ok(),
         };
     }
 
-    /// Returns the [`EthMessage`] for this type
+    /// Returns true if this request is supported for the negotiated eth protocol version.
+    #[inline]
+    pub fn is_supported_by_eth_version(&self, version: EthVersion) -> bool {
+        match self {
+            Self::GetBlockAccessLists { .. } => version >= EthVersion::Eth71,
+            _ => true,
+        }
+    }
+
+    /// Returns `true` if this is a snap protocol request.
+    pub const fn is_snap_request(&self) -> bool {
+        matches!(
+            self,
+            Self::GetAccountRange { .. } |
+                Self::GetStorageRanges { .. } |
+                Self::GetByteCodes { .. } |
+                Self::GetTrieNodes { .. }
+        )
+    }
+
+    /// Returns the [`EthMessage`] for this type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if called on a snap protocol request variant. Use [`Self::is_snap_request`] to
+    /// check before calling this method. Snap requests are handled separately in the session
+    /// layer.
     pub fn create_request_message(&self, request_id: u64) -> EthMessage<N> {
         match self {
             Self::GetBlockHeaders { request, .. } => {
@@ -294,6 +382,18 @@ impl<N: NetworkPrimitives> PeerRequest<N> {
             Self::GetReceipts70 { request, .. } => {
                 EthMessage::GetReceipts70(RequestPair { request_id, message: request.clone() })
             }
+            Self::GetBlockAccessLists { request, .. } => {
+                EthMessage::GetBlockAccessLists(RequestPair {
+                    request_id,
+                    message: request.clone(),
+                })
+            }
+            Self::GetAccountRange { .. } |
+            Self::GetStorageRanges { .. } |
+            Self::GetByteCodes { .. } |
+            Self::GetTrieNodes { .. } => {
+                panic!("snap protocol requests cannot be converted to EthMessage, handle them separately via is_snap_request()")
+            }
         }
     }
 
@@ -344,3 +444,18 @@ impl<R> fmt::Debug for PeerRequestSender<R> {
         f.debug_struct("PeerRequestSender").field("peer_id", &self.peer_id).finish_non_exhaustive()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_block_access_lists_version_support() {
+        let (tx, _rx) = oneshot::channel();
+        let req: PeerRequest<EthNetworkPrimitives> =
+            PeerRequest::GetBlockAccessLists { request: GetBlockAccessLists(vec![]), response: tx };
+
+        assert!(!req.is_supported_by_eth_version(EthVersion::Eth70));
+        assert!(req.is_supported_by_eth_version(EthVersion::Eth71));
+    }
+}

crates/net/network-api/src/lib.rs

@@ -38,7 +38,7 @@ use reth_eth_wire_types::{
     capability::Capabilities, Capability, DisconnectReason, EthVersion, NetworkPrimitives,
     UnifiedStatus,
 };
-use reth_network_p2p::sync::NetworkSyncUpdater;
+use reth_network_p2p::{snap::client::SnapClient, sync::NetworkSyncUpdater};
 use reth_network_peers::NodeRecord;
 use std::{future::Future, net::SocketAddr, sync::Arc, time::Instant};
 
@@ -48,7 +48,7 @@ pub type PeerId = alloy_primitives::B512;
 /// Helper trait that unifies network API needed to launch node.
 pub trait FullNetwork:
     BlockDownloaderProvider<
-        Client: BlockClient<Block = <Self::Primitives as NetworkPrimitives>::Block>,
+        Client: BlockClient<Block = <Self::Primitives as NetworkPrimitives>::Block> + SnapClient,
     > + NetworkSyncUpdater
     + NetworkInfo
     + NetworkEventListenerProvider
@@ -62,7 +62,8 @@ pub trait FullNetwork:
 
 impl<T> FullNetwork for T where
     T: BlockDownloaderProvider<
-            Client: BlockClient<Block = <Self::Primitives as NetworkPrimitives>::Block>,
+            Client: BlockClient<Block = <Self::Primitives as NetworkPrimitives>::Block>
+                        + SnapClient,
         > + NetworkSyncUpdater
         + NetworkInfo
         + NetworkEventListenerProvider

crates/net/network-types/src/peers/config.rs

@@ -172,6 +172,11 @@ pub struct PeersConfig {
     /// IPs within the specified CIDR ranges will be allowed.
     #[cfg_attr(feature = "serde", serde(skip))]
     pub ip_filter: IpFilter,
+    /// If true, discovered peers without a confirmed ENR [`ForkId`](alloy_eip2124::ForkId)
+    /// (EIP-868) will not be added to the peer set until their fork ID is verified.
+    ///
+    /// This filters out peers from other networks that pollute the discovery table.
+    pub enforce_enr_fork_id: bool,
 }
 
 impl Default for PeersConfig {
@@ -191,6 +196,7 @@ impl Default for PeersConfig {
             max_backoff_count: 5,
             incoming_ip_throttle_duration: INBOUND_IP_THROTTLE_DURATION,
             ip_filter: IpFilter::default(),
+            enforce_enr_fork_id: false,
         }
     }
 }
@@ -314,6 +320,13 @@ impl PeersConfig {
         self
     }
 
+    /// If set, discovered peers without a confirmed ENR [`ForkId`](alloy_eip2124::ForkId) will not
+    /// be added to the peer set until their fork ID is verified via EIP-868.
+    pub const fn with_enforce_enr_fork_id(mut self, enforce: bool) -> Self {
+        self.enforce_enr_fork_id = enforce;
+        self
+    }
+
     /// Returns settings for testing
     #[cfg(any(test, feature = "test-utils"))]
     pub fn test() -> Self {

crates/net/network/src/config.rs

@@ -20,7 +20,7 @@ use reth_ethereum_forks::{ForkFilter, Head};
 use reth_network_peers::{mainnet_nodes, pk2id, sepolia_nodes, PeerId, TrustedPeer};
 use reth_network_types::{PeersConfig, SessionsConfig};
 use reth_storage_api::{noop::NoopProvider, BlockNumReader, BlockReader, HeaderProvider};
-use reth_tasks::{TaskSpawner, TokioTaskExecutor};
+use reth_tasks::Runtime;
 use secp256k1::SECP256K1;
 use std::{collections::HashSet, net::SocketAddr, sync::Arc};
 
@@ -76,7 +76,7 @@ pub struct NetworkConfig<C, N: NetworkPrimitives = EthNetworkPrimitives> {
     /// The default mode of the network.
     pub network_mode: NetworkMode,
     /// The executor to use for spawning tasks.
-    pub executor: Box<dyn TaskSpawner>,
+    pub executor: Runtime,
     /// The `Status` message to send to peers at the beginning.
     pub status: UnifiedStatus,
     /// Sets the hello message for the p2p handshake in `RLPx`
@@ -206,7 +206,7 @@ pub struct NetworkConfigBuilder<N: NetworkPrimitives = EthNetworkPrimitives> {
     /// The default mode of the network.
     network_mode: NetworkMode,
     /// The executor to use for spawning tasks.
-    executor: Option<Box<dyn TaskSpawner>>,
+    executor: Option<Runtime>,
     /// Sets the hello message for the p2p handshake in `RLPx`
     hello_message: Option<HelloMessageWithProtocols>,
     /// The executor to use for spawning tasks.
@@ -342,7 +342,7 @@ impl<N: NetworkPrimitives> NetworkConfigBuilder<N> {
     /// Sets the executor to use for spawning tasks.
     ///
     /// If `None`, then [`tokio::spawn`] is used for spawning tasks.
-    pub fn with_task_executor(mut self, executor: Box<dyn TaskSpawner>) -> Self {
+    pub fn with_task_executor(mut self, executor: Runtime) -> Self {
         self.executor = Some(executor);
         self
     }
@@ -691,7 +691,11 @@ impl<N: NetworkPrimitives> NetworkConfigBuilder<N> {
             chain_id,
             block_import: block_import.unwrap_or_else(|| Box::<ProofOfStakeBlockImport>::default()),
             network_mode,
-            executor: executor.unwrap_or_else(|| Box::<TokioTaskExecutor>::default()),
+            executor: executor.unwrap_or_else(|| match tokio::runtime::Handle::try_current() {
+                Ok(handle) => Runtime::with_existing_handle(handle)
+                    .expect("failed to create runtime with existing handle"),
+                Err(_) => Runtime::test(),
+            }),
             status,
             hello_message,
             extra_protocols,

crates/net/network/src/discovery.rs

@@ -240,7 +240,7 @@ impl Discovery {
                 self.on_node_record_update(record, None);
             }
             DiscoveryUpdate::EnrForkId(node, fork_id) => {
-                self.queued_events.push_back(DiscoveryEvent::EnrForkId(node.id, fork_id))
+                self.queued_events.push_back(DiscoveryEvent::EnrForkId(node, fork_id))
             }
             DiscoveryUpdate::Removed(peer_id) => {
                 self.discovered_nodes.remove(&peer_id);

crates/net/network/src/eth_requests.rs

@@ -6,12 +6,13 @@ use crate::{
 };
 use alloy_consensus::{BlockHeader, ReceiptWithBloom};
 use alloy_eips::BlockHashOrNumber;
+use alloy_primitives::Bytes;
 use alloy_rlp::Encodable;
 use futures::StreamExt;
 use reth_eth_wire::{
-    BlockBodies, BlockHeaders, EthNetworkPrimitives, GetBlockBodies, GetBlockHeaders, GetNodeData,
-    GetReceipts, GetReceipts70, HeadersDirection, NetworkPrimitives, NodeData, Receipts,
-    Receipts69, Receipts70,
+    BlockAccessLists, BlockBodies, BlockHeaders, EthNetworkPrimitives, GetBlockAccessLists,
+    GetBlockBodies, GetBlockHeaders, GetNodeData, GetReceipts, GetReceipts70, HeadersDirection,
+    NetworkPrimitives, NodeData, Receipts, Receipts69, Receipts70,
 };
 use reth_network_api::test_utils::PeersHandle;
 use reth_network_p2p::error::RequestResult;
@@ -281,6 +282,19 @@ where
         let _ = response.send(Ok(Receipts70 { last_block_incomplete, receipts }));
     }
 
+    /// Handles [`GetBlockAccessLists`] queries.
+    ///
+    /// For now this returns one empty BAL per requested hash.
+    fn on_block_access_lists_request(
+        &self,
+        _peer_id: PeerId,
+        request: GetBlockAccessLists,
+        response: oneshot::Sender<RequestResult<BlockAccessLists>>,
+    ) {
+        let access_lists = request.0.into_iter().map(|_| Bytes::new()).collect();
+        let _ = response.send(Ok(BlockAccessLists(access_lists)));
+    }
+
     #[inline]
     fn get_receipts_response<T, F>(&self, request: GetReceipts, transform_fn: F) -> Vec<Vec<T>>
     where
@@ -352,6 +366,9 @@ where
                     IncomingEthRequest::GetReceipts70 { peer_id, request, response } => {
                         this.on_receipts70_request(peer_id, request, response)
                     }
+                    IncomingEthRequest::GetBlockAccessLists { peer_id, request, response } => {
+                        this.on_block_access_lists_request(peer_id, request, response)
+                    }
                 }
             },
         );
@@ -437,4 +454,15 @@ pub enum IncomingEthRequest<N: NetworkPrimitives = EthNetworkPrimitives> {
         /// The channel sender for the response containing Receipts70.
         response: oneshot::Sender<RequestResult<Receipts70<N::Receipt>>>,
     },
+    /// Request Block Access Lists from the peer.
+    ///
+    /// The response should be sent through the channel.
+    GetBlockAccessLists {
+        /// The ID of the peer to request block access lists from.
+        peer_id: PeerId,
+        /// The requested block hashes.
+        request: GetBlockAccessLists,
+        /// The channel sender for the response containing block access lists.
+        response: oneshot::Sender<RequestResult<BlockAccessLists>>,
+    },
 }

crates/net/network/src/fetch/client.rs

@@ -4,6 +4,9 @@ use crate::{fetch::DownloadRequest, flattened_response::FlattenedResponse};
 use alloy_primitives::B256;
 use futures::{future, future::Either};
 use reth_eth_wire::{EthNetworkPrimitives, NetworkPrimitives};
+use reth_eth_wire_types::snap::{
+    GetAccountRangeMessage, GetByteCodesMessage, GetStorageRangesMessage, GetTrieNodesMessage,
+};
 use reth_network_api::test_utils::PeersHandle;
 use reth_network_p2p::{
     bodies::client::{BodiesClient, BodiesFut},
@@ -11,6 +14,7 @@ use reth_network_p2p::{
     error::{PeerRequestResult, RequestError},
     headers::client::{HeadersClient, HeadersRequest},
     priority::Priority,
+    snap::client::{SnapClient, SnapResponse},
     BlockClient,
 };
 use reth_network_peers::PeerId;
@@ -105,3 +109,92 @@ impl<N: NetworkPrimitives> BodiesClient for FetchClient<N> {
 impl<N: NetworkPrimitives> BlockClient for FetchClient<N> {
     type Block = N::Block;
 }
+
+type SnapClientFuture = Either<
+    FlattenedResponse<PeerRequestResult<SnapResponse>>,
+    future::Ready<PeerRequestResult<SnapResponse>>,
+>;
+
+impl<N: NetworkPrimitives> SnapClient for FetchClient<N> {
+    type Output = SnapClientFuture;
+
+    fn get_account_range_with_priority(
+        &self,
+        request: GetAccountRangeMessage,
+        priority: Priority,
+    ) -> Self::Output {
+        let (response, rx) = oneshot::channel();
+        if self
+            .request_tx
+            .send(DownloadRequest::GetAccountRange { request, response, priority })
+            .is_ok()
+        {
+            Either::Left(FlattenedResponse::from(rx))
+        } else {
+            Either::Right(future::err(RequestError::ChannelClosed))
+        }
+    }
+
+    fn get_storage_ranges(&self, request: GetStorageRangesMessage) -> Self::Output {
+        self.get_storage_ranges_with_priority(request, Priority::Normal)
+    }
+
+    fn get_storage_ranges_with_priority(
+        &self,
+        request: GetStorageRangesMessage,
+        priority: Priority,
+    ) -> Self::Output {
+        let (response, rx) = oneshot::channel();
+        if self
+            .request_tx
+            .send(DownloadRequest::GetStorageRanges { request, response, priority })
+            .is_ok()
+        {
+            Either::Left(FlattenedResponse::from(rx))
+        } else {
+            Either::Right(future::err(RequestError::ChannelClosed))
+        }
+    }
+
+    fn get_byte_codes(&self, request: GetByteCodesMessage) -> Self::Output {
+        self.get_byte_codes_with_priority(request, Priority::Normal)
+    }
+
+    fn get_byte_codes_with_priority(
+        &self,
+        request: GetByteCodesMessage,
+        priority: Priority,
+    ) -> Self::Output {
+        let (response, rx) = oneshot::channel();
+        if self
+            .request_tx
+            .send(DownloadRequest::GetByteCodes { request, response, priority })
+            .is_ok()
+        {
+            Either::Left(FlattenedResponse::from(rx))
+        } else {
+            Either::Right(future::err(RequestError::ChannelClosed))
+        }
+    }
+
+    fn get_trie_nodes(&self, request: GetTrieNodesMessage) -> Self::Output {
+        self.get_trie_nodes_with_priority(request, Priority::Normal)
+    }
+
+    fn get_trie_nodes_with_priority(
+        &self,
+        request: GetTrieNodesMessage,
+        priority: Priority,
+    ) -> Self::Output {
+        let (response, rx) = oneshot::channel();
+        if self
+            .request_tx
+            .send(DownloadRequest::GetTrieNodes { request, response, priority })
+            .is_ok()
+        {
+            Either::Left(FlattenedResponse::from(rx))
+        } else {
+            Either::Right(future::err(RequestError::ChannelClosed))
+        }
+    }
+}