fix: revert slow path optimization that caused regression

The slow path optimization attempted to reuse ancestor cached overlays, but those overlays were built with a DIFFERENT anchor_hash. Since the slow path is triggered precisely because the anchor changed (after persist/reorg), reusing overlays from the old anchor produces incorrect results. Reverted to the original slow path that rebuilds from each ancestor's per-block state changes. The Arc::make_mut tracking metrics are kept.
fix: address clippy doc-markdown lints
2026-04-30 03:01:58 -04:00 · 2026-01-06 23:29:13 +00:00 · 2026-01-06 23:29:13 +00:00 · 2026-01-06 23:29:13 +00:00 · 2026-01-06 23:29:13 +00:00 · 2026-01-06 23:29:13 +00:00
497 changed files with 6600 additions and 22346 deletions
--- a/.config/zepter.yaml
+++ b/.config/zepter.yaml
@@ -12,7 +12,7 @@ workflows:
        # Check that `A` activates the features of `B`.
        "propagate-feature",
        # These are the features to check:
-        "--features=std,op,dev,asm-keccak,jemalloc,jemalloc-prof,tracy-allocator,tracy,serde-bincode-compat,serde,test-utils,arbitrary,bench,alloy-compat,min-error-logs,min-warn-logs,min-info-logs,min-debug-logs,min-trace-logs,otlp,otlp-logs,js-tracer,portable,keccak-cache-global",
+        "--features=std,op,dev,asm-keccak,jemalloc,jemalloc-prof,tracy-allocator,serde-bincode-compat,serde,test-utils,arbitrary,bench,alloy-compat,min-error-logs,min-warn-logs,min-info-logs,min-debug-logs,min-trace-logs,otlp,js-tracer,portable,keccak-cache-global",
        # Do not try to add a new section to `[features]` of `A` only because `B` exposes that feature. There are edge-cases where this is still needed, but we can add them manually.
        "--left-side-feature-missing=ignore",
        # Ignore the case that `A` it outside of the workspace. Otherwise it will report errors in external dependencies that we have no influence on.
--- a/.github/workflows/dependencies.yml
+++ b/.github/workflows/dependencies.yml
@@ -15,6 +15,6 @@ permissions:

 jobs:
  update:
-    uses: tempoxyz/ci/.github/workflows/cargo-update-pr.yml@main
+    uses: ithacaxyz/ci/.github/workflows/cargo-update-pr.yml@main
    secrets:
      token: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/docker-nightly.yml
+++ b/.github/workflows/docker-nightly.yml
@@ -28,14 +28,10 @@ jobs:
        build:
          - name: 'Build and push the nightly reth image'
            command: 'make PROFILE=maxperf docker-build-push-nightly'
-          - name: 'Build and push the nightly edge profiling reth image'
-            command: 'make PROFILE=profiling docker-build-push-nightly-edge-profiling'
          - name: 'Build and push the nightly profiling reth image'
            command: 'make PROFILE=profiling docker-build-push-nightly-profiling'
          - name: 'Build and push the nightly op-reth image'
            command: 'make IMAGE_NAME=$OP_IMAGE_NAME DOCKER_IMAGE_NAME=$OP_DOCKER_IMAGE_NAME PROFILE=maxperf op-docker-build-push-nightly'
-          - name: 'Build and push the nightly edge profiling op-reth image'
-            command: 'make IMAGE_NAME=$OP_IMAGE_NAME DOCKER_IMAGE_NAME=$OP_DOCKER_IMAGE_NAME PROFILE=profiling op-docker-build-push-nightly-edge-profiling'
          - name: 'Build and push the nightly profiling op-reth image'
            command: 'make IMAGE_NAME=$OP_IMAGE_NAME DOCKER_IMAGE_NAME=$OP_DOCKER_IMAGE_NAME PROFILE=profiling op-docker-build-push-nightly-profiling'
    steps:
--- a/.github/workflows/hive.yml
+++ b/.github/workflows/hive.yml
@@ -15,21 +15,11 @@ concurrency:
  cancel-in-progress: true

 jobs:
-  prepare-reth-stable:
+  prepare-reth:
    uses: ./.github/workflows/prepare-reth.yml
    with:
      image_tag: ghcr.io/paradigmxyz/reth:latest
      binary_name: reth
-      cargo_features: "asm-keccak"
-      artifact_name: "reth-stable"
-
-  prepare-reth-edge:
-    uses: ./.github/workflows/prepare-reth.yml
-    with:
-      image_tag: ghcr.io/paradigmxyz/reth:latest
-      binary_name: reth
-      cargo_features: "asm-keccak edge"
-      artifact_name: "reth-edge"

  prepare-hive:
    if: github.repository == 'paradigmxyz/reth'
@@ -87,7 +77,6 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        storage: [stable, edge]
        # ethereum/rpc to be deprecated:
        # https://github.com/ethereum/hive/pull/1117
        scenario:
@@ -97,7 +86,7 @@ jobs:
          - sim: devp2p
            limit: discv4
          # started failing after https://github.com/ethereum/go-ethereum/pull/31843, no
-          # action on our side, remove from here when we get unexpected passes on these tests
+          # action on our side, remove from here when we get unxpected passes on these tests
          # - sim: devp2p
          #  limit: eth
          #  include:
@@ -187,10 +176,9 @@ jobs:
          - sim: ethereum/eels/consume-rlp
            limit: .*tests/paris.*
    needs:
-      - prepare-reth-stable
-      - prepare-reth-edge
+      - prepare-reth
      - prepare-hive
-    name: ${{ matrix.storage }} / ${{ matrix.scenario.sim }}${{ matrix.scenario.limit && format(' - {0}', matrix.scenario.limit) }}
+    name: run ${{ matrix.scenario.sim }}${{ matrix.scenario.limit && format(' - {0}', matrix.scenario.limit) }}
    runs-on:
      group: Reth
    permissions:
@@ -209,7 +197,7 @@ jobs:
      - name: Download reth image
        uses: actions/download-artifact@v7
        with:
-          name: reth-${{ matrix.storage }}
+          name: artifacts
          path: /tmp

      - name: Load Docker images
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -285,7 +285,7 @@ jobs:
      - run: zepter run check

  deny:
-    uses: tempoxyz/ci/.github/workflows/deny.yml@main
+    uses: ithacaxyz/ci/.github/workflows/deny.yml@main

  lint-success:
    name: lint success
--- a/.github/workflows/prepare-reth.yml
+++ b/.github/workflows/prepare-reth.yml
@@ -21,11 +21,6 @@ on:
        required: false
        type: string
        description: "Optional cargo package path"
-      artifact_name:
-        required: false
-        type: string
-        default: "artifacts"
-        description: "Name for the uploaded artifact"

 jobs:
  prepare-reth:
@@ -57,5 +52,5 @@ jobs:
        id: upload
        uses: actions/upload-artifact@v6
        with:
-          name: ${{ inputs.artifact_name }}
+          name: artifacts
          path: ./artifacts
--- a/.github/workflows/unit.yml
+++ b/.github/workflows/unit.yml
@@ -19,22 +19,29 @@ concurrency:

 jobs:
  test:
-    name: test / ${{ matrix.type }} / ${{ matrix.storage }}
+    name: test / ${{ matrix.type }} (${{ matrix.partition }}/${{ matrix.total_partitions }})
    runs-on: depot-ubuntu-latest-4
    env:
      RUST_BACKTRACE: 1
-      EDGE_FEATURES: ${{ matrix.storage == 'edge' && 'edge' || '' }}
    strategy:
      matrix:
-        type: [ethereum, optimism]
-        storage: [stable, edge]
        include:
          - type: ethereum
-            features: asm-keccak ethereum
-            exclude_args: ""
+            args: --features "asm-keccak ethereum" --locked
+            partition: 1
+            total_partitions: 2
+          - type: ethereum
+            args: --features "asm-keccak ethereum" --locked
+            partition: 2
+            total_partitions: 2
          - type: optimism
-            features: asm-keccak
-            exclude_args: --exclude reth --exclude reth-bench --exclude "example-*" --exclude "reth-ethereum-*" --exclude "*-ethereum"
+            args: --features "asm-keccak" --locked --exclude reth --exclude reth-bench --exclude "example-*" --exclude "reth-ethereum-*" --exclude "*-ethereum"
+            partition: 1
+            total_partitions: 2
+          - type: optimism
+            args: --features "asm-keccak" --locked --exclude reth --exclude reth-bench --exclude "example-*" --exclude "reth-ethereum-*" --exclude "*-ethereum"
+            partition: 2
+            total_partitions: 2
    timeout-minutes: 30
    steps:
      - uses: actions/checkout@v6
@@ -52,9 +59,9 @@ jobs:
      - name: Run tests
        run: |
          cargo nextest run \
-            --features "${{ matrix.features }} $EDGE_FEATURES" --locked \
-            ${{ matrix.exclude_args }} --workspace \
+            ${{ matrix.args }} --workspace \
            --exclude ef-tests --no-tests=warn \
+            --partition hash:${{ matrix.partition }}/2 \
            -E "!kind(test) and not binary(e2e_testsuite)"

  state:
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -18,7 +18,7 @@ Reth is a high-performance Ethereum execution client written in Rust, focusing o
 6. **Pipeline (`crates/stages/`)**: Staged sync architecture for blockchain synchronization
 7. **Trie (`crates/trie/`)**: Merkle Patricia Trie implementation with parallel state root computation
 8. **Node Builder (`crates/node/`)**: High-level node orchestration and configuration
-9. **The Consensus Engine (`crates/engine/`)**: Handles processing blocks received from the consensus layer with the Engine API (newPayload, forkchoiceUpdated)
+9  **The Consensus Engine (`crates/engine/`)**: Handles processing blocks received from the consensus layer with the Engine API (newPayload, forkchoiceUpdated)

 ### Key Design Principles

@@ -249,7 +249,7 @@ Write comments that remain valuable after the PR is merged. Future readers won't
 unsafe impl GlobalAlloc for LimitedAllocator { ... }

 // Binary search requires sorted input. Panics on unsorted slices.
-fn find_index(items: &[Item], target: &Item) -> Option<usize>
+fn find_index(items: &[Item], target: &Item) -> Option

 // Timeout set to 5s to match EVM block processing limits
 const TRACER_TIMEOUT: Duration = Duration::from_secs(5);
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -51,7 +51,9 @@ elsewhere.
 <!-- -   **Asking in the support Telegram:** The [Foundry Support Telegram][support-tg] is a fast and easy way to ask questions. -->
 <!-- -   **Opening a discussion:** This repository comes with a discussions board where you can also ask for help. Click the "Discussions" tab at the top. -->

-If you have reviewed existing documentation and still have questions, or you are having problems, you can get help by **opening a discussion**. This repository comes with a discussions board where you can also ask for help. Click the "Discussions" tab at the top.
+If you have reviewed existing documentation and still have questions, or you are having problems, you can get help by *
+*opening a discussion**. This repository comes with a discussions board where you can also ask for help. Click the "
+Discussions" tab at the top.

 As Reth is still in heavy development, the documentation can be a bit scattered. The [Reth Docs][reth-docs] is our
 current best-effort attempt at keeping up-to-date information.
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace.package]
-version = "1.10.1"
+version = "1.9.3"
 edition = "2024"
 rust-version = "1.88"
 license = "MIT OR Apache-2.0"
@@ -473,22 +473,22 @@ reth-ress-protocol = { path = "crates/ress/protocol" }
 reth-ress-provider = { path = "crates/ress/provider" }

 # revm
-revm = { version = "34.0.0", default-features = false }
-revm-bytecode = { version = "8.0.0", default-features = false }
-revm-database = { version = "10.0.0", default-features = false }
-revm-state = { version = "9.0.0", default-features = false }
-revm-primitives = { version = "22.0.0", default-features = false }
-revm-interpreter = { version = "32.0.0", default-features = false }
-revm-database-interface = { version = "9.0.0", default-features = false }
-op-revm = { version = "15.0.0", default-features = false }
-revm-inspectors = "0.34.0"
+revm = { version = "33.1.0", default-features = false }
+revm-bytecode = { version = "7.1.1", default-features = false }
+revm-database = { version = "9.0.5", default-features = false }
+revm-state = { version = "8.1.1", default-features = false }
+revm-primitives = { version = "21.0.2", default-features = false }
+revm-interpreter = { version = "31.1.0", default-features = false }
+revm-database-interface = { version = "8.0.5", default-features = false }
+op-revm = { version = "14.1.0", default-features = false }
+revm-inspectors = "0.33.2"

 # eth
 alloy-chains = { version = "0.2.5", default-features = false }
-alloy-dyn-abi = "1.4.3"
+alloy-dyn-abi = "1.4.1"
 alloy-eip2124 = { version = "0.2.0", default-features = false }
-alloy-eip7928 = { version = "0.3.0", default-features = false }
-alloy-evm = { version = "0.26.3", default-features = false }
+alloy-eip7928 = { version = "0.1.0" }
+alloy-evm = { version = "0.25.1", default-features = false }
 alloy-primitives = { version = "1.5.0", default-features = false, features = ["map-foldhash"] }
 alloy-rlp = { version = "0.3.10", default-features = false, features = ["core-net"] }
 alloy-sol-macro = "1.5.0"
@@ -497,36 +497,36 @@ alloy-trie = { version = "0.9.1", default-features = false }

 alloy-hardforks = "0.4.5"

-alloy-consensus = { version = "1.4.3", default-features = false }
-alloy-contract = { version = "1.4.3", default-features = false }
-alloy-eips = { version = "1.4.3", default-features = false }
-alloy-genesis = { version = "1.4.3", default-features = false }
-alloy-json-rpc = { version = "1.4.3", default-features = false }
-alloy-network = { version = "1.4.3", default-features = false }
-alloy-network-primitives = { version = "1.4.3", default-features = false }
-alloy-provider = { version = "1.4.3", features = ["reqwest", "debug-api"], default-features = false }
-alloy-pubsub = { version = "1.4.3", default-features = false }
-alloy-rpc-client = { version = "1.4.3", default-features = false }
-alloy-rpc-types = { version = "1.4.3", features = ["eth"], default-features = false }
-alloy-rpc-types-admin = { version = "1.4.3", default-features = false }
-alloy-rpc-types-anvil = { version = "1.4.3", default-features = false }
-alloy-rpc-types-beacon = { version = "1.4.3", default-features = false }
-alloy-rpc-types-debug = { version = "1.4.3", default-features = false }
-alloy-rpc-types-engine = { version = "1.4.3", default-features = false }
-alloy-rpc-types-eth = { version = "1.4.3", default-features = false }
-alloy-rpc-types-mev = { version = "1.4.3", default-features = false }
-alloy-rpc-types-trace = { version = "1.4.3", default-features = false }
-alloy-rpc-types-txpool = { version = "1.4.3", default-features = false }
-alloy-serde = { version = "1.4.3", default-features = false }
-alloy-signer = { version = "1.4.3", default-features = false }
-alloy-signer-local = { version = "1.4.3", default-features = false }
-alloy-transport = { version = "1.4.3" }
-alloy-transport-http = { version = "1.4.3", features = ["reqwest-rustls-tls"], default-features = false }
-alloy-transport-ipc = { version = "1.4.3", default-features = false }
-alloy-transport-ws = { version = "1.4.3", default-features = false }
+alloy-consensus = { version = "1.2.1", default-features = false }
+alloy-contract = { version = "1.2.1", default-features = false }
+alloy-eips = { version = "1.2.1", default-features = false }
+alloy-genesis = { version = "1.2.1", default-features = false }
+alloy-json-rpc = { version = "1.2.1", default-features = false }
+alloy-network = { version = "1.2.1", default-features = false }
+alloy-network-primitives = { version = "1.2.1", default-features = false }
+alloy-provider = { version = "1.2.1", features = ["reqwest", "debug-api"], default-features = false }
+alloy-pubsub = { version = "1.2.1", default-features = false }
+alloy-rpc-client = { version = "1.2.1", default-features = false }
+alloy-rpc-types = { version = "1.2.1", features = ["eth"], default-features = false }
+alloy-rpc-types-admin = { version = "1.2.1", default-features = false }
+alloy-rpc-types-anvil = { version = "1.2.1", default-features = false }
+alloy-rpc-types-beacon = { version = "1.2.1", default-features = false }
+alloy-rpc-types-debug = { version = "1.2.1", default-features = false }
+alloy-rpc-types-engine = { version = "1.2.1", default-features = false }
+alloy-rpc-types-eth = { version = "1.2.1", default-features = false }
+alloy-rpc-types-mev = { version = "1.2.1", default-features = false }
+alloy-rpc-types-trace = { version = "1.2.1", default-features = false }
+alloy-rpc-types-txpool = { version = "1.2.1", default-features = false }
+alloy-serde = { version = "1.2.1", default-features = false }
+alloy-signer = { version = "1.2.1", default-features = false }
+alloy-signer-local = { version = "1.2.1", default-features = false }
+alloy-transport = { version = "1.2.1" }
+alloy-transport-http = { version = "1.2.1", features = ["reqwest-rustls-tls"], default-features = false }
+alloy-transport-ipc = { version = "1.2.1", default-features = false }
+alloy-transport-ws = { version = "1.2.1", default-features = false }

 # op
-alloy-op-evm = { version = "0.26.3", default-features = false }
+alloy-op-evm = { version = "0.25.0", default-features = false }
 alloy-op-hardforks = "0.4.4"
 op-alloy-rpc-types = { version = "0.23.1", default-features = false }
 op-alloy-rpc-types-engine = { version = "0.23.1", default-features = false }
@@ -555,7 +555,6 @@ dirs-next = "2.0.0"
 dyn-clone = "1.0.17"
 eyre = "0.6"
 fdlimit = "0.3.0"
-fixed-map = { version = "0.9", default-features = false }
 humantime = "2.1"
 humantime-serde = "1.1"
 itertools = { version = "0.14", default-features = false }
@@ -597,9 +596,9 @@ chrono = "0.4.41"
 # metrics
 metrics = "0.24.0"
 metrics-derive = "0.1"
-metrics-exporter-prometheus = { version = "0.18.0", default-features = false }
+metrics-exporter-prometheus = { version = "0.16.0", default-features = false }
 metrics-process = "2.1.0"
-metrics-util = { default-features = false, version = "0.20.0" }
+metrics-util = { default-features = false, version = "0.19.0" }

 # proc-macros
 proc-macro2 = "1.0"
@@ -665,7 +664,6 @@ opentelemetry_sdk = "0.31"
 opentelemetry = "0.31"
 opentelemetry-otlp = "0.31"
 opentelemetry-semantic-conventions = "0.31"
-opentelemetry-appender-tracing = "0.31"
 tracing-opentelemetry = "0.32"

 # misc-testing
@@ -686,7 +684,6 @@ ethereum_ssz = "0.9.0"
 ethereum_ssz_derive = "0.9.0"

 # allocators
-jemalloc_pprof = { version = "0.8", default-features = false }
 tikv-jemalloc-ctl = "0.6"
 tikv-jemallocator = "0.6"
 tracy-client = "0.18.0"
@@ -736,18 +733,17 @@ tracing-journald = "0.3"
 tracing-logfmt = "0.3.3"
 tracing-samply = "0.1"
 tracing-subscriber = { version = "0.3", default-features = false }
-tracing-tracy = "0.11"
 triehash = "0.8"
 typenum = "1.15.0"
-vergen = "9.1.0"
+vergen = "9.0.4"
 visibility = "0.1.1"
 walkdir = "2.3.3"
-vergen-git2 = "9.1.0"
+vergen-git2 = "1.0.5"

 # networking
 ipnet = "2.11"

-[patch.crates-io]
+# [patch.crates-io]
 # alloy-consensus = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
 # alloy-contract = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
 # alloy-eips = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
@@ -792,8 +788,3 @@ ipnet = "2.11"

 # alloy-evm = { git = "https://github.com/alloy-rs/evm", rev = "a69f0b45a6b0286e16072cb8399e02ce6ceca353" }
 # alloy-op-evm = { git = "https://github.com/alloy-rs/evm", rev = "a69f0b45a6b0286e16072cb8399e02ce6ceca353" }
-
-# revm-inspectors = { git = "https://github.com/paradigmxyz/revm-inspectors", rev = "3020ea8" }
-
-# alloy-evm = { git = "https://github.com/alloy-rs/evm", rev = "072c248" }
-# alloy-op-evm = { git = "https://github.com/alloy-rs/evm", rev = "072c248" }
--- a/18
+++ b/18
@@ -276,18 +276,13 @@ docker-build-push-latest: ## Build and push a cross-arch Docker image tagged wit
 docker-build-push-nightly: ## Build and push cross-arch Docker image tagged with the latest git tag with a `-nightly` suffix, and `latest-nightly`.
 	$(call docker_build_push,nightly,nightly)

-.PHONY: docker-build-push-nightly-edge-profiling
-docker-build-push-nightly-edge-profiling: FEATURES := $(FEATURES) edge
-docker-build-push-nightly-edge-profiling: ## Build and push cross-arch Docker image with edge features tagged with `nightly-edge-profiling`.
-	$(call docker_build_push,nightly-edge-profiling,nightly-edge-profiling)
-
 # Create a cross-arch Docker image with the given tags and push it
 define docker_build_push
-	$(MAKE) FEATURES="$(FEATURES)" build-x86_64-unknown-linux-gnu
+	$(MAKE) build-x86_64-unknown-linux-gnu
 	mkdir -p $(BIN_DIR)/amd64
 	cp $(CARGO_TARGET_DIR)/x86_64-unknown-linux-gnu/$(PROFILE)/reth $(BIN_DIR)/amd64/reth

-	$(MAKE) FEATURES="$(FEATURES)" build-aarch64-unknown-linux-gnu
+	$(MAKE) build-aarch64-unknown-linux-gnu
 	mkdir -p $(BIN_DIR)/arm64
 	cp $(CARGO_TARGET_DIR)/aarch64-unknown-linux-gnu/$(PROFILE)/reth $(BIN_DIR)/arm64/reth

@@ -333,11 +328,6 @@ op-docker-build-push-latest: ## Build and push a cross-arch Docker image tagged
 op-docker-build-push-nightly: ## Build and push cross-arch Docker image tagged with the latest git tag with a `-nightly` suffix, and `latest-nightly`.
 	$(call op_docker_build_push,nightly,nightly)

-.PHONY: op-docker-build-push-nightly-edge-profiling
-op-docker-build-push-nightly-edge-profiling: FEATURES := $(FEATURES) edge
-op-docker-build-push-nightly-edge-profiling: ## Build and push cross-arch Docker image with edge features tagged with `nightly-edge-profiling`.
-	$(call op_docker_build_push,nightly-edge-profiling,nightly-edge-profiling)
-
 # Note: This requires a buildx builder with emulation support. For example:
 #
 # `docker run --privileged --rm tonistiigi/binfmt --install amd64,arm64`
@@ -357,11 +347,11 @@ op-docker-build-push-nightly-profiling: ## Build and push cross-arch Docker imag

 # Create a cross-arch Docker image with the given tags and push it
 define op_docker_build_push
-	$(MAKE) FEATURES="$(FEATURES)" op-build-x86_64-unknown-linux-gnu
+	$(MAKE) op-build-x86_64-unknown-linux-gnu
 	mkdir -p $(BIN_DIR)/amd64
 	cp $(CARGO_TARGET_DIR)/x86_64-unknown-linux-gnu/$(PROFILE)/op-reth $(BIN_DIR)/amd64/op-reth

-	$(MAKE) FEATURES="$(FEATURES)" op-build-aarch64-unknown-linux-gnu
+	$(MAKE) op-build-aarch64-unknown-linux-gnu
 	mkdir -p $(BIN_DIR)/arm64
 	cp $(CARGO_TARGET_DIR)/aarch64-unknown-linux-gnu/$(PROFILE)/op-reth $(BIN_DIR)/arm64/op-reth

--- a/README.md
+++ b/README.md
@@ -44,7 +44,7 @@ More historical context below:
 -   We released 1.0 "production-ready" stable Reth in June 2024.
    -   Reth completed an audit with [Sigma Prime](https://sigmaprime.io/), the developers of [Lighthouse](https://github.com/sigp/lighthouse), the Rust Consensus Layer implementation. Find it [here](./audit/sigma_prime_audit_v2.pdf).
    -   Revm (the EVM used in Reth) underwent an audit with [Guido Vranken](https://x.com/guidovranken) (#1 [Ethereum Bug Bounty](https://ethereum.org/en/bug-bounty)). We will publish the results soon.
-   We released multiple iterative beta versions, up to [beta.9](https://github.com/paradigmxyz/reth/releases/tag/v0.2.0-beta.9) on Monday June 3, 2024, the last beta release.
+-   We released multiple iterative beta versions, up to [beta.9](https://github.com/paradigmxyz/reth/releases/tag/v0.2.0-beta.9) on Monday June 3, 2024,the last beta release.
 -   We released [beta](https://github.com/paradigmxyz/reth/releases/tag/v0.2.0-beta.1) on Monday March 4, 2024, our first breaking change to the database model, providing faster query speed, smaller database footprint, and allowing "history" to be mounted on separate drives.
 -   We shipped iterative improvements until the last alpha release on February 28, 2024, [0.1.0-alpha.21](https://github.com/paradigmxyz/reth/releases/tag/v0.1.0-alpha.21).
 -   We [initially announced](https://www.paradigm.xyz/2023/06/reth-alpha) [0.1.0-alpha.1](https://github.com/paradigmxyz/reth/releases/tag/v0.1.0-alpha.1) on June 20, 2023.
--- a/bin/reth-bench-compare/Cargo.toml
+++ b/bin/reth-bench-compare/Cargo.toml
@@ -25,9 +25,7 @@ reth-chainspec.workspace = true

 # alloy
 alloy-provider = { workspace = true, features = ["reqwest-rustls-tls"], default-features = false }
-alloy-rpc-client = { workspace = true, features = ["pubsub"] }
 alloy-rpc-types-eth.workspace = true
-alloy-transport-ws.workspace = true
 alloy-primitives.workspace = true

 # CLI and argument parsing
@@ -71,11 +69,7 @@ jemalloc = [
    "reth-node-core/jemalloc",
 ]
 jemalloc-prof = ["reth-cli-util/jemalloc-prof"]
-tracy-allocator = ["reth-cli-util/tracy-allocator", "tracy"]
-tracy = [
-    "reth-node-core/tracy",
-    "reth-tracing/tracy",
-]
+tracy-allocator = ["reth-cli-util/tracy-allocator"]

 min-error-logs = [
    "tracing/release_max_level_error",
--- a/bin/reth-bench-compare/README.md
+++ b/bin/reth-bench-compare/README.md
@@ -1,50 +0,0 @@
-# reth-bench-compare
-
-Compare reth performance between two git references.
-
-## Usage
-
-```bash
-reth-bench-compare \
-  --baseline-ref main \
-  --feature-ref my-feature \
-  --blocks 100 \
-  --wait-for-persistence
-```
-
-## Arguments
-
-| Argument | Description | Default | Required |
-|----------|-------------|---------|----------|
-| `--baseline-ref <REF>` | Git reference for baseline | - | Yes |
-| `--feature-ref <REF>` | Git reference to compare | - | Yes |
-| `--blocks <N>` | Number of blocks to benchmark | `100` | No |
-| `--chain <CHAIN>` | Chain to benchmark | `mainnet` | No |
-| `--datadir <PATH>` | Data directory path | OS-specific | No |
-| `--rpc-url <URL>` | RPC endpoint for block data | Chain default | No |
-| `--output-dir <PATH>` | Output directory | `./reth-bench-compare` | No |
-| `--wait-for-persistence` | Wait for block persistence | `false` | No |
-| `--persistence-threshold <N>` | Wait after every N+1 blocks | `2` | No |
-| `--wait-time <DURATION>` | Fixed delay (legacy) | - | No |
-| `--warmup-blocks <N>` | Cache warmup blocks | Same as `--blocks` | No |
-| `--draw` | Generate charts (needs Python/uv) | `false` | No |
-| `--profile` | Enable CPU profiling (needs samply) | `false` | No |
-| `-vvvv` | Debug logging | Info | No |
-| `--features <FEATURES>` | Rust features for both builds | `jemalloc,asm-keccak` | No |
-| `--rustflags <FLAGS>` | RUSTFLAGS for both builds | `-C target-cpu=native` | No |
-| `--baseline-features <FEATURES>` | Features for baseline only | Inherits `--features` | No |
-| `--feature-features <FEATURES>` | Features for feature only | Inherits `--features` | No |
-| `--baseline-rustflags <FLAGS>` | RUSTFLAGS for baseline only | Inherits `--rustflags` | No |
-| `--feature-rustflags <FLAGS>` | RUSTFLAGS for feature only | Inherits `--rustflags` | No |
-| `--baseline-args <ARGS>` | Extra args for baseline node | - | No |
-| `--feature-args <ARGS>` | Extra args for feature node | - | No |
-| `--metrics-port <PORT>` | Metrics endpoint port | `5005` | No |
-| `--sudo` | Run with elevated privileges | `false` | No |
-
-## Output
-
-Results in `./reth-bench-compare/results/<timestamp>/`:
- `comparison_report.json` - Metrics comparison
- `per_block_comparison.csv` - Per-block statistics
- `baseline/` and `feature/` - Individual run results
- `latency_comparison.png` - Chart (if `--draw` used)
--- a/bin/reth-bench-compare/src/benchmark.rs
+++ b/bin/reth-bench-compare/src/benchmark.rs
@@ -18,8 +18,6 @@ pub(crate) struct BenchmarkRunner {
    rpc_url: String,
    jwt_secret: String,
    wait_time: Option<String>,
-    wait_for_persistence: bool,
-    persistence_threshold: Option<u64>,
    warmup_blocks: u64,
 }

@@ -30,8 +28,6 @@ impl BenchmarkRunner {
            rpc_url: args.get_rpc_url(),
            jwt_secret: args.jwt_secret_path().to_string_lossy().to_string(),
            wait_time: args.wait_time.clone(),
-            wait_for_persistence: args.wait_for_persistence,
-            persistence_threshold: args.persistence_threshold,
            warmup_blocks: args.get_warmup_blocks(),
        }
    }
@@ -100,9 +96,13 @@ impl BenchmarkRunner {
            &from_block.to_string(),
            "--to",
            &to_block.to_string(),
-            "--wait-time=0ms", // Warmup should avoid persistence waits.
        ]);

+        // Add wait-time argument if provided
+        if let Some(ref wait_time) = self.wait_time {
+            cmd.args(["--wait-time", wait_time]);
+        }
+
        cmd.env("RUST_LOG_STYLE", "never")
            .stdout(std::process::Stdio::piped())
            .stderr(std::process::Stdio::piped())
@@ -186,16 +186,9 @@ impl BenchmarkRunner {
            &output_dir.to_string_lossy(),
        ]);

-        // Configure wait mode: wait-time takes precedence over persistence-based flow
+        // Add wait-time argument if provided
        if let Some(ref wait_time) = self.wait_time {
            cmd.args(["--wait-time", wait_time]);
-        } else if self.wait_for_persistence {
-            cmd.arg("--wait-for-persistence");
-
-            // Add persistence threshold if specified
-            if let Some(threshold) = self.persistence_threshold {
-                cmd.args(["--persistence-threshold", &threshold.to_string()]);
-            }
        }

        cmd.env("RUST_LOG_STYLE", "never")
--- a/bin/reth-bench-compare/src/cli.rs
+++ b/bin/reth-bench-compare/src/cli.rs
@@ -114,29 +114,10 @@ pub(crate) struct Args {
    #[arg(long)]
    pub profile: bool,

-    /// Optional fixed delay between engine API calls (passed to reth-bench).
-    ///
-    /// When set, reth-bench uses wait-time mode and disables persistence-based flow.
-    /// This flag remains for compatibility with older scripts.
-    #[arg(long, value_name = "DURATION", hide = true)]
+    /// Wait time between engine API calls (passed to reth-bench)
+    #[arg(long, value_name = "DURATION")]
    pub wait_time: Option<String>,

-    /// Wait for blocks to be persisted before sending the next batch (passed to reth-bench).
-    ///
-    /// When enabled, waits for every Nth block to be persisted using the
-    /// `reth_subscribePersistedBlock` subscription. This ensures the benchmark
-    /// doesn't outpace persistence.
-    #[arg(long)]
-    pub wait_for_persistence: bool,
-
-    /// Engine persistence threshold (passed to reth-bench).
-    ///
-    /// The benchmark waits after every `(threshold + 1)` blocks. By default this
-    /// matches the engine's default persistence threshold (2), so waits occur
-    /// at blocks 3, 6, 9, etc.
-    #[arg(long, value_name = "PERSISTENCE_THRESHOLD")]
-    pub persistence_threshold: Option<u64>,
-
    /// Number of blocks to run for cache warmup after clearing caches.
    /// If not specified, defaults to the same as --blocks
    #[arg(long, value_name = "N")]
@@ -147,11 +128,6 @@ pub(crate) struct Args {
    #[arg(long)]
    pub no_clear_cache: bool,

-    /// Skip waiting for the node to sync before starting benchmarks.
-    /// When enabled, assumes the node is already synced and skips the initial tip check.
-    #[arg(long)]
-    pub skip_wait_syncing: bool,
-
    #[command(flatten)]
    pub logs: LogArgs,

@@ -536,7 +512,6 @@ async fn run_compilation_phase(
    Ok((baseline_commit, feature_commit))
 }

-#[allow(clippy::too_many_arguments)]
 /// Run warmup phase to warm up caches before benchmarking
 async fn run_warmup_phase(
    git_manager: &GitManager,
@@ -546,15 +521,9 @@ async fn run_warmup_phase(
    args: &Args,
    is_optimism: bool,
    baseline_commit: &str,
-    starting_tip: u64,
 ) -> Result<()> {
    info!("=== Running warmup phase ===");

-    // Unwind to starting block minus warmup blocks, so we end up back at starting_tip
-    let warmup_blocks = args.get_warmup_blocks();
-    let unwind_target = starting_tip.saturating_sub(warmup_blocks);
-    node_manager.unwind_to_block(unwind_target).await?;
-
    // Use baseline for warmup
    let warmup_ref = &args.baseline_ref;

@@ -583,13 +552,12 @@ async fn run_warmup_phase(
        node_manager.start_node(&binary_path, warmup_ref, "warmup", &additional_args).await?;

    // Wait for node to be ready and get its current tip
-    let current_tip = if args.skip_wait_syncing {
-        node_manager.wait_for_rpc_and_get_tip(&mut node_process).await?
-    } else {
-        node_manager.wait_for_node_ready_and_get_tip(&mut node_process).await?
-    };
+    let current_tip = node_manager.wait_for_node_ready_and_get_tip().await?;
    info!("Warmup node is ready at tip: {}", current_tip);

+    // Store the tip we'll unwind back to
+    let original_tip = current_tip;
+
    // Clear filesystem caches before warmup run only (unless disabled)
    if args.no_clear_cache {
        info!("Skipping filesystem cache clearing (--no-clear-cache flag set)");
@@ -600,9 +568,12 @@ async fn run_warmup_phase(
    // Run warmup to warm up caches
    benchmark_runner.run_warmup(current_tip).await?;

-    // Stop node after warmup
+    // Stop node before unwinding (node must be stopped to release database lock)
    node_manager.stop_node(&mut node_process).await?;

+    // Unwind back to starting block after warmup
+    node_manager.unwind_to_block(original_tip).await?;
+
    info!("Warmup phase completed");
    Ok(())
 }
@@ -624,31 +595,6 @@ async fn run_benchmark_workflow(
    let (baseline_commit, feature_commit) =
        run_compilation_phase(git_manager, compilation_manager, args, is_optimism).await?;

-    // Switch to baseline reference and get the starting tip
-    git_manager.switch_ref(&args.baseline_ref)?;
-    let binary_path =
-        compilation_manager.get_cached_binary_path_for_commit(&baseline_commit, is_optimism);
-    if !binary_path.exists() {
-        return Err(eyre!(
-            "Cached baseline binary not found at {:?}. Compilation phase should have created it.",
-            binary_path
-        ));
-    }
-
-    // Start node briefly to get the current tip, then stop it
-    info!("=== Determining initial block height ===");
-    let additional_args = args.build_additional_args("baseline", args.baseline_args.as_ref());
-    let (mut node_process, _) = node_manager
-        .start_node(&binary_path, &args.baseline_ref, "baseline", &additional_args)
-        .await?;
-    let starting_tip = if args.skip_wait_syncing {
-        node_manager.wait_for_rpc_and_get_tip(&mut node_process).await?
-    } else {
-        node_manager.wait_for_node_ready_and_get_tip(&mut node_process).await?
-    };
-    info!("Node starting tip: {}", starting_tip);
-    node_manager.stop_node(&mut node_process).await?;
-
    // Run warmup phase before benchmarking (skip if warmup_blocks is 0)
    if args.get_warmup_blocks() > 0 {
        run_warmup_phase(
@@ -659,7 +605,6 @@ async fn run_benchmark_workflow(
            args,
            is_optimism,
            &baseline_commit,
-            starting_tip,
        )
        .await?;
    } else {
@@ -675,10 +620,6 @@ async fn run_benchmark_workflow(
        let commit = commits[i];
        info!("=== Processing {} reference: {} ===", ref_type, git_ref);

-        // Unwind to starting block minus benchmark blocks, so we end up back at starting_tip
-        let unwind_target = starting_tip.saturating_sub(args.blocks);
-        node_manager.unwind_to_block(unwind_target).await?;
-
        // Switch to target reference
        git_manager.switch_ref(git_ref)?;

@@ -712,18 +653,17 @@ async fn run_benchmark_workflow(
            node_manager.start_node(&binary_path, git_ref, ref_type, &additional_args).await?;

        // Wait for node to be ready and get its current tip (wherever it is)
-        let current_tip = if args.skip_wait_syncing {
-            node_manager.wait_for_rpc_and_get_tip(&mut node_process).await?
-        } else {
-            node_manager.wait_for_node_ready_and_get_tip(&mut node_process).await?
-        };
+        let current_tip = node_manager.wait_for_node_ready_and_get_tip().await?;
        info!("Node is ready at tip: {}", current_tip);

+        // Store the tip we'll unwind back to
+        let original_tip = current_tip;
+
        // Calculate benchmark range
        // Note: reth-bench has an off-by-one error where it consumes the first block
        // of the range, so we add 1 to compensate and get exactly args.blocks blocks
-        let from_block = current_tip;
-        let to_block = current_tip + args.blocks;
+        let from_block = original_tip;
+        let to_block = original_tip + args.blocks;

        // Run benchmark
        let output_dir = comparison_generator.get_ref_output_dir(ref_type);
@@ -740,6 +680,9 @@ async fn run_benchmark_workflow(
        // Stop node
        node_manager.stop_node(&mut node_process).await?;

+        // Unwind back to original tip
+        node_manager.unwind_to_block(original_tip).await?;
+
        // Store results for comparison
        comparison_generator.add_ref_results(ref_type, &output_dir)?;

--- a/bin/reth-bench-compare/src/comparison.rs
+++ b/bin/reth-bench-compare/src/comparison.rs
@@ -99,7 +99,6 @@ pub(crate) struct RefInfo {
 /// Summary of the comparison between references.
 ///
 /// Percent deltas are `(feature - baseline) / baseline * 100`:
-/// - `new_payload_latency_mean_change_percent`: percent changes of the per-block means.
 /// - `new_payload_latency_p50_change_percent` / p90 / p99: percent changes of the respective
 ///   per-block percentiles.
 /// - `per_block_latency_change_mean_percent` / `per_block_latency_change_median_percent` are the
@@ -117,7 +116,6 @@ pub(crate) struct ComparisonSummary {
    pub per_block_latency_change_median_percent: f64,
    pub per_block_latency_change_std_dev_percent: f64,
    pub new_payload_total_latency_change_percent: f64,
-    pub new_payload_latency_mean_change_percent: f64,
    pub new_payload_latency_p50_change_percent: f64,
    pub new_payload_latency_p90_change_percent: f64,
    pub new_payload_latency_p99_change_percent: f64,
@@ -447,10 +445,6 @@ impl ComparisonGenerator {
            per_block_latency_change_median_percent,
            per_block_latency_change_std_dev_percent,
            new_payload_total_latency_change_percent,
-            new_payload_latency_mean_change_percent: calc_percent_change(
-                baseline.mean_new_payload_latency_ms,
-                feature.mean_new_payload_latency_ms,
-            ),
            new_payload_latency_p50_change_percent: calc_percent_change(
                baseline.median_new_payload_latency_ms,
                feature.median_new_payload_latency_ms,
@@ -581,10 +575,6 @@ impl ComparisonGenerator {
            "  Total newPayload time change:                {:+.2}%",
            summary.new_payload_total_latency_change_percent
        );
-        println!(
-            "  NewPayload Latency mean:           {:+.2}%",
-            summary.new_payload_latency_mean_change_percent
-        );
        println!(
            "  NewPayload Latency p50:           {:+.2}%",
            summary.new_payload_latency_p50_change_percent
--- a/bin/reth-bench-compare/src/compilation.rs
+++ b/bin/reth-bench-compare/src/compilation.rs
@@ -121,7 +121,8 @@ impl CompilationManager {
        cmd.env("RUSTFLAGS", rustflags);
        info!("Using RUSTFLAGS: {rustflags}");

-        info!("Compiling {binary_name} with {cmd:?}");
+        // Debug log the command
+        debug!("Executing cargo command: {:?}", cmd);

        let output = cmd.output().wrap_err("Failed to execute cargo build command")?;

@@ -230,7 +231,8 @@ impl CompilationManager {
        let mut cmd = Command::new("cargo");
        cmd.args(["install", "--locked", "samply"]);

-        info!("Installing samply with {cmd:?}");
+        // Debug log the command
+        debug!("Executing cargo command: {:?}", cmd);

        let output = cmd.output().wrap_err("Failed to execute cargo install samply command")?;

@@ -305,7 +307,8 @@ impl CompilationManager {
        let mut cmd = Command::new("make");
        cmd.arg("install-reth-bench").current_dir(&self.repo_root);

-        info!("Compiling reth-bench with {cmd:?}");
+        // Debug log the command
+        debug!("Executing make command: {:?}", cmd);

        let output = cmd.output().wrap_err("Failed to execute make install-reth-bench command")?;

--- a/bin/reth-bench-compare/src/node.rs
+++ b/bin/reth-bench-compare/src/node.rs
@@ -2,9 +2,7 @@

 use crate::cli::Args;
 use alloy_provider::{Provider, ProviderBuilder};
-use alloy_rpc_client::RpcClient;
 use alloy_rpc_types_eth::SyncStatus;
-use alloy_transport_ws::WsConnect;
 use eyre::{eyre, OptionExt, Result, WrapErr};
 #[cfg(unix)]
 use nix::sys::signal::{killpg, Signal};
@@ -20,9 +18,6 @@ use tokio::{
 };
 use tracing::{debug, info, warn};

-/// Default websocket RPC port used by reth
-const DEFAULT_WS_RPC_PORT: u16 = 8546;
-
 /// Manages reth node lifecycle and operations
 pub(crate) struct NodeManager {
    datadir: Option<String>,
@@ -157,13 +152,9 @@ impl NodeManager {
            metrics_arg,
            "--http".to_string(),
            "--http.api".to_string(),
-            "eth,reth".to_string(),
-            "--ws".to_string(),
-            "--ws.api".to_string(),
-            "eth,reth".to_string(),
+            "eth".to_string(),
            "--disable-discovery".to_string(),
            "--trusted-only".to_string(),
-            "--disable-tx-gossip".to_string(),
        ]);

        // Add tracing arguments if OTLP endpoint is configured
@@ -368,13 +359,8 @@ impl NodeManager {
        Ok((child, reth_command))
    }

-    /// Wait for the node to be ready and return its current tip.
-    ///
-    /// Fails early if the node process exits before becoming ready.
-    pub(crate) async fn wait_for_node_ready_and_get_tip(
-        &self,
-        child: &mut tokio::process::Child,
-    ) -> Result<u64> {
+    /// Wait for the node to be ready and return its current tip
+    pub(crate) async fn wait_for_node_ready_and_get_tip(&self) -> Result<u64> {
        info!("Waiting for node to be ready and synced...");

        let max_wait = Duration::from_secs(120); // 2 minutes to allow for sync
@@ -385,23 +371,8 @@ impl NodeManager {
        let url = rpc_url.parse().map_err(|e| eyre!("Invalid RPC URL '{}': {}", rpc_url, e))?;
        let provider = ProviderBuilder::new().connect_http(url);

-        let start_time = tokio::time::Instant::now();
-        let mut iteration = 0;
-
        timeout(max_wait, async {
            loop {
-                iteration += 1;
-                debug!(
-                    "Readiness check iteration {} (elapsed: {:?})",
-                    iteration,
-                    start_time.elapsed()
-                );
-
-                // Check if the node process has exited.
-                if let Some(status) = child.try_wait()? {
-                    return Err(eyre!("Node process exited unexpectedly with {status}"));
-                }
-
                // First check if RPC is up and node is not syncing
                match provider.syncing().await {
                    Ok(sync_result) => {
@@ -410,48 +381,24 @@ impl NodeManager {
                                debug!("Node is still syncing {sync_info:?}, waiting...");
                            }
                            _ => {
-                                debug!("HTTP RPC is up and node is not syncing, checking block number...");
                                // Node is not syncing, now get the tip
                                match provider.get_block_number().await {
                                    Ok(tip) => {
-                                        debug!("HTTP RPC ready at block: {}, checking WebSocket...", tip);
-
-                                        // Verify WebSocket RPC is ready (public endpoint, no JWT required)
-                                        let ws_url = format!("ws://localhost:{}", DEFAULT_WS_RPC_PORT);
-                                        debug!("Attempting WebSocket connection to {} (public endpoint)", ws_url);
-                                        let ws_connect = WsConnect::new(&ws_url);
-
-                                        match RpcClient::connect_pubsub(ws_connect).await
-                                        {
-                                            Ok(_) => {
-                                                info!(
-                                                    "Node is ready (HTTP and WebSocket) at block: {} (took {:?}, {} iterations)",
-                                                    tip, start_time.elapsed(), iteration
-                                                );
-                                                return Ok(tip);
-                                            }
-                                            Err(e) => {
-                                                debug!(
-                                                    "HTTP RPC ready but WebSocket not ready yet (iteration {}): {:?}",
-                                                    iteration, e
-                                                );
-                                                debug!("WebSocket error details: {}", e);
-                                            }
-                                        }
+                                        info!("Node is ready and not syncing at block: {}", tip);
+                                        return Ok(tip);
                                    }
                                    Err(e) => {
-                                        debug!("Failed to get block number (iteration {}): {:?}", iteration, e);
+                                        debug!("Failed to get block number: {}", e);
                                    }
                                }
                            }
                        }
                    }
                    Err(e) => {
-                        debug!("Node RPC not ready yet or failed to check sync status (iteration {}): {:?}", iteration, e);
+                        debug!("Node RPC not ready yet or failed to check sync status: {}", e);
                    }
                }

-                debug!("Sleeping for {:?} before next check", check_interval);
                sleep(check_interval).await;
            }
        })
@@ -459,76 +406,6 @@ impl NodeManager {
        .wrap_err("Timed out waiting for node to be ready and synced")?
    }

-    /// Wait for the node RPC to be ready and return its current tip, without waiting for sync.
-    ///
-    /// This is faster than `wait_for_node_ready_and_get_tip` but may return a tip while
-    /// the node is still syncing.
-    pub(crate) async fn wait_for_rpc_and_get_tip(
-        &self,
-        child: &mut tokio::process::Child,
-    ) -> Result<u64> {
-        info!("Waiting for node RPC to be ready (skipping sync wait)...");
-
-        let max_wait = Duration::from_secs(60);
-        let check_interval = Duration::from_secs(2);
-        let rpc_url = "http://localhost:8545";
-
-        let url = rpc_url.parse().map_err(|e| eyre!("Invalid RPC URL '{}': {}", rpc_url, e))?;
-        let provider = ProviderBuilder::new().connect_http(url);
-
-        let start_time = tokio::time::Instant::now();
-        let mut iteration = 0;
-
-        timeout(max_wait, async {
-            loop {
-                iteration += 1;
-                debug!(
-                    "RPC readiness check iteration {} (elapsed: {:?})",
-                    iteration,
-                    start_time.elapsed()
-                );
-
-                if let Some(status) = child.try_wait()? {
-                    return Err(eyre!("Node process exited unexpectedly with {status}"));
-                }
-
-                match provider.get_block_number().await {
-                    Ok(tip) => {
-                        debug!("HTTP RPC ready at block: {}, checking WebSocket...", tip);
-
-                        let ws_url = format!("ws://localhost:{}", DEFAULT_WS_RPC_PORT);
-                        let ws_connect = WsConnect::new(&ws_url);
-
-                        match RpcClient::connect_pubsub(ws_connect).await {
-                            Ok(_) => {
-                                info!(
-                                    "Node RPC is ready at block: {} (took {:?}, {} iterations)",
-                                    tip,
-                                    start_time.elapsed(),
-                                    iteration
-                                );
-                                return Ok(tip);
-                            }
-                            Err(e) => {
-                                debug!(
-                                    "HTTP RPC ready but WebSocket not ready yet (iteration {}): {:?}",
-                                    iteration, e
-                                );
-                            }
-                        }
-                    }
-                    Err(e) => {
-                        debug!("RPC not ready yet (iteration {}): {:?}", iteration, e);
-                    }
-                }
-
-                sleep(check_interval).await;
-            }
-        })
-        .await
-        .wrap_err("Timed out waiting for node RPC to be ready")?
-    }
-
    /// Stop the reth node gracefully
    pub(crate) async fn stop_node(&self, child: &mut tokio::process::Child) -> Result<()> {
        let pid = child.id().ok_or_eyre("Child process ID should be available")?;
--- a/bin/reth-bench/Cargo.toml
+++ b/bin/reth-bench/Cargo.toml
@@ -16,27 +16,20 @@ workspace = true
 # reth
 reth-cli-runner.workspace = true
 reth-cli-util.workspace = true
-reth-engine-primitives.workspace = true
-reth-ethereum-primitives.workspace = true
 reth-fs-util.workspace = true
 reth-node-api.workspace = true
 reth-node-core.workspace = true
 reth-primitives-traits.workspace = true
-reth-rpc-api.workspace = true
-
 reth-tracing.workspace = true
-reth-chainspec.workspace = true

 # alloy
 alloy-eips.workspace = true
 alloy-json-rpc.workspace = true
-alloy-consensus.workspace = true
-alloy-network.workspace = true
 alloy-primitives.workspace = true
-alloy-provider = { workspace = true, features = ["engine-api", "pubsub", "reqwest-rustls-tls"], default-features = false }
+alloy-provider = { workspace = true, features = ["engine-api", "reqwest-rustls-tls"], default-features = false }
 alloy-pubsub.workspace = true
-alloy-rpc-client = { workspace = true, features = ["pubsub"] }
-alloy-rpc-types-engine = { workspace = true, features = ["kzg"] }
+alloy-rpc-client.workspace = true
+alloy-rpc-types-engine.workspace = true
 alloy-transport-http.workspace = true
 alloy-transport-ipc.workspace = true
 alloy-transport-ws.workspace = true
@@ -57,9 +50,6 @@ tracing.workspace = true
 serde.workspace = true
 serde_json.workspace = true

-# url parsing
-url.workspace = true
-
 # async
 async-trait.workspace = true
 futures.workspace = true
@@ -90,11 +80,7 @@ jemalloc = [
    "reth-node-core/jemalloc",
 ]
 jemalloc-prof = ["reth-cli-util/jemalloc-prof"]
-tracy-allocator = ["reth-cli-util/tracy-allocator", "tracy"]
-tracy = [
-    "reth-node-core/tracy",
-    "reth-tracing/tracy",
-]
+tracy-allocator = ["reth-cli-util/tracy-allocator"]

 min-error-logs = [
    "tracing/release_max_level_error",
--- a/bin/reth-bench/README.md
+++ b/bin/reth-bench/README.md
@@ -31,14 +31,6 @@ Otherwise, running `make maxperf` at the root of the repo should be sufficient f
 `reth-bench` contains different commands to benchmark different patterns of engine API calls.
 The `reth-bench new-payload-fcu` command is the most representative of ethereum mainnet live sync, alternating between sending `engine_newPayload` calls and `engine_forkchoiceUpdated` calls.

-The `new-payload-fcu` command supports two optional waiting modes that can be used together or independently:
- `--wait-time <duration>`: Fixed sleep interval between blocks (e.g., `--wait-time 100ms`)
- `--wait-for-persistence`: Waits for blocks to be persisted using the `reth_subscribePersistedBlock` subscription
-
-When using `--wait-for-persistence`, the benchmark waits after every `(threshold + 1)` blocks, where the threshold defaults to the engine's persistence threshold (2). This can be customized with `--persistence-threshold <N>`.
-
-By default, the WebSocket URL for persistence subscriptions is derived from `--engine-rpc-url` (converting to ws:// on port 8546). Use `--ws-rpc-url` to override this.
-
 Below is an overview of how to run a benchmark:

 ### Setup
--- a/bin/reth-bench/src/authenticated_transport.rs
+++ b/bin/reth-bench/src/authenticated_transport.rs
@@ -163,7 +163,7 @@ impl AuthenticatedTransport {

            // shift the iat forward by one second so there is some buffer time
            let mut shifted_claims = inner_and_claims.1;
-            shifted_claims.iat -= 30;
+            shifted_claims.iat -= 1;

            // if the claims are out of date, reset the inner transport
            if !shifted_claims.is_within_time_window() {
--- a/bin/reth-bench/src/bench/gas_limit_ramp.rs
+++ b/bin/reth-bench/src/bench/gas_limit_ramp.rs
@@ -1,160 +0,0 @@
-//! Benchmarks empty block processing by ramping the block gas limit.
-
-use crate::{
-    authenticated_transport::AuthenticatedTransportConnect,
-    bench::{
-        helpers::{build_payload, prepare_payload_request, rpc_block_to_header},
-        output::GasRampPayloadFile,
-    },
-    valid_payload::{call_forkchoice_updated, call_new_payload, payload_to_new_payload},
-};
-use alloy_eips::BlockNumberOrTag;
-use alloy_provider::{network::AnyNetwork, Provider, RootProvider};
-use alloy_rpc_client::ClientBuilder;
-use alloy_rpc_types_engine::{ExecutionPayload, ForkchoiceState, JwtSecret};
-
-use clap::Parser;
-use reqwest::Url;
-use reth_chainspec::ChainSpec;
-use reth_cli_runner::CliContext;
-use reth_ethereum_primitives::TransactionSigned;
-use reth_primitives_traits::constants::{GAS_LIMIT_BOUND_DIVISOR, MAXIMUM_GAS_LIMIT_BLOCK};
-use std::{path::PathBuf, time::Instant};
-use tracing::info;
-
-/// `reth benchmark gas-limit-ramp` command.
-#[derive(Debug, Parser)]
-pub struct Command {
-    /// Number of blocks to generate.
-    #[arg(long, value_name = "BLOCKS")]
-    blocks: u64,
-
-    /// The Engine API RPC URL.
-    #[arg(long = "engine-rpc-url", value_name = "ENGINE_RPC_URL")]
-    engine_rpc_url: String,
-
-    /// Path to the JWT secret for Engine API authentication.
-    #[arg(long = "jwt-secret", value_name = "JWT_SECRET")]
-    jwt_secret: PathBuf,
-
-    /// Output directory for benchmark results and generated payloads.
-    #[arg(long, value_name = "OUTPUT")]
-    output: PathBuf,
-}
-
-impl Command {
-    /// Execute `benchmark gas-limit-ramp` command.
-    pub async fn execute(self, _ctx: CliContext) -> eyre::Result<()> {
-        if self.blocks == 0 {
-            return Err(eyre::eyre!("--blocks must be greater than 0"));
-        }
-
-        // Ensure output directory exists
-        if self.output.is_file() {
-            return Err(eyre::eyre!("Output path must be a directory"));
-        }
-        if !self.output.exists() {
-            std::fs::create_dir_all(&self.output)?;
-            info!("Created output directory: {:?}", self.output);
-        }
-
-        // Set up authenticated provider (used for both Engine API and eth_ methods)
-        let jwt = std::fs::read_to_string(&self.jwt_secret)?;
-        let jwt = JwtSecret::from_hex(jwt)?;
-        let auth_url = Url::parse(&self.engine_rpc_url)?;
-
-        info!("Connecting to Engine RPC at {}", auth_url);
-        let auth_transport = AuthenticatedTransportConnect::new(auth_url, jwt);
-        let client = ClientBuilder::default().connect_with(auth_transport).await?;
-        let provider = RootProvider::<AnyNetwork>::new(client);
-
-        // Get chain spec - required for fork detection
-        let chain_id = provider.get_chain_id().await?;
-        let chain_spec = ChainSpec::from_chain_id(chain_id)
-            .ok_or_else(|| eyre::eyre!("Unsupported chain id: {chain_id}"))?;
-
-        // Fetch the current head block as parent
-        let parent_block = provider
-            .get_block_by_number(BlockNumberOrTag::Latest)
-            .full()
-            .await?
-            .ok_or_else(|| eyre::eyre!("Failed to fetch latest block"))?;
-
-        let (mut parent_header, mut parent_hash) = rpc_block_to_header(parent_block);
-
-        let canonical_parent = parent_header.number;
-        let start_block = canonical_parent + 1;
-        let end_block = start_block + self.blocks - 1;
-
-        info!(canonical_parent, start_block, end_block, "Starting gas limit ramp benchmark");
-
-        let mut next_block_number = start_block;
-        let total_benchmark_duration = Instant::now();
-
-        while next_block_number <= end_block {
-            let timestamp = parent_header.timestamp.saturating_add(1);
-
-            let request = prepare_payload_request(&chain_spec, timestamp, parent_hash);
-            let new_payload_version = request.new_payload_version;
-
-            let (payload, sidecar) = build_payload(&provider, request).await?;
-
-            let mut block =
-                payload.clone().try_into_block_with_sidecar::<TransactionSigned>(&sidecar)?;
-
-            let max_increase = max_gas_limit_increase(parent_header.gas_limit);
-            let gas_limit =
-                parent_header.gas_limit.saturating_add(max_increase).min(MAXIMUM_GAS_LIMIT_BLOCK);
-
-            block.header.gas_limit = gas_limit;
-
-            let block_hash = block.header.hash_slow();
-            // 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(
-                payload,
-                sidecar,
-                false,
-                block.header.withdrawals_root,
-                Some(new_payload_version),
-            )?;
-
-            // 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 payload_json = serde_json::to_string_pretty(&file)?;
-            std::fs::write(&payload_path, &payload_json)?;
-            info!(block_number = block.header.number, path = %payload_path.display(), "Saved payload");
-
-            call_new_payload(&provider, version, params).await?;
-
-            let forkchoice_state = ForkchoiceState {
-                head_block_hash: block_hash,
-                safe_block_hash: block_hash,
-                finalized_block_hash: block_hash,
-            };
-            call_forkchoice_updated(&provider, version, forkchoice_state, None).await?;
-
-            parent_header = block.header;
-            parent_hash = block_hash;
-            next_block_number += 1;
-        }
-
-        let final_gas_limit = parent_header.gas_limit;
-        info!(
-            total_duration=?total_benchmark_duration.elapsed(),
-            blocks_processed = self.blocks,
-            final_gas_limit,
-            "Benchmark complete"
-        );
-
-        Ok(())
-    }
-}
-
-const fn max_gas_limit_increase(parent_gas_limit: u64) -> u64 {
-    (parent_gas_limit / GAS_LIMIT_BOUND_DIVISOR).saturating_sub(1)
-}
--- a/bin/reth-bench/src/bench/generate_big_block.rs
+++ b/bin/reth-bench/src/bench/generate_big_block.rs
@@ -1,617 +0,0 @@
-//! Command for generating large blocks by packing transactions from real blocks.
-//!
-//! This command fetches transactions from existing blocks and packs them into a single
-//! large block using the `testing_buildBlockV1` RPC endpoint.
-
-use crate::authenticated_transport::AuthenticatedTransportConnect;
-use alloy_eips::{BlockNumberOrTag, Typed2718};
-use alloy_primitives::{Bytes, B256};
-use alloy_provider::{ext::EngineApi, network::AnyNetwork, Provider, RootProvider};
-use alloy_rpc_client::ClientBuilder;
-use alloy_rpc_types_engine::{
-    ExecutionPayloadEnvelopeV4, ExecutionPayloadEnvelopeV5, ForkchoiceState, JwtSecret,
-    PayloadAttributes,
-};
-use alloy_transport::layers::RetryBackoffLayer;
-use clap::Parser;
-use eyre::Context;
-use reqwest::Url;
-use reth_cli_runner::CliContext;
-use reth_rpc_api::TestingBuildBlockRequestV1;
-use std::future::Future;
-use tokio::sync::mpsc;
-use tracing::{info, warn};
-
-/// A single transaction with its gas used and raw encoded bytes.
-#[derive(Debug, Clone)]
-pub struct RawTransaction {
-    /// The actual gas used by the transaction (from receipt).
-    pub gas_used: u64,
-    /// The transaction type (e.g., 3 for EIP-4844 blob txs).
-    pub tx_type: u8,
-    /// The raw RLP-encoded transaction bytes.
-    pub raw: Bytes,
-}
-
-/// Abstraction over sources of transactions for big block generation.
-///
-/// Implementors provide transactions from different sources (RPC, database, files, etc.)
-pub trait TransactionSource {
-    /// Fetch transactions from a specific block number.
-    ///
-    /// Returns `Ok(None)` if the block doesn't exist.
-    /// Returns `Ok(Some((transactions, gas_used)))` with the block's transactions and total gas.
-    fn fetch_block_transactions(
-        &self,
-        block_number: u64,
-    ) -> impl Future<Output = eyre::Result<Option<(Vec<RawTransaction>, u64)>>> + Send;
-}
-
-/// RPC-based transaction source that fetches from a remote node.
-#[derive(Debug)]
-pub struct RpcTransactionSource {
-    provider: RootProvider<AnyNetwork>,
-}
-
-impl RpcTransactionSource {
-    /// Create a new RPC transaction source.
-    pub const fn new(provider: RootProvider<AnyNetwork>) -> Self {
-        Self { provider }
-    }
-
-    /// Create from an RPC URL with retry backoff.
-    pub fn from_url(rpc_url: &str) -> eyre::Result<Self> {
-        let client = ClientBuilder::default()
-            .layer(RetryBackoffLayer::new(10, 800, u64::MAX))
-            .http(rpc_url.parse()?);
-        let provider = RootProvider::<AnyNetwork>::new(client);
-        Ok(Self { provider })
-    }
-}
-
-impl TransactionSource for RpcTransactionSource {
-    async fn fetch_block_transactions(
-        &self,
-        block_number: u64,
-    ) -> eyre::Result<Option<(Vec<RawTransaction>, u64)>> {
-        // Fetch block and receipts in parallel
-        let (block, receipts) = tokio::try_join!(
-            self.provider.get_block_by_number(block_number.into()).full(),
-            self.provider.get_block_receipts(block_number.into())
-        )?;
-
-        let Some(block) = block else {
-            return Ok(None);
-        };
-
-        let Some(receipts) = receipts else {
-            return Err(eyre::eyre!("Receipts not found for block {}", block_number));
-        };
-
-        let block_gas_used = block.header.gas_used;
-
-        // Convert cumulative gas from receipts to per-tx gas_used
-        let mut prev_cumulative = 0u64;
-        let transactions: Vec<RawTransaction> = block
-            .transactions
-            .txns()
-            .zip(receipts.iter())
-            .map(|(tx, receipt)| {
-                let cumulative = receipt.inner.inner.inner.receipt.cumulative_gas_used;
-                let gas_used = cumulative - prev_cumulative;
-                prev_cumulative = cumulative;
-
-                let with_encoded = tx.inner.inner.clone().into_encoded();
-                RawTransaction {
-                    gas_used,
-                    tx_type: tx.inner.ty(),
-                    raw: with_encoded.encoded_bytes().clone(),
-                }
-            })
-            .collect();
-
-        Ok(Some((transactions, block_gas_used)))
-    }
-}
-
-/// Collects transactions from a source up to a target gas usage.
-#[derive(Debug)]
-pub struct TransactionCollector<S> {
-    source: S,
-    target_gas: u64,
-}
-
-impl<S: TransactionSource> TransactionCollector<S> {
-    /// Create a new transaction collector.
-    pub const fn new(source: S, target_gas: u64) -> Self {
-        Self { source, target_gas }
-    }
-
-    /// Collect transactions starting from the given block number.
-    ///
-    /// Skips blob transactions (type 3) and collects until target gas is reached.
-    /// Returns the collected raw transaction bytes, total gas used, and the next block number.
-    pub async fn collect(&self, start_block: u64) -> eyre::Result<(Vec<Bytes>, u64, u64)> {
-        let mut transactions: Vec<Bytes> = Vec::new();
-        let mut total_gas: u64 = 0;
-        let mut current_block = start_block;
-
-        while total_gas < self.target_gas {
-            let Some((block_txs, _)) = self.source.fetch_block_transactions(current_block).await?
-            else {
-                warn!(block = current_block, "Block not found, stopping");
-                break;
-            };
-
-            for tx in block_txs {
-                // Skip blob transactions (EIP-4844, type 3)
-                if tx.tx_type == 3 {
-                    continue;
-                }
-
-                if total_gas + tx.gas_used <= self.target_gas {
-                    transactions.push(tx.raw);
-                    total_gas += tx.gas_used;
-                }
-
-                if total_gas >= self.target_gas {
-                    break;
-                }
-            }
-
-            current_block += 1;
-
-            // Stop early if remaining gas is under 1M (close enough to target)
-            let remaining_gas = self.target_gas.saturating_sub(total_gas);
-            if remaining_gas < 1_000_000 {
-                break;
-            }
-        }
-
-        info!(
-            total_txs = transactions.len(),
-            total_gas,
-            next_block = current_block,
-            "Finished collecting transactions"
-        );
-
-        Ok((transactions, total_gas, current_block))
-    }
-}
-
-/// `reth bench generate-big-block` command
-///
-/// Generates a large block by fetching transactions from existing blocks and packing them
-/// into a single block using the `testing_buildBlockV1` RPC endpoint.
-#[derive(Debug, Parser)]
-pub struct Command {
-    /// The RPC URL to use for fetching blocks (can be an external archive node).
-    #[arg(long, value_name = "RPC_URL")]
-    rpc_url: String,
-
-    /// The engine RPC URL (with JWT authentication).
-    #[arg(long, value_name = "ENGINE_RPC_URL", default_value = "http://localhost:8551")]
-    engine_rpc_url: String,
-
-    /// The RPC URL for `testing_buildBlockV1` calls (same node as engine, regular RPC port).
-    #[arg(long, value_name = "TESTING_RPC_URL", default_value = "http://localhost:8545")]
-    testing_rpc_url: String,
-
-    /// Path to the JWT secret file for engine API authentication.
-    #[arg(long, value_name = "JWT_SECRET")]
-    jwt_secret: std::path::PathBuf,
-
-    /// Target gas to pack into the block.
-    #[arg(long, value_name = "TARGET_GAS", default_value = "30000000")]
-    target_gas: u64,
-
-    /// Starting block number to fetch transactions from.
-    /// If not specified, starts from the engine's latest block.
-    #[arg(long, value_name = "FROM_BLOCK")]
-    from_block: Option<u64>,
-
-    /// Execute the payload (call newPayload + forkchoiceUpdated).
-    /// If false, only builds the payload and prints it.
-    #[arg(long, default_value = "false")]
-    execute: bool,
-
-    /// Number of payloads to generate. Each payload uses the previous as parent.
-    /// When count == 1, the payload is only generated and saved, not executed.
-    /// When count > 1, each payload is executed before building the next.
-    #[arg(long, default_value = "1")]
-    count: u64,
-
-    /// Number of transaction batches to prefetch in background when count > 1.
-    /// Higher values reduce latency but use more memory.
-    #[arg(long, default_value = "4")]
-    prefetch_buffer: usize,
-
-    /// Output directory for generated payloads. Each payload is saved as `payload_block_N.json`.
-    #[arg(long, value_name = "OUTPUT_DIR")]
-    output_dir: std::path::PathBuf,
-}
-
-/// A built payload ready for execution.
-struct BuiltPayload {
-    block_number: u64,
-    envelope: ExecutionPayloadEnvelopeV4,
-    block_hash: B256,
-    timestamp: u64,
-}
-
-impl Command {
-    /// Execute the `generate-big-block` command
-    pub async fn execute(self, _ctx: CliContext) -> eyre::Result<()> {
-        info!(target_gas = self.target_gas, count = self.count, "Generating big block(s)");
-
-        // Set up authenticated engine provider
-        let jwt =
-            std::fs::read_to_string(&self.jwt_secret).wrap_err("Failed to read JWT secret file")?;
-        let jwt = JwtSecret::from_hex(jwt.trim())?;
-        let auth_url = Url::parse(&self.engine_rpc_url)?;
-
-        info!("Connecting to Engine RPC at {}", auth_url);
-        let auth_transport = AuthenticatedTransportConnect::new(auth_url.clone(), jwt);
-        let auth_client = ClientBuilder::default().connect_with(auth_transport).await?;
-        let auth_provider = RootProvider::<AnyNetwork>::new(auth_client);
-
-        // Set up testing RPC provider (for testing_buildBlockV1)
-        info!("Connecting to Testing RPC at {}", self.testing_rpc_url);
-        let testing_client = ClientBuilder::default()
-            .layer(RetryBackoffLayer::new(10, 800, u64::MAX))
-            .http(self.testing_rpc_url.parse()?);
-        let testing_provider = RootProvider::<AnyNetwork>::new(testing_client);
-
-        // Get the parent block (latest canonical block)
-        info!(endpoint = "engine", method = "eth_getBlockByNumber", block = "latest", "RPC call");
-        let parent_block = auth_provider
-            .get_block_by_number(BlockNumberOrTag::Latest)
-            .await?
-            .ok_or_else(|| eyre::eyre!("Failed to fetch latest block"))?;
-
-        let parent_hash = parent_block.header.hash;
-        let parent_number = parent_block.header.number;
-        let parent_timestamp = parent_block.header.timestamp;
-
-        info!(
-            parent_hash = %parent_hash,
-            parent_number = parent_number,
-            "Using initial parent block"
-        );
-
-        // Create output directory
-        std::fs::create_dir_all(&self.output_dir).wrap_err_with(|| {
-            format!("Failed to create output directory: {:?}", self.output_dir)
-        })?;
-
-        let start_block = self.from_block.unwrap_or(parent_number);
-
-        // Use pipelined execution when generating multiple payloads
-        if self.count > 1 {
-            self.execute_pipelined(
-                &auth_provider,
-                &testing_provider,
-                start_block,
-                parent_hash,
-                parent_timestamp,
-            )
-            .await?;
-        } else {
-            // Single payload - collect transactions and build
-            let tx_source = RpcTransactionSource::from_url(&self.rpc_url)?;
-            let collector = TransactionCollector::new(tx_source, self.target_gas);
-            let (transactions, _total_gas, _next_block) = collector.collect(start_block).await?;
-
-            if transactions.is_empty() {
-                return Err(eyre::eyre!("No transactions collected"));
-            }
-
-            self.execute_sequential(
-                &auth_provider,
-                &testing_provider,
-                transactions,
-                parent_hash,
-                parent_timestamp,
-            )
-            .await?;
-        }
-
-        info!(count = self.count, output_dir = %self.output_dir.display(), "All payloads generated");
-        Ok(())
-    }
-
-    /// Sequential execution path for single payload or no-execute mode.
-    async fn execute_sequential(
-        &self,
-        auth_provider: &RootProvider<AnyNetwork>,
-        testing_provider: &RootProvider<AnyNetwork>,
-        transactions: Vec<Bytes>,
-        mut parent_hash: B256,
-        mut parent_timestamp: u64,
-    ) -> eyre::Result<()> {
-        for i in 0..self.count {
-            info!(
-                payload = i + 1,
-                total = self.count,
-                parent_hash = %parent_hash,
-                parent_timestamp = parent_timestamp,
-                "Building payload via testing_buildBlockV1"
-            );
-
-            let built = self
-                .build_payload(testing_provider, &transactions, i, parent_hash, parent_timestamp)
-                .await?;
-
-            self.save_payload(&built)?;
-
-            if self.execute || self.count > 1 {
-                info!(payload = i + 1, block_hash = %built.block_hash, "Executing payload (newPayload + FCU)");
-                self.execute_payload_v4(auth_provider, built.envelope, parent_hash).await?;
-                info!(payload = i + 1, "Payload executed successfully");
-            }
-
-            parent_hash = built.block_hash;
-            parent_timestamp = built.timestamp;
-        }
-        Ok(())
-    }
-
-    /// Pipelined execution - fetches transactions and builds payloads in background.
-    async fn execute_pipelined(
-        &self,
-        auth_provider: &RootProvider<AnyNetwork>,
-        testing_provider: &RootProvider<AnyNetwork>,
-        start_block: u64,
-        initial_parent_hash: B256,
-        initial_parent_timestamp: u64,
-    ) -> eyre::Result<()> {
-        // Create channel for transaction batches (one batch per payload)
-        let (tx_sender, mut tx_receiver) = mpsc::channel::<Vec<Bytes>>(self.prefetch_buffer);
-
-        // Spawn background task to continuously fetch transaction batches
-        let rpc_url = self.rpc_url.clone();
-        let target_gas = self.target_gas;
-        let count = self.count;
-
-        let fetcher_handle = tokio::spawn(async move {
-            let tx_source = match RpcTransactionSource::from_url(&rpc_url) {
-                Ok(source) => source,
-                Err(e) => {
-                    warn!(error = %e, "Failed to create transaction source");
-                    return;
-                }
-            };
-
-            let collector = TransactionCollector::new(tx_source, target_gas);
-            let mut current_block = start_block;
-
-            for payload_idx in 0..count {
-                match collector.collect(current_block).await {
-                    Ok((transactions, total_gas, next_block)) => {
-                        info!(
-                            payload = payload_idx + 1,
-                            tx_count = transactions.len(),
-                            total_gas,
-                            blocks = format!("{}..{}", current_block, next_block),
-                            "Fetched transactions"
-                        );
-                        current_block = next_block;
-
-                        if tx_sender.send(transactions).await.is_err() {
-                            break;
-                        }
-                    }
-                    Err(e) => {
-                        warn!(payload = payload_idx + 1, error = %e, "Failed to fetch transactions");
-                        break;
-                    }
-                }
-            }
-        });
-
-        let mut parent_hash = initial_parent_hash;
-        let mut parent_timestamp = initial_parent_timestamp;
-        let mut pending_build: Option<tokio::task::JoinHandle<eyre::Result<BuiltPayload>>> = None;
-
-        for i in 0..self.count {
-            let is_last = i == self.count - 1;
-
-            // Get current payload (either from pending build or build now)
-            let current_payload = if let Some(handle) = pending_build.take() {
-                handle.await??
-            } else {
-                // First payload - wait for transactions and build synchronously
-                let transactions = tx_receiver
-                    .recv()
-                    .await
-                    .ok_or_else(|| eyre::eyre!("Transaction fetcher stopped unexpectedly"))?;
-
-                if transactions.is_empty() {
-                    return Err(eyre::eyre!("No transactions collected for payload {}", i + 1));
-                }
-
-                info!(
-                    payload = i + 1,
-                    total = self.count,
-                    parent_hash = %parent_hash,
-                    parent_timestamp = parent_timestamp,
-                    tx_count = transactions.len(),
-                    "Building payload via testing_buildBlockV1"
-                );
-                self.build_payload(
-                    testing_provider,
-                    &transactions,
-                    i,
-                    parent_hash,
-                    parent_timestamp,
-                )
-                .await?
-            };
-
-            self.save_payload(&current_payload)?;
-
-            let current_block_hash = current_payload.block_hash;
-            let current_timestamp = current_payload.timestamp;
-
-            // Execute current payload first
-            info!(payload = i + 1, block_hash = %current_block_hash, "Executing payload (newPayload + FCU)");
-            self.execute_payload_v4(auth_provider, current_payload.envelope, parent_hash).await?;
-            info!(payload = i + 1, "Payload executed successfully");
-
-            // Start building next payload in background (if not last) - AFTER execution
-            if !is_last {
-                // Get transactions for next payload (should already be fetched or fetching)
-                let next_transactions = tx_receiver
-                    .recv()
-                    .await
-                    .ok_or_else(|| eyre::eyre!("Transaction fetcher stopped unexpectedly"))?;
-
-                if next_transactions.is_empty() {
-                    return Err(eyre::eyre!("No transactions collected for payload {}", i + 2));
-                }
-
-                let testing_provider = testing_provider.clone();
-                let next_index = i + 1;
-                let total = self.count;
-
-                pending_build = Some(tokio::spawn(async move {
-                    info!(
-                        payload = next_index + 1,
-                        total = total,
-                        parent_hash = %current_block_hash,
-                        parent_timestamp = current_timestamp,
-                        tx_count = next_transactions.len(),
-                        "Building payload via testing_buildBlockV1"
-                    );
-
-                    Self::build_payload_static(
-                        &testing_provider,
-                        &next_transactions,
-                        next_index,
-                        current_block_hash,
-                        current_timestamp,
-                    )
-                    .await
-                }));
-            }
-
-            parent_hash = current_block_hash;
-            parent_timestamp = current_timestamp;
-        }
-
-        // Clean up the fetcher task
-        drop(tx_receiver);
-        let _ = fetcher_handle.await;
-
-        Ok(())
-    }
-
-    /// Build a single payload via `testing_buildBlockV1`.
-    async fn build_payload(
-        &self,
-        testing_provider: &RootProvider<AnyNetwork>,
-        transactions: &[Bytes],
-        index: u64,
-        parent_hash: B256,
-        parent_timestamp: u64,
-    ) -> eyre::Result<BuiltPayload> {
-        Self::build_payload_static(
-            testing_provider,
-            transactions,
-            index,
-            parent_hash,
-            parent_timestamp,
-        )
-        .await
-    }
-
-    /// Static version for use in spawned tasks.
-    async fn build_payload_static(
-        testing_provider: &RootProvider<AnyNetwork>,
-        transactions: &[Bytes],
-        index: u64,
-        parent_hash: B256,
-        parent_timestamp: u64,
-    ) -> eyre::Result<BuiltPayload> {
-        let request = TestingBuildBlockRequestV1 {
-            parent_block_hash: parent_hash,
-            payload_attributes: PayloadAttributes {
-                timestamp: parent_timestamp + 12,
-                prev_randao: B256::ZERO,
-                suggested_fee_recipient: alloy_primitives::Address::ZERO,
-                withdrawals: Some(vec![]),
-                parent_beacon_block_root: Some(B256::ZERO),
-            },
-            transactions: transactions.to_vec(),
-            extra_data: None,
-        };
-
-        let total_tx_bytes: usize = transactions.iter().map(|tx| tx.len()).sum();
-        info!(
-            payload = index + 1,
-            tx_count = transactions.len(),
-            total_tx_bytes = total_tx_bytes,
-            parent_hash = %parent_hash,
-            "Sending to testing_buildBlockV1"
-        );
-        let envelope: ExecutionPayloadEnvelopeV5 =
-            testing_provider.client().request("testing_buildBlockV1", [request]).await?;
-
-        let v4_envelope = envelope.try_into_v4()?;
-
-        let inner = &v4_envelope.envelope_inner.execution_payload.payload_inner.payload_inner;
-        let block_hash = inner.block_hash;
-        let block_number = inner.block_number;
-        let timestamp = inner.timestamp;
-
-        Ok(BuiltPayload { block_number, envelope: v4_envelope, block_hash, timestamp })
-    }
-
-    /// Save a payload to disk.
-    fn save_payload(&self, payload: &BuiltPayload) -> eyre::Result<()> {
-        let filename = format!("payload_block_{}.json", payload.block_number);
-        let filepath = self.output_dir.join(&filename);
-        let json = serde_json::to_string_pretty(&payload.envelope)?;
-        std::fs::write(&filepath, &json)
-            .wrap_err_with(|| format!("Failed to write payload to {:?}", filepath))?;
-        info!(block_number = payload.block_number, block_hash = %payload.block_hash, path = %filepath.display(), "Payload saved");
-        Ok(())
-    }
-
-    async fn execute_payload_v4(
-        &self,
-        provider: &RootProvider<AnyNetwork>,
-        envelope: ExecutionPayloadEnvelopeV4,
-        parent_hash: B256,
-    ) -> eyre::Result<()> {
-        let block_hash =
-            envelope.envelope_inner.execution_payload.payload_inner.payload_inner.block_hash;
-
-        let status = provider
-            .new_payload_v4(
-                envelope.envelope_inner.execution_payload,
-                vec![],
-                B256::ZERO,
-                envelope.execution_requests.to_vec(),
-            )
-            .await?;
-
-        if !status.is_valid() {
-            return Err(eyre::eyre!("Payload rejected: {:?}", status));
-        }
-
-        let fcu_state = ForkchoiceState {
-            head_block_hash: block_hash,
-            safe_block_hash: parent_hash,
-            finalized_block_hash: parent_hash,
-        };
-
-        let fcu_result = provider.fork_choice_updated_v3(fcu_state, None).await?;
-
-        if !fcu_result.is_valid() {
-            return Err(eyre::eyre!("FCU rejected: {:?}", fcu_result));
-        }
-
-        Ok(())
-    }
-}
--- a/bin/reth-bench/src/bench/helpers.rs
+++ b/bin/reth-bench/src/bench/helpers.rs
@@ -1,196 +0,0 @@
-//! Common helpers for reth-bench commands.
-
-use crate::valid_payload::call_forkchoice_updated;
-use alloy_consensus::Header;
-use alloy_eips::eip4844::kzg_to_versioned_hash;
-use alloy_primitives::{Address, B256};
-use alloy_provider::{ext::EngineApi, network::AnyNetwork, RootProvider};
-use alloy_rpc_types_engine::{
-    CancunPayloadFields, ExecutionPayload, ExecutionPayloadSidecar, ForkchoiceState,
-    PayloadAttributes, PayloadId, PraguePayloadFields,
-};
-use eyre::OptionExt;
-use reth_chainspec::{ChainSpec, EthereumHardforks};
-use reth_node_api::EngineApiMessageVersion;
-use tracing::debug;
-
-/// Prepared payload request data for triggering block building.
-pub(crate) struct PayloadRequest {
-    /// The payload attributes for the new block.
-    pub(crate) attributes: PayloadAttributes,
-    /// The forkchoice state pointing to the parent block.
-    pub(crate) forkchoice_state: ForkchoiceState,
-    /// The engine API version for FCU calls.
-    pub(crate) fcu_version: EngineApiMessageVersion,
-    /// The getPayload version to use (1-5).
-    pub(crate) get_payload_version: u8,
-    /// The newPayload version to use.
-    pub(crate) new_payload_version: EngineApiMessageVersion,
-}
-
-/// Prepare payload attributes and forkchoice state for a new block.
-pub(crate) fn prepare_payload_request(
-    chain_spec: &ChainSpec,
-    timestamp: u64,
-    parent_hash: B256,
-) -> PayloadRequest {
-    let shanghai_active = chain_spec.is_shanghai_active_at_timestamp(timestamp);
-    let cancun_active = chain_spec.is_cancun_active_at_timestamp(timestamp);
-    let prague_active = chain_spec.is_prague_active_at_timestamp(timestamp);
-    let osaka_active = chain_spec.is_osaka_active_at_timestamp(timestamp);
-
-    // FCU version: V3 for Cancun+Prague+Osaka, V2 for Shanghai, V1 otherwise
-    let fcu_version = if cancun_active {
-        EngineApiMessageVersion::V3
-    } else if shanghai_active {
-        EngineApiMessageVersion::V2
-    } else {
-        EngineApiMessageVersion::V1
-    };
-
-    // getPayload version: 5 for Osaka, 4 for Prague, 3 for Cancun, 2 for Shanghai, 1 otherwise
-    // newPayload version: 4 for Prague+Osaka (no V5), 3 for Cancun, 2 for Shanghai, 1 otherwise
-    let (get_payload_version, new_payload_version) = if osaka_active {
-        (5, EngineApiMessageVersion::V4) // Osaka uses getPayloadV5 but newPayloadV4
-    } else if prague_active {
-        (4, EngineApiMessageVersion::V4)
-    } else if cancun_active {
-        (3, EngineApiMessageVersion::V3)
-    } else if shanghai_active {
-        (2, EngineApiMessageVersion::V2)
-    } else {
-        (1, EngineApiMessageVersion::V1)
-    };
-
-    PayloadRequest {
-        attributes: PayloadAttributes {
-            timestamp,
-            prev_randao: B256::ZERO,
-            suggested_fee_recipient: Address::ZERO,
-            withdrawals: shanghai_active.then(Vec::new),
-            parent_beacon_block_root: cancun_active.then_some(B256::ZERO),
-        },
-        forkchoice_state: ForkchoiceState {
-            head_block_hash: parent_hash,
-            safe_block_hash: parent_hash,
-            finalized_block_hash: parent_hash,
-        },
-        fcu_version,
-        get_payload_version,
-        new_payload_version,
-    }
-}
-
-/// Trigger payload building via FCU and retrieve the built payload.
-///
-/// This sends a forkchoiceUpdated with payload attributes to start building,
-/// then calls getPayload to retrieve the result.
-pub(crate) async fn build_payload(
-    provider: &RootProvider<AnyNetwork>,
-    request: PayloadRequest,
-) -> eyre::Result<(ExecutionPayload, ExecutionPayloadSidecar)> {
-    let fcu_result = call_forkchoice_updated(
-        provider,
-        request.fcu_version,
-        request.forkchoice_state,
-        Some(request.attributes.clone()),
-    )
-    .await?;
-
-    let payload_id =
-        fcu_result.payload_id.ok_or_eyre("Payload builder did not return a payload id")?;
-
-    get_payload_with_sidecar(
-        provider,
-        request.get_payload_version,
-        payload_id,
-        request.attributes.parent_beacon_block_root,
-    )
-    .await
-}
-
-/// Convert an RPC block to a consensus header and block hash.
-pub(crate) fn rpc_block_to_header(block: alloy_provider::network::AnyRpcBlock) -> (Header, B256) {
-    let block_hash = block.header.hash;
-    let header = block.header.inner.clone().into_header_with_defaults();
-    (header, block_hash)
-}
-
-/// Compute versioned hashes from KZG commitments.
-fn versioned_hashes_from_commitments(
-    commitments: &[alloy_primitives::FixedBytes<48>],
-) -> Vec<B256> {
-    commitments.iter().map(|c| kzg_to_versioned_hash(c.as_ref())).collect()
-}
-
-/// Fetch an execution payload using the appropriate engine API version.
-pub(crate) async fn get_payload_with_sidecar(
-    provider: &RootProvider<AnyNetwork>,
-    version: u8,
-    payload_id: PayloadId,
-    parent_beacon_block_root: Option<B256>,
-) -> eyre::Result<(ExecutionPayload, ExecutionPayloadSidecar)> {
-    debug!(get_payload_version = ?version, ?payload_id, "Sending getPayload");
-
-    match version {
-        1 => {
-            let payload = provider.get_payload_v1(payload_id).await?;
-            Ok((ExecutionPayload::V1(payload), ExecutionPayloadSidecar::none()))
-        }
-        2 => {
-            let envelope = provider.get_payload_v2(payload_id).await?;
-            let payload = match envelope.execution_payload {
-                alloy_rpc_types_engine::ExecutionPayloadFieldV2::V1(p) => ExecutionPayload::V1(p),
-                alloy_rpc_types_engine::ExecutionPayloadFieldV2::V2(p) => ExecutionPayload::V2(p),
-            };
-            Ok((payload, ExecutionPayloadSidecar::none()))
-        }
-        3 => {
-            let envelope = provider.get_payload_v3(payload_id).await?;
-            let versioned_hashes =
-                versioned_hashes_from_commitments(&envelope.blobs_bundle.commitments);
-            let cancun_fields = CancunPayloadFields {
-                parent_beacon_block_root: parent_beacon_block_root
-                    .ok_or_eyre("parent_beacon_block_root required for V3")?,
-                versioned_hashes,
-            };
-            Ok((
-                ExecutionPayload::V3(envelope.execution_payload),
-                ExecutionPayloadSidecar::v3(cancun_fields),
-            ))
-        }
-        4 => {
-            let envelope = provider.get_payload_v4(payload_id).await?;
-            let versioned_hashes = versioned_hashes_from_commitments(
-                &envelope.envelope_inner.blobs_bundle.commitments,
-            );
-            let cancun_fields = CancunPayloadFields {
-                parent_beacon_block_root: parent_beacon_block_root
-                    .ok_or_eyre("parent_beacon_block_root required for V4")?,
-                versioned_hashes,
-            };
-            let prague_fields = PraguePayloadFields::new(envelope.execution_requests);
-            Ok((
-                ExecutionPayload::V3(envelope.envelope_inner.execution_payload),
-                ExecutionPayloadSidecar::v4(cancun_fields, prague_fields),
-            ))
-        }
-        5 => {
-            // V5 (Osaka) - use raw request since alloy doesn't have get_payload_v5 yet
-            let envelope = provider.get_payload_v5(payload_id).await?;
-            let versioned_hashes =
-                versioned_hashes_from_commitments(&envelope.blobs_bundle.commitments);
-            let cancun_fields = CancunPayloadFields {
-                parent_beacon_block_root: parent_beacon_block_root
-                    .ok_or_eyre("parent_beacon_block_root required for V5")?,
-                versioned_hashes,
-            };
-            let prague_fields = PraguePayloadFields::new(envelope.execution_requests);
-            Ok((
-                ExecutionPayload::V3(envelope.execution_payload),
-                ExecutionPayloadSidecar::v4(cancun_fields, prague_fields),
-            ))
-        }
-        _ => panic!("This tool does not support getPayload versions past v5"),
-    }
-}
--- a/bin/reth-bench/src/bench/mod.rs
+++ b/bin/reth-bench/src/bench/mod.rs
@@ -6,16 +6,9 @@ use reth_node_core::args::LogArgs;
 use reth_tracing::FileWorkerGuard;

 mod context;
-mod gas_limit_ramp;
-mod generate_big_block;
-pub(crate) mod helpers;
-pub use generate_big_block::{
-    RawTransaction, RpcTransactionSource, TransactionCollector, TransactionSource,
-};
 mod new_payload_fcu;
 mod new_payload_only;
 mod output;
-mod replay_payloads;
 mod send_payload;

 /// `reth bench` command
@@ -34,9 +27,6 @@ pub enum Subcommands {
    /// Benchmark which calls `newPayload`, then `forkchoiceUpdated`.
    NewPayloadFcu(new_payload_fcu::Command),

-    /// Benchmark which builds empty blocks with a ramped gas limit.
-    GasLimitRamp(gas_limit_ramp::Command),
-
    /// Benchmark which only calls subsequent `newPayload` calls.
    NewPayloadOnly(new_payload_only::Command),

@@ -51,29 +41,6 @@ pub enum Subcommands {
    /// `cast block latest --full --json | reth-bench send-payload --rpc-url localhost:5000
    /// --jwt-secret $(cat ~/.local/share/reth/mainnet/jwt.hex)`
    SendPayload(send_payload::Command),
-
-    /// Generate a large block by packing transactions from existing blocks.
-    ///
-    /// This command fetches transactions from real blocks and packs them into a single
-    /// block using the `testing_buildBlockV1` RPC endpoint.
-    ///
-    /// Example:
-    ///
-    /// `reth-bench generate-big-block --rpc-url http://localhost:8545 --engine-rpc-url
-    /// http://localhost:8551 --jwt-secret ~/.local/share/reth/mainnet/jwt.hex --target-gas
-    /// 30000000`
-    GenerateBigBlock(generate_big_block::Command),
-
-    /// Replay pre-generated payloads from a directory.
-    ///
-    /// This command reads payload files from a previous `generate-big-block` run and replays
-    /// them in sequence using `newPayload` followed by `forkchoiceUpdated`.
-    ///
-    /// Example:
-    ///
-    /// `reth-bench replay-payloads --payload-dir ./payloads --engine-rpc-url
-    /// http://localhost:8551 --jwt-secret ~/.local/share/reth/mainnet/jwt.hex`
-    ReplayPayloads(replay_payloads::Command),
 }

 impl BenchmarkCommand {
@@ -84,11 +51,8 @@ impl BenchmarkCommand {

        match self.command {
            Subcommands::NewPayloadFcu(command) => command.execute(ctx).await,
-            Subcommands::GasLimitRamp(command) => command.execute(ctx).await,
            Subcommands::NewPayloadOnly(command) => command.execute(ctx).await,
            Subcommands::SendPayload(command) => command.execute(ctx).await,
-            Subcommands::GenerateBigBlock(command) => command.execute(ctx).await,
-            Subcommands::ReplayPayloads(command) => command.execute(ctx).await,
        }
    }

--- a/bin/reth-bench/src/bench/new_payload_fcu.rs
+++ b/bin/reth-bench/src/bench/new_payload_fcu.rs
@@ -1,42 +1,26 @@
 //! Runs the `reth bench` command, calling first newPayload for each block, then calling
 //! forkchoiceUpdated.
-//!
-//! Supports configurable waiting behavior:
-//! - **`--wait-time`**: Fixed sleep interval between blocks.
-//! - **`--wait-for-persistence`**: Waits for every Nth block to be persisted using the
-//!   `reth_subscribePersistedBlock` subscription, where N matches the engine's persistence
-//!   threshold. This ensures the benchmark doesn't outpace persistence.
-//!
-//! Both options can be used together or independently.

 use crate::{
    bench::{
        context::BenchContext,
        output::{
-            write_benchmark_results, CombinedResult, NewPayloadResult, TotalGasOutput, TotalGasRow,
+            CombinedResult, NewPayloadResult, TotalGasOutput, TotalGasRow, COMBINED_OUTPUT_SUFFIX,
+            GAS_OUTPUT_SUFFIX,
        },
    },
    valid_payload::{block_to_new_payload, call_forkchoice_updated, call_new_payload},
 };
-use alloy_eips::BlockNumHash;
-use alloy_network::Ethereum;
-use alloy_provider::{Provider, RootProvider};
-use alloy_pubsub::SubscriptionStream;
-use alloy_rpc_client::RpcClient;
+use alloy_provider::Provider;
 use alloy_rpc_types_engine::ForkchoiceState;
-use alloy_transport_ws::WsConnect;
 use clap::Parser;
+use csv::Writer;
 use eyre::{Context, OptionExt};
-use futures::StreamExt;
 use humantime::parse_duration;
 use reth_cli_runner::CliContext;
-use reth_engine_primitives::config::DEFAULT_PERSISTENCE_THRESHOLD;
 use reth_node_core::args::BenchmarkArgs;
 use std::time::{Duration, Instant};
 use tracing::{debug, info};
-use url::Url;
-
-const PERSISTENCE_CHECKPOINT_TIMEOUT: Duration = Duration::from_secs(60);

 /// `reth benchmark new-payload-fcu` command
 #[derive(Debug, Parser)]
@@ -46,31 +30,8 @@ pub struct Command {
    rpc_url: String,

    /// How long to wait after a forkchoice update before sending the next payload.
-    #[arg(long, value_name = "WAIT_TIME", value_parser = parse_duration, verbatim_doc_comment)]
-    wait_time: Option<Duration>,
-
-    /// Wait for blocks to be persisted before sending the next batch.
-    ///
-    /// When enabled, waits for every Nth block to be persisted using the
-    /// `reth_subscribePersistedBlock` subscription. This ensures the benchmark
-    /// doesn't outpace persistence.
-    ///
-    /// The subscription uses the regular RPC websocket endpoint (no JWT required).
-    #[arg(long, default_value = "false", verbatim_doc_comment)]
-    wait_for_persistence: bool,
-
-    /// Engine persistence threshold used for deciding when to wait for persistence.
-    ///
-    /// The benchmark waits after every `(threshold + 1)` blocks. By default this
-    /// matches the engine's `DEFAULT_PERSISTENCE_THRESHOLD` (2), so waits occur
-    /// at blocks 3, 6, 9, etc.
-    #[arg(
-        long = "persistence-threshold",
-        value_name = "PERSISTENCE_THRESHOLD",
-        default_value_t = DEFAULT_PERSISTENCE_THRESHOLD,
-        verbatim_doc_comment
-    )]
-    persistence_threshold: u64,
+    #[arg(long, value_name = "WAIT_TIME", value_parser = parse_duration, default_value = "250ms", verbatim_doc_comment)]
+    wait_time: Duration,

    /// The size of the block buffer (channel capacity) for prefetching blocks from the RPC
    /// endpoint.
@@ -89,39 +50,12 @@ pub struct Command {
 impl Command {
    /// Execute `benchmark new-payload-fcu` command
    pub async fn execute(self, _ctx: CliContext) -> eyre::Result<()> {
-        // Log mode configuration
-        if let Some(duration) = self.wait_time {
-            info!("Using wait-time mode with {}ms delay between blocks", duration.as_millis());
-        }
-        if self.wait_for_persistence {
-            info!(
-                "Persistence waiting enabled (waits after every {} blocks to match engine gap > {} behavior)",
-                self.persistence_threshold + 1,
-                self.persistence_threshold
-            );
-        }
-
-        // Set up waiter based on configured options (duration takes precedence)
-        let mut waiter = match (self.wait_time, self.wait_for_persistence) {
-            (Some(duration), _) => Some(PersistenceWaiter::with_duration(duration)),
-            (None, true) => {
-                let sub = self.setup_persistence_subscription().await?;
-                Some(PersistenceWaiter::with_subscription(
-                    sub,
-                    self.persistence_threshold,
-                    PERSISTENCE_CHECKPOINT_TIMEOUT,
-                ))
-            }
-            (None, false) => None,
-        };
-
        let BenchContext {
            benchmark_mode,
            block_provider,
            auth_provider,
            mut next_block,
            is_optimism,
-            ..
        } = BenchContext::new(&self.benchmark, self.rpc_url).await?;

        let buffer_size = self.rpc_block_buffer_size;
@@ -176,6 +110,7 @@ impl Command {
            }
        });

+        // put results in a summary vec so they can be printed at the end
        let mut results = Vec::new();
        let total_benchmark_duration = Instant::now();
        let mut total_wait_time = Duration::ZERO;
@@ -186,13 +121,14 @@ impl Command {
            total_wait_time += wait_start.elapsed();
            result
        } {
+            // just put gas used here
            let gas_used = block.header.gas_used;
-            let gas_limit = block.header.gas_limit;
            let block_number = block.header.number;
            let transaction_count = block.transactions.len() as u64;

-            debug!(target: "reth-bench", ?block_number, "Sending payload");
+            debug!(target: "reth-bench", ?block_number, "Sending payload",);

+            // construct fcu to call
            let forkchoice_state = ForkchoiceState {
                head_block_hash: head,
                safe_block_hash: safe,
@@ -207,26 +143,28 @@ impl Command {

            call_forkchoice_updated(&auth_provider, version, forkchoice_state, None).await?;

+            // calculate the total duration and the fcu latency, record
            let total_latency = start.elapsed();
            let fcu_latency = total_latency - new_payload_result.latency;
            let combined_result = CombinedResult {
                block_number,
-                gas_limit,
                transaction_count,
                new_payload_result,
                fcu_latency,
                total_latency,
            };

-            // Exclude time spent waiting on the block prefetch channel from the benchmark duration.
-            // We want to measure engine throughput, not RPC fetch latency.
+            // current duration since the start of the benchmark minus the time
+            // waiting for blocks
            let current_duration = total_benchmark_duration.elapsed() - total_wait_time;
+
+            // convert gas used to gigagas, then compute gigagas per second
            info!(%combined_result);

-            if let Some(w) = &mut waiter {
-                w.on_block(block_number).await?;
-            }
+            // wait before sending the next payload
+            tokio::time::sleep(self.wait_time).await;

+            // record the current result
            let gas_row =
                TotalGasRow { block_number, transaction_count, gas_used, time: current_duration };
            results.push((gas_row, combined_result));
@@ -237,19 +175,34 @@ impl Command {
            return Err(error);
        }

-        // Drop waiter - we don't need to wait for final blocks to persist
-        // since the benchmark goal is measuring Ggas/s of newPayload/FCU, not persistence.
-        drop(waiter);
-
-        let (gas_output_results, combined_results): (Vec<TotalGasRow>, Vec<CombinedResult>) =
+        let (gas_output_results, combined_results): (_, Vec<CombinedResult>) =
            results.into_iter().unzip();

-        if let Some(ref path) = self.benchmark.output {
-            write_benchmark_results(path, &gas_output_results, combined_results)?;
+        // write the csv output to files
+        if let Some(path) = self.benchmark.output {
+            // first write the combined results to a file
+            let output_path = path.join(COMBINED_OUTPUT_SUFFIX);
+            info!("Writing engine api call latency output to file: {:?}", output_path);
+            let mut writer = Writer::from_path(output_path)?;
+            for result in combined_results {
+                writer.serialize(result)?;
+            }
+            writer.flush()?;
+
+            // now write the gas output to a file
+            let output_path = path.join(GAS_OUTPUT_SUFFIX);
+            info!("Writing total gas output to file: {:?}", output_path);
+            let mut writer = Writer::from_path(output_path)?;
+            for row in &gas_output_results {
+                writer.serialize(row)?;
+            }
+            writer.flush()?;
+
+            info!("Finished writing benchmark output files to {:?}.", path);
        }

+        // accumulate the results and calculate the overall Ggas/s
        let gas_output = TotalGasOutput::new(gas_output_results)?;
-
        info!(
            total_duration=?gas_output.total_duration,
            total_gas_used=?gas_output.total_gas_used,
@@ -260,278 +213,4 @@ impl Command {

        Ok(())
    }
-
-    /// Returns the websocket RPC URL used for the persistence subscription.
-    ///
-    /// Preference:
-    /// - If `--ws-rpc-url` is provided, use it directly.
-    /// - Otherwise, derive a WS RPC URL from `--engine-rpc-url`.
-    ///
-    /// The persistence subscription endpoint (`reth_subscribePersistedBlock`) is exposed on
-    /// the regular RPC server (WS port, usually 8546), not on the engine API port (usually 8551).
-    /// Since `BenchmarkArgs` only has the engine URL by default, we convert the scheme
-    /// (http→ws, https→wss) and force the port to 8546.
-    fn derive_ws_rpc_url(&self) -> eyre::Result<Url> {
-        if let Some(ref ws_url) = self.benchmark.ws_rpc_url {
-            let parsed: Url = ws_url
-                .parse()
-                .wrap_err_with(|| format!("Failed to parse WebSocket RPC URL: {ws_url}"))?;
-            info!(target: "reth-bench", ws_url = %parsed, "Using provided WebSocket RPC URL");
-            Ok(parsed)
-        } else {
-            let derived = engine_url_to_ws_url(&self.benchmark.engine_rpc_url)?;
-            debug!(
-                target: "reth-bench",
-                engine_url = %self.benchmark.engine_rpc_url,
-                %derived,
-                "Derived WebSocket RPC URL from engine RPC URL"
-            );
-            Ok(derived)
-        }
-    }
-
-    /// Establishes a websocket connection and subscribes to `reth_subscribePersistedBlock`.
-    async fn setup_persistence_subscription(&self) -> eyre::Result<PersistenceSubscription> {
-        let ws_url = self.derive_ws_rpc_url()?;
-
-        info!("Connecting to WebSocket at {} for persistence subscription", ws_url);
-
-        let ws_connect = WsConnect::new(ws_url.to_string());
-        let client = RpcClient::connect_pubsub(ws_connect)
-            .await
-            .wrap_err("Failed to connect to WebSocket RPC endpoint")?;
-        let provider: RootProvider<Ethereum> = RootProvider::new(client);
-
-        let subscription = provider
-            .subscribe_to::<BlockNumHash>("reth_subscribePersistedBlock")
-            .await
-            .wrap_err("Failed to subscribe to persistence notifications")?;
-
-        info!("Subscribed to persistence notifications");
-
-        Ok(PersistenceSubscription::new(provider, subscription.into_stream()))
-    }
-}
-
-/// Converts an engine API URL to the default RPC websocket URL.
-///
-/// Transformations:
-/// - `http`  → `ws`
-/// - `https` → `wss`
-/// - `ws` / `wss` keep their scheme
-/// - Port is always set to `8546`, reth's default RPC websocket port.
-///
-/// This is used when we only know the engine API URL (typically `:8551`) but
-/// need to connect to the node's WS RPC endpoint for persistence events.
-fn engine_url_to_ws_url(engine_url: &str) -> eyre::Result<Url> {
-    let url: Url = engine_url
-        .parse()
-        .wrap_err_with(|| format!("Failed to parse engine RPC URL: {engine_url}"))?;
-
-    let mut ws_url = url.clone();
-
-    match ws_url.scheme() {
-        "http" => ws_url
-            .set_scheme("ws")
-            .map_err(|_| eyre::eyre!("Failed to set WS scheme for URL: {url}"))?,
-        "https" => ws_url
-            .set_scheme("wss")
-            .map_err(|_| eyre::eyre!("Failed to set WSS scheme for URL: {url}"))?,
-        "ws" | "wss" => {}
-        scheme => {
-            return Err(eyre::eyre!(
-            "Unsupported URL scheme '{scheme}' for URL: {url}. Expected http, https, ws, or wss."
-        ))
-        }
-    }
-
-    ws_url.set_port(Some(8546)).map_err(|_| eyre::eyre!("Failed to set port for URL: {url}"))?;
-
-    Ok(ws_url)
-}
-
-/// Waits until the persistence subscription reports that `target` has been persisted.
-///
-/// Consumes subscription events until `last_persisted >= target`, or returns an error if:
-/// - the subscription stream ends unexpectedly, or
-/// - `timeout` elapses before `target` is observed.
-async fn wait_for_persistence(
-    stream: &mut SubscriptionStream<BlockNumHash>,
-    target: u64,
-    last_persisted: &mut u64,
-    timeout: Duration,
-) -> eyre::Result<()> {
-    tokio::time::timeout(timeout, async {
-        while *last_persisted < target {
-            match stream.next().await {
-                Some(persisted) => {
-                    *last_persisted = persisted.number;
-                    debug!(
-                        target: "reth-bench",
-                        persisted_block = ?last_persisted,
-                        "Received persistence notification"
-                    );
-                }
-                None => {
-                    return Err(eyre::eyre!("Persistence subscription closed unexpectedly"));
-                }
-            }
-        }
-        Ok(())
-    })
-    .await
-    .map_err(|_| {
-        eyre::eyre!(
-            "Persistence timeout: target block {} not persisted within {:?}. Last persisted: {}",
-            target,
-            timeout,
-            last_persisted
-        )
-    })?
-}
-
-/// Wrapper that keeps both the subscription stream and the underlying provider alive.
-/// The provider must be kept alive for the subscription to continue receiving events.
-struct PersistenceSubscription {
-    _provider: RootProvider<Ethereum>,
-    stream: SubscriptionStream<BlockNumHash>,
-}
-
-impl PersistenceSubscription {
-    const fn new(
-        provider: RootProvider<Ethereum>,
-        stream: SubscriptionStream<BlockNumHash>,
-    ) -> Self {
-        Self { _provider: provider, stream }
-    }
-
-    const fn stream_mut(&mut self) -> &mut SubscriptionStream<BlockNumHash> {
-        &mut self.stream
-    }
-}
-
-/// Encapsulates the block waiting logic.
-///
-/// Provides a simple `on_block()` interface that handles both:
-/// - Fixed duration waits (when `wait_time` is set)
-/// - Persistence-based waits (when `subscription` is set)
-///
-/// For persistence mode, waits after every `(threshold + 1)` blocks.
-struct PersistenceWaiter {
-    wait_time: Option<Duration>,
-    subscription: Option<PersistenceSubscription>,
-    blocks_sent: u64,
-    last_persisted: u64,
-    threshold: u64,
-    timeout: Duration,
-}
-
-impl PersistenceWaiter {
-    const fn with_duration(wait_time: Duration) -> Self {
-        Self {
-            wait_time: Some(wait_time),
-            subscription: None,
-            blocks_sent: 0,
-            last_persisted: 0,
-            threshold: 0,
-            timeout: Duration::ZERO,
-        }
-    }
-
-    const fn with_subscription(
-        subscription: PersistenceSubscription,
-        threshold: u64,
-        timeout: Duration,
-    ) -> Self {
-        Self {
-            wait_time: None,
-            subscription: Some(subscription),
-            blocks_sent: 0,
-            last_persisted: 0,
-            threshold,
-            timeout,
-        }
-    }
-
-    /// Called once per block. Waits based on the configured mode.
-    #[allow(clippy::manual_is_multiple_of)]
-    async fn on_block(&mut self, block_number: u64) -> eyre::Result<()> {
-        if let Some(wait_time) = self.wait_time {
-            tokio::time::sleep(wait_time).await;
-            return Ok(());
-        }
-
-        let Some(ref mut subscription) = self.subscription else {
-            return Ok(());
-        };
-
-        self.blocks_sent += 1;
-
-        if self.blocks_sent % (self.threshold + 1) == 0 {
-            debug!(
-                target: "reth-bench",
-                target_block = ?block_number,
-                last_persisted = self.last_persisted,
-                blocks_sent = self.blocks_sent,
-                "Waiting for persistence"
-            );
-
-            wait_for_persistence(
-                subscription.stream_mut(),
-                block_number,
-                &mut self.last_persisted,
-                self.timeout,
-            )
-            .await?;
-
-            debug!(
-                target: "reth-bench",
-                persisted = self.last_persisted,
-                "Persistence caught up"
-            );
-        }
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_engine_url_to_ws_url() {
-        // http -> ws, always uses port 8546
-        let result = engine_url_to_ws_url("http://localhost:8551").unwrap();
-        assert_eq!(result.as_str(), "ws://localhost:8546/");
-
-        // https -> wss
-        let result = engine_url_to_ws_url("https://localhost:8551").unwrap();
-        assert_eq!(result.as_str(), "wss://localhost:8546/");
-
-        // Custom engine port still maps to 8546
-        let result = engine_url_to_ws_url("http://localhost:9551").unwrap();
-        assert_eq!(result.port(), Some(8546));
-
-        // Already ws passthrough
-        let result = engine_url_to_ws_url("ws://localhost:8546").unwrap();
-        assert_eq!(result.scheme(), "ws");
-
-        // Invalid inputs
-        assert!(engine_url_to_ws_url("ftp://localhost:8551").is_err());
-        assert!(engine_url_to_ws_url("not a valid url").is_err());
-    }
-
-    #[tokio::test]
-    async fn test_waiter_with_duration() {
-        let mut waiter = PersistenceWaiter::with_duration(Duration::from_millis(1));
-
-        let start = Instant::now();
-        waiter.on_block(1).await.unwrap();
-        waiter.on_block(2).await.unwrap();
-        waiter.on_block(3).await.unwrap();
-
-        // Should have waited ~3ms total
-        assert!(start.elapsed() >= Duration::from_millis(3));
-    }
 }
--- a/bin/reth-bench/src/bench/new_payload_only.rs
+++ b/bin/reth-bench/src/bench/new_payload_only.rs
@@ -49,7 +49,6 @@ impl Command {
            auth_provider,
            mut next_block,
            is_optimism,
-            ..
        } = BenchContext::new(&self.benchmark, self.rpc_url).await?;

        let buffer_size = self.rpc_block_buffer_size;
@@ -97,7 +96,11 @@ impl Command {
            let transaction_count = block.transactions.len() as u64;
            let gas_used = block.header.gas_used;

-            debug!(number=?block.header.number, "Sending payload to engine");
+            debug!(
+                target: "reth-bench",
+                number=?block.header.number,
+                "Sending payload to engine",
+            );

            let (version, params) = block_to_new_payload(block, is_optimism)?;

--- a/bin/reth-bench/src/bench/output.rs
+++ b/bin/reth-bench/src/bench/output.rs
@@ -1,13 +1,10 @@
 //! Contains various benchmark output formats, either for logging or for
 //! serialization to / from files.

-use alloy_primitives::B256;
-use csv::Writer;
 use eyre::OptionExt;
 use reth_primitives_traits::constants::GIGAGAS;
-use serde::{ser::SerializeStruct, Deserialize, Serialize};
-use std::{path::Path, time::Duration};
-use tracing::info;
+use serde::{ser::SerializeStruct, Serialize};
+use std::time::Duration;

 /// This is the suffix for gas output csv files.
 pub(crate) const GAS_OUTPUT_SUFFIX: &str = "total_gas.csv";
@@ -18,17 +15,6 @@ pub(crate) const COMBINED_OUTPUT_SUFFIX: &str = "combined_latency.csv";
 /// This is the suffix for new payload output csv files.
 pub(crate) const NEW_PAYLOAD_OUTPUT_SUFFIX: &str = "new_payload_latency.csv";

-/// Serialized format for gas ramp payloads on disk.
-#[derive(Debug, Serialize, Deserialize)]
-pub(crate) struct GasRampPayloadFile {
-    /// Engine API version (1-5).
-    pub(crate) version: u8,
-    /// The block hash for FCU.
-    pub(crate) block_hash: B256,
-    /// The params to pass to newPayload.
-    pub(crate) params: serde_json::Value,
-}
-
 /// This represents the results of a single `newPayload` call in the benchmark, containing the gas
 /// used and the `newPayload` latency.
 #[derive(Debug)]
@@ -81,8 +67,6 @@ impl Serialize for NewPayloadResult {
 pub(crate) struct CombinedResult {
    /// The block number of the block being processed.
    pub(crate) block_number: u64,
-    /// The gas limit of the block.
-    pub(crate) gas_limit: u64,
    /// The number of transactions in the block.
    pub(crate) transaction_count: u64,
    /// The `newPayload` result.
@@ -104,7 +88,7 @@ impl std::fmt::Display for CombinedResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
-            "Block {} processed at {:.4} Ggas/s, used {} total gas. Combined: {:.4} Ggas/s. fcu: {:?}, newPayload: {:?}",
+            "Payload {} processed at {:.4} Ggas/s, used {} total gas. Combined gas per second: {:.4} Ggas/s. fcu latency: {:?}, newPayload latency: {:?}",
            self.block_number,
            self.new_payload_result.gas_per_second() / GIGAGAS as f64,
            self.new_payload_result.gas_used,
@@ -126,11 +110,10 @@ 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", 6)?;

        // flatten the new payload result because this is meant for CSV writing
        state.serialize_field("block_number", &self.block_number)?;
-        state.serialize_field("gas_limit", &self.gas_limit)?;
        state.serialize_field("transaction_count", &self.transaction_count)?;
        state.serialize_field("gas_used", &self.new_payload_result.gas_used)?;
        state.serialize_field("new_payload_latency", &new_payload_latency)?;
@@ -184,36 +167,6 @@ impl TotalGasOutput {
    }
 }

-/// Write benchmark results to CSV files.
-///
-/// Writes two files to the output directory:
-/// - `combined_latency.csv`: Per-block latency results
-/// - `total_gas.csv`: Per-block gas usage over time
-pub(crate) fn write_benchmark_results(
-    output_dir: &Path,
-    gas_results: &[TotalGasRow],
-    combined_results: Vec<CombinedResult>,
-) -> eyre::Result<()> {
-    let output_path = output_dir.join(COMBINED_OUTPUT_SUFFIX);
-    info!("Writing engine api call latency output to file: {:?}", output_path);
-    let mut writer = Writer::from_path(&output_path)?;
-    for result in combined_results {
-        writer.serialize(result)?;
-    }
-    writer.flush()?;
-
-    let output_path = output_dir.join(GAS_OUTPUT_SUFFIX);
-    info!("Writing total gas output to file: {:?}", output_path);
-    let mut writer = Writer::from_path(&output_path)?;
-    for row in gas_results {
-        writer.serialize(row)?;
-    }
-    writer.flush()?;
-
-    info!("Finished writing benchmark output files to {:?}.", output_dir);
-    Ok(())
-}
-
 /// This serializes the `time` field of the [`TotalGasRow`] to microseconds.
 ///
 /// This is essentially just for the csv writer, which would have headers
--- a/bin/reth-bench/src/bench/replay_payloads.rs
+++ b/bin/reth-bench/src/bench/replay_payloads.rs
@@ -1,332 +0,0 @@
-//! Command for replaying pre-generated payloads from disk.
-//!
-//! This command reads `ExecutionPayloadEnvelopeV4` files from a directory and replays them
-//! in sequence using `newPayload` followed by `forkchoiceUpdated`.
-
-use crate::{
-    authenticated_transport::AuthenticatedTransportConnect,
-    bench::output::GasRampPayloadFile,
-    valid_payload::{call_forkchoice_updated, call_new_payload},
-};
-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 clap::Parser;
-use eyre::Context;
-use reqwest::Url;
-use reth_cli_runner::CliContext;
-use reth_node_api::EngineApiMessageVersion;
-use std::path::PathBuf;
-use tracing::{debug, info};
-
-/// `reth bench replay-payloads` command
-///
-/// Replays pre-generated payloads from a directory by calling `newPayload` followed by
-/// `forkchoiceUpdated` for each payload in sequence.
-#[derive(Debug, Parser)]
-pub struct Command {
-    /// The engine RPC URL (with JWT authentication).
-    #[arg(long, value_name = "ENGINE_RPC_URL", default_value = "http://localhost:8551")]
-    engine_rpc_url: String,
-
-    /// Path to the JWT secret file for engine API authentication.
-    #[arg(long, value_name = "JWT_SECRET")]
-    jwt_secret: PathBuf,
-
-    /// Directory containing payload files (`payload_block_N.json`).
-    #[arg(long, value_name = "PAYLOAD_DIR")]
-    payload_dir: PathBuf,
-
-    /// Optional limit on the number of payloads to replay.
-    /// If not specified, replays all payloads in the directory.
-    #[arg(long, value_name = "COUNT")]
-    count: Option<usize>,
-
-    /// Skip the first N payloads.
-    #[arg(long, value_name = "SKIP", default_value = "0")]
-    skip: usize,
-
-    /// Optional directory containing gas ramp payloads to replay first.
-    /// These are replayed before the main payloads to warm up the gas limit.
-    #[arg(long, value_name = "GAS_RAMP_DIR")]
-    gas_ramp_dir: Option<PathBuf>,
-}
-
-/// A loaded payload ready for execution.
-struct LoadedPayload {
-    /// The index (from filename).
-    index: u64,
-    /// The payload envelope.
-    envelope: ExecutionPayloadEnvelopeV4,
-    /// The block hash.
-    block_hash: B256,
-}
-
-/// A gas ramp payload loaded from disk.
-struct GasRampPayload {
-    /// Block number from filename.
-    block_number: u64,
-    /// Engine API version for newPayload.
-    version: EngineApiMessageVersion,
-    /// The file contents.
-    file: GasRampPayloadFile,
-}
-
-impl Command {
-    /// Execute the `replay-payloads` command.
-    pub async fn execute(self, _ctx: CliContext) -> eyre::Result<()> {
-        info!(payload_dir = %self.payload_dir.display(), "Replaying payloads");
-
-        // Set up authenticated engine provider
-        let jwt =
-            std::fs::read_to_string(&self.jwt_secret).wrap_err("Failed to read JWT secret file")?;
-        let jwt = JwtSecret::from_hex(jwt.trim())?;
-        let auth_url = Url::parse(&self.engine_rpc_url)?;
-
-        info!("Connecting to Engine RPC at {}", auth_url);
-        let auth_transport = AuthenticatedTransportConnect::new(auth_url.clone(), jwt);
-        let auth_client = ClientBuilder::default().connect_with(auth_transport).await?;
-        let auth_provider = RootProvider::<AnyNetwork>::new(auth_client);
-
-        // Get parent block (latest canonical block) - we need this for the first FCU
-        let parent_block = auth_provider
-            .get_block_by_number(alloy_eips::BlockNumberOrTag::Latest)
-            .await?
-            .ok_or_else(|| eyre::eyre!("Failed to fetch latest block"))?;
-
-        let initial_parent_hash = parent_block.header.hash;
-        let initial_parent_number = parent_block.header.number;
-
-        info!(
-            parent_hash = %initial_parent_hash,
-            parent_number = initial_parent_number,
-            "Using initial parent block"
-        );
-
-        // Load all payloads upfront to avoid I/O delays between phases
-        let gas_ramp_payloads = if let Some(ref gas_ramp_dir) = self.gas_ramp_dir {
-            let payloads = self.load_gas_ramp_payloads(gas_ramp_dir)?;
-            if payloads.is_empty() {
-                return Err(eyre::eyre!("No gas ramp payload files found in {:?}", gas_ramp_dir));
-            }
-            info!(count = payloads.len(), "Loaded gas ramp payloads from disk");
-            payloads
-        } else {
-            Vec::new()
-        };
-
-        let payloads = self.load_payloads()?;
-        if payloads.is_empty() {
-            return Err(eyre::eyre!("No payload files found in {:?}", self.payload_dir));
-        }
-        info!(count = payloads.len(), "Loaded main payloads from disk");
-
-        let mut parent_hash = initial_parent_hash;
-
-        // Replay gas ramp payloads first
-        for (i, payload) in gas_ramp_payloads.iter().enumerate() {
-            info!(
-                gas_ramp_payload = i + 1,
-                total = gas_ramp_payloads.len(),
-                block_number = payload.block_number,
-                block_hash = %payload.file.block_hash,
-                "Executing gas ramp payload (newPayload + FCU)"
-            );
-
-            call_new_payload(&auth_provider, payload.version, payload.file.params.clone()).await?;
-
-            let fcu_state = ForkchoiceState {
-                head_block_hash: payload.file.block_hash,
-                safe_block_hash: parent_hash,
-                finalized_block_hash: parent_hash,
-            };
-            call_forkchoice_updated(&auth_provider, payload.version, fcu_state, None).await?;
-
-            info!(gas_ramp_payload = i + 1, "Gas ramp payload executed successfully");
-            parent_hash = payload.file.block_hash;
-        }
-
-        if !gas_ramp_payloads.is_empty() {
-            info!(count = gas_ramp_payloads.len(), "All gas ramp payloads replayed");
-        }
-
-        for (i, payload) in payloads.iter().enumerate() {
-            info!(
-                payload = i + 1,
-                total = payloads.len(),
-                index = payload.index,
-                block_hash = %payload.block_hash,
-                "Executing payload (newPayload + FCU)"
-            );
-
-            self.execute_payload_v4(&auth_provider, &payload.envelope, parent_hash).await?;
-
-            info!(payload = i + 1, "Payload executed successfully");
-            parent_hash = payload.block_hash;
-        }
-
-        info!(count = payloads.len(), "All payloads replayed successfully");
-        Ok(())
-    }
-
-    /// Load and parse all payload files from the directory.
-    fn load_payloads(&self) -> eyre::Result<Vec<LoadedPayload>> {
-        let mut payloads = Vec::new();
-
-        // Read directory entries
-        let entries: Vec<_> = std::fs::read_dir(&self.payload_dir)
-            .wrap_err_with(|| format!("Failed to read directory {:?}", self.payload_dir))?
-            .filter_map(|e| e.ok())
-            .filter(|e| {
-                e.path().extension().and_then(|s| s.to_str()) == Some("json") &&
-                    e.file_name().to_string_lossy().starts_with("payload_")
-            })
-            .collect();
-
-        // Parse filenames to get indices and sort
-        let mut indexed_paths: Vec<(u64, PathBuf)> = entries
-            .into_iter()
-            .filter_map(|e| {
-                let name = e.file_name();
-                let name_str = name.to_string_lossy();
-                // Extract index from "payload_NNN.json"
-                let index_str = name_str.strip_prefix("payload_")?.strip_suffix(".json")?;
-                let index: u64 = index_str.parse().ok()?;
-                Some((index, e.path()))
-            })
-            .collect();
-
-        indexed_paths.sort_by_key(|(idx, _)| *idx);
-
-        // Apply skip and count
-        let indexed_paths: Vec<_> = indexed_paths.into_iter().skip(self.skip).collect();
-        let indexed_paths: Vec<_> = match self.count {
-            Some(count) => indexed_paths.into_iter().take(count).collect(),
-            None => indexed_paths,
-        };
-
-        // Load each payload
-        for (index, path) in indexed_paths {
-            let content = std::fs::read_to_string(&path)
-                .wrap_err_with(|| format!("Failed to read {:?}", path))?;
-            let envelope: ExecutionPayloadEnvelopeV4 = serde_json::from_str(&content)
-                .wrap_err_with(|| format!("Failed to parse {:?}", path))?;
-
-            let block_hash =
-                envelope.envelope_inner.execution_payload.payload_inner.payload_inner.block_hash;
-
-            info!(
-                index = index,
-                block_hash = %block_hash,
-                path = %path.display(),
-                "Loaded payload"
-            );
-
-            payloads.push(LoadedPayload { index, envelope, block_hash });
-        }
-
-        Ok(payloads)
-    }
-
-    /// Load and parse gas ramp payload files from a directory.
-    fn load_gas_ramp_payloads(&self, dir: &PathBuf) -> eyre::Result<Vec<GasRampPayload>> {
-        let mut payloads = Vec::new();
-
-        let entries: Vec<_> = std::fs::read_dir(dir)
-            .wrap_err_with(|| format!("Failed to read directory {:?}", dir))?
-            .filter_map(|e| e.ok())
-            .filter(|e| {
-                e.path().extension().and_then(|s| s.to_str()) == Some("json") &&
-                    e.file_name().to_string_lossy().starts_with("payload_block_")
-            })
-            .collect();
-
-        // Parse filenames to get block numbers and sort
-        let mut indexed_paths: Vec<(u64, PathBuf)> = entries
-            .into_iter()
-            .filter_map(|e| {
-                let name = e.file_name();
-                let name_str = name.to_string_lossy();
-                // Extract block number from "payload_block_NNN.json"
-                let block_str = name_str.strip_prefix("payload_block_")?.strip_suffix(".json")?;
-                let block_number: u64 = block_str.parse().ok()?;
-                Some((block_number, e.path()))
-            })
-            .collect();
-
-        indexed_paths.sort_by_key(|(num, _)| *num);
-
-        for (block_number, path) in indexed_paths {
-            let content = std::fs::read_to_string(&path)
-                .wrap_err_with(|| format!("Failed to read {:?}", path))?;
-            let file: GasRampPayloadFile = serde_json::from_str(&content)
-                .wrap_err_with(|| format!("Failed to parse {:?}", path))?;
-
-            let version = match file.version {
-                1 => EngineApiMessageVersion::V1,
-                2 => EngineApiMessageVersion::V2,
-                3 => EngineApiMessageVersion::V3,
-                4 => EngineApiMessageVersion::V4,
-                5 => EngineApiMessageVersion::V5,
-                v => return Err(eyre::eyre!("Invalid version {} in {:?}", v, path)),
-            };
-
-            info!(
-                block_number,
-                block_hash = %file.block_hash,
-                path = %path.display(),
-                "Loaded gas ramp payload"
-            );
-
-            payloads.push(GasRampPayload { block_number, version, file });
-        }
-
-        Ok(payloads)
-    }
-
-    async fn execute_payload_v4(
-        &self,
-        provider: &RootProvider<AnyNetwork>,
-        envelope: &ExecutionPayloadEnvelopeV4,
-        parent_hash: B256,
-    ) -> eyre::Result<()> {
-        let block_hash =
-            envelope.envelope_inner.execution_payload.payload_inner.payload_inner.block_hash;
-
-        debug!(
-            method = "engine_newPayloadV4",
-            block_hash = %block_hash,
-            "Sending newPayload"
-        );
-
-        let status = provider
-            .new_payload_v4(
-                envelope.envelope_inner.execution_payload.clone(),
-                vec![],
-                B256::ZERO,
-                envelope.execution_requests.to_vec(),
-            )
-            .await?;
-
-        info!(?status, "newPayloadV4 response");
-
-        if !status.is_valid() {
-            return Err(eyre::eyre!("Payload rejected: {:?}", status));
-        }
-
-        let fcu_state = ForkchoiceState {
-            head_block_hash: block_hash,
-            safe_block_hash: parent_hash,
-            finalized_block_hash: parent_hash,
-        };
-
-        debug!(method = "engine_forkchoiceUpdatedV3", ?fcu_state, "Sending forkchoiceUpdated");
-
-        let fcu_result = provider.fork_choice_updated_v3(fcu_state, None).await?;
-
-        info!(?fcu_result, "forkchoiceUpdatedV3 response");
-
-        Ok(())
-    }
-}
--- a/bin/reth-bench/src/valid_payload.rs
+++ b/bin/reth-bench/src/valid_payload.rs
@@ -3,16 +3,15 @@
 //! before sending additional calls.

 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,
+    ExecutionPayload, ExecutionPayloadInputV2, ForkchoiceState, ForkchoiceUpdated,
+    PayloadAttributes, PayloadStatus,
 };
 use alloy_transport::TransportResult;
 use op_alloy_rpc_types_engine::OpExecutionPayloadV4;
 use reth_node_api::EngineApiMessageVersion;
-use tracing::{debug, error};
+use tracing::error;

 /// An extension trait for providers that implement the engine API, to wait for a VALID response.
 #[async_trait::async_trait]
@@ -53,13 +52,6 @@ where
        fork_choice_state: ForkchoiceState,
        payload_attributes: Option<PayloadAttributes>,
    ) -> TransportResult<ForkchoiceUpdated> {
-        debug!(
-            method = "engine_forkchoiceUpdatedV1",
-            ?fork_choice_state,
-            ?payload_attributes,
-            "Sending forkchoiceUpdated"
-        );
-
        let mut status =
            self.fork_choice_updated_v1(fork_choice_state, payload_attributes.clone()).await?;

@@ -90,13 +82,6 @@ where
        fork_choice_state: ForkchoiceState,
        payload_attributes: Option<PayloadAttributes>,
    ) -> TransportResult<ForkchoiceUpdated> {
-        debug!(
-            method = "engine_forkchoiceUpdatedV2",
-            ?fork_choice_state,
-            ?payload_attributes,
-            "Sending forkchoiceUpdated"
-        );
-
        let mut status =
            self.fork_choice_updated_v2(fork_choice_state, payload_attributes.clone()).await?;

@@ -127,13 +112,6 @@ where
        fork_choice_state: ForkchoiceState,
        payload_attributes: Option<PayloadAttributes>,
    ) -> TransportResult<ForkchoiceUpdated> {
-        debug!(
-            method = "engine_forkchoiceUpdatedV3",
-            ?fork_choice_state,
-            ?payload_attributes,
-            "Sending forkchoiceUpdated"
-        );
-
        let mut status =
            self.fork_choice_updated_v3(fork_choice_state, payload_attributes.clone()).await?;

@@ -170,47 +148,33 @@ pub(crate) fn block_to_new_payload(

    // Convert to execution payload
    let (payload, sidecar) = ExecutionPayload::from_block_slow(&block);
-    payload_to_new_payload(payload, sidecar, is_optimism, block.withdrawals_root, None)
-}

-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)> {
    let (version, params) = match payload {
        ExecutionPayload::V3(payload) => {
            let cancun = sidecar.cancun().unwrap();

            if let Some(prague) = sidecar.prague() {
-                // Use target version if provided (for Osaka), otherwise default to V4
-                let version = target_version.unwrap_or(EngineApiMessageVersion::V4);
-
                if is_optimism {
-                    let withdrawals_root = withdrawals_root.ok_or_else(|| {
-                        eyre::eyre!("Missing withdrawals root for Optimism payload")
-                    })?;
                    (
-                        version,
+                        EngineApiMessageVersion::V4,
                        serde_json::to_value((
-                            OpExecutionPayloadV4 { payload_inner: payload, withdrawals_root },
+                            OpExecutionPayloadV4 {
+                                payload_inner: payload,
+                                withdrawals_root: block.withdrawals_root.unwrap(),
+                            },
                            cancun.versioned_hashes.clone(),
                            cancun.parent_beacon_block_root,
                            Requests::default(),
                        ))?,
                    )
                } else {
-                    // Extract actual Requests from RequestsOrHash
-                    let requests = prague.requests.requests_hash();
                    (
-                        version,
+                        EngineApiMessageVersion::V4,
                        serde_json::to_value((
                            payload,
                            cancun.versioned_hashes.clone(),
                            cancun.parent_beacon_block_root,
-                            requests,
+                            prague.requests.requests_hash(),
                        ))?,
                    )
                }
@@ -253,8 +217,6 @@ pub(crate) async fn call_new_payload<N: Network, P: Provider<N>>(
 ) -> TransportResult<()> {
    let method = version.method_name();

-    debug!(method, "Sending newPayload");
-
    let mut status: PayloadStatus = provider.client().request(method, &params).await?;

    while !status.is_valid() {
@@ -275,15 +237,12 @@ pub(crate) async fn call_new_payload<N: Network, P: Provider<N>>(
 /// Calls the correct `engine_forkchoiceUpdated` method depending on the given
 /// `EngineApiMessageVersion`, using the provided forkchoice state and payload attributes for the
 /// actual engine api message call.
-///
-/// Note: For Prague (V4), we still use forkchoiceUpdatedV3 as there is no V4.
 pub(crate) async fn call_forkchoice_updated<N, P: EngineApiValidWaitExt<N>>(
    provider: P,
    message_version: EngineApiMessageVersion,
    forkchoice_state: ForkchoiceState,
    payload_attributes: Option<PayloadAttributes>,
 ) -> TransportResult<ForkchoiceUpdated> {
-    // FCU V3 is used for both Cancun and Prague (there is no FCU V4)
    match message_version {
        EngineApiMessageVersion::V3 | EngineApiMessageVersion::V4 | EngineApiMessageVersion::V5 => {
            provider.fork_choice_updated_v3_wait(forkchoice_state, payload_attributes).await
--- a/bin/reth/Cargo.toml
+++ b/bin/reth/Cargo.toml
@@ -81,16 +81,12 @@ backon.workspace = true
 tempfile.workspace = true

 [features]
-default = ["jemalloc", "otlp", "otlp-logs", "reth-revm/portable", "js-tracer", "keccak-cache-global", "asm-keccak"]
+default = ["jemalloc", "otlp", "reth-revm/portable", "js-tracer", "keccak-cache-global", "asm-keccak"]

 otlp = [
    "reth-ethereum-cli/otlp",
    "reth-node-core/otlp",
 ]
-otlp-logs = [
-    "reth-ethereum-cli/otlp-logs",
-    "reth-node-core/otlp-logs",
-]
 js-tracer = [
    "reth-node-builder/js-tracer",
    "reth-node-ethereum/js-tracer",
@@ -120,11 +116,6 @@ jemalloc-prof = [
    "reth-cli-util/jemalloc",
    "reth-cli-util/jemalloc-prof",
    "reth-ethereum-cli/jemalloc-prof",
-    "reth-node-metrics/jemalloc-prof",
-]
-jemalloc-symbols = [
-    "jemalloc-prof",
-    "reth-ethereum-cli/jemalloc-symbols",
 ]
 jemalloc-unprefixed = [
    "reth-cli-util/jemalloc-unprefixed",
@@ -135,11 +126,6 @@ jemalloc-unprefixed = [
 tracy-allocator = [
    "reth-cli-util/tracy-allocator",
    "reth-ethereum-cli/tracy-allocator",
-    "tracy",
-]
-tracy = [
-    "reth-ethereum-cli/tracy",
-    "reth-node-core/tracy",
 ]

 # Because jemalloc is default and preferred over snmalloc when both features are
@@ -180,8 +166,6 @@ min-trace-logs = [
    "reth-node-core/min-trace-logs",
 ]

-edge = ["reth-ethereum-cli/edge", "reth-node-core/edge"]
-
 [[bin]]
 name = "reth"
 path = "src/main.rs"
--- a/bin/reth/src/lib.rs
+++ b/bin/reth/src/lib.rs
@@ -2,46 +2,22 @@
 //!
 //! ## Feature Flags
 //!
-//! ### Default Features
-//!
 //! - `jemalloc`: Uses [jemallocator](https://github.com/tikv/jemallocator) as the global allocator.
 //!   This is **not recommended on Windows**. See [here](https://rust-lang.github.io/rfcs/1974-global-allocators.html#jemalloc)
 //!   for more info.
-//! - `otlp`: Enables [OpenTelemetry](https://opentelemetry.io/) metrics export to a configured OTLP
-//!   collector endpoint.
-//! - `js-tracer`: Enables the `JavaScript` tracer for the `debug_trace` endpoints, allowing custom
-//!   `JavaScript`-based transaction tracing.
-//! - `keccak-cache-global`: Enables global caching for Keccak256 hashes to improve performance.
-//! - `asm-keccak`: Replaces the default, pure-Rust implementation of Keccak256 with one implemented
-//!   in assembly; see [the `keccak-asm` crate](https://github.com/DaniPopes/keccak-asm) for more
-//!   details and supported targets.
-//!
-//! ### Allocator Features
-//!
 //! - `jemalloc-prof`: Enables [jemallocator's](https://github.com/tikv/jemallocator) heap profiling
 //!   and leak detection functionality. See [jemalloc's opt.prof](https://jemalloc.net/jemalloc.3.html#opt.prof)
-//!   documentation for usage details. This is **not recommended on Windows**.
-//! - `jemalloc-symbols`: Enables jemalloc symbols for profiling. Includes `jemalloc-prof`.
-//! - `jemalloc-unprefixed`: Uses unprefixed jemalloc symbols.
-//! - `tracy-allocator`: Enables [Tracy](https://github.com/wolfpld/tracy) profiler allocator
-//!   integration for memory profiling.
-//! - `snmalloc`: Uses [snmalloc](https://github.com/snmalloc/snmalloc) as the global allocator. Use
-//!   `--no-default-features` when enabling this, as jemalloc takes precedence.
-//! - `snmalloc-native`: Uses snmalloc with native CPU optimizations. Use `--no-default-features`
-//!   when enabling this.
-//!
-//! ### Log Level Features
-//!
+//!   documentation for usage details. This is **not recommended on Windows**. See [here](https://rust-lang.github.io/rfcs/1974-global-allocators.html#jemalloc)
+//!   for more info.
+//! - `asm-keccak`: replaces the default, pure-Rust implementation of Keccak256 with one implemented
+//!   in assembly; see [the `keccak-asm` crate](https://github.com/DaniPopes/keccak-asm) for more
+//!   details and supported targets
 //! - `min-error-logs`: Disables all logs below `error` level.
 //! - `min-warn-logs`: Disables all logs below `warn` level.
 //! - `min-info-logs`: Disables all logs below `info` level. This can speed up the node, since fewer
 //!   calls to the logging component are made.
 //! - `min-debug-logs`: Disables all logs below `debug` level.
 //! - `min-trace-logs`: Disables all logs below `trace` level.
-//!
-//! ### Development Features
-//!
-//! - `dev`: Enables development mode features, including test vector generation commands.

 #![doc(
    html_logo_url = "https://raw.githubusercontent.com/paradigmxyz/reth/main/assets/reth-docs.png",
@@ -194,7 +170,7 @@ pub mod rpc {
        pub use reth_rpc::eth::*;
    }

-    /// Re-exported from `reth_rpc_server_types::result`.
+    /// Re-exported from `reth_rpc::rpc`.
    pub mod result {
        pub use reth_rpc_server_types::result::*;
    }
--- a/bin/reth/src/main.rs
+++ b/bin/reth/src/main.rs
@@ -3,10 +3,6 @@
 #[global_allocator]
 static ALLOC: reth_cli_util::allocator::Allocator = reth_cli_util::allocator::new_allocator();

-#[cfg(all(feature = "jemalloc-prof", unix))]
-#[unsafe(export_name = "_rjem_malloc_conf")]
-static MALLOC_CONF: &[u8] = b"prof:true,prof_active:true,lg_prof_sample:19\0";
-
 use clap::Parser;
 use reth::{args::RessArgs, cli::Cli, ress::install_ress_subprotocol};
 use reth_ethereum_cli::chainspec::EthereumChainSpecParser;
--- a/crates/chain-state/src/chain_info.rs
+++ b/crates/chain-state/src/chain_info.rs
@@ -33,7 +33,6 @@ where
    ) -> Self {
        let (finalized_block, _) = watch::channel(finalized);
        let (safe_block, _) = watch::channel(safe);
-        let (persisted_block, _) = watch::channel(None);

        Self {
            inner: Arc::new(ChainInfoInner {
@@ -43,7 +42,6 @@ where
                canonical_head: RwLock::new(head),
                safe_block,
                finalized_block,
-                persisted_block,
            }),
        }
    }
@@ -99,11 +97,6 @@ where
        self.inner.finalized_block.borrow().as_ref().map(SealedHeader::num_hash)
    }

-    /// Returns the `BlockNumHash` of the persisted block.
-    pub fn get_persisted_num_hash(&self) -> Option<BlockNumHash> {
-        *self.inner.persisted_block.borrow()
-    }
-
    /// Sets the canonical head of the chain.
    pub fn set_canonical_head(&self, header: SealedHeader<N::BlockHeader>) {
        let number = header.number();
@@ -137,18 +130,6 @@ where
        });
    }

-    /// Sets the persisted block of the chain.
-    pub fn set_persisted(&self, num_hash: BlockNumHash) {
-        self.inner.persisted_block.send_if_modified(|current| {
-            if current.map(|b| b.hash) != Some(num_hash.hash) {
-                let _ = current.replace(num_hash);
-                return true
-            }
-
-            false
-        });
-    }
-
    /// Subscribe to the finalized block.
    pub fn subscribe_finalized_block(
        &self,
@@ -160,11 +141,6 @@ where
    pub fn subscribe_safe_block(&self) -> watch::Receiver<Option<SealedHeader<N::BlockHeader>>> {
        self.inner.safe_block.subscribe()
    }
-
-    /// Subscribe to the persisted block.
-    pub fn subscribe_persisted_block(&self) -> watch::Receiver<Option<BlockNumHash>> {
-        self.inner.persisted_block.subscribe()
-    }
 }

 /// Container type for all chain info fields
@@ -183,14 +159,11 @@ struct ChainInfoInner<N: NodePrimitives = reth_ethereum_primitives::EthPrimitive
    safe_block: watch::Sender<Option<SealedHeader<N::BlockHeader>>>,
    /// The block that the beacon node considers finalized.
    finalized_block: watch::Sender<Option<SealedHeader<N::BlockHeader>>>,
-    /// The last block that was persisted to disk.
-    persisted_block: watch::Sender<Option<BlockNumHash>>,
 }

 #[cfg(test)]
 mod tests {
    use super::*;
-    use alloy_primitives::B256;
    use reth_ethereum_primitives::EthPrimitives;
    use reth_testing_utils::{generators, generators::random_header};

@@ -365,28 +338,4 @@ mod tests {
        // Assert that the BlockNumHash returned matches the safe header
        assert_eq!(tracker.get_safe_num_hash(), Some(safe_header.num_hash()));
    }
-
-    #[test]
-    fn test_set_persisted() {
-        let mut rng = generators::rng();
-        let header = random_header(&mut rng, 10, None);
-        let tracker: ChainInfoTracker<EthPrimitives> = ChainInfoTracker::new(header, None, None);
-
-        // Initial state: persisted block should be None
-        assert!(tracker.get_persisted_num_hash().is_none());
-
-        // Set a persisted block
-        let num_hash1 = BlockNumHash::new(10, B256::random());
-        tracker.set_persisted(num_hash1);
-        assert_eq!(tracker.get_persisted_num_hash(), Some(num_hash1));
-
-        // Setting the same block again should not change anything
-        tracker.set_persisted(num_hash1);
-        assert_eq!(tracker.get_persisted_num_hash(), Some(num_hash1));
-
-        // Set a different block
-        let num_hash2 = BlockNumHash::new(20, B256::random());
-        tracker.set_persisted(num_hash2);
-        assert_eq!(tracker.get_persisted_num_hash(), Some(num_hash2));
-    }
 }
--- a/crates/chain-state/src/deferred_trie.rs
+++ b/crates/chain-state/src/deferred_trie.rs
@@ -37,19 +37,27 @@ pub struct ComputedTrieData {

 /// Trie input bundled with its anchor hash.
 ///
-/// The `trie_input` contains the **cumulative** overlay of all in-memory ancestor blocks,
-/// not just this block's changes. Child blocks reuse the parent's overlay in O(1) by
-/// cloning the Arc-wrapped data.
+/// This is used to store the trie input and anchor hash for a block together.
+/// The `trie_input` contains the **cumulative** overlay of all in-memory ancestor blocks
+/// since the anchor, not just this block's changes. This enables O(1) overlay reuse
+/// when building child blocks with the same anchor.
 ///
-/// The `anchor_hash` is metadata indicating which persisted base state this overlay
-/// sits on top of. It is CRITICAL for overlay reuse decisions: an overlay built on top
-/// of Anchor A cannot be reused for a block anchored to Anchor B, as it would result
-/// in an incorrect state.
+/// # Invariants
+///
+/// For correctness of overlay reuse optimizations:
+/// - The `ancestors` passed to [`DeferredTrieData::pending`] must form a true ancestor chain (each
+///   entry's parent is the previous entry, oldest to newest order)
+/// - When `anchor_hash` matches the parent's `anchor_hash`, the parent's `trie_input` already
+///   contains all ancestors in that chain, enabling O(1) reuse
+/// - A given `anchor_hash` uniquely identifies a persisted base state
 #[derive(Clone, Debug)]
 pub struct AnchoredTrieInput {
    /// The persisted ancestor hash this trie input is anchored to.
    pub anchor_hash: B256,
-    /// Cumulative trie input overlay from all in-memory ancestors.
+    /// Cumulative trie input overlay from all in-memory ancestors since the anchor.
+    /// Note: This is the merged overlay, not just this block's changes.
+    /// The per-block changes are in [`ComputedTrieData::hashed_state`] and
+    /// [`ComputedTrieData::trie_updates`].
    pub trie_input: Arc<TrieInputSorted>,
 }

@@ -61,6 +69,12 @@ struct DeferredTrieMetrics {
    deferred_trie_async_ready: Counter,
    /// Number of times deferred trie data required synchronous computation (fallback path).
    deferred_trie_sync_fallback: Counter,
+    /// Number of times the parent's trie overlay was reused (O(1) fast path).
+    deferred_trie_overlay_reused: Counter,
+    /// Number of times the trie overlay was rebuilt from all ancestors (O(N) slow path).
+    deferred_trie_overlay_rebuilt: Counter,
+    /// Number of times `Arc::make_mut` triggered a clone (`strong_count` > 1).
+    deferred_trie_arc_clone_triggered: Counter,
 }

 static DEFERRED_TRIE_METRICS: LazyLock<DeferredTrieMetrics> =
@@ -69,8 +83,7 @@ static DEFERRED_TRIE_METRICS: LazyLock<DeferredTrieMetrics> =
 /// Internal state for deferred trie data.
 enum DeferredState {
    /// Data is not yet available; raw inputs stored for fallback computation.
-    /// Wrapped in `Option` to allow taking ownership during computation.
-    Pending(Option<PendingInputs>),
+    Pending(PendingInputs),
    /// Data has been computed and is ready.
    Ready(ComputedTrieData),
 }
@@ -120,12 +133,12 @@ impl DeferredTrieData {
        ancestors: Vec<Self>,
    ) -> Self {
        Self {
-            state: Arc::new(Mutex::new(DeferredState::Pending(Some(PendingInputs {
+            state: Arc::new(Mutex::new(DeferredState::Pending(PendingInputs {
                hashed_state,
                trie_updates,
                anchor_hash,
                ancestors,
-            })))),
+            }))),
        }
    }

@@ -146,10 +159,16 @@ impl DeferredTrieData {
    ///
    /// # Process
    /// 1. Sort the current block's hashed state and trie updates
-    /// 2. Reuse parent's cached overlay if available (O(1) - the common case)
-    /// 3. Otherwise, rebuild overlay from ancestors (rare fallback)
+    /// 2. Try to reuse parent's overlay if anchor matches (O(1) fast path)
+    /// 3. Otherwise, merge all ancestor overlays (O(N) slow path, rare after persist/reorg)
    /// 4. Extend the overlay with this block's sorted data
    ///
+    /// # Complexity
+    /// - Normal case (same anchor as parent): O(1) - just clone parent's overlay
+    /// - After persist/reorg (anchor mismatch): O(N) - merge all ancestors once
+    ///
+    /// This eliminates the previous O(N²) complexity where each block re-merged all ancestors.
+    ///
    /// Used by both the async background task and the synchronous fallback path.
    ///
    /// # Arguments
@@ -158,98 +177,113 @@ impl DeferredTrieData {
    /// * `anchor_hash` - The persisted ancestor hash this trie input is anchored to
    /// * `ancestors` - Deferred trie data from ancestor blocks for merging (oldest -> newest)
    pub fn sort_and_build_trie_input(
-        hashed_state: Arc<HashedPostState>,
-        trie_updates: Arc<TrieUpdates>,
+        hashed_state: &HashedPostState,
+        trie_updates: &TrieUpdates,
        anchor_hash: B256,
        ancestors: &[Self],
    ) -> ComputedTrieData {
-        let sorted_hashed_state = match Arc::try_unwrap(hashed_state) {
-            Ok(state) => state.into_sorted(),
-            Err(arc) => arc.clone_into_sorted(),
-        };
-        let sorted_trie_updates = match Arc::try_unwrap(trie_updates) {
-            Ok(updates) => updates.into_sorted(),
-            Err(arc) => arc.clone_into_sorted(),
-        };
+        // Sort the current block's hashed state and trie updates
+        let sorted_hashed_state = Arc::new(hashed_state.clone_into_sorted());
+        let sorted_trie_updates = Arc::new(trie_updates.clone_into_sorted());

-        // Reuse parent's overlay if available and anchors match.
-        // We can only reuse the parent's overlay if it was built on top of the same
-        // persisted anchor. If the anchor has changed (e.g., due to persistence),
-        // the parent's overlay is relative to an old state and cannot be used.
-        let overlay = if let Some(parent) = ancestors.last() {
+        // Determine base overlay by checking if we can reuse parent's overlay
+        let mut overlay = if let Some(parent) = ancestors.last() {
            let parent_data = parent.wait_cloned();

            match &parent_data.anchored_trie_input {
-                // Case 1: Parent has cached overlay AND anchors match.
+                // Fast path: reuse parent's already-merged overlay if anchors match.
+                // Parent's overlay already contains all ancestors merged, so we just clone
+                // the Arc-wrapped nodes and state (O(1)).
+                //
+                // IMPORTANT: We do NOT clone prefix_sets from the parent overlay.
+                // Prefix sets only need to represent the current block's changes, not
+                // cumulative ancestor changes. The incremental state root algorithms
+                // use prefix_sets to identify which trie branches changed since the
+                // last root computation - ancestors' changes are already embodied in
+                // the trie nodes. This matches the pattern in merkle_changesets.rs
+                // which explicitly uses per-block prefix sets.
                Some(AnchoredTrieInput { anchor_hash: parent_anchor, trie_input })
                    if *parent_anchor == anchor_hash =>
                {
-                    // O(1): Reuse parent's overlay, extend with current block's data.
-                    let mut overlay = TrieInputSorted::new(
+                    DEFERRED_TRIE_METRICS.deferred_trie_overlay_reused.increment(1);
+                    TrieInputSorted::new(
                        Arc::clone(&trie_input.nodes),
                        Arc::clone(&trie_input.state),
-                        Default::default(), // prefix_sets are per-block, not cumulative
-                    );
-                    // Only trigger COW clone if there's actually data to add.
-                    if !sorted_hashed_state.is_empty() {
-                        Arc::make_mut(&mut overlay.state).extend_ref_and_sort(&sorted_hashed_state);
-                    }
-                    if !sorted_trie_updates.is_empty() {
-                        Arc::make_mut(&mut overlay.nodes).extend_ref_and_sort(&sorted_trie_updates);
-                    }
-                    overlay
+                        Default::default(), // Fresh prefix_sets - will be set by caller
+                    )
+                }
+
+                // Slow path: no matching parent overlay -> rebuild from all ancestors.
+                // This happens after persist (anchor changes) or if parent lacks anchored input.
+                // O(N) but only at persist/reorg boundaries, not per block.
+                _ => {
+                    DEFERRED_TRIE_METRICS.deferred_trie_overlay_rebuilt.increment(1);
+                    Self::merge_ancestors_into_overlay(ancestors)
                }
-                // Case 2: Parent exists but anchor mismatch or no cached overlay.
-                // We must rebuild from the ancestors list (which only contains unpersisted blocks).
-                _ => Self::merge_ancestors_into_overlay(
-                    ancestors,
-                    &sorted_hashed_state,
-                    &sorted_trie_updates,
-                ),
            }
        } else {
-            // Case 3: No in-memory ancestors (first block after persisted anchor).
-            // Build overlay with just this block's data.
-            Self::merge_ancestors_into_overlay(&[], &sorted_hashed_state, &sorted_trie_updates)
+            // No ancestors: start from empty overlay (first block after anchor)
+            TrieInputSorted::default()
        };

+        // Extend overlay with current block's sorted data.
+        // Track if Arc::make_mut triggers a clone (strong_count > 1 means parent still holds ref).
+        {
+            let will_clone = Arc::strong_count(&overlay.state) > 1;
+            if will_clone {
+                DEFERRED_TRIE_METRICS.deferred_trie_arc_clone_triggered.increment(1);
+            }
+            let state_mut = Arc::make_mut(&mut overlay.state);
+            state_mut.extend_ref(sorted_hashed_state.as_ref());
+        }
+        {
+            let will_clone = Arc::strong_count(&overlay.nodes) > 1;
+            if will_clone {
+                DEFERRED_TRIE_METRICS.deferred_trie_arc_clone_triggered.increment(1);
+            }
+            let nodes_mut = Arc::make_mut(&mut overlay.nodes);
+            nodes_mut.extend_ref(sorted_trie_updates.as_ref());
+        }
+
        ComputedTrieData::with_trie_input(
-            Arc::new(sorted_hashed_state),
-            Arc::new(sorted_trie_updates),
+            sorted_hashed_state,
+            sorted_trie_updates,
            anchor_hash,
            Arc::new(overlay),
        )
    }

-    /// Merge all ancestors and current block's data into a single overlay.
+    /// Merge all ancestors into a single overlay.
    ///
-    /// This is a rare fallback path, only used when no ancestor has a cached
-    /// `anchored_trie_input` (e.g., blocks created via alternative constructors).
-    /// In normal operation, the parent always has a cached overlay and this
-    /// function is never called.
+    /// This is the slow path used when the parent's overlay cannot be reused
+    /// (e.g., after persist when anchor changes). Iterates ancestors oldest -> newest
+    /// so newer state takes precedence.
    ///
-    /// Iterates ancestors oldest -> newest, then extends with current block's data,
-    /// so later state takes precedence.
-    fn merge_ancestors_into_overlay(
-        ancestors: &[Self],
-        sorted_hashed_state: &HashedPostStateSorted,
-        sorted_trie_updates: &TrieUpdatesSorted,
-    ) -> TrieInputSorted {
+    /// Note: We intentionally do NOT reuse ancestor cached overlays here because
+    /// those overlays were built with a different anchor_hash. The slow path is
+    /// triggered precisely because the anchor changed, so we must rebuild from
+    /// each ancestor's per-block state changes.
+    fn merge_ancestors_into_overlay(ancestors: &[Self]) -> TrieInputSorted {
        let mut overlay = TrieInputSorted::default();
-
-        let state_mut = Arc::make_mut(&mut overlay.state);
-        let nodes_mut = Arc::make_mut(&mut overlay.nodes);
-
        for ancestor in ancestors {
            let ancestor_data = ancestor.wait_cloned();
-            state_mut.extend_ref_and_sort(ancestor_data.hashed_state.as_ref());
-            nodes_mut.extend_ref_and_sort(ancestor_data.trie_updates.as_ref());
+            {
+                let will_clone = Arc::strong_count(&overlay.state) > 1;
+                if will_clone {
+                    DEFERRED_TRIE_METRICS.deferred_trie_arc_clone_triggered.increment(1);
+                }
+                let state_mut = Arc::make_mut(&mut overlay.state);
+                state_mut.extend_ref(ancestor_data.hashed_state.as_ref());
+            }
+            {
+                let will_clone = Arc::strong_count(&overlay.nodes) > 1;
+                if will_clone {
+                    DEFERRED_TRIE_METRICS.deferred_trie_arc_clone_triggered.increment(1);
+                }
+                let nodes_mut = Arc::make_mut(&mut overlay.nodes);
+                nodes_mut.extend_ref(ancestor_data.trie_updates.as_ref());
+            }
        }
-
-        // Extend with current block's sorted data last (takes precedence)
-        state_mut.extend_ref_and_sort(sorted_hashed_state);
-        nodes_mut.extend_ref_and_sort(sorted_trie_updates);
-
        overlay
    }

@@ -267,7 +301,7 @@ impl DeferredTrieData {
    #[instrument(level = "debug", target = "engine::tree::deferred_trie", skip_all)]
    pub fn wait_cloned(&self) -> ComputedTrieData {
        let mut state = self.state.lock();
-        match &mut *state {
+        match &*state {
            // If the deferred trie data is ready, return the cached result.
            DeferredState::Ready(bundle) => {
                DEFERRED_TRIE_METRICS.deferred_trie_async_ready.increment(1);
@@ -275,23 +309,15 @@ impl DeferredTrieData {
            }
            // If the deferred trie data is pending, compute the trie data synchronously and return
            // the result. This is the fallback path if the async task hasn't completed.
-            DeferredState::Pending(maybe_inputs) => {
+            DeferredState::Pending(inputs) => {
                DEFERRED_TRIE_METRICS.deferred_trie_sync_fallback.increment(1);
-
-                let inputs = maybe_inputs.take().expect("inputs must be present in Pending state");
-
                let computed = Self::sort_and_build_trie_input(
-                    inputs.hashed_state,
-                    inputs.trie_updates,
+                    &inputs.hashed_state,
+                    &inputs.trie_updates,
                    inputs.anchor_hash,
                    &inputs.ancestors,
                );
                *state = DeferredState::Ready(computed.clone());
-
-                // Release lock before inputs (and its ancestors) drop to avoid holding it
-                // while their potential last Arc refs drop (which could trigger recursive locking)
-                drop(state);
-
                computed
            }
        }
@@ -521,7 +547,7 @@ mod tests {
        let hashed_state = Arc::new(HashedPostStateSorted::new(accounts, B256Map::default()));
        let trie_updates = Arc::default();
        let mut overlay = TrieInputSorted::default();
-        Arc::make_mut(&mut overlay.state).extend_ref_and_sort(hashed_state.as_ref());
+        Arc::make_mut(&mut overlay.state).extend_ref(hashed_state.as_ref());

        DeferredTrieData::ready(ComputedTrieData {
            hashed_state,
@@ -559,9 +585,9 @@ mod tests {
        assert_eq!(found_account.unwrap().nonce, 1);
    }

-    /// Verifies that parent's overlay is reused regardless of anchor.
+    /// Verifies that when parent has matching anchor, its overlay is reused (O(1) fast path).
    #[test]
-    fn reuses_parent_overlay() {
+    fn reuses_parent_overlay_when_anchor_matches() {
        let anchor = B256::with_last_byte(1);
        let key = B256::with_last_byte(42);
        let account = Account { nonce: 100, balance: U256::ZERO, bytecode_hash: None };
@@ -569,11 +595,11 @@ mod tests {
        // Create parent with anchored trie input
        let parent = ready_block_with_state(anchor, vec![(key, Some(account))]);

-        // Create child - should reuse parent's overlay
+        // Create child with same anchor - should reuse parent's overlay
        let child = DeferredTrieData::pending(
            Arc::new(HashedPostState::default()),
            Arc::new(TrieUpdates::default()),
-            anchor,
+            anchor, // Same anchor as parent
            vec![parent],
        );

@@ -588,9 +614,7 @@ mod tests {
        assert_eq!(found_account.unwrap().nonce, 100);
    }

-    /// Verifies that parent's overlay is NOT reused when anchor changes (after persist).
-    /// The overlay data is dependent on the anchor, so it must be rebuilt from the
-    /// remaining ancestors.
+    /// Verifies that when anchor changes (after persist), all ancestors are rebuilt.
    #[test]
    fn rebuilds_overlay_when_anchor_changes() {
        let old_anchor = B256::with_last_byte(1);
@@ -602,25 +626,19 @@ mod tests {
        let parent = ready_block_with_state(old_anchor, vec![(key, Some(account))]);

        // Create child with NEW anchor (simulates after persist)
-        // Should NOT reuse parent's overlay because anchor changed
        let child = DeferredTrieData::pending(
            Arc::new(HashedPostState::default()),
            Arc::new(TrieUpdates::default()),
-            new_anchor,
+            new_anchor, // Different anchor - triggers rebuild
            vec![parent],
        );

        let result = child.wait_cloned();

-        // Verify result uses new anchor
+        // Verify result uses new anchor and still has parent's data
        let overlay = result.anchored_trie_input.as_ref().unwrap();
        assert_eq!(overlay.anchor_hash, new_anchor);
-
-        // Crucially, since we provided `parent` in ancestors but it has a different anchor,
-        // the code falls back to `merge_ancestors_into_overlay`.
-        // `merge_ancestors_into_overlay` reads `parent.hashed_state` (which has the account).
-        // So the account IS present, but it was obtained via REBUILD, not REUSE.
-        // We can check `DEFERRED_TRIE_METRICS` if we want to be sure, but functionally:
+        // Parent's account should still be in the overlay (from rebuild)
        assert_eq!(overlay.trie_input.state.accounts.len(), 1);
        let (found_key, found_account) = &overlay.trie_input.state.accounts[0];
        assert_eq!(*found_key, key);
@@ -790,87 +808,4 @@ mod tests {
        let overlay = final_result.anchored_trie_input.as_ref().unwrap();
        assert_eq!(overlay.trie_input.state.accounts.len(), num_blocks);
    }
-
-    /// Verifies that a multi-ancestor overlay is rebuilt when anchor changes.
-    /// This simulates the "persist prefix then keep building" scenario where:
-    /// 1. A chain of blocks is built with anchor A
-    /// 2. Some blocks are persisted, changing anchor to B
-    /// 3. New blocks must rebuild the overlay from the remaining ancestors
-    #[test]
-    fn multi_ancestor_overlay_rebuilt_after_anchor_change() {
-        let old_anchor = B256::with_last_byte(1);
-        let new_anchor = B256::with_last_byte(2);
-        let key1 = B256::with_last_byte(1);
-        let key2 = B256::with_last_byte(2);
-        let key3 = B256::with_last_byte(3);
-        let key4 = B256::with_last_byte(4);
-
-        // Build a chain of 3 blocks with old_anchor
-        let block1 = ready_block_with_state(
-            old_anchor,
-            vec![(key1, Some(Account { nonce: 1, balance: U256::ZERO, bytecode_hash: None }))],
-        );
-
-        let block2_hashed = HashedPostState::default().with_accounts([(
-            key2,
-            Some(Account { nonce: 2, balance: U256::ZERO, bytecode_hash: None }),
-        )]);
-        let block2 = DeferredTrieData::pending(
-            Arc::new(block2_hashed),
-            Arc::new(TrieUpdates::default()),
-            old_anchor,
-            vec![block1.clone()],
-        );
-        let block2_ready = DeferredTrieData::ready(block2.wait_cloned());
-
-        let block3_hashed = HashedPostState::default().with_accounts([(
-            key3,
-            Some(Account { nonce: 3, balance: U256::ZERO, bytecode_hash: None }),
-        )]);
-        let block3 = DeferredTrieData::pending(
-            Arc::new(block3_hashed),
-            Arc::new(TrieUpdates::default()),
-            old_anchor,
-            vec![block1.clone(), block2_ready.clone()],
-        );
-        let block3_ready = DeferredTrieData::ready(block3.wait_cloned());
-
-        // Verify block3's overlay has all 3 accounts with old_anchor
-        let block3_overlay = block3_ready.wait_cloned().anchored_trie_input.unwrap();
-        assert_eq!(block3_overlay.anchor_hash, old_anchor);
-        assert_eq!(block3_overlay.trie_input.state.accounts.len(), 3);
-
-        // Now simulate persist: create block4 with NEW anchor but same ancestors.
-        // To verify correct rebuilding, we must provide ALL unpersisted ancestors.
-        // If we only provided block3, the rebuild would only see block3's state.
-        // We pass block1, block2, block3 to simulate that they are all still in memory
-        // but the anchor check forces a rebuild (e.g. artificial anchor change).
-        let block4_hashed = HashedPostState::default().with_accounts([(
-            key4,
-            Some(Account { nonce: 4, balance: U256::ZERO, bytecode_hash: None }),
-        )]);
-        let block4 = DeferredTrieData::pending(
-            Arc::new(block4_hashed),
-            Arc::new(TrieUpdates::default()),
-            new_anchor, // Different anchor - simulates post-persist
-            vec![block1, block2_ready, block3_ready],
-        );
-
-        let result = block4.wait_cloned();
-
-        // Verify:
-        // 1. New anchor is used in result
-        assert_eq!(result.anchor_hash(), Some(new_anchor));
-
-        // 2. All 4 accounts are in the overlay (rebuilt from ancestors + extended)
-        let overlay = result.anchored_trie_input.as_ref().unwrap();
-        assert_eq!(overlay.trie_input.state.accounts.len(), 4);
-
-        // 3. All accounts have correct values
-        let accounts = &overlay.trie_input.state.accounts;
-        assert!(accounts.iter().any(|(k, a)| *k == key1 && a.unwrap().nonce == 1));
-        assert!(accounts.iter().any(|(k, a)| *k == key2 && a.unwrap().nonce == 2));
-        assert!(accounts.iter().any(|(k, a)| *k == key3 && a.unwrap().nonce == 3));
-        assert!(accounts.iter().any(|(k, a)| *k == key4 && a.unwrap().nonce == 4));
-    }
 }
--- a/crates/chain-state/src/in_memory.rs
+++ b/crates/chain-state/src/in_memory.rs
@@ -10,15 +10,15 @@ use alloy_primitives::{map::HashMap, BlockNumber, TxHash, B256};
 use parking_lot::RwLock;
 use reth_chainspec::ChainInfo;
 use reth_ethereum_primitives::EthPrimitives;
-use reth_execution_types::{BlockExecutionOutput, BlockExecutionResult, Chain, ExecutionOutcome};
+use reth_execution_types::{Chain, ExecutionOutcome};
 use reth_metrics::{metrics::Gauge, Metrics};
 use reth_primitives_traits::{
    BlockBody as _, IndexedTx, NodePrimitives, RecoveredBlock, SealedBlock, SealedHeader,
    SignedTransaction,
 };
 use reth_storage_api::StateProviderBox;
-use reth_trie::{updates::TrieUpdatesSorted, HashedPostStateSorted, LazyTrieData, TrieInputSorted};
-use std::{collections::BTreeMap, sync::Arc, time::Instant};
+use reth_trie::{updates::TrieUpdatesSorted, HashedPostStateSorted, TrieInputSorted};
+use std::{collections::BTreeMap, ops::Deref, sync::Arc, time::Instant};
 use tokio::sync::{broadcast, watch};

 /// Size of the broadcast channel used to notify canonical state events.
@@ -317,7 +317,6 @@ impl<N: NodePrimitives> CanonicalInMemoryState<N> {
    /// This will update the links between blocks and remove all blocks that are [..
    /// `persisted_height`].
    pub fn remove_persisted_blocks(&self, persisted_num_hash: BlockNumHash) {
-        self.set_persisted(persisted_num_hash);
        // if the persisted hash is not in the canonical in memory state, do nothing, because it
        // means canonical blocks were not actually persisted.
        //
@@ -445,11 +444,6 @@ impl<N: NodePrimitives> CanonicalInMemoryState<N> {
        self.inner.chain_info_tracker.set_finalized(header);
    }

-    /// Persisted block setter.
-    pub fn set_persisted(&self, num_hash: BlockNumHash) {
-        self.inner.chain_info_tracker.set_persisted(num_hash);
-    }
-
    /// Canonical head getter.
    pub fn get_canonical_head(&self) -> SealedHeader<N::BlockHeader> {
        self.inner.chain_info_tracker.get_canonical_head()
@@ -465,11 +459,6 @@ impl<N: NodePrimitives> CanonicalInMemoryState<N> {
        self.inner.chain_info_tracker.get_safe_header()
    }

-    /// Persisted block `BlockNumHash` getter.
-    pub fn get_persisted_num_hash(&self) -> Option<BlockNumHash> {
-        self.inner.chain_info_tracker.get_persisted_num_hash()
-    }
-
    /// Returns the `SealedHeader` corresponding to the pending state.
    pub fn pending_sealed_header(&self) -> Option<SealedHeader<N::BlockHeader>> {
        self.pending_state().map(|h| h.block_ref().recovered_block().clone_sealed_header())
@@ -522,11 +511,6 @@ impl<N: NodePrimitives> CanonicalInMemoryState<N> {
        self.inner.chain_info_tracker.subscribe_finalized_block()
    }

-    /// Subscribe to new persisted block events.
-    pub fn subscribe_persisted_block(&self) -> watch::Receiver<Option<BlockNumHash>> {
-        self.inner.chain_info_tracker.subscribe_persisted_block()
-    }
-
    /// Attempts to send a new [`CanonStateNotification`] to all active Receiver handles.
    pub fn notify_canon_state(&self, event: CanonStateNotification<N>) {
        self.inner.canon_state_notification_sender.send(event).ok();
@@ -648,7 +632,7 @@ impl<N: NodePrimitives> BlockState<N> {
    }

    /// Returns the `Receipts` of executed block that determines the state.
-    pub fn receipts(&self) -> &Vec<N::Receipt> {
+    pub fn receipts(&self) -> &Vec<Vec<N::Receipt>> {
        &self.block.execution_outcome().receipts
    }

@@ -659,7 +643,15 @@ impl<N: NodePrimitives> BlockState<N> {
    ///
    /// This clones the vector of receipts. To avoid it, use [`Self::executed_block_receipts_ref`].
    pub fn executed_block_receipts(&self) -> Vec<N::Receipt> {
-        self.receipts().clone()
+        let receipts = self.receipts();
+
+        debug_assert!(
+            receipts.len() <= 1,
+            "Expected at most one block's worth of receipts, found {}",
+            receipts.len()
+        );
+
+        receipts.first().cloned().unwrap_or_default()
    }

    /// Returns a slice of `Receipt` of executed block that determines the state.
@@ -667,7 +659,15 @@ impl<N: NodePrimitives> BlockState<N> {
    /// has only one element corresponding to the executed block associated to
    /// the state.
    pub fn executed_block_receipts_ref(&self) -> &[N::Receipt] {
-        self.receipts()
+        let receipts = self.receipts();
+
+        debug_assert!(
+            receipts.len() <= 1,
+            "Expected at most one block's worth of receipts, found {}",
+            receipts.len()
+        );
+
+        receipts.first().map(|receipts| receipts.deref()).unwrap_or_default()
    }

    /// Returns an iterator over __parent__ `BlockStates`.
@@ -751,7 +751,7 @@ pub struct ExecutedBlock<N: NodePrimitives = EthPrimitives> {
    /// Recovered Block
    pub recovered_block: Arc<RecoveredBlock<N::Block>>,
    /// Block's execution outcome.
-    pub execution_output: Arc<BlockExecutionOutput<N::Receipt>>,
+    pub execution_output: Arc<ExecutionOutcome<N::Receipt>>,
    /// Deferred trie data produced by execution.
    ///
    /// This allows deferring the computation of the trie data which can be expensive.
@@ -763,15 +763,7 @@ impl<N: NodePrimitives> Default for ExecutedBlock<N> {
    fn default() -> Self {
        Self {
            recovered_block: Default::default(),
-            execution_output: Arc::new(BlockExecutionOutput {
-                result: BlockExecutionResult {
-                    receipts: Default::default(),
-                    requests: Default::default(),
-                    gas_used: 0,
-                    blob_gas_used: 0,
-                },
-                state: Default::default(),
-            }),
+            execution_output: Default::default(),
            trie_data: DeferredTrieData::ready(ComputedTrieData::default()),
        }
    }
@@ -792,7 +784,7 @@ impl<N: NodePrimitives> ExecutedBlock<N> {
    /// payload builders). This is the safe default path.
    pub fn new(
        recovered_block: Arc<RecoveredBlock<N::Block>>,
-        execution_output: Arc<BlockExecutionOutput<N::Receipt>>,
+        execution_output: Arc<ExecutionOutcome<N::Receipt>>,
        trie_data: ComputedTrieData,
    ) -> Self {
        Self { recovered_block, execution_output, trie_data: DeferredTrieData::ready(trie_data) }
@@ -814,7 +806,7 @@ impl<N: NodePrimitives> ExecutedBlock<N> {
    /// Use [`Self::new()`] instead when trie data is already computed and available immediately.
    pub const fn with_deferred_trie_data(
        recovered_block: Arc<RecoveredBlock<N::Block>>,
-        execution_output: Arc<BlockExecutionOutput<N::Receipt>>,
+        execution_output: Arc<ExecutionOutcome<N::Receipt>>,
        trie_data: DeferredTrieData,
    ) -> Self {
        Self { recovered_block, execution_output, trie_data }
@@ -834,7 +826,7 @@ impl<N: NodePrimitives> ExecutedBlock<N> {

    /// Returns a reference to the block's execution outcome
    #[inline]
-    pub fn execution_outcome(&self) -> &BlockExecutionOutput<N::Receipt> {
+    pub fn execution_outcome(&self) -> &ExecutionOutcome<N::Receipt> {
        &self.execution_output
    }

@@ -934,39 +926,31 @@ impl<N: NodePrimitives<SignedTx: SignedTransaction>> NewCanonicalChain<N> {
    pub fn to_chain_notification(&self) -> CanonStateNotification<N> {
        match self {
            Self::Commit { new } => {
-                CanonStateNotification::Commit { new: Arc::new(Self::blocks_to_chain(new)) }
-            }
-            Self::Reorg { new, old } => CanonStateNotification::Reorg {
-                new: Arc::new(Self::blocks_to_chain(new)),
-                old: Arc::new(Self::blocks_to_chain(old)),
-            },
-        }
-    }
-
-    /// Converts a slice of executed blocks into a [`Chain`].
-    fn blocks_to_chain(blocks: &[ExecutedBlock<N>]) -> Chain<N> {
-        match blocks {
-            [] => Chain::default(),
-            [first, rest @ ..] => {
-                let mut chain = Chain::from_block(
-                    first.recovered_block().clone(),
-                    ExecutionOutcome::from((
-                        first.execution_outcome().clone(),
-                        first.block_number(),
-                    )),
-                    LazyTrieData::ready(first.hashed_state(), first.trie_updates()),
-                );
-                for exec in rest {
+                let new = Arc::new(new.iter().fold(Chain::default(), |mut chain, exec| {
                    chain.append_block(
                        exec.recovered_block().clone(),
-                        ExecutionOutcome::from((
-                            exec.execution_outcome().clone(),
-                            exec.block_number(),
-                        )),
-                        LazyTrieData::ready(exec.hashed_state(), exec.trie_updates()),
+                        exec.execution_outcome().clone(),
                    );
-                }
-                chain
+                    chain
+                }));
+                CanonStateNotification::Commit { new }
+            }
+            Self::Reorg { new, old } => {
+                let new = Arc::new(new.iter().fold(Chain::default(), |mut chain, exec| {
+                    chain.append_block(
+                        exec.recovered_block().clone(),
+                        exec.execution_outcome().clone(),
+                    );
+                    chain
+                }));
+                let old = Arc::new(old.iter().fold(Chain::default(), |mut chain, exec| {
+                    chain.append_block(
+                        exec.recovered_block().clone(),
+                        exec.execution_outcome().clone(),
+                    );
+                    chain
+                }));
+                CanonStateNotification::Reorg { new, old }
            }
        }
    }
@@ -1260,7 +1244,7 @@ mod tests {

        let state = BlockState::new(block);

-        assert_eq!(state.receipts(), receipts.first().unwrap());
+        assert_eq!(state.receipts(), &receipts);
    }

    #[test]
@@ -1537,31 +1521,22 @@ mod tests {
        let block2a =
            test_block_builder.get_executed_block_with_number(2, block1.recovered_block.hash());

-        // Test commit notification
-        let chain_commit = NewCanonicalChain::Commit { new: vec![block0.clone(), block1.clone()] };
-
-        // Build expected trie data map
-        let mut expected_trie_data = BTreeMap::new();
-        expected_trie_data
-            .insert(0, LazyTrieData::ready(block0.hashed_state(), block0.trie_updates()));
-        expected_trie_data
-            .insert(1, LazyTrieData::ready(block1.hashed_state(), block1.trie_updates()));
-
-        // Build expected execution outcome (first_block matches first block number)
-        let commit_execution_outcome = ExecutionOutcome {
+        let sample_execution_outcome = ExecutionOutcome {
            receipts: vec![vec![], vec![]],
            requests: vec![Requests::default(), Requests::default()],
-            first_block: 0,
            ..Default::default()
        };

+        // Test commit notification
+        let chain_commit = NewCanonicalChain::Commit { new: vec![block0.clone(), block1.clone()] };
+
        assert_eq!(
            chain_commit.to_chain_notification(),
            CanonStateNotification::Commit {
                new: Arc::new(Chain::new(
                    vec![block0.recovered_block().clone(), block1.recovered_block().clone()],
-                    commit_execution_outcome,
-                    expected_trie_data,
+                    sample_execution_outcome.clone(),
+                    None
                ))
            }
        );
@@ -1572,39 +1547,18 @@ mod tests {
            old: vec![block1.clone(), block2.clone()],
        };

-        // Build expected trie data for old chain
-        let mut old_trie_data = BTreeMap::new();
-        old_trie_data.insert(1, LazyTrieData::ready(block1.hashed_state(), block1.trie_updates()));
-        old_trie_data.insert(2, LazyTrieData::ready(block2.hashed_state(), block2.trie_updates()));
-
-        // Build expected trie data for new chain
-        let mut new_trie_data = BTreeMap::new();
-        new_trie_data
-            .insert(1, LazyTrieData::ready(block1a.hashed_state(), block1a.trie_updates()));
-        new_trie_data
-            .insert(2, LazyTrieData::ready(block2a.hashed_state(), block2a.trie_updates()));
-
-        // Build expected execution outcome for reorg chains (first_block matches first block
-        // number)
-        let reorg_execution_outcome = ExecutionOutcome {
-            receipts: vec![vec![], vec![]],
-            requests: vec![Requests::default(), Requests::default()],
-            first_block: 1,
-            ..Default::default()
-        };
-
        assert_eq!(
            chain_reorg.to_chain_notification(),
            CanonStateNotification::Reorg {
                old: Arc::new(Chain::new(
                    vec![block1.recovered_block().clone(), block2.recovered_block().clone()],
-                    reorg_execution_outcome.clone(),
-                    old_trie_data,
+                    sample_execution_outcome.clone(),
+                    None
                )),
                new: Arc::new(Chain::new(
                    vec![block1a.recovered_block().clone(), block2a.recovered_block().clone()],
-                    reorg_execution_outcome,
-                    new_trie_data,
+                    sample_execution_outcome,
+                    None
                ))
            }
        );
--- a/crates/chain-state/src/lazy_overlay.rs
+++ b/crates/chain-state/src/lazy_overlay.rs
@@ -1,228 +0,0 @@
-//! Lazy overlay computation for trie input.
-//!
-//! This module provides [`LazyOverlay`], a type that computes the [`TrieInputSorted`]
-//! lazily on first access. This allows execution to start before the trie overlay
-//! is fully computed.
-
-use crate::DeferredTrieData;
-use alloy_primitives::B256;
-use reth_trie::{updates::TrieUpdatesSorted, HashedPostStateSorted, TrieInputSorted};
-use std::sync::{Arc, OnceLock};
-use tracing::{debug, trace};
-
-/// Inputs captured for lazy overlay computation.
-#[derive(Clone)]
-struct LazyOverlayInputs {
-    /// The persisted ancestor hash (anchor) this overlay should be built on.
-    anchor_hash: B256,
-    /// Deferred trie data handles for all in-memory blocks (newest to oldest).
-    blocks: Vec<DeferredTrieData>,
-}
-
-/// Lazily computed trie overlay.
-///
-/// Captures the inputs needed to compute a [`TrieInputSorted`] and defers the actual
-/// computation until first access. This is conceptually similar to [`DeferredTrieData`]
-/// but for overlay computation.
-///
-/// # Fast Path vs Slow Path
-///
-/// - **Fast path**: If the tip block's cached `anchored_trie_input` is ready and its `anchor_hash`
-///   matches our expected anchor, we can reuse it directly (O(1)).
-/// - **Slow path**: Otherwise, we merge all ancestor blocks' trie data into a new overlay.
-#[derive(Clone)]
-pub struct LazyOverlay {
-    /// Computed result, cached after first access.
-    inner: Arc<OnceLock<TrieInputSorted>>,
-    /// Inputs for lazy computation.
-    inputs: LazyOverlayInputs,
-}
-
-impl std::fmt::Debug for LazyOverlay {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("LazyOverlay")
-            .field("anchor_hash", &self.inputs.anchor_hash)
-            .field("num_blocks", &self.inputs.blocks.len())
-            .field("computed", &self.inner.get().is_some())
-            .finish()
-    }
-}
-
-impl LazyOverlay {
-    /// Create a new lazy overlay with the given anchor hash and block handles.
-    ///
-    /// # Arguments
-    ///
-    /// * `anchor_hash` - The persisted ancestor hash this overlay is built on top of
-    /// * `blocks` - Deferred trie data handles for in-memory blocks (newest to oldest)
-    pub fn new(anchor_hash: B256, blocks: Vec<DeferredTrieData>) -> Self {
-        Self { inner: Arc::new(OnceLock::new()), inputs: LazyOverlayInputs { anchor_hash, blocks } }
-    }
-
-    /// Returns the anchor hash this overlay is built on.
-    pub const fn anchor_hash(&self) -> B256 {
-        self.inputs.anchor_hash
-    }
-
-    /// Returns the number of in-memory blocks this overlay covers.
-    pub const fn num_blocks(&self) -> usize {
-        self.inputs.blocks.len()
-    }
-
-    /// Returns true if the overlay has already been computed.
-    pub fn is_computed(&self) -> bool {
-        self.inner.get().is_some()
-    }
-
-    /// Returns the computed trie input, computing it if necessary.
-    ///
-    /// The first call triggers computation (which may block waiting for deferred data).
-    /// Subsequent calls return the cached result immediately.
-    pub fn get(&self) -> &TrieInputSorted {
-        self.inner.get_or_init(|| self.compute())
-    }
-
-    /// Returns the overlay as (nodes, state) tuple for use with `OverlayStateProviderFactory`.
-    pub fn as_overlay(&self) -> (Arc<TrieUpdatesSorted>, Arc<HashedPostStateSorted>) {
-        let input = self.get();
-        (Arc::clone(&input.nodes), Arc::clone(&input.state))
-    }
-
-    /// Compute the trie input overlay.
-    fn compute(&self) -> TrieInputSorted {
-        let anchor_hash = self.inputs.anchor_hash;
-        let blocks = &self.inputs.blocks;
-
-        if blocks.is_empty() {
-            debug!(target: "chain_state::lazy_overlay", "No in-memory blocks, returning empty overlay");
-            return TrieInputSorted::default();
-        }
-
-        // Fast path: Check if tip block's overlay is ready and anchor matches.
-        // The tip block (first in list) has the cumulative overlay from all ancestors.
-        if let Some(tip) = blocks.first() {
-            let data = tip.wait_cloned();
-            if let Some(anchored) = &data.anchored_trie_input {
-                if anchored.anchor_hash == anchor_hash {
-                    trace!(target: "chain_state::lazy_overlay", %anchor_hash, "Reusing tip block's cached overlay (fast path)");
-                    return (*anchored.trie_input).clone();
-                }
-                debug!(
-                    target: "chain_state::lazy_overlay",
-                    computed_anchor = %anchored.anchor_hash,
-                    %anchor_hash,
-                    "Anchor mismatch, falling back to merge"
-                );
-            }
-        }
-
-        // Slow path: Merge all blocks' trie data into a new overlay.
-        debug!(target: "chain_state::lazy_overlay", num_blocks = blocks.len(), "Merging blocks (slow path)");
-        Self::merge_blocks(blocks)
-    }
-
-    /// Merge all blocks' trie data into a single [`TrieInputSorted`].
-    ///
-    /// Blocks are ordered newest to oldest. Uses hybrid merge algorithm that
-    /// switches between `extend_ref` (small batches) and k-way merge (large batches).
-    fn merge_blocks(blocks: &[DeferredTrieData]) -> TrieInputSorted {
-        const MERGE_BATCH_THRESHOLD: usize = 64;
-
-        if blocks.is_empty() {
-            return TrieInputSorted::default();
-        }
-
-        // Single block: use its data directly (no allocation)
-        if blocks.len() == 1 {
-            let data = blocks[0].wait_cloned();
-            return TrieInputSorted {
-                state: data.hashed_state,
-                nodes: data.trie_updates,
-                prefix_sets: Default::default(),
-            };
-        }
-
-        if blocks.len() < MERGE_BATCH_THRESHOLD {
-            // Small k: extend_ref loop with Arc::make_mut is faster.
-            // Uses copy-on-write - only clones inner data if Arc has multiple refs.
-            // Iterate oldest->newest so newer values override older ones.
-            let mut blocks_iter = blocks.iter().rev();
-            let first = blocks_iter.next().expect("blocks is non-empty");
-            let data = first.wait_cloned();
-
-            let mut state = data.hashed_state;
-            let mut nodes = data.trie_updates;
-
-            for block in blocks_iter {
-                let block_data = block.wait_cloned();
-                Arc::make_mut(&mut state).extend_ref_and_sort(block_data.hashed_state.as_ref());
-                Arc::make_mut(&mut nodes).extend_ref_and_sort(block_data.trie_updates.as_ref());
-            }
-
-            TrieInputSorted { state, nodes, prefix_sets: Default::default() }
-        } else {
-            // Large k: k-way merge is faster (O(n log k)).
-            // Collect is unavoidable here - we need all data materialized for k-way merge.
-            let trie_data: Vec<_> = blocks.iter().map(|b| b.wait_cloned()).collect();
-
-            let merged_state = HashedPostStateSorted::merge_batch(
-                trie_data.iter().map(|d| d.hashed_state.as_ref()),
-            );
-            let merged_nodes =
-                TrieUpdatesSorted::merge_batch(trie_data.iter().map(|d| d.trie_updates.as_ref()));
-
-            TrieInputSorted {
-                state: Arc::new(merged_state),
-                nodes: Arc::new(merged_nodes),
-                prefix_sets: Default::default(),
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use reth_trie::{updates::TrieUpdates, HashedPostState};
-
-    fn empty_deferred(anchor: B256) -> DeferredTrieData {
-        DeferredTrieData::pending(
-            Arc::new(HashedPostState::default()),
-            Arc::new(TrieUpdates::default()),
-            anchor,
-            Vec::new(),
-        )
-    }
-
-    #[test]
-    fn empty_blocks_returns_default() {
-        let overlay = LazyOverlay::new(B256::ZERO, vec![]);
-        let result = overlay.get();
-        assert!(result.state.is_empty());
-        assert!(result.nodes.is_empty());
-    }
-
-    #[test]
-    fn single_block_uses_data_directly() {
-        let anchor = B256::random();
-        let deferred = empty_deferred(anchor);
-        let overlay = LazyOverlay::new(anchor, vec![deferred]);
-
-        assert!(!overlay.is_computed());
-        let _ = overlay.get();
-        assert!(overlay.is_computed());
-    }
-
-    #[test]
-    fn cached_after_first_access() {
-        let overlay = LazyOverlay::new(B256::ZERO, vec![]);
-
-        // First access computes
-        let _ = overlay.get();
-        assert!(overlay.is_computed());
-
-        // Second access uses cache
-        let _ = overlay.get();
-        assert!(overlay.is_computed());
-    }
-}
--- a/crates/chain-state/src/lib.rs
+++ b/crates/chain-state/src/lib.rs
@@ -14,9 +14,6 @@ pub use in_memory::*;
 mod deferred_trie;
 pub use deferred_trie::*;

-mod lazy_overlay;
-pub use lazy_overlay::*;
-
 mod noop;

 mod chain_info;
@@ -26,8 +23,7 @@ mod notifications;
 pub use notifications::{
    CanonStateNotification, CanonStateNotificationSender, CanonStateNotificationStream,
    CanonStateNotifications, CanonStateSubscriptions, ForkChoiceNotifications, ForkChoiceStream,
-    ForkChoiceSubscriptions, PersistedBlockNotifications, PersistedBlockSubscriptions,
-    WatchValueStream,
+    ForkChoiceSubscriptions,
 };

 mod memory_overlay;
--- a/crates/chain-state/src/noop.rs
+++ b/crates/chain-state/src/noop.rs
@@ -2,7 +2,7 @@

 use crate::{
    CanonStateNotifications, CanonStateSubscriptions, ForkChoiceNotifications,
-    ForkChoiceSubscriptions, PersistedBlockNotifications, PersistedBlockSubscriptions,
+    ForkChoiceSubscriptions,
 };
 use reth_primitives_traits::NodePrimitives;
 use reth_storage_api::noop::NoopProvider;
@@ -27,10 +27,3 @@ impl<C: Send + Sync, N: NodePrimitives> ForkChoiceSubscriptions for NoopProvider
        ForkChoiceNotifications(rx)
    }
 }
-
-impl<C: Send + Sync, N: NodePrimitives> PersistedBlockSubscriptions for NoopProvider<C, N> {
-    fn subscribe_persisted_block(&self) -> PersistedBlockNotifications {
-        let (_, rx) = watch::channel(None);
-        PersistedBlockNotifications(rx)
-    }
-}
--- a/crates/chain-state/src/notifications.rs
+++ b/crates/chain-state/src/notifications.rs
@@ -1,6 +1,6 @@
 //! Canonical chain state notification trait and types.

-use alloy_eips::{eip2718::Encodable2718, BlockNumHash};
+use alloy_eips::eip2718::Encodable2718;
 use derive_more::{Deref, DerefMut};
 use reth_execution_types::{BlockReceipts, Chain};
 use reth_primitives_traits::{NodePrimitives, RecoveredBlock, SealedHeader};
@@ -205,22 +205,22 @@ pub trait ForkChoiceSubscriptions: Send + Sync {
    }
 }

-/// A stream that yields values from a `watch::Receiver<Option<T>>`, filtering out `None` values.
+/// A stream for fork choice watch channels (pending, safe or finalized watchers)
 #[derive(Debug)]
 #[pin_project::pin_project]
-pub struct WatchValueStream<T> {
+pub struct ForkChoiceStream<T> {
    #[pin]
    st: WatchStream<Option<T>>,
 }

-impl<T: Clone + Sync + Send + 'static> WatchValueStream<T> {
-    /// Creates a new [`WatchValueStream`]
+impl<T: Clone + Sync + Send + 'static> ForkChoiceStream<T> {
+    /// Creates a new `ForkChoiceStream`
    pub fn new(rx: watch::Receiver<Option<T>>) -> Self {
        Self { st: WatchStream::from_changes(rx) }
    }
 }

-impl<T: Clone + Sync + Send + 'static> Stream for WatchValueStream<T> {
+impl<T: Clone + Sync + Send + 'static> Stream for ForkChoiceStream<T> {
    type Item = T;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
@@ -234,24 +234,6 @@ impl<T: Clone + Sync + Send + 'static> Stream for WatchValueStream<T> {
    }
 }

-/// Alias for [`WatchValueStream`] for fork choice watch channels.
-pub type ForkChoiceStream<T> = WatchValueStream<T>;
-
-/// Wrapper around a watch receiver that receives persisted block notifications.
-#[derive(Debug, Deref, DerefMut)]
-pub struct PersistedBlockNotifications(pub watch::Receiver<Option<BlockNumHash>>);
-
-/// A trait that allows subscribing to persisted block events.
-pub trait PersistedBlockSubscriptions: Send + Sync {
-    /// Get notified when a new block is persisted to disk.
-    fn subscribe_persisted_block(&self) -> PersistedBlockNotifications;
-
-    /// Convenience method to get a stream of the persisted blocks.
-    fn persisted_block_stream(&self) -> WatchValueStream<BlockNumHash> {
-        WatchValueStream::new(self.subscribe_persisted_block().0)
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -260,7 +242,6 @@ mod tests {
    use reth_ethereum_primitives::{Receipt, TransactionSigned, TxType};
    use reth_execution_types::ExecutionOutcome;
    use reth_primitives_traits::SealedBlock;
-    use std::collections::BTreeMap;

    #[test]
    fn test_commit_notification() {
@@ -279,7 +260,7 @@ mod tests {
        let chain: Arc<Chain> = Arc::new(Chain::new(
            vec![block1.clone(), block2.clone()],
            ExecutionOutcome::default(),
-            BTreeMap::new(),
+            None,
        ));

        // Create a commit notification
@@ -314,15 +295,12 @@ mod tests {
        block3.set_block_number(3);
        block3.set_hash(block3_hash);

-        let old_chain: Arc<Chain> = Arc::new(Chain::new(
-            vec![block1.clone()],
-            ExecutionOutcome::default(),
-            BTreeMap::new(),
-        ));
+        let old_chain: Arc<Chain> =
+            Arc::new(Chain::new(vec![block1.clone()], ExecutionOutcome::default(), None));
        let new_chain = Arc::new(Chain::new(
            vec![block2.clone(), block3.clone()],
            ExecutionOutcome::default(),
-            BTreeMap::new(),
+            None,
        ));

        // Create a reorg notification
@@ -384,11 +362,8 @@ mod tests {
        let execution_outcome = ExecutionOutcome { receipts, ..Default::default() };

        // Create a new chain segment with `block1` and `block2` and the execution outcome.
-        let new_chain: Arc<Chain> = Arc::new(Chain::new(
-            vec![block1.clone(), block2.clone()],
-            execution_outcome,
-            BTreeMap::new(),
-        ));
+        let new_chain: Arc<Chain> =
+            Arc::new(Chain::new(vec![block1.clone(), block2.clone()], execution_outcome, None));

        // Create a commit notification containing the new chain segment.
        let notification = CanonStateNotification::Commit { new: new_chain };
@@ -446,7 +421,7 @@ mod tests {

        // Create an old chain segment to be reverted, containing `old_block1`.
        let old_chain: Arc<Chain> =
-            Arc::new(Chain::new(vec![old_block1.clone()], old_execution_outcome, BTreeMap::new()));
+            Arc::new(Chain::new(vec![old_block1.clone()], old_execution_outcome, None));

        // Define block2 for the new chain segment, which will be committed.
        let mut body = BlockBody::<TransactionSigned>::default();
@@ -474,8 +449,7 @@ mod tests {
            ExecutionOutcome { receipts: new_receipts, ..Default::default() };

        // Create a new chain segment to be committed, containing `new_block1`.
-        let new_chain =
-            Arc::new(Chain::new(vec![new_block1.clone()], new_execution_outcome, BTreeMap::new()));
+        let new_chain = Arc::new(Chain::new(vec![new_block1.clone()], new_execution_outcome, None));

        // Create a reorg notification with both reverted (old) and committed (new) chain segments.
        let notification = CanonStateNotification::Reorg { old: old_chain, new: new_chain };
--- a/crates/chain-state/src/test_utils.rs
+++ b/crates/chain-state/src/test_utils.rs
@@ -3,7 +3,10 @@ use crate::{
    CanonStateSubscriptions, ComputedTrieData,
 };
 use alloy_consensus::{Header, SignableTransaction, TxEip1559, TxReceipt, EMPTY_ROOT_HASH};
-use alloy_eips::eip1559::{ETHEREUM_BLOCK_GAS_LIMIT_30M, INITIAL_BASE_FEE};
+use alloy_eips::{
+    eip1559::{ETHEREUM_BLOCK_GAS_LIMIT_30M, INITIAL_BASE_FEE},
+    eip7685::Requests,
+};
 use alloy_primitives::{Address, BlockNumber, B256, U256};
 use alloy_signer::SignerSync;
 use alloy_signer_local::PrivateKeySigner;
@@ -13,7 +16,7 @@ use reth_chainspec::{ChainSpec, EthereumHardfork, MIN_TRANSACTION_GAS};
 use reth_ethereum_primitives::{
    Block, BlockBody, EthPrimitives, Receipt, Transaction, TransactionSigned,
 };
-use reth_execution_types::{BlockExecutionOutput, BlockExecutionResult, Chain, ExecutionOutcome};
+use reth_execution_types::{Chain, ExecutionOutcome};
 use reth_primitives_traits::{
    proofs::{calculate_receipt_root, calculate_transaction_root, calculate_withdrawals_root},
    Account, NodePrimitives, Recovered, RecoveredBlock, SealedBlock, SealedHeader,
@@ -198,7 +201,7 @@ impl<N: NodePrimitives> TestBlockBuilder<N> {
    fn get_executed_block(
        &mut self,
        block_number: BlockNumber,
-        mut receipts: Vec<Vec<Receipt>>,
+        receipts: Vec<Vec<Receipt>>,
        parent_hash: B256,
    ) -> ExecutedBlock {
        let block = self.generate_random_block(block_number, parent_hash);
@@ -206,15 +209,12 @@ impl<N: NodePrimitives> TestBlockBuilder<N> {
        let trie_data = ComputedTrieData::default();
        ExecutedBlock::new(
            Arc::new(RecoveredBlock::new_sealed(block, senders)),
-            Arc::new(BlockExecutionOutput {
-                result: BlockExecutionResult {
-                    receipts: receipts.pop().unwrap_or_default(),
-                    requests: Default::default(),
-                    gas_used: 0,
-                    blob_gas_used: 0,
-                },
-                state: BundleState::default(),
-            }),
+            Arc::new(ExecutionOutcome::new(
+                BundleState::default(),
+                receipts,
+                block_number,
+                vec![Requests::default()],
+            )),
            trie_data,
        )
    }
--- a/crates/chainspec/src/spec.rs
+++ b/crates/chainspec/src/spec.rs
@@ -460,18 +460,6 @@ impl ChainSpec {
    pub fn builder() -> ChainSpecBuilder {
        ChainSpecBuilder::default()
    }
-
-    /// Map a chain ID to a known chain spec, if available.
-    pub fn from_chain_id(chain_id: u64) -> Option<Arc<Self>> {
-        match NamedChain::try_from(chain_id).ok()? {
-            NamedChain::Mainnet => Some(MAINNET.clone()),
-            NamedChain::Sepolia => Some(SEPOLIA.clone()),
-            NamedChain::Holesky => Some(HOLESKY.clone()),
-            NamedChain::Hoodi => Some(HOODI.clone()),
-            NamedChain::Dev => Some(DEV.clone()),
-            _ => None,
-        }
-    }
 }

 impl<H: BlockHeader> ChainSpec<H> {
--- a/crates/cli/commands/Cargo.toml
+++ b/crates/cli/commands/Cargo.toml
@@ -83,7 +83,6 @@ backon.workspace = true
 secp256k1 = { workspace = true, features = ["global-context", "std", "recovery"] }
 tokio-stream.workspace = true
 reqwest.workspace = true
-url.workspace = true
 metrics.workspace = true

 # io
@@ -130,5 +129,3 @@ arbitrary = [
    "reth-primitives-traits/arbitrary",
    "reth-ethereum-primitives/arbitrary",
 ]
-
-edge = ["reth-db-common/edge", "reth-stages/rocksdb"]
--- a/crates/cli/commands/src/common.rs
+++ b/crates/cli/commands/src/common.rs
@@ -107,13 +107,13 @@ impl<C: ChainSpecParser> EnvironmentArgs<C> {
        let (db, sfp) = match access {
            AccessRights::RW => (
                Arc::new(init_db(db_path, self.db.database_args())?),
-                StaticFileProviderBuilder::read_write(sf_path)
+                StaticFileProviderBuilder::read_write(sf_path)?
                    .with_genesis_block_number(genesis_block_number)
                    .build()?,
            ),
            AccessRights::RO | AccessRights::RoInconsistent => {
                (Arc::new(open_db_read_only(&db_path, self.db.database_args())?), {
-                    let provider = StaticFileProviderBuilder::read_only(sf_path)
+                    let provider = StaticFileProviderBuilder::read_only(sf_path)?
                        .with_genesis_block_number(genesis_block_number)
                        .build()?;
                    provider.watch_directory();
--- a/crates/cli/commands/src/db/clear.rs
+++ b/crates/cli/commands/src/db/clear.rs
@@ -29,7 +29,7 @@ impl Command {
                let static_file_provider = tool.provider_factory.static_file_provider();
                let static_files = iter_static_files(static_file_provider.directory())?;

-                if let Some(segment_static_files) = static_files.get(segment) {
+                if let Some(segment_static_files) = static_files.get(&segment) {
                    for (block_range, _) in segment_static_files {
                        static_file_provider.delete_jar(segment, block_range.start())?;
                    }
--- a/crates/cli/commands/src/db/get.rs
+++ b/crates/cli/commands/src/db/get.rs
@@ -2,8 +2,8 @@ use alloy_primitives::{hex, BlockHash};
 use clap::Parser;
 use reth_db::{
    static_file::{
-        AccountChangesetMask, ColumnSelectorOne, ColumnSelectorTwo, HeaderWithHashMask,
-        ReceiptMask, TransactionMask, TransactionSenderMask,
+        ColumnSelectorOne, ColumnSelectorTwo, HeaderWithHashMask, ReceiptMask, TransactionMask,
+        TransactionSenderMask,
    },
    RawDupSort,
 };
@@ -19,7 +19,7 @@ use reth_db_common::DbTool;
 use reth_node_api::{HeaderTy, ReceiptTy, TxTy};
 use reth_node_builder::NodeTypesWithDB;
 use reth_primitives_traits::ValueWithSubKey;
-use reth_provider::{providers::ProviderNodeTypes, ChangeSetReader, StaticFileProviderFactory};
+use reth_provider::{providers::ProviderNodeTypes, StaticFileProviderFactory};
 use reth_static_file_types::StaticFileSegment;
 use tracing::error;

@@ -64,10 +64,6 @@ enum Subcommand {
        #[arg(value_parser = maybe_json_value_parser)]
        key: String,

-        /// The subkey to get content for, for example address in changeset
-        #[arg(value_parser = maybe_json_value_parser)]
-        subkey: Option<String>,
-
        /// Output bytes instead of human-readable decoded value
        #[arg(long)]
        raw: bool,
@@ -81,77 +77,33 @@ impl Command {
            Subcommand::Mdbx { table, key, subkey, end_key, end_subkey, raw } => {
                table.view(&GetValueViewer { tool, key, subkey, end_key, end_subkey, raw })?
            }
-            Subcommand::StaticFile { segment, key, subkey, raw } => {
-                let (key, subkey, mask): (u64, _, _) = match segment {
+            Subcommand::StaticFile { segment, key, raw } => {
+                let (key, mask): (u64, _) = match segment {
                    StaticFileSegment::Headers => (
                        table_key::<tables::Headers>(&key)?,
-                        None,
                        <HeaderWithHashMask<HeaderTy<N>>>::MASK,
                    ),
-                    StaticFileSegment::Transactions => (
-                        table_key::<tables::Transactions>(&key)?,
-                        None,
-                        <TransactionMask<TxTy<N>>>::MASK,
-                    ),
-                    StaticFileSegment::Receipts => (
-                        table_key::<tables::Receipts>(&key)?,
-                        None,
-                        <ReceiptMask<ReceiptTy<N>>>::MASK,
-                    ),
+                    StaticFileSegment::Transactions => {
+                        (table_key::<tables::Transactions>(&key)?, <TransactionMask<TxTy<N>>>::MASK)
+                    }
+                    StaticFileSegment::Receipts => {
+                        (table_key::<tables::Receipts>(&key)?, <ReceiptMask<ReceiptTy<N>>>::MASK)
+                    }
                    StaticFileSegment::TransactionSenders => (
                        table_key::<tables::TransactionSenders>(&key)?,
-                        None,
-                        TransactionSenderMask::MASK,
+                        <TransactionSenderMask>::MASK,
                    ),
-                    StaticFileSegment::AccountChangeSets => {
-                        let subkey =
-                            table_subkey::<tables::AccountChangeSets>(subkey.as_deref()).ok();
-                        (
-                            table_key::<tables::AccountChangeSets>(&key)?,
-                            subkey,
-                            AccountChangesetMask::MASK,
-                        )
-                    }
                };

-                // handle account changesets differently if a subkey is provided.
-                if let StaticFileSegment::AccountChangeSets = segment {
-                    let Some(subkey) = subkey else {
-                        // get all changesets for the block
-                        let changesets = tool
-                            .provider_factory
-                            .static_file_provider()
-                            .account_block_changeset(key)?;
-
-                        println!("{}", serde_json::to_string_pretty(&changesets)?);
-                        return Ok(())
-                    };
-
-                    let account = tool
-                        .provider_factory
-                        .static_file_provider()
-                        .get_account_before_block(key, subkey)?;
-
-                    if let Some(account) = account {
-                        println!("{}", serde_json::to_string_pretty(&account)?);
-                    } else {
-                        error!(target: "reth::cli", "No content for the given table key.");
-                    }
-
-                    return Ok(())
-                }
-
-                let content = tool.provider_factory.static_file_provider().find_static_file(
-                    segment,
-                    |provider| {
-                        let mut cursor = provider.cursor()?;
-                        cursor.get(key.into(), mask).map(|result| {
-                            result.map(|vec| {
-                                vec.iter().map(|slice| slice.to_vec()).collect::<Vec<_>>()
-                            })
-                        })
-                    },
-                )?;
+                let content = tool
+                    .provider_factory
+                    .static_file_provider()
+                    .get_segment_provider(segment, key)?
+                    .cursor()?
+                    .get(key.into(), mask)
+                    .map(|result| {
+                        result.map(|vec| vec.iter().map(|slice| slice.to_vec()).collect::<Vec<_>>())
+                    })?;

                match content {
                    Some(content) => {
@@ -187,9 +139,6 @@ impl Command {
                                        )?;
                                    println!("{}", serde_json::to_string_pretty(&sender)?);
                                }
-                                StaticFileSegment::AccountChangeSets => {
-                                    unreachable!("account changeset static files are special cased before this match")
-                                }
                            }
                        }
                    }
--- a/crates/cli/commands/src/db/list.rs
+++ b/crates/cli/commands/src/db/list.rs
@@ -100,7 +100,7 @@ impl<N: NodeTypes> TableViewer<()> for ListTableViewer<'_, N> {
            tx.disable_long_read_transaction_safety();

            let table_db = tx.inner.open_db(Some(self.args.table.name())).wrap_err("Could not open db.")?;
-            let stats = tx.inner.db_stat(table_db.dbi()).wrap_err(format!("Could not find table: {}", self.args.table.name()))?;
+            let stats = tx.inner.db_stat(&table_db).wrap_err(format!("Could not find table: {}", self.args.table.name()))?;
            let total_entries = stats.entries();
            let final_entry_idx = total_entries.saturating_sub(1);
            if self.args.skip > final_entry_idx {
--- a/crates/cli/commands/src/db/mod.rs
+++ b/crates/cli/commands/src/db/mod.rs
@@ -162,7 +162,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> Command<C>
                let access_rights =
                    if command.dry_run { AccessRights::RO } else { AccessRights::RW };
                db_exec!(self.env, tool, N, access_rights, {
-                    command.execute(&tool, ctx.task_executor.clone(), &data_dir)?;
+                    command.execute(&tool, ctx.task_executor.clone())?;
                });
            }
            Subcommands::StaticFileHeader(command) => {
--- a/crates/cli/commands/src/db/repair_trie.rs
+++ b/crates/cli/commands/src/db/repair_trie.rs
@@ -9,10 +9,7 @@ use reth_db_api::{
    transaction::{DbTx, DbTxMut},
 };
 use reth_db_common::DbTool;
-use reth_node_core::{
-    dirs::{ChainPath, DataDirPath},
-    version::version_metadata,
-};
+use reth_node_core::version::version_metadata;
 use reth_node_metrics::{
    chain::ChainSpecInfo,
    hooks::Hooks,
@@ -56,13 +53,11 @@ impl Command {
        self,
        tool: &DbTool<N>,
        task_executor: TaskExecutor,
-        data_dir: &ChainPath<DataDirPath>,
    ) -> eyre::Result<()> {
        // Set up metrics server if requested
        let _metrics_handle = if let Some(listen_addr) = self.metrics {
            let chain_name = tool.provider_factory.chain_spec().chain().to_string();
            let executor = task_executor.clone();
-            let pprof_dump_dir = data_dir.pprof_dumps();

            let handle = task_executor.spawn_critical("metrics server", async move {
                let config = MetricServerConfig::new(
@@ -78,7 +73,6 @@ impl Command {
                    ChainSpecInfo { name: chain_name },
                    executor,
                    Hooks::builder().build(),
-                    pprof_dump_dir,
                );

                // Spawn the metrics server
--- a/crates/cli/commands/src/db/settings.rs
+++ b/crates/cli/commands/src/db/settings.rs
@@ -40,32 +40,12 @@ enum Subcommands {
 #[clap(rename_all = "snake_case")]
 pub enum SetCommand {
    /// Store receipts in static files instead of the database
-    Receipts {
+    ReceiptsInStaticFiles {
        #[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 {
+    TransactionSendersInStaticFiles {
        #[clap(action(ArgAction::Set))]
        value: bool,
    },
@@ -114,12 +94,11 @@ impl Command {
            storages_history_in_rocksdb: _,
            transaction_hash_numbers_in_rocksdb: _,
            account_history_in_rocksdb: _,
-            account_changesets_in_static_files: _,
        } = settings.unwrap_or_else(StorageSettings::legacy);

        // Update the setting based on the key
        match cmd {
-            SetCommand::Receipts { value } => {
+            SetCommand::ReceiptsInStaticFiles { value } => {
                if settings.receipts_in_static_files == value {
                    println!("receipts_in_static_files is already set to {}", value);
                    return Ok(());
@@ -127,7 +106,7 @@ impl Command {
                settings.receipts_in_static_files = value;
                println!("Set receipts_in_static_files = {}", value);
            }
-            SetCommand::TransactionSenders { value } => {
+            SetCommand::TransactionSendersInStaticFiles { value } => {
                if settings.transaction_senders_in_static_files == value {
                    println!("transaction_senders_in_static_files is already set to {}", value);
                    return Ok(());
@@ -135,38 +114,6 @@ impl Command {
                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);
-            }
        }

        // Write updated settings
--- a/crates/cli/commands/src/db/stats.rs
+++ b/crates/cli/commands/src/db/stats.rs
@@ -88,7 +88,7 @@ impl Command {

                let stats = tx
                    .inner
-                    .db_stat(table_db.dbi())
+                    .db_stat(&table_db)
                    .wrap_err(format!("Could not find table: {db_table}"))?;

                // Defaults to 16KB right now but we should
@@ -129,8 +129,7 @@ impl Command {
            table.add_row(row);

            let freelist = tx.inner.env().freelist()?;
-            let pagesize =
-                tx.inner.db_stat(mdbx::Database::freelist_db().dbi())?.page_size() as usize;
+            let pagesize = tx.inner.db_stat(&mdbx::Database::freelist_db())?.page_size() as usize;
            let freelist_size = freelist * pagesize;

            let mut row = Row::new();
--- a/crates/cli/commands/src/download.rs
+++ b/crates/cli/commands/src/download.rs
@@ -2,22 +2,20 @@ use crate::common::EnvironmentArgs;
 use clap::Parser;
 use eyre::Result;
 use lz4::Decoder;
-use reqwest::{blocking::Client as BlockingClient, header::RANGE, Client, StatusCode};
+use reqwest::Client;
 use reth_chainspec::{EthChainSpec, EthereumHardforks};
 use reth_cli::chainspec::ChainSpecParser;
 use reth_fs_util as fs;
 use std::{
    borrow::Cow,
-    fs::OpenOptions,
-    io::{self, BufWriter, Read, Write},
-    path::{Path, PathBuf},
+    io::{self, Read, Write},
+    path::Path,
    sync::{Arc, OnceLock},
    time::{Duration, Instant},
 };
 use tar::Archive;
 use tokio::task;
 use tracing::info;
-use url::Url;
 use zstd::stream::read::Decoder as ZstdDecoder;

 const BYTE_UNITS: [&str; 4] = ["B", "KB", "MB", "GB"];
@@ -87,9 +85,6 @@ impl DownloadDefaults {
            "\nIf no URL is provided, the latest mainnet archive snapshot\nwill be proposed for download from ",
        );
        help.push_str(self.default_base_url.as_ref());
-        help.push_str(
-            ".\n\nLocal file:// URLs are also supported for extracting snapshots from disk.",
-        );
        help
    }

@@ -175,14 +170,12 @@ struct DownloadProgress {
    downloaded: u64,
    total_size: u64,
    last_displayed: Instant,
-    started_at: Instant,
 }

 impl DownloadProgress {
    /// Creates new progress tracker with given total size
    fn new(total_size: u64) -> Self {
-        let now = Instant::now();
-        Self { downloaded: 0, total_size, last_displayed: now, started_at: now }
+        Self { downloaded: 0, total_size, last_displayed: Instant::now() }
    }

    /// Converts bytes to human readable format (B, KB, MB, GB)
@@ -198,18 +191,6 @@ impl DownloadProgress {
        format!("{:.2} {}", size, BYTE_UNITS[unit_index])
    }

-    /// Format duration as human readable string
-    fn format_duration(duration: Duration) -> String {
-        let secs = duration.as_secs();
-        if secs < 60 {
-            format!("{secs}s")
-        } else if secs < 3600 {
-            format!("{}m {}s", secs / 60, secs % 60)
-        } else {
-            format!("{}h {}m", secs / 3600, (secs % 3600) / 60)
-        }
-    }
-
    /// Updates progress bar
    fn update(&mut self, chunk_size: u64) -> Result<()> {
        self.downloaded += chunk_size;
@@ -220,24 +201,8 @@ impl DownloadProgress {
            let formatted_total = Self::format_size(self.total_size);
            let progress = (self.downloaded as f64 / self.total_size as f64) * 100.0;

-            // Calculate ETA based on current speed
-            let elapsed = self.started_at.elapsed();
-            let eta = if self.downloaded > 0 {
-                let remaining = self.total_size.saturating_sub(self.downloaded);
-                let speed = self.downloaded as f64 / elapsed.as_secs_f64();
-                if speed > 0.0 {
-                    Duration::from_secs_f64(remaining as f64 / speed)
-                } else {
-                    Duration::ZERO
-                }
-            } else {
-                Duration::ZERO
-            };
-            let eta_str = Self::format_duration(eta);
-
-            // Pad with spaces to clear any previous longer line
            print!(
-                "\rDownloading and extracting... {progress:.2}% ({formatted_downloaded} / {formatted_total}) ETA: {eta_str}     ",
+                "\rDownloading and extracting... {progress:.2}% ({formatted_downloaded} / {formatted_total})",
            );
            io::stdout().flush()?;
            self.last_displayed = Instant::now();
@@ -281,30 +246,29 @@ enum CompressionFormat {
 impl CompressionFormat {
    /// Detect compression format from file extension
    fn from_url(url: &str) -> Result<Self> {
-        let path =
-            Url::parse(url).map(|u| u.path().to_string()).unwrap_or_else(|_| url.to_string());
-
-        if path.ends_with(EXTENSION_TAR_LZ4) {
+        if url.ends_with(EXTENSION_TAR_LZ4) {
            Ok(Self::Lz4)
-        } else if path.ends_with(EXTENSION_TAR_ZSTD) {
+        } else if url.ends_with(EXTENSION_TAR_ZSTD) {
            Ok(Self::Zstd)
        } else {
-            Err(eyre::eyre!(
-                "Unsupported file format. Expected .tar.lz4 or .tar.zst, got: {}",
-                path
-            ))
+            Err(eyre::eyre!("Unsupported file format. Expected .tar.lz4 or .tar.zst, got: {}", url))
        }
    }
 }

-/// Extracts a compressed tar archive to the target directory with progress tracking.
-fn extract_archive<R: Read>(
-    reader: R,
-    total_size: u64,
-    format: CompressionFormat,
-    target_dir: &Path,
-) -> Result<()> {
-    let progress_reader = ProgressReader::new(reader, total_size);
+/// Downloads and extracts a snapshot, blocking until finished.
+fn blocking_download_and_extract(url: &str, target_dir: &Path) -> Result<()> {
+    let client = reqwest::blocking::Client::builder().build()?;
+    let response = client.get(url).send()?.error_for_status()?;
+
+    let total_size = response.content_length().ok_or_else(|| {
+        eyre::eyre!(
+            "Server did not provide Content-Length header. This is required for snapshot downloads"
+        )
+    })?;
+
+    let progress_reader = ProgressReader::new(response, total_size);
+    let format = CompressionFormat::from_url(url)?;

    match format {
        CompressionFormat::Lz4 => {
@@ -321,185 +285,6 @@ fn extract_archive<R: Read>(
    Ok(())
 }

-/// Extracts a snapshot from a local file.
-fn extract_from_file(path: &Path, format: CompressionFormat, target_dir: &Path) -> Result<()> {
-    let file = std::fs::File::open(path)?;
-    let total_size = file.metadata()?.len();
-    extract_archive(file, total_size, format, target_dir)
-}
-
-const MAX_DOWNLOAD_RETRIES: u32 = 10;
-const RETRY_BACKOFF_SECS: u64 = 5;
-
-/// Wrapper that tracks download progress while writing data.
-/// Used with [`io::copy`] to display progress during downloads.
-struct ProgressWriter<W> {
-    inner: W,
-    progress: DownloadProgress,
-}
-
-impl<W: Write> Write for ProgressWriter<W> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let n = self.inner.write(buf)?;
-        let _ = self.progress.update(n as u64);
-        Ok(n)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        self.inner.flush()
-    }
-}
-
-/// Downloads a file with resume support using HTTP Range requests.
-/// Automatically retries on failure, resuming from where it left off.
-/// Returns the path to the downloaded file and its total size.
-fn resumable_download(url: &str, target_dir: &Path) -> Result<(PathBuf, u64)> {
-    let file_name = Url::parse(url)
-        .ok()
-        .and_then(|u| u.path_segments()?.next_back().map(|s| s.to_string()))
-        .unwrap_or_else(|| "snapshot.tar".to_string());
-
-    let final_path = target_dir.join(&file_name);
-    let part_path = target_dir.join(format!("{file_name}.part"));
-
-    let client = BlockingClient::builder().timeout(Duration::from_secs(30)).build()?;
-
-    let mut total_size: Option<u64> = None;
-    let mut last_error: Option<eyre::Error> = None;
-
-    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));
-        }
-
-        if attempt > 1 {
-            info!(target: "reth::cli",
-                "Retry attempt {}/{} - resuming from {} bytes",
-                attempt, MAX_DOWNLOAD_RETRIES, existing_size
-            );
-        }
-
-        let mut request = client.get(url);
-        if existing_size > 0 {
-            request = request.header(RANGE, format!("bytes={existing_size}-"));
-            if attempt == 1 {
-                info!(target: "reth::cli", "Resuming download from {} bytes", existing_size);
-            }
-        }
-
-        let response = match request.send().and_then(|r| r.error_for_status()) {
-            Ok(r) => r,
-            Err(e) => {
-                last_error = Some(e.into());
-                if attempt < MAX_DOWNLOAD_RETRIES {
-                    info!(target: "reth::cli",
-                        "Download failed, retrying in {} seconds...", RETRY_BACKOFF_SECS
-                    );
-                    std::thread::sleep(Duration::from_secs(RETRY_BACKOFF_SECS));
-                }
-                continue;
-            }
-        };
-
-        let is_partial = response.status() == StatusCode::PARTIAL_CONTENT;
-
-        let size = if is_partial {
-            response
-                .headers()
-                .get("Content-Range")
-                .and_then(|v| v.to_str().ok())
-                .and_then(|v| v.split('/').next_back())
-                .and_then(|v| v.parse().ok())
-        } else {
-            response.content_length()
-        };
-
-        if total_size.is_none() {
-            total_size = size;
-        }
-
-        let current_total = total_size.ok_or_else(|| {
-            eyre::eyre!("Server did not provide Content-Length or Content-Range header")
-        })?;
-
-        let file = if is_partial && existing_size > 0 {
-            OpenOptions::new()
-                .append(true)
-                .open(&part_path)
-                .map_err(|e| fs::FsPathError::open(e, &part_path))?
-        } else {
-            fs::create_file(&part_path)?
-        };
-
-        let start_offset = if is_partial { existing_size } else { 0 };
-        let mut progress = DownloadProgress::new(current_total);
-        progress.downloaded = start_offset;
-
-        let mut writer = ProgressWriter { inner: BufWriter::new(file), progress };
-        let mut reader = response;
-
-        let copy_result = io::copy(&mut reader, &mut writer);
-        let flush_result = writer.inner.flush();
-        println!();
-
-        if let Err(e) = copy_result.and(flush_result) {
-            last_error = Some(e.into());
-            if attempt < MAX_DOWNLOAD_RETRIES {
-                info!(target: "reth::cli",
-                    "Download interrupted, retrying in {} seconds...", RETRY_BACKOFF_SECS
-                );
-                std::thread::sleep(Duration::from_secs(RETRY_BACKOFF_SECS));
-            }
-            continue;
-        }
-
-        fs::rename(&part_path, &final_path)?;
-        info!(target: "reth::cli", "Download complete: {}", final_path.display());
-        return Ok((final_path, current_total));
-    }
-
-    Err(last_error
-        .unwrap_or_else(|| eyre::eyre!("Download failed after {} attempts", MAX_DOWNLOAD_RETRIES)))
-}
-
-/// Fetches the snapshot from a remote URL with resume support, then extracts it.
-fn download_and_extract(url: &str, format: CompressionFormat, target_dir: &Path) -> Result<()> {
-    let (downloaded_path, total_size) = resumable_download(url, target_dir)?;
-
-    info!(target: "reth::cli", "Extracting snapshot...");
-    let file = fs::open(&downloaded_path)?;
-    extract_archive(file, total_size, format, target_dir)?;
-
-    fs::remove_file(&downloaded_path)?;
-    info!(target: "reth::cli", "Removed downloaded archive");
-
-    Ok(())
-}
-
-/// Downloads and extracts a snapshot, blocking until finished.
-///
-/// Supports both `file://` URLs for local files and HTTP(S) URLs for remote downloads.
-fn blocking_download_and_extract(url: &str, target_dir: &Path) -> Result<()> {
-    let format = CompressionFormat::from_url(url)?;
-
-    if let Ok(parsed_url) = Url::parse(url) &&
-        parsed_url.scheme() == "file"
-    {
-        let file_path = parsed_url
-            .to_file_path()
-            .map_err(|_| eyre::eyre!("Invalid file:// URL path: {}", url))?;
-        extract_from_file(&file_path, format, target_dir)
-    } else {
-        download_and_extract(url, format, target_dir)
-    }
-}
-
 async fn stream_and_extract(url: &str, target_dir: &Path) -> Result<()> {
    let target_dir = target_dir.to_path_buf();
    let url = url.to_string();
@@ -558,7 +343,6 @@ mod tests {
        assert!(help.contains("Available snapshot sources:"));
        assert!(help.contains("merkle.io"));
        assert!(help.contains("publicnode.com"));
-        assert!(help.contains("file://"));
    }

    #[test]
@@ -583,25 +367,4 @@ mod tests {
        assert_eq!(defaults.available_snapshots.len(), 4); // 2 defaults + 2 added
        assert_eq!(defaults.long_help, Some("Custom help for snapshots".to_string()));
    }
-
-    #[test]
-    fn test_compression_format_detection() {
-        assert!(matches!(
-            CompressionFormat::from_url("https://example.com/snapshot.tar.lz4"),
-            Ok(CompressionFormat::Lz4)
-        ));
-        assert!(matches!(
-            CompressionFormat::from_url("https://example.com/snapshot.tar.zst"),
-            Ok(CompressionFormat::Zstd)
-        ));
-        assert!(matches!(
-            CompressionFormat::from_url("file:///path/to/snapshot.tar.lz4"),
-            Ok(CompressionFormat::Lz4)
-        ));
-        assert!(matches!(
-            CompressionFormat::from_url("file:///path/to/snapshot.tar.zst"),
-            Ok(CompressionFormat::Zstd)
-        ));
-        assert!(CompressionFormat::from_url("https://example.com/snapshot.tar.gz").is_err());
-    }
 }
--- a/crates/cli/commands/src/import_core.rs
+++ b/crates/cli/commands/src/import_core.rs
@@ -69,7 +69,9 @@ pub async fn import_blocks_from_file<N>(
    provider_factory: ProviderFactory<N>,
    config: &Config,
    executor: impl ConfigureEvm<Primitives = N::Primitives> + 'static,
-    consensus: Arc<impl FullConsensus<N::Primitives> + 'static>,
+    consensus: Arc<
+        impl FullConsensus<N::Primitives, Error = reth_consensus::ConsensusError> + 'static,
+    >,
 ) -> eyre::Result<ImportResult>
 where
    N: ProviderNodeTypes,
@@ -196,7 +198,7 @@ pub fn build_import_pipeline_impl<N, C, E>(
 ) -> eyre::Result<(Pipeline<N>, impl futures::Stream<Item = NodeEvent<N::Primitives>> + use<N, C, E>)>
 where
    N: ProviderNodeTypes,
-    C: FullConsensus<N::Primitives> + 'static,
+    C: FullConsensus<N::Primitives, Error = reth_consensus::ConsensusError> + 'static,
    E: ConfigureEvm<Primitives = N::Primitives> + 'static,
 {
    if !file_client.has_canonical_blocks() {
--- a/crates/cli/commands/src/init_state/without_evm.rs
+++ b/crates/cli/commands/src/init_state/without_evm.rs
@@ -99,7 +99,6 @@ where
 /// * Headers: It will push an empty block.
 /// * Transactions: It will not push any tx, only increments the end block range.
 /// * Receipts: It will not push any receipt, only increments the end block range.
-/// * TransactionSenders: If the segment exists, increments the end block range.
 fn append_dummy_chain<N, F>(
    sf_provider: &StaticFileProvider<N>,
    target_height: BlockNumber,
@@ -111,15 +110,8 @@ where
 {
    let (tx, rx) = std::sync::mpsc::channel();

-    // Spawn jobs for incrementing the block end range of transactions, receipts, and senders.
-    for segment in [
-        StaticFileSegment::Transactions,
-        StaticFileSegment::Receipts,
-        StaticFileSegment::TransactionSenders,
-    ] {
-        if sf_provider.get_highest_static_file_block(segment).is_none() {
-            continue
-        }
+    // Spawn jobs for incrementing the block end range of transactions and receipts
+    for segment in [StaticFileSegment::Transactions, StaticFileSegment::Receipts] {
        let tx_clone = tx.clone();
        let provider = sf_provider.clone();
        std::thread::spawn(move || {
@@ -159,15 +151,9 @@ where

    // If, for any reason, rayon crashes this verifies if all segments are at the same
    // target_height.
-    for segment in [
-        StaticFileSegment::Headers,
-        StaticFileSegment::Receipts,
-        StaticFileSegment::Transactions,
-        StaticFileSegment::TransactionSenders,
-    ] {
-        if sf_provider.get_highest_static_file_block(segment).is_none() {
-            continue
-        }
+    for segment in
+        [StaticFileSegment::Headers, StaticFileSegment::Receipts, StaticFileSegment::Transactions]
+    {
        assert_eq!(
            sf_provider.latest_writer(segment)?.user_header().block_end(),
            Some(target_height),
--- a/crates/cli/commands/src/re_execute.rs
+++ b/crates/cli/commands/src/re_execute.rs
@@ -42,9 +42,9 @@ pub struct Command<C: ChainSpecParser> {
    #[arg(long)]
    to: Option<u64>,

-    /// Number of tasks to run in parallel. Defaults to the number of available CPUs.
-    #[arg(long)]
-    num_tasks: Option<u64>,
+    /// Number of tasks to run in parallel
+    #[arg(long, default_value = "10")]
+    num_tasks: u64,

    /// Continues with execution when an invalid block is encountered and collects these blocks.
    #[arg(long)]
@@ -84,16 +84,12 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
            }
        };

-        let num_tasks = self.num_tasks.unwrap_or_else(|| {
-            std::thread::available_parallelism().map(|n| n.get() as u64).unwrap_or(10)
-        });
-
        let total_blocks = max_block - min_block;
        let total_gas = calculate_gas_used_from_headers(
            &provider_factory.static_file_provider(),
            min_block..=max_block,
        )?;
-        let blocks_per_task = total_blocks / num_tasks;
+        let blocks_per_task = total_blocks / self.num_tasks;

        let db_at = {
            let provider_factory = provider_factory.clone();
@@ -111,10 +107,10 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
        let _guard = cancellation.drop_guard();

        let mut tasks = JoinSet::new();
-        for i in 0..num_tasks {
+        for i in 0..self.num_tasks {
            let start_block = min_block + i * blocks_per_task;
            let end_block =
-                if i == num_tasks - 1 { max_block } else { start_block + blocks_per_task };
+                if i == self.num_tasks - 1 { max_block } else { start_block + blocks_per_task };

            // Spawn thread executing blocks
            let provider_factory = provider_factory.clone();
@@ -152,7 +148,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
                    };

                    if let Err(err) = consensus
-                        .validate_block_post_execution(&block, &result, None)
+                        .validate_block_post_execution(&block, &result)
                        .wrap_err_with(|| {
                            format!("Failed to validate block {} {}", block.number(), block.hash())
                        })
--- a/crates/cli/commands/src/stage/drop.rs
+++ b/crates/cli/commands/src/stage/drop.rs
@@ -15,7 +15,7 @@ use reth_db_common::{
 use reth_node_api::{HeaderTy, ReceiptTy, TxTy};
 use reth_node_core::args::StageEnum;
 use reth_provider::{
-    DBProvider, DatabaseProviderFactory, StaticFileProviderFactory, StaticFileWriter,
+    DBProvider, DatabaseProviderFactory, StaticFileProviderFactory, StaticFileWriter, TrieWriter,
 };
 use reth_prune::PruneSegment;
 use reth_stages::StageId;
@@ -87,9 +87,6 @@ impl<C: ChainSpecParser> Command<C> {
                            .unwrap_or_default();
                        writer.prune_transaction_senders(to_delete, 0)?;
                    }
-                    StaticFileSegment::AccountChangeSets => {
-                        writer.prune_account_changesets(highest_block)?;
-                    }
                }
            }
        }
@@ -167,6 +164,10 @@ impl<C: ChainSpecParser> Command<C> {
                    None,
                )?;
            }
+            StageEnum::MerkleChangeSets => {
+                provider_rw.clear_trie_changesets()?;
+                reset_stage_checkpoint(tx, StageId::MerkleChangeSets)?;
+            }
            StageEnum::AccountHistory | StageEnum::StorageHistory => {
                tx.clear::<tables::AccountsHistory>()?;
                tx.clear::<tables::StoragesHistory>()?;
--- a/crates/cli/commands/src/stage/dump/execution.rs
+++ b/crates/cli/commands/src/stage/dump/execution.rs
@@ -1,5 +1,5 @@
 use super::setup;
-use reth_consensus::{noop::NoopConsensus, FullConsensus};
+use reth_consensus::{noop::NoopConsensus, ConsensusError, FullConsensus};
 use reth_db::DatabaseEnv;
 use reth_db_api::{
    cursor::DbCursorRO, database::Database, table::TableImporter, tables, transaction::DbTx,
@@ -28,7 +28,7 @@ pub(crate) async fn dump_execution_stage<N, E, C>(
 where
    N: ProviderNodeTypes<DB = Arc<DatabaseEnv>>,
    E: ConfigureEvm<Primitives = N::Primitives> + 'static,
-    C: FullConsensus<E::Primitives> + 'static,
+    C: FullConsensus<E::Primitives, Error = ConsensusError> + 'static,
 {
    let (output_db, tip_block_number) = setup(from, to, &output_datadir.db(), db_tool)?;

@@ -169,7 +169,7 @@ fn dry_run<N, E, C>(
 where
    N: ProviderNodeTypes,
    E: ConfigureEvm<Primitives = N::Primitives> + 'static,
-    C: FullConsensus<E::Primitives> + 'static,
+    C: FullConsensus<E::Primitives, Error = ConsensusError> + 'static,
 {
    info!(target: "reth::cli", "Executing stage. [dry-run]");

--- a/crates/cli/commands/src/stage/dump/merkle.rs
+++ b/crates/cli/commands/src/stage/dump/merkle.rs
@@ -4,7 +4,7 @@ use super::setup;
 use alloy_primitives::{Address, BlockNumber};
 use eyre::Result;
 use reth_config::config::EtlConfig;
-use reth_consensus::FullConsensus;
+use reth_consensus::{ConsensusError, FullConsensus};
 use reth_db::DatabaseEnv;
 use reth_db_api::{database::Database, models::BlockNumberAddress, table::TableImporter, tables};
 use reth_db_common::DbTool;
@@ -31,7 +31,7 @@ pub(crate) async fn dump_merkle_stage<N>(
    output_datadir: ChainPath<DataDirPath>,
    should_run: bool,
    evm_config: impl ConfigureEvm<Primitives = N::Primitives>,
-    consensus: impl FullConsensus<N::Primitives> + 'static,
+    consensus: impl FullConsensus<N::Primitives, Error = ConsensusError> + 'static,
 ) -> Result<()>
 where
    N: ProviderNodeTypes<DB = Arc<DatabaseEnv>>,
@@ -79,7 +79,7 @@ fn unwind_and_copy<N: ProviderNodeTypes>(
    tip_block_number: u64,
    output_db: &DatabaseEnv,
    evm_config: impl ConfigureEvm<Primitives = N::Primitives>,
-    consensus: impl FullConsensus<N::Primitives> + 'static,
+    consensus: impl FullConsensus<N::Primitives, Error = ConsensusError> + 'static,
 ) -> eyre::Result<()> {
    let (from, to) = range;
    let provider = db_tool.provider_factory.database_provider_rw()?;
--- a/crates/cli/commands/src/stage/run.rs
+++ b/crates/cli/commands/src/stage/run.rs
@@ -11,6 +11,7 @@ use reth_cli::chainspec::ChainSpecParser;
 use reth_cli_runner::CliContext;
 use reth_cli_util::get_secret_key;
 use reth_config::config::{HashingConfig, SenderRecoveryConfig, TransactionLookupConfig};
+use reth_db_api::database_metrics::DatabaseMetrics;
 use reth_downloaders::{
    bodies::bodies::BodiesDownloaderBuilder,
    headers::reverse_headers::ReverseHeadersDownloaderBuilder,
@@ -18,19 +19,19 @@ use reth_downloaders::{
 use reth_exex::ExExManagerHandle;
 use reth_network::BlockDownloaderProvider;
 use reth_network_p2p::HeadersClient;
-use reth_node_builder::common::metrics_hooks;
 use reth_node_core::{
    args::{NetworkArgs, StageEnum},
    version::version_metadata,
 };
 use reth_node_metrics::{
    chain::ChainSpecInfo,
+    hooks::Hooks,
    server::{MetricServer, MetricServerConfig},
    version::VersionInfo,
 };
 use reth_provider::{
    ChainSpecProvider, DBProvider, DatabaseProviderFactory, StageCheckpointReader,
-    StageCheckpointWriter,
+    StageCheckpointWriter, StaticFileProviderFactory,
 };
 use reth_stages::{
    stages::{
@@ -138,8 +139,20 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
                },
                ChainSpecInfo { name: provider_factory.chain_spec().chain().to_string() },
                ctx.task_executor,
-                metrics_hooks(&provider_factory),
-                data_dir.pprof_dumps(),
+                Hooks::builder()
+                    .with_hook({
+                        let db = provider_factory.db_ref().clone();
+                        move || db.report_metrics()
+                    })
+                    .with_hook({
+                        let sfp = provider_factory.static_file_provider();
+                        move || {
+                            if let Err(error) = sfp.report_metrics() {
+                                error!(%error, "Failed to report metrics from static file provider");
+                            }
+                        }
+                    })
+                    .build(),
            );

            MetricServer::new(config).serve().await?;
--- a/crates/cli/runner/src/lib.rs
+++ b/crates/cli/runner/src/lib.rs
@@ -18,8 +18,8 @@ use tracing::{debug, error, trace};
 ///
 /// Provides utilities for running a cli command to completion.
 #[derive(Debug)]
+#[non_exhaustive]
 pub struct CliRunner {
-    config: CliRunnerConfig,
    tokio_runtime: tokio::runtime::Runtime,
 }

@@ -29,18 +29,12 @@ impl CliRunner {
    ///
    /// The default tokio runtime is multi-threaded, with both I/O and time drivers enabled.
    pub fn try_default_runtime() -> Result<Self, std::io::Error> {
-        Ok(Self { config: CliRunnerConfig::default(), tokio_runtime: tokio_runtime()? })
+        Ok(Self { tokio_runtime: tokio_runtime()? })
    }

    /// Create a new [`CliRunner`] from a provided tokio [`Runtime`](tokio::runtime::Runtime).
    pub const fn from_runtime(tokio_runtime: tokio::runtime::Runtime) -> Self {
-        Self { config: CliRunnerConfig::new(), tokio_runtime }
-    }
-
-    /// Sets the [`CliRunnerConfig`] for this runner.
-    pub const fn with_config(mut self, config: CliRunnerConfig) -> Self {
-        self.config = config;
-        self
+        Self { tokio_runtime }
    }

    /// Executes an async block on the runtime and blocks until completion.
@@ -80,7 +74,7 @@ impl CliRunner {
            // after the command has finished or exit signal was received we shutdown the task
            // manager which fires the shutdown signal to all tasks spawned via the task
            // executor and awaiting on tasks spawned with graceful shutdown
-            task_manager.graceful_shutdown_with_timeout(self.config.graceful_shutdown_timeout);
+            task_manager.graceful_shutdown_with_timeout(Duration::from_secs(5));
        }

        // `drop(tokio_runtime)` would block the current thread until its pools
@@ -134,7 +128,7 @@ impl CliRunner {
            error!(target: "reth::cli", "shutting down due to error");
        } else {
            debug!(target: "reth::cli", "shutting down gracefully");
-            task_manager.graceful_shutdown_with_timeout(self.config.graceful_shutdown_timeout);
+            task_manager.graceful_shutdown_with_timeout(Duration::from_secs(5));
        }

        // Shutdown the runtime on a separate thread
@@ -217,38 +211,6 @@ pub struct CliContext {
    pub task_executor: TaskExecutor,
 }

-/// Default timeout for graceful shutdown of tasks.
-const DEFAULT_GRACEFUL_SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(5);
-
-/// Configuration for [`CliRunner`].
-#[derive(Debug, Clone)]
-pub struct CliRunnerConfig {
-    /// Timeout for graceful shutdown of tasks.
-    ///
-    /// After the command completes, this is the maximum time to wait for spawned tasks
-    /// to finish before forcefully terminating them.
-    pub graceful_shutdown_timeout: Duration,
-}
-
-impl Default for CliRunnerConfig {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl CliRunnerConfig {
-    /// Creates a new config with default values.
-    pub const fn new() -> Self {
-        Self { graceful_shutdown_timeout: DEFAULT_GRACEFUL_SHUTDOWN_TIMEOUT }
-    }
-
-    /// Sets the graceful shutdown timeout.
-    pub const fn with_graceful_shutdown_timeout(mut self, timeout: Duration) -> Self {
-        self.graceful_shutdown_timeout = timeout;
-        self
-    }
-}
-
 /// Creates a new default tokio multi-thread [Runtime](tokio::runtime::Runtime) with all features
 /// enabled
 pub fn tokio_runtime() -> Result<tokio::runtime::Runtime, std::io::Error> {
--- a/crates/cli/util/Cargo.toml
+++ b/crates/cli/util/Cargo.toml
@@ -26,8 +26,7 @@ rand_08.workspace = true
 thiserror.workspace = true
 serde.workspace = true

-tracy-client = { workspace = true, optional = true }
-reth-tracing = { workspace = true, optional = true }
+tracy-client = { workspace = true, optional = true, features = ["demangle"] }

 [dev-dependencies]
 rand.workspace = true
@@ -47,7 +46,7 @@ jemalloc-prof = ["jemalloc", "tikv-jemallocator?/profiling"]
 jemalloc-unprefixed = ["jemalloc", "tikv-jemallocator?/unprefixed_malloc_on_supported_platforms"]

 # Wraps the selected allocator in the tracy profiling allocator
-tracy-allocator = ["dep:tracy-client", "dep:reth-tracing"]
+tracy-allocator = ["dep:tracy-client"]

 snmalloc = ["dep:snmalloc-rs"]

--- a/crates/cli/util/src/allocator.rs
+++ b/crates/cli/util/src/allocator.rs
@@ -25,6 +25,7 @@ cfg_if::cfg_if! {
 cfg_if::cfg_if! {
    if #[cfg(feature = "tracy-allocator")] {
        type AllocatorWrapper = tracy_client::ProfiledAllocator<AllocatorInner>;
+        tracy_client::register_demangler!();
        const fn new_allocator_wrapper() -> AllocatorWrapper {
            AllocatorWrapper::new(AllocatorInner {}, 100)
        }
--- a/crates/cli/util/src/lib.rs
+++ b/crates/cli/util/src/lib.rs
@@ -8,9 +8,6 @@
 #![cfg_attr(not(test), warn(unused_crate_dependencies))]
 #![cfg_attr(docsrs, feature(doc_cfg))]

-#[cfg(feature = "tracy-allocator")]
-use reth_tracing as _;
-
 pub mod allocator;
 pub mod cancellation;

--- a/crates/config/src/config.rs
+++ b/crates/config/src/config.rs
@@ -2,8 +2,9 @@
 use reth_network_types::{PeersConfig, SessionsConfig};
 use reth_prune_types::PruneModes;
 use reth_stages_types::ExecutionStageThresholds;
-use reth_static_file_types::{StaticFileMap, StaticFileSegment};
+use reth_static_file_types::StaticFileSegment;
 use std::{
+    collections::HashMap,
    path::{Path, PathBuf},
    time::Duration,
 };
@@ -436,8 +437,6 @@ pub struct BlocksPerFileConfig {
    pub receipts: Option<u64>,
    /// Number of blocks per file for the transaction senders segment.
    pub transaction_senders: Option<u64>,
-    /// Number of blocks per file for the account changesets segment.
-    pub account_change_sets: Option<u64>,
 }

 impl StaticFilesConfig {
@@ -445,13 +444,8 @@ impl StaticFilesConfig {
    ///
    /// Returns an error if any blocks per file value is zero.
    pub fn validate(&self) -> eyre::Result<()> {
-        let BlocksPerFileConfig {
-            headers,
-            transactions,
-            receipts,
-            transaction_senders,
-            account_change_sets,
-        } = self.blocks_per_file;
+        let BlocksPerFileConfig { headers, transactions, receipts, transaction_senders } =
+            self.blocks_per_file;
        eyre::ensure!(headers != Some(0), "Headers segment blocks per file must be greater than 0");
        eyre::ensure!(
            transactions != Some(0),
@@ -465,24 +459,15 @@ impl StaticFilesConfig {
            transaction_senders != Some(0),
            "Transaction senders segment blocks per file must be greater than 0"
        );
-        eyre::ensure!(
-            account_change_sets != Some(0),
-            "Account changesets segment blocks per file must be greater than 0"
-        );
        Ok(())
    }

-    /// Converts the blocks per file configuration into a [`StaticFileMap`].
-    pub fn as_blocks_per_file_map(&self) -> StaticFileMap<u64> {
-        let BlocksPerFileConfig {
-            headers,
-            transactions,
-            receipts,
-            transaction_senders,
-            account_change_sets,
-        } = self.blocks_per_file;
+    /// Converts the blocks per file configuration into a [`HashMap`] per segment.
+    pub fn as_blocks_per_file_map(&self) -> HashMap<StaticFileSegment, u64> {
+        let BlocksPerFileConfig { headers, transactions, receipts, transaction_senders } =
+            self.blocks_per_file;

-        let mut map = StaticFileMap::default();
+        let mut map = HashMap::new();
        // Iterating over all possible segments allows us to do an exhaustive match here,
        // to not forget to configure new segments in the future.
        for segment in StaticFileSegment::iter() {
@@ -491,7 +476,6 @@ impl StaticFilesConfig {
                StaticFileSegment::Transactions => transactions,
                StaticFileSegment::Receipts => receipts,
                StaticFileSegment::TransactionSenders => transaction_senders,
-                StaticFileSegment::AccountChangeSets => account_change_sets,
            };

            if let Some(blocks_per_file) = blocks_per_file {
@@ -543,13 +527,14 @@ impl PruneConfig {

    /// Returns whether there is any kind of receipt pruning configuration.
    pub fn has_receipts_pruning(&self) -> bool {
-        self.segments.has_receipts_pruning()
+        self.segments.receipts.is_some() || !self.segments.receipts_log_filter.is_empty()
    }

    /// Merges values from `other` into `self`.
    /// - `Option<PruneMode>` fields: set from `other` only if `self` is `None`.
    /// - `block_interval`: set from `other` only if `self.block_interval ==
    ///   DEFAULT_BLOCK_INTERVAL`.
+    /// - `merkle_changesets`: always set from `other`.
    /// - `receipts_log_filter`: set from `other` only if `self` is empty and `other` is non-empty.
    pub fn merge(&mut self, other: Self) {
        let Self {
@@ -562,6 +547,7 @@ impl PruneConfig {
                    account_history,
                    storage_history,
                    bodies_history,
+                    merkle_changesets,
                    receipts_log_filter,
                },
        } = other;
@@ -578,6 +564,8 @@ impl PruneConfig {
        self.segments.account_history = self.segments.account_history.or(account_history);
        self.segments.storage_history = self.segments.storage_history.or(storage_history);
        self.segments.bodies_history = self.segments.bodies_history.or(bodies_history);
+        // Merkle changesets is not optional; always take the value from `other`
+        self.segments.merkle_changesets = merkle_changesets;

        if self.segments.receipts_log_filter.0.is_empty() && !receipts_log_filter.0.is_empty() {
            self.segments.receipts_log_filter = receipts_log_filter;
@@ -1074,6 +1062,18 @@ transaction_lookup = 'full'
 receipts = { distance = 16384 }
 #";
        let _conf: Config = toml::from_str(s).unwrap();
+
+        let s = r"#
+[prune]
+block_interval = 5
+
+[prune.segments]
+sender_recovery = { distance = 16384 }
+transaction_lookup = 'full'
+receipts = 'full'
+#";
+        let err = toml::from_str::<Config>(s).unwrap_err().to_string();
+        assert!(err.contains("invalid value: string \"full\""), "{}", err);
    }

    #[test]
@@ -1087,6 +1087,7 @@ receipts = { distance = 16384 }
                account_history: None,
                storage_history: Some(PruneMode::Before(5000)),
                bodies_history: None,
+                merkle_changesets: PruneMode::Before(0),
                receipts_log_filter: ReceiptsLogPruneConfig(BTreeMap::from([(
                    Address::random(),
                    PruneMode::Full,
@@ -1103,6 +1104,7 @@ receipts = { distance = 16384 }
                account_history: Some(PruneMode::Distance(2000)),
                storage_history: Some(PruneMode::Distance(3000)),
                bodies_history: None,
+                merkle_changesets: PruneMode::Distance(10000),
                receipts_log_filter: ReceiptsLogPruneConfig(BTreeMap::from([
                    (Address::random(), PruneMode::Distance(1000)),
                    (Address::random(), PruneMode::Before(2000)),
@@ -1121,6 +1123,7 @@ receipts = { distance = 16384 }
        assert_eq!(config1.segments.receipts, Some(PruneMode::Distance(1000)));
        assert_eq!(config1.segments.account_history, Some(PruneMode::Distance(2000)));
        assert_eq!(config1.segments.storage_history, Some(PruneMode::Before(5000)));
+        assert_eq!(config1.segments.merkle_changesets, PruneMode::Distance(10000));
        assert_eq!(config1.segments.receipts_log_filter, original_filter);
    }

--- a/crates/consensus/common/src/validation.rs
+++ b/crates/consensus/common/src/validation.rs
@@ -500,11 +500,13 @@ mod tests {
        let expected_blob_gas_used = 10 * DATA_GAS_PER_BLOB;

        // validate blob, it should fail blob gas used validation
-        assert!(matches!(
-            validate_block_pre_execution(&block, &chain_spec).unwrap_err(),
-            ConsensusError::BlobGasUsedDiff(diff)
-                if diff.got == 1 && diff.expected == expected_blob_gas_used
-        ));
+        assert_eq!(
+            validate_block_pre_execution(&block, &chain_spec),
+            Err(ConsensusError::BlobGasUsedDiff(GotExpected {
+                got: 1,
+                expected: expected_blob_gas_used
+            }))
+        );
    }

    #[test]
@@ -515,10 +517,10 @@ mod tests {

        // Test exceeding default - should fail
        let header_33 = Header { extra_data: Bytes::from(vec![0; 33]), ..Default::default() };
-        assert!(matches!(
-            validate_header_extra_data(&header_33, 32).unwrap_err(),
-            ConsensusError::ExtraDataExceedsMax { len } if len == 33
-        ));
+        assert_eq!(
+            validate_header_extra_data(&header_33, 32),
+            Err(ConsensusError::ExtraDataExceedsMax { len: 33 })
+        );

        // Test with custom larger limit - should pass
        assert!(validate_header_extra_data(&header_33, 64).is_ok());
--- a/crates/consensus/consensus/src/lib.rs
+++ b/crates/consensus/consensus/src/lib.rs
@@ -11,16 +11,9 @@

 extern crate alloc;

-use alloc::{boxed::Box, fmt::Debug, string::String, sync::Arc, vec::Vec};
+use alloc::{boxed::Box, fmt::Debug, string::String, vec::Vec};
 use alloy_consensus::Header;
 use alloy_primitives::{BlockHash, BlockNumber, Bloom, B256};
-use core::error::Error;
-
-/// Pre-computed receipt root and logs bloom.
-///
-/// When provided to [`FullConsensus::validate_block_post_execution`], this allows skipping
-/// the receipt root computation and using the pre-computed values instead.
-pub type ReceiptRootBloom = (B256, Bloom);
 use reth_execution_types::BlockExecutionResult;
 use reth_primitives_traits::{
    constants::{GAS_LIMIT_BOUND_DIVISOR, MAXIMUM_GAS_LIMIT_BLOCK, MINIMUM_GAS_LIMIT},
@@ -45,27 +38,26 @@ pub trait FullConsensus<N: NodePrimitives>: Consensus<N::Block> {
    ///
    /// See the Yellow Paper sections 4.3.2 "Holistic Validity".
    ///
-    /// If `receipt_root_bloom` is provided, the implementation should use the pre-computed
-    /// receipt root and logs bloom instead of computing them from the receipts.
-    ///
    /// Note: validating blocks does not include other validations of the Consensus
    fn validate_block_post_execution(
        &self,
        block: &RecoveredBlock<N::Block>,
        result: &BlockExecutionResult<N::Receipt>,
-        receipt_root_bloom: Option<ReceiptRootBloom>,
    ) -> Result<(), ConsensusError>;
 }

 /// Consensus is a protocol that chooses canonical chain.
 #[auto_impl::auto_impl(&, Arc)]
 pub trait Consensus<B: Block>: HeaderValidator<B::Header> {
+    /// The error type related to consensus.
+    type Error;
+
    /// Ensures that body field values match the header.
    fn validate_body_against_header(
        &self,
        body: &B::Body,
        header: &SealedHeader<B::Header>,
-    ) -> Result<(), ConsensusError>;
+    ) -> Result<(), Self::Error>;

    /// Validate a block disregarding world state, i.e. things that can be checked before sender
    /// recovery and execution.
@@ -77,7 +69,7 @@ pub trait Consensus<B: Block>: HeaderValidator<B::Header> {
    /// **This should not be called for the genesis block**.
    ///
    /// Note: validating blocks does not include other validations of the Consensus
-    fn validate_block_pre_execution(&self, block: &SealedBlock<B>) -> Result<(), ConsensusError>;
+    fn validate_block_pre_execution(&self, block: &SealedBlock<B>) -> Result<(), Self::Error>;
 }

 /// `HeaderValidator` is a protocol that validates headers and their relationships.
@@ -133,7 +125,7 @@ pub trait HeaderValidator<H = Header>: Debug + Send + Sync {
 }

 /// Consensus Errors
-#[derive(Debug, Clone, thiserror::Error)]
+#[derive(Debug, PartialEq, Eq, Clone, thiserror::Error)]
 pub enum ConsensusError {
    /// Error when the gas used in the header exceeds the gas limit.
    #[error("block used gas ({gas_used}) is greater than gas limit ({gas_limit})")]
@@ -418,9 +410,6 @@ pub enum ConsensusError {
    /// Other, likely an injected L2 error.
    #[error("{0}")]
    Other(String),
-    /// Other unspecified error.
-    #[error(transparent)]
-    Custom(#[from] Arc<dyn Error + Send + Sync>),
 }

 impl ConsensusError {
@@ -458,34 +447,3 @@ pub struct TxGasLimitTooHighErr {
    /// The maximum allowed gas limit
    pub max_allowed: u64,
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[derive(thiserror::Error, Debug)]
-    #[error("Custom L2 consensus error")]
-    struct CustomL2Error;
-
-    #[test]
-    fn test_custom_error_conversion() {
-        // Test conversion from custom error to ConsensusError
-        let custom_err = CustomL2Error;
-        let arc_err: Arc<dyn Error + Send + Sync> = Arc::new(custom_err);
-        let consensus_err: ConsensusError = arc_err.into();
-
-        // Verify it's the Custom variant
-        assert!(matches!(consensus_err, ConsensusError::Custom(_)));
-    }
-
-    #[test]
-    fn test_custom_error_display() {
-        let custom_err = CustomL2Error;
-        let arc_err: Arc<dyn Error + Send + Sync> = Arc::new(custom_err);
-        let consensus_err: ConsensusError = arc_err.into();
-
-        // Verify the error message is preserved through transparent attribute
-        let error_message = format!("{}", consensus_err);
-        assert_eq!(error_message, "Custom L2 consensus error");
-    }
-}
--- a/crates/consensus/consensus/src/noop.rs
+++ b/crates/consensus/consensus/src/noop.rs
@@ -18,7 +18,7 @@
 //!
 //! **Not for production use** - provides no security guarantees or consensus validation.

-use crate::{Consensus, ConsensusError, FullConsensus, HeaderValidator, ReceiptRootBloom};
+use crate::{Consensus, ConsensusError, FullConsensus, HeaderValidator};
 use alloc::sync::Arc;
 use reth_execution_types::BlockExecutionResult;
 use reth_primitives_traits::{Block, NodePrimitives, RecoveredBlock, SealedBlock, SealedHeader};
@@ -55,17 +55,19 @@ impl<H> HeaderValidator<H> for NoopConsensus {
 }

 impl<B: Block> Consensus<B> for NoopConsensus {
+    type Error = ConsensusError;
+
    /// Validates body against header (no-op implementation).
    fn validate_body_against_header(
        &self,
        _body: &B::Body,
        _header: &SealedHeader<B::Header>,
-    ) -> Result<(), ConsensusError> {
+    ) -> Result<(), Self::Error> {
        Ok(())
    }

    /// Validates block before execution (no-op implementation).
-    fn validate_block_pre_execution(&self, _block: &SealedBlock<B>) -> Result<(), ConsensusError> {
+    fn validate_block_pre_execution(&self, _block: &SealedBlock<B>) -> Result<(), Self::Error> {
        Ok(())
    }
 }
@@ -76,7 +78,6 @@ impl<N: NodePrimitives> FullConsensus<N> for NoopConsensus {
        &self,
        _block: &RecoveredBlock<N::Block>,
        _result: &BlockExecutionResult<N::Receipt>,
-        _receipt_root_bloom: Option<ReceiptRootBloom>,
    ) -> Result<(), ConsensusError> {
        Ok(())
    }
--- a/crates/consensus/consensus/src/test_utils.rs
+++ b/crates/consensus/consensus/src/test_utils.rs
@@ -1,4 +1,4 @@
-use crate::{Consensus, ConsensusError, FullConsensus, HeaderValidator, ReceiptRootBloom};
+use crate::{Consensus, ConsensusError, FullConsensus, HeaderValidator};
 use core::sync::atomic::{AtomicBool, Ordering};
 use reth_execution_types::BlockExecutionResult;
 use reth_primitives_traits::{Block, NodePrimitives, RecoveredBlock, SealedBlock, SealedHeader};
@@ -51,7 +51,6 @@ impl<N: NodePrimitives> FullConsensus<N> for TestConsensus {
        &self,
        _block: &RecoveredBlock<N::Block>,
        _result: &BlockExecutionResult<N::Receipt>,
-        _receipt_root_bloom: Option<ReceiptRootBloom>,
    ) -> Result<(), ConsensusError> {
        if self.fail_validation() {
            Err(ConsensusError::BaseFeeMissing)
@@ -62,11 +61,13 @@ impl<N: NodePrimitives> FullConsensus<N> for TestConsensus {
 }

 impl<B: Block> Consensus<B> for TestConsensus {
+    type Error = ConsensusError;
+
    fn validate_body_against_header(
        &self,
        _body: &B::Body,
        _header: &SealedHeader<B::Header>,
-    ) -> Result<(), ConsensusError> {
+    ) -> Result<(), Self::Error> {
        if self.fail_body_against_header() {
            Err(ConsensusError::BaseFeeMissing)
        } else {
@@ -74,7 +75,7 @@ impl<B: Block> Consensus<B> for TestConsensus {
        }
    }

-    fn validate_block_pre_execution(&self, _block: &SealedBlock<B>) -> Result<(), ConsensusError> {
+    fn validate_block_pre_execution(&self, _block: &SealedBlock<B>) -> Result<(), Self::Error> {
        if self.fail_validation() {
            Err(ConsensusError::BaseFeeMissing)
        } else {
--- a/crates/e2e-test-utils/src/node.rs
+++ b/crates/e2e-test-utils/src/node.rs
@@ -2,11 +2,11 @@ use crate::{network::NetworkTestContext, payload::PayloadTestContext, rpc::RpcTe
 use alloy_consensus::{transaction::TxHashRef, BlockHeader};
 use alloy_eips::BlockId;
 use alloy_primitives::{BlockHash, BlockNumber, Bytes, Sealable, B256};
-use alloy_rpc_types_engine::{ExecutionPayloadEnvelopeV5, ForkchoiceState};
+use alloy_rpc_types_engine::ForkchoiceState;
 use alloy_rpc_types_eth::BlockNumberOrTag;
 use eyre::Ok;
 use futures_util::Future;
-use jsonrpsee::{core::client::ClientT, http_client::HttpClient};
+use jsonrpsee::http_client::HttpClient;
 use reth_chainspec::EthereumHardforks;
 use reth_network_api::test_utils::PeersHandleProvider;
 use reth_node_api::{
@@ -20,7 +20,6 @@ use reth_provider::{
    BlockReader, BlockReaderIdExt, CanonStateNotificationStream, CanonStateSubscriptions,
    HeaderProvider, StageCheckpointReader,
 };
-use reth_rpc_api::TestingBuildBlockRequestV1;
 use reth_rpc_builder::auth::AuthServerHandle;
 use reth_rpc_eth_api::helpers::{EthApiSpec, EthTransactions, TraceExt};
 use reth_stages_types::StageId;
@@ -320,20 +319,4 @@ where

        Ok(crate::testsuite::NodeClient::new_with_beacon_engine(rpc, auth, url, beacon_handle))
    }
-
-    /// Calls the `testing_buildBlockV1` RPC on this node.
-    ///
-    /// This endpoint builds a block using the provided parent, payload attributes, and
-    /// transactions. Requires the `Testing` RPC module to be enabled.
-    pub async fn testing_build_block_v1(
-        &self,
-        request: TestingBuildBlockRequestV1,
-    ) -> eyre::Result<ExecutionPayloadEnvelopeV5> {
-        let client =
-            self.rpc_client().ok_or_else(|| eyre::eyre!("HTTP RPC client not available"))?;
-
-        let res: ExecutionPayloadEnvelopeV5 =
-            client.request("testing_buildBlockV1", [request]).await?;
-        eyre::Ok(res)
-    }
 }
--- a/crates/e2e-test-utils/src/setup_import.rs
+++ b/crates/e2e-test-utils/src/setup_import.rs
@@ -113,6 +113,7 @@ pub async fn setup_engine_with_chain_import(
        let rocksdb_dir_path = datadir.join("rocksdb");

        // Initialize the database using init_db (same as CLI import command)
+        // Use the same database arguments as the node will use
        let db_args = reth_node_core::args::DatabaseArgs::default().database_args();
        let db_env = reth_db::init_db(&db_path, db_args)?;
        let db = Arc::new(db_env);
@@ -316,8 +317,7 @@ mod tests {

        // Import the chain
        {
-            let db_args = reth_node_core::args::DatabaseArgs::default().database_args();
-            let db_env = reth_db::init_db(&db_path, db_args).unwrap();
+            let db_env = reth_db::init_db(&db_path, DatabaseArguments::default()).unwrap();
            let db = Arc::new(db_env);

            let provider_factory: ProviderFactory<
@@ -475,8 +475,7 @@ mod tests {
        let datadir = temp_dir.path().join("datadir");
        std::fs::create_dir_all(&datadir).unwrap();
        let db_path = datadir.join("db");
-        let db_args = reth_node_core::args::DatabaseArgs::default().database_args();
-        let db_env = reth_db::init_db(&db_path, db_args).unwrap();
+        let db_env = reth_db::init_db(&db_path, DatabaseArguments::default()).unwrap();
        let db = Arc::new(reth_db::test_utils::TempDatabase::new(db_env, db_path));

        // Create static files path
--- a/crates/engine/invalid-block-hooks/src/witness.rs
+++ b/crates/engine/invalid-block-hooks/src/witness.rs
@@ -448,14 +448,12 @@ mod tests {
                    nonce: account.nonce,
                    code_hash: account.bytecode_hash.unwrap_or_default(),
                    code: None,
-                    account_id: None,
                }),
                original_info: (i == 0).then(|| AccountInfo {
                    balance: account.balance.checked_div(U256::from(2)).unwrap_or(U256::ZERO),
                    nonce: 0,
                    code_hash: account.bytecode_hash.unwrap_or_default(),
                    code: None,
-                    account_id: None,
                }),
                storage,
                status: AccountStatus::default(),
--- a/crates/engine/primitives/src/config.rs
+++ b/crates/engine/primitives/src/config.rs
@@ -135,8 +135,6 @@ pub struct TreeConfig {
    storage_worker_count: usize,
    /// Number of account proof worker threads.
    account_worker_count: usize,
-    /// Whether to enable V2 storage proofs.
-    enable_proof_v2: bool,
 }

 impl Default for TreeConfig {
@@ -165,7 +163,6 @@ impl Default for TreeConfig {
            allow_unwind_canonical_header: false,
            storage_worker_count: default_storage_worker_count(),
            account_worker_count: default_account_worker_count(),
-            enable_proof_v2: false,
        }
    }
 }
@@ -197,7 +194,6 @@ impl TreeConfig {
        allow_unwind_canonical_header: bool,
        storage_worker_count: usize,
        account_worker_count: usize,
-        enable_proof_v2: bool,
    ) -> Self {
        Self {
            persistence_threshold,
@@ -223,7 +219,6 @@ impl TreeConfig {
            allow_unwind_canonical_header,
            storage_worker_count,
            account_worker_count,
-            enable_proof_v2,
        }
    }

@@ -505,15 +500,4 @@ impl TreeConfig {
        self.account_worker_count = account_worker_count.max(MIN_WORKER_COUNT);
        self
    }
-
-    /// Return whether V2 storage proofs are enabled.
-    pub const fn enable_proof_v2(&self) -> bool {
-        self.enable_proof_v2
-    }
-
-    /// Setter for whether to enable V2 storage proofs.
-    pub const fn with_enable_proof_v2(mut self, enable_proof_v2: bool) -> Self {
-        self.enable_proof_v2 = enable_proof_v2;
-        self
-    }
 }
--- a/crates/engine/service/Cargo.toml
+++ b/crates/engine/service/Cargo.toml
@@ -25,7 +25,6 @@ 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
@@ -41,8 +40,6 @@ 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
--- a/crates/engine/service/src/service.rs
+++ b/crates/engine/service/src/service.rs
@@ -1,7 +1,7 @@
 use futures::{Stream, StreamExt};
 use pin_project::pin_project;
 use reth_chainspec::EthChainSpec;
-use reth_consensus::FullConsensus;
+use reth_consensus::{ConsensusError, FullConsensus};
 use reth_engine_primitives::{BeaconEngineMessage, ConsensusEngineEvent};
 use reth_engine_tree::{
    backfill::PipelineSync,
@@ -26,7 +26,6 @@ use reth_provider::{
 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,
@@ -71,7 +70,7 @@ where
    /// Constructor for `EngineService`.
    #[expect(clippy::too_many_arguments)]
    pub fn new<V, C>(
-        consensus: Arc<dyn FullConsensus<N::Primitives>>,
+        consensus: Arc<dyn FullConsensus<N::Primitives, Error = ConsensusError>>,
        chain_spec: Arc<N::ChainSpec>,
        client: Client,
        incoming_requests: EngineMessageStream<N::Payload>,
@@ -85,7 +84,6 @@ where
        tree_config: TreeConfig,
        sync_metrics_tx: MetricEventsSender,
        evm_config: C,
-        changeset_cache: ChangesetCache,
    ) -> Self
    where
        V: EngineValidator<N::Payload>,
@@ -111,7 +109,6 @@ where
            tree_config,
            engine_kind,
            evm_config,
-            changeset_cache,
        );

        let engine_handler = EngineApiRequestHandler::new(to_tree_tx, from_tree);
@@ -159,7 +156,6 @@ mod tests {
    };
    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;
@@ -192,8 +188,6 @@ mod tests {
        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(),
@@ -201,7 +195,6 @@ mod tests {
            engine_payload_validator,
            TreeConfig::default(),
            Box::new(NoopInvalidBlockHook::default()),
-            changeset_cache.clone(),
        );

        let (sync_metrics_tx, _sync_metrics_rx) = unbounded_channel();
@@ -221,7 +214,6 @@ mod tests {
            TreeConfig::default(),
            sync_metrics_tx,
            evm_config,
-            changeset_cache,
        );
    }
 }
--- a/crates/engine/tree/Cargo.toml
+++ b/crates/engine/tree/Cargo.toml
@@ -29,13 +29,12 @@ reth-provider.workspace = true
 reth-prune.workspace = true
 reth-revm.workspace = true
 reth-stages-api.workspace = true
+reth-storage-errors.workspace = true
 reth-tasks.workspace = true
 reth-trie-parallel.workspace = true
 reth-trie-sparse = { workspace = true, features = ["std", "metrics"] }
 reth-trie-sparse-parallel = { workspace = true, features = ["std"] }
 reth-trie.workspace = true
-reth-trie-common.workspace = true
-reth-trie-db.workspace = true

 # alloy
 alloy-evm.workspace = true
@@ -96,7 +95,7 @@ reth-tracing.workspace = true
 reth-node-ethereum.workspace = true
 reth-e2e-test-utils.workspace = true

-# revm
+# alloy
 revm-state.workspace = true

 assert_matches.workspace = true
@@ -135,8 +134,6 @@ test-utils = [
    "reth-static-file",
    "reth-tracing",
    "reth-trie/test-utils",
-    "reth-trie-common/test-utils",
-    "reth-trie-db/test-utils",
    "reth-trie-sparse/test-utils",
    "reth-prune-types?/test-utils",
    "reth-trie-parallel/test-utils",
--- a/crates/engine/tree/benches/channel_perf.rs
+++ b/crates/engine/tree/benches/channel_perf.rs
@@ -26,9 +26,7 @@ fn create_bench_state(num_accounts: usize) -> EvmState {
                nonce: 10,
                code_hash: B256::from_slice(&rng.random::<[u8; 32]>()),
                code: Default::default(),
-                account_id: None,
            },
-            original_info: Box::new(AccountInfo::default()),
            storage,
            status: AccountStatus::empty(),
            transaction_id: 0,
--- a/crates/engine/tree/benches/state_root_task.rs
+++ b/crates/engine/tree/benches/state_root_task.rs
@@ -62,7 +62,6 @@ fn create_bench_state_updates(params: &BenchParams) -> Vec<EvmState> {
                    storage: HashMap::default(),
                    status: AccountStatus::SelfDestructed,
                    transaction_id: 0,
-                    original_info: Box::new(AccountInfo::default()),
                }
            } else {
                RevmAccount {
@@ -71,7 +70,6 @@ fn create_bench_state_updates(params: &BenchParams) -> Vec<EvmState> {
                        nonce: rng.random::<u64>(),
                        code_hash: KECCAK_EMPTY,
                        code: Some(Default::default()),
-                        account_id: None,
                    },
                    storage: (0..rng.random_range(0..=params.storage_slots_per_account))
                        .map(|_| {
@@ -86,7 +84,6 @@ fn create_bench_state_updates(params: &BenchParams) -> Vec<EvmState> {
                        })
                        .collect(),
                    status: AccountStatus::Touched,
-                    original_info: Box::new(AccountInfo::default()),
                    transaction_id: 0,
                }
            };
@@ -242,10 +239,7 @@ fn bench_state_root(c: &mut Criterion) {
                                    std::convert::identity,
                                ),
                                StateProviderBuilder::new(provider.clone(), genesis_hash, None),
-                                OverlayStateProviderFactory::new(
-                                    provider,
-                                    reth_trie_db::ChangesetCache::new(),
-                                ),
+                                OverlayStateProviderFactory::new(provider),
                                &TreeConfig::default(),
                                None,
                            );
--- a/crates/engine/tree/src/download.rs
+++ b/crates/engine/tree/src/download.rs
@@ -4,7 +4,7 @@ use crate::{engine::DownloadRequest, metrics::BlockDownloaderMetrics};
 use alloy_consensus::BlockHeader;
 use alloy_primitives::B256;
 use futures::FutureExt;
-use reth_consensus::Consensus;
+use reth_consensus::{Consensus, ConsensusError};
 use reth_network_p2p::{
    full_block::{FetchFullBlockFuture, FetchFullBlockRangeFuture, FullBlockClient},
    BlockClient,
@@ -81,7 +81,7 @@ where
    B: Block,
 {
    /// Create a new instance
-    pub fn new(client: Client, consensus: Arc<dyn Consensus<B>>) -> Self {
+    pub fn new(client: Client, consensus: Arc<dyn Consensus<B, Error = ConsensusError>>) -> Self {
        Self {
            full_block_client: FullBlockClient::new(client, consensus),
            inflight_full_block_requests: Vec::new(),
--- a/crates/engine/tree/src/engine.rs
+++ b/crates/engine/tree/src/engine.rs
@@ -6,7 +6,6 @@ use crate::{
    download::{BlockDownloader, DownloadAction, DownloadOutcome},
 };
 use alloy_primitives::B256;
-use crossbeam_channel::Sender;
 use futures::{Stream, StreamExt};
 use reth_chain_state::ExecutedBlock;
 use reth_engine_primitives::{BeaconEngineMessage, ConsensusEngineEvent};
@@ -16,6 +15,7 @@ use reth_primitives_traits::{Block, NodePrimitives, SealedBlock};
 use std::{
    collections::HashSet,
    fmt::Display,
+    sync::mpsc::Sender,
    task::{ready, Context, Poll},
 };
 use tokio::sync::mpsc::UnboundedReceiver;
--- a/crates/engine/tree/src/persistence.rs
+++ b/crates/engine/tree/src/persistence.rs
@@ -1,13 +1,12 @@
 use crate::metrics::PersistenceMetrics;
 use alloy_eips::BlockNumHash;
-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_provider::{
    providers::ProviderNodeTypes, BlockExecutionWriter, BlockHashReader, ChainStateBlockWriter,
-    DBProvider, DatabaseProviderFactory, ProviderFactory, SaveBlocksMode,
+    DBProvider, DatabaseProviderFactory, ProviderFactory,
 };
 use reth_prune::{PrunerError, PrunerOutput, PrunerWithFactory};
 use reth_stages_api::{MetricEvent, MetricEventsSender};
@@ -16,6 +15,7 @@ use std::{
    time::Instant,
 };
 use thiserror::Error;
+use tokio::sync::oneshot;
 use tracing::{debug, error};

 /// Writes parts of reth's in memory tree state to the database and static files.
@@ -151,7 +151,7 @@ where
        if last_block.is_some() {
            let provider_rw = self.provider.database_provider_rw()?;

-            provider_rw.save_blocks(blocks, SaveBlocksMode::Full)?;
+            provider_rw.save_blocks(blocks)?;
            provider_rw.commit()?;
        }

@@ -159,7 +159,6 @@ where

        self.metrics.save_blocks_block_count.record(block_count as f64);
        self.metrics.save_blocks_duration_seconds.record(start_time.elapsed());
-
        Ok(last_block)
    }
 }
@@ -184,13 +183,13 @@ pub enum PersistenceAction<N: NodePrimitives = EthPrimitives> {
    ///
    /// First, header, transaction, and receipt-related data should be written to static files.
    /// Then the execution history-related data will be written to the database.
-    SaveBlocks(Vec<ExecutedBlock<N>>, CrossbeamSender<Option<BlockNumHash>>),
+    SaveBlocks(Vec<ExecutedBlock<N>>, oneshot::Sender<Option<BlockNumHash>>),

    /// Removes block data above the given block number from the database.
    ///
    /// This will first update checkpoints from the database, then remove actual block data from
    /// static files.
-    RemoveBlocksAbove(u64, CrossbeamSender<Option<BlockNumHash>>),
+    RemoveBlocksAbove(u64, oneshot::Sender<Option<BlockNumHash>>),

    /// Update the persisted finalized block on disk
    SaveFinalizedBlock(u64),
@@ -262,7 +261,7 @@ impl<T: NodePrimitives> PersistenceHandle<T> {
    pub fn save_blocks(
        &self,
        blocks: Vec<ExecutedBlock<T>>,
-        tx: CrossbeamSender<Option<BlockNumHash>>,
+        tx: oneshot::Sender<Option<BlockNumHash>>,
    ) -> Result<(), SendError<PersistenceAction<T>>> {
        self.send_action(PersistenceAction::SaveBlocks(blocks, tx))
    }
@@ -291,7 +290,7 @@ impl<T: NodePrimitives> PersistenceHandle<T> {
    pub fn remove_blocks_above(
        &self,
        block_num: u64,
-        tx: CrossbeamSender<Option<BlockNumHash>>,
+        tx: oneshot::Sender<Option<BlockNumHash>>,
    ) -> Result<(), SendError<PersistenceAction<T>>> {
        self.send_action(PersistenceAction::RemoveBlocksAbove(block_num, tx))
    }
@@ -320,22 +319,22 @@ mod tests {
        PersistenceHandle::<EthPrimitives>::spawn_service(provider, pruner, sync_metrics_tx)
    }

-    #[test]
-    fn test_save_blocks_empty() {
+    #[tokio::test]
+    async fn test_save_blocks_empty() {
        reth_tracing::init_test_tracing();
        let persistence_handle = default_persistence_handle();

        let blocks = vec![];
-        let (tx, rx) = crossbeam_channel::bounded(1);
+        let (tx, rx) = oneshot::channel();

        persistence_handle.save_blocks(blocks, tx).unwrap();

-        let hash = rx.recv().unwrap();
+        let hash = rx.await.unwrap();
        assert_eq!(hash, None);
    }

-    #[test]
-    fn test_save_blocks_single_block() {
+    #[tokio::test]
+    async fn test_save_blocks_single_block() {
        reth_tracing::init_test_tracing();
        let persistence_handle = default_persistence_handle();
        let block_number = 0;
@@ -345,35 +344,37 @@ mod tests {
        let block_hash = executed.recovered_block().hash();

        let blocks = vec![executed];
-        let (tx, rx) = crossbeam_channel::bounded(1);
+        let (tx, rx) = oneshot::channel();

        persistence_handle.save_blocks(blocks, tx).unwrap();

-        let BlockNumHash { hash: actual_hash, number: _ } = rx
-            .recv_timeout(std::time::Duration::from_secs(10))
-            .expect("test timed out")
-            .expect("no hash returned");
+        let BlockNumHash { hash: actual_hash, number: _ } =
+            tokio::time::timeout(std::time::Duration::from_secs(10), rx)
+                .await
+                .expect("test timed out")
+                .expect("channel closed unexpectedly")
+                .expect("no hash returned");

        assert_eq!(block_hash, actual_hash);
    }

-    #[test]
-    fn test_save_blocks_multiple_blocks() {
+    #[tokio::test]
+    async fn test_save_blocks_multiple_blocks() {
        reth_tracing::init_test_tracing();
        let persistence_handle = default_persistence_handle();

        let mut test_block_builder = TestBlockBuilder::eth();
        let blocks = test_block_builder.get_executed_blocks(0..5).collect::<Vec<_>>();
        let last_hash = blocks.last().unwrap().recovered_block().hash();
-        let (tx, rx) = crossbeam_channel::bounded(1);
+        let (tx, rx) = oneshot::channel();

        persistence_handle.save_blocks(blocks, tx).unwrap();
-        let BlockNumHash { hash: actual_hash, number: _ } = rx.recv().unwrap().unwrap();
+        let BlockNumHash { hash: actual_hash, number: _ } = rx.await.unwrap().unwrap();
        assert_eq!(last_hash, actual_hash);
    }

-    #[test]
-    fn test_save_blocks_multiple_calls() {
+    #[tokio::test]
+    async fn test_save_blocks_multiple_calls() {
        reth_tracing::init_test_tracing();
        let persistence_handle = default_persistence_handle();

@@ -382,11 +383,11 @@ mod tests {
        for range in ranges {
            let blocks = test_block_builder.get_executed_blocks(range).collect::<Vec<_>>();
            let last_hash = blocks.last().unwrap().recovered_block().hash();
-            let (tx, rx) = crossbeam_channel::bounded(1);
+            let (tx, rx) = oneshot::channel();

            persistence_handle.save_blocks(blocks, tx).unwrap();

-            let BlockNumHash { hash: actual_hash, number: _ } = rx.recv().unwrap().unwrap();
+            let BlockNumHash { hash: actual_hash, number: _ } = rx.await.unwrap().unwrap();
            assert_eq!(last_hash, actual_hash);
        }
    }
--- a/crates/engine/tree/src/tree/cached_state.rs
+++ b/crates/engine/tree/src/tree/cached_state.rs
@@ -629,11 +629,6 @@ impl SavedCache {
        Arc::strong_count(&self.usage_guard) == 1
    }

-    /// Returns the current strong count of the usage guard.
-    pub(crate) fn usage_count(&self) -> usize {
-        Arc::strong_count(&self.usage_guard)
-    }
-
    /// Returns the [`ExecutionCache`] belonging to the tracked hash.
    pub(crate) const fn cache(&self) -> &ExecutionCache {
        &self.caches
--- a/crates/engine/tree/src/tree/error.rs
+++ b/crates/engine/tree/src/tree/error.rs
@@ -6,13 +6,15 @@ use reth_errors::{BlockExecutionError, BlockValidationError, ProviderError};
 use reth_evm::execute::InternalBlockExecutionError;
 use reth_payload_primitives::NewPayloadError;
 use reth_primitives_traits::{Block, BlockBody, SealedBlock};
+use tokio::sync::oneshot::error::TryRecvError;

-/// This is an error that can come from advancing persistence.
+/// This is an error that can come from advancing persistence. Either this can be a
+/// [`TryRecvError`], or this can be a [`ProviderError`]
 #[derive(Debug, thiserror::Error)]
 pub enum AdvancePersistenceError {
-    /// The persistence channel was closed unexpectedly
-    #[error("persistence channel closed")]
-    ChannelClosed,
+    /// An error that can be from failing to receive a value from persistence
+    #[error(transparent)]
+    RecvError(#[from] TryRecvError),
    /// A provider error
    #[error(transparent)]
    Provider(#[from] ProviderError),
--- a/crates/engine/tree/src/tree/metrics.rs
+++ b/crates/engine/tree/src/tree/metrics.rs
@@ -60,22 +60,16 @@ impl EngineApiMetrics {
    ///
    /// This method updates metrics for execution time, gas usage, and the number
    /// of accounts, storage slots and bytecodes loaded and updated.
-    ///
-    /// The optional `on_receipt` callback is invoked after each transaction with the receipt
-    /// index and a reference to all receipts collected so far. This allows callers to stream
-    /// receipts to a background task for incremental receipt root computation.
-    pub(crate) fn execute_metered<E, DB, F>(
+    pub(crate) fn execute_metered<E, DB>(
        &self,
        executor: E,
        mut transactions: impl Iterator<Item = Result<impl ExecutableTx<E>, BlockExecutionError>>,
        transaction_count: usize,
        state_hook: Box<dyn OnStateHook>,
-        mut on_receipt: F,
    ) -> Result<(BlockExecutionOutput<E::Receipt>, Vec<Address>), BlockExecutionError>
    where
        DB: alloy_evm::Database,
        E: BlockExecutor<Evm: Evm<DB: BorrowMut<State<DB>>>, Transaction: SignedTransaction>,
-        F: FnMut(&[E::Receipt]),
    {
        // clone here is cheap, all the metrics are Option<Arc<_>>. additionally
        // they are globally registered so that the data recorded in the hook will
@@ -101,21 +95,14 @@ impl EngineApiMetrics {
                let tx = tx?;
                senders.push(*tx.signer());

-                let span = debug_span!(
-                    target: "engine::tree",
-                    "execute tx",
-                    tx_hash = ?tx.tx().tx_hash(),
-                    gas_used = tracing::field::Empty,
-                );
+                let span =
+                    debug_span!(target: "engine::tree", "execute tx", tx_hash=?tx.tx().tx_hash());
                let enter = span.entered();
                trace!(target: "engine::tree", "Executing transaction");
                let start = Instant::now();
                let gas_used = executor.execute_transaction(tx)?;
                self.executor.transaction_execution_histogram.record(start.elapsed());

-                // Invoke callback with the latest receipt
-                on_receipt(executor.receipts());
-
                // record the tx gas used
                enter.record("gas_used", gas_used);
            }
@@ -270,10 +257,7 @@ impl ForkchoiceUpdatedMetrics {
 pub(crate) struct NewPayloadStatusMetrics {
    /// Finish time of the latest new payload call.
    #[metric(skip)]
-    pub(crate) latest_finish_at: Option<Instant>,
-    /// Start time of the latest new payload call.
-    #[metric(skip)]
-    pub(crate) latest_start_at: Option<Instant>,
+    pub(crate) latest_at: Option<Instant>,
    /// The total count of new payload messages received.
    pub(crate) new_payload_messages: Counter,
    /// The total count of new payload messages that we responded to with
@@ -301,10 +285,6 @@ pub(crate) struct NewPayloadStatusMetrics {
    pub(crate) new_payload_latency: Histogram,
    /// Latency for the last new payload call.
    pub(crate) new_payload_last: Gauge,
-    /// Time from previous payload finish to current payload start (idle time).
-    pub(crate) time_between_new_payloads: Histogram,
-    /// Time from previous payload start to current payload start (total interval).
-    pub(crate) new_payload_interval: Histogram,
 }

 impl NewPayloadStatusMetrics {
@@ -318,14 +298,7 @@ impl NewPayloadStatusMetrics {
        let finish = Instant::now();
        let elapsed = finish - start;

-        if let Some(prev_finish) = self.latest_finish_at {
-            self.time_between_new_payloads.record(start - prev_finish);
-        }
-        if let Some(prev_start) = self.latest_start_at {
-            self.new_payload_interval.record(start - prev_start);
-        }
-        self.latest_finish_at = Some(finish);
-        self.latest_start_at = Some(start);
+        self.latest_at = Some(finish);
        match result {
            Ok(outcome) => match outcome.outcome.status {
                PayloadStatusEnum::Valid => {
@@ -348,7 +321,7 @@ impl NewPayloadStatusMetrics {
 }

 /// Metrics for non-execution related block validation.
-#[derive(Metrics, Clone)]
+#[derive(Metrics)]
 #[metrics(scope = "sync.block_validation")]
 pub(crate) struct BlockValidationMetrics {
    /// Total number of storage tries updated in the state root calculation
@@ -361,6 +334,10 @@ pub(crate) struct BlockValidationMetrics {
    pub(crate) state_root_histogram: Histogram,
    /// Histogram of deferred trie computation duration.
    pub(crate) deferred_trie_compute_duration: Histogram,
+    /// Histogram of time spent waiting for deferred trie data to become available.
+    pub(crate) deferred_trie_wait_duration: Histogram,
+    /// Trie input computation duration
+    pub(crate) trie_input_duration: Histogram,
    /// Payload conversion and validation latency
    pub(crate) payload_validation_duration: Gauge,
    /// Histogram of payload validation latency
@@ -371,14 +348,6 @@ pub(crate) struct BlockValidationMetrics {
    pub(crate) post_execution_validation_duration: Histogram,
    /// Total duration of the new payload call
    pub(crate) total_duration: Histogram,
-    /// Size of `HashedPostStateSorted` (`total_len`)
-    pub(crate) hashed_post_state_size: Histogram,
-    /// Size of `TrieUpdatesSorted` (`total_len`)
-    pub(crate) trie_updates_sorted_size: Histogram,
-    /// Size of `AnchoredTrieInput` overlay `TrieUpdatesSorted` (`total_len`)
-    pub(crate) anchored_overlay_trie_updates_size: Histogram,
-    /// Size of `AnchoredTrieInput` overlay `HashedPostStateSorted` (`total_len`)
-    pub(crate) anchored_overlay_hashed_state_size: Histogram,
 }

 impl BlockValidationMetrics {
@@ -431,13 +400,12 @@ mod tests {
    /// A simple mock executor for testing that doesn't require complex EVM setup
    struct MockExecutor {
        state: EvmState,
-        receipts: Vec<Receipt>,
        hook: Option<Box<dyn OnStateHook>>,
    }

    impl MockExecutor {
        fn new(state: EvmState) -> Self {
-            Self { state, receipts: vec![], hook: None }
+            Self { state, hook: None }
        }
    }

@@ -519,16 +487,12 @@ mod tests {
            self.hook = hook;
        }

-        fn evm_mut(&mut self) -> &mut Self::Evm {
-            panic!("Mock executor evm_mut() not implemented")
-        }
-
        fn evm(&self) -> &Self::Evm {
            panic!("Mock executor evm() not implemented")
        }

-        fn receipts(&self) -> &[Self::Receipt] {
-            &self.receipts
+        fn evm_mut(&mut self) -> &mut Self::Evm {
+            panic!("Mock executor evm_mut() not implemented")
        }
    }

@@ -563,12 +527,11 @@ mod tests {
        let executor = MockExecutor::new(state);

        // This will fail to create the EVM but should still call the hook
-        let _result = metrics.execute_metered::<_, EmptyDB, _>(
+        let _result = metrics.execute_metered::<_, EmptyDB>(
            executor,
            input.clone_transactions_recovered().map(Ok::<_, BlockExecutionError>),
            input.transaction_count(),
            state_hook,
-            |_| {},
        );

        // Check if hook was called (it might not be if finish() fails early)
@@ -609,9 +572,7 @@ mod tests {
                        nonce: 10,
                        code_hash: B256::random(),
                        code: Default::default(),
-                        account_id: None,
                    },
-                    original_info: Box::new(AccountInfo::default()),
                    storage,
                    status: AccountStatus::default(),
                    transaction_id: 0,
@@ -623,12 +584,11 @@ mod tests {
        let executor = MockExecutor::new(state);

        // Execute (will fail but should still update some metrics)
-        let _result = metrics.execute_metered::<_, EmptyDB, _>(
+        let _result = metrics.execute_metered::<_, EmptyDB>(
            executor,
            input.clone_transactions_recovered().map(Ok::<_, BlockExecutionError>),
            input.transaction_count(),
            state_hook,
-            |_| {},
        );

        let snapshot = snapshotter.snapshot().into_vec();
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -30,21 +30,25 @@ use reth_payload_primitives::{
 };
 use reth_primitives_traits::{NodePrimitives, RecoveredBlock, SealedBlock, SealedHeader};
 use reth_provider::{
-    BlockExecutionOutput, BlockExecutionResult, BlockNumReader, BlockReader, ChangeSetReader,
-    DatabaseProviderFactory, HashedPostStateProvider, ProviderError, StageCheckpointReader,
-    StateProviderBox, StateProviderFactory, StateReader, TransactionVariant,
+    BlockReader, DatabaseProviderFactory, HashedPostStateProvider, ProviderError, StateProviderBox,
+    StateProviderFactory, StateReader, TransactionVariant, TrieReader,
 };
 use reth_revm::database::StateProviderDatabase;
 use reth_stages_api::ControlFlow;
-use reth_trie_db::ChangesetCache;
 use revm::state::EvmState;
 use state::TreeState;
-use std::{fmt::Debug, ops, sync::Arc, time::Instant};
-
-use crossbeam_channel::{Receiver, Sender};
+use std::{
+    fmt::Debug,
+    ops,
+    sync::{
+        mpsc::{Receiver, RecvError, RecvTimeoutError, Sender},
+        Arc,
+    },
+    time::Instant,
+};
 use tokio::sync::{
    mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
-    oneshot,
+    oneshot::{self, error::TryRecvError},
 };
 use tracing::*;

@@ -236,7 +240,7 @@ where
    C: ConfigureEvm<Primitives = N> + 'static,
 {
    provider: P,
-    consensus: Arc<dyn FullConsensus<N>>,
+    consensus: Arc<dyn FullConsensus<N, Error = ConsensusError>>,
    payload_validator: V,
    /// Keeps track of internals such as executed and buffered blocks.
    state: EngineApiTreeState<N>,
@@ -273,8 +277,6 @@ where
    engine_kind: EngineApiKind,
    /// The EVM configuration.
    evm_config: C,
-    /// Changeset cache for in-memory trie changesets
-    changeset_cache: ChangesetCache,
 }

 impl<N, P: Debug, T: PayloadTypes + Debug, V: Debug, C> std::fmt::Debug
@@ -299,7 +301,6 @@ where
            .field("metrics", &self.metrics)
            .field("engine_kind", &self.engine_kind)
            .field("evm_config", &self.evm_config)
-            .field("changeset_cache", &self.changeset_cache)
            .finish()
    }
 }
@@ -312,12 +313,11 @@ where
        + StateProviderFactory
        + StateReader<Receipt = N::Receipt>
        + HashedPostStateProvider
+        + TrieReader
        + Clone
        + 'static,
-    <P as DatabaseProviderFactory>::Provider: BlockReader<Block = N::Block, Header = N::BlockHeader>
-        + StageCheckpointReader
-        + ChangeSetReader
-        + BlockNumReader,
+    <P as DatabaseProviderFactory>::Provider:
+        BlockReader<Block = N::Block, Header = N::BlockHeader>,
    C: ConfigureEvm<Primitives = N> + 'static,
    T: PayloadTypes<BuiltPayload: BuiltPayload<Primitives = N>>,
    V: EngineValidator<T>,
@@ -326,7 +326,7 @@ where
    #[expect(clippy::too_many_arguments)]
    pub fn new(
        provider: P,
-        consensus: Arc<dyn FullConsensus<N>>,
+        consensus: Arc<dyn FullConsensus<N, Error = ConsensusError>>,
        payload_validator: V,
        outgoing: UnboundedSender<EngineApiEvent<N>>,
        state: EngineApiTreeState<N>,
@@ -337,9 +337,8 @@ where
        config: TreeConfig,
        engine_kind: EngineApiKind,
        evm_config: C,
-        changeset_cache: ChangesetCache,
    ) -> Self {
-        let (incoming_tx, incoming) = crossbeam_channel::unbounded();
+        let (incoming_tx, incoming) = std::sync::mpsc::channel();

        Self {
            provider,
@@ -358,7 +357,6 @@ where
            incoming_tx,
            engine_kind,
            evm_config,
-            changeset_cache,
        }
    }

@@ -370,7 +368,7 @@ where
    #[expect(clippy::complexity)]
    pub fn spawn_new(
        provider: P,
-        consensus: Arc<dyn FullConsensus<N>>,
+        consensus: Arc<dyn FullConsensus<N, Error = ConsensusError>>,
        payload_validator: V,
        persistence: PersistenceHandle<N>,
        payload_builder: PayloadBuilderHandle<T>,
@@ -378,7 +376,6 @@ where
        config: TreeConfig,
        kind: EngineApiKind,
        evm_config: C,
-        changeset_cache: ChangesetCache,
    ) -> (Sender<FromEngine<EngineApiRequest<T, N>, N::Block>>, UnboundedReceiver<EngineApiEvent<N>>)
    {
        let best_block_number = provider.best_block_number().unwrap_or(0);
@@ -410,7 +407,6 @@ where
            config,
            kind,
            evm_config,
-            changeset_cache,
        );
        let incoming = task.incoming_tx.clone();
        std::thread::Builder::new().name("Engine Task".to_string()).spawn(|| task.run()).unwrap();
@@ -427,8 +423,8 @@ where
    /// This will block the current thread and process incoming messages.
    pub fn run(mut self) {
        loop {
-            match self.wait_for_event() {
-                LoopEvent::EngineMessage(msg) => {
+            match self.try_recv_engine_message() {
+                Ok(Some(msg)) => {
                    debug!(target: "engine::tree", %msg, "received new engine message");
                    match self.on_engine_message(msg) {
                        Ok(ops::ControlFlow::Break(())) => return,
@@ -439,22 +435,15 @@ where
                        }
                    }
                }
-                LoopEvent::PersistenceComplete { result, start_time } => {
-                    if let Err(err) = self.on_persistence_complete(result, start_time) {
-                        error!(target: "engine::tree", %err, "Persistence complete handling failed");
-                        return
-                    }
+                Ok(None) => {
+                    debug!(target: "engine::tree", "received no engine message for some time, while waiting for persistence task to complete");
                }
-                LoopEvent::Disconnected => {
-                    error!(target: "engine::tree", "Channel disconnected");
+                Err(_err) => {
+                    error!(target: "engine::tree", "Engine channel disconnected");
                    return
                }
            }

-            // Always check if we need to trigger new persistence after any event:
-            // - After engine messages: new blocks may have been inserted that exceed the
-            //   persistence threshold
-            // - After persistence completion: we can now persist more blocks if needed
            if let Err(err) = self.advance_persistence() {
                error!(target: "engine::tree", %err, "Advancing persistence failed");
                return
@@ -462,47 +451,6 @@ where
        }
    }

-    /// Blocks until the next event is ready: either an incoming engine message or a persistence
-    /// completion (if one is in progress).
-    ///
-    /// Uses biased selection to prioritize persistence completion to update in-memory state and
-    /// unblock further writes.
-    fn wait_for_event(&mut self) -> LoopEvent<T, N> {
-        // Take ownership of persistence rx if present
-        let maybe_persistence = self.persistence_state.rx.take();
-
-        if let Some((persistence_rx, start_time, action)) = maybe_persistence {
-            // Biased select prioritizes persistence completion to update in memory state and
-            // unblock further writes
-            crossbeam_channel::select_biased! {
-                recv(persistence_rx) -> result => {
-                    // Don't put it back - consumed (oneshot-like behavior)
-                    match result {
-                        Ok(value) => LoopEvent::PersistenceComplete {
-                            result: value,
-                            start_time,
-                        },
-                        Err(_) => LoopEvent::Disconnected,
-                    }
-                },
-                recv(self.incoming) -> msg => {
-                    // Put the persistence rx back - we didn't consume it
-                    self.persistence_state.rx = Some((persistence_rx, start_time, action));
-                    match msg {
-                        Ok(m) => LoopEvent::EngineMessage(m),
-                        Err(_) => LoopEvent::Disconnected,
-                    }
-                },
-            }
-        } else {
-            // No persistence in progress - just wait on incoming
-            match self.incoming.recv() {
-                Ok(m) => LoopEvent::EngineMessage(m),
-                Err(_) => LoopEvent::Disconnected,
-            }
-        }
-    }
-
    /// Invoked when previously requested blocks were downloaded.
    ///
    /// If the block count exceeds the configured batch size we're allowed to execute at once, this
@@ -1243,13 +1191,39 @@ where
        .with_event(TreeEvent::Download(DownloadRequest::single_block(target))))
    }

+    /// Attempts to receive the next engine request.
+    ///
+    /// If there's currently no persistence action in progress, this will block until a new request
+    /// is received. If there's a persistence action in progress, this will try to receive the
+    /// next request with a timeout to not block indefinitely and return `Ok(None)` if no request is
+    /// received in time.
+    ///
+    /// Returns an error if the engine channel is disconnected.
+    #[expect(clippy::type_complexity)]
+    fn try_recv_engine_message(
+        &self,
+    ) -> Result<Option<FromEngine<EngineApiRequest<T, N>, N::Block>>, RecvError> {
+        if self.persistence_state.in_progress() {
+            // try to receive the next request with a timeout to not block indefinitely
+            match self.incoming.recv_timeout(std::time::Duration::from_millis(500)) {
+                Ok(msg) => Ok(Some(msg)),
+                Err(err) => match err {
+                    RecvTimeoutError::Timeout => Ok(None),
+                    RecvTimeoutError::Disconnected => Err(RecvError),
+                },
+            }
+        } else {
+            self.incoming.recv().map(Some)
+        }
+    }
+
    /// Helper method to remove blocks and set the persistence state. This ensures we keep track of
    /// the current persistence action while we're removing blocks.
    fn remove_blocks(&mut self, new_tip_num: u64) {
        debug!(target: "engine::tree", ?new_tip_num, last_persisted_block_number=?self.persistence_state.last_persisted_block.number, "Removing blocks using persistence task");
        if new_tip_num < self.persistence_state.last_persisted_block.number {
            debug!(target: "engine::tree", ?new_tip_num, "Starting remove blocks job");
-            let (tx, rx) = crossbeam_channel::bounded(1);
+            let (tx, rx) = oneshot::channel();
            let _ = self.persistence.remove_blocks_above(new_tip_num, tx);
            self.persistence_state.start_remove(new_tip_num, rx);
        }
@@ -1271,17 +1245,35 @@ where
            .expect("Checked non-empty persisting blocks");

        debug!(target: "engine::tree", count=blocks_to_persist.len(), blocks = ?blocks_to_persist.iter().map(|block| block.recovered_block().num_hash()).collect::<Vec<_>>(), "Persisting blocks");
-        let (tx, rx) = crossbeam_channel::bounded(1);
+        let (tx, rx) = oneshot::channel();
        let _ = self.persistence.save_blocks(blocks_to_persist, tx);

        self.persistence_state.start_save(highest_num_hash, rx);
    }

-    /// Triggers new persistence actions if no persistence task is currently in progress.
+    /// Attempts to advance the persistence state.
    ///
-    /// This checks if we need to remove blocks (disk reorg) or save new blocks to disk.
-    /// Persistence completion is handled separately via the `wait_for_event` method.
+    /// If we're currently awaiting a response this will try to receive the response (non-blocking)
+    /// or send a new persistence action if necessary.
    fn advance_persistence(&mut self) -> Result<(), AdvancePersistenceError> {
+        if self.persistence_state.in_progress() {
+            let (mut rx, start_time, current_action) = self
+                .persistence_state
+                .rx
+                .take()
+                .expect("if a persistence task is in progress Receiver must be Some");
+            // Check if persistence has complete
+            match rx.try_recv() {
+                Ok(last_persisted_hash_num) => {
+                    self.on_persistence_complete(last_persisted_hash_num, start_time)?;
+                }
+                Err(TryRecvError::Closed) => return Err(TryRecvError::Closed.into()),
+                Err(TryRecvError::Empty) => {
+                    self.persistence_state.rx = Some((rx, start_time, current_action))
+                }
+            }
+        }
+
        if !self.persistence_state.in_progress() {
            if let Some(new_tip_num) = self.find_disk_reorg()? {
                self.remove_blocks(new_tip_num)
@@ -1314,7 +1306,7 @@ where
        loop {
            // Wait for any in-progress persistence to complete (blocking)
            if let Some((rx, start_time, _action)) = self.persistence_state.rx.take() {
-                let result = rx.recv().map_err(|_| AdvancePersistenceError::ChannelClosed)?;
+                let result = rx.blocking_recv().map_err(|_| TryRecvError::Closed)?;
                self.on_persistence_complete(result, start_time)?;
            }

@@ -1330,31 +1322,6 @@ where
        }
    }

-    /// Tries to poll for a completed persistence task (non-blocking).
-    ///
-    /// Returns `true` if a persistence task was completed, `false` otherwise.
-    #[cfg(test)]
-    pub fn try_poll_persistence(&mut self) -> Result<bool, AdvancePersistenceError> {
-        let Some((rx, start_time, action)) = self.persistence_state.rx.take() else {
-            return Ok(false);
-        };
-
-        match rx.try_recv() {
-            Ok(result) => {
-                self.on_persistence_complete(result, start_time)?;
-                Ok(true)
-            }
-            Err(crossbeam_channel::TryRecvError::Empty) => {
-                // Not ready yet, put it back
-                self.persistence_state.rx = Some((rx, start_time, action));
-                Ok(false)
-            }
-            Err(crossbeam_channel::TryRecvError::Disconnected) => {
-                Err(AdvancePersistenceError::ChannelClosed)
-            }
-        }
-    }
-
    /// Handles a completed persistence task.
    fn on_persistence_complete(
        &mut self,
@@ -1375,21 +1342,6 @@ where

        debug!(target: "engine::tree", ?last_persisted_block_hash, ?last_persisted_block_number, elapsed=?start_time.elapsed(), "Finished persisting, calling finish");
        self.persistence_state.finish(last_persisted_block_hash, last_persisted_block_number);
-
-        // Evict trie changesets for blocks below the finalized block, but keep at least 64 blocks
-        if let Some(finalized) = self.canonical_in_memory_state.get_finalized_num_hash() {
-            let min_threshold = last_persisted_block_number.saturating_sub(64);
-            let eviction_threshold = finalized.number.min(min_threshold);
-            debug!(
-                target: "engine::tree",
-                last_persisted = last_persisted_block_number,
-                finalized_number = finalized.number,
-                eviction_threshold,
-                "Evicting changesets below threshold"
-            );
-            self.changeset_cache.evict(eviction_threshold);
-        }
-
        self.on_new_persisted_block()?;
        Ok(())
    }
@@ -1478,7 +1430,7 @@ where

                                self.metrics.engine.forkchoice_updated.update_response_metrics(
                                    start,
-                                    &mut self.metrics.engine.new_payload.latest_finish_at,
+                                    &mut self.metrics.engine.new_payload.latest_at,
                                    has_attrs,
                                    &output,
                                );
@@ -1676,18 +1628,6 @@ where
                )));
                return Ok(());
            }
-        } else {
-            // We don't have the head block or any of its ancestors buffered. Request
-            // a download for the head block which will then trigger further sync.
-            debug!(
-                target: "engine::tree",
-                head_hash = %sync_target_state.head_block_hash,
-                "Backfill complete but head block not buffered, requesting download"
-            );
-            self.emit_event(EngineApiEvent::Download(DownloadRequest::single_block(
-                sync_target_state.head_block_hash,
-            )));
-            return Ok(());
        }

        // try to close the gap by executing buffered blocks that are child blocks of the new head
@@ -1855,7 +1795,6 @@ where
    /// or the database. If the required historical data (such as trie change sets) has been
    /// pruned for a given block, this operation will return an error. On archive nodes, it
    /// can retrieve any block.
-    #[instrument(level = "debug", target = "engine::tree", skip(self))]
    fn canonical_block_by_hash(&self, hash: B256) -> ProviderResult<Option<ExecutedBlock<N>>> {
        trace!(target: "engine::tree", ?hash, "Fetching executed block by hash");
        // check memory first
@@ -1868,23 +1807,12 @@ where
            .sealed_block_with_senders(hash.into(), TransactionVariant::WithHash)?
            .ok_or_else(|| ProviderError::HeaderNotFound(hash.into()))?
            .split_sealed();
-        let mut execution_output = self
+        let execution_output = self
            .provider
            .get_state(block.header().number())?
            .ok_or_else(|| ProviderError::StateForNumberNotFound(block.header().number()))?;
        let hashed_state = self.provider.hashed_post_state(execution_output.state());
-
-        debug!(
-            target: "engine::tree",
-            number = ?block.number(),
-            "computing block trie updates",
-        );
-        let db_provider = self.provider.database_provider_ro()?;
-        let trie_updates = reth_trie_db::compute_block_trie_updates(
-            &self.changeset_cache,
-            &db_provider,
-            block.number(),
-        )?;
+        let trie_updates = self.provider.get_block_trie_updates(block.number())?;

        let sorted_hashed_state = Arc::new(hashed_state.into_sorted());
        let sorted_trie_updates = Arc::new(trie_updates);
@@ -1892,19 +1820,9 @@ where
        let trie_data =
            ComputedTrieData::without_trie_input(sorted_hashed_state, sorted_trie_updates);

-        let execution_output = Arc::new(BlockExecutionOutput {
-            state: execution_output.bundle,
-            result: BlockExecutionResult {
-                receipts: execution_output.receipts.pop().unwrap_or_default(),
-                requests: execution_output.requests.pop().unwrap_or_default(),
-                gas_used: block.gas_used(),
-                blob_gas_used: block.blob_gas_used().unwrap_or_default(),
-            },
-        });
-
        Ok(Some(ExecutedBlock::new(
            Arc::new(RecoveredBlock::new_sealed(block, senders)),
-            execution_output,
+            Arc::new(execution_output),
            trie_data,
        )))
    }
@@ -2930,26 +2848,6 @@ where
    }
 }

-/// Events received in the main engine loop.
-#[derive(Debug)]
-enum LoopEvent<T, N>
-where
-    N: NodePrimitives,
-    T: PayloadTypes,
-{
-    /// An engine API message was received.
-    EngineMessage(FromEngine<EngineApiRequest<T, N>, N::Block>),
-    /// A persistence task completed.
-    PersistenceComplete {
-        /// The result of the persistence operation.
-        result: Option<BlockNumHash>,
-        /// When the persistence operation started.
-        start_time: Instant,
-    },
-    /// A channel was disconnected.
-    Disconnected,
-}
-
 /// Block inclusion can be valid, accepted, or invalid. Invalid blocks are returned as an error
 /// variant.
 ///
--- a/crates/engine/tree/src/tree/payload_processor/bal.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal.rs
@@ -101,7 +101,7 @@ impl<'a> Iterator for BALSlotIter<'a> {
                    return None;
                }

-                return Some((address, StorageKey::from(slot)));
+                return Some((address, slot));
            }

            // Move to next account
@@ -177,11 +177,13 @@ where
            let mut storage_map = HashedStorage::new(false);

            for slot_changes in &account_changes.storage_changes {
-                let hashed_slot = keccak256(slot_changes.slot.to_be_bytes::<32>());
+                let hashed_slot = keccak256(slot_changes.slot);

                // Get the last change for this slot
                if let Some(last_change) = slot_changes.changes.last() {
-                    storage_map.storage.insert(hashed_slot, last_change.new_value);
+                    storage_map
+                        .storage
+                        .insert(hashed_slot, U256::from_be_bytes(last_change.new_value.0));
                }
            }

@@ -235,8 +237,8 @@ mod tests {
        let provider = StateProviderTest::default();

        let address = Address::random();
-        let slot = U256::random();
-        let value = U256::random();
+        let slot = StorageKey::random();
+        let value = B256::random();

        let slot_changes = SlotChanges { slot, changes: vec![StorageChange::new(0, value)] };

@@ -256,10 +258,10 @@ mod tests {
        assert!(result.storages.contains_key(&hashed_address));

        let storage = result.storages.get(&hashed_address).unwrap();
-        let hashed_slot = keccak256(slot.to_be_bytes::<32>());
+        let hashed_slot = keccak256(slot);

        let stored_value = storage.storage.get(&hashed_slot).unwrap();
-        assert_eq!(*stored_value, value);
+        assert_eq!(*stored_value, U256::from_be_bytes(value.0));
    }

    #[test]
@@ -390,15 +392,15 @@ mod tests {
        let provider = StateProviderTest::default();

        let address = Address::random();
-        let slot = U256::random();
+        let slot = StorageKey::random();

        // Multiple changes to the same slot - should take the last one
        let slot_changes = SlotChanges {
            slot,
            changes: vec![
-                StorageChange::new(0, U256::from(100)),
-                StorageChange::new(1, U256::from(200)),
-                StorageChange::new(2, U256::from(300)),
+                StorageChange::new(0, B256::from(U256::from(100).to_be_bytes::<32>())),
+                StorageChange::new(1, B256::from(U256::from(200).to_be_bytes::<32>())),
+                StorageChange::new(2, B256::from(U256::from(300).to_be_bytes::<32>())),
            ],
        };

@@ -416,7 +418,7 @@ mod tests {

        let hashed_address = keccak256(address);
        let storage = result.storages.get(&hashed_address).unwrap();
-        let hashed_slot = keccak256(slot.to_be_bytes::<32>());
+        let hashed_slot = keccak256(slot);

        let stored_value = storage.storage.get(&hashed_slot).unwrap();

@@ -436,15 +438,15 @@ mod tests {
            address: addr1,
            storage_changes: vec![
                SlotChanges {
-                    slot: U256::from(100),
-                    changes: vec![StorageChange::new(0, U256::ZERO)],
+                    slot: StorageKey::from(U256::from(100)),
+                    changes: vec![StorageChange::new(0, B256::ZERO)],
                },
                SlotChanges {
-                    slot: U256::from(101),
-                    changes: vec![StorageChange::new(0, U256::ZERO)],
+                    slot: StorageKey::from(U256::from(101)),
+                    changes: vec![StorageChange::new(0, B256::ZERO)],
                },
            ],
-            storage_reads: vec![U256::from(102)],
+            storage_reads: vec![StorageKey::from(U256::from(102))],
            balance_changes: vec![],
            nonce_changes: vec![],
            code_changes: vec![],
@@ -454,10 +456,10 @@ mod tests {
        let account2 = AccountChanges {
            address: addr2,
            storage_changes: vec![SlotChanges {
-                slot: U256::from(200),
-                changes: vec![StorageChange::new(0, U256::ZERO)],
+                slot: StorageKey::from(U256::from(200)),
+                changes: vec![StorageChange::new(0, B256::ZERO)],
            }],
-            storage_reads: vec![U256::from(201)],
+            storage_reads: vec![StorageKey::from(U256::from(201))],
            balance_changes: vec![],
            nonce_changes: vec![],
            code_changes: vec![],
@@ -468,15 +470,15 @@ mod tests {
            address: addr3,
            storage_changes: vec![
                SlotChanges {
-                    slot: U256::from(300),
-                    changes: vec![StorageChange::new(0, U256::ZERO)],
+                    slot: StorageKey::from(U256::from(300)),
+                    changes: vec![StorageChange::new(0, B256::ZERO)],
                },
                SlotChanges {
-                    slot: U256::from(301),
-                    changes: vec![StorageChange::new(0, U256::ZERO)],
+                    slot: StorageKey::from(U256::from(301)),
+                    changes: vec![StorageChange::new(0, B256::ZERO)],
                },
            ],
-            storage_reads: vec![U256::from(302)],
+            storage_reads: vec![StorageKey::from(U256::from(302))],
            balance_changes: vec![],
            nonce_changes: vec![],
            code_changes: vec![],
--- a/crates/engine/tree/src/tree/payload_processor/configured_sparse_trie.rs
+++ b/crates/engine/tree/src/tree/payload_processor/configured_sparse_trie.rs
@@ -1,7 +1,7 @@
 //! Configured sparse trie enum for switching between serial and parallel implementations.

 use alloy_primitives::B256;
-use reth_trie::{BranchNodeMasks, Nibbles, ProofTrieNode, TrieNode};
+use reth_trie::{Nibbles, ProofTrieNode, TrieMasks, TrieNode};
 use reth_trie_sparse::{
    errors::SparseTrieResult, provider::TrieNodeProvider, LeafLookup, LeafLookupError,
    SerialSparseTrie, SparseTrieInterface, SparseTrieUpdates,
@@ -44,7 +44,7 @@ impl SparseTrieInterface for ConfiguredSparseTrie {
    fn with_root(
        self,
        root: TrieNode,
-        masks: Option<BranchNodeMasks>,
+        masks: TrieMasks,
        retain_updates: bool,
    ) -> SparseTrieResult<Self> {
        match self {
@@ -75,7 +75,7 @@ impl SparseTrieInterface for ConfiguredSparseTrie {
        &mut self,
        path: Nibbles,
        node: TrieNode,
-        masks: Option<BranchNodeMasks>,
+        masks: TrieMasks,
    ) -> SparseTrieResult<()> {
        match self {
            Self::Serial(trie) => trie.reveal_node(path, node, masks),
--- a/crates/engine/tree/src/tree/payload_processor/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/mod.rs
@@ -28,10 +28,10 @@ use reth_evm::{
    ConfigureEvm, EvmEnvFor, ExecutableTxIterator, ExecutableTxTuple, OnStateHook, SpecFor,
    TxEnvFor,
 };
+use reth_execution_types::ExecutionOutcome;
 use reth_primitives_traits::NodePrimitives;
 use reth_provider::{
-    BlockExecutionOutput, BlockReader, DatabaseProviderROFactory, StateProvider,
-    StateProviderFactory, StateReader,
+    BlockReader, DatabaseProviderROFactory, StateProvider, StateProviderFactory, StateReader,
 };
 use reth_revm::{db::BundleState, state::EvmState};
 use reth_trie::{hashed_cursor::HashedCursorFactory, trie_cursor::TrieCursorFactory};
@@ -61,7 +61,6 @@ mod configured_sparse_trie;
 pub mod executor;
 pub mod multiproof;
 pub mod prewarm;
-pub mod receipt_root_task;
 pub mod sparse_trie;

 use configured_sparse_trie::ConfiguredSparseTrie;
@@ -275,23 +274,24 @@ where
        let task_ctx = ProofTaskCtx::new(multiproof_provider_factory);
        let storage_worker_count = config.storage_worker_count();
        let account_worker_count = config.account_worker_count();
-        let v2_proofs_enabled = config.enable_proof_v2();
        let proof_handle = ProofWorkerHandle::new(
            self.executor.handle().clone(),
            task_ctx,
            storage_worker_count,
            account_worker_count,
-            v2_proofs_enabled,
        );

        let multi_proof_task = MultiProofTask::new(
            proof_handle.clone(),
            to_sparse_trie,
            config.multiproof_chunking_enabled().then_some(config.multiproof_chunk_size()),
-            to_multi_proof.clone(),
+            to_multi_proof,
            from_multi_proof,
        );

+        // wire the multiproof task to the prewarm task
+        let to_multi_proof = Some(multi_proof_task.state_root_message_sender());
+
        // spawn multi-proof task
        let parent_span = span.clone();
        let saved_cache = prewarm_handle.saved_cache.clone();
@@ -316,7 +316,7 @@ where
        self.spawn_sparse_trie_task(sparse_trie_rx, proof_handle, state_root_tx);

        PayloadHandle {
-            to_multi_proof: Some(to_multi_proof),
+            to_multi_proof,
            prewarm_handle,
            state_root: Some(state_root_rx),
            transactions: execution_rx,
@@ -492,40 +492,38 @@ where
        BPF::AccountNodeProvider: TrieNodeProvider + Send + Sync,
        BPF::StorageNodeProvider: TrieNodeProvider + Send + Sync,
    {
+        // Reuse a stored SparseStateTrie, or create a new one using the desired configuration if
+        // there's none to reuse.
        let cleared_sparse_trie = Arc::clone(&self.sparse_state_trie);
-        let disable_parallel_sparse_trie = self.disable_parallel_sparse_trie;
-        let trie_metrics = self.trie_metrics.clone();
-        let span = Span::current();
-
-        self.executor.spawn_blocking(move || {
-            let _enter = span.entered();
-
-            // Reuse a stored SparseStateTrie, or create a new one using the desired configuration
-            // if there's none to reuse.
-            let sparse_state_trie = cleared_sparse_trie.lock().take().unwrap_or_else(|| {
-                let default_trie = SparseTrie::blind_from(if disable_parallel_sparse_trie {
-                    ConfiguredSparseTrie::Serial(Default::default())
-                } else {
-                    ConfiguredSparseTrie::Parallel(Box::new(
-                        ParallelSparseTrie::default()
-                            .with_parallelism_thresholds(PARALLEL_SPARSE_TRIE_PARALLELISM_THRESHOLDS),
-                    ))
-                });
-                ClearedSparseStateTrie::from_state_trie(
-                    SparseStateTrie::new()
-                        .with_accounts_trie(default_trie.clone())
-                        .with_default_storage_trie(default_trie)
-                        .with_updates(true),
-                )
+        let sparse_state_trie = cleared_sparse_trie.lock().take().unwrap_or_else(|| {
+            let default_trie = SparseTrie::blind_from(if self.disable_parallel_sparse_trie {
+                ConfiguredSparseTrie::Serial(Default::default())
+            } else {
+                ConfiguredSparseTrie::Parallel(Box::new(
+                    ParallelSparseTrie::default()
+                        .with_parallelism_thresholds(PARALLEL_SPARSE_TRIE_PARALLELISM_THRESHOLDS),
+                ))
            });
+            ClearedSparseStateTrie::from_state_trie(
+                SparseStateTrie::new()
+                    .with_accounts_trie(default_trie.clone())
+                    .with_default_storage_trie(default_trie)
+                    .with_updates(true),
+            )
+        });

-            let task = SparseTrieTask::<_, ConfiguredSparseTrie, ConfiguredSparseTrie>::new_with_cleared_trie(
+        let task =
+            SparseTrieTask::<_, ConfiguredSparseTrie, ConfiguredSparseTrie>::new_with_cleared_trie(
                sparse_trie_rx,
                proof_worker_handle,
-                trie_metrics,
+                self.trie_metrics.clone(),
                sparse_state_trie,
            );

+        let span = Span::current();
+        self.executor.spawn_blocking(move || {
+            let _enter = span.entered();
+
            let (result, trie) = task.run();
            // Send state root computation result
            let _ = state_root_tx.send(result);
@@ -666,15 +664,13 @@ impl<Tx, Err, R: Send + Sync + 'static> PayloadHandle<Tx, Err, R> {

    /// Terminates the entire caching task.
    ///
-    /// If the [`BlockExecutionOutput`] is provided it will update the shared cache using its
+    /// If the [`ExecutionOutcome`] is provided it will update the shared cache using its
    /// bundle state. Using `Arc<ExecutionOutcome>` allows sharing with the main execution
    /// path without cloning the expensive `BundleState`.
-    ///
-    /// Returns a sender for the channel that should be notified on block validation success.
    pub(super) fn terminate_caching(
        &mut self,
-        execution_outcome: Option<Arc<BlockExecutionOutput<R>>>,
-    ) -> Option<mpsc::Sender<()>> {
+        execution_outcome: Option<Arc<ExecutionOutcome<R>>>,
+    ) {
        self.prewarm_handle.terminate_caching(execution_outcome)
    }

@@ -710,21 +706,15 @@ impl<R: Send + Sync + 'static> CacheTaskHandle<R> {

    /// Terminates the entire pre-warming task.
    ///
-    /// If the [`BlockExecutionOutput`] is provided it will update the shared cache using its
+    /// If the [`ExecutionOutcome`] is provided it will update the shared cache using its
    /// bundle state. Using `Arc<ExecutionOutcome>` avoids cloning the expensive `BundleState`.
-    #[must_use = "sender must be used and notified on block validation success"]
    pub(super) fn terminate_caching(
        &mut self,
-        execution_outcome: Option<Arc<BlockExecutionOutput<R>>>,
-    ) -> Option<mpsc::Sender<()>> {
+        execution_outcome: Option<Arc<ExecutionOutcome<R>>>,
+    ) {
        if let Some(tx) = self.to_prewarm_task.take() {
-            let (valid_block_tx, valid_block_rx) = mpsc::channel();
-            let event = PrewarmTaskEvent::Terminate { execution_outcome, valid_block_rx };
+            let event = PrewarmTaskEvent::Terminate { execution_outcome };
            let _ = tx.send(event);
-
-            Some(valid_block_tx)
-        } else {
-            None
        }
    }
 }
@@ -733,10 +723,7 @@ impl<R> Drop for CacheTaskHandle<R> {
    fn drop(&mut self) {
        // Ensure we always terminate on drop - send None without needing Send + Sync bounds
        if let Some(tx) = self.to_prewarm_task.take() {
-            let _ = tx.send(PrewarmTaskEvent::Terminate {
-                execution_outcome: None,
-                valid_block_rx: mpsc::channel().1,
-            });
+            let _ = tx.send(PrewarmTaskEvent::Terminate { execution_outcome: None });
        }
    }
 }
@@ -788,34 +775,12 @@ impl ExecutionCache {
            warn!(blocked_for=?elapsed, "Blocked waiting for execution cache mutex");
        }

-        if let Some(c) = cache.as_ref() {
-            let cached_hash = c.executed_block_hash();
-            // Check that the cache hash matches the parent hash of the current block. It won't
-            // match in case it's a fork block.
-            let hash_matches = cached_hash == parent_hash;
+        cache
+            .as_ref()
            // Check `is_available()` to ensure no other tasks (e.g., prewarming) currently hold
            // a reference to this cache. We can only reuse it when we have exclusive access.
-            let available = c.is_available();
-            let usage_count = c.usage_count();
-
-            debug!(
-                target: "engine::caching",
-                %cached_hash,
-                %parent_hash,
-                hash_matches,
-                available,
-                usage_count,
-                "Existing cache found"
-            );
-
-            if hash_matches && available {
-                return Some(c.clone());
-            }
-        } else {
-            debug!(target: "engine::caching", %parent_hash, "No cache found");
-        }
-
-        None
+            .filter(|c| c.executed_block_hash() == parent_hash && c.is_available())
+            .cloned()
    }

    /// Clears the tracked cache
@@ -898,7 +863,6 @@ mod tests {
    use reth_revm::db::BundleState;
    use reth_testing_utils::generators;
    use reth_trie::{test_utils::state_root, HashedPostState};
-    use reth_trie_db::ChangesetCache;
    use revm_primitives::{Address, HashMap, B256, KECCAK_EMPTY, U256};
    use revm_state::{AccountInfo, AccountStatus, EvmState, EvmStorageSlot};
    use std::sync::Arc;
@@ -1071,9 +1035,7 @@ mod tests {
                        nonce: rng.random::<u64>(),
                        code_hash: KECCAK_EMPTY,
                        code: Some(Default::default()),
-                        account_id: None,
                    },
-                    original_info: Box::new(AccountInfo::default()),
                    storage,
                    status: AccountStatus::Touched,
                    transaction_id: 0,
@@ -1156,7 +1118,7 @@ mod tests {
                std::convert::identity,
            ),
            StateProviderBuilder::new(provider_factory.clone(), genesis_hash, None),
-            OverlayStateProviderFactory::new(provider_factory, ChangesetCache::new()),
+            OverlayStateProviderFactory::new(provider_factory),
            &TreeConfig::default(),
            None, // No BAL for test
        );
--- a/crates/engine/tree/src/tree/payload_processor/multiproof.rs
+++ b/crates/engine/tree/src/tree/payload_processor/multiproof.rs
--- a/crates/engine/tree/src/tree/payload_processor/prewarm.rs
+++ b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
@@ -29,13 +29,12 @@ use alloy_evm::Database;
 use alloy_primitives::{keccak256, map::B256Set, B256};
 use crossbeam_channel::Sender as CrossbeamSender;
 use metrics::{Counter, Gauge, Histogram};
+use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use reth_evm::{execute::ExecutableTxFor, ConfigureEvm, Evm, EvmFor, SpecFor};
+use reth_execution_types::ExecutionOutcome;
 use reth_metrics::Metrics;
 use reth_primitives_traits::NodePrimitives;
-use reth_provider::{
-    AccountReader, BlockExecutionOutput, BlockReader, StateProvider, StateProviderFactory,
-    StateReader,
-};
+use reth_provider::{AccountReader, BlockReader, StateProvider, StateProviderFactory, StateReader};
 use reth_revm::{database::StateProviderDatabase, state::EvmState};
 use reth_trie::MultiProofTargets;
 use std::{
@@ -261,11 +260,7 @@ where
    ///
    /// This method is called from `run()` only after all execution tasks are complete.
    #[instrument(level = "debug", target = "engine::tree::payload_processor::prewarm", skip_all)]
-    fn save_cache(
-        self,
-        execution_outcome: Arc<BlockExecutionOutput<N::Receipt>>,
-        valid_block_rx: mpsc::Receiver<()>,
-    ) {
+    fn save_cache(self, execution_outcome: Arc<ExecutionOutcome<N::Receipt>>) {
        let start = Instant::now();

        let Self { execution_cache, ctx: PrewarmContext { env, metrics, saved_cache, .. }, .. } =
@@ -283,7 +278,7 @@ where

                // Insert state into cache while holding the lock
                // Access the BundleState through the shared ExecutionOutcome
-                if new_cache.cache().insert_state(&execution_outcome.state).is_err() {
+                if new_cache.cache().insert_state(execution_outcome.state()).is_err() {
                    // Clear the cache on error to prevent having a polluted cache
                    *cached = None;
                    debug!(target: "engine::caching", "cleared execution cache on update error");
@@ -292,11 +287,9 @@ where

                new_cache.update_metrics();

-                if valid_block_rx.recv().is_ok() {
-                    // Replace the shared cache with the new one; the previous cache (if any) is
-                    // dropped.
-                    *cached = Some(new_cache);
-                }
+                // Replace the shared cache with the new one; the previous cache (if any) is
+                // dropped.
+                *cached = Some(new_cache);
            });

            let elapsed = start.elapsed();
@@ -427,10 +420,9 @@ where
                    // completed executing a set of transactions
                    self.send_multi_proof_targets(proof_targets);
                }
-                PrewarmTaskEvent::Terminate { execution_outcome, valid_block_rx } => {
+                PrewarmTaskEvent::Terminate { execution_outcome } => {
                    trace!(target: "engine::tree::payload_processor::prewarm", "Received termination signal");
-                    final_execution_outcome =
-                        Some(execution_outcome.map(|outcome| (outcome, valid_block_rx)));
+                    final_execution_outcome = Some(execution_outcome);

                    if finished_execution {
                        // all tasks are done, we can exit, which will save caches and exit
@@ -455,8 +447,8 @@ where
        debug!(target: "engine::tree::payload_processor::prewarm", "Completed prewarm execution");

        // save caches and finish using the shared ExecutionOutcome
-        if let Some(Some((execution_outcome, valid_block_rx))) = final_execution_outcome {
-            self.save_cache(execution_outcome, valid_block_rx);
+        if let Some(Some(execution_outcome)) = final_execution_outcome {
+            self.save_cache(execution_outcome);
        }
    }
 }
@@ -576,14 +568,9 @@ where
                .entered();
            txs.recv()
        } {
-            let enter = debug_span!(
-                target: "engine::tree::payload_processor::prewarm",
-                "prewarm tx",
-                index,
-                tx_hash = %tx.tx().tx_hash(),
-                is_success = tracing::field::Empty,
-            )
-            .entered();
+            let enter =
+                debug_span!(target: "engine::tree::payload_processor::prewarm", "prewarm tx", index, tx_hash=%tx.tx().tx_hash())
+                    .entered();

            // create the tx env
            let start = Instant::now();
@@ -632,7 +619,8 @@ where
                let _enter =
                    debug_span!(target: "engine::tree::payload_processor::prewarm", "prewarm outcome", index, tx_hash=%tx.tx().tx_hash())
                        .entered();
-                let (targets, storage_targets) = multiproof_targets_from_state(res.state);
+                let targets = multiproof_targets_from_state(res.state);
+                let storage_targets = targets.storage_targets_count();
                metrics.prefetch_storage_targets.record(storage_targets as f64);
                let _ = sender.send(PrewarmTaskEvent::Outcome { proof_targets: Some(targets) });
                drop(_enter);
@@ -779,37 +767,33 @@ where

 /// Returns a set of [`MultiProofTargets`] and the total amount of storage targets, based on the
 /// given state.
-fn multiproof_targets_from_state(state: EvmState) -> (MultiProofTargets, usize) {
-    let mut targets = MultiProofTargets::with_capacity(state.len());
-    let mut storage_targets = 0;
-    for (addr, account) in state {
-        // if the account was not touched, or if the account was selfdestructed, do not
-        // fetch proofs for it
-        //
-        // Since selfdestruct can only happen in the same transaction, we can skip
-        // prefetching proofs for selfdestructed accounts
-        //
-        // See: https://eips.ethereum.org/EIPS/eip-6780
-        if !account.is_touched() || account.is_selfdestructed() {
-            continue
-        }
-
-        let mut storage_set =
-            B256Set::with_capacity_and_hasher(account.storage.len(), Default::default());
-        for (key, slot) in account.storage {
-            // do nothing if unchanged
-            if !slot.is_changed() {
-                continue
+fn multiproof_targets_from_state(state: EvmState) -> MultiProofTargets {
+    state
+        .into_par_iter()
+        .filter_map(|(address, account)| {
+            // if the account was not touched, or if the account was selfdestructed, do not
+            // fetch proofs for it
+            //
+            // Since selfdestruct can only happen in the same transaction, we can skip
+            // prefetching proofs for selfdestructed accounts
+            //
+            // See: https://eips.ethereum.org/EIPS/eip-6780
+            if !account.is_touched() || account.is_selfdestructed() {
+                return None;
            }

-            storage_set.insert(keccak256(B256::new(key.to_be_bytes())));
-        }
+            let hashed_address = keccak256(address);

-        storage_targets += storage_set.len();
-        targets.insert(keccak256(addr), storage_set);
-    }
+            let storage_set: B256Set = account
+                .storage
+                .into_iter()
+                .filter(|(_, slot)| slot.is_changed())
+                .map(|(key, _)| keccak256(B256::new(key.to_be_bytes())))
+                .collect();

-    (targets, storage_targets)
+            Some((hashed_address, storage_set))
+        })
+        .collect()
 }

 /// The events the pre-warm task can handle.
@@ -824,12 +808,7 @@ pub(super) enum PrewarmTaskEvent<R> {
    Terminate {
        /// The final execution outcome. Using `Arc` allows sharing with the main execution
        /// path without cloning the expensive `BundleState`.
-        execution_outcome: Option<Arc<BlockExecutionOutput<R>>>,
-        /// Receiver for the block validation result.
-        ///
-        /// Cache saving is racing the state root validation. We optimistically construct the
-        /// updated cache but only save it once we know the block is valid.
-        valid_block_rx: mpsc::Receiver<()>,
+        execution_outcome: Option<Arc<ExecutionOutcome<R>>>,
    },
    /// The outcome of a pre-warm task
    Outcome {
--- a/crates/engine/tree/src/tree/payload_processor/receipt_root_task.rs
+++ b/crates/engine/tree/src/tree/payload_processor/receipt_root_task.rs
@@ -1,250 +0,0 @@
-//! Receipt root computation in a background task.
-//!
-//! This module provides a streaming receipt root builder that computes the receipt trie root
-//! in a background thread. Receipts are sent via a channel with their index, and for each
-//! receipt received, the builder incrementally flushes leaves to the underlying
-//! [`OrderedTrieRootEncodedBuilder`] when possible. When the channel closes, the task returns the
-//! computed root.
-
-use alloy_eips::Encodable2718;
-use alloy_primitives::{Bloom, B256};
-use crossbeam_channel::Receiver;
-use reth_primitives_traits::Receipt;
-use reth_trie_common::ordered_root::OrderedTrieRootEncodedBuilder;
-use tokio::sync::oneshot;
-
-/// Receipt with index, ready to be sent to the background task for encoding and trie building.
-#[derive(Debug, Clone)]
-pub struct IndexedReceipt<R> {
-    /// The transaction index within the block.
-    pub index: usize,
-    /// The receipt.
-    pub receipt: R,
-}
-
-impl<R> IndexedReceipt<R> {
-    /// Creates a new indexed receipt.
-    #[inline]
-    pub const fn new(index: usize, receipt: R) -> Self {
-        Self { index, receipt }
-    }
-}
-
-/// Handle for running the receipt root computation in a background task.
-///
-/// This struct holds the channels needed to receive receipts and send the result.
-/// Use [`Self::run`] to execute the computation (typically in a spawned blocking task).
-#[derive(Debug)]
-pub struct ReceiptRootTaskHandle<R> {
-    /// Receiver for indexed receipts.
-    receipt_rx: Receiver<IndexedReceipt<R>>,
-    /// Sender for the computed result.
-    result_tx: oneshot::Sender<(B256, Bloom)>,
-}
-
-impl<R: Receipt> ReceiptRootTaskHandle<R> {
-    /// Creates a new handle from the receipt receiver and result sender channels.
-    pub const fn new(
-        receipt_rx: Receiver<IndexedReceipt<R>>,
-        result_tx: oneshot::Sender<(B256, Bloom)>,
-    ) -> Self {
-        Self { receipt_rx, result_tx }
-    }
-
-    /// Runs the receipt root computation, consuming the handle.
-    ///
-    /// This method receives indexed receipts from the channel, encodes them,
-    /// and builds the trie incrementally. When all receipts have been received
-    /// (channel closed), it sends the result through the oneshot channel.
-    ///
-    /// This is designed to be called inside a blocking task (e.g., via
-    /// `executor.spawn_blocking(move || handle.run(receipts_len))`).
-    ///
-    /// # Arguments
-    ///
-    /// * `receipts_len` - The total number of receipts expected. This is needed to correctly order
-    ///   the trie keys according to RLP encoding rules.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the number of receipts received doesn't match `receipts_len`.
-    pub fn run(self, receipts_len: usize) {
-        let mut builder = OrderedTrieRootEncodedBuilder::new(receipts_len);
-        let mut aggregated_bloom = Bloom::ZERO;
-        let mut encode_buf = Vec::new();
-
-        for indexed_receipt in self.receipt_rx {
-            let receipt_with_bloom = indexed_receipt.receipt.with_bloom_ref();
-
-            encode_buf.clear();
-            receipt_with_bloom.encode_2718(&mut encode_buf);
-
-            aggregated_bloom |= *receipt_with_bloom.bloom_ref();
-            builder.push_unchecked(indexed_receipt.index, &encode_buf);
-        }
-
-        let root = builder.finalize().expect("receipt root builder incomplete");
-        let _ = self.result_tx.send((root, aggregated_bloom));
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use alloy_consensus::{proofs::calculate_receipt_root, TxReceipt};
-    use alloy_primitives::{b256, hex, Address, Bytes, Log};
-    use crossbeam_channel::bounded;
-    use reth_ethereum_primitives::{Receipt, TxType};
-
-    #[tokio::test]
-    async fn test_receipt_root_task_empty() {
-        let (_tx, rx) = bounded::<IndexedReceipt<Receipt>>(1);
-        let (result_tx, result_rx) = oneshot::channel();
-        drop(_tx);
-
-        let handle = ReceiptRootTaskHandle::new(rx, result_tx);
-        tokio::task::spawn_blocking(move || handle.run(0)).await.unwrap();
-
-        let (root, bloom) = result_rx.await.unwrap();
-
-        // Empty trie root
-        assert_eq!(root, reth_trie_common::EMPTY_ROOT_HASH);
-        assert_eq!(bloom, Bloom::ZERO);
-    }
-
-    #[tokio::test]
-    async fn test_receipt_root_task_single_receipt() {
-        let receipts: Vec<Receipt> = vec![Receipt::default()];
-
-        let (tx, rx) = bounded(1);
-        let (result_tx, result_rx) = oneshot::channel();
-        let receipts_len = receipts.len();
-
-        let handle = ReceiptRootTaskHandle::new(rx, result_tx);
-        let join_handle = tokio::task::spawn_blocking(move || handle.run(receipts_len));
-
-        for (i, receipt) in receipts.clone().into_iter().enumerate() {
-            tx.send(IndexedReceipt::new(i, receipt)).unwrap();
-        }
-        drop(tx);
-
-        join_handle.await.unwrap();
-        let (root, _bloom) = result_rx.await.unwrap();
-
-        // Verify against the standard calculation
-        let receipts_with_bloom: Vec<_> = receipts.iter().map(|r| r.with_bloom_ref()).collect();
-        let expected_root = calculate_receipt_root(&receipts_with_bloom);
-
-        assert_eq!(root, expected_root);
-    }
-
-    #[tokio::test]
-    async fn test_receipt_root_task_multiple_receipts() {
-        let receipts: Vec<Receipt> = vec![Receipt::default(); 5];
-
-        let (tx, rx) = bounded(4);
-        let (result_tx, result_rx) = oneshot::channel();
-        let receipts_len = receipts.len();
-
-        let handle = ReceiptRootTaskHandle::new(rx, result_tx);
-        let join_handle = tokio::task::spawn_blocking(move || handle.run(receipts_len));
-
-        for (i, receipt) in receipts.into_iter().enumerate() {
-            tx.send(IndexedReceipt::new(i, receipt)).unwrap();
-        }
-        drop(tx);
-
-        join_handle.await.unwrap();
-        let (root, bloom) = result_rx.await.unwrap();
-
-        // Verify against expected values from existing test
-        assert_eq!(
-            root,
-            b256!("0x61353b4fb714dc1fccacbf7eafc4273e62f3d1eed716fe41b2a0cd2e12c63ebc")
-        );
-        assert_eq!(
-            bloom,
-            Bloom::from(hex!("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"))
-        );
-    }
-
-    #[tokio::test]
-    async fn test_receipt_root_matches_standard_calculation() {
-        // Create some receipts with actual data
-        let receipts = vec![
-            Receipt {
-                tx_type: TxType::Legacy,
-                cumulative_gas_used: 21000,
-                success: true,
-                logs: vec![],
-            },
-            Receipt {
-                tx_type: TxType::Eip1559,
-                cumulative_gas_used: 42000,
-                success: true,
-                logs: vec![Log {
-                    address: Address::ZERO,
-                    data: alloy_primitives::LogData::new_unchecked(vec![B256::ZERO], Bytes::new()),
-                }],
-            },
-            Receipt {
-                tx_type: TxType::Eip2930,
-                cumulative_gas_used: 63000,
-                success: false,
-                logs: vec![],
-            },
-        ];
-
-        // Calculate expected values first (before we move receipts)
-        let receipts_with_bloom: Vec<_> = receipts.iter().map(|r| r.with_bloom_ref()).collect();
-        let expected_root = calculate_receipt_root(&receipts_with_bloom);
-        let expected_bloom =
-            receipts_with_bloom.iter().fold(Bloom::ZERO, |bloom, r| bloom | r.bloom_ref());
-
-        // Calculate using the task
-        let (tx, rx) = bounded(4);
-        let (result_tx, result_rx) = oneshot::channel();
-        let receipts_len = receipts.len();
-
-        let handle = ReceiptRootTaskHandle::new(rx, result_tx);
-        let join_handle = tokio::task::spawn_blocking(move || handle.run(receipts_len));
-
-        for (i, receipt) in receipts.into_iter().enumerate() {
-            tx.send(IndexedReceipt::new(i, receipt)).unwrap();
-        }
-        drop(tx);
-
-        join_handle.await.unwrap();
-        let (task_root, task_bloom) = result_rx.await.unwrap();
-
-        assert_eq!(task_root, expected_root);
-        assert_eq!(task_bloom, expected_bloom);
-    }
-
-    #[tokio::test]
-    async fn test_receipt_root_task_out_of_order() {
-        let receipts: Vec<Receipt> = vec![Receipt::default(); 5];
-
-        // Calculate expected values first (before we move receipts)
-        let receipts_with_bloom: Vec<_> = receipts.iter().map(|r| r.with_bloom_ref()).collect();
-        let expected_root = calculate_receipt_root(&receipts_with_bloom);
-
-        let (tx, rx) = bounded(4);
-        let (result_tx, result_rx) = oneshot::channel();
-        let receipts_len = receipts.len();
-
-        let handle = ReceiptRootTaskHandle::new(rx, result_tx);
-        let join_handle = tokio::task::spawn_blocking(move || handle.run(receipts_len));
-
-        // Send in reverse order to test out-of-order handling
-        for (i, receipt) in receipts.into_iter().enumerate().rev() {
-            tx.send(IndexedReceipt::new(i, receipt)).unwrap();
-        }
-        drop(tx);
-
-        join_handle.await.unwrap();
-        let (root, _bloom) = result_rx.await.unwrap();
-
-        assert_eq!(root, expected_root);
-    }
-}
--- a/crates/engine/tree/src/tree/payload_processor/sparse_trie.rs
+++ b/crates/engine/tree/src/tree/payload_processor/sparse_trie.rs
@@ -121,9 +121,8 @@ where
                ParallelStateRootError::Other(format!("could not calculate state root: {e:?}"))
            })?;

-        let end = Instant::now();
-        self.metrics.sparse_trie_final_update_duration_histogram.record(end.duration_since(start));
-        self.metrics.sparse_trie_total_duration_histogram.record(end.duration_since(now));
+        self.metrics.sparse_trie_final_update_duration_histogram.record(start.elapsed());
+        self.metrics.sparse_trie_total_duration_histogram.record(now.elapsed());

        Ok(StateRootComputeOutcome { state_root, trie_updates })
    }
@@ -174,7 +173,7 @@ where
        .par_bridge()
        .map(|(address, storage, storage_trie)| {
            let _enter =
-                debug_span!(target: "engine::tree::payload_processor::sparse_trie", parent: &span, "storage trie", ?address)
+                debug_span!(target: "engine::tree::payload_processor::sparse_trie", parent: span.clone(), "storage trie", ?address)
                    .entered();

            trace!(target: "engine::tree::payload_processor::sparse_trie", "Updating storage");
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -15,11 +15,9 @@ use alloy_eip7928::BlockAccessList;
 use alloy_eips::{eip1898::BlockWithParent, NumHash};
 use alloy_evm::Evm;
 use alloy_primitives::B256;
-
-use crate::tree::payload_processor::receipt_root_task::{IndexedReceipt, ReceiptRootTaskHandle};
 use rayon::prelude::*;
-use reth_chain_state::{CanonicalInMemoryState, DeferredTrieData, ExecutedBlock, LazyOverlay};
-use reth_consensus::{ConsensusError, FullConsensus, ReceiptRootBloom};
+use reth_chain_state::{CanonicalInMemoryState, DeferredTrieData, ExecutedBlock};
+use reth_consensus::{ConsensusError, FullConsensus};
 use reth_engine_primitives::{
    ConfigureEngineEvm, ExecutableTxIterator, ExecutionPayload, InvalidBlockHook, PayloadValidator,
 };
@@ -36,14 +34,14 @@ use reth_primitives_traits::{
    SealedHeader, SignerRecoverable,
 };
 use reth_provider::{
-    providers::OverlayStateProviderFactory, BlockExecutionOutput, BlockNumReader, BlockReader,
-    ChangeSetReader, DatabaseProviderFactory, DatabaseProviderROFactory, HashedPostStateProvider,
+    providers::OverlayStateProviderFactory, BlockExecutionOutput, BlockReader,
+    DatabaseProviderFactory, DatabaseProviderROFactory, ExecutionOutcome, HashedPostStateProvider,
    ProviderError, PruneCheckpointReader, StageCheckpointReader, StateProvider,
-    StateProviderFactory, StateReader,
+    StateProviderFactory, StateReader, TrieReader,
 };
 use reth_revm::db::State;
-use reth_trie::{updates::TrieUpdates, HashedPostState, StateRoot};
-use reth_trie_db::ChangesetCache;
+use reth_storage_errors::db::DatabaseError;
+use reth_trie::{updates::TrieUpdates, HashedPostState, StateRoot, TrieInputSorted};
 use reth_trie_parallel::root::{ParallelStateRoot, ParallelStateRootError};
 use revm_primitives::Address;
 use std::{
@@ -114,7 +112,7 @@ where
    /// Provider for database access.
    provider: P,
    /// Consensus implementation for validation.
-    consensus: Arc<dyn FullConsensus<Evm::Primitives>>,
+    consensus: Arc<dyn FullConsensus<Evm::Primitives, Error = ConsensusError>>,
    /// EVM configuration.
    evm_config: Evm,
    /// Configuration for the tree.
@@ -132,22 +130,14 @@ where
    metrics: EngineApiMetrics,
    /// Validator for the payload.
    validator: V,
-    /// Changeset cache for in-memory trie changesets
-    changeset_cache: ChangesetCache,
 }

 impl<N, P, Evm, V> BasicEngineValidator<P, Evm, V>
 where
    N: NodePrimitives,
    P: DatabaseProviderFactory<
-            Provider: BlockReader
-                          + StageCheckpointReader
-                          + PruneCheckpointReader
-                          + ChangeSetReader
-                          + BlockNumReader,
+            Provider: BlockReader + TrieReader + StageCheckpointReader + PruneCheckpointReader,
        > + BlockReader<Header = N::BlockHeader>
-        + ChangeSetReader
-        + BlockNumReader
        + StateProviderFactory
        + StateReader
        + HashedPostStateProvider
@@ -159,12 +149,11 @@ where
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        provider: P,
-        consensus: Arc<dyn FullConsensus<N>>,
+        consensus: Arc<dyn FullConsensus<N, Error = ConsensusError>>,
        evm_config: Evm,
        validator: V,
        config: TreeConfig,
        invalid_block_hook: Box<dyn InvalidBlockHook<N>>,
-        changeset_cache: ChangesetCache,
    ) -> Self {
        let precompile_cache_map = PrecompileCacheMap::default();
        let payload_processor = PayloadProcessor::new(
@@ -184,7 +173,6 @@ where
            invalid_block_hook,
            metrics: EngineApiMetrics::default(),
            validator,
-            changeset_cache,
        }
    }

@@ -369,6 +357,7 @@ where
        }

        let parent_hash = input.parent_hash();
+        let block_num_hash = input.num_hash();

        trace!(target: "engine::tree::payload_validator", "Fetching block state provider");
        let _enter =
@@ -423,23 +412,13 @@ where
            .map_err(Box::<dyn std::error::Error + Send + Sync>::from))
        .map(Arc::new);

-        // Create lazy overlay from ancestors - this doesn't block, allowing execution to start
-        // before the trie data is ready. The overlay will be computed on first access.
-        let (lazy_overlay, anchor_hash) = Self::get_parent_lazy_overlay(parent_hash, ctx.state());
-
-        // Create overlay factory for payload processor (StateRootTask path needs it for
-        // multiproofs)
-        let overlay_factory =
-            OverlayStateProviderFactory::new(self.provider.clone(), self.changeset_cache.clone())
-                .with_block_hash(Some(anchor_hash))
-                .with_lazy_overlay(lazy_overlay);
-
        // Spawn the appropriate processor based on strategy
        let mut handle = ensure_ok!(self.spawn_payload_processor(
            env.clone(),
            txs,
            provider_builder,
-            overlay_factory.clone(),
+            parent_hash,
+            ctx.state(),
            strategy,
            block_access_list,
        ));
@@ -455,44 +434,19 @@ where
            state_provider = Box::new(InstrumentedStateProvider::new(state_provider, "engine"));
        }

-        // Execute the block and handle any execution errors.
-        // The receipt root task is spawned before execution and receives receipts incrementally
-        // as transactions complete, allowing parallel computation during execution.
-        let (output, senders, receipt_root_rx) =
-            match self.execute_block(state_provider, env, &input, &mut handle) {
-                Ok(output) => output,
-                Err(err) => return self.handle_execution_error(input, err, &parent_block),
-            };
+        // Execute the block and handle any execution errors
+        let (output, senders) = match self.execute_block(state_provider, env, &input, &mut handle) {
+            Ok(output) => output,
+            Err(err) => return self.handle_execution_error(input, err, &parent_block),
+        };

        // After executing the block we can stop prewarming transactions
        handle.stop_prewarming_execution();

-        // Create ExecutionOutcome early so we can terminate caching before validation and state
-        // root computation. Using Arc allows sharing with both the caching task and the deferred
-        // trie task without cloning the expensive BundleState.
-        let output = Arc::new(output);
-
-        // Terminate caching task early since execution is complete and caching is no longer
-        // needed. This frees up resources while state root computation continues.
-        let valid_block_tx = handle.terminate_caching(Some(output.clone()));
-
        let block = self.convert_to_block(input)?.with_senders(senders);

-        // Wait for the receipt root computation to complete.
-        let receipt_root_bloom = Some(
-            receipt_root_rx
-                .blocking_recv()
-                .expect("receipt root task dropped sender without result"),
-        );
-
        let hashed_state = ensure_ok_post_block!(
-            self.validate_post_execution(
-                &block,
-                &parent_block,
-                &output,
-                &mut ctx,
-                receipt_root_bloom
-            ),
+            self.validate_post_execution(&block, &parent_block, &output, &mut ctx),
            block
        );

@@ -525,7 +479,11 @@ where
            }
            StateRootStrategy::Parallel => {
                debug!(target: "engine::tree::payload_validator", "Using parallel state root algorithm");
-                match self.compute_state_root_parallel(overlay_factory.clone(), &hashed_state) {
+                match self.compute_state_root_parallel(
+                    block.parent_hash(),
+                    &hashed_state,
+                    ctx.state(),
+                ) {
                    Ok(result) => {
                        let elapsed = root_time.elapsed();
                        info!(
@@ -561,7 +519,7 @@ where
            }

            let (root, updates) = ensure_ok_post_block!(
-                self.compute_state_root_serial(overlay_factory.clone(), &hashed_state),
+                self.compute_state_root_serial(block.parent_hash(), &hashed_state, ctx.state()),
                block
            );
            (root, updates, root_time.elapsed())
@@ -591,18 +549,14 @@ where
            .into())
        }

-        if let Some(valid_block_tx) = valid_block_tx {
-            let _ = valid_block_tx.send(());
-        }
+        // Create ExecutionOutcome and wrap in Arc for sharing with both the caching task
+        // and the deferred trie task. This avoids cloning the expensive BundleState.
+        let execution_outcome = Arc::new(ExecutionOutcome::from((output, block_num_hash.number)));

-        Ok(self.spawn_deferred_trie_task(
-            block,
-            output,
-            &ctx,
-            hashed_state,
-            trie_output,
-            overlay_factory,
-        ))
+        // Terminate prewarming task with the shared execution outcome
+        handle.terminate_caching(Some(Arc::clone(&execution_outcome)));
+
+        Ok(self.spawn_deferred_trie_task(block, execution_outcome, &ctx, hashed_state, trie_output))
    }

    /// Return sealed block header from database or in-memory state by hash.
@@ -640,21 +594,13 @@ where

    /// Executes a block with the given state provider
    #[instrument(level = "debug", target = "engine::tree::payload_validator", skip_all)]
-    #[expect(clippy::type_complexity)]
    fn execute_block<S, Err, T>(
        &mut self,
        state_provider: S,
        env: ExecutionEnv<Evm>,
        input: &BlockOrPayload<T>,
        handle: &mut PayloadHandle<impl ExecutableTxFor<Evm>, Err, N::Receipt>,
-    ) -> Result<
-        (
-            BlockExecutionOutput<N::Receipt>,
-            Vec<Address>,
-            tokio::sync::oneshot::Receiver<(B256, alloy_primitives::Bloom)>,
-        ),
-        InsertBlockErrorKind,
-    >
+    ) -> Result<(BlockExecutionOutput<N::Receipt>, Vec<Address>), InsertBlockErrorKind>
    where
        S: StateProvider + Send,
        Err: core::error::Error + Send + Sync + 'static,
@@ -670,8 +616,7 @@ where
            .without_state_clear()
            .build();

-        let spec_id = *env.evm_env.spec_id();
-        let evm = self.evm_config.evm_with_env(&mut db, env.evm_env);
+        let evm = self.evm_config.evm_with_env(&mut db, env.evm_env.clone());
        let ctx =
            self.execution_ctx_for(input).map_err(|e| InsertBlockErrorKind::Other(Box::new(e)))?;
        let mut executor = self.evm_config.create_executor(evm, ctx);
@@ -687,20 +632,12 @@ where
                CachedPrecompile::wrap(
                    precompile,
                    self.precompile_cache_map.cache_for_address(*address),
-                    spec_id,
+                    *env.evm_env.spec_id(),
                    Some(metrics),
                )
            });
        }

-        // Spawn background task to compute receipt root and logs bloom incrementally.
-        // Unbounded channel is used since tx count bounds capacity anyway (max ~30k txs per block).
-        let receipts_len = input.transaction_count();
-        let (receipt_tx, receipt_rx) = crossbeam_channel::unbounded();
-        let (result_tx, result_rx) = tokio::sync::oneshot::channel();
-        let task_handle = ReceiptRootTaskHandle::new(receipt_rx, result_tx);
-        self.payload_processor.executor().spawn_blocking(move || task_handle.run(receipts_len));
-
        let execution_start = Instant::now();
        let state_hook = Box::new(handle.state_hook());
        let (output, senders) = self.metrics.execute_metered(
@@ -708,30 +645,15 @@ where
            handle.iter_transactions().map(|res| res.map_err(BlockExecutionError::other)),
            input.transaction_count(),
            state_hook,
-            |receipts| {
-                // Send the latest receipt to the background task for incremental root computation.
-                // The receipt is cloned here; encoding happens in the background thread.
-                if let Some(receipt) = receipts.last() {
-                    // Infer tx_index from the number of receipts collected so far
-                    let tx_index = receipts.len() - 1;
-                    let _ = receipt_tx.send(IndexedReceipt::new(tx_index, receipt.clone()));
-                }
-            },
        )?;
-        drop(receipt_tx);
-
        let execution_finish = Instant::now();
        let execution_time = execution_finish.duration_since(execution_start);
        debug!(target: "engine::tree::payload_validator", elapsed = ?execution_time, "Executed block");
-        Ok((output, senders, result_rx))
+        Ok((output, senders))
    }

    /// Compute state root for the given hashed post state in parallel.
    ///
-    /// Uses an overlay factory which provides the state of the parent block, along with the
-    /// [`HashedPostState`] containing the changes of this block, to compute the state root and
-    /// trie updates for this block.
-    ///
    /// # Returns
    ///
    /// Returns `Ok(_)` if computed successfully.
@@ -739,40 +661,60 @@ where
    #[instrument(level = "debug", target = "engine::tree::payload_validator", skip_all)]
    fn compute_state_root_parallel(
        &self,
-        overlay_factory: OverlayStateProviderFactory<P>,
+        parent_hash: B256,
        hashed_state: &HashedPostState,
+        state: &EngineApiTreeState<N>,
    ) -> Result<(B256, TrieUpdates), ParallelStateRootError> {
-        // The `hashed_state` argument will be taken into account as part of the overlay, but we
+        let (mut input, block_hash) = self.compute_trie_input(parent_hash, state)?;
+
+        // Extend state overlay with current block's sorted state.
+        input.prefix_sets.extend(hashed_state.construct_prefix_sets());
+        let sorted_hashed_state = hashed_state.clone_into_sorted();
+        Arc::make_mut(&mut input.state).extend_ref(&sorted_hashed_state);
+
+        let TrieInputSorted { nodes, state, prefix_sets: prefix_sets_mut } = input;
+
+        let factory = OverlayStateProviderFactory::new(self.provider.clone())
+            .with_block_hash(Some(block_hash))
+            .with_trie_overlay(Some(nodes))
+            .with_hashed_state_overlay(Some(state));
+
+        // The `hashed_state` argument is already taken into account as part of the overlay, but we
        // need to use the prefix sets which were generated from it to indicate to the
        // ParallelStateRoot which parts of the trie need to be recomputed.
-        let prefix_sets = hashed_state.construct_prefix_sets().freeze();
-        let overlay_factory =
-            overlay_factory.with_extended_hashed_state_overlay(hashed_state.clone_into_sorted());
-        ParallelStateRoot::new(overlay_factory, prefix_sets).incremental_root_with_updates()
+        let prefix_sets = prefix_sets_mut.freeze();
+
+        ParallelStateRoot::new(factory, prefix_sets).incremental_root_with_updates()
    }

    /// Compute state root for the given hashed post state in serial.
-    ///
-    /// Uses an overlay factory which provides the state of the parent block, along with the
-    /// [`HashedPostState`] containing the changes of this block, to compute the state root and
-    /// trie updates for this block.
    fn compute_state_root_serial(
        &self,
-        overlay_factory: OverlayStateProviderFactory<P>,
+        parent_hash: B256,
        hashed_state: &HashedPostState,
+        state: &EngineApiTreeState<N>,
    ) -> ProviderResult<(B256, TrieUpdates)> {
-        // The `hashed_state` argument will be taken into account as part of the overlay, but we
-        // need to use the prefix sets which were generated from it to indicate to the
-        // StateRoot which parts of the trie need to be recomputed.
-        let prefix_sets = hashed_state.construct_prefix_sets().freeze();
-        let overlay_factory =
-            overlay_factory.with_extended_hashed_state_overlay(hashed_state.clone_into_sorted());
+        let (mut input, block_hash) = self.compute_trie_input(parent_hash, state)?;

-        let provider = overlay_factory.database_provider_ro()?;
+        // Extend state overlay with current block's sorted state.
+        input.prefix_sets.extend(hashed_state.construct_prefix_sets());
+        let sorted_hashed_state = hashed_state.clone_into_sorted();
+        Arc::make_mut(&mut input.state).extend_ref(&sorted_hashed_state);
+
+        let TrieInputSorted { nodes, state, .. } = input;
+        let prefix_sets = hashed_state.construct_prefix_sets();
+
+        let factory = OverlayStateProviderFactory::new(self.provider.clone())
+            .with_block_hash(Some(block_hash))
+            .with_trie_overlay(Some(nodes))
+            .with_hashed_state_overlay(Some(state));
+
+        let provider = factory.database_provider_ro()?;

        Ok(StateRoot::new(&provider, &provider)
-            .with_prefix_sets(prefix_sets)
-            .root_with_updates()?)
+            .with_prefix_sets(prefix_sets.freeze())
+            .root_with_updates()
+            .map_err(Into::<DatabaseError>::into)?)
    }

    /// Validates the block after execution.
@@ -781,9 +723,6 @@ where
    /// - parent header validation
    /// - post-execution consensus validation
    /// - state-root based post-execution validation
-    ///
-    /// If `receipt_root_bloom` is provided, it will be used instead of computing the receipt root
-    /// and logs bloom from the receipts.
    #[instrument(level = "debug", target = "engine::tree::payload_validator", skip_all)]
    fn validate_post_execution<T: PayloadTypes<BuiltPayload: BuiltPayload<Primitives = N>>>(
        &self,
@@ -791,7 +730,6 @@ where
        parent_block: &SealedHeader<N::BlockHeader>,
        output: &BlockExecutionOutput<N::Receipt>,
        ctx: &mut TreeCtx<'_, N>,
-        receipt_root_bloom: Option<ReceiptRootBloom>,
    ) -> Result<HashedPostState, InsertBlockErrorKind>
    where
        V: PayloadValidator<T, Block = N::Block>,
@@ -818,9 +756,7 @@ where
        let _enter =
            debug_span!(target: "engine::tree::payload_validator", "validate_block_post_execution")
                .entered();
-        if let Err(err) =
-            self.consensus.validate_block_post_execution(block, output, receipt_root_bloom)
-        {
+        if let Err(err) = self.consensus.validate_block_post_execution(block, output) {
            // call post-block hook
            self.on_invalid_block(parent_block, block, output, None, ctx.state_mut());
            return Err(err.into())
@@ -860,11 +796,6 @@ where
    ///
    /// The method handles strategy fallbacks if the preferred approach fails, ensuring
    /// block execution always completes with a valid state root.
-    ///
-    /// # Arguments
-    ///
-    /// * `overlay_factory` - Pre-computed overlay factory for multiproof generation
-    ///   (`StateRootTask`)
    #[allow(clippy::too_many_arguments)]
    #[instrument(
        level = "debug",
@@ -877,7 +808,8 @@ where
        env: ExecutionEnv<Evm>,
        txs: T,
        provider_builder: StateProviderBuilder<N, P>,
-        overlay_factory: OverlayStateProviderFactory<P>,
+        parent_hash: B256,
+        state: &EngineApiTreeState<N>,
        strategy: StateRootStrategy,
        block_access_list: Option<Arc<BlockAccessList>>,
    ) -> Result<
@@ -890,14 +822,32 @@ where
    > {
        match strategy {
            StateRootStrategy::StateRootTask => {
+                // Compute trie input
+                let trie_input_start = Instant::now();
+                let (trie_input, block_hash) = self.compute_trie_input(parent_hash, state)?;
+
+                // Create OverlayStateProviderFactory with sorted trie data for multiproofs
+                let TrieInputSorted { nodes, state, .. } = trie_input;
+
+                let multiproof_provider_factory =
+                    OverlayStateProviderFactory::new(self.provider.clone())
+                        .with_block_hash(Some(block_hash))
+                        .with_trie_overlay(Some(nodes))
+                        .with_hashed_state_overlay(Some(state));
+
+                // Record trie input duration including OverlayStateProviderFactory setup
+                self.metrics
+                    .block_validation
+                    .trie_input_duration
+                    .record(trie_input_start.elapsed().as_secs_f64());
+
                let spawn_start = Instant::now();

-                // Use the pre-computed overlay factory for multiproofs
                let handle = self.payload_processor.spawn(
                    env,
                    txs,
                    provider_builder,
-                    overlay_factory,
+                    multiproof_provider_factory,
                    &self.config,
                    block_access_list,
                );
@@ -991,36 +941,99 @@ where
        self.invalid_block_hook.on_invalid_block(parent_header, block, output, trie_updates);
    }

-    /// Creates a [`LazyOverlay`] for the parent block without blocking.
+    /// Computes [`TrieInputSorted`] for the provided parent hash by combining database state
+    /// with in-memory overlays.
    ///
-    /// Returns a lazy overlay that will compute the trie input on first access, and the anchor
-    /// block hash (the highest persisted ancestor). This allows execution to start immediately
-    /// while the trie input computation is deferred until the overlay is actually needed.
+    /// The goal of this function is to take in-memory blocks and generate a [`TrieInputSorted`]
+    /// that extends from the highest persisted ancestor up through the parent. This enables state
+    /// root computation and proof generation without requiring all blocks to be persisted
+    /// first.
    ///
-    /// If parent is on disk (no in-memory blocks), returns `None` for the lazy overlay.
-    fn get_parent_lazy_overlay(
+    /// It works as follows:
+    /// 1. Collect in-memory overlay blocks using [`crate::tree::TreeState::blocks_by_hash`]. This
+    ///    returns the highest persisted ancestor hash (`block_hash`) and the list of in-memory
+    ///    blocks building on top of it.
+    /// 2. Fast path: If the tip in-memory block's trie input is already anchored to `block_hash`
+    ///    (its `anchor_hash` matches `block_hash`), reuse it directly.
+    /// 3. Slow path: Build a new [`TrieInputSorted`] by aggregating the overlay blocks (from oldest
+    ///    to newest) on top of the database state at `block_hash`.
+    #[instrument(
+        level = "debug",
+        target = "engine::tree::payload_validator",
+        skip_all,
+        fields(parent_hash)
+    )]
+    fn compute_trie_input(
+        &self,
        parent_hash: B256,
        state: &EngineApiTreeState<N>,
-    ) -> (Option<LazyOverlay>, B256) {
-        let (anchor_hash, blocks) =
+    ) -> ProviderResult<(TrieInputSorted, B256)> {
+        let wait_start = Instant::now();
+        let (block_hash, blocks) =
            state.tree_state.blocks_by_hash(parent_hash).unwrap_or_else(|| (parent_hash, vec![]));

-        if blocks.is_empty() {
-            debug!(target: "engine::tree::payload_validator", "Parent found on disk, no lazy overlay needed");
-            return (None, anchor_hash);
+        // Fast path: if the tip block's anchor matches the persisted ancestor hash, reuse its
+        // TrieInput. This means the TrieInputSorted already aggregates all in-memory overlays
+        // from that ancestor, so we can avoid re-aggregation.
+        if let Some(tip_block) = blocks.first() {
+            let data = tip_block.trie_data();
+            if let (Some(anchor_hash), Some(trie_input)) =
+                (data.anchor_hash(), data.trie_input().cloned()) &&
+                anchor_hash == block_hash
+            {
+                trace!(target: "engine::tree::payload_validator", %block_hash,"Reusing trie input with matching anchor hash");
+                self.metrics
+                    .block_validation
+                    .deferred_trie_wait_duration
+                    .record(wait_start.elapsed().as_secs_f64());
+                return Ok(((*trie_input).clone(), block_hash));
+            }
        }

-        debug!(
-            target: "engine::tree::payload_validator",
-            %anchor_hash,
-            num_blocks = blocks.len(),
-            "Creating lazy overlay for in-memory blocks"
-        );
+        if blocks.is_empty() {
+            debug!(target: "engine::tree::payload_validator", "Parent found on disk");
+        } else {
+            debug!(target: "engine::tree::payload_validator", historical = ?block_hash, blocks = blocks.len(), "Parent found in memory");
+        }

-        // Extract deferred trie data handles (non-blocking)
-        let handles: Vec<DeferredTrieData> = blocks.iter().map(|b| b.trie_data_handle()).collect();
+        // Extend with contents of parent in-memory blocks directly in sorted form.
+        let input = Self::merge_overlay_trie_input(&blocks);

-        (Some(LazyOverlay::new(anchor_hash, handles)), anchor_hash)
+        self.metrics
+            .block_validation
+            .deferred_trie_wait_duration
+            .record(wait_start.elapsed().as_secs_f64());
+        Ok((input, block_hash))
+    }
+
+    /// Aggregates multiple in-memory blocks into a single [`TrieInputSorted`] by combining their
+    /// state changes.
+    ///
+    /// The input `blocks` vector is ordered newest -> oldest (see `TreeState::blocks_by_hash`).
+    /// We iterate it in reverse so we start with the oldest block's trie data and extend forward
+    /// toward the newest, ensuring newer state takes precedence.
+    fn merge_overlay_trie_input(blocks: &[ExecutedBlock<N>]) -> TrieInputSorted {
+        let mut input = TrieInputSorted::default();
+        let mut blocks_iter = blocks.iter().rev().peekable();
+
+        if let Some(first) = blocks_iter.next() {
+            let data = first.trie_data();
+            input.state = data.hashed_state;
+            input.nodes = data.trie_updates;
+
+            // Only clone and mutate if there are more in-memory blocks.
+            if blocks_iter.peek().is_some() {
+                let state_mut = Arc::make_mut(&mut input.state);
+                let nodes_mut = Arc::make_mut(&mut input.nodes);
+                for block in blocks_iter {
+                    let data = block.trie_data();
+                    state_mut.extend_ref(data.hashed_state.as_ref());
+                    nodes_mut.extend_ref(data.trie_updates.as_ref());
+                }
+            }
+        }
+
+        input
    }

    /// Spawns a background task to compute and sort trie data for the executed block.
@@ -1042,11 +1055,10 @@ where
    fn spawn_deferred_trie_task(
        &self,
        block: RecoveredBlock<N::Block>,
-        execution_outcome: Arc<BlockExecutionOutput<N::Receipt>>,
+        execution_outcome: Arc<ExecutionOutcome<N::Receipt>>,
        ctx: &TreeCtx<'_, N>,
        hashed_state: HashedPostState,
        trie_output: TrieUpdates,
-        overlay_factory: OverlayStateProviderFactory<P>,
    ) -> ExecutedBlock<N> {
        // Capture parent hash and ancestor overlays for deferred trie input construction.
        let (anchor_hash, overlay_blocks) = ctx
@@ -1068,79 +1080,16 @@ where
            ancestors,
        );
        let deferred_handle_task = deferred_trie_data.clone();
-        let block_validation_metrics = self.metrics.block_validation.clone();
-
-        // Capture block info and cache handle for changeset computation
-        let block_hash = block.hash();
-        let block_number = block.number();
-        let changeset_cache = self.changeset_cache.clone();
+        let deferred_compute_duration =
+            self.metrics.block_validation.deferred_trie_compute_duration.clone();

        // Spawn background task to compute trie data. Calling `wait_cloned` will compute from
        // the stored inputs and cache the result, so subsequent calls return immediately.
        let compute_trie_input_task = move || {
-            let _span = debug_span!(
-                target: "engine::tree::payload_validator",
-                "compute_trie_input_task",
-                block_number
-            )
-            .entered();
-
            let result = panic::catch_unwind(AssertUnwindSafe(|| {
                let compute_start = Instant::now();
-                let computed = deferred_handle_task.wait_cloned();
-                block_validation_metrics
-                    .deferred_trie_compute_duration
-                    .record(compute_start.elapsed().as_secs_f64());
-
-                // Record sizes of the computed trie data
-                block_validation_metrics
-                    .hashed_post_state_size
-                    .record(computed.hashed_state.total_len() as f64);
-                block_validation_metrics
-                    .trie_updates_sorted_size
-                    .record(computed.trie_updates.total_len() as f64);
-                if let Some(anchored) = &computed.anchored_trie_input {
-                    block_validation_metrics
-                        .anchored_overlay_trie_updates_size
-                        .record(anchored.trie_input.nodes.total_len() as f64);
-                    block_validation_metrics
-                        .anchored_overlay_hashed_state_size
-                        .record(anchored.trie_input.state.total_len() as f64);
-                }
-
-                // Compute and cache changesets using the computed trie_updates
-                let changeset_start = Instant::now();
-
-                // Get a provider from the overlay factory for trie cursor access
-                let changeset_result =
-                    overlay_factory.database_provider_ro().and_then(|provider| {
-                        reth_trie::changesets::compute_trie_changesets(
-                            &provider,
-                            &computed.trie_updates,
-                        )
-                        .map_err(ProviderError::Database)
-                    });
-
-                match changeset_result {
-                    Ok(changesets) => {
-                        debug!(
-                            target: "engine::tree::changeset",
-                            ?block_number,
-                            elapsed = ?changeset_start.elapsed(),
-                            "Computed and caching changesets"
-                        );
-
-                        changeset_cache.insert(block_hash, block_number, Arc::new(changesets));
-                    }
-                    Err(e) => {
-                        warn!(
-                            target: "engine::tree::changeset",
-                            ?block_number,
-                            ?e,
-                            "Failed to compute changesets in deferred trie task"
-                        );
-                    }
-                }
+                let _ = deferred_handle_task.wait_cloned();
+                deferred_compute_duration.record(compute_start.elapsed().as_secs_f64());
            }));

            if result.is_err() {
@@ -1236,16 +1185,10 @@ pub trait EngineValidator<
 impl<N, Types, P, Evm, V> EngineValidator<Types> for BasicEngineValidator<P, Evm, V>
 where
    P: DatabaseProviderFactory<
-            Provider: BlockReader
-                          + StageCheckpointReader
-                          + PruneCheckpointReader
-                          + ChangeSetReader
-                          + BlockNumReader,
+            Provider: BlockReader + TrieReader + StageCheckpointReader + PruneCheckpointReader,
        > + BlockReader<Header = N::BlockHeader>
        + StateProviderFactory
        + StateReader
-        + ChangeSetReader
-        + BlockNumReader
        + HashedPostStateProvider
        + Clone
        + 'static,
@@ -1289,7 +1232,7 @@ where
    fn on_inserted_executed_block(&self, block: ExecutedBlock<N>) {
        self.payload_processor.on_inserted_executed_block(
            block.recovered_block.block_with_parent(),
-            &block.execution_output.state,
+            block.execution_output.state(),
        );
    }
 }
--- a/crates/engine/tree/src/tree/persistence_state.rs
+++ b/crates/engine/tree/src/tree/persistence_state.rs
@@ -22,12 +22,12 @@

 use alloy_eips::BlockNumHash;
 use alloy_primitives::B256;
-use crossbeam_channel::Receiver as CrossbeamReceiver;
 use std::time::Instant;
+use tokio::sync::oneshot;
 use tracing::trace;

 /// The state of the persistence task.
-#[derive(Debug)]
+#[derive(Default, Debug)]
 pub struct PersistenceState {
    /// Hash and number of the last block persisted.
    ///
@@ -36,7 +36,7 @@ pub struct PersistenceState {
    /// Receiver end of channel where the result of the persistence task will be
    /// sent when done. A None value means there's no persistence task in progress.
    pub(crate) rx:
-        Option<(CrossbeamReceiver<Option<BlockNumHash>>, Instant, CurrentPersistenceAction)>,
+        Option<(oneshot::Receiver<Option<BlockNumHash>>, Instant, CurrentPersistenceAction)>,
 }

 impl PersistenceState {
@@ -50,7 +50,7 @@ impl PersistenceState {
    pub(crate) fn start_remove(
        &mut self,
        new_tip_num: u64,
-        rx: CrossbeamReceiver<Option<BlockNumHash>>,
+        rx: oneshot::Receiver<Option<BlockNumHash>>,
    ) {
        self.rx =
            Some((rx, Instant::now(), CurrentPersistenceAction::RemovingBlocks { new_tip_num }));
@@ -60,7 +60,7 @@ impl PersistenceState {
    pub(crate) fn start_save(
        &mut self,
        highest: BlockNumHash,
-        rx: CrossbeamReceiver<Option<BlockNumHash>>,
+        rx: oneshot::Receiver<Option<BlockNumHash>>,
    ) {
        self.rx = Some((rx, Instant::now(), CurrentPersistenceAction::SavingBlocks { highest }));
    }
--- a/crates/engine/tree/src/tree/tests.rs
+++ b/crates/engine/tree/src/tree/tests.rs
@@ -7,7 +7,6 @@ use crate::{
        PersistTarget, TreeConfig,
    },
 };
-use reth_trie_db::ChangesetCache;

 use alloy_eips::eip1898::BlockWithParent;
 use alloy_primitives::{
@@ -27,12 +26,12 @@ use reth_ethereum_engine_primitives::EthEngineTypes;
 use reth_ethereum_primitives::{Block, EthPrimitives};
 use reth_evm_ethereum::MockEvmConfig;
 use reth_primitives_traits::Block as _;
-use reth_provider::test_utils::MockEthProvider;
+use reth_provider::{test_utils::MockEthProvider, ExecutionOutcome};
 use std::{
    collections::BTreeMap,
    str::FromStr,
    sync::{
-        mpsc::{Receiver, Sender},
+        mpsc::{channel, Receiver, Sender},
        Arc,
    },
 };
@@ -98,7 +97,6 @@ struct TestChannel<T> {
 impl<T: Send + 'static> TestChannel<T> {
    /// Creates a new test channel
    fn spawn_channel() -> (Sender<T>, Receiver<T>, TestChannelHandle) {
-        use std::sync::mpsc::channel;
        let (original_tx, original_rx) = channel();
        let (wrapped_tx, wrapped_rx) = channel();
        let (release_tx, release_rx) = channel();
@@ -145,9 +143,7 @@ struct TestHarness {
        BasicEngineValidator<MockEthProvider, MockEvmConfig, MockEngineValidator>,
        MockEvmConfig,
    >,
-    to_tree_tx: crossbeam_channel::Sender<
-        FromEngine<EngineApiRequest<EthEngineTypes, EthPrimitives>, Block>,
-    >,
+    to_tree_tx: Sender<FromEngine<EngineApiRequest<EthEngineTypes, EthPrimitives>, Block>>,
    from_tree_rx: UnboundedReceiver<EngineApiEvent>,
    blocks: Vec<ExecutedBlock>,
    action_rx: Receiver<PersistenceAction>,
@@ -157,7 +153,6 @@ struct TestHarness {

 impl TestHarness {
    fn new(chain_spec: Arc<ChainSpec>) -> Self {
-        use std::sync::mpsc::channel;
        let (action_tx, action_rx) = channel();
        Self::with_persistence_channel(chain_spec, action_tx, action_rx)
    }
@@ -193,7 +188,6 @@ impl TestHarness {
        let payload_builder = PayloadBuilderHandle::new(to_payload_service);

        let evm_config = MockEvmConfig::default();
-        let changeset_cache = ChangesetCache::new();
        let engine_validator = BasicEngineValidator::new(
            provider.clone(),
            consensus.clone(),
@@ -201,7 +195,6 @@ impl TestHarness {
            payload_validator,
            TreeConfig::default(),
            Box::new(NoopInvalidBlockHook::default()),
-            changeset_cache.clone(),
        );

        let tree = EngineApiTreeHandler::new(
@@ -212,13 +205,12 @@ impl TestHarness {
            engine_api_tree_state,
            canonical_in_memory_state,
            persistence_handle,
-            PersistenceState { last_persisted_block: BlockNumHash::default(), rx: None },
+            PersistenceState::default(),
            payload_builder,
            // always assume enough parallelism for tests
            TreeConfig::default().with_legacy_state_root(false).with_has_enough_parallelism(true),
            EngineApiKind::Ethereum,
            evm_config,
-            changeset_cache,
        );

        let block_builder = TestBlockBuilder::default().with_chain_spec((*chain_spec).clone());
@@ -392,7 +384,6 @@ impl ValidatorTestHarness {
        let provider = harness.provider.clone();
        let payload_validator = MockEngineValidator;
        let evm_config = MockEvmConfig::default();
-        let changeset_cache = ChangesetCache::new();

        let validator = BasicEngineValidator::new(
            provider,
@@ -401,7 +392,6 @@ impl ValidatorTestHarness {
            payload_validator,
            TreeConfig::default(),
            Box::new(NoopInvalidBlockHook::default()),
-            changeset_cache,
        );

        Self { harness, validator, metrics: TestMetrics::default() }
@@ -409,8 +399,10 @@ impl ValidatorTestHarness {

    /// Configure `PersistenceState` for specific persistence scenarios
    fn start_persistence_operation(&mut self, action: CurrentPersistenceAction) {
+        use tokio::sync::oneshot;
+
        // Create a dummy receiver for testing - it will never receive a value
-        let (_tx, rx) = crossbeam_channel::bounded(1);
+        let (_tx, rx) = oneshot::channel();

        match action {
            CurrentPersistenceAction::SavingBlocks { highest } => {
@@ -506,17 +498,11 @@ fn test_tree_persist_block_batch() {
    test_harness.to_tree_tx.send(FromEngine::DownloadedBlocks(blocks)).unwrap();

    // process the message
-    let msg = match test_harness.tree.wait_for_event() {
-        super::LoopEvent::EngineMessage(msg) => msg,
-        other => panic!("unexpected event: {other:?}"),
-    };
+    let msg = test_harness.tree.try_recv_engine_message().unwrap().unwrap();
    let _ = test_harness.tree.on_engine_message(msg).unwrap();

    // we now should receive the other batch
-    let msg = match test_harness.tree.wait_for_event() {
-        super::LoopEvent::EngineMessage(msg) => msg,
-        other => panic!("unexpected event: {other:?}"),
-    };
+    let msg = test_harness.tree.try_recv_engine_message().unwrap().unwrap();
    match msg {
        FromEngine::DownloadedBlocks(blocks) => {
            assert_eq!(blocks.len(), tree_config.max_execute_block_batch_size());
@@ -767,8 +753,8 @@ async fn test_tree_state_on_new_head_reorg() {
        })
    );

-    // after polling persistence completion, we should be at `None` for the next action
-    test_harness.tree.try_poll_persistence().unwrap();
+    // after advancing persistence, we should be at `None` for the next action
+    test_harness.tree.advance_persistence().unwrap();
    let current_action = test_harness.tree.persistence_state.current_action().cloned();
    assert_eq!(current_action, None);

@@ -838,7 +824,7 @@ fn test_tree_state_on_new_head_deep_fork() {
    for block in &chain_a {
        test_harness.tree.state.tree_state.insert_executed(ExecutedBlock::new(
            Arc::new(block.clone()),
-            Arc::new(BlockExecutionOutput::default()),
+            Arc::new(ExecutionOutcome::default()),
            empty_trie_data(),
        ));
    }
@@ -847,7 +833,7 @@ fn test_tree_state_on_new_head_deep_fork() {
    for block in &chain_b {
        test_harness.tree.state.tree_state.insert_executed(ExecutedBlock::new(
            Arc::new(block.clone()),
-            Arc::new(BlockExecutionOutput::default()),
+            Arc::new(ExecutionOutcome::default()),
            empty_trie_data(),
        ));
    }
@@ -1008,15 +994,6 @@ async fn test_engine_tree_live_sync_transition_required_blocks_requested() {
        _ => panic!("Unexpected event: {event:#?}"),
    }

-    // After backfill completes with head not buffered, we also request head download
-    let event = test_harness.from_tree_rx.recv().await.unwrap();
-    match event {
-        EngineApiEvent::Download(DownloadRequest::BlockSet(hash_set)) => {
-            assert_eq!(hash_set, HashSet::from_iter([main_chain_last_hash]));
-        }
-        _ => panic!("Unexpected event: {event:#?}"),
-    }
-
    let _ = test_harness
        .tree
        .on_engine_message(FromEngine::DownloadedBlocks(vec![main_chain
--- a/crates/ethereum/cli/Cargo.toml
+++ b/crates/ethereum/cli/Cargo.toml
@@ -38,7 +38,6 @@ tempfile.workspace = true
 default = []

 otlp = ["reth-tracing/otlp", "reth-node-core/otlp"]
-otlp-logs = ["reth-tracing/otlp-logs", "reth-node-core/otlp-logs"]

 dev = ["reth-cli-commands/arbitrary"]

@@ -52,15 +51,9 @@ jemalloc = [
    "reth-node-metrics/jemalloc",
 ]
 jemalloc-prof = [
-    "jemalloc",
-    "reth-node-metrics/jemalloc-prof",
+    "reth-node-core/jemalloc",
 ]
-jemalloc-symbols = [
-    "jemalloc-prof",
-    "reth-node-metrics/jemalloc-symbols",
-]
-tracy-allocator = ["tracy"]
-tracy = ["reth-tracing/tracy", "reth-node-core/tracy"]
+tracy-allocator = []

 # Because jemalloc is default and preferred over snmalloc when both features are
 # enabled, `--no-default-features` should be used when enabling snmalloc or
@@ -88,5 +81,3 @@ min-trace-logs = [
    "tracing/release_max_level_trace",
    "reth-node-core/min-trace-logs",
 ]
-
-edge = ["reth-cli-commands/edge"]
--- a/crates/ethereum/cli/src/interface.rs
+++ b/crates/ethereum/cli/src/interface.rs
@@ -19,7 +19,7 @@ use reth_db::DatabaseEnv;
 use reth_node_api::NodePrimitives;
 use reth_node_builder::{NodeBuilder, WithLaunchContext};
 use reth_node_core::{
-    args::{LogArgs, OtlpInitStatus, OtlpLogsStatus, TraceArgs},
+    args::{LogArgs, OtlpInitStatus, TraceArgs},
    version::version_metadata,
 };
 use reth_node_metrics::recorder::install_prometheus_recorder;
@@ -223,19 +223,16 @@ impl<
    /// If file logging is enabled, this function returns a guard that must be kept alive to ensure
    /// that all logs are flushed to disk.
    ///
-    /// If an OTLP endpoint is specified, it will export traces and logs to the configured
-    /// collector.
+    /// If an OTLP endpoint is specified, it will export metrics to the configured collector.
    pub fn init_tracing(
        &mut self,
        runner: &CliRunner,
        mut layers: Layers,
    ) -> eyre::Result<Option<FileWorkerGuard>> {
        let otlp_status = runner.block_on(self.traces.init_otlp_tracing(&mut layers))?;
-        let otlp_logs_status = runner.block_on(self.traces.init_otlp_logs(&mut layers))?;

        let guard = self.logs.init_tracing_with_layers(layers)?;
        info!(target: "reth::cli", "Initialized tracing, debug log directory: {}", self.logs.log_file_directory);
-
        match otlp_status {
            OtlpInitStatus::Started(endpoint) => {
                info!(target: "reth::cli", "Started OTLP {:?} tracing export to {endpoint}", self.traces.protocol);
@@ -246,16 +243,6 @@ impl<
            OtlpInitStatus::Disabled => {}
        }

-        match otlp_logs_status {
-            OtlpLogsStatus::Started(endpoint) => {
-                info!(target: "reth::cli", "Started OTLP {:?} logs export to {endpoint}", self.traces.protocol);
-            }
-            OtlpLogsStatus::NoFeature => {
-                warn!(target: "reth::cli", "Provided OTLP logs arguments do not have effect, compile with the `otlp-logs` feature")
-            }
-            OtlpLogsStatus::Disabled => {}
-        }
-
        Ok(guard)
    }
 }
--- a/crates/ethereum/consensus/src/lib.rs
+++ b/crates/ethereum/consensus/src/lib.rs
@@ -15,7 +15,7 @@ use alloc::{fmt::Debug, sync::Arc};
 use alloy_consensus::{constants::MAXIMUM_EXTRA_DATA_SIZE, EMPTY_OMMER_ROOT_HASH};
 use alloy_eips::eip7840::BlobParams;
 use reth_chainspec::{EthChainSpec, EthereumHardforks};
-use reth_consensus::{Consensus, ConsensusError, FullConsensus, HeaderValidator, ReceiptRootBloom};
+use reth_consensus::{Consensus, ConsensusError, FullConsensus, HeaderValidator};
 use reth_consensus_common::validation::{
    validate_4844_header_standalone, validate_against_parent_4844,
    validate_against_parent_eip1559_base_fee, validate_against_parent_gas_limit,
@@ -74,15 +74,8 @@ where
        &self,
        block: &RecoveredBlock<N::Block>,
        result: &BlockExecutionResult<N::Receipt>,
-        receipt_root_bloom: Option<ReceiptRootBloom>,
    ) -> Result<(), ConsensusError> {
-        validate_block_post_execution(
-            block,
-            &self.chain_spec,
-            &result.receipts,
-            &result.requests,
-            receipt_root_bloom,
-        )
+        validate_block_post_execution(block, &self.chain_spec, &result.receipts, &result.requests)
    }
 }

@@ -91,15 +84,17 @@ where
    B: Block,
    ChainSpec: EthChainSpec<Header = B::Header> + EthereumHardforks + Debug + Send + Sync,
 {
+    type Error = ConsensusError;
+
    fn validate_body_against_header(
        &self,
        body: &B::Body,
        header: &SealedHeader<B::Header>,
-    ) -> Result<(), ConsensusError> {
+    ) -> Result<(), Self::Error> {
        validate_body_against_header(body, header.header())
    }

-    fn validate_block_pre_execution(&self, block: &SealedBlock<B>) -> Result<(), ConsensusError> {
+    fn validate_block_pre_execution(&self, block: &SealedBlock<B>) -> Result<(), Self::Error> {
        validate_block_pre_execution(block, &self.chain_spec)
    }
 }
@@ -233,12 +228,10 @@ mod tests {
        let parent = header_with_gas_limit(GAS_LIMIT_BOUND_DIVISOR * 10);
        let child = header_with_gas_limit((parent.gas_limit + 5) as u64);

-        assert!(validate_against_parent_gas_limit(
-            &child,
-            &parent,
-            &ChainSpec::<Header>::default()
-        )
-        .is_ok());
+        assert_eq!(
+            validate_against_parent_gas_limit(&child, &parent, &ChainSpec::<Header>::default()),
+            Ok(())
+        );
    }

    #[test]
@@ -246,11 +239,10 @@ mod tests {
        let parent = header_with_gas_limit(MINIMUM_GAS_LIMIT);
        let child = header_with_gas_limit(MINIMUM_GAS_LIMIT - 1);

-        assert!(matches!(
-            validate_against_parent_gas_limit(&child, &parent, &ChainSpec::<Header>::default()).unwrap_err(),
-            ConsensusError::GasLimitInvalidMinimum { child_gas_limit }
-                if child_gas_limit == child.gas_limit as u64
-        ));
+        assert_eq!(
+            validate_against_parent_gas_limit(&child, &parent, &ChainSpec::<Header>::default()),
+            Err(ConsensusError::GasLimitInvalidMinimum { child_gas_limit: child.gas_limit as u64 })
+        );
    }

    #[test]
@@ -260,11 +252,13 @@ mod tests {
            parent.gas_limit + parent.gas_limit / GAS_LIMIT_BOUND_DIVISOR + 1,
        );

-        assert!(matches!(
-            validate_against_parent_gas_limit(&child, &parent, &ChainSpec::<Header>::default()).unwrap_err(),
-            ConsensusError::GasLimitInvalidIncrease { parent_gas_limit, child_gas_limit }
-                if parent_gas_limit == parent.gas_limit && child_gas_limit == child.gas_limit
-        ));
+        assert_eq!(
+            validate_against_parent_gas_limit(&child, &parent, &ChainSpec::<Header>::default()),
+            Err(ConsensusError::GasLimitInvalidIncrease {
+                parent_gas_limit: parent.gas_limit,
+                child_gas_limit: child.gas_limit,
+            })
+        );
    }

    #[test]
@@ -272,12 +266,10 @@ mod tests {
        let parent = header_with_gas_limit(GAS_LIMIT_BOUND_DIVISOR * 10);
        let child = header_with_gas_limit(parent.gas_limit - 5);

-        assert!(validate_against_parent_gas_limit(
-            &child,
-            &parent,
-            &ChainSpec::<Header>::default()
-        )
-        .is_ok());
+        assert_eq!(
+            validate_against_parent_gas_limit(&child, &parent, &ChainSpec::<Header>::default()),
+            Ok(())
+        );
    }

    #[test]
@@ -287,11 +279,13 @@ mod tests {
            parent.gas_limit - parent.gas_limit / GAS_LIMIT_BOUND_DIVISOR - 1,
        );

-        assert!(matches!(
-            validate_against_parent_gas_limit(&child, &parent, &ChainSpec::<Header>::default()).unwrap_err(),
-            ConsensusError::GasLimitInvalidDecrease { parent_gas_limit, child_gas_limit }
-                if parent_gas_limit == parent.gas_limit && child_gas_limit == child.gas_limit
-        ));
+        assert_eq!(
+            validate_against_parent_gas_limit(&child, &parent, &ChainSpec::<Header>::default()),
+            Err(ConsensusError::GasLimitInvalidDecrease {
+                parent_gas_limit: parent.gas_limit,
+                child_gas_limit: child.gas_limit,
+            })
+        );
    }

    #[test]
@@ -306,8 +300,9 @@ mod tests {
            ..Default::default()
        };

-        assert!(EthBeaconConsensus::new(chain_spec)
-            .validate_header(&SealedHeader::seal_slow(header,))
-            .is_ok());
+        assert_eq!(
+            EthBeaconConsensus::new(chain_spec).validate_header(&SealedHeader::seal_slow(header,)),
+            Ok(())
+        );
    }
 }
--- a/crates/ethereum/consensus/src/validation.rs
+++ b/crates/ethereum/consensus/src/validation.rs
@@ -12,15 +12,11 @@ use reth_primitives_traits::{
 ///
 /// - Compares the receipts root in the block header to the block body
 /// - Compares the gas used in the block header to the actual gas usage after execution
-///
-/// If `receipt_root_bloom` is provided, the pre-computed receipt root and logs bloom are used
-/// instead of computing them from the receipts.
 pub fn validate_block_post_execution<B, R, ChainSpec>(
    block: &RecoveredBlock<B>,
    chain_spec: &ChainSpec,
    receipts: &[R],
    requests: &Requests,
-    receipt_root_bloom: Option<(B256, Bloom)>,
 ) -> Result<(), ConsensusError>
 where
    B: Block,
@@ -41,26 +37,19 @@ where
    // operation as hashing that is required for state root got calculated in every
    // transaction This was replaced with is_success flag.
    // See more about EIP here: https://eips.ethereum.org/EIPS/eip-658
-    if chain_spec.is_byzantium_active_at_block(block.header().number()) {
-        let result = if let Some((receipts_root, logs_bloom)) = receipt_root_bloom {
-            compare_receipts_root_and_logs_bloom(
-                receipts_root,
-                logs_bloom,
-                block.header().receipts_root(),
-                block.header().logs_bloom(),
-            )
-        } else {
-            verify_receipts(block.header().receipts_root(), block.header().logs_bloom(), receipts)
-        };
-
-        if let Err(error) = result {
-            let receipts = receipts
-                .iter()
-                .map(|r| Bytes::from(r.with_bloom_ref().encoded_2718()))
-                .collect::<Vec<_>>();
-            tracing::debug!(%error, ?receipts, "receipts verification failed");
-            return Err(error)
-        }
+    if chain_spec.is_byzantium_active_at_block(block.header().number()) &&
+        let Err(error) = verify_receipts(
+            block.header().receipts_root(),
+            block.header().logs_bloom(),
+            receipts,
+        )
+    {
+        let receipts = receipts
+            .iter()
+            .map(|r| Bytes::from(r.with_bloom_ref().encoded_2718()))
+            .collect::<Vec<_>>();
+        tracing::debug!(%error, ?receipts, "receipts verification failed");
+        return Err(error)
    }

    // Validate that the header requests hash matches the calculated requests hash
@@ -181,16 +170,18 @@ mod tests {
        let expected_receipts_root = B256::random();
        let expected_logs_bloom = calculated_logs_bloom;

-        assert!(matches!(
+        assert_eq!(
            compare_receipts_root_and_logs_bloom(
                calculated_receipts_root,
                calculated_logs_bloom,
                expected_receipts_root,
                expected_logs_bloom
-            ).unwrap_err(),
-            ConsensusError::BodyReceiptRootDiff(diff)
-                if diff.got == calculated_receipts_root && diff.expected == expected_receipts_root
-        ));
+            ),
+            Err(ConsensusError::BodyReceiptRootDiff(
+                GotExpected { got: calculated_receipts_root, expected: expected_receipts_root }
+                    .into()
+            ))
+        );
    }

    #[test]
@@ -201,15 +192,16 @@ mod tests {
        let expected_receipts_root = calculated_receipts_root;
        let expected_logs_bloom = Bloom::random();

-        assert!(matches!(
+        assert_eq!(
            compare_receipts_root_and_logs_bloom(
                calculated_receipts_root,
                calculated_logs_bloom,
                expected_receipts_root,
                expected_logs_bloom
-            ).unwrap_err(),
-            ConsensusError::BodyBloomLogDiff(diff)
-                if diff.got == calculated_logs_bloom && diff.expected == expected_logs_bloom
-        ));
+            ),
+            Err(ConsensusError::BodyBloomLogDiff(
+                GotExpected { got: calculated_logs_bloom, expected: expected_logs_bloom }.into()
+            ))
+        );
    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
yongkangc	5121ad2244	fix: revert slow path optimization that caused regression The slow path optimization attempted to reuse ancestor cached overlays, but those overlays were built with a DIFFERENT anchor_hash. Since the slow path is triggered precisely because the anchor changed (after persist/reorg), reusing overlays from the old anchor produces incorrect results. Reverted to the original slow path that rebuilds from each ancestor's per-block state changes. The Arc::make_mut tracking metrics are kept.	2026-01-06 23:29:13 +00:00
yongkangc	f073e6ec49	fix: address clippy doc-markdown lints	2026-01-06 23:29:13 +00:00
yongkangc	dcde41a6b4	perf: optimize slow path to reuse ancestor cached overlays Instead of iterating all ancestors from scratch in merge_ancestors_into_overlay, we now find the most recent ancestor that has a cached anchored_trie_input and use that as the base overlay. This reduces O(N) work to O(N - cached_depth). This optimization is particularly helpful at persist/reorg boundaries where the slow path is triggered. If any ancestor in the chain already has a cached overlay, we skip rebuilding everything before it. Also adds Arc::make_mut clone tracking metrics to help identify when CoW clones are triggered (when strong_count > 1).	2026-01-06 23:29:13 +00:00
yongkangc	517d5ad6be	perf: avoid O(N) prefix_sets clone on overlay reuse The fast path overlay reuse was cloning the entire TrieInputSorted, including prefix_sets (a B256Map<PrefixSetMut>) which caused O(N) HashMap clones per block. prefix_sets does not need to accumulate across blocks - it only needs the current block's changes. Ancestors' trie changes are already embodied in the nodes and state overlays. The incremental state root algorithms use prefix_sets to identify which branches changed since the last root computation. Now we only Arc::clone the nodes and state (O(1)) and use a fresh empty prefix_sets, which the caller extends with only the current block's changes. This matches the existing pattern in merkle_changesets.rs. Amp-Thread-ID: https://ampcode.com/threads/T-019b9306-9706-7736-8571-4a8d4acb814c	2026-01-06 23:29:13 +00:00
yongkangc	0a08af0288	fix: use rfind instead of filter().next_back() per clippy lint	2026-01-06 23:29:13 +00:00
yongkangc	9ca0850121	fix: address clippy lints (redundant clone, doc-markdown, double-ended-iterator-last)	2026-01-06 23:29:13 +00:00
yongkangc	3b38fe6bfb	style: apply rustfmt formatting	2026-01-06 23:29:13 +00:00
yongkangc	d74914d86d	perf(chain-state): fix O(N²) complexity in deferred trie overlay computation Summary Eliminate O(N²) complexity in sort_and_build_trie_input() by reusing the parent block's already-merged trie overlay instead of re-merging all ancestors for every block. Problem Previously, each block iterated through ALL ancestors calling wait_cloned() on each to merge their state into the overlay. For block N, this meant N-1 wait_cloned() calls, leading to O(N²) total calls for N blocks. This became a severe bottleneck under load when blocks arrive faster than the async task can complete (sync fallback path). Solution - Fast path (O(1)): When parent's anchor_hash matches, clone its overlay which already contains all ancestors merged - Slow path (O(N)): When anchor changes (after persist/reorg), rebuild from all ancestors - but this only happens at persist boundaries, not per block Changes - Modified sort_and_build_trie_input() to check if parent's overlay can be reused before falling back to full ancestor merge - Added merge_ancestors_into_overlay() helper for the slow path - Added metrics: deferred_trie_overlay_reused and deferred_trie_overlay_rebuilt - Added comprehensive tests for fast path, slow path, chain building, and O(N) performance verification - Documented invariants on AnchoredTrieInput for correctness guarantees Performance Impact - Before: 79,800 wait_cloned() calls for 400 blocks (O(N²)) - After: 400 wait_cloned() calls for 400 blocks (O(N)) Amp-Thread-ID: https://ampcode.com/threads/T-019b9262-f4d6-71c4-8fb0-36a245ad4c28	2026-01-06 23:29:13 +00:00