wip: benching dashmap with big blocks

Adds a new reth-bench subcommand that generates large blocks by:
1. Fetching transactions from existing blocks via RPC
2. Packing them until target gas is reached
3. Calling engine_getPayloadV3Hacked or V4 to build the payload
4. Optionally executing via newPayload + forkchoiceUpdated

Usage:
  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 \
    --execute

.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,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,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.

.github/CODEOWNERS

@@ -1,52 +1,45 @@
 *                           @gakonst
+crates/blockchain-tree-api/ @rakita @mattsse @Rjected
+crates/blockchain-tree/     @rakita @mattsse @Rjected
 crates/chain-state/         @fgimenez @mattsse
 crates/chainspec/           @Rjected @joshieDo @mattsse
 crates/cli/                 @mattsse
-crates/config/              @shekhirin @mattsse @Rjected 
 crates/consensus/           @mattsse @Rjected
 crates/e2e-test-utils/      @mattsse @Rjected @klkvr @fgimenez
-crates/engine/              @mattsse @Rjected @mediocregopher @yongkangc
-crates/era/                 @mattsse
-crates/era-downloader/      @mattsse
-crates/era-utils/           @mattsse
+crates/engine/              @mattsse @Rjected @fgimenez @mediocregopher @yongkangc
+crates/era/                 @mattsse @RomanHodulak
 crates/errors/              @mattsse
+crates/ethereum-forks/      @mattsse @Rjected
 crates/ethereum/            @mattsse @Rjected
 crates/etl/                 @joshieDo @shekhirin
-crates/evm/                 @mattsse @Rjected @klkvr
+crates/evm/                 @rakita @mattsse @Rjected
 crates/exex/                @shekhirin
-crates/fs-util/             @mattsse
-crates/metrics/             @mattsse @Rjected 
 crates/net/                 @mattsse @Rjected
 crates/net/downloaders/     @Rjected
 crates/node/                @mattsse @Rjected @klkvr
-crates/optimism/            @mattsse @Rjected
+crates/optimism/            @mattsse @Rjected @fgimenez
 crates/payload/             @mattsse @Rjected
-crates/primitives-traits/   @Rjected @mattsse @klkvr
+crates/primitives-traits/   @Rjected @RomanHodulak @mattsse @klkvr
 crates/primitives/          @Rjected @mattsse @klkvr
 crates/prune/               @shekhirin @joshieDo
-crates/ress/                @shekhirin @Rjected
-crates/revm/                @mattsse
-crates/rpc/                 @mattsse @Rjected
+crates/ress                 @shekhirin @Rjected
+crates/revm/                @mattsse @rakita
+crates/rpc/                 @mattsse @Rjected @RomanHodulak
 crates/stages/              @shekhirin @mediocregopher
 crates/static-file/         @joshieDo @shekhirin
-crates/stateless/           @mattsse
 crates/storage/codecs/      @joshieDo
-crates/storage/db-api/      @joshieDo
+crates/storage/db-api/      @joshieDo @rakita
 crates/storage/db-common/   @Rjected
-crates/storage/db/          @joshieDo
-crates/storage/errors/      @joshieDo
-crates/storage/libmdbx-rs/  @shekhirin
+crates/storage/db/          @joshieDo @rakita
+crates/storage/errors/      @rakita
+crates/storage/libmdbx-rs/  @rakita @shekhirin
 crates/storage/nippy-jar/   @joshieDo @shekhirin
-crates/storage/provider/    @joshieDo @shekhirin @yongkangc
+crates/storage/provider/    @rakita @joshieDo @shekhirin
 crates/storage/storage-api/ @joshieDo
 crates/tasks/               @mattsse
-crates/tokio-util/          @mattsse 
-crates/tracing/             @mattsse @shekhirin
-crates/tracing-otlp/        @mattsse @Rjected 
+crates/tokio-util/          @fgimenez
 crates/transaction-pool/    @mattsse @yongkangc
-crates/trie/                @Rjected @shekhirin @mediocregopher @yongkangc
-bin/reth/                   @mattsse @shekhirin @Rjected 
-bin/reth-bench/             @mattsse @Rjected @shekhirin @yongkangc 
+crates/trie/                @Rjected @shekhirin @mediocregopher
 bin/reth-bench-compare/     @mediocregopher @shekhirin @yongkangc
 etc/                        @Rjected @shekhirin
 .github/                    @gakonst @DaniPopes

.github/scripts/codspeed-build.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+# TODO: Benchmarks run WAY too slow due to excessive amount of iterations.
+
+cmd=(cargo codspeed build --profile profiling)
+crates=(
+    -p reth-primitives
+    -p reth-trie
+    -p reth-trie-common
+    -p reth-trie-sparse
+)
+
+"${cmd[@]}" --features test-utils "${crates[@]}"

.github/workflows/bench.yml

@@ -17,16 +17,6 @@ name: bench
 jobs:
   codspeed:
     runs-on: depot-ubuntu-latest
-    strategy:
-      matrix:
-        partition: [1, 2]
-        total_partitions: [2]
-        include:
-          - partition: 1
-            crates: "-p reth-primitives -p reth-trie-common -p reth-trie-sparse"
-          - partition: 2
-            crates: "-p reth-trie"
-    name: codspeed (${{ matrix.partition }}/${{ matrix.total_partitions }})
     steps:
       - uses: actions/checkout@v6
         with:
@@ -42,10 +32,10 @@ jobs:
         with:
           tool: cargo-codspeed
       - name: Build the benchmark target(s)
-        run: cargo codspeed build --profile profiling --features test-utils ${{ matrix.crates }}
+        run: ./.github/scripts/codspeed-build.sh
       - name: Run the benchmarks
         uses: CodSpeedHQ/action@v4
         with:
-          run: cargo codspeed run ${{ matrix.crates }}
+          run: cargo codspeed run --workspace
           mode: instrumentation
           token: ${{ secrets.CODSPEED_TOKEN }}

.github/workflows/check-alloy.yml

@@ -1,65 +0,0 @@
-# Checks reth compilation against alloy branches to detect breaking changes.
-# Run on-demand via workflow_dispatch.
-
-name: Check Alloy Breaking Changes
-
-on:
-  workflow_dispatch:
-    inputs:
-      alloy_branch:
-        description: 'Branch/rev for alloy-rs/alloy (leave empty to skip)'
-        required: false
-        type: string
-      alloy_evm_branch:
-        description: 'Branch/rev for alloy-rs/evm (alloy-evm, alloy-op-evm) (leave empty to skip)'
-        required: false
-        type: string
-      op_alloy_branch:
-        description: 'Branch/rev for alloy-rs/op-alloy (leave empty to skip)'
-        required: false
-        type: string
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  check:
-    name: Check compilation with patched alloy
-    runs-on: depot-ubuntu-latest-16
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: dtolnay/rust-toolchain@stable
-
-      - uses: Swatinem/rust-cache@v2
-        with:
-          cache-on-failure: true
-
-      - name: Apply alloy patches
-        run: |
-          ARGS=""
-          if [ -n "${{ inputs.alloy_branch }}" ]; then
-            ARGS="$ARGS --alloy ${{ inputs.alloy_branch }}"
-          fi
-          if [ -n "${{ inputs.alloy_evm_branch }}" ]; then
-            ARGS="$ARGS --evm ${{ inputs.alloy_evm_branch }}"
-          fi
-          if [ -n "${{ inputs.op_alloy_branch }}" ]; then
-            ARGS="$ARGS --op ${{ inputs.op_alloy_branch }}"
-          fi
-          
-          if [ -z "$ARGS" ]; then
-            echo "No branches specified, nothing to patch"
-            exit 1
-          fi
-          
-          ./scripts/patch-alloy.sh $ARGS
-          
-          echo "=== Final patch section ==="
-          tail -50 Cargo.toml
-
-      - name: Check workspace
-        run: cargo clippy --workspace --lib --examples --tests --benches --all-features --locked
-        env:
-          RUSTFLAGS: -D warnings

.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 }}

.github/workflows/docker-git.yml

@@ -0,0 +1,54 @@
+# Publishes the Docker image, only to be used with `workflow_dispatch`. The
+# images from this workflow will be tagged with the git sha of the branch used
+# and will NOT tag it as `latest`.
+
+name: docker-git
+
+on:
+  workflow_dispatch: {}
+
+env:
+  REPO_NAME: ${{ github.repository_owner }}/reth
+  IMAGE_NAME: ${{ github.repository_owner }}/reth
+  OP_IMAGE_NAME: ${{ github.repository_owner }}/op-reth
+  CARGO_TERM_COLOR: always
+  DOCKER_IMAGE_NAME: ghcr.io/${{ github.repository_owner }}/reth
+  OP_DOCKER_IMAGE_NAME: ghcr.io/${{ github.repository_owner }}/op-reth
+  DOCKER_USERNAME: ${{ github.actor }}
+  GIT_SHA: ${{ github.sha }}
+
+jobs:
+  build:
+    name: build and push
+    runs-on: ubuntu-24.04
+    permissions:
+      packages: write
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        build:
+          - name: 'Build and push the git-sha-tagged reth image'
+            command: 'make PROFILE=maxperf GIT_SHA=$GIT_SHA docker-build-push-git-sha'
+          - name: 'Build and push the git-sha-tagged op-reth image'
+            command: 'make IMAGE_NAME=$OP_IMAGE_NAME DOCKER_IMAGE_NAME=$OP_DOCKER_IMAGE_NAME GIT_SHA=$GIT_SHA PROFILE=maxperf op-docker-build-push-git-sha'
+    steps:
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          cache-on-failure: true
+      - name: Install cross main
+        id: cross_main
+        run: |
+          cargo install cross --git https://github.com/cross-rs/cross
+      - name: Log in to Docker
+        run: |
+          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io --username ${DOCKER_USERNAME} --password-stdin
+      - name: Set up Docker builder
+        run: |
+          docker run --privileged --rm tonistiigi/binfmt --install arm64,amd64
+          docker buildx create --use --name cross-builder
+      - name: Build and push ${{ matrix.build.name }}
+        run: ${{ matrix.build.command }}

.github/workflows/docker-nightly.yml

@@ -0,0 +1,65 @@
+# Publishes the nightly Docker image.
+
+name: docker-nightly
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 1 * * *"
+env:
+  REPO_NAME: ${{ github.repository_owner }}/reth
+  IMAGE_NAME: ${{ github.repository_owner }}/reth
+  OP_IMAGE_NAME: ${{ github.repository_owner }}/op-reth
+  CARGO_TERM_COLOR: always
+  DOCKER_IMAGE_NAME: ghcr.io/${{ github.repository_owner }}/reth
+  OP_DOCKER_IMAGE_NAME: ghcr.io/${{ github.repository_owner }}/op-reth
+  DOCKER_USERNAME: ${{ github.actor }}
+
+jobs:
+  build:
+    name: build and push
+    runs-on: ubuntu-24.04
+    permissions:
+      packages: write
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        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:
+      - uses: actions/checkout@v6
+      - name: Remove bloatware
+        uses: laverdet/remove-bloatware@v1.0.0
+        with:
+          docker: true
+          lang: rust
+      - uses: rui314/setup-mold@v1
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          cache-on-failure: true
+      - name: Install cross main
+        id: cross_main
+        run: |
+          cargo install cross --git https://github.com/cross-rs/cross
+      - name: Log in to Docker
+        run: |
+          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io --username ${DOCKER_USERNAME} --password-stdin
+      - name: Set up Docker builder
+        run: |
+          docker run --privileged --rm tonistiigi/binfmt --install arm64,amd64
+          docker buildx create --use --name cross-builder
+      - name: Build and push ${{ matrix.build.name }}
+        run: ${{ matrix.build.command }}

.github/workflows/docker.yml

@@ -1,9 +1,4 @@
-# Publishes Docker images.
-#
-# Triggers:
-#   - Push tag v*: builds release (RC or latest)
-#   - Schedule: builds nightly + profiling
-#   - Manual: builds git-sha or nightly
+# Publishes the Docker image.
 
 name: docker
 
@@ -11,94 +6,84 @@ on:
   push:
     tags:
       - v*
-  schedule:
-    - cron: "0 1 * * *"
-  workflow_dispatch:
-    inputs:
-      build_type:
-        description: "Build type"
-        required: true
-        type: choice
-        options:
-          - git-sha
-          - nightly
-        default: git-sha
-      dry_run:
-        description: "Skip pushing images (dry run)"
-        required: false
-        type: boolean
-        default: false
+
+env:
+  IMAGE_NAME: ${{ github.repository_owner }}/reth
+  OP_IMAGE_NAME: ${{ github.repository_owner }}/op-reth
+  CARGO_TERM_COLOR: always
+  DOCKER_IMAGE_NAME: ghcr.io/${{ github.repository_owner }}/reth
+  OP_DOCKER_IMAGE_NAME: ghcr.io/${{ github.repository_owner }}/op-reth
+  DOCKER_USERNAME: ${{ github.actor }}
 
 jobs:
-  build:
-    name: Build Docker images
+  build-rc:
+    if: contains(github.ref, '-rc')
+    name: build and push as release candidate
     runs-on: ubuntu-24.04
     permissions:
       packages: write
       contents: read
-      id-token: write
+    strategy:
+      fail-fast: false
+      matrix:
+        build:
+          - name: "Build and push reth image"
+            command: "make IMAGE_NAME=$IMAGE_NAME DOCKER_IMAGE_NAME=$DOCKER_IMAGE_NAME PROFILE=maxperf docker-build-push"
+          - name: "Build and push op-reth image"
+            command: "make IMAGE_NAME=$OP_IMAGE_NAME DOCKER_IMAGE_NAME=$OP_DOCKER_IMAGE_NAME PROFILE=maxperf op-docker-build-push"
     steps:
       - uses: actions/checkout@v6
-
-      - name: Set up Depot CLI
-        uses: depot/setup-action@v1
-
-      - name: Log in to GHCR
-        uses: docker/login-action@v3
+      - uses: rui314/setup-mold@v1
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
         with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Get git info for vergen
-        id: git
+          cache-on-failure: true
+      - name: Install cross main
+        id: cross_main
         run: |
-          echo "sha=${{ github.sha }}" >> "$GITHUB_OUTPUT"
-          echo "describe=$(git describe --always --tags)" >> "$GITHUB_OUTPUT"
-          echo "dirty=false" >> "$GITHUB_OUTPUT"
-
-      - name: Determine build parameters
-        id: params
+          cargo install cross --git https://github.com/cross-rs/cross
+      - name: Log in to Docker
         run: |
-          REGISTRY="ghcr.io/${{ github.repository_owner }}"
+          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io --username ${DOCKER_USERNAME} --password-stdin
+      - name: Set up Docker builder
+        run: |
+          docker run --privileged --rm tonistiigi/binfmt --install arm64,amd64
+          docker buildx create --use --name cross-builder
+      - name: Build and push ${{ matrix.build.name }}
+        run: ${{ matrix.build.command }}
 
-          if [[ "${{ github.event_name }}" == "push" ]]; then
-            VERSION="${GITHUB_REF#refs/tags/}"
-            echo "targets=ethereum optimism" >> "$GITHUB_OUTPUT"
-
-            # Add 'latest' tag for non-RC releases
-            if [[ ! "$VERSION" =~ -rc ]]; then
-              echo "ethereum_tags=${REGISTRY}/reth:${VERSION},${REGISTRY}/reth:latest" >> "$GITHUB_OUTPUT"
-              echo "optimism_tags=${REGISTRY}/op-reth:${VERSION},${REGISTRY}/op-reth:latest" >> "$GITHUB_OUTPUT"
-            else
-              echo "ethereum_tags=${REGISTRY}/reth:${VERSION}" >> "$GITHUB_OUTPUT"
-              echo "optimism_tags=${REGISTRY}/op-reth:${VERSION}" >> "$GITHUB_OUTPUT"
-            fi
-
-          elif [[ "${{ github.event_name }}" == "schedule" ]] || [[ "${{ inputs.build_type }}" == "nightly" ]]; then
-            echo "targets=nightly" >> "$GITHUB_OUTPUT"
-            echo "ethereum_tags=${REGISTRY}/reth:nightly" >> "$GITHUB_OUTPUT"
-            echo "optimism_tags=${REGISTRY}/op-reth:nightly" >> "$GITHUB_OUTPUT"
-
-          else
-            # git-sha build
-            echo "targets=ethereum optimism" >> "$GITHUB_OUTPUT"
-            echo "ethereum_tags=${REGISTRY}/reth:${{ github.sha }}" >> "$GITHUB_OUTPUT"
-            echo "optimism_tags=${REGISTRY}/op-reth:${{ github.sha }}" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Build and push images
-        uses: depot/bake-action@v1
-        env:
-          VERGEN_GIT_SHA: ${{ steps.git.outputs.sha }}
-          VERGEN_GIT_DESCRIBE: ${{ steps.git.outputs.describe }}
-          VERGEN_GIT_DIRTY: ${{ steps.git.outputs.dirty }}
-          DEPOT_TOKEN: ${{ secrets.DEPOT_TOKEN }}
+  build:
+    if: ${{ !contains(github.ref, '-rc') }}
+    name: build and push as latest
+    runs-on: ubuntu-24.04
+    permissions:
+      packages: write
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        build:
+          - name: "Build and push reth image"
+            command: "make IMAGE_NAME=$IMAGE_NAME DOCKER_IMAGE_NAME=$DOCKER_IMAGE_NAME PROFILE=maxperf docker-build-push-latest"
+          - name: "Build and push op-reth image"
+            command: "make IMAGE_NAME=$OP_IMAGE_NAME DOCKER_IMAGE_NAME=$OP_DOCKER_IMAGE_NAME PROFILE=maxperf op-docker-build-push-latest"
+    steps:
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
         with:
-          project: ${{ vars.DEPOT_PROJECT_ID }}
-          files: docker-bake.hcl
-          targets: ${{ steps.params.outputs.targets }}
-          push: ${{ !(github.event_name == 'workflow_dispatch' && inputs.dry_run) }}
-          set: |
-            ethereum.tags=${{ steps.params.outputs.ethereum_tags }}
-            optimism.tags=${{ steps.params.outputs.optimism_tags }}
+          cache-on-failure: true
+      - name: Install cross main
+        id: cross_main
+        run: |
+          cargo install cross --git https://github.com/cross-rs/cross
+      - name: Log in to Docker
+        run: |
+          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io --username ${DOCKER_USERNAME} --password-stdin
+      - name: Set up Docker builder
+        run: |
+          docker run --privileged --rm tonistiigi/binfmt --install arm64,amd64
+          docker buildx create --use --name cross-builder
+      - name: Build and push ${{ matrix.build.name }}
+        run: ${{ matrix.build.command }}

.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

CLAUDE.md

@@ -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);

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace.package]
-version = "1.10.2"
+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.1"
+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.5.2"
+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.27.0", default-features = false }
+alloy-eip7928 = { version = "0.1.0", default-features = false }
+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.5.2", default-features = false }
-alloy-contract = { version = "1.5.2", default-features = false }
-alloy-eips = { version = "1.5.2", default-features = false }
-alloy-genesis = { version = "1.5.2", default-features = false }
-alloy-json-rpc = { version = "1.5.2", default-features = false }
-alloy-network = { version = "1.5.2", default-features = false }
-alloy-network-primitives = { version = "1.5.2", default-features = false }
-alloy-provider = { version = "1.5.2", features = ["reqwest", "debug-api"], default-features = false }
-alloy-pubsub = { version = "1.5.2", default-features = false }
-alloy-rpc-client = { version = "1.5.2", default-features = false }
-alloy-rpc-types = { version = "1.5.2", features = ["eth"], default-features = false }
-alloy-rpc-types-admin = { version = "1.5.2", default-features = false }
-alloy-rpc-types-anvil = { version = "1.5.2", default-features = false }
-alloy-rpc-types-beacon = { version = "1.5.2", default-features = false }
-alloy-rpc-types-debug = { version = "1.5.2", default-features = false }
-alloy-rpc-types-engine = { version = "1.5.2", default-features = false }
-alloy-rpc-types-eth = { version = "1.5.2", default-features = false }
-alloy-rpc-types-mev = { version = "1.5.2", default-features = false }
-alloy-rpc-types-trace = { version = "1.5.2", default-features = false }
-alloy-rpc-types-txpool = { version = "1.5.2", default-features = false }
-alloy-serde = { version = "1.5.2", default-features = false }
-alloy-signer = { version = "1.5.2", default-features = false }
-alloy-signer-local = { version = "1.5.2", default-features = false }
-alloy-transport = { version = "1.5.2" }
-alloy-transport-http = { version = "1.5.2", features = ["reqwest-rustls-tls"], default-features = false }
-alloy-transport-ipc = { version = "1.5.2", default-features = false }
-alloy-transport-ws = { version = "1.5.2", default-features = false }
+alloy-consensus = { version = "1.4.0", default-features = false }
+alloy-contract = { version = "1.4.0", default-features = false }
+alloy-eips = { version = "1.4.0", default-features = false }
+alloy-genesis = { version = "1.4.0", default-features = false }
+alloy-json-rpc = { version = "1.4.0", default-features = false }
+alloy-network = { version = "1.4.0", default-features = false }
+alloy-network-primitives = { version = "1.4.0", default-features = false }
+alloy-provider = { version = "1.4.0", features = ["reqwest", "debug-api"], default-features = false }
+alloy-pubsub = { version = "1.4.0", default-features = false }
+alloy-rpc-client = { version = "1.4.0", default-features = false }
+alloy-rpc-types = { version = "1.4.0", features = ["eth"], default-features = false }
+alloy-rpc-types-admin = { version = "1.4.0", default-features = false }
+alloy-rpc-types-anvil = { version = "1.4.0", default-features = false }
+alloy-rpc-types-beacon = { version = "1.4.0", default-features = false }
+alloy-rpc-types-debug = { version = "1.4.0", default-features = false }
+alloy-rpc-types-engine = { version = "1.4.0", default-features = false }
+alloy-rpc-types-eth = { version = "1.4.0", default-features = false }
+alloy-rpc-types-mev = { version = "1.4.0", default-features = false }
+alloy-rpc-types-trace = { version = "1.4.0", default-features = false }
+alloy-rpc-types-txpool = { version = "1.4.0", default-features = false }
+alloy-serde = { version = "1.4.0", default-features = false }
+alloy-signer = { version = "1.4.0", default-features = false }
+alloy-signer-local = { version = "1.4.0", default-features = false }
+alloy-transport = { version = "1.4.0" }
+alloy-transport-http = { version = "1.4.0", features = ["reqwest-rustls-tls"], default-features = false }
+alloy-transport-ipc = { version = "1.4.0", default-features = false }
+alloy-transport-ws = { version = "1.4.0", default-features = false }
 
 # op
-alloy-op-evm = { version = "0.27.0", 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 }
@@ -588,7 +588,7 @@ tracing-appender = "0.2"
 url = { version = "2.3", default-features = false }
 zstd = "0.13"
 byteorder = "1"
-fixed-cache = { version = "0.1.7", features = ["stats"] }
+mini-moka = "0.10"
 moka = "0.12"
 tar-no-std = { version = "0.3.2", default-features = false }
 miniz_oxide = { version = "0.8.4", default-features = false }
@@ -665,7 +665,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
@@ -739,42 +738,45 @@ 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]
-# 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" }
-# alloy-genesis = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-json-rpc = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-network = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-network-primitives = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-provider = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-pubsub = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-rpc-client = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-rpc-types = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-rpc-types-admin = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-rpc-types-anvil = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-rpc-types-beacon = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-rpc-types-debug = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-rpc-types-engine = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-rpc-types-eth = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-rpc-types-mev = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-rpc-types-trace = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-rpc-types-txpool = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-serde = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-signer = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-signer-local = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-transport = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-transport-http = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-transport-ipc = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
-# alloy-transport-ws = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
+alloy-consensus = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-consensus-any = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-contract = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-eips = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-genesis = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-json-rpc = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-network = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-network-primitives = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-provider = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-pubsub = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-rpc-client = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-rpc-types = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-rpc-types-admin = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-rpc-types-anvil = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-rpc-types-any = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-rpc-types-beacon = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-rpc-types-debug = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-rpc-types-engine = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-rpc-types-eth = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-rpc-types-mev = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-rpc-types-trace = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-rpc-types-txpool = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-serde = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-signer = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-signer-local = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-transport = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-transport-http = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-transport-ipc = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-transport-ws = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
+alloy-tx-macros = { git = "https://github.com/alloy-rs/alloy", rev = "82055ca44d660508a3614a1fb9acfd9ece2c24d7" }
 
 # op-alloy-consensus = { git = "https://github.com/alloy-rs/op-alloy", rev = "a79d6fc" }
 # op-alloy-network = { git = "https://github.com/alloy-rs/op-alloy", rev = "a79d6fc" }
@@ -790,10 +792,5 @@ ipnet = "2.11"
 # jsonrpsee-http-client = { git = "https://github.com/paradigmxyz/jsonrpsee", branch = "matt/make-rpc-service-pub" }
 # jsonrpsee-types = { git = "https://github.com/paradigmxyz/jsonrpsee", branch = "matt/make-rpc-service-pub" }
 
-# alloy-evm = { git = "https://github.com/alloy-rs/evm", rev = "df124c0" }
-# alloy-op-evm = { git = "https://github.com/alloy-rs/evm", rev = "df124c0" }
-
-# 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" }
+# alloy-evm = { git = "https://github.com/alloy-rs/evm", rev = "a69f0b45a6b0286e16072cb8399e02ce6ceca353" }
+# alloy-op-evm = { git = "https://github.com/alloy-rs/evm", rev = "a69f0b45a6b0286e16072cb8399e02ce6ceca353" }

Dockerfile.cross

@@ -0,0 +1,15 @@
+# This image is meant to enable cross-architecture builds.
+# It assumes the reth binary has already been compiled for `$TARGETPLATFORM` and is
+# locatable in `./dist/bin/$TARGETARCH`
+FROM --platform=$TARGETPLATFORM ubuntu:22.04
+
+LABEL org.opencontainers.image.source=https://github.com/paradigmxyz/reth
+LABEL org.opencontainers.image.licenses="MIT OR Apache-2.0"
+
+# Filled by docker buildx
+ARG TARGETARCH
+
+COPY ./dist/bin/$TARGETARCH/reth /usr/local/bin/reth
+
+EXPOSE 30303 30303/udp 9001 8545 8546
+ENTRYPOINT ["/usr/local/bin/reth"]

Dockerfile.depot

@@ -1,99 +0,0 @@
-# syntax=docker/dockerfile:1
-
-# Unified Dockerfile for reth and op-reth, optimized for Depot builds
-# Usage:
-#   reth:    --build-arg BINARY=reth
-#   op-reth: --build-arg BINARY=op-reth --build-arg MANIFEST_PATH=crates/optimism/bin
-
-FROM lukemathwalker/cargo-chef:latest-rust-1 AS chef
-WORKDIR /app
-
-LABEL org.opencontainers.image.source=https://github.com/paradigmxyz/reth
-LABEL org.opencontainers.image.licenses="MIT OR Apache-2.0"
-
-RUN apt-get update && apt-get install -y libclang-dev pkg-config
-
-# Install sccache for compilation caching
-RUN cargo install sccache --locked
-ENV RUSTC_WRAPPER=sccache
-ENV SCCACHE_DIR=/sccache
-ENV SCCACHE_WEBDAV_ENDPOINT=https://cache.depot.dev
-
-# Builds a cargo-chef plan
-FROM chef AS planner
-COPY --exclude=.git . .
-RUN cargo chef prepare --recipe-path recipe.json
-
-FROM chef AS builder
-COPY --from=planner /app/recipe.json recipe.json
-
-# Binary to build (reth or op-reth)
-ARG BINARY=reth
-
-# Manifest path for the binary
-ARG MANIFEST_PATH=bin/reth
-
-# Build profile, release by default
-ARG BUILD_PROFILE=release
-ENV BUILD_PROFILE=$BUILD_PROFILE
-
-# Extra Cargo flags
-ARG RUSTFLAGS=""
-ENV RUSTFLAGS="$RUSTFLAGS"
-
-# Extra Cargo features
-ARG FEATURES=""
-ENV FEATURES=$FEATURES
-
-# Git info for vergen (since .git is excluded from Docker context)
-ARG VERGEN_GIT_SHA=""
-ARG VERGEN_GIT_DESCRIBE=""
-ARG VERGEN_GIT_DIRTY="false"
-ENV VERGEN_GIT_SHA=$VERGEN_GIT_SHA
-ENV VERGEN_GIT_DESCRIBE=$VERGEN_GIT_DESCRIBE
-ENV VERGEN_GIT_DIRTY=$VERGEN_GIT_DIRTY
-
-# Build dependencies
-RUN --mount=type=secret,id=DEPOT_TOKEN,env=SCCACHE_WEBDAV_TOKEN \
-    --mount=type=cache,target=/usr/local/cargo/registry,sharing=shared \
-    --mount=type=cache,target=/usr/local/cargo/git,sharing=shared \
-    --mount=type=cache,target=$SCCACHE_DIR,sharing=shared \
-    cargo chef cook --profile $BUILD_PROFILE --features "$FEATURES" --locked --recipe-path recipe.json --manifest-path $MANIFEST_PATH/Cargo.toml
-
-# Build application
-COPY --exclude=.git . .
-RUN --mount=type=secret,id=DEPOT_TOKEN,env=SCCACHE_WEBDAV_TOKEN \
-    --mount=type=cache,target=/usr/local/cargo/registry,sharing=shared \
-    --mount=type=cache,target=/usr/local/cargo/git,sharing=shared \
-    --mount=type=cache,target=$SCCACHE_DIR,sharing=shared \
-    cargo build --profile $BUILD_PROFILE --features "$FEATURES" --locked --bin $BINARY --manifest-path $MANIFEST_PATH/Cargo.toml
-
-RUN sccache --show-stats || true
-
-# Copy binary to a known location (ARG not resolved in COPY)
-# Note: Custom profiles like maxperf/profiling output to target/<profile>/, not target/release/
-RUN cp /app/target/$BUILD_PROFILE/$BINARY /app/binary || \
-    cp /app/target/release/$BINARY /app/binary
-
-FROM ubuntu:24.04 AS runtime
-WORKDIR /app
-
-# Binary name for entrypoint
-ARG BINARY=reth
-
-# Install runtime dependencies
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends ca-certificates && \
-    rm -rf /var/lib/apt/lists/*
-
-# Copy binary from build stage and create canonical symlink for entrypoint
-COPY --from=builder /app/binary /usr/local/bin/
-RUN mv /usr/local/bin/binary /usr/local/bin/$BINARY && \
-    ln -s /usr/local/bin/$BINARY /usr/local/bin/reth-binary && \
-    chmod +x /usr/local/bin/$BINARY
-
-# Copy licenses
-COPY LICENSE-* ./
-
-EXPOSE 30303 30303/udp 9001 8545 8546
-ENTRYPOINT ["/usr/local/bin/reth-binary"]

DockerfileOp.cross

@@ -0,0 +1,15 @@
+# This image is meant to enable cross-architecture builds.
+# It assumes the reth binary has already been compiled for `$TARGETPLATFORM` and is
+# locatable in `./dist/bin/$TARGETARCH`
+FROM --platform=$TARGETPLATFORM ubuntu:22.04
+
+LABEL org.opencontainers.image.source=https://github.com/paradigmxyz/reth
+LABEL org.opencontainers.image.licenses="MIT OR Apache-2.0"
+
+# Filled by docker buildx
+ARG TARGETARCH
+
+COPY ./dist/bin/$TARGETARCH/op-reth /usr/local/bin/op-reth
+
+EXPOSE 30303 30303/udp 9001 8545 8546
+ENTRYPOINT ["/usr/local/bin/op-reth"]

Makefile

@@ -35,6 +35,9 @@ EEST_TESTS_TAG := v4.5.0
 EEST_TESTS_URL := https://github.com/ethereum/execution-spec-tests/releases/download/$(EEST_TESTS_TAG)/fixtures_stable.tar.gz
 EEST_TESTS_DIR := ./testing/ef-tests/execution-spec-tests
 
+# The docker image name
+DOCKER_IMAGE_NAME ?= ghcr.io/paradigmxyz/reth
+
 ##@ Help
 
 .PHONY: help
@@ -239,6 +242,137 @@ install-reth-bench: ## Build and install the reth binary under `$(CARGO_HOME)/bi
 		--features "$(FEATURES)" \
 		--profile "$(PROFILE)"
 
+##@ Docker
+
+# Note: This requires a buildx builder with emulation support. For example:
+#
+# `docker run --privileged --rm tonistiigi/binfmt --install amd64,arm64`
+# `docker buildx create --use --driver docker-container --name cross-builder`
+.PHONY: docker-build-push
+docker-build-push: ## Build and push a cross-arch Docker image tagged with the latest git tag.
+	$(call docker_build_push,$(GIT_TAG),$(GIT_TAG))
+
+# Note: This requires a buildx builder with emulation support. For example:
+#
+# `docker run --privileged --rm tonistiigi/binfmt --install amd64,arm64`
+# `docker buildx create --use --driver docker-container --name cross-builder`
+.PHONY: docker-build-push-git-sha
+docker-build-push-git-sha: ## Build and push a cross-arch Docker image tagged with the latest git sha.
+	$(call docker_build_push,$(GIT_SHA),$(GIT_SHA))
+
+# Note: This requires a buildx builder with emulation support. For example:
+#
+# `docker run --privileged --rm tonistiigi/binfmt --install amd64,arm64`
+# `docker buildx create --use --driver docker-container --name cross-builder`
+.PHONY: docker-build-push-latest
+docker-build-push-latest: ## Build and push a cross-arch Docker image tagged with the latest git tag and `latest`.
+	$(call docker_build_push,$(GIT_TAG),latest)
+
+# Note: This requires a buildx builder with emulation support. For example:
+#
+# `docker run --privileged --rm tonistiigi/binfmt --install amd64,arm64`
+# `docker buildx create --use --name cross-builder`
+.PHONY: docker-build-push-nightly
+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
+	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
+	mkdir -p $(BIN_DIR)/arm64
+	cp $(CARGO_TARGET_DIR)/aarch64-unknown-linux-gnu/$(PROFILE)/reth $(BIN_DIR)/arm64/reth
+
+	docker buildx build --file ./Dockerfile.cross . \
+		--platform linux/amd64,linux/arm64 \
+		--tag $(DOCKER_IMAGE_NAME):$(1) \
+		--tag $(DOCKER_IMAGE_NAME):$(2) \
+		--provenance=false \
+		--push
+endef
+
+##@ Optimism docker
+
+# Note: This requires a buildx builder with emulation support. For example:
+#
+# `docker run --privileged --rm tonistiigi/binfmt --install amd64,arm64`
+# `docker buildx create --use --driver docker-container --name cross-builder`
+.PHONY: op-docker-build-push
+op-docker-build-push: ## Build and push a cross-arch Docker image tagged with the latest git tag.
+	$(call op_docker_build_push,$(GIT_TAG),$(GIT_TAG))
+
+# Note: This requires a buildx builder with emulation support. For example:
+#
+# `docker run --privileged --rm tonistiigi/binfmt --install amd64,arm64`
+# `docker buildx create --use --driver docker-container --name cross-builder`
+.PHONY: op-docker-build-push-git-sha
+op-docker-build-push-git-sha: ## Build and push a cross-arch Docker image tagged with the latest git sha.
+	$(call op_docker_build_push,$(GIT_SHA),$(GIT_SHA))
+
+# Note: This requires a buildx builder with emulation support. For example:
+#
+# `docker run --privileged --rm tonistiigi/binfmt --install amd64,arm64`
+# `docker buildx create --use --driver docker-container --name cross-builder`
+.PHONY: op-docker-build-push-latest
+op-docker-build-push-latest: ## Build and push a cross-arch Docker image tagged with the latest git tag and `latest`.
+	$(call op_docker_build_push,$(GIT_TAG),latest)
+
+# Note: This requires a buildx builder with emulation support. For example:
+#
+# `docker run --privileged --rm tonistiigi/binfmt --install amd64,arm64`
+# `docker buildx create --use --name cross-builder`
+.PHONY: op-docker-build-push-nightly
+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`
+# `docker buildx create --use --name cross-builder`
+.PHONY: docker-build-push-nightly-profiling
+docker-build-push-nightly-profiling: ## Build and push cross-arch Docker image with profiling profile tagged with nightly-profiling.
+	$(call docker_build_push,nightly-profiling,nightly-profiling)
+
+	# Note: This requires a buildx builder with emulation support. For example:
+#
+# `docker run --privileged --rm tonistiigi/binfmt --install amd64,arm64`
+# `docker buildx create --use --name cross-builder`
+.PHONY: op-docker-build-push-nightly-profiling
+op-docker-build-push-nightly-profiling: ## 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-profiling,nightly-profiling)
+
+
+# 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
+	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
+	mkdir -p $(BIN_DIR)/arm64
+	cp $(CARGO_TARGET_DIR)/aarch64-unknown-linux-gnu/$(PROFILE)/op-reth $(BIN_DIR)/arm64/op-reth
+
+	docker buildx build --file ./DockerfileOp.cross . \
+		--platform linux/amd64,linux/arm64 \
+		--tag $(DOCKER_IMAGE_NAME):$(1) \
+		--tag $(DOCKER_IMAGE_NAME):$(2) \
+		--provenance=false \
+		--push
+endef
+
 ##@ Other
 
 .PHONY: clean

analyze_pinned_thread.py

@@ -0,0 +1,27 @@
+from playwright.sync_api import sync_playwright
+import time
+
+# The pinned thread URL - switch to call tree view
+BASE_URL = "https://profiler.firefox.com/public/q0h10v5sjtqstm2sj90azpzxpmhjd8r3agnx058"
+CALL_TREE_URL = BASE_URL + "/calltree/?globalTrackOrder=201&hiddenGlobalTracks=01&hiddenLocalTracksByPid=1153071.2-0wh~1153071.1-xgwxiz7z9wA5A7wAp&localTrackOrderByPid=1153071.1-xhxiz7z9wA5A7wApz8xjwz1Di0wxfz2wz6A6AqAswDfArDgDhxg&range=19841m4475&symbolServer=http%3A%2F%2F127.0.0.1%3A3001%2F24w2lg79pyph7f2pbcpqnhsfk1rrhp6yl4pr074&thread=E5&v=12"
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    page = browser.new_page()
+    
+    print(f"Loading: {CALL_TREE_URL}")
+    page.goto(CALL_TREE_URL, timeout=60000)
+    page.wait_for_load_state('networkidle')
+    time.sleep(8)  # Extra time for profile to load
+    
+    page.screenshot(path='/tmp/pinned_thread_calltree.png', full_page=True)
+    print("Screenshot saved to /tmp/pinned_thread_calltree.png")
+    
+    # Get the full page text
+    body_text = page.locator('body').inner_text()
+    print("\n" + "="*80)
+    print("FULL PAGE TEXT:")
+    print("="*80)
+    print(body_text[:8000])
+    
+    browser.close()

analyze_profiler.py

@@ -0,0 +1,59 @@
+from playwright.sync_api import sync_playwright
+import time
+
+URLS = {
+    "slow_block_main": "https://share.firefox.dev/45a9S1G",
+    "normal_blocks": "https://share.firefox.dev/4j7tadO",
+    "pinned_thread": "https://share.firefox.dev/3LylcxY",
+    "proof_fetch_tasks": "https://share.firefox.dev/4pAZyac",
+}
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    
+    for name, url in URLS.items():
+        print(f"\n{'='*60}")
+        print(f"PROFILE: {name}")
+        print(f"URL: {url}")
+        print('='*60)
+        
+        page = browser.new_page()
+        page.goto(url, timeout=60000)
+        
+        # Wait for the profiler to fully load
+        page.wait_for_load_state('networkidle')
+        time.sleep(5)  # Extra time for JS rendering
+        
+        # Get the final URL (profiler redirects)
+        final_url = page.url
+        print(f"Final URL: {final_url}")
+        
+        # Take a screenshot
+        page.screenshot(path=f'/tmp/{name}.png', full_page=True)
+        print(f"Screenshot saved to /tmp/{name}.png")
+        
+        # Try to extract call tree content
+        try:
+            # Look for the call tree table
+            call_tree = page.locator('.treeView, .call-tree, [class*="CallTree"], [class*="callTree"]').first
+            if call_tree:
+                text = call_tree.inner_text()
+                print(f"\nCall Tree Content (first 3000 chars):\n{text[:3000]}")
+        except Exception as e:
+            print(f"Could not extract call tree: {e}")
+        
+        # Get visible text content
+        try:
+            body_text = page.locator('body').inner_text()
+            # Filter for relevant content
+            lines = body_text.split('\n')
+            relevant = [l for l in lines if any(kw in l.lower() for kw in 
+                ['%', 'reth', 'proof', 'trie', 'hash', 'fetch', 'state', 'root', 
+                 'rayon', 'tokio', 'engine', 'execute', 'sload', 'journal'])]
+            print(f"\nRelevant lines:\n" + '\n'.join(relevant[:100]))
+        except Exception as e:
+            print(f"Could not extract body: {e}")
+        
+        page.close()
+    
+    browser.close()

bin/reth-bench-compare/src/cli.rs

@@ -147,11 +147,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,
 
@@ -583,11 +578,7 @@ 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(&mut node_process).await?;
     info!("Warmup node is ready at tip: {}", current_tip);
 
     // Clear filesystem caches before warmup run only (unless disabled)
@@ -641,11 +632,7 @@ async fn run_benchmark_workflow(
     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?
-    };
+    let starting_tip = 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?;
 
@@ -712,11 +699,7 @@ 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(&mut node_process).await?;
         info!("Node is ready at tip: {}", current_tip);
 
         // Calculate benchmark range

bin/reth-bench-compare/src/node.rs

@@ -163,7 +163,6 @@ impl NodeManager {
             "eth,reth".to_string(),
             "--disable-discovery".to_string(),
             "--trusted-only".to_string(),
-            "--disable-tx-gossip".to_string(),
         ]);
 
         // Add tracing arguments if OTLP endpoint is configured
@@ -459,76 +458,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")?;

bin/reth-bench/Cargo.toml

@@ -32,7 +32,7 @@ alloy-eips.workspace = true
 alloy-json-rpc.workspace = true
 alloy-consensus.workspace = true
 alloy-network.workspace = true
-alloy-primitives = { workspace = true, features = ["rand"] }
+alloy-primitives.workspace = true
 alloy-provider = { workspace = true, features = ["engine-api", "pubsub", "reqwest-rustls-tls"], default-features = false }
 alloy-pubsub.workspace = true
 alloy-rpc-client = { workspace = true, features = ["pubsub"] }

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

@@ -3,8 +3,10 @@
 use crate::{
     authenticated_transport::AuthenticatedTransportConnect,
     bench::{
-        helpers::{build_payload, parse_gas_limit, prepare_payload_request, rpc_block_to_header},
-        output::GasRampPayloadFile,
+        helpers::{build_payload, prepare_payload_request, rpc_block_to_header},
+        output::{
+            write_benchmark_results, CombinedResult, NewPayloadResult, TotalGasOutput, TotalGasRow,
+        },
     },
     valid_payload::{call_forkchoice_updated, call_new_payload, payload_to_new_payload},
 };
@@ -15,26 +17,19 @@ use alloy_rpc_types_engine::{ExecutionPayload, ForkchoiceState, JwtSecret};
 
 use clap::Parser;
 use reqwest::Url;
-use reth_chainspec::ChainSpec;
+use reth_chainspec::{ChainSpec, NamedChain, DEV, HOLESKY, HOODI, MAINNET, SEPOLIA};
 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;
+use std::{path::PathBuf, sync::Arc, time::Instant};
+use tracing::{debug, info};
 
 /// `reth benchmark gas-limit-ramp` command.
 #[derive(Debug, Parser)]
 pub struct Command {
-    /// Number of blocks to generate. Mutually exclusive with --target-gas-limit.
-    #[arg(long, value_name = "BLOCKS", conflicts_with = "target_gas_limit")]
-    blocks: Option<u64>,
-
-    /// Target gas limit to ramp up to. The benchmark will generate blocks until the gas limit
-    /// reaches or exceeds this value. Mutually exclusive with --blocks.
-    /// Accepts short notation: K for thousand, M for million, G for billion (e.g., 2G = 2
-    /// billion).
-    #[arg(long, value_name = "TARGET_GAS_LIMIT", conflicts_with = "blocks", value_parser = parse_gas_limit)]
-    target_gas_limit: Option<u64>,
+    /// 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")]
@@ -44,50 +39,39 @@ pub struct Command {
     #[arg(long = "jwt-secret", value_name = "JWT_SECRET")]
     jwt_secret: PathBuf,
 
-    /// Output directory for benchmark results and generated payloads.
+    /// Optional output directory for benchmark results.
     #[arg(long, value_name = "OUTPUT")]
-    output: PathBuf,
+    output: Option<PathBuf>,
 }
 
-/// Mode for determining when to stop ramping.
-#[derive(Debug, Clone, Copy)]
-enum RampMode {
-    /// Ramp for a fixed number of blocks.
-    Blocks(u64),
-    /// Ramp until reaching or exceeding target gas limit.
-    TargetGasLimit(u64),
+/// Map a chain ID to a known chain spec.
+fn chain_spec_from_id(chain_id: u64) -> Option<Arc<ChainSpec>> {
+    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 Command {
     /// Execute `benchmark gas-limit-ramp` command.
     pub async fn execute(self, _ctx: CliContext) -> eyre::Result<()> {
-        let mode = match (self.blocks, self.target_gas_limit) {
-            (Some(blocks), None) => {
-                if blocks == 0 {
-                    return Err(eyre::eyre!("--blocks must be greater than 0"));
-                }
-                RampMode::Blocks(blocks)
-            }
-            (None, Some(target)) => {
-                if target == 0 {
-                    return Err(eyre::eyre!("--target-gas-limit must be greater than 0"));
-                }
-                RampMode::TargetGasLimit(target)
-            }
-            _ => {
-                return Err(eyre::eyre!(
-                    "Exactly one of --blocks or --target-gas-limit must be specified"
-                ));
-            }
-        };
+        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);
+        if let Some(ref output) = self.output {
+            if output.is_file() {
+                return Err(eyre::eyre!("Output path must be a directory"));
+            }
+            if !output.exists() {
+                std::fs::create_dir_all(output)?;
+                info!("Created output directory: {:?}", output);
+            }
         }
 
         // Set up authenticated provider (used for both Engine API and eth_ methods)
@@ -102,7 +86,7 @@ impl Command {
 
         // Get chain spec - required for fork detection
         let chain_id = provider.get_chain_id().await?;
-        let chain_spec = ChainSpec::from_chain_id(chain_id)
+        let chain_spec = chain_spec_from_id(chain_id)
             .ok_or_else(|| eyre::eyre!("Unsupported chain id: {chain_id}"))?;
 
         // Fetch the current head block as parent
@@ -112,35 +96,22 @@ impl Command {
             .await?
             .ok_or_else(|| eyre::eyre!("Failed to fetch latest block"))?;
 
+        debug!(?parent_block, "Raw RPC parent 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 start_block = parent_header.number + 1;
+        let end_block = start_block + self.blocks - 1;
 
-        match mode {
-            RampMode::Blocks(blocks) => {
-                info!(
-                    canonical_parent,
-                    start_block,
-                    end_block = start_block + blocks - 1,
-                    "Starting gas limit ramp benchmark (block count mode)"
-                );
-            }
-            RampMode::TargetGasLimit(target) => {
-                info!(
-                    canonical_parent,
-                    start_block,
-                    current_gas_limit = parent_header.gas_limit,
-                    target_gas_limit = target,
-                    "Starting gas limit ramp benchmark (target gas limit mode)"
-                );
-            }
-        }
+        debug!(?parent_header, "Converted parent header");
 
-        let mut blocks_processed = 0u64;
+        info!(start_block, end_block, "Starting gas limit ramp benchmark");
+
+        let mut next_block_number = start_block;
+        let mut results = Vec::new();
         let total_benchmark_duration = Instant::now();
 
-        while !should_stop(mode, blocks_processed, parent_header.gas_limit) {
+        while next_block_number <= end_block {
             let timestamp = parent_header.timestamp.saturating_add(1);
 
             let request = prepare_payload_request(&chain_spec, timestamp, parent_hash);
@@ -152,8 +123,7 @@ impl Command {
                 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);
+            let gas_limit = next_gas_limit(parent_header.gas_limit, max_increase);
 
             block.header.gas_limit = gas_limit;
 
@@ -169,17 +139,20 @@ impl Command {
                 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");
+            debug!(
+                target: "reth-bench",
+                block_number = block.header.number,
+                gas_limit,
+                max_increase,
+                "Sending empty payload"
+            );
 
+            let start = Instant::now();
             call_new_payload(&provider, version, params).await?;
 
+            let new_payload_result =
+                NewPayloadResult { gas_used: block.header.gas_used, latency: start.elapsed() };
+
             let forkchoice_state = ForkchoiceState {
                 head_block_hash: block_hash,
                 safe_block_hash: block_hash,
@@ -187,17 +160,51 @@ impl Command {
             };
             call_forkchoice_updated(&provider, version, forkchoice_state, None).await?;
 
+            let total_latency = start.elapsed();
+            let fcu_latency = total_latency - new_payload_result.latency;
+            let transaction_count = block.body.transactions.len() as u64;
+            let combined_result = CombinedResult {
+                block_number: block.header.number,
+                gas_limit,
+                transaction_count,
+                new_payload_result,
+                fcu_latency,
+                total_latency,
+            };
+
+            info!(%combined_result);
+
+            let gas_row = TotalGasRow {
+                block_number: block.header.number,
+                transaction_count,
+                gas_used: block.header.gas_used,
+                time: total_benchmark_duration.elapsed(),
+            };
+            results.push((gas_row, combined_result));
+
             parent_header = block.header;
             parent_hash = block_hash;
-            blocks_processed += 1;
+
+            debug!(?parent_header, "RPC parent header");
+            next_block_number += 1;
+        }
+
+        let (gas_output_results, combined_results): (Vec<TotalGasRow>, Vec<CombinedResult>) =
+            results.into_iter().unzip();
+
+        if let Some(ref path) = self.output {
+            write_benchmark_results(path, &gas_output_results, combined_results)?;
         }
 
         let final_gas_limit = parent_header.gas_limit;
+        let gas_output = TotalGasOutput::new(gas_output_results)?;
         info!(
-            total_duration=?total_benchmark_duration.elapsed(),
-            blocks_processed,
+            total_duration=?gas_output.total_duration,
+            total_gas_used=?gas_output.total_gas_used,
+            blocks_processed=?gas_output.blocks_processed,
             final_gas_limit,
-            "Benchmark complete"
+            "Total Ggas/s: {:.4}",
+            gas_output.total_gigagas_per_second()
         );
 
         Ok(())
@@ -208,9 +215,6 @@ const fn max_gas_limit_increase(parent_gas_limit: u64) -> u64 {
     (parent_gas_limit / GAS_LIMIT_BOUND_DIVISOR).saturating_sub(1)
 }
 
-const fn should_stop(mode: RampMode, blocks_processed: u64, current_gas_limit: u64) -> bool {
-    match mode {
-        RampMode::Blocks(target_blocks) => blocks_processed >= target_blocks,
-        RampMode::TargetGasLimit(target) => current_gas_limit >= target,
-    }
+fn next_gas_limit(parent_gas_limit: u64, max_increase: u64) -> u64 {
+    parent_gas_limit.saturating_add(max_increase).min(MAXIMUM_GAS_LIMIT_BLOCK)
 }

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

@@ -1,11 +1,10 @@
 //! 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.
+//! large block using the `testing_packBlock` RPC endpoint.
 
-use crate::{
-    authenticated_transport::AuthenticatedTransportConnect, bench::helpers::parse_gas_limit,
-};
+use crate::authenticated_transport::AuthenticatedTransportConnect;
+use alloy_consensus::Transaction;
 use alloy_eips::{BlockNumberOrTag, Typed2718};
 use alloy_primitives::{Bytes, B256};
 use alloy_provider::{ext::EngineApi, network::AnyNetwork, Provider, RootProvider};
@@ -22,13 +21,13 @@ use reth_cli_runner::CliContext;
 use reth_rpc_api::TestingBuildBlockRequestV1;
 use std::future::Future;
 use tokio::sync::mpsc;
-use tracing::{info, warn};
+use tracing::{debug, info, warn};
 
-/// A single transaction with its gas used and raw encoded bytes.
+/// A single transaction with its gas limit and raw encoded bytes.
 #[derive(Debug, Clone)]
 pub struct RawTransaction {
-    /// The actual gas used by the transaction (from receipt).
-    pub gas_used: u64,
+    /// The gas limit of the transaction.
+    pub gas_limit: u64,
     /// The transaction type (e.g., 3 for EIP-4844 blob txs).
     pub tx_type: u8,
     /// The raw RLP-encoded transaction bytes.
@@ -57,7 +56,7 @@ pub struct RpcTransactionSource {
 
 impl RpcTransactionSource {
     /// Create a new RPC transaction source.
-    pub const fn new(provider: RootProvider<AnyNetwork>) -> Self {
+    pub fn new(provider: RootProvider<AnyNetwork>) -> Self {
         Self { provider }
     }
 
@@ -76,47 +75,31 @@ impl TransactionSource for RpcTransactionSource {
         &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 block = self.provider.get_block_by_number(block_number.into()).full().await?;
 
         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
+        let gas_used = block.header.gas_used;
+        let transactions = 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;
-
+            .map(|tx| {
                 let with_encoded = tx.inner.inner.clone().into_encoded();
                 RawTransaction {
-                    gas_used,
+                    gas_limit: tx.gas_limit(),
                     tx_type: tx.inner.ty(),
                     raw: with_encoded.encoded_bytes().clone(),
                 }
             })
             .collect();
 
-        Ok(Some((transactions, block_gas_used)))
+        Ok(Some((transactions, gas_used)))
     }
 }
 
-/// Collects transactions from a source up to a target gas usage.
+/// Collects transactions from a source up to a target gas limit.
 #[derive(Debug)]
 pub struct TransactionCollector<S> {
     source: S,
@@ -125,35 +108,53 @@ pub struct TransactionCollector<S> {
 
 impl<S: TransactionSource> TransactionCollector<S> {
     /// Create a new transaction collector.
-    pub const fn new(source: S, target_gas: u64) -> Self {
+    pub 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.
+    /// Returns the collected raw transaction bytes, total gas collected, 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;
 
+        info!(start_block = start_block, "Fetching transactions from blocks");
+
         while total_gas < self.target_gas {
-            let Some((block_txs, _)) = self.source.fetch_block_transactions(current_block).await?
+            info!(
+                block = current_block,
+                total_gas = total_gas,
+                target_gas = self.target_gas,
+                progress_pct = (total_gas as f64 / self.target_gas as f64 * 100.0) as u32,
+                "Fetching block"
+            );
+
+            let Some((block_txs, block_gas_used)) =
+                self.source.fetch_block_transactions(current_block).await?
             else {
                 warn!(block = current_block, "Block not found, stopping");
                 break;
             };
 
+            let block_tx_count = block_txs.len();
+            let mut block_gas_added: u64 = 0;
+            let mut block_txs_added: usize = 0;
+
             for tx in block_txs {
                 // Skip blob transactions (EIP-4844, type 3)
                 if tx.tx_type == 3 {
+                    debug!("Skipping blob transaction");
                     continue;
                 }
 
-                if total_gas + tx.gas_used <= self.target_gas {
+                if total_gas + tx.gas_limit <= self.target_gas {
                     transactions.push(tx.raw);
-                    total_gas += tx.gas_used;
+                    total_gas += tx.gas_limit;
+                    block_gas_added += tx.gas_limit;
+                    block_txs_added += 1;
                 }
 
                 if total_gas >= self.target_gas {
@@ -161,18 +162,30 @@ impl<S: TransactionSource> TransactionCollector<S> {
                 }
             }
 
+            info!(
+                block = current_block,
+                block_txs = block_tx_count,
+                block_gas_used = block_gas_used,
+                added_txs = block_txs_added,
+                added_gas = block_gas_added,
+                total_txs = transactions.len(),
+                total_gas = total_gas,
+                "Processed block"
+            );
+
             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 {
+                info!(remaining_gas = remaining_gas, "Stopping: within 1M of target gas");
                 break;
             }
         }
 
         info!(
             total_txs = transactions.len(),
-            total_gas,
+            total_gas = total_gas,
             next_block = current_block,
             "Finished collecting transactions"
         );
@@ -184,7 +197,7 @@ impl<S: TransactionSource> TransactionCollector<S> {
 /// `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.
+/// into a single block using the `testing_packBlock` RPC endpoint.
 #[derive(Debug, Parser)]
 pub struct Command {
     /// The RPC URL to use for fetching blocks (can be an external archive node).
@@ -195,7 +208,7 @@ pub struct Command {
     #[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).
+    /// The RPC URL for testing_packBlock calls (same node as engine, regular RPC port).
     #[arg(long, value_name = "TESTING_RPC_URL", default_value = "http://localhost:8545")]
     testing_rpc_url: String,
 
@@ -204,26 +217,13 @@ pub struct Command {
     jwt_secret: std::path::PathBuf,
 
     /// Target gas to pack into the block.
-    /// Accepts short notation: K for thousand, M for million, G for billion (e.g., 1G = 1
-    /// billion).
-    #[arg(long, value_name = "TARGET_GAS", default_value = "30000000", value_parser = parse_gas_limit)]
+    #[arg(long, value_name = "TARGET_GAS", default_value = "30000000")]
     target_gas: u64,
 
-    /// Block number to start fetching transactions from (required).
-    ///
-    /// This must be the last canonical block BEFORE any gas limit ramping was performed.
-    /// The command collects transactions from historical blocks starting at this number
-    /// to pack into large blocks.
-    ///
-    /// How to determine this value:
-    /// - If starting from a fresh node (no gas limit ramp yet): use the current chain tip
-    /// - If gas limit ramping has already been performed: use the block number that was the chain
-    ///   tip BEFORE ramping began (you must track this yourself)
-    ///
-    /// Using a block after ramping started will cause transaction collection to fail
-    /// because those blocks contain synthetic transactions that cannot be replayed.
+    /// 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: u64,
+    from_block: Option<u64>,
 
     /// Execute the payload (call newPayload + forkchoiceUpdated).
     /// If false, only builds the payload and prints it.
@@ -231,8 +231,6 @@ pub struct Command {
     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,
 
@@ -241,14 +239,14 @@ pub struct Command {
     #[arg(long, default_value = "4")]
     prefetch_buffer: usize,
 
-    /// Output directory for generated payloads. Each payload is saved as `payload_block_N.json`.
+    /// Output directory for generated payloads. Each payload is saved as payload_NNN.json.
     #[arg(long, value_name = "OUTPUT_DIR")]
     output_dir: std::path::PathBuf,
 }
 
 /// A built payload ready for execution.
 struct BuiltPayload {
-    block_number: u64,
+    index: u64,
     envelope: ExecutionPayloadEnvelopeV4,
     block_hash: B256,
     timestamp: u64,
@@ -270,7 +268,7 @@ impl Command {
         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)
+        // Set up testing RPC provider (for testing_packBlock)
         info!("Connecting to Testing RPC at {}", self.testing_rpc_url);
         let testing_client = ClientBuilder::default()
             .layer(RetryBackoffLayer::new(10, 800, u64::MAX))
@@ -299,7 +297,7 @@ impl Command {
             format!("Failed to create output directory: {:?}", self.output_dir)
         })?;
 
-        let start_block = self.from_block;
+        let start_block = self.from_block.unwrap_or(parent_number);
 
         // Use pipelined execution when generating multiple payloads
         if self.count > 1 {
@@ -350,7 +348,7 @@ impl Command {
                 total = self.count,
                 parent_hash = %parent_hash,
                 parent_timestamp = parent_timestamp,
-                "Building payload via testing_buildBlockV1"
+                "Building payload via testing_packBlock"
             );
 
             let built = self
@@ -363,6 +361,9 @@ impl Command {
                 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");
+
+                // Small delay to allow in-memory state to propagate before building next payload
+                tokio::time::sleep(std::time::Duration::from_millis(50)).await;
             }
 
             parent_hash = built.block_hash;
@@ -401,14 +402,20 @@ impl Command {
             let mut current_block = start_block;
 
             for payload_idx in 0..count {
+                info!(
+                    payload = payload_idx + 1,
+                    start_block = current_block,
+                    "Fetching transactions for payload"
+                );
+
                 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"
+                            total_gas = total_gas,
+                            next_block = next_block,
+                            "Fetched transactions for payload"
                         );
                         current_block = next_block;
 
@@ -451,7 +458,7 @@ impl Command {
                     parent_hash = %parent_hash,
                     parent_timestamp = parent_timestamp,
                     tx_count = transactions.len(),
-                    "Building payload via testing_buildBlockV1"
+                    "Building payload via testing_packBlock"
                 );
                 self.build_payload(
                     testing_provider,
@@ -473,6 +480,9 @@ impl Command {
             self.execute_payload_v4(auth_provider, current_payload.envelope, parent_hash).await?;
             info!(payload = i + 1, "Payload executed successfully");
 
+            // Small delay to allow in-memory state to propagate before building next payload
+            tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+
             // 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)
@@ -496,7 +506,7 @@ impl Command {
                         parent_hash = %current_block_hash,
                         parent_timestamp = current_timestamp,
                         tx_count = next_transactions.len(),
-                        "Building payload via testing_buildBlockV1"
+                        "Building payload via testing_packBlock"
                     );
 
                     Self::build_payload_static(
@@ -521,7 +531,7 @@ impl Command {
         Ok(())
     }
 
-    /// Build a single payload via `testing_buildBlockV1`.
+    /// Build a single payload via testing_packBlock.
     async fn build_payload(
         &self,
         testing_provider: &RootProvider<AnyNetwork>,
@@ -561,35 +571,35 @@ impl Command {
             extra_data: None,
         };
 
-        let total_tx_bytes: usize = transactions.iter().map(|tx| tx.len()).sum();
         info!(
+            endpoint = "testing",
+            method = "testing_packBlock",
             payload = index + 1,
-            tx_count = transactions.len(),
-            total_tx_bytes = total_tx_bytes,
             parent_hash = %parent_hash,
-            "Sending to testing_buildBlockV1"
+            "RPC call"
         );
         let envelope: ExecutionPayloadEnvelopeV5 =
-            testing_provider.client().request("testing_buildBlockV1", [request]).await?;
+            testing_provider.client().request("testing_packBlock", [request]).await?;
+        info!(payload = index + 1, "testing_packBlock response received, converting to V4 envelope");
 
         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;
+        let block_hash =
+            v4_envelope.envelope_inner.execution_payload.payload_inner.payload_inner.block_hash;
+        let timestamp =
+            v4_envelope.envelope_inner.execution_payload.payload_inner.payload_inner.timestamp;
 
-        Ok(BuiltPayload { block_number, envelope: v4_envelope, block_hash, timestamp })
+        Ok(BuiltPayload { index, 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 filename = format!("payload_{:03}.json", payload.index + 1);
         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");
+        info!(payload = payload.index + 1, block_hash = %payload.block_hash, path = %filepath.display(), "Payload saved");
         Ok(())
     }
 
@@ -602,6 +612,13 @@ impl Command {
         let block_hash =
             envelope.envelope_inner.execution_payload.payload_inner.payload_inner.block_hash;
 
+        info!(
+            endpoint = "engine",
+            method = "engine_newPayloadV4",
+            block_hash = %block_hash,
+            "RPC call"
+        );
+
         let status = provider
             .new_payload_v4(
                 envelope.envelope_inner.execution_payload,
@@ -611,6 +628,8 @@ impl Command {
             )
             .await?;
 
+        info!(endpoint = "engine", method = "engine_newPayloadV4", ?status, "RPC response");
+
         if !status.is_valid() {
             return Err(eyre::eyre!("Payload rejected: {:?}", status));
         }
@@ -621,11 +640,18 @@ impl Command {
             finalized_block_hash: parent_hash,
         };
 
+        info!(
+            endpoint = "engine",
+            method = "engine_forkchoiceUpdatedV3",
+            head = %block_hash,
+            safe = %parent_hash,
+            finalized = %parent_hash,
+            "RPC call"
+        );
+
         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));
-        }
+        info!(endpoint = "engine", method = "engine_forkchoiceUpdatedV3", ?fcu_result, "RPC response");
 
         Ok(())
     }

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

@@ -1,29 +1,6 @@
 //! Common helpers for reth-bench commands.
 
 use crate::valid_payload::call_forkchoice_updated;
-
-/// Parses a gas limit value with optional suffix: K for thousand, M for million, G for billion.
-///
-/// Examples: "30000000", "30M", "1G", "2G"
-pub(crate) fn parse_gas_limit(s: &str) -> eyre::Result<u64> {
-    let s = s.trim();
-    if s.is_empty() {
-        return Err(eyre::eyre!("empty value"));
-    }
-
-    let (num_str, multiplier) = if let Some(prefix) = s.strip_suffix(['G', 'g']) {
-        (prefix, 1_000_000_000u64)
-    } else if let Some(prefix) = s.strip_suffix(['M', 'm']) {
-        (prefix, 1_000_000u64)
-    } else if let Some(prefix) = s.strip_suffix(['K', 'k']) {
-        (prefix, 1_000u64)
-    } else {
-        (s, 1u64)
-    };
-
-    let base: u64 = num_str.trim().parse()?;
-    base.checked_mul(multiplier).ok_or_else(|| eyre::eyre!("value overflow"))
-}
 use alloy_consensus::Header;
 use alloy_eips::eip4844::kzg_to_versioned_hash;
 use alloy_primitives::{Address, B256};
@@ -153,7 +130,21 @@ pub(crate) async fn get_payload_with_sidecar(
     payload_id: PayloadId,
     parent_beacon_block_root: Option<B256>,
 ) -> eyre::Result<(ExecutionPayload, ExecutionPayloadSidecar)> {
-    debug!(get_payload_version = ?version, ?payload_id, "Sending getPayload");
+    let method = match version {
+        1 => "engine_getPayloadV1",
+        2 => "engine_getPayloadV2",
+        3 => "engine_getPayloadV3",
+        4 => "engine_getPayloadV4",
+        5 => "engine_getPayloadV5",
+        _ => return Err(eyre::eyre!("Unsupported getPayload version: {}", version)),
+    };
+
+    debug!(
+        target: "reth-bench",
+        method,
+        ?payload_id,
+        "Sending getPayload"
+    );
 
     match version {
         1 => {
@@ -200,7 +191,11 @@ pub(crate) async fn get_payload_with_sidecar(
         }
         5 => {
             // V5 (Osaka) - use raw request since alloy doesn't have get_payload_v5 yet
-            let envelope = provider.get_payload_v5(payload_id).await?;
+            use alloy_provider::Provider;
+            use alloy_rpc_types_engine::ExecutionPayloadEnvelopeV5;
+
+            let envelope: ExecutionPayloadEnvelopeV5 =
+                provider.client().request(method, (payload_id,)).await?;
             let versioned_hashes =
                 versioned_hashes_from_commitments(&envelope.blobs_bundle.commitments);
             let cancun_fields = CancunPayloadFields {
@@ -214,53 +209,6 @@ pub(crate) async fn get_payload_with_sidecar(
                 ExecutionPayloadSidecar::v4(cancun_fields, prague_fields),
             ))
         }
-        _ => panic!("This tool does not support getPayload versions past v5"),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_gas_limit_plain_number() {
-        assert_eq!(parse_gas_limit("30000000").unwrap(), 30_000_000);
-        assert_eq!(parse_gas_limit("1").unwrap(), 1);
-        assert_eq!(parse_gas_limit("0").unwrap(), 0);
-    }
-
-    #[test]
-    fn test_parse_gas_limit_k_suffix() {
-        assert_eq!(parse_gas_limit("1K").unwrap(), 1_000);
-        assert_eq!(parse_gas_limit("30k").unwrap(), 30_000);
-        assert_eq!(parse_gas_limit("100K").unwrap(), 100_000);
-    }
-
-    #[test]
-    fn test_parse_gas_limit_m_suffix() {
-        assert_eq!(parse_gas_limit("1M").unwrap(), 1_000_000);
-        assert_eq!(parse_gas_limit("30m").unwrap(), 30_000_000);
-        assert_eq!(parse_gas_limit("100M").unwrap(), 100_000_000);
-    }
-
-    #[test]
-    fn test_parse_gas_limit_g_suffix() {
-        assert_eq!(parse_gas_limit("1G").unwrap(), 1_000_000_000);
-        assert_eq!(parse_gas_limit("2g").unwrap(), 2_000_000_000);
-        assert_eq!(parse_gas_limit("10G").unwrap(), 10_000_000_000);
-    }
-
-    #[test]
-    fn test_parse_gas_limit_with_whitespace() {
-        assert_eq!(parse_gas_limit(" 1G ").unwrap(), 1_000_000_000);
-        assert_eq!(parse_gas_limit("2 M").unwrap(), 2_000_000);
-    }
-
-    #[test]
-    fn test_parse_gas_limit_errors() {
-        assert!(parse_gas_limit("").is_err());
-        assert!(parse_gas_limit("abc").is_err());
-        assert!(parse_gas_limit("G").is_err());
-        assert!(parse_gas_limit("-1G").is_err());
+        _ => unreachable!(),
     }
 }

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

@@ -16,7 +16,6 @@ mod new_payload_fcu;
 mod new_payload_only;
 mod output;
 mod replay_payloads;
-mod send_invalid_payload;
 mod send_payload;
 
 /// `reth bench` command
@@ -56,7 +55,7 @@ pub enum Subcommands {
     /// 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.
+    /// block using the `testing_packBlock` RPC endpoint.
     ///
     /// Example:
     ///
@@ -75,18 +74,6 @@ pub enum Subcommands {
     /// `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),
-
-    /// Generate and send an invalid `engine_newPayload` request for testing.
-    ///
-    /// Takes a valid block and modifies fields to make it invalid, allowing you to test
-    /// Engine API rejection behavior. Block hash is recalculated after modifications
-    /// unless `--invalid-block-hash` or `--skip-hash-recalc` is used.
-    ///
-    /// Example:
-    ///
-    /// `cast block latest --full --json | reth-bench send-invalid-payload --rpc-url localhost:5000
-    /// --jwt-secret $(cat ~/.local/share/reth/mainnet/jwt.hex) --invalid-state-root`
-    SendInvalidPayload(Box<send_invalid_payload::Command>),
 }
 
 impl BenchmarkCommand {
@@ -102,7 +89,6 @@ impl BenchmarkCommand {
             Subcommands::SendPayload(command) => command.execute(ctx).await,
             Subcommands::GenerateBigBlock(command) => command.execute(ctx).await,
             Subcommands::ReplayPayloads(command) => command.execute(ctx).await,
-            Subcommands::SendInvalidPayload(command) => (*command).execute(ctx).await,
         }
     }
 

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

@@ -97,7 +97,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)?;
 

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

@@ -1,11 +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 serde::{ser::SerializeStruct, Serialize};
 use std::{path::Path, time::Duration};
 use tracing::info;
 
@@ -18,17 +17,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)]
@@ -104,8 +92,9 @@ 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: {:?}",
+            "Block {} (gas_limit: {}) at {:.4} Ggas/s, used {} gas. Combined: {:.4} Ggas/s. fcu: {:?}, newPayload: {:?}",
             self.block_number,
+            self.gas_limit,
             self.new_payload_result.gas_per_second() / GIGAGAS as f64,
             self.new_payload_result.gas_used,
             self.combined_gas_per_second() / GIGAGAS as f64,

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

@@ -3,11 +3,7 @@
 //! 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 crate::authenticated_transport::AuthenticatedTransportConnect;
 use alloy_primitives::B256;
 use alloy_provider::{ext::EngineApi, network::AnyNetwork, Provider, RootProvider};
 use alloy_rpc_client::ClientBuilder;
@@ -16,7 +12,6 @@ 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};
 
@@ -34,7 +29,7 @@ pub struct Command {
     #[arg(long, value_name = "JWT_SECRET")]
     jwt_secret: PathBuf,
 
-    /// Directory containing payload files (`payload_block_N.json`).
+    /// Directory containing payload files (payload_001.json, payload_002.json, etc.).
     #[arg(long, value_name = "PAYLOAD_DIR")]
     payload_dir: PathBuf,
 
@@ -46,11 +41,6 @@ pub struct Command {
     /// 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.
@@ -63,16 +53,6 @@ struct LoadedPayload {
     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<()> {
@@ -104,53 +84,18 @@ impl Command {
             "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()
-        };
-
+        // Discover and load payloads
         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");
 
+        info!(count = payloads.len(), "Loaded payloads from disk");
+
+        // Execute payloads in sequence
         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,
@@ -180,7 +125,7 @@ impl Command {
             .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_")
+                    e.file_name().to_string_lossy().starts_with("payload_")
             })
             .collect();
 
@@ -191,7 +136,7 @@ impl Command {
                 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_block_")?.strip_suffix(".json")?;
+                let index_str = name_str.strip_prefix("payload_")?.strip_suffix(".json")?;
                 let index: u64 = index_str.parse().ok()?;
                 Some((index, e.path()))
             })
@@ -229,62 +174,6 @@ impl Command {
         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>,

bin/reth-bench/src/bench/send_invalid_payload/invalidation.rs

@@ -1,219 +0,0 @@
-use alloy_eips::eip4895::Withdrawal;
-use alloy_primitives::{Address, Bloom, Bytes, B256, U256};
-use alloy_rpc_types_engine::{ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3};
-
-/// Configuration for invalidating payload fields
-#[derive(Debug, Default)]
-pub(super) struct InvalidationConfig {
-    // Explicit value overrides (Option<T>)
-    pub(super) parent_hash: Option<B256>,
-    pub(super) fee_recipient: Option<Address>,
-    pub(super) state_root: Option<B256>,
-    pub(super) receipts_root: Option<B256>,
-    pub(super) logs_bloom: Option<Bloom>,
-    pub(super) prev_randao: Option<B256>,
-    pub(super) block_number: Option<u64>,
-    pub(super) gas_limit: Option<u64>,
-    pub(super) gas_used: Option<u64>,
-    pub(super) timestamp: Option<u64>,
-    pub(super) extra_data: Option<Bytes>,
-    pub(super) base_fee_per_gas: Option<u64>,
-    pub(super) block_hash: Option<B256>,
-    pub(super) blob_gas_used: Option<u64>,
-    pub(super) excess_blob_gas: Option<u64>,
-
-    // Auto-invalidation flags
-    pub(super) invalidate_parent_hash: bool,
-    pub(super) invalidate_state_root: bool,
-    pub(super) invalidate_receipts_root: bool,
-    pub(super) invalidate_gas_used: bool,
-    pub(super) invalidate_block_number: bool,
-    pub(super) invalidate_timestamp: bool,
-    pub(super) invalidate_base_fee: bool,
-    pub(super) invalidate_transactions: bool,
-    pub(super) invalidate_block_hash: bool,
-    pub(super) invalidate_withdrawals: bool,
-    pub(super) invalidate_blob_gas_used: bool,
-    pub(super) invalidate_excess_blob_gas: bool,
-}
-
-impl InvalidationConfig {
-    /// Returns true if `block_hash` is being explicitly set or auto-invalidated.
-    /// When true, the caller should skip recalculating the block hash since it will be overwritten.
-    pub(super) const fn should_skip_hash_recalc(&self) -> bool {
-        self.block_hash.is_some() || self.invalidate_block_hash
-    }
-
-    /// Applies invalidations to a V1 payload, returns list of what was changed.
-    pub(super) fn apply_to_payload_v1(&self, payload: &mut ExecutionPayloadV1) -> Vec<String> {
-        let mut changes = Vec::new();
-
-        // Explicit value overrides
-        if let Some(parent_hash) = self.parent_hash {
-            payload.parent_hash = parent_hash;
-            changes.push(format!("parent_hash = {parent_hash}"));
-        }
-
-        if let Some(fee_recipient) = self.fee_recipient {
-            payload.fee_recipient = fee_recipient;
-            changes.push(format!("fee_recipient = {fee_recipient}"));
-        }
-
-        if let Some(state_root) = self.state_root {
-            payload.state_root = state_root;
-            changes.push(format!("state_root = {state_root}"));
-        }
-
-        if let Some(receipts_root) = self.receipts_root {
-            payload.receipts_root = receipts_root;
-            changes.push(format!("receipts_root = {receipts_root}"));
-        }
-
-        if let Some(logs_bloom) = self.logs_bloom {
-            payload.logs_bloom = logs_bloom;
-            changes.push("logs_bloom = <custom>".to_string());
-        }
-
-        if let Some(prev_randao) = self.prev_randao {
-            payload.prev_randao = prev_randao;
-            changes.push(format!("prev_randao = {prev_randao}"));
-        }
-
-        if let Some(block_number) = self.block_number {
-            payload.block_number = block_number;
-            changes.push(format!("block_number = {block_number}"));
-        }
-
-        if let Some(gas_limit) = self.gas_limit {
-            payload.gas_limit = gas_limit;
-            changes.push(format!("gas_limit = {gas_limit}"));
-        }
-
-        if let Some(gas_used) = self.gas_used {
-            payload.gas_used = gas_used;
-            changes.push(format!("gas_used = {gas_used}"));
-        }
-
-        if let Some(timestamp) = self.timestamp {
-            payload.timestamp = timestamp;
-            changes.push(format!("timestamp = {timestamp}"));
-        }
-
-        if let Some(ref extra_data) = self.extra_data {
-            payload.extra_data = extra_data.clone();
-            changes.push(format!("extra_data = {} bytes", extra_data.len()));
-        }
-
-        if let Some(base_fee_per_gas) = self.base_fee_per_gas {
-            payload.base_fee_per_gas = U256::from_limbs([base_fee_per_gas, 0, 0, 0]);
-            changes.push(format!("base_fee_per_gas = {base_fee_per_gas}"));
-        }
-
-        if let Some(block_hash) = self.block_hash {
-            payload.block_hash = block_hash;
-            changes.push(format!("block_hash = {block_hash}"));
-        }
-
-        // Auto-invalidation flags
-        if self.invalidate_parent_hash {
-            let random_hash = B256::random();
-            payload.parent_hash = random_hash;
-            changes.push(format!("parent_hash = {random_hash} (auto-invalidated: random)"));
-        }
-
-        if self.invalidate_state_root {
-            payload.state_root = B256::ZERO;
-            changes.push("state_root = ZERO (auto-invalidated: empty trie root)".to_string());
-        }
-
-        if self.invalidate_receipts_root {
-            payload.receipts_root = B256::ZERO;
-            changes.push("receipts_root = ZERO (auto-invalidated)".to_string());
-        }
-
-        if self.invalidate_gas_used {
-            let invalid_gas = payload.gas_limit + 1;
-            payload.gas_used = invalid_gas;
-            changes.push(format!("gas_used = {invalid_gas} (auto-invalidated: exceeds gas_limit)"));
-        }
-
-        if self.invalidate_block_number {
-            let invalid_number = payload.block_number + 999;
-            payload.block_number = invalid_number;
-            changes.push(format!("block_number = {invalid_number} (auto-invalidated: huge gap)"));
-        }
-
-        if self.invalidate_timestamp {
-            payload.timestamp = 0;
-            changes.push("timestamp = 0 (auto-invalidated: impossibly old)".to_string());
-        }
-
-        if self.invalidate_base_fee {
-            payload.base_fee_per_gas = U256::ZERO;
-            changes
-                .push("base_fee_per_gas = 0 (auto-invalidated: invalid post-London)".to_string());
-        }
-
-        if self.invalidate_transactions {
-            let invalid_tx = Bytes::from_static(&[0xff, 0xff, 0xff]);
-            payload.transactions.insert(0, invalid_tx);
-            changes.push("transactions = prepended invalid RLP (auto-invalidated)".to_string());
-        }
-
-        if self.invalidate_block_hash {
-            let random_hash = B256::random();
-            payload.block_hash = random_hash;
-            changes.push(format!("block_hash = {random_hash} (auto-invalidated: random)"));
-        }
-
-        changes
-    }
-
-    /// Applies invalidations to a V2 payload, returns list of what was changed.
-    pub(super) fn apply_to_payload_v2(&self, payload: &mut ExecutionPayloadV2) -> Vec<String> {
-        let mut changes = self.apply_to_payload_v1(&mut payload.payload_inner);
-
-        // Handle withdrawals invalidation (V2+)
-        if self.invalidate_withdrawals {
-            let fake_withdrawal = Withdrawal {
-                index: u64::MAX,
-                validator_index: u64::MAX,
-                address: Address::ZERO,
-                amount: u64::MAX,
-            };
-            payload.withdrawals.push(fake_withdrawal);
-            changes.push("withdrawals = added fake withdrawal (auto-invalidated)".to_string());
-        }
-
-        changes
-    }
-
-    /// Applies invalidations to a V3 payload, returns list of what was changed.
-    pub(super) fn apply_to_payload_v3(&self, payload: &mut ExecutionPayloadV3) -> Vec<String> {
-        let mut changes = self.apply_to_payload_v2(&mut payload.payload_inner);
-
-        // Explicit overrides for V3 fields
-        if let Some(blob_gas_used) = self.blob_gas_used {
-            payload.blob_gas_used = blob_gas_used;
-            changes.push(format!("blob_gas_used = {blob_gas_used}"));
-        }
-
-        if let Some(excess_blob_gas) = self.excess_blob_gas {
-            payload.excess_blob_gas = excess_blob_gas;
-            changes.push(format!("excess_blob_gas = {excess_blob_gas}"));
-        }
-
-        // Auto-invalidation for V3 fields
-        if self.invalidate_blob_gas_used {
-            payload.blob_gas_used = u64::MAX;
-            changes.push("blob_gas_used = MAX (auto-invalidated)".to_string());
-        }
-
-        if self.invalidate_excess_blob_gas {
-            payload.excess_blob_gas = u64::MAX;
-            changes.push("excess_blob_gas = MAX (auto-invalidated)".to_string());
-        }
-
-        changes
-    }
-}

bin/reth-bench/src/bench/send_invalid_payload/mod.rs

@@ -1,367 +0,0 @@
-//! Command for sending invalid payloads to test Engine API rejection.
-
-mod invalidation;
-use invalidation::InvalidationConfig;
-
-use alloy_primitives::{Address, B256};
-use alloy_provider::network::AnyRpcBlock;
-use alloy_rpc_types_engine::ExecutionPayload;
-use clap::Parser;
-use eyre::{OptionExt, Result};
-use op_alloy_consensus::OpTxEnvelope;
-use reth_cli_runner::CliContext;
-use std::io::{BufReader, Read, Write};
-
-/// Command for generating and sending an invalid `engine_newPayload` request.
-///
-/// Takes a valid block and modifies fields to make it invalid for testing
-/// Engine API rejection behavior. Block hash is recalculated after modifications
-/// unless `--invalidate-block-hash` or `--skip-hash-recalc` is used.
-#[derive(Debug, Parser)]
-pub struct Command {
-    // ==================== Input Options ====================
-    /// Path to the JSON file containing the block. If not specified, stdin will be used.
-    #[arg(short, long, help_heading = "Input Options")]
-    path: Option<String>,
-
-    /// The engine RPC URL to use.
-    #[arg(
-        short,
-        long,
-        help_heading = "Input Options",
-        required_if_eq_any([("mode", "execute"), ("mode", "cast")]),
-        required_unless_present("mode")
-    )]
-    rpc_url: Option<String>,
-
-    /// The JWT secret to use. Can be either a path to a file containing the secret or the secret
-    /// itself.
-    #[arg(short, long, help_heading = "Input Options")]
-    jwt_secret: Option<String>,
-
-    /// The newPayload version to use (3 or 4).
-    #[arg(long, default_value_t = 3, help_heading = "Input Options")]
-    new_payload_version: u8,
-
-    /// The output mode to use.
-    #[arg(long, value_enum, default_value = "execute", help_heading = "Input Options")]
-    mode: Mode,
-
-    // ==================== Explicit Value Overrides ====================
-    /// Override the parent hash with a specific value.
-    #[arg(long, value_name = "HASH", help_heading = "Explicit Value Overrides")]
-    parent_hash: Option<B256>,
-
-    /// Override the fee recipient (coinbase) with a specific address.
-    #[arg(long, value_name = "ADDR", help_heading = "Explicit Value Overrides")]
-    fee_recipient: Option<Address>,
-
-    /// Override the state root with a specific value.
-    #[arg(long, value_name = "HASH", help_heading = "Explicit Value Overrides")]
-    state_root: Option<B256>,
-
-    /// Override the receipts root with a specific value.
-    #[arg(long, value_name = "HASH", help_heading = "Explicit Value Overrides")]
-    receipts_root: Option<B256>,
-
-    /// Override the block number with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    block_number: Option<u64>,
-
-    /// Override the gas limit with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    gas_limit: Option<u64>,
-
-    /// Override the gas used with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    gas_used: Option<u64>,
-
-    /// Override the timestamp with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    timestamp: Option<u64>,
-
-    /// Override the base fee per gas with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    base_fee_per_gas: Option<u64>,
-
-    /// Override the block hash with a specific value (skips hash recalculation).
-    #[arg(long, value_name = "HASH", help_heading = "Explicit Value Overrides")]
-    block_hash: Option<B256>,
-
-    /// Override the blob gas used with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    blob_gas_used: Option<u64>,
-
-    /// Override the excess blob gas with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    excess_blob_gas: Option<u64>,
-
-    /// Override the parent beacon block root with a specific value.
-    #[arg(long, value_name = "HASH", help_heading = "Explicit Value Overrides")]
-    parent_beacon_block_root: Option<B256>,
-
-    /// Override the requests hash with a specific value (EIP-7685).
-    #[arg(long, value_name = "HASH", help_heading = "Explicit Value Overrides")]
-    requests_hash: Option<B256>,
-
-    // ==================== Auto-Invalidation Flags ====================
-    /// Invalidate the parent hash by setting it to a random value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_parent_hash: bool,
-
-    /// Invalidate the state root by setting it to a random value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_state_root: bool,
-
-    /// Invalidate the receipts root by setting it to a random value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_receipts_root: bool,
-
-    /// Invalidate the gas used by setting it to an incorrect value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_gas_used: bool,
-
-    /// Invalidate the block number by setting it to an incorrect value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_block_number: bool,
-
-    /// Invalidate the timestamp by setting it to an incorrect value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_timestamp: bool,
-
-    /// Invalidate the base fee by setting it to an incorrect value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_base_fee: bool,
-
-    /// Invalidate the transactions by modifying them.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_transactions: bool,
-
-    /// Invalidate the block hash by not recalculating it after modifications.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_block_hash: bool,
-
-    /// Invalidate the withdrawals by modifying them.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_withdrawals: bool,
-
-    /// Invalidate the blob gas used by setting it to an incorrect value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_blob_gas_used: bool,
-
-    /// Invalidate the excess blob gas by setting it to an incorrect value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_excess_blob_gas: bool,
-
-    /// Invalidate the requests hash by setting it to a random value (EIP-7685).
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_requests_hash: bool,
-
-    // ==================== Meta Flags ====================
-    /// Skip block hash recalculation after modifications.
-    #[arg(long, default_value_t = false, help_heading = "Meta Flags")]
-    skip_hash_recalc: bool,
-
-    /// Print what would be done without actually sending the payload.
-    #[arg(long, default_value_t = false, help_heading = "Meta Flags")]
-    dry_run: bool,
-}
-
-#[derive(Debug, Clone, clap::ValueEnum)]
-enum Mode {
-    /// Execute the `cast` command. This works with blocks of any size, because it pipes the
-    /// payload into the `cast` command.
-    Execute,
-    /// Print the `cast` command. Caution: this may not work with large blocks because of the
-    /// command length limit.
-    Cast,
-    /// Print the JSON payload. Can be piped into `cast` command if the block is small enough.
-    Json,
-}
-
-impl Command {
-    /// Read input from either a file or stdin
-    fn read_input(&self) -> Result<String> {
-        Ok(match &self.path {
-            Some(path) => reth_fs_util::read_to_string(path)?,
-            None => String::from_utf8(
-                BufReader::new(std::io::stdin()).bytes().collect::<Result<Vec<_>, _>>()?,
-            )?,
-        })
-    }
-
-    /// Load JWT secret from either a file or use the provided string directly
-    fn load_jwt_secret(&self) -> Result<Option<String>> {
-        match &self.jwt_secret {
-            Some(secret) => match std::fs::read_to_string(secret) {
-                Ok(contents) => Ok(Some(contents.trim().to_string())),
-                Err(_) => Ok(Some(secret.clone())),
-            },
-            None => Ok(None),
-        }
-    }
-
-    /// Build `InvalidationConfig` from command flags
-    const fn build_invalidation_config(&self) -> InvalidationConfig {
-        InvalidationConfig {
-            parent_hash: self.parent_hash,
-            fee_recipient: self.fee_recipient,
-            state_root: self.state_root,
-            receipts_root: self.receipts_root,
-            logs_bloom: None,
-            prev_randao: None,
-            block_number: self.block_number,
-            gas_limit: self.gas_limit,
-            gas_used: self.gas_used,
-            timestamp: self.timestamp,
-            extra_data: None,
-            base_fee_per_gas: self.base_fee_per_gas,
-            block_hash: self.block_hash,
-            blob_gas_used: self.blob_gas_used,
-            excess_blob_gas: self.excess_blob_gas,
-            invalidate_parent_hash: self.invalidate_parent_hash,
-            invalidate_state_root: self.invalidate_state_root,
-            invalidate_receipts_root: self.invalidate_receipts_root,
-            invalidate_gas_used: self.invalidate_gas_used,
-            invalidate_block_number: self.invalidate_block_number,
-            invalidate_timestamp: self.invalidate_timestamp,
-            invalidate_base_fee: self.invalidate_base_fee,
-            invalidate_transactions: self.invalidate_transactions,
-            invalidate_block_hash: self.invalidate_block_hash,
-            invalidate_withdrawals: self.invalidate_withdrawals,
-            invalidate_blob_gas_used: self.invalidate_blob_gas_used,
-            invalidate_excess_blob_gas: self.invalidate_excess_blob_gas,
-        }
-    }
-
-    /// Execute the command
-    pub async fn execute(self, _ctx: CliContext) -> Result<()> {
-        let block_json = self.read_input()?;
-        let jwt_secret = self.load_jwt_secret()?;
-
-        let block = serde_json::from_str::<AnyRpcBlock>(&block_json)?
-            .into_inner()
-            .map_header(|header| header.map(|h| h.into_header_with_defaults()))
-            .try_map_transactions(|tx| tx.try_into_either::<OpTxEnvelope>())?
-            .into_consensus();
-
-        let config = self.build_invalidation_config();
-
-        let parent_beacon_block_root =
-            self.parent_beacon_block_root.or(block.header.parent_beacon_block_root);
-        let blob_versioned_hashes =
-            block.body.blob_versioned_hashes_iter().copied().collect::<Vec<_>>();
-        let use_v4 = block.header.requests_hash.is_some();
-        let requests_hash = self.requests_hash.or(block.header.requests_hash);
-
-        let mut execution_payload = ExecutionPayload::from_block_slow(&block).0;
-
-        let changes = match &mut execution_payload {
-            ExecutionPayload::V1(p) => config.apply_to_payload_v1(p),
-            ExecutionPayload::V2(p) => config.apply_to_payload_v2(p),
-            ExecutionPayload::V3(p) => config.apply_to_payload_v3(p),
-        };
-
-        let skip_recalc = self.skip_hash_recalc || config.should_skip_hash_recalc();
-        if !skip_recalc {
-            let new_hash = match execution_payload.clone().into_block_raw() {
-                Ok(block) => block.header.hash_slow(),
-                Err(e) => {
-                    eprintln!(
-                        "Warning: Could not recalculate block hash: {e}. Using original hash."
-                    );
-                    match &execution_payload {
-                        ExecutionPayload::V1(p) => p.block_hash,
-                        ExecutionPayload::V2(p) => p.payload_inner.block_hash,
-                        ExecutionPayload::V3(p) => p.payload_inner.payload_inner.block_hash,
-                    }
-                }
-            };
-
-            match &mut execution_payload {
-                ExecutionPayload::V1(p) => p.block_hash = new_hash,
-                ExecutionPayload::V2(p) => p.payload_inner.block_hash = new_hash,
-                ExecutionPayload::V3(p) => p.payload_inner.payload_inner.block_hash = new_hash,
-            }
-        }
-
-        if self.dry_run {
-            println!("=== Dry Run ===");
-            println!("Changes that would be applied:");
-            for change in &changes {
-                println!("  - {}", change);
-            }
-            if changes.is_empty() {
-                println!("  (no changes)");
-            }
-            if skip_recalc {
-                println!("  - Block hash recalculation: SKIPPED");
-            } else {
-                println!("  - Block hash recalculation: PERFORMED");
-            }
-            println!("\nResulting payload JSON:");
-            let json = serde_json::to_string_pretty(&execution_payload)?;
-            println!("{}", json);
-            return Ok(());
-        }
-
-        let json_request = if use_v4 {
-            serde_json::to_string(&(
-                execution_payload,
-                blob_versioned_hashes,
-                parent_beacon_block_root,
-                requests_hash.unwrap_or_default(),
-            ))?
-        } else {
-            serde_json::to_string(&(
-                execution_payload,
-                blob_versioned_hashes,
-                parent_beacon_block_root,
-            ))?
-        };
-
-        match self.mode {
-            Mode::Execute => {
-                let mut command = std::process::Command::new("cast");
-                let method = if use_v4 { "engine_newPayloadV4" } else { "engine_newPayloadV3" };
-                command.arg("rpc").arg(method).arg("--raw");
-                if let Some(rpc_url) = self.rpc_url {
-                    command.arg("--rpc-url").arg(rpc_url);
-                }
-                if let Some(secret) = &jwt_secret {
-                    command.arg("--jwt-secret").arg(secret);
-                }
-
-                let mut process = command.stdin(std::process::Stdio::piped()).spawn()?;
-
-                process
-                    .stdin
-                    .take()
-                    .ok_or_eyre("stdin not available")?
-                    .write_all(json_request.as_bytes())?;
-
-                process.wait()?;
-            }
-            Mode::Cast => {
-                let mut cmd = format!(
-                    "cast rpc engine_newPayloadV{} --raw '{}'",
-                    self.new_payload_version, json_request
-                );
-
-                if let Some(rpc_url) = self.rpc_url {
-                    cmd += &format!(" --rpc-url {rpc_url}");
-                }
-                if let Some(secret) = &jwt_secret {
-                    cmd += &format!(" --jwt-secret {secret}");
-                }
-
-                println!("{cmd}");
-            }
-            Mode::Json => {
-                println!("{json_request}");
-            }
-        }
-
-        Ok(())
-    }
-}

bin/reth-bench/src/valid_payload.rs

@@ -54,6 +54,7 @@ where
         payload_attributes: Option<PayloadAttributes>,
     ) -> TransportResult<ForkchoiceUpdated> {
         debug!(
+            target: "reth-bench",
             method = "engine_forkchoiceUpdatedV1",
             ?fork_choice_state,
             ?payload_attributes,
@@ -91,6 +92,7 @@ where
         payload_attributes: Option<PayloadAttributes>,
     ) -> TransportResult<ForkchoiceUpdated> {
         debug!(
+            target: "reth-bench",
             method = "engine_forkchoiceUpdatedV2",
             ?fork_choice_state,
             ?payload_attributes,
@@ -128,6 +130,7 @@ where
         payload_attributes: Option<PayloadAttributes>,
     ) -> TransportResult<ForkchoiceUpdated> {
         debug!(
+            target: "reth-bench",
             method = "engine_forkchoiceUpdatedV3",
             ?fork_choice_state,
             ?payload_attributes,
@@ -203,7 +206,11 @@ pub(crate) fn payload_to_new_payload(
                     )
                 } else {
                     // Extract actual Requests from RequestsOrHash
-                    let requests = prague.requests.requests_hash();
+                    let requests = prague
+                        .requests
+                        .requests()
+                        .cloned()
+                        .ok_or_else(|| eyre::eyre!("Prague sidecar has hash, not requests"))?;
                     (
                         version,
                         serde_json::to_value((
@@ -253,7 +260,12 @@ pub(crate) async fn call_new_payload<N: Network, P: Provider<N>>(
 ) -> TransportResult<()> {
     let method = version.method_name();
 
-    debug!(method, "Sending newPayload");
+    debug!(
+        target: "reth-bench",
+        method,
+        params = %serde_json::to_string_pretty(&params).unwrap_or_default(),
+        "Sending newPayload"
+    );
 
     let mut status: PayloadStatus = provider.client().request(method, &params).await?;
 

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",

bin/reth/src/lib.rs

@@ -25,8 +25,8 @@
 //! - `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/microsoft/snmalloc) as the global allocator.
-//!   Use `--no-default-features` when enabling this, as jemalloc takes precedence.
+//! - `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.
 //!

crates/chain-state/Cargo.toml

@@ -41,7 +41,6 @@ derive_more.workspace = true
 metrics.workspace = true
 parking_lot.workspace = true
 pin-project.workspace = true
-rayon = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
 
 # optional deps for test-utils
@@ -85,7 +84,6 @@ test-utils = [
     "reth-trie/test-utils",
     "reth-ethereum-primitives/test-utils",
 ]
-rayon = ["dep:rayon"]
 
 [[bench]]
 name = "canonical_hashes_range"

crates/chain-state/src/deferred_trie.rs

@@ -163,29 +163,14 @@ impl DeferredTrieData {
         anchor_hash: B256,
         ancestors: &[Self],
     ) -> ComputedTrieData {
-        #[cfg(feature = "rayon")]
-        let (sorted_hashed_state, sorted_trie_updates) = rayon::join(
-            || match Arc::try_unwrap(hashed_state) {
-                Ok(state) => state.into_sorted(),
-                Err(arc) => arc.clone_into_sorted(),
-            },
-            || match Arc::try_unwrap(trie_updates) {
-                Ok(updates) => updates.into_sorted(),
-                Err(arc) => arc.clone_into_sorted(),
-            },
-        );
-
-        #[cfg(not(feature = "rayon"))]
-        let (sorted_hashed_state, sorted_trie_updates) = (
-            match Arc::try_unwrap(hashed_state) {
-                Ok(state) => state.into_sorted(),
-                Err(arc) => arc.clone_into_sorted(),
-            },
-            match Arc::try_unwrap(trie_updates) {
-                Ok(updates) => updates.into_sorted(),
-                Err(arc) => arc.clone_into_sorted(),
-            },
-        );
+        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(),
+        };
 
         // 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
@@ -206,33 +191,11 @@ impl DeferredTrieData {
                         Default::default(), // prefix_sets are per-block, not cumulative
                     );
                     // Only trigger COW clone if there's actually data to add.
-                    #[cfg(feature = "rayon")]
-                    {
-                        rayon::join(
-                            || {
-                                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);
-                                }
-                            },
-                        );
+                    if !sorted_hashed_state.is_empty() {
+                        Arc::make_mut(&mut overlay.state).extend_ref(&sorted_hashed_state);
                     }
-                    #[cfg(not(feature = "rayon"))]
-                    {
-                        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);
-                        }
+                    if !sorted_trie_updates.is_empty() {
+                        Arc::make_mut(&mut overlay.nodes).extend_ref(&sorted_trie_updates);
                     }
                     overlay
                 }
@@ -279,22 +242,13 @@ impl DeferredTrieData {
 
         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());
+            state_mut.extend_ref(ancestor_data.hashed_state.as_ref());
+            nodes_mut.extend_ref(ancestor_data.trie_updates.as_ref());
         }
 
         // Extend with current block's sorted data last (takes precedence)
-        #[cfg(feature = "rayon")]
-        rayon::join(
-            || state_mut.extend_ref_and_sort(sorted_hashed_state),
-            || nodes_mut.extend_ref_and_sort(sorted_trie_updates),
-        );
-
-        #[cfg(not(feature = "rayon"))]
-        {
-            state_mut.extend_ref_and_sort(sorted_hashed_state);
-            nodes_mut.extend_ref_and_sort(sorted_trie_updates);
-        }
+        state_mut.extend_ref(sorted_hashed_state);
+        nodes_mut.extend_ref(sorted_trie_updates);
 
         overlay
     }
@@ -333,11 +287,6 @@ impl DeferredTrieData {
                     &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
             }
         }
@@ -567,7 +516,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,

crates/chain-state/src/in_memory.rs

@@ -10,18 +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, SortedTrieData,
-    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.
@@ -651,7 +648,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
     }
 
@@ -662,7 +659,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.
@@ -670,7 +675,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`.
@@ -754,7 +767,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.
@@ -766,15 +779,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()),
         }
     }
@@ -795,7 +800,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) }
@@ -817,7 +822,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 }
@@ -837,7 +842,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
     }
 
@@ -937,53 +942,37 @@ 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 trie_data_handle = first.trie_data_handle();
-                let mut chain = Chain::from_block(
-                    first.recovered_block().clone(),
-                    ExecutionOutcome::from((
-                        first.execution_outcome().clone(),
-                        first.block_number(),
-                    )),
-                    LazyTrieData::deferred(move || {
-                        let trie_data = trie_data_handle.wait_cloned();
-                        SortedTrieData {
-                            hashed_state: trie_data.hashed_state,
-                            trie_updates: trie_data.trie_updates,
-                        }
-                    }),
-                );
-                for exec in rest {
-                    let trie_data_handle = exec.trie_data_handle();
+                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::deferred(move || {
-                            let trie_data = trie_data_handle.wait_cloned();
-                            SortedTrieData {
-                                hashed_state: trie_data.hashed_state,
-                                trie_updates: trie_data.trie_updates,
-                            }
-                        }),
+                        exec.execution_outcome().clone(),
+                        exec.trie_updates(),
+                        exec.hashed_state(),
                     );
-                }
-                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(),
+                        exec.trie_updates(),
+                        exec.hashed_state(),
+                    );
+                    chain
+                }));
+                let old = Arc::new(old.iter().fold(Chain::default(), |mut chain, exec| {
+                    chain.append_block(
+                        exec.recovered_block().clone(),
+                        exec.execution_outcome().clone(),
+                        exec.trie_updates(),
+                        exec.hashed_state(),
+                    );
+                    chain
+                }));
+                CanonStateNotification::Reorg { new, old }
             }
         }
     }
@@ -1277,7 +1266,7 @@ mod tests {
 
         let state = BlockState::new(block);
 
-        assert_eq!(state.receipts(), receipts.first().unwrap());
+        assert_eq!(state.receipts(), &receipts);
     }
 
     #[test]
@@ -1554,31 +1543,33 @@ mod tests {
         let block2a =
             test_block_builder.get_executed_block_with_number(2, block1.recovered_block.hash());
 
+        let sample_execution_outcome = ExecutionOutcome {
+            receipts: vec![vec![], vec![]],
+            requests: vec![Requests::default(), Requests::default()],
+            ..Default::default()
+        };
+
         // 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 trie updates map
+        let mut expected_trie_updates = BTreeMap::new();
+        expected_trie_updates.insert(0, block0.trie_updates());
+        expected_trie_updates.insert(1, block1.trie_updates());
 
-        // Build expected execution outcome (first_block matches first block number)
-        let commit_execution_outcome = ExecutionOutcome {
-            receipts: vec![vec![], vec![]],
-            requests: vec![Requests::default(), Requests::default()],
-            first_block: 0,
-            ..Default::default()
-        };
+        // Build expected hashed state map
+        let mut expected_hashed_state = BTreeMap::new();
+        expected_hashed_state.insert(0, block0.hashed_state());
+        expected_hashed_state.insert(1, block1.hashed_state());
 
         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(),
+                    expected_trie_updates,
+                    expected_hashed_state
                 ))
             }
         );
@@ -1589,39 +1580,40 @@ 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 updates for old chain
+        let mut old_trie_updates = BTreeMap::new();
+        old_trie_updates.insert(1, block1.trie_updates());
+        old_trie_updates.insert(2, 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 trie updates for new chain
+        let mut new_trie_updates = BTreeMap::new();
+        new_trie_updates.insert(1, block1a.trie_updates());
+        new_trie_updates.insert(2, 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()
-        };
+        // Build expected hashed state for old chain
+        let mut old_hashed_state = BTreeMap::new();
+        old_hashed_state.insert(1, block1.hashed_state());
+        old_hashed_state.insert(2, block2.hashed_state());
+
+        // Build expected hashed state for new chain
+        let mut new_hashed_state = BTreeMap::new();
+        new_hashed_state.insert(1, block1a.hashed_state());
+        new_hashed_state.insert(2, block2a.hashed_state());
 
         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(),
+                    old_trie_updates,
+                    old_hashed_state
                 )),
                 new: Arc::new(Chain::new(
                     vec![block1a.recovered_block().clone(), block2a.recovered_block().clone()],
-                    reorg_execution_outcome,
-                    new_trie_data,
+                    sample_execution_outcome,
+                    new_trie_updates,
+                    new_hashed_state
                 ))
             }
         );

crates/chain-state/src/lazy_overlay.rs

@@ -1,186 +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.
-    fn merge_blocks(blocks: &[DeferredTrieData]) -> TrieInputSorted {
-        if blocks.is_empty() {
-            return TrieInputSorted::default();
-        }
-
-        let state =
-            HashedPostStateSorted::merge_batch(blocks.iter().map(|b| b.wait_cloned().hashed_state));
-        let nodes =
-            TrieUpdatesSorted::merge_batch(blocks.iter().map(|b| b.wait_cloned().trie_updates));
-
-        TrieInputSorted { state, 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());
-    }
-}

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;

crates/chain-state/src/notifications.rs

@@ -280,6 +280,7 @@ mod tests {
             vec![block1.clone(), block2.clone()],
             ExecutionOutcome::default(),
             BTreeMap::new(),
+            BTreeMap::new(),
         ));
 
         // Create a commit notification
@@ -318,11 +319,13 @@ mod tests {
             vec![block1.clone()],
             ExecutionOutcome::default(),
             BTreeMap::new(),
+            BTreeMap::new(),
         ));
         let new_chain = Arc::new(Chain::new(
             vec![block2.clone(), block3.clone()],
             ExecutionOutcome::default(),
             BTreeMap::new(),
+            BTreeMap::new(),
         ));
 
         // Create a reorg notification
@@ -388,6 +391,7 @@ mod tests {
             vec![block1.clone(), block2.clone()],
             execution_outcome,
             BTreeMap::new(),
+            BTreeMap::new(),
         ));
 
         // Create a commit notification containing the new chain segment.
@@ -445,8 +449,12 @@ mod tests {
             ExecutionOutcome { receipts: old_receipts, ..Default::default() };
 
         // 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()));
+        let old_chain: Arc<Chain> = Arc::new(Chain::new(
+            vec![old_block1.clone()],
+            old_execution_outcome,
+            BTreeMap::new(),
+            BTreeMap::new(),
+        ));
 
         // Define block2 for the new chain segment, which will be committed.
         let mut body = BlockBody::<TransactionSigned>::default();
@@ -474,8 +482,12 @@ 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,
+            BTreeMap::new(),
+            BTreeMap::new(),
+        ));
 
         // Create a reorg notification with both reverted (old) and committed (new) chain segments.
         let notification = CanonStateNotification::Reorg { old: old_chain, new: new_chain };

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,
         )
     }

crates/chainspec/src/lib.rs

@@ -25,7 +25,6 @@ pub use alloy_chains::{Chain, ChainKind, NamedChain};
 /// Re-export for convenience
 pub use reth_ethereum_forks::*;
 
-pub use alloy_evm::EvmLimitParams;
 pub use api::EthChainSpec;
 pub use info::ChainInfo;
 #[cfg(any(test, feature = "test-utils"))]

crates/chainspec/src/spec.rs

@@ -278,7 +278,6 @@ pub fn create_chain_config(
     // Check if DAO fork is supported (it has an activation block)
     let dao_fork_support = hardforks.fork(EthereumHardfork::Dao) != ForkCondition::Never;
 
-    #[allow(clippy::needless_update)]
     ChainConfig {
         chain_id: chain.map(|c| c.id()).unwrap_or(0),
         homestead_block: block_num(EthereumHardfork::Homestead),
@@ -314,7 +313,6 @@ pub fn create_chain_config(
         extra_fields: Default::default(),
         deposit_contract_address,
         blob_schedule,
-        ..Default::default()
     }
 }
 

crates/cli/commands/Cargo.toml

@@ -50,7 +50,6 @@ reth-stages-types = { workspace = true, optional = true }
 reth-static-file-types = { workspace = true, features = ["clap"] }
 reth-static-file.workspace = true
 reth-tasks.workspace = true
-reth-storage-api.workspace = true
 reth-trie = { workspace = true, features = ["metrics"] }
 reth-trie-db = { workspace = true, features = ["metrics"] }
 reth-trie-common.workspace = true
@@ -84,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
@@ -132,4 +130,4 @@ arbitrary = [
     "reth-ethereum-primitives/arbitrary",
 ]
 
-edge = ["reth-db-common/edge", "reth-stages/rocksdb", "reth-provider/rocksdb"]
+edge = ["reth-db-common/edge", "reth-stages/rocksdb"]

crates/cli/commands/src/common.rs

@@ -19,7 +19,7 @@ use reth_node_builder::{
     Node, NodeComponents, NodeComponentsBuilder, NodeTypes, NodeTypesWithDBAdapter,
 };
 use reth_node_core::{
-    args::{DatabaseArgs, DatadirArgs, RocksDbArgs, StaticFilesArgs},
+    args::{DatabaseArgs, DatadirArgs, StaticFilesArgs},
     dirs::{ChainPath, DataDirPath},
 };
 use reth_provider::{
@@ -27,7 +27,7 @@ use reth_provider::{
         BlockchainProvider, NodeTypesForProvider, RocksDBProvider, StaticFileProvider,
         StaticFileProviderBuilder,
     },
-    ProviderFactory, StaticFileProviderFactory, StorageSettings,
+    ProviderFactory, StaticFileProviderFactory,
 };
 use reth_stages::{sets::DefaultStages, Pipeline, PipelineTarget};
 use reth_static_file::StaticFileProducer;
@@ -66,24 +66,9 @@ pub struct EnvironmentArgs<C: ChainSpecParser> {
     /// All static files related arguments
     #[command(flatten)]
     pub static_files: StaticFilesArgs,
-
-    /// All `RocksDB` related arguments
-    #[command(flatten)]
-    pub rocksdb: RocksDbArgs,
 }
 
 impl<C: ChainSpecParser> EnvironmentArgs<C> {
-    /// Returns the effective storage settings derived from static-file and `RocksDB` CLI args.
-    pub fn storage_settings(&self) -> StorageSettings {
-        StorageSettings::base()
-            .with_receipts_in_static_files(self.static_files.receipts)
-            .with_transaction_senders_in_static_files(self.static_files.transaction_senders)
-            .with_account_changesets_in_static_files(self.static_files.account_changesets)
-            .with_transaction_hash_numbers_in_rocksdb(self.rocksdb.all || self.rocksdb.tx_hash)
-            .with_storages_history_in_rocksdb(self.rocksdb.all || self.rocksdb.storages_history)
-            .with_account_history_in_rocksdb(self.rocksdb.all || self.rocksdb.account_history)
-    }
-
     /// Initializes environment according to [`AccessRights`] and returns an instance of
     /// [`Environment`].
     pub fn init<N: CliNodeTypes>(&self, access: AccessRights) -> eyre::Result<Environment<N>>
@@ -136,17 +121,17 @@ impl<C: ChainSpecParser> EnvironmentArgs<C> {
                 })
             }
         };
+        // TransactionDB only support read-write mode
         let rocksdb_provider = RocksDBProvider::builder(data_dir.rocksdb())
             .with_default_tables()
             .with_database_log_level(self.db.log_level)
-            .with_read_only(!access.is_read_write())
             .build()?;
 
         let provider_factory =
             self.create_provider_factory(&config, db, sfp, rocksdb_provider, access)?;
         if access.is_read_write() {
             debug!(target: "reth::cli", chain=%self.chain.chain(), genesis=?self.chain.genesis_hash(), "Initializing genesis");
-            init_genesis_with_settings(&provider_factory, self.storage_settings())?;
+            init_genesis_with_settings(&provider_factory, self.static_files.to_settings())?;
         }
 
         Ok(Environment { config, provider_factory, data_dir })

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

@@ -0,0 +1,145 @@
+use crate::{
+    common::CliNodeTypes,
+    db::get::{maybe_json_value_parser, table_key},
+};
+use alloy_primitives::map::foldhash::fast::FixedState;
+use clap::Parser;
+use reth_chainspec::EthereumHardforks;
+use reth_db::DatabaseEnv;
+use reth_db_api::{
+    cursor::DbCursorRO, table::Table, transaction::DbTx, RawKey, RawTable, RawValue, TableViewer,
+    Tables,
+};
+use reth_db_common::DbTool;
+use reth_node_builder::{NodeTypesWithDB, NodeTypesWithDBAdapter};
+use reth_provider::{providers::ProviderNodeTypes, DBProvider};
+use std::{
+    hash::{BuildHasher, Hasher},
+    sync::Arc,
+    time::{Duration, Instant},
+};
+use tracing::{info, warn};
+
+#[derive(Parser, Debug)]
+/// The arguments for the `reth db checksum` command
+pub struct Command {
+    /// The table name
+    table: Tables,
+
+    /// The start of the range to checksum.
+    #[arg(long, value_parser = maybe_json_value_parser)]
+    start_key: Option<String>,
+
+    /// The end of the range to checksum.
+    #[arg(long, value_parser = maybe_json_value_parser)]
+    end_key: Option<String>,
+
+    /// The maximum number of records that are queried and used to compute the
+    /// checksum.
+    #[arg(long)]
+    limit: Option<usize>,
+}
+
+impl Command {
+    /// Execute `db checksum` command
+    pub fn execute<N: CliNodeTypes<ChainSpec: EthereumHardforks>>(
+        self,
+        tool: &DbTool<NodeTypesWithDBAdapter<N, Arc<DatabaseEnv>>>,
+    ) -> eyre::Result<()> {
+        warn!("This command should be run without the node running!");
+        self.table.view(&ChecksumViewer {
+            tool,
+            start_key: self.start_key,
+            end_key: self.end_key,
+            limit: self.limit,
+        })?;
+        Ok(())
+    }
+}
+
+pub(crate) struct ChecksumViewer<'a, N: NodeTypesWithDB> {
+    tool: &'a DbTool<N>,
+    start_key: Option<String>,
+    end_key: Option<String>,
+    limit: Option<usize>,
+}
+
+impl<N: NodeTypesWithDB> ChecksumViewer<'_, N> {
+    pub(crate) const fn new(tool: &'_ DbTool<N>) -> ChecksumViewer<'_, N> {
+        ChecksumViewer { tool, start_key: None, end_key: None, limit: None }
+    }
+}
+
+impl<N: ProviderNodeTypes> TableViewer<(u64, Duration)> for ChecksumViewer<'_, N> {
+    type Error = eyre::Report;
+
+    fn view<T: Table>(&self) -> Result<(u64, Duration), Self::Error> {
+        let provider =
+            self.tool.provider_factory.provider()?.disable_long_read_transaction_safety();
+        let tx = provider.tx_ref();
+        info!(
+            "Start computing checksum, start={:?}, end={:?}, limit={:?}",
+            self.start_key, self.end_key, self.limit
+        );
+
+        let mut cursor = tx.cursor_read::<RawTable<T>>()?;
+        let walker = match (self.start_key.as_deref(), self.end_key.as_deref()) {
+            (Some(start), Some(end)) => {
+                let start_key = table_key::<T>(start).map(RawKey::new)?;
+                let end_key = table_key::<T>(end).map(RawKey::new)?;
+                cursor.walk_range(start_key..=end_key)?
+            }
+            (None, Some(end)) => {
+                let end_key = table_key::<T>(end).map(RawKey::new)?;
+
+                cursor.walk_range(..=end_key)?
+            }
+            (Some(start), None) => {
+                let start_key = table_key::<T>(start).map(RawKey::new)?;
+                cursor.walk_range(start_key..)?
+            }
+            (None, None) => cursor.walk_range(..)?,
+        };
+
+        let start_time = Instant::now();
+        let mut hasher = FixedState::with_seed(u64::from_be_bytes(*b"RETHRETH")).build_hasher();
+        let mut total = 0;
+
+        let limit = self.limit.unwrap_or(usize::MAX);
+        let mut enumerate_start_key = None;
+        let mut enumerate_end_key = None;
+        for (index, entry) in walker.enumerate() {
+            let (k, v): (RawKey<T::Key>, RawValue<T::Value>) = entry?;
+
+            if index.is_multiple_of(100_000) {
+                info!("Hashed {index} entries.");
+            }
+
+            hasher.write(k.raw_key());
+            hasher.write(v.raw_value());
+
+            if enumerate_start_key.is_none() {
+                enumerate_start_key = Some(k.clone());
+            }
+            enumerate_end_key = Some(k);
+
+            total = index + 1;
+            if total >= limit {
+                break
+            }
+        }
+
+        info!("Hashed {total} entries.");
+        if let (Some(s), Some(e)) = (enumerate_start_key, enumerate_end_key) {
+            info!("start-key: {}", serde_json::to_string(&s.key()?).unwrap_or_default());
+            info!("end-key: {}", serde_json::to_string(&e.key()?).unwrap_or_default());
+        }
+
+        let checksum = hasher.finish();
+        let elapsed = start_time.elapsed();
+
+        info!("Checksum for table `{}`: {:#x} (elapsed: {:?})", T::NAME, checksum, elapsed);
+
+        Ok((checksum, elapsed))
+    }
+}

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

@@ -1,288 +0,0 @@
-use crate::{
-    common::CliNodeTypes,
-    db::get::{maybe_json_value_parser, table_key},
-};
-use alloy_primitives::map::foldhash::fast::FixedState;
-use clap::Parser;
-use itertools::Itertools;
-use reth_chainspec::EthereumHardforks;
-use reth_db::{static_file::iter_static_files, DatabaseEnv};
-use reth_db_api::{
-    cursor::DbCursorRO, table::Table, transaction::DbTx, RawKey, RawTable, RawValue, TableViewer,
-    Tables,
-};
-use reth_db_common::DbTool;
-use reth_node_builder::{NodeTypesWithDB, NodeTypesWithDBAdapter};
-use reth_provider::{providers::ProviderNodeTypes, DBProvider, StaticFileProviderFactory};
-use reth_static_file_types::StaticFileSegment;
-use std::{
-    hash::{BuildHasher, Hasher},
-    sync::Arc,
-    time::{Duration, Instant},
-};
-use tracing::{info, warn};
-
-#[cfg(all(unix, feature = "edge"))]
-mod rocksdb;
-
-/// Interval for logging progress during checksum computation.
-const PROGRESS_LOG_INTERVAL: usize = 100_000;
-
-#[derive(Parser, Debug)]
-/// The arguments for the `reth db checksum` command
-pub struct Command {
-    #[command(subcommand)]
-    subcommand: Subcommand,
-}
-
-#[derive(clap::Subcommand, Debug)]
-enum Subcommand {
-    /// Calculates the checksum of a database table
-    Mdbx {
-        /// The table name
-        table: Tables,
-
-        /// The start of the range to checksum.
-        #[arg(long, value_parser = maybe_json_value_parser)]
-        start_key: Option<String>,
-
-        /// The end of the range to checksum.
-        #[arg(long, value_parser = maybe_json_value_parser)]
-        end_key: Option<String>,
-
-        /// The maximum number of records that are queried and used to compute the
-        /// checksum.
-        #[arg(long)]
-        limit: Option<usize>,
-    },
-    /// Calculates the checksum of a static file segment
-    StaticFile {
-        /// The static file segment
-        #[arg(value_enum)]
-        segment: StaticFileSegment,
-
-        /// The block number to start from (inclusive).
-        #[arg(long)]
-        start_block: Option<u64>,
-
-        /// The block number to end at (inclusive).
-        #[arg(long)]
-        end_block: Option<u64>,
-
-        /// The maximum number of rows to checksum.
-        #[arg(long)]
-        limit: Option<usize>,
-    },
-    /// Calculates the checksum of a RocksDB table
-    #[cfg(all(unix, feature = "edge"))]
-    Rocksdb {
-        /// The RocksDB table
-        #[arg(value_enum)]
-        table: rocksdb::RocksDbTable,
-
-        /// The maximum number of records to checksum.
-        #[arg(long)]
-        limit: Option<usize>,
-    },
-}
-
-impl Command {
-    /// Execute `db checksum` command
-    pub fn execute<N: CliNodeTypes<ChainSpec: EthereumHardforks>>(
-        self,
-        tool: &DbTool<NodeTypesWithDBAdapter<N, Arc<DatabaseEnv>>>,
-    ) -> eyre::Result<()> {
-        warn!("This command should be run without the node running!");
-
-        match self.subcommand {
-            Subcommand::Mdbx { table, start_key, end_key, limit } => {
-                table.view(&ChecksumViewer { tool, start_key, end_key, limit })?;
-            }
-            Subcommand::StaticFile { segment, start_block, end_block, limit } => {
-                checksum_static_file(tool, segment, start_block, end_block, limit)?;
-            }
-            #[cfg(all(unix, feature = "edge"))]
-            Subcommand::Rocksdb { table, limit } => {
-                rocksdb::checksum_rocksdb(tool, table, limit)?;
-            }
-        }
-
-        Ok(())
-    }
-}
-
-/// Creates a new hasher with the standard seed used for checksum computation.
-fn checksum_hasher() -> impl Hasher {
-    FixedState::with_seed(u64::from_be_bytes(*b"RETHRETH")).build_hasher()
-}
-
-fn checksum_static_file<N: CliNodeTypes<ChainSpec: EthereumHardforks>>(
-    tool: &DbTool<NodeTypesWithDBAdapter<N, Arc<DatabaseEnv>>>,
-    segment: StaticFileSegment,
-    start_block: Option<u64>,
-    end_block: Option<u64>,
-    limit: Option<usize>,
-) -> eyre::Result<()> {
-    let static_file_provider = tool.provider_factory.static_file_provider();
-    if let Err(err) = static_file_provider.check_consistency(&tool.provider_factory.provider()?) {
-        warn!("Error checking consistency of static files: {err}");
-    }
-
-    let static_files = iter_static_files(static_file_provider.directory())?;
-
-    let ranges = static_files
-        .get(segment)
-        .ok_or_else(|| eyre::eyre!("No static files found for segment: {}", segment))?;
-
-    let start_time = Instant::now();
-    let mut hasher = checksum_hasher();
-    let mut total = 0usize;
-    let limit = limit.unwrap_or(usize::MAX);
-
-    let start_block = start_block.unwrap_or(0);
-    let end_block = end_block.unwrap_or(u64::MAX);
-
-    info!(
-        "Computing checksum for {} static files, start_block={}, end_block={}, limit={:?}",
-        segment,
-        start_block,
-        end_block,
-        if limit == usize::MAX { None } else { Some(limit) }
-    );
-
-    'outer: for (block_range, _header) in ranges.iter().sorted_by_key(|(range, _)| range.start()) {
-        if block_range.end() < start_block || block_range.start() > end_block {
-            continue;
-        }
-
-        let fixed_block_range = static_file_provider.find_fixed_range(segment, block_range.start());
-        let jar_provider = static_file_provider
-            .get_segment_provider_for_range(segment, || Some(fixed_block_range), None)?
-            .ok_or_else(|| {
-                eyre::eyre!(
-                    "Failed to get segment provider for segment {} at range {}",
-                    segment,
-                    block_range
-                )
-            })?;
-
-        let mut cursor = jar_provider.cursor()?;
-
-        while let Ok(Some(row)) = cursor.next_row() {
-            for col_data in row.iter() {
-                hasher.write(col_data);
-            }
-
-            total += 1;
-
-            if total.is_multiple_of(PROGRESS_LOG_INTERVAL) {
-                info!("Hashed {total} entries.");
-            }
-
-            if total >= limit {
-                break 'outer;
-            }
-        }
-
-        // Explicitly drop provider before removing from cache to avoid deadlock
-        drop(jar_provider);
-        static_file_provider.remove_cached_provider(segment, fixed_block_range.end());
-    }
-
-    let checksum = hasher.finish();
-    let elapsed = start_time.elapsed();
-
-    info!(
-        "Checksum for static file segment `{}`: {:#x} ({} entries, elapsed: {:?})",
-        segment, checksum, total, elapsed
-    );
-
-    Ok(())
-}
-
-pub(crate) struct ChecksumViewer<'a, N: NodeTypesWithDB> {
-    tool: &'a DbTool<N>,
-    start_key: Option<String>,
-    end_key: Option<String>,
-    limit: Option<usize>,
-}
-
-impl<N: NodeTypesWithDB> ChecksumViewer<'_, N> {
-    pub(crate) const fn new(tool: &'_ DbTool<N>) -> ChecksumViewer<'_, N> {
-        ChecksumViewer { tool, start_key: None, end_key: None, limit: None }
-    }
-}
-
-impl<N: ProviderNodeTypes> TableViewer<(u64, Duration)> for ChecksumViewer<'_, N> {
-    type Error = eyre::Report;
-
-    fn view<T: Table>(&self) -> Result<(u64, Duration), Self::Error> {
-        let provider =
-            self.tool.provider_factory.provider()?.disable_long_read_transaction_safety();
-        let tx = provider.tx_ref();
-        info!(
-            "Start computing checksum, start={:?}, end={:?}, limit={:?}",
-            self.start_key, self.end_key, self.limit
-        );
-
-        let mut cursor = tx.cursor_read::<RawTable<T>>()?;
-        let walker = match (self.start_key.as_deref(), self.end_key.as_deref()) {
-            (Some(start), Some(end)) => {
-                let start_key = table_key::<T>(start).map(RawKey::new)?;
-                let end_key = table_key::<T>(end).map(RawKey::new)?;
-                cursor.walk_range(start_key..=end_key)?
-            }
-            (None, Some(end)) => {
-                let end_key = table_key::<T>(end).map(RawKey::new)?;
-
-                cursor.walk_range(..=end_key)?
-            }
-            (Some(start), None) => {
-                let start_key = table_key::<T>(start).map(RawKey::new)?;
-                cursor.walk_range(start_key..)?
-            }
-            (None, None) => cursor.walk_range(..)?,
-        };
-
-        let start_time = Instant::now();
-        let mut hasher = checksum_hasher();
-        let mut total = 0;
-
-        let limit = self.limit.unwrap_or(usize::MAX);
-        let mut enumerate_start_key = None;
-        let mut enumerate_end_key = None;
-        for (index, entry) in walker.enumerate() {
-            let (k, v): (RawKey<T::Key>, RawValue<T::Value>) = entry?;
-
-            if index.is_multiple_of(PROGRESS_LOG_INTERVAL) {
-                info!("Hashed {index} entries.");
-            }
-
-            hasher.write(k.raw_key());
-            hasher.write(v.raw_value());
-
-            if enumerate_start_key.is_none() {
-                enumerate_start_key = Some(k.clone());
-            }
-            enumerate_end_key = Some(k);
-
-            total = index + 1;
-            if total >= limit {
-                break
-            }
-        }
-
-        info!("Hashed {total} entries.");
-        if let (Some(s), Some(e)) = (enumerate_start_key, enumerate_end_key) {
-            info!("start-key: {}", serde_json::to_string(&s.key()?).unwrap_or_default());
-            info!("end-key: {}", serde_json::to_string(&e.key()?).unwrap_or_default());
-        }
-
-        let checksum = hasher.finish();
-        let elapsed = start_time.elapsed();
-
-        info!("Checksum for table `{}`: {:#x} (elapsed: {:?})", T::NAME, checksum, elapsed);
-
-        Ok((checksum, elapsed))
-    }
-}

crates/cli/commands/src/db/checksum/rocksdb.rs

@@ -1,106 +0,0 @@
-//! RocksDB checksum implementation.
-
-use super::{checksum_hasher, PROGRESS_LOG_INTERVAL};
-use crate::common::CliNodeTypes;
-use clap::ValueEnum;
-use reth_chainspec::EthereumHardforks;
-use reth_db::{tables, DatabaseEnv};
-use reth_db_api::table::Table;
-use reth_db_common::DbTool;
-use reth_node_builder::NodeTypesWithDBAdapter;
-use reth_provider::RocksDBProviderFactory;
-use std::{hash::Hasher, sync::Arc, time::Instant};
-use tracing::info;
-
-/// RocksDB tables that can be checksummed.
-#[derive(Debug, Clone, Copy, ValueEnum)]
-pub enum RocksDbTable {
-    /// Transaction hash to transaction number mapping
-    TransactionHashNumbers,
-    /// Account history indices
-    AccountsHistory,
-    /// Storage history indices
-    StoragesHistory,
-}
-
-impl RocksDbTable {
-    /// Returns the table name as a string
-    const fn name(&self) -> &'static str {
-        match self {
-            Self::TransactionHashNumbers => tables::TransactionHashNumbers::NAME,
-            Self::AccountsHistory => tables::AccountsHistory::NAME,
-            Self::StoragesHistory => tables::StoragesHistory::NAME,
-        }
-    }
-}
-
-/// Computes a checksum for a RocksDB table.
-pub fn checksum_rocksdb<N: CliNodeTypes<ChainSpec: EthereumHardforks>>(
-    tool: &DbTool<NodeTypesWithDBAdapter<N, Arc<DatabaseEnv>>>,
-    table: RocksDbTable,
-    limit: Option<usize>,
-) -> eyre::Result<()> {
-    let rocksdb = tool.provider_factory.rocksdb_provider();
-
-    let start_time = Instant::now();
-    let limit = limit.unwrap_or(usize::MAX);
-
-    info!(
-        "Computing checksum for RocksDB table `{}`, limit={:?}",
-        table.name(),
-        if limit == usize::MAX { None } else { Some(limit) }
-    );
-
-    let (checksum, total) = match table {
-        RocksDbTable::TransactionHashNumbers => {
-            checksum_rocksdb_table::<tables::TransactionHashNumbers>(&rocksdb, limit)?
-        }
-        RocksDbTable::AccountsHistory => {
-            checksum_rocksdb_table::<tables::AccountsHistory>(&rocksdb, limit)?
-        }
-        RocksDbTable::StoragesHistory => {
-            checksum_rocksdb_table::<tables::StoragesHistory>(&rocksdb, limit)?
-        }
-    };
-
-    let elapsed = start_time.elapsed();
-
-    info!(
-        "Checksum for RocksDB table `{}`: {:#x} ({} entries, elapsed: {:?})",
-        table.name(),
-        checksum,
-        total,
-        elapsed
-    );
-
-    Ok(())
-}
-
-/// Computes checksum for a specific RocksDB table by iterating over rows.
-fn checksum_rocksdb_table<T: Table>(
-    rocksdb: &reth_provider::providers::RocksDBProvider,
-    limit: usize,
-) -> eyre::Result<(u64, usize)> {
-    let iter = rocksdb.raw_iter::<T>()?;
-    let mut hasher = checksum_hasher();
-    let mut total = 0usize;
-
-    for entry in iter {
-        let (key_bytes, value_bytes) = entry?;
-
-        hasher.write(&key_bytes);
-        hasher.write(&value_bytes);
-
-        total += 1;
-
-        if total.is_multiple_of(PROGRESS_LOG_INTERVAL) {
-            info!("Hashed {total} entries.");
-        }
-
-        if total >= limit {
-            break;
-        }
-    }
-
-    Ok((hasher.finish(), total))
-}

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

@@ -21,7 +21,6 @@ use reth_node_builder::NodeTypesWithDB;
 use reth_primitives_traits::ValueWithSubKey;
 use reth_provider::{providers::ProviderNodeTypes, ChangeSetReader, StaticFileProviderFactory};
 use reth_static_file_types::StaticFileSegment;
-use reth_storage_api::StorageChangeSetReader;
 use tracing::error;
 
 /// The arguments for the `reth db get` command
@@ -83,33 +82,6 @@ impl Command {
                 table.view(&GetValueViewer { tool, key, subkey, end_key, end_subkey, raw })?
             }
             Subcommand::StaticFile { segment, key, subkey, raw } => {
-                if let StaticFileSegment::StorageChangeSets = segment {
-                    let storage_key =
-                        table_subkey::<tables::StorageChangeSets>(subkey.as_deref()).ok();
-                    let key = table_key::<tables::StorageChangeSets>(&key)?;
-
-                    let provider = tool.provider_factory.static_file_provider();
-
-                    if let Some(storage_key) = storage_key {
-                        let entry = provider.get_storage_before_block(
-                            key.block_number(),
-                            key.address(),
-                            storage_key,
-                        )?;
-
-                        if let Some(entry) = entry {
-                            println!("{}", serde_json::to_string_pretty(&entry)?);
-                        } else {
-                            error!(target: "reth::cli", "No content for the given table key.");
-                        }
-                        return Ok(());
-                    }
-
-                    let changesets = provider.storage_changeset(key.block_number())?;
-                    println!("{}", serde_json::to_string_pretty(&changesets)?);
-                    return Ok(());
-                }
-
                 let (key, subkey, mask): (u64, _, _) = match segment {
                     StaticFileSegment::Headers => (
                         table_key::<tables::Headers>(&key)?,
@@ -140,9 +112,6 @@ impl Command {
                             AccountChangesetMask::MASK,
                         )
                     }
-                    StaticFileSegment::StorageChangeSets => {
-                        unreachable!("storage changesets handled above");
-                    }
                 };
 
                 // handle account changesets differently if a subkey is provided.
@@ -221,9 +190,6 @@ impl Command {
                                 StaticFileSegment::AccountChangeSets => {
                                     unreachable!("account changeset static files are special cased before this match")
                                 }
-                                StaticFileSegment::StorageChangeSets => {
-                                    unreachable!("storage changeset static files are special cased before this match")
-                                }
                             }
                         }
                     }

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

@@ -61,21 +61,19 @@ impl Command {
     }
 
     /// Generate [`ListFilter`] from command.
-    pub fn list_filter(&self) -> eyre::Result<ListFilter> {
-        let search = match self.search.as_deref() {
-            Some(search) => {
+    pub fn list_filter(&self) -> ListFilter {
+        let search = self
+            .search
+            .as_ref()
+            .map(|search| {
                 if let Some(search) = search.strip_prefix("0x") {
-                    hex::decode(search).wrap_err(
-                        "Invalid hex content after 0x prefix in --search (expected valid hex like 0xdeadbeef).",
-                    )?
-                } else {
-                    search.as_bytes().to_vec()
+                    return hex::decode(search).unwrap()
                 }
-            }
-            None => Vec::new(),
-        };
+                search.as_bytes().to_vec()
+            })
+            .unwrap_or_default();
 
-        Ok(ListFilter {
+        ListFilter {
             skip: self.skip,
             len: self.len,
             search,
@@ -84,7 +82,7 @@ impl Command {
             min_value_size: self.min_value_size,
             reverse: self.reverse,
             only_count: self.count,
-        })
+        }
     }
 }
 
@@ -102,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 {
@@ -117,7 +115,7 @@ impl<N: NodeTypes> TableViewer<()> for ListTableViewer<'_, N> {
             }
 
 
-            let list_filter = self.args.list_filter()?;
+            let list_filter = self.args.list_filter();
 
             if self.args.json || self.args.count {
                 let (list, count) = self.tool.list::<T>(&list_filter)?;

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

@@ -39,7 +39,7 @@ pub enum Subcommands {
     Stats(stats::Command),
     /// Lists the contents of a table
     List(list::Command),
-    /// Calculates the content checksum of a table or static file segment
+    /// Calculates the content checksum of a table
     Checksum(checksum::Command),
     /// Create a diff between two database tables or two entire databases.
     Diff(diff::Command),
@@ -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, &data_dir)?;
+                    command.execute(&tool, ctx.task_executor.clone(), &data_dir)?;
                 });
             }
             Subcommands::StaticFileHeader(command) => {

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

@@ -54,26 +54,6 @@ pub enum SetCommand {
         #[clap(action(ArgAction::Set))]
         value: bool,
     },
-    /// Store storage history in rocksdb instead of MDBX
-    StoragesHistory {
-        #[clap(action(ArgAction::Set))]
-        value: bool,
-    },
-    /// Store transaction hash to number mapping in rocksdb instead of MDBX
-    TransactionHashNumbers {
-        #[clap(action(ArgAction::Set))]
-        value: bool,
-    },
-    /// Store account history in rocksdb instead of MDBX
-    AccountHistory {
-        #[clap(action(ArgAction::Set))]
-        value: bool,
-    },
-    /// Store storage changesets in static files instead of the database
-    StorageChangesets {
-        #[clap(action(ArgAction::Set))]
-        value: bool,
-    },
 }
 
 impl Command {
@@ -120,7 +100,6 @@ impl Command {
             transaction_hash_numbers_in_rocksdb: _,
             account_history_in_rocksdb: _,
             account_changesets_in_static_files: _,
-            storage_changesets_in_static_files: _,
         } = settings.unwrap_or_else(StorageSettings::legacy);
 
         // Update the setting based on the key
@@ -149,38 +128,6 @@ impl Command {
                 settings.account_changesets_in_static_files = value;
                 println!("Set account_changesets_in_static_files = {}", value);
             }
-            SetCommand::StoragesHistory { value } => {
-                if settings.storages_history_in_rocksdb == value {
-                    println!("storages_history_in_rocksdb is already set to {}", value);
-                    return Ok(());
-                }
-                settings.storages_history_in_rocksdb = value;
-                println!("Set storages_history_in_rocksdb = {}", value);
-            }
-            SetCommand::TransactionHashNumbers { value } => {
-                if settings.transaction_hash_numbers_in_rocksdb == value {
-                    println!("transaction_hash_numbers_in_rocksdb is already set to {}", value);
-                    return Ok(());
-                }
-                settings.transaction_hash_numbers_in_rocksdb = value;
-                println!("Set transaction_hash_numbers_in_rocksdb = {}", value);
-            }
-            SetCommand::AccountHistory { value } => {
-                if settings.account_history_in_rocksdb == value {
-                    println!("account_history_in_rocksdb is already set to {}", value);
-                    return Ok(());
-                }
-                settings.account_history_in_rocksdb = value;
-                println!("Set account_history_in_rocksdb = {}", value);
-            }
-            SetCommand::StorageChangesets { value } => {
-                if settings.storage_changesets_in_static_files == value {
-                    println!("storage_changesets_in_static_files is already set to {}", value);
-                    return Ok(());
-                }
-                settings.storage_changesets_in_static_files = value;
-                println!("Set storage_changesets_in_static_files = {}", value);
-            }
         }
 
         // Write updated settings

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

@@ -11,10 +11,7 @@ use reth_db_common::DbTool;
 use reth_fs_util as fs;
 use reth_node_builder::{NodePrimitives, NodeTypesWithDB, NodeTypesWithDBAdapter};
 use reth_node_core::dirs::{ChainPath, DataDirPath};
-use reth_provider::{
-    providers::{ProviderNodeTypes, StaticFileProvider},
-    RocksDBProviderFactory,
-};
+use reth_provider::providers::{ProviderNodeTypes, StaticFileProvider};
 use reth_static_file_types::SegmentRangeInclusive;
 use std::{sync::Arc, time::Duration};
 
@@ -64,11 +61,6 @@ impl Command {
         let db_stats_table = self.db_stats_table(tool)?;
         println!("{db_stats_table}");
 
-        println!("\n");
-
-        let rocksdb_stats_table = self.rocksdb_stats_table(tool);
-        println!("{rocksdb_stats_table}");
-
         Ok(())
     }
 
@@ -96,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
@@ -137,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();
@@ -156,70 +147,6 @@ impl Command {
         Ok(table)
     }
 
-    fn rocksdb_stats_table<N: NodeTypesWithDB>(&self, tool: &DbTool<N>) -> ComfyTable {
-        let mut table = ComfyTable::new();
-        table.load_preset(comfy_table::presets::ASCII_MARKDOWN);
-        table.set_header([
-            "RocksDB Table Name",
-            "# Entries",
-            "SST Size",
-            "Memtable Size",
-            "Total Size",
-            "Pending Compaction",
-        ]);
-
-        let stats = tool.provider_factory.rocksdb_provider().table_stats();
-        let mut total_sst: u64 = 0;
-        let mut total_memtable: u64 = 0;
-        let mut total_size: u64 = 0;
-        let mut total_pending: u64 = 0;
-
-        for stat in &stats {
-            total_sst += stat.sst_size_bytes;
-            total_memtable += stat.memtable_size_bytes;
-            total_size += stat.estimated_size_bytes;
-            total_pending += stat.pending_compaction_bytes;
-            let mut row = Row::new();
-            row.add_cell(Cell::new(&stat.name))
-                .add_cell(Cell::new(stat.estimated_num_keys))
-                .add_cell(Cell::new(human_bytes(stat.sst_size_bytes as f64)))
-                .add_cell(Cell::new(human_bytes(stat.memtable_size_bytes as f64)))
-                .add_cell(Cell::new(human_bytes(stat.estimated_size_bytes as f64)))
-                .add_cell(Cell::new(human_bytes(stat.pending_compaction_bytes as f64)));
-            table.add_row(row);
-        }
-
-        if !stats.is_empty() {
-            let max_widths = table.column_max_content_widths();
-            let mut separator = Row::new();
-            for width in max_widths {
-                separator.add_cell(Cell::new("-".repeat(width as usize)));
-            }
-            table.add_row(separator);
-
-            let mut row = Row::new();
-            row.add_cell(Cell::new("RocksDB Total"))
-                .add_cell(Cell::new(""))
-                .add_cell(Cell::new(human_bytes(total_sst as f64)))
-                .add_cell(Cell::new(human_bytes(total_memtable as f64)))
-                .add_cell(Cell::new(human_bytes(total_size as f64)))
-                .add_cell(Cell::new(human_bytes(total_pending as f64)));
-            table.add_row(row);
-
-            let wal_size = tool.provider_factory.rocksdb_provider().wal_size_bytes();
-            let mut row = Row::new();
-            row.add_cell(Cell::new("WAL"))
-                .add_cell(Cell::new(""))
-                .add_cell(Cell::new(""))
-                .add_cell(Cell::new(""))
-                .add_cell(Cell::new(human_bytes(wal_size as f64)))
-                .add_cell(Cell::new(""));
-            table.add_row(row);
-        }
-
-        table
-    }
-
     fn static_files_stats_table<N: NodePrimitives>(
         &self,
         data_dir: ChainPath<DataDirPath>,

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());
-    }
 }

crates/cli/commands/src/import.rs

@@ -26,14 +26,6 @@ pub struct ImportCommand<C: ChainSpecParser> {
     #[arg(long, value_name = "CHUNK_LEN", verbatim_doc_comment)]
     chunk_len: Option<u64>,
 
-    /// Fail immediately when an invalid block is encountered.
-    ///
-    /// By default, the import will stop at the last valid block if an invalid block is
-    /// encountered during execution or validation, leaving the database at the last valid
-    /// block state. When this flag is set, the import will instead fail with an error.
-    #[arg(long, verbatim_doc_comment)]
-    fail_on_invalid_block: bool,
-
     /// The path(s) to block file(s) for import.
     ///
     /// The online stages (headers and bodies) are replaced by a file import, after which the
@@ -60,11 +52,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> ImportComm
 
         info!(target: "reth::cli", "Starting import of {} file(s)", self.paths.len());
 
-        let import_config = ImportConfig {
-            no_state: self.no_state,
-            chunk_len: self.chunk_len,
-            fail_on_invalid_block: self.fail_on_invalid_block,
-        };
+        let import_config = ImportConfig { no_state: self.no_state, chunk_len: self.chunk_len };
 
         let executor = components.evm_config().clone();
         let consensus = Arc::new(components.consensus().clone());
@@ -93,20 +81,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> ImportComm
             total_decoded_blocks += result.total_decoded_blocks;
             total_decoded_txns += result.total_decoded_txns;
 
-            // Check if we stopped due to an invalid block
-            if result.stopped_on_invalid_block {
-                info!(target: "reth::cli",
-                      "Stopped at last valid block {} due to invalid block {} in file: {}. Imported {} blocks, {} transactions",
-                      result.last_valid_block.unwrap_or(0),
-                      result.bad_block.unwrap_or(0),
-                      path.display(),
-                      result.total_imported_blocks,
-                      result.total_imported_txns);
-                // Stop importing further files and exit successfully
-                break;
-            }
-
-            if !result.is_successful() {
+            if !result.is_complete() {
                 return Err(eyre::eyre!(
                     "Chain was partially imported from file: {}. Imported {}/{} blocks, {}/{} transactions",
                     path.display(),
@@ -123,7 +98,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> ImportComm
         }
 
         info!(target: "reth::cli",
-              "Import complete. Total: {}/{} blocks, {}/{} transactions",
+              "All files imported successfully. Total: {}/{} blocks, {}/{} transactions",
               total_imported_blocks, total_decoded_blocks, total_imported_txns, total_decoded_txns);
 
         Ok(())
@@ -164,20 +139,4 @@ mod tests {
         assert_eq!(args.paths[1], PathBuf::from("file2.rlp"));
         assert_eq!(args.paths[2], PathBuf::from("file3.rlp"));
     }
-
-    #[test]
-    fn parse_import_command_with_fail_on_invalid_block() {
-        let args: ImportCommand<EthereumChainSpecParser> =
-            ImportCommand::parse_from(["reth", "--fail-on-invalid-block", "chain.rlp"]);
-        assert!(args.fail_on_invalid_block);
-        assert_eq!(args.paths.len(), 1);
-        assert_eq!(args.paths[0], PathBuf::from("chain.rlp"));
-    }
-
-    #[test]
-    fn parse_import_command_default_stops_on_invalid_block() {
-        let args: ImportCommand<EthereumChainSpecParser> =
-            ImportCommand::parse_from(["reth", "chain.rlp"]);
-        assert!(!args.fail_on_invalid_block);
-    }
 }

crates/cli/commands/src/import_core.rs

@@ -22,11 +22,11 @@ use reth_provider::{
     StageCheckpointReader,
 };
 use reth_prune::PruneModes;
-use reth_stages::{prelude::*, ControlFlow, Pipeline, StageId, StageSet};
+use reth_stages::{prelude::*, Pipeline, StageId, StageSet};
 use reth_static_file::StaticFileProducer;
 use std::{path::Path, sync::Arc};
 use tokio::sync::watch;
-use tracing::{debug, error, info, warn};
+use tracing::{debug, error, info};
 
 /// Configuration for importing blocks from RLP files.
 #[derive(Debug, Clone, Default)]
@@ -35,9 +35,6 @@ pub struct ImportConfig {
     pub no_state: bool,
     /// Chunk byte length to read from file.
     pub chunk_len: Option<u64>,
-    /// If true, fail immediately when an invalid block is encountered.
-    /// By default (false), the import stops at the last valid block and exits successfully.
-    pub fail_on_invalid_block: bool,
 }
 
 /// Result of an import operation.
@@ -51,12 +48,6 @@ pub struct ImportResult {
     pub total_imported_blocks: usize,
     /// Total number of transactions imported into the database.
     pub total_imported_txns: usize,
-    /// Whether the import was stopped due to an invalid block.
-    pub stopped_on_invalid_block: bool,
-    /// The block number that was invalid, if any.
-    pub bad_block: Option<u64>,
-    /// The last valid block number when stopped due to invalid block.
-    pub last_valid_block: Option<u64>,
 }
 
 impl ImportResult {
@@ -65,14 +56,6 @@ impl ImportResult {
         self.total_decoded_blocks == self.total_imported_blocks &&
             self.total_decoded_txns == self.total_imported_txns
     }
-
-    /// Returns true if the import was successful, considering stop-on-invalid-block mode.
-    ///
-    /// In stop-on-invalid-block mode, a partial import is considered successful if we
-    /// stopped due to an invalid block (leaving the DB at the last valid block).
-    pub fn is_successful(&self) -> bool {
-        self.is_complete() || self.stopped_on_invalid_block
-    }
 }
 
 /// Imports blocks from an RLP-encoded file into the database.
@@ -120,11 +103,6 @@ where
     let static_file_producer =
         StaticFileProducer::new(provider_factory.clone(), PruneModes::default());
 
-    // Track if we stopped due to an invalid block
-    let mut stopped_on_invalid_block = false;
-    let mut bad_block_number: Option<u64> = None;
-    let mut last_valid_block_number: Option<u64> = None;
-
     while let Some(file_client) =
         reader.next_chunk::<BlockTy<N>>(consensus.clone(), Some(sealed_header)).await?
     {
@@ -159,51 +137,12 @@ where
 
         // Run pipeline
         info!(target: "reth::import", "Starting sync pipeline");
-        if import_config.fail_on_invalid_block {
-            // Original behavior: fail on unwind
-            tokio::select! {
-                res = pipeline.run() => res?,
-                _ = tokio::signal::ctrl_c() => {
-                    info!(target: "reth::import", "Import interrupted by user");
-                    break;
-                },
-            }
-        } else {
-            // Default behavior: Use run_loop() to handle unwinds gracefully
-            let result = tokio::select! {
-                res = pipeline.run_loop() => res,
-                _ = tokio::signal::ctrl_c() => {
-                    info!(target: "reth::import", "Import interrupted by user");
-                    break;
-                },
-            };
-
-            match result {
-                Ok(ControlFlow::Unwind { target, bad_block }) => {
-                    // An invalid block was encountered; stop at last valid block
-                    let bad = bad_block.block.number;
-                    warn!(
-                        target: "reth::import",
-                        bad_block = bad,
-                        last_valid_block = target,
-                        "Invalid block encountered during import; stopping at last valid block"
-                    );
-                    stopped_on_invalid_block = true;
-                    bad_block_number = Some(bad);
-                    last_valid_block_number = Some(target);
-                    break;
-                }
-                Ok(ControlFlow::Continue { block_number }) => {
-                    debug!(target: "reth::import", block_number, "Pipeline chunk completed");
-                }
-                Ok(ControlFlow::NoProgress { block_number }) => {
-                    debug!(target: "reth::import", ?block_number, "Pipeline made no progress");
-                }
-                Err(e) => {
-                    // Propagate other pipeline errors
-                    return Err(e.into());
-                }
-            }
+        tokio::select! {
+            res = pipeline.run() => res?,
+            _ = tokio::signal::ctrl_c() => {
+                info!(target: "reth::import", "Import interrupted by user");
+                break;
+            },
         }
 
         sealed_header = provider_factory
@@ -221,20 +160,9 @@ where
         total_decoded_txns,
         total_imported_blocks,
         total_imported_txns,
-        stopped_on_invalid_block,
-        bad_block: bad_block_number,
-        last_valid_block: last_valid_block_number,
     };
 
-    if result.stopped_on_invalid_block {
-        info!(target: "reth::import",
-            total_imported_blocks,
-            total_imported_txns,
-            bad_block = ?result.bad_block,
-            last_valid_block = ?result.last_valid_block,
-            "Import stopped at last valid block due to invalid block"
-        );
-    } else if !result.is_complete() {
+    if !result.is_complete() {
         error!(target: "reth::import",
             total_decoded_blocks,
             total_imported_blocks,

crates/cli/commands/src/node.rs

@@ -10,8 +10,7 @@ use reth_node_builder::NodeBuilder;
 use reth_node_core::{
     args::{
         DatabaseArgs, DatadirArgs, DebugArgs, DevArgs, EngineArgs, EraArgs, MetricArgs,
-        NetworkArgs, PayloadBuilderArgs, PruningArgs, RocksDbArgs, RpcServerArgs, StaticFilesArgs,
-        TxPoolArgs,
+        NetworkArgs, PayloadBuilderArgs, PruningArgs, RpcServerArgs, StaticFilesArgs, TxPoolArgs,
     },
     node_config::NodeConfig,
     version,
@@ -103,10 +102,6 @@ pub struct NodeCommand<C: ChainSpecParser, Ext: clap::Args + fmt::Debug = NoArgs
     #[command(flatten)]
     pub pruning: PruningArgs,
 
-    /// All `RocksDB` table routing arguments
-    #[command(flatten)]
-    pub rocksdb: RocksDbArgs,
-
     /// Engine cli arguments
     #[command(flatten, next_help_heading = "Engine")]
     pub engine: EngineArgs,
@@ -171,16 +166,12 @@ where
             db,
             dev,
             pruning,
-            rocksdb,
             engine,
             era,
             static_files,
             ext,
         } = self;
 
-        // Validate RocksDB arguments
-        rocksdb.validate()?;
-
         // set up node config
         let mut node_config = NodeConfig {
             datadir,
@@ -196,7 +187,6 @@ where
             db,
             dev,
             pruning,
-            rocksdb,
             engine,
             era,
             static_files,

crates/cli/commands/src/p2p/enode.rs

@@ -1,34 +0,0 @@
-//! Enode identifier command
-
-use clap::Parser;
-use reth_cli_util::get_secret_key;
-use reth_network_peers::NodeRecord;
-use std::{
-    net::{IpAddr, Ipv4Addr, SocketAddr},
-    path::PathBuf,
-};
-
-/// Print the enode identifier for a given secret key.
-#[derive(Parser, Debug)]
-pub struct Command {
-    /// Path to the secret key file for discovery.
-    pub discovery_secret: PathBuf,
-
-    /// Optional IP address to include in the enode URL.
-    ///
-    /// If not provided, defaults to 0.0.0.0.
-    #[arg(long)]
-    pub ip: Option<IpAddr>,
-}
-
-impl Command {
-    /// Execute the enode command.
-    pub fn execute(self) -> eyre::Result<()> {
-        let sk = get_secret_key(&self.discovery_secret)?;
-        let ip = self.ip.unwrap_or(IpAddr::V4(Ipv4Addr::UNSPECIFIED));
-        let addr = SocketAddr::new(ip, 30303);
-        let enr = NodeRecord::from_secret_key(addr, &sk);
-        println!("{enr}");
-        Ok(())
-    }
-}

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

@@ -18,7 +18,6 @@ use reth_node_core::{
 };
 
 pub mod bootnode;
-pub mod enode;
 pub mod rlpx;
 
 /// `reth p2p` command
@@ -86,9 +85,6 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
             Subcommands::Bootnode(command) => {
                 command.execute().await?;
             }
-            Subcommands::Enode(command) => {
-                command.execute()?;
-            }
         }
 
         Ok(())
@@ -103,7 +99,6 @@ impl<C: ChainSpecParser> Command<C> {
             Subcommands::Body { args, .. } => Some(&args.chain),
             Subcommands::Rlpx(_) => None,
             Subcommands::Bootnode(_) => None,
-            Subcommands::Enode(_) => None,
         }
     }
 }
@@ -131,8 +126,6 @@ pub enum Subcommands<C: ChainSpecParser> {
     Rlpx(rlpx::Command),
     /// Bootnode command
     Bootnode(bootnode::Command),
-    /// Print enode identifier
-    Enode(enode::Command),
 }
 
 #[derive(Debug, Clone, Parser)]
@@ -232,16 +225,4 @@ mod tests {
         let _args: Command<EthereumChainSpecParser> =
             Command::parse_from(["reth", "body", "--chain", "mainnet", "1000"]);
     }
-
-    #[test]
-    fn parse_enode_cmd() {
-        let _args: Command<EthereumChainSpecParser> =
-            Command::parse_from(["reth", "enode", "/tmp/secret"]);
-    }
-
-    #[test]
-    fn parse_enode_cmd_with_ip() {
-        let _args: Command<EthereumChainSpecParser> =
-            Command::parse_from(["reth", "enode", "/tmp/secret", "--ip", "192.168.1.1"]);
-    }
 }

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())
                         })

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

@@ -15,8 +15,7 @@ use reth_db_common::{
 use reth_node_api::{HeaderTy, ReceiptTy, TxTy};
 use reth_node_core::args::StageEnum;
 use reth_provider::{
-    DBProvider, RocksDBProviderFactory, StaticFileProviderFactory, StaticFileWriter,
-    StorageSettingsCache,
+    DBProvider, DatabaseProviderFactory, StaticFileProviderFactory, StaticFileWriter, TrieWriter,
 };
 use reth_prune::PruneSegment;
 use reth_stages::StageId;
@@ -91,14 +90,11 @@ impl<C: ChainSpecParser> Command<C> {
                     StaticFileSegment::AccountChangeSets => {
                         writer.prune_account_changesets(highest_block)?;
                     }
-                    StaticFileSegment::StorageChangeSets => {
-                        writer.prune_storage_changesets(highest_block)?;
-                    }
                 }
             }
         }
 
-        let provider_rw = tool.provider_factory.unwind_provider_rw()?;
+        let provider_rw = tool.provider_factory.database_provider_rw()?;
         let tx = provider_rw.tx_ref();
 
         match self.stage {
@@ -171,21 +167,13 @@ impl<C: ChainSpecParser> Command<C> {
                     None,
                 )?;
             }
+            StageEnum::MerkleChangeSets => {
+                provider_rw.clear_trie_changesets()?;
+                reset_stage_checkpoint(tx, StageId::MerkleChangeSets)?;
+            }
             StageEnum::AccountHistory | StageEnum::StorageHistory => {
-                let settings = provider_rw.cached_storage_settings();
-                let rocksdb = tool.provider_factory.rocksdb_provider();
-
-                if settings.account_history_in_rocksdb {
-                    rocksdb.clear::<tables::AccountsHistory>()?;
-                } else {
-                    tx.clear::<tables::AccountsHistory>()?;
-                }
-
-                if settings.storages_history_in_rocksdb {
-                    rocksdb.clear::<tables::StoragesHistory>()?;
-                } else {
-                    tx.clear::<tables::StoragesHistory>()?;
-                }
+                tx.clear::<tables::AccountsHistory>()?;
+                tx.clear::<tables::StoragesHistory>()?;
 
                 reset_stage_checkpoint(tx, StageId::IndexAccountHistory)?;
                 reset_stage_checkpoint(tx, StageId::IndexStorageHistory)?;
@@ -193,14 +181,7 @@ impl<C: ChainSpecParser> Command<C> {
                 insert_genesis_history(&provider_rw, self.env.chain.genesis().alloc.iter())?;
             }
             StageEnum::TxLookup => {
-                if provider_rw.cached_storage_settings().transaction_hash_numbers_in_rocksdb {
-                    tool.provider_factory
-                        .rocksdb_provider()
-                        .clear::<tables::TransactionHashNumbers>()?;
-                } else {
-                    tx.clear::<tables::TransactionHashNumbers>()?;
-                }
-
+                tx.clear::<tables::TransactionHashNumbers>()?;
                 reset_prune_checkpoint(tx, PruneSegment::TransactionLookup)?;
 
                 reset_stage_checkpoint(tx, StageId::TransactionLookup)?;

crates/cli/util/src/sigsegv_handler.rs

@@ -121,16 +121,7 @@ pub fn install() {
     unsafe {
         let alt_stack_size: usize = min_sigstack_size() + 64 * 1024;
         let mut alt_stack: libc::stack_t = mem::zeroed();
-        // Both SysV AMD64 ABI and aarch64 ABI require 16 bytes alignment. We are going to be
-        // generous here and just use a size of a page.
-        let raw_page_sz = libc::sysconf(libc::_SC_PAGESIZE);
-        let page_sz = if raw_page_sz == -1 {
-            // Fallback alignment in case sysconf fails.
-            4096_usize
-        } else {
-            raw_page_sz as usize
-        };
-        alt_stack.ss_sp = alloc(Layout::from_size_align(alt_stack_size, page_sz).unwrap()).cast();
+        alt_stack.ss_sp = alloc(Layout::from_size_align(alt_stack_size, 1).unwrap()).cast();
         alt_stack.ss_size = alt_stack_size;
         libc::sigaltstack(&raw const alt_stack, ptr::null_mut());
 

crates/config/src/config.rs

@@ -438,8 +438,6 @@ pub struct BlocksPerFileConfig {
     pub transaction_senders: Option<u64>,
     /// Number of blocks per file for the account changesets segment.
     pub account_change_sets: Option<u64>,
-    /// Number of blocks per file for the storage changesets segment.
-    pub storage_change_sets: Option<u64>,
 }
 
 impl StaticFilesConfig {
@@ -453,7 +451,6 @@ impl StaticFilesConfig {
             receipts,
             transaction_senders,
             account_change_sets,
-            storage_change_sets,
         } = self.blocks_per_file;
         eyre::ensure!(headers != Some(0), "Headers segment blocks per file must be greater than 0");
         eyre::ensure!(
@@ -472,10 +469,6 @@ impl StaticFilesConfig {
             account_change_sets != Some(0),
             "Account changesets segment blocks per file must be greater than 0"
         );
-        eyre::ensure!(
-            storage_change_sets != Some(0),
-            "Storage changesets segment blocks per file must be greater than 0"
-        );
         Ok(())
     }
 
@@ -487,7 +480,6 @@ impl StaticFilesConfig {
             receipts,
             transaction_senders,
             account_change_sets,
-            storage_change_sets,
         } = self.blocks_per_file;
 
         let mut map = StaticFileMap::default();
@@ -500,7 +492,6 @@ impl StaticFilesConfig {
                 StaticFileSegment::Receipts => receipts,
                 StaticFileSegment::TransactionSenders => transaction_senders,
                 StaticFileSegment::AccountChangeSets => account_change_sets,
-                StaticFileSegment::StorageChangeSets => storage_change_sets,
             };
 
             if let Some(blocks_per_file) = blocks_per_file {
@@ -559,6 +550,7 @@ impl PruneConfig {
     /// - `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 {
@@ -571,6 +563,7 @@ impl PruneConfig {
                     account_history,
                     storage_history,
                     bodies_history,
+                    merkle_changesets,
                     receipts_log_filter,
                 },
         } = other;
@@ -587,6 +580,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;
@@ -1096,6 +1091,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,
@@ -1112,6 +1108,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)),
@@ -1130,6 +1127,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);
     }
 

crates/consensus/common/src/validation.rs

@@ -1,11 +1,14 @@
 //! Collection of methods for block validation.
 
-use alloy_consensus::{BlockHeader as _, EMPTY_OMMER_ROOT_HASH};
+use alloy_consensus::{BlockHeader as _, Transaction, EMPTY_OMMER_ROOT_HASH};
 use alloy_eips::{eip4844::DATA_GAS_PER_BLOB, eip7840::BlobParams};
 use reth_chainspec::{EthChainSpec, EthereumHardfork, EthereumHardforks};
-use reth_consensus::ConsensusError;
+use reth_consensus::{ConsensusError, TxGasLimitTooHighErr};
 use reth_primitives_traits::{
-    constants::{GAS_LIMIT_BOUND_DIVISOR, MAXIMUM_GAS_LIMIT_BLOCK, MINIMUM_GAS_LIMIT},
+    constants::{
+        GAS_LIMIT_BOUND_DIVISOR, MAXIMUM_GAS_LIMIT_BLOCK, MAX_TX_GAS_LIMIT_OSAKA, MINIMUM_GAS_LIMIT,
+    },
+    transaction::TxHashRef,
     Block, BlockBody, BlockHeader, GotExpected, SealedBlock, SealedHeader,
 };
 
@@ -143,7 +146,7 @@ pub fn validate_block_pre_execution<B, ChainSpec>(
 ) -> Result<(), ConsensusError>
 where
     B: Block,
-    ChainSpec: EthChainSpec + EthereumHardforks,
+    ChainSpec: EthereumHardforks,
 {
     post_merge_hardfork_fields(block, chain_spec)?;
 
@@ -151,6 +154,19 @@ where
     if let Err(error) = block.ensure_transaction_root_valid() {
         return Err(ConsensusError::BodyTransactionRootDiff(error.into()))
     }
+    // EIP-7825 validation
+    if chain_spec.is_osaka_active_at_timestamp(block.timestamp()) {
+        for tx in block.body().transactions() {
+            if tx.gas_limit() > MAX_TX_GAS_LIMIT_OSAKA {
+                return Err(TxGasLimitTooHighErr {
+                    tx_hash: *tx.tx_hash(),
+                    gas_limit: tx.gas_limit(),
+                    max_allowed: MAX_TX_GAS_LIMIT_OSAKA,
+                }
+                .into());
+            }
+        }
+    }
 
     Ok(())
 }

crates/consensus/consensus/src/lib.rs

@@ -15,12 +15,6 @@ use alloc::{boxed::Box, fmt::Debug, string::String, sync::Arc, 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,15 +39,11 @@ 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>;
 }
 

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};
@@ -76,7 +76,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(())
     }

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)

crates/e2e-test-utils/Cargo.toml

@@ -72,11 +72,3 @@ derive_more.workspace = true
 [[test]]
 name = "e2e_testsuite"
 path = "tests/e2e-testsuite/main.rs"
-
-[[test]]
-name = "rocksdb"
-path = "tests/rocksdb/main.rs"
-required-features = ["edge"]
-
-[features]
-edge = ["reth-node-core/edge", "reth-provider/rocksdb", "reth-cli-commands/edge"]

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

@@ -103,10 +103,7 @@ where
     N: NodeBuilderHelper,
 {
     E2ETestSetupBuilder::new(num_nodes, chain_spec, attributes_generator)
-        .with_tree_config_modifier(move |base| {
-            // Apply caller's tree_config but preserve the small cache size from base
-            tree_config.clone().with_cross_block_cache_size(base.cross_block_cache_size())
-        })
+        .with_tree_config_modifier(move |_| tree_config.clone())
         .with_node_config_modifier(move |config| config.set_dev(is_dev))
         .with_connect_nodes(connect_nodes)
         .build()

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

@@ -112,13 +112,11 @@ where
             ..NetworkArgs::default()
         };
 
-        // Apply tree config modifier if present, with test-appropriate defaults
-        let base_tree_config =
-            reth_node_api::TreeConfig::default().with_cross_block_cache_size(1024 * 1024);
+        // Apply tree config modifier if present
         let tree_config = if let Some(modifier) = self.tree_config_modifier {
-            modifier(base_tree_config)
+            modifier(reth_node_api::TreeConfig::default())
         } else {
-            base_tree_config
+            reth_node_api::TreeConfig::default()
         };
 
         let mut nodes = (0..self.num_nodes)

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

@@ -38,18 +38,6 @@ impl TransactionTestContext {
         signed.encoded_2718().into()
     }
 
-    /// Creates a transfer with a specific nonce and signs it, returning bytes.
-    /// Uses high `max_fee_per_gas` (1000 gwei) to ensure tx acceptance regardless of basefee.
-    pub async fn transfer_tx_bytes_with_nonce(
-        chain_id: u64,
-        wallet: PrivateKeySigner,
-        nonce: u64,
-    ) -> Bytes {
-        let tx = tx(chain_id, 21000, None, None, nonce, Some(1000e9 as u128));
-        let signed = Self::sign_tx(wallet, tx).await;
-        signed.encoded_2718().into()
-    }
-
     /// Creates a deployment transaction and signs it, returning an envelope.
     pub async fn deploy_tx(
         chain_id: u64,

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

@@ -1,470 +0,0 @@
-//! E2E tests for `RocksDB` provider functionality.
-
-#![cfg(all(feature = "edge", unix))]
-
-use alloy_consensus::BlockHeader;
-use alloy_primitives::B256;
-use alloy_rpc_types_eth::{Transaction, TransactionReceipt};
-use eyre::Result;
-use jsonrpsee::core::client::ClientT;
-use reth_chainspec::{ChainSpec, ChainSpecBuilder, MAINNET};
-use reth_db::tables;
-use reth_e2e_test_utils::{transaction::TransactionTestContext, wallet, E2ETestSetupBuilder};
-use reth_node_builder::NodeConfig;
-use reth_node_core::args::RocksDbArgs;
-use reth_node_ethereum::EthereumNode;
-use reth_payload_builder::EthPayloadBuilderAttributes;
-use reth_provider::RocksDBProviderFactory;
-use std::{sync::Arc, time::Duration};
-
-const ROCKSDB_POLL_TIMEOUT: Duration = Duration::from_secs(60);
-const ROCKSDB_POLL_INTERVAL: Duration = Duration::from_millis(50);
-
-/// Polls RPC until the given `tx_hash` is visible as pending (not yet mined).
-/// Prevents race conditions where `advance_block` is called before txs are in the pool.
-/// Returns the pending transaction.
-async fn wait_for_pending_tx<C: ClientT>(client: &C, tx_hash: B256) -> Transaction {
-    let start = std::time::Instant::now();
-    loop {
-        let tx: Option<Transaction> = client
-            .request("eth_getTransactionByHash", [tx_hash])
-            .await
-            .expect("RPC request failed");
-        if let Some(tx) = tx {
-            assert!(
-                tx.block_number.is_none(),
-                "Expected pending tx but tx_hash={tx_hash:?} is already mined in block {:?}",
-                tx.block_number
-            );
-            return tx;
-        }
-        assert!(
-            start.elapsed() < ROCKSDB_POLL_TIMEOUT,
-            "Timed out after {:?} waiting for tx_hash={tx_hash:?} to appear in pending pool",
-            start.elapsed()
-        );
-        tokio::time::sleep(ROCKSDB_POLL_INTERVAL).await;
-    }
-}
-
-/// Polls `RocksDB` until the given `tx_hash` appears in `TransactionHashNumbers`.
-/// Returns the `tx_number` on success, or panics on timeout.
-async fn poll_tx_in_rocksdb<P: RocksDBProviderFactory>(provider: &P, tx_hash: B256) -> u64 {
-    let start = std::time::Instant::now();
-    let mut interval = ROCKSDB_POLL_INTERVAL;
-    loop {
-        // Re-acquire handle each iteration to avoid stale snapshot reads
-        let rocksdb = provider.rocksdb_provider();
-        let tx_number: Option<u64> =
-            rocksdb.get::<tables::TransactionHashNumbers>(tx_hash).expect("RocksDB get failed");
-        if let Some(n) = tx_number {
-            return n;
-        }
-        assert!(
-            start.elapsed() < ROCKSDB_POLL_TIMEOUT,
-            "Timed out after {:?} waiting for tx_hash={tx_hash:?} in RocksDB",
-            start.elapsed()
-        );
-        tokio::time::sleep(interval).await;
-        // Simple backoff: 50ms -> 100ms -> 200ms (capped)
-        interval = std::cmp::min(interval * 2, Duration::from_millis(200));
-    }
-}
-
-/// Returns the test chain spec for `RocksDB` tests.
-fn test_chain_spec() -> Arc<ChainSpec> {
-    Arc::new(
-        ChainSpecBuilder::default()
-            .chain(MAINNET.chain)
-            .genesis(
-                serde_json::from_str(include_str!("../../src/testsuite/assets/genesis.json"))
-                    .expect("failed to parse genesis.json"),
-            )
-            .cancun_activated()
-            .build(),
-    )
-}
-
-/// Returns test payload attributes for the given timestamp.
-fn test_attributes_generator(timestamp: u64) -> EthPayloadBuilderAttributes {
-    let attributes = alloy_rpc_types_engine::PayloadAttributes {
-        timestamp,
-        prev_randao: B256::ZERO,
-        suggested_fee_recipient: alloy_primitives::Address::ZERO,
-        withdrawals: Some(vec![]),
-        parent_beacon_block_root: Some(B256::ZERO),
-    };
-    EthPayloadBuilderAttributes::new(B256::ZERO, attributes)
-}
-
-/// Enables `RocksDB` for `TransactionHashNumbers` table.
-///
-/// Note: Static file changesets are disabled because `persistence_threshold(0)` causes
-/// a race where the static file writer expects sequential block numbers but receives
-/// them out of order, resulting in `UnexpectedStaticFileBlockNumber` errors.
-fn with_rocksdb_enabled<C>(mut config: NodeConfig<C>) -> NodeConfig<C> {
-    config.rocksdb = RocksDbArgs { tx_hash: true, ..Default::default() };
-    config.static_files.storage_changesets = false;
-    config.static_files.account_changesets = false;
-    config
-}
-
-/// Smoke test: node boots with `RocksDB` routing enabled.
-#[tokio::test]
-async fn test_rocksdb_node_startup() -> Result<()> {
-    reth_tracing::init_test_tracing();
-
-    let chain_spec = test_chain_spec();
-
-    let (nodes, _tasks, _wallet) =
-        E2ETestSetupBuilder::<EthereumNode, _>::new(1, chain_spec, test_attributes_generator)
-            .with_node_config_modifier(with_rocksdb_enabled)
-            .build()
-            .await?;
-
-    assert_eq!(nodes.len(), 1);
-
-    // Verify RocksDB provider is functional (can query without error)
-    let rocksdb = nodes[0].inner.provider.rocksdb_provider();
-    let missing_hash = B256::from([0xab; 32]);
-    let result: Option<u64> = rocksdb.get::<tables::TransactionHashNumbers>(missing_hash)?;
-    assert!(result.is_none(), "Missing hash should return None");
-
-    let genesis_hash = nodes[0].block_hash(0);
-    assert_ne!(genesis_hash, B256::ZERO);
-
-    Ok(())
-}
-
-/// Block mining works with `RocksDB` storage.
-#[tokio::test]
-async fn test_rocksdb_block_mining() -> Result<()> {
-    reth_tracing::init_test_tracing();
-
-    let chain_spec = test_chain_spec();
-    let chain_id = chain_spec.chain().id();
-
-    let (mut nodes, _tasks, _wallet) =
-        E2ETestSetupBuilder::<EthereumNode, _>::new(1, chain_spec, test_attributes_generator)
-            .with_node_config_modifier(with_rocksdb_enabled)
-            .build()
-            .await?;
-
-    assert_eq!(nodes.len(), 1);
-
-    let genesis_hash = nodes[0].block_hash(0);
-    assert_ne!(genesis_hash, B256::ZERO);
-
-    // Mine 3 blocks with transactions
-    let wallets = wallet::Wallet::new(1).with_chain_id(chain_id).wallet_gen();
-    let signer = wallets[0].clone();
-    let client = nodes[0].rpc_client().expect("RPC client should be available");
-
-    for i in 1..=3u64 {
-        let raw_tx =
-            TransactionTestContext::transfer_tx_bytes_with_nonce(chain_id, signer.clone(), i - 1)
-                .await;
-        let tx_hash = nodes[0].rpc.inject_tx(raw_tx).await?;
-
-        // Wait for tx to enter pending pool before mining
-        wait_for_pending_tx(&client, tx_hash).await;
-
-        let payload = nodes[0].advance_block().await?;
-        let block = payload.block();
-        assert_eq!(block.number(), i);
-        assert_ne!(block.hash(), B256::ZERO);
-
-        // Verify tx was actually included in the block
-        let receipt: Option<TransactionReceipt> =
-            client.request("eth_getTransactionReceipt", [tx_hash]).await?;
-        let receipt = receipt.expect("Receipt should exist after mining");
-        assert_eq!(receipt.block_number, Some(i), "Tx should be in block {i}");
-    }
-
-    // Verify all blocks are stored
-    for i in 0..=3 {
-        let block_hash = nodes[0].block_hash(i);
-        assert_ne!(block_hash, B256::ZERO);
-    }
-
-    Ok(())
-}
-
-/// Tx hash lookup exercises `TransactionHashNumbers` table.
-#[tokio::test]
-async fn test_rocksdb_transaction_queries() -> Result<()> {
-    reth_tracing::init_test_tracing();
-
-    let chain_spec = test_chain_spec();
-    let chain_id = chain_spec.chain().id();
-
-    let (mut nodes, _tasks, _) = E2ETestSetupBuilder::<EthereumNode, _>::new(
-        1,
-        chain_spec.clone(),
-        test_attributes_generator,
-    )
-    .with_node_config_modifier(with_rocksdb_enabled)
-    .with_tree_config_modifier(|config| config.with_persistence_threshold(0))
-    .build()
-    .await?;
-
-    assert_eq!(nodes.len(), 1);
-
-    // Inject and mine a transaction
-    let wallets = wallet::Wallet::new(1).with_chain_id(chain_id).wallet_gen();
-    let signer = wallets[0].clone();
-    let client = nodes[0].rpc_client().expect("RPC client should be available");
-
-    let raw_tx = TransactionTestContext::transfer_tx_bytes(chain_id, signer).await;
-    let tx_hash = nodes[0].rpc.inject_tx(raw_tx).await?;
-
-    // Wait for tx to enter pending pool before mining
-    wait_for_pending_tx(&client, tx_hash).await;
-
-    let payload = nodes[0].advance_block().await?;
-    assert_eq!(payload.block().number(), 1);
-
-    // Query each transaction by hash
-    let tx: Option<Transaction> = client.request("eth_getTransactionByHash", [tx_hash]).await?;
-    let tx = tx.expect("Transaction should be found");
-    assert_eq!(tx.block_number, Some(1));
-
-    let receipt: Option<TransactionReceipt> =
-        client.request("eth_getTransactionReceipt", [tx_hash]).await?;
-    let receipt = receipt.expect("Receipt should be found");
-    assert_eq!(receipt.block_number, Some(1));
-    assert!(receipt.status());
-
-    // Direct RocksDB assertion - poll with timeout since persistence is async
-    let tx_number = poll_tx_in_rocksdb(&nodes[0].inner.provider, tx_hash).await;
-    assert_eq!(tx_number, 0, "First tx should have TxNumber 0");
-
-    // Verify missing hash returns None
-    let missing_hash = B256::from([0xde; 32]);
-    let rocksdb = nodes[0].inner.provider.rocksdb_provider();
-    let missing_tx_number: Option<u64> =
-        rocksdb.get::<tables::TransactionHashNumbers>(missing_hash)?;
-    assert!(missing_tx_number.is_none());
-
-    let missing_tx: Option<Transaction> =
-        client.request("eth_getTransactionByHash", [missing_hash]).await?;
-    assert!(missing_tx.is_none(), "expected no transaction for missing hash");
-
-    let missing_receipt: Option<TransactionReceipt> =
-        client.request("eth_getTransactionReceipt", [missing_hash]).await?;
-    assert!(missing_receipt.is_none(), "expected no receipt for missing hash");
-
-    Ok(())
-}
-
-/// Multiple transactions in the same block are correctly persisted to `RocksDB`.
-#[tokio::test]
-async fn test_rocksdb_multi_tx_same_block() -> Result<()> {
-    reth_tracing::init_test_tracing();
-
-    let chain_spec = test_chain_spec();
-    let chain_id = chain_spec.chain().id();
-
-    let (mut nodes, _tasks, _) = E2ETestSetupBuilder::<EthereumNode, _>::new(
-        1,
-        chain_spec.clone(),
-        test_attributes_generator,
-    )
-    .with_node_config_modifier(with_rocksdb_enabled)
-    .with_tree_config_modifier(|config| config.with_persistence_threshold(0))
-    .build()
-    .await?;
-
-    // Create 3 txs from the same wallet with sequential nonces
-    let wallets = wallet::Wallet::new(1).with_chain_id(chain_id).wallet_gen();
-    let signer = wallets[0].clone();
-    let client = nodes[0].rpc_client().expect("RPC client");
-
-    let mut tx_hashes = Vec::new();
-    for nonce in 0..3 {
-        let raw_tx =
-            TransactionTestContext::transfer_tx_bytes_with_nonce(chain_id, signer.clone(), nonce)
-                .await;
-        let tx_hash = nodes[0].rpc.inject_tx(raw_tx).await?;
-        tx_hashes.push(tx_hash);
-    }
-
-    // Wait for all txs to appear in pending pool before mining
-    for tx_hash in &tx_hashes {
-        wait_for_pending_tx(&client, *tx_hash).await;
-    }
-
-    // Mine one block containing all 3 txs
-    let payload = nodes[0].advance_block().await?;
-    assert_eq!(payload.block().number(), 1);
-
-    // Verify block contains all 3 txs
-    let block: Option<alloy_rpc_types_eth::Block> =
-        client.request("eth_getBlockByNumber", ("0x1", true)).await?;
-    let block = block.expect("Block 1 should exist");
-    assert_eq!(block.transactions.len(), 3, "Block should contain 3 txs");
-
-    // Verify each tx via RPC
-    for tx_hash in &tx_hashes {
-        let tx: Option<Transaction> = client.request("eth_getTransactionByHash", [tx_hash]).await?;
-        let tx = tx.expect("Transaction should be found");
-        assert_eq!(tx.block_number, Some(1), "All txs should be in block 1");
-    }
-
-    // Poll RocksDB for all tx hashes and collect tx_numbers
-    let mut tx_numbers = Vec::new();
-    for tx_hash in &tx_hashes {
-        let n = poll_tx_in_rocksdb(&nodes[0].inner.provider, *tx_hash).await;
-        tx_numbers.push(n);
-    }
-
-    // Verify tx_numbers form the set {0, 1, 2}
-    tx_numbers.sort();
-    assert_eq!(tx_numbers, vec![0, 1, 2], "TxNumbers should be 0, 1, 2");
-
-    Ok(())
-}
-
-/// Transactions across multiple blocks have globally continuous `tx_numbers`.
-#[tokio::test]
-async fn test_rocksdb_txs_across_blocks() -> Result<()> {
-    reth_tracing::init_test_tracing();
-
-    let chain_spec = test_chain_spec();
-    let chain_id = chain_spec.chain().id();
-
-    let (mut nodes, _tasks, _) = E2ETestSetupBuilder::<EthereumNode, _>::new(
-        1,
-        chain_spec.clone(),
-        test_attributes_generator,
-    )
-    .with_node_config_modifier(with_rocksdb_enabled)
-    .with_tree_config_modifier(|config| config.with_persistence_threshold(0))
-    .build()
-    .await?;
-
-    let wallets = wallet::Wallet::new(1).with_chain_id(chain_id).wallet_gen();
-    let signer = wallets[0].clone();
-    let client = nodes[0].rpc_client().expect("RPC client");
-
-    // Block 1: 2 transactions
-    let tx_hash_0 = nodes[0]
-        .rpc
-        .inject_tx(
-            TransactionTestContext::transfer_tx_bytes_with_nonce(chain_id, signer.clone(), 0).await,
-        )
-        .await?;
-    let tx_hash_1 = nodes[0]
-        .rpc
-        .inject_tx(
-            TransactionTestContext::transfer_tx_bytes_with_nonce(chain_id, signer.clone(), 1).await,
-        )
-        .await?;
-
-    // Wait for both txs to appear in pending pool
-    wait_for_pending_tx(&client, tx_hash_0).await;
-    wait_for_pending_tx(&client, tx_hash_1).await;
-
-    let payload1 = nodes[0].advance_block().await?;
-    assert_eq!(payload1.block().number(), 1);
-
-    // Block 2: 1 transaction
-    let tx_hash_2 = nodes[0]
-        .rpc
-        .inject_tx(
-            TransactionTestContext::transfer_tx_bytes_with_nonce(chain_id, signer.clone(), 2).await,
-        )
-        .await?;
-
-    wait_for_pending_tx(&client, tx_hash_2).await;
-
-    let payload2 = nodes[0].advance_block().await?;
-    assert_eq!(payload2.block().number(), 2);
-
-    // Verify block contents via RPC
-    let tx0: Option<Transaction> = client.request("eth_getTransactionByHash", [tx_hash_0]).await?;
-    let tx1: Option<Transaction> = client.request("eth_getTransactionByHash", [tx_hash_1]).await?;
-    let tx2: Option<Transaction> = client.request("eth_getTransactionByHash", [tx_hash_2]).await?;
-
-    assert_eq!(tx0.expect("tx0").block_number, Some(1));
-    assert_eq!(tx1.expect("tx1").block_number, Some(1));
-    assert_eq!(tx2.expect("tx2").block_number, Some(2));
-
-    // Poll RocksDB and verify global tx_number continuity
-    let all_tx_hashes = [tx_hash_0, tx_hash_1, tx_hash_2];
-    let mut tx_numbers = Vec::new();
-    for tx_hash in &all_tx_hashes {
-        let n = poll_tx_in_rocksdb(&nodes[0].inner.provider, *tx_hash).await;
-        tx_numbers.push(n);
-    }
-
-    // Verify they form a continuous sequence {0, 1, 2}
-    tx_numbers.sort();
-    assert_eq!(tx_numbers, vec![0, 1, 2], "TxNumbers should be globally continuous: 0, 1, 2");
-
-    // Re-query block 1 txs after block 2 is mined (regression guard)
-    let tx0_again: Option<Transaction> =
-        client.request("eth_getTransactionByHash", [tx_hash_0]).await?;
-    assert!(tx0_again.is_some(), "Block 1 tx should still be queryable after block 2");
-
-    Ok(())
-}
-
-/// Pending transactions should NOT appear in `RocksDB` until mined.
-#[tokio::test]
-async fn test_rocksdb_pending_tx_not_in_storage() -> Result<()> {
-    reth_tracing::init_test_tracing();
-
-    let chain_spec = test_chain_spec();
-    let chain_id = chain_spec.chain().id();
-
-    let (mut nodes, _tasks, _) = E2ETestSetupBuilder::<EthereumNode, _>::new(
-        1,
-        chain_spec.clone(),
-        test_attributes_generator,
-    )
-    .with_node_config_modifier(with_rocksdb_enabled)
-    .with_tree_config_modifier(|config| config.with_persistence_threshold(0))
-    .build()
-    .await?;
-
-    let wallets = wallet::Wallet::new(1).with_chain_id(chain_id).wallet_gen();
-    let signer = wallets[0].clone();
-
-    // Inject tx but do NOT mine
-    let raw_tx = TransactionTestContext::transfer_tx_bytes(chain_id, signer).await;
-    let tx_hash = nodes[0].rpc.inject_tx(raw_tx).await?;
-
-    // Verify tx is in pending pool via RPC
-    let client = nodes[0].rpc_client().expect("RPC client");
-    wait_for_pending_tx(&client, tx_hash).await;
-
-    let pending_tx: Option<Transaction> =
-        client.request("eth_getTransactionByHash", [tx_hash]).await?;
-    assert!(pending_tx.is_some(), "Pending tx should be visible via RPC");
-    assert!(pending_tx.unwrap().block_number.is_none(), "Pending tx should have no block_number");
-
-    // Assert tx is NOT in RocksDB before mining (single check - tx is confirmed pending)
-    let rocksdb = nodes[0].inner.provider.rocksdb_provider();
-    let tx_number: Option<u64> = rocksdb.get::<tables::TransactionHashNumbers>(tx_hash)?;
-    assert!(
-        tx_number.is_none(),
-        "Pending tx should NOT be in RocksDB before mining, but found tx_number={:?}",
-        tx_number
-    );
-
-    // Now mine the block
-    let payload = nodes[0].advance_block().await?;
-    assert_eq!(payload.block().number(), 1);
-
-    // Poll until tx appears in RocksDB
-    let tx_number = poll_tx_in_rocksdb(&nodes[0].inner.provider, tx_hash).await;
-    assert_eq!(tx_number, 0, "First tx should have tx_number 0");
-
-    // Verify tx is now mined via RPC
-    let mined_tx: Option<Transaction> =
-        client.request("eth_getTransactionByHash", [tx_hash]).await?;
-    assert_eq!(mined_tx.expect("mined tx").block_number, Some(1));
-
-    Ok(())
-}

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(),

crates/engine/primitives/src/config.rs

@@ -34,11 +34,6 @@ fn default_account_worker_count() -> usize {
 /// The size of proof targets chunk to spawn in one multiproof calculation.
 pub const DEFAULT_MULTIPROOF_TASK_CHUNK_SIZE: usize = 60;
 
-/// The size of proof targets chunk to spawn in one multiproof calculation when V2 proofs are
-/// enabled. This is 4x the default chunk size to take advantage of more efficient V2 proof
-/// computation.
-pub const DEFAULT_MULTIPROOF_TASK_CHUNK_SIZE_V2: usize = DEFAULT_MULTIPROOF_TASK_CHUNK_SIZE * 4;
-
 /// Default number of reserved CPU cores for non-reth processes.
 ///
 /// This will be deducted from the thread count of main reth global threadpool.
@@ -50,17 +45,7 @@ pub const DEFAULT_PREWARM_MAX_CONCURRENCY: usize = 16;
 const DEFAULT_BLOCK_BUFFER_LIMIT: u32 = EPOCH_SLOTS as u32 * 2;
 const DEFAULT_MAX_INVALID_HEADER_CACHE_LENGTH: u32 = 256;
 const DEFAULT_MAX_EXECUTE_BLOCK_BATCH_SIZE: usize = 4;
-const DEFAULT_CROSS_BLOCK_CACHE_SIZE: usize = default_cross_block_cache_size();
-
-const fn default_cross_block_cache_size() -> usize {
-    if cfg!(test) {
-        1024 * 1024 // 1 MB in tests
-    } else if cfg!(target_pointer_width = "32") {
-        usize::MAX // max possible on wasm32 / 32-bit
-    } else {
-        4 * 1024 * 1024 * 1024 // 4 GB on 64-bit
-    }
-}
+const DEFAULT_CROSS_BLOCK_CACHE_SIZE: u64 = 4 * 1024 * 1024 * 1024;
 
 /// Determines if the host has enough parallelism to run the payload processor.
 ///
@@ -110,10 +95,12 @@ pub struct TreeConfig {
     disable_state_cache: bool,
     /// Whether to disable parallel prewarming.
     disable_prewarming: bool,
+    /// Whether to disable the parallel sparse trie state root algorithm.
+    disable_parallel_sparse_trie: bool,
     /// Whether to enable state provider metrics.
     state_provider_metrics: bool,
     /// Cross-block cache size in bytes.
-    cross_block_cache_size: usize,
+    cross_block_cache_size: u64,
     /// Whether the host has enough parallelism to run state root task.
     has_enough_parallelism: bool,
     /// Whether multiproof task should chunk proof targets.
@@ -150,8 +137,6 @@ pub struct TreeConfig {
     account_worker_count: usize,
     /// Whether to enable V2 storage proofs.
     enable_proof_v2: bool,
-    /// Whether to disable cache metrics recording (can be expensive with large cached state).
-    disable_cache_metrics: bool,
 }
 
 impl Default for TreeConfig {
@@ -166,6 +151,7 @@ impl Default for TreeConfig {
             always_compare_trie_updates: false,
             disable_state_cache: false,
             disable_prewarming: false,
+            disable_parallel_sparse_trie: false,
             state_provider_metrics: false,
             cross_block_cache_size: DEFAULT_CROSS_BLOCK_CACHE_SIZE,
             has_enough_parallelism: has_enough_parallelism(),
@@ -180,7 +166,6 @@ impl Default for TreeConfig {
             storage_worker_count: default_storage_worker_count(),
             account_worker_count: default_account_worker_count(),
             enable_proof_v2: false,
-            disable_cache_metrics: false,
         }
     }
 }
@@ -198,8 +183,9 @@ impl TreeConfig {
         always_compare_trie_updates: bool,
         disable_state_cache: bool,
         disable_prewarming: bool,
+        disable_parallel_sparse_trie: bool,
         state_provider_metrics: bool,
-        cross_block_cache_size: usize,
+        cross_block_cache_size: u64,
         has_enough_parallelism: bool,
         multiproof_chunking_enabled: bool,
         multiproof_chunk_size: usize,
@@ -212,7 +198,6 @@ impl TreeConfig {
         storage_worker_count: usize,
         account_worker_count: usize,
         enable_proof_v2: bool,
-        disable_cache_metrics: bool,
     ) -> Self {
         Self {
             persistence_threshold,
@@ -224,6 +209,7 @@ impl TreeConfig {
             always_compare_trie_updates,
             disable_state_cache,
             disable_prewarming,
+            disable_parallel_sparse_trie,
             state_provider_metrics,
             cross_block_cache_size,
             has_enough_parallelism,
@@ -238,7 +224,6 @@ impl TreeConfig {
             storage_worker_count,
             account_worker_count,
             enable_proof_v2,
-            disable_cache_metrics,
         }
     }
 
@@ -277,17 +262,6 @@ impl TreeConfig {
         self.multiproof_chunk_size
     }
 
-    /// Return the multiproof task chunk size, using the V2 default if V2 proofs are enabled
-    /// and the chunk size is at the default value.
-    pub const fn effective_multiproof_chunk_size(&self) -> usize {
-        if self.enable_proof_v2 && self.multiproof_chunk_size == DEFAULT_MULTIPROOF_TASK_CHUNK_SIZE
-        {
-            DEFAULT_MULTIPROOF_TASK_CHUNK_SIZE_V2
-        } else {
-            self.multiproof_chunk_size
-        }
-    }
-
     /// Return the number of reserved CPU cores for non-reth processes
     pub const fn reserved_cpu_cores(&self) -> usize {
         self.reserved_cpu_cores
@@ -304,6 +278,11 @@ impl TreeConfig {
         self.state_provider_metrics
     }
 
+    /// Returns whether or not the parallel sparse trie is disabled.
+    pub const fn disable_parallel_sparse_trie(&self) -> bool {
+        self.disable_parallel_sparse_trie
+    }
+
     /// Returns whether or not state cache is disabled.
     pub const fn disable_state_cache(&self) -> bool {
         self.disable_state_cache
@@ -321,7 +300,7 @@ impl TreeConfig {
     }
 
     /// Returns the cross-block cache size.
-    pub const fn cross_block_cache_size(&self) -> usize {
+    pub const fn cross_block_cache_size(&self) -> u64 {
         self.cross_block_cache_size
     }
 
@@ -424,7 +403,7 @@ impl TreeConfig {
     }
 
     /// Setter for cross block cache size.
-    pub const fn with_cross_block_cache_size(mut self, cross_block_cache_size: usize) -> Self {
+    pub const fn with_cross_block_cache_size(mut self, cross_block_cache_size: u64) -> Self {
         self.cross_block_cache_size = cross_block_cache_size;
         self
     }
@@ -441,6 +420,15 @@ impl TreeConfig {
         self
     }
 
+    /// Setter for whether to disable the parallel sparse trie
+    pub const fn with_disable_parallel_sparse_trie(
+        mut self,
+        disable_parallel_sparse_trie: bool,
+    ) -> Self {
+        self.disable_parallel_sparse_trie = disable_parallel_sparse_trie;
+        self
+    }
+
     /// Setter for whether multiproof task should chunk proof targets.
     pub const fn with_multiproof_chunking_enabled(
         mut self,
@@ -528,15 +516,4 @@ impl TreeConfig {
         self.enable_proof_v2 = enable_proof_v2;
         self
     }
-
-    /// Returns whether cache metrics recording is disabled.
-    pub const fn disable_cache_metrics(&self) -> bool {
-        self.disable_cache_metrics
-    }
-
-    /// Setter for whether to disable cache metrics recording.
-    pub const fn without_cache_metrics(mut self, disable_cache_metrics: bool) -> Self {
-        self.disable_cache_metrics = disable_cache_metrics;
-        self
-    }
 }

crates/engine/primitives/src/lib.rs

@@ -62,8 +62,7 @@ pub trait EngineTypes:
                           + TryInto<Self::ExecutionPayloadEnvelopeV2>
                           + TryInto<Self::ExecutionPayloadEnvelopeV3>
                           + TryInto<Self::ExecutionPayloadEnvelopeV4>
-                          + TryInto<Self::ExecutionPayloadEnvelopeV5>
-                          + TryInto<Self::ExecutionPayloadEnvelopeV6>,
+                          + TryInto<Self::ExecutionPayloadEnvelopeV5>,
     > + DeserializeOwned
     + Serialize
 {
@@ -107,14 +106,6 @@ pub trait EngineTypes:
         + Send
         + Sync
         + 'static;
-    /// Execution Payload V6 envelope type.
-    type ExecutionPayloadEnvelopeV6: DeserializeOwned
-        + Serialize
-        + Clone
-        + Unpin
-        + Send
-        + Sync
-        + 'static;
 }
 
 /// Type that validates the payloads processed by the engine API.

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

crates/engine/service/src/service.rs

@@ -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,
@@ -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,
         );
     }
 }

crates/engine/tree/Cargo.toml

@@ -12,7 +12,7 @@ workspace = true
 
 [dependencies]
 # reth
-reth-chain-state = { workspace = true, features = ["rayon"] }
+reth-chain-state.workspace = true
 reth-chainspec = { workspace = true, optional = true }
 reth-consensus.workspace = true
 reth-db.workspace = true
@@ -34,8 +34,6 @@ 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
@@ -46,6 +44,8 @@ alloy-primitives.workspace = true
 alloy-rlp.workspace = true
 alloy-rpc-types-engine.workspace = true
 
+parking_lot.workspace = true
+
 revm.workspace = true
 revm-primitives.workspace = true
 
@@ -53,7 +53,7 @@ revm-primitives.workspace = true
 futures.workspace = true
 thiserror.workspace = true
 tokio = { workspace = true, features = ["rt", "rt-multi-thread", "sync", "macros"] }
-fixed-cache.workspace = true
+mini-moka = { workspace = true, features = ["sync"] }
 moka = { workspace = true, features = ["sync"] }
 smallvec.workspace = true
 
@@ -67,7 +67,6 @@ schnellru.workspace = true
 rayon.workspace = true
 tracing.workspace = true
 derive_more.workspace = true
-parking_lot.workspace = true
 crossbeam-channel.workspace = true
 
 # optional deps for test-utils
@@ -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",

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,

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,
                             );

crates/engine/tree/src/persistence.rs

@@ -7,7 +7,7 @@ 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};
@@ -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)
     }
 }

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

@@ -1,15 +1,25 @@
-use crate::tree::{error::InsertBlockFatalError, TreeOutcome};
+use crate::tree::{error::InsertBlockFatalError, MeteredStateHook, TreeOutcome};
+use alloy_consensus::transaction::TxHashRef;
+use alloy_evm::{
+    block::{BlockExecutor, ExecutableTx},
+    Evm,
+};
 use alloy_rpc_types_engine::{PayloadStatus, PayloadStatusEnum};
+use core::borrow::BorrowMut;
 use reth_engine_primitives::{ForkchoiceStatus, OnForkChoiceUpdated};
-use reth_errors::ProviderError;
-use reth_evm::metrics::ExecutorMetrics;
+use reth_errors::{BlockExecutionError, ProviderError};
+use reth_evm::{metrics::ExecutorMetrics, OnStateHook};
 use reth_execution_types::BlockExecutionOutput;
 use reth_metrics::{
     metrics::{Counter, Gauge, Histogram},
     Metrics,
 };
+use reth_primitives_traits::SignedTransaction;
 use reth_trie::updates::TrieUpdates;
-use std::time::{Duration, Instant};
+use revm::database::{states::bundle_state::BundleRetention, State};
+use revm_primitives::Address;
+use std::time::Instant;
+use tracing::{debug_span, trace};
 
 /// Metrics for the `EngineApi`.
 #[derive(Debug, Default)]
@@ -22,30 +32,104 @@ pub(crate) struct EngineApiMetrics {
     pub(crate) block_validation: BlockValidationMetrics,
     /// Canonical chain and reorg related metrics
     pub tree: TreeMetrics,
-    /// Metrics for EIP-7928 Block-Level Access Lists (BAL).
-    #[allow(dead_code)]
-    pub(crate) bal: BalMetrics,
 }
 
 impl EngineApiMetrics {
-    /// Records metrics for block execution.
+    /// Helper function for metered execution
+    fn metered<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce() -> (u64, R),
+    {
+        // Execute the block and record the elapsed time.
+        let execute_start = Instant::now();
+        let (gas_used, output) = f();
+        let execution_duration = execute_start.elapsed().as_secs_f64();
+
+        // Update gas metrics.
+        self.executor.gas_processed_total.increment(gas_used);
+        self.executor.gas_per_second.set(gas_used as f64 / execution_duration);
+        self.executor.gas_used_histogram.record(gas_used as f64);
+        self.executor.execution_histogram.record(execution_duration);
+        self.executor.execution_duration.set(execution_duration);
+
+        output
+    }
+
+    /// Execute the given block using the provided [`BlockExecutor`] and update metrics for the
+    /// execution.
     ///
     /// This method updates metrics for execution time, gas usage, and the number
-    /// of accounts, storage slots and bytecodes updated.
-    pub(crate) fn record_block_execution<R>(
+    /// of accounts, storage slots and bytecodes loaded and updated.
+    pub(crate) fn execute_metered<E, DB>(
         &self,
-        output: &BlockExecutionOutput<R>,
-        execution_duration: Duration,
-    ) {
-        let execution_secs = execution_duration.as_secs_f64();
-        let gas_used = output.result.gas_used;
+        executor: E,
+        mut transactions: impl Iterator<Item = Result<impl ExecutableTx<E>, BlockExecutionError>>,
+        transaction_count: usize,
+        state_hook: Box<dyn OnStateHook>,
+    ) -> Result<(BlockExecutionOutput<E::Receipt>, Vec<Address>), BlockExecutionError>
+    where
+        DB: alloy_evm::Database,
+        E: BlockExecutor<Evm: Evm<DB: BorrowMut<State<DB>>>, Transaction: SignedTransaction>,
+    {
+        // clone here is cheap, all the metrics are Option<Arc<_>>. additionally
+        // they are globally registered so that the data recorded in the hook will
+        // be accessible.
+        let wrapper = MeteredStateHook { metrics: self.executor.clone(), inner_hook: state_hook };
 
-        // Update gas metrics
-        self.executor.gas_processed_total.increment(gas_used);
-        self.executor.gas_per_second.set(gas_used as f64 / execution_secs);
-        self.executor.gas_used_histogram.record(gas_used as f64);
-        self.executor.execution_histogram.record(execution_secs);
-        self.executor.execution_duration.set(execution_secs);
+        let mut senders = Vec::with_capacity(transaction_count);
+        let mut executor = executor.with_state_hook(Some(Box::new(wrapper)));
+
+        let f = || {
+            let start = Instant::now();
+            debug_span!(target: "engine::tree", "pre execution")
+                .entered()
+                .in_scope(|| executor.apply_pre_execution_changes())?;
+            self.executor.pre_execution_histogram.record(start.elapsed());
+
+            let exec_span = debug_span!(target: "engine::tree", "execution").entered();
+            loop {
+                let start = Instant::now();
+                let Some(tx) = transactions.next() else { break };
+                self.executor.transaction_wait_histogram.record(start.elapsed());
+
+                let tx = tx?;
+                senders.push(*tx.signer());
+
+                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());
+
+                // record the tx gas used
+                enter.record("gas_used", gas_used);
+            }
+            drop(exec_span);
+
+            let start = Instant::now();
+            let result = debug_span!(target: "engine::tree", "finish")
+                .entered()
+                .in_scope(|| executor.finish())
+                .map(|(evm, result)| (evm.into_db(), result));
+            self.executor.post_execution_histogram.record(start.elapsed());
+
+            result
+        };
+
+        // Use metered to execute and track timing/gas metrics
+        let (mut db, result) = self.metered(|| {
+            let res = f();
+            let gas_used = res.as_ref().map(|r| r.1.gas_used).unwrap_or(0);
+            (gas_used, res)
+        })?;
+
+        // merge transitions into bundle state
+        debug_span!(target: "engine::tree", "merge transitions")
+            .entered()
+            .in_scope(|| db.borrow_mut().merge_transitions(BundleRetention::Reverts));
+        let output = BlockExecutionOutput { result, state: db.borrow_mut().take_bundle() };
 
         // Update the metrics for the number of accounts, storage slots and bytecodes updated
         let accounts = output.state.state.len();
@@ -56,31 +140,8 @@ impl EngineApiMetrics {
         self.executor.accounts_updated_histogram.record(accounts as f64);
         self.executor.storage_slots_updated_histogram.record(storage_slots as f64);
         self.executor.bytecodes_updated_histogram.record(bytecodes as f64);
-    }
 
-    /// Returns a reference to the executor metrics for use in state hooks.
-    pub(crate) const fn executor_metrics(&self) -> &ExecutorMetrics {
-        &self.executor
-    }
-
-    /// Records the duration of block pre-execution changes (e.g., beacon root update).
-    pub(crate) fn record_pre_execution(&self, elapsed: Duration) {
-        self.executor.pre_execution_histogram.record(elapsed);
-    }
-
-    /// Records the duration of block post-execution changes (e.g., finalization).
-    pub(crate) fn record_post_execution(&self, elapsed: Duration) {
-        self.executor.post_execution_histogram.record(elapsed);
-    }
-
-    /// Records the time spent waiting for the next transaction from the iterator.
-    pub(crate) fn record_transaction_wait(&self, elapsed: Duration) {
-        self.executor.transaction_wait_histogram.record(elapsed);
-    }
-
-    /// Records the duration of a single transaction execution.
-    pub(crate) fn record_transaction_execution(&self, elapsed: Duration) {
-        self.executor.transaction_execution_histogram.record(elapsed);
+        Ok((output, senders))
     }
 }
 
@@ -136,12 +197,6 @@ pub(crate) struct EngineMetrics {
 #[derive(Metrics)]
 #[metrics(scope = "consensus.engine.beacon")]
 pub(crate) struct ForkchoiceUpdatedMetrics {
-    /// Finish time of the latest forkchoice updated call.
-    #[metric(skip)]
-    pub(crate) latest_finish_at: Option<Instant>,
-    /// Start time of the latest forkchoice updated call.
-    #[metric(skip)]
-    pub(crate) latest_start_at: Option<Instant>,
     /// The total count of forkchoice updated messages received.
     pub(crate) forkchoice_updated_messages: Counter,
     /// The total count of forkchoice updated messages with payload received.
@@ -164,35 +219,18 @@ pub(crate) struct ForkchoiceUpdatedMetrics {
     pub(crate) forkchoice_updated_last: Gauge,
     /// Time diff between new payload call response and the next forkchoice updated call request.
     pub(crate) new_payload_forkchoice_updated_time_diff: Histogram,
-    /// Time from previous forkchoice updated finish to current forkchoice updated start (idle
-    /// time).
-    pub(crate) time_between_forkchoice_updated: Histogram,
-    /// Time from previous forkchoice updated start to current forkchoice updated start (total
-    /// interval).
-    pub(crate) forkchoice_updated_interval: Histogram,
 }
 
 impl ForkchoiceUpdatedMetrics {
     /// Increment the forkchoiceUpdated counter based on the given result
     pub(crate) fn update_response_metrics(
-        &mut self,
+        &self,
         start: Instant,
         latest_new_payload_at: &mut Option<Instant>,
         has_attrs: bool,
         result: &Result<TreeOutcome<OnForkChoiceUpdated>, ProviderError>,
     ) {
-        let finish = Instant::now();
-        let elapsed = finish - start;
-
-        if let Some(prev_finish) = self.latest_finish_at {
-            self.time_between_forkchoice_updated.record(start - prev_finish);
-        }
-        if let Some(prev_start) = self.latest_start_at {
-            self.forkchoice_updated_interval.record(start - prev_start);
-        }
-        self.latest_finish_at = Some(finish);
-        self.latest_start_at = Some(start);
-
+        let elapsed = start.elapsed();
         match result {
             Ok(outcome) => match outcome.outcome.forkchoice_status() {
                 ForkchoiceStatus::Valid => self.forkchoice_updated_valid.increment(1),
@@ -219,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
@@ -242,8 +277,6 @@ pub(crate) struct NewPayloadStatusMetrics {
     pub(crate) new_payload_error: Counter,
     /// The total gas of valid new payload messages received.
     pub(crate) new_payload_total_gas: Histogram,
-    /// The gas used for the last valid new payload.
-    pub(crate) new_payload_total_gas_last: Gauge,
     /// The gas per second of valid new payload messages received.
     pub(crate) new_payload_gas_per_second: Histogram,
     /// The gas per second for the last new payload call.
@@ -252,12 +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,
-    /// Time diff between forkchoice updated call response and the next new payload call request.
-    pub(crate) forkchoice_updated_new_payload_time_diff: Histogram,
 }
 
 impl NewPayloadStatusMetrics {
@@ -265,27 +292,18 @@ impl NewPayloadStatusMetrics {
     pub(crate) fn update_response_metrics(
         &mut self,
         start: Instant,
-        latest_forkchoice_updated_at: &mut Option<Instant>,
         result: &Result<TreeOutcome<PayloadStatus>, InsertBlockFatalError>,
         gas_used: u64,
     ) {
         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 => {
                     self.new_payload_valid.increment(1);
                     self.new_payload_total_gas.record(gas_used as f64);
-                    self.new_payload_total_gas_last.set(gas_used as f64);
                     let gas_per_second = gas_used as f64 / elapsed.as_secs_f64();
                     self.new_payload_gas_per_second.record(gas_per_second);
                     self.new_payload_gas_per_second_last.set(gas_per_second);
@@ -299,40 +317,9 @@ impl NewPayloadStatusMetrics {
         self.new_payload_messages.increment(1);
         self.new_payload_latency.record(elapsed);
         self.new_payload_last.set(elapsed);
-        if let Some(latest_forkchoice_updated_at) = latest_forkchoice_updated_at.take() {
-            self.forkchoice_updated_new_payload_time_diff
-                .record(start - latest_forkchoice_updated_at);
-        }
     }
 }
 
-/// Metrics for EIP-7928 Block-Level Access Lists (BAL).
-///
-/// See also <https://github.com/ethereum/execution-metrics/issues/5>
-#[allow(dead_code)]
-#[derive(Metrics, Clone)]
-#[metrics(scope = "execution.block_access_list")]
-pub(crate) struct BalMetrics {
-    /// Size of the BAL in bytes for the current block.
-    pub(crate) size_bytes: Gauge,
-    /// Total number of blocks with valid BALs.
-    pub(crate) valid_total: Counter,
-    /// Total number of blocks with invalid BALs.
-    pub(crate) invalid_total: Counter,
-    /// Time taken to validate the BAL against actual execution.
-    pub(crate) validation_time_seconds: Histogram,
-    /// Number of account changes in the BAL.
-    pub(crate) account_changes: Gauge,
-    /// Number of storage changes in the BAL.
-    pub(crate) storage_changes: Gauge,
-    /// Number of balance changes in the BAL.
-    pub(crate) balance_changes: Gauge,
-    /// Number of nonce changes in the BAL.
-    pub(crate) nonce_changes: Gauge,
-    /// Number of code changes in the BAL.
-    pub(crate) code_changes: Gauge,
-}
-
 /// Metrics for non-execution related block validation.
 #[derive(Metrics, Clone)]
 #[metrics(scope = "sync.block_validation")]
@@ -341,14 +328,16 @@ pub(crate) struct BlockValidationMetrics {
     pub(crate) state_root_storage_tries_updated_total: Counter,
     /// Total number of times the parallel state root computation fell back to regular.
     pub(crate) state_root_parallel_fallback_total: Counter,
-    /// Total number of times the state root task failed but the fallback succeeded.
-    pub(crate) state_root_task_fallback_success_total: Counter,
     /// Latest state root duration, ie the time spent blocked waiting for the state root.
     pub(crate) state_root_duration: Gauge,
     /// Histogram for state root duration ie the time spent blocked waiting for the state root
     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
@@ -398,10 +387,133 @@ pub(crate) struct BlockBufferMetrics {
 mod tests {
     use super::*;
     use alloy_eips::eip7685::Requests;
+    use alloy_evm::block::StateChangeSource;
+    use alloy_primitives::{B256, U256};
     use metrics_util::debugging::{DebuggingRecorder, Snapshotter};
-    use reth_ethereum_primitives::Receipt;
+    use reth_ethereum_primitives::{Receipt, TransactionSigned};
+    use reth_evm_ethereum::EthEvm;
     use reth_execution_types::BlockExecutionResult;
-    use reth_revm::db::BundleState;
+    use reth_primitives_traits::RecoveredBlock;
+    use revm::{
+        context::result::{ExecutionResult, Output, ResultAndState, SuccessReason},
+        database::State,
+        database_interface::EmptyDB,
+        inspector::NoOpInspector,
+        state::{Account, AccountInfo, AccountStatus, EvmState, EvmStorage, EvmStorageSlot},
+        Context, MainBuilder, MainContext,
+    };
+    use revm_primitives::Bytes;
+    use std::sync::mpsc;
+
+    /// A simple mock executor for testing that doesn't require complex EVM setup
+    struct MockExecutor {
+        state: EvmState,
+        hook: Option<Box<dyn OnStateHook>>,
+    }
+
+    impl MockExecutor {
+        fn new(state: EvmState) -> Self {
+            Self { state, hook: None }
+        }
+    }
+
+    // Mock Evm type for testing
+    type MockEvm = EthEvm<State<EmptyDB>, NoOpInspector>;
+
+    impl BlockExecutor for MockExecutor {
+        type Transaction = TransactionSigned;
+        type Receipt = Receipt;
+        type Evm = MockEvm;
+
+        fn apply_pre_execution_changes(&mut self) -> Result<(), BlockExecutionError> {
+            Ok(())
+        }
+
+        fn execute_transaction_without_commit(
+            &mut self,
+            _tx: impl ExecutableTx<Self>,
+        ) -> Result<ResultAndState<<Self::Evm as Evm>::HaltReason>, BlockExecutionError> {
+            // Call hook with our mock state for each transaction
+            if let Some(hook) = self.hook.as_mut() {
+                hook.on_state(StateChangeSource::Transaction(0), &self.state);
+            }
+
+            Ok(ResultAndState::new(
+                ExecutionResult::Success {
+                    reason: SuccessReason::Return,
+                    gas_used: 1000, // Mock gas used
+                    gas_refunded: 0,
+                    logs: vec![],
+                    output: Output::Call(Bytes::from(vec![])),
+                },
+                Default::default(),
+            ))
+        }
+
+        fn commit_transaction(
+            &mut self,
+            _output: ResultAndState<<Self::Evm as Evm>::HaltReason>,
+            _tx: impl ExecutableTx<Self>,
+        ) -> Result<u64, BlockExecutionError> {
+            Ok(1000)
+        }
+
+        fn finish(
+            self,
+        ) -> Result<(Self::Evm, BlockExecutionResult<Self::Receipt>), BlockExecutionError> {
+            let Self { hook, state, .. } = self;
+
+            // Call hook with our mock state
+            if let Some(mut hook) = hook {
+                hook.on_state(StateChangeSource::Transaction(0), &state);
+            }
+
+            // Create a mock EVM
+            let db = State::builder()
+                .with_database(EmptyDB::default())
+                .with_bundle_update()
+                .without_state_clear()
+                .build();
+            let evm = EthEvm::new(
+                Context::mainnet().with_db(db).build_mainnet_with_inspector(NoOpInspector {}),
+                false,
+            );
+
+            // Return successful result like the original tests
+            Ok((
+                evm,
+                BlockExecutionResult {
+                    receipts: vec![],
+                    requests: Requests::default(),
+                    gas_used: 1000,
+                    blob_gas_used: 0,
+                },
+            ))
+        }
+
+        fn set_state_hook(&mut self, hook: Option<Box<dyn OnStateHook>>) {
+            self.hook = hook;
+        }
+
+        fn evm(&self) -> &Self::Evm {
+            panic!("Mock executor evm() not implemented")
+        }
+
+        fn evm_mut(&mut self) -> &mut Self::Evm {
+            panic!("Mock executor evm_mut() not implemented")
+        }
+    }
+
+    struct ChannelStateHook {
+        output: i32,
+        sender: mpsc::Sender<i32>,
+    }
+
+    impl OnStateHook for ChannelStateHook {
+        fn on_state(&mut self, _source: StateChangeSource, _state: &EvmState) {
+            let _ = self.sender.send(self.output);
+        }
+    }
 
     fn setup_test_recorder() -> Snapshotter {
         let recorder = DebuggingRecorder::new();
@@ -411,7 +523,37 @@ mod tests {
     }
 
     #[test]
-    fn test_record_block_execution_metrics() {
+    fn test_executor_metrics_hook_called() {
+        let metrics = EngineApiMetrics::default();
+        let input = RecoveredBlock::<reth_ethereum_primitives::Block>::default();
+
+        let (tx, rx) = mpsc::channel();
+        let expected_output = 42;
+        let state_hook = Box::new(ChannelStateHook { sender: tx, output: expected_output });
+
+        let state = EvmState::default();
+        let executor = MockExecutor::new(state);
+
+        // This will fail to create the EVM but should still call the hook
+        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)
+        match rx.try_recv() {
+            Ok(actual_output) => assert_eq!(actual_output, expected_output),
+            Err(_) => {
+                // Hook wasn't called, which is expected if the mock fails early
+                // The test still validates that the code compiles and runs
+            }
+        }
+    }
+
+    #[test]
+    fn test_executor_metrics_hook_metrics_recorded() {
         let snapshotter = setup_test_recorder();
         let metrics = EngineApiMetrics::default();
 
@@ -420,17 +562,42 @@ mod tests {
         metrics.executor.gas_per_second.set(0.0);
         metrics.executor.gas_used_histogram.record(0.0);
 
-        let output = BlockExecutionOutput::<Receipt> {
-            state: BundleState::default(),
-            result: BlockExecutionResult {
-                receipts: vec![],
-                requests: Requests::default(),
-                gas_used: 21000,
-                blob_gas_used: 0,
-            },
+        let input = RecoveredBlock::<reth_ethereum_primitives::Block>::default();
+
+        let (tx, _rx) = mpsc::channel();
+        let state_hook = Box::new(ChannelStateHook { sender: tx, output: 42 });
+
+        // Create a state with some data
+        let state = {
+            let mut state = EvmState::default();
+            let storage =
+                EvmStorage::from_iter([(U256::from(1), EvmStorageSlot::new(U256::from(2), 0))]);
+            state.insert(
+                Default::default(),
+                Account {
+                    info: AccountInfo {
+                        balance: U256::from(100),
+                        nonce: 10,
+                        code_hash: B256::random(),
+                        code: Default::default(),
+                    },
+                    storage,
+                    status: AccountStatus::default(),
+                    transaction_id: 0,
+                },
+            );
+            state
         };
 
-        metrics.record_block_execution(&output, Duration::from_millis(100));
+        let executor = MockExecutor::new(state);
+
+        // Execute (will fail but should still update some metrics)
+        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();
 

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

@@ -30,14 +30,11 @@ 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, StorageChangeSetReader,
-    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};
@@ -85,12 +82,6 @@ pub mod state;
 /// backfill this gap.
 pub(crate) const MIN_BLOCKS_FOR_PIPELINE_RUN: u64 = EPOCH_SLOTS;
 
-/// The minimum number of blocks to retain in the changeset cache after eviction.
-///
-/// This ensures that recent trie changesets are kept in memory for potential reorgs,
-/// even when the finalized block is not set (e.g., on L2s like Optimism).
-const CHANGESET_CACHE_RETENTION_BLOCKS: u64 = 64;
-
 /// A builder for creating state providers that can be used across threads.
 #[derive(Clone, Debug)]
 pub struct StateProviderBuilder<N: NodePrimitives, P> {
@@ -280,8 +271,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
@@ -306,7 +295,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()
     }
 }
@@ -319,13 +307,11 @@ where
         + StateProviderFactory
         + StateReader<Receipt = N::Receipt>
         + HashedPostStateProvider
+        + TrieReader
         + Clone
         + 'static,
-    <P as DatabaseProviderFactory>::Provider: BlockReader<Block = N::Block, Header = N::BlockHeader>
-        + StageCheckpointReader
-        + ChangeSetReader
-        + StorageChangeSetReader
-        + 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>,
@@ -345,7 +331,6 @@ where
         config: TreeConfig,
         engine_kind: EngineApiKind,
         evm_config: C,
-        changeset_cache: ChangesetCache,
     ) -> Self {
         let (incoming_tx, incoming) = crossbeam_channel::unbounded();
 
@@ -366,7 +351,6 @@ where
             incoming_tx,
             engine_kind,
             evm_config,
-            changeset_cache,
         }
     }
 
@@ -386,7 +370,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);
@@ -418,7 +401,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();
@@ -1383,29 +1365,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 eviction threshold.
-        // Keep at least CHANGESET_CACHE_RETENTION_BLOCKS from the persisted tip, and also respect
-        // the finalized block if set.
-        let min_threshold =
-            last_persisted_block_number.saturating_sub(CHANGESET_CACHE_RETENTION_BLOCKS);
-        let eviction_threshold =
-            if let Some(finalized) = self.canonical_in_memory_state.get_finalized_num_hash() {
-                // Use the minimum of finalized block and retention threshold to be conservative
-                finalized.number.min(min_threshold)
-            } else {
-                // When finalized is not set (e.g., on L2s), use the retention threshold
-                min_threshold
-            };
-        debug!(
-            target: "engine::tree",
-            last_persisted = last_persisted_block_number,
-            finalized_number = ?self.canonical_in_memory_state.get_finalized_num_hash().map(|f| f.number),
-            eviction_threshold,
-            "Evicting changesets below threshold"
-        );
-        self.changeset_cache.evict(eviction_threshold);
-
         self.on_new_persisted_block()?;
         Ok(())
     }
@@ -1492,13 +1451,9 @@ where
                                     self.on_maybe_tree_event(res.event.take())?;
                                 }
 
-                                if let Err(ref err) = output {
-                                    error!(target: "engine::tree", %err, ?state, "Error processing forkchoice update");
-                                }
-
                                 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,
                                 );
@@ -1518,12 +1473,10 @@ where
                                 let gas_used = payload.gas_used();
                                 let num_hash = payload.num_hash();
                                 let mut output = self.on_new_payload(payload);
-                                self.metrics.engine.new_payload.update_response_metrics(
-                                    start,
-                                    &mut self.metrics.engine.forkchoice_updated.latest_finish_at,
-                                    &output,
-                                    gas_used,
-                                );
+                                self.metrics
+                                    .engine
+                                    .new_payload
+                                    .update_response_metrics(start, &output, gas_used);
 
                                 let maybe_event =
                                     output.as_mut().ok().and_then(|out| out.event.take());
@@ -1698,18 +1651,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
@@ -1877,7 +1818,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
@@ -1890,23 +1830,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);
@@ -1914,19 +1843,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,
         )))
     }

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![],

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

@@ -0,0 +1,188 @@
+//! 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_sparse::{
+    errors::SparseTrieResult, provider::TrieNodeProvider, LeafLookup, LeafLookupError,
+    SerialSparseTrie, SparseTrieInterface, SparseTrieUpdates,
+};
+use reth_trie_sparse_parallel::ParallelSparseTrie;
+use std::borrow::Cow;
+
+/// Enum for switching between serial and parallel sparse trie implementations.
+///
+/// This type allows runtime selection between different sparse trie implementations,
+/// providing flexibility in choosing the appropriate implementation based on workload
+/// characteristics.
+#[derive(Debug, Clone)]
+pub(crate) enum ConfiguredSparseTrie {
+    /// Serial implementation of the sparse trie.
+    Serial(Box<SerialSparseTrie>),
+    /// Parallel implementation of the sparse trie.
+    Parallel(Box<ParallelSparseTrie>),
+}
+
+impl From<SerialSparseTrie> for ConfiguredSparseTrie {
+    fn from(trie: SerialSparseTrie) -> Self {
+        Self::Serial(Box::new(trie))
+    }
+}
+
+impl From<ParallelSparseTrie> for ConfiguredSparseTrie {
+    fn from(trie: ParallelSparseTrie) -> Self {
+        Self::Parallel(Box::new(trie))
+    }
+}
+
+impl Default for ConfiguredSparseTrie {
+    fn default() -> Self {
+        Self::Serial(Default::default())
+    }
+}
+
+impl SparseTrieInterface for ConfiguredSparseTrie {
+    fn with_root(
+        self,
+        root: TrieNode,
+        masks: Option<BranchNodeMasks>,
+        retain_updates: bool,
+    ) -> SparseTrieResult<Self> {
+        match self {
+            Self::Serial(trie) => {
+                trie.with_root(root, masks, retain_updates).map(|t| Self::Serial(Box::new(t)))
+            }
+            Self::Parallel(trie) => {
+                trie.with_root(root, masks, retain_updates).map(|t| Self::Parallel(Box::new(t)))
+            }
+        }
+    }
+
+    fn with_updates(self, retain_updates: bool) -> Self {
+        match self {
+            Self::Serial(trie) => Self::Serial(Box::new(trie.with_updates(retain_updates))),
+            Self::Parallel(trie) => Self::Parallel(Box::new(trie.with_updates(retain_updates))),
+        }
+    }
+
+    fn reserve_nodes(&mut self, additional: usize) {
+        match self {
+            Self::Serial(trie) => trie.reserve_nodes(additional),
+            Self::Parallel(trie) => trie.reserve_nodes(additional),
+        }
+    }
+
+    fn reveal_node(
+        &mut self,
+        path: Nibbles,
+        node: TrieNode,
+        masks: Option<BranchNodeMasks>,
+    ) -> SparseTrieResult<()> {
+        match self {
+            Self::Serial(trie) => trie.reveal_node(path, node, masks),
+            Self::Parallel(trie) => trie.reveal_node(path, node, masks),
+        }
+    }
+
+    fn reveal_nodes(&mut self, nodes: Vec<ProofTrieNode>) -> SparseTrieResult<()> {
+        match self {
+            Self::Serial(trie) => trie.reveal_nodes(nodes),
+            Self::Parallel(trie) => trie.reveal_nodes(nodes),
+        }
+    }
+
+    fn update_leaf<P: TrieNodeProvider>(
+        &mut self,
+        full_path: Nibbles,
+        value: Vec<u8>,
+        provider: P,
+    ) -> SparseTrieResult<()> {
+        match self {
+            Self::Serial(trie) => trie.update_leaf(full_path, value, provider),
+            Self::Parallel(trie) => trie.update_leaf(full_path, value, provider),
+        }
+    }
+
+    fn remove_leaf<P: TrieNodeProvider>(
+        &mut self,
+        full_path: &Nibbles,
+        provider: P,
+    ) -> SparseTrieResult<()> {
+        match self {
+            Self::Serial(trie) => trie.remove_leaf(full_path, provider),
+            Self::Parallel(trie) => trie.remove_leaf(full_path, provider),
+        }
+    }
+
+    fn root(&mut self) -> B256 {
+        match self {
+            Self::Serial(trie) => trie.root(),
+            Self::Parallel(trie) => trie.root(),
+        }
+    }
+
+    fn update_subtrie_hashes(&mut self) {
+        match self {
+            Self::Serial(trie) => trie.update_subtrie_hashes(),
+            Self::Parallel(trie) => trie.update_subtrie_hashes(),
+        }
+    }
+
+    fn get_leaf_value(&self, full_path: &Nibbles) -> Option<&Vec<u8>> {
+        match self {
+            Self::Serial(trie) => trie.get_leaf_value(full_path),
+            Self::Parallel(trie) => trie.get_leaf_value(full_path),
+        }
+    }
+
+    fn find_leaf(
+        &self,
+        full_path: &Nibbles,
+        expected_value: Option<&Vec<u8>>,
+    ) -> Result<LeafLookup, LeafLookupError> {
+        match self {
+            Self::Serial(trie) => trie.find_leaf(full_path, expected_value),
+            Self::Parallel(trie) => trie.find_leaf(full_path, expected_value),
+        }
+    }
+
+    fn take_updates(&mut self) -> SparseTrieUpdates {
+        match self {
+            Self::Serial(trie) => trie.take_updates(),
+            Self::Parallel(trie) => trie.take_updates(),
+        }
+    }
+
+    fn wipe(&mut self) {
+        match self {
+            Self::Serial(trie) => trie.wipe(),
+            Self::Parallel(trie) => trie.wipe(),
+        }
+    }
+
+    fn clear(&mut self) {
+        match self {
+            Self::Serial(trie) => trie.clear(),
+            Self::Parallel(trie) => trie.clear(),
+        }
+    }
+
+    fn updates_ref(&self) -> Cow<'_, SparseTrieUpdates> {
+        match self {
+            Self::Serial(trie) => trie.updates_ref(),
+            Self::Parallel(trie) => trie.updates_ref(),
+        }
+    }
+    fn shrink_nodes_to(&mut self, size: usize) {
+        match self {
+            Self::Serial(trie) => trie.shrink_nodes_to(size),
+            Self::Parallel(trie) => trie.shrink_nodes_to(size),
+        }
+    }
+
+    fn shrink_values_to(&mut self, size: usize) {
+        match self {
+            Self::Serial(trie) => trie.shrink_values_to(size),
+            Self::Parallel(trie) => trie.shrink_values_to(size),
+        }
+    }
+}

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

@@ -2,7 +2,10 @@
 
 use super::precompile_cache::PrecompileCacheMap;
 use crate::tree::{
-    cached_state::{CachedStateMetrics, CachedStateProvider, ExecutionCache, SavedCache},
+    cached_state::{
+        CachedStateMetrics, CachedStateProvider, ExecutionCache as StateExecutionCache,
+        ExecutionCacheBuilder, SavedCache,
+    },
     payload_processor::{
         prewarm::{PrewarmCacheTask, PrewarmContext, PrewarmMode, PrewarmTaskEvent},
         sparse_trie::StateRootComputeOutcome,
@@ -12,26 +15,23 @@ use crate::tree::{
 };
 use alloy_eip7928::BlockAccessList;
 use alloy_eips::eip1898::BlockWithParent;
-use alloy_evm::block::StateChangeSource;
+use alloy_evm::{block::StateChangeSource, ToTxEnv};
 use alloy_primitives::B256;
 use crossbeam_channel::Sender as CrossbeamSender;
 use executor::WorkloadExecutor;
-use metrics::Counter;
 use multiproof::{SparseTrieUpdate, *};
 use parking_lot::RwLock;
 use prewarm::PrewarmMetrics;
 use rayon::prelude::*;
 use reth_evm::{
-    block::ExecutableTxParts,
     execute::{ExecutableTxFor, WithTxEnv},
     ConfigureEvm, EvmEnvFor, ExecutableTxIterator, ExecutableTxTuple, OnStateHook, SpecFor,
     TxEnvFor,
 };
-use reth_metrics::Metrics;
+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};
@@ -41,7 +41,7 @@ use reth_trie_parallel::{
 };
 use reth_trie_sparse::{
     provider::{TrieNodeProvider, TrieNodeProviderFactory},
-    ClearedSparseStateTrie, RevealableSparseTrie, SparseStateTrie,
+    ClearedSparseStateTrie, SparseStateTrie, SparseTrie,
 };
 use reth_trie_sparse_parallel::{ParallelSparseTrie, ParallelismThresholds};
 use std::{
@@ -57,12 +57,14 @@ use std::{
 use tracing::{debug, debug_span, instrument, warn, Span};
 
 pub mod bal;
+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;
+
 /// Default parallelism thresholds to use with the [`ParallelSparseTrie`].
 ///
 /// These values were determined by performing benchmarks using gradually increasing values to judge
@@ -96,7 +98,7 @@ pub const SPARSE_TRIE_MAX_VALUES_SHRINK_CAPACITY: usize = 1_000_000;
 
 /// Type alias for [`PayloadHandle`] returned by payload processor spawn methods.
 type IteratorPayloadHandle<Evm, I, N> = PayloadHandle<
-    WithTxEnv<TxEnvFor<Evm>, <I as ExecutableTxIterator<Evm>>::Recovered>,
+    WithTxEnv<TxEnvFor<Evm>, <I as ExecutableTxTuple>::Tx>,
     <I as ExecutableTxTuple>::Error,
     <N as NodePrimitives>::Receipt,
 >;
@@ -110,11 +112,11 @@ where
     /// The executor used by to spawn tasks.
     executor: WorkloadExecutor,
     /// The most recent cache used for execution.
-    execution_cache: PayloadExecutionCache,
+    execution_cache: ExecutionCache,
     /// Metrics for trie operations
     trie_metrics: MultiProofTaskMetrics,
     /// Cross-block cache size in bytes.
-    cross_block_cache_size: usize,
+    cross_block_cache_size: u64,
     /// Whether transactions should not be executed on prewarming task.
     disable_transaction_prewarming: bool,
     /// Whether state cache should be disable
@@ -128,12 +130,14 @@ where
     /// A cleared `SparseStateTrie`, kept around to be reused for the state root computation so
     /// that allocations can be minimized.
     sparse_state_trie: Arc<
-        parking_lot::Mutex<Option<ClearedSparseStateTrie<ParallelSparseTrie, ParallelSparseTrie>>>,
+        parking_lot::Mutex<
+            Option<ClearedSparseStateTrie<ConfiguredSparseTrie, ConfiguredSparseTrie>>,
+        >,
     >,
+    /// Whether to disable the parallel sparse trie.
+    disable_parallel_sparse_trie: bool,
     /// Maximum concurrency for prewarm task.
     prewarm_max_concurrency: usize,
-    /// Whether to disable cache metrics recording.
-    disable_cache_metrics: bool,
 }
 
 impl<N, Evm> PayloadProcessor<Evm>
@@ -164,8 +168,8 @@ where
             precompile_cache_disabled: config.precompile_cache_disabled(),
             precompile_cache_map,
             sparse_state_trie: Arc::default(),
+            disable_parallel_sparse_trie: config.disable_parallel_sparse_trie(),
             prewarm_max_concurrency: config.prewarm_max_concurrency(),
-            disable_cache_metrics: config.disable_cache_metrics(),
         }
     }
 }
@@ -237,9 +241,6 @@ where
         let (to_sparse_trie, sparse_trie_rx) = channel();
         let (to_multi_proof, from_multi_proof) = crossbeam_channel::unbounded();
 
-        // Extract V2 proofs flag early so we can pass it to prewarm
-        let v2_proofs_enabled = config.enable_proof_v2();
-
         // Handle BAL-based optimization if available
         let prewarm_handle = if let Some(bal) = bal {
             // When BAL is present, use BAL prewarming and send BAL to multiproof
@@ -256,7 +257,6 @@ where
                 provider_builder.clone(),
                 None, // Don't send proof targets when BAL is present
                 Some(bal),
-                v2_proofs_enabled,
             )
         } else {
             // Normal path: spawn with transaction prewarming
@@ -267,7 +267,6 @@ where
                 provider_builder.clone(),
                 Some(to_multi_proof.clone()),
                 None,
-                v2_proofs_enabled,
             )
         };
 
@@ -275,6 +274,7 @@ 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,
@@ -286,13 +286,10 @@ where
         let multi_proof_task = MultiProofTask::new(
             proof_handle.clone(),
             to_sparse_trie,
-            config
-                .multiproof_chunking_enabled()
-                .then_some(config.effective_multiproof_chunk_size()),
+            config.multiproof_chunking_enabled().then_some(config.multiproof_chunk_size()),
             to_multi_proof.clone(),
             from_multi_proof,
-        )
-        .with_v2_proofs_enabled(v2_proofs_enabled);
+        );
 
         // spawn multi-proof task
         let parent_span = span.clone();
@@ -302,7 +299,7 @@ where
             // Build a state provider for the multiproof task
             let provider = provider_builder.build().expect("failed to build provider");
             let provider = if let Some(saved_cache) = saved_cache {
-                let (cache, metrics, _disable_metrics) = saved_cache.split();
+                let (cache, metrics) = saved_cache.split();
                 Box::new(CachedStateProvider::new(provider, cache, metrics))
                     as Box<dyn StateProvider>
             } else {
@@ -341,9 +338,8 @@ where
         P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
     {
         let (prewarm_rx, execution_rx, size_hint) = self.spawn_tx_iterator(transactions);
-        // This path doesn't use multiproof, so V2 proofs flag doesn't matter
         let prewarm_handle =
-            self.spawn_caching_with(env, prewarm_rx, size_hint, provider_builder, None, bal, false);
+            self.spawn_caching_with(env, prewarm_rx, size_hint, provider_builder, None, bal);
         PayloadHandle {
             to_multi_proof: None,
             prewarm_handle,
@@ -359,8 +355,8 @@ where
         &self,
         transactions: I,
     ) -> (
-        mpsc::Receiver<WithTxEnv<TxEnvFor<Evm>, I::Recovered>>,
-        mpsc::Receiver<Result<WithTxEnv<TxEnvFor<Evm>, I::Recovered>, I::Error>>,
+        mpsc::Receiver<WithTxEnv<TxEnvFor<Evm>, I::Tx>>,
+        mpsc::Receiver<Result<WithTxEnv<TxEnvFor<Evm>, I::Tx>, I::Error>>,
         usize,
     ) {
         let (transactions, convert) = transactions.into();
@@ -375,10 +371,7 @@ where
         self.executor.spawn_blocking(move || {
             transactions.enumerate().for_each_with(ooo_tx, |ooo_tx, (idx, tx)| {
                 let tx = convert(tx);
-                let tx = tx.map(|tx| {
-                    let (tx_env, tx) = tx.into_parts();
-                    WithTxEnv { tx_env, tx: Arc::new(tx) }
-                });
+                let tx = tx.map(|tx| WithTxEnv { tx_env: tx.to_tx_env(), tx: Arc::new(tx) });
                 // Only send Ok(_) variants to prewarming task.
                 if let Ok(tx) = &tx {
                     let _ = prewarm_tx.send(tx.clone());
@@ -413,7 +406,6 @@ where
     }
 
     /// Spawn prewarming optionally wired to the multiproof task for target updates.
-    #[expect(clippy::too_many_arguments)]
     fn spawn_caching_with<P>(
         &self,
         env: ExecutionEnv<Evm>,
@@ -422,7 +414,6 @@ where
         provider_builder: StateProviderBuilder<N, P>,
         to_multi_proof: Option<CrossbeamSender<MultiProofMessage>>,
         bal: Option<Arc<BlockAccessList>>,
-        v2_proofs_enabled: bool,
     ) -> CacheTaskHandle<N::Receipt>
     where
         P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
@@ -445,7 +436,6 @@ where
             terminate_execution: Arc::new(AtomicBool::new(false)),
             precompile_cache_disabled: self.precompile_cache_disabled,
             precompile_cache_map: self.precompile_cache_map.clone(),
-            v2_proofs_enabled,
         };
 
         let (prewarm_task, to_prewarm_task) = PrewarmCacheTask::new(
@@ -484,12 +474,8 @@ where
             cache
         } else {
             debug!("creating new execution cache on cache miss");
-            let start = Instant::now();
-            let cache = ExecutionCache::new(self.cross_block_cache_size);
-            let metrics = CachedStateMetrics::zeroed();
-            metrics.record_cache_creation(start.elapsed());
-            SavedCache::new(parent_hash, cache, metrics)
-                .with_disable_cache_metrics(self.disable_cache_metrics)
+            let cache = ExecutionCacheBuilder::default().build_caches(self.cross_block_cache_size);
+            SavedCache::new(parent_hash, cache, CachedStateMetrics::zeroed())
         }
     }
 
@@ -506,6 +492,7 @@ where
         BPF::StorageNodeProvider: TrieNodeProvider + Send + Sync,
     {
         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();
 
@@ -515,10 +502,14 @@ where
             // 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 = RevealableSparseTrie::blind_from(
-                    ParallelSparseTrie::default()
-                        .with_parallelism_thresholds(PARALLEL_SPARSE_TRIE_PARALLELISM_THRESHOLDS),
-                );
+                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())
@@ -527,13 +518,12 @@ where
                 )
             });
 
-            let task =
-                SparseTrieTask::<_, ParallelSparseTrie, ParallelSparseTrie>::new_with_cleared_trie(
-                    sparse_trie_rx,
-                    proof_worker_handle,
-                    trie_metrics,
-                    sparse_state_trie,
-                );
+            let task = SparseTrieTask::<_, ConfiguredSparseTrie, ConfiguredSparseTrie>::new_with_cleared_trie(
+                sparse_trie_rx,
+                proof_worker_handle,
+                trie_metrics,
+                sparse_state_trie,
+            );
 
             let (result, trie) = task.run();
             // Send state root computation result
@@ -567,7 +557,6 @@ where
         block_with_parent: BlockWithParent,
         bundle_state: &BundleState,
     ) {
-        let disable_cache_metrics = self.disable_cache_metrics;
         self.execution_cache.update_with_guard(|cached| {
             if cached.as_ref().is_some_and(|c| c.executed_block_hash() != block_with_parent.parent) {
                 debug!(
@@ -575,27 +564,26 @@ where
                     parent_hash = %block_with_parent.parent,
                     "Cannot find cache for parent hash, skip updating cache with new state for inserted executed block",
                 );
-                return
+                return;
             }
 
             // Take existing cache (if any) or create fresh caches
-            let (caches, cache_metrics, _) = match cached.take() {
-                Some(existing) => existing.split(),
+            let (caches, cache_metrics) = match cached.take() {
+                Some(existing) => {
+                    existing.split()
+                }
                 None => (
-                    ExecutionCache::new(self.cross_block_cache_size),
+                    ExecutionCacheBuilder::default().build_caches(self.cross_block_cache_size),
                     CachedStateMetrics::zeroed(),
-                    false,
                 ),
             };
 
             // Insert the block's bundle state into cache
-            let new_cache =
-                SavedCache::new(block_with_parent.block.hash, caches, cache_metrics)
-                    .with_disable_cache_metrics(disable_cache_metrics);
+            let new_cache = SavedCache::new(block_with_parent.block.hash, caches, cache_metrics);
             if new_cache.cache().insert_state(bundle_state).is_err() {
                 *cached = None;
                 debug!(target: "engine::caching", "cleared execution cache on update error");
-                return
+                return;
             }
             new_cache.update_metrics();
 
@@ -659,7 +647,7 @@ impl<Tx, Err, R: Send + Sync + 'static> PayloadHandle<Tx, Err, R> {
     }
 
     /// Returns a clone of the caches used by prewarming
-    pub(super) fn caches(&self) -> Option<ExecutionCache> {
+    pub(super) fn caches(&self) -> Option<StateExecutionCache> {
         self.prewarm_handle.saved_cache.as_ref().map(|cache| cache.cache().clone())
     }
 
@@ -677,15 +665,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)
     }
 
@@ -721,21 +707,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
         }
     }
 }
@@ -744,10 +724,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 });
         }
     }
 }
@@ -763,29 +740,27 @@ impl<R> Drop for CacheTaskHandle<R> {
 /// ## Cache Safety
 ///
 /// **CRITICAL**: Cache update operations require exclusive access. All concurrent cache users
-/// (such as prewarming tasks) must be terminated before calling
-/// [`PayloadExecutionCache::update_with_guard`], otherwise the cache may be corrupted or cleared.
+/// (such as prewarming tasks) must be terminated before calling `update_with_guard`, otherwise
+/// the cache may be corrupted or cleared.
 ///
 /// ## Cache vs Prewarming Distinction
 ///
-/// **[`PayloadExecutionCache`]**:
+/// **`ExecutionCache`**:
 /// - Stores parent block's execution state after completion
 /// - Used to fetch parent data for next block's execution
 /// - Must be exclusively accessed during save operations
 ///
-/// **[`PrewarmCacheTask`]**:
+/// **`PrewarmCacheTask`**:
 /// - Speculatively loads accounts/storage that might be used in transaction execution
 /// - Prepares data for state root proof computation
 /// - Runs concurrently but must not interfere with cache saves
 #[derive(Clone, Debug, Default)]
-struct PayloadExecutionCache {
+struct ExecutionCache {
     /// Guarded cloneable cache identified by a block hash.
     inner: Arc<RwLock<Option<SavedCache>>>,
-    /// Metrics for cache operations.
-    metrics: ExecutionCacheMetrics,
 }
 
-impl PayloadExecutionCache {
+impl ExecutionCache {
     /// Returns the cache for `parent_hash` if it's available for use.
     ///
     /// A cache is considered available when:
@@ -821,16 +796,8 @@ impl PayloadExecutionCache {
                 "Existing cache found"
             );
 
-            if available {
-                // If the has is available (no other threads are using it), but has a mismatching
-                // parent hash, we can just clear it and keep using without re-creating from
-                // scratch.
-                if !hash_matches {
-                    c.clear();
-                }
-                return Some(c.clone())
-            } else if hash_matches {
-                self.metrics.execution_cache_in_use.increment(1);
+            if hash_matches && available {
+                return Some(c.clone());
             }
         } else {
             debug!(target: "engine::caching", %parent_hash, "No cache found");
@@ -867,15 +834,6 @@ impl PayloadExecutionCache {
     }
 }
 
-/// Metrics for execution cache operations.
-#[derive(Metrics, Clone)]
-#[metrics(scope = "consensus.engine.beacon")]
-pub(crate) struct ExecutionCacheMetrics {
-    /// Counter for when the execution cache was unavailable because other threads
-    /// (e.g., prewarming) are still using it.
-    pub(crate) execution_cache_in_use: Counter,
-}
-
 /// EVM context required to execute a block.
 #[derive(Debug, Clone)]
 pub struct ExecutionEnv<Evm: ConfigureEvm> {
@@ -902,9 +860,9 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::PayloadExecutionCache;
+    use super::ExecutionCache;
     use crate::tree::{
-        cached_state::{CachedStateMetrics, ExecutionCache, SavedCache},
+        cached_state::{CachedStateMetrics, ExecutionCacheBuilder, SavedCache},
         payload_processor::{
             evm_state_to_hashed_post_state, executor::WorkloadExecutor, PayloadProcessor,
         },
@@ -928,19 +886,18 @@ 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;
 
     fn make_saved_cache(hash: B256) -> SavedCache {
-        let execution_cache = ExecutionCache::new(1_000);
+        let execution_cache = ExecutionCacheBuilder::default().build_caches(1_000);
         SavedCache::new(hash, execution_cache, CachedStateMetrics::zeroed())
     }
 
     #[test]
     fn execution_cache_allows_single_checkout() {
-        let execution_cache = PayloadExecutionCache::default();
+        let execution_cache = ExecutionCache::default();
         let hash = B256::from([1u8; 32]);
 
         execution_cache.update_with_guard(|slot| *slot = Some(make_saved_cache(hash)));
@@ -959,7 +916,7 @@ mod tests {
 
     #[test]
     fn execution_cache_checkout_releases_on_drop() {
-        let execution_cache = PayloadExecutionCache::default();
+        let execution_cache = ExecutionCache::default();
         let hash = B256::from([2u8; 32]);
 
         execution_cache.update_with_guard(|slot| *slot = Some(make_saved_cache(hash)));
@@ -975,21 +932,19 @@ mod tests {
     }
 
     #[test]
-    fn execution_cache_mismatch_parent_clears_and_returns() {
-        let execution_cache = PayloadExecutionCache::default();
+    fn execution_cache_mismatch_parent_returns_none() {
+        let execution_cache = ExecutionCache::default();
         let hash = B256::from([3u8; 32]);
 
         execution_cache.update_with_guard(|slot| *slot = Some(make_saved_cache(hash)));
 
-        // When the parent hash doesn't match, the cache is cleared and returned for reuse
-        let different_hash = B256::from([4u8; 32]);
-        let cache = execution_cache.get_cache_for(different_hash);
-        assert!(cache.is_some(), "cache should be returned for reuse after clearing")
+        let miss = execution_cache.get_cache_for(B256::from([4u8; 32]));
+        assert!(miss.is_none(), "checkout should fail for different parent hash");
     }
 
     #[test]
     fn execution_cache_update_after_release_succeeds() {
-        let execution_cache = PayloadExecutionCache::default();
+        let execution_cache = ExecutionCache::default();
         let initial = B256::from([5u8; 32]);
 
         execution_cache.update_with_guard(|slot| *slot = Some(make_saved_cache(initial)));
@@ -1103,9 +1058,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,
@@ -1188,7 +1141,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
         );

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

@@ -11,20 +11,15 @@ use reth_metrics::Metrics;
 use reth_provider::AccountReader;
 use reth_revm::state::EvmState;
 use reth_trie::{
-    added_removed_keys::MultiAddedRemovedKeys, proof_v2, HashedPostState, HashedStorage,
+    added_removed_keys::MultiAddedRemovedKeys, DecodedMultiProof, HashedPostState, HashedStorage,
     MultiProofTargets,
 };
-#[cfg(test)]
-use reth_trie_parallel::stats::ParallelTrieTracker;
 use reth_trie_parallel::{
     proof::ParallelProof,
     proof_task::{
-        AccountMultiproofInput, ProofResult, ProofResultContext, ProofResultMessage,
-        ProofWorkerHandle,
+        AccountMultiproofInput, ProofResultContext, ProofResultMessage, ProofWorkerHandle,
     },
-    targets_v2::{ChunkedMultiProofTargetsV2, MultiProofTargetsV2},
 };
-use revm_primitives::map::{hash_map, B256Map};
 use std::{collections::BTreeMap, sync::Arc, time::Instant};
 use tracing::{debug, error, instrument, trace};
 
@@ -67,12 +62,12 @@ const DEFAULT_MAX_TARGETS_FOR_CHUNKING: usize = 300;
 
 /// A trie update that can be applied to sparse trie alongside the proofs for touched parts of the
 /// state.
-#[derive(Debug)]
+#[derive(Default, Debug)]
 pub struct SparseTrieUpdate {
     /// The state update that was used to calculate the proof
     pub(crate) state: HashedPostState,
     /// The calculated multiproof
-    pub(crate) multiproof: ProofResult,
+    pub(crate) multiproof: DecodedMultiProof,
 }
 
 impl SparseTrieUpdate {
@@ -84,11 +79,7 @@ impl SparseTrieUpdate {
     /// Construct update from multiproof.
     #[cfg(test)]
     pub(super) fn from_multiproof(multiproof: reth_trie::MultiProof) -> alloy_rlp::Result<Self> {
-        let stats = ParallelTrieTracker::default().finish();
-        Ok(Self {
-            state: HashedPostState::default(),
-            multiproof: ProofResult::Legacy(multiproof.try_into()?, stats),
-        })
+        Ok(Self { multiproof: multiproof.try_into()?, ..Default::default() })
     }
 
     /// Extend update with contents of the other.
@@ -102,7 +93,7 @@ impl SparseTrieUpdate {
 #[derive(Debug)]
 pub(super) enum MultiProofMessage {
     /// Prefetch proof targets
-    PrefetchProofs(VersionedMultiProofTargets),
+    PrefetchProofs(MultiProofTargets),
     /// New state update from transaction execution with its source
     StateUpdate(Source, EvmState),
     /// State update that can be applied to the sparse trie without any new proofs.
@@ -149,27 +140,22 @@ impl ProofSequencer {
     /// Adds a proof with the corresponding state update and returns all sequential proofs and state
     /// updates if we have a continuous sequence
     fn add_proof(&mut self, sequence: u64, update: SparseTrieUpdate) -> Vec<SparseTrieUpdate> {
-        // Optimization: fast path for in-order delivery to avoid BTreeMap overhead.
-        // If this is the expected sequence, return it immediately without buffering.
-        if sequence == self.next_to_deliver {
-            let mut consecutive_proofs = Vec::with_capacity(1);
-            consecutive_proofs.push(update);
-            self.next_to_deliver += 1;
-
-            // Check if we have subsequent proofs in the pending buffer
-            while let Some(pending) = self.pending_proofs.remove(&self.next_to_deliver) {
-                consecutive_proofs.push(pending);
-                self.next_to_deliver += 1;
-            }
-
-            return consecutive_proofs;
-        }
-
-        if sequence > self.next_to_deliver {
+        if sequence >= self.next_to_deliver {
             self.pending_proofs.insert(sequence, update);
         }
 
-        Vec::new()
+        let mut consecutive_proofs = Vec::with_capacity(self.pending_proofs.len());
+        let mut current_sequence = self.next_to_deliver;
+
+        // keep collecting proofs and state updates as long as we have consecutive sequence numbers
+        while let Some(pending) = self.pending_proofs.remove(&current_sequence) {
+            consecutive_proofs.push(pending);
+            current_sequence += 1;
+        }
+
+        self.next_to_deliver += consecutive_proofs.len() as u64;
+
+        consecutive_proofs
     }
 
     /// Returns true if we still have pending proofs
@@ -231,158 +217,15 @@ pub(crate) fn evm_state_to_hashed_post_state(update: EvmState) -> HashedPostStat
     hashed_state
 }
 
-/// Extends a `MultiProofTargets` with the contents of a `VersionedMultiProofTargets`,
-/// regardless of which variant the latter is.
-fn extend_multiproof_targets(dest: &mut MultiProofTargets, src: &VersionedMultiProofTargets) {
-    match src {
-        VersionedMultiProofTargets::Legacy(targets) => {
-            dest.extend_ref(targets);
-        }
-        VersionedMultiProofTargets::V2(targets) => {
-            // Add all account targets
-            for target in &targets.account_targets {
-                dest.entry(target.key()).or_default();
-            }
-
-            // Add all storage targets
-            for (hashed_address, slots) in &targets.storage_targets {
-                let slot_set = dest.entry(*hashed_address).or_default();
-                for slot in slots {
-                    slot_set.insert(slot.key());
-                }
-            }
-        }
-    }
-}
-
-/// A set of multiproof targets which can be either in the legacy or V2 representations.
-#[derive(Debug)]
-pub(super) enum VersionedMultiProofTargets {
-    /// Legacy targets
-    Legacy(MultiProofTargets),
-    /// V2 targets
-    V2(MultiProofTargetsV2),
-}
-
-impl VersionedMultiProofTargets {
-    /// Returns true if there are no account or storage targets.
-    fn is_empty(&self) -> bool {
-        match self {
-            Self::Legacy(targets) => targets.is_empty(),
-            Self::V2(targets) => targets.is_empty(),
-        }
-    }
-
-    /// Returns the number of account targets in the multiproof target
-    fn account_targets_len(&self) -> usize {
-        match self {
-            Self::Legacy(targets) => targets.len(),
-            Self::V2(targets) => targets.account_targets.len(),
-        }
-    }
-
-    /// Returns the number of storage targets in the multiproof target
-    fn storage_targets_len(&self) -> usize {
-        match self {
-            Self::Legacy(targets) => targets.values().map(|slots| slots.len()).sum::<usize>(),
-            Self::V2(targets) => {
-                targets.storage_targets.values().map(|slots| slots.len()).sum::<usize>()
-            }
-        }
-    }
-
-    /// Returns the number of accounts in the multiproof targets.
-    fn len(&self) -> usize {
-        match self {
-            Self::Legacy(targets) => targets.len(),
-            Self::V2(targets) => targets.account_targets.len(),
-        }
-    }
-
-    /// Returns the total storage slot count across all accounts.
-    fn storage_count(&self) -> usize {
-        match self {
-            Self::Legacy(targets) => targets.values().map(|slots| slots.len()).sum(),
-            Self::V2(targets) => targets.storage_targets.values().map(|slots| slots.len()).sum(),
-        }
-    }
-
-    /// Returns the number of items that will be considered during chunking.
-    fn chunking_length(&self) -> usize {
-        match self {
-            Self::Legacy(targets) => targets.chunking_length(),
-            Self::V2(targets) => {
-                // For V2, count accounts + storage slots
-                targets.account_targets.len() +
-                    targets.storage_targets.values().map(|slots| slots.len()).sum::<usize>()
-            }
-        }
-    }
-
-    /// Retains the targets representing the difference with another `MultiProofTargets`.
-    /// Removes all targets that are already present in `other`.
-    fn retain_difference(&mut self, other: &MultiProofTargets) {
-        match self {
-            Self::Legacy(targets) => {
-                targets.retain_difference(other);
-            }
-            Self::V2(targets) => {
-                // Remove account targets that exist in other
-                targets.account_targets.retain(|target| !other.contains_key(&target.key()));
-
-                // For each account in storage_targets, remove slots that exist in other
-                targets.storage_targets.retain(|hashed_address, slots| {
-                    if let Some(other_slots) = other.get(hashed_address) {
-                        slots.retain(|slot| !other_slots.contains(&slot.key()));
-                        !slots.is_empty()
-                    } else {
-                        true
-                    }
-                });
-            }
-        }
-    }
-
-    /// Extends this `VersionedMultiProofTargets` with the contents of another.
-    ///
-    /// Panics if the variants do not match.
-    fn extend(&mut self, other: Self) {
-        match (self, other) {
-            (Self::Legacy(dest), Self::Legacy(src)) => {
-                dest.extend(src);
-            }
-            (Self::V2(dest), Self::V2(src)) => {
-                dest.account_targets.extend(src.account_targets);
-                for (addr, slots) in src.storage_targets {
-                    dest.storage_targets.entry(addr).or_default().extend(slots);
-                }
-            }
-            _ => panic!("Cannot extend VersionedMultiProofTargets with mismatched variants"),
-        }
-    }
-
-    /// Chunks this `VersionedMultiProofTargets` into smaller chunks of the given size.
-    fn chunks(self, chunk_size: usize) -> Box<dyn Iterator<Item = Self>> {
-        match self {
-            Self::Legacy(targets) => {
-                Box::new(MultiProofTargets::chunks(targets, chunk_size).map(Self::Legacy))
-            }
-            Self::V2(targets) => {
-                Box::new(ChunkedMultiProofTargetsV2::new(targets, chunk_size).map(Self::V2))
-            }
-        }
-    }
-}
-
 /// Input parameters for dispatching a multiproof calculation.
 #[derive(Debug)]
 struct MultiproofInput {
     source: Option<Source>,
     hashed_state_update: HashedPostState,
-    proof_targets: VersionedMultiProofTargets,
+    proof_targets: MultiProofTargets,
     proof_sequence_number: u64,
     state_root_message_sender: CrossbeamSender<MultiProofMessage>,
-    multi_added_removed_keys: Option<Arc<MultiAddedRemovedKeys>>,
+    multi_added_removed_keys: Option<MultiAddedRemovedKeys>,
 }
 
 impl MultiproofInput {
@@ -414,6 +257,8 @@ pub struct MultiproofManager {
     proof_result_tx: CrossbeamSender<ProofResultMessage>,
     /// Metrics
     metrics: MultiProofTaskMetrics,
+    /// Whether to use V2 storage proofs
+    v2_proofs_enabled: bool,
 }
 
 impl MultiproofManager {
@@ -427,7 +272,9 @@ impl MultiproofManager {
         metrics.max_storage_workers.set(proof_worker_handle.total_storage_workers() as f64);
         metrics.max_account_workers.set(proof_worker_handle.total_account_workers() as f64);
 
-        Self { metrics, proof_worker_handle, proof_result_tx }
+        let v2_proofs_enabled = proof_worker_handle.v2_proofs_enabled();
+
+        Self { metrics, proof_worker_handle, proof_result_tx, v2_proofs_enabled }
     }
 
     /// Dispatches a new multiproof calculation to worker pools.
@@ -472,48 +319,41 @@ impl MultiproofManager {
             multi_added_removed_keys,
         } = multiproof_input;
 
+        let account_targets = proof_targets.len();
+        let storage_targets = proof_targets.values().map(|slots| slots.len()).sum::<usize>();
+
         trace!(
             target: "engine::tree::payload_processor::multiproof",
             proof_sequence_number,
             ?proof_targets,
-            account_targets = proof_targets.account_targets_len(),
-            storage_targets = proof_targets.storage_targets_len(),
+            account_targets,
+            storage_targets,
             ?source,
             "Dispatching multiproof to workers"
         );
 
         let start = Instant::now();
 
-        // Workers will send ProofResultMessage directly to proof_result_rx
-        let proof_result_sender = ProofResultContext::new(
-            self.proof_result_tx.clone(),
-            proof_sequence_number,
-            hashed_state_update,
-            start,
-        );
-
-        let input = match proof_targets {
-            VersionedMultiProofTargets::Legacy(proof_targets) => {
-                // Extend prefix sets with targets
-                let frozen_prefix_sets = ParallelProof::extend_prefix_sets_with_targets(
-                    &Default::default(),
-                    &proof_targets,
-                );
-
-                AccountMultiproofInput::Legacy {
-                    targets: proof_targets,
-                    prefix_sets: frozen_prefix_sets,
-                    collect_branch_node_masks: true,
-                    multi_added_removed_keys,
-                    proof_result_sender,
-                }
-            }
-            VersionedMultiProofTargets::V2(proof_targets) => {
-                AccountMultiproofInput::V2 { targets: proof_targets, proof_result_sender }
-            }
-        };
+        // Extend prefix sets with targets
+        let frozen_prefix_sets =
+            ParallelProof::extend_prefix_sets_with_targets(&Default::default(), &proof_targets);
 
         // Dispatch account multiproof to worker pool with result sender
+        let input = AccountMultiproofInput {
+            targets: proof_targets,
+            prefix_sets: frozen_prefix_sets,
+            collect_branch_node_masks: true,
+            multi_added_removed_keys,
+            // Workers will send ProofResultMessage directly to proof_result_rx
+            proof_result_sender: ProofResultContext::new(
+                self.proof_result_tx.clone(),
+                proof_sequence_number,
+                hashed_state_update,
+                start,
+            ),
+            v2_proofs_enabled: self.v2_proofs_enabled,
+        };
+
         if let Err(e) = self.proof_worker_handle.dispatch_account_multiproof(input) {
             error!(target: "engine::tree::payload_processor::multiproof", ?e, "Failed to dispatch account multiproof");
             return;
@@ -715,9 +555,6 @@ pub(super) struct MultiProofTask {
     /// there are any active workers and force chunking across workers. This is to prevent tasks
     /// which are very long from hitting a single worker.
     max_targets_for_chunking: usize,
-    /// Whether or not V2 proof calculation is enabled. If enabled then [`MultiProofTargetsV2`]
-    /// will be produced by state updates.
-    v2_proofs_enabled: bool,
 }
 
 impl MultiProofTask {
@@ -749,16 +586,9 @@ impl MultiProofTask {
             ),
             metrics,
             max_targets_for_chunking: DEFAULT_MAX_TARGETS_FOR_CHUNKING,
-            v2_proofs_enabled: false,
         }
     }
 
-    /// Enables V2 proof target generation on state updates.
-    pub(super) const fn with_v2_proofs_enabled(mut self, v2_proofs_enabled: bool) -> Self {
-        self.v2_proofs_enabled = v2_proofs_enabled;
-        self
-    }
-
     /// Handles request for proof prefetch.
     ///
     /// Returns how many multiproof tasks were dispatched for the prefetch request.
@@ -766,40 +596,22 @@ impl MultiProofTask {
         level = "debug",
         target = "engine::tree::payload_processor::multiproof",
         skip_all,
-        fields(accounts = targets.account_targets_len(), chunks = 0)
+        fields(accounts = targets.len(), chunks = 0)
     )]
-    fn on_prefetch_proof(&mut self, mut targets: VersionedMultiProofTargets) -> u64 {
+    fn on_prefetch_proof(&mut self, mut targets: MultiProofTargets) -> u64 {
         // Remove already fetched proof targets to avoid redundant work.
         targets.retain_difference(&self.fetched_proof_targets);
-        extend_multiproof_targets(&mut self.fetched_proof_targets, &targets);
+        self.fetched_proof_targets.extend_ref(&targets);
 
-        // For Legacy multiproofs, make sure all target accounts have an `AddedRemovedKeySet` in the
+        // Make sure all target accounts have an `AddedRemovedKeySet` in the
         // [`MultiAddedRemovedKeys`]. Even if there are not any known removed keys for the account,
         // we still want to optimistically fetch extension children for the leaf addition case.
-        // V2 multiproofs don't need this.
-        //
-        // Only clone the AddedRemovedKeys for accounts in the targets, not the entire accumulated
-        // set, to avoid O(n) cloning with many buffered blocks.
-        let multi_added_removed_keys =
-            if let VersionedMultiProofTargets::Legacy(legacy_targets) = &targets {
-                self.multi_added_removed_keys.touch_accounts(legacy_targets.keys().copied());
-                Some(Arc::new(MultiAddedRemovedKeys {
-                    account: self.multi_added_removed_keys.account.clone(),
-                    storages: legacy_targets
-                        .keys()
-                        .filter_map(|k| {
-                            self.multi_added_removed_keys.storages.get(k).map(|v| (*k, v.clone()))
-                        })
-                        .collect(),
-                }))
-            } else {
-                None
-            };
+        self.multi_added_removed_keys.touch_accounts(targets.keys().copied());
 
         self.metrics.prefetch_proof_targets_accounts_histogram.record(targets.len() as f64);
         self.metrics
             .prefetch_proof_targets_storages_histogram
-            .record(targets.storage_count() as f64);
+            .record(targets.values().map(|slots| slots.len()).sum::<usize>() as f64);
 
         let chunking_len = targets.chunking_length();
         let available_account_workers =
@@ -813,7 +625,7 @@ impl MultiProofTask {
             self.max_targets_for_chunking,
             available_account_workers,
             available_storage_workers,
-            VersionedMultiProofTargets::chunks,
+            MultiProofTargets::chunks,
             |proof_targets| {
                 self.multiproof_manager.dispatch(MultiproofInput {
                     source: None,
@@ -821,7 +633,7 @@ impl MultiProofTask {
                     proof_targets,
                     proof_sequence_number: self.proof_sequencer.next_sequence(),
                     state_root_message_sender: self.tx.clone(),
-                    multi_added_removed_keys: multi_added_removed_keys.clone(),
+                    multi_added_removed_keys: Some(self.multi_added_removed_keys.clone()),
                 });
             },
         );
@@ -889,42 +701,12 @@ impl MultiProofTask {
             state_updates += 1;
         }
 
-        // Clone+Arc MultiAddedRemovedKeys for sharing with the dispatched multiproof tasks
-        let multi_added_removed_keys = Arc::new(MultiAddedRemovedKeys {
-            account: self.multi_added_removed_keys.account.clone(),
-            storages: {
-                let mut storages = B256Map::with_capacity_and_hasher(
-                    not_fetched_state_update.storages.len(),
-                    Default::default(),
-                );
-
-                for account in not_fetched_state_update
-                    .storages
-                    .keys()
-                    .chain(not_fetched_state_update.accounts.keys())
-                {
-                    if let hash_map::Entry::Vacant(entry) = storages.entry(*account) {
-                        entry.insert(
-                            self.multi_added_removed_keys
-                                .storages
-                                .get(account)
-                                .cloned()
-                                .unwrap_or_default(),
-                        );
-                    }
-                }
-
-                storages
-            },
-        });
-
         let chunking_len = not_fetched_state_update.chunking_length();
         let mut spawned_proof_targets = MultiProofTargets::default();
         let available_account_workers =
             self.multiproof_manager.proof_worker_handle.available_account_workers();
         let available_storage_workers =
             self.multiproof_manager.proof_worker_handle.available_storage_workers();
-
         let num_chunks = dispatch_with_chunking(
             not_fetched_state_update,
             chunking_len,
@@ -937,10 +719,9 @@ impl MultiProofTask {
                 let proof_targets = get_proof_targets(
                     &hashed_state_update,
                     &self.fetched_proof_targets,
-                    &multi_added_removed_keys,
-                    self.v2_proofs_enabled,
+                    &self.multi_added_removed_keys,
                 );
-                extend_multiproof_targets(&mut spawned_proof_targets, &proof_targets);
+                spawned_proof_targets.extend_ref(&proof_targets);
 
                 self.multiproof_manager.dispatch(MultiproofInput {
                     source: Some(source),
@@ -948,7 +729,7 @@ impl MultiProofTask {
                     proof_targets,
                     proof_sequence_number: self.proof_sequencer.next_sequence(),
                     state_root_message_sender: self.tx.clone(),
-                    multi_added_removed_keys: Some(multi_added_removed_keys.clone()),
+                    multi_added_removed_keys: Some(self.multi_added_removed_keys.clone()),
                 });
             },
         );
@@ -1040,10 +821,7 @@ impl MultiProofTask {
                             batch_metrics.proofs_processed += 1;
                             if let Some(combined_update) = self.on_proof(
                                 sequence_number,
-                                SparseTrieUpdate {
-                                    state,
-                                    multiproof: ProofResult::empty(self.v2_proofs_enabled),
-                                },
+                                SparseTrieUpdate { state, multiproof: Default::default() },
                             ) {
                                 let _ = self.to_sparse_trie.send(combined_update);
                             }
@@ -1070,7 +848,8 @@ impl MultiProofTask {
                 }
 
                 let account_targets = merged_targets.len();
-                let storage_targets = merged_targets.storage_count();
+                let storage_targets =
+                    merged_targets.values().map(|slots| slots.len()).sum::<usize>();
                 batch_metrics.prefetch_proofs_requested += self.on_prefetch_proof(merged_targets);
                 trace!(
                     target: "engine::tree::payload_processor::multiproof",
@@ -1174,10 +953,7 @@ impl MultiProofTask {
 
                 if let Some(combined_update) = self.on_proof(
                     sequence_number,
-                    SparseTrieUpdate {
-                        state,
-                        multiproof: ProofResult::empty(self.v2_proofs_enabled),
-                    },
+                    SparseTrieUpdate { state, multiproof: Default::default() },
                 ) {
                     let _ = self.to_sparse_trie.send(combined_update);
                 }
@@ -1280,7 +1056,7 @@ impl MultiProofTask {
 
                                     let update = SparseTrieUpdate {
                                         state: proof_result.state,
-                                        multiproof: proof_result_data,
+                                        multiproof: proof_result_data.proof,
                                     };
 
                                     if let Some(combined_update) =
@@ -1370,7 +1146,7 @@ struct MultiproofBatchCtx {
     /// received.
     updates_finished_time: Option<Instant>,
     /// Reusable buffer for accumulating prefetch targets during batching.
-    accumulated_prefetch_targets: Vec<VersionedMultiProofTargets>,
+    accumulated_prefetch_targets: Vec<MultiProofTargets>,
 }
 
 impl MultiproofBatchCtx {
@@ -1416,77 +1192,40 @@ fn get_proof_targets(
     state_update: &HashedPostState,
     fetched_proof_targets: &MultiProofTargets,
     multi_added_removed_keys: &MultiAddedRemovedKeys,
-    v2_enabled: bool,
-) -> VersionedMultiProofTargets {
-    if v2_enabled {
-        let mut targets = MultiProofTargetsV2::default();
+) -> MultiProofTargets {
+    let mut targets = MultiProofTargets::default();
 
-        // first collect all new accounts (not previously fetched)
-        for &hashed_address in state_update.accounts.keys() {
-            if !fetched_proof_targets.contains_key(&hashed_address) {
-                targets.account_targets.push(hashed_address.into());
-            }
+    // first collect all new accounts (not previously fetched)
+    for hashed_address in state_update.accounts.keys() {
+        if !fetched_proof_targets.contains_key(hashed_address) {
+            targets.insert(*hashed_address, HashSet::default());
         }
-
-        // then process storage slots for all accounts in the state update
-        for (hashed_address, storage) in &state_update.storages {
-            let fetched = fetched_proof_targets.get(hashed_address);
-
-            // If the storage is wiped, we still need to fetch the account proof.
-            if storage.wiped && fetched.is_none() {
-                targets.account_targets.push(Into::<proof_v2::Target>::into(*hashed_address));
-                continue
-            }
-
-            let changed_slots = storage
-                .storage
-                .keys()
-                .filter(|slot| !fetched.is_some_and(|f| f.contains(*slot)))
-                .map(|slot| Into::<proof_v2::Target>::into(*slot))
-                .collect::<Vec<_>>();
-
-            if !changed_slots.is_empty() {
-                targets.account_targets.push((*hashed_address).into());
-                targets.storage_targets.insert(*hashed_address, changed_slots);
-            }
-        }
-
-        VersionedMultiProofTargets::V2(targets)
-    } else {
-        let mut targets = MultiProofTargets::default();
-
-        // first collect all new accounts (not previously fetched)
-        for hashed_address in state_update.accounts.keys() {
-            if !fetched_proof_targets.contains_key(hashed_address) {
-                targets.insert(*hashed_address, HashSet::default());
-            }
-        }
-
-        // then process storage slots for all accounts in the state update
-        for (hashed_address, storage) in &state_update.storages {
-            let fetched = fetched_proof_targets.get(hashed_address);
-            let storage_added_removed_keys = multi_added_removed_keys.get_storage(hashed_address);
-            let mut changed_slots = storage
-                .storage
-                .keys()
-                .filter(|slot| {
-                    !fetched.is_some_and(|f| f.contains(*slot)) ||
-                        storage_added_removed_keys.is_some_and(|k| k.is_removed(slot))
-                })
-                .peekable();
-
-            // If the storage is wiped, we still need to fetch the account proof.
-            if storage.wiped && fetched.is_none() {
-                targets.entry(*hashed_address).or_default();
-            }
-
-            if changed_slots.peek().is_some() {
-                targets.entry(*hashed_address).or_default().extend(changed_slots);
-            }
-        }
-
-        VersionedMultiProofTargets::Legacy(targets)
     }
+
+    // then process storage slots for all accounts in the state update
+    for (hashed_address, storage) in &state_update.storages {
+        let fetched = fetched_proof_targets.get(hashed_address);
+        let storage_added_removed_keys = multi_added_removed_keys.get_storage(hashed_address);
+        let mut changed_slots = storage
+            .storage
+            .keys()
+            .filter(|slot| {
+                !fetched.is_some_and(|f| f.contains(*slot)) ||
+                    storage_added_removed_keys.as_ref().is_some_and(|k| k.is_removed(slot))
+            })
+            .peekable();
+
+        // If the storage is wiped, we still need to fetch the account proof.
+        if storage.wiped && fetched.is_none() {
+            targets.entry(*hashed_address).or_default();
+        }
+
+        if changed_slots.peek().is_some() {
+            targets.entry(*hashed_address).or_default().extend(changed_slots);
+        }
+    }
+
+    targets
 }
 
 /// Dispatches work items as a single unit or in chunks based on target size and worker
@@ -1527,18 +1266,16 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::tree::cached_state::CachedStateProvider;
-
     use super::*;
+    use crate::tree::cached_state::{CachedStateProvider, ExecutionCacheBuilder};
     use alloy_eip7928::{AccountChanges, BalanceChange};
     use alloy_primitives::Address;
     use reth_provider::{
         providers::OverlayStateProviderFactory, test_utils::create_test_provider_factory,
         BlockNumReader, BlockReader, ChangeSetReader, DatabaseProviderFactory, LatestStateProvider,
-        PruneCheckpointReader, StageCheckpointReader, StateProviderBox, StorageChangeSetReader,
+        PruneCheckpointReader, StageCheckpointReader, StateProviderBox, TrieReader,
     };
     use reth_trie::MultiProof;
-    use reth_trie_db::ChangesetCache;
     use reth_trie_parallel::proof_task::{ProofTaskCtx, ProofWorkerHandle};
     use revm_primitives::{B256, U256};
     use std::sync::{Arc, OnceLock};
@@ -1559,18 +1296,17 @@ mod tests {
     where
         F: DatabaseProviderFactory<
                 Provider: BlockReader
+                              + TrieReader
                               + StageCheckpointReader
                               + PruneCheckpointReader
                               + ChangeSetReader
-                              + StorageChangeSetReader
                               + BlockNumReader,
             > + Clone
             + Send
             + 'static,
     {
         let rt_handle = get_test_runtime_handle();
-        let changeset_cache = ChangesetCache::new();
-        let overlay_factory = OverlayStateProviderFactory::new(factory, changeset_cache);
+        let overlay_factory = OverlayStateProviderFactory::new(factory);
         let task_ctx = ProofTaskCtx::new(overlay_factory);
         let proof_handle = ProofWorkerHandle::new(rt_handle, task_ctx, 1, 1, false);
         let (to_sparse_trie, _receiver) = std::sync::mpsc::channel();
@@ -1582,14 +1318,14 @@ mod tests {
     fn create_cached_provider<F>(factory: F) -> CachedStateProvider<StateProviderBox>
     where
         F: DatabaseProviderFactory<
-                Provider: BlockReader + StageCheckpointReader + PruneCheckpointReader,
+                Provider: BlockReader + TrieReader + StageCheckpointReader + PruneCheckpointReader,
             > + Clone
             + Send
             + 'static,
     {
         let db_provider = factory.database_provider_ro().unwrap();
         let state_provider: StateProviderBox = Box::new(LatestStateProvider::new(db_provider));
-        let cache = crate::tree::cached_state::ExecutionCache::new(1000);
+        let cache = ExecutionCacheBuilder::default().build_caches(1000);
         CachedStateProvider::new(state_provider, cache, Default::default())
     }
 
@@ -1694,24 +1430,12 @@ mod tests {
         state
     }
 
-    fn unwrap_legacy_targets(targets: VersionedMultiProofTargets) -> MultiProofTargets {
-        match targets {
-            VersionedMultiProofTargets::Legacy(targets) => targets,
-            VersionedMultiProofTargets::V2(_) => panic!("Expected Legacy targets"),
-        }
-    }
-
     #[test]
     fn test_get_proof_targets_new_account_targets() {
         let state = create_get_proof_targets_state();
         let fetched = MultiProofTargets::default();
 
-        let targets = unwrap_legacy_targets(get_proof_targets(
-            &state,
-            &fetched,
-            &MultiAddedRemovedKeys::new(),
-            false,
-        ));
+        let targets = get_proof_targets(&state, &fetched, &MultiAddedRemovedKeys::new());
 
         // should return all accounts as targets since nothing was fetched before
         assert_eq!(targets.len(), state.accounts.len());
@@ -1725,12 +1449,7 @@ mod tests {
         let state = create_get_proof_targets_state();
         let fetched = MultiProofTargets::default();
 
-        let targets = unwrap_legacy_targets(get_proof_targets(
-            &state,
-            &fetched,
-            &MultiAddedRemovedKeys::new(),
-            false,
-        ));
+        let targets = get_proof_targets(&state, &fetched, &MultiAddedRemovedKeys::new());
 
         // verify storage slots are included for accounts with storage
         for (addr, storage) in &state.storages {
@@ -1758,12 +1477,7 @@ mod tests {
         // mark the account as already fetched
         fetched.insert(*fetched_addr, HashSet::default());
 
-        let targets = unwrap_legacy_targets(get_proof_targets(
-            &state,
-            &fetched,
-            &MultiAddedRemovedKeys::new(),
-            false,
-        ));
+        let targets = get_proof_targets(&state, &fetched, &MultiAddedRemovedKeys::new());
 
         // should not include the already fetched account since it has no storage updates
         assert!(!targets.contains_key(fetched_addr));
@@ -1783,12 +1497,7 @@ mod tests {
         fetched_slots.insert(fetched_slot);
         fetched.insert(*addr, fetched_slots);
 
-        let targets = unwrap_legacy_targets(get_proof_targets(
-            &state,
-            &fetched,
-            &MultiAddedRemovedKeys::new(),
-            false,
-        ));
+        let targets = get_proof_targets(&state, &fetched, &MultiAddedRemovedKeys::new());
 
         // should not include the already fetched storage slot
         let target_slots = &targets[addr];
@@ -1801,12 +1510,7 @@ mod tests {
         let state = HashedPostState::default();
         let fetched = MultiProofTargets::default();
 
-        let targets = unwrap_legacy_targets(get_proof_targets(
-            &state,
-            &fetched,
-            &MultiAddedRemovedKeys::new(),
-            false,
-        ));
+        let targets = get_proof_targets(&state, &fetched, &MultiAddedRemovedKeys::new());
 
         assert!(targets.is_empty());
     }
@@ -1833,12 +1537,7 @@ mod tests {
         fetched_slots.insert(slot1);
         fetched.insert(addr1, fetched_slots);
 
-        let targets = unwrap_legacy_targets(get_proof_targets(
-            &state,
-            &fetched,
-            &MultiAddedRemovedKeys::new(),
-            false,
-        ));
+        let targets = get_proof_targets(&state, &fetched, &MultiAddedRemovedKeys::new());
 
         assert!(targets.contains_key(&addr2));
         assert!(!targets[&addr1].contains(&slot1));
@@ -1864,12 +1563,7 @@ mod tests {
         assert!(!state.accounts.contains_key(&addr));
         assert!(!fetched.contains_key(&addr));
 
-        let targets = unwrap_legacy_targets(get_proof_targets(
-            &state,
-            &fetched,
-            &MultiAddedRemovedKeys::new(),
-            false,
-        ));
+        let targets = get_proof_targets(&state, &fetched, &MultiAddedRemovedKeys::new());
 
         // verify that we still get the storage slots for the unmodified account
         assert!(targets.contains_key(&addr));
@@ -1911,12 +1605,7 @@ mod tests {
         removed_state.storages.insert(addr, removed_storage);
         multi_added_removed_keys.update_with_state(&removed_state);
 
-        let targets = unwrap_legacy_targets(get_proof_targets(
-            &state,
-            &fetched,
-            &multi_added_removed_keys,
-            false,
-        ));
+        let targets = get_proof_targets(&state, &fetched, &multi_added_removed_keys);
 
         // slot1 should be included despite being fetched, because it's marked as removed
         assert!(targets.contains_key(&addr));
@@ -1943,12 +1632,7 @@ mod tests {
         storage.storage.insert(slot1, U256::from(100));
         state.storages.insert(addr, storage);
 
-        let targets = unwrap_legacy_targets(get_proof_targets(
-            &state,
-            &fetched,
-            &multi_added_removed_keys,
-            false,
-        ));
+        let targets = get_proof_targets(&state, &fetched, &multi_added_removed_keys);
 
         // account should be included because storage is wiped and account wasn't fetched
         assert!(targets.contains_key(&addr));
@@ -1991,12 +1675,7 @@ mod tests {
         removed_state.storages.insert(addr, removed_storage);
         multi_added_removed_keys.update_with_state(&removed_state);
 
-        let targets = unwrap_legacy_targets(get_proof_targets(
-            &state,
-            &fetched,
-            &multi_added_removed_keys,
-            false,
-        ));
+        let targets = get_proof_targets(&state, &fetched, &multi_added_removed_keys);
 
         // only slots in the state update can be included, so slot3 should not appear
         assert!(!targets.contains_key(&addr));
@@ -2023,12 +1702,9 @@ mod tests {
         targets3.insert(addr3, HashSet::default());
 
         let tx = task.tx.clone();
-        tx.send(MultiProofMessage::PrefetchProofs(VersionedMultiProofTargets::Legacy(targets1)))
-            .unwrap();
-        tx.send(MultiProofMessage::PrefetchProofs(VersionedMultiProofTargets::Legacy(targets2)))
-            .unwrap();
-        tx.send(MultiProofMessage::PrefetchProofs(VersionedMultiProofTargets::Legacy(targets3)))
-            .unwrap();
+        tx.send(MultiProofMessage::PrefetchProofs(targets1)).unwrap();
+        tx.send(MultiProofMessage::PrefetchProofs(targets2)).unwrap();
+        tx.send(MultiProofMessage::PrefetchProofs(targets3)).unwrap();
 
         let proofs_requested =
             if let Ok(MultiProofMessage::PrefetchProofs(targets)) = task.rx.recv() {
@@ -2042,12 +1718,11 @@ mod tests {
 
                 assert_eq!(num_batched, 3);
                 assert_eq!(merged_targets.len(), 3);
-                let legacy_targets = unwrap_legacy_targets(merged_targets);
-                assert!(legacy_targets.contains_key(&addr1));
-                assert!(legacy_targets.contains_key(&addr2));
-                assert!(legacy_targets.contains_key(&addr3));
+                assert!(merged_targets.contains_key(&addr1));
+                assert!(merged_targets.contains_key(&addr2));
+                assert!(merged_targets.contains_key(&addr3));
 
-                task.on_prefetch_proof(VersionedMultiProofTargets::Legacy(legacy_targets))
+                task.on_prefetch_proof(merged_targets)
             } else {
                 panic!("Expected PrefetchProofs message");
             };
@@ -2090,9 +1765,7 @@ mod tests {
                     nonce: 1,
                     code_hash: Default::default(),
                     code: Default::default(),
-                    account_id: None,
                 },
-                original_info: Box::new(revm_state::AccountInfo::default()),
                 transaction_id: Default::default(),
                 storage: Default::default(),
                 status: revm_state::AccountStatus::Touched,
@@ -2109,9 +1782,7 @@ mod tests {
                     nonce: 2,
                     code_hash: Default::default(),
                     code: Default::default(),
-                    account_id: None,
                 },
-                original_info: Box::new(revm_state::AccountInfo::default()),
                 transaction_id: Default::default(),
                 storage: Default::default(),
                 status: revm_state::AccountStatus::Touched,
@@ -2122,16 +1793,11 @@ mod tests {
 
         // Queue: [PrefetchProofs1, PrefetchProofs2, StateUpdate1, StateUpdate2, PrefetchProofs3]
         let tx = task.tx.clone();
-        tx.send(MultiProofMessage::PrefetchProofs(VersionedMultiProofTargets::Legacy(targets1)))
-            .unwrap();
-        tx.send(MultiProofMessage::PrefetchProofs(VersionedMultiProofTargets::Legacy(targets2)))
-            .unwrap();
+        tx.send(MultiProofMessage::PrefetchProofs(targets1)).unwrap();
+        tx.send(MultiProofMessage::PrefetchProofs(targets2)).unwrap();
         tx.send(MultiProofMessage::StateUpdate(source.into(), state_update1)).unwrap();
         tx.send(MultiProofMessage::StateUpdate(source.into(), state_update2)).unwrap();
-        tx.send(MultiProofMessage::PrefetchProofs(VersionedMultiProofTargets::Legacy(
-            targets3.clone(),
-        )))
-        .unwrap();
+        tx.send(MultiProofMessage::PrefetchProofs(targets3.clone())).unwrap();
 
         // Step 1: Receive and batch PrefetchProofs (should get targets1 + targets2)
         let mut pending_msg: Option<MultiProofMessage> = None;
@@ -2157,10 +1823,9 @@ mod tests {
             // Should have batched exactly 2 PrefetchProofs (not 3!)
             assert_eq!(num_batched, 2, "Should batch only until different message type");
             assert_eq!(merged_targets.len(), 2);
-            let legacy_targets = unwrap_legacy_targets(merged_targets);
-            assert!(legacy_targets.contains_key(&addr1));
-            assert!(legacy_targets.contains_key(&addr2));
-            assert!(!legacy_targets.contains_key(&addr3), "addr3 should NOT be in first batch");
+            assert!(merged_targets.contains_key(&addr1));
+            assert!(merged_targets.contains_key(&addr2));
+            assert!(!merged_targets.contains_key(&addr3), "addr3 should NOT be in first batch");
         } else {
             panic!("Expected PrefetchProofs message");
         }
@@ -2185,8 +1850,7 @@ mod tests {
         match task.rx.try_recv() {
             Ok(MultiProofMessage::PrefetchProofs(targets)) => {
                 assert_eq!(targets.len(), 1);
-                let legacy_targets = unwrap_legacy_targets(targets);
-                assert!(legacy_targets.contains_key(&addr3));
+                assert!(targets.contains_key(&addr3));
             }
             _ => panic!("PrefetchProofs3 was lost!"),
         }
@@ -2220,9 +1884,7 @@ mod tests {
                     nonce: 1,
                     code_hash: Default::default(),
                     code: Default::default(),
-                    account_id: None,
                 },
-                original_info: Box::new(revm_state::AccountInfo::default()),
                 transaction_id: Default::default(),
                 storage: Default::default(),
                 status: revm_state::AccountStatus::Touched,
@@ -2232,13 +1894,9 @@ mod tests {
         let source = StateChangeSource::Transaction(99);
 
         let tx = task.tx.clone();
-        tx.send(MultiProofMessage::PrefetchProofs(VersionedMultiProofTargets::Legacy(prefetch1)))
-            .unwrap();
+        tx.send(MultiProofMessage::PrefetchProofs(prefetch1)).unwrap();
         tx.send(MultiProofMessage::StateUpdate(source.into(), state_update)).unwrap();
-        tx.send(MultiProofMessage::PrefetchProofs(VersionedMultiProofTargets::Legacy(
-            prefetch2.clone(),
-        )))
-        .unwrap();
+        tx.send(MultiProofMessage::PrefetchProofs(prefetch2.clone())).unwrap();
 
         let mut ctx = MultiproofBatchCtx::new(Instant::now());
         let mut batch_metrics = MultiproofBatchMetrics::default();
@@ -2271,8 +1929,7 @@ mod tests {
         match task.rx.try_recv() {
             Ok(MultiProofMessage::PrefetchProofs(targets)) => {
                 assert_eq!(targets.len(), 1);
-                let legacy_targets = unwrap_legacy_targets(targets);
-                assert!(legacy_targets.contains_key(&prefetch_addr2));
+                assert!(targets.contains_key(&prefetch_addr2));
             }
             other => panic!("Expected PrefetchProofs2 in channel, got {:?}", other),
         }

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

@@ -16,25 +16,24 @@ use crate::tree::{
     payload_processor::{
         bal::{total_slots, BALSlotIter},
         executor::WorkloadExecutor,
-        multiproof::{MultiProofMessage, VersionedMultiProofTargets},
-        PayloadExecutionCache,
+        multiproof::MultiProofMessage,
+        ExecutionCache as PayloadExecutionCache,
     },
     precompile_cache::{CachedPrecompile, PrecompileCacheMap},
     ExecutionEnv, StateProviderBuilder,
 };
 use alloy_consensus::transaction::TxHashRef;
 use alloy_eip7928::BlockAccessList;
+use alloy_eips::Typed2718;
 use alloy_evm::Database;
 use alloy_primitives::{keccak256, map::B256Set, B256};
-use crossbeam_channel::{Receiver as CrossbeamReceiver, Sender as CrossbeamSender};
+use crossbeam_channel::Sender as CrossbeamSender;
 use metrics::{Counter, Gauge, Histogram};
-use reth_evm::{execute::ExecutableTxFor, ConfigureEvm, Evm, EvmFor, RecoveredTx, SpecFor};
+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::{
@@ -65,6 +64,19 @@ struct IndexedTransaction<Tx> {
     tx: Tx,
 }
 
+/// Maximum standard Ethereum transaction type value.
+///
+/// Standard transaction types are:
+/// - Type 0: Legacy transactions (original Ethereum)
+/// - Type 1: EIP-2930 (access list transactions)
+/// - Type 2: EIP-1559 (dynamic fee transactions)
+/// - Type 3: EIP-4844 (blob transactions)
+/// - Type 4: EIP-7702 (set code authorization transactions)
+///
+/// Any transaction with a type > 4 is considered a non-standard/system transaction,
+/// typically used by L2s for special purposes (e.g., Optimism deposit transactions use type 126).
+const MAX_STANDARD_TX_TYPE: u8 = 4;
+
 /// A task that is responsible for caching and prewarming the cache by executing transactions
 /// individually in parallel.
 ///
@@ -163,8 +175,8 @@ where
                 transaction_count_hint.min(max_concurrency)
             };
 
-            // Spawn workers
-            let tx_sender = ctx.clone().spawn_workers(workers_needed, &executor, actions_tx.clone(), done_tx.clone());
+            // Initialize worker handles container
+            let handles = ctx.clone().spawn_workers(workers_needed, &executor, actions_tx.clone(), done_tx.clone());
 
             // Distribute transactions to workers
             let mut tx_index = 0usize;
@@ -179,18 +191,37 @@ where
                 }
 
                 let indexed_tx = IndexedTransaction { index: tx_index, tx };
+                let is_system_tx = indexed_tx.tx.tx().ty() > MAX_STANDARD_TX_TYPE;
 
-                // Send transaction to the workers
-                // Ignore send errors: workers listen to terminate_execution and may
-                // exit early when signaled.
-                let _ = tx_sender.send(indexed_tx);
+                // System transactions (type > 4) in the first position set critical metadata
+                // that affects all subsequent transactions (e.g., L1 block info on L2s).
+                // Broadcast the first system transaction to all workers to ensure they have
+                // the critical state. This is particularly important for L2s like Optimism
+                // where the first deposit transaction (type 126) contains essential block metadata.
+                if tx_index == 0 && is_system_tx {
+                    for handle in &handles {
+                        // Ignore send errors: workers listen to terminate_execution and may
+                        // exit early when signaled. Sending to a disconnected worker is
+                        // possible and harmless and should happen at most once due to
+                        //  the terminate_execution check above.
+                        let _ = handle.send(indexed_tx.clone());
+                    }
+                } else {
+                    // Round-robin distribution for all other transactions
+                    let worker_idx = tx_index % workers_needed;
+                    // Ignore send errors: workers listen to terminate_execution and may
+                    // exit early when signaled. Sending to a disconnected worker is
+                    // possible and harmless and should happen at most once due to
+                    //  the terminate_execution check above.
+                    let _ = handles[worker_idx].send(indexed_tx);
+                }
 
                 tx_index += 1;
             }
 
-            // drop sender and wait for all tasks to finish
+            // drop handle and wait for all tasks to finish and drop theirs
             drop(done_tx);
-            drop(tx_sender);
+            drop(handles);
             while done_rx.recv().is_ok() {}
 
             let _ = actions_tx
@@ -204,7 +235,7 @@ where
     }
 
     /// If configured and the tx returned proof targets, emit the targets the transaction produced
-    fn send_multi_proof_targets(&self, targets: Option<VersionedMultiProofTargets>) {
+    fn send_multi_proof_targets(&self, targets: Option<MultiProofTargets>) {
         if self.is_execution_terminated() {
             // if execution is already terminated then we dont need to send more proof fetch
             // messages
@@ -228,11 +259,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, .. }, .. } =
@@ -245,13 +272,12 @@ where
             execution_cache.update_with_guard(|cached| {
                 // consumes the `SavedCache` held by the prewarming task, which releases its usage
                 // guard
-                let (caches, cache_metrics, disable_cache_metrics) = saved_cache.split();
-                let new_cache = SavedCache::new(hash, caches, cache_metrics)
-                    .with_disable_cache_metrics(disable_cache_metrics);
+                let (caches, cache_metrics) = saved_cache.split();
+                let new_cache = SavedCache::new(hash, caches, cache_metrics);
 
                 // 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");
@@ -260,16 +286,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);
-                } else {
-                    // Block was invalid; caches were already mutated by insert_state above,
-                    // so we must clear to prevent using polluted state
-                    *cached = None;
-                    debug!(target: "engine::caching", "cleared execution cache on invalid block");
-                }
+                // Replace the shared cache with the new one; the previous cache (if any) is
+                // dropped.
+                *cached = Some(new_cache);
             });
 
             let elapsed = start.elapsed();
@@ -400,10 +419,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
@@ -428,8 +446,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);
         }
     }
 }
@@ -451,8 +469,6 @@ where
     pub(super) terminate_execution: Arc<AtomicBool>,
     pub(super) precompile_cache_disabled: bool,
     pub(super) precompile_cache_map: PrecompileCacheMap<SpecFor<Evm>>,
-    /// Whether V2 proof calculation is enabled.
-    pub(super) v2_proofs_enabled: bool,
 }
 
 impl<N, P, Evm> PrewarmContext<N, P, Evm>
@@ -461,12 +477,10 @@ where
     P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
     Evm: ConfigureEvm<Primitives = N> + 'static,
 {
-    /// Splits this context into an evm, an evm config, metrics, the atomic bool for terminating
-    /// execution, and whether V2 proofs are enabled.
+    /// Splits this context into an evm, an evm config, metrics, and the atomic bool for terminating
+    /// execution.
     #[instrument(level = "debug", target = "engine::tree::payload_processor::prewarm", skip_all)]
-    fn evm_for_ctx(
-        self,
-    ) -> Option<(EvmFor<Evm, impl Database>, PrewarmMetrics, Arc<AtomicBool>, bool)> {
+    fn evm_for_ctx(self) -> Option<(EvmFor<Evm, impl Database>, PrewarmMetrics, Arc<AtomicBool>)> {
         let Self {
             env,
             evm_config,
@@ -476,7 +490,6 @@ where
             terminate_execution,
             precompile_cache_disabled,
             precompile_cache_map,
-            v2_proofs_enabled,
         } = self;
 
         let mut state_provider = match provider.build() {
@@ -526,10 +539,10 @@ where
             });
         }
 
-        Some((evm, metrics, terminate_execution, v2_proofs_enabled))
+        Some((evm, metrics, terminate_execution))
     }
 
-    /// Accepts a [`CrossbeamReceiver`] of transactions and a handle to prewarm task. Executes
+    /// Accepts an [`mpsc::Receiver`] of transactions and a handle to prewarm task. Executes
     /// transactions and streams [`PrewarmTaskEvent::Outcome`] messages for each transaction.
     ///
     /// This function processes transactions sequentially from the receiver and emits outcome events
@@ -541,30 +554,22 @@ where
     #[instrument(level = "debug", target = "engine::tree::payload_processor::prewarm", skip_all)]
     fn transact_batch<Tx>(
         self,
-        txs: CrossbeamReceiver<IndexedTransaction<Tx>>,
+        txs: mpsc::Receiver<IndexedTransaction<Tx>>,
         sender: Sender<PrewarmTaskEvent<N::Receipt>>,
         done_tx: Sender<()>,
     ) where
         Tx: ExecutableTxFor<Evm>,
     {
-        let Some((mut evm, metrics, terminate_execution, v2_proofs_enabled)) = self.evm_for_ctx()
-        else {
-            return
-        };
+        let Some((mut evm, metrics, terminate_execution)) = self.evm_for_ctx() else { return };
 
         while let Ok(IndexedTransaction { index, tx }) = {
             let _enter = debug_span!(target: "engine::tree::payload_processor::prewarm", "recv tx")
                 .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();
@@ -576,8 +581,7 @@ where
                 break
             }
 
-            let (tx_env, tx) = tx.into_parts();
-            let res = match evm.transact(tx_env) {
+            let res = match evm.transact(&tx) {
                 Ok(res) => res,
                 Err(err) => {
                     trace!(
@@ -614,8 +618,7 @@ 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, v2_proofs_enabled);
+                let (targets, storage_targets) = multiproof_targets_from_state(res.state);
                 metrics.prefetch_storage_targets.record(storage_targets as f64);
                 let _ = sender.send(PrewarmTaskEvent::Outcome { proof_targets: Some(targets) });
                 drop(_enter);
@@ -628,31 +631,35 @@ where
         let _ = done_tx.send(());
     }
 
-    /// Spawns worker tasks that pull transactions from a shared channel.
-    ///
-    /// Returns the sender for distributing transactions to workers.
+    /// Spawns a worker task for transaction execution and returns its sender channel.
     fn spawn_workers<Tx>(
         self,
         workers_needed: usize,
         task_executor: &WorkloadExecutor,
         actions_tx: Sender<PrewarmTaskEvent<N::Receipt>>,
         done_tx: Sender<()>,
-    ) -> CrossbeamSender<IndexedTransaction<Tx>>
+    ) -> Vec<mpsc::Sender<IndexedTransaction<Tx>>>
     where
         Tx: ExecutableTxFor<Evm> + Send + 'static,
     {
-        let (tx_sender, tx_receiver) = crossbeam_channel::unbounded();
+        let mut handles = Vec::with_capacity(workers_needed);
+        let mut receivers = Vec::with_capacity(workers_needed);
 
-        // Spawn workers that all pull from the shared receiver
+        for _ in 0..workers_needed {
+            let (tx, rx) = mpsc::channel();
+            handles.push(tx);
+            receivers.push(rx);
+        }
+
+        // Spawn a separate task spawning workers in parallel.
         let executor = task_executor.clone();
         let span = Span::current();
         task_executor.spawn_blocking(move || {
             let _enter = span.entered();
-            for idx in 0..workers_needed {
+            for (idx, rx) in receivers.into_iter().enumerate() {
                 let ctx = self.clone();
                 let actions_tx = actions_tx.clone();
                 let done_tx = done_tx.clone();
-                let rx = tx_receiver.clone();
                 let span = debug_span!(target: "engine::tree::payload_processor::prewarm", "prewarm worker", idx);
                 executor.spawn_blocking(move || {
                     let _enter = span.entered();
@@ -661,7 +668,7 @@ where
             }
         });
 
-        tx_sender
+        handles
     }
 
     /// Spawns a worker task for BAL slot prefetching.
@@ -756,22 +763,9 @@ where
     }
 }
 
-/// Returns a set of [`VersionedMultiProofTargets`] and the total amount of storage targets, based
-/// on the given state.
-fn multiproof_targets_from_state(
-    state: EvmState,
-    v2_enabled: bool,
-) -> (VersionedMultiProofTargets, usize) {
-    if v2_enabled {
-        multiproof_targets_v2_from_state(state)
-    } else {
-        multiproof_targets_legacy_from_state(state)
-    }
-}
-
-/// Returns legacy [`MultiProofTargets`] and the total amount of storage targets, based on the
+/// Returns a set of [`MultiProofTargets`] and the total amount of storage targets, based on the
 /// given state.
-fn multiproof_targets_legacy_from_state(state: EvmState) -> (VersionedMultiProofTargets, usize) {
+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 {
@@ -801,50 +795,7 @@ fn multiproof_targets_legacy_from_state(state: EvmState) -> (VersionedMultiProof
         targets.insert(keccak256(addr), storage_set);
     }
 
-    (VersionedMultiProofTargets::Legacy(targets), storage_targets)
-}
-
-/// Returns V2 [`reth_trie_parallel::targets_v2::MultiProofTargetsV2`] and the total amount of
-/// storage targets, based on the given state.
-fn multiproof_targets_v2_from_state(state: EvmState) -> (VersionedMultiProofTargets, usize) {
-    use reth_trie::proof_v2;
-    use reth_trie_parallel::targets_v2::MultiProofTargetsV2;
-
-    let mut targets = MultiProofTargetsV2::default();
-    let mut storage_target_count = 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 hashed_address = keccak256(addr);
-        targets.account_targets.push(hashed_address.into());
-
-        let mut storage_slots = Vec::with_capacity(account.storage.len());
-        for (key, slot) in account.storage {
-            // do nothing if unchanged
-            if !slot.is_changed() {
-                continue
-            }
-
-            let hashed_slot = keccak256(B256::new(key.to_be_bytes()));
-            storage_slots.push(proof_v2::Target::from(hashed_slot));
-        }
-
-        storage_target_count += storage_slots.len();
-        if !storage_slots.is_empty() {
-            targets.storage_targets.insert(hashed_address, storage_slots);
-        }
-    }
-
-    (VersionedMultiProofTargets::V2(targets), storage_target_count)
+    (targets, storage_targets)
 }
 
 /// The events the pre-warm task can handle.
@@ -859,17 +810,12 @@ 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 {
         /// The prepared proof targets based on the evm state outcome
-        proof_targets: Option<VersionedMultiProofTargets>,
+        proof_targets: Option<MultiProofTargets>,
     },
     /// Finished executing all transactions
     FinishedTxExecution {

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

@@ -1,259 +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.
-    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();
-        let mut received_count = 0usize;
-
-        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);
-            received_count += 1;
-        }
-
-        let Ok(root) = builder.finalize() else {
-            // Finalize fails if we didn't receive exactly `receipts_len` receipts. This can
-            // happen if execution was aborted early (e.g., invalid transaction encountered).
-            // We return without sending a result, allowing the caller to handle the abort.
-            tracing::error!(
-                target: "engine::tree::payload_processor",
-                expected = receipts_len,
-                received = received_count,
-                "Receipt root task received incomplete receipts, execution likely aborted"
-            );
-            return;
-        };
-        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);
-    }
-}

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

@@ -4,11 +4,11 @@ use crate::tree::payload_processor::multiproof::{MultiProofTaskMetrics, SparseTr
 use alloy_primitives::B256;
 use rayon::iter::{ParallelBridge, ParallelIterator};
 use reth_trie::{updates::TrieUpdates, Nibbles};
-use reth_trie_parallel::{proof_task::ProofResult, root::ParallelStateRootError};
+use reth_trie_parallel::root::ParallelStateRootError;
 use reth_trie_sparse::{
     errors::{SparseStateTrieResult, SparseTrieErrorKind},
     provider::{TrieNodeProvider, TrieNodeProviderFactory},
-    ClearedSparseStateTrie, SerialSparseTrie, SparseStateTrie, SparseTrie,
+    ClearedSparseStateTrie, SerialSparseTrie, SparseStateTrie, SparseTrieInterface,
 };
 use smallvec::SmallVec;
 use std::{
@@ -38,8 +38,8 @@ where
     BPF: TrieNodeProviderFactory + Send + Sync + Clone,
     BPF::AccountNodeProvider: TrieNodeProvider + Send + Sync,
     BPF::StorageNodeProvider: TrieNodeProvider + Send + Sync,
-    A: SparseTrie + Send + Sync + Default,
-    S: SparseTrie + Send + Sync + Default + Clone,
+    A: SparseTrieInterface + Send + Sync + Default,
+    S: SparseTrieInterface + Send + Sync + Default + Clone,
 {
     /// Creates a new sparse trie, pre-populating with a [`ClearedSparseStateTrie`].
     pub(super) fn new_with_cleared_trie(
@@ -97,8 +97,8 @@ where
             debug!(
                 target: "engine::root",
                 num_updates,
-                account_proofs = update.multiproof.account_proofs_len(),
-                storage_proofs = update.multiproof.storage_proofs_len(),
+                account_proofs = update.multiproof.account_subtree.len(),
+                storage_proofs = update.multiproof.storages.len(),
                 "Updating sparse trie"
             );
 
@@ -150,21 +150,14 @@ where
     BPF: TrieNodeProviderFactory + Send + Sync,
     BPF::AccountNodeProvider: TrieNodeProvider + Send + Sync,
     BPF::StorageNodeProvider: TrieNodeProvider + Send + Sync,
-    A: SparseTrie + Send + Sync + Default,
-    S: SparseTrie + Send + Sync + Default + Clone,
+    A: SparseTrieInterface + Send + Sync + Default,
+    S: SparseTrieInterface + Send + Sync + Default + Clone,
 {
     trace!(target: "engine::root::sparse", "Updating sparse trie");
     let started_at = Instant::now();
 
     // Reveal new accounts and storage slots.
-    match multiproof {
-        ProofResult::Legacy(decoded, _) => {
-            trie.reveal_decoded_multiproof(decoded)?;
-        }
-        ProofResult::V2(decoded_v2) => {
-            trie.reveal_decoded_multiproof_v2(decoded_v2)?;
-        }
-    }
+    trie.reveal_decoded_multiproof(multiproof)?;
     let reveal_multiproof_elapsed = started_at.elapsed();
     trace!(
         target: "engine::root::sparse",

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

@@ -7,19 +7,17 @@ use crate::tree::{
     payload_processor::{executor::WorkloadExecutor, PayloadProcessor},
     precompile_cache::{CachedPrecompile, CachedPrecompileMetrics, PrecompileCacheMap},
     sparse_trie::StateRootComputeOutcome,
-    EngineApiMetrics, EngineApiTreeState, ExecutionEnv, MeteredStateHook, PayloadHandle,
-    StateProviderBuilder, StateProviderDatabase, TreeConfig,
+    EngineApiMetrics, EngineApiTreeState, ExecutionEnv, PayloadHandle, StateProviderBuilder,
+    StateProviderDatabase, TreeConfig,
 };
-use alloy_consensus::transaction::{Either, TxHashRef};
+use alloy_consensus::transaction::Either;
 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,
 };
@@ -37,13 +35,12 @@ use reth_primitives_traits::{
 };
 use reth_provider::{
     providers::OverlayStateProviderFactory, BlockExecutionOutput, BlockNumReader, BlockReader,
-    ChangeSetReader, DatabaseProviderFactory, DatabaseProviderROFactory, HashedPostStateProvider,
-    ProviderError, PruneCheckpointReader, StageCheckpointReader, StateProvider,
-    StateProviderFactory, StateReader, StorageChangeSetReader,
+    ChangeSetReader, DatabaseProviderFactory, DatabaseProviderROFactory, ExecutionOutcome,
+    HashedPostStateProvider, ProviderError, PruneCheckpointReader, StageCheckpointReader,
+    StateProvider, StateProviderFactory, StateReader, TrieReader,
 };
-use reth_revm::db::{states::bundle_state::BundleRetention, State};
-use reth_trie::{updates::TrieUpdates, HashedPostState, StateRoot};
-use reth_trie_db::ChangesetCache;
+use reth_revm::db::State;
+use reth_trie::{updates::TrieUpdates, HashedPostState, StateRoot, TrieInputSorted};
 use reth_trie_parallel::root::{ParallelStateRoot, ParallelStateRootError};
 use revm_primitives::Address;
 use std::{
@@ -132,8 +129,6 @@ 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>
@@ -141,10 +136,10 @@ where
     N: NodePrimitives,
     P: DatabaseProviderFactory<
             Provider: BlockReader
+                          + TrieReader
                           + StageCheckpointReader
                           + PruneCheckpointReader
                           + ChangeSetReader
-                          + StorageChangeSetReader
                           + BlockNumReader,
         > + BlockReader<Header = N::BlockHeader>
         + ChangeSetReader
@@ -165,7 +160,6 @@ where
         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(
@@ -185,7 +179,6 @@ where
             invalid_block_hook,
             metrics: EngineApiMetrics::default(),
             validator,
-            changeset_cache,
         }
     }
 
@@ -370,6 +363,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 =
@@ -424,23 +418,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,
         ));
@@ -456,54 +440,24 @@ 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 = receipt_root_rx
-            .blocking_recv()
-            .inspect_err(|_| {
-                tracing::error!(
-                    target: "engine::tree::payload_validator",
-                    "Receipt root task dropped sender without result, receipt root calculation likely aborted"
-                );
-            })
-            .ok();
-
         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
         );
 
         let root_time = Instant::now();
         let mut maybe_state_root = None;
-        let mut state_root_task_failed = false;
 
         match strategy {
             StateRootStrategy::StateRootTask => {
@@ -522,18 +476,20 @@ where
                                 block_state_root = ?block.header().state_root(),
                                 "State root task returned incorrect state root"
                             );
-                            state_root_task_failed = true;
                         }
                     }
                     Err(error) => {
                         debug!(target: "engine::tree::payload_validator", %error, "State root task failed");
-                        state_root_task_failed = true;
                     }
                 }
             }
             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!(
@@ -569,14 +525,9 @@ 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
             );
-
-            if state_root_task_failed {
-                self.metrics.block_validation.state_root_task_fallback_success_total.increment(1);
-            }
-
             (root, updates, root_time.elapsed())
         };
 
@@ -604,18 +555,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.
@@ -651,29 +598,15 @@ where
         Ok(())
     }
 
-    /// Executes a block with the given state provider.
-    ///
-    /// This method orchestrates block execution:
-    /// 1. Sets up the EVM with state database and precompile caching
-    /// 2. Spawns a background task for incremental receipt root computation
-    /// 3. Executes transactions with metrics collection via state hooks
-    /// 4. Merges state transitions and records execution metrics
+    /// 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,
@@ -712,131 +645,22 @@ where
             });
         }
 
-        // 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));
-
-        // Wrap the state hook with metrics collection
-        let inner_hook = Box::new(handle.state_hook());
-        let state_hook =
-            MeteredStateHook { metrics: self.metrics.executor_metrics().clone(), inner_hook };
-
-        let transaction_count = input.transaction_count();
-        let executor = executor.with_state_hook(Some(Box::new(state_hook)));
-
         let execution_start = Instant::now();
-
-        // Execute all transactions and finalize
-        let (executor, senders) = self.execute_transactions(
+        let state_hook = Box::new(handle.state_hook());
+        let (output, senders) = self.metrics.execute_metered(
             executor,
-            transaction_count,
-            handle.iter_transactions(),
-            &receipt_tx,
+            handle.iter_transactions().map(|res| res.map_err(BlockExecutionError::other)),
+            input.transaction_count(),
+            state_hook,
         )?;
-        drop(receipt_tx);
-
-        // Finish execution and get the result
-        let post_exec_start = Instant::now();
-        let (_evm, result) = debug_span!(target: "engine::tree", "finish")
-            .in_scope(|| executor.finish())
-            .map(|(evm, result)| (evm.into_db(), result))?;
-        self.metrics.record_post_execution(post_exec_start.elapsed());
-
-        // Merge transitions into bundle state
-        debug_span!(target: "engine::tree", "merge transitions")
-            .in_scope(|| db.merge_transitions(BundleRetention::Reverts));
-
-        let output = BlockExecutionOutput { result, state: db.take_bundle() };
-
-        let execution_duration = execution_start.elapsed();
-        self.metrics.record_block_execution(&output, execution_duration);
-
-        debug!(target: "engine::tree::payload_validator", elapsed = ?execution_duration, "Executed block");
-        Ok((output, senders, result_rx))
-    }
-
-    /// Executes transactions and collects senders, streaming receipts to a background task.
-    ///
-    /// This method handles:
-    /// - Applying pre-execution changes (e.g., beacon root updates)
-    /// - Executing each transaction with timing metrics
-    /// - Streaming receipts to the receipt root computation task
-    /// - Collecting transaction senders for later use
-    ///
-    /// Returns the executor (for finalization) and the collected senders.
-    fn execute_transactions<E, Tx, InnerTx, Err>(
-        &self,
-        mut executor: E,
-        transaction_count: usize,
-        transactions: impl Iterator<Item = Result<Tx, Err>>,
-        receipt_tx: &crossbeam_channel::Sender<IndexedReceipt<N::Receipt>>,
-    ) -> Result<(E, Vec<Address>), BlockExecutionError>
-    where
-        E: BlockExecutor<Receipt = N::Receipt>,
-        Tx: alloy_evm::block::ExecutableTx<E> + alloy_evm::RecoveredTx<InnerTx>,
-        InnerTx: TxHashRef,
-        Err: core::error::Error + Send + Sync + 'static,
-    {
-        let mut senders = Vec::with_capacity(transaction_count);
-
-        // Apply pre-execution changes (e.g., beacon root update)
-        let pre_exec_start = Instant::now();
-        debug_span!(target: "engine::tree", "pre execution")
-            .in_scope(|| executor.apply_pre_execution_changes())?;
-        self.metrics.record_pre_execution(pre_exec_start.elapsed());
-
-        // Execute transactions
-        let exec_span = debug_span!(target: "engine::tree", "execution").entered();
-        let mut transactions = transactions.into_iter();
-        loop {
-            // Measure time spent waiting for next transaction from iterator
-            // (e.g., parallel signature recovery)
-            let wait_start = Instant::now();
-            let Some(tx_result) = transactions.next() else { break };
-            self.metrics.record_transaction_wait(wait_start.elapsed());
-
-            let tx = tx_result.map_err(BlockExecutionError::other)?;
-            let tx_signer = *<Tx as alloy_evm::RecoveredTx<InnerTx>>::signer(&tx);
-            let tx_hash = <Tx as alloy_evm::RecoveredTx<InnerTx>>::tx(&tx).tx_hash();
-
-            senders.push(tx_signer);
-
-            let span = debug_span!(
-                target: "engine::tree",
-                "execute tx",
-                ?tx_hash,
-                gas_used = tracing::field::Empty,
-            );
-            let enter = span.entered();
-            trace!(target: "engine::tree", "Executing transaction");
-
-            let tx_start = Instant::now();
-            let gas_used = executor.execute_transaction(tx)?;
-            self.metrics.record_transaction_execution(tx_start.elapsed());
-
-            // Send the latest receipt to the background task for incremental root computation
-            if let Some(receipt) = executor.receipts().last() {
-                let tx_index = executor.receipts().len() - 1;
-                let _ = receipt_tx.send(IndexedReceipt::new(tx_index, receipt.clone()));
-            }
-
-            enter.record("gas_used", gas_used);
-        }
-        drop(exec_span);
-
-        Ok((executor, senders))
+        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))
     }
 
     /// 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.
@@ -844,39 +668,58 @@ 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)
+            .with_prefix_sets(prefix_sets.freeze())
             .root_with_updates()?)
     }
 
@@ -886,9 +729,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,
@@ -896,7 +736,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>,
@@ -923,9 +762,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())
@@ -965,11 +802,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",
@@ -982,7 +814,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<
@@ -995,14 +828,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,
                 );
@@ -1096,36 +947,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.
@@ -1147,11 +1061,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
@@ -1175,21 +1088,9 @@ where
         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();
-
         // 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();
@@ -1212,40 +1113,6 @@ where
                         .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"
-                        );
-                    }
-                }
             }));
 
             if result.is_err() {
@@ -1342,10 +1209,10 @@ impl<N, Types, P, Evm, V> EngineValidator<Types> for BasicEngineValidator<P, Evm
 where
     P: DatabaseProviderFactory<
             Provider: BlockReader
+                          + TrieReader
                           + StageCheckpointReader
                           + PruneCheckpointReader
                           + ChangeSetReader
-                          + StorageChangeSetReader
                           + BlockNumReader,
         > + BlockReader<Header = N::BlockHeader>
         + StateProviderFactory
@@ -1395,7 +1262,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(),
         );
     }
 }

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,7 +26,7 @@ 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,
@@ -193,7 +192,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 +199,6 @@ impl TestHarness {
             payload_validator,
             TreeConfig::default(),
             Box::new(NoopInvalidBlockHook::default()),
-            changeset_cache.clone(),
         );
 
         let tree = EngineApiTreeHandler::new(
@@ -218,7 +215,6 @@ impl TestHarness {
             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 +388,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 +396,6 @@ impl ValidatorTestHarness {
             payload_validator,
             TreeConfig::default(),
             Box::new(NoopInvalidBlockHook::default()),
-            changeset_cache,
         );
 
         Self { harness, validator, metrics: TestMetrics::default() }
@@ -838,7 +832,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 +841,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 +1002,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

crates/era-downloader/src/fs.rs

@@ -52,7 +52,7 @@ pub fn read_dir(
         checksums.next().transpose()?.ok_or_eyre("Got less checksums than ERA files")?;
     }
 
-    entries.sort_by_key(|(left, _)| *left);
+    entries.sort_by(|(left, _), (right, _)| left.cmp(right));
 
     Ok(stream::iter(entries.into_iter().skip_while(move |(n, _)| *n < start_index).map(
         move |(_, path)| {

crates/era-utils/src/export.rs

@@ -20,7 +20,6 @@ use reth_era::{
     },
 };
 use reth_fs_util as fs;
-use reth_primitives_traits::Block;
 use reth_storage_api::{BlockNumReader, BlockReader, HeaderProvider};
 use std::{
     path::PathBuf,
@@ -296,11 +295,9 @@ where
         return Err(eyre!("Expected block {expected_block_number}, got {actual_block_number}"));
     }
 
-    // CompressedBody must contain the block *body* (rlp(body)), not the full block (rlp(block)).
     let body = provider
         .block_by_number(actual_block_number)?
-        .ok_or_else(|| eyre!("Block not found for block {}", actual_block_number))?
-        .into_body();
+        .ok_or_else(|| eyre!("Block body not found for block {}", actual_block_number))?;
 
     let receipts = provider
         .receipts_by_block(actual_block_number.into())?

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"]
 

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)
     }
 }

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)
     }
 }
 

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

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

@@ -17,11 +17,10 @@ pub use payload::{payload_id, BlobSidecars, EthBuiltPayload, EthPayloadBuilderAt
 mod error;
 pub use error::*;
 
-use alloy_rpc_types_engine::{ExecutionData, ExecutionPayload};
+use alloy_rpc_types_engine::{ExecutionData, ExecutionPayload, ExecutionPayloadEnvelopeV5};
 pub use alloy_rpc_types_engine::{
     ExecutionPayloadEnvelopeV2, ExecutionPayloadEnvelopeV3, ExecutionPayloadEnvelopeV4,
-    ExecutionPayloadEnvelopeV5, ExecutionPayloadEnvelopeV6, ExecutionPayloadV1,
-    PayloadAttributes as EthPayloadAttributes,
+    ExecutionPayloadV1, PayloadAttributes as EthPayloadAttributes,
 };
 use reth_engine_primitives::EngineTypes;
 use reth_payload_primitives::{BuiltPayload, PayloadTypes};
@@ -67,15 +66,13 @@ where
         + TryInto<ExecutionPayloadEnvelopeV2>
         + TryInto<ExecutionPayloadEnvelopeV3>
         + TryInto<ExecutionPayloadEnvelopeV4>
-        + TryInto<ExecutionPayloadEnvelopeV5>
-        + TryInto<ExecutionPayloadEnvelopeV6>,
+        + TryInto<ExecutionPayloadEnvelopeV5>,
 {
     type ExecutionPayloadEnvelopeV1 = ExecutionPayloadV1;
     type ExecutionPayloadEnvelopeV2 = ExecutionPayloadEnvelopeV2;
     type ExecutionPayloadEnvelopeV3 = ExecutionPayloadEnvelopeV3;
     type ExecutionPayloadEnvelopeV4 = ExecutionPayloadEnvelopeV4;
     type ExecutionPayloadEnvelopeV5 = ExecutionPayloadEnvelopeV5;
-    type ExecutionPayloadEnvelopeV6 = ExecutionPayloadEnvelopeV6;
 }
 
 /// A default payload type for [`EthEngineTypes`]