fix: allow smaller header size

.changelog/big-mules-cook.md

@@ -1,4 +0,0 @@
----
----
-
-Added site-level meta description for SEO.

.changelog/config.toml

@@ -1,20 +0,0 @@
-# Changelogs configuration for reth
-# https://github.com/wevm/changelogs
-
-# How to bump packages that depend on changed packages
-dependent_bump = "patch"
-
-[changelog]
-# Generate per-crate changelogs (vs single root changelog)
-format = "per-crate"
-
-# Fixed groups: all always share the same version
-# reth binaries share version
-[[fixed]]
-members = ["reth"]
-
-# Packages to ignore (internal/test-only crates)
-ignore = [
-    "reth-testing-utils",
-    "reth-bench",
-]

.changelog/cute-bears-paint.md

@@ -1,17 +0,0 @@
----
-reth: minor
-reth-cli-commands: minor
-reth-e2e-test-utils: minor
-reth-ethereum-cli: minor
-reth-node-core: minor
-reth-optimism-bin: minor
-reth-optimism-cli: minor
-reth-prune: patch
-reth-stages: patch
-reth-storage-api: minor
-reth-storage-db-api: minor
-reth-storage-db-common: patch
-reth-storage-provider: patch
----
-
-Introduced `--storage.v2` flag to control storage mode defaults, replacing the `edge` feature flag with `rocksdb` feature. The new flag enables v2 storage settings (static files + RocksDB routing) while individual `--static-files.*` and `--rocksdb.*` flags can still override defaults. Updated feature gates from `edge` to `rocksdb` across all affected crates.

.changelog/dry-ants-bow.md

@@ -1,5 +0,0 @@
----
-reth: patch
----
-
-Removed Windows platform support from the codebase, including the Windows cross-compilation Dockerfile, build targets in Cross.toml and Makefile, and Windows-specific options in the bug report template.

.changelog/gentle-moons-cry.md

@@ -1,5 +0,0 @@
----
-reth-engine-tree: patch
----
-
-Reordered cache size calculations in `ExecutionCache::new` to group related operations together.

.changelog/lively-deer-shout.md

@@ -1,5 +0,0 @@
----
-reth: patch
----
-
-Re-enabled changelog workflow to run automatically on pull requests.

.changelog/quiet-foxes-dance.md

@@ -1,6 +0,0 @@
----
-reth-static-file-types: patch
-reth-provider: patch
----
-
-Move changeset offsets from segment header to external `.csoff` sidecar file for incremental writes and crash recovery.

.changelog/shy-tigers-dry.md

@@ -1,5 +0,0 @@
----
-reth: patch
----
-
-Added automated changelog generation infrastructure using wevm/changelogs-rs with Claude Code integration. Configured per-crate changelog format with fixed version groups for reth binaries and exclusions for internal test utilities.

.changelog/vain-lakes-cry.md

@@ -1,5 +0,0 @@
----
-reth: patch
----
-
-Updated Alloy dependencies from 1.5.2 to 1.6.1.

.changelog/zesty-birds-smile.md

@@ -1,6 +0,0 @@
----
-reth-trie: minor
-reth-trie-parallel: minor
----
-
-Added `root_node` and `storage_root_node` methods to proof calculators for efficient root-only calculations. These methods directly return the root node without requiring dummy targets, replacing the previous workaround of passing fake targets to proof generation.

.config/zepter.yaml

@@ -12,7 +12,7 @@ workflows:
         # Check that `A` activates the features of `B`.
         "propagate-feature",
         # These are the features to check:
-        "--features=std,op,dev,asm-keccak,jemalloc,jemalloc-prof,tracy-allocator,tracy,serde-bincode-compat,serde,test-utils,arbitrary,bench,alloy-compat,min-error-logs,min-warn-logs,min-info-logs,min-debug-logs,min-trace-logs,otlp,otlp-logs,js-tracer,portable,keccak-cache-global",
+        "--features=std,op,dev,asm-keccak,jemalloc,jemalloc-prof,tracy-allocator,serde-bincode-compat,serde,test-utils,arbitrary,bench,alloy-compat,min-error-logs,min-warn-logs,min-info-logs,min-debug-logs,min-trace-logs,otlp,js-tracer,portable,keccak-cache-global",
         # Do not try to add a new section to `[features]` of `A` only because `B` exposes that feature. There are edge-cases where this is still needed, but we can add them manually.
         "--left-side-feature-missing=ignore",
         # Ignore the case that `A` it outside of the workspace. Otherwise it will report errors in external dependencies that we have no influence on.

.github/CODEOWNERS

@@ -1,51 +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 @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/ISSUE_TEMPLATE/bug.yml

@@ -43,6 +43,7 @@ body:
 
         - `~/.cache/reth/logs` on Linux
         - `~/Library/Caches/reth/logs` on macOS
+        - `%localAppData%/reth/logs` on Windows
       render: text
     validations:
       required: false
@@ -57,6 +58,8 @@ body:
         - Linux (ARM)
         - Mac (Intel)
         - Mac (Apple Silicon)
+        - Windows (x86)
+        - Windows (ARM)
   - type: dropdown
     id: container_type
     attributes:

.github/assets/check_rv32imac.sh

@@ -29,6 +29,13 @@ crates_to_check=(
     reth-ethereum-primitives
     reth-ethereum-consensus
     reth-stateless
+
+    ## optimism
+    reth-optimism-chainspec
+    reth-optimism-forks
+    reth-optimism-consensus
+    reth-optimism-primitives
+    reth-optimism-evm
 )
 
 # Array to hold the results

.github/assets/check_wasm.sh

@@ -40,6 +40,12 @@ exclude_crates=(
   reth-node-ethereum
   reth-node-events
   reth-node-metrics
+  reth-optimism-cli
+  reth-optimism-flashblocks
+  reth-optimism-node
+  reth-optimism-payload-builder
+  reth-optimism-rpc
+  reth-optimism-storage
   reth-rpc
   reth-rpc-api
   reth-rpc-api-testing-util
@@ -71,6 +77,7 @@ exclude_crates=(
   reth-trie-parallel # tokio
   reth-trie-sparse-parallel # rayon
   reth-testing-utils
+  reth-optimism-txpool # reth-transaction-pool
   reth-era-downloader # tokio
   reth-era-utils # tokio
   reth-tracing-otlp

.github/assets/hive/build_simulators.sh

@@ -38,6 +38,6 @@ for pid in "${saving_pids[@]}"; do
 done
 
 # Make sure we don't rebuild images on the CI jobs
-git apply ../.github/scripts/hive/no_sim_build.diff
+git apply ../.github/assets/hive/no_sim_build.diff
 go build .
 mv ./hive ../hive_assets/

.github/assets/kurtosis_op_network_params.yaml

@@ -0,0 +1,36 @@
+ethereum_package:
+  participants:
+    - el_type: reth
+      el_extra_params:
+        - "--rpc.eth-proof-window=100"
+      cl_type: teku
+  network_params:
+    preset: minimal
+    genesis_delay: 5
+    additional_preloaded_contracts: '
+      {
+        "0x4e59b44847b379578588920cA78FbF26c0B4956C": {
+          "balance": "0ETH",
+          "code": "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf3",
+          "storage": {},
+          "nonce": "1"
+        }
+      }'
+optimism_package:
+  chains:
+    chain0:
+      participants:
+        node0:
+          el:
+            type: op-geth
+          cl:
+            type: op-node
+        node1:
+          el:
+            type: op-reth
+            image: "ghcr.io/paradigmxyz/op-reth:kurtosis-ci"
+          cl:
+            type: op-node
+      network_params:
+        holocene_time_offset: 0
+        isthmus_time_offset: 0

.github/dependabot.yml

@@ -4,17 +4,3 @@ updates:
   directory: "/"
   schedule:
     interval: "weekly"
-- package-ecosystem: "cargo"
-  directory: "/"
-  schedule:
-    interval: "weekly"
-  labels:
-    - "A-dependencies"
-  commit-message:
-    prefix: "chore(deps)"
-  open-pull-requests-limit: 1
-  groups:
-    cargo-weekly:
-      applies-to: "version-updates"
-      patterns: ["*"]
-      update-types: ["minor", "patch"]

.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/scripts/verify_image_arch.sh

@@ -1,53 +0,0 @@
-#!/usr/bin/env bash
-# Verifies that Docker images have the expected architectures.
-#
-# Usage:
-#   ./verify_image_arch.sh <targets> <registry> <ethereum_tags>
-#
-# Environment:
-#   DRY_RUN=true  - Skip actual verification, just print what would be checked.
-
-set -euo pipefail
-
-TARGETS="${1:-}"
-REGISTRY="${2:-}"
-ETHEREUM_TAGS="${3:-}"
-DRY_RUN="${DRY_RUN:-false}"
-
-verify_image() {
-    local image="$1"
-    shift
-    local expected_archs=("$@")
-
-    echo "Checking $image..."
-
-    if [[ "$DRY_RUN" == "true" ]]; then
-        echo "  [dry-run] Would verify architectures: ${expected_archs[*]}"
-        return 0
-    fi
-
-    manifest=$(docker manifest inspect "$image" 2>/dev/null) || {
-        echo "::error::Failed to inspect manifest for $image"
-        return 1
-    }
-
-    for arch in "${expected_archs[@]}"; do
-        if ! echo "$manifest" | jq -e ".manifests[] | select(.platform.architecture == \"$arch\" and .platform.os == \"linux\")" > /dev/null; then
-            echo "::error::Missing architecture $arch for $image"
-            return 1
-        fi
-        echo "  ✓ linux/$arch"
-    done
-}
-
-if [[ "$TARGETS" == *"nightly"* ]]; then
-    verify_image "${REGISTRY}/reth:nightly" amd64 arm64
-    verify_image "${REGISTRY}/reth:nightly-profiling" amd64
-    verify_image "${REGISTRY}/reth:nightly-edge-profiling" amd64
-else
-    for tag in $(echo "$ETHEREUM_TAGS" | tr ',' ' '); do
-        verify_image "$tag" amd64 arm64
-    done
-fi
-
-echo "All image architectures verified successfully"

.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/changelog.yml

@@ -1,25 +0,0 @@
-name: Changelog
-
-on:
-  pull_request:
-    types: [opened, synchronize]
-
-jobs:
-  changelog:
-    # Skip for fork PRs since they can't access secrets
-    if: github.event.pull_request.head.repo.full_name == github.repository
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          ref: ${{ github.event.pull_request.head.sha }}
-      - run: npm install -g @anthropic-ai/claude-code
-      - uses: wevm/changelogs/check@master
-        with:
-          ai: 'claude -p'
-        env:
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

.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/compact.yml

@@ -23,6 +23,7 @@ jobs:
       matrix:
         bin:
           - cargo run --bin reth --features "dev"
+          - cargo run --bin op-reth --features "dev" --manifest-path crates/optimism/bin/Cargo.toml
     steps:
       - uses: rui314/setup-mold@v1
       - uses: dtolnay/rust-toolchain@stable

.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,61 @@
+# 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 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 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-tag-latest.yml

@@ -14,6 +14,12 @@ on:
         required: false
         type: boolean
         default: true
+      tag_op_reth:
+        description: 'Tag op-reth image as latest'
+        required: false
+        type: boolean
+        default: false
+
 env:
   DOCKER_USERNAME: ${{ github.actor }}
 
@@ -41,3 +47,27 @@ jobs:
       - name: Push reth latest tag
         run: |
           docker push ghcr.io/${{ github.repository_owner }}/reth:latest
+
+  tag-op-reth-latest:
+    name: Tag op-reth as latest
+    runs-on: ubuntu-24.04
+    if: ${{ inputs.tag_op_reth }}
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      - name: Log in to Docker
+        run: |
+          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io --username ${DOCKER_USERNAME} --password-stdin
+
+      - name: Pull op-reth release image
+        run: |
+          docker pull ghcr.io/${{ github.repository_owner }}/op-reth:${{ inputs.version }}
+
+      - name: Tag op-reth as latest
+        run: |
+          docker tag ghcr.io/${{ github.repository_owner }}/op-reth:${{ inputs.version }} ghcr.io/${{ github.repository_owner }}/op-reth:latest
+
+      - name: Push op-reth latest tag
+        run: |
+          docker push ghcr.io/${{ github.repository_owner }}/op-reth:latest

.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,111 +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 }}"
-
-          if [[ "${{ github.event_name }}" == "push" ]]; then
-            VERSION="${GITHUB_REF#refs/tags/}"
-            echo "targets=ethereum" >> "$GITHUB_OUTPUT"
-
-            # Add 'latest' tag for non-RC releases
-            if [[ ! "$VERSION" =~ -rc ]]; then
-              echo "ethereum_tags=${REGISTRY}/reth:${VERSION},${REGISTRY}/reth:latest" >> "$GITHUB_OUTPUT"
-            else
-              echo "ethereum_tags=${REGISTRY}/reth:${VERSION}" >> "$GITHUB_OUTPUT"
-            fi
-
-          elif [[ "${{ github.event_name }}" == "schedule" ]] || [[ "${{ inputs.build_type }}" == "nightly" ]]; then
-            echo "targets=nightly" >> "$GITHUB_OUTPUT"
-            echo "ethereum_tags=${REGISTRY}/reth:nightly" >> "$GITHUB_OUTPUT"
-
-          else
-            # git-sha build
-            echo "targets=ethereum" >> "$GITHUB_OUTPUT"
-            echo "ethereum_tags=${REGISTRY}/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 }}
-        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 }}
-
-      - name: Verify image architectures
-        env:
-          DRY_RUN: ${{ github.event_name == 'workflow_dispatch' && inputs.dry_run }}
+          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io --username ${DOCKER_USERNAME} --password-stdin
+      - name: Set up Docker builder
         run: |
-          ./.github/scripts/verify_image_arch.sh \
-            "${{ steps.params.outputs.targets }}" \
-            "ghcr.io/${{ github.repository_owner }}" \
-            "${{ steps.params.outputs.ethereum_tags }}"
+          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 }}
 
-  notify:
-    name: Notify on failure
-    runs-on: ubuntu-latest
-    needs: build
-    if: failure() && github.event_name == 'schedule'
+  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:
-      - name: Slack Webhook Action
-        uses: rtCamp/action-slack-notify@v2
-        env:
-          SLACK_COLOR: ${{ job.status }}
-          SLACK_MESSAGE: "Failed run: https://github.com/paradigmxyz/reth/actions/runs/${{ github.run_id }}"
-          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }}
+      - 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/e2e.yml

@@ -41,26 +41,6 @@ jobs:
             --exclude 'exex-subscription' \
             --exclude 'reth-bench' \
             --exclude 'ef-tests' \
+            --exclude 'op-reth' \
             --exclude 'reth' \
             -E 'binary(e2e_testsuite)'
-
-  rocksdb:
-    name: e2e-rocksdb
-    runs-on: depot-ubuntu-latest-4
-    env:
-      RUST_BACKTRACE: 1
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: mozilla-actions/sccache-action@v0.0.9
-      - uses: taiki-e/install-action@nextest
-      - uses: Swatinem/rust-cache@v2
-        with:
-          cache-on-failure: true
-      - name: Run RocksDB e2e tests
-        run: |
-          cargo nextest run \
-            --locked --features "edge" \
-            -p reth-e2e-test-utils \
-            -E 'binary(rocksdb)'

.github/workflows/hive.yml

@@ -15,27 +15,16 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  prepare-reth-stable:
+  prepare-reth:
     uses: ./.github/workflows/prepare-reth.yml
     with:
       image_tag: ghcr.io/paradigmxyz/reth:latest
       binary_name: reth
-      cargo_features: "asm-keccak"
-      artifact_name: "reth-stable"
-
-  prepare-reth-edge:
-    uses: ./.github/workflows/prepare-reth.yml
-    with:
-      image_tag: ghcr.io/paradigmxyz/reth:latest
-      binary_name: reth
-      cargo_features: "asm-keccak edge"
-      artifact_name: "reth-edge"
 
   prepare-hive:
     if: github.repository == 'paradigmxyz/reth'
     timeout-minutes: 45
-    runs-on:
-      group: Reth
+    runs-on: depot-ubuntu-latest-16
     steps:
       - uses: actions/checkout@v6
       - name: Checkout hive tests
@@ -58,11 +47,11 @@ jobs:
         uses: actions/cache@v5
         with:
           path: ./hive_assets
-          key: hive-assets-${{ steps.hive-commit.outputs.hash }}-${{ hashFiles('.github/scripts/hive/build_simulators.sh') }}
+          key: hive-assets-${{ steps.hive-commit.outputs.hash }}-${{ hashFiles('.github/assets/hive/build_simulators.sh') }}
 
       - name: Build hive assets
         if: steps.cache-hive.outputs.cache-hit != 'true'
-        run: .github/scripts/hive/build_simulators.sh
+        run: .github/assets/hive/build_simulators.sh
 
       - name: Load cached Docker images
         if: steps.cache-hive.outputs.cache-hit == 'true'
@@ -87,7 +76,6 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        storage: [stable, edge]
         # ethereum/rpc to be deprecated:
         # https://github.com/ethereum/hive/pull/1117
         scenario:
@@ -97,7 +85,7 @@ jobs:
           - sim: devp2p
             limit: discv4
           # started failing after https://github.com/ethereum/go-ethereum/pull/31843, no
-          # action on our side, remove from here when we get unexpected passes on these tests
+          # action on our side, remove from here when we get unxpected passes on these tests
           # - sim: devp2p
           #  limit: eth
           #  include:
@@ -187,12 +175,10 @@ jobs:
           - sim: ethereum/eels/consume-rlp
             limit: .*tests/paris.*
     needs:
-      - prepare-reth-stable
-      - prepare-reth-edge
+      - prepare-reth
       - prepare-hive
-    name: ${{ matrix.storage }} / ${{ matrix.scenario.sim }}${{ matrix.scenario.limit && format(' - {0}', matrix.scenario.limit) }}
-    runs-on:
-      group: Reth
+    name: run ${{ matrix.scenario.sim }}${{ matrix.scenario.limit && format(' - {0}', matrix.scenario.limit) }}
+    runs-on: depot-ubuntu-latest-16
     permissions:
       issues: write
     steps:
@@ -209,11 +195,11 @@ jobs:
       - name: Download reth image
         uses: actions/download-artifact@v7
         with:
-          name: reth-${{ matrix.storage }}
+          name: artifacts
           path: /tmp
 
       - name: Load Docker images
-        run: .github/scripts/hive/load_images.sh
+        run: .github/assets/hive/load_images.sh
 
       - name: Move hive binary
         run: |
@@ -241,11 +227,11 @@ jobs:
             FILTER="/"
           fi
           echo "filter: $FILTER"
-          .github/scripts/hive/run_simulator.sh "${{ matrix.scenario.sim }}" "$FILTER"
+          .github/assets/hive/run_simulator.sh "${{ matrix.scenario.sim }}" "$FILTER"
 
       - name: Parse hive output
         run: |
-          find hivetests/workspace/logs -type f -name "*.json" ! -name "hive.json" | xargs -I {} python .github/scripts/hive/parse.py {} --exclusion .github/scripts/hive/expected_failures.yaml --ignored .github/scripts/hive/ignored_tests.yaml
+          find hivetests/workspace/logs -type f -name "*.json" ! -name "hive.json" | xargs -I {} python .github/assets/hive/parse.py {} --exclusion .github/assets/hive/expected_failures.yaml --ignored .github/assets/hive/ignored_tests.yaml
 
       - name: Print simulator output
         if: ${{ failure() }}
@@ -266,4 +252,4 @@ jobs:
         env:
           SLACK_COLOR: ${{ job.status }}
           SLACK_MESSAGE: "Failed run: https://github.com/paradigmxyz/reth/actions/runs/${{ github.run_id }}"
-          SLACK_WEBHOOK: ${{ secrets.SLACK_HIVE_WEBHOOK_URL }}
+          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }}

.github/workflows/integration.yml

@@ -22,33 +22,38 @@ concurrency:
 
 jobs:
   test:
-    name: test / ${{ matrix.network }} / ${{ matrix.storage }}
+    name: test / ${{ matrix.network }}
     if: github.event_name != 'schedule'
     runs-on: depot-ubuntu-latest-4
     env:
       RUST_BACKTRACE: 1
     strategy:
       matrix:
-        network: ["ethereum"]
-        storage: ["stable", "edge"]
+        network: ["ethereum", "optimism"]
     timeout-minutes: 60
     steps:
       - uses: actions/checkout@v6
       - uses: rui314/setup-mold@v1
       - uses: dtolnay/rust-toolchain@stable
       - name: Install Geth
-        run: .github/scripts/install_geth.sh
+        run: .github/assets/install_geth.sh
       - uses: taiki-e/install-action@nextest
       - uses: mozilla-actions/sccache-action@v0.0.9
       - uses: Swatinem/rust-cache@v2
         with:
           cache-on-failure: true
-      - name: Run tests
+      - if: matrix.network == 'ethereum'
+        name: Run tests
         run: |
           cargo nextest run \
-            --locked --features "asm-keccak ${{ matrix.network }} ${{ matrix.storage == 'edge' && 'edge' || '' }}" \
+            --locked --features "asm-keccak ${{ matrix.network }}" \
             --workspace --exclude ef-tests \
             -E "kind(test) and not binary(e2e_testsuite)"
+      - if: matrix.network == 'optimism'
+        name: Run tests
+        run: |
+          cargo nextest run \
+            --locked -p reth-optimism-node
 
   integration-success:
     name: integration success

.github/workflows/kurtosis-op.yml

@@ -0,0 +1,95 @@
+# Runs simple OP stack setup in Kurtosis
+
+name: kurtosis-op
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 */6 * * *"
+
+  push:
+    tags:
+      - "*"
+
+env:
+  CARGO_TERM_COLOR: always
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  prepare-reth:
+    uses: ./.github/workflows/prepare-reth.yml
+    with:
+      image_tag: ghcr.io/paradigmxyz/op-reth:kurtosis-ci
+      binary_name: op-reth
+      cargo_features: asm-keccak
+      cargo_package: crates/optimism/bin/Cargo.toml
+
+  test:
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+    name: run kurtosis
+    runs-on: depot-ubuntu-latest
+    needs:
+      - prepare-reth
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Download reth image
+        uses: actions/download-artifact@v7
+        with:
+          name: artifacts
+          path: /tmp
+
+      - name: Load Docker image
+        run: |
+          docker load -i /tmp/reth_image.tar &
+          wait
+          docker image ls -a
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+
+      - name: Run kurtosis
+        run: |
+          echo "deb [trusted=yes] https://apt.fury.io/kurtosis-tech/ /" | sudo tee /etc/apt/sources.list.d/kurtosis.list
+          sudo apt update
+          sudo apt install kurtosis-cli
+          kurtosis engine start
+          kurtosis run --enclave op-devnet github.com/ethpandaops/optimism-package --args-file .github/assets/kurtosis_op_network_params.yaml
+          ENCLAVE_ID=$(curl http://127.0.0.1:9779/api/enclaves | jq --raw-output 'keys[0]')
+          GETH_PORT=$(curl "http://127.0.0.1:9779/api/enclaves/$ENCLAVE_ID/services" | jq '."op-el-2151908-node0-op-geth".public_ports.rpc.number')
+          RETH_PORT=$(curl "http://127.0.0.1:9779/api/enclaves/$ENCLAVE_ID/services" | jq '."op-el-2151908-node1-op-reth".public_ports.rpc.number')
+          echo "GETH_RPC=http://127.0.0.1:$GETH_PORT" >> $GITHUB_ENV
+          echo "RETH_RPC=http://127.0.0.1:$RETH_PORT" >> $GITHUB_ENV
+
+      - name: Assert that clients advance
+        run: |
+          for i in {1..100}; do
+            sleep 5
+            BLOCK_GETH=$(cast bn --rpc-url $GETH_RPC)
+            BLOCK_RETH=$(cast bn --rpc-url $RETH_RPC)
+
+            if [ $BLOCK_GETH -ge 100 ] && [ $BLOCK_RETH -ge 100 ] ; then exit 0; fi
+            echo "Waiting for clients to advance..., Reth: $BLOCK_RETH Geth: $BLOCK_GETH"
+          done
+          kurtosis service logs -a op-devnet op-el-2151908-2-op-reth-op-node-op-kurtosis
+          kurtosis service logs -a op-devnet op-cl-2151908-2-op-node-op-reth-op-kurtosis
+          exit 1
+
+  notify-on-error:
+    needs: test
+    if: failure()
+    runs-on: ubuntu-latest
+    steps:
+      - name: Slack Webhook Action
+        uses: rtCamp/action-slack-notify@v2
+        env:
+          SLACK_COLOR: ${{ job.status }}
+          SLACK_MESSAGE: "Failed run: https://github.com/paradigmxyz/reth/actions/runs/${{ github.run_id }}"
+          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }}

.github/workflows/label-pr.yml

@@ -19,5 +19,5 @@ jobs:
         uses: actions/github-script@v8
         with:
           script: |
-            const label_pr = require('./.github/scripts/label_pr.js')
+            const label_pr = require('./.github/assets/label_pr.js')
             await label_pr({github, context})

.github/workflows/lint.yml

@@ -76,7 +76,7 @@ jobs:
       - name: Run Wasm checks
         run: |
           sudo apt update && sudo apt install gcc-multilib
-          .github/scripts/check_wasm.sh
+          .github/assets/check_wasm.sh
 
   riscv:
     runs-on: depot-ubuntu-latest
@@ -94,7 +94,7 @@ jobs:
           cache-on-failure: true
       - uses: dcarbone/install-jq-action@v3
       - name: Run RISC-V checks
-        run: .github/scripts/check_rv32imac.sh
+        run: .github/assets/check_rv32imac.sh
 
   crate-checks:
     name: crate-checks (${{ matrix.partition }}/${{ matrix.total_partitions }})
@@ -119,6 +119,11 @@ jobs:
     name: MSRV
     runs-on: depot-ubuntu-latest
     timeout-minutes: 30
+    strategy:
+      matrix:
+        include:
+          - binary: reth
+          - binary: op-reth
     steps:
       - uses: actions/checkout@v6
       - uses: rui314/setup-mold@v1
@@ -129,7 +134,7 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         with:
           cache-on-failure: true
-      - run: cargo build --bin reth --workspace
+      - run: cargo build --bin "${{ matrix.binary }}" --workspace
         env:
           RUSTFLAGS: -D warnings
 
@@ -193,9 +198,10 @@ jobs:
         with:
           cache-on-failure: true
       - run: cargo build --bin reth --workspace
+      - run: cargo build --bin op-reth --workspace
         env:
           RUSTFLAGS: -D warnings
-      - run: ./docs/cli/update.sh target/debug/reth
+      - run: ./docs/cli/update.sh target/debug/reth target/debug/op-reth
       - name: Check docs changes
         run: git diff --exit-code
 
@@ -271,7 +277,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
       - uses: mozilla-actions/sccache-action@v0.0.9
       - uses: rui314/setup-mold@v1
-      - uses: taiki-e/cache-cargo-install-action@v3
+      - uses: taiki-e/cache-cargo-install-action@v2
         with:
           tool: zepter
       - name: Eagerly pull dependencies
@@ -279,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

.github/workflows/prepare-reth.yml

@@ -11,7 +11,7 @@ on:
         required: false
         type: string
         default: "reth"
-        description: "Binary name to build"
+        description: "Binary name to build (reth or op-reth)"
       cargo_features:
         required: false
         type: string
@@ -21,11 +21,6 @@ on:
         required: false
         type: string
         description: "Optional cargo package path"
-      artifact_name:
-        required: false
-        type: string
-        default: "artifacts"
-        description: "Name for the uploaded artifact"
 
 jobs:
   prepare-reth:
@@ -43,7 +38,7 @@ jobs:
         uses: docker/build-push-action@v6
         with:
           context: .
-          file: .github/scripts/hive/Dockerfile
+          file: .github/assets/hive/Dockerfile
           tags: ${{ inputs.image_tag }}
           outputs: type=docker,dest=./artifacts/reth_image.tar
           build-args: |
@@ -57,5 +52,5 @@ jobs:
         id: upload
         uses: actions/upload-artifact@v6
         with:
-          name: ${{ inputs.artifact_name }}
+          name: artifacts
           path: ./artifacts

.github/workflows/release.yml

@@ -17,9 +17,11 @@ on:
 env:
   REPO_NAME: ${{ github.repository_owner }}/reth
   IMAGE_NAME: ${{ github.repository_owner }}/reth
+  OP_IMAGE_NAME: ${{ github.repository_owner }}/op-reth
   REPRODUCIBLE_IMAGE_NAME: ${{ github.repository_owner }}/reth-reproducible
   CARGO_TERM_COLOR: always
   DOCKER_IMAGE_NAME_URL: https://ghcr.io/${{ github.repository_owner }}/reth
+  DOCKER_OP_IMAGE_NAME_URL: https://ghcr.io/${{ github.repository_owner }}/op-reth
   RUSTC_WRAPPER: "sccache"
 
 jobs:
@@ -85,6 +87,10 @@ jobs:
             os: macos-14
             profile: maxperf
             allow_fail: false
+          - target: x86_64-pc-windows-gnu
+            os: ubuntu-24.04
+            profile: maxperf
+            allow_fail: false
           - target: riscv64gc-unknown-linux-gnu
             os: ubuntu-24.04
             profile: maxperf
@@ -92,6 +98,8 @@ jobs:
         build:
           - command: build
             binary: reth
+          - command: op-build
+            binary: op-reth
     steps:
       - uses: actions/checkout@v6
       - uses: rui314/setup-mold@v1
@@ -118,7 +126,8 @@ jobs:
       - name: Move binary
         run: |
           mkdir artifacts
-          mv "target/${{ matrix.configs.target }}/${{ matrix.configs.profile }}/${{ matrix.build.binary }}" ./artifacts
+          [[ "${{ matrix.configs.target }}" == *windows* ]] && ext=".exe"
+          mv "target/${{ matrix.configs.target }}/${{ matrix.configs.profile }}/${{ matrix.build.binary }}${ext}" ./artifacts
 
       - name: Configure GPG and create artifacts
         env:
@@ -235,9 +244,21 @@ jobs:
           |:---:|:---:|:---:|:---|
           | <img src="https://www.svgrepo.com/download/473700/linux.svg" width="50"/> | x86_64 | [reth-${{ env.VERSION }}-x86_64-unknown-linux-gnu.tar.gz](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/reth-${{ env.VERSION }}-x86_64-unknown-linux-gnu.tar.gz) | [PGP Signature](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/reth-${{ env.VERSION }}-x86_64-unknown-linux-gnu.tar.gz.asc) |
           | <img src="https://www.svgrepo.com/download/473700/linux.svg" width="50"/> | aarch64 | [reth-${{ env.VERSION }}-aarch64-unknown-linux-gnu.tar.gz](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/reth-${{ env.VERSION }}-aarch64-unknown-linux-gnu.tar.gz) | [PGP Signature](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/reth-${{ env.VERSION }}-aarch64-unknown-linux-gnu.tar.gz.asc) |
+          | <img src="https://www.svgrepo.com/download/513083/windows-174.svg" width="50"/> | x86_64 | [reth-${{ env.VERSION }}-x86_64-pc-windows-gnu.tar.gz](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/reth-${{ env.VERSION }}-x86_64-pc-windows-gnu.tar.gz) | [PGP Signature](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/reth-${{ env.VERSION }}-x86_64-pc-windows-gnu.tar.gz.asc) |
           | <img src="https://www.svgrepo.com/download/511330/apple-173.svg" width="50"/> | x86_64 | [reth-${{ env.VERSION }}-x86_64-apple-darwin.tar.gz](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/reth-${{ env.VERSION }}-x86_64-apple-darwin.tar.gz) | [PGP Signature](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/reth-${{ env.VERSION }}-x86_64-apple-darwin.tar.gz.asc) |
           | <img src="https://www.svgrepo.com/download/511330/apple-173.svg" width="50"/> | aarch64 | [reth-${{ env.VERSION }}-aarch64-apple-darwin.tar.gz](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/reth-${{ env.VERSION }}-aarch64-apple-darwin.tar.gz) | [PGP Signature](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/reth-${{ env.VERSION }}-aarch64-apple-darwin.tar.gz.asc) |
           | <img src="https://www.svgrepo.com/download/473589/docker.svg" width="50"/> | Docker | [${{ env.IMAGE_NAME }}](${{ env.DOCKER_IMAGE_NAME_URL }}) | - |
+
+          ### OP-Reth
+
+          | System | Architecture | Binary | PGP Signature |
+          |:---:|:---:|:---:|:---|
+          | <img src="https://www.svgrepo.com/download/473700/linux.svg" width="50"/> | x86_64 | [op-reth-${{ env.VERSION }}-x86_64-unknown-linux-gnu.tar.gz](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/op-reth-${{ env.VERSION }}-x86_64-unknown-linux-gnu.tar.gz) | [PGP Signature](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/op-reth-${{ env.VERSION }}-x86_64-unknown-linux-gnu.tar.gz.asc) |
+          | <img src="https://www.svgrepo.com/download/473700/linux.svg" width="50"/> | aarch64 | [op-reth-${{ env.VERSION }}-aarch64-unknown-linux-gnu.tar.gz](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/op-reth-${{ env.VERSION }}-aarch64-unknown-linux-gnu.tar.gz) | [PGP Signature](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/op-reth-${{ env.VERSION }}-aarch64-unknown-linux-gnu.tar.gz.asc) |
+          | <img src="https://www.svgrepo.com/download/513083/windows-174.svg" width="50"/> | x86_64 | [op-reth-${{ env.VERSION }}-x86_64-pc-windows-gnu.tar.gz](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/op-reth-${{ env.VERSION }}-x86_64-pc-windows-gnu.tar.gz) | [PGP Signature](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/op-reth-${{ env.VERSION }}-x86_64-pc-windows-gnu.tar.gz.asc) |
+          | <img src="https://www.svgrepo.com/download/511330/apple-173.svg" width="50"/> | x86_64 | [op-reth-${{ env.VERSION }}-x86_64-apple-darwin.tar.gz](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/op-reth-${{ env.VERSION }}-x86_64-apple-darwin.tar.gz) | [PGP Signature](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/op-reth-${{ env.VERSION }}-x86_64-apple-darwin.tar.gz.asc) |
+          | <img src="https://www.svgrepo.com/download/511330/apple-173.svg" width="50"/> | aarch64 | [op-reth-${{ env.VERSION }}-aarch64-apple-darwin.tar.gz](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/op-reth-${{ env.VERSION }}-aarch64-apple-darwin.tar.gz) | [PGP Signature](https://github.com/${{ env.REPO_NAME }}/releases/download/${{ env.VERSION }}/op-reth-${{ env.VERSION }}-aarch64-apple-darwin.tar.gz.asc) |
+          | <img src="https://www.svgrepo.com/download/473589/docker.svg" width="50"/> | Docker | [${{ env.OP_IMAGE_NAME }}](${{ env.DOCKER_OP_IMAGE_NAME_URL }}) | - |
           ENDBODY
           )
           assets=()

.github/workflows/sync-era.yml

@@ -32,6 +32,12 @@ jobs:
             tip: "0x91c90676cab257a59cd956d7cb0bceb9b1a71d79755c23c7277a0697ccfaf8c4"
             block: 100000
             unwind-target: "0x52e0509d33a988ef807058e2980099ee3070187f7333aae12b64d4d675f34c5a"
+          - build: install-op
+            bin: op-reth
+            chain: base
+            tip: "0xbb9b85352c7ebca6ba8efc63bd66cecd038c92ec8ebd02e153a3e0b197e672b7"
+            block: 10000
+            unwind-target: "0x118a6e922a8c6cab221fc5adfe5056d2b72d58c6580e9c5629de55299e2cf8de"
     steps:
       - uses: actions/checkout@v6
       - uses: rui314/setup-mold@v1

.github/workflows/sync.yml

@@ -32,6 +32,12 @@ jobs:
             tip: "0x91c90676cab257a59cd956d7cb0bceb9b1a71d79755c23c7277a0697ccfaf8c4"
             block: 100000
             unwind-target: "0x52e0509d33a988ef807058e2980099ee3070187f7333aae12b64d4d675f34c5a"
+          - build: install-op
+            bin: op-reth
+            chain: base
+            tip: "0xbb9b85352c7ebca6ba8efc63bd66cecd038c92ec8ebd02e153a3e0b197e672b7"
+            block: 10000
+            unwind-target: "0x118a6e922a8c6cab221fc5adfe5056d2b72d58c6580e9c5629de55299e2cf8de"
     steps:
       - uses: actions/checkout@v6
       - uses: rui314/setup-mold@v1

.github/workflows/unit.yml

@@ -19,19 +19,29 @@ concurrency:
 
 jobs:
   test:
-    name: test / ${{ matrix.type }} / ${{ matrix.storage }}
+    name: test / ${{ matrix.type }} (${{ matrix.partition }}/${{ matrix.total_partitions }})
     runs-on: depot-ubuntu-latest-4
     env:
       RUST_BACKTRACE: 1
-      EDGE_FEATURES: ${{ matrix.storage == 'edge' && 'edge' || '' }}
     strategy:
       matrix:
-        type: [ethereum]
-        storage: [stable, edge]
         include:
           - type: ethereum
-            features: asm-keccak ethereum
-            exclude_args: ""
+            args: --features "asm-keccak ethereum" --locked
+            partition: 1
+            total_partitions: 2
+          - type: ethereum
+            args: --features "asm-keccak ethereum" --locked
+            partition: 2
+            total_partitions: 2
+          - type: optimism
+            args: --features "asm-keccak" --locked --exclude reth --exclude reth-bench --exclude "example-*" --exclude "reth-ethereum-*" --exclude "*-ethereum"
+            partition: 1
+            total_partitions: 2
+          - type: optimism
+            args: --features "asm-keccak" --locked --exclude reth --exclude reth-bench --exclude "example-*" --exclude "reth-ethereum-*" --exclude "*-ethereum"
+            partition: 2
+            total_partitions: 2
     timeout-minutes: 30
     steps:
       - uses: actions/checkout@v6
@@ -49,9 +59,9 @@ jobs:
       - name: Run tests
         run: |
           cargo nextest run \
-            --features "${{ matrix.features }} $EDGE_FEATURES" --locked \
-            ${{ matrix.exclude_args }} --workspace \
+            ${{ matrix.args }} --workspace \
             --exclude ef-tests --no-tests=warn \
+            --partition hash:${{ matrix.partition }}/2 \
             -E "!kind(test) and not binary(e2e_testsuite)"
 
   state:
@@ -87,7 +97,7 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         with:
           cache-on-failure: true
-      - run: cargo nextest run --cargo-profile hivetests -p ef-tests --features "asm-keccak ef-tests"
+      - run: cargo nextest run --release -p ef-tests --features "asm-keccak ef-tests"
 
   doc:
     name: doc tests

.github/workflows/update-superchain.yml

@@ -0,0 +1,36 @@
+name: Update Superchain Config
+
+on:
+  schedule:
+    - cron: '0 3 * * 0'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  update-superchain:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Install required tools
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y jq zstd qpdf yq
+
+      - name: Run fetch_superchain_config.sh
+        run: |
+          chmod +x crates/optimism/chainspec/res/fetch_superchain_config.sh
+          cd crates/optimism/chainspec/res
+          ./fetch_superchain_config.sh
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v8
+        with:
+          commit-message: "chore: update superchain config"
+          title: "chore: update superchain config"
+          body: "This PR updates the superchain configs via scheduled workflow."
+          branch: "ci/update-superchain-config"
+          delete-branch: true

.github/workflows/windows.yml

@@ -0,0 +1,54 @@
+# Windows build
+
+name: windows
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  merge_group:
+
+env:
+  RUSTC_WRAPPER: "sccache"
+
+jobs:
+  check-reth:
+    runs-on: depot-ubuntu-latest
+    timeout-minutes: 60
+
+    steps:
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          target: x86_64-pc-windows-gnu
+      - uses: taiki-e/install-action@cross
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
+        with:
+          cache-on-failure: true
+      - name: mingw-w64
+        run: sudo apt-get install -y mingw-w64
+      - name: Check Reth
+        run: cargo check --target x86_64-pc-windows-gnu
+
+  check-op-reth:
+    runs-on: depot-ubuntu-latest
+    timeout-minutes: 60
+
+    steps:
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          target: x86_64-pc-windows-gnu
+      - uses: taiki-e/install-action@cross
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
+        with:
+          cache-on-failure: true
+      - name: mingw-w64
+        run: sudo apt-get install -y mingw-w64
+      - name: Check OP-Reth
+        run: cargo check -p op-reth --target x86_64-pc-windows-gnu

.gitignore

@@ -12,9 +12,6 @@ target/
 # Generated by Intellij-based IDEs.
 .idea
 
-# ck-search metadata
-.ck
-
 # Generated by MacOS
 .DS_Store
 

CLAUDE.md

@@ -18,13 +18,13 @@ Reth is a high-performance Ethereum execution client written in Rust, focusing o
 6. **Pipeline (`crates/stages/`)**: Staged sync architecture for blockchain synchronization
 7. **Trie (`crates/trie/`)**: Merkle Patricia Trie implementation with parallel state root computation
 8. **Node Builder (`crates/node/`)**: High-level node orchestration and configuration
-9. **The Consensus Engine (`crates/engine/`)**: Handles processing blocks received from the consensus layer with the Engine API (newPayload, forkchoiceUpdated)
+9  **The Consensus Engine (`crates/engine/`)**: Handles processing blocks received from the consensus layer with the Engine API (newPayload, forkchoiceUpdated)
 
 ### Key Design Principles
 
 - **Modularity**: Each crate can be used as a standalone library
 - **Performance**: Extensive use of parallelism, memory-mapped I/O, and optimized data structures
-- **Extensibility**: Traits and generic types allow for different chain implementations
+- **Extensibility**: Traits and generic types allow for different implementations (Ethereum, Optimism, etc.)
 - **Type Safety**: Strong typing throughout with minimal use of dynamic dispatch
 
 ## Development Workflow
@@ -38,7 +38,7 @@ Reth is a high-performance Ethereum execution client written in Rust, focusing o
 
 2. **Linting**: Run clippy with all features
    ```bash
-   cargo +nightly clippy --workspace --lib --examples --tests --benches --all-features 
+   RUSTFLAGS="-D warnings" cargo +nightly clippy --workspace --lib --examples --tests --benches --all-features --locked
    ```
 
 3. **Testing**: Use nextest for faster test execution
@@ -169,16 +169,18 @@ Based on PR patterns, avoid:
 Before submitting changes, ensure:
 
 1. **Format Check**: `cargo +nightly fmt --all --check`
-2. **Clippy**: No warnings
+2. **Clippy**: No warnings with `RUSTFLAGS="-D warnings"`
 3. **Tests Pass**: All unit and integration tests
 4. **Documentation**: Update relevant docs and add doc comments with `cargo docs --document-private-items`
 5. **Commit Messages**: Follow conventional format (feat:, fix:, chore:, etc.)
 
+
 ### Opening PRs against <https://github.com/paradigmxyz/reth>
 
 Label PRs appropriately, first check the available labels and then apply the relevant ones:
 * when changes are RPC related, add A-rpc label
 * when changes are docs related, add C-docs label
+* when changes are optimism related (e.g. new feature or exclusive changes to crates/optimism), add A-op-reth label
 * ... and so on, check the available labels for more options.
 * if being tasked to open a pr, ensure that all changes are properly formatted: `cargo +nightly fmt --all`
 
@@ -232,7 +234,7 @@ Tests often need expansion for:
 Common refactoring pattern:
 - Replace concrete types with generics
 - Add trait bounds for flexibility
-- Enable reuse across different chain types
+- Enable reuse across different chain types (Ethereum, Optimism)
 
 #### When to Comment
 
@@ -247,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);
@@ -347,11 +349,11 @@ Let's say you want to fix a bug where external IP resolution fails on startup:
    }
    ```
 
-5. **Run checks** (IMPORTANT!):
+5. **Run checks**:
    ```bash
    cargo +nightly fmt --all
-   cargo clippy --workspace --all-features # Make sure WHOLE WORKSPACE compiles!
-   cargo nextest run -p reth-discv4
+   cargo clippy --all-features
+   cargo test -p reth-discv4
    ```
 
 6. **Commit with clear message**:
@@ -372,7 +374,7 @@ Let's say you want to fix a bug where external IP resolution fails on startup:
 cargo +nightly fmt --all
 
 # Run lints
-cargo +nightly clippy --workspace --all-features
+RUSTFLAGS="-D warnings" cargo +nightly clippy --workspace --all-features --locked
 
 # Run tests
 cargo nextest run --workspace

CONTRIBUTING.md

@@ -51,7 +51,9 @@ elsewhere.
 <!-- -   **Asking in the support Telegram:** The [Foundry Support Telegram][support-tg] is a fast and easy way to ask questions. -->
 <!-- -   **Opening a discussion:** This repository comes with a discussions board where you can also ask for help. Click the "Discussions" tab at the top. -->
 
-If you have reviewed existing documentation and still have questions, or you are having problems, you can get help by **opening a discussion**. This repository comes with a discussions board where you can also ask for help. Click the "Discussions" tab at the top.
+If you have reviewed existing documentation and still have questions, or you are having problems, you can get help by *
+*opening a discussion**. This repository comes with a discussions board where you can also ask for help. Click the "
+Discussions" tab at the top.
 
 As Reth is still in heavy development, the documentation can be a bit scattered. The [Reth Docs][reth-docs] is our
 current best-effort attempt at keeping up-to-date information.

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"
@@ -72,6 +72,20 @@ members = [
     "crates/node/events/",
     "crates/node/metrics",
     "crates/node/types",
+    "crates/optimism/bin",
+    "crates/optimism/chainspec",
+    "crates/optimism/cli",
+    "crates/optimism/consensus",
+    "crates/optimism/evm/",
+    "crates/optimism/flashblocks/",
+    "crates/optimism/hardforks/",
+    "crates/optimism/node/",
+    "crates/optimism/payload/",
+    "crates/optimism/primitives/",
+    "crates/optimism/reth/",
+    "crates/optimism/rpc/",
+    "crates/optimism/storage",
+    "crates/optimism/txpool/",
     "crates/payload/basic/",
     "crates/payload/builder/",
     "crates/payload/builder-primitives/",
@@ -131,6 +145,7 @@ members = [
     "examples/beacon-api-sse/",
     "examples/bsc-p2p",
     "examples/custom-dev-node/",
+    "examples/custom-node/",
     "examples/custom-engine-types/",
     "examples/custom-evm/",
     "examples/custom-hardforks/",
@@ -139,7 +154,10 @@ members = [
     "examples/custom-payload-builder/",
     "examples/custom-rlpx-subprotocol",
     "examples/custom-rpc-middleware",
+    "examples/custom-node",
     "examples/db-access",
+    "examples/engine-api-access",
+    "examples/exex-hello-world",
     "examples/exex-subscription",
     "examples/exex-test",
     "examples/full-contract-state",
@@ -150,6 +168,7 @@ members = [
     "examples/node-builder-api/",
     "examples/node-custom-rpc/",
     "examples/node-event-hooks/",
+    "examples/op-db-access/",
     "examples/polygon-p2p/",
     "examples/rpc-db/",
     "examples/precompile-cache/",
@@ -318,6 +337,7 @@ incremental = false
 
 [workspace.dependencies]
 # reth
+op-reth = { path = "crates/optimism/bin" }
 reth = { path = "bin/reth" }
 reth-storage-rpc-provider = { path = "crates/storage/rpc-provider" }
 reth-basic-payload-builder = { path = "crates/payload/basic" }
@@ -366,6 +386,7 @@ reth-ethereum = { path = "crates/ethereum/reth" }
 reth-etl = { path = "crates/etl" }
 reth-evm = { path = "crates/evm/evm", default-features = false }
 reth-evm-ethereum = { path = "crates/ethereum/evm", default-features = false }
+reth-optimism-evm = { path = "crates/optimism/evm", default-features = false }
 reth-execution-errors = { path = "crates/evm/execution-errors", default-features = false }
 reth-execution-types = { path = "crates/evm/execution-types", default-features = false }
 reth-exex = { path = "crates/exex/exex" }
@@ -392,7 +413,18 @@ reth-node-ethereum = { path = "crates/ethereum/node" }
 reth-node-ethstats = { path = "crates/node/ethstats" }
 reth-node-events = { path = "crates/node/events" }
 reth-node-metrics = { path = "crates/node/metrics" }
+reth-optimism-node = { path = "crates/optimism/node" }
 reth-node-types = { path = "crates/node/types" }
+reth-op = { path = "crates/optimism/reth", default-features = false }
+reth-optimism-chainspec = { path = "crates/optimism/chainspec", default-features = false }
+reth-optimism-cli = { path = "crates/optimism/cli", default-features = false }
+reth-optimism-consensus = { path = "crates/optimism/consensus", default-features = false }
+reth-optimism-forks = { path = "crates/optimism/hardforks", default-features = false }
+reth-optimism-payload-builder = { path = "crates/optimism/payload" }
+reth-optimism-primitives = { path = "crates/optimism/primitives", default-features = false }
+reth-optimism-rpc = { path = "crates/optimism/rpc" }
+reth-optimism-storage = { path = "crates/optimism/storage" }
+reth-optimism-txpool = { path = "crates/optimism/txpool" }
 reth-payload-builder = { path = "crates/payload/builder" }
 reth-payload-builder-primitives = { path = "crates/payload/builder-primitives" }
 reth-payload-primitives = { path = "crates/payload/primitives" }
@@ -413,6 +445,7 @@ reth-rpc-engine-api = { path = "crates/rpc/rpc-engine-api" }
 reth-rpc-eth-api = { path = "crates/rpc/rpc-eth-api" }
 reth-rpc-eth-types = { path = "crates/rpc/rpc-eth-types", default-features = false }
 reth-rpc-layer = { path = "crates/rpc/rpc-layer" }
+reth-optimism-flashblocks = { path = "crates/optimism/flashblocks" }
 reth-rpc-server-types = { path = "crates/rpc/rpc-server-types" }
 reth-rpc-convert = { path = "crates/rpc/rpc-convert" }
 reth-stages = { path = "crates/stages/stages" }
@@ -440,60 +473,60 @@ 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.2"
+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-dyn-abi = "1.5.4"
-alloy-primitives = { version = "1.5.4", default-features = false, features = ["map-foldhash"] }
-alloy-sol-types = { version = "1.5.4", default-features = false }
-
 alloy-chains = { version = "0.2.5", default-features = false }
+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.2", default-features = false }
+alloy-eip7928 = { version = "0.1.0" }
+alloy-evm = { version = "0.25.1", default-features = false }
+alloy-primitives = { version = "1.5.0", default-features = false, features = ["map-foldhash"] }
 alloy-rlp = { version = "0.3.10", default-features = false, features = ["core-net"] }
-alloy-trie = { version = "0.9.4", default-features = false }
+alloy-sol-macro = "1.5.0"
+alloy-sol-types = { version = "1.5.0", default-features = false }
+alloy-trie = { version = "0.9.1", default-features = false }
 
 alloy-hardforks = "0.4.5"
 
-alloy-consensus = { version = "1.6.1", default-features = false }
-alloy-contract = { version = "1.6.1", default-features = false }
-alloy-eips = { version = "1.6.1", default-features = false }
-alloy-genesis = { version = "1.6.1", default-features = false }
-alloy-json-rpc = { version = "1.6.1", default-features = false }
-alloy-network = { version = "1.6.1", default-features = false }
-alloy-network-primitives = { version = "1.6.1", default-features = false }
-alloy-provider = { version = "1.6.1", features = ["reqwest", "debug-api"], default-features = false }
-alloy-pubsub = { version = "1.6.1", default-features = false }
-alloy-rpc-client = { version = "1.6.1", default-features = false }
-alloy-rpc-types = { version = "1.6.1", features = ["eth"], default-features = false }
-alloy-rpc-types-admin = { version = "1.6.1", default-features = false }
-alloy-rpc-types-anvil = { version = "1.6.1", default-features = false }
-alloy-rpc-types-beacon = { version = "1.6.1", default-features = false }
-alloy-rpc-types-debug = { version = "1.6.1", default-features = false }
-alloy-rpc-types-engine = { version = "1.6.1", default-features = false }
-alloy-rpc-types-eth = { version = "1.6.1", default-features = false }
-alloy-rpc-types-mev = { version = "1.6.1", default-features = false }
-alloy-rpc-types-trace = { version = "1.6.1", default-features = false }
-alloy-rpc-types-txpool = { version = "1.6.1", default-features = false }
-alloy-serde = { version = "1.6.1", default-features = false }
-alloy-signer = { version = "1.6.1", default-features = false }
-alloy-signer-local = { version = "1.6.1", default-features = false }
-alloy-transport = { version = "1.6.1" }
-alloy-transport-http = { version = "1.6.1", features = ["reqwest-rustls-tls"], default-features = false }
-alloy-transport-ipc = { version = "1.6.1", default-features = false }
-alloy-transport-ws = { version = "1.6.1", default-features = false }
+alloy-consensus = { version = "1.1.3", default-features = false }
+alloy-contract = { version = "1.1.3", default-features = false }
+alloy-eips = { version = "1.1.3", default-features = false }
+alloy-genesis = { version = "1.1.3", default-features = false }
+alloy-json-rpc = { version = "1.1.3", default-features = false }
+alloy-network = { version = "1.1.3", default-features = false }
+alloy-network-primitives = { version = "1.1.3", default-features = false }
+alloy-provider = { version = "1.1.3", features = ["reqwest", "debug-api"], default-features = false }
+alloy-pubsub = { version = "1.1.3", default-features = false }
+alloy-rpc-client = { version = "1.1.3", default-features = false }
+alloy-rpc-types = { version = "1.1.3", features = ["eth"], default-features = false }
+alloy-rpc-types-admin = { version = "1.1.3", default-features = false }
+alloy-rpc-types-anvil = { version = "1.1.3", default-features = false }
+alloy-rpc-types-beacon = { version = "1.1.3", default-features = false }
+alloy-rpc-types-debug = { version = "1.1.3", default-features = false }
+alloy-rpc-types-engine = { version = "1.1.3", default-features = false }
+alloy-rpc-types-eth = { version = "1.1.3", default-features = false }
+alloy-rpc-types-mev = { version = "1.1.3", default-features = false }
+alloy-rpc-types-trace = { version = "1.1.3", default-features = false }
+alloy-rpc-types-txpool = { version = "1.1.3", default-features = false }
+alloy-serde = { version = "1.1.3", default-features = false }
+alloy-signer = { version = "1.1.3", default-features = false }
+alloy-signer-local = { version = "1.1.3", default-features = false }
+alloy-transport = { version = "1.1.3" }
+alloy-transport-http = { version = "1.1.3", features = ["reqwest-rustls-tls"], default-features = false }
+alloy-transport-ipc = { version = "1.1.3", default-features = false }
+alloy-transport-ws = { version = "1.1.3", default-features = false }
 
 # op
-alloy-op-evm = { version = "0.27.2", 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 }
@@ -511,26 +544,24 @@ backon = { version = "1.2", default-features = false, features = ["std-blocking-
 bincode = "1.3"
 bitflags = "2.4"
 boyer-moore-magiclen = "0.2.16"
-bytes = { version = "1.11.1", default-features = false }
+bytes = { version = "1.5", default-features = false }
 brotli = "8"
 cfg-if = "1.0"
 clap = "4"
-color-eyre = "0.6"
 dashmap = "6.0"
 derive_more = { version = "2", default-features = false, features = ["full"] }
 dirs-next = "2.0.0"
 dyn-clone = "1.0.17"
 eyre = "0.6"
 fdlimit = "0.3.0"
-fixed-map = { version = "0.9", default-features = false }
 humantime = "2.1"
 humantime-serde = "1.1"
 itertools = { version = "0.14", default-features = false }
 linked_hash_set = "0.1"
 lz4 = "1.28.1"
-modular-bitfield = "0.13.1"
+modular-bitfield = "0.11.2"
 notify = { version = "8.0.0", default-features = false, features = ["macos_fsevent"] }
-nybbles = { version = "0.4.8", default-features = false }
+nybbles = { version = "0.4.2", default-features = false }
 once_cell = { version = "1.19", default-features = false, features = ["critical-section"] }
 parking_lot = "0.12"
 paste = "1.0"
@@ -555,18 +586,17 @@ tracing-appender = "0.2"
 url = { version = "2.3", default-features = false }
 zstd = "0.13"
 byteorder = "1"
-fixed-cache = { version = "0.1.7", features = ["stats"] }
-moka = "0.12"
-tar-no-std = { version = "0.4.2", default-features = false }
-miniz_oxide = { version = "0.9.0", default-features = false }
+mini-moka = "0.10"
+tar-no-std = { version = "0.3.2", default-features = false }
+miniz_oxide = { version = "0.8.4", default-features = false }
 chrono = "0.4.41"
 
 # metrics
 metrics = "0.24.0"
-metrics-derive = "0.1.1"
-metrics-exporter-prometheus = { version = "0.18.0", default-features = false }
+metrics-derive = "0.1"
+metrics-exporter-prometheus = { version = "0.16.0", default-features = false }
 metrics-process = "2.1.0"
-metrics-util = { default-features = false, version = "0.20.0" }
+metrics-util = { default-features = false, version = "0.19.0" }
 
 # proc-macros
 proc-macro2 = "1.0"
@@ -575,7 +605,7 @@ quote = "1.0"
 # tokio
 tokio = { version = "1.44.2", default-features = false }
 tokio-stream = "0.1.11"
-tokio-tungstenite = "0.28.0"
+tokio-tungstenite = "0.26.2"
 tokio-util = { version = "0.7.4", features = ["codec"] }
 
 # async
@@ -588,7 +618,7 @@ futures-util = { version = "0.3", default-features = false }
 hyper = "1.3"
 hyper-util = "0.1.5"
 pin-project = "1.0.12"
-reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "rustls-tls-native-roots", "stream"] }
+reqwest = { version = "0.12", default-features = false }
 tracing-futures = "0.2"
 tower = "0.5"
 tower-http = "0.6"
@@ -608,6 +638,7 @@ jsonrpsee-types = "0.26.0"
 http = "1.0"
 http-body = "1.0"
 http-body-util = "0.1.2"
+jsonwebtoken = "9"
 proptest-arbitrary-interop = "0.1.0"
 
 # crypto
@@ -621,7 +652,7 @@ rand_08 = { package = "rand", version = "0.8" }
 c-kzg = "2.1.5"
 
 # config
-toml = "0.9"
+toml = "0.8"
 
 # rocksdb
 rocksdb = { version = "0.24" }
@@ -631,28 +662,26 @@ 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
 arbitrary = "1.3"
 assert_matches = "1.5.0"
-criterion = { package = "codspeed-criterion-compat", version = "4.3" }
+criterion = { package = "codspeed-criterion-compat", version = "2.7" }
 insta = "1.41"
 proptest = "1.7"
-proptest-derive = "0.7"
+proptest-derive = "0.5"
 similar-asserts = { version = "1.5.0", features = ["serde"] }
 tempfile = "3.20"
 test-fuzz = "7"
-rstest = "0.26.1"
+rstest = "0.24.0"
 test-case = "3"
 
 # ssz encoding
-ethereum_ssz = "0.10.1"
-ethereum_ssz_derive = "0.10.1"
+ethereum_ssz = "0.9.0"
+ethereum_ssz_derive = "0.9.0"
 
 # allocators
-jemalloc_pprof = { version = "0.8", default-features = false }
 tikv-jemalloc-ctl = "0.6"
 tikv-jemallocator = "0.6"
 tracy-client = "0.18.0"
@@ -661,14 +690,14 @@ snmalloc-rs = { version = "0.3.7", features = ["build_cc"] }
 aes = "0.8.1"
 ahash = "0.8"
 anyhow = "1.0"
-bindgen = { version = "0.72", default-features = false }
-block-padding = "0.3"
-cc = "1.2.15"
+bindgen = { version = "0.71", default-features = false }
+block-padding = "0.3.2"
+cc = "=1.2.15"
 cipher = "0.4.3"
 comfy-table = "7.0"
 concat-kdf = "0.1.0"
 crossbeam-channel = "0.5.13"
-crossterm = "0.29.0"
+crossterm = "0.28.0"
 csv = "1.3.0"
 ctrlc = "3.4"
 ctr = "0.9.2"
@@ -681,7 +710,7 @@ hmac = "0.12.1"
 human_bytes = "0.4.1"
 indexmap = "2"
 interprocess = "2.2.0"
-lz4_flex = { version = "0.12", default-features = false }
+lz4_flex = { version = "0.11", default-features = false }
 memmap2 = "0.9.4"
 mev-share-sse = { version = "0.5.0", default-features = false }
 num-traits = "0.2.15"
@@ -689,31 +718,29 @@ page_size = "0.6.0"
 parity-scale-codec = "3.2.1"
 plain_hasher = "0.2"
 pretty_assertions = "1.4"
-ratatui = { version = "0.30", default-features = false }
-ringbuffer = "0.16.0"
+ratatui = { version = "0.29", default-features = false }
+ringbuffer = "0.15.0"
 rmp-serde = "1.3"
-roaring = "0.11.3"
+roaring = "0.10.2"
 rolling-file = "0.2.0"
 sha3 = "0.10.5"
 snap = "1.1.1"
-socket2 = { version = "0.6", default-features = false }
-sysinfo = { version = "0.38", default-features = false }
+socket2 = { version = "0.5", default-features = false }
+sysinfo = { version = "0.33", default-features = false }
 tracing-journald = "0.3"
-tracing-logfmt = "=0.3.5"
-tracing-samply = "0.1"
+tracing-logfmt = "0.3.3"
 tracing-subscriber = { version = "0.3", default-features = false }
-tracing-tracy = "0.11"
 triehash = "0.8"
 typenum = "1.15.0"
-vergen = "9.1.0"
+vergen = "9.0.4"
 visibility = "0.1.1"
 walkdir = "2.3.3"
-vergen-git2 = "9.1.0"
+vergen-git2 = "1.0.5"
 
 # networking
 ipnet = "2.11"
 
-[patch.crates-io]
+# [patch.crates-io]
 # alloy-consensus = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
 # alloy-contract = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
 # alloy-eips = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
@@ -756,10 +783,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" }

Cross.toml

@@ -15,6 +15,15 @@ pre-build = [
     "apt-get update && apt-get install --assume-yes --no-install-recommends llvm-dev libclang-dev clang",
 ]
 
+[target.x86_64-pc-windows-gnu]
+# Why do we need a custom Dockerfile on Windows:
+# 1. `reth-libmdbx` stopped working with MinGW 9.3 that cross image comes with.
+# 2. To be able to update the version of MinGW, we need to also update the Ubuntu that the image is based on.
+#
+# Also see https://github.com/cross-rs/cross/issues/1667
+# Inspired by https://github.com/cross-rs/cross/blob/9e2298e17170655342d3248a9c8ac37ef92ba38f/docker/Dockerfile.x86_64-pc-windows-gnu#L51
+dockerfile = "./Dockerfile.x86_64-pc-windows-gnu"
+
 [target.riscv64gc-unknown-linux-gnu]
 image = "ubuntu:24.04"
 pre-build = [

Dockerfile

@@ -18,7 +18,7 @@ FROM chef AS builder
 COPY --from=planner /app/recipe.json recipe.json
 
 # Build profile, release by default
-ARG BUILD_PROFILE=maxperf
+ARG BUILD_PROFILE=release
 ENV BUILD_PROFILE=$BUILD_PROFILE
 
 # Extra Cargo flags

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,89 +0,0 @@
-# syntax=docker/dockerfile:1
-
-# Dockerfile for reth, optimized for Depot builds
-# Usage:
-#   reth: --build-arg BINARY=reth
-
-FROM rust:1 AS builder
-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
-
-# Binary to build
-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 (can be overridden, otherwise set per-platform below)
-ARG 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 application
-# Platform-specific RUSTFLAGS: amd64 uses x86-64-v3 (Haswell+) with pclmulqdq for rocksdb
-ARG TARGETPLATFORM
-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 \
-    if [ -n "$RUSTFLAGS" ]; then \
-        export RUSTFLAGS="$RUSTFLAGS"; \
-    elif [ "$TARGETPLATFORM" = "linux/amd64" ]; then \
-        export RUSTFLAGS="-C target-cpu=x86-64-v3 -C target-feature=+pclmulqdq"; \
-    fi && \
-    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"]

Dockerfile.x86_64-pc-windows-gnu

@@ -0,0 +1,79 @@
+FROM ubuntu:24.04 AS cross-base
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Use HTTPS for package sources
+RUN apt-get update && apt-get install --assume-yes --no-install-recommends ca-certificates
+RUN find /etc/apt/ -type f \( -name '*.list' -o -name '*.sources' \) -exec sed -i 's|http://|https://|g' {} +
+
+# Configure APT retries and timeouts to handle network issues
+RUN echo 'Acquire::Retries \"3\";' > /etc/apt/apt.conf.d/80-retries && \
+    echo 'Acquire::http::Timeout \"60\";' >> /etc/apt/apt.conf.d/80-retries && \
+    echo 'Acquire::ftp::Timeout \"60\";' >> /etc/apt/apt.conf.d/80-retries
+
+# configure fallback mirrors
+RUN sed -i 's|URIs: https://archive.ubuntu.com/ubuntu/|URIs: https://mirror.cov.ukservers.com/ubuntu/ https://archive.ubuntu.com/ubuntu/ https://mirror.ox.ac.uk/sites/archive.ubuntu.com/ubuntu/|g' /etc/apt/sources.list.d/ubuntu.sources
+
+RUN apt-get update && apt-get install --assume-yes --no-install-recommends git
+
+RUN git clone https://github.com/cross-rs/cross /cross
+WORKDIR /cross/docker
+RUN git checkout baf457efc2555225af47963475bd70e8d2f5993f
+
+# xargo doesn't work with Rust 1.89 and higher: https://github.com/cross-rs/cross/issues/1701.
+#
+# When this PR https://github.com/cross-rs/cross/pull/1580 is merged,
+# we can update the checkout above and remove this replacement.
+RUN sed -i 's|sh rustup-init.sh -y --no-modify-path --profile minimal|sh rustup-init.sh -y --no-modify-path --profile minimal --default-toolchain=1.88.0|' xargo.sh
+
+RUN cp common.sh lib.sh / && /common.sh
+RUN cp cmake.sh / && /cmake.sh
+RUN cp xargo.sh / && /xargo.sh
+
+FROM cross-base AS build
+
+RUN apt-get install --assume-yes --no-install-recommends libz-mingw-w64-dev g++-mingw-w64-x86-64 gfortran-mingw-w64-x86-64
+
+# Install Wine using OpenSUSE repository because official one is often lagging behind
+RUN dpkg --add-architecture i386 && \
+    apt-get install --assume-yes --no-install-recommends wget gpg && \
+    mkdir -pm755 /etc/apt/keyrings && curl -fsSL \
+    https://download.opensuse.org/repositories/Emulators:/Wine:/Debian/xUbuntu_24.04/Release.key \
+    | tee /etc/apt/keyrings/obs-winehq.key >/dev/null && \
+    echo "deb [arch=amd64,i386 signed-by=/etc/apt/keyrings/obs-winehq.key] \
+    https://download.opensuse.org/repositories/Emulators:/Wine:/Debian/xUbuntu_24.04/ ./" \
+    | tee /etc/apt/sources.list.d/obs-winehq.list && \
+    apt-get update && apt-get install --assume-yes --install-recommends winehq-stable
+
+# run-detectors are responsible for calling the correct interpreter for exe
+# files. For some reason it does not work inside a docker container (it works
+# fine in the host). So we replace the usual paths of run-detectors to run wine
+# directly. This only affects the guest, we are not messing up with the host.
+#
+# See /usr/share/doc/binfmt-support/detectors
+RUN mkdir -p /usr/lib/binfmt-support/ && \
+    rm -f /usr/lib/binfmt-support/run-detectors /usr/bin/run-detectors && \
+    ln -s /usr/bin/wine /usr/lib/binfmt-support/run-detectors && \
+    ln -s /usr/bin/wine /usr/bin/run-detectors
+
+RUN cp windows-entry.sh /
+ENTRYPOINT ["/windows-entry.sh"]
+
+RUN cp toolchain.cmake /opt/toolchain.cmake
+
+# for why we always link with pthread support, see:
+# https://github.com/cross-rs/cross/pull/1123#issuecomment-1312287148
+ENV CROSS_TOOLCHAIN_PREFIX=x86_64-w64-mingw32-
+ENV CROSS_TOOLCHAIN_SUFFIX=-posix
+ENV CROSS_SYSROOT=/usr/x86_64-w64-mingw32
+ENV CROSS_TARGET_RUNNER="env -u CARGO_TARGET_X86_64_PC_WINDOWS_GNU_RUNNER wine"
+ENV CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER="$CROSS_TOOLCHAIN_PREFIX"gcc"$CROSS_TOOLCHAIN_SUFFIX" \
+    CARGO_TARGET_X86_64_PC_WINDOWS_GNU_RUNNER="$CROSS_TARGET_RUNNER" \
+    AR_x86_64_pc_windows_gnu="$CROSS_TOOLCHAIN_PREFIX"ar \
+    CC_x86_64_pc_windows_gnu="$CROSS_TOOLCHAIN_PREFIX"gcc"$CROSS_TOOLCHAIN_SUFFIX" \
+    CXX_x86_64_pc_windows_gnu="$CROSS_TOOLCHAIN_PREFIX"g++"$CROSS_TOOLCHAIN_SUFFIX" \
+    CMAKE_TOOLCHAIN_FILE_x86_64_pc_windows_gnu=/opt/toolchain.cmake \
+    BINDGEN_EXTRA_CLANG_ARGS_x86_64_pc_windows_gnu="--sysroot=$CROSS_SYSROOT -idirafter/usr/include" \
+    CROSS_CMAKE_SYSTEM_NAME=Windows \
+    CROSS_CMAKE_SYSTEM_PROCESSOR=AMD64 \
+    CROSS_CMAKE_CRT=gnu \
+    CROSS_CMAKE_OBJECT_FLAGS="-ffunction-sections -fdata-sections -m64"

DockerfileOp

@@ -0,0 +1,46 @@
+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 -y upgrade && apt-get install -y libclang-dev pkg-config
+
+# Builds a cargo-chef plan
+FROM chef AS planner
+COPY . .
+RUN cargo chef prepare --recipe-path recipe.json
+
+FROM chef AS builder
+COPY --from=planner /app/recipe.json recipe.json
+
+ARG BUILD_PROFILE=release
+ENV BUILD_PROFILE=$BUILD_PROFILE
+
+ARG RUSTFLAGS=""
+ENV RUSTFLAGS="$RUSTFLAGS"
+
+ARG FEATURES=""
+ENV FEATURES=$FEATURES
+
+RUN cargo chef cook --profile $BUILD_PROFILE --features "$FEATURES" --recipe-path recipe.json --manifest-path /app/crates/optimism/bin/Cargo.toml
+
+COPY . .
+RUN cargo build --profile $BUILD_PROFILE --features "$FEATURES" --bin op-reth --manifest-path /app/crates/optimism/bin/Cargo.toml
+
+RUN ls -la /app/target/$BUILD_PROFILE/op-reth
+RUN cp /app/target/$BUILD_PROFILE/op-reth /app/op-reth
+
+FROM ubuntu AS runtime
+
+RUN apt-get update && \
+    apt-get install -y ca-certificates libssl-dev pkg-config strace && \
+    rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY --from=builder /app/op-reth /usr/local/bin/
+RUN chmod +x /usr/local/bin/op-reth
+COPY LICENSE-* ./
+
+EXPOSE 30303 30303/udp 9001 8545 8546 7545 8551
+ENTRYPOINT ["/usr/local/bin/op-reth"]

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

HARDFORK-CHECKLIST.md

@@ -24,3 +24,18 @@
   parameters.
 - Update version specific validation checks in the `EngineValidator` trait.
 
+## Op-Reth changes
+
+### Updates to the engine API
+
+Opstack tries to be as close to the L1 engine API as much as possible. Isthmus (Prague equivalent) introduced the first
+deviation from the L1 engine API with an additional field in the `ExecutionPayload`. For this reason the op engine API
+has its own server traits `OpEngineApi`.
+Adding a new versioned endpoint requires the same changes as for L1 just for the dedicated OP types.
+
+### Hardforks
+
+Opstack has dedicated hardforks (e.g. Isthmus), that can be entirely opstack specific (e.g. Holocene) or can be an L1
+equivalent hardfork. Since opstack sticks to the L1 header primitive, a new L1 equivalent hardfork also requires new
+equivalent consensus checks. For this reason these `OpHardfork` must be mapped to L1 `EthereumHardfork`, for example:
+`OpHardfork::Isthmus` corresponds to `EthereumHardfork::Prague`. These mappings must be defined in the `ChainSpec`.

LICENSE-APACHE

@@ -186,7 +186,7 @@ APPENDIX: How to apply the Apache License to your work.
    same "printed page" as the copyright notice for easier
    identification within third-party archives.
 
-Copyright 2022-2026 Reth Contributors
+Copyright 2022-2025 Reth Contributors
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

LICENSE-MIT

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2022-2026 Reth Contributors
+Copyright (c) 2022-2025 Reth Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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
@@ -50,6 +53,13 @@ install: ## Build and install the reth binary under `$(CARGO_HOME)/bin`.
 		--profile "$(PROFILE)" \
 		$(CARGO_INSTALL_EXTRA_FLAGS)
 
+.PHONY: install-op
+install-op: ## Build and install the op-reth binary under `$(CARGO_HOME)/bin`.
+	cargo install --path crates/optimism/bin --bin op-reth --force --locked \
+		--features "$(FEATURES)" \
+		--profile "$(PROFILE)" \
+		$(CARGO_INSTALL_EXTRA_FLAGS)
+
 .PHONY: build
 build: ## Build the reth binary into `target` directory.
 	cargo build --bin reth --features "$(FEATURES)" --profile "$(PROFILE)"
@@ -77,10 +87,21 @@ build-%-reproducible:
 .PHONY: build-debug
 build-debug: ## Build the reth binary into `target/debug` directory.
 	cargo build --bin reth --features "$(FEATURES)"
+.PHONY: build-debug-op
+build-debug-op: ## Build the op-reth binary into `target/debug` directory.
+	cargo build --bin op-reth --features "$(FEATURES)" --manifest-path crates/optimism/bin/Cargo.toml
+
+.PHONY: build-op
+build-op: ## Build the op-reth binary into `target` directory.
+	cargo build --bin op-reth --features "$(FEATURES)" --profile "$(PROFILE)" --manifest-path crates/optimism/bin/Cargo.toml
+
 # Builds the reth binary natively.
 build-native-%:
 	cargo build --bin reth --target $* --features "$(FEATURES)" --profile "$(PROFILE)"
 
+op-build-native-%:
+	cargo build --bin op-reth --target $* --features "$(FEATURES)" --profile "$(PROFILE)" --manifest-path crates/optimism/bin/Cargo.toml
+
 # The following commands use `cross` to build a cross-compile.
 #
 # These commands require that:
@@ -97,6 +118,11 @@ build-native-%:
 # on other systems. JEMALLOC_SYS_WITH_LG_PAGE=16 tells jemalloc to use 64-KiB
 # pages. See: https://github.com/paradigmxyz/reth/issues/6742
 build-aarch64-unknown-linux-gnu: export JEMALLOC_SYS_WITH_LG_PAGE=16
+op-build-aarch64-unknown-linux-gnu: export JEMALLOC_SYS_WITH_LG_PAGE=16
+
+# No jemalloc on Windows
+build-x86_64-pc-windows-gnu: FEATURES := $(filter-out jemalloc jemalloc-prof,$(FEATURES))
+op-build-x86_64-pc-windows-gnu: FEATURES := $(filter-out jemalloc jemalloc-prof,$(FEATURES))
 
 # Note: The additional rustc compiler flags are for intrinsics needed by MDBX.
 # See: https://github.com/cross-rs/cross/wiki/FAQ#undefined-reference-with-build-std
@@ -104,6 +130,10 @@ build-%:
 	RUSTFLAGS="-C link-arg=-lgcc -Clink-arg=-static-libgcc" \
 		cross build --bin reth --target $* --features "$(FEATURES)" --profile "$(PROFILE)"
 
+op-build-%:
+	RUSTFLAGS="-C link-arg=-lgcc -Clink-arg=-static-libgcc" \
+		cross build --bin op-reth --target $* --features "$(FEATURES)" --profile "$(PROFILE)" --manifest-path crates/optimism/bin/Cargo.toml
+
 # Unfortunately we can't easily use cross to build for Darwin because of licensing issues.
 # If we wanted to, we would need to build a custom Docker image with the SDK available.
 #
@@ -114,6 +144,11 @@ build-x86_64-apple-darwin:
 	$(MAKE) build-native-x86_64-apple-darwin
 build-aarch64-apple-darwin:
 	$(MAKE) build-native-aarch64-apple-darwin
+op-build-x86_64-apple-darwin:
+	$(MAKE) op-build-native-x86_64-apple-darwin
+op-build-aarch64-apple-darwin:
+	$(MAKE) op-build-native-aarch64-apple-darwin
+
 build-deb-%:
 	@case "$*" in \
 		x86_64-unknown-linux-gnu|aarch64-unknown-linux-gnu|riscv64gc-unknown-linux-gnu) \
@@ -149,6 +184,8 @@ build-release-tarballs: ## Create a series of `.tar.gz` files in the BIN_DIR dir
 	$(call tarball_release_binary,"x86_64-unknown-linux-gnu","reth","")
 	$(MAKE) build-aarch64-unknown-linux-gnu
 	$(call tarball_release_binary,"aarch64-unknown-linux-gnu","reth","")
+	$(MAKE) build-x86_64-pc-windows-gnu
+	$(call tarball_release_binary,"x86_64-pc-windows-gnu","reth.exe","")
 
 ##@ Test
 
@@ -205,6 +242,127 @@ 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)
+
+# Create a cross-arch Docker image with the given tags and push it
+define docker_build_push
+	$(MAKE) build-x86_64-unknown-linux-gnu
+	mkdir -p $(BIN_DIR)/amd64
+	cp $(CARGO_TARGET_DIR)/x86_64-unknown-linux-gnu/$(PROFILE)/reth $(BIN_DIR)/amd64/reth
+
+	$(MAKE) 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)
+
+# 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) 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) 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
@@ -232,18 +390,26 @@ db-tools: ## Compile MDBX debugging tools.
 	@echo "Run \"$(DB_TOOLS_DIR)/mdbx_chk\" for the MDBX db file integrity check."
 
 .PHONY: update-book-cli
-update-book-cli: build-debug ## Update book cli documentation.
+update-book-cli: build-debug build-debug-op## Update book cli documentation.
 	@echo "Updating book cli doc..."
-	@./docs/cli/update.sh $(CARGO_TARGET_DIR)/debug/reth
+	@./docs/cli/update.sh $(CARGO_TARGET_DIR)/debug/reth $(CARGO_TARGET_DIR)/debug/op-reth
 
 .PHONY: profiling
 profiling: ## Builds `reth` with optimisations, but also symbols.
 	RUSTFLAGS="-C target-cpu=native" cargo build --profile profiling --features jemalloc,asm-keccak
 
+.PHONY: profiling-op
+profiling-op: ## Builds `op-reth` with optimisations, but also symbols.
+	RUSTFLAGS="-C target-cpu=native" cargo build --profile profiling --features jemalloc,asm-keccak --bin op-reth --manifest-path crates/optimism/bin/Cargo.toml
+
 .PHONY: maxperf
 maxperf: ## Builds `reth` with the most aggressive optimisations.
 	RUSTFLAGS="-C target-cpu=native" cargo build --profile maxperf --features jemalloc,asm-keccak
 
+.PHONY: maxperf-op
+maxperf-op: ## Builds `op-reth` with the most aggressive optimisations.
+	RUSTFLAGS="-C target-cpu=native" cargo build --profile maxperf --features jemalloc,asm-keccak --bin op-reth --manifest-path crates/optimism/bin/Cargo.toml
+
 .PHONY: maxperf-no-asm
 maxperf-no-asm: ## Builds `reth` with the most aggressive optimisations, minus the "asm-keccak" feature.
 	RUSTFLAGS="-C target-cpu=native" cargo build --profile maxperf --features jemalloc
@@ -262,6 +428,17 @@ clippy:
 	--all-features \
 	-- -D warnings
 
+clippy-op-dev:
+	cargo +nightly clippy \
+	--bin op-reth \
+	--workspace \
+	--lib \
+	--examples \
+	--tests \
+	--benches \
+	--locked \
+	--all-features
+
 lint-typos: ensure-typos
 	typos
 
@@ -326,6 +503,7 @@ rustdocs: ## Runs `cargo docs` to generate the Rust documents in the `target/doc
 cargo-test:
 	cargo test \
 	--workspace \
+	--bin "op-reth" \
 	--lib --examples \
 	--tests \
 	--benches \

README.md

@@ -18,11 +18,6 @@
 [gh-lint]: https://github.com/paradigmxyz/reth/actions/workflows/lint.yml
 [tg-badge]: https://img.shields.io/endpoint?color=neon&logo=telegram&label=chat&url=https%3A%2F%2Ftg.sumanjay.workers.dev%2Fparadigm%5Freth
 
-> **Note: OP-Reth has moved**
->
-> The Optimism (op-reth) crates have been moved to [ethereum-optimism/optimism](https://github.com/ethereum-optimism/optimism).
-> Git contribution history has been preserved. If you are looking for op-reth, please see the new repository.
-
 ## What is Reth?
 
 Reth (short for Rust Ethereum, [pronunciation](https://x.com/kelvinfichter/status/1597653609411268608)) is a new Ethereum full node implementation that is focused on being user-friendly, highly modular, as well as being fast and efficient. Reth is an Execution Layer (EL) and is compatible with all Ethereum Consensus Layer (CL) implementations that support the [Engine API](https://github.com/ethereum/execution-apis/tree/a0d03086564ab1838b462befbc083f873dcf0c0f/src/engine). It is originally built and driven forward by [Paradigm](https://paradigm.xyz/), and is licensed under the Apache and MIT licenses.
@@ -37,7 +32,7 @@ More concretely, our goals are:
 2. **Performance**: Reth aims to be fast, so we use Rust and the [Erigon staged-sync](https://erigon.substack.com/p/erigon-stage-sync-and-control-flows) node architecture. We also use our Ethereum libraries (including [Alloy](https://github.com/alloy-rs/alloy/) and [revm](https://github.com/bluealloy/revm/)) which we've battle-tested and optimized via [Foundry](https://github.com/foundry-rs/foundry/).
 3. **Free for anyone to use any way they want**: Reth is free open source software, built for the community, by the community. By licensing the software under the Apache/MIT license, we want developers to use it without being bound by business licenses, or having to think about the implications of GPL-like licenses.
 4. **Client Diversity**: The Ethereum protocol becomes more antifragile when no node implementation dominates. This ensures that if there's a software bug, the network does not finalize a bad block. By building a new client, we hope to contribute to Ethereum's antifragility.
-5. **Support as many EVM chains as possible**: We aspire that Reth can full-sync not only Ethereum, but also other chains like Optimism, Polygon, BNB Smart Chain, and more. If you're working on any of these projects, please reach out. Note: OP-Reth has moved to [ethereum-optimism/optimism](https://github.com/ethereum-optimism/optimism).
+5. **Support as many EVM chains as possible**: We aspire that Reth can full-sync not only Ethereum, but also other chains like Optimism, Polygon, BNB Smart Chain, and more. If you're working on any of these projects, please reach out.
 6. **Configurability**: We want to solve for node operators that care about fast historical queries, but also for hobbyists who cannot operate on large hardware. We also want to support teams and individuals who want both sync from genesis and via "fast sync". We envision that Reth will be configurable enough and provide configurable "profiles" for the tradeoffs that each team faces.
 
 ## Status
@@ -46,13 +41,13 @@ Reth is production ready, and suitable for usage in mission-critical environment
 
 More historical context below:
 
-- We released 1.0 "production-ready" stable Reth in June 2024.
-  - Reth completed an audit with [Sigma Prime](https://sigmaprime.io/), the developers of [Lighthouse](https://github.com/sigp/lighthouse), the Rust Consensus Layer implementation. Find it [here](./audit/sigma_prime_audit_v2.pdf).
-  - Revm (the EVM used in Reth) underwent an audit with [Guido Vranken](https://x.com/guidovranken) (#1 [Ethereum Bug Bounty](https://ethereum.org/en/bug-bounty)). We will publish the results soon.
-- We released multiple iterative beta versions, up to [beta.9](https://github.com/paradigmxyz/reth/releases/tag/v0.2.0-beta.9) on Monday June 3, 2024, the last beta release.
-- We released [beta](https://github.com/paradigmxyz/reth/releases/tag/v0.2.0-beta.1) on Monday March 4, 2024, our first breaking change to the database model, providing faster query speed, smaller database footprint, and allowing "history" to be mounted on separate drives.
-- We shipped iterative improvements until the last alpha release on February 28, 2024, [0.1.0-alpha.21](https://github.com/paradigmxyz/reth/releases/tag/v0.1.0-alpha.21).
-- We [initially announced](https://www.paradigm.xyz/2023/06/reth-alpha) [0.1.0-alpha.1](https://github.com/paradigmxyz/reth/releases/tag/v0.1.0-alpha.1) on June 20, 2023.
+-   We released 1.0 "production-ready" stable Reth in June 2024.
+    -   Reth completed an audit with [Sigma Prime](https://sigmaprime.io/), the developers of [Lighthouse](https://github.com/sigp/lighthouse), the Rust Consensus Layer implementation. Find it [here](./audit/sigma_prime_audit_v2.pdf).
+    -   Revm (the EVM used in Reth) underwent an audit with [Guido Vranken](https://x.com/guidovranken) (#1 [Ethereum Bug Bounty](https://ethereum.org/en/bug-bounty)). We will publish the results soon.
+-   We released multiple iterative beta versions, up to [beta.9](https://github.com/paradigmxyz/reth/releases/tag/v0.2.0-beta.9) on Monday June 3, 2024,the last beta release.
+-   We released [beta](https://github.com/paradigmxyz/reth/releases/tag/v0.2.0-beta.1) on Monday March 4, 2024, our first breaking change to the database model, providing faster query speed, smaller database footprint, and allowing "history" to be mounted on separate drives.
+-   We shipped iterative improvements until the last alpha release on February 28, 2024, [0.1.0-alpha.21](https://github.com/paradigmxyz/reth/releases/tag/v0.1.0-alpha.21).
+-   We [initially announced](https://www.paradigm.xyz/2023/06/reth-alpha) [0.1.0-alpha.1](https://github.com/paradigmxyz/reth/releases/tag/v0.1.0-alpha.1) on June 20, 2023.
 
 ### Database compatibility
 
@@ -82,8 +77,8 @@ For a general overview of the crates, see [Project Layout](./docs/repo/layout.md
 
 If you want to contribute, or follow along with contributor discussion, you can use our [main telegram](https://t.me/paradigm_reth) to chat with us about the development of Reth!
 
-- Our contributor guidelines can be found in [`CONTRIBUTING.md`](./CONTRIBUTING.md).
-- See our [contributor docs](./docs) for more information on the project. A good starting point is [Project Layout](./docs/repo/layout.md).
+-   Our contributor guidelines can be found in [`CONTRIBUTING.md`](./CONTRIBUTING.md).
+-   See our [contributor docs](./docs) for more information on the project. A good starting point is [Project Layout](./docs/repo/layout.md).
 
 ### Building and testing
 
@@ -128,9 +123,9 @@ If you have any questions, first see if the answer to your question can be found
 
 If the answer is not there:
 
-- Join the [Telegram][tg-url] to get help, or
-- Open a [discussion](https://github.com/paradigmxyz/reth/discussions/new) with your question, or
-- Open an issue with [the bug](https://github.com/paradigmxyz/reth/issues/new?assignees=&labels=C-bug%2CS-needs-triage&projects=&template=bug.yml)
+-   Join the [Telegram][tg-url] to get help, or
+-   Open a [discussion](https://github.com/paradigmxyz/reth/discussions/new) with your question, or
+-   Open an issue with [the bug](https://github.com/paradigmxyz/reth/issues/new?assignees=&labels=C-bug%2CS-needs-triage&projects=&template=bug.yml)
 
 ## Security
 
@@ -142,9 +137,9 @@ Reth is a new implementation of the Ethereum protocol. In the process of develop
 
 None of this would have been possible without them, so big shoutout to the teams below:
 
-- [Geth](https://github.com/ethereum/go-ethereum/): We would like to express our heartfelt gratitude to the go-ethereum team for their outstanding contributions to Ethereum over the years. Their tireless efforts and dedication have helped to shape the Ethereum ecosystem and make it the vibrant and innovative community it is today. Thank you for your hard work and commitment to the project.
-- [Erigon](https://github.com/ledgerwatch/erigon) (fka Turbo-Geth): Erigon pioneered the ["Staged Sync" architecture](https://erigon.substack.com/p/erigon-stage-sync-and-control-flows) that Reth is using, as well as [introduced MDBX](https://github.com/ledgerwatch/erigon/wiki/Choice-of-storage-engine) as the database of choice. We thank Erigon for pushing the state of the art research on the performance limits of Ethereum nodes.
-- [Akula](https://github.com/akula-bft/akula/): Reth uses forks of the Apache versions of Akula's [MDBX Bindings](https://github.com/paradigmxyz/reth/pull/132), [FastRLP](https://github.com/paradigmxyz/reth/pull/63) and [ECIES](https://github.com/paradigmxyz/reth/pull/80). Given that these packages were already released under the Apache License, and they implement standardized solutions, we decided not to reimplement them to iterate faster. We thank the Akula team for their contributions to the Rust Ethereum ecosystem and for publishing these packages.
+-   [Geth](https://github.com/ethereum/go-ethereum/): We would like to express our heartfelt gratitude to the go-ethereum team for their outstanding contributions to Ethereum over the years. Their tireless efforts and dedication have helped to shape the Ethereum ecosystem and make it the vibrant and innovative community it is today. Thank you for your hard work and commitment to the project.
+-   [Erigon](https://github.com/ledgerwatch/erigon) (fka Turbo-Geth): Erigon pioneered the ["Staged Sync" architecture](https://erigon.substack.com/p/erigon-stage-sync-and-control-flows) that Reth is using, as well as [introduced MDBX](https://github.com/ledgerwatch/erigon/wiki/Choice-of-storage-engine) as the database of choice. We thank Erigon for pushing the state of the art research on the performance limits of Ethereum nodes.
+-   [Akula](https://github.com/akula-bft/akula/): Reth uses forks of the Apache versions of Akula's [MDBX Bindings](https://github.com/paradigmxyz/reth/pull/132), [FastRLP](https://github.com/paradigmxyz/reth/pull/63) and [ECIES](https://github.com/paradigmxyz/reth/pull/80). Given that these packages were already released under the Apache License, and they implement standardized solutions, we decided not to reimplement them to iterate faster. We thank the Akula team for their contributions to the Rust Ethereum ecosystem and for publishing these packages.
 
 ## Warning
 

bin/reth-bench-compare/Cargo.toml

@@ -25,9 +25,7 @@ reth-chainspec.workspace = true
 
 # alloy
 alloy-provider = { workspace = true, features = ["reqwest-rustls-tls"], default-features = false }
-alloy-rpc-client = { workspace = true, features = ["pubsub"] }
 alloy-rpc-types-eth.workspace = true
-alloy-transport-ws.workspace = true
 alloy-primitives.workspace = true
 
 # CLI and argument parsing
@@ -56,7 +54,7 @@ ctrlc.workspace = true
 shlex.workspace = true
 
 [target.'cfg(unix)'.dependencies]
-nix = { version = "0.31", features = ["signal", "process"] }
+nix = { version = "0.29", features = ["signal", "process"] }
 
 [features]
 default = ["jemalloc"]
@@ -71,11 +69,7 @@ jemalloc = [
     "reth-node-core/jemalloc",
 ]
 jemalloc-prof = ["reth-cli-util/jemalloc-prof"]
-tracy-allocator = ["reth-cli-util/tracy-allocator", "tracy"]
-tracy = [
-    "reth-node-core/tracy",
-    "reth-tracing/tracy",
-]
+tracy-allocator = ["reth-cli-util/tracy-allocator"]
 
 min-error-logs = [
     "tracing/release_max_level_error",
@@ -98,5 +92,5 @@ min-trace-logs = [
     "reth-node-core/min-trace-logs",
 ]
 
-# no-op feature flag for CI matrices
+# no-op feature flag for switching between the `optimism` and default functionality in CI matrices
 ethereum = []

bin/reth-bench-compare/README.md

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

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

@@ -18,8 +18,6 @@ pub(crate) struct BenchmarkRunner {
     rpc_url: String,
     jwt_secret: String,
     wait_time: Option<String>,
-    wait_for_persistence: bool,
-    persistence_threshold: Option<u64>,
     warmup_blocks: u64,
 }
 
@@ -30,8 +28,6 @@ impl BenchmarkRunner {
             rpc_url: args.get_rpc_url(),
             jwt_secret: args.jwt_secret_path().to_string_lossy().to_string(),
             wait_time: args.wait_time.clone(),
-            wait_for_persistence: args.wait_for_persistence,
-            persistence_threshold: args.persistence_threshold,
             warmup_blocks: args.get_warmup_blocks(),
         }
     }
@@ -100,9 +96,13 @@ impl BenchmarkRunner {
             &from_block.to_string(),
             "--to",
             &to_block.to_string(),
-            "--wait-time=0ms", // Warmup should avoid persistence waits.
         ]);
 
+        // Add wait-time argument if provided
+        if let Some(ref wait_time) = self.wait_time {
+            cmd.args(["--wait-time", wait_time]);
+        }
+
         cmd.env("RUST_LOG_STYLE", "never")
             .stdout(std::process::Stdio::piped())
             .stderr(std::process::Stdio::piped())
@@ -186,19 +186,10 @@ impl BenchmarkRunner {
             &output_dir.to_string_lossy(),
         ]);
 
-        // Configure wait mode: both can be used together
-        // When both are set: wait at least wait_time, and also wait for persistence if needed
+        // Add wait-time argument if provided
         if let Some(ref wait_time) = self.wait_time {
             cmd.args(["--wait-time", wait_time]);
         }
-        if self.wait_for_persistence {
-            cmd.arg("--wait-for-persistence");
-
-            // Add persistence threshold if specified
-            if let Some(threshold) = self.persistence_threshold {
-                cmd.args(["--persistence-threshold", &threshold.to_string()]);
-            }
-        }
 
         cmd.env("RUST_LOG_STYLE", "never")
             .stdout(std::process::Stdio::piped())

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

@@ -114,32 +114,10 @@ pub(crate) struct Args {
     #[arg(long)]
     pub profile: bool,
 
-    /// Optional fixed delay between engine API calls (passed to reth-bench).
-    ///
-    /// Can be combined with `--wait-for-persistence`: when both are set,
-    /// waits at least this duration, and also waits for persistence if needed.
+    /// Wait time between engine API calls (passed to reth-bench)
     #[arg(long, value_name = "DURATION")]
     pub wait_time: Option<String>,
 
-    /// Wait for blocks to be persisted before sending the next batch (passed to reth-bench).
-    ///
-    /// When enabled, waits for every Nth block to be persisted using the
-    /// `reth_subscribePersistedBlock` subscription. This ensures the benchmark
-    /// doesn't outpace persistence.
-    ///
-    /// Can be combined with `--wait-time`: when both are set, waits at least
-    /// wait-time, and also waits for persistence if the block hasn't been persisted yet.
-    #[arg(long)]
-    pub wait_for_persistence: bool,
-
-    /// Engine persistence threshold (passed to reth-bench).
-    ///
-    /// The benchmark waits after every `(threshold + 1)` blocks. By default this
-    /// matches the engine's default persistence threshold (2), so waits occur
-    /// at blocks 3, 6, 9, etc.
-    #[arg(long, value_name = "PERSISTENCE_THRESHOLD")]
-    pub persistence_threshold: Option<u64>,
-
     /// Number of blocks to run for cache warmup after clearing caches.
     /// If not specified, defaults to the same as --blocks
     #[arg(long, value_name = "N")]
@@ -150,11 +128,6 @@ pub(crate) struct Args {
     #[arg(long)]
     pub no_clear_cache: bool,
 
-    /// Skip waiting for the node to sync before starting benchmarks.
-    /// When enabled, assumes the node is already synced and skips the initial tip check.
-    #[arg(long)]
-    pub skip_wait_syncing: bool,
-
     #[command(flatten)]
     pub logs: LogArgs,
 
@@ -191,42 +164,12 @@ pub(crate) struct Args {
     #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
     pub reth_args: Vec<String>,
 
-    /// Comma-separated list of features to enable during reth compilation (applied to both builds)
+    /// Comma-separated list of features to enable during reth compilation
     ///
     /// Example: `jemalloc,asm-keccak`
     #[arg(long, value_name = "FEATURES", default_value = "jemalloc,asm-keccak")]
     pub features: String,
 
-    /// Comma-separated list of features to enable only for baseline build (overrides --features)
-    ///
-    /// Example: `--baseline-features jemalloc`
-    #[arg(long, value_name = "FEATURES")]
-    pub baseline_features: Option<String>,
-
-    /// Comma-separated list of features to enable only for feature build (overrides --features)
-    ///
-    /// Example: `--feature-features jemalloc,asm-keccak`
-    #[arg(long, value_name = "FEATURES")]
-    pub feature_features: Option<String>,
-
-    /// RUSTFLAGS to use for both baseline and feature builds
-    ///
-    /// Example: `--rustflags "-C target-cpu=native"`
-    #[arg(long, value_name = "FLAGS", default_value = "-C target-cpu=native")]
-    pub rustflags: String,
-
-    /// RUSTFLAGS to use only for baseline build (overrides --rustflags)
-    ///
-    /// Example: `--baseline-rustflags "-C target-cpu=native -C lto"`
-    #[arg(long, value_name = "FLAGS")]
-    pub baseline_rustflags: Option<String>,
-
-    /// RUSTFLAGS to use only for feature build (overrides --rustflags)
-    ///
-    /// Example: `--feature-rustflags "-C target-cpu=native -C lto"`
-    #[arg(long, value_name = "FLAGS")]
-    pub feature_rustflags: Option<String>,
-
     /// Disable automatic --debug.startup-sync-state-idle flag for specific runs.
     /// Can be "baseline", "feature", or "all".
     /// By default, the flag is passed to warmup, baseline, and feature runs.
@@ -277,10 +220,10 @@ impl Args {
     /// Get the default RPC URL for a given chain
     const fn get_default_rpc_url(chain: &Chain) -> &'static str {
         match chain.id() {
-            8453 => "https://base.reth.rs/rpc",             // base
+            8453 => "https://base-mainnet.rpc.ithaca.xyz",  // base
             84532 => "https://base-sepolia.rpc.ithaca.xyz", // base-sepolia
             27082 => "https://rpc.hoodi.ethpandaops.io",    // hoodi
-            _ => "https://ethereum.reth.rs/rpc",            // mainnet and fallback
+            _ => "https://reth-ethereum.ithaca.xyz/rpc",    // mainnet and fallback
         }
     }
 
@@ -385,6 +328,7 @@ pub(crate) async fn run_comparison(args: Args, _ctx: CliContext) -> Result<()> {
         git_manager.repo_root().to_string(),
         output_dir.clone(),
         git_manager.clone(),
+        args.features.clone(),
     )?;
     // Initialize node manager
     let mut node_manager = NodeManager::new(&args);
@@ -474,6 +418,7 @@ async fn run_compilation_phase(
     git_manager: &GitManager,
     compilation_manager: &CompilationManager,
     args: &Args,
+    is_optimism: bool,
 ) -> Result<(String, String)> {
     info!("=== Running compilation phase ===");
 
@@ -503,18 +448,6 @@ async fn run_compilation_phase(
         let ref_type = ref_types[i];
         let commit = &ref_commits[git_ref];
 
-        // Get per-build features and rustflags
-        let features = match ref_type {
-            "baseline" => args.baseline_features.as_ref().unwrap_or(&args.features),
-            "feature" => args.feature_features.as_ref().unwrap_or(&args.features),
-            _ => &args.features,
-        };
-        let rustflags = match ref_type {
-            "baseline" => args.baseline_rustflags.as_ref().unwrap_or(&args.rustflags),
-            "feature" => args.feature_rustflags.as_ref().unwrap_or(&args.rustflags),
-            _ => &args.rustflags,
-        };
-
         info!(
             "Compiling {} binary for reference: {} (commit: {})",
             ref_type,
@@ -526,7 +459,7 @@ async fn run_compilation_phase(
         git_manager.switch_ref(git_ref)?;
 
         // Compile reth (with caching)
-        compilation_manager.compile_reth(commit, features, rustflags)?;
+        compilation_manager.compile_reth(commit, is_optimism)?;
 
         info!("Completed compilation for {} reference", ref_type);
     }
@@ -538,7 +471,6 @@ async fn run_compilation_phase(
     Ok((baseline_commit, feature_commit))
 }
 
-#[allow(clippy::too_many_arguments)]
 /// Run warmup phase to warm up caches before benchmarking
 async fn run_warmup_phase(
     git_manager: &GitManager,
@@ -546,16 +478,11 @@ async fn run_warmup_phase(
     node_manager: &mut NodeManager,
     benchmark_runner: &BenchmarkRunner,
     args: &Args,
+    is_optimism: bool,
     baseline_commit: &str,
-    starting_tip: u64,
 ) -> Result<()> {
     info!("=== Running warmup phase ===");
 
-    // Unwind to starting block minus warmup blocks, so we end up back at starting_tip
-    let warmup_blocks = args.get_warmup_blocks();
-    let unwind_target = starting_tip.saturating_sub(warmup_blocks);
-    node_manager.unwind_to_block(unwind_target).await?;
-
     // Use baseline for warmup
     let warmup_ref = &args.baseline_ref;
 
@@ -563,7 +490,8 @@ async fn run_warmup_phase(
     git_manager.switch_ref(warmup_ref)?;
 
     // Get the cached binary path for baseline (should already be compiled)
-    let binary_path = compilation_manager.get_cached_binary_path_for_commit(baseline_commit);
+    let binary_path =
+        compilation_manager.get_cached_binary_path_for_commit(baseline_commit, is_optimism);
 
     // Verify the cached binary exists
     if !binary_path.exists() {
@@ -583,13 +511,12 @@ async fn run_warmup_phase(
         node_manager.start_node(&binary_path, warmup_ref, "warmup", &additional_args).await?;
 
     // Wait for node to be ready and get its current tip
-    let current_tip = if args.skip_wait_syncing {
-        node_manager.wait_for_rpc_and_get_tip(&mut node_process).await?
-    } else {
-        node_manager.wait_for_node_ready_and_get_tip(&mut node_process).await?
-    };
+    let current_tip = node_manager.wait_for_node_ready_and_get_tip().await?;
     info!("Warmup node is ready at tip: {}", current_tip);
 
+    // Store the tip we'll unwind back to
+    let original_tip = current_tip;
+
     // Clear filesystem caches before warmup run only (unless disabled)
     if args.no_clear_cache {
         info!("Skipping filesystem cache clearing (--no-clear-cache flag set)");
@@ -600,9 +527,12 @@ async fn run_warmup_phase(
     // Run warmup to warm up caches
     benchmark_runner.run_warmup(current_tip).await?;
 
-    // Stop node after warmup
+    // Stop node before unwinding (node must be stopped to release database lock)
     node_manager.stop_node(&mut node_process).await?;
 
+    // Unwind back to starting block after warmup
+    node_manager.unwind_to_block(original_tip).await?;
+
     info!("Warmup phase completed");
     Ok(())
 }
@@ -616,33 +546,13 @@ async fn run_benchmark_workflow(
     comparison_generator: &mut ComparisonGenerator,
     args: &Args,
 ) -> Result<()> {
+    // Detect if this is an Optimism chain once at the beginning
+    let rpc_url = args.get_rpc_url();
+    let is_optimism = compilation_manager.detect_optimism_chain(&rpc_url).await?;
+
     // Run compilation phase for both binaries
     let (baseline_commit, feature_commit) =
-        run_compilation_phase(git_manager, compilation_manager, args).await?;
-
-    // Switch to baseline reference and get the starting tip
-    git_manager.switch_ref(&args.baseline_ref)?;
-    let binary_path = compilation_manager.get_cached_binary_path_for_commit(&baseline_commit);
-    if !binary_path.exists() {
-        return Err(eyre!(
-            "Cached baseline binary not found at {:?}. Compilation phase should have created it.",
-            binary_path
-        ));
-    }
-
-    // Start node briefly to get the current tip, then stop it
-    info!("=== Determining initial block height ===");
-    let additional_args = args.build_additional_args("baseline", args.baseline_args.as_ref());
-    let (mut node_process, _) = node_manager
-        .start_node(&binary_path, &args.baseline_ref, "baseline", &additional_args)
-        .await?;
-    let starting_tip = if args.skip_wait_syncing {
-        node_manager.wait_for_rpc_and_get_tip(&mut node_process).await?
-    } else {
-        node_manager.wait_for_node_ready_and_get_tip(&mut node_process).await?
-    };
-    info!("Node starting tip: {}", starting_tip);
-    node_manager.stop_node(&mut node_process).await?;
+        run_compilation_phase(git_manager, compilation_manager, args, is_optimism).await?;
 
     // Run warmup phase before benchmarking (skip if warmup_blocks is 0)
     if args.get_warmup_blocks() > 0 {
@@ -652,8 +562,8 @@ async fn run_benchmark_workflow(
             node_manager,
             benchmark_runner,
             args,
+            is_optimism,
             &baseline_commit,
-            starting_tip,
         )
         .await?;
     } else {
@@ -669,15 +579,12 @@ async fn run_benchmark_workflow(
         let commit = commits[i];
         info!("=== Processing {} reference: {} ===", ref_type, git_ref);
 
-        // Unwind to starting block minus benchmark blocks, so we end up back at starting_tip
-        let unwind_target = starting_tip.saturating_sub(args.blocks);
-        node_manager.unwind_to_block(unwind_target).await?;
-
         // Switch to target reference
         git_manager.switch_ref(git_ref)?;
 
         // Get the cached binary path for this git reference (should already be compiled)
-        let binary_path = compilation_manager.get_cached_binary_path_for_commit(commit);
+        let binary_path =
+            compilation_manager.get_cached_binary_path_for_commit(commit, is_optimism);
 
         // Verify the cached binary exists
         if !binary_path.exists() {
@@ -705,18 +612,17 @@ async fn run_benchmark_workflow(
             node_manager.start_node(&binary_path, git_ref, ref_type, &additional_args).await?;
 
         // Wait for node to be ready and get its current tip (wherever it is)
-        let current_tip = if args.skip_wait_syncing {
-            node_manager.wait_for_rpc_and_get_tip(&mut node_process).await?
-        } else {
-            node_manager.wait_for_node_ready_and_get_tip(&mut node_process).await?
-        };
+        let current_tip = node_manager.wait_for_node_ready_and_get_tip().await?;
         info!("Node is ready at tip: {}", current_tip);
 
+        // Store the tip we'll unwind back to
+        let original_tip = current_tip;
+
         // Calculate benchmark range
         // Note: reth-bench has an off-by-one error where it consumes the first block
         // of the range, so we add 1 to compensate and get exactly args.blocks blocks
-        let from_block = current_tip;
-        let to_block = current_tip + args.blocks;
+        let from_block = original_tip;
+        let to_block = original_tip + args.blocks;
 
         // Run benchmark
         let output_dir = comparison_generator.get_ref_output_dir(ref_type);
@@ -733,6 +639,9 @@ async fn run_benchmark_workflow(
         // Stop node
         node_manager.stop_node(&mut node_process).await?;
 
+        // Unwind back to original tip
+        node_manager.unwind_to_block(original_tip).await?;
+
         // Store results for comparison
         comparison_generator.add_ref_results(ref_type, &output_dir)?;
 

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

@@ -39,8 +39,7 @@ pub(crate) struct BenchmarkResults {
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub(crate) struct CombinedLatencyRow {
     pub block_number: u64,
-    #[serde(default)]
-    pub transaction_count: Option<u64>,
+    pub transaction_count: u64,
     pub gas_used: u64,
     pub new_payload_latency: u128,
 }
@@ -49,8 +48,7 @@ pub(crate) struct CombinedLatencyRow {
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub(crate) struct TotalGasRow {
     pub block_number: u64,
-    #[serde(default)]
-    pub transaction_count: Option<u64>,
+    pub transaction_count: u64,
     pub gas_used: u64,
     pub time: u128,
 }
@@ -99,7 +97,6 @@ pub(crate) struct RefInfo {
 /// Summary of the comparison between references.
 ///
 /// Percent deltas are `(feature - baseline) / baseline * 100`:
-/// - `new_payload_latency_mean_change_percent`: percent changes of the per-block means.
 /// - `new_payload_latency_p50_change_percent` / p90 / p99: percent changes of the respective
 ///   per-block percentiles.
 /// - `per_block_latency_change_mean_percent` / `per_block_latency_change_median_percent` are the
@@ -117,7 +114,6 @@ pub(crate) struct ComparisonSummary {
     pub per_block_latency_change_median_percent: f64,
     pub per_block_latency_change_std_dev_percent: f64,
     pub new_payload_total_latency_change_percent: f64,
-    pub new_payload_latency_mean_change_percent: f64,
     pub new_payload_latency_p50_change_percent: f64,
     pub new_payload_latency_p90_change_percent: f64,
     pub new_payload_latency_p99_change_percent: f64,
@@ -129,8 +125,7 @@ pub(crate) struct ComparisonSummary {
 #[derive(Debug, Serialize)]
 pub(crate) struct BlockComparison {
     pub block_number: u64,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub transaction_count: Option<u64>,
+    pub transaction_count: u64,
     pub gas_used: u64,
     pub baseline_new_payload_latency: u128,
     pub feature_new_payload_latency: u128,
@@ -447,10 +442,6 @@ impl ComparisonGenerator {
             per_block_latency_change_median_percent,
             per_block_latency_change_std_dev_percent,
             new_payload_total_latency_change_percent,
-            new_payload_latency_mean_change_percent: calc_percent_change(
-                baseline.mean_new_payload_latency_ms,
-                feature.mean_new_payload_latency_ms,
-            ),
             new_payload_latency_p50_change_percent: calc_percent_change(
                 baseline.median_new_payload_latency_ms,
                 feature.median_new_payload_latency_ms,
@@ -581,10 +572,6 @@ impl ComparisonGenerator {
             "  Total newPayload time change:                {:+.2}%",
             summary.new_payload_total_latency_change_percent
         );
-        println!(
-            "  NewPayload Latency mean:           {:+.2}%",
-            summary.new_payload_latency_mean_change_percent
-        );
         println!(
             "  NewPayload Latency p50:           {:+.2}%",
             summary.new_payload_latency_p50_change_percent

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

@@ -1,6 +1,8 @@
 //! Compilation operations for reth and reth-bench.
 
 use crate::git::GitManager;
+use alloy_primitives::address;
+use alloy_provider::{Provider, ProviderBuilder};
 use eyre::{eyre, Result, WrapErr};
 use std::{fs, path::PathBuf, process::Command};
 use tracing::{debug, error, info, warn};
@@ -11,6 +13,7 @@ pub(crate) struct CompilationManager {
     repo_root: String,
     output_dir: PathBuf,
     git_manager: GitManager,
+    features: String,
 }
 
 impl CompilationManager {
@@ -19,18 +22,53 @@ impl CompilationManager {
         repo_root: String,
         output_dir: PathBuf,
         git_manager: GitManager,
+        features: String,
     ) -> Result<Self> {
-        Ok(Self { repo_root, output_dir, git_manager })
+        Ok(Self { repo_root, output_dir, git_manager, features })
+    }
+
+    /// Detect if the RPC endpoint is an Optimism chain
+    pub(crate) async fn detect_optimism_chain(&self, rpc_url: &str) -> Result<bool> {
+        info!("Detecting chain type from RPC endpoint...");
+
+        // Create Alloy provider
+        let url = rpc_url.parse().map_err(|e| eyre!("Invalid RPC URL '{}': {}", rpc_url, e))?;
+        let provider = ProviderBuilder::new().connect_http(url);
+
+        // Check for Optimism predeploy at address 0x420000000000000000000000000000000000000F
+        let is_optimism = !provider
+            .get_code_at(address!("0x420000000000000000000000000000000000000F"))
+            .await?
+            .is_empty();
+
+        if is_optimism {
+            info!("Detected Optimism chain");
+        } else {
+            info!("Detected Ethereum chain");
+        }
+
+        Ok(is_optimism)
     }
 
     /// Get the path to the cached binary using explicit commit hash
-    pub(crate) fn get_cached_binary_path_for_commit(&self, commit: &str) -> PathBuf {
+    pub(crate) fn get_cached_binary_path_for_commit(
+        &self,
+        commit: &str,
+        is_optimism: bool,
+    ) -> PathBuf {
         let identifier = &commit[..8]; // Use first 8 chars of commit
-        self.output_dir.join("bin").join(format!("reth_{identifier}"))
+
+        let binary_name = if is_optimism {
+            format!("op-reth_{}", identifier)
+        } else {
+            format!("reth_{}", identifier)
+        };
+
+        self.output_dir.join("bin").join(binary_name)
     }
 
     /// Compile reth using cargo build and cache the binary
-    pub(crate) fn compile_reth(&self, commit: &str, features: &str, rustflags: &str) -> Result<()> {
+    pub(crate) fn compile_reth(&self, commit: &str, is_optimism: bool) -> Result<()> {
         // Validate that current git commit matches the expected commit
         let current_commit = self.git_manager.get_current_commit()?;
         if current_commit != commit {
@@ -41,7 +79,7 @@ impl CompilationManager {
             ));
         }
 
-        let cached_path = self.get_cached_binary_path_for_commit(commit);
+        let cached_path = self.get_cached_binary_path_for_commit(commit, is_optimism);
 
         // Check if cached binary already exists (since path contains commit hash, it's valid)
         if cached_path.exists() {
@@ -51,7 +89,7 @@ impl CompilationManager {
 
         info!("No cached binary found, compiling (commit: {})...", &commit[..8]);
 
-        let binary_name = "reth";
+        let binary_name = if is_optimism { "op-reth" } else { "reth" };
 
         info!(
             "Compiling {} with profiling configuration (commit: {})...",
@@ -62,16 +100,25 @@ impl CompilationManager {
         let mut cmd = Command::new("cargo");
         cmd.arg("build").arg("--profile").arg("profiling");
 
-        cmd.arg("--features").arg(features);
-        info!("Using features: {features}");
+        // Add features
+        cmd.arg("--features").arg(&self.features);
+        info!("Using features: {}", self.features);
+
+        // Add bin-specific arguments for optimism
+        if is_optimism {
+            cmd.arg("--bin")
+                .arg("op-reth")
+                .arg("--manifest-path")
+                .arg("crates/optimism/bin/Cargo.toml");
+        }
 
         cmd.current_dir(&self.repo_root);
 
-        // Set RUSTFLAGS
-        cmd.env("RUSTFLAGS", rustflags);
-        info!("Using RUSTFLAGS: {rustflags}");
+        // Set RUSTFLAGS for native CPU optimization
+        cmd.env("RUSTFLAGS", "-C target-cpu=native");
 
-        info!("Compiling {binary_name} with {cmd:?}");
+        // Debug log the command
+        debug!("Executing cargo command: {:?}", cmd);
 
         let output = cmd.output().wrap_err("Failed to execute cargo build command")?;
 
@@ -180,7 +227,8 @@ impl CompilationManager {
         let mut cmd = Command::new("cargo");
         cmd.args(["install", "--locked", "samply"]);
 
-        info!("Installing samply with {cmd:?}");
+        // Debug log the command
+        debug!("Executing cargo command: {:?}", cmd);
 
         let output = cmd.output().wrap_err("Failed to execute cargo install samply command")?;
 
@@ -255,7 +303,8 @@ impl CompilationManager {
         let mut cmd = Command::new("make");
         cmd.arg("install-reth-bench").current_dir(&self.repo_root);
 
-        info!("Compiling reth-bench with {cmd:?}");
+        // Debug log the command
+        debug!("Executing make command: {:?}", cmd);
 
         let output = cmd.output().wrap_err("Failed to execute make install-reth-bench command")?;
 

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

@@ -14,8 +14,6 @@
 #[global_allocator]
 static ALLOC: reth_cli_util::allocator::Allocator = reth_cli_util::allocator::new_allocator();
 
-use alloy_primitives as _;
-
 mod benchmark;
 mod cli;
 mod comparison;

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

@@ -2,9 +2,7 @@
 
 use crate::cli::Args;
 use alloy_provider::{Provider, ProviderBuilder};
-use alloy_rpc_client::RpcClient;
 use alloy_rpc_types_eth::SyncStatus;
-use alloy_transport_ws::WsConnect;
 use eyre::{eyre, OptionExt, Result, WrapErr};
 #[cfg(unix)]
 use nix::sys::signal::{killpg, Signal};
@@ -20,9 +18,6 @@ use tokio::{
 };
 use tracing::{debug, info, warn};
 
-/// Default websocket RPC port used by reth
-const DEFAULT_WS_RPC_PORT: u16 = 8546;
-
 /// Manages reth node lifecycle and operations
 pub(crate) struct NodeManager {
     datadir: Option<String>,
@@ -157,13 +152,9 @@ impl NodeManager {
             metrics_arg,
             "--http".to_string(),
             "--http.api".to_string(),
-            "eth,reth".to_string(),
-            "--ws".to_string(),
-            "--ws.api".to_string(),
-            "eth,reth".to_string(),
+            "eth".to_string(),
             "--disable-discovery".to_string(),
             "--trusted-only".to_string(),
-            "--disable-tx-gossip".to_string(),
         ]);
 
         // Add tracing arguments if OTLP endpoint is configured
@@ -220,11 +211,6 @@ impl NodeManager {
         cmd.arg("--");
         cmd.args(reth_args);
 
-        // Enable tracing-samply
-        if supports_samply_flags(&reth_args[0]) {
-            cmd.arg("--log.samply");
-        }
-
         // Set environment variable to disable log styling
         cmd.env("RUST_LOG_STYLE", "never");
 
@@ -368,13 +354,8 @@ impl NodeManager {
         Ok((child, reth_command))
     }
 
-    /// Wait for the node to be ready and return its current tip.
-    ///
-    /// Fails early if the node process exits before becoming ready.
-    pub(crate) async fn wait_for_node_ready_and_get_tip(
-        &self,
-        child: &mut tokio::process::Child,
-    ) -> Result<u64> {
+    /// Wait for the node to be ready and return its current tip
+    pub(crate) async fn wait_for_node_ready_and_get_tip(&self) -> Result<u64> {
         info!("Waiting for node to be ready and synced...");
 
         let max_wait = Duration::from_secs(120); // 2 minutes to allow for sync
@@ -385,23 +366,8 @@ impl NodeManager {
         let url = rpc_url.parse().map_err(|e| eyre!("Invalid RPC URL '{}': {}", rpc_url, e))?;
         let provider = ProviderBuilder::new().connect_http(url);
 
-        let start_time = tokio::time::Instant::now();
-        let mut iteration = 0;
-
         timeout(max_wait, async {
             loop {
-                iteration += 1;
-                debug!(
-                    "Readiness check iteration {} (elapsed: {:?})",
-                    iteration,
-                    start_time.elapsed()
-                );
-
-                // Check if the node process has exited.
-                if let Some(status) = child.try_wait()? {
-                    return Err(eyre!("Node process exited unexpectedly with {status}"));
-                }
-
                 // First check if RPC is up and node is not syncing
                 match provider.syncing().await {
                     Ok(sync_result) => {
@@ -410,48 +376,24 @@ impl NodeManager {
                                 debug!("Node is still syncing {sync_info:?}, waiting...");
                             }
                             _ => {
-                                debug!("HTTP RPC is up and node is not syncing, checking block number...");
                                 // Node is not syncing, now get the tip
                                 match provider.get_block_number().await {
                                     Ok(tip) => {
-                                        debug!("HTTP RPC ready at block: {}, checking WebSocket...", tip);
-
-                                        // Verify WebSocket RPC is ready (public endpoint, no JWT required)
-                                        let ws_url = format!("ws://localhost:{}", DEFAULT_WS_RPC_PORT);
-                                        debug!("Attempting WebSocket connection to {} (public endpoint)", ws_url);
-                                        let ws_connect = WsConnect::new(&ws_url);
-
-                                        match RpcClient::connect_pubsub(ws_connect).await
-                                        {
-                                            Ok(_) => {
-                                                info!(
-                                                    "Node is ready (HTTP and WebSocket) at block: {} (took {:?}, {} iterations)",
-                                                    tip, start_time.elapsed(), iteration
-                                                );
-                                                return Ok(tip);
-                                            }
-                                            Err(e) => {
-                                                debug!(
-                                                    "HTTP RPC ready but WebSocket not ready yet (iteration {}): {:?}",
-                                                    iteration, e
-                                                );
-                                                debug!("WebSocket error details: {}", e);
-                                            }
-                                        }
+                                        info!("Node is ready and not syncing at block: {}", tip);
+                                        return Ok(tip);
                                     }
                                     Err(e) => {
-                                        debug!("Failed to get block number (iteration {}): {:?}", iteration, e);
+                                        debug!("Failed to get block number: {}", e);
                                     }
                                 }
                             }
                         }
                     }
                     Err(e) => {
-                        debug!("Node RPC not ready yet or failed to check sync status (iteration {}): {:?}", iteration, e);
+                        debug!("Node RPC not ready yet or failed to check sync status: {}", e);
                     }
                 }
 
-                debug!("Sleeping for {:?} before next check", check_interval);
                 sleep(check_interval).await;
             }
         })
@@ -459,79 +401,9 @@ 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")?;
+        let pid = child.id().expect("Child process ID should be available");
 
         // Check if the process has already exited
         match child.try_wait() {
@@ -680,16 +552,3 @@ impl NodeManager {
         Ok(())
     }
 }
-
-fn supports_samply_flags(bin: &str) -> bool {
-    let mut cmd = std::process::Command::new(bin);
-    // NOTE: The flag to check must come before --help.
-    // We pass --help as a shortcut to not execute any command.
-    cmd.args(["--log.samply", "--help"]);
-    debug!(?cmd, "Checking samply flags support");
-    let Ok(output) = cmd.output() else {
-        return false;
-    };
-    debug!(?output, "Samply flags support check");
-    output.status.success()
-}

bin/reth-bench/Cargo.toml

@@ -16,27 +16,20 @@ workspace = true
 # reth
 reth-cli-runner.workspace = true
 reth-cli-util.workspace = true
-reth-engine-primitives.workspace = true
-reth-ethereum-primitives.workspace = true
 reth-fs-util.workspace = true
 reth-node-api.workspace = true
 reth-node-core.workspace = true
 reth-primitives-traits.workspace = true
-reth-rpc-api.workspace = true
-
 reth-tracing.workspace = true
-reth-chainspec.workspace = true
 
 # alloy
 alloy-eips.workspace = true
 alloy-json-rpc.workspace = true
-alloy-consensus.workspace = true
-alloy-network.workspace = true
-alloy-primitives = { workspace = true, features = ["rand"] }
-alloy-provider = { workspace = true, features = ["engine-api", "pubsub", "reqwest-rustls-tls"], default-features = false }
+alloy-primitives.workspace = true
+alloy-provider = { workspace = true, features = ["engine-api", "reqwest-rustls-tls"], default-features = false }
 alloy-pubsub.workspace = true
-alloy-rpc-client = { workspace = true, features = ["pubsub"] }
-alloy-rpc-types-engine = { workspace = true, features = ["kzg"] }
+alloy-rpc-client.workspace = true
+alloy-rpc-types-engine.workspace = true
 alloy-transport-http.workspace = true
 alloy-transport-ipc.workspace = true
 alloy-transport-ws.workspace = true
@@ -45,7 +38,7 @@ op-alloy-consensus = { workspace = true, features = ["alloy-compat"] }
 op-alloy-rpc-types-engine = { workspace = true, features = ["serde"] }
 
 # reqwest
-reqwest.workspace = true
+reqwest = { workspace = true, default-features = false, features = ["rustls-tls-native-roots"] }
 
 # tower
 tower.workspace = true
@@ -57,9 +50,6 @@ tracing.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 
-# url parsing
-url.workspace = true
-
 # async
 async-trait.workspace = true
 futures.workspace = true
@@ -68,7 +58,6 @@ tokio = { workspace = true, features = ["sync", "macros", "time", "rt-multi-thre
 # misc
 clap = { workspace = true, features = ["derive", "env"] }
 eyre.workspace = true
-color-eyre.workspace = true
 thiserror.workspace = true
 humantime.workspace = true
 
@@ -90,11 +79,7 @@ jemalloc = [
     "reth-node-core/jemalloc",
 ]
 jemalloc-prof = ["reth-cli-util/jemalloc-prof"]
-tracy-allocator = ["reth-cli-util/tracy-allocator", "tracy"]
-tracy = [
-    "reth-node-core/tracy",
-    "reth-tracing/tracy",
-]
+tracy-allocator = ["reth-cli-util/tracy-allocator"]
 
 min-error-logs = [
     "tracing/release_max_level_error",
@@ -117,7 +102,7 @@ min-trace-logs = [
     "reth-node-core/min-trace-logs",
 ]
 
-# no-op feature flag for CI matrices
+# no-op feature flag for switching between the `optimism` and default functionality in CI matrices
 ethereum = []
 
 [[bin]]

bin/reth-bench/README.md

@@ -31,14 +31,6 @@ Otherwise, running `make maxperf` at the root of the repo should be sufficient f
 `reth-bench` contains different commands to benchmark different patterns of engine API calls.
 The `reth-bench new-payload-fcu` command is the most representative of ethereum mainnet live sync, alternating between sending `engine_newPayload` calls and `engine_forkchoiceUpdated` calls.
 
-The `new-payload-fcu` command supports two optional waiting modes that can be used together or independently:
-- `--wait-time <duration>`: Fixed sleep interval between blocks (e.g., `--wait-time 100ms`)
-- `--wait-for-persistence`: Waits for blocks to be persisted using the `reth_subscribePersistedBlock` subscription
-
-When using `--wait-for-persistence`, the benchmark waits after every `(threshold + 1)` blocks, where the threshold defaults to the engine's persistence threshold (2). This can be customized with `--persistence-threshold <N>`.
-
-By default, the WebSocket URL for persistence subscriptions is derived from `--engine-rpc-url` (converting to ws:// on port 8546). Use `--ws-rpc-url` to override this.
-
 Below is an overview of how to run a benchmark:
 
 ### Setup

bin/reth-bench/src/authenticated_transport.rs

@@ -163,7 +163,7 @@ impl AuthenticatedTransport {
 
             // shift the iat forward by one second so there is some buffer time
             let mut shifted_claims = inner_and_claims.1;
-            shifted_claims.iat -= 30;
+            shifted_claims.iat -= 1;
 
             // if the claims are out of date, reset the inner transport
             if !shifted_claims.is_within_time_window() {

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

@@ -35,7 +35,7 @@ impl BenchContext {
     /// This is the initialization code for most benchmarks, taking in a [`BenchmarkArgs`] and
     /// returning the providers needed to run a benchmark.
     pub(crate) async fn new(bench_args: &BenchmarkArgs, rpc_url: String) -> eyre::Result<Self> {
-        info!(target: "reth-bench", "Running benchmark using data from RPC URL: {}", rpc_url);
+        info!("Running benchmark using data from RPC URL: {}", rpc_url);
 
         // Ensure that output directory exists and is a directory
         if let Some(output) = &bench_args.output {
@@ -45,7 +45,7 @@ impl BenchContext {
             // Create the directory if it doesn't exist
             if !output.exists() {
                 std::fs::create_dir_all(output)?;
-                info!(target: "reth-bench", "Created output directory: {:?}", output);
+                info!("Created output directory: {:?}", output);
             }
         }
 
@@ -77,7 +77,7 @@ impl BenchContext {
         let auth_url = Url::parse(&bench_args.engine_rpc_url)?;
 
         // construct the authed transport
-        info!(target: "reth-bench", "Connecting to Engine RPC at {} for replay", auth_url);
+        info!("Connecting to Engine RPC at {} for replay", auth_url);
         let auth_transport = AuthenticatedTransportConnect::new(auth_url, jwt);
         let client = ClientBuilder::default().connect_with(auth_transport).await?;
         let auth_provider = RootProvider::<AnyNetwork>::new(client);
@@ -103,20 +103,14 @@ impl BenchContext {
             (bench_args.from, bench_args.to)
         };
 
-        // If `--to` are not provided, we will run the benchmark continuously,
+        // If neither `--from` nor `--to` are provided, we will run the benchmark continuously,
         // starting at the latest block.
-        let latest_block = block_provider
-            .get_block_by_number(BlockNumberOrTag::Latest)
-            .full()
-            .await?
-            .ok_or_else(|| eyre::eyre!("Failed to fetch latest block from RPC"))?;
-        let mut benchmark_mode = BenchMode::new(from, to, latest_block.into_inner().number())?;
+        let mut benchmark_mode = BenchMode::new(from, to)?;
 
         let first_block = match benchmark_mode {
-            BenchMode::Continuous(start) => {
-                block_provider.get_block_by_number(start.into()).full().await?.ok_or_else(|| {
-                    eyre::eyre!("Failed to fetch block {} from RPC for continuous mode", start)
-                })?
+            BenchMode::Continuous => {
+                // fetch Latest block
+                block_provider.get_block_by_number(BlockNumberOrTag::Latest).full().await?.unwrap()
             }
             BenchMode::Range(ref mut range) => {
                 match range.next() {
@@ -126,9 +120,7 @@ impl BenchContext {
                             .get_block_by_number(block_number.into())
                             .full()
                             .await?
-                            .ok_or_else(|| {
-                                eyre::eyre!("Failed to fetch block {} from RPC", block_number)
-                            })?
+                            .unwrap()
                     }
                     None => {
                         return Err(eyre::eyre!(

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

@@ -1,219 +0,0 @@
-//! Benchmarks empty block processing by ramping the block gas limit.
-
-use crate::{
-    authenticated_transport::AuthenticatedTransportConnect,
-    bench::{
-        helpers::{build_payload, parse_gas_limit, prepare_payload_request, rpc_block_to_header},
-        output::GasRampPayloadFile,
-    },
-    valid_payload::{call_forkchoice_updated, call_new_payload, payload_to_new_payload},
-};
-use alloy_eips::BlockNumberOrTag;
-use alloy_provider::{network::AnyNetwork, Provider, RootProvider};
-use alloy_rpc_client::ClientBuilder;
-use alloy_rpc_types_engine::{ExecutionPayload, ForkchoiceState, JwtSecret};
-
-use clap::Parser;
-use reqwest::Url;
-use reth_chainspec::ChainSpec;
-use reth_cli_runner::CliContext;
-use reth_ethereum_primitives::TransactionSigned;
-use reth_primitives_traits::constants::{GAS_LIMIT_BOUND_DIVISOR, MAXIMUM_GAS_LIMIT_BLOCK};
-use std::{path::PathBuf, time::Instant};
-use tracing::info;
-
-/// `reth benchmark gas-limit-ramp` command.
-#[derive(Debug, Parser)]
-pub struct Command {
-    /// Number of blocks to generate. 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>,
-
-    /// The Engine API RPC URL.
-    #[arg(long = "engine-rpc-url", value_name = "ENGINE_RPC_URL")]
-    engine_rpc_url: String,
-
-    /// Path to the JWT secret for Engine API authentication.
-    #[arg(long = "jwt-secret", value_name = "JWT_SECRET")]
-    jwt_secret: PathBuf,
-
-    /// Output directory for benchmark results and generated payloads.
-    #[arg(long, value_name = "OUTPUT")]
-    output: PathBuf,
-}
-
-/// 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),
-}
-
-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"
-                ));
-            }
-        };
-
-        // 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!(target: "reth-bench", "Created output directory: {:?}", self.output);
-        }
-
-        // Set up authenticated provider (used for both Engine API and eth_ methods)
-        let jwt = std::fs::read_to_string(&self.jwt_secret)?;
-        let jwt = JwtSecret::from_hex(jwt)?;
-        let auth_url = Url::parse(&self.engine_rpc_url)?;
-
-        info!(target: "reth-bench", "Connecting to Engine RPC at {}", auth_url);
-        let auth_transport = AuthenticatedTransportConnect::new(auth_url, jwt);
-        let client = ClientBuilder::default().connect_with(auth_transport).await?;
-        let provider = RootProvider::<AnyNetwork>::new(client);
-
-        // Get chain spec - required for fork detection
-        let chain_id = provider.get_chain_id().await?;
-        let chain_spec = ChainSpec::from_chain_id(chain_id)
-            .ok_or_else(|| eyre::eyre!("Unsupported chain id: {chain_id}"))?;
-
-        // Fetch the current head block as parent
-        let parent_block = provider
-            .get_block_by_number(BlockNumberOrTag::Latest)
-            .full()
-            .await?
-            .ok_or_else(|| eyre::eyre!("Failed to fetch latest block"))?;
-
-        let (mut parent_header, mut parent_hash) = rpc_block_to_header(parent_block);
-
-        let canonical_parent = parent_header.number;
-        let start_block = canonical_parent + 1;
-
-        match mode {
-            RampMode::Blocks(blocks) => {
-                info!(
-                    target: "reth-bench",
-                    canonical_parent,
-                    start_block,
-                    end_block = start_block + blocks - 1,
-                    "Starting gas limit ramp benchmark (block count mode)"
-                );
-            }
-            RampMode::TargetGasLimit(target) => {
-                info!(
-                    target: "reth-bench",
-                    canonical_parent,
-                    start_block,
-                    current_gas_limit = parent_header.gas_limit,
-                    target_gas_limit = target,
-                    "Starting gas limit ramp benchmark (target gas limit mode)"
-                );
-            }
-        }
-
-        let mut blocks_processed = 0u64;
-        let total_benchmark_duration = Instant::now();
-
-        while !should_stop(mode, blocks_processed, parent_header.gas_limit) {
-            let timestamp = parent_header.timestamp.saturating_add(1);
-
-            let request = prepare_payload_request(&chain_spec, timestamp, parent_hash);
-            let new_payload_version = request.new_payload_version;
-
-            let (payload, sidecar) = build_payload(&provider, request).await?;
-
-            let mut block =
-                payload.clone().try_into_block_with_sidecar::<TransactionSigned>(&sidecar)?;
-
-            let max_increase = max_gas_limit_increase(parent_header.gas_limit);
-            let gas_limit =
-                parent_header.gas_limit.saturating_add(max_increase).min(MAXIMUM_GAS_LIMIT_BLOCK);
-
-            block.header.gas_limit = gas_limit;
-
-            let block_hash = block.header.hash_slow();
-            // Regenerate the payload from the modified block, but keep the original sidecar
-            // which contains the actual execution requests data (not just the hash)
-            let (payload, _) = ExecutionPayload::from_block_unchecked(block_hash, &block);
-            let (version, params) = payload_to_new_payload(
-                payload,
-                sidecar,
-                false,
-                block.header.withdrawals_root,
-                Some(new_payload_version),
-            )?;
-
-            // Save payload to file with version info for replay
-            let payload_path =
-                self.output.join(format!("payload_block_{}.json", block.header.number));
-            let file =
-                GasRampPayloadFile { version: version as u8, block_hash, params: params.clone() };
-            let payload_json = serde_json::to_string_pretty(&file)?;
-            std::fs::write(&payload_path, &payload_json)?;
-            info!(target: "reth-bench", block_number = block.header.number, path = %payload_path.display(), "Saved payload");
-
-            call_new_payload(&provider, version, params).await?;
-
-            let forkchoice_state = ForkchoiceState {
-                head_block_hash: block_hash,
-                safe_block_hash: block_hash,
-                finalized_block_hash: block_hash,
-            };
-            call_forkchoice_updated(&provider, version, forkchoice_state, None).await?;
-
-            parent_header = block.header;
-            parent_hash = block_hash;
-            blocks_processed += 1;
-        }
-
-        let final_gas_limit = parent_header.gas_limit;
-        info!(
-            target: "reth-bench",
-            total_duration=?total_benchmark_duration.elapsed(),
-            blocks_processed,
-            final_gas_limit,
-            "Benchmark complete"
-        );
-
-        Ok(())
-    }
-}
-
-const fn max_gas_limit_increase(parent_gas_limit: u64) -> u64 {
-    (parent_gas_limit / GAS_LIMIT_BOUND_DIVISOR).saturating_sub(1)
-}
-
-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,
-    }
-}

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

@@ -1,851 +0,0 @@
-//! Command for generating large blocks by packing transactions from real blocks.
-//!
-//! This command fetches transactions from existing blocks and packs them into a single
-//! large block using the `testing_buildBlockV1` RPC endpoint.
-
-use crate::{
-    authenticated_transport::AuthenticatedTransportConnect, bench::helpers::parse_gas_limit,
-};
-use alloy_eips::{BlockNumberOrTag, Typed2718};
-use alloy_primitives::{Bytes, B256};
-use alloy_provider::{ext::EngineApi, network::AnyNetwork, Provider, RootProvider};
-use alloy_rpc_client::ClientBuilder;
-use alloy_rpc_types_engine::{
-    ExecutionPayloadEnvelopeV4, ExecutionPayloadEnvelopeV5, ForkchoiceState, JwtSecret,
-    PayloadAttributes,
-};
-use alloy_transport::layers::RetryBackoffLayer;
-use clap::Parser;
-use eyre::Context;
-use reqwest::Url;
-use reth_cli_runner::CliContext;
-use reth_rpc_api::TestingBuildBlockRequestV1;
-use std::future::Future;
-use tokio::sync::mpsc;
-use tracing::{info, warn};
-
-/// A single transaction with its gas used and raw encoded bytes.
-#[derive(Debug, Clone)]
-pub struct RawTransaction {
-    /// The actual gas used by the transaction (from receipt).
-    pub gas_used: u64,
-    /// The transaction type (e.g., 3 for EIP-4844 blob txs).
-    pub tx_type: u8,
-    /// The raw RLP-encoded transaction bytes.
-    pub raw: Bytes,
-}
-
-/// Abstraction over sources of transactions for big block generation.
-///
-/// Implementors provide transactions from different sources (RPC, database, files, etc.)
-pub trait TransactionSource {
-    /// Fetch transactions from a specific block number.
-    ///
-    /// Returns `Ok(None)` if the block doesn't exist.
-    /// Returns `Ok(Some((transactions, gas_used)))` with the block's transactions and total gas.
-    fn fetch_block_transactions(
-        &self,
-        block_number: u64,
-    ) -> impl Future<Output = eyre::Result<Option<(Vec<RawTransaction>, u64)>>> + Send;
-}
-
-/// RPC-based transaction source that fetches from a remote node.
-#[derive(Debug)]
-pub struct RpcTransactionSource {
-    provider: RootProvider<AnyNetwork>,
-}
-
-impl RpcTransactionSource {
-    /// Create a new RPC transaction source.
-    pub const fn new(provider: RootProvider<AnyNetwork>) -> Self {
-        Self { provider }
-    }
-
-    /// Create from an RPC URL with retry backoff.
-    pub fn from_url(rpc_url: &str) -> eyre::Result<Self> {
-        let client = ClientBuilder::default()
-            .layer(RetryBackoffLayer::new(10, 800, u64::MAX))
-            .http(rpc_url.parse()?);
-        let provider = RootProvider::<AnyNetwork>::new(client);
-        Ok(Self { provider })
-    }
-}
-
-impl TransactionSource for RpcTransactionSource {
-    async fn fetch_block_transactions(
-        &self,
-        block_number: u64,
-    ) -> eyre::Result<Option<(Vec<RawTransaction>, u64)>> {
-        // Fetch block and receipts in parallel
-        let (block, receipts) = tokio::try_join!(
-            self.provider.get_block_by_number(block_number.into()).full(),
-            self.provider.get_block_receipts(block_number.into())
-        )?;
-
-        let Some(block) = block else {
-            return Ok(None);
-        };
-
-        let Some(receipts) = receipts else {
-            return Err(eyre::eyre!("Receipts not found for block {}", block_number));
-        };
-
-        let block_gas_used = block.header.gas_used;
-
-        // Convert cumulative gas from receipts to per-tx gas_used
-        let mut prev_cumulative = 0u64;
-        let transactions: Vec<RawTransaction> = block
-            .transactions
-            .txns()
-            .zip(receipts.iter())
-            .map(|(tx, receipt)| {
-                let cumulative = receipt.inner.inner.inner.receipt.cumulative_gas_used;
-                let gas_used = cumulative - prev_cumulative;
-                prev_cumulative = cumulative;
-
-                let with_encoded = tx.inner.inner.clone().into_encoded();
-                RawTransaction {
-                    gas_used,
-                    tx_type: tx.inner.ty(),
-                    raw: with_encoded.encoded_bytes().clone(),
-                }
-            })
-            .collect();
-
-        Ok(Some((transactions, block_gas_used)))
-    }
-}
-
-/// Collects transactions from a source up to a target gas usage.
-#[derive(Debug)]
-pub struct TransactionCollector<S> {
-    source: S,
-    target_gas: u64,
-}
-
-impl<S: TransactionSource> TransactionCollector<S> {
-    /// Create a new transaction collector.
-    pub const fn new(source: S, target_gas: u64) -> Self {
-        Self { source, target_gas }
-    }
-
-    /// Collect transactions starting from the given block number.
-    ///
-    /// Skips blob transactions (type 3) and collects until target gas is reached.
-    /// Returns a `CollectionResult` with transactions, gas info, and next block.
-    pub async fn collect(&self, start_block: u64) -> eyre::Result<CollectionResult> {
-        self.collect_gas(start_block, self.target_gas).await
-    }
-
-    /// Collect transactions up to a specific gas target.
-    ///
-    /// This is used both for initial collection and for retry top-ups.
-    pub async fn collect_gas(
-        &self,
-        start_block: u64,
-        gas_target: u64,
-    ) -> eyre::Result<CollectionResult> {
-        let mut transactions: Vec<RawTransaction> = Vec::new();
-        let mut total_gas: u64 = 0;
-        let mut current_block = start_block;
-
-        while total_gas < gas_target {
-            let Some((block_txs, _)) = self.source.fetch_block_transactions(current_block).await?
-            else {
-                warn!(target: "reth-bench", block = current_block, "Block not found, stopping");
-                break;
-            };
-
-            for tx in block_txs {
-                // Skip blob transactions (EIP-4844, type 3)
-                if tx.tx_type == 3 {
-                    continue;
-                }
-
-                if total_gas + tx.gas_used <= gas_target {
-                    total_gas += tx.gas_used;
-                    transactions.push(tx);
-                }
-
-                if total_gas >= gas_target {
-                    break;
-                }
-            }
-
-            current_block += 1;
-
-            // Stop early if remaining gas is under 1M (close enough to target)
-            let remaining_gas = gas_target.saturating_sub(total_gas);
-            if remaining_gas < 1_000_000 {
-                break;
-            }
-        }
-
-        info!(
-            target: "reth-bench",
-            total_txs = transactions.len(),
-            gas_sent = total_gas,
-            next_block = current_block,
-            "Finished collecting transactions"
-        );
-
-        Ok(CollectionResult { transactions, gas_sent: total_gas, next_block: current_block })
-    }
-}
-
-/// `reth bench generate-big-block` command
-///
-/// Generates a large block by fetching transactions from existing blocks and packing them
-/// into a single block using the `testing_buildBlockV1` RPC endpoint.
-#[derive(Debug, Parser)]
-pub struct Command {
-    /// The RPC URL to use for fetching blocks (can be an external archive node).
-    #[arg(long, value_name = "RPC_URL")]
-    rpc_url: String,
-
-    /// The engine RPC URL (with JWT authentication).
-    #[arg(long, value_name = "ENGINE_RPC_URL", default_value = "http://localhost:8551")]
-    engine_rpc_url: String,
-
-    /// The RPC URL for `testing_buildBlockV1` calls (same node as engine, regular RPC port).
-    #[arg(long, value_name = "TESTING_RPC_URL", default_value = "http://localhost:8545")]
-    testing_rpc_url: String,
-
-    /// Path to the JWT secret file for engine API authentication.
-    #[arg(long, value_name = "JWT_SECRET")]
-    jwt_secret: std::path::PathBuf,
-
-    /// Target gas to pack into the block.
-    /// 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)]
-    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.
-    #[arg(long, value_name = "FROM_BLOCK")]
-    from_block: u64,
-
-    /// Execute the payload (call newPayload + forkchoiceUpdated).
-    /// If false, only builds the payload and prints it.
-    #[arg(long, default_value = "false")]
-    execute: bool,
-
-    /// Number of payloads to generate. Each payload uses the previous as parent.
-    /// When count == 1, the payload is only generated and saved, not executed.
-    /// When count > 1, each payload is executed before building the next.
-    #[arg(long, default_value = "1")]
-    count: u64,
-
-    /// Number of transaction batches to prefetch in background when count > 1.
-    /// Higher values reduce latency but use more memory.
-    #[arg(long, default_value = "4")]
-    prefetch_buffer: usize,
-
-    /// Output directory for generated payloads. Each payload is saved as `payload_block_N.json`.
-    #[arg(long, value_name = "OUTPUT_DIR")]
-    output_dir: std::path::PathBuf,
-}
-
-/// A built payload ready for execution.
-struct BuiltPayload {
-    block_number: u64,
-    envelope: ExecutionPayloadEnvelopeV4,
-    block_hash: B256,
-    timestamp: u64,
-    /// The actual gas used in the built block.
-    gas_used: u64,
-}
-
-/// Result of collecting transactions from blocks.
-#[derive(Debug)]
-pub struct CollectionResult {
-    /// Collected transactions with their gas info.
-    pub transactions: Vec<RawTransaction>,
-    /// Total gas sent (sum of historical `gas_used` for all collected txs).
-    pub gas_sent: u64,
-    /// Next block number to continue collecting from.
-    pub next_block: u64,
-}
-
-/// Constants for retry logic.
-const MAX_BUILD_RETRIES: u32 = 5;
-/// Maximum retries for fetching a transaction batch.
-const MAX_FETCH_RETRIES: u32 = 5;
-/// Tolerance: if `gas_used` is within 1M of target, don't retry.
-const MIN_TARGET_SLACK: u64 = 1_000_000;
-/// Maximum gas to request in retries (10x target as safety cap).
-const MAX_ADDITIONAL_GAS_MULTIPLIER: u64 = 10;
-
-/// Fetches a batch of transactions with retry logic.
-///
-/// Returns `None` if all retries are exhausted.
-async fn fetch_batch_with_retry<S: TransactionSource>(
-    collector: &TransactionCollector<S>,
-    block: u64,
-) -> Option<CollectionResult> {
-    for attempt in 1..=MAX_FETCH_RETRIES {
-        match collector.collect(block).await {
-            Ok(result) => return Some(result),
-            Err(e) => {
-                if attempt == MAX_FETCH_RETRIES {
-                    warn!(target: "reth-bench", attempt, error = %e, "Failed to fetch transactions after max retries");
-                    return None;
-                }
-                warn!(target: "reth-bench", attempt, error = %e, "Failed to fetch transactions, retrying...");
-                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-            }
-        }
-    }
-    None
-}
-
-/// Outcome of a build attempt check.
-enum RetryOutcome {
-    /// Payload is close enough to target gas.
-    Success,
-    /// Max retries reached, accept what we have.
-    MaxRetries,
-    /// Need more transactions with the specified gas amount.
-    NeedMore(u64),
-}
-
-/// Buffer for receiving transaction batches from the fetcher.
-///
-/// This abstracts over the channel to allow the main loop to request
-/// batches on demand, including for retries.
-struct TxBuffer {
-    receiver: mpsc::Receiver<CollectionResult>,
-}
-
-impl TxBuffer {
-    const fn new(receiver: mpsc::Receiver<CollectionResult>) -> Self {
-        Self { receiver }
-    }
-
-    /// Take the next available batch from the fetcher.
-    async fn take_batch(&mut self) -> Option<CollectionResult> {
-        self.receiver.recv().await
-    }
-}
-
-impl Command {
-    /// Execute the `generate-big-block` command
-    pub async fn execute(self, _ctx: CliContext) -> eyre::Result<()> {
-        info!(target: "reth-bench", target_gas = self.target_gas, count = self.count, "Generating big block(s)");
-
-        // Set up authenticated engine provider
-        let jwt =
-            std::fs::read_to_string(&self.jwt_secret).wrap_err("Failed to read JWT secret file")?;
-        let jwt = JwtSecret::from_hex(jwt.trim())?;
-        let auth_url = Url::parse(&self.engine_rpc_url)?;
-
-        info!(target: "reth-bench", "Connecting to Engine RPC at {}", auth_url);
-        let auth_transport = AuthenticatedTransportConnect::new(auth_url.clone(), jwt);
-        let auth_client = ClientBuilder::default().connect_with(auth_transport).await?;
-        let auth_provider = RootProvider::<AnyNetwork>::new(auth_client);
-
-        // Set up testing RPC provider (for testing_buildBlockV1)
-        info!(target: "reth-bench", "Connecting to Testing RPC at {}", self.testing_rpc_url);
-        let testing_client = ClientBuilder::default()
-            .layer(RetryBackoffLayer::new(10, 800, u64::MAX))
-            .http(self.testing_rpc_url.parse()?);
-        let testing_provider = RootProvider::<AnyNetwork>::new(testing_client);
-
-        // Get the parent block (latest canonical block)
-        info!(target: "reth-bench", endpoint = "engine", method = "eth_getBlockByNumber", block = "latest", "RPC call");
-        let parent_block = auth_provider
-            .get_block_by_number(BlockNumberOrTag::Latest)
-            .await?
-            .ok_or_else(|| eyre::eyre!("Failed to fetch latest block"))?;
-
-        let parent_hash = parent_block.header.hash;
-        let parent_number = parent_block.header.number;
-        let parent_timestamp = parent_block.header.timestamp;
-
-        info!(
-            target: "reth-bench",
-            parent_hash = %parent_hash,
-            parent_number = parent_number,
-            "Using initial parent block"
-        );
-
-        // Create output directory
-        std::fs::create_dir_all(&self.output_dir).wrap_err_with(|| {
-            format!("Failed to create output directory: {:?}", self.output_dir)
-        })?;
-
-        let start_block = self.from_block;
-
-        // Use pipelined execution when generating multiple payloads
-        if self.count > 1 {
-            self.execute_pipelined(
-                &auth_provider,
-                &testing_provider,
-                start_block,
-                parent_hash,
-                parent_timestamp,
-            )
-            .await?;
-        } else {
-            // Single payload - collect transactions and build with retry
-            let tx_source = RpcTransactionSource::from_url(&self.rpc_url)?;
-            let collector = TransactionCollector::new(tx_source, self.target_gas);
-            let result = collector.collect(start_block).await?;
-
-            if result.transactions.is_empty() {
-                return Err(eyre::eyre!("No transactions collected"));
-            }
-
-            self.execute_sequential_with_retry(
-                &auth_provider,
-                &testing_provider,
-                &collector,
-                result,
-                parent_hash,
-                parent_timestamp,
-            )
-            .await?;
-        }
-
-        info!(target: "reth-bench", count = self.count, output_dir = %self.output_dir.display(), "All payloads generated");
-        Ok(())
-    }
-
-    /// Sequential execution path with retry logic for underfilled payloads.
-    async fn execute_sequential_with_retry<S: TransactionSource>(
-        &self,
-        auth_provider: &RootProvider<AnyNetwork>,
-        testing_provider: &RootProvider<AnyNetwork>,
-        collector: &TransactionCollector<S>,
-        initial_result: CollectionResult,
-        mut parent_hash: B256,
-        mut parent_timestamp: u64,
-    ) -> eyre::Result<()> {
-        let mut current_result = initial_result;
-
-        for i in 0..self.count {
-            let built = self
-                .build_with_retry(
-                    testing_provider,
-                    collector,
-                    &mut current_result,
-                    i,
-                    parent_hash,
-                    parent_timestamp,
-                )
-                .await?;
-
-            self.save_payload(&built)?;
-
-            if self.execute || self.count > 1 {
-                info!(target: "reth-bench", payload = i + 1, block_hash = %built.block_hash, gas_used = built.gas_used, "Executing payload (newPayload + FCU)");
-                self.execute_payload_v4(auth_provider, built.envelope, parent_hash).await?;
-                info!(target: "reth-bench", payload = i + 1, "Payload executed successfully");
-            }
-
-            parent_hash = built.block_hash;
-            parent_timestamp = built.timestamp;
-        }
-        Ok(())
-    }
-
-    /// Build a payload with retry logic when `gas_used` is below target.
-    ///
-    /// Uses the ratio of `gas_used/gas_sent` to estimate how many more transactions
-    /// are needed to hit the target gas.
-    async fn build_with_retry<S: TransactionSource>(
-        &self,
-        testing_provider: &RootProvider<AnyNetwork>,
-        collector: &TransactionCollector<S>,
-        result: &mut CollectionResult,
-        index: u64,
-        parent_hash: B256,
-        parent_timestamp: u64,
-    ) -> eyre::Result<BuiltPayload> {
-        for attempt in 1..=MAX_BUILD_RETRIES {
-            let tx_bytes: Vec<Bytes> = result.transactions.iter().map(|t| t.raw.clone()).collect();
-            let gas_sent = result.gas_sent;
-
-            info!(
-                target: "reth-bench",
-                payload = index + 1,
-                attempt,
-                tx_count = tx_bytes.len(),
-                gas_sent,
-                parent_hash = %parent_hash,
-                "Building payload via testing_buildBlockV1"
-            );
-
-            let built = Self::build_payload_static(
-                testing_provider,
-                &tx_bytes,
-                index,
-                parent_hash,
-                parent_timestamp,
-            )
-            .await?;
-
-            match self.check_retry_outcome(&built, index, attempt, gas_sent) {
-                RetryOutcome::Success | RetryOutcome::MaxRetries => return Ok(built),
-                RetryOutcome::NeedMore(additional_gas) => {
-                    let additional =
-                        collector.collect_gas(result.next_block, additional_gas).await?;
-                    result.transactions.extend(additional.transactions);
-                    result.gas_sent = result.gas_sent.saturating_add(additional.gas_sent);
-                    result.next_block = additional.next_block;
-                }
-            }
-        }
-
-        warn!(target: "reth-bench", payload = index + 1, "Retry loop exited without returning a payload");
-        Err(eyre::eyre!("build_with_retry exhausted retries without result"))
-    }
-
-    /// Pipelined execution - fetches transactions in background, builds with retry.
-    ///
-    /// The fetcher continuously produces transaction batches. The main loop consumes them,
-    /// builds payloads with retry logic (requesting more transactions if underfilled),
-    /// and executes each payload before moving to the next.
-    async fn execute_pipelined(
-        &self,
-        auth_provider: &RootProvider<AnyNetwork>,
-        testing_provider: &RootProvider<AnyNetwork>,
-        start_block: u64,
-        initial_parent_hash: B256,
-        initial_parent_timestamp: u64,
-    ) -> eyre::Result<()> {
-        // Create channel for transaction batches - fetcher sends CollectionResult
-        let (tx_sender, tx_receiver) = mpsc::channel::<CollectionResult>(self.prefetch_buffer);
-
-        // Spawn background task to continuously fetch transaction batches
-        let rpc_url = self.rpc_url.clone();
-        let target_gas = self.target_gas;
-
-        let fetcher_handle = tokio::spawn(async move {
-            let tx_source = match RpcTransactionSource::from_url(&rpc_url) {
-                Ok(source) => source,
-                Err(e) => {
-                    warn!(target: "reth-bench", error = %e, "Failed to create transaction source");
-                    return None;
-                }
-            };
-
-            let collector = TransactionCollector::new(tx_source, target_gas);
-            let mut current_block = start_block;
-
-            while let Some(batch) = fetch_batch_with_retry(&collector, current_block).await {
-                if batch.transactions.is_empty() {
-                    info!(target: "reth-bench", block = current_block, "Reached chain tip, stopping fetcher");
-                    break;
-                }
-
-                info!(
-                    target: "reth-bench",
-                    tx_count = batch.transactions.len(),
-                    gas_sent = batch.gas_sent,
-                    blocks = format!("{}..{}", current_block, batch.next_block),
-                    "Fetched transaction batch"
-                );
-                current_block = batch.next_block;
-
-                if tx_sender.send(batch).await.is_err() {
-                    break;
-                }
-            }
-
-            Some(current_block)
-        });
-
-        // Transaction buffer: holds transactions from batches + any extras from retries
-        let mut tx_buffer = TxBuffer::new(tx_receiver);
-
-        let mut parent_hash = initial_parent_hash;
-        let mut parent_timestamp = initial_parent_timestamp;
-
-        for i in 0..self.count {
-            // Get initial batch of transactions for this payload
-            let Some(mut result) = tx_buffer.take_batch().await else {
-                info!(
-                    target: "reth-bench",
-                    payloads_built = i,
-                    payloads_requested = self.count,
-                    "Transaction source exhausted, stopping"
-                );
-                break;
-            };
-
-            if result.transactions.is_empty() {
-                info!(
-                    target: "reth-bench",
-                    payloads_built = i,
-                    payloads_requested = self.count,
-                    "No more transactions available, stopping"
-                );
-                break;
-            }
-
-            // Build with retry - may need to request more transactions
-            let built = self
-                .build_with_retry_buffered(
-                    testing_provider,
-                    &mut tx_buffer,
-                    &mut result,
-                    i,
-                    parent_hash,
-                    parent_timestamp,
-                )
-                .await?;
-
-            self.save_payload(&built)?;
-
-            let current_block_hash = built.block_hash;
-            let current_timestamp = built.timestamp;
-
-            // Execute payload
-            info!(target: "reth-bench", payload = i + 1, block_hash = %current_block_hash, gas_used = built.gas_used, "Executing payload (newPayload + FCU)");
-            self.execute_payload_v4(auth_provider, built.envelope, parent_hash).await?;
-            info!(target: "reth-bench", payload = i + 1, "Payload executed successfully");
-
-            parent_hash = current_block_hash;
-            parent_timestamp = current_timestamp;
-        }
-
-        // Clean up the fetcher task
-        drop(tx_buffer);
-        let _ = fetcher_handle.await;
-
-        Ok(())
-    }
-
-    /// Build a payload with retry logic, using the buffered transaction source.
-    async fn build_with_retry_buffered(
-        &self,
-        testing_provider: &RootProvider<AnyNetwork>,
-        tx_buffer: &mut TxBuffer,
-        result: &mut CollectionResult,
-        index: u64,
-        parent_hash: B256,
-        parent_timestamp: u64,
-    ) -> eyre::Result<BuiltPayload> {
-        for attempt in 1..=MAX_BUILD_RETRIES {
-            let tx_bytes: Vec<Bytes> = result.transactions.iter().map(|t| t.raw.clone()).collect();
-            let gas_sent = result.gas_sent;
-
-            info!(
-                target: "reth-bench",
-                payload = index + 1,
-                attempt,
-                tx_count = tx_bytes.len(),
-                gas_sent,
-                parent_hash = %parent_hash,
-                "Building payload via testing_buildBlockV1"
-            );
-
-            let built = Self::build_payload_static(
-                testing_provider,
-                &tx_bytes,
-                index,
-                parent_hash,
-                parent_timestamp,
-            )
-            .await?;
-
-            match self.check_retry_outcome(&built, index, attempt, gas_sent) {
-                RetryOutcome::Success | RetryOutcome::MaxRetries => return Ok(built),
-                RetryOutcome::NeedMore(additional_gas) => {
-                    let mut collected_gas = 0u64;
-                    while collected_gas < additional_gas {
-                        if let Some(batch) = tx_buffer.take_batch().await {
-                            collected_gas += batch.gas_sent;
-                            result.transactions.extend(batch.transactions);
-                            result.gas_sent = result.gas_sent.saturating_add(batch.gas_sent);
-                            result.next_block = batch.next_block;
-                        } else {
-                            warn!(target: "reth-bench", "Transaction fetcher exhausted, proceeding with available transactions");
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-
-        warn!(target: "reth-bench", payload = index + 1, "Retry loop exited without returning a payload");
-        Err(eyre::eyre!("build_with_retry_buffered exhausted retries without result"))
-    }
-
-    /// Determines the outcome of a build attempt.
-    fn check_retry_outcome(
-        &self,
-        built: &BuiltPayload,
-        index: u64,
-        attempt: u32,
-        gas_sent: u64,
-    ) -> RetryOutcome {
-        let gas_used = built.gas_used;
-
-        if gas_used + MIN_TARGET_SLACK >= self.target_gas {
-            info!(
-                target: "reth-bench",
-                payload = index + 1,
-                gas_used,
-                target_gas = self.target_gas,
-                attempts = attempt,
-                "Payload built successfully"
-            );
-            return RetryOutcome::Success;
-        }
-
-        if attempt == MAX_BUILD_RETRIES {
-            warn!(
-                target: "reth-bench",
-                payload = index + 1,
-                gas_used,
-                target_gas = self.target_gas,
-                gas_sent,
-                "Underfilled after max retries, accepting payload"
-            );
-            return RetryOutcome::MaxRetries;
-        }
-
-        if gas_used == 0 {
-            warn!(
-                target: "reth-bench",
-                payload = index + 1,
-                "Zero gas used in payload, requesting fixed chunk of additional transactions"
-            );
-            return RetryOutcome::NeedMore(self.target_gas);
-        }
-
-        let gas_sent_needed_total =
-            (self.target_gas as u128 * gas_sent as u128).div_ceil(gas_used as u128) as u64;
-        let additional = gas_sent_needed_total.saturating_sub(gas_sent);
-        let additional = additional.min(self.target_gas * MAX_ADDITIONAL_GAS_MULTIPLIER);
-
-        if additional == 0 {
-            info!(
-                target: "reth-bench",
-                payload = index + 1,
-                gas_used,
-                target_gas = self.target_gas,
-                "No additional transactions needed based on ratio"
-            );
-            return RetryOutcome::Success;
-        }
-
-        let ratio = gas_used as f64 / gas_sent as f64;
-        info!(
-            target: "reth-bench",
-            payload = index + 1,
-            gas_used,
-            gas_sent,
-            ratio = format!("{:.4}", ratio),
-            additional_gas = additional,
-            "Underfilled, collecting more transactions for retry"
-        );
-        RetryOutcome::NeedMore(additional)
-    }
-
-    /// Build a single payload via `testing_buildBlockV1`.
-    async fn build_payload_static(
-        testing_provider: &RootProvider<AnyNetwork>,
-        transactions: &[Bytes],
-        index: u64,
-        parent_hash: B256,
-        parent_timestamp: u64,
-    ) -> eyre::Result<BuiltPayload> {
-        let request = TestingBuildBlockRequestV1 {
-            parent_block_hash: parent_hash,
-            payload_attributes: PayloadAttributes {
-                timestamp: parent_timestamp + 12,
-                prev_randao: B256::ZERO,
-                suggested_fee_recipient: alloy_primitives::Address::ZERO,
-                withdrawals: Some(vec![]),
-                parent_beacon_block_root: Some(B256::ZERO),
-            },
-            transactions: transactions.to_vec(),
-            extra_data: None,
-        };
-
-        let total_tx_bytes: usize = transactions.iter().map(|tx| tx.len()).sum();
-        info!(
-            target: "reth-bench",
-            payload = index + 1,
-            tx_count = transactions.len(),
-            total_tx_bytes = total_tx_bytes,
-            parent_hash = %parent_hash,
-            "Sending to testing_buildBlockV1"
-        );
-        let envelope: ExecutionPayloadEnvelopeV5 =
-            testing_provider.client().request("testing_buildBlockV1", [request]).await?;
-
-        let v4_envelope = envelope.try_into_v4()?;
-
-        let inner = &v4_envelope.envelope_inner.execution_payload.payload_inner.payload_inner;
-        let block_hash = inner.block_hash;
-        let block_number = inner.block_number;
-        let timestamp = inner.timestamp;
-        let gas_used = inner.gas_used;
-
-        Ok(BuiltPayload { block_number, envelope: v4_envelope, block_hash, timestamp, gas_used })
-    }
-
-    /// Save a payload to disk.
-    fn save_payload(&self, payload: &BuiltPayload) -> eyre::Result<()> {
-        let filename = format!("payload_block_{}.json", payload.block_number);
-        let filepath = self.output_dir.join(&filename);
-        let json = serde_json::to_string_pretty(&payload.envelope)?;
-        std::fs::write(&filepath, &json)
-            .wrap_err_with(|| format!("Failed to write payload to {:?}", filepath))?;
-        info!(target: "reth-bench", block_number = payload.block_number, block_hash = %payload.block_hash, path = %filepath.display(), "Payload saved");
-        Ok(())
-    }
-
-    async fn execute_payload_v4(
-        &self,
-        provider: &RootProvider<AnyNetwork>,
-        envelope: ExecutionPayloadEnvelopeV4,
-        parent_hash: B256,
-    ) -> eyre::Result<()> {
-        let block_hash =
-            envelope.envelope_inner.execution_payload.payload_inner.payload_inner.block_hash;
-
-        let status = provider
-            .new_payload_v4(
-                envelope.envelope_inner.execution_payload,
-                vec![],
-                B256::ZERO,
-                envelope.execution_requests.to_vec(),
-            )
-            .await?;
-
-        if !status.is_valid() {
-            return Err(eyre::eyre!("Payload rejected: {:?}", status));
-        }
-
-        let fcu_state = ForkchoiceState {
-            head_block_hash: block_hash,
-            safe_block_hash: parent_hash,
-            finalized_block_hash: parent_hash,
-        };
-
-        let fcu_result = provider.fork_choice_updated_v3(fcu_state, None).await?;
-
-        if !fcu_result.is_valid() {
-            return Err(eyre::eyre!("FCU rejected: {:?}", fcu_result));
-        }
-
-        Ok(())
-    }
-}

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

@@ -1,273 +0,0 @@
-//! Common helpers for reth-bench commands.
-
-use crate::valid_payload::call_forkchoice_updated;
-use eyre::Result;
-use std::io::{BufReader, Read};
-
-/// Read input from either a file path or stdin.
-pub(crate) fn read_input(path: Option<&str>) -> Result<String> {
-    Ok(match 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.
-pub(crate) fn load_jwt_secret(jwt_secret: Option<&str>) -> Result<Option<String>> {
-    match jwt_secret {
-        Some(secret) => {
-            // Try to read as file first
-            match std::fs::read_to_string(secret) {
-                Ok(contents) => Ok(Some(contents.trim().to_string())),
-                // If file read fails, use the string directly
-                Err(_) => Ok(Some(secret.to_string())),
-            }
-        }
-        None => Ok(None),
-    }
-}
-
-/// 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};
-use alloy_provider::{ext::EngineApi, network::AnyNetwork, RootProvider};
-use alloy_rpc_types_engine::{
-    CancunPayloadFields, ExecutionPayload, ExecutionPayloadSidecar, ForkchoiceState,
-    PayloadAttributes, PayloadId,
-};
-use eyre::OptionExt;
-use reth_chainspec::{ChainSpec, EthereumHardforks};
-use reth_node_api::EngineApiMessageVersion;
-use tracing::debug;
-
-/// Prepared payload request data for triggering block building.
-pub(crate) struct PayloadRequest {
-    /// The payload attributes for the new block.
-    pub(crate) attributes: PayloadAttributes,
-    /// The forkchoice state pointing to the parent block.
-    pub(crate) forkchoice_state: ForkchoiceState,
-    /// The engine API version for FCU calls.
-    pub(crate) fcu_version: EngineApiMessageVersion,
-    /// The getPayload version to use (1-5).
-    pub(crate) get_payload_version: u8,
-    /// The newPayload version to use.
-    pub(crate) new_payload_version: EngineApiMessageVersion,
-}
-
-/// Prepare payload attributes and forkchoice state for a new block.
-pub(crate) fn prepare_payload_request(
-    chain_spec: &ChainSpec,
-    timestamp: u64,
-    parent_hash: B256,
-) -> PayloadRequest {
-    let shanghai_active = chain_spec.is_shanghai_active_at_timestamp(timestamp);
-    let cancun_active = chain_spec.is_cancun_active_at_timestamp(timestamp);
-    let prague_active = chain_spec.is_prague_active_at_timestamp(timestamp);
-    let osaka_active = chain_spec.is_osaka_active_at_timestamp(timestamp);
-
-    // FCU version: V3 for Cancun+Prague+Osaka, V2 for Shanghai, V1 otherwise
-    let fcu_version = if cancun_active {
-        EngineApiMessageVersion::V3
-    } else if shanghai_active {
-        EngineApiMessageVersion::V2
-    } else {
-        EngineApiMessageVersion::V1
-    };
-
-    // getPayload version: 5 for Osaka, 4 for Prague, 3 for Cancun, 2 for Shanghai, 1 otherwise
-    // newPayload version: 4 for Prague+Osaka (no V5), 3 for Cancun, 2 for Shanghai, 1 otherwise
-    let (get_payload_version, new_payload_version) = if osaka_active {
-        (5, EngineApiMessageVersion::V4) // Osaka uses getPayloadV5 but newPayloadV4
-    } else if prague_active {
-        (4, EngineApiMessageVersion::V4)
-    } else if cancun_active {
-        (3, EngineApiMessageVersion::V3)
-    } else if shanghai_active {
-        (2, EngineApiMessageVersion::V2)
-    } else {
-        (1, EngineApiMessageVersion::V1)
-    };
-
-    PayloadRequest {
-        attributes: PayloadAttributes {
-            timestamp,
-            prev_randao: B256::ZERO,
-            suggested_fee_recipient: Address::ZERO,
-            withdrawals: shanghai_active.then(Vec::new),
-            parent_beacon_block_root: cancun_active.then_some(B256::ZERO),
-        },
-        forkchoice_state: ForkchoiceState {
-            head_block_hash: parent_hash,
-            safe_block_hash: parent_hash,
-            finalized_block_hash: parent_hash,
-        },
-        fcu_version,
-        get_payload_version,
-        new_payload_version,
-    }
-}
-
-/// Trigger payload building via FCU and retrieve the built payload.
-///
-/// This sends a forkchoiceUpdated with payload attributes to start building,
-/// then calls getPayload to retrieve the result.
-pub(crate) async fn build_payload(
-    provider: &RootProvider<AnyNetwork>,
-    request: PayloadRequest,
-) -> eyre::Result<(ExecutionPayload, ExecutionPayloadSidecar)> {
-    let fcu_result = call_forkchoice_updated(
-        provider,
-        request.fcu_version,
-        request.forkchoice_state,
-        Some(request.attributes.clone()),
-    )
-    .await?;
-
-    let payload_id =
-        fcu_result.payload_id.ok_or_eyre("Payload builder did not return a payload id")?;
-
-    get_payload_with_sidecar(
-        provider,
-        request.get_payload_version,
-        payload_id,
-        request.attributes.parent_beacon_block_root,
-    )
-    .await
-}
-
-/// Convert an RPC block to a consensus header and block hash.
-pub(crate) fn rpc_block_to_header(block: alloy_provider::network::AnyRpcBlock) -> (Header, B256) {
-    let block_hash = block.header.hash;
-    let header = block.header.inner.clone().into_header_with_defaults();
-    (header, block_hash)
-}
-
-/// Compute versioned hashes from KZG commitments.
-fn versioned_hashes_from_commitments(
-    commitments: &[alloy_primitives::FixedBytes<48>],
-) -> Vec<B256> {
-    commitments.iter().map(|c| kzg_to_versioned_hash(c.as_ref())).collect()
-}
-
-/// Fetch an execution payload using the appropriate engine API version.
-pub(crate) async fn get_payload_with_sidecar(
-    provider: &RootProvider<AnyNetwork>,
-    version: u8,
-    payload_id: PayloadId,
-    parent_beacon_block_root: Option<B256>,
-) -> eyre::Result<(ExecutionPayload, ExecutionPayloadSidecar)> {
-    debug!(target: "reth-bench", get_payload_version = ?version, ?payload_id, "Sending getPayload");
-
-    match version {
-        1 => {
-            let payload = provider.get_payload_v1(payload_id).await?;
-            Ok((ExecutionPayload::V1(payload), ExecutionPayloadSidecar::none()))
-        }
-        2 => {
-            let envelope = provider.get_payload_v2(payload_id).await?;
-            let payload = match envelope.execution_payload {
-                alloy_rpc_types_engine::ExecutionPayloadFieldV2::V1(p) => ExecutionPayload::V1(p),
-                alloy_rpc_types_engine::ExecutionPayloadFieldV2::V2(p) => ExecutionPayload::V2(p),
-            };
-            Ok((payload, ExecutionPayloadSidecar::none()))
-        }
-        3 => {
-            let envelope = provider.get_payload_v3(payload_id).await?;
-            let versioned_hashes =
-                versioned_hashes_from_commitments(&envelope.blobs_bundle.commitments);
-            let cancun_fields = CancunPayloadFields {
-                parent_beacon_block_root: parent_beacon_block_root
-                    .ok_or_eyre("parent_beacon_block_root required for V3")?,
-                versioned_hashes,
-            };
-            Ok((
-                ExecutionPayload::V3(envelope.execution_payload),
-                ExecutionPayloadSidecar::v3(cancun_fields),
-            ))
-        }
-        4 => {
-            let envelope = provider.get_payload_v4(payload_id).await?;
-            Ok(envelope.into_payload_and_sidecar(
-                parent_beacon_block_root.ok_or_eyre("parent_beacon_block_root required for V4")?,
-            ))
-        }
-        5 => {
-            let envelope = provider.get_payload_v5(payload_id).await?;
-            Ok(envelope.into_payload_and_sidecar(
-                parent_beacon_block_root.ok_or_eyre("parent_beacon_block_root required for V5")?,
-            ))
-        }
-        _ => 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());
-    }
-}

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

@@ -6,18 +6,9 @@ use reth_node_core::args::LogArgs;
 use reth_tracing::FileWorkerGuard;
 
 mod context;
-mod gas_limit_ramp;
-mod generate_big_block;
-pub(crate) mod helpers;
-pub use generate_big_block::{
-    RawTransaction, RpcTransactionSource, TransactionCollector, TransactionSource,
-};
 mod new_payload_fcu;
 mod new_payload_only;
 mod output;
-mod persistence_waiter;
-mod replay_payloads;
-mod send_invalid_payload;
 mod send_payload;
 
 /// `reth bench` command
@@ -36,9 +27,6 @@ pub enum Subcommands {
     /// Benchmark which calls `newPayload`, then `forkchoiceUpdated`.
     NewPayloadFcu(new_payload_fcu::Command),
 
-    /// Benchmark which builds empty blocks with a ramped gas limit.
-    GasLimitRamp(gas_limit_ramp::Command),
-
     /// Benchmark which only calls subsequent `newPayload` calls.
     NewPayloadOnly(new_payload_only::Command),
 
@@ -53,41 +41,6 @@ pub enum Subcommands {
     /// `cast block latest --full --json | reth-bench send-payload --rpc-url localhost:5000
     /// --jwt-secret $(cat ~/.local/share/reth/mainnet/jwt.hex)`
     SendPayload(send_payload::Command),
-
-    /// Generate a large block by packing transactions from existing blocks.
-    ///
-    /// This command fetches transactions from real blocks and packs them into a single
-    /// block using the `testing_buildBlockV1` RPC endpoint.
-    ///
-    /// Example:
-    ///
-    /// `reth-bench generate-big-block --rpc-url http://localhost:8545 --engine-rpc-url
-    /// http://localhost:8551 --jwt-secret ~/.local/share/reth/mainnet/jwt.hex --target-gas
-    /// 30000000`
-    GenerateBigBlock(generate_big_block::Command),
-
-    /// Replay pre-generated payloads from a directory.
-    ///
-    /// This command reads payload files from a previous `generate-big-block` run and replays
-    /// them in sequence using `newPayload` followed by `forkchoiceUpdated`.
-    ///
-    /// Example:
-    ///
-    /// `reth-bench replay-payloads --payload-dir ./payloads --engine-rpc-url
-    /// http://localhost:8551 --jwt-secret ~/.local/share/reth/mainnet/jwt.hex`
-    ReplayPayloads(replay_payloads::Command),
-
-    /// 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 {
@@ -98,12 +51,8 @@ impl BenchmarkCommand {
 
         match self.command {
             Subcommands::NewPayloadFcu(command) => command.execute(ctx).await,
-            Subcommands::GasLimitRamp(command) => command.execute(ctx).await,
             Subcommands::NewPayloadOnly(command) => command.execute(ctx).await,
             Subcommands::SendPayload(command) => command.execute(ctx).await,
-            Subcommands::GenerateBigBlock(command) => command.execute(ctx).await,
-            Subcommands::ReplayPayloads(command) => command.execute(ctx).await,
-            Subcommands::SendInvalidPayload(command) => (*command).execute(ctx).await,
         }
     }
 
@@ -111,18 +60,7 @@ impl BenchmarkCommand {
     ///
     /// If file logging is enabled, this function returns a guard that must be kept alive to ensure
     /// that all logs are flushed to disk.
-    ///
-    /// Always enables log target display (`RUST_LOG_TARGET=1`) so that the `reth-bench` target
-    /// is visible in output, making it easy to distinguish reth-bench logs from reth logs when
-    /// both are streamed to the same console or file.
     pub fn init_tracing(&self) -> eyre::Result<Option<FileWorkerGuard>> {
-        // Always show the log target so "reth-bench" is visible in the output.
-        if std::env::var_os("RUST_LOG_TARGET").is_none() {
-            // SAFETY: This is called early during single-threaded initialization, before any
-            // threads are spawned and before the tracing subscriber is set up.
-            unsafe { std::env::set_var("RUST_LOG_TARGET", "1") };
-        }
-
         let guard = self.logs.init_tracing()?;
         Ok(guard)
     }

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

@@ -1,23 +1,12 @@
 //! Runs the `reth bench` command, calling first newPayload for each block, then calling
 //! forkchoiceUpdated.
-//!
-//! Supports configurable waiting behavior:
-//! - **`--wait-time`**: Fixed sleep interval between blocks.
-//! - **`--wait-for-persistence`**: Waits for every Nth block to be persisted using the
-//!   `reth_subscribePersistedBlock` subscription, where N matches the engine's persistence
-//!   threshold. This ensures the benchmark doesn't outpace persistence.
-//!
-//! Both options can be used together or independently.
 
 use crate::{
     bench::{
         context::BenchContext,
         output::{
-            write_benchmark_results, CombinedResult, NewPayloadResult, TotalGasOutput, TotalGasRow,
-        },
-        persistence_waiter::{
-            derive_ws_rpc_url, setup_persistence_subscription, PersistenceWaiter,
-            PERSISTENCE_CHECKPOINT_TIMEOUT,
+            CombinedResult, NewPayloadResult, TotalGasOutput, TotalGasRow, COMBINED_OUTPUT_SUFFIX,
+            GAS_OUTPUT_SUFFIX,
         },
     },
     valid_payload::{block_to_new_payload, call_forkchoice_updated, call_new_payload},
@@ -25,10 +14,10 @@ use crate::{
 use alloy_provider::Provider;
 use alloy_rpc_types_engine::ForkchoiceState;
 use clap::Parser;
+use csv::Writer;
 use eyre::{Context, OptionExt};
 use humantime::parse_duration;
 use reth_cli_runner::CliContext;
-use reth_engine_primitives::config::DEFAULT_PERSISTENCE_THRESHOLD;
 use reth_node_core::args::BenchmarkArgs;
 use std::time::{Duration, Instant};
 use tracing::{debug, info};
@@ -41,31 +30,8 @@ pub struct Command {
     rpc_url: String,
 
     /// How long to wait after a forkchoice update before sending the next payload.
-    #[arg(long, value_name = "WAIT_TIME", value_parser = parse_duration, verbatim_doc_comment)]
-    wait_time: Option<Duration>,
-
-    /// Wait for blocks to be persisted before sending the next batch.
-    ///
-    /// When enabled, waits for every Nth block to be persisted using the
-    /// `reth_subscribePersistedBlock` subscription. This ensures the benchmark
-    /// doesn't outpace persistence.
-    ///
-    /// The subscription uses the regular RPC websocket endpoint (no JWT required).
-    #[arg(long, default_value = "false", verbatim_doc_comment)]
-    wait_for_persistence: bool,
-
-    /// Engine persistence threshold used for deciding when to wait for persistence.
-    ///
-    /// The benchmark waits after every `(threshold + 1)` blocks. By default this
-    /// matches the engine's `DEFAULT_PERSISTENCE_THRESHOLD` (2), so waits occur
-    /// at blocks 3, 6, 9, etc.
-    #[arg(
-        long = "persistence-threshold",
-        value_name = "PERSISTENCE_THRESHOLD",
-        default_value_t = DEFAULT_PERSISTENCE_THRESHOLD,
-        verbatim_doc_comment
-    )]
-    persistence_threshold: u64,
+    #[arg(long, value_name = "WAIT_TIME", value_parser = parse_duration, default_value = "250ms", verbatim_doc_comment)]
+    wait_time: Duration,
 
     /// The size of the block buffer (channel capacity) for prefetching blocks from the RPC
     /// endpoint.
@@ -84,58 +50,12 @@ pub struct Command {
 impl Command {
     /// Execute `benchmark new-payload-fcu` command
     pub async fn execute(self, _ctx: CliContext) -> eyre::Result<()> {
-        // Log mode configuration
-        if let Some(duration) = self.wait_time {
-            info!(target: "reth-bench", "Using wait-time mode with {}ms delay between blocks", duration.as_millis());
-        }
-        if self.wait_for_persistence {
-            info!(
-                target: "reth-bench",
-                "Persistence waiting enabled (waits after every {} blocks to match engine gap > {} behavior)",
-                self.persistence_threshold + 1,
-                self.persistence_threshold
-            );
-        }
-
-        // Set up waiter based on configured options
-        // When both are set: wait at least wait_time, and also wait for persistence if needed
-        let mut waiter = match (self.wait_time, self.wait_for_persistence) {
-            (Some(duration), true) => {
-                let ws_url = derive_ws_rpc_url(
-                    self.benchmark.ws_rpc_url.as_deref(),
-                    &self.benchmark.engine_rpc_url,
-                )?;
-                let sub = setup_persistence_subscription(ws_url).await?;
-                Some(PersistenceWaiter::with_duration_and_subscription(
-                    duration,
-                    sub,
-                    self.persistence_threshold,
-                    PERSISTENCE_CHECKPOINT_TIMEOUT,
-                ))
-            }
-            (Some(duration), false) => Some(PersistenceWaiter::with_duration(duration)),
-            (None, true) => {
-                let ws_url = derive_ws_rpc_url(
-                    self.benchmark.ws_rpc_url.as_deref(),
-                    &self.benchmark.engine_rpc_url,
-                )?;
-                let sub = setup_persistence_subscription(ws_url).await?;
-                Some(PersistenceWaiter::with_subscription(
-                    sub,
-                    self.persistence_threshold,
-                    PERSISTENCE_CHECKPOINT_TIMEOUT,
-                ))
-            }
-            (None, false) => None,
-        };
-
         let BenchContext {
             benchmark_mode,
             block_provider,
             auth_provider,
             mut next_block,
             is_optimism,
-            ..
         } = BenchContext::new(&self.benchmark, self.rpc_url).await?;
 
         let buffer_size = self.rpc_block_buffer_size;
@@ -154,7 +74,7 @@ impl Command {
                 let block = match block_res.and_then(|opt| opt.ok_or_eyre("Block not found")) {
                     Ok(block) => block,
                     Err(e) => {
-                        tracing::error!(target: "reth-bench", "Failed to fetch block {next_block}: {e}");
+                        tracing::error!("Failed to fetch block {next_block}: {e}");
                         let _ = error_sender.send(e);
                         break;
                     }
@@ -184,12 +104,13 @@ impl Command {
                     .send((block, head_block_hash, safe_block_hash, finalized_block_hash))
                     .await
                 {
-                    tracing::error!(target: "reth-bench", "Failed to send block data: {e}");
+                    tracing::error!("Failed to send block data: {e}");
                     break;
                 }
             }
         });
 
+        // put results in a summary vec so they can be printed at the end
         let mut results = Vec::new();
         let total_benchmark_duration = Instant::now();
         let mut total_wait_time = Duration::ZERO;
@@ -200,13 +121,14 @@ impl Command {
             total_wait_time += wait_start.elapsed();
             result
         } {
+            // just put gas used here
             let gas_used = block.header.gas_used;
-            let gas_limit = block.header.gas_limit;
             let block_number = block.header.number;
             let transaction_count = block.transactions.len() as u64;
 
-            debug!(target: "reth-bench", ?block_number, "Sending payload");
+            debug!(target: "reth-bench", ?block_number, "Sending payload",);
 
+            // construct fcu to call
             let forkchoice_state = ForkchoiceState {
                 head_block_hash: head,
                 safe_block_hash: safe,
@@ -221,26 +143,28 @@ impl Command {
 
             call_forkchoice_updated(&auth_provider, version, forkchoice_state, None).await?;
 
+            // calculate the total duration and the fcu latency, record
             let total_latency = start.elapsed();
             let fcu_latency = total_latency - new_payload_result.latency;
             let combined_result = CombinedResult {
                 block_number,
-                gas_limit,
                 transaction_count,
                 new_payload_result,
                 fcu_latency,
                 total_latency,
             };
 
-            // Exclude time spent waiting on the block prefetch channel from the benchmark duration.
-            // We want to measure engine throughput, not RPC fetch latency.
+            // current duration since the start of the benchmark minus the time
+            // waiting for blocks
             let current_duration = total_benchmark_duration.elapsed() - total_wait_time;
-            info!(target: "reth-bench", %combined_result);
 
-            if let Some(w) = &mut waiter {
-                w.on_block(block_number).await?;
-            }
+            // convert gas used to gigagas, then compute gigagas per second
+            info!(%combined_result);
 
+            // wait before sending the next payload
+            tokio::time::sleep(self.wait_time).await;
+
+            // record the current result
             let gas_row =
                 TotalGasRow { block_number, transaction_count, gas_used, time: current_duration };
             results.push((gas_row, combined_result));
@@ -251,29 +175,40 @@ impl Command {
             return Err(error);
         }
 
-        // Drop waiter - we don't need to wait for final blocks to persist
-        // since the benchmark goal is measuring Ggas/s of newPayload/FCU, not persistence.
-        drop(waiter);
-
-        let (gas_output_results, combined_results): (Vec<TotalGasRow>, Vec<CombinedResult>) =
+        let (gas_output_results, combined_results): (_, Vec<CombinedResult>) =
             results.into_iter().unzip();
 
-        if let Some(ref path) = self.benchmark.output {
-            write_benchmark_results(path, &gas_output_results, &combined_results)?;
+        // write the csv output to files
+        if let Some(path) = self.benchmark.output {
+            // first write the combined results to a file
+            let output_path = path.join(COMBINED_OUTPUT_SUFFIX);
+            info!("Writing engine api call latency output to file: {:?}", output_path);
+            let mut writer = Writer::from_path(output_path)?;
+            for result in combined_results {
+                writer.serialize(result)?;
+            }
+            writer.flush()?;
+
+            // now write the gas output to a file
+            let output_path = path.join(GAS_OUTPUT_SUFFIX);
+            info!("Writing total gas output to file: {:?}", output_path);
+            let mut writer = Writer::from_path(output_path)?;
+            for row in &gas_output_results {
+                writer.serialize(row)?;
+            }
+            writer.flush()?;
+
+            info!("Finished writing benchmark output files to {:?}.", path);
         }
 
-        let gas_output =
-            TotalGasOutput::with_combined_results(gas_output_results, &combined_results)?;
-
+        // accumulate the results and calculate the overall Ggas/s
+        let gas_output = TotalGasOutput::new(gas_output_results)?;
         info!(
-            target: "reth-bench",
-            total_gas_used = gas_output.total_gas_used,
-            total_duration = ?gas_output.total_duration,
-            execution_duration = ?gas_output.execution_duration,
-            blocks_processed = gas_output.blocks_processed,
-            wall_clock_ggas_per_second = format_args!("{:.4}", gas_output.total_gigagas_per_second()),
-            execution_ggas_per_second = format_args!("{:.4}", gas_output.execution_gigagas_per_second()),
-            "Benchmark complete"
+            total_duration=?gas_output.total_duration,
+            total_gas_used=?gas_output.total_gas_used,
+            blocks_processed=?gas_output.blocks_processed,
+            "Total Ggas/s: {:.4}",
+            gas_output.total_gigagas_per_second()
         );
 
         Ok(())

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

@@ -49,7 +49,6 @@ impl Command {
             auth_provider,
             mut next_block,
             is_optimism,
-            ..
         } = BenchContext::new(&self.benchmark, self.rpc_url).await?;
 
         let buffer_size = self.rpc_block_buffer_size;
@@ -68,7 +67,7 @@ impl Command {
                 let block = match block_res.and_then(|opt| opt.ok_or_eyre("Block not found")) {
                     Ok(block) => block,
                     Err(e) => {
-                        tracing::error!(target: "reth-bench", "Failed to fetch block {next_block}: {e}");
+                        tracing::error!("Failed to fetch block {next_block}: {e}");
                         let _ = error_sender.send(e);
                         break;
                     }
@@ -76,7 +75,7 @@ impl Command {
 
                 next_block += 1;
                 if let Err(e) = sender.send(block).await {
-                    tracing::error!(target: "reth-bench", "Failed to send block data: {e}");
+                    tracing::error!("Failed to send block data: {e}");
                     break;
                 }
             }
@@ -97,7 +96,11 @@ impl Command {
             let transaction_count = block.transactions.len() as u64;
             let gas_used = block.header.gas_used;
 
-            debug!(target: "reth-bench", 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)?;
 
@@ -105,7 +108,7 @@ impl Command {
             call_new_payload(&auth_provider, version, params).await?;
 
             let new_payload_result = NewPayloadResult { gas_used, latency: start.elapsed() };
-            info!(target: "reth-bench", %new_payload_result);
+            info!(%new_payload_result);
 
             // current duration since the start of the benchmark minus the time
             // waiting for blocks
@@ -129,7 +132,7 @@ impl Command {
         if let Some(path) = self.benchmark.output {
             // first write the new payload results to a file
             let output_path = path.join(NEW_PAYLOAD_OUTPUT_SUFFIX);
-            info!(target: "reth-bench", "Writing newPayload call latency output to file: {:?}", output_path);
+            info!("Writing newPayload call latency output to file: {:?}", output_path);
             let mut writer = Writer::from_path(output_path)?;
             for result in new_payload_results {
                 writer.serialize(result)?;
@@ -138,20 +141,19 @@ impl Command {
 
             // now write the gas output to a file
             let output_path = path.join(GAS_OUTPUT_SUFFIX);
-            info!(target: "reth-bench", "Writing total gas output to file: {:?}", output_path);
+            info!("Writing total gas output to file: {:?}", output_path);
             let mut writer = Writer::from_path(output_path)?;
             for row in &gas_output_results {
                 writer.serialize(row)?;
             }
             writer.flush()?;
 
-            info!(target: "reth-bench", "Finished writing benchmark output files to {:?}.", path);
+            info!("Finished writing benchmark output files to {:?}.", path);
         }
 
         // accumulate the results and calculate the overall Ggas/s
         let gas_output = TotalGasOutput::new(gas_output_results)?;
         info!(
-            target: "reth-bench",
             total_duration=?gas_output.total_duration,
             total_gas_used=?gas_output.total_gas_used,
             blocks_processed=?gas_output.blocks_processed,

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

@@ -1,13 +1,10 @@
 //! Contains various benchmark output formats, either for logging or for
 //! serialization to / from files.
 
-use alloy_primitives::B256;
-use csv::Writer;
 use eyre::OptionExt;
 use reth_primitives_traits::constants::GIGAGAS;
-use serde::{ser::SerializeStruct, Deserialize, Serialize};
-use std::{fs, path::Path, time::Duration};
-use tracing::info;
+use serde::{ser::SerializeStruct, Serialize};
+use std::time::Duration;
 
 /// This is the suffix for gas output csv files.
 pub(crate) const GAS_OUTPUT_SUFFIX: &str = "total_gas.csv";
@@ -18,17 +15,6 @@ pub(crate) const COMBINED_OUTPUT_SUFFIX: &str = "combined_latency.csv";
 /// This is the suffix for new payload output csv files.
 pub(crate) const NEW_PAYLOAD_OUTPUT_SUFFIX: &str = "new_payload_latency.csv";
 
-/// Serialized format for gas ramp payloads on disk.
-#[derive(Debug, Serialize, Deserialize)]
-pub(crate) struct GasRampPayloadFile {
-    /// Engine API version (1-5).
-    pub(crate) version: u8,
-    /// The block hash for FCU.
-    pub(crate) block_hash: B256,
-    /// The params to pass to newPayload.
-    pub(crate) params: serde_json::Value,
-}
-
 /// This represents the results of a single `newPayload` call in the benchmark, containing the gas
 /// used and the `newPayload` latency.
 #[derive(Debug)]
@@ -81,8 +67,6 @@ impl Serialize for NewPayloadResult {
 pub(crate) struct CombinedResult {
     /// The block number of the block being processed.
     pub(crate) block_number: u64,
-    /// The gas limit of the block.
-    pub(crate) gas_limit: u64,
     /// The number of transactions in the block.
     pub(crate) transaction_count: u64,
     /// The `newPayload` result.
@@ -104,7 +88,7 @@ impl std::fmt::Display for CombinedResult {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
-            "Block {} processed at {:.4} Ggas/s, used {} total gas. Combined: {:.4} Ggas/s. fcu: {:?}, newPayload: {:?}",
+            "Payload {} processed at {:.4} Ggas/s, used {} total gas. Combined gas per second: {:.4} Ggas/s. fcu latency: {:?}, newPayload latency: {:?}",
             self.block_number,
             self.new_payload_result.gas_per_second() / GIGAGAS as f64,
             self.new_payload_result.gas_used,
@@ -126,11 +110,10 @@ impl Serialize for CombinedResult {
         let fcu_latency = self.fcu_latency.as_micros();
         let new_payload_latency = self.new_payload_result.latency.as_micros();
         let total_latency = self.total_latency.as_micros();
-        let mut state = serializer.serialize_struct("CombinedResult", 7)?;
+        let mut state = serializer.serialize_struct("CombinedResult", 6)?;
 
         // flatten the new payload result because this is meant for CSV writing
         state.serialize_field("block_number", &self.block_number)?;
-        state.serialize_field("gas_limit", &self.gas_limit)?;
         state.serialize_field("transaction_count", &self.transaction_count)?;
         state.serialize_field("gas_used", &self.new_payload_result.gas_used)?;
         state.serialize_field("new_payload_latency", &new_payload_latency)?;
@@ -158,91 +141,30 @@ pub(crate) struct TotalGasRow {
 pub(crate) struct TotalGasOutput {
     /// The total gas used in the benchmark.
     pub(crate) total_gas_used: u64,
-    /// The total wall-clock duration of the benchmark (includes wait times).
+    /// The total duration of the benchmark.
     pub(crate) total_duration: Duration,
-    /// The total execution-only duration (excludes wait times).
-    pub(crate) execution_duration: Duration,
+    /// The total gas used per second.
+    pub(crate) total_gas_per_second: f64,
     /// The number of blocks processed.
     pub(crate) blocks_processed: u64,
 }
 
 impl TotalGasOutput {
-    /// Create a new [`TotalGasOutput`] from gas rows only.
-    ///
-    /// Use this when execution-only timing is not available (e.g., `new_payload_only`).
-    /// `execution_duration` will equal `total_duration`.
+    /// Create a new [`TotalGasOutput`] from a list of [`TotalGasRow`].
     pub(crate) fn new(rows: Vec<TotalGasRow>) -> eyre::Result<Self> {
+        // the duration is obtained from the last row
         let total_duration = rows.last().map(|row| row.time).ok_or_eyre("empty results")?;
         let blocks_processed = rows.len() as u64;
         let total_gas_used: u64 = rows.into_iter().map(|row| row.gas_used).sum();
+        let total_gas_per_second = total_gas_used as f64 / total_duration.as_secs_f64();
 
-        Ok(Self {
-            total_gas_used,
-            total_duration,
-            execution_duration: total_duration,
-            blocks_processed,
-        })
+        Ok(Self { total_gas_used, total_duration, total_gas_per_second, blocks_processed })
     }
 
-    /// Create a new [`TotalGasOutput`] from gas rows and combined results.
-    ///
-    /// - `rows`: Used for total gas and wall-clock duration
-    /// - `combined_results`: Used for execution-only duration (sum of `total_latency`)
-    pub(crate) fn with_combined_results(
-        rows: Vec<TotalGasRow>,
-        combined_results: &[CombinedResult],
-    ) -> eyre::Result<Self> {
-        let total_duration = rows.last().map(|row| row.time).ok_or_eyre("empty results")?;
-        let blocks_processed = rows.len() as u64;
-        let total_gas_used: u64 = rows.into_iter().map(|row| row.gas_used).sum();
-
-        // Sum execution-only time from combined results
-        let execution_duration: Duration = combined_results.iter().map(|r| r.total_latency).sum();
-
-        Ok(Self { total_gas_used, total_duration, execution_duration, blocks_processed })
-    }
-
-    /// Return the total gigagas per second based on wall-clock time.
+    /// Return the total gigagas per second.
     pub(crate) fn total_gigagas_per_second(&self) -> f64 {
-        self.total_gas_used as f64 / self.total_duration.as_secs_f64() / GIGAGAS as f64
+        self.total_gas_per_second / GIGAGAS as f64
     }
-
-    /// Return the execution-only gigagas per second (excludes wait times).
-    pub(crate) fn execution_gigagas_per_second(&self) -> f64 {
-        self.total_gas_used as f64 / self.execution_duration.as_secs_f64() / GIGAGAS as f64
-    }
-}
-
-/// Write benchmark results to CSV files.
-///
-/// Writes two files to the output directory:
-/// - `combined_latency.csv`: Per-block latency results
-/// - `total_gas.csv`: Per-block gas usage over time
-pub(crate) fn write_benchmark_results(
-    output_dir: &Path,
-    gas_results: &[TotalGasRow],
-    combined_results: &[CombinedResult],
-) -> eyre::Result<()> {
-    fs::create_dir_all(output_dir)?;
-
-    let output_path = output_dir.join(COMBINED_OUTPUT_SUFFIX);
-    info!(target: "reth-bench", "Writing engine api call latency output to file: {:?}", output_path);
-    let mut writer = Writer::from_path(&output_path)?;
-    for result in combined_results {
-        writer.serialize(result)?;
-    }
-    writer.flush()?;
-
-    let output_path = output_dir.join(GAS_OUTPUT_SUFFIX);
-    info!(target: "reth-bench", "Writing total gas output to file: {:?}", output_path);
-    let mut writer = Writer::from_path(&output_path)?;
-    for row in gas_results {
-        writer.serialize(row)?;
-    }
-    writer.flush()?;
-
-    info!(target: "reth-bench", "Finished writing benchmark output files to {:?}.", output_dir);
-    Ok(())
 }
 
 /// This serializes the `time` field of the [`TotalGasRow`] to microseconds.

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

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

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

@@ -1,485 +0,0 @@
-//! Command for replaying pre-generated payloads from disk.
-//!
-//! This command reads `ExecutionPayloadEnvelopeV4` files from a directory and replays them
-//! in sequence using `newPayload` followed by `forkchoiceUpdated`.
-//!
-//! Supports configurable waiting behavior:
-//! - **`--wait-time`**: Fixed sleep interval between blocks.
-//! - **`--wait-for-persistence`**: Waits for every Nth block to be persisted using the
-//!   `reth_subscribePersistedBlock` subscription, where N matches the engine's persistence
-//!   threshold. This ensures the benchmark doesn't outpace persistence.
-//!
-//! Both options can be used together or independently.
-
-use crate::{
-    authenticated_transport::AuthenticatedTransportConnect,
-    bench::{
-        output::{
-            write_benchmark_results, CombinedResult, GasRampPayloadFile, NewPayloadResult,
-            TotalGasOutput, TotalGasRow,
-        },
-        persistence_waiter::{
-            derive_ws_rpc_url, setup_persistence_subscription, PersistenceWaiter,
-            PERSISTENCE_CHECKPOINT_TIMEOUT,
-        },
-    },
-    valid_payload::{call_forkchoice_updated, call_new_payload},
-};
-use alloy_primitives::B256;
-use alloy_provider::{ext::EngineApi, network::AnyNetwork, Provider, RootProvider};
-use alloy_rpc_client::ClientBuilder;
-use alloy_rpc_types_engine::{ExecutionPayloadEnvelopeV4, ForkchoiceState, JwtSecret};
-use clap::Parser;
-use eyre::Context;
-use humantime::parse_duration;
-use reth_cli_runner::CliContext;
-use reth_engine_primitives::config::DEFAULT_PERSISTENCE_THRESHOLD;
-use reth_node_api::EngineApiMessageVersion;
-use std::{
-    path::PathBuf,
-    time::{Duration, Instant},
-};
-use tracing::{debug, info};
-use url::Url;
-
-/// `reth bench replay-payloads` command
-///
-/// Replays pre-generated payloads from a directory by calling `newPayload` followed by
-/// `forkchoiceUpdated` for each payload in sequence.
-#[derive(Debug, Parser)]
-pub struct Command {
-    /// The engine RPC URL (with JWT authentication).
-    #[arg(long, value_name = "ENGINE_RPC_URL", default_value = "http://localhost:8551")]
-    engine_rpc_url: String,
-
-    /// Path to the JWT secret file for engine API authentication.
-    #[arg(long, value_name = "JWT_SECRET")]
-    jwt_secret: PathBuf,
-
-    /// Directory containing payload files (`payload_block_N.json`).
-    #[arg(long, value_name = "PAYLOAD_DIR")]
-    payload_dir: PathBuf,
-
-    /// Optional limit on the number of payloads to replay.
-    /// If not specified, replays all payloads in the directory.
-    #[arg(long, value_name = "COUNT")]
-    count: Option<usize>,
-
-    /// Skip the first N payloads.
-    #[arg(long, value_name = "SKIP", default_value = "0")]
-    skip: usize,
-
-    /// Optional directory containing gas ramp payloads to replay first.
-    /// These are replayed before the main payloads to warm up the gas limit.
-    #[arg(long, value_name = "GAS_RAMP_DIR")]
-    gas_ramp_dir: Option<PathBuf>,
-
-    /// Optional output directory for benchmark results (CSV files).
-    #[arg(long, value_name = "OUTPUT")]
-    output: Option<PathBuf>,
-
-    /// How long to wait after a forkchoice update before sending the next payload.
-    #[arg(long, value_name = "WAIT_TIME", value_parser = parse_duration, verbatim_doc_comment)]
-    wait_time: Option<Duration>,
-
-    /// Wait for blocks to be persisted before sending the next batch.
-    ///
-    /// When enabled, waits for every Nth block to be persisted using the
-    /// `reth_subscribePersistedBlock` subscription. This ensures the benchmark
-    /// doesn't outpace persistence.
-    ///
-    /// The subscription uses the regular RPC websocket endpoint (no JWT required).
-    #[arg(long, default_value = "false", verbatim_doc_comment)]
-    wait_for_persistence: bool,
-
-    /// Engine persistence threshold used for deciding when to wait for persistence.
-    ///
-    /// The benchmark waits after every `(threshold + 1)` blocks. By default this
-    /// matches the engine's `DEFAULT_PERSISTENCE_THRESHOLD` (2), so waits occur
-    /// at blocks 3, 6, 9, etc.
-    #[arg(
-        long = "persistence-threshold",
-        value_name = "PERSISTENCE_THRESHOLD",
-        default_value_t = DEFAULT_PERSISTENCE_THRESHOLD,
-        verbatim_doc_comment
-    )]
-    persistence_threshold: u64,
-
-    /// Optional `WebSocket` RPC URL for persistence subscription.
-    /// If not provided, derives from engine RPC URL by changing scheme to ws and port to 8546.
-    #[arg(long, value_name = "WS_RPC_URL", verbatim_doc_comment)]
-    ws_rpc_url: Option<String>,
-}
-
-/// A loaded payload ready for execution.
-struct LoadedPayload {
-    /// The index (from filename).
-    index: u64,
-    /// The payload envelope.
-    envelope: ExecutionPayloadEnvelopeV4,
-    /// The block hash.
-    block_hash: B256,
-}
-
-/// A gas ramp payload loaded from disk.
-struct GasRampPayload {
-    /// Block number from filename.
-    block_number: u64,
-    /// Engine API version for newPayload.
-    version: EngineApiMessageVersion,
-    /// The file contents.
-    file: GasRampPayloadFile,
-}
-
-impl Command {
-    /// Execute the `replay-payloads` command.
-    pub async fn execute(self, _ctx: CliContext) -> eyre::Result<()> {
-        info!(target: "reth-bench", payload_dir = %self.payload_dir.display(), "Replaying payloads");
-
-        // Log mode configuration
-        if let Some(duration) = self.wait_time {
-            info!(target: "reth-bench", "Using wait-time mode with {}ms delay between blocks", duration.as_millis());
-        }
-        if self.wait_for_persistence {
-            info!(
-                target: "reth-bench",
-                "Persistence waiting enabled (waits after every {} blocks to match engine gap > {} behavior)",
-                self.persistence_threshold + 1,
-                self.persistence_threshold
-            );
-        }
-
-        // Set up waiter based on configured options
-        // When both are set: wait at least wait_time, and also wait for persistence if needed
-        let mut waiter = match (self.wait_time, self.wait_for_persistence) {
-            (Some(duration), true) => {
-                let ws_url = derive_ws_rpc_url(self.ws_rpc_url.as_deref(), &self.engine_rpc_url)?;
-                let sub = setup_persistence_subscription(ws_url).await?;
-                Some(PersistenceWaiter::with_duration_and_subscription(
-                    duration,
-                    sub,
-                    self.persistence_threshold,
-                    PERSISTENCE_CHECKPOINT_TIMEOUT,
-                ))
-            }
-            (Some(duration), false) => Some(PersistenceWaiter::with_duration(duration)),
-            (None, true) => {
-                let ws_url = derive_ws_rpc_url(self.ws_rpc_url.as_deref(), &self.engine_rpc_url)?;
-                let sub = setup_persistence_subscription(ws_url).await?;
-                Some(PersistenceWaiter::with_subscription(
-                    sub,
-                    self.persistence_threshold,
-                    PERSISTENCE_CHECKPOINT_TIMEOUT,
-                ))
-            }
-            (None, false) => None,
-        };
-
-        // Set up authenticated engine provider
-        let jwt =
-            std::fs::read_to_string(&self.jwt_secret).wrap_err("Failed to read JWT secret file")?;
-        let jwt = JwtSecret::from_hex(jwt.trim())?;
-        let auth_url = Url::parse(&self.engine_rpc_url)?;
-
-        info!(target: "reth-bench", "Connecting to Engine RPC at {}", auth_url);
-        let auth_transport = AuthenticatedTransportConnect::new(auth_url.clone(), jwt);
-        let auth_client = ClientBuilder::default().connect_with(auth_transport).await?;
-        let auth_provider = RootProvider::<AnyNetwork>::new(auth_client);
-
-        // Get parent block (latest canonical block) - we need this for the first FCU
-        let parent_block = auth_provider
-            .get_block_by_number(alloy_eips::BlockNumberOrTag::Latest)
-            .await?
-            .ok_or_else(|| eyre::eyre!("Failed to fetch latest block"))?;
-
-        let initial_parent_hash = parent_block.header.hash;
-        let initial_parent_number = parent_block.header.number;
-
-        info!(
-            target: "reth-bench",
-            parent_hash = %initial_parent_hash,
-            parent_number = initial_parent_number,
-            "Using initial parent block"
-        );
-
-        // Load all payloads upfront to avoid I/O delays between phases
-        let gas_ramp_payloads = if let Some(ref gas_ramp_dir) = self.gas_ramp_dir {
-            let payloads = self.load_gas_ramp_payloads(gas_ramp_dir)?;
-            if payloads.is_empty() {
-                return Err(eyre::eyre!("No gas ramp payload files found in {:?}", gas_ramp_dir));
-            }
-            info!(target: "reth-bench", count = payloads.len(), "Loaded gas ramp payloads from disk");
-            payloads
-        } else {
-            Vec::new()
-        };
-
-        let payloads = self.load_payloads()?;
-        if payloads.is_empty() {
-            return Err(eyre::eyre!("No payload files found in {:?}", self.payload_dir));
-        }
-        info!(target: "reth-bench", count = payloads.len(), "Loaded main payloads from disk");
-
-        let mut parent_hash = initial_parent_hash;
-
-        // Replay gas ramp payloads first
-        for (i, payload) in gas_ramp_payloads.iter().enumerate() {
-            info!(
-                target: "reth-bench",
-                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!(target: "reth-bench", gas_ramp_payload = i + 1, "Gas ramp payload executed successfully");
-
-            if let Some(w) = &mut waiter {
-                w.on_block(payload.block_number).await?;
-            }
-
-            parent_hash = payload.file.block_hash;
-        }
-
-        if !gas_ramp_payloads.is_empty() {
-            info!(target: "reth-bench", count = gas_ramp_payloads.len(), "All gas ramp payloads replayed");
-        }
-
-        let mut results = Vec::new();
-        let total_benchmark_duration = Instant::now();
-
-        for (i, payload) in payloads.iter().enumerate() {
-            let envelope = &payload.envelope;
-            let block_hash = payload.block_hash;
-            let execution_payload = &envelope.envelope_inner.execution_payload;
-            let inner_payload = &execution_payload.payload_inner.payload_inner;
-
-            let gas_used = inner_payload.gas_used;
-            let gas_limit = inner_payload.gas_limit;
-            let block_number = inner_payload.block_number;
-            let transaction_count =
-                execution_payload.payload_inner.payload_inner.transactions.len() as u64;
-
-            debug!(
-                target: "reth-bench",
-                payload = i + 1,
-                total = payloads.len(),
-                index = payload.index,
-                block_hash = %block_hash,
-                "Executing payload (newPayload + FCU)"
-            );
-
-            let start = Instant::now();
-
-            debug!(
-                target: "reth-bench",
-                method = "engine_newPayloadV4",
-                block_hash = %block_hash,
-                "Sending newPayload"
-            );
-
-            let status = auth_provider
-                .new_payload_v4(
-                    execution_payload.clone(),
-                    vec![],
-                    B256::ZERO,
-                    envelope.execution_requests.to_vec(),
-                )
-                .await?;
-
-            let new_payload_result = NewPayloadResult { gas_used, latency: start.elapsed() };
-
-            if !status.is_valid() {
-                return Err(eyre::eyre!("Payload rejected: {:?}", status));
-            }
-
-            let fcu_state = ForkchoiceState {
-                head_block_hash: block_hash,
-                safe_block_hash: parent_hash,
-                finalized_block_hash: parent_hash,
-            };
-
-            debug!(target: "reth-bench", method = "engine_forkchoiceUpdatedV3", ?fcu_state, "Sending forkchoiceUpdated");
-
-            let fcu_result = auth_provider.fork_choice_updated_v3(fcu_state, None).await?;
-
-            let total_latency = start.elapsed();
-            let fcu_latency = total_latency - new_payload_result.latency;
-
-            let combined_result = CombinedResult {
-                block_number,
-                gas_limit,
-                transaction_count,
-                new_payload_result,
-                fcu_latency,
-                total_latency,
-            };
-
-            let current_duration = total_benchmark_duration.elapsed();
-            info!(target: "reth-bench", %combined_result);
-
-            if let Some(w) = &mut waiter {
-                w.on_block(block_number).await?;
-            }
-
-            let gas_row =
-                TotalGasRow { block_number, transaction_count, gas_used, time: current_duration };
-            results.push((gas_row, combined_result));
-
-            debug!(target: "reth-bench", ?status, ?fcu_result, "Payload executed successfully");
-            parent_hash = block_hash;
-        }
-
-        // Drop waiter - we don't need to wait for final blocks to persist
-        // since the benchmark goal is measuring Ggas/s of newPayload/FCU, not persistence.
-        drop(waiter);
-
-        let (gas_output_results, combined_results): (Vec<TotalGasRow>, Vec<CombinedResult>) =
-            results.into_iter().unzip();
-
-        if let Some(ref path) = self.output {
-            write_benchmark_results(path, &gas_output_results, &combined_results)?;
-        }
-
-        let gas_output =
-            TotalGasOutput::with_combined_results(gas_output_results, &combined_results)?;
-        info!(
-            target: "reth-bench",
-            total_gas_used = gas_output.total_gas_used,
-            total_duration = ?gas_output.total_duration,
-            execution_duration = ?gas_output.execution_duration,
-            blocks_processed = gas_output.blocks_processed,
-            wall_clock_ggas_per_second = format_args!("{:.4}", gas_output.total_gigagas_per_second()),
-            execution_ggas_per_second = format_args!("{:.4}", gas_output.execution_gigagas_per_second()),
-            "Benchmark complete"
-        );
-
-        Ok(())
-    }
-
-    /// Load and parse all payload files from the directory.
-    fn load_payloads(&self) -> eyre::Result<Vec<LoadedPayload>> {
-        let mut payloads = Vec::new();
-
-        // Read directory entries
-        let entries: Vec<_> = std::fs::read_dir(&self.payload_dir)
-            .wrap_err_with(|| format!("Failed to read directory {:?}", self.payload_dir))?
-            .filter_map(|e| e.ok())
-            .filter(|e| {
-                e.path().extension().and_then(|s| s.to_str()) == Some("json") &&
-                    e.file_name().to_string_lossy().starts_with("payload_block_")
-            })
-            .collect();
-
-        // Parse filenames to get indices and sort
-        let mut indexed_paths: Vec<(u64, PathBuf)> = entries
-            .into_iter()
-            .filter_map(|e| {
-                let name = e.file_name();
-                let name_str = name.to_string_lossy();
-                // Extract index from "payload_NNN.json"
-                let index_str = name_str.strip_prefix("payload_block_")?.strip_suffix(".json")?;
-                let index: u64 = index_str.parse().ok()?;
-                Some((index, e.path()))
-            })
-            .collect();
-
-        indexed_paths.sort_by_key(|(idx, _)| *idx);
-
-        // Apply skip and count
-        let indexed_paths: Vec<_> = indexed_paths.into_iter().skip(self.skip).collect();
-        let indexed_paths: Vec<_> = match self.count {
-            Some(count) => indexed_paths.into_iter().take(count).collect(),
-            None => indexed_paths,
-        };
-
-        // Load each payload
-        for (index, path) in indexed_paths {
-            let content = std::fs::read_to_string(&path)
-                .wrap_err_with(|| format!("Failed to read {:?}", path))?;
-            let envelope: ExecutionPayloadEnvelopeV4 = serde_json::from_str(&content)
-                .wrap_err_with(|| format!("Failed to parse {:?}", path))?;
-
-            let block_hash =
-                envelope.envelope_inner.execution_payload.payload_inner.payload_inner.block_hash;
-
-            debug!(
-                target: "reth-bench",
-                index = index,
-                block_hash = %block_hash,
-                path = %path.display(),
-                "Loaded payload"
-            );
-
-            payloads.push(LoadedPayload { index, envelope, block_hash });
-        }
-
-        Ok(payloads)
-    }
-
-    /// Load and parse gas ramp payload files from a directory.
-    fn load_gas_ramp_payloads(&self, dir: &PathBuf) -> eyre::Result<Vec<GasRampPayload>> {
-        let mut payloads = Vec::new();
-
-        let entries: Vec<_> = std::fs::read_dir(dir)
-            .wrap_err_with(|| format!("Failed to read directory {:?}", dir))?
-            .filter_map(|e| e.ok())
-            .filter(|e| {
-                e.path().extension().and_then(|s| s.to_str()) == Some("json") &&
-                    e.file_name().to_string_lossy().starts_with("payload_block_")
-            })
-            .collect();
-
-        // Parse filenames to get block numbers and sort
-        let mut indexed_paths: Vec<(u64, PathBuf)> = entries
-            .into_iter()
-            .filter_map(|e| {
-                let name = e.file_name();
-                let name_str = name.to_string_lossy();
-                // Extract block number from "payload_block_NNN.json"
-                let block_str = name_str.strip_prefix("payload_block_")?.strip_suffix(".json")?;
-                let block_number: u64 = block_str.parse().ok()?;
-                Some((block_number, e.path()))
-            })
-            .collect();
-
-        indexed_paths.sort_by_key(|(num, _)| *num);
-
-        for (block_number, path) in indexed_paths {
-            let content = std::fs::read_to_string(&path)
-                .wrap_err_with(|| format!("Failed to read {:?}", path))?;
-            let file: GasRampPayloadFile = serde_json::from_str(&content)
-                .wrap_err_with(|| format!("Failed to parse {:?}", path))?;
-
-            let version = match file.version {
-                1 => EngineApiMessageVersion::V1,
-                2 => EngineApiMessageVersion::V2,
-                3 => EngineApiMessageVersion::V3,
-                4 => EngineApiMessageVersion::V4,
-                5 => EngineApiMessageVersion::V5,
-                v => return Err(eyre::eyre!("Invalid version {} in {:?}", v, path)),
-            };
-
-            info!(
-                block_number,
-                block_hash = %file.block_hash,
-                path = %path.display(),
-                "Loaded gas ramp payload"
-            );
-
-            payloads.push(GasRampPayload { block_number, version, file });
-        }
-
-        Ok(payloads)
-    }
-}

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,347 +0,0 @@
-//! Command for sending invalid payloads to test Engine API rejection.
-
-mod invalidation;
-use invalidation::InvalidationConfig;
-
-use super::helpers::{load_jwt_secret, read_input};
-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::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 {
-    /// 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 = read_input(self.path.as_deref())?;
-        let jwt_secret = load_jwt_secret(self.jwt_secret.as_deref())?;
-
-        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/bench/send_payload.rs

@@ -1,11 +1,10 @@
-use super::helpers::{load_jwt_secret, read_input};
 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::Write;
+use std::io::{BufReader, Read, Write};
 
 /// Command for generating and sending an `engine_newPayload` request constructed from an RPC
 /// block.
@@ -52,13 +51,38 @@ enum Mode {
 }
 
 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) => {
+                // Try to read as file first
+                match std::fs::read_to_string(secret) {
+                    Ok(contents) => Ok(Some(contents.trim().to_string())),
+                    // If file read fails, use the string directly
+                    Err(_) => Ok(Some(secret.clone())),
+                }
+            }
+            None => Ok(None),
+        }
+    }
+
     /// Execute the generate payload command
     pub async fn execute(self, _ctx: CliContext) -> Result<()> {
         // Load block
-        let block_json = read_input(self.path.as_deref())?;
+        let block_json = self.read_input()?;
 
         // Load JWT secret
-        let jwt_secret = load_jwt_secret(self.jwt_secret.as_deref())?;
+        let jwt_secret = self.load_jwt_secret()?;
 
         // Parse the block
         let block = serde_json::from_str::<AnyRpcBlock>(&block_json)?

bin/reth-bench/src/bench_mode.rs

@@ -5,8 +5,9 @@ use std::ops::RangeInclusive;
 /// Whether or not the benchmark should run as a continuous stream of payloads.
 #[derive(Debug, PartialEq, Eq)]
 pub enum BenchMode {
+    // TODO: just include the start block in `Continuous`
     /// Run the benchmark as a continuous stream of payloads, until the benchmark is interrupted.
-    Continuous(u64),
+    Continuous,
     /// Run the benchmark for a specific range of blocks.
     Range(RangeInclusive<u64>),
 }
@@ -15,19 +16,18 @@ impl BenchMode {
     /// Check if the block number is in the range
     pub fn contains(&self, block_number: u64) -> bool {
         match self {
-            Self::Continuous(start) => block_number >= *start,
+            Self::Continuous => true,
             Self::Range(range) => range.contains(&block_number),
         }
     }
 
     /// Create a [`BenchMode`] from optional `from` and `to` fields.
-    pub fn new(from: Option<u64>, to: Option<u64>, latest_block: u64) -> Result<Self, eyre::Error> {
+    pub fn new(from: Option<u64>, to: Option<u64>) -> Result<Self, eyre::Error> {
         // If neither `--from` nor `--to` are provided, we will run the benchmark continuously,
         // starting at the latest block.
         match (from, to) {
             (Some(from), Some(to)) => Ok(Self::Range(from..=to)),
-            (None, None) => Ok(Self::Continuous(latest_block)),
-            (Some(start), None) => Ok(Self::Continuous(start)),
+            (None, None) => Ok(Self::Continuous),
             _ => {
                 // both or neither are allowed, everything else is ambiguous
                 Err(eyre::eyre!("`from` and `to` must be provided together, or not at all."))

bin/reth-bench/src/main.rs

@@ -23,7 +23,7 @@ use bench::BenchmarkCommand;
 use clap::Parser;
 use reth_cli_runner::CliRunner;
 
-fn main() -> eyre::Result<()> {
+fn main() {
     // Enable backtraces unless a RUST_BACKTRACE value has already been explicitly provided.
     if std::env::var_os("RUST_BACKTRACE").is_none() {
         unsafe {
@@ -31,11 +31,12 @@ fn main() -> eyre::Result<()> {
         }
     }
 
-    color_eyre::install()?;
-
     // Run until either exit or sigint or sigterm
-    let runner = CliRunner::try_default_runtime()?;
-    runner.run_command_until_exit(|ctx| BenchmarkCommand::parse().execute(ctx))?;
-
-    Ok(())
+    let runner = CliRunner::try_default_runtime().unwrap();
+    runner
+        .run_command_until_exit(|ctx| {
+            let command = BenchmarkCommand::parse();
+            command.execute(ctx)
+        })
+        .unwrap();
 }

bin/reth-bench/src/valid_payload.rs

@@ -3,16 +3,15 @@
 //! before sending additional calls.
 
 use alloy_eips::eip7685::Requests;
-use alloy_primitives::B256;
 use alloy_provider::{ext::EngineApi, network::AnyRpcBlock, Network, Provider};
 use alloy_rpc_types_engine::{
-    ExecutionPayload, ExecutionPayloadInputV2, ExecutionPayloadSidecar, ForkchoiceState,
-    ForkchoiceUpdated, PayloadAttributes, PayloadStatus,
+    ExecutionPayload, ExecutionPayloadInputV2, ForkchoiceState, ForkchoiceUpdated,
+    PayloadAttributes, PayloadStatus,
 };
 use alloy_transport::TransportResult;
 use op_alloy_rpc_types_engine::OpExecutionPayloadV4;
 use reth_node_api::EngineApiMessageVersion;
-use tracing::{debug, error};
+use tracing::error;
 
 /// An extension trait for providers that implement the engine API, to wait for a VALID response.
 #[async_trait::async_trait]
@@ -53,21 +52,12 @@ where
         fork_choice_state: ForkchoiceState,
         payload_attributes: Option<PayloadAttributes>,
     ) -> TransportResult<ForkchoiceUpdated> {
-        debug!(
-            target: "reth-bench",
-            method = "engine_forkchoiceUpdatedV1",
-            ?fork_choice_state,
-            ?payload_attributes,
-            "Sending forkchoiceUpdated"
-        );
-
         let mut status =
             self.fork_choice_updated_v1(fork_choice_state, payload_attributes.clone()).await?;
 
         while !status.is_valid() {
             if status.is_invalid() {
                 error!(
-                    target: "reth-bench",
                     ?status,
                     ?fork_choice_state,
                     ?payload_attributes,
@@ -92,21 +82,12 @@ where
         fork_choice_state: ForkchoiceState,
         payload_attributes: Option<PayloadAttributes>,
     ) -> TransportResult<ForkchoiceUpdated> {
-        debug!(
-            target: "reth-bench",
-            method = "engine_forkchoiceUpdatedV2",
-            ?fork_choice_state,
-            ?payload_attributes,
-            "Sending forkchoiceUpdated"
-        );
-
         let mut status =
             self.fork_choice_updated_v2(fork_choice_state, payload_attributes.clone()).await?;
 
         while !status.is_valid() {
             if status.is_invalid() {
                 error!(
-                    target: "reth-bench",
                     ?status,
                     ?fork_choice_state,
                     ?payload_attributes,
@@ -131,21 +112,12 @@ where
         fork_choice_state: ForkchoiceState,
         payload_attributes: Option<PayloadAttributes>,
     ) -> TransportResult<ForkchoiceUpdated> {
-        debug!(
-            target: "reth-bench",
-            method = "engine_forkchoiceUpdatedV3",
-            ?fork_choice_state,
-            ?payload_attributes,
-            "Sending forkchoiceUpdated"
-        );
-
         let mut status =
             self.fork_choice_updated_v3(fork_choice_state, payload_attributes.clone()).await?;
 
         while !status.is_valid() {
             if status.is_invalid() {
                 error!(
-                    target: "reth-bench",
                     ?status,
                     ?fork_choice_state,
                     ?payload_attributes,
@@ -176,47 +148,33 @@ pub(crate) fn block_to_new_payload(
 
     // Convert to execution payload
     let (payload, sidecar) = ExecutionPayload::from_block_slow(&block);
-    payload_to_new_payload(payload, sidecar, is_optimism, block.withdrawals_root, None)
-}
 
-pub(crate) fn payload_to_new_payload(
-    payload: ExecutionPayload,
-    sidecar: ExecutionPayloadSidecar,
-    is_optimism: bool,
-    withdrawals_root: Option<B256>,
-    target_version: Option<EngineApiMessageVersion>,
-) -> eyre::Result<(EngineApiMessageVersion, serde_json::Value)> {
     let (version, params) = match payload {
         ExecutionPayload::V3(payload) => {
             let cancun = sidecar.cancun().unwrap();
 
             if let Some(prague) = sidecar.prague() {
-                // Use target version if provided (for Osaka), otherwise default to V4
-                let version = target_version.unwrap_or(EngineApiMessageVersion::V4);
-
                 if is_optimism {
-                    let withdrawals_root = withdrawals_root.ok_or_else(|| {
-                        eyre::eyre!("Missing withdrawals root for Optimism payload")
-                    })?;
                     (
-                        version,
+                        EngineApiMessageVersion::V4,
                         serde_json::to_value((
-                            OpExecutionPayloadV4 { payload_inner: payload, withdrawals_root },
+                            OpExecutionPayloadV4 {
+                                payload_inner: payload,
+                                withdrawals_root: block.withdrawals_root.unwrap(),
+                            },
                             cancun.versioned_hashes.clone(),
                             cancun.parent_beacon_block_root,
                             Requests::default(),
                         ))?,
                     )
                 } else {
-                    // Extract actual Requests from RequestsOrHash
-                    let requests = prague.requests.requests_hash();
                     (
-                        version,
+                        EngineApiMessageVersion::V4,
                         serde_json::to_value((
                             payload,
                             cancun.versioned_hashes.clone(),
                             cancun.parent_beacon_block_root,
-                            requests,
+                            prague.requests.requests_hash(),
                         ))?,
                     )
                 }
@@ -259,16 +217,12 @@ pub(crate) async fn call_new_payload<N: Network, P: Provider<N>>(
 ) -> TransportResult<()> {
     let method = version.method_name();
 
-    debug!(target: "reth-bench", method, "Sending newPayload");
-
     let mut status: PayloadStatus = provider.client().request(method, &params).await?;
 
     while !status.is_valid() {
         if status.is_invalid() {
-            error!(target: "reth-bench", ?status, ?params, "Invalid {method}",);
-            return Err(alloy_json_rpc::RpcError::LocalUsageError(Box::new(std::io::Error::other(
-                format!("Invalid {method}: {status:?}"),
-            ))))
+            error!(?status, ?params, "Invalid {method}",);
+            panic!("Invalid {method}: {status:?}");
         }
         if status.is_syncing() {
             return Err(alloy_json_rpc::RpcError::UnsupportedFeature(
@@ -283,15 +237,12 @@ pub(crate) async fn call_new_payload<N: Network, P: Provider<N>>(
 /// Calls the correct `engine_forkchoiceUpdated` method depending on the given
 /// `EngineApiMessageVersion`, using the provided forkchoice state and payload attributes for the
 /// actual engine api message call.
-///
-/// Note: For Prague (V4), we still use forkchoiceUpdatedV3 as there is no V4.
 pub(crate) async fn call_forkchoice_updated<N, P: EngineApiValidWaitExt<N>>(
     provider: P,
     message_version: EngineApiMessageVersion,
     forkchoice_state: ForkchoiceState,
     payload_attributes: Option<PayloadAttributes>,
 ) -> TransportResult<ForkchoiceUpdated> {
-    // FCU V3 is used for both Cancun and Prague (there is no FCU V4)
     match message_version {
         EngineApiMessageVersion::V3 | EngineApiMessageVersion::V4 | EngineApiMessageVersion::V5 => {
             provider.fork_choice_updated_v3_wait(forkchoice_state, payload_attributes).await

bin/reth/Cargo.toml

@@ -81,25 +81,12 @@ backon.workspace = true
 tempfile.workspace = true
 
 [features]
-default = [
-    "jemalloc",
-    "otlp",
-    "otlp-logs",
-    "reth-revm/portable",
-    "js-tracer",
-    "keccak-cache-global",
-    "asm-keccak",
-    "rocksdb",
-]
+default = ["jemalloc", "otlp", "reth-revm/portable", "js-tracer", "keccak-cache-global"]
 
 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",
@@ -107,7 +94,6 @@ js-tracer = [
     "reth-rpc-eth-types/js-tracer",
 ]
 
-debug-jitter = ["reth-node-builder/debug-jitter"]
 dev = ["reth-ethereum-cli/dev"]
 
 asm-keccak = [
@@ -117,7 +103,6 @@ asm-keccak = [
     "reth-node-ethereum/asm-keccak",
 ]
 keccak-cache-global = [
-    "reth-node-core/keccak-cache-global",
     "reth-node-ethereum/keccak-cache-global",
 ]
 jemalloc = [
@@ -130,11 +115,6 @@ jemalloc-prof = [
     "reth-cli-util/jemalloc",
     "reth-cli-util/jemalloc-prof",
     "reth-ethereum-cli/jemalloc-prof",
-    "reth-node-metrics/jemalloc-prof",
-]
-jemalloc-symbols = [
-    "jemalloc-prof",
-    "reth-ethereum-cli/jemalloc-symbols",
 ]
 jemalloc-unprefixed = [
     "reth-cli-util/jemalloc-unprefixed",
@@ -145,11 +125,6 @@ jemalloc-unprefixed = [
 tracy-allocator = [
     "reth-cli-util/tracy-allocator",
     "reth-ethereum-cli/tracy-allocator",
-    "tracy",
-]
-tracy = [
-    "reth-ethereum-cli/tracy",
-    "reth-node-core/tracy",
 ]
 
 # Because jemalloc is default and preferred over snmalloc when both features are
@@ -190,9 +165,6 @@ min-trace-logs = [
     "reth-node-core/min-trace-logs",
 ]
 
-rocksdb = ["reth-ethereum-cli/rocksdb", "reth-node-core/rocksdb"]
-edge = ["rocksdb"]
-
 [[bin]]
 name = "reth"
 path = "src/main.rs"

bin/reth/src/lib.rs

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

bin/reth/src/main.rs

@@ -3,10 +3,6 @@
 #[global_allocator]
 static ALLOC: reth_cli_util::allocator::Allocator = reth_cli_util::allocator::new_allocator();
 
-#[cfg(all(feature = "jemalloc-prof", unix))]
-#[unsafe(export_name = "_rjem_malloc_conf")]
-static MALLOC_CONF: &[u8] = b"prof:true,prof_active:true,lg_prof_sample:19\0";
-
 use clap::Parser;
 use reth::{args::RessArgs, cli::Cli, ress::install_ress_subprotocol};
 use reth_ethereum_cli::chainspec::EthereumChainSpecParser;

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/chain_info.rs

@@ -33,7 +33,6 @@ where
     ) -> Self {
         let (finalized_block, _) = watch::channel(finalized);
         let (safe_block, _) = watch::channel(safe);
-        let (persisted_block, _) = watch::channel(None);
 
         Self {
             inner: Arc::new(ChainInfoInner {
@@ -43,7 +42,6 @@ where
                 canonical_head: RwLock::new(head),
                 safe_block,
                 finalized_block,
-                persisted_block,
             }),
         }
     }
@@ -99,11 +97,6 @@ where
         self.inner.finalized_block.borrow().as_ref().map(SealedHeader::num_hash)
     }
 
-    /// Returns the `BlockNumHash` of the persisted block.
-    pub fn get_persisted_num_hash(&self) -> Option<BlockNumHash> {
-        *self.inner.persisted_block.borrow()
-    }
-
     /// Sets the canonical head of the chain.
     pub fn set_canonical_head(&self, header: SealedHeader<N::BlockHeader>) {
         let number = header.number();
@@ -137,18 +130,6 @@ where
         });
     }
 
-    /// Sets the persisted block of the chain.
-    pub fn set_persisted(&self, num_hash: BlockNumHash) {
-        self.inner.persisted_block.send_if_modified(|current| {
-            if current.map(|b| b.hash) != Some(num_hash.hash) {
-                let _ = current.replace(num_hash);
-                return true
-            }
-
-            false
-        });
-    }
-
     /// Subscribe to the finalized block.
     pub fn subscribe_finalized_block(
         &self,
@@ -160,11 +141,6 @@ where
     pub fn subscribe_safe_block(&self) -> watch::Receiver<Option<SealedHeader<N::BlockHeader>>> {
         self.inner.safe_block.subscribe()
     }
-
-    /// Subscribe to the persisted block.
-    pub fn subscribe_persisted_block(&self) -> watch::Receiver<Option<BlockNumHash>> {
-        self.inner.persisted_block.subscribe()
-    }
 }
 
 /// Container type for all chain info fields
@@ -183,14 +159,11 @@ struct ChainInfoInner<N: NodePrimitives = reth_ethereum_primitives::EthPrimitive
     safe_block: watch::Sender<Option<SealedHeader<N::BlockHeader>>>,
     /// The block that the beacon node considers finalized.
     finalized_block: watch::Sender<Option<SealedHeader<N::BlockHeader>>>,
-    /// The last block that was persisted to disk.
-    persisted_block: watch::Sender<Option<BlockNumHash>>,
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy_primitives::B256;
     use reth_ethereum_primitives::EthPrimitives;
     use reth_testing_utils::{generators, generators::random_header};
 
@@ -365,28 +338,4 @@ mod tests {
         // Assert that the BlockNumHash returned matches the safe header
         assert_eq!(tracker.get_safe_num_hash(), Some(safe_header.num_hash()));
     }
-
-    #[test]
-    fn test_set_persisted() {
-        let mut rng = generators::rng();
-        let header = random_header(&mut rng, 10, None);
-        let tracker: ChainInfoTracker<EthPrimitives> = ChainInfoTracker::new(header, None, None);
-
-        // Initial state: persisted block should be None
-        assert!(tracker.get_persisted_num_hash().is_none());
-
-        // Set a persisted block
-        let num_hash1 = BlockNumHash::new(10, B256::random());
-        tracker.set_persisted(num_hash1);
-        assert_eq!(tracker.get_persisted_num_hash(), Some(num_hash1));
-
-        // Setting the same block again should not change anything
-        tracker.set_persisted(num_hash1);
-        assert_eq!(tracker.get_persisted_num_hash(), Some(num_hash1));
-
-        // Set a different block
-        let num_hash2 = BlockNumHash::new(20, B256::random());
-        tracker.set_persisted(num_hash2);
-        assert_eq!(tracker.get_persisted_num_hash(), Some(num_hash2));
-    }
 }