wip: add dm-delay simulation

wip: add latency simulation
2026-04-30 03:01:58 -04:00 · 2026-04-22 15:03:17 -04:00 · 2026-04-22 13:40:53 -04:00
197 changed files with 2606 additions and 7548 deletions
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -4,14 +4,10 @@ updates:
  directory: "/"
  schedule:
    interval: "weekly"
-  cooldown:
-    default-days: 7
 - package-ecosystem: "cargo"
  directory: "/"
  schedule:
    interval: "weekly"
-  cooldown:
-    default-days: 7
  labels:
    - "A-dependencies"
  commit-message:
--- a/.github/scripts/bench-reth-build.sh
+++ b/.github/scripts/bench-reth-build.sh
@@ -53,7 +53,7 @@ build_node_binary() {

  # shellcheck disable=SC2086
  RUSTFLAGS="-C target-cpu=native${EXTRA_RUSTFLAGS}" \
-    cargo build --locked --profile profiling $NODE_PKG $workspace_arg $features_arg
+    cargo build --profile profiling $NODE_PKG $workspace_arg $features_arg
 }

 case "$MODE" in
--- a/.github/scripts/bench-reth-run.sh
+++ b/.github/scripts/bench-reth-run.sh
@@ -28,6 +28,127 @@ mkdir -p "$OUTPUT_DIR"
 LOG="${OUTPUT_DIR}/node.log"

 RETH_SCOPE="${RETH_SCOPE:-reth-bench.scope}"
+DELAY_DM_NAME=""
+
+mount_fs() {
+  local source="$1"
+  local target="$2"
+  local fstype="$3"
+  local options="$4"
+
+  local -a mount_cmd=(sudo mount -t "$fstype")
+  if [ -n "$options" ]; then
+    mount_cmd+=(-o "$options")
+  fi
+  mount_cmd+=("$source" "$target")
+  "${mount_cmd[@]}"
+}
+
+wait_for_block_device() {
+  local device="$1"
+  local timeout_s="${2:-5}"
+
+  for _ in $(seq 1 "$timeout_s"); do
+    if [ -b "$device" ]; then
+      return 0
+    fi
+    sleep 1
+  done
+
+  return 1
+}
+
+resolve_dm_block_device() {
+  local device_name="$1"
+  local devno
+
+  devno="$(sudo dmsetup info -C --noheadings --separator : -o major,minor "$device_name" 2>/dev/null | tr -d '[:space:]')"
+  if [ -z "$devno" ]; then
+    return 1
+  fi
+
+  printf '/dev/block/%s\n' "$devno"
+}
+
+setup_delay_target() {
+  local read_delay_ms="${BENCH_DISK_READ_DELAY_MS:-0}"
+  local write_delay_ms="${BENCH_DISK_WRITE_DELAY_MS:-0}"
+  read_delay_ms="${read_delay_ms:-0}"
+  write_delay_ms="${write_delay_ms:-0}"
+
+  if ! [[ "$read_delay_ms" =~ ^[0-9]+$ && "$write_delay_ms" =~ ^[0-9]+$ ]]; then
+    echo "::error::BENCH_DISK_READ_DELAY_MS and BENCH_DISK_WRITE_DELAY_MS must be non-negative integers"
+    exit 1
+  fi
+
+  if [ "$read_delay_ms" = "0" ] && [ "$write_delay_ms" = "0" ]; then
+    return
+  fi
+
+  local mount_source
+  local mount_fstype
+  local mount_options
+  mount_source="$(findmnt -no SOURCE --target "$SCHELK_MOUNT")"
+  mount_fstype="$(findmnt -no FSTYPE --target "$SCHELK_MOUNT")"
+  mount_options="$(findmnt -no OPTIONS --target "$SCHELK_MOUNT")"
+  local sectors
+  sectors="$(sudo blockdev --getsz "$mount_source")"
+
+  DELAY_DM_NAME="reth-bench-delay-${LABEL}-$$"
+  local delayed_device=""
+  local table="0 ${sectors} delay ${mount_source} 0 ${read_delay_ms} ${mount_source} 0 ${write_delay_ms}"
+
+  echo "Applying dm-delay to ${mount_source}: read=${read_delay_ms}ms write=${write_delay_ms}ms"
+  sudo umount "$SCHELK_MOUNT"
+  if ! sudo dmsetup create "$DELAY_DM_NAME" --addnodeoncreate --table "$table"; then
+    DELAY_DM_NAME=""
+    mount_fs "$mount_source" "$SCHELK_MOUNT" "$mount_fstype" "$mount_options"
+    echo "::error::Failed to create dm-delay target"
+    exit 1
+  fi
+
+  delayed_device="$(resolve_dm_block_device "$DELAY_DM_NAME" || true)"
+  if [ -z "$delayed_device" ]; then
+    local failed_device_name="$DELAY_DM_NAME"
+    sudo dmsetup remove "$DELAY_DM_NAME" || true
+    DELAY_DM_NAME=""
+    mount_fs "$mount_source" "$SCHELK_MOUNT" "$mount_fstype" "$mount_options"
+    echo "::error::Failed to resolve delayed device node for ${failed_device_name}"
+    exit 1
+  fi
+
+  if ! wait_for_block_device "$delayed_device"; then
+    delayed_device="$(resolve_dm_block_device "$DELAY_DM_NAME" || true)"
+    if ! wait_for_block_device "$delayed_device"; then
+      sudo dmsetup remove "$DELAY_DM_NAME" || true
+      DELAY_DM_NAME=""
+      mount_fs "$mount_source" "$SCHELK_MOUNT" "$mount_fstype" "$mount_options"
+      echo "::error::Delayed device node did not appear: ${delayed_device}"
+      exit 1
+    fi
+  fi
+
+  if ! mount_fs "$delayed_device" "$SCHELK_MOUNT" "$mount_fstype" "$mount_options"; then
+    sudo dmsetup remove "$DELAY_DM_NAME" || true
+    DELAY_DM_NAME=""
+    mount_fs "$mount_source" "$SCHELK_MOUNT" "$mount_fstype" "$mount_options"
+    echo "::error::Failed to remount delayed device"
+    exit 1
+  fi
+}
+
+teardown_delay_target() {
+  if [ -z "$DELAY_DM_NAME" ]; then
+    return
+  fi
+
+  echo "Removing dm-delay target ${DELAY_DM_NAME}"
+  if mountpoint -q "$SCHELK_MOUNT"; then
+    sudo umount "$SCHELK_MOUNT" || true
+  fi
+  sudo dmsetup remove "$DELAY_DM_NAME" || sudo dmsetup remove -f "$DELAY_DM_NAME" || true
+  DELAY_DM_NAME=""
+}

 cleanup() {
  kill "$TAIL_PID" 2>/dev/null || true
@@ -76,6 +197,7 @@ cleanup() {
  sudo systemctl reset-failed "$RETH_SCOPE" 2>/dev/null || true
  # Fix ownership of reth-created files (reth runs as root)
  sudo chown -R "$(id -un):$(id -gn)" "$OUTPUT_DIR" 2>/dev/null || true
+  teardown_delay_target
  # Let schelk recover the mounted volume in place so dm-era can restore only
  # the changed blocks and clean up its own state.
  sudo schelk recover -y --kill || true
@@ -92,6 +214,7 @@ sudo schelk recover -y --kill || sudo schelk full-recover -y || true

 # Mount
 sudo schelk mount -y || true
+setup_delay_target
 if [ ! -d "$DATADIR/db" ] || [ ! -d "$DATADIR/static_files" ]; then
  echo "::error::Failed to mount benchmark datadir at ${DATADIR}"
  ls -la "$SCHELK_MOUNT" || true
@@ -323,18 +446,13 @@ if [ "$BIG_BLOCKS" = "true" ]; then
    --output "$OUTPUT_DIR" 2>&1 | sed -u "s/^/[bench] /"
 else
  # Standard mode: warmup + new-payload-fcu
-  WARMUP="${BENCH_WARMUP_BLOCKS:-50}"
-  if [ "$WARMUP" -gt 0 ] 2>/dev/null; then
-    # Warm up the node before measuring the benchmark window.
-    $BENCH_NICE "$RETH_BENCH" new-payload-fcu \
-      --rpc-url "$BENCH_RPC_URL" \
-      --engine-rpc-url http://127.0.0.1:8551 \
-      --jwt-secret "$DATADIR/jwt.hex" \
-      --advance "$WARMUP" \
-      "${EXTRA_BENCH_ARGS[@]}" 2>&1 | sed -u "s/^/[bench] /"
-  else
-    echo "Skipping warmup (0 blocks)..."
-  fi
+  # Warmup
+  $BENCH_NICE "$RETH_BENCH" new-payload-fcu \
+    --rpc-url "$BENCH_RPC_URL" \
+    --engine-rpc-url http://127.0.0.1:8551 \
+    --jwt-secret "$DATADIR/jwt.hex" \
+    --advance "${BENCH_WARMUP_BLOCKS:-50}" \
+    "${EXTRA_BENCH_ARGS[@]}" 2>&1 | sed -u "s/^/[bench] /"

  # Start tracy-capture after warmup so profile only covers the benchmark
  if [ "${BENCH_TRACY:-off}" != "off" ]; then
--- a/.github/scripts/hive/build_simulators.sh
+++ b/.github/scripts/hive/build_simulators.sh
@@ -1,23 +1,6 @@
 #!/usr/bin/env bash
 set -eo pipefail

-fixture_variant="${1:-osaka}"
-
-case "${fixture_variant}" in
-    amsterdam)
-        eels_fixtures="https://github.com/ethereum/execution-spec-tests/releases/download/snobal-devnet-5@v8037.0.0/fixtures_snobal-devnet-5.tar.gz"
-        eels_branch="devnets/snobal/5"
-        ;;
-    osaka)
-        eels_fixtures="https://github.com/ethereum/execution-spec-tests/releases/download/v5.3.0/fixtures_develop.tar.gz"
-        eels_branch="forks/osaka"
-        ;;
-    *)
-        echo "unknown hive fixture variant: ${fixture_variant}"
-        exit 1
-        ;;
-esac
-
 # Create the hive_assets directory
 mkdir hive_assets/

@@ -29,12 +12,12 @@ go build .
 # Run each hive command in the background for each simulator and wait
 echo "Building images"
 ./hive -client reth --sim "ethereum/eels/consume-engine" \
-    --sim.buildarg fixtures="${eels_fixtures}" \
-    --sim.buildarg branch="${eels_branch}" \
+    --sim.buildarg fixtures=https://github.com/ethereum/execution-spec-tests/releases/download/v5.3.0/fixtures_develop.tar.gz \
+    --sim.buildarg branch=forks/osaka \
    --sim.timelimit 1s || true &
 ./hive -client reth --sim "ethereum/eels/consume-rlp" \
-    --sim.buildarg fixtures="${eels_fixtures}" \
-    --sim.buildarg branch="${eels_branch}" \
+    --sim.buildarg fixtures=https://github.com/ethereum/execution-spec-tests/releases/download/v5.3.0/fixtures_develop.tar.gz \
+    --sim.buildarg branch=forks/osaka \
    --sim.timelimit 1s || true &
 ./hive -client reth --sim "ethereum/engine" -sim.timelimit 1s || true &
 ./hive -client reth --sim "devp2p" -sim.timelimit 1s || true &
--- a/.github/scripts/hive/expected_failures.yaml
+++ b/.github/scripts/hive/expected_failures.yaml
@@ -13,15 +13,15 @@ rpc-compat:
  # syncing mode, the test expects syncing to be false on start
  - eth_syncing/check-syncing (reth)

-engine-withdrawals: []
+engine-withdrawals: [ ]

-engine-api: []
+engine-api: [ ]

-engine-cancun: []
+engine-cancun: [ ]

-sync: []
+sync: [ ]

-engine-auth: []
+engine-auth: [ ]

 # EIP-7610 related tests (Revert creation in case of non-empty storage):
 #
@@ -99,40 +99,6 @@ eels/consume-engine:
  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Prague-tx_type_1-blockchain_test_engine_from_state_test-non-empty-balance-revert-initcode]-reth
  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Prague-tx_type_2-blockchain_test_engine_from_state_test-non-empty-balance-revert-initcode]-reth
  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Shanghai-tx_type_0-blockchain_test_engine_from_state_test-non-empty-balance-correct-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_opcode[fork_Amsterdam-blockchain_test_engine_from_state_test-opcode_CREATE2-non-empty-balance-correct-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_collision_with_create2_revert_in_initcode[fork_Amsterdam-blockchain_test_engine_from_state_test]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Amsterdam-blockchain_test_engine_from_state_test-initcode-with-deploy]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_opcode[fork_Amsterdam-blockchain_test_engine_from_state_test-opcode_CREATE2-non-empty-balance-revert-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Amsterdam-blockchain_test_engine_from_state_test-empty-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Amsterdam-blockchain_test_engine_from_state_test-sstore-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Amsterdam-tx_type_2-blockchain_test_engine_from_state_test-non-empty-balance-revert-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Amsterdam-tx_type_2-blockchain_test_engine_from_state_test-non-empty-balance-correct-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Amsterdam-tx_type_1-blockchain_test_engine_from_state_test-non-empty-balance-correct-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Amsterdam-tx_type_1-blockchain_test_engine_from_state_test-non-empty-balance-revert-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_opcode[fork_Amsterdam-blockchain_test_engine_from_state_test-opcode_CREATE-non-empty-balance-correct-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Amsterdam-tx_type_0-blockchain_test_engine_from_state_test-non-empty-balance-correct-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Amsterdam-tx_type_0-blockchain_test_engine_from_state_test-non-empty-balance-revert-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_opcode[fork_Amsterdam-blockchain_test_engine_from_state_test-opcode_CREATE-non-empty-balance-revert-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Prague-blockchain_test_engine_from_state_test-initcode-with-deploy]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Prague-blockchain_test_engine_from_state_test-empty-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_collision_with_create2_revert_in_initcode[fork_Prague-blockchain_test_engine_from_state_test]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_collision_with_create2_revert_in_initcode[fork_Shanghai-blockchain_test_engine_from_state_test]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_collision_with_create2_revert_in_initcode[fork_Paris-blockchain_test_engine_from_state_test]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Shanghai-blockchain_test_engine_from_state_test-empty-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_collision_with_create2_revert_in_initcode[fork_Cancun-blockchain_test_engine_from_state_test]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Shanghai-blockchain_test_engine_from_state_test-initcode-with-deploy]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Paris-blockchain_test_engine_from_state_test-initcode-with-deploy]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Cancun-blockchain_test_engine_from_state_test-initcode-with-deploy]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Shanghai-blockchain_test_engine_from_state_test-sstore-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Osaka-blockchain_test_engine_from_state_test-sstore-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Paris-blockchain_test_engine_from_state_test-empty-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Prague-blockchain_test_engine_from_state_test-sstore-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_collision_with_create2_revert_in_initcode[fork_Osaka-blockchain_test_engine_from_state_test]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Cancun-blockchain_test_engine_from_state_test-sstore-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Paris-blockchain_test_engine_from_state_test-sstore-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Osaka-blockchain_test_engine_from_state_test-empty-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Osaka-blockchain_test_engine_from_state_test-initcode-with-deploy]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Cancun-blockchain_test_engine_from_state_test-empty-initcode]-reth

 # Blob limit tests:
 #
@@ -227,37 +193,3 @@ eels/consume-rlp:
  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Prague-tx_type_1-blockchain_test_from_state_test-non-empty-balance-revert-initcode]-reth
  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Prague-tx_type_2-blockchain_test_from_state_test-non-empty-balance-revert-initcode]-reth
  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Shanghai-tx_type_0-blockchain_test_from_state_test-non-empty-balance-correct-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Amsterdam-blockchain_test_from_state_test-initcode-with-deploy]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Amsterdam-blockchain_test_from_state_test-sstore-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Amsterdam-tx_type_2-blockchain_test_from_state_test-non-empty-balance-correct-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Amsterdam-tx_type_2-blockchain_test_from_state_test-non-empty-balance-revert-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Amsterdam-tx_type_1-blockchain_test_from_state_test-non-empty-balance-revert-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_collision_with_create2_revert_in_initcode[fork_Amsterdam-blockchain_test_from_state_test]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Amsterdam-tx_type_1-blockchain_test_from_state_test-non-empty-balance-correct-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Amsterdam-tx_type_0-blockchain_test_from_state_test-non-empty-balance-correct-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_tx[fork_Amsterdam-tx_type_0-blockchain_test_from_state_test-non-empty-balance-revert-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_opcode[fork_Amsterdam-blockchain_test_from_state_test-opcode_CREATE-non-empty-balance-revert-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_opcode[fork_Amsterdam-blockchain_test_from_state_test-opcode_CREATE-non-empty-balance-correct-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_opcode[fork_Amsterdam-blockchain_test_from_state_test-opcode_CREATE2-non-empty-balance-correct-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_initcollision.py::test_init_collision_create_opcode[fork_Amsterdam-blockchain_test_from_state_test-opcode_CREATE2-non-empty-balance-revert-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Amsterdam-blockchain_test_from_state_test-empty-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Prague-blockchain_test_from_state_test-initcode-with-deploy]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Prague-blockchain_test_from_state_test-empty-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_collision_with_create2_revert_in_initcode[fork_Prague-blockchain_test_from_state_test]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_collision_with_create2_revert_in_initcode[fork_Shanghai-blockchain_test_from_state_test]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Cancun-blockchain_test_from_state_test-empty-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_collision_with_create2_revert_in_initcode[fork_Paris-blockchain_test_from_state_test]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Shanghai-blockchain_test_from_state_test-empty-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Shanghai-blockchain_test_from_state_test-initcode-with-deploy]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Paris-blockchain_test_from_state_test-initcode-with-deploy]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_collision_with_create2_revert_in_initcode[fork_Cancun-blockchain_test_from_state_test]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Shanghai-blockchain_test_from_state_test-sstore-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Cancun-blockchain_test_from_state_test-initcode-with-deploy]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Osaka-blockchain_test_from_state_test-sstore-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Paris-blockchain_test_from_state_test-empty-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_collision_with_create2_revert_in_initcode[fork_Osaka-blockchain_test_from_state_test]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Prague-blockchain_test_from_state_test-sstore-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Cancun-blockchain_test_from_state_test-sstore-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Paris-blockchain_test_from_state_test-sstore-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Osaka-blockchain_test_from_state_test-empty-initcode]-reth
-  - tests/paris/eip7610_create_collision/test_revert_in_create.py::test_create2_collision_storage[fork_Osaka-blockchain_test_from_state_test-initcode-with-deploy]-reth
--- a/.github/scripts/hive/run_simulator.sh
+++ b/.github/scripts/hive/run_simulator.sh
@@ -5,12 +5,6 @@ cd hivetests/

 sim="${1}"
 limit="${2}"
-fixture_variant="${3:-}"
-
-if [[ "${fixture_variant}" == "osaka" && "${sim}" == *"eels"* && "${limit}" == *"tests/amsterdam"* ]]; then
-    echo "osaka fixtures do not support amsterdam tests"
-    exit 1
-fi

 # Use lower parallelism for eels tests to avoid OOM-killing the runner
 parallelism=16
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -54,7 +54,9 @@ env:

 name: bench-scheduled

-permissions: {}
+permissions:
+  contents: read
+  actions: read

 jobs:
  # ---------------------------------------------------------------------------
@@ -63,9 +65,6 @@ jobs:
  resolve-refs:
    name: resolve-refs
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      actions: read
    outputs:
      mode: ${{ steps.mode.outputs.mode }}
      baseline-ref: ${{ steps.refs.outputs.baseline-ref }}
@@ -77,26 +76,21 @@ jobs:
      long-running: ${{ steps.refs.outputs.long-running }}
      release-tag: ${{ steps.refs.outputs.release-tag }}
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@v6
        with:
-          persist-credentials: false
          sparse-checkout: .github/scripts
          sparse-checkout-cone-mode: true
          fetch-depth: 2

      - name: Detect mode
        id: mode
-        env:
-          EVENT_NAME: ${{ github.event_name }}
-          INPUT_MODE: ${{ inputs.mode }}
-          SCHEDULE: ${{ github.event.schedule }}
        run: |
          # Maps cron schedules to modes (must match the schedule entries above)
-          if [ "$EVENT_NAME" = "workflow_dispatch" ]; then
-            MODE="${INPUT_MODE:-nightly}"
-          elif [ "$SCHEDULE" = "30 5 * * *" ]; then
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            MODE="${{ inputs.mode || 'nightly' }}"
+          elif [ "${{ github.event.schedule }}" = "30 5 * * *" ]; then
            MODE="nightly"
-          elif [ "$SCHEDULE" = "0 9 * * *" ]; then
+          elif [ "${{ github.event.schedule }}" = "0 9 * * *" ]; then
            MODE="release"
          else
            MODE="hourly"
@@ -111,15 +105,14 @@ jobs:
          DEREK_TOKEN: ${{ secrets.DEREK_TOKEN }}
          GITHUB_REPOSITORY: ${{ github.repository }}
          GITHUB_RUN_ID: ${{ github.run_id }}
-          INPUT_FORCE: ${{ inputs.force || 'false' }}
        run: |
-          FORCE="${INPUT_FORCE:-false}"
+          FORCE="${{ inputs.force || 'false' }}"
          MODE="${{ steps.mode.outputs.mode }}"
          .github/scripts/bench-scheduled-refs.sh "$FORCE" "$MODE"

      - name: Alert on long-running hourly
        if: steps.mode.outputs.mode == 'hourly' && steps.refs.outputs.long-running == 'true' && !(github.event_name == 'workflow_dispatch' && inputs.slack == 'never')
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        env:
          SLACK_BENCH_BOT_TOKEN: ${{ secrets.SLACK_BENCH_BOT_TOKEN }}
          SLACK_BENCH_CHANNEL: ${{ secrets.SLACK_BENCH_CHANNEL }}
@@ -161,7 +154,7 @@ jobs:

      - name: Alert on stale nightly
        if: steps.mode.outputs.mode == 'nightly' && steps.refs.outputs.is-stale == 'true' && !(github.event_name == 'workflow_dispatch' && inputs.slack == 'never')
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        env:
          SLACK_BENCH_BOT_TOKEN: ${{ secrets.SLACK_BENCH_BOT_TOKEN }}
          SLACK_BENCH_CHANNEL: ${{ secrets.SLACK_BENCH_CHANNEL }}
@@ -249,9 +242,6 @@ jobs:
      needs.resolve-refs.outputs.is-stale != 'true'
    name: bench-scheduled
    runs-on: [self-hosted, Linux, X64, available]
-    permissions:
-      contents: read
-      actions: read
    timeout-minutes: 120
    env:
      BENCH_RPC_URL: https://ethereum.reth.rs/rpc
@@ -280,16 +270,15 @@ jobs:
      - name: Clean up previous bench-work
        run: sudo rm -rf "$BENCH_WORK_DIR" 2>/dev/null || true

-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@v6
        with:
-          persist-credentials: false
          submodules: true
          fetch-depth: 0
          ref: ${{ needs.resolve-refs.outputs.feature-ref }}

      - name: Resolve job URL
        id: job-url
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          script: |
            const { data: jobs } = await github.rest.actions.listJobsForWorkflowRun({
@@ -302,9 +291,8 @@ jobs:
            core.exportVariable('BENCH_JOB_URL', jobUrl);

      - uses: dtolnay/rust-toolchain@stable
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
+      - uses: mozilla-actions/sccache-action@v0.0.9
        continue-on-error: true
-      - uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1

      - name: Install dependencies
        env:
@@ -378,24 +366,19 @@ jobs:

      - name: Prepare source dirs
        run: |
-          prepare_source_dir() {
-            local dir="$1"
-            local ref="$2"
+          if [ -d ../reth-baseline ]; then
+            git -C ../reth-baseline fetch origin "$BASELINE_REF"
+          else
+            git clone . ../reth-baseline
+          fi
+          git -C ../reth-baseline checkout "$BASELINE_REF"

-            if [ -d "$dir" ]; then
-              git -C "$dir" reset --hard HEAD
-              git -C "$dir" clean -fdx
-              git -C "$dir" fetch origin "$ref"
-            else
-              git clone . "$dir"
-            fi
-
-            git -C "$dir" checkout --force "$ref"
-          }
-
-          prepare_source_dir ../reth-baseline "$BASELINE_REF"
-
-          prepare_source_dir ../reth-feature "$FEATURE_REF"
+          if [ -d ../reth-feature ]; then
+            git -C ../reth-feature fetch origin "$FEATURE_REF"
+          else
+            git clone . ../reth-feature
+          fi
+          git -C ../reth-feature checkout "$FEATURE_REF"

      - name: Build binaries
        id: build
@@ -640,7 +623,7 @@ jobs:

      - name: Upload results
        if: "!cancelled()"
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        uses: actions/upload-artifact@v7
        with:
          name: bench-scheduled-results
          path: ${{ env.BENCH_WORK_DIR }}
@@ -648,12 +631,10 @@ jobs:
      - name: Push charts
        id: push-charts
        if: success() && env.BENCH_MODE != 'hourly'
-        env:
-          DEREK_TOKEN: ${{ secrets.DEREK_TOKEN }}
-          RUN_ID: ${{ github.run_id }}
        run: |
+          RUN_ID=${{ github.run_id }}
          CHART_DIR="${BENCH_MODE}/${RUN_ID}"
-          CHARTS_REPO="https://x-access-token:${DEREK_TOKEN}@github.com/decofe/reth-bench-charts.git"
+          CHARTS_REPO="https://x-access-token:${{ secrets.DEREK_TOKEN }}@github.com/decofe/reth-bench-charts.git"

          TMP_DIR=$(mktemp -d)
          if git clone --depth 1 "${CHARTS_REPO}" "${TMP_DIR}" 2>/dev/null; then
@@ -674,7 +655,7 @@ jobs:

      - name: Write job summary
        if: success()
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          script: |
            const fs = require('fs');
@@ -753,7 +734,7 @@ jobs:

      - name: Send Slack notification (success)
        if: success() && (env.BENCH_SLACK == 'always' || env.BENCH_SLACK == 'on-win')
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        env:
          SLACK_BENCH_BOT_TOKEN: ${{ secrets.SLACK_BENCH_BOT_TOKEN }}
          SLACK_BENCH_CHANNEL: ${{ secrets.SLACK_BENCH_CHANNEL }}
@@ -908,7 +889,7 @@ jobs:

      - name: Send Slack notification (failure)
        if: failure() && env.BENCH_SLACK != 'never' && env.BENCH_SLACK != 'on-win'
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        env:
          SLACK_BENCH_BOT_TOKEN: ${{ secrets.SLACK_BENCH_BOT_TOKEN }}
          SLACK_BENCH_CHANNEL: ${{ secrets.SLACK_BENCH_CHANNEL }}
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -51,6 +51,16 @@ on:
        required: false
        default: ""
        type: string
+      disk_read_delay_ms:
+        description: "Apply dm-delay read latency to the schelk volume (milliseconds)"
+        required: false
+        default: ""
+        type: string
+      disk_write_delay_ms:
+        description: "Apply dm-delay write latency to the schelk volume (milliseconds)"
+        required: false
+        default: ""
+        type: string
      baseline_args:
        description: "Extra CLI args for the baseline reth node"
        required: false
@@ -82,7 +92,7 @@ on:
          - on-error
          - never
      abba:
-        description: "Run ABBA (FBBF) interleaved order; false = single FB pass"
+        description: "Run ABBA (BFFB) interleaved order; false = single AB pass"
        required: false
        default: "true"
        type: boolean
@@ -99,7 +109,9 @@ env:

 name: bench

-permissions: {}
+permissions:
+  contents: read
+  pull-requests: write

 jobs:
  reth-bench-ack:
@@ -108,9 +120,6 @@ jobs:
      github.event_name == 'workflow_dispatch'
    name: reth-bench-ack
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: write
    outputs:
      pr: ${{ steps.args.outputs.pr }}
      actor: ${{ steps.args.outputs.actor }}
@@ -126,6 +135,8 @@ jobs:
      big-blocks: ${{ steps.args.outputs.big-blocks }}
      bal: ${{ steps.args.outputs.bal }}
      wait-time: ${{ steps.args.outputs.wait-time }}
+      disk-read-delay-ms: ${{ steps.args.outputs.disk-read-delay-ms }}
+      disk-write-delay-ms: ${{ steps.args.outputs.disk-write-delay-ms }}
      baseline-args: ${{ steps.args.outputs.baseline-args }}
      feature-args: ${{ steps.args.outputs.feature-args }}
      abba: ${{ steps.args.outputs.abba }}
@@ -134,7 +145,7 @@ jobs:
    steps:
      - name: Check org membership
        if: github.event_name == 'issue_comment'
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          script: |
@@ -153,13 +164,13 @@ jobs:

      - name: Parse arguments
        id: args
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          github-token: ${{ secrets.DEREK_PAT }}
          script: |
            const validBalModes = new Set(['false', 'true', 'feature', 'baseline']);
            const validSlackModes = new Set(['always', 'on-win', 'on-error', 'never']);
-            const usage = '`@decofe bench [blocks=N] [big-blocks[=true|false]] [bal=true|false|feature|baseline] [warmup=N] [baseline=REF] [feature=REF] [samply] [slack=always|on-win|on-error|never] [cores=N] [abba=true|false] [otlp=true|false] [wait-time=DURATION] [baseline-args="..."] [feature-args="..."]`';
+            const usage = '`@decofe bench [blocks=N] [big-blocks[=true|false]] [bal=true|false|feature|baseline] [warmup=N] [baseline=REF] [feature=REF] [samply] [slack=always|on-win|on-error|never] [cores=N] [abba=true|false] [otlp=true|false] [wait-time=DURATION] [disk-read-delay-ms=N] [disk-write-delay-ms=N] [baseline-args="..."] [feature-args="..."]`';
            let pr, actor, blocks, warmup, baseline, feature, samply, cores, bigBlocks, bal;
            let explicitWarmup = false;

@@ -178,6 +189,8 @@ jobs:
              var abba = '${{ github.event.inputs.abba }}' !== 'false' ? 'true' : 'false';
              var otlp = '${{ github.event.inputs.otlp }}' !== 'false' ? 'true' : 'false';
              var waitTime = '${{ github.event.inputs.wait_time }}' || '';
+              var diskReadDelayMs = '${{ github.event.inputs.disk_read_delay_ms }}' || '';
+              var diskWriteDelayMs = '${{ github.event.inputs.disk_write_delay_ms }}' || '';
              var baselineNodeArgs = '${{ github.event.inputs.baseline_args }}' || '';
              var featureNodeArgs = '${{ github.event.inputs.feature_args }}' || '';

@@ -205,8 +218,9 @@ jobs:
              const boolDefaultTrue = new Set(['abba', 'otlp']);
              const enumArgs = new Map([['bal', validBalModes], ['slack', validSlackModes]]);
              const durationArgs = new Set(['wait-time']);
+              const optionalIntArgs = new Set(['disk-read-delay-ms', 'disk-write-delay-ms']);
              const stringArgs = new Set(['baseline-args', 'feature-args']);
-              const defaults = { blocks: '500', warmup: '200', baseline: '', feature: '', samply: 'false', slack: 'always', 'big-blocks': 'false', bal: 'false', cores: '0', abba: 'true', otlp: 'true', 'wait-time': '', 'baseline-args': '', 'feature-args': '' };
+              const defaults = { blocks: '500', warmup: '200', baseline: '', feature: '', samply: 'false', slack: 'always', 'big-blocks': 'false', bal: 'false', cores: '0', abba: 'true', otlp: 'true', 'wait-time': '', 'disk-read-delay-ms': '', 'disk-write-delay-ms': '', 'baseline-args': '', 'feature-args': '' };
              const unknown = [];
              const invalid = [];
              const args = body.replace(/^(?:@decofe|derek) bench\s*/, '');
@@ -245,6 +259,12 @@ jobs:
                  } else {
                    invalid.push(`\`${key}=${value}\` (must be a duration like 500ms, 1s, 2m)`);
                  }
+                } else if (optionalIntArgs.has(key)) {
+                  if (!/^\d+$/.test(value)) {
+                    invalid.push(`\`${key}=${value}\` (must be a non-negative integer in milliseconds)`);
+                  } else {
+                    defaults[key] = value;
+                  }
                } else if (enumArgs.has(key)) {
                  if (enumArgs.get(key).has(value)) {
                    defaults[key] = value;
@@ -296,6 +316,8 @@ jobs:
              var abba = defaults.abba;
              var otlp = defaults.otlp;
              var waitTime = defaults['wait-time'];
+              var diskReadDelayMs = defaults['disk-read-delay-ms'];
+              var diskWriteDelayMs = defaults['disk-write-delay-ms'];
              var baselineNodeArgs = defaults['baseline-args'];
              var featureNodeArgs = defaults['feature-args'];
            }
@@ -353,6 +375,8 @@ jobs:
            core.setOutput('big-blocks', bigBlocks);
            core.setOutput('bal', bal);
            core.setOutput('wait-time', waitTime);
+            core.setOutput('disk-read-delay-ms', diskReadDelayMs);
+            core.setOutput('disk-write-delay-ms', diskWriteDelayMs);
            core.setOutput('baseline-args', baselineNodeArgs);
            core.setOutput('feature-args', featureNodeArgs);
            core.setOutput('abba', abba);
@@ -360,7 +384,7 @@ jobs:

      - name: Acknowledge request
        id: ack
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          github-token: ${{ secrets.DEREK_PAT }}
          script: |
@@ -428,12 +452,16 @@ jobs:
            const otlpNote = !otlpEnabled ? ', otlp: `disabled`' : '';
            const waitTimeVal = '${{ steps.args.outputs.wait-time }}';
            const waitTimeNote = waitTimeVal ? `, wait-time: \`${waitTimeVal}\`` : '';
+            const diskReadDelayVal = '${{ steps.args.outputs.disk-read-delay-ms }}';
+            const diskReadDelayNote = diskReadDelayVal && diskReadDelayVal !== '0' ? `, disk-read-delay: \`${diskReadDelayVal}ms\`` : '';
+            const diskWriteDelayVal = '${{ steps.args.outputs.disk-write-delay-ms }}';
+            const diskWriteDelayNote = diskWriteDelayVal && diskWriteDelayVal !== '0' ? `, disk-write-delay: \`${diskWriteDelayVal}ms\`` : '';
            const baselineArgsVal = '${{ steps.args.outputs.baseline-args }}';
            const baselineArgsNote = baselineArgsVal ? `, baseline-args: \`${baselineArgsVal}\`` : '';
            const featureArgsVal = '${{ steps.args.outputs.feature-args }}';
            const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
            const blocksDesc = bigBlocks ? 'blocks: `big`' : `${blocks} blocks, ${warmup} warmup blocks`;
-            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
+            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${diskReadDelayNote}${diskWriteDelayNote}${baselineArgsNote}${featureArgsNote}`;

            const { data: comment } = await github.rest.issues.createComment({
              owner: context.repo.owner,
@@ -446,7 +474,7 @@ jobs:

      - name: Poll queue position
        if: steps.ack.outputs.comment-id && steps.ack.outputs.queue-position != '0'
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          github-token: ${{ secrets.DEREK_PAT }}
          script: |
@@ -472,12 +500,16 @@ jobs:
            const otlpNote = !otlpEnabled ? ', otlp: `disabled`' : '';
            const waitTimeVal = '${{ steps.args.outputs.wait-time }}';
            const waitTimeNote = waitTimeVal ? `, wait-time: \`${waitTimeVal}\`` : '';
+            const diskReadDelayVal = '${{ steps.args.outputs.disk-read-delay-ms }}';
+            const diskReadDelayNote = diskReadDelayVal && diskReadDelayVal !== '0' ? `, disk-read-delay: \`${diskReadDelayVal}ms\`` : '';
+            const diskWriteDelayVal = '${{ steps.args.outputs.disk-write-delay-ms }}';
+            const diskWriteDelayNote = diskWriteDelayVal && diskWriteDelayVal !== '0' ? `, disk-write-delay: \`${diskWriteDelayVal}ms\`` : '';
            const baselineArgsVal = '${{ steps.args.outputs.baseline-args }}';
            const baselineArgsNote = baselineArgsVal ? `, baseline-args: \`${baselineArgsVal}\`` : '';
            const featureArgsVal = '${{ steps.args.outputs.feature-args }}';
            const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
            const blocksDesc = bigBlocks ? 'blocks: `big`' : `${blocks} blocks, ${warmup} warmup blocks`;
-            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
+            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${diskReadDelayNote}${diskWriteDelayNote}${baselineArgsNote}${featureArgsNote}`;
            const runUrl = `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`;

            const numRunners = parseInt(process.env.BENCH_RUNNERS) || 1;
@@ -530,9 +562,6 @@ jobs:
    needs: reth-bench-ack
    name: reth-bench
    runs-on: [self-hosted, Linux, X64, available]
-    permissions:
-      contents: read
-      pull-requests: write
    timeout-minutes: 120
    env:
      BENCH_RPC_URL: https://ethereum.reth.rs/rpc
@@ -548,6 +577,8 @@ jobs:
      BENCH_BIG_BLOCKS: ${{ needs.reth-bench-ack.outputs.big-blocks }}
      BENCH_BAL: ${{ needs.reth-bench-ack.outputs.bal }}
      BENCH_WAIT_TIME: ${{ needs.reth-bench-ack.outputs.wait-time }}
+      BENCH_DISK_READ_DELAY_MS: ${{ needs.reth-bench-ack.outputs.disk-read-delay-ms }}
+      BENCH_DISK_WRITE_DELAY_MS: ${{ needs.reth-bench-ack.outputs.disk-write-delay-ms }}
      BENCH_BASELINE_ARGS: ${{ needs.reth-bench-ack.outputs.baseline-args }}
      BENCH_FEATURE_ARGS: ${{ needs.reth-bench-ack.outputs.feature-args }}
      BENCH_ABBA: ${{ needs.reth-bench-ack.outputs.abba }}
@@ -564,7 +595,7 @@ jobs:

      - name: Resolve checkout ref
        id: checkout-ref
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          script: |
            if (!process.env.BENCH_PR) {
@@ -582,16 +613,15 @@ jobs:
            core.info(`PR #${process.env.BENCH_PR} (${pr.state}), using head SHA ${pr.head.sha}`);
            core.setOutput('ref', pr.head.sha);

-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@v6
        with:
-          persist-credentials: false
          submodules: true
          fetch-depth: 0
          ref: ${{ steps.checkout-ref.outputs.ref }}

      - name: Resolve job URL and update status
        if: env.BENCH_COMMENT_ID
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          github-token: ${{ secrets.DEREK_PAT }}
          script: |
@@ -623,12 +653,16 @@ jobs:
            const otlpNote = !otlpEnabled ? ', otlp: `disabled`' : '';
            const waitTimeVal = process.env.BENCH_WAIT_TIME || '';
            const waitTimeNote = waitTimeVal ? `, wait-time: \`${waitTimeVal}\`` : '';
+            const diskReadDelayVal = process.env.BENCH_DISK_READ_DELAY_MS || '';
+            const diskReadDelayNote = diskReadDelayVal && diskReadDelayVal !== '0' ? `, disk-read-delay: \`${diskReadDelayVal}ms\`` : '';
+            const diskWriteDelayVal = process.env.BENCH_DISK_WRITE_DELAY_MS || '';
+            const diskWriteDelayNote = diskWriteDelayVal && diskWriteDelayVal !== '0' ? `, disk-write-delay: \`${diskWriteDelayVal}ms\`` : '';
            const baselineArgsVal = process.env.BENCH_BASELINE_ARGS || '';
            const baselineArgsNote = baselineArgsVal ? `, baseline-args: \`${baselineArgsVal}\`` : '';
            const featureArgsVal = process.env.BENCH_FEATURE_ARGS || '';
            const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
            const blocksDesc = bigBlocks ? 'blocks: `big`' : `${blocks} blocks, ${warmup} warmup blocks`;
-            core.exportVariable('BENCH_CONFIG', `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`);
+            core.exportVariable('BENCH_CONFIG', `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${diskReadDelayNote}${diskWriteDelayNote}${baselineArgsNote}${featureArgsNote}`);

            const { buildBody } = require('./.github/scripts/bench-update-status.js');
            await github.rest.issues.updateComment({
@@ -639,9 +673,8 @@ jobs:
            });

      - uses: dtolnay/rust-toolchain@stable
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
+      - uses: mozilla-actions/sccache-action@v0.0.9
        continue-on-error: true
-      - uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1

      - name: Install dependencies
        env:
@@ -690,7 +723,7 @@ jobs:
          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
          missing=()
-          for cmd in schelk cpupower taskset stdbuf python3 curl make uv jq; do
+          for cmd in schelk cpupower taskset stdbuf python3 curl make uv jq dmsetup; do
            command -v "$cmd" &>/dev/null || missing+=("$cmd")
          done
          if [ ${#missing[@]} -gt 0 ]; then
@@ -702,7 +735,7 @@ jobs:
      # Build binaries
      - name: Resolve PR head branch
        id: pr-info
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          script: |
            if (process.env.BENCH_PR) {
@@ -720,7 +753,7 @@ jobs:

      - name: Resolve refs
        id: refs
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          script: |
            const { execSync } = require('child_process');
@@ -808,26 +841,21 @@ jobs:

      - name: Prepare source dirs
        run: |
-          prepare_source_dir() {
-            local dir="$1"
-            local ref="$2"
-
-            if [ -d "$dir" ]; then
-              git -C "$dir" reset --hard HEAD
-              git -C "$dir" clean -fdx
-              git -C "$dir" fetch origin "$ref"
-            else
-              git clone . "$dir"
-            fi
-
-            git -C "$dir" checkout --force "$ref"
-          }
-
          BASELINE_REF="${{ steps.refs.outputs.baseline-ref }}"
-          prepare_source_dir ../reth-baseline "$BASELINE_REF"
+          if [ -d ../reth-baseline ]; then
+            git -C ../reth-baseline fetch origin "$BASELINE_REF"
+          else
+            git clone . ../reth-baseline
+          fi
+          git -C ../reth-baseline checkout "$BASELINE_REF"

          FEATURE_REF="${{ steps.refs.outputs.feature-ref }}"
-          prepare_source_dir ../reth-feature "$FEATURE_REF"
+          if [ -d ../reth-feature ]; then
+            git -C ../reth-feature fetch origin "$FEATURE_REF"
+          else
+            git clone . ../reth-feature
+          fi
+          git -C ../reth-feature checkout "$FEATURE_REF"

      - name: Build binaries
        id: build
@@ -943,28 +971,15 @@ jobs:

      - name: Update status (running benchmarks)
        if: success() && env.BENCH_COMMENT_ID
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          github-token: ${{ secrets.DEREK_PAT }}
          script: |
            const s = require('./.github/scripts/bench-update-status.js');
            await s({github, context, status: 'Running benchmarks...'});

-      # Interleaved run order (F-B-B-F) to reduce systematic bias from
+      # Interleaved run order (B-F-F-B) to reduce systematic bias from
      # thermal drift and cache warming.
-      - name: "Run benchmark: feature (1/2)"
-        id: run-feature-1
-        env:
-          FEATURE_REF: ${{ steps.refs.outputs.feature-ref }}
-          OTEL_RESOURCE_ATTRIBUTES: "benchmark_id=${{ env.BENCH_ID }},benchmark_run=feature-1,run_type=feature,git_ref=${{ steps.refs.outputs.feature-ref }}"
-        run: |
-          LAST_RUN_START=$(date +%s)
-          echo "BENCH_LAST_RUN_START=${LAST_RUN_START}" >> "$GITHUB_ENV"
-          cat > "$BENCH_LABELS_FILE" <<LABELS
-          {"benchmark_run":"feature-1","run_type":"feature","git_ref":"${FEATURE_REF}","bench_sha":"${FEATURE_REF}","benchmark_id":"${BENCH_ID}","run_start_epoch":"${LAST_RUN_START}","reference_epoch":"${BENCH_REFERENCE_EPOCH}"}
-          LABELS
-          taskset -c 0 .github/scripts/bench-reth-run.sh feature "../reth-feature/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/feature-1"
-
      - name: "Run benchmark: baseline (1/2)"
        id: run-baseline-1
        env:
@@ -978,19 +993,18 @@ jobs:
          LABELS
          taskset -c 0 .github/scripts/bench-reth-run.sh baseline "../reth-baseline/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/baseline-1"

-      - name: "Run benchmark: baseline (2/2)"
-        if: env.BENCH_ABBA != 'false'
-        id: run-baseline-2
+      - name: "Run benchmark: feature (1/2)"
+        id: run-feature-1
        env:
-          BASELINE_REF: ${{ steps.refs.outputs.baseline-ref }}
-          OTEL_RESOURCE_ATTRIBUTES: "benchmark_id=${{ env.BENCH_ID }},benchmark_run=baseline-2,run_type=baseline,git_ref=${{ steps.refs.outputs.baseline-ref }}"
+          FEATURE_REF: ${{ steps.refs.outputs.feature-ref }}
+          OTEL_RESOURCE_ATTRIBUTES: "benchmark_id=${{ env.BENCH_ID }},benchmark_run=feature-1,run_type=feature,git_ref=${{ steps.refs.outputs.feature-ref }}"
        run: |
          LAST_RUN_START=$(date +%s)
          echo "BENCH_LAST_RUN_START=${LAST_RUN_START}" >> "$GITHUB_ENV"
          cat > "$BENCH_LABELS_FILE" <<LABELS
-          {"benchmark_run":"baseline-2","run_type":"baseline","git_ref":"${BASELINE_REF}","bench_sha":"${BASELINE_REF}","benchmark_id":"${BENCH_ID}","run_start_epoch":"${LAST_RUN_START}","reference_epoch":"${BENCH_REFERENCE_EPOCH}"}
+          {"benchmark_run":"feature-1","run_type":"feature","git_ref":"${FEATURE_REF}","bench_sha":"${FEATURE_REF}","benchmark_id":"${BENCH_ID}","run_start_epoch":"${LAST_RUN_START}","reference_epoch":"${BENCH_REFERENCE_EPOCH}"}
          LABELS
-          taskset -c 0 .github/scripts/bench-reth-run.sh baseline "../reth-baseline/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/baseline-2"
+          taskset -c 0 .github/scripts/bench-reth-run.sh feature "../reth-feature/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/feature-1"

      - name: "Run benchmark: feature (2/2)"
        if: env.BENCH_ABBA != 'false'
@@ -1006,6 +1020,20 @@ jobs:
          LABELS
          taskset -c 0 .github/scripts/bench-reth-run.sh feature "../reth-feature/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/feature-2"

+      - name: "Run benchmark: baseline (2/2)"
+        if: env.BENCH_ABBA != 'false'
+        id: run-baseline-2
+        env:
+          BASELINE_REF: ${{ steps.refs.outputs.baseline-ref }}
+          OTEL_RESOURCE_ATTRIBUTES: "benchmark_id=${{ env.BENCH_ID }},benchmark_run=baseline-2,run_type=baseline,git_ref=${{ steps.refs.outputs.baseline-ref }}"
+        run: |
+          LAST_RUN_START=$(date +%s)
+          echo "BENCH_LAST_RUN_START=${LAST_RUN_START}" >> "$GITHUB_ENV"
+          cat > "$BENCH_LABELS_FILE" <<LABELS
+          {"benchmark_run":"baseline-2","run_type":"baseline","git_ref":"${BASELINE_REF}","bench_sha":"${BASELINE_REF}","benchmark_id":"${BENCH_ID}","run_start_epoch":"${LAST_RUN_START}","reference_epoch":"${BENCH_REFERENCE_EPOCH}"}
+          LABELS
+          taskset -c 0 .github/scripts/bench-reth-run.sh baseline "../reth-baseline/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/baseline-2"
+
      - name: Stop metrics proxy & generate Grafana URL
        id: metrics
        if: "!cancelled()"
@@ -1172,7 +1200,7 @@ jobs:

      - name: Upload results
        if: "!cancelled()"
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        uses: actions/upload-artifact@v7
        with:
          name: bench-reth-results
          path: ${{ env.BENCH_WORK_DIR }}
@@ -1180,13 +1208,11 @@ jobs:
      - name: Push charts
        id: push-charts
        if: success()
-        env:
-          DEREK_TOKEN: ${{ secrets.DEREK_TOKEN }}
-          RUN_ID: ${{ github.run_id }}
        run: |
          PR_NUMBER="${BENCH_PR:-0}"
+          RUN_ID=${{ github.run_id }}
          CHART_DIR="pr/${PR_NUMBER}/${RUN_ID}"
-          CHARTS_REPO="https://x-access-token:${DEREK_TOKEN}@github.com/decofe/reth-bench-charts.git"
+          CHARTS_REPO="https://x-access-token:${{ secrets.DEREK_TOKEN }}@github.com/decofe/reth-bench-charts.git"

          TMP_DIR=$(mktemp -d)
          if git clone --depth 1 "${CHARTS_REPO}" "${TMP_DIR}" 2>/dev/null; then
@@ -1199,35 +1225,15 @@ jobs:
          mkdir -p "${TMP_DIR}/${CHART_DIR}"
          cp "$BENCH_WORK_DIR"/charts/*.png "${TMP_DIR}/${CHART_DIR}/"
          git -C "${TMP_DIR}" add "${CHART_DIR}"
-          if git -C "${TMP_DIR}" diff --cached --quiet; then
-            echo "Charts for ${CHART_DIR} are already present, skipping push"
-            echo "sha=$(git -C "${TMP_DIR}" rev-parse HEAD)" >> "$GITHUB_OUTPUT"
-            rm -rf "${TMP_DIR}"
-            exit 0
-          fi
          git -C "${TMP_DIR}" -c user.name="github-actions" -c user.email="github-actions@github.com" \
            commit -m "bench charts for PR #${PR_NUMBER} run ${RUN_ID}"
-
-          for attempt in 1 2 3 4 5; do
-            if git -C "${TMP_DIR}" push origin HEAD:main; then
-              break
-            fi
-            if [ "$attempt" -eq 5 ]; then
-              echo "::error::Failed to push charts after ${attempt} attempts"
-              rm -rf "${TMP_DIR}"
-              exit 1
-            fi
-            sleep "$attempt"
-            git -C "${TMP_DIR}" fetch origin main
-            git -C "${TMP_DIR}" rebase origin/main
-          done
-
+          git -C "${TMP_DIR}" push origin HEAD:main
          echo "sha=$(git -C "${TMP_DIR}" rev-parse HEAD)" >> "$GITHUB_OUTPUT"
          rm -rf "${TMP_DIR}"

      - name: Compare & comment
        if: success() && env.BENCH_COMMENT_ID
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          github-token: ${{ secrets.DEREK_PAT }}
          script: |
@@ -1263,7 +1269,7 @@ jobs:
            // Samply profile links (URLs point directly to Firefox Profiler)
            if (process.env.BENCH_SAMPLY === 'true') {
              const abba = (process.env.BENCH_ABBA || 'true') !== 'false';
-              const runs = abba ? ['feature-1', 'baseline-1', 'baseline-2', 'feature-2'] : ['feature-1', 'baseline-1'];
+              const runs = abba ? ['baseline-1', 'feature-1', 'feature-2', 'baseline-2'] : ['baseline-1', 'feature-1'];
              const links = [];
              for (const run of runs) {
                try {
@@ -1307,7 +1313,7 @@ jobs:

      - name: Write job summary
        if: success()
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          script: |
            const jobSummary = require('./.github/scripts/bench-job-summary.js');
@@ -1321,7 +1327,7 @@ jobs:

      - name: Send Slack notification (success)
        if: success() && (env.BENCH_SLACK == 'always' || env.BENCH_SLACK == 'on-win')
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        env:
          SLACK_BENCH_BOT_TOKEN: ${{ secrets.SLACK_BENCH_BOT_TOKEN }}
          SLACK_BENCH_CHANNEL: ${{ secrets.SLACK_BENCH_CHANNEL }}
@@ -1332,7 +1338,7 @@ jobs:

      - name: Update status (failed)
        if: failure() && env.BENCH_COMMENT_ID
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          github-token: ${{ secrets.DEREK_PAT }}
          script: |
@@ -1342,10 +1348,10 @@ jobs:
              ...(bigBlocks ? [['validating local big-block data', '${{ steps.big-blocks-check.outcome }}']] : []),
              ['validating local snapshot', '${{ steps.snapshot-check.outcome }}'],
              ['building binaries', '${{ steps.build.outcome }}'],
-              ['running feature benchmark (1/2)', '${{ steps.run-feature-1.outcome }}'],
              ['running baseline benchmark (1/2)', '${{ steps.run-baseline-1.outcome }}'],
-              ...(abba ? [['running baseline benchmark (2/2)', '${{ steps.run-baseline-2.outcome }}']] : []),
+              ['running feature benchmark (1/2)', '${{ steps.run-feature-1.outcome }}'],
              ...(abba ? [['running feature benchmark (2/2)', '${{ steps.run-feature-2.outcome }}']] : []),
+              ...(abba ? [['running baseline benchmark (2/2)', '${{ steps.run-baseline-2.outcome }}']] : []),
            ];
            const failed = steps_status.find(([, o]) => o === 'failure');
            const failedStep = failed ? failed[0] : 'unknown step';
@@ -1368,7 +1374,7 @@ jobs:

      - name: Send Slack notification (failure)
        if: failure() && env.BENCH_SLACK != 'never' && env.BENCH_SLACK != 'on-win'
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        env:
          SLACK_BENCH_BOT_TOKEN: ${{ secrets.SLACK_BENCH_BOT_TOKEN }}
          SLACK_BENCH_CHANNEL: ${{ secrets.SLACK_BENCH_CHANNEL }}
@@ -1380,10 +1386,10 @@ jobs:
              ...(bigBlocks ? [['validating local big-block data', '${{ steps.big-blocks-check.outcome }}']] : []),
              ['validating local snapshot', '${{ steps.snapshot-check.outcome }}'],
              ['building binaries', '${{ steps.build.outcome }}'],
-              ['running feature benchmark (1/2)', '${{ steps.run-feature-1.outcome }}'],
              ['running baseline benchmark (1/2)', '${{ steps.run-baseline-1.outcome }}'],
-              ...(abba ? [['running baseline benchmark (2/2)', '${{ steps.run-baseline-2.outcome }}']] : []),
+              ['running feature benchmark (1/2)', '${{ steps.run-feature-1.outcome }}'],
              ...(abba ? [['running feature benchmark (2/2)', '${{ steps.run-feature-2.outcome }}']] : []),
+              ...(abba ? [['running baseline benchmark (2/2)', '${{ steps.run-baseline-2.outcome }}']] : []),
            ];
            const failed = steps_status.find(([, o]) => o === 'failure');
            const failedStep = failed ? failed[0] : 'unknown step';
@@ -1392,7 +1398,7 @@ jobs:

      - name: Update status (cancelled)
        if: cancelled() && env.BENCH_COMMENT_ID
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          github-token: ${{ secrets.DEREK_PAT }}
          script: |
--- a/.github/workflows/book.yml
+++ b/.github/workflows/book.yml
@@ -10,22 +10,19 @@ on:
    types: [opened, reopened, synchronize, closed]
  merge_group:

-permissions: {}
+env:
+  RUSTC_WRAPPER: "sccache"

 jobs:
  build:
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest-8' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    timeout-minutes: 90
    steps:
      - name: Checkout
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+        uses: actions/checkout@v6

      - name: Install bun
-        uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
+        uses: oven-sh/setup-bun@v2
        with:
          bun-version: v1.2.23

@@ -39,6 +36,8 @@ jobs:
      - name: Install Rust nightly
        uses: dtolnay/rust-toolchain@nightly

+      - uses: mozilla-actions/sccache-action@v0.0.9
+
      - name: Build docs
        run: cd docs/vocs && bash scripts/build-cargo-docs.sh

@@ -48,10 +47,10 @@ jobs:
          echo "Vocs Build Complete"

      - name: Setup Pages
-        uses: actions/configure-pages@45bfe0192ca1faeb007ade9deae92b16b8254a0d # v6.0.0
+        uses: actions/configure-pages@v6

      - name: Upload artifact
-        uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0
+        uses: actions/upload-pages-artifact@v5
        with:
          path: "./docs/vocs/docs/dist"

@@ -75,4 +74,4 @@ jobs:
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
-        uses: actions/deploy-pages@cd2ce8fcbc39b97be8ca5fce6e763baed58fa128 # v5.0.0
+        uses: actions/deploy-pages@v5
--- a/.github/workflows/check-alloy.yml
+++ b/.github/workflows/check-alloy.yml
@@ -22,41 +22,31 @@ on:
 env:
  CARGO_TERM_COLOR: always

-permissions: {}
-
 jobs:
  check:
    name: Check compilation with patched alloy
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest-16' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v4

      - uses: dtolnay/rust-toolchain@stable

-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true

      - name: Apply alloy patches
-        env:
-          ALLOY_BRANCH: ${{ inputs.alloy_branch }}
-          ALLOY_EVM_BRANCH: ${{ inputs.alloy_evm_branch }}
-          OP_ALLOY_BRANCH: ${{ inputs.op_alloy_branch }}
        run: |
          ARGS=""
-          if [ -n "$ALLOY_BRANCH" ]; then
-            ARGS="$ARGS --alloy $ALLOY_BRANCH"
+          if [ -n "${{ inputs.alloy_branch }}" ]; then
+            ARGS="$ARGS --alloy ${{ inputs.alloy_branch }}"
          fi
-          if [ -n "$ALLOY_EVM_BRANCH" ]; then
-            ARGS="$ARGS --evm $ALLOY_EVM_BRANCH"
+          if [ -n "${{ inputs.alloy_evm_branch }}" ]; then
+            ARGS="$ARGS --evm ${{ inputs.alloy_evm_branch }}"
          fi
-          if [ -n "$OP_ALLOY_BRANCH" ]; then
-            ARGS="$ARGS --op $OP_ALLOY_BRANCH"
+          if [ -n "${{ inputs.op_alloy_branch }}" ]; then
+            ARGS="$ARGS --op ${{ inputs.op_alloy_branch }}"
          fi
          
          if [ -z "$ARGS" ]; then
--- a/.github/workflows/compact.yml
+++ b/.github/workflows/compact.yml
@@ -16,38 +16,32 @@ env:
  RUSTC_WRAPPER: "sccache"

 name: compact-codec
-permissions: {}
-
 jobs:
  compact-codec:
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    strategy:
      matrix:
        bin:
          - cargo run --bin reth --features "dev"
    steps:
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
      - name: Checkout base
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@v6
        with:
          ref: ${{ github.base_ref || 'main' }}
-          persist-credentials: false
      # On `main` branch, generates test vectors and serializes them to disk using `Compact`.
      - name: Generate compact vectors
        run: |
          ${{ matrix.bin }} -- test-vectors compact --write
      - name: Checkout PR
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@v6
        with:
          clean: false
-          persist-credentials: false
      # On incoming merge try to read and decode previously generated vectors with `Compact`
      - name: Read vectors
        run: ${{ matrix.bin }} -- test-vectors compact --read
--- a/.github/workflows/dependencies.yml
+++ b/.github/workflows/dependencies.yml
@@ -9,14 +9,13 @@ on:
  workflow_dispatch:
    # Needed so we can run it manually

-permissions: {}
+permissions:
+  contents: write
+  pull-requests: write

 jobs:
  update:
    if: github.repository == 'paradigmxyz/reth'
-    permissions:
-      contents: write
-      pull-requests: write
    uses: tempoxyz/ci/.github/workflows/cargo-update-pr.yml@main
    secrets:
-      token: ${{ secrets.GITHUB_TOKEN }}
+      token: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/docker-tag-latest.yml
+++ b/.github/workflows/docker-tag-latest.yml
@@ -17,8 +17,6 @@ on:
 env:
  DOCKER_USERNAME: ${{ github.actor }}

-permissions: {}
-
 jobs:
  tag-reth-latest:
    name: Tag reth as latest
@@ -29,22 +27,16 @@ jobs:
      contents: read
    steps:
      - name: Log in to Docker
-        env:
-          DOCKER_PASSWORD: ${{ secrets.GITHUB_TOKEN }}
        run: |
-          echo "$DOCKER_PASSWORD" | docker login ghcr.io --username "${DOCKER_USERNAME}" --password-stdin
+          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io --username ${DOCKER_USERNAME} --password-stdin

      - name: Pull reth release image
-        env:
-          VERSION: ${{ inputs.version }}
        run: |
-          docker pull ghcr.io/${{ github.repository_owner }}/reth:${VERSION}
+          docker pull ghcr.io/${{ github.repository_owner }}/reth:${{ inputs.version }}

      - name: Tag reth as latest
-        env:
-          VERSION: ${{ inputs.version }}
        run: |
-          docker tag ghcr.io/${{ github.repository_owner }}/reth:${VERSION} ghcr.io/${{ github.repository_owner }}/reth:latest
+          docker tag ghcr.io/${{ github.repository_owner }}/reth:${{ inputs.version }} ghcr.io/${{ github.repository_owner }}/reth:latest

      - name: Push reth latest tag
        run: |
--- a/.github/workflows/docker-test.yml
+++ b/.github/workflows/docker-test.yml
@@ -13,8 +13,6 @@ on:
        default: "artifacts"
        description: "Name for the uploaded artifact"

-permissions: {}
-
 jobs:
  build:
    timeout-minutes: 45
@@ -23,9 +21,7 @@ jobs:
      id-token: write
      contents: read
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6
      - run: mkdir -p artifacts

      - name: Get git info
@@ -36,12 +32,8 @@ jobs:

      - name: Detect fork
        id: fork
-        env:
-          EVENT_NAME: ${{ github.event_name }}
-          HEAD_REPO: ${{ github.event.pull_request.head.repo.full_name }}
-          REPO: ${{ github.repository }}
        run: |
-          if [ "$EVENT_NAME" = "pull_request" ] && [ "$HEAD_REPO" != "$REPO" ]; then
+          if [ "${{ github.event_name }}" = "pull_request" ] && [ "${{ github.event.pull_request.head.repo.full_name }}" != "${{ github.repository }}" ]; then
            echo "is_fork=true" >> "$GITHUB_OUTPUT"
          else
            echo "is_fork=false" >> "$GITHUB_OUTPUT"
@@ -50,11 +42,11 @@ jobs:
      # Depot build (upstream only)
      - name: Set up Depot CLI
        if: steps.fork.outputs.is_fork == 'false'
-        uses: depot/setup-action@15c09a5f77a0840ad4bce955686522a257853461 # v1.7.1
+        uses: depot/setup-action@v1

      - name: Build reth image (Depot)
        if: steps.fork.outputs.is_fork == 'false'
-        uses: depot/bake-action@1d58c2668346981089b088b7ef36755b206b20e9 # v1.13.0
+        uses: depot/bake-action@v1
        env:
          DEPOT_TOKEN: ${{ secrets.DEPOT_TOKEN }}
          VERGEN_GIT_SHA: ${{ steps.git.outputs.sha }}
@@ -68,11 +60,11 @@ jobs:
      # Docker build (forks)
      - name: Set up Docker Buildx
        if: steps.fork.outputs.is_fork == 'true'
-        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
+        uses: docker/setup-buildx-action@v3

      - name: Build reth image (Docker)
        if: steps.fork.outputs.is_fork == 'true'
-        uses: docker/bake-action@82490499d2e5613fcead7e128237ef0b0ea210f7 # v7.0.0
+        uses: docker/bake-action@v6
        env:
          VERGEN_GIT_SHA: ${{ steps.git.outputs.sha }}
          VERGEN_GIT_DESCRIBE: ${{ steps.git.outputs.describe }}
@@ -84,7 +76,7 @@ jobs:
            *.dockerfile=Dockerfile

      - name: Upload reth image
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        uses: actions/upload-artifact@v7
        with:
          name: ${{ inputs.artifact_name }}
          path: ./artifacts
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -29,8 +29,6 @@ on:
        type: boolean
        default: false

-permissions: {}
-
 jobs:
  build:
    if: github.repository == 'paradigmxyz/reth'
@@ -41,15 +39,13 @@ jobs:
      contents: read
      id-token: write
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6

      - name: Set up Depot CLI
-        uses: depot/setup-action@15c09a5f77a0840ad4bce955686522a257853461 # v1.7.1
+        uses: depot/setup-action@v1

      - name: Log in to GHCR
-        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        uses: docker/login-action@v4
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
@@ -64,13 +60,10 @@ jobs:

      - name: Determine build parameters
        id: params
-        env:
-          EVENT_NAME: ${{ github.event_name }}
-          BUILD_TYPE: ${{ inputs.build_type }}
        run: |
          REGISTRY="ghcr.io/${{ github.repository_owner }}"

-          if [[ "${EVENT_NAME}" == "push" ]]; then
+          if [[ "${{ github.event_name }}" == "push" ]]; then
            VERSION="${GITHUB_REF#refs/tags/}"
            echo "targets=ethereum" >> "$GITHUB_OUTPUT"

@@ -88,7 +81,7 @@ jobs:
              echo "ethereum_set=ethereum.tags=${REGISTRY}/reth:${VERSION}" >> "$GITHUB_OUTPUT"
            fi

-          elif [[ "${EVENT_NAME}" == "schedule" ]] || [[ "${BUILD_TYPE}" == "nightly" ]]; then
+          elif [[ "${{ github.event_name }}" == "schedule" ]] || [[ "${{ inputs.build_type }}" == "nightly" ]]; then
            echo "targets=nightly" >> "$GITHUB_OUTPUT"
            echo "ethereum_tags=${REGISTRY}/reth:nightly" >> "$GITHUB_OUTPUT"
            echo "ethereum_set=ethereum.tags=${REGISTRY}/reth:nightly" >> "$GITHUB_OUTPUT"
@@ -101,7 +94,7 @@ jobs:
          fi

      - name: Build and push images
-        uses: depot/bake-action@1d58c2668346981089b088b7ef36755b206b20e9 # v1.13.0
+        uses: depot/bake-action@v1
        env:
          VERGEN_GIT_SHA: ${{ steps.git.outputs.sha }}
          VERGEN_GIT_DESCRIBE: ${{ steps.git.outputs.describe }}
@@ -112,8 +105,6 @@ jobs:
          files: docker-bake.hcl
          targets: ${{ steps.params.outputs.targets }}
          push: ${{ !(github.event_name == 'workflow_dispatch' && inputs.dry_run) }}
-          save: false
-          load: false
          set: |
            ${{ steps.params.outputs.ethereum_set }}

@@ -133,7 +124,7 @@ jobs:
    if: failure() && github.event_name == 'schedule'
    steps:
      - name: Slack Webhook Action
-        uses: rtCamp/action-slack-notify@e31e87e03dd19038e411e38ae27cbad084a90661 # v2.3.3
+        uses: rtCamp/action-slack-notify@v2
        env:
          SLACK_COLOR: danger
          SLACK_ICON_EMOJI: ":rotating_light:"
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -17,27 +17,19 @@ concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

-permissions: {}
-
 jobs:
  test:
    name: e2e-testsuite
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest-4' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    env:
      RUST_BACKTRACE: 1
    timeout-minutes: 90
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6
      - uses: dtolnay/rust-toolchain@stable
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: taiki-e/install-action@1f2425cdb59f8fffb99ee16a5968edf6f57a2b93 # v2.75.24
-        with:
-          tool: nextest
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - 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 e2e tests
@@ -56,21 +48,15 @@ jobs:
  rocksdb:
    name: e2e-rocksdb
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest-4' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    env:
      RUST_BACKTRACE: 1
    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6
      - uses: dtolnay/rust-toolchain@stable
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: taiki-e/install-action@1f2425cdb59f8fffb99ee16a5968edf6f57a2b93 # v2.75.24
-        with:
-          tool: nextest
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - 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
--- a/.github/workflows/fetch-grafana-dashboard.yml
+++ b/.github/workflows/fetch-grafana-dashboard.yml
@@ -12,8 +12,6 @@ on:
        required: true
        default: "etc/grafana/dashboards/overview.json"

-permissions: {}
-
 jobs:
  fetch:
    runs-on: ubuntu-latest
@@ -21,11 +19,9 @@ jobs:
      contents: write
      pull-requests: write
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6

-      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"

@@ -33,18 +29,14 @@ jobs:
        env:
          FETCH_GRAFANA_DASHBOARD_URL: ${{ secrets.FETCH_GRAFANA_DASHBOARD_URL }}
          FETCH_GRAFANA_DASHBOARD_TOKEN: ${{ secrets.FETCH_GRAFANA_DASHBOARD_TOKEN }}
-          DASHBOARD_UID: ${{ inputs.dashboard_uid }}
-          TARGET_PATH: ${{ inputs.target_path }}
        run: |
-          python3 .github/scripts/fetch-grafana-dashboard.py "${DASHBOARD_UID}" \
-            > "${TARGET_PATH}"
+          python3 .github/scripts/fetch-grafana-dashboard.py "${{ inputs.dashboard_uid }}" \
+            > "${{ inputs.target_path }}"

      - name: Check for changes
        id: diff
-        env:
-          TARGET_PATH: ${{ inputs.target_path }}
        run: |
-          if git diff --quiet "${TARGET_PATH}"; then
+          if git diff --quiet "${{ inputs.target_path }}"; then
            echo "changed=false" >> "$GITHUB_OUTPUT"
            echo "No changes detected."
          else
@@ -55,10 +47,8 @@ jobs:
        if: steps.diff.outputs.changed == 'true'
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          DASHBOARD_UID: ${{ inputs.dashboard_uid }}
-          TARGET_PATH: ${{ inputs.target_path }}
        run: |
-          TARGET="${TARGET_PATH}"
+          TARGET="${{ inputs.target_path }}"
          FILENAME="$(basename "$TARGET")"
          BRANCH="chore/sync-grafana-${FILENAME%.*}-$(date +%Y%m%d-%H%M%S)"
          git config user.name "github-actions[bot]"
@@ -69,4 +59,4 @@ jobs:
          git push origin "$BRANCH"
          gh pr create \
            --title "chore: update Grafana dashboard ${FILENAME}" \
-            --body "Automated export from Grafana (dashboard UID: \`${DASHBOARD_UID}\`, target: \`${TARGET}\`)."
+            --body "Automated export from Grafana (dashboard UID: \`${{ inputs.dashboard_uid }}\`, target: \`${TARGET}\`)."
--- a/.github/workflows/grafana.yml
+++ b/.github/workflows/grafana.yml
@@ -6,17 +6,11 @@ on:
  push:
    branches: [main]

-permissions: {}
-
 jobs:
  check-dashboard:
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6
      - name: Validate dashboard format
        run: |
          python3 -c "
--- a/.github/workflows/hive.yml
+++ b/.github/workflows/hive.yml
@@ -14,13 +14,8 @@ concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

-permissions: {}
-
 jobs:
  build-reth:
-    permissions:
-      contents: read
-      id-token: write
    uses: ./.github/workflows/docker-test.yml
    with:
      hive_target: hive
@@ -30,46 +25,34 @@ jobs:
  prepare-hive:
    if: github.repository == 'paradigmxyz/reth'
    timeout-minutes: 45
-    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest-16' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
-    strategy:
-      fail-fast: false
-      matrix:
-        variant:
-          - amsterdam
-          - osaka
-    name: Prepare Hive - ${{ matrix.variant == 'amsterdam' && 'Amsterdam' || 'Osaka' }}
+    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest-4' || 'ubuntu-latest' }}
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6
      - name: Checkout hive tests
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@v6
        with:
          repository: ethereum/hive
          path: hivetests
-          persist-credentials: false

      - name: Get hive commit hash
        id: hive-commit
        run: echo "hash=$(cd hivetests && git rev-parse HEAD)" >> $GITHUB_OUTPUT

-      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+      - uses: actions/setup-go@v6
        with:
          go-version: "^1.13.1"
      - run: go version

      - name: Restore hive assets cache
        id: cache-hive
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache@v5
        with:
          path: ./hive_assets
-          key: hive-assets-${{ matrix.variant }}-${{ steps.hive-commit.outputs.hash }}-${{ hashFiles('.github/scripts/hive/build_simulators.sh') }}
+          key: hive-assets-${{ steps.hive-commit.outputs.hash }}-${{ hashFiles('.github/scripts/hive/build_simulators.sh') }}

      - name: Build hive assets
        if: steps.cache-hive.outputs.cache-hit != 'true'
-        run: .github/scripts/hive/build_simulators.sh ${{ matrix.variant }}
+        run: .github/scripts/hive/build_simulators.sh

      - name: Load cached Docker images
        if: steps.cache-hive.outputs.cache-hit == 'true'
@@ -85,195 +68,11 @@ jobs:
          chmod +x hive

      - name: Upload hive assets
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        uses: actions/upload-artifact@v7
        with:
-          name: hive_assets_${{ matrix.variant }}
+          name: hive_assets
          path: ./hive_assets
-  test-amsterdam:
-    timeout-minutes: 120
-    strategy:
-      fail-fast: false
-      matrix:
-        # ethereum/rpc to be deprecated:
-        # https://github.com/ethereum/hive/pull/1117
-        scenario:
-          - sim: smoke/genesis
-          - sim: smoke/network
-          - sim: ethereum/sync
-          - 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
-          # - sim: devp2p
-          #  limit: eth
-          #  include:
-          #    - MaliciousHandshake
-          #    # failures tracked in https://github.com/paradigmxyz/reth/issues/14825
-          #    - Status
-          #    - GetBlockHeaders
-          #    - ZeroRequestID
-          #    - GetBlockBodies
-          #    - Transaction
-          #    - NewPooledTxs
-          - sim: devp2p
-            limit: discv5
-            include:
-              # failures tracked at https://github.com/paradigmxyz/reth/issues/14825
-              - PingLargeRequestID
-          - sim: ethereum/engine
-            limit: engine-exchange-capabilities
-          - sim: ethereum/engine
-            limit: engine-withdrawals
-          - sim: ethereum/engine
-            limit: engine-auth
-          - sim: ethereum/engine
-            limit: engine-api
-          - sim: ethereum/engine
-            limit: cancun
-          # eth_ rpc methods
-          - sim: ethereum/rpc-compat
-            include:
-              - eth_blockNumber
-              - eth_call
-              - eth_chainId
-              - eth_createAccessList
-              - eth_estimateGas
-              - eth_feeHistory
-              - eth_getBalance
-              - eth_getBlockBy
-              - eth_getBlockTransactionCountBy
-              - eth_getCode
-              - eth_getProof
-              - eth_getStorage
-              - eth_getTransactionBy
-              - eth_getTransactionCount
-              - eth_getTransactionReceipt
-              - eth_sendRawTransaction
-              - eth_syncing
-              # debug_ rpc methods
-              - debug_
-
-          # consume-engine
-          - sim: ethereum/eels/consume-engine
-            limit: .*tests/amsterdam.*
-          - sim: ethereum/eels/consume-engine
-            limit: .*tests/osaka.*
-          - sim: ethereum/eels/consume-engine
-            limit: .*tests/prague.*
-          - sim: ethereum/eels/consume-engine
-            limit: .*tests/cancun.*
-          - sim: ethereum/eels/consume-engine
-            limit: .*tests/shanghai.*
-          - sim: ethereum/eels/consume-engine
-            limit: .*tests/berlin.*
-          - sim: ethereum/eels/consume-engine
-            limit: .*tests/istanbul.*
-          - sim: ethereum/eels/consume-engine
-            limit: .*tests/homestead.*
-          - sim: ethereum/eels/consume-engine
-            limit: .*tests/frontier.*
-          - sim: ethereum/eels/consume-engine
-            limit: .*tests/paris.*
-
-          # consume-rlp
-          - sim: ethereum/eels/consume-rlp
-            limit: .*tests/amsterdam.*
-          - sim: ethereum/eels/consume-rlp
-            limit: .*tests/osaka.*
-          - sim: ethereum/eels/consume-rlp
-            limit: .*tests/prague.*
-          - sim: ethereum/eels/consume-rlp
-            limit: .*tests/cancun.*
-          - sim: ethereum/eels/consume-rlp
-            limit: .*tests/shanghai.*
-          - sim: ethereum/eels/consume-rlp
-            limit: .*tests/berlin.*
-          - sim: ethereum/eels/consume-rlp
-            limit: .*tests/istanbul.*
-          - sim: ethereum/eels/consume-rlp
-            limit: .*tests/homestead.*
-          - sim: ethereum/eels/consume-rlp
-            limit: .*tests/frontier.*
-          - sim: ethereum/eels/consume-rlp
-            limit: .*tests/paris.*
-    needs:
-      - build-reth
-      - prepare-hive
-    name: Hive-Amsterdam / ${{ matrix.scenario.sim }}${{ matrix.scenario.limit && format(' - {0}', matrix.scenario.limit) }}
-    # Use larger runners for eels tests to avoid OOM runner crashes
-    runs-on: ${{ github.repository == 'paradigmxyz/reth' && (contains(matrix.scenario.sim, 'eels') && 'depot-ubuntu-latest-8' || 'depot-ubuntu-latest-4') || 'ubuntu-latest' }}
-    permissions:
-      contents: read
-      issues: write
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-          fetch-depth: 0
-
-      - name: Download hive assets
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
-        with:
-          name: hive_assets_amsterdam
-          path: /tmp
-
-      - name: Download reth image
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
-        with:
-          name: reth
-          path: /tmp
-
-      - name: Load Docker images
-        run: .github/scripts/hive/load_images.sh
-
-      - name: Move hive binary
-        run: |
-          mv /tmp/hive /usr/local/bin
-          chmod +x /usr/local/bin/hive
-
-      - name: Checkout hive tests
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          repository: ethereum/hive
-          ref: master
-          path: hivetests
-          persist-credentials: false
-
-      - name: Run simulator
-        env:
-          SCENARIO_SIM: ${{ matrix.scenario.sim }}
-          SCENARIO_LIMIT: ${{ matrix.scenario.limit }}
-          SCENARIO_TESTS: ${{ join(matrix.scenario.include, '|') }}
-        run: |
-          LIMIT="$SCENARIO_LIMIT"
-          TESTS="$SCENARIO_TESTS"
-          if [ -n "$LIMIT" ] && [ -n "$TESTS" ]; then
-            FILTER="$LIMIT/$TESTS"
-          elif [ -n "$LIMIT" ]; then
-            FILTER="$LIMIT"
-          elif [ -n "$TESTS" ]; then
-            FILTER="/$TESTS"
-          else
-            FILTER="/"
-          fi
-          echo "filter: $FILTER"
-          .github/scripts/hive/run_simulator.sh "$SCENARIO_SIM" "$FILTER" "amsterdam"
-
-      - 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
-
-      - name: Print simulator output
-        if: ${{ failure() }}
-        run: |
-          cat hivetests/workspace/logs/*simulator*.log
-
-      - name: Print reth client logs
-        if: ${{ failure() }}
-        run: |
-          cat hivetests/workspace/logs/reth/client-*.log
-
-  test-osaka:
+  test:
    timeout-minutes: 120
    strategy:
      fail-fast: false
@@ -379,26 +178,24 @@ jobs:
    needs:
      - build-reth
      - prepare-hive
-    name: Hive-Osaka / ${{ matrix.scenario.sim }}${{ matrix.scenario.limit && format(' - {0}', matrix.scenario.limit) }}
+    name: ${{ matrix.scenario.sim }}${{ matrix.scenario.limit && format(' - {0}', matrix.scenario.limit) }}
    # Use larger runners for eels tests to avoid OOM runner crashes
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && (contains(matrix.scenario.sim, 'eels') && 'depot-ubuntu-latest-8' || 'depot-ubuntu-latest-4') || 'ubuntu-latest' }}
    permissions:
-      contents: read
      issues: write
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@v6
        with:
-          persist-credentials: false
          fetch-depth: 0

      - name: Download hive assets
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@v8
        with:
-          name: hive_assets_osaka
+          name: hive_assets
          path: /tmp

      - name: Download reth image
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@v8
        with:
          name: reth
          path: /tmp
@@ -412,21 +209,16 @@ jobs:
          chmod +x /usr/local/bin/hive

      - name: Checkout hive tests
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@v6
        with:
          repository: ethereum/hive
          ref: master
          path: hivetests
-          persist-credentials: false

      - name: Run simulator
-        env:
-          SCENARIO_SIM: ${{ matrix.scenario.sim }}
-          SCENARIO_LIMIT: ${{ matrix.scenario.limit }}
-          SCENARIO_TESTS: ${{ join(matrix.scenario.include, '|') }}
        run: |
-          LIMIT="$SCENARIO_LIMIT"
-          TESTS="$SCENARIO_TESTS"
+          LIMIT="${{ matrix.scenario.limit }}"
+          TESTS="${{ join(matrix.scenario.include, '|') }}"
          if [ -n "$LIMIT" ] && [ -n "$TESTS" ]; then
            FILTER="$LIMIT/$TESTS"
          elif [ -n "$LIMIT" ]; then
@@ -437,7 +229,7 @@ jobs:
            FILTER="/"
          fi
          echo "filter: $FILTER"
-          .github/scripts/hive/run_simulator.sh "$SCENARIO_SIM" "$FILTER" "osaka"
+          .github/scripts/hive/run_simulator.sh "${{ matrix.scenario.sim }}" "$FILTER"

      - name: Parse hive output
        run: |
@@ -453,14 +245,12 @@ jobs:
        run: |
          cat hivetests/workspace/logs/reth/client-*.log
  notify-on-error:
-    needs:
-      - test-amsterdam
-      - test-osaka
+    needs: test
    if: failure()
    runs-on: ubuntu-latest
    steps:
      - name: Slack Webhook Action
-        uses: rtCamp/action-slack-notify@e31e87e03dd19038e411e38ae27cbad084a90661 # v2.3.3
+        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 }}"
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -20,15 +20,11 @@ concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

-permissions: {}
-
 jobs:
  test:
    name: test / ${{ matrix.network }}
    if: github.event_name != 'schedule'
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest-4' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    env:
      RUST_BACKTRACE: 1
    strategy:
@@ -36,18 +32,14 @@ jobs:
        network: ["ethereum"]
    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
      - name: Install Geth
        run: .github/scripts/install_geth.sh
-      - uses: taiki-e/install-action@1f2425cdb59f8fffb99ee16a5968edf6f57a2b93 # v2.75.24
-        with:
-          tool: nextest
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - 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
@@ -66,7 +58,7 @@ jobs:
    timeout-minutes: 30
    steps:
      - name: Decide whether the needed jobs succeeded or failed
-        uses: re-actors/alls-green@05ac9388f0aebcb5727afa17fcccfecd6f8ec5fe # release/v1
+        uses: re-actors/alls-green@release/v1
        with:
          jobs: ${{ toJSON(needs) }}

@@ -74,19 +66,13 @@ jobs:
    name: era1 file integration tests once a day
    if: github.event_name == 'schedule' && github.repository == 'paradigmxyz/reth'
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
-      - uses: taiki-e/install-action@1f2425cdb59f8fffb99ee16a5968edf6f57a2b93 # v2.75.24
-        with:
-          tool: nextest
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - 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 era1 files integration tests
--- a/.github/workflows/kurtosis.yml
+++ b/.github/workflows/kurtosis.yml
@@ -18,14 +18,9 @@ concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

-permissions: {}
-
 jobs:
  build-reth:
    if: github.repository == 'paradigmxyz/reth'
-    permissions:
-      contents: read
-      id-token: write
    uses: ./.github/workflows/docker-test.yml
    with:
      hive_target: kurtosis
@@ -37,18 +32,15 @@ jobs:
      fail-fast: false
    name: run kurtosis
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    needs:
      - build-reth
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@v6
        with:
-          persist-credentials: false
          fetch-depth: 0

      - name: Download reth image
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@v8
        with:
          name: artifacts
          path: /tmp
@@ -60,7 +52,7 @@ jobs:
          docker image ls -a

      - name: Run kurtosis
-        uses: ethpandaops/kurtosis-assertoor-github-action@f64942cbc780df731a731ea9f45765b161d2c8df # v1.0.1
+        uses: ethpandaops/kurtosis-assertoor-github-action@v1
        with:
          ethereum_package_args: ".github/assets/kurtosis_network_params.yaml"

@@ -70,7 +62,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Slack Webhook Action
-        uses: rtCamp/action-slack-notify@e31e87e03dd19038e411e38ae27cbad084a90661 # v2.3.3
+        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 }}"
--- a/.github/workflows/label-pr.yml
+++ b/.github/workflows/label-pr.yml
@@ -4,23 +4,19 @@ on:
  pull_request:
    types: [opened]

-permissions: {}
-
 jobs:
  label_prs:
    runs-on: ubuntu-latest
    permissions:
-      contents: read
      issues: write
      pull-requests: write
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@v6
        with:
-          persist-credentials: false
          fetch-depth: 0

      - name: Label PRs
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@v9
        with:
          script: |
            const label_pr = require('./.github/scripts/label_pr.js')
--- a/.github/workflows/lint-actions.yml
+++ b/.github/workflows/lint-actions.yml
@@ -8,17 +8,11 @@ on:
    paths:
    - '.github/**'

-permissions: {}
-
 jobs:
  actionlint:
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6
      - name: Download actionlint
        id: get_actionlint
        run: bash <(curl https://raw.githubusercontent.com/rhysd/actionlint/main/scripts/download-actionlint.bash)
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -10,14 +10,10 @@ env:
  CARGO_TERM_COLOR: always
  RUSTC_WRAPPER: "sccache"

-permissions: {}
-
 jobs:
  clippy-binaries:
    name: clippy binaries / ${{ matrix.type }}
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    timeout-minutes: 30
    strategy:
      matrix:
@@ -26,19 +22,17 @@ jobs:
            args: --workspace --lib --examples --tests --benches --locked
            features: "ethereum asm-keccak jemalloc jemalloc-prof min-error-logs min-warn-logs min-info-logs min-debug-logs min-trace-logs"
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@clippy
        with:
          components: clippy
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
      - if: "${{ matrix.type == 'book' }}"
-        uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
+        uses: arduino/setup-protoc@v3
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}
      - name: Run clippy on binaries
@@ -49,19 +43,15 @@ jobs:
  clippy:
    name: clippy
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@nightly
        with:
          components: clippy
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
      - run: cargo clippy --workspace --lib --examples --tests --benches --all-features --locked
@@ -70,25 +60,19 @@ jobs:

  wasm:
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
        with:
          target: wasm32-wasip1
-      - uses: taiki-e/install-action@1f2425cdb59f8fffb99ee16a5968edf6f57a2b93 # v2.75.24
-        with:
-          tool: cargo-hack
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: taiki-e/install-action@cargo-hack
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
-      - uses: dcarbone/install-jq-action@b7ef57d46ece78760b4019dbc4080a1ba2a40b45 # v3.2.0
+      - uses: dcarbone/install-jq-action@v3
      - name: Run Wasm checks
        run: |
          sudo apt update && sudo apt install gcc-multilib
@@ -96,49 +80,37 @@ jobs:

  riscv:
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
        with:
          target: riscv32imac-unknown-none-elf
-      - uses: taiki-e/install-action@1f2425cdb59f8fffb99ee16a5968edf6f57a2b93 # v2.75.24
-        with:
-          tool: cargo-hack
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: taiki-e/install-action@cargo-hack
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
-      - uses: dcarbone/install-jq-action@b7ef57d46ece78760b4019dbc4080a1ba2a40b45 # v3.2.0
+      - uses: dcarbone/install-jq-action@v3
      - name: Run RISC-V checks
        run: .github/scripts/check_rv32imac.sh

  crate-checks:
    name: crate-checks (${{ matrix.partition }}/${{ matrix.total_partitions }})
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest-4' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    strategy:
      matrix:
        partition: [1, 2, 3]
        total_partitions: [3]
    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
-      - uses: taiki-e/install-action@1f2425cdb59f8fffb99ee16a5968edf6f57a2b93 # v2.75.24
-        with:
-          tool: cargo-hack
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: taiki-e/install-action@cargo-hack
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
      - run: cargo hack check --workspace --partition ${{ matrix.partition }}/${{ matrix.total_partitions }}
@@ -146,19 +118,15 @@ jobs:
  msrv:
    name: MSRV
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest-8' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@master
        with:
          toolchain: "1.93" # MSRV
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
      - run: cargo build --bin reth --workspace
@@ -168,17 +136,13 @@ jobs:
  docs:
    name: docs
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest-4' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@nightly
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
      - run: cargo docs --document-private-items
@@ -190,56 +154,42 @@ jobs:
  fmt:
    name: fmt
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@nightly
        with:
          components: rustfmt
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
+      - uses: mozilla-actions/sccache-action@v0.0.9
      - name: Run fmt
        run: cargo fmt --all --check

  udeps:
    name: udeps
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@nightly
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
-      - uses: taiki-e/install-action@1f2425cdb59f8fffb99ee16a5968edf6f57a2b93 # v2.75.24
-        with:
-          tool: cargo-udeps
+      - uses: taiki-e/install-action@cargo-udeps
      - run: cargo udeps --workspace --lib --examples --tests --benches --all-features --locked

  book:
    name: book
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@nightly
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
      - run: cargo build --bin reth --workspace
@@ -251,54 +201,38 @@ jobs:

  typos:
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: crate-ci/typos@02ea592e44b3a53c302f697cddca7641cd051c3d # v1.45.0
+      - uses: actions/checkout@v6
+      - uses: crate-ci/typos@v1

  check-toml:
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
    timeout-minutes: 30
    steps:
      - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+        uses: actions/checkout@v6
      - name: Run dprint
-        uses: dprint/check@9cb3a2b17a8e606d37aae341e49df3654933fc23 # v2.3
+        uses: dprint/check@v2.3
        with:
          config-path: dprint.json

  grafana:
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6
      - name: Check dashboard JSON with jq
-        uses: sergeysova/jq-action@a3f0d4ff59cc1dddf023fc0b325dd75b10deec58 # v2.3.0
+        uses: sergeysova/jq-action@v2
        with:
          cmd: jq empty etc/grafana/dashboards/overview.json

  no-test-deps:
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
      - name: Ensure no arbitrary or proptest dependency on default build
        run: cargo tree --package reth -e=features,no-dev | grep -Eq "arbitrary|proptest" && exit 1 || exit 0
@@ -306,17 +240,13 @@ jobs:
  # Check crates correctly propagate features
  feature-propagation:
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    timeout-minutes: 20
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6
      - uses: dtolnay/rust-toolchain@stable
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
-      - uses: taiki-e/cache-cargo-install-action@a8b9ecf8e0c0ea09d7481cfc583a5203ecd585b5 # v3.0.5
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: rui314/setup-mold@v1
+      - uses: taiki-e/cache-cargo-install-action@v3
        with:
          tool: zepter
      - name: Eagerly pull dependencies
@@ -324,8 +254,6 @@ jobs:
      - run: zepter run check

  deny:
-    permissions:
-      contents: read
    uses: tempoxyz/ci/.github/workflows/deny.yml@main

  lint-success:
@@ -349,6 +277,6 @@ jobs:
    timeout-minutes: 30
    steps:
      - name: Decide whether the needed jobs succeeded or failed
-        uses: re-actors/alls-green@05ac9388f0aebcb5727afa17fcccfecd6f8ec5fe # release/v1
+        uses: re-actors/alls-green@release/v1
        with:
          jobs: ${{ toJSON(needs) }}
--- a/.github/workflows/pr-audit.yml
+++ b/.github/workflows/pr-audit.yml
@@ -4,36 +4,27 @@ on:
  pull_request:
    types: [labeled]

-permissions: {}
-
 jobs:
  publish:
    runs-on: ubuntu-latest
    if: github.event.label.name == 'cyclops'
-    permissions: {}
    steps:
      - name: Publish event
-        env:
-          EVENTS_KEY: ${{ secrets.EVENTS_KEY }}
-          EVENTS_CERT: ${{ secrets.EVENTS_CERT }}
-          EVENTS_ARGS: ${{ secrets.EVENTS_ARGS }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          PR_SHA: ${{ github.event.pull_request.head.sha }}
        run: |
          set -euo pipefail

-          echo "$EVENTS_KEY" > "${{ runner.temp }}/key"
-          echo "$EVENTS_CERT" > "${{ runner.temp }}/cert"
+          echo "${{ secrets.EVENTS_KEY }}" > ${{ runner.temp }}/key
+          echo "${{ secrets.EVENTS_CERT }}" > ${{ runner.temp }}/cert

-          curl -sf -o /dev/null -X POST $EVENTS_ARGS \
+          curl -sf -o /dev/null -X POST ${{ secrets.EVENTS_ARGS }} \
            -H "Content-Type: application/json" \
-            --key "${{ runner.temp }}/key" \
-            --cert "${{ runner.temp }}/cert" \
+            --key ${{ runner.temp }}/key \
+            --cert ${{ runner.temp }}/cert \
            -d '{
              "repository": "${{ github.repository }}",
              "event": "pr_audit",
              "data": {
-                "pr_number": '"$PR_NUMBER"',
-                "sha": "'"$PR_SHA"'"
+                "pr_number": ${{ github.event.pull_request.number }},
+                "sha": "${{ github.event.pull_request.head.sha }}"
              }
            }'
--- a/.github/workflows/pr-title.yml
+++ b/.github/workflows/pr-title.yml
@@ -8,19 +8,20 @@ on:
      - edited
      - synchronize

-permissions: {}
+permissions:
+  pull-requests: read
+  contents: read

 jobs:
  conventional-title:
    name: Validate PR title is Conventional Commit
    runs-on: ubuntu-latest
    permissions:
-      contents: read
      pull-requests: write
    steps:
      - name: Check title
        id: lint_pr_title
-        uses: amannn/action-semantic-pull-request@48f256284bd46cdaab1048c3721360e808335d50 # v6.1.1
+        uses: amannn/action-semantic-pull-request@v6
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
@@ -39,7 +40,7 @@ jobs:
        continue-on-error: true
      - name: Add PR Comment for Invalid Title
        if: steps.lint_pr_title.outcome == 'failure'
-        uses: marocchino/sticky-pull-request-comment@d4d6b0936434b21bc8345ad45a440c5f7d2c40ff # v3.0.3
+        uses: marocchino/sticky-pull-request-comment@v2
        with:
          header: pr-title-lint-error
          message: |
@@ -75,7 +76,7 @@ jobs:

      - name: Remove Comment for Valid Title
        if: steps.lint_pr_title.outcome == 'success'
-        uses: marocchino/sticky-pull-request-comment@d4d6b0936434b21bc8345ad45a440c5f7d2c40ff # v3.0.3
+        uses: marocchino/sticky-pull-request-comment@v2
        with:
          header: pr-title-lint-error
          delete: true
--- a/.github/workflows/release-dist.yml
+++ b/.github/workflows/release-dist.yml
@@ -7,15 +7,12 @@ on:
  release:
    types: [published]

-permissions: {}
-
 jobs:
  release-homebrew:
    runs-on: ubuntu-latest
-    permissions: {}
    steps:
      - name: Update Homebrew formula
-        uses: dawidd6/action-homebrew-bump-formula@1446dca236b0440c6f02723a3f14f13be2c04ab0 # v7
+        uses: dawidd6/action-homebrew-bump-formula@v7
        with:
          token: ${{ secrets.HOMEBREW }}
          no_fork: true
--- a/.github/workflows/release-reproducible.yml
+++ b/.github/workflows/release-reproducible.yml
@@ -2,8 +2,6 @@

 name: release-reproducible

-permissions: {}
-
 on:
  workflow_run:
    workflows: [release]
@@ -17,23 +15,20 @@ jobs:
    name: extract version
    if: ${{ github.event.workflow_run.conclusion == 'success' }}
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
    steps:
      - name: Extract version from triggering tag
        id: extract_version
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
        run: |
          # Get the tag that points to the head SHA of the triggering workflow
          TAG=$(gh api /repos/${{ github.repository }}/git/refs/tags \
-            --jq ".[] | select(.object.sha == \"${HEAD_SHA}\") | .ref" \
+            --jq '.[] | select(.object.sha == "${{ github.event.workflow_run.head_sha }}") | .ref' \
            | head -1 \
            | sed 's|refs/tags/||')

          if [ -z "$TAG" ]; then
-            echo "No tag found for SHA ${HEAD_SHA}"
+            echo "No tag found for SHA ${{ github.event.workflow_run.head_sha }}"
            exit 1
          fi

@@ -49,16 +44,15 @@ jobs:
      packages: write
      contents: write
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@v6
        with:
-          persist-credentials: false
          ref: ${{ needs.extract-version.outputs.VERSION }}

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
+        uses: docker/setup-buildx-action@v3

      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        uses: docker/login-action@v4
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
@@ -71,7 +65,7 @@ jobs:
          echo "RUST_TOOLCHAIN=$RUST_TOOLCHAIN" >> $GITHUB_OUTPUT

      - name: Build reproducible artifacts
-        uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7.0.0
+        uses: docker/build-push-action@v6
        id: docker_build
        with:
          context: .
@@ -81,11 +75,13 @@ jobs:
            VERSION=${{ needs.extract-version.outputs.VERSION }}
          target: artifacts
          outputs: type=local,dest=./docker-artifacts
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
        env:
          DOCKER_BUILD_RECORD_UPLOAD: false

      - name: Build and push final image
-        uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7.0.0
+        uses: docker/build-push-action@v6
        with:
          context: .
          file: ./Dockerfile.reproducible
@@ -96,6 +92,8 @@ jobs:
          tags: |
            ${{ env.DOCKER_REPRODUCIBLE_IMAGE_NAME }}:${{ needs.extract-version.outputs.VERSION }}
            ${{ env.DOCKER_REPRODUCIBLE_IMAGE_NAME }}:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
          provenance: false
        env:
          DOCKER_BUILD_RECORD_UPLOAD: false
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -3,8 +3,6 @@

 name: release

-permissions: {}
-
 on:
  push:
    tags:
@@ -22,24 +20,21 @@ env:
  REPRODUCIBLE_IMAGE_NAME: ${{ github.repository_owner }}/reth-reproducible
  CARGO_TERM_COLOR: always
  DOCKER_IMAGE_NAME_URL: https://ghcr.io/${{ github.repository_owner }}/reth
+  RUSTC_WRAPPER: "sccache"

 jobs:
  dry-run:
    name: check dry run
    runs-on: ubuntu-latest
-    permissions: {}
    steps:
-      - env:
-          DRY_RUN: ${{ github.event.inputs.dry_run }}
-        run: |
-          echo "Dry run value: ${DRY_RUN}"
-          echo "Dry run enabled: $( [ "${DRY_RUN}" = 'true' ] && echo true || echo false )"
-          echo "Dry run disabled: $( [ "${DRY_RUN}" != 'true' ] && echo true || echo false )"
+      - run: |
+          echo "Dry run value: ${{ github.event.inputs.dry_run }}"
+          echo "Dry run enabled: ${{ github.event.inputs.dry_run == 'true'}}"
+          echo "Dry run disabled: ${{ github.event.inputs.dry_run != 'true'}}"

  extract-version:
    name: extract version
    runs-on: ubuntu-latest
-    permissions: {}
    steps:
      - name: Extract version
        run: echo "VERSION=${GITHUB_REF_NAME//\//-}" >> $GITHUB_OUTPUT
@@ -50,15 +45,12 @@ jobs:
  check-version:
    name: check version
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
    needs: extract-version
    if: ${{ github.event.inputs.dry_run != 'true' }}
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6
      - uses: dtolnay/rust-toolchain@stable
+      - uses: mozilla-actions/sccache-action@v0.0.9
      - name: Verify crate version matches tag
        # Check that the Cargo version starts with the tag,
        # so that Cargo version 1.4.8 can be matched against both v1.4.8 and v1.4.8-rc.1
@@ -71,8 +63,6 @@ jobs:
  build:
    name: build release
    runs-on: ${{ matrix.configs.os }}
-    permissions:
-      contents: read
    needs: extract-version
    continue-on-error: ${{ matrix.configs.allow_fail }}
    strategy:
@@ -105,20 +95,20 @@ jobs:
          - command: build
            binary: reth
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
        with:
          target: ${{ matrix.configs.target }}
+      - uses: mozilla-actions/sccache-action@v0.0.9
      - name: Install cross main
        if: ${{ !matrix.configs.native }}
        id: cross_main
        run: |
-          cargo install cross --locked \
-            --git https://github.com/cross-rs/cross \
-            --rev 65fe72b0cdb1e7e0cc0652517498d4389cc8f5cf
+          cargo install cross --locked --git https://github.com/cross-rs/cross
+      - uses: Swatinem/rust-cache@v2
+        with:
+          cache-on-failure: true

      - name: Apple M1 setup
        if: matrix.configs.target == 'aarch64-apple-darwin'
@@ -155,14 +145,14 @@ jobs:

      - name: Upload artifact
        if: ${{ github.event.inputs.dry_run != 'true' }}
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        uses: actions/upload-artifact@v7
        with:
          name: ${{ matrix.build.binary }}-${{ needs.extract-version.outputs.VERSION }}-${{ matrix.configs.target }}.tar.gz
          path: ${{ matrix.build.binary }}-${{ needs.extract-version.outputs.VERSION }}-${{ matrix.configs.target }}.tar.gz

      - name: Upload signature
        if: ${{ github.event.inputs.dry_run != 'true' }}
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        uses: actions/upload-artifact@v7
        with:
          name: ${{ matrix.build.binary }}-${{ needs.extract-version.outputs.VERSION }}-${{ matrix.configs.target }}.tar.gz.asc
          path: ${{ matrix.build.binary }}-${{ needs.extract-version.outputs.VERSION }}-${{ matrix.configs.target }}.tar.gz.asc
@@ -181,12 +171,11 @@ jobs:
    steps:
      # This is necessary for generating the changelog.
      # It has to come before "Download Artifacts" or else it deletes the artifacts.
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@v6
        with:
-          persist-credentials: false
          fetch-depth: 0
      - name: Download artifacts
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@v8
      - name: Generate full changelog
        id: changelog
        run: |
@@ -272,7 +261,6 @@ jobs:
  dry-run-summary:
    name: dry run summary
    runs-on: ubuntu-latest
-    permissions: {}
    needs: [build, extract-version]
    if: ${{ github.event.inputs.dry_run == 'true' }}
    env:
--- a/.github/workflows/reproducible-build.yml
+++ b/.github/workflows/reproducible-build.yml
@@ -5,15 +5,11 @@ on:
  schedule:
    - cron: "0 1 */2 * *"

-permissions: {}
-
 jobs:
  build:
    if: github.repository == 'paradigmxyz/reth'
    name: build reproducible binaries
    runs-on: ${{ matrix.runner }}
-    permissions:
-      contents: read
    strategy:
      matrix:
        include:
@@ -22,16 +18,14 @@ jobs:
          - runner: ubuntu-22.04
            machine: machine-2
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6

      - uses: dtolnay/rust-toolchain@stable
        with:
          target: x86_64-unknown-linux-gnu

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
+        uses: docker/setup-buildx-action@v3

      - name: Build reproducible binary with Docker
        run: |
@@ -49,7 +43,7 @@ jobs:
          echo "Binaries SHA256 on ${{ matrix.machine }}: $(cat checksum.sha256)"

      - name: Upload the hash
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        uses: actions/upload-artifact@v7
        with:
          name: checksum-${{ matrix.machine }}
          path: |
@@ -62,12 +56,12 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Download artifacts from machine-1
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@v8
        with:
          name: checksum-machine-1
          path: machine-1/
      - name: Download artifacts from machine-2
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@v8
        with:
          name: checksum-machine-2
          path: machine-2/
--- a/.github/workflows/stage.yml
+++ b/.github/workflows/stage.yml
@@ -18,28 +18,22 @@ concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

-permissions: {}
-
 jobs:
  stage:
    name: stage-run-test
    # Only run stage commands test in merge groups
    if: github.event_name == 'merge_group'
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    env:
      RUST_LOG: info,sync=error
      RUST_BACKTRACE: 1
    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
      - name: Build reth
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@@ -7,8 +7,6 @@ on:
  schedule:
    - cron: "30 1 * * *"

-permissions: {}
-
 jobs:
  close-issues:
    if: github.repository == 'paradigmxyz/reth'
@@ -17,7 +15,7 @@ jobs:
      issues: write
      pull-requests: write
    steps:
-      - uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
+      - uses: actions/stale@v10
        with:
          days-before-stale: 21
          days-before-close: 7
--- a/.github/workflows/sync-era.yml
+++ b/.github/workflows/sync-era.yml
@@ -15,15 +15,11 @@ concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

-permissions: {}
-
 jobs:
  sync:
    if: github.repository == 'paradigmxyz/reth'
    name: sync (${{ matrix.chain.bin }})
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    env:
      RUST_LOG: info,sync=error
      RUST_BACKTRACE: 1
@@ -38,13 +34,11 @@ jobs:
            block: 100000
            unwind-target: "0x52e0509d33a988ef807058e2980099ee3070187f7333aae12b64d4d675f34c5a"
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
      - name: Build ${{ matrix.chain.bin }}
--- a/.github/workflows/sync.yml
+++ b/.github/workflows/sync.yml
@@ -15,15 +15,11 @@ concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

-permissions: {}
-
 jobs:
  sync:
    if: github.repository == 'paradigmxyz/reth'
    name: sync (${{ matrix.chain.bin }})
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    env:
      RUST_LOG: info,sync=error
      RUST_BACKTRACE: 1
@@ -38,13 +34,11 @@ jobs:
            block: 100000
            unwind-target: "0x52e0509d33a988ef807058e2980099ee3070187f7333aae12b64d4d675f34c5a"
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
      - name: Build ${{ matrix.chain.bin }}
--- a/.github/workflows/unit.yml
+++ b/.github/workflows/unit.yml
@@ -17,14 +17,10 @@ concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

-permissions: {}
-
 jobs:
  test:
    name: test / ${{ matrix.type }}
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest-4' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    env:
      RUST_BACKTRACE: 1
    strategy:
@@ -36,20 +32,16 @@ jobs:
            exclude_args: ""
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
-      - uses: taiki-e/install-action@1f2425cdb59f8fffb99ee16a5968edf6f57a2b93 # v2.75.24
-        with:
-          tool: nextest
+      - uses: taiki-e/install-action@nextest
      - if: "${{ matrix.type == 'book' }}"
-        uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
+        uses: arduino/setup-protoc@v3
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}
      - name: Run tests
@@ -64,25 +56,20 @@ jobs:
  state:
    name: Ethereum state tests
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest-8' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    env:
      RUST_LOG: info,sync=error
      RUST_BACKTRACE: 1
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v6
      - name: Checkout ethereum/tests
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@v6
        with:
          repository: ethereum/tests
          ref: 81862e4848585a438d64f911a19b3825f0f4cd95
          path: testing/ef-tests/ethereum-tests
          submodules: recursive
          fetch-depth: 1
-          persist-credentials: false
      - name: Download & extract EEST fixtures (public)
        shell: bash
        env:
@@ -92,13 +79,11 @@ jobs:
          mkdir -p testing/ef-tests/execution-spec-tests
          URL="https://github.com/ethereum/execution-spec-tests/releases/download/${EEST_TESTS_TAG}/fixtures_stable.tar.gz"
          curl -L "$URL" | tar -xz --strip-components=1 -C testing/ef-tests/execution-spec-tests
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
-      - uses: taiki-e/install-action@1f2425cdb59f8fffb99ee16a5968edf6f57a2b93 # v2.75.24
-        with:
-          tool: nextest
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: taiki-e/install-action@nextest
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
      - run: cargo nextest run --no-fail-fast --cargo-profile hivetests -p ef-tests --features "asm-keccak ef-tests"
@@ -106,19 +91,15 @@ jobs:
  doc:
    name: doc tests
    runs-on: ${{ github.repository == 'paradigmxyz/reth' && 'depot-ubuntu-latest' || 'ubuntu-latest' }}
-    permissions:
-      contents: read
    env:
      RUST_BACKTRACE: 1
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-      - uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+      - uses: actions/checkout@v6
+      - uses: rui314/setup-mold@v1
      - uses: dtolnay/rust-toolchain@stable
-      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+      - uses: mozilla-actions/sccache-action@v0.0.9
+      - uses: Swatinem/rust-cache@v2
        with:
          cache-on-failure: true
      - name: Run doctests
@@ -132,6 +113,6 @@ jobs:
    timeout-minutes: 30
    steps:
      - name: Decide whether the needed jobs succeeded or failed
-        uses: re-actors/alls-green@05ac9388f0aebcb5727afa17fcccfecd6f8ec5fe # release/v1
+        uses: re-actors/alls-green@release/v1
        with:
          jobs: ${{ toJSON(needs) }}
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace.package]
-version = "2.2.0"
+version = "2.1.0"
 edition = "2024"
 rust-version = "1.93"
 license = "MIT OR Apache-2.0"
@@ -326,8 +326,8 @@ reth-cli = { path = "crates/cli/cli" }
 reth-cli-commands = { path = "crates/cli/commands" }
 reth-cli-runner = { path = "crates/cli/runner" }
 reth-cli-util = { path = "crates/cli/util" }
-reth-codecs = { version = "0.3.1", default-features = false }
-reth-codecs-derive = "0.3.1"
+reth-codecs = { version = "0.3.0", default-features = false }
+reth-codecs-derive = "0.3.0"
 reth-config = { path = "crates/config", default-features = false }
 reth-consensus = { path = "crates/consensus/consensus", default-features = false }
 reth-consensus-common = { path = "crates/consensus/common", default-features = false }
@@ -395,7 +395,7 @@ reth-payload-builder-primitives = { path = "crates/payload/builder-primitives" }
 reth-payload-primitives = { path = "crates/payload/primitives" }
 reth-payload-validator = { path = "crates/payload/validator" }
 reth-payload-util = { path = "crates/payload/util" }
-reth-primitives-traits = { version = "0.3.1", default-features = false }
+reth-primitives-traits = { version = "0.3.0", default-features = false }
 reth-provider = { path = "crates/storage/provider" }
 reth-prune = { path = "crates/prune/prune" }
 reth-prune-types = { path = "crates/prune/types", default-features = false }
@@ -411,7 +411,7 @@ reth-rpc-eth-types = { path = "crates/rpc/rpc-eth-types", default-features = fal
 reth-rpc-layer = { path = "crates/rpc/rpc-layer" }
 reth-rpc-server-types = { path = "crates/rpc/rpc-server-types" }
 reth-rpc-convert = { path = "crates/rpc/rpc-convert" }
-reth-rpc-traits = { version = "0.3.1", default-features = false }
+reth-rpc-traits = { version = "0.3.0", default-features = false }
 reth-stages = { path = "crates/stages/stages" }
 reth-stages-api = { path = "crates/stages/api" }
 reth-stages-types = { path = "crates/stages/types", default-features = false }
@@ -430,7 +430,7 @@ reth-trie-common = { path = "crates/trie/common", default-features = false }
 reth-trie-db = { path = "crates/trie/db" }
 reth-trie-parallel = { path = "crates/trie/parallel" }
 reth-trie-sparse = { path = "crates/trie/sparse", default-features = false }
-reth-zstd-compressors = { version = "0.3.1", default-features = false }
+reth-zstd-compressors = { version = "0.3.0", default-features = false }

 # revm
 revm = { version = "38.0.0", default-features = false }
@@ -449,40 +449,40 @@ alloy-sol-types = { version = "1.5.6", default-features = false }

 alloy-chains = { version = "0.2.33", default-features = false }
 alloy-eip2124 = { version = "0.2.0", default-features = false }
-alloy-eip7928 = { version = "0.3.4", default-features = false }
-alloy-evm = { version = "0.34.0", default-features = false }
+alloy-eip7928 = { version = "0.3.0", default-features = false }
+alloy-evm = { version = "0.33.0", default-features = false }
 alloy-rlp = { version = "0.3.13", default-features = false, features = ["core-net"] }
 alloy-trie = { version = "0.9.4", default-features = false }

 alloy-hardforks = "0.4.7"

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

 # misc
 either = { version = "1.15.0", default-features = false }
@@ -581,7 +581,7 @@ tower = "0.5"
 tower-http = "0.6"

 # p2p
-discv5 = { git = "https://github.com/sigp/discv5", rev = "7663c00" }
+discv5 = "0.10"
 if-addrs = "0.14"

 # rpc
--- a/13
+++ b/13
@@ -33,24 +33,15 @@ ENV FEATURES=$FEATURES
 RUN cargo chef cook --profile $BUILD_PROFILE --features "$FEATURES" --recipe-path recipe.json

 # Build application
-# Platform-specific RUSTFLAGS: amd64 uses x86-64-v3 (Haswell+) with pclmulqdq for rocksdb
-#
-# TARGETPLATFORM is set by BuildKit: https://docs.docker.com/reference/dockerfile#automatic-platform-args-in-the-global-scope
-ARG TARGETPLATFORM
 COPY --exclude=dist . .
-RUN 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 reth
+RUN cargo build --profile $BUILD_PROFILE --features "$FEATURES" --locked --bin reth

 # ARG is not resolved in COPY so we have to hack around it by copying the
 # binary to a temporary location
 RUN cp /app/target/$BUILD_PROFILE/reth /app/reth

 # Use Ubuntu as the release image
-FROM ubuntu:24.04 AS runtime
+FROM ubuntu AS runtime
 WORKDIR /app

 # Copy reth over from the build stage
--- a/bin/reth-bb/Cargo.toml
+++ b/bin/reth-bb/Cargo.toml
@@ -69,7 +69,6 @@ default = [
    "jemalloc",
    "reth-cli-util/jemalloc",
    "asm-keccak",
-    "keccak-cache-global",
    "min-debug-logs",
 ]

@@ -90,12 +89,6 @@ asm-keccak = [
    "revm-primitives/asm-keccak",
 ]

-keccak-cache-global = [
-    "reth-node-core/keccak-cache-global",
-    "reth-node-ethereum/keccak-cache-global",
-    "alloy-primitives/keccak-cache-global",
-]
-
 min-debug-logs = [
    "tracing/release_max_level_debug",
    "reth-ethereum-cli/min-debug-logs",
--- a/bin/reth-bb/src/evm.rs
+++ b/bin/reth-bb/src/evm.rs
@@ -7,16 +7,15 @@
 //! `execute_transaction` to apply segment-boundary changes.

 use crate::evm_config::BigBlockSegment;
-use alloy_consensus::TransactionEnvelope;
 use alloy_eips::eip7685::Requests;
 use alloy_evm::{
    block::{
        BlockExecutionError, BlockExecutionResult, BlockExecutor, BlockExecutorFactory,
-        ExecutableTx, GasOutput, OnStateHook, StateChangeSource, StateDB,
+        BlockExecutorFor, ExecutableTx, GasOutput, OnStateHook, StateChangeSource, StateDB,
    },
    eth::{EthBlockExecutionCtx, EthBlockExecutor, EthEvmContext, EthTxResult},
    precompiles::PrecompilesMap,
-    Database, EthEvm, EthEvmFactory, Evm, EvmFactory, FromRecoveredTx, FromTxWithEncoded,
+    Database, EthEvm, EthEvmFactory, Evm, FromRecoveredTx, FromTxWithEncoded,
 };
 use alloy_primitives::B256;
 use reth_ethereum_primitives::{Receipt, TransactionSigned};
@@ -37,7 +36,6 @@ use tracing::{debug, trace};
 // ---------------------------------------------------------------------------

 /// Runtime state for segment boundary tracking.
-#[derive(Clone)]
 pub(crate) struct BbEvmPlan {
    /// The segment boundaries and environments.
    pub(crate) segments: Vec<BigBlockSegment>,
@@ -75,10 +73,6 @@ impl BbEvmPlan {
            .filter(|(n, _)| *n >= min && *n < block_number)
            .collect()
    }
-
-    pub(crate) fn segment_index_for_tx(&self, tx_index: usize) -> usize {
-        self.segments.partition_point(|segment| segment.start_tx <= tx_index).saturating_sub(1)
-    }
 }

 impl std::fmt::Debug for BbEvmPlan {
@@ -103,9 +97,6 @@ impl std::fmt::Debug for BbEvmPlan {
 /// segment boundaries without requiring additional trait bounds on `DB`.
 pub(crate) type BlockHashSeeder<DB> = fn(&mut DB, &[(u64, B256)]);

-/// Function pointer that reads the BAL index from the DB.
-pub(crate) type BalIndexReader<DB> = fn(&DB) -> u64;
-
 /// Block executor that wraps [`EthBlockExecutor`] and handles segment-boundary
 /// changes for big-block execution.
 ///
@@ -117,8 +108,7 @@ pub(crate) type BalIndexReader<DB> = fn(&DB) -> u64;
 /// Gas counters reset at each boundary so that each segment's real gas limit
 /// is used (preserving correct GASLIMIT opcode behavior). Accumulated offsets
 /// are applied to receipts and totals in `finish()`.
-#[expect(missing_debug_implementations)]
-pub struct BbBlockExecutor<'a, DB, I, P, Spec>
+pub(crate) struct BbBlockExecutor<'a, DB, I, P, Spec>
 where
    DB: Database,
 {
@@ -141,10 +131,6 @@ where
    /// Callback to reseed block hashes into the DB's cache at segment
    /// boundaries. See [`BlockHashSeeder`].
    block_hash_seeder: Option<BlockHashSeeder<DB>>,
-    /// Callback to read the BAL index from the DB.
-    bal_index_reader: Option<BalIndexReader<DB>>,
-    /// Whether the executor has selected its starting segment.
-    initialized: bool,
 }

 impl<'a, DB, I, P, Spec> BbBlockExecutor<'a, DB, I, P, Spec>
@@ -170,7 +156,6 @@ where
        receipt_builder: RethReceiptBuilder,
        plan: Option<BbEvmPlan>,
        block_hash_seeder: Option<BlockHashSeeder<DB>>,
-        bal_index_reader: Option<BalIndexReader<DB>>,
    ) -> Self {
        let inner = EthBlockExecutor::new(evm, ctx, spec, receipt_builder);
        Self {
@@ -181,63 +166,9 @@ where
            blob_gas_used_offset: 0,
            shared_hook: Arc::new(Mutex::new(None)),
            block_hash_seeder,
-            bal_index_reader,
-            initialized: false,
        }
    }

-    fn initialize(&mut self) -> Result<(), BlockExecutionError> {
-        if self.initialized {
-            return Ok(());
-        }
-
-        let plan = match &self.plan {
-            Some(plan) => plan,
-            None => return Ok(()),
-        };
-
-        self.initialized = true;
-
-        let bal_index =
-            self.bal_index_reader.map(|reader| reader(self.inner().evm().db())).unwrap_or(0);
-        let segment_idx =
-            if bal_index == 0 { 0 } else { plan.segment_index_for_tx((bal_index - 1) as usize) };
-        let segment = &plan.segments[segment_idx];
-
-        // Swap the EVM's block_env and executor ctx to the selected segment's
-        // values so that EIP-2935/EIP-4788 system calls use the correct block
-        // number and parent hash. Without this, the outer big block header's
-        // block_number (which is synthetic) would be used, writing to wrong
-        // EIP-2935 slots and corrupting state.
-        let block_env = segment.evm_env.block_env.clone();
-        let block_number = block_env.number.saturating_to::<u64>();
-        let mut cfg_env = segment.evm_env.cfg_env.clone();
-        cfg_env.disable_base_fee = true;
-        let ctx = EthBlockExecutionCtx {
-            parent_hash: segment.ctx.parent_hash,
-            parent_beacon_block_root: segment.ctx.parent_beacon_block_root,
-            ommers: segment.ctx.ommers,
-            withdrawals: segment.ctx.withdrawals.clone(),
-            extra_data: segment.ctx.extra_data.clone(),
-            tx_count_hint: segment.ctx.tx_count_hint,
-            slot_number: segment.ctx.slot_number,
-        };
-
-        let inner = self.inner_mut();
-        let evm_ctx = inner.evm.ctx_mut();
-        evm_ctx.block = block_env;
-        evm_ctx.cfg = cfg_env;
-        inner.ctx = ctx;
-
-        self.reseed_block_hashes_for(block_number);
-
-        if bal_index > 0 {
-            self.plan = None;
-        }
-
-        Ok(())
-    }
-
    /// Creates a forwarding `OnStateHook` that delegates to the shared hook.
    fn forwarding_hook(&self) -> Option<Box<dyn OnStateHook>> {
        let shared = self.shared_hook.clone();
@@ -418,9 +349,35 @@ where
    type Result = EthTxResult<HaltReason, alloy_consensus::TxType>;

    fn apply_pre_execution_changes(&mut self) -> Result<(), BlockExecutionError> {
-        // The outer big-block header uses a synthetic block number, so start
-        // system calls must run against the selected real segment env.
-        self.initialize()?;
+        // Swap the EVM's block_env and executor ctx to the first segment's
+        // values so that the initial EIP-2935/EIP-4788 system calls use the
+        // correct block number and parent hash. Without this, the outer big
+        // block header's block_number (which is synthetic) would be used,
+        // writing to wrong EIP-2935 slots and corrupting state.
+        if let Some(seg0) = self.plan.as_ref().map(|p| &p.segments[0]) {
+            let block_env = seg0.evm_env.block_env.clone();
+            let block_number = block_env.number.saturating_to::<u64>();
+            let mut cfg_env = seg0.evm_env.cfg_env.clone();
+            cfg_env.disable_base_fee = true;
+            let seg0_ctx = EthBlockExecutionCtx {
+                parent_hash: seg0.ctx.parent_hash,
+                parent_beacon_block_root: seg0.ctx.parent_beacon_block_root,
+                ommers: seg0.ctx.ommers,
+                withdrawals: seg0.ctx.withdrawals.clone(),
+                extra_data: seg0.ctx.extra_data.clone(),
+                tx_count_hint: seg0.ctx.tx_count_hint,
+                slot_number: seg0.ctx.slot_number,
+            };
+
+            let inner = self.inner_mut();
+            let evm_ctx = inner.evm.ctx_mut();
+            evm_ctx.block = block_env;
+            evm_ctx.cfg = cfg_env;
+            inner.ctx = seg0_ctx;
+
+            self.reseed_block_hashes_for(block_number);
+        }
+
        self.inner_mut().apply_pre_execution_changes()
    }

@@ -428,16 +385,15 @@ where
        &mut self,
        tx: impl ExecutableTx<Self>,
    ) -> Result<Self::Result, BlockExecutionError> {
-        self.initialize()?;
        self.maybe_apply_boundary()?;
        self.inner_mut().execute_transaction_without_commit(tx)
    }

-    fn commit_transaction(&mut self, output: Self::Result) -> GasOutput {
-        self.maybe_apply_boundary()
-            .expect("segment boundary application must succeed before committing transaction");
-
-        let gas_used = self.inner_mut().commit_transaction(output);
+    fn commit_transaction(
+        &mut self,
+        output: Self::Result,
+    ) -> Result<GasOutput, BlockExecutionError> {
+        let gas_used = self.inner_mut().commit_transaction(output)?;

        // Fix up cumulative_gas_used on the just-committed receipt so that
        // the receipt root task (which reads receipts incrementally) sees
@@ -452,7 +408,7 @@ where
        if let Some(plan) = &mut self.plan {
            plan.tx_counter += 1;
        }
-        gas_used
+        Ok(gas_used)
    }

    fn finish(
@@ -543,7 +499,7 @@ pub struct BbBlockExecutorFactory<Spec> {
    receipt_builder: RethReceiptBuilder,
    spec: Spec,
    evm_factory: EthEvmFactory,
-    /// Staged plan cloned into each [`BbBlockExecutor`].
+    /// Staged plan consumed by the next [`BbBlockExecutor`].
    pub(crate) staged_plan: Arc<Mutex<Option<BbEvmPlan>>>,
 }

@@ -572,12 +528,8 @@ impl<Spec> BbBlockExecutorFactory<Spec> {
        *self.staged_plan.lock().unwrap() = Some(plan);
    }

-    pub(crate) fn clear_staged_plan(&self) {
-        *self.staged_plan.lock().unwrap() = None;
-    }
-
-    fn peek_plan(&self) -> Option<BbEvmPlan> {
-        self.staged_plan.lock().unwrap().clone()
+    fn take_plan(&self) -> Option<BbEvmPlan> {
+        self.staged_plan.lock().unwrap().take()
    }

    pub(crate) fn create_executor_with_seeder<'a, DB, I>(
@@ -585,23 +537,14 @@ impl<Spec> BbBlockExecutorFactory<Spec> {
        evm: EthEvm<DB, I, PrecompilesMap>,
        ctx: EthBlockExecutionCtx<'a>,
        block_hash_seeder: Option<BlockHashSeeder<DB>>,
-        bal_index_reader: Option<BalIndexReader<DB>>,
    ) -> BbBlockExecutor<'a, DB, I, PrecompilesMap, &'a Spec>
    where
        Spec: alloy_evm::eth::spec::EthExecutorSpec,
        DB: StateDB + 'a,
        I: Inspector<EthEvmContext<DB>> + 'a,
    {
-        let plan = self.peek_plan();
-        BbBlockExecutor::new(
-            evm,
-            ctx,
-            &self.spec,
-            self.receipt_builder,
-            plan,
-            block_hash_seeder,
-            bal_index_reader,
-        )
+        let plan = self.take_plan();
+        BbBlockExecutor::new(evm, ctx, &self.spec, self.receipt_builder, plan, block_hash_seeder)
    }
 }

@@ -614,12 +557,6 @@ where
    type ExecutionCtx<'a> = EthBlockExecutionCtx<'a>;
    type Transaction = TransactionSigned;
    type Receipt = Receipt;
-    type TxExecutionResult = EthTxResult<
-        <EthEvmFactory as EvmFactory>::HaltReason,
-        <TransactionSigned as TransactionEnvelope>::TxType,
-    >;
-    type Executor<'a, DB: StateDB, I: Inspector<EthEvmContext<DB>>> =
-        BbBlockExecutor<'a, DB, I, PrecompilesMap, &'a Spec>;

    fn evm_factory(&self) -> &Self::EvmFactory {
        &self.evm_factory
@@ -629,12 +566,12 @@ where
        &'a self,
        evm: EthEvm<DB, I, PrecompilesMap>,
        ctx: EthBlockExecutionCtx<'a>,
-    ) -> Self::Executor<'a, DB, I>
+    ) -> impl BlockExecutorFor<'a, Self, DB, I>
    where
-        DB: StateDB,
-        I: Inspector<EthEvmContext<DB>>,
+        DB: StateDB + 'a,
+        I: Inspector<EthEvmContext<DB>> + 'a,
    {
-        let plan = self.peek_plan();
-        BbBlockExecutor::new(evm, ctx, &self.spec, self.receipt_builder, plan, None, None)
+        let plan = self.take_plan();
+        BbBlockExecutor::new(evm, ctx, &self.spec, self.receipt_builder, plan, None)
    }
 }
--- a/bin/reth-bb/src/evm_config.rs
+++ b/bin/reth-bb/src/evm_config.rs
@@ -8,14 +8,11 @@
 pub(crate) use reth_engine_primitives::BigBlockData;

 use crate::{
-    evm::{BalIndexReader, BbBlockExecutorFactory, BbEvmPlan},
+    evm::{BbBlockExecutorFactory, BbEvmPlan},
    BigBlockMap,
 };
 use alloy_consensus::Header;
-use alloy_evm::{
-    eth::{spec::EthExecutorSpec, EthBlockExecutionCtx},
-    EthEvmFactory,
-};
+use alloy_evm::eth::EthBlockExecutionCtx;
 use alloy_primitives::B256;
 use alloy_rpc_types::engine::ExecutionData;
 use core::convert::Infallible;
@@ -23,8 +20,8 @@ use reth_chainspec::{ChainSpec, EthChainSpec};
 use reth_ethereum_forks::Hardforks;
 use reth_ethereum_primitives::EthPrimitives;
 use reth_evm::{
-    ConfigureEngineEvm, ConfigureEvm, Database, EvmEnv, EvmEnvFor, ExecutableTxIterator,
-    ExecutionCtxFor, NextBlockEnvAttributes,
+    ConfigureEngineEvm, ConfigureEvm, Database, EvmEnv, ExecutableTxIterator,
+    NextBlockEnvAttributes,
 };
 use reth_evm_ethereum::{EthBlockAssembler, EthEvmConfig, RethReceiptBuilder};
 use reth_primitives_traits::{SealedBlock, SealedHeader};
@@ -32,6 +29,9 @@ use revm::primitives::hardfork::SpecId;
 use std::sync::Arc;
 use tracing::debug;

+use alloy_evm::{eth::spec::EthExecutorSpec, EthEvmFactory};
+use reth_evm::{EvmEnvFor, ExecutionCtxFor};
+
 // ---------------------------------------------------------------------------
 // Execution plan types
 // ---------------------------------------------------------------------------
@@ -55,7 +55,7 @@ pub(crate) struct BigBlockSegment {
 ///
 /// Wraps [`EthEvmConfig`] and a shared [`BigBlockMap`]. When a big-block
 /// payload is received, the plan is staged on the [`BbBlockExecutorFactory`]
-/// and cloned when executors are created. Block hashes for inter-segment
+/// and consumed when the executor is created. Block hashes for inter-segment
 /// BLOCKHASH resolution are reseeded into `State::block_hashes` at each
 /// segment boundary via a [`BlockHashSeeder`](crate::evm::BlockHashSeeder)
 /// callback injected in [`ConfigureEvm::create_executor`].
@@ -106,10 +106,6 @@ fn seed_state_block_hashes<DB>(state: &mut &mut revm::database::State<DB>, hashe
    }
 }

-fn read_bal_index<DB>(state: &&mut revm::database::State<DB>) -> u64 {
-    state.bal_state.bal_index()
-}
-
 // ---------------------------------------------------------------------------
 // ConfigureEvm
 // ---------------------------------------------------------------------------
@@ -148,12 +144,6 @@ where
        &self,
        block: &'a SealedBlock<reth_ethereum_primitives::Block>,
    ) -> Result<EthBlockExecutionCtx<'a>, Self::Error> {
-        if let Some(plan) = self.plan_for_payload_hash(&block.hash()) {
-            self.executor_factory.stage_plan(plan);
-        } else {
-            self.executor_factory.clear_staged_plan();
-        }
-
        self.inner.context_for_block(block)
    }

@@ -169,7 +159,7 @@ where
        &'a self,
        evm: reth_evm::EvmFor<Self, &'a mut revm::database::State<DB>, I>,
        ctx: EthBlockExecutionCtx<'a>,
-    ) -> alloy_evm::block::BlockExecutorFor<
+    ) -> impl alloy_evm::block::BlockExecutorFor<
        'a,
        Self::BlockExecutorFactory,
        &'a mut revm::database::State<DB>,
@@ -179,16 +169,15 @@ where
        DB: Database,
        I: reth_evm::InspectorFor<Self, &'a mut revm::database::State<DB>> + 'a,
    {
-        let bal_index_reader: Option<BalIndexReader<&'a mut revm::database::State<DB>>> =
-            Some(read_bal_index::<DB>);
-
-        // Inject concrete function pointers that know the `State<DB>` type so
-        // the generic executor can reseed block hashes and read `bal_index`.
+        // Use create_executor_with_seeder to inject a concrete seeder that
+        // can reseed State::block_hashes at segment boundaries. The seeder
+        // is a function pointer that knows the concrete State<DB> type,
+        // allowing the generic BbBlockExecutor to reseed without additional
+        // trait bounds on DB.
        self.executor_factory.create_executor_with_seeder(
            evm,
            ctx,
            Some(seed_state_block_hashes::<DB>),
-            bal_index_reader,
        )
    }
 }
@@ -225,7 +214,6 @@ where

            Ok(env)
        } else {
-            self.executor_factory.clear_staged_plan();
            self.inner.evm_env_for_payload(payload)
        }
    }
@@ -260,12 +248,10 @@ where
    /// In practice, this is called from `evm_env_for_payload` in the
    /// engine pipeline.
    pub fn stage_plan_for_payload(&self, payload_hash: &B256) {
-        let Some(plan) = self.plan_for_payload_hash(payload_hash) else { return };
-        self.executor_factory.stage_plan(plan);
-    }
-
-    fn plan_for_payload_hash(&self, payload_hash: &B256) -> Option<BbEvmPlan> {
-        let bb = self.pending.lock().unwrap().remove(payload_hash)?;
+        let bb = match self.pending.lock().unwrap().remove(payload_hash) {
+            Some(bb) => bb,
+            None => return,
+        };

        let segments: Vec<_> = bb
            .env_switches
@@ -301,6 +287,6 @@ where

        plan.block_hashes_to_seed.sort_unstable_by_key(|(n, _)| *n);

-        Some(plan)
+        self.executor_factory.stage_plan(plan);
    }
 }
--- a/bin/reth-bench/src/bench/context.rs
+++ b/bin/reth-bench/src/bench/context.rs
@@ -21,8 +21,6 @@ pub(crate) struct BenchContext {
    pub(crate) auth_provider: RootProvider<AnyNetwork>,
    /// The block provider is used for block queries.
    pub(crate) block_provider: RootProvider<AnyNetwork>,
-    /// The local regular RPC provider is used for non-authenticated node RPCs like `testing_*`.
-    pub(crate) local_rpc_provider: RootProvider<AnyNetwork>,
    /// The benchmark mode, which defines whether the benchmark should run for a closed or open
    /// range of blocks.
    pub(crate) benchmark_mode: BenchMode,
@@ -85,11 +83,6 @@ impl BenchContext {
        let client = ClientBuilder::default().connect_with(auth_transport).await?;
        let auth_provider = RootProvider::<AnyNetwork>::new(client);

-        let local_rpc_url = Url::parse(&bench_args.local_rpc_url)?;
-        info!(target: "reth-bench", "Connecting to local regular RPC at {} for testing namespace calls", local_rpc_url);
-        let local_rpc_provider =
-            RootProvider::<AnyNetwork>::new(ClientBuilder::default().http(local_rpc_url));
-
        // Computes the block range for the benchmark.
        //
        // - If `--advance` is provided, fetches the latest block from the engine and sets:
@@ -166,7 +159,6 @@ impl BenchContext {
        Ok(Self {
            auth_provider,
            block_provider,
-            local_rpc_provider,
            benchmark_mode,
            next_block,
            use_reth_namespace,
--- a/bin/reth-bench/src/bench/generate_big_block.rs
+++ b/bin/reth-bench/src/bench/generate_big_block.rs
@@ -21,7 +21,6 @@ use alloy_rpc_types_engine::{
 };
 use clap::Parser;
 use eyre::Context;
-use futures::{stream, StreamExt};
 use reth_chainspec::EthChainSpec;
 use reth_cli::chainspec::ChainSpecParser;
 use reth_cli_runner::CliContext;
@@ -30,10 +29,7 @@ use reth_ethereum_cli::chainspec::EthereumChainSpecParser;
 use reth_ethereum_primitives::Receipt;
 use reth_primitives_traits::proofs;
 use serde::{Deserialize, Serialize};
-use std::{
-    collections::{HashMap, HashSet},
-    future::Future,
-};
+use std::{collections::HashMap, future::Future};
 use tracing::{info, warn};

 use crate::bench::helpers::fetch_block_access_list;
@@ -271,15 +267,6 @@ pub struct Command {
    /// the flattened BAL on the stored payload.
    #[arg(long, default_value_t = false)]
    bal: bool,
-
-    /// Maximum number of in-flight RPC fetches to keep buffered ahead of the merger.
-    ///
-    /// Each entry is one full per-block fetch (block + receipts, plus BAL when `--bal` is
-    /// set). Larger values absorb RPC latency at the cost of more concurrent connections
-    /// and memory; the buffer persists across `--num-big-blocks` so prefetching continues
-    /// across big-block boundaries.
-    #[arg(long, value_name = "PREFETCH_BUFFER", default_value_t = 32)]
-    prefetch_buffer: usize,
 }

 impl Command {
@@ -332,27 +319,13 @@ impl Command {
        }
        let mut prev_big_block_header: Option<PrevBigBlockHeader> = None;

-        // Persistent prefetch stream: keeps `prefetch_buffer` per-block fetches in flight
-        // ahead of the merger across all big blocks. Each item is a fully materialized
-        // `FetchedBlock` (or `None` once the chain tip is reached on this fetch).
-        let prefetch_buffer = self.prefetch_buffer.max(1);
-        let bal_enabled = self.bal;
-        let block_stream = stream::iter(self.from_block..)
-            .map(|block_number| {
-                let provider = provider.clone();
-                async move { fetch_one_block(provider, block_number, bal_enabled).await }
-            })
-            .buffered(prefetch_buffer);
-        let mut block_stream = Box::pin(block_stream);
-
-        // Track the next block number we expect from the stream (purely for logging /
-        // big-block range bookkeeping; the stream produces blocks in `from_block..` order).
+        // Track the next block to fetch across big blocks so they don't overlap.
        let mut next_block = self.from_block;

        for big_block_idx in 0..self.num_big_blocks {
            let range_start = next_block;

-            // Drain the prefetch stream until the gas target is reached for this big block.
+            // Fetch consecutive blocks until the gas target is reached.
            let mut blocks = Vec::new();
            let mut block_receipts: Vec<Vec<Receipt>> = Vec::new();
            let mut block_access_lists: Vec<Option<BlockAccessList>> = Vec::new();
@@ -361,11 +334,16 @@ impl Command {
            let mut reached_chain_tip = false;
            while accumulated_block_gas < self.target_gas {
                let block_number = next_block;
-                info!(target: "reth-bench", block_number, big_block = big_block_idx, "Awaiting prefetched block");
+                info!(target: "reth-bench", block_number, big_block = big_block_idx, "Fetching block");

-                let fetched = match block_stream.next().await {
-                    Some(Ok(Some(fetched))) => fetched,
-                    Some(Ok(None)) => {
+                let fetch_result = tokio::try_join!(
+                    provider.get_block_by_number(block_number.into()).full(),
+                    provider.get_block_receipts(block_number.into()),
+                );
+
+                let (rpc_block, receipts) = match fetch_result {
+                    Ok((Some(block), Some(receipts))) => (block, receipts),
+                    Ok((None, _) | (_, None)) => {
                        warn!(
                            target: "reth-bench",
                            block_number,
@@ -374,16 +352,52 @@ impl Command {
                        reached_chain_tip = true;
                        break;
                    }
-                    Some(Err(e)) => return Err(e),
-                    // The block-number stream is open-ended; this only fires if the
-                    // upstream `iter(from..)` is somehow exhausted.
-                    None => {
-                        reached_chain_tip = true;
-                        break;
-                    }
+                    Err(e) => return Err(e.into()),
                };
-                let FetchedBlock { execution_data, consensus_receipts, block_access_list } =
-                    fetched;
+
+                let block_access_list = if self.bal {
+                    Some(fetch_block_access_list(&provider, block_number).await.wrap_err_with(
+                        || format!("Failed to fetch BAL for block {block_number}"),
+                    )?)
+                } else {
+                    None
+                };
+
+                // Convert RPC receipts to consensus receipts
+                let consensus_receipts: Vec<Receipt> = receipts
+                    .iter()
+                    .map(|r| {
+                        let inner = &r.inner.inner.inner;
+                        let tx_type = r.inner.inner.r#type.try_into().unwrap_or_default();
+                        Receipt {
+                            tx_type,
+                            success: inner.receipt.status.coerce_status(),
+                            cumulative_gas_used: inner.receipt.cumulative_gas_used,
+                            logs: inner
+                                .receipt
+                                .logs
+                                .iter()
+                                .map(|log| alloy_primitives::Log {
+                                    address: log.inner.address,
+                                    data: log.inner.data.clone(),
+                                })
+                                .collect(),
+                        }
+                    })
+                    .collect();
+
+                // Convert to consensus block
+                let block = rpc_block
+                    .into_inner()
+                    .map_header(|header| header.map(|h| h.into_header_with_defaults()))
+                    .try_map_transactions(|tx| -> eyre::Result<TxEnvelope> {
+                        tx.try_into().map_err(|_| eyre::eyre!("unsupported tx type"))
+                    })?
+                    .into_consensus();
+
+                // Convert to ExecutionData
+                let (payload, sidecar) = ExecutionPayload::from_block_slow(&block);
+                let execution_data = ExecutionData { payload, sidecar };

                let block_gas = execution_data.payload.as_v1().gas_used;
                let block_blob_gas =
@@ -657,79 +671,6 @@ impl Command {
    }
 }

-/// One fully-materialized block fetched by the prefetcher.
-struct FetchedBlock {
-    /// Execution payload with sidecar derived from the RPC block.
-    execution_data: ExecutionData,
-    /// Consensus-format receipts (`cumulative_gas_used` is still per-block, callers offset
-    /// it when merging).
-    consensus_receipts: Vec<Receipt>,
-    /// `eth_getBlockAccessListByBlockNumber` result when `--bal` is enabled.
-    block_access_list: Option<BlockAccessList>,
-}
-
-/// Fetches one block + receipts (and optionally its BAL) from the RPC. Returns `Ok(None)`
-/// when the block doesn't exist yet (chain-tip reached).
-async fn fetch_one_block(
-    provider: RootProvider<AnyNetwork>,
-    block_number: u64,
-    bal_enabled: bool,
-) -> eyre::Result<Option<FetchedBlock>> {
-    let (rpc_block, receipts) = tokio::try_join!(
-        provider.get_block_by_number(block_number.into()).full(),
-        provider.get_block_receipts(block_number.into()),
-    )?;
-    let (rpc_block, receipts) = match (rpc_block, receipts) {
-        (Some(b), Some(r)) => (b, r),
-        _ => return Ok(None),
-    };
-
-    let block_access_list = if bal_enabled {
-        Some(
-            fetch_block_access_list(&provider, block_number)
-                .await
-                .wrap_err_with(|| format!("Failed to fetch BAL for block {block_number}"))?,
-        )
-    } else {
-        None
-    };
-
-    let consensus_receipts: Vec<Receipt> = receipts
-        .iter()
-        .map(|r| {
-            let inner = &r.inner.inner.inner;
-            let tx_type = r.inner.inner.r#type.try_into().unwrap_or_default();
-            Receipt {
-                tx_type,
-                success: inner.receipt.status.coerce_status(),
-                cumulative_gas_used: inner.receipt.cumulative_gas_used,
-                logs: inner
-                    .receipt
-                    .logs
-                    .iter()
-                    .map(|log| alloy_primitives::Log {
-                        address: log.inner.address,
-                        data: log.inner.data.clone(),
-                    })
-                    .collect(),
-            }
-        })
-        .collect();
-
-    let block = rpc_block
-        .into_inner()
-        .map_header(|header| header.map(|h| h.into_header_with_defaults()))
-        .try_map_transactions(|tx| -> eyre::Result<TxEnvelope> {
-            tx.try_into().map_err(|_| eyre::eyre!("unsupported tx type"))
-        })?
-        .into_consensus();
-
-    let (payload, sidecar) = ExecutionPayload::from_block_slow(&block);
-    let execution_data = ExecutionData { payload, sidecar };
-
-    Ok(Some(FetchedBlock { execution_data, consensus_receipts, block_access_list }))
-}
-
 fn merge_block_access_list(
    merged: &mut BlockAccessList,
    incoming: BlockAccessList,
@@ -776,17 +717,6 @@ fn merge_account_changes(existing: &mut AccountChanges, incoming: AccountChanges
    existing.balance_changes.extend(incoming.balance_changes);
    existing.nonce_changes.extend(incoming.nonce_changes);
    existing.code_changes.extend(incoming.code_changes);
-
-    // EIP-7928 invariant: a slot must appear in either storage_changes or storage_reads,
-    // not both. Per-block BALs respect this, but merging blocks can produce a slot
-    // that is read in one block and changed in another. Without this normalization,
-    // an empty read entry can shadow the real writes during BAL deserialization,
-    // making reads of that slot fall through to stale snapshot state.
-    let written: HashSet<_> =
-        existing.storage_changes.iter().map(|slot_changes| slot_changes.slot).collect();
-    existing.storage_reads.retain(|slot| !written.contains(slot));
-    let mut seen = HashSet::with_capacity(existing.storage_reads.len());
-    existing.storage_reads.retain(|slot| seen.insert(*slot));
 }

 fn merge_slot_changes(existing: &mut Vec<SlotChanges>, incoming: Vec<SlotChanges>) {
@@ -906,54 +836,4 @@ mod tests {
        assert_eq!(other.address, Address::repeat_byte(0x22));
        assert_eq!(other.storage_changes[0].changes[0].block_access_index, 3);
    }
-
-    #[test]
-    fn merge_account_changes_normalizes_storage_reads_after_cross_block_merge() {
-        let address = Address::repeat_byte(0x33);
-        const A: U256 = U256::from_limbs([1, 0, 0, 0]);
-        const B: U256 = U256::from_limbs([2, 0, 0, 0]);
-        const C: U256 = U256::from_limbs([3, 0, 0, 0]);
-        const D: U256 = U256::from_limbs([4, 0, 0, 0]);
-
-        // Each AccountChanges value is valid on its own: storage slots only appear in
-        // either reads or changes. The invalid read/change overlap is introduced when
-        // these per-block BAL entries are merged for a standalone big block.
-        let mut existing = AccountChanges {
-            address,
-            storage_changes: vec![SlotChanges::new(A, vec![StorageChange::new(0, U256::from(10))])],
-            storage_reads: vec![B, C],
-            balance_changes: vec![],
-            nonce_changes: vec![],
-            code_changes: vec![],
-        };
-
-        // B is read before it is written by the incoming block, and A is written before
-        // it appears as a read in the incoming block. C is read in both blocks, so the
-        // merge should also dedupe it. D remains read-only.
-        let incoming = AccountChanges {
-            address,
-            storage_changes: vec![SlotChanges::new(B, vec![StorageChange::new(1, U256::from(20))])],
-            storage_reads: vec![A, C, D],
-            balance_changes: vec![],
-            nonce_changes: vec![],
-            code_changes: vec![],
-        };
-
-        merge_account_changes(&mut existing, incoming);
-
-        // Written slots remain represented by storage_changes, while storage_reads only
-        // keeps unique read-only slots in first-seen order.
-        assert_eq!(
-            existing
-                .storage_changes
-                .iter()
-                .map(|slot_changes| slot_changes.slot)
-                .collect::<Vec<_>>(),
-            vec![A, B]
-        );
-        assert_eq!(existing.storage_reads, vec![C, D]);
-        assert!(existing.storage_reads.iter().all(|read_slot| {
-            !existing.storage_changes.iter().any(|slot_changes| slot_changes.slot == *read_slot)
-        }));
-    }
 }
--- a/bin/reth-bench/src/bench/new_payload_fcu.rs
+++ b/bin/reth-bench/src/bench/new_payload_fcu.rs
@@ -14,24 +14,14 @@ use crate::{
        block_to_new_payload, call_forkchoice_updated_with_reth, call_new_payload_with_reth,
    },
 };
-use alloy_consensus::TxEnvelope;
-use alloy_eips::Encodable2718;
-use alloy_primitives::B256;
-use alloy_provider::{
-    ext::DebugApi,
-    network::{AnyNetwork, AnyRpcBlock},
-    Provider, RootProvider,
-};
-use alloy_rpc_types_engine::{
-    ExecutionData, ExecutionPayloadEnvelopeV5, ForkchoiceState, PayloadAttributes,
-};
+use alloy_provider::{ext::DebugApi, Provider};
+use alloy_rpc_types_engine::ForkchoiceState;
 use clap::Parser;
-use eyre::{bail, ensure, Context, OptionExt};
+use eyre::{Context, OptionExt};
 use futures::{stream, StreamExt, TryStreamExt};
 use reth_cli_runner::CliContext;
 use reth_engine_primitives::config::DEFAULT_PERSISTENCE_THRESHOLD;
 use reth_node_core::args::BenchmarkArgs;
-use reth_rpc_api::{RethNewPayloadInput, TestingBuildBlockRequestV1};
 use std::time::{Duration, Instant};
 use tracing::{debug, info, warn};

@@ -42,22 +32,6 @@ pub struct Command {
    #[arg(long, value_name = "RPC_URL", verbatim_doc_comment)]
    rpc_url: String,

-    /// Build a separate fork with `testing_buildBlockV1` and alternate forkchoice updates between
-    /// the canonical chain and that fork on every block while the fork grows up to the configured
-    /// depth.
-    ///
-    /// This requires enabling the hidden `testing` RPC module on the target node,
-    /// for example with `reth node --http --http.api eth,testing`.
-    #[arg(
-        long,
-        value_name = "DEPTH",
-        num_args = 0..=1,
-        default_missing_value = "8",
-        value_parser = parse_reorg_depth,
-        verbatim_doc_comment
-    )]
-    reorg: Option<usize>,
-
    /// How long to wait after a forkchoice update before sending the next payload.
    ///
    /// Accepts a duration string (e.g. `100ms`, `2s`) or a bare integer treated as
@@ -109,79 +83,18 @@ pub struct Command {
    benchmark: BenchmarkArgs,
 }

-#[derive(Debug)]
-struct PreparedBuiltBlock {
-    block_hash: B256,
-    params: serde_json::Value,
-}
-
-#[derive(Debug)]
-struct QueuedForkBlock {
-    block_number: u64,
-    prepared: PreparedBuiltBlock,
-}
-
-#[derive(Debug)]
-struct ReorgState {
-    depth: usize,
-    fork_length: usize,
-    branch_point_hash: Option<B256>,
-    fork_parent_hash: Option<B256>,
-}
-
-impl ReorgState {
-    const fn new(depth: usize) -> Self {
-        Self { depth, fork_length: 0, branch_point_hash: None, fork_parent_hash: None }
-    }
-
-    const fn push_fork_head(&mut self, canonical_parent_hash: B256, fork_head_hash: B256) {
-        if self.fork_length == 0 {
-            self.branch_point_hash = Some(canonical_parent_hash);
-        }
-        self.fork_length += 1;
-        self.fork_parent_hash = Some(fork_head_hash);
-    }
-
-    fn forkchoice_state(&self, fork_head_hash: B256) -> eyre::Result<ForkchoiceState> {
-        let branch_point_hash = self.branch_point_hash.ok_or_eyre("missing reorg branch point")?;
-
-        Ok(ForkchoiceState {
-            head_block_hash: fork_head_hash,
-            safe_block_hash: branch_point_hash,
-            finalized_block_hash: branch_point_hash,
-        })
-    }
-
-    const fn reset(&mut self) {
-        self.fork_length = 0;
-        self.branch_point_hash = None;
-        self.fork_parent_hash = None;
-    }
-}
-
 impl Command {
    /// Execute `benchmark new-payload-fcu` command
    pub async fn execute(self, _ctx: CliContext) -> eyre::Result<()> {
-        if self.reorg.is_some() && self.benchmark.rlp_blocks {
-            bail!("--reorg cannot be combined with --rlp-blocks")
-        }
-        if self.reorg.is_some() && self.enable_bal {
-            bail!("--reorg cannot be combined with --enable-bal")
-        }
-
        // Log mode configuration
        if let Some(duration) = self.wait_time {
            info!(target: "reth-bench", "Using wait-time mode with {}ms minimum interval between blocks", duration.as_millis());
        }
-        if let Some(depth) = self.reorg {
-            info!(target: "reth-bench", depth, "Using testing_buildBlockV1 reorg mode");
-        }

        let BenchContext {
            benchmark_mode,
            block_provider,
            auth_provider,
-            local_rpc_provider,
            next_block,
            use_reth_namespace,
            rlp_blocks,
@@ -269,8 +182,7 @@ impl Command {
        let mut blocks_processed = 0u64;
        let total_benchmark_duration = Instant::now();
        let mut total_wait_time = Duration::ZERO;
-        let mut reorg_state = self.reorg.map(ReorgState::new);
-        let mut queued_fork_block = None;
+
        while let Some((block, head, safe, finalized, rlp)) = {
            let wait_start = Instant::now();
            let result = blocks.try_next().await?;
@@ -280,13 +192,11 @@ impl Command {
            let gas_used = block.header.gas_used;
            let gas_limit = block.header.gas_limit;
            let block_number = block.header.number;
-            let canonical_parent_hash = block.header.parent_hash;
            let transaction_count = block.transactions.len() as u64;
-            let deferred_branch_start_block = reorg_state
-                .as_ref()
-                .filter(|state| state.fork_length == 0 && queued_fork_block.is_none())
-                .map(|_| block.clone());
-            let canonical_forkchoice_state = ForkchoiceState {
+
+            debug!(target: "reth-bench", ?block_number, "Sending payload");
+
+            let forkchoice_state = ForkchoiceState {
                head_block_hash: head,
                safe_block_hash: safe,
                finalized_block_hash: finalized,
@@ -308,11 +218,10 @@ impl Command {
                no_wait_for_caches,
                bal,
            )?;
-
-            debug!(target: "reth-bench", ?block_number, "Sending payload");
            let start = Instant::now();
            let server_timings =
                call_new_payload_with_reth(&auth_provider, version, params).await?;
+
            let np_latency =
                server_timings.as_ref().map(|t| t.latency).unwrap_or_else(|| start.elapsed());
            let new_payload_result = NewPayloadResult {
@@ -333,12 +242,17 @@ impl Command {
            };

            let fcu_start = Instant::now();
-            call_forkchoice_updated_with_reth(&auth_provider, version, canonical_forkchoice_state)
-                .await?;
+            call_forkchoice_updated_with_reth(&auth_provider, version, forkchoice_state).await?;
            let fcu_latency = fcu_start.elapsed();

-            let total_latency =
-                if server_timings.is_some() { np_latency + fcu_latency } else { start.elapsed() };
+            let total_latency = if server_timings.is_some() {
+                // When using server-side latency for newPayload, derive total from the
+                // independently measured components to avoid mixing server-side and
+                // client-side (network-inclusive) timings.
+                np_latency + fcu_latency
+            } else {
+                start.elapsed()
+            };
            let combined_result = CombinedResult {
                block_number,
                gas_limit,
@@ -348,88 +262,6 @@ impl Command {
                total_latency,
            };

-            if let Some(reorg_state) = reorg_state.as_mut() {
-                if queued_fork_block.is_none() && reorg_state.fork_length == 0 {
-                    // A branch start uses a canonical parent, so it can be built lazily here
-                    // instead of being queued ahead of time.
-                    let block = deferred_branch_start_block
-                        .as_ref()
-                        .ok_or_eyre("missing deferred fork block for reorg branch start")?;
-                    queued_fork_block = Some(QueuedForkBlock {
-                        block_number,
-                        prepared: prepare_built_block(
-                            &local_rpc_provider,
-                            block,
-                            canonical_parent_hash,
-                            no_wait_for_caches,
-                        )
-                        .await?,
-                    });
-                }
-
-                let queued = queued_fork_block
-                    .take()
-                    .ok_or_eyre("missing queued fork block for reorg replay")?;
-                ensure!(
-                    queued.block_number == block_number,
-                    "queued fork block {} does not match source block {}",
-                    queued.block_number,
-                    block_number
-                );
-                let prepared = queued.prepared;
-
-                call_new_payload_with_reth(&auth_provider, None, prepared.params).await?;
-
-                reorg_state.push_fork_head(canonical_parent_hash, prepared.block_hash);
-                let forkchoice_state = reorg_state.forkchoice_state(prepared.block_hash)?;
-
-                info!(
-                    target: "reth-bench",
-                    block_number,
-                    branch_point = %forkchoice_state.safe_block_hash,
-                    fork_head = %prepared.block_hash,
-                    fork_depth = reorg_state.fork_length,
-                    max_reorg_depth = reorg_state.depth,
-                    "Switching forkchoice to reorg branch"
-                );
-
-                let fcu_start = Instant::now();
-                call_forkchoice_updated_with_reth(&auth_provider, None, forkchoice_state).await?;
-                let _fork_fcu_latency = fcu_start.elapsed();
-
-                let next_fork_block_number = block_number + 1;
-                if reorg_state.fork_length < reorg_state.depth {
-                    queued_fork_block = queue_fork_block(
-                        &block_provider,
-                        &local_rpc_provider,
-                        &benchmark_mode,
-                        next_fork_block_number,
-                        Some(prepared.block_hash),
-                        no_wait_for_caches,
-                    )
-                    .await?;
-                } else {
-                    info!(
-                        target: "reth-bench",
-                        block_number,
-                        reorg_depth = reorg_state.depth,
-                        "Resetting reorg branch after reaching max depth"
-                    );
-
-                    // `testing_buildBlockV1` resolves the parent from canonical state, so switch
-                    // back to the source chain before reseeding the next queued fork block.
-                    call_forkchoice_updated_with_reth(
-                        &auth_provider,
-                        version,
-                        canonical_forkchoice_state,
-                    )
-                    .await?;
-
-                    reorg_state.reset();
-                    queued_fork_block = None;
-                }
-            }
-
            // Exclude time spent waiting on the block prefetch channel from the benchmark duration.
            // We want to measure engine throughput, not RPC fetch latency.
            blocks_processed += 1;
@@ -486,155 +318,3 @@ impl Command {
        Ok(())
    }
 }
-
-async fn prepare_built_block(
-    block_provider: &RootProvider<AnyNetwork>,
-    block: &AnyRpcBlock,
-    parent_block_hash: B256,
-    no_wait_for_caches: bool,
-) -> eyre::Result<PreparedBuiltBlock> {
-    const MAX_BUILD_ATTEMPTS: usize = 10;
-    const BUILD_RETRY_INTERVAL: Duration = Duration::from_millis(100);
-
-    let request = build_block_request(block, parent_block_hash)?;
-    let built_payload: ExecutionPayloadEnvelopeV5 = {
-        let mut attempts_remaining = MAX_BUILD_ATTEMPTS;
-
-        loop {
-            match block_provider.client().request("testing_buildBlockV1", [request.clone()]).await {
-                Ok(payload) => break payload,
-                Err(err) if attempts_remaining > 1 && is_retryable_build_block_error(&err) => {
-                    warn!(
-                        target: "reth-bench",
-                        block_number = block.header.number,
-                        %parent_block_hash,
-                        attempts_remaining,
-                        error = %err,
-                        "Retrying testing_buildBlockV1 after transient fork build failure"
-                    );
-                    attempts_remaining -= 1;
-                    tokio::time::sleep(BUILD_RETRY_INTERVAL).await;
-                }
-                Err(err) => {
-                    return Err(err).wrap_err_with(|| {
-                        format!(
-                            "Failed to build block {} via testing_buildBlockV1",
-                            block.header.number
-                        )
-                    })
-                }
-            }
-        }
-    };
-
-    let payload = &built_payload.execution_payload.payload_inner.payload_inner;
-    let block_hash = payload.block_hash;
-    let (payload, sidecar) = built_payload
-        .into_payload_and_sidecar(block.header.parent_beacon_block_root.unwrap_or_default());
-    // Fork payloads are built immediately before the next `testing_buildBlockV1` call. Leaving
-    // reth's default persistence wait enabled here gives the regular RPC side a consistent base
-    // state for the next synthetic fork block build.
-    let params = serde_json::to_value((
-        RethNewPayloadInput::ExecutionData(ExecutionData { payload, sidecar }),
-        None::<bool>,
-        no_wait_for_caches.then_some(false),
-    ))?;
-
-    Ok(PreparedBuiltBlock { block_hash, params })
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn queue_fork_block(
-    block_provider: &RootProvider<AnyNetwork>,
-    local_rpc_provider: &RootProvider<AnyNetwork>,
-    benchmark_mode: &crate::bench_mode::BenchMode,
-    block_number: u64,
-    parent_block_hash: Option<B256>,
-    no_wait_for_caches: bool,
-) -> eyre::Result<Option<QueuedForkBlock>> {
-    if !benchmark_mode.contains(block_number) {
-        return Ok(None)
-    }
-
-    let future_block = block_provider
-        .get_block_by_number(alloy_eips::BlockNumberOrTag::Number(block_number))
-        .full()
-        .await
-        .wrap_err_with(|| format!("Failed to fetch block by number {block_number}"))?
-        .ok_or_eyre("Block not found")?;
-    let parent_block_hash = parent_block_hash.unwrap_or(future_block.header.parent_hash);
-
-    Ok(Some(QueuedForkBlock {
-        block_number,
-        prepared: prepare_built_block(
-            local_rpc_provider,
-            &future_block,
-            parent_block_hash,
-            no_wait_for_caches,
-        )
-        .await?,
-    }))
-}
-
-fn is_retryable_build_block_error(err: &alloy_transport::TransportError) -> bool {
-    let message = err.to_string();
-    message.contains("block not found: hash") ||
-        message.contains("block hash not found for block number")
-}
-
-fn build_block_request(
-    block: &AnyRpcBlock,
-    parent_block_hash: B256,
-) -> eyre::Result<TestingBuildBlockRequestV1> {
-    let mut transactions = block
-        .clone()
-        .try_into_transactions()
-        .map_err(|_| eyre::eyre!("Block transactions must be fetched in full for --reorg"))?
-        .into_iter()
-        .map(|tx| {
-            let tx: TxEnvelope =
-                tx.try_into().map_err(|_| eyre::eyre!("unsupported tx type in RPC block"))?;
-            if tx.is_eip4844() {
-                return Ok(None)
-            }
-            Ok(Some(tx.encoded_2718().into()))
-        })
-        .filter_map(|tx| tx.transpose())
-        .collect::<eyre::Result<Vec<_>>>()?;
-
-    // `testing_buildBlockV1` only takes raw transaction bytes, so we exclude blob transactions
-    // from the synthetic fork blocks rather than trying to reconstruct their sidecars.
-    // Keep only 90% of the remaining transactions so the alternate branch produces a materially
-    // different post-state instead of only differing by header data.
-    let keep = transactions.len().saturating_mul(9) / 10;
-    transactions.truncate(keep);
-
-    let rpc_block = block.clone().into_inner();
-
-    Ok(TestingBuildBlockRequestV1 {
-        parent_block_hash,
-        payload_attributes: PayloadAttributes {
-            timestamp: block.header.timestamp,
-            prev_randao: block.header.mix_hash.unwrap_or_default(),
-            suggested_fee_recipient: block.header.beneficiary,
-            withdrawals: rpc_block.withdrawals.map(|withdrawals| withdrawals.into_inner()),
-            parent_beacon_block_root: block.header.parent_beacon_block_root,
-            slot_number: block.header.slot_number,
-        },
-        transactions,
-        extra_data: Some(block.header.extra_data.clone()),
-    })
-}
-
-fn parse_reorg_depth(value: &str) -> Result<usize, String> {
-    let depth = value
-        .trim()
-        .parse::<usize>()
-        .map_err(|_| format!("invalid reorg depth {value:?}, expected a positive integer"))?;
-
-    if depth == 0 {
-        return Err("reorg depth must be greater than 0".to_string())
-    }
-
-    Ok(depth)
-}
--- a/bin/reth-bench/src/bench/new_payload_only.rs
+++ b/bin/reth-bench/src/bench/new_payload_only.rs
@@ -54,7 +54,6 @@ impl Command {
            rlp_blocks,
            wait_for_persistence,
            no_wait_for_caches,
-            ..
        } = BenchContext::new(&self.benchmark, self.rpc_url).await?;

        let total_blocks = benchmark_mode.total_blocks();
--- a/crates/chain-state/Cargo.toml
+++ b/crates/chain-state/Cargo.toml
@@ -18,7 +18,7 @@ reth-errors.workspace = true
 reth-execution-types.workspace = true
 reth-metrics.workspace = true
 reth-ethereum-primitives.workspace = true
-reth-primitives-traits = { workspace = true, features = ["dashmap"] }
+reth-primitives-traits.workspace = true
 reth-storage-api.workspace = true
 reth-trie.workspace = true

--- a/crates/chain-state/src/lazy_overlay.rs
+++ b/crates/chain-state/src/lazy_overlay.rs
@@ -4,32 +4,26 @@
 //! lazily on first access. This allows execution to start before the trie overlay
 //! is fully computed.

-use crate::{EthPrimitives, ExecutedBlock};
+use crate::DeferredTrieData;
 use alloy_primitives::B256;
-use reth_primitives_traits::{
-    dashmap::{self, DashMap},
-    AlloyBlockHeader, NodePrimitives,
-};
 use reth_trie::{updates::TrieUpdatesSorted, HashedPostStateSorted, TrieInputSorted};
-use std::sync::Arc;
+use std::sync::{Arc, OnceLock};
 use tracing::{debug, trace};

 /// Inputs captured for lazy overlay computation.
 #[derive(Clone)]
-struct LazyOverlayInputs<N: NodePrimitives = EthPrimitives> {
-    /// In-memory blocks from tip to anchor child.
-    ///
-    /// Blocks must be provided in reverse chain order (newest to oldest).
-    blocks: Vec<ExecutedBlock<N>>,
+struct LazyOverlayInputs {
+    /// The persisted ancestor hash (anchor) this overlay should be built on.
+    anchor_hash: B256,
+    /// Deferred trie data handles for all in-memory blocks (newest to oldest).
+    blocks: Vec<DeferredTrieData>,
 }

 /// Lazily computed trie overlay.
 ///
 /// Captures the inputs needed to compute a [`TrieInputSorted`] and defers the actual
-/// computation until first access.
-///
-/// Blocks must be provided in reverse chain order (newest to oldest), so the first block is the
-/// chain tip and the last block is the oldest in-memory block in the chain segment.
+/// computation until first access. This is conceptually similar to [`DeferredTrieData`]
+/// but for overlay computation.
 ///
 /// # Fast Path vs Slow Path
 ///
@@ -37,41 +31,37 @@ struct LazyOverlayInputs<N: NodePrimitives = EthPrimitives> {
 ///   matches our expected anchor, we can reuse it directly (O(1)).
 /// - **Slow path**: Otherwise, we merge all ancestor blocks' trie data into a new overlay.
 #[derive(Clone)]
-pub struct LazyOverlay<N: NodePrimitives = EthPrimitives> {
-    /// Computed results, cached by requested anchor hash.
-    inner: Arc<DashMap<B256, Arc<TrieInputSorted>>>,
+pub struct LazyOverlay {
+    /// Computed result, cached after first access.
+    inner: Arc<OnceLock<TrieInputSorted>>,
    /// Inputs for lazy computation.
-    inputs: LazyOverlayInputs<N>,
+    inputs: LazyOverlayInputs,
 }

-impl<N: NodePrimitives> std::fmt::Debug for LazyOverlay<N> {
+impl std::fmt::Debug for LazyOverlay {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("LazyOverlay")
-            .field(
-                "oldest_block_parent_hash",
-                &self.inputs.blocks.last().map(|block| block.recovered_block().parent_hash()),
-            )
+            .field("anchor_hash", &self.inputs.anchor_hash)
            .field("num_blocks", &self.inputs.blocks.len())
-            .field("cached_anchors", &self.inner.len())
+            .field("computed", &self.inner.get().is_some())
            .finish()
    }
 }

-impl<N: NodePrimitives> LazyOverlay<N> {
-    /// Create a new lazy overlay from in-memory blocks.
+impl LazyOverlay {
+    /// Create a new lazy overlay with the given anchor hash and block handles.
    ///
    /// # Arguments
    ///
-    /// * `blocks` - Executed blocks in reverse chain order (newest to oldest)
-    pub fn new(blocks: Vec<ExecutedBlock<N>>) -> Self {
-        debug_assert!(
-            blocks.windows(2).all(|window| {
-                window[0].recovered_block().parent_hash() == window[1].recovered_block().hash()
-            }),
-            "LazyOverlay blocks must be ordered newest to oldest along a single chain"
-        );
+    /// * `anchor_hash` - The persisted ancestor hash this overlay is built on top of
+    /// * `blocks` - Deferred trie data handles for in-memory blocks (newest to oldest)
+    pub fn new(anchor_hash: B256, blocks: Vec<DeferredTrieData>) -> Self {
+        Self { inner: Arc::new(OnceLock::new()), inputs: LazyOverlayInputs { anchor_hash, blocks } }
+    }

-        Self { inner: Default::default(), inputs: LazyOverlayInputs { blocks } }
+    /// Returns the anchor hash this overlay is built on.
+    pub const fn anchor_hash(&self) -> B256 {
+        self.inputs.anchor_hash
    }

    /// Returns the number of in-memory blocks this overlay covers.
@@ -79,75 +69,43 @@ impl<N: NodePrimitives> LazyOverlay<N> {
        self.inputs.blocks.len()
    }

-    /// Returns the oldest anchor hash this overlay can serve.
-    ///
-    /// This is the parent hash of the oldest block in the stored newest-to-oldest chain segment.
-    pub fn anchor_hash(&self) -> Option<B256> {
-        self.inputs.blocks.last().map(|block| block.recovered_block().parent_hash())
+    /// Returns true if the overlay has already been computed.
+    pub fn is_computed(&self) -> bool {
+        self.inner.get().is_some()
    }

-    /// Returns true if there are no blocks in the overlay, or if one of the blocks has the given
-    /// hash as a parent hash.
-    pub fn has_anchor_hash(&self, hash: B256) -> bool {
-        self.inputs.blocks.is_empty() ||
-            self.inputs.blocks.iter().any(|b| b.recovered_block().parent_hash() == hash)
-    }
-
-    #[cfg(test)]
-    /// Returns true if the overlay has already been computed for the requested anchor.
-    pub fn is_computed(&self, anchor_hash: B256) -> bool {
-        self.inner.contains_key(&anchor_hash)
-    }
-
-    /// Returns the computed trie input for the requested anchor, computing it if necessary.
+    /// Returns the computed trie input, computing it if necessary.
    ///
    /// The first call triggers computation (which may block waiting for deferred data).
-    /// Subsequent calls for the same anchor return the cached result immediately.
-    pub fn get(&self, anchor_hash: B256) -> Arc<TrieInputSorted> {
-        match self.inner.entry(anchor_hash) {
-            dashmap::Entry::Occupied(entry) => Arc::clone(entry.get()),
-            dashmap::Entry::Vacant(entry) => {
-                let input = self.compute(anchor_hash);
-                entry.insert(Arc::clone(&input));
-                input
-            }
-        }
+    /// Subsequent calls return the cached result immediately.
+    pub fn get(&self) -> &TrieInputSorted {
+        self.inner.get_or_init(|| self.compute())
    }

    /// Returns the overlay as (nodes, state) tuple for use with `OverlayStateProviderFactory`.
-    pub fn as_overlay(
-        &self,
-        anchor_hash: B256,
-    ) -> (Arc<TrieUpdatesSorted>, Arc<HashedPostStateSorted>) {
-        let input = self.get(anchor_hash);
+    pub fn as_overlay(&self) -> (Arc<TrieUpdatesSorted>, Arc<HashedPostStateSorted>) {
+        let input = self.get();
        (Arc::clone(&input.nodes), Arc::clone(&input.state))
    }

    /// Compute the trie input overlay.
-    fn compute(&self, anchor_hash: B256) -> Arc<TrieInputSorted> {
+    fn compute(&self) -> TrieInputSorted {
+        let anchor_hash = self.inputs.anchor_hash;
        let blocks = &self.inputs.blocks;
+
        if blocks.is_empty() {
-            return Default::default()
+            debug!(target: "chain_state::lazy_overlay", "No in-memory blocks, returning empty overlay");
+            return TrieInputSorted::default();
        }

-        let Some(last_index) =
-            blocks.iter().position(|block| block.recovered_block().parent_hash() == anchor_hash)
-        else {
-            panic!(
-                "LazyOverlay does not contain a block whose parent hash matches requested anchor {anchor_hash}"
-            );
-        };
-        let blocks = &blocks[..=last_index];
-
        // Fast path: Check if tip block's overlay is ready and anchor matches.
-        // The tip block (first in list) has the cumulative overlay from all ancestors up to the
-        // requested anchor.
+        // The tip block (first in list) has the cumulative overlay from all ancestors.
        if let Some(tip) = blocks.first() {
-            let data = tip.trie_data();
+            let data = tip.wait_cloned();
            if let Some(anchored) = &data.anchored_trie_input {
                if anchored.anchor_hash == anchor_hash {
                    trace!(target: "chain_state::lazy_overlay", %anchor_hash, "Reusing tip block's cached overlay (fast path)");
-                    return Arc::clone(&anchored.trie_input);
+                    return (*anchored.trie_input).clone();
                }
                debug!(
                    target: "chain_state::lazy_overlay",
@@ -158,30 +116,23 @@ impl<N: NodePrimitives> LazyOverlay<N> {
            }
        }

-        // Slow path: Merge the prefix of blocks from the tip back to the requested anchor.
-        debug!(
-            target: "chain_state::lazy_overlay",
-            %anchor_hash,
-            num_blocks = blocks.len(),
-            "Merging blocks (slow path)"
-        );
-        Arc::new(Self::merge_blocks(blocks))
+        // Slow path: Merge all blocks' trie data into a new overlay.
+        debug!(target: "chain_state::lazy_overlay", num_blocks = blocks.len(), "Merging blocks (slow path)");
+        Self::merge_blocks(blocks)
    }

    /// Merge all blocks' trie data into a single [`TrieInputSorted`].
    ///
    /// Blocks are ordered newest to oldest.
-    fn merge_blocks(blocks: &[ExecutedBlock<N>]) -> TrieInputSorted {
+    fn merge_blocks(blocks: &[DeferredTrieData]) -> TrieInputSorted {
        if blocks.is_empty() {
            return TrieInputSorted::default();
        }

-        let state = HashedPostStateSorted::merge_batch(
-            blocks.iter().map(|block| block.trie_data().hashed_state),
-        );
-        let nodes = TrieUpdatesSorted::merge_batch(
-            blocks.iter().map(|block| block.trie_data().trie_updates),
-        );
+        let state =
+            HashedPostStateSorted::merge_batch(blocks.iter().map(|b| b.wait_cloned().hashed_state));
+        let nodes =
+            TrieUpdatesSorted::merge_batch(blocks.iter().map(|b| b.wait_cloned().trie_updates));

        TrieInputSorted { state, nodes, prefix_sets: Default::default() }
    }
@@ -190,138 +141,46 @@ impl<N: NodePrimitives> LazyOverlay<N> {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::{test_utils::TestBlockBuilder, ComputedTrieData, EthPrimitives, ExecutedBlock};
-    use alloy_primitives::U256;
-    use reth_primitives_traits::Account;
-    use reth_trie::{updates::TrieUpdatesSorted, HashedPostState, HashedStorage};
-    use std::sync::Arc;
+    use reth_trie::{updates::TrieUpdates, HashedPostState};

-    fn with_unique_state(
-        block: &ExecutedBlock<EthPrimitives>,
-        id: u8,
-    ) -> ExecutedBlock<EthPrimitives> {
-        let hashed_address = B256::with_last_byte(id);
-        let hashed_slot = B256::with_last_byte(id.saturating_add(32));
-        let hashed_state = HashedPostState::default()
-            .with_accounts([(hashed_address, Some(Account::default()))])
-            .with_storages([(
-                hashed_address,
-                HashedStorage::from_iter(false, [(hashed_slot, U256::from(id))]),
-            )])
-            .into_sorted();
-
-        ExecutedBlock::new(
-            Arc::clone(&block.recovered_block),
-            Arc::clone(&block.execution_output),
-            ComputedTrieData::without_trie_input(
-                Arc::new(hashed_state),
-                Arc::new(TrieUpdatesSorted::default()),
-            ),
+    fn empty_deferred(anchor: B256) -> DeferredTrieData {
+        DeferredTrieData::pending(
+            Arc::new(HashedPostState::default()),
+            Arc::new(TrieUpdates::default()),
+            anchor,
+            Vec::new(),
        )
    }

-    fn test_blocks() -> Vec<ExecutedBlock<EthPrimitives>> {
-        TestBlockBuilder::eth()
-            .get_executed_blocks(1..4)
-            .collect::<Vec<_>>()
-            .into_iter()
-            .rev()
-            .enumerate()
-            .map(|(index, block)| with_unique_state(&block, index as u8 + 1))
-            .collect()
+    #[test]
+    fn empty_blocks_returns_default() {
+        let overlay = LazyOverlay::new(B256::ZERO, vec![]);
+        let result = overlay.get();
+        assert!(result.state.is_empty());
+        assert!(result.nodes.is_empty());
    }

    #[test]
    fn single_block_uses_data_directly() {
-        let block = TestBlockBuilder::eth().get_executed_block_with_number(1, B256::random());
-        let anchor_hash = block.recovered_block().parent_hash();
-        let overlay = LazyOverlay::new(vec![block]);
+        let anchor = B256::random();
+        let deferred = empty_deferred(anchor);
+        let overlay = LazyOverlay::new(anchor, vec![deferred]);

-        assert!(!overlay.is_computed(anchor_hash));
-        let _ = overlay.get(anchor_hash);
-        assert!(overlay.is_computed(anchor_hash));
+        assert!(!overlay.is_computed());
+        let _ = overlay.get();
+        assert!(overlay.is_computed());
    }

    #[test]
-    fn caches_results_per_anchor() {
-        let blocks = test_blocks();
-        let prefix_anchor = blocks[2].recovered_block().hash();
-        let full_anchor = blocks[2].recovered_block().parent_hash();
-        let overlay = LazyOverlay::new(blocks);
+    fn cached_after_first_access() {
+        let overlay = LazyOverlay::new(B256::ZERO, vec![]);

-        let prefix = overlay.get(prefix_anchor);
-        let full = overlay.get(full_anchor);
+        // First access computes
+        let _ = overlay.get();
+        assert!(overlay.is_computed());

-        assert!(overlay.is_computed(prefix_anchor));
-        assert!(overlay.is_computed(full_anchor));
-        assert!(!Arc::ptr_eq(&prefix, &full));
-        assert!(Arc::ptr_eq(&prefix, &overlay.get(prefix_anchor)));
-        assert!(Arc::ptr_eq(&full, &overlay.get(full_anchor)));
-    }
-
-    #[test]
-    fn requested_anchor_limits_the_merged_prefix() {
-        let blocks = test_blocks();
-        let prefix_anchor = blocks[2].recovered_block().hash();
-        let expected = LazyOverlay::merge_blocks(&blocks[..2]);
-        let overlay = LazyOverlay::new(blocks);
-        let actual = overlay.get(prefix_anchor);
-
-        assert_eq!(actual.nodes.as_ref(), expected.nodes.as_ref());
-        assert_eq!(actual.state.as_ref(), expected.state.as_ref());
-    }
-
-    #[test]
-    fn anchor_hash_returns_oldest_served_anchor() {
-        let blocks = test_blocks();
-        let expected_anchor = blocks.last().unwrap().recovered_block().parent_hash();
-        let overlay = LazyOverlay::new(blocks);
-
-        assert_eq!(overlay.anchor_hash(), Some(expected_anchor));
-    }
-
-    #[test]
-    fn reuses_tip_overlay_when_anchor_matches() {
-        let mut blocks = test_blocks();
-        let prefix_anchor = blocks[2].recovered_block().hash();
-        let tip_overlay = Arc::new(LazyOverlay::merge_blocks(&blocks[..2]));
-        let tip_data = blocks[0].trie_data();
-
-        blocks[0] = ExecutedBlock::new(
-            Arc::clone(&blocks[0].recovered_block),
-            Arc::clone(&blocks[0].execution_output),
-            ComputedTrieData::with_trie_input(
-                tip_data.hashed_state,
-                tip_data.trie_updates,
-                prefix_anchor,
-                Arc::clone(&tip_overlay),
-            ),
-        );
-
-        let overlay = LazyOverlay::new(blocks);
-        let actual = overlay.get(prefix_anchor);
-
-        assert!(Arc::ptr_eq(&actual, &tip_overlay));
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "LazyOverlay does not contain a block whose parent hash matches requested anchor"
-    )]
-    fn missing_anchor_panics() {
-        let blocks = test_blocks();
-        let missing_anchor = blocks[0].recovered_block().hash();
-        let overlay = LazyOverlay::new(blocks);
-
-        let _ = overlay.get(missing_anchor);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "LazyOverlay blocks must be ordered newest to oldest along a single chain"
-    )]
-    fn misordered_blocks_panic() {
-        let blocks: Vec<_> = TestBlockBuilder::eth().get_executed_blocks(1..3).collect();
-        let _ = LazyOverlay::new(blocks);
+        // Second access uses cache
+        let _ = overlay.get();
+        assert!(overlay.is_computed());
    }
 }
--- a/crates/cli/commands/src/common.rs
+++ b/crates/cli/commands/src/common.rs
@@ -150,22 +150,16 @@ impl<C: ChainSpecParser> EnvironmentArgs<C> {
            // commands can proceed.
            debug!(target: "reth::cli", ?rocksdb_path, "RocksDB not found, initializing empty database");
            reth_fs_util::create_dir_all(&rocksdb_path)?;
-            let mut builder = RocksDBProvider::builder(data_dir.rocksdb())
-                .with_default_tables()
-                .with_database_log_level(self.db.log_level);
-            if let Some(cache_size) = self.db.rocksdb_block_cache_size {
-                builder = builder.with_block_cache_size(cache_size);
-            }
-            builder.build()?
-        } else {
-            let mut builder = RocksDBProvider::builder(data_dir.rocksdb())
+            RocksDBProvider::builder(data_dir.rocksdb())
                .with_default_tables()
                .with_database_log_level(self.db.log_level)
-                .with_read_only(!access.is_read_write());
-            if let Some(cache_size) = self.db.rocksdb_block_cache_size {
-                builder = builder.with_block_cache_size(cache_size);
-            }
-            builder.build()?
+                .build()?
+        } else {
+            RocksDBProvider::builder(data_dir.rocksdb())
+                .with_default_tables()
+                .with_database_log_level(self.db.log_level)
+                .with_read_only(!access.is_read_write())
+                .build()?
        };

        let provider_factory =
--- a/crates/cli/commands/src/db/get.rs
+++ b/crates/cli/commands/src/db/get.rs
@@ -14,7 +14,7 @@ use reth_db_api::{
    table::{Compress, Decompress, DupSort, Table},
    tables,
    transaction::DbTx,
-    RawKey, RawTable, TableViewer,
+    RawKey, RawTable, Receipts, TableViewer, Transactions,
 };
 use reth_db_common::DbTool;
 use reth_node_api::{HeaderTy, ReceiptTy, TxTy};
@@ -264,12 +264,15 @@ impl Command {
                                    );
                                }
                                StaticFileSegment::Transactions => {
-                                    let transaction = TxTy::<N>::decompress(content[0].as_slice())?;
+                                    let transaction = <<Transactions as Table>::Value>::decompress(
+                                        content[0].as_slice(),
+                                    )?;
                                    println!("{}", serde_json::to_string_pretty(&transaction)?);
                                }
                                StaticFileSegment::Receipts => {
-                                    let receipt =
-                                        ReceiptTy::<N>::decompress(content[0].as_slice())?;
+                                    let receipt = <<Receipts as Table>::Value>::decompress(
+                                        content[0].as_slice(),
+                                    )?;
                                    println!("{}", serde_json::to_string_pretty(&receipt)?);
                                }
                                StaticFileSegment::TransactionSenders => {
--- a/crates/cli/commands/src/db/migrate_v2.rs
+++ b/crates/cli/commands/src/db/migrate_v2.rs
@@ -5,7 +5,6 @@
 //! state), compacts MDBX, then runs the pipeline to rebuild them.

 use crate::common::CliNodeTypes;
-use alloy_primitives::Address;
 use clap::Parser;
 use reth_db::{
    mdbx::{self, ffi},
@@ -133,12 +132,8 @@ impl Command {
            .and_then(|cp| cp.block_number)
            .map_or(0, |b| b + 1);

-        // The writer always starts at the fixed range boundary (e.g. 2500000) which may be
-        // earlier than first_block (e.g. 2603897 from prune checkpoint).
-        let mut writer = sf_provider.latest_writer(StaticFileSegment::AccountChangeSets)?;
-        if first_block > 0 {
-            writer.ensure_at_block(first_block - 1)?;
-        }
+        let mut writer =
+            sf_provider.get_writer(first_block, StaticFileSegment::AccountChangeSets)?;

        let mut count = 0u64;
        let mut walker = cursor.walk(Some(first_block))?.peekable();
@@ -179,15 +174,11 @@ impl Command {
            .and_then(|cp| cp.block_number)
            .map_or(0, |b| b + 1);

-        // The writer always starts at the fixed range boundary (e.g. 2500000) which may be
-        // earlier than first_block (e.g. 2603897 from prune checkpoint).
-        let mut writer = sf_provider.latest_writer(StaticFileSegment::StorageChangeSets)?;
-        if first_block > 0 {
-            writer.ensure_at_block(first_block - 1)?;
-        }
+        let mut writer =
+            sf_provider.get_writer(first_block, StaticFileSegment::StorageChangeSets)?;

        let mut count = 0u64;
-        let mut walker = cursor.walk(Some((first_block, Address::ZERO).into()))?.peekable();
+        let mut walker = cursor.walk(Some(Default::default()))?.peekable();

        for block in first_block..=tip {
            let mut entries = Vec::new();
@@ -247,18 +238,6 @@ impl Command {
            .map_or(0, |b| b + 1);
        let first_block = prune_start.max(existing.map_or(0, |b| b + 1));

-        // The writer always starts at the fixed range boundary (e.g. 2500000) which may be
-        // earlier than first_block (e.g. 2603897 from prune checkpoint).
-        if first_block > 0 {
-            let mut writer = sf_provider.latest_writer(StaticFileSegment::Receipts)?;
-            writer.ensure_at_block(first_block - 1)?;
-            writer.commit()?;
-        }
-
-        let before = sf_provider
-            .get_highest_static_file_tx(StaticFileSegment::Receipts)
-            .map_or(0, |tx| tx + 1);
-
        let block_range = first_block..=tip;

        let segment = reth_static_file::segments::Receipts;
@@ -266,11 +245,7 @@ impl Command {

        sf_provider.commit()?;

-        let after = sf_provider
-            .get_highest_static_file_tx(StaticFileSegment::Receipts)
-            .map_or(0, |tx| tx + 1);
-        let count = after - before;
-        info!(target: "reth::cli", count, "Receipts migrated");
+        info!(target: "reth::cli", "Receipts migrated");
        Ok(())
    }

--- a/crates/cli/commands/src/init_state/without_evm.rs
+++ b/crates/cli/commands/src/init_state/without_evm.rs
@@ -50,13 +50,8 @@ where
    info!(target: "reth::cli", new_tip = ?header.num_hash(), "Setting up dummy EVM chain before importing state.");

    let static_file_provider = provider_rw.static_file_provider();
-    // Write EVM dummy data up to `header - 1` block. Skip when the supplied
-    // header is at block 0: `header.number() - 1` would underflow in u64 to
-    // `u64::MAX`, sending `append_dummy_chain` into a 1..=u64::MAX loop that
-    // exhausts memory before failing.
-    if header.number() > 0 {
-        append_dummy_chain(&static_file_provider, header.number() - 1, header_factory)?;
-    }
+    // Write EVM dummy data up to `header - 1` block
+    append_dummy_chain(&static_file_provider, header.number() - 1, header_factory)?;

    info!(target: "reth::cli", "Appending first valid block.");

@@ -196,13 +191,7 @@ mod tests {
    use alloy_primitives::{address, b256};
    use reth_db_common::init::init_genesis;
    use reth_provider::{test_utils::create_test_provider_factory, DatabaseProviderFactory};
-    use std::{
-        io::Write,
-        sync::{
-            atomic::{AtomicU64, Ordering},
-            Arc,
-        },
-    };
+    use std::io::Write;
    use tempfile::NamedTempFile;

    #[test]
@@ -275,45 +264,4 @@ mod tests {

        assert_eq!(actual_next_height, expected_next_height);
    }
-
-    /// Regression: a header at block 0 used to send `append_dummy_chain` into
-    /// a `1..=u64::MAX` loop because `header.number() - 1` underflowed in
-    /// u64. The guard `if header.number() > 0` skips the dummy-chain step
-    /// when there is no pre-genesis range to backfill, so `header_factory`
-    /// is never invoked.
-    #[test]
-    fn test_setup_without_evm_skips_dummy_chain_for_genesis_header() {
-        let header = Header { number: 0, ..Default::default() };
-        let header_hash = header.hash_slow();
-
-        let provider_factory = create_test_provider_factory();
-        init_genesis(&provider_factory).unwrap();
-        let provider_rw = provider_factory.database_provider_rw().unwrap();
-
-        let factory_calls = Arc::new(AtomicU64::new(0));
-        let factory_calls_inner = Arc::clone(&factory_calls);
-
-        // The Result of `setup_without_evm` itself is not asserted: with
-        // `number == 0` plus a genesis already written by `init_genesis`,
-        // the subsequent `append_first_block` may legitimately fail. The
-        // bug under test is the OOM in the dummy-chain loop, observable
-        // through the factory-call counter below.
-        let _ = setup_without_evm(
-            &provider_rw,
-            SealedHeader::new(header, header_hash),
-            move |number| {
-                // Bound calls so a regression cannot exhaust the test
-                // runner's memory; the only correct value here is 0.
-                let n = factory_calls_inner.fetch_add(1, Ordering::Relaxed);
-                assert!(n < 8, "header_factory must not be invoked for a genesis-block header");
-                Header { number, ..Default::default() }
-            },
-        );
-
-        assert_eq!(
-            factory_calls.load(Ordering::Relaxed),
-            0,
-            "append_dummy_chain must be skipped when header.number() == 0"
-        );
-    }
 }
--- a/crates/cli/commands/src/p2p/mod.rs
+++ b/crates/cli/commands/src/p2p/mod.rs
@@ -188,7 +188,7 @@ impl<C: ChainSpecParser> DownloadArgs<C> {
            )
        }

-        config.peers.trusted_nodes_only |= self.network.trusted_only;
+        config.peers.trusted_nodes_only = self.network.trusted_only;

        let default_secret_key_path = data_dir.p2p_secret();
        let p2p_secret_key = self.network.secret_key(default_secret_key_path)?;
--- a/crates/cli/commands/src/re_execute.rs
+++ b/crates/cli/commands/src/re_execute.rs
@@ -5,7 +5,6 @@ use crate::common::{
    EnvironmentArgs,
 };
 use alloy_consensus::{transaction::TxHashRef, BlockHeader, TxReceipt};
-use alloy_primitives::{Address, B256, U256};
 use clap::Parser;
 use eyre::WrapErr;
 use reth_chainspec::{EthChainSpec, EthereumHardforks, Hardforks};
@@ -13,22 +12,15 @@ use reth_cli::chainspec::ChainSpecParser;
 use reth_cli_util::cancellation::CancellationToken;
 use reth_consensus::FullConsensus;
 use reth_evm::{execute::Executor, ConfigureEvm};
-use reth_primitives_traits::{format_gas_throughput, Account, BlockBody, GotExpected};
+use reth_primitives_traits::{format_gas_throughput, BlockBody, GotExpected};
 use reth_provider::{
    BlockNumReader, BlockReader, ChainSpecProvider, DatabaseProviderFactory, ReceiptProvider,
    StaticFileProviderFactory, TransactionVariant,
 };
-use reth_revm::{
-    database::StateProviderDatabase,
-    db::{
-        states::reverts::{AccountInfoRevert, RevertToSlot},
-        BundleState,
-    },
-};
+use reth_revm::database::StateProviderDatabase;
 use reth_stages::stages::calculate_gas_used_from_headers;
-use reth_storage_api::{ChangeSetReader, DBProvider, StorageChangeSetReader};
+use reth_storage_api::{DBProvider, TryIntoHistoricalStateProvider};
 use std::{
-    collections::HashMap,
    sync::{
        atomic::{AtomicU64, Ordering},
        Arc,
@@ -77,18 +69,13 @@ impl<C: ChainSpecParser> Command<C> {
 impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>> Command<C> {
    /// Execute `re-execute` command
    pub async fn execute<N>(
-        mut self,
+        self,
        components: impl CliComponentsBuilder<N>,
        runtime: reth_tasks::Runtime,
    ) -> eyre::Result<()>
    where
        N: CliNodeTypes<ChainSpec = C::ChainSpec>,
    {
-        // Default to 4GB RocksDB block cache for re-execute unless explicitly set.
-        if self.env.db.rocksdb_block_cache_size.is_none() {
-            self.env.db.rocksdb_block_cache_size = Some(4 << 30);
-        }
-
        let Environment { provider_factory, .. } = self.env.init::<N>(AccessRights::RO, runtime)?;

        let components = components(provider_factory.chain_spec());
@@ -122,6 +109,20 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
            min_block..=max_block,
        )?;

+        let db_at = {
+            let provider_factory = provider_factory.clone();
+            move |block_number: u64| {
+                StateProviderDatabase(
+                    provider_factory
+                        .provider()
+                        .unwrap()
+                        .disable_long_read_transaction_safety()
+                        .try_into_history_at_block(block_number)
+                        .unwrap(),
+                )
+            }
+        };
+
        let skip_invalid_blocks = self.skip_invalid_blocks;
        let blocks_per_chunk = self.blocks_per_chunk;
        let (stats_tx, mut stats_rx) = mpsc::unbounded_channel();
@@ -137,23 +138,13 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
            let provider_factory = provider_factory.clone();
            let evm_config = components.evm_config().clone();
            let consensus = components.consensus().clone();
+            let db_at = db_at.clone();
            let stats_tx = stats_tx.clone();
            let info_tx = info_tx.clone();
            let cancellation = cancellation.clone();
            let next_block = Arc::clone(&next_block);
            tasks.spawn_blocking(move || {
                let executor_lifetime = Duration::from_secs(600);
-                let provider = provider_factory.database_provider_ro()?.disable_long_read_transaction_safety();
-
-                let db_at = {
-                    |block_number: u64| {
-                        StateProviderDatabase(
-                            provider
-                                .history_by_block_number(block_number)
-                                .unwrap(),
-                        )
-                    }
-                };

                loop {
                    if cancellation.is_cancelled() {
@@ -263,28 +254,11 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
                        if executor.size_hint() > 5_000_000 ||
                            executor_created.elapsed() > executor_lifetime
                        {
-                            let last_block = block.number();
-                            let old_executor = std::mem::replace(
-                                &mut executor,
-                                evm_config.batch_executor(db_at(last_block)),
-                            );
-                            let bundle = old_executor.into_state().take_bundle();
-                            verify_bundle_against_changesets(
-                                &provider,
-                                &bundle,
-                                last_block,
-                            )?;
+                            executor =
+                                evm_config.batch_executor(db_at(block.number()));
                            executor_created = Instant::now();
                        }
                    }
-
-                    // Full verification at chunk end for remaining unverified blocks
-                    let bundle = executor.into_state().take_bundle();
-                    verify_bundle_against_changesets(
-                        &provider,
-                        &bundle,
-                        chunk_end - 1,
-                    )?;
                }

                eyre::Ok(())
@@ -365,103 +339,3 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
        Ok(())
    }
 }
-
-/// Verifies reverts against database changesets.
-///
-/// For each block, reverts must match changeset entries exactly. No extra slots/accounts
-/// in reverts for non-destroyed accounts. Destroyed accounts may have extra changeset slots
-/// (from DB storage wipe) absent from reverts.
-fn verify_bundle_against_changesets<P>(
-    provider: &P,
-    bundle: &BundleState,
-    last_block: u64,
-) -> eyre::Result<()>
-where
-    P: ChangeSetReader + StorageChangeSetReader,
-{
-    // Verify reverts against changesets per block
-    for (i, block_reverts) in bundle.reverts.iter().rev().enumerate() {
-        let block_number = last_block - i as u64;
-
-        let mut cs_accounts: HashMap<Address, Option<Account>> = provider
-            .account_block_changeset(block_number)?
-            .into_iter()
-            .map(|cs| (cs.address, cs.info))
-            .collect();
-
-        let mut cs_storage: HashMap<Address, HashMap<B256, U256>> = HashMap::new();
-        for (bna, entry) in provider.storage_changeset(block_number)? {
-            cs_storage.entry(bna.address()).or_default().insert(entry.key, entry.value);
-        }
-
-        for (addr, revert) in block_reverts {
-            // Verify account info
-            match &revert.account {
-                AccountInfoRevert::DoNothing => {
-                    eyre::ensure!(
-                        !cs_accounts.contains_key(addr),
-                        "Block {block_number}: account {addr} in changeset but revert is DoNothing",
-                    );
-                }
-                AccountInfoRevert::DeleteIt => {
-                    let cs_info = cs_accounts.remove(addr).ok_or_else(|| {
-                        eyre::eyre!("Block {block_number}: account {addr} revert is DeleteIt but not in changeset")
-                    })?;
-                    eyre::ensure!(
-                        cs_info.is_none(),
-                        "Block {block_number}: account {addr} revert is DeleteIt but changeset has {cs_info:?}",
-                    );
-                }
-                AccountInfoRevert::RevertTo(info) => {
-                    let cs_info = cs_accounts.remove(addr).ok_or_else(|| {
-                        eyre::eyre!("Block {block_number}: account {addr} revert is RevertTo but not in changeset")
-                    })?;
-                    let revert_acct = Some(Account::from(info));
-                    eyre::ensure!(
-                        revert_acct == cs_info,
-                        "Block {block_number}: account {addr} info mismatch: revert={revert_acct:?} cs={cs_info:?}",
-                    );
-                }
-            }
-
-            // Verify storage slots — remove matched changeset entries as we go
-            let mut cs_slots = cs_storage.get_mut(addr);
-            for (slot_key, revert_slot) in &revert.storage {
-                let b256_key = B256::from(*slot_key);
-                let cs_value = cs_slots.as_mut().and_then(|s| s.remove(&b256_key));
-                match (revert_slot, cs_value) {
-                    // When a contract is selfdestructed and re-created at the same address
-                    // within the same block, revm marks slots touched by the new contract
-                    // as `Destroyed` and never reads the original DB value, so
-                    // `to_previous_value()` would resolve to zero, which might be wrong.
-                    (RevertToSlot::Destroyed, _) => {}
-                    (RevertToSlot::Some(prev), Some(cs_value)) => eyre::ensure!(
-                        *prev == cs_value,
-                        "Block {block_number}: {addr} slot {b256_key} mismatch: \
-                         revert={prev} cs={cs_value}",
-                    ),
-                    (RevertToSlot::Some(_), None) => eyre::ensure!(
-                        revert.wipe_storage,
-                        "Block {block_number}: {addr} slot {b256_key} in reverts but not in changeset",
-                    ),
-                }
-            }
-
-            // Any remaining cs_storage slots for this address must be from a destroyed account
-            if let Some(remaining) = cs_slots.filter(|s| !s.is_empty()) {
-                eyre::ensure!(
-                    revert.wipe_storage,
-                    "Block {block_number}: {addr} has {} unmatched storage slots in changeset",
-                    remaining.len(),
-                );
-            }
-        }
-
-        // Any remaining cs_accounts entries had no corresponding revert
-        if let Some(addr) = cs_accounts.keys().next() {
-            eyre::bail!("Block {block_number}: account {addr} in changeset but not in reverts");
-        }
-    }
-
-    Ok(())
-}
--- a/crates/cli/commands/src/stage/dump/execution.rs
+++ b/crates/cli/commands/src/stage/dump/execution.rs
@@ -6,7 +6,7 @@ use reth_db_api::{
 };
 use reth_db_common::DbTool;
 use reth_evm::ConfigureEvm;
-use reth_node_api::{HeaderTy, TxTy};
+use reth_node_api::HeaderTy;
 use reth_node_core::dirs::{ChainPath, DataDirPath};
 use reth_provider::{
    providers::{ProviderNodeTypes, RocksDBProvider, StaticFileProvider},
@@ -88,7 +88,7 @@ fn import_tables_with_range<N: ProviderNodeTypes>(
        )
    })??;
    output_db.update(|tx| {
-        tx.import_table_with_range::<tables::BlockOmmers<HeaderTy<N>>, _>(
+        tx.import_table_with_range::<tables::BlockOmmers, _>(
            &db_tool.provider_factory.db_ref().tx()?,
            Some(from),
            to,
@@ -110,7 +110,7 @@ fn import_tables_with_range<N: ProviderNodeTypes>(
    })??;

    output_db.update(|tx| {
-        tx.import_table_with_range::<tables::Transactions<TxTy<N>>, _>(
+        tx.import_table_with_range::<tables::Transactions, _>(
            &db_tool.provider_factory.db_ref().tx()?,
            Some(from_tx),
            to_tx,
--- a/crates/cli/commands/src/stage/run.rs
+++ b/crates/cli/commands/src/stage/run.rs
@@ -210,7 +210,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
                    let consensus = Arc::new(components.consensus().clone());

                    let mut config = config;
-                    config.peers.trusted_nodes_only |= self.network.trusted_only;
+                    config.peers.trusted_nodes_only = self.network.trusted_only;
                    config.peers.trusted_nodes.extend(self.network.trusted_peers.clone());

                    let network_secret_path = self
--- a/crates/e2e-test-utils/src/payload.rs
+++ b/crates/e2e-test-utils/src/payload.rs
@@ -1,8 +1,8 @@
 use futures_util::StreamExt;
-use reth_node_api::{PayloadAttributes, PayloadKind};
+use reth_node_api::{BlockBody, PayloadAttributes, PayloadKind};
 use reth_payload_builder::{PayloadBuilderHandle, PayloadId};
 use reth_payload_builder_primitives::Events;
-use reth_payload_primitives::PayloadTypes;
+use reth_payload_primitives::{BuiltPayload, PayloadTypes};
 use tokio_stream::wrappers::BroadcastStream;

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

    /// Expects the next event to be a built payload event or panics
--- a/crates/engine/primitives/src/config.rs
+++ b/crates/engine/primitives/src/config.rs
@@ -15,9 +15,6 @@ pub const DEFAULT_MEMORY_BLOCK_BUFFER_TARGET: u64 = 0;
 /// The size of proof targets chunk to spawn in one multiproof calculation.
 pub const DEFAULT_MULTIPROOF_TASK_CHUNK_SIZE: usize = 5;

-/// Default number of cache hits before an invalid header entry is evicted and reprocessed.
-pub const DEFAULT_INVALID_HEADER_HIT_EVICTION_THRESHOLD: u8 = 128;
-
 /// Gas threshold below which the small block chunk size is used.
 pub const SMALL_BLOCK_GAS_THRESHOLD: u64 = 20_000_000;

@@ -105,11 +102,6 @@ pub struct TreeConfig {
    block_buffer_limit: u32,
    /// Number of invalid headers to keep in cache.
    max_invalid_header_cache_length: u32,
-    /// Number of cache hits before an invalid header entry is evicted and reprocessed.
-    ///
-    /// Setting this to `0` effectively disables the cache because entries are evicted on the
-    /// first lookup.
-    invalid_header_hit_eviction_threshold: u8,
    /// Maximum number of blocks to execute sequentially in a batch.
    ///
    /// This is used as a cutoff to prevent long-running sequential block execution when we receive
@@ -191,9 +183,9 @@ pub struct TreeConfig {
    /// When disabled, the BAL hashed post state is not sent to the multiproof task for
    /// early parallel state root computation.
    disable_bal_parallel_state_root: bool,
-    /// Whether to disable BAL (Block Access List) storage prefetch IO during prewarming.
-    /// When set, BAL storage slots are not read into the execution cache. BAL hashed-state
-    /// streaming for parallel state-root computation is controlled separately.
+    /// Whether to disable BAL (Block Access List) batched IO during prewarming.
+    /// When disabled, falls back to individual per-slot storage reads instead of
+    /// batched cursor reads via `storage_range`.
    disable_bal_batch_io: bool,
    /// Maximum random jitter applied before each proof computation (trie-debug only).
    /// When set, each proof worker sleeps for a random duration up to this value
@@ -214,7 +206,6 @@ impl Default for TreeConfig {
            persistence_backpressure_threshold: DEFAULT_PERSISTENCE_BACKPRESSURE_THRESHOLD,
            block_buffer_limit: DEFAULT_BLOCK_BUFFER_LIMIT,
            max_invalid_header_cache_length: DEFAULT_MAX_INVALID_HEADER_CACHE_LENGTH,
-            invalid_header_hit_eviction_threshold: DEFAULT_INVALID_HEADER_HIT_EVICTION_THRESHOLD,
            max_execute_block_batch_size: DEFAULT_MAX_EXECUTE_BLOCK_BATCH_SIZE,
            legacy_state_root: false,
            always_compare_trie_updates: false,
@@ -239,7 +230,7 @@ impl Default for TreeConfig {
            share_execution_cache_with_payload_builder: false,
            share_sparse_trie_with_payload_builder: false,
            suppress_persistence_during_build: false,
-            disable_bal_parallel_execution: true,
+            disable_bal_parallel_execution: false,
            disable_bal_parallel_state_root: false,
            disable_bal_batch_io: false,
            #[cfg(feature = "trie-debug")]
@@ -257,7 +248,6 @@ impl TreeConfig {
        persistence_backpressure_threshold: u64,
        block_buffer_limit: u32,
        max_invalid_header_cache_length: u32,
-        invalid_header_hit_eviction_threshold: u8,
        max_execute_block_batch_size: usize,
        legacy_state_root: bool,
        always_compare_trie_updates: bool,
@@ -291,7 +281,6 @@ impl TreeConfig {
            persistence_backpressure_threshold,
            block_buffer_limit,
            max_invalid_header_cache_length,
-            invalid_header_hit_eviction_threshold,
            max_execute_block_batch_size,
            legacy_state_root,
            always_compare_trie_updates,
@@ -316,7 +305,7 @@ impl TreeConfig {
            share_execution_cache_with_payload_builder,
            share_sparse_trie_with_payload_builder,
            suppress_persistence_during_build: false,
-            disable_bal_parallel_execution: true,
+            disable_bal_parallel_execution: false,
            disable_bal_parallel_state_root: false,
            disable_bal_batch_io: false,
            #[cfg(feature = "trie-debug")]
@@ -349,14 +338,6 @@ impl TreeConfig {
        self.max_invalid_header_cache_length
    }

-    /// Return the invalid header cache hit eviction threshold.
-    ///
-    /// Setting this to `0` effectively disables the cache because entries are evicted on the
-    /// first lookup.
-    pub const fn invalid_header_hit_eviction_threshold(&self) -> u8 {
-        self.invalid_header_hit_eviction_threshold
-    }
-
    /// Return the maximum execute block batch size.
    pub const fn max_execute_block_batch_size(&self) -> usize {
        self.max_execute_block_batch_size
@@ -487,15 +468,6 @@ impl TreeConfig {
        self
    }

-    /// Setter for the invalid header cache hit eviction threshold.
-    pub const fn with_invalid_header_hit_eviction_threshold(
-        mut self,
-        invalid_header_hit_eviction_threshold: u8,
-    ) -> Self {
-        self.invalid_header_hit_eviction_threshold = invalid_header_hit_eviction_threshold;
-        self
-    }
-
    /// Setter for maximum execute block batch size.
    pub const fn with_max_execute_block_batch_size(
        mut self,
--- a/crates/engine/primitives/src/forkchoice.rs
+++ b/crates/engine/primitives/src/forkchoice.rs
@@ -21,8 +21,7 @@ impl ForkchoiceStateTracker {
    /// `sync_target` to `None`, since we're now fully synced.
    pub const fn set_latest(&mut self, state: ForkchoiceState, status: ForkchoiceStatus) {
        if status.is_valid() {
-            self.last_syncing = None;
-            self.last_valid = Some(state);
+            self.set_valid(state);
        } else if status.is_syncing() {
            self.last_syncing = Some(state);
        }
@@ -31,24 +30,11 @@ impl ForkchoiceStateTracker {
        self.latest = Some(received);
    }

-    /// Promotes a previously tracked syncing forkchoice state to valid, without overwriting a
-    /// newer `latest` state.
-    ///
-    /// This is used when a `Syncing` FCU's head finally becomes canonical via the downloaded-block
-    /// flow, so the safe/finalized anchors of that FCU can be applied. Unlike
-    /// [`Self::set_latest`], this preserves a newer `latest` (e.g. an `Invalid` FCU received
-    /// after the syncing one) and only flips `latest` to `Valid` when it still refers to the same
-    /// syncing FCU being promoted.
-    pub fn promote_sync_target_to_valid(&mut self, state: ForkchoiceState) {
+    const fn set_valid(&mut self, state: ForkchoiceState) {
+        // we no longer need to sync to this state.
        self.last_syncing = None;
-        self.last_valid = Some(state);

-        if let Some(received) = self.latest.as_mut() &&
-            received.state == state &&
-            received.status.is_syncing()
-        {
-            received.status = ForkchoiceStatus::Valid;
-        }
+        self.last_valid = Some(state);
    }

    /// Returns the [`ForkchoiceStatus`] of the latest received FCU.
--- a/crates/engine/tree/src/tree/invalid_headers.rs
+++ b/crates/engine/tree/src/tree/invalid_headers.rs
@@ -8,28 +8,25 @@ use schnellru::{ByLength, LruMap};
 use std::fmt::Debug;
 use tracing::warn;

+/// The max hit counter for invalid headers in the cache before it is forcefully evicted.
+///
+/// In other words, if a header is referenced more than this number of times, it will be evicted to
+/// allow for reprocessing.
+const INVALID_HEADER_HIT_EVICTION_THRESHOLD: u8 = 128;
+
 /// Keeps track of invalid headers.
 #[derive(Debug)]
 pub struct InvalidHeaderCache {
    /// This maps a header hash to a reference to its invalid ancestor.
    headers: LruMap<B256, HeaderEntry>,
-    /// Number of cache hits before an invalid header entry is evicted and reprocessed.
-    hit_eviction_threshold: u8,
    /// Metrics for the cache.
    metrics: InvalidHeaderCacheMetrics,
 }

 impl InvalidHeaderCache {
    /// Invalid header cache constructor.
-    ///
-    /// Setting `hit_eviction_threshold` to `0` effectively disables the cache because entries are
-    /// evicted on the first lookup.
-    pub fn new(max_length: u32, hit_eviction_threshold: u8) -> Self {
-        Self {
-            headers: LruMap::new(ByLength::new(max_length)),
-            hit_eviction_threshold,
-            metrics: Default::default(),
-        }
+    pub fn new(max_length: u32) -> Self {
+        Self { headers: LruMap::new(ByLength::new(max_length)), metrics: Default::default() }
    }

    fn insert_entry(&mut self, hash: B256, header: BlockWithParent) {
@@ -44,7 +41,7 @@ impl InvalidHeaderCache {
        {
            let entry = self.headers.get(hash)?;
            entry.hit_count += 1;
-            if entry.hit_count < self.hit_eviction_threshold {
+            if entry.hit_count < INVALID_HEADER_HIT_EVICTION_THRESHOLD {
                return Some(entry.header)
            }
        }
@@ -113,28 +110,17 @@ mod tests {

    #[test]
    fn test_hit_eviction() {
-        let hit_eviction_threshold = 3;
-        let mut cache = InvalidHeaderCache::new(10, hit_eviction_threshold);
+        let mut cache = InvalidHeaderCache::new(10);
        let header = Header::default();
        let header = SealedHeader::seal_slow(header);
        cache.insert(header.block_with_parent());
        assert_eq!(cache.headers.get(&header.hash()).unwrap().hit_count, 0);

-        for hit in 1..hit_eviction_threshold {
+        for hit in 1..INVALID_HEADER_HIT_EVICTION_THRESHOLD {
            assert!(cache.get(&header.hash()).is_some());
            assert_eq!(cache.headers.get(&header.hash()).unwrap().hit_count, hit);
        }

        assert!(cache.get(&header.hash()).is_none());
    }
-
-    #[test]
-    fn test_zero_hit_eviction_threshold_effectively_disables_cache() {
-        let mut cache = InvalidHeaderCache::new(10, 0);
-        let header = SealedHeader::seal_slow(Header::default());
-        cache.insert(header.block_with_parent());
-
-        assert!(cache.get(&header.hash()).is_none());
-        assert_eq!(cache.headers.len(), 0);
-    }
 }
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -151,15 +151,11 @@ impl<N: NodePrimitives> EngineApiTreeState<N> {
    fn new(
        block_buffer_limit: u32,
        max_invalid_header_cache_length: u32,
-        invalid_header_hit_eviction_threshold: u8,
        canonical_block: BlockNumHash,
        engine_kind: EngineApiKind,
    ) -> Self {
        Self {
-            invalid_headers: InvalidHeaderCache::new(
-                max_invalid_header_cache_length,
-                invalid_header_hit_eviction_threshold,
-            ),
+            invalid_headers: InvalidHeaderCache::new(max_invalid_header_cache_length),
            buffer: BlockBuffer::new(block_buffer_limit),
            tree_state: TreeState::new(canonical_block, engine_kind),
            forkchoice_state_tracker: ForkchoiceStateTracker::default(),
@@ -440,7 +436,6 @@ where
        let state = EngineApiTreeState::new(
            config.block_buffer_limit(),
            config.max_invalid_header_cache_length(),
-            config.invalid_header_hit_eviction_threshold(),
            header.num_hash(),
            kind,
        );
@@ -1511,9 +1506,9 @@ where
        // Re-prepare overlay for the current canonical head with the new anchor.
        // Spawn a background task to trigger computation so it's ready when the next payload
        // arrives.
-        if let Some(prepared) = self.state.tree_state.prepare_canonical_overlay() {
+        if let Some(overlay) = self.state.tree_state.prepare_canonical_overlay() {
            self.runtime.spawn_blocking_named("prepare-overlay", move || {
-                let _ = prepared.overlay.get(prepared.anchor_hash);
+                let _ = overlay.get();
            });
        }

@@ -1917,37 +1912,9 @@ where
            self.on_canonical_chain_update(chain_update);
        }

-        self.on_canonicalized_sync_target(target);
-
        Ok(())
    }

-    /// Applies the tracked forkchoice state once its sync target head becomes canonical.
-    fn on_canonicalized_sync_target(&mut self, target: B256) {
-        let Some(sync_target_state) = self
-            .state
-            .forkchoice_state_tracker
-            .sync_target_state()
-            .filter(|state| state.head_block_hash == target)
-        else {
-            return;
-        };
-
-        if let Err(outcome) = self.ensure_consistent_forkchoice_state(sync_target_state) {
-            debug!(
-                target: "engine::tree",
-                head = %sync_target_state.head_block_hash,
-                safe = %sync_target_state.safe_block_hash,
-                finalized = %sync_target_state.finalized_block_hash,
-                ?outcome,
-                "Canonicalized sync target head before safe/finalized could be applied"
-            );
-            return;
-        }
-
-        self.state.forkchoice_state_tracker.promote_sync_target_to_valid(sync_target_state);
-    }
-
    /// Convenience function to handle an optional tree event.
    fn on_maybe_tree_event(&mut self, event: Option<TreeEvent>) -> ProviderResult<()> {
        if let Some(event) = event {
@@ -3057,15 +3024,7 @@ where
            InsertBlockValidationError::Consensus(err) => self.consensus.is_transient_error(err),
            _ => false,
        };
-        if is_transient {
-            warn!(
-                target: "engine::tree",
-                invalid_hash=%block.hash(),
-                invalid_number=block.number(),
-                %validation_err,
-                "Skipping invalid header cache insert for transient validation error",
-            );
-        } else {
+        if !is_transient {
            self.state.invalid_headers.insert(block.block_with_parent());
        }
        self.emit_event(EngineApiEvent::BeaconConsensus(ConsensusEngineEvent::InvalidBlock(
--- a/crates/engine/tree/src/tree/payload_processor/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/mod.rs
@@ -7,7 +7,7 @@ use crate::tree::{
    CacheWaitDurations, CachedStateMetrics, CachedStateMetricsSource, ExecutionCache,
    PayloadExecutionCache, SavedCache, StateProviderBuilder, TreeConfig, WaitForCaches,
 };
-use alloy_eip7928::bal::DecodedBal;
+use alloy_eip7928::BlockAccessList;
 use alloy_eips::{eip1898::BlockWithParent, eip4895::Withdrawal};
 use alloy_primitives::B256;
 use crossbeam_channel::{Receiver as CrossbeamReceiver, Sender as CrossbeamSender};
@@ -250,6 +250,7 @@ where
        provider_builder: StateProviderBuilder<N, P>,
        multiproof_provider_factory: F,
        config: &TreeConfig,
+        bal: Option<Arc<BlockAccessList>>,
    ) -> IteratorPayloadHandle<Evm, I, N>
    where
        P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
@@ -272,12 +273,13 @@ where
            halve_workers,
            config,
        );
-        let install_state_hook = env.decoded_bal.is_none();
+        let install_state_hook = bal.is_none();
        let prewarm_handle = self.spawn_caching_with(
            env,
            prewarm_rx,
            provider_builder,
            Some(state_root_handle.updates_tx().clone()),
+            bal,
        );

        PayloadHandle {
@@ -298,13 +300,14 @@ where
        env: ExecutionEnv<Evm>,
        transactions: I,
        provider_builder: StateProviderBuilder<N, P>,
+        bal: Option<Arc<BlockAccessList>>,
    ) -> IteratorPayloadHandle<Evm, I, N>
    where
        P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
    {
        let (prewarm_rx, execution_rx) =
            self.spawn_tx_iterator(transactions, env.transaction_count);
-        let prewarm_handle = self.spawn_caching_with(env, prewarm_rx, provider_builder, None);
+        let prewarm_handle = self.spawn_caching_with(env, prewarm_rx, provider_builder, None, bal);
        PayloadHandle {
            state_root_handle: None,
            install_state_hook: false,
@@ -462,7 +465,7 @@ where
        level = "debug",
        target = "engine::tree::payload_processor",
        skip_all,
-        fields(bal=%env.decoded_bal.is_some())
+        fields(bal=%bal.is_some())
    )]
    fn spawn_caching_with<P>(
        &self,
@@ -470,6 +473,7 @@ where
        transactions: mpsc::Receiver<(usize, impl ExecutableTxFor<Evm> + Clone + Send + 'static)>,
        provider_builder: StateProviderBuilder<N, P>,
        to_sparse_trie_task: Option<CrossbeamSender<StateRootMessage>>,
+        bal: Option<Arc<BlockAccessList>>,
    ) -> CacheTaskHandle<N::Receipt>
    where
        P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
@@ -480,7 +484,7 @@ where
        let saved_cache = self.disable_state_cache.not().then(|| self.cache_for(env.parent_hash));

        let executed_tx_index = Arc::new(AtomicUsize::new(0));
-        let maybe_decoded_bal = env.decoded_bal.clone();
+
        // configure prewarming
        let prewarm_ctx = PrewarmContext {
            env,
@@ -503,16 +507,15 @@ where
            prewarm_ctx,
            to_sparse_trie_task,
        );
+
        {
            let to_prewarm_task = to_prewarm_task.clone();
            let disable_bal_parallel_execution = self.disable_bal_parallel_execution;
            self.executor.spawn_blocking_named("prewarm", move || {
                let mode = if skip_prewarm {
                    PrewarmMode::Skipped
-                } else if let Some(decoded_bal) =
-                    maybe_decoded_bal.filter(|_| !disable_bal_parallel_execution)
-                {
-                    PrewarmMode::BlockAccessList(decoded_bal)
+                } else if let Some(bal) = bal.filter(|_| !disable_bal_parallel_execution) {
+                    PrewarmMode::BlockAccessList(bal)
                } else {
                    PrewarmMode::Transactions(transactions)
                };
@@ -933,9 +936,6 @@ pub struct ExecutionEnv<Evm: ConfigureEvm> {
    /// Withdrawals included in the block.
    /// Used to generate prefetch targets for withdrawal addresses.
    pub withdrawals: Option<Vec<Withdrawal>>,
-    /// Optional decoded BAL for the block.
-    /// Used to validate and optimize execution.
-    pub decoded_bal: Option<Arc<DecodedBal>>,
 }

 impl<Evm: ConfigureEvm> ExecutionEnv<Evm>
@@ -953,7 +953,6 @@ where
            transaction_count: 0,
            gas_used: 0,
            withdrawals: None,
-            decoded_bal: None,
        }
    }
 }
@@ -970,12 +969,12 @@ mod tests {
    use rand::Rng;
    use reth_chainspec::ChainSpec;
    use reth_db_common::init::init_genesis;
-    use reth_ethereum_primitives::{EthPrimitives, TransactionSigned};
+    use reth_ethereum_primitives::TransactionSigned;
    use reth_evm::OnStateHook;
    use reth_evm_ethereum::EthEvmConfig;
    use reth_primitives_traits::{Account, Recovered, StorageEntry};
    use reth_provider::{
-        providers::{BlockchainProvider, OverlayBuilder, OverlayStateProviderFactory},
+        providers::{BlockchainProvider, OverlayStateProviderFactory},
        test_utils::create_test_provider_factory_with_chain_spec,
        ChainSpecProvider, HashingWriter,
    };
@@ -1250,11 +1249,9 @@ mod tests {
                std::convert::identity,
            ),
            StateProviderBuilder::new(provider_factory.clone(), genesis_hash, None),
-            OverlayStateProviderFactory::new(
-                provider_factory,
-                OverlayBuilder::<EthPrimitives>::new(genesis_hash, ChangesetCache::new()),
-            ),
+            OverlayStateProviderFactory::new(provider_factory, ChangesetCache::new()),
            &TreeConfig::default(),
+            None, // No BAL for test
        );

        let mut state_hook = handle.state_hook().expect("state hook is None");
--- a/crates/engine/tree/src/tree/payload_processor/prewarm.rs
+++ b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
@@ -18,7 +18,7 @@ use crate::tree::{
    StateProviderBuilder,
 };
 use alloy_consensus::transaction::TxHashRef;
-use alloy_eip7928::bal::DecodedBal;
+use alloy_eip7928::BlockAccessList;
 use alloy_eips::eip4895::Withdrawal;
 use alloy_primitives::{keccak256, StorageKey, B256};
 use crossbeam_channel::Sender as CrossbeamSender;
@@ -48,7 +48,7 @@ pub enum PrewarmMode<Tx> {
    /// Prewarm by executing transactions from a stream, each paired with its block index.
    Transactions(Receiver<(usize, Tx)>),
    /// Prewarm by prefetching slots from a Block Access List.
-    BlockAccessList(Arc<DecodedBal>),
+    BlockAccessList(Arc<BlockAccessList>),
    /// Transaction prewarming is skipped (e.g. small blocks where the overhead exceeds the
    /// benefit). No workers are spawned.
    Skipped,
@@ -331,10 +331,9 @@ where
    #[instrument(level = "debug", target = "engine::tree::payload_processor::prewarm", skip_all)]
    fn run_bal_prewarm(
        &self,
-        decoded_bal: Arc<DecodedBal>,
+        bal: Arc<BlockAccessList>,
        actions_tx: Sender<PrewarmTaskEvent<N::Receipt>>,
    ) {
-        let bal = decoded_bal.as_bal();
        if bal.is_empty() {
            if let Some(to_sparse_trie_task) = self.to_sparse_trie_task.as_ref() {
                let _ = to_sparse_trie_task.send(StateRootMessage::FinishedStateUpdates);
@@ -356,63 +355,27 @@ where
        let parent_span = Span::current();
        let prefetch_parent_span = parent_span.clone();
        let stream_parent_span = parent_span;
-        let prefetch_bal = Arc::clone(&decoded_bal);
-        let stream_bal = Arc::clone(&decoded_bal);
+        let prefetch_bal = Arc::clone(&bal);
+        let stream_bal = Arc::clone(&bal);
        let (prefetch_tx, prefetch_rx) = oneshot::channel();
        let (stream_tx, stream_rx) = oneshot::channel();

-        if let Some(to_sparse_trie_task) = to_sparse_trie_task {
-            let stream_ctx = ctx.clone();
-            executor.bal_streaming_pool().spawn(move || {
-                let branch_span = debug_span!(
-                    target: "engine::tree::payload_processor::prewarm",
-                    parent: &stream_parent_span,
-                    "bal_hashed_state_stream",
-                    bal_accounts = stream_bal.as_bal().len(),
-                );
-                let provider_parent_span = branch_span.clone();
-                let _span = branch_span.entered();
-
-                stream_bal.as_bal().par_iter().for_each_init(
-                    || {
-                        (
-                            stream_ctx.clone(),
-                            None::<Box<dyn AccountReader>>,
-                            provider_parent_span.clone(),
-                        )
-                    },
-                    |(ctx, provider, parent_span), account_changes| {
-                        ctx.send_bal_hashed_state(
-                            parent_span,
-                            provider,
-                            account_changes,
-                            &to_sparse_trie_task,
-                        );
-                    },
-                );
-
-                let _ = to_sparse_trie_task.send(StateRootMessage::FinishedStateUpdates);
-                let _ = stream_tx.send(());
-            });
-        } else {
-            let _ = stream_tx.send(());
-        }
-
        if ctx.saved_cache.is_some() {
+            let prefetch_ctx = ctx.clone();
            executor.prewarming_pool().spawn(move || {
                let branch_span = debug_span!(
                    target: "engine::tree::payload_processor::prewarm",
                    parent: &prefetch_parent_span,
                    "bal_prefetch_storage",
-                    bal_accounts = prefetch_bal.as_bal().len(),
+                    bal_accounts = prefetch_bal.len(),
                );
                let provider_parent_span = branch_span.clone();
                let _span = branch_span.entered();

-                prefetch_bal.as_bal().par_iter().for_each_init(
+                prefetch_bal.par_iter().for_each_init(
                    || {
                        (
-                            ctx.clone(),
+                            prefetch_ctx.clone(),
                            None::<CachedStateProvider<reth_provider::StateProviderBox, true>>,
                            provider_parent_span.clone(),
                        )
@@ -431,6 +394,36 @@ where
            let _ = prefetch_tx.send(());
        }

+        if let Some(to_sparse_trie_task) = to_sparse_trie_task {
+            executor.bal_streaming_pool().spawn(move || {
+                let branch_span = debug_span!(
+                    target: "engine::tree::payload_processor::prewarm",
+                    parent: &stream_parent_span,
+                    "bal_hashed_state_stream",
+                    bal_accounts = stream_bal.len(),
+                );
+                let provider_parent_span = branch_span.clone();
+                let _span = branch_span.entered();
+
+                stream_bal.par_iter().for_each_init(
+                    || (ctx.clone(), None::<Box<dyn AccountReader>>, provider_parent_span.clone()),
+                    |(ctx, provider, parent_span), account_changes| {
+                        ctx.send_bal_hashed_state(
+                            parent_span,
+                            provider,
+                            account_changes,
+                            &to_sparse_trie_task,
+                        );
+                    },
+                );
+
+                let _ = to_sparse_trie_task.send(StateRootMessage::FinishedStateUpdates);
+                let _ = stream_tx.send(());
+            });
+        } else {
+            let _ = stream_tx.send(());
+        }
+
        prefetch_rx
            .blocking_recv()
            .expect("BAL prefetch task dropped without signaling completion");
@@ -757,9 +750,7 @@ where
        provider: &mut Option<CachedStateProvider<reth_provider::StateProviderBox, true>>,
        account: &alloy_eip7928::AccountChanges,
    ) {
-        if self.disable_bal_batch_io ||
-            (account.storage_changes.is_empty() && account.storage_reads.is_empty())
-        {
+        if account.storage_changes.is_empty() && account.storage_reads.is_empty() {
            return;
        }

--- a/crates/engine/tree/src/tree/payload_processor/sparse_trie.rs
+++ b/crates/engine/tree/src/tree/payload_processor/sparse_trie.rs
@@ -894,9 +894,7 @@ mod tests {
    use super::*;
    use alloy_primitives::{keccak256, Address, B256, U256};
    use reth_provider::{
-        providers::{OverlayBuilder, OverlayStateProviderFactory},
-        test_utils::create_test_provider_factory,
-        ChainSpecProvider,
+        providers::OverlayStateProviderFactory, test_utils::create_test_provider_factory,
    };
    use reth_trie_db::ChangesetCache;
    use reth_trie_parallel::proof_task::ProofTaskCtx;
@@ -985,14 +983,8 @@ mod tests {
    fn run_returns_parent_root_without_revealing_blind_trie_when_no_state_updates() {
        let runtime = reth_tasks::Runtime::test();
        let provider_factory = create_test_provider_factory();
-        let anchor_hash = provider_factory.chain_spec().genesis_hash();
-        let overlay_factory = OverlayStateProviderFactory::new(
-            provider_factory,
-            OverlayBuilder::<reth_chain_state::EthPrimitives>::new(
-                anchor_hash,
-                ChangesetCache::new(),
-            ),
-        );
+        let overlay_factory =
+            OverlayStateProviderFactory::new(provider_factory, ChangesetCache::new());
        let proof_worker_handle =
            ProofWorkerHandle::new(&runtime, ProofTaskCtx::new(overlay_factory), false);

--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -48,10 +48,7 @@ use crate::tree::{
    PayloadHandle, StateProviderBuilder, StateProviderDatabase, TreeConfig, WaitForCaches,
 };
 use alloy_consensus::transaction::{Either, TxHashRef};
-use alloy_eip7928::{
-    bal::{Bal, DecodedBal},
-    BlockAccessList,
-};
+use alloy_eip7928::{bal::Bal, BlockAccessList};
 use alloy_eips::{eip1898::BlockWithParent, eip4895::Withdrawal, NumHash};
 use alloy_evm::Evm;
 use alloy_primitives::{map::B256Set, B256};
@@ -80,14 +77,13 @@ use reth_primitives_traits::{
    RecoveredBlock, SealedBlock, SealedHeader, SignerRecoverable,
 };
 use reth_provider::{
-    providers::{OverlayBuilder, OverlayStateProviderFactory},
-    BlockExecutionOutput, BlockNumReader, BlockReader, ChangeSetReader, DatabaseProviderFactory,
-    DatabaseProviderROFactory, HashedPostStateProvider, ProviderError, PruneCheckpointReader,
-    StageCheckpointReader, StateProvider, StateProviderBox, StateProviderFactory, StateReader,
-    StorageChangeSetReader, StorageSettingsCache,
+    providers::OverlayStateProviderFactory, BlockExecutionOutput, BlockNumReader, BlockReader,
+    ChangeSetReader, DatabaseProviderFactory, DatabaseProviderROFactory, HashedPostStateProvider,
+    ProviderError, PruneCheckpointReader, StageCheckpointReader, StateProvider,
+    StateProviderFactory, StateReader, StorageChangeSetReader, StorageSettingsCache,
 };
 use reth_revm::db::{states::bundle_state::BundleRetention, BundleAccount, State};
-use reth_trie::{trie_cursor::TrieCursorFactory, updates::TrieUpdates, HashedPostState};
+use reth_trie::{trie_cursor::TrieCursorFactory, updates::TrieUpdates, HashedPostState, StateRoot};
 use reth_trie_db::ChangesetCache;
 use reth_trie_parallel::root::{ParallelStateRoot, ParallelStateRootError};
 use revm_primitives::{Address, KECCAK_EMPTY};
@@ -491,12 +487,6 @@ where
            .in_scope(|| self.evm_env_for(&input))
            .map_err(NewPayloadError::other)?;

-        // Extract the decoded BAL, if valid and available.
-        let decoded_bal = ensure_ok!(input
-            .try_decoded_access_list()
-            .map_err(|err| { Box::<dyn std::error::Error + Send + Sync>::from(err) }))
-        .map(Arc::new);
-
        let env = ExecutionEnv {
            evm_env,
            hash: input.hash(),
@@ -505,7 +495,6 @@ where
            transaction_count: input.transaction_count(),
            gas_used: input.gas_used(),
            withdrawals: input.withdrawals().map(|w| w.to_vec()),
-            decoded_bal,
        };

        // Plan the strategy used for state root computation.
@@ -520,25 +509,33 @@ where
        // Get an iterator over the transactions in the payload
        let txs = self.tx_iterator_for(&input)?;

+        // Extract the BAL, if valid and available
+        let block_access_list = ensure_ok!(input
+            .block_access_list()
+            .transpose()
+            // Eventually gets converted to a `InsertBlockErrorKind::Other`
+            .map_err(Box::<dyn std::error::Error + Send + Sync>::from))
+        .map(Arc::new);
+
        // Create lazy overlay from ancestors - this doesn't block, allowing execution to start
        // before the trie data is ready. The overlay will be computed on first access.
        let (lazy_overlay, anchor_hash) = Self::get_parent_lazy_overlay(parent_hash, ctx.state());

        // Create overlay factory for payload processor (StateRootTask path needs it for
        // multiproofs)
-        let provider_factory = self.provider.clone();
-        let overlay_builder = OverlayBuilder::<N>::new(anchor_hash, self.changeset_cache.clone())
-            .with_lazy_overlay(lazy_overlay);
        let overlay_factory =
-            OverlayStateProviderFactory::new(provider_factory.clone(), overlay_builder.clone());
+            OverlayStateProviderFactory::new(self.provider.clone(), self.changeset_cache.clone())
+                .with_block_hash(Some(anchor_hash))
+                .with_lazy_overlay(lazy_overlay);

        // Spawn the appropriate processor based on strategy
        let mut handle = ensure_ok!(self.spawn_payload_processor(
            env.clone(),
            txs,
-            provider_builder.clone(),
+            provider_builder,
            overlay_factory.clone(),
            strategy,
+            block_access_list,
        ));

        // Create optional cache stats for detailed block logging
@@ -667,7 +664,7 @@ where
                let task_result = ensure_ok_post_block!(
                    self.await_state_root_with_timeout(
                        &mut handle,
-                        provider_builder.clone(),
+                        overlay_factory.clone(),
                        &hashed_state,
                    ),
                    block
@@ -691,9 +688,7 @@ where
                        // Compare trie updates with serial computation if configured
                        if self.config.always_compare_trie_updates() {
                            let _has_diff = self.compare_trie_updates_with_serial(
-                                provider_builder.clone(),
-                                provider_factory,
-                                overlay_builder,
+                                overlay_factory.clone(),
                                &hashed_state,
                                trie_updates.as_ref().clone(),
                            );
@@ -732,11 +727,7 @@ where
            }
            StateRootStrategy::Parallel => {
                debug!(target: "engine::tree::payload_validator", "Using parallel state root algorithm");
-                match self.compute_state_root_parallel(
-                    provider_factory,
-                    overlay_builder,
-                    &hashed_state,
-                ) {
+                match self.compute_state_root_parallel(overlay_factory.clone(), &hashed_state) {
                    Ok(result) => {
                        let elapsed = root_time.elapsed();
                        info!(
@@ -772,9 +763,7 @@ where
            }

            let (root, updates) = ensure_ok_post_block!(
-                provider_builder
-                    .build()
-                    .and_then(|provider| Self::compute_state_root_serial(provider, &hashed_state)),
+                Self::compute_state_root_serial(overlay_factory.clone(), &hashed_state),
                block
            );

@@ -1098,8 +1087,7 @@ where
    #[instrument(level = "debug", target = "engine::tree::payload_validator", skip_all)]
    fn compute_state_root_parallel(
        &self,
-        provider_factory: P,
-        overlay_builder: OverlayBuilder<N>,
+        overlay_factory: OverlayStateProviderFactory<P>,
        hashed_state: &LazyHashedPostState,
    ) -> Result<(B256, TrieUpdates), ParallelStateRootError> {
        let hashed_state = hashed_state.get();
@@ -1107,24 +1095,34 @@ where
        // need to use the prefix sets which were generated from it to indicate to the
        // ParallelStateRoot which parts of the trie need to be recomputed.
        let prefix_sets = hashed_state.construct_prefix_sets().freeze();
-        let overlay_factory = OverlayStateProviderFactory::new(
-            provider_factory,
-            overlay_builder.with_extended_hashed_state_overlay(hashed_state.clone_into_sorted()),
-        );
+        let overlay_factory =
+            overlay_factory.with_extended_hashed_state_overlay(hashed_state.clone_into_sorted());
        ParallelStateRoot::new(overlay_factory, prefix_sets, self.runtime.clone())
            .incremental_root_with_updates()
    }

    /// Compute state root for the given hashed post state in serial.
    ///
-    /// Uses the same provider construction path as main execution and computes the state root and
-    /// trie updates for this block directly via
-    /// [`reth_provider::StateRootProvider::state_root_with_updates`].
+    /// Uses an overlay factory which provides the state of the parent block, along with the
+    /// [`HashedPostState`] containing the changes of this block, to compute the state root and
+    /// trie updates for this block.
    fn compute_state_root_serial(
-        state_provider: StateProviderBox,
+        overlay_factory: OverlayStateProviderFactory<P>,
        hashed_state: &LazyHashedPostState,
    ) -> ProviderResult<(B256, TrieUpdates)> {
-        state_provider.state_root_with_updates(hashed_state.get().clone())
+        let hashed_state = hashed_state.get();
+        // The `hashed_state` argument will be taken into account as part of the overlay, but we
+        // need to use the prefix sets which were generated from it to indicate to the
+        // StateRoot which parts of the trie need to be recomputed.
+        let prefix_sets = hashed_state.construct_prefix_sets().freeze();
+        let overlay_factory =
+            overlay_factory.with_extended_hashed_state_overlay(hashed_state.clone_into_sorted());
+
+        let provider = overlay_factory.database_provider_ro()?;
+
+        Ok(StateRoot::new(&provider, &provider)
+            .with_prefix_sets(prefix_sets)
+            .root_with_updates()?)
    }

    /// Awaits the state root from the background task, with an optional timeout fallback.
@@ -1149,7 +1147,7 @@ where
    fn await_state_root_with_timeout<Tx, Err, R: Send + Sync + 'static>(
        &self,
        handle: &mut PayloadHandle<Tx, Err, R>,
-        state_provider_builder: StateProviderBuilder<N, P>,
+        overlay_factory: OverlayStateProviderFactory<P>,
        hashed_state: &LazyHashedPostState,
    ) -> ProviderResult<Result<StateRootComputeOutcome, ParallelStateRootError>> {
        let Some(timeout) = self.config.state_root_task_timeout() else {
@@ -1174,11 +1172,10 @@ where
                let (seq_tx, seq_rx) =
                    std::sync::mpsc::channel::<ProviderResult<(B256, TrieUpdates)>>();

+                let seq_overlay = overlay_factory;
                let seq_hashed_state = hashed_state.clone();
                self.payload_processor.executor().spawn_blocking_named("serial-root", move || {
-                    let result = state_provider_builder.build().and_then(|provider| {
-                        Self::compute_state_root_serial(provider, &seq_hashed_state)
-                    });
+                    let result = Self::compute_state_root_serial(seq_overlay, &seq_hashed_state);
                    let _ = seq_tx.send(result);
                });

@@ -1242,18 +1239,13 @@ where
    /// updates.
    fn compare_trie_updates_with_serial(
        &self,
-        state_provider_builder: StateProviderBuilder<N, P>,
-        provider_factory: P,
-        overlay_builder: OverlayBuilder<N>,
+        overlay_factory: OverlayStateProviderFactory<P>,
        hashed_state: &LazyHashedPostState,
        task_trie_updates: TrieUpdates,
    ) -> bool {
        debug!(target: "engine::tree::payload_validator", "Comparing trie updates with serial computation");

-        match state_provider_builder
-            .build()
-            .and_then(|provider| Self::compute_state_root_serial(provider, hashed_state))
-        {
+        match Self::compute_state_root_serial(overlay_factory.clone(), hashed_state) {
            Ok((serial_root, serial_trie_updates)) => {
                debug!(
                    target: "engine::tree::payload_validator",
@@ -1262,8 +1254,6 @@ where
                );

                // Get a database provider to use as trie cursor factory
-                let overlay_factory =
-                    OverlayStateProviderFactory::new(provider_factory, overlay_builder);
                match overlay_factory.database_provider_ro() {
                    Ok(provider) => {
                        match super::trie_updates::compare_trie_updates(
@@ -1447,8 +1437,9 @@ where
        env: ExecutionEnv<Evm>,
        txs: T,
        provider_builder: StateProviderBuilder<N, P>,
-        overlay_factory: OverlayStateProviderFactory<P, N>,
+        overlay_factory: OverlayStateProviderFactory<P>,
        strategy: StateRootStrategy,
+        block_access_list: Option<Arc<BlockAccessList>>,
    ) -> Result<
        PayloadHandle<
            impl ExecutableTxFor<Evm> + use<N, P, Evm, V, T>,
@@ -1468,6 +1459,7 @@ where
                    provider_builder,
                    overlay_factory,
                    &self.config,
+                    block_access_list,
                );

                // record prewarming initialization duration
@@ -1480,8 +1472,12 @@ where
            }
            StateRootStrategy::Parallel | StateRootStrategy::Synchronous => {
                let start = Instant::now();
-                let handle =
-                    self.payload_processor.spawn_cache_exclusive(env, txs, provider_builder);
+                let handle = self.payload_processor.spawn_cache_exclusive(
+                    env,
+                    txs,
+                    provider_builder,
+                    block_access_list,
+                );

                // Record prewarming initialization duration
                self.metrics
@@ -1567,7 +1563,7 @@ where
    fn get_parent_lazy_overlay(
        parent_hash: B256,
        state: &EngineApiTreeState<N>,
-    ) -> (Option<LazyOverlay<N>>, B256) {
+    ) -> (Option<LazyOverlay>, B256) {
        // Get blocks leading to the parent to determine the anchor
        let (anchor_hash, blocks) =
            state.tree_state.blocks_by_hash(parent_hash).unwrap_or_else(|| (parent_hash, vec![]));
@@ -1595,7 +1591,10 @@ where
            "Creating lazy overlay for in-memory blocks"
        );

-        (Some(LazyOverlay::new(blocks)), anchor_hash)
+        // Extract deferred trie data handles (non-blocking)
+        let handles: Vec<DeferredTrieData> = blocks.iter().map(|b| b.trie_data_handle()).collect();
+
+        (Some(LazyOverlay::new(anchor_hash, handles)), anchor_hash)
    }

    /// Spawns a background task to compute and sort trie data for the executed block.
@@ -2027,11 +2026,10 @@ where
        state: &EngineApiTreeState<N>,
    ) -> Option<StateRootHandle> {
        let (lazy_overlay, anchor_hash) = Self::get_parent_lazy_overlay(parent_hash, state);
-        let overlay_factory = OverlayStateProviderFactory::new(
-            self.provider.clone(),
-            OverlayBuilder::<N>::new(anchor_hash, self.changeset_cache.clone())
-                .with_lazy_overlay(lazy_overlay),
-        );
+        let overlay_factory =
+            OverlayStateProviderFactory::new(self.provider.clone(), self.changeset_cache.clone())
+                .with_block_hash(Some(anchor_hash))
+                .with_lazy_overlay(lazy_overlay);

        Some(self.payload_processor.spawn_state_root(
            overlay_factory,
@@ -2112,17 +2110,6 @@ impl<T: PayloadTypes> BlockOrPayload<T> {
        }
    }

-    /// Returns the decoded block access list, if present and successfully decoded.
-    pub fn try_decoded_access_list(&self) -> Result<Option<DecodedBal>, alloy_rlp::Error> {
-        match self {
-            Self::Payload(payload) => payload
-                .block_access_list()
-                .map(|block_access_list| DecodedBal::from_rlp_bytes(block_access_list.clone()))
-                .transpose(),
-            Self::Block(_) => Ok(None),
-        }
-    }
-
    /// Returns the number of transactions in the payload or block.
    pub fn transaction_count(&self) -> usize
    where
--- a/crates/engine/tree/src/tree/precompile_cache.rs
+++ b/crates/engine/tree/src/tree/precompile_cache.rs
@@ -13,7 +13,7 @@ use std::{hash::Hash, sync::Arc};
 use tracing::error;

 /// Default max cache size for [`PrecompileCache`]
-const MAX_CACHE_SIZE: u32 = 1024 * 1024;
+const MAX_CACHE_SIZE: u32 = 10_000;

 /// Stores caches for each precompile.
 #[derive(Debug, Clone, Default)]
@@ -54,9 +54,6 @@ where
            moka::sync::CacheBuilder::new(MAX_CACHE_SIZE as u64)
                .initial_capacity(MAX_CACHE_SIZE as usize)
                .eviction_policy(EvictionPolicy::lru())
-                .weigher(|key: &Bytes, value: &CacheEntry<S>| {
-                    (key.len() + value.output.bytes.len()) as u32
-                })
                .build_with_hasher(Default::default()),
        )
    }
--- a/crates/engine/tree/src/tree/state.rs
+++ b/crates/engine/tree/src/tree/state.rs
@@ -6,7 +6,7 @@ use alloy_primitives::{
    map::{B256Map, B256Set},
    BlockNumber, B256,
 };
-use reth_chain_state::{EthPrimitives, ExecutedBlock, LazyOverlay};
+use reth_chain_state::{DeferredTrieData, EthPrimitives, ExecutedBlock, LazyOverlay};
 use reth_primitives_traits::{AlloyBlockHeader, NodePrimitives, SealedHeader};
 use std::{
    collections::{btree_map, hash_map, BTreeMap, VecDeque},
@@ -43,7 +43,7 @@ pub struct TreeState<N: NodePrimitives = EthPrimitives> {
    /// This is optimistically prepared after the canonical head changes, so that
    /// the next payload building on the canonical head can use it immediately
    /// without recomputing.
-    pub(crate) cached_canonical_overlay: Option<PreparedCanonicalOverlay<N>>,
+    pub(crate) cached_canonical_overlay: Option<PreparedCanonicalOverlay>,
 }

 impl<N: NodePrimitives> TreeState<N> {
@@ -106,10 +106,10 @@ impl<N: NodePrimitives> TreeState<N> {
    /// This should be called after the canonical head changes to optimistically
    /// prepare the overlay for the next payload that will likely build on it.
    ///
-    /// Returns a clone of the prepared overlay so the caller can spawn a background
-    /// task to trigger computation via [`LazyOverlay::get`] for the cached anchor.
-    /// This ensures the overlay is actually computed before the next payload arrives.
-    pub(crate) fn prepare_canonical_overlay(&mut self) -> Option<PreparedCanonicalOverlay<N>> {
+    /// Returns a clone of the [`LazyOverlay`] so the caller can spawn a background
+    /// task to trigger computation via [`LazyOverlay::get`]. This ensures the overlay
+    /// is actually computed before the next payload arrives.
+    pub(crate) fn prepare_canonical_overlay(&mut self) -> Option<LazyOverlay> {
        let canonical_hash = self.current_canonical_head.hash;

        // Get blocks leading to the canonical head
@@ -119,23 +119,25 @@ impl<N: NodePrimitives> TreeState<N> {
            return None;
        };

-        let num_blocks = blocks.len();
-        let prepared = PreparedCanonicalOverlay {
+        // Extract deferred trie data handles from blocks (newest to oldest)
+        let handles: Vec<DeferredTrieData> = blocks.iter().map(|b| b.trie_data_handle()).collect();
+
+        let overlay = LazyOverlay::new(anchor_hash, handles);
+        self.cached_canonical_overlay = Some(PreparedCanonicalOverlay {
            parent_hash: canonical_hash,
-            overlay: LazyOverlay::new(blocks),
+            overlay: overlay.clone(),
            anchor_hash,
-        };
-        self.cached_canonical_overlay = Some(prepared.clone());
+        });

        debug!(
            target: "engine::tree",
            %canonical_hash,
            %anchor_hash,
-            num_blocks,
+            num_blocks = blocks.len(),
            "Prepared cached canonical overlay"
        );

-        Some(prepared)
+        Some(overlay)
    }

    /// Returns the cached overlay if it matches the requested parent hash and anchor.
@@ -146,7 +148,7 @@ impl<N: NodePrimitives> TreeState<N> {
        &self,
        parent_hash: B256,
        expected_anchor: B256,
-    ) -> Option<&PreparedCanonicalOverlay<N>> {
+    ) -> Option<&PreparedCanonicalOverlay> {
        self.cached_canonical_overlay.as_ref().filter(|cached| {
            cached.parent_hash == parent_hash && cached.anchor_hash == expected_anchor
        })
@@ -427,10 +429,10 @@ impl<N: NodePrimitives> TreeState<N> {
 /// the next payload (which typically builds on the canonical head) to reuse
 /// the pre-computed overlay immediately without re-traversing in-memory blocks.
 ///
-/// The overlay captures executed blocks from all in-memory blocks
+/// The overlay captures deferred trie data handles from all in-memory blocks
 /// between the canonical head and the persisted anchor. When a new payload
 /// arrives building on the canonical head, this cached overlay can be used
-/// directly instead of calling `blocks_by_hash` again.
+/// directly instead of calling `blocks_by_hash` and collecting handles again.
 ///
 /// # Invalidation
 ///
@@ -438,16 +440,16 @@ impl<N: NodePrimitives> TreeState<N> {
 /// - Persistence completes (anchor changes)
 /// - The canonical head changes to a different block
 #[derive(Debug, Clone)]
-pub struct PreparedCanonicalOverlay<N: NodePrimitives = EthPrimitives> {
+pub struct PreparedCanonicalOverlay {
    /// The block hash for which this overlay is prepared as a parent.
    ///
    /// When a payload arrives with this parent hash, the overlay can be reused.
    pub parent_hash: B256,
-    /// The pre-computed lazy overlay containing executed blocks for the canonical segment.
+    /// The pre-computed lazy overlay containing deferred trie data handles.
    ///
-    /// This is computed optimistically after `set_canonical_head` so subsequent payloads don't
-    /// need to walk the in-memory chain again.
-    pub overlay: LazyOverlay<N>,
+    /// This is computed optimistically after `set_canonical_head` so subsequent
+    /// payloads don't need to re-collect the handles.
+    pub overlay: LazyOverlay,
    /// The anchor hash (persisted ancestor) this overlay is based on.
    ///
    /// Used to verify the overlay is still valid (anchor hasn't changed due to persistence).
--- a/crates/engine/tree/src/tree/tests.rs
+++ b/crates/engine/tree/src/tree/tests.rs
@@ -184,18 +184,11 @@ impl TestHarness {
        let payload_validator = MockEngineValidator;

        let (from_tree_tx, from_tree_rx) = unbounded_channel();
-        let tree_config =
-            TreeConfig::default().with_legacy_state_root(false).with_has_enough_parallelism(true);

        let header = chain_spec.genesis_header().clone();
        let header = SealedHeader::seal_slow(header);
-        let engine_api_tree_state = EngineApiTreeState::new(
-            10,
-            10,
-            tree_config.invalid_header_hit_eviction_threshold(),
-            header.num_hash(),
-            EngineApiKind::Ethereum,
-        );
+        let engine_api_tree_state =
+            EngineApiTreeState::new(10, 10, header.num_hash(), EngineApiKind::Ethereum);
        let canonical_in_memory_state = CanonicalInMemoryState::with_head(header, None, None);

        let (to_payload_service, _payload_command_rx) = unbounded_channel();
@@ -224,7 +217,8 @@ impl TestHarness {
            persistence_handle,
            PersistenceState { last_persisted_block: BlockNumHash::default(), rx: None },
            payload_builder,
-            tree_config,
+            // always assume enough parallelism for tests
+            TreeConfig::default().with_legacy_state_root(false).with_has_enough_parallelism(true),
            EngineApiKind::Ethereum,
            evm_config,
            changeset_cache,
@@ -2254,65 +2248,3 @@ fn test_on_valid_downloaded_head_sync_target_returns_make_canonical() {
        other => panic!("Expected MakeCanonical for head block, got: {other:?}"),
    }
 }
-
-/// Tests that canonicalizing a downloaded sync target head also applies the tracked finalized
-/// block from the original `SYNCING` forkchoice state.
-#[test]
-fn test_canonicalizing_downloaded_sync_target_head_updates_finalized() {
-    reth_tracing::init_test_tracing();
-
-    let chain_spec = MAINNET.clone();
-    let mut test_harness = TestHarness::new(chain_spec);
-
-    let blocks: Vec<_> = test_harness.block_builder.get_executed_blocks(0..3).collect();
-    let genesis = &blocks[0];
-    let finalized_block = &blocks[1];
-    let head_block = &blocks[2];
-
-    test_harness = test_harness.with_blocks(vec![
-        genesis.clone(),
-        finalized_block.clone(),
-        head_block.clone(),
-    ]);
-
-    let finalized_num_hash = finalized_block.recovered_block().num_hash();
-    let head_num_hash = head_block.recovered_block().num_hash();
-
-    test_harness.tree.state.tree_state.set_canonical_head(genesis.recovered_block().num_hash());
-
-    let fcu_state = ForkchoiceState {
-        head_block_hash: head_num_hash.hash,
-        safe_block_hash: head_num_hash.hash,
-        finalized_block_hash: finalized_num_hash.hash,
-    };
-    test_harness
-        .tree
-        .state
-        .forkchoice_state_tracker
-        .set_latest(fcu_state, ForkchoiceStatus::Syncing);
-
-    let event = test_harness
-        .tree
-        .on_valid_downloaded_block(head_num_hash)
-        .unwrap()
-        .expect("expected canonicalization event for sync target head");
-
-    test_harness.tree.on_tree_event(event).unwrap();
-
-    assert_eq!(test_harness.tree.state.tree_state.canonical_block_hash(), head_num_hash.hash);
-    assert_eq!(
-        test_harness.tree.canonical_in_memory_state.get_finalized_num_hash(),
-        Some(finalized_num_hash),
-        "Finalized block from the syncing FCU should be applied once the head becomes canonical"
-    );
-    assert_eq!(
-        test_harness.tree.canonical_in_memory_state.get_safe_num_hash(),
-        Some(head_num_hash),
-        "Safe block from the syncing FCU should be applied once the head becomes canonical"
-    );
-    assert_eq!(
-        test_harness.tree.state.forkchoice_state_tracker.last_valid_state(),
-        Some(fcu_state)
-    );
-    assert!(test_harness.tree.state.forkchoice_state_tracker.sync_target_state().is_none());
-}
--- a/crates/engine/util/src/reorg.rs
+++ b/crates/engine/util/src/reorg.rs
@@ -287,7 +287,7 @@ where
        let tx_recovered =
            tx.try_into_recovered().map_err(|_| ProviderError::SenderRecoveryError)?;
        let gas_used = match builder.execute_transaction(tx_recovered) {
-            Ok(gas_used) => gas_used.tx_gas_used(),
+            Ok(gas_used) => gas_used,
            Err(BlockExecutionError::Validation(BlockValidationError::InvalidTx {
                hash,
                error,
--- a/crates/era-utils/src/export.rs
+++ b/crates/era-utils/src/export.rs
@@ -2,8 +2,8 @@
 //! and injecting them into era1 files with `Era1Writer`.

 use crate::calculate_td_by_number;
-use alloy_consensus::{BlockHeader, Sealable, TxReceipt};
-use alloy_primitives::{BlockNumber, U256};
+use alloy_consensus::BlockHeader;
+use alloy_primitives::{BlockNumber, B256, U256};
 use eyre::{eyre, Result};
 use reth_era::{
    common::file_ops::{EraFileId, StreamWriter},
@@ -13,7 +13,7 @@ use reth_era::{
        types::{
            execution::{
                Accumulator, BlockTuple, CompressedBody, CompressedHeader, CompressedReceipts,
-                HeaderRecord, TotalDifficulty, MAX_BLOCKS_PER_ERA1,
+                TotalDifficulty, MAX_BLOCKS_PER_ERA1,
            },
            group::{BlockIndex, Era1Id},
        },
@@ -139,21 +139,17 @@ where

        let headers = provider.headers_range(start_block..=end_block)?;

-        // Pre-compute accumulator from headers to determine filename
-        let mut precompute_td = total_difficulty;
-        let header_records: Vec<HeaderRecord> = headers
-            .iter()
-            .map(|h| {
-                precompute_td += h.difficulty();
-                HeaderRecord { block_hash: h.hash_slow(), total_difficulty: precompute_td }
+        // Extract first 4 bytes of last block's state root as historical identifier
+        let historical_root = headers
+            .last()
+            .map(|header| {
+                let state_root = header.state_root();
+                [state_root[0], state_root[1], state_root[2], state_root[3]]
            })
-            .collect();
-        let accumulator = Accumulator::from_header_records(&header_records)
-            .map_err(|e| eyre!("Failed to compute accumulator: {e}"))?;
-        let file_hash: [u8; 4] = accumulator.root[..4].try_into().unwrap();
+            .unwrap_or([0u8; 4]);

-        let era1_id =
-            Era1Id::new(&config.network, start_block, block_count as u32).with_hash(file_hash);
+        let era1_id = Era1Id::new(&config.network, start_block, block_count as u32)
+            .with_hash(historical_root);

        let era1_id = if config.max_blocks_per_file == MAX_BLOCKS_PER_ERA1 as u64 {
            era1_id
@@ -170,6 +166,7 @@ where
        let mut offsets = Vec::<i64>::with_capacity(block_count);
        let mut position = VERSION_ENTRY_SIZE as i64;
        let mut blocks_written = 0;
+        let mut final_header_data = Vec::new();

        for (i, header) in headers.into_iter().enumerate() {
            let expected_block_number = start_block + i as u64;
@@ -181,6 +178,11 @@ where
                &mut total_difficulty,
            )?;

+            // Save last block's header data for accumulator
+            if expected_block_number == end_block {
+                final_header_data = compressed_header.data.clone();
+            }
+
            let difficulty = TotalDifficulty::new(total_difficulty);

            let header_size = compressed_header.data.len() + ENTRY_HEADER_SIZE;
@@ -216,12 +218,10 @@ where
            }
        }
        if blocks_written > 0 {
-            // Convert absolute offsets to relative (measured from block-index entry start)
-            let accumulator_entry_size = (ENTRY_HEADER_SIZE + 32) as i64;
-            let block_index_position = position + accumulator_entry_size;
-            let relative_offsets: Vec<i64> =
-                offsets.iter().map(|&abs| abs - block_index_position).collect();
-            let block_index = BlockIndex::new(start_block, relative_offsets);
+            let accumulator_hash =
+                B256::from_slice(&final_header_data[0..32.min(final_header_data.len())]);
+            let accumulator = Accumulator::new(accumulator_hash);
+            let block_index = BlockIndex::new(start_block, offsets);

            writer.write_accumulator(&accumulator)?;
            writer.write_block_index(&block_index)?;
@@ -310,9 +310,7 @@ where

    let compressed_header = CompressedHeader::from_header(&header)?;
    let compressed_body = CompressedBody::from_body(&body)?;
-    let receipts_with_bloom: Vec<_> =
-        receipts.iter().map(|r| TxReceipt::with_bloom_ref(r)).collect();
-    let compressed_receipts = CompressedReceipts::from_encodable_list(&receipts_with_bloom)
+    let compressed_receipts = CompressedReceipts::from_encodable_list(&receipts)
        .map_err(|e| eyre!("Failed to compress receipts: {}", e))?;

    Ok((compressed_header, compressed_body, compressed_receipts))
--- a/crates/era/Cargo.toml
+++ b/crates/era/Cargo.toml
@@ -24,7 +24,6 @@ snap.workspace = true
 # ssz encoding and decoding
 ethereum_ssz.workspace = true
 ethereum_ssz_derive.workspace = true
-sha2.workspace = true

 [dev-dependencies]
 eyre.workspace = true
--- a/crates/era/src/era1/types/execution.rs
+++ b/crates/era/src/era1/types/execution.rs
@@ -76,7 +76,6 @@ use crate::{
 use alloy_consensus::{Block, BlockBody, Header};
 use alloy_primitives::{B256, U256};
 use alloy_rlp::{Decodable, Encodable};
-use sha2::{Digest, Sha256};
 use snap::{read::FrameDecoder, write::FrameEncoder};
 use std::{
    io::{Read, Write},
@@ -494,73 +493,6 @@ impl Accumulator {

        Ok(Self { root: B256::from(root) })
    }
-
-    /// Compute the accumulator from a list of header records.
-    ///
-    /// Implements `hash_tree_root(List[HeaderRecord, 8192])` per the ERA1 spec:
-    /// - Each leaf is `sha256(block_hash || total_difficulty_le_bytes32)`
-    /// - Leaves are padded to `MAX_BLOCKS_PER_ERA1` (8192) with zero hashes
-    /// - Binary Merkle tree is computed bottom-up
-    /// - Final root is `sha256(merkle_root || le_bytes32(actual_count))`
-    ///
-    /// Returns `Err` if `records` exceeds [`MAX_BLOCKS_PER_ERA1`].
-    pub fn from_header_records(records: &[HeaderRecord]) -> Result<Self, E2sError> {
-        let capacity = MAX_BLOCKS_PER_ERA1;
-
-        if records.len() > capacity {
-            return Err(E2sError::Ssz(format!(
-                "Too many header records: got {}, max {}",
-                records.len(),
-                capacity
-            )));
-        }
-
-        // Compute leaf hash for each header record
-        let mut leaves = Vec::with_capacity(capacity);
-        for record in records {
-            let mut data = [0u8; 64];
-            data[..32].copy_from_slice(record.block_hash.as_slice());
-            data[32..].copy_from_slice(&record.total_difficulty.to_le_bytes::<32>());
-            leaves.push(<[u8; 32]>::from(Sha256::digest(data)));
-        }
-
-        // Pad to capacity with zero hashes
-        leaves.resize(capacity, [0u8; 32]);
-
-        // Binary Merkle tree bottom-up (capacity is always a power of two)
-        while leaves.len() > 1 {
-            let mut next_level = Vec::with_capacity(leaves.len() / 2);
-            for pair in leaves.chunks_exact(2) {
-                let mut data = [0u8; 64];
-                data[..32].copy_from_slice(&pair[0]);
-                data[32..].copy_from_slice(&pair[1]);
-                next_level.push(<[u8; 32]>::from(Sha256::digest(data)));
-            }
-            leaves = next_level;
-        }
-
-        let merkle_root = leaves[0];
-
-        // mix_in_length: sha256(merkle_root || le_bytes32(actual_length))
-        let mut mix = [0u8; 64];
-        mix[..32].copy_from_slice(&merkle_root);
-        let length = records.len() as u64;
-        mix[32..40].copy_from_slice(&length.to_le_bytes());
-        // remaining bytes stay zero (uint256 LE padding)
-
-        Ok(Self { root: B256::from(<[u8; 32]>::from(Sha256::digest(mix))) })
-    }
-}
-
-/// A header record used to compute the ERA1 accumulator.
-///
-/// Per the ERA1 spec: `header-record := { block-hash: Bytes32, total-difficulty: Uint256 }`
-#[derive(Debug, Clone)]
-pub struct HeaderRecord {
-    /// The block hash (keccak256 of RLP-encoded header)
-    pub block_hash: B256,
-    /// The cumulative total difficulty at this block
-    pub total_difficulty: U256,
 }

 /// A block tuple in an Era1 file, containing all components for a single block
@@ -759,44 +691,6 @@ mod tests {
        }
    }

-    #[test]
-    fn test_accumulator_from_header_records_known_vectors() {
-        // Known-answer vectors computed from the SSZ spec:
-        //   hash_tree_root(List[HeaderRecord, 8192])
-        let expected_empty: B256 =
-            "4a8c3a07c8d23adc5bac61157555c3c784d53d9bc110c1370809bd23cd93777d".parse().unwrap();
-        let expected_single_zero: B256 =
-            "81fd641249670887a731386e756a7a1538dc781b1b0bf016889045d350812817".parse().unwrap();
-        let expected_single_nonzero: B256 =
-            "ada35c48d81117f4fd588554cd4c4752356336e84cb41106dea1ceb4cfac8799".parse().unwrap();
-
-        // Empty list
-        let acc_empty = Accumulator::from_header_records(&[]).unwrap();
-        assert_eq!(acc_empty.root, expected_empty);
-
-        // Single record with zero values
-        let records = vec![HeaderRecord { block_hash: B256::ZERO, total_difficulty: U256::ZERO }];
-        let acc = Accumulator::from_header_records(&records).unwrap();
-        assert_eq!(acc.root, expected_single_zero);
-
-        // Single record with non-zero values
-        let records2 = vec![HeaderRecord {
-            block_hash: B256::from([1u8; 32]),
-            total_difficulty: U256::from(100u64),
-        }];
-        let acc2 = Accumulator::from_header_records(&records2).unwrap();
-        assert_eq!(acc2.root, expected_single_nonzero);
-    }
-
-    #[test]
-    fn test_accumulator_rejects_oversized_input() {
-        let records = vec![
-            HeaderRecord { block_hash: B256::ZERO, total_difficulty: U256::ZERO };
-            MAX_BLOCKS_PER_ERA1 + 1
-        ];
-        assert!(Accumulator::from_header_records(&records).is_err());
-    }
-
    #[test]
    fn test_receipt_list_compression() {
        let receipts = create_test_receipts();
--- a/crates/era/src/era1/types/group.rs
+++ b/crates/era/src/era1/types/group.rs
@@ -102,8 +102,8 @@ pub struct Era1Id {
    /// Number of blocks in the file
    pub block_count: u32,

-    /// Optional hash identifier for this file.
-    /// First 4 bytes of the accumulator root hash.
+    /// Optional hash identifier for this file
+    /// First 4 bytes of the last historical root in the last state in the era file
    pub hash: Option<[u8; 4]>,

    /// Whether to include era count in filename
--- a/crates/ethereum/node/Cargo.toml
+++ b/crates/ethereum/node/Cargo.toml
@@ -48,7 +48,7 @@ tokio.workspace = true

 # revm with required ethereum features
 # Note: this must be kept to ensure all features are properly enabled/forwarded
-revm = { workspace = true, features = ["secp256k1", "blst", "c-kzg", "memory_limit", "p256-aws-lc-rs"] }
+revm = { workspace = true, features = ["secp256k1", "blst", "c-kzg", "memory_limit"] }

 # misc
 eyre.workspace = true
--- a/crates/ethereum/node/tests/e2e/rpc.rs
+++ b/crates/ethereum/node/tests/e2e/rpc.rs
@@ -12,7 +12,7 @@ use alloy_rpc_types_eth::TransactionRequest;
 use rand::{rngs::StdRng, Rng, SeedableRng};
 use reth_chainspec::{ChainSpecBuilder, EthChainSpec, MAINNET};
 use reth_e2e_test_utils::setup_engine;
-use reth_network::{types::NatResolver, PeersInfo};
+use reth_network::types::NatResolver;
 use reth_node_builder::{NodeBuilder, NodeHandle};
 use reth_node_core::{
    args::{NetworkArgs, RpcServerArgs},
@@ -375,47 +375,3 @@ async fn test_admin_external_ip() -> eyre::Result<()> {

    Ok(())
 }
-
-#[tokio::test]
-async fn test_admin_node_info_uses_discv5_port_when_discv4_is_disabled() -> eyre::Result<()> {
-    reth_tracing::init_test_tracing();
-
-    let runtime = Runtime::test();
-
-    let genesis: Genesis = serde_json::from_str(include_str!("../assets/genesis.json")).unwrap();
-    let chain_spec =
-        Arc::new(ChainSpecBuilder::default().chain(MAINNET.chain).genesis(genesis).build());
-
-    let mut network = NetworkArgs::default().with_unused_ports();
-    network.bootnodes = Some(Vec::new());
-    network.discovery.disable_dns_discovery = true;
-    network.discovery.disable_discv4_discovery = true;
-    network = network.with_nat_resolver(NatResolver::ExternalIp("127.0.0.1".parse().unwrap()));
-
-    let node_config = NodeConfig::test()
-        .with_chain(chain_spec)
-        .with_network(network)
-        .with_rpc(RpcServerArgs::default().with_unused_ports().with_http());
-
-    let NodeHandle { node, node_exit_future: _ } = NodeBuilder::new(node_config)
-        .testing_node(runtime)
-        .node(EthereumNode::default())
-        .launch()
-        .await?;
-
-    assert!(node.network.discv4().is_none());
-    let discv5_port = node.network.discv5().expect("discv5 should be enabled").local_port();
-
-    let local_record = node.network.local_node_record();
-    let local_enr = node.network.local_enr();
-    let info = node.add_ons_handle.admin_api().node_info().await.unwrap();
-
-    assert_eq!(local_record.udp_port, discv5_port);
-    assert_eq!(local_enr.udp4(), Some(discv5_port));
-    assert_eq!(info.ports.discovery, discv5_port);
-    assert_eq!(info.ports.listener, local_record.tcp_port);
-    assert_eq!(info.enode, local_record.to_string());
-    assert!(info.enode.contains(&format!("?discport={discv5_port}")));
-
-    Ok(())
-}
--- a/crates/ethereum/payload/src/lib.rs
+++ b/crates/ethereum/payload/src/lib.rs
@@ -21,7 +21,6 @@ use reth_consensus_common::validation::MAX_RLP_BLOCK_SIZE;
 use reth_errors::{BlockExecutionError, BlockValidationError, ConsensusError};
 use reth_ethereum_primitives::{EthPrimitives, TransactionSigned};
 use reth_evm::{
-    block::TxResult,
    execute::{BlockBuilder, BlockBuilderOutcome, BlockExecutor},
    ConfigureEvm, Evm, NextBlockEnvAttributes,
 };
@@ -38,7 +37,7 @@ use reth_transaction_pool::{
    BestTransactions, BestTransactionsAttributes, PoolTransaction, TransactionPool,
    ValidPoolTransaction,
 };
-use revm::context_interface::{Block as _, Cfg as _};
+use revm::context_interface::Block as _;
 use std::sync::Arc;
 use tracing::{debug, trace, warn};

@@ -205,11 +204,8 @@ where
        .map_err(PayloadBuilderError::other)?;

    debug!(target: "payload_builder", id=%payload_id, parent_header = ?parent_header.hash(), parent_number = parent_header.number, "building new payload");
-    let mut cumulative_tx_gas_used = 0;
-    let mut block_regular_gas_used = 0;
-    let mut block_state_gas_used = 0;
+    let mut cumulative_gas_used = 0;
    let block_gas_limit: u64 = builder.evm_mut().block().gas_limit();
-    let tx_gas_limit_cap = builder.evm_mut().cfg_env().tx_gas_limit_cap();
    let base_fee = builder.evm_mut().block().basefee();

    let mut best_txs = best_txs(BestTransactionsAttributes::new(
@@ -254,34 +250,13 @@ where

    while let Some(pool_tx) = best_txs.next() {
        // ensure we still have capacity for this transaction
-        let exceeds_gas_limit = if is_amsterdam {
-            let regular_available_gas = block_gas_limit.saturating_sub(block_regular_gas_used);
-            let state_available_gas = block_gas_limit.saturating_sub(block_state_gas_used);
-            let regular_tx_gas_limit = pool_tx.gas_limit().min(tx_gas_limit_cap);
-
-            if regular_tx_gas_limit > regular_available_gas {
-                Some((regular_tx_gas_limit, regular_available_gas))
-            } else if pool_tx.gas_limit() > state_available_gas {
-                Some((pool_tx.gas_limit(), state_available_gas))
-            } else {
-                None
-            }
-        } else {
-            let block_available_gas = block_gas_limit.saturating_sub(cumulative_tx_gas_used);
-            (pool_tx.gas_limit() > block_available_gas)
-                .then_some((pool_tx.gas_limit(), block_available_gas))
-        };
-
-        if let Some((transaction_gas_limit, block_available_gas)) = exceeds_gas_limit {
+        if cumulative_gas_used + pool_tx.gas_limit() > block_gas_limit {
            // we can't fit this transaction into the block, so we need to mark it as invalid
            // which also removes all dependent transaction from the iterator before we can
            // continue
            best_txs.mark_invalid(
                &pool_tx,
-                &InvalidPoolTransactionError::ExceedsGasLimit(
-                    transaction_gas_limit,
-                    block_available_gas,
-                ),
+                &InvalidPoolTransactionError::ExceedsGasLimit(pool_tx.gas_limit(), block_gas_limit),
            );
            continue
        }
@@ -366,11 +341,8 @@ where
        let miner_fee = tx.effective_tip_per_gas(base_fee);
        let tx_hash = *tx.tx_hash();

-        let mut tx_regular_gas_used = 0;
-        let gas_output = match builder.execute_transaction_with_result_closure(tx, |result| {
-            tx_regular_gas_used = result.result().result.gas().block_regular_gas_used();
-        }) {
-            Ok(gas_output) => gas_output,
+        let gas_used = match builder.execute_transaction(tx) {
+            Ok(gas_used) => gas_used,
            Err(BlockExecutionError::Validation(BlockValidationError::InvalidTx {
                error, ..
            })) => {
@@ -390,8 +362,9 @@ where
                }
                continue
            }
-            // The executor is the source of truth for block gas availability. Keep this
-            // non-fatal in case local builder accounting diverges from executor rules.
+            // EIP-7778: the executor tracks gas_before_refund while the payload builder's
+            // pre-check uses gas_after_refund. Near-full blocks can pass the pre-check but
+            // fail the executor's check. Skip the tx and continue building.
            Err(BlockExecutionError::Validation(
                BlockValidationError::TransactionGasLimitMoreThanAvailableBlockGas {
                    transaction_gas_limit,
@@ -425,12 +398,9 @@ where
        block_transactions_rlp_length += tx_rlp_len;

        // update and add to total fees
-        let gas_used = gas_output.tx_gas_used();
        let miner_fee = miner_fee.expect("fee is always valid; execution succeeded");
        total_fees += U256::from(miner_fee) * U256::from(gas_used);
-        cumulative_tx_gas_used += gas_used;
-        block_regular_gas_used += tx_regular_gas_used;
-        block_state_gas_used += gas_output.state_gas_used();
+        cumulative_gas_used += gas_used;

        // Add blob tx sidecar to the payload.
        if let Some(sidecar) = blob_tx_sidecar {
--- a/crates/evm/evm/src/aliases.rs
+++ b/crates/evm/evm/src/aliases.rs
@@ -1,11 +1,8 @@
 //! Helper aliases when working with [`ConfigureEvm`] and the traits in this crate.

 use crate::ConfigureEvm;
-use alloy_evm::{
-    block::{BlockExecutorFactory, BlockExecutorFor},
-    Database, EvmEnv, EvmFactory,
-};
-use revm::{database::State, inspector::NoOpInspector, Inspector};
+use alloy_evm::{block::BlockExecutorFactory, Database, EvmEnv, EvmFactory};
+use revm::{inspector::NoOpInspector, Inspector};

 /// Helper to access [`EvmFactory`] for a given [`ConfigureEvm`].
 pub type EvmFactoryFor<Evm> =
@@ -36,10 +33,6 @@ pub type TxEnvFor<Evm> = <EvmFactoryFor<Evm> as EvmFactory>::Tx;
 pub type ExecutionCtxFor<'a, Evm> =
    <<Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::ExecutionCtx<'a>;

-/// Helper to access [`alloy_evm::block::BlockExecutor`] for a given [`ConfigureEvm`].
-pub type BlockExecutorForEvm<'a, Evm, DB, I = NoOpInspector> =
-    BlockExecutorFor<'a, <Evm as ConfigureEvm>::BlockExecutorFactory, &'a mut State<DB>, I>;
-
 /// Type alias for [`EvmEnv`] for a given [`ConfigureEvm`].
 pub type EvmEnvFor<Evm> = EvmEnv<SpecFor<Evm>, BlockEnvFor<Evm>>;

--- a/crates/evm/evm/src/execute.rs
+++ b/crates/evm/evm/src/execute.rs
@@ -4,7 +4,7 @@ use crate::{ConfigureEvm, Database, OnStateHook, TxEnvFor};
 use alloc::{boxed::Box, sync::Arc, vec::Vec};
 use alloy_consensus::{BlockHeader, Header};
 use alloy_eips::eip2718::WithEncoded;
-pub use alloy_evm::block::{BlockExecutor, BlockExecutorFactory, GasOutput};
+pub use alloy_evm::block::{BlockExecutor, BlockExecutorFactory};
 use alloy_evm::{
    block::{CommitChanges, ExecutableTxParts},
    Evm, EvmEnv, EvmFactory, RecoveredTx, ToTxEnv,
@@ -327,7 +327,7 @@ pub trait BlockBuilder {
        &mut self,
        tx: impl ExecutorTx<Self::Executor>,
        f: impl FnOnce(&<Self::Executor as BlockExecutor>::Result) -> CommitChanges,
-    ) -> Result<Option<GasOutput>, BlockExecutionError>;
+    ) -> Result<Option<u64>, BlockExecutionError>;

    /// Invokes [`BlockExecutor::execute_transaction_with_result_closure`] and saves the
    /// transaction in internal state.
@@ -335,7 +335,7 @@ pub trait BlockBuilder {
        &mut self,
        tx: impl ExecutorTx<Self::Executor>,
        f: impl FnOnce(&<Self::Executor as BlockExecutor>::Result),
-    ) -> Result<GasOutput, BlockExecutionError> {
+    ) -> Result<u64, BlockExecutionError> {
        self.execute_transaction_with_commit_condition(tx, |res| {
            f(res);
            CommitChanges::Yes
@@ -348,7 +348,7 @@ pub trait BlockBuilder {
    fn execute_transaction(
        &mut self,
        tx: impl ExecutorTx<Self::Executor>,
-    ) -> Result<GasOutput, BlockExecutionError> {
+    ) -> Result<u64, BlockExecutionError> {
        self.execute_transaction_with_result_closure(tx, |_| ())
    }

@@ -460,13 +460,13 @@ where
        &mut self,
        tx: impl ExecutorTx<Self::Executor>,
        f: impl FnOnce(&<Self::Executor as BlockExecutor>::Result) -> CommitChanges,
-    ) -> Result<Option<GasOutput>, BlockExecutionError> {
+    ) -> Result<Option<u64>, BlockExecutionError> {
        let (tx_env, tx) = tx.into_parts();
        if let Some(gas_used) =
            self.executor.execute_transaction_with_commit_condition((tx_env, &tx), f)?
        {
            self.transactions.push(tx);
-            Ok(Some(gas_used))
+            Ok(Some(gas_used.tx_gas_used()))
        } else {
            Ok(None)
        }
--- a/crates/evm/evm/src/lib.rs
+++ b/crates/evm/evm/src/lib.rs
@@ -20,7 +20,10 @@ extern crate alloc;
 use crate::execute::{BasicBlockBuilder, Executor};
 use alloc::vec::Vec;
 use alloy_eips::eip4895::Withdrawals;
-use alloy_evm::{block::BlockExecutorFactory, precompiles::PrecompilesMap};
+use alloy_evm::{
+    block::{BlockExecutorFactory, BlockExecutorFor},
+    precompiles::PrecompilesMap,
+};
 use alloy_primitives::{Address, Bytes, B256};
 use core::{error::Error, fmt::Debug};
 use execute::{BasicBlockExecutor, BlockAssembler, BlockBuilder};
@@ -309,7 +312,7 @@ pub trait ConfigureEvm: Clone + Debug + Send + Sync + Unpin {
        &'a self,
        evm: EvmFor<Self, &'a mut State<DB>, I>,
        ctx: <Self::BlockExecutorFactory as BlockExecutorFactory>::ExecutionCtx<'a>,
-    ) -> BlockExecutorForEvm<'a, Self, DB, I>
+    ) -> impl BlockExecutorFor<'a, Self::BlockExecutorFactory, &'a mut State<DB>, I>
    where
        DB: Database,
        I: InspectorFor<Self, &'a mut State<DB>> + 'a,
@@ -322,7 +325,8 @@ pub trait ConfigureEvm: Clone + Debug + Send + Sync + Unpin {
        &'a self,
        db: &'a mut State<DB>,
        block: &'a SealedBlock<<Self::Primitives as NodePrimitives>::Block>,
-    ) -> Result<BlockExecutorForEvm<'a, Self, DB>, Self::Error> {
+    ) -> Result<impl BlockExecutorFor<'a, Self::BlockExecutorFactory, &'a mut State<DB>>, Self::Error>
+    {
        let evm = self.evm_for_block(db, block.header())?;
        let ctx = self.context_for_block(block)?;
        Ok(self.create_executor(evm, ctx))
@@ -348,7 +352,10 @@ pub trait ConfigureEvm: Clone + Debug + Send + Sync + Unpin {
        evm: EvmFor<Self, &'a mut State<DB>, I>,
        parent: &'a SealedHeader<HeaderTy<Self::Primitives>>,
        ctx: <Self::BlockExecutorFactory as BlockExecutorFactory>::ExecutionCtx<'a>,
-    ) -> impl BlockBuilder<Primitives = Self::Primitives, Executor = BlockExecutorForEvm<'a, Self, DB, I>>
+    ) -> impl BlockBuilder<
+        Primitives = Self::Primitives,
+        Executor: BlockExecutorFor<'a, Self::BlockExecutorFactory, &'a mut State<DB>, I>,
+    >
    where
        DB: Database,
        I: InspectorFor<Self, &'a mut State<DB>> + 'a,
@@ -397,7 +404,10 @@ pub trait ConfigureEvm: Clone + Debug + Send + Sync + Unpin {
        parent: &'a SealedHeader<<Self::Primitives as NodePrimitives>::BlockHeader>,
        attributes: Self::NextBlockEnvCtx,
    ) -> Result<
-        impl BlockBuilder<Primitives = Self::Primitives, Executor = BlockExecutorForEvm<'a, Self, DB>>,
+        impl BlockBuilder<
+            Primitives = Self::Primitives,
+            Executor: BlockExecutorFor<'a, Self::BlockExecutorFactory, &'a mut State<DB>>,
+        >,
        Self::Error,
    > {
        let evm_env = self.next_evm_env(parent, &attributes)?;
--- a/crates/metrics/Cargo.toml
+++ b/crates/metrics/Cargo.toml
@@ -16,13 +16,10 @@ workspace = true
 metrics.workspace = true
 metrics-derive.workspace = true

-# reth
-reth-primitives-traits = { workspace = true, optional = true }
-
 # async
 tokio = { workspace = true, features = ["full"], optional = true }
 futures = { workspace = true, optional = true }
 tokio-util = { workspace = true, optional = true }

 [features]
-common = ["tokio", "futures", "tokio-util", "reth-primitives-traits"]
+common = ["tokio", "futures", "tokio-util"]
--- a/crates/metrics/src/common/mpsc.rs
+++ b/crates/metrics/src/common/mpsc.rs
@@ -4,13 +4,8 @@
 use crate::Metrics;
 use futures::Stream;
 use metrics::Counter;
-use reth_primitives_traits::InMemorySize;
 use std::{
    pin::Pin,
-    sync::{
-        atomic::{AtomicUsize, Ordering},
-        Arc,
-    },
    task::{ready, Context, Poll},
 };
 use tokio::sync::mpsc::{
@@ -404,147 +399,3 @@ struct MeteredPollSenderMetrics {
    /// Number of delayed message deliveries caused by a full channel
    back_pressure_total: Counter,
 }
-
-/// Shared state for tracking memory budget across sender and receiver.
-///
-/// `used` is a pure accounting counter — it does not gate access to any other
-/// shared memory, so all operations on it use [`Ordering::Relaxed`]. Cross-thread
-/// publication of message contents is handled by the underlying mpsc channel.
-#[derive(Debug)]
-struct MemoryBudget {
-    /// Current number of bytes used by buffered messages.
-    used: AtomicUsize,
-    /// Maximum allowed bytes.
-    max_bytes: usize,
-}
-
-/// Guard that releases memory budget when dropped.
-///
-/// Holds the size of the message and a reference to the shared budget counter.
-/// When dropped, it atomically decreases the used counter.
-#[derive(Debug)]
-struct BudgetGuard {
-    size: usize,
-    budget: Arc<MemoryBudget>,
-}
-
-impl Drop for BudgetGuard {
-    fn drop(&mut self) {
-        self.budget.used.fetch_sub(self.size, Ordering::Relaxed);
-    }
-}
-
-/// Message envelope that holds the memory budget while the message sits in the channel.
-///
-/// The guard is dropped (releasing the budget) as soon as the receiver dequeues
-/// the message via [`MemoryBoundedReceiver::recv`] / [`MemoryBoundedReceiver::poll_recv`],
-/// so the budget tracks bytes *currently in the channel queue*, not bytes in flight
-/// downstream of the receiver.
-#[derive(Debug)]
-struct Budgeted<T> {
-    msg: T,
-    _guard: BudgetGuard,
-}
-
-/// A sender that enforces a byte budget before enqueueing messages.
-///
-/// Uses a shared atomic counter to track memory usage. Each message's size is added
-/// to the counter on send and subtracted when the message is dequeued by the receiver.
-///
-/// The current call sites (specifically [`crate::common::mpsc::MemoryBoundedSender`] used
-/// for the `NetworkManager → TransactionsManager` channel) have a single producer driven
-/// from a single `poll`, so the `fetch_add → check → fetch_sub-on-overflow` reservation
-/// pattern can never race with itself. The atomic is still used so the receiver can
-/// release budget from a different task.
-#[derive(Debug, Clone)]
-pub struct MemoryBoundedSender<T: InMemorySize> {
-    /// The underlying unbounded metered sender
-    inner: UnboundedMeteredSender<Budgeted<T>>,
-    /// Shared memory budget tracker
-    budget: Arc<MemoryBudget>,
-}
-
-impl<T: InMemorySize> MemoryBoundedSender<T> {
-    /// Tries to send a message if there is sufficient budget.
-    ///
-    /// Returns `TrySendError::Full` if insufficient budget is available.
-    pub fn try_send(&self, msg: T) -> Result<(), TrySendError<T>> {
-        let size = msg.size();
-
-        // Reserve budget: add first, check after
-        let prev = self.budget.used.fetch_add(size, Ordering::Relaxed);
-        if prev.saturating_add(size) > self.budget.max_bytes {
-            // Over budget, undo
-            self.budget.used.fetch_sub(size, Ordering::Relaxed);
-            return Err(TrySendError::Full(msg));
-        }
-
-        let guard = BudgetGuard { size, budget: Arc::clone(&self.budget) };
-        let budgeted = Budgeted { msg, _guard: guard };
-
-        self.inner.send(budgeted).map_err(|e| {
-            // Guard will be dropped here, releasing the budget
-            TrySendError::Closed(e.0.msg)
-        })
-    }
-}
-
-/// A receiver for memory-bounded messages.
-///
-/// On receive, the budget reserved for the message is released immediately and the
-/// inner `T` is yielded — callers do not need to opt into any wrapper type.
-#[derive(Debug)]
-pub struct MemoryBoundedReceiver<T> {
-    /// The underlying unbounded metered receiver
-    inner: UnboundedMeteredReceiver<Budgeted<T>>,
-}
-
-impl<T> MemoryBoundedReceiver<T> {
-    /// Receives the next message, returning `None` if the channel is closed.
-    ///
-    /// Releases the message's reserved budget before returning.
-    pub async fn recv(&mut self) -> Option<T> {
-        self.inner.recv().await.map(unwrap_budgeted)
-    }
-
-    /// Polls to receive the next message on this channel.
-    ///
-    /// Releases the message's reserved budget before returning.
-    pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<T>> {
-        self.inner.poll_recv(cx).map(|opt| opt.map(unwrap_budgeted))
-    }
-}
-
-/// Releases the budget guard and returns the inner message.
-fn unwrap_budgeted<T>(b: Budgeted<T>) -> T {
-    // Destructuring binds `_guard` so it is dropped when this function returns,
-    // which runs `BudgetGuard::drop` and releases the reserved bytes.
-    let Budgeted { msg, _guard } = b;
-    msg
-}
-
-impl<T> Stream for MemoryBoundedReceiver<T> {
-    type Item = T;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.poll_recv(cx)
-    }
-}
-
-/// Creates a new memory-bounded channel with the given byte budget.
-///
-/// The budget tracks bytes currently buffered in the channel; it is reserved on
-/// [`MemoryBoundedSender::try_send`] and released as soon as the receiver dequeues
-/// the message.
-pub fn memory_bounded_channel<T: InMemorySize>(
-    max_bytes: usize,
-    scope: &'static str,
-) -> (MemoryBoundedSender<T>, MemoryBoundedReceiver<T>) {
-    let (tx, rx) = metered_unbounded_channel(scope);
-    let budget = Arc::new(MemoryBudget { used: AtomicUsize::new(0), max_bytes });
-
-    let sender = MemoryBoundedSender { inner: tx, budget };
-    let receiver = MemoryBoundedReceiver { inner: rx };
-
-    (sender, receiver)
-}
--- a/crates/net/discv4/src/lib.rs
+++ b/crates/net/discv4/src/lib.rs
@@ -47,7 +47,9 @@ use secp256k1::SecretKey;
 use std::{
    cell::RefCell,
    collections::{btree_map, hash_map::Entry, BTreeMap, HashMap, VecDeque},
-    fmt, io,
+    fmt,
+    future::poll_fn,
+    io,
    net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4},
    pin::Pin,
    rc::Rc,
@@ -241,56 +243,17 @@ impl Discv4 {
    /// ```
    pub async fn bind(
        local_address: SocketAddr,
-        local_node_record: NodeRecord,
-        secret_key: SecretKey,
-        config: Discv4Config,
-    ) -> io::Result<(Self, Discv4Service)> {
-        let socket = Arc::new(UdpSocket::bind(local_address).await?);
-        trace!(target: "discv4", local_addr=?socket.local_addr(), "opened UDP socket");
-        let (tx, rx) = mpsc::channel(config.udp_ingress_message_buffer);
-
-        Self::bind_with_socket(socket, Some(tx), rx, local_node_record, secret_key, config)
-    }
-
-    /// Creates a new `Discv4` instance using a pre-bound shared socket. No receive loop is
-    /// spawned; instead returns an [`IngressHandler`] that should be used to forward raw packets
-    /// received by the socket owner (e.g. discv5 unrecognized frames).
-    pub fn bind_shared(
-        socket: Arc<UdpSocket>,
-        local_node_record: NodeRecord,
-        secret_key: SecretKey,
-        config: Discv4Config,
-    ) -> io::Result<(Self, Discv4Service, IngressHandler)> {
-        let (tx, rx) = mpsc::channel(config.udp_ingress_message_buffer);
-        let local_id = local_node_record.id;
-        let (discv4, service) =
-            Self::bind_with_socket(socket, None, rx, local_node_record, secret_key, config)?;
-
-        let handler = IngressHandler::new(tx, local_id);
-
-        Ok((discv4, service, handler))
-    }
-
-    fn bind_with_socket(
-        socket: Arc<UdpSocket>,
-        ingress_tx: Option<IngressSender>,
-        ingress_rx: IngressReceiver,
        mut local_node_record: NodeRecord,
        secret_key: SecretKey,
        config: Discv4Config,
    ) -> io::Result<(Self, Discv4Service)> {
+        let socket = UdpSocket::bind(local_address).await?;
        let local_addr = socket.local_addr()?;
        local_node_record.udp_port = local_addr.port();
+        trace!(target: "discv4", ?local_addr,"opened UDP socket");

-        let mut service = Discv4Service::new(
-            socket,
-            ingress_tx,
-            ingress_rx,
-            local_addr,
-            local_node_record,
-            secret_key,
-            config,
-        );
+        let mut service =
+            Discv4Service::new(socket, local_addr, local_node_record, secret_key, config);

        // resolve the external address immediately
        service.resolve_external_ip();
@@ -557,25 +520,20 @@ pub struct Discv4Service {

 impl Discv4Service {
    /// Create a new instance for a bound [`UdpSocket`].
-    ///
-    /// If `ingress_tx` is `Some`, the receive loop is spawned to read from the socket. If `None`,
-    /// the caller feeds packets into `ingress_rx` externally (shared socket mode).
    pub(crate) fn new(
-        socket: Arc<UdpSocket>,
-        ingress_tx: Option<IngressSender>,
-        ingress_rx: IngressReceiver,
+        socket: UdpSocket,
        local_address: SocketAddr,
        local_node_record: NodeRecord,
        secret_key: SecretKey,
        config: Discv4Config,
    ) -> Self {
+        let socket = Arc::new(socket);
+        let (ingress_tx, ingress_rx) = mpsc::channel(config.udp_ingress_message_buffer);
        let (egress_tx, egress_rx) = mpsc::channel(config.udp_egress_message_buffer);
        let mut tasks = JoinSet::<()>::new();

-        if let Some(ingress_tx) = ingress_tx {
-            let udp = Arc::clone(&socket);
-            tasks.spawn(receive_loop(udp, ingress_tx, local_node_record.id));
-        }
+        let udp = Arc::clone(&socket);
+        tasks.spawn(receive_loop(udp, ingress_tx, local_node_record.id));

        let udp = Arc::clone(&socket);
        tasks.spawn(send_loop(udp, egress_rx));
@@ -989,7 +947,7 @@ impl Discv4Service {
        let key = kad_key(peer_id);
        match self.kbuckets.entry(&key) {
            BucketEntry::Present(entry, _) => Some(f(entry.value())),
-            BucketEntry::Pending(entry, _) => Some(f(entry.value())),
+            BucketEntry::Pending(mut entry, _) => Some(f(entry.value())),
            _ => None,
        }
    }
@@ -1015,9 +973,7 @@ impl Discv4Service {
            kbucket::Entry::Present(mut entry, _) => {
                entry.value_mut().update_with_enr(last_enr_seq)
            }
-            kbucket::Entry::Pending(mut entry, _) => {
-                entry.value_mut().update_with_enr(last_enr_seq)
-            }
+            kbucket::Entry::Pending(mut entry, _) => entry.value().update_with_enr(last_enr_seq),
            _ => return,
        };

@@ -1069,8 +1025,8 @@ impl Discv4Service {
            }
            kbucket::Entry::Pending(mut entry, mut status) => {
                // endpoint is now proven
-                entry.value_mut().establish_proof();
-                entry.value_mut().update_with_enr(last_enr_seq);
+                entry.value().establish_proof();
+                entry.value().update_with_enr(last_enr_seq);

                if !status.is_connected() {
                    status.state = ConnectionState::Connected;
@@ -1202,7 +1158,7 @@ impl Discv4Service {
                } else {
                    is_proven = entry.value().has_endpoint_proof;
                }
-                entry.value_mut().update_with_enr(ping.enr_sq)
+                entry.value().update_with_enr(ping.enr_sq)
            }
            kbucket::Entry::Absent(entry) => {
                let mut node = NodeEntry::new(record);
@@ -1432,7 +1388,7 @@ impl Discv4Service {
                        (entry.value().record, id)
                    }
                    kbucket::Entry::Pending(mut entry, _) => {
-                        let id = entry.value_mut().update_with_fork_id(fork_id);
+                        let id = entry.value().update_with_fork_id(fork_id);
                        (entry.value().record, id)
                    }
                    _ => return,
@@ -1582,7 +1538,7 @@ impl Discv4Service {
                        }
                    }
                }
-                BucketEntry::Pending(entry, _) => {
+                BucketEntry::Pending(mut entry, _) => {
                    if entry.value().has_endpoint_proof {
                        if entry
                            .value()
@@ -1686,7 +1642,7 @@ impl Discv4Service {
                    entry.value().find_node_failures
                }
                kbucket::Entry::Pending(mut entry, _) => {
-                    entry.value_mut().inc_failed_request();
+                    entry.value().inc_failed_request();
                    entry.value().find_node_failures
                }
                _ => continue,
@@ -2006,100 +1962,80 @@ const MAX_INCOMING_PACKETS_PER_MINUTE_BY_IP: usize = 60usize;

 /// Continuously awaits new incoming messages and sends them back through the channel.
 ///
-/// The receive loop enforces primitive rate limiting for IPs to prevent message spams from
-/// individual IPs.
+/// The receive loop enforce primitive rate limiting for ips to prevent message spams from
+/// individual IPs
 pub(crate) async fn receive_loop(udp: Arc<UdpSocket>, tx: IngressSender, local_id: PeerId) {
-    let mut handler = IngressHandler::new(tx, local_id);
+    let send = |event: IngressEvent| async {
+        let _ = tx.send(event).await.map_err(|err| {
+            debug!(
+                target: "discv4",
+                 %err,
+                "failed send incoming packet",
+            )
+        });
+    };
+
+    let mut cache = ReceiveCache::default();
+
+    // tick at half the rate of the limit
+    let tick = MAX_INCOMING_PACKETS_PER_MINUTE_BY_IP / 2;
+    let mut interval = tokio::time::interval(Duration::from_secs(tick as u64));
+
    let mut buf = [0; MAX_PACKET_SIZE];
    loop {
        let res = udp.recv_from(&mut buf).await;
        match res {
            Err(err) => {
                debug!(target: "discv4", %err, "Failed to read datagram.");
-                handler.send(IngressEvent::RecvError(err)).await;
+                send(IngressEvent::RecvError(err)).await;
            }
            Ok((read, remote_addr)) => {
-                handler.handle_packet(&buf[..read], remote_addr).await;
-            }
-        }
-    }
-}
-
-/// Handles decoding, rate-limiting, and deduplication of incoming discv4 packets.
-///
-/// Used by both the standalone receive loop and the shared-port mode via
-/// [`Discv4::bind_shared`].
-#[derive(Debug)]
-pub struct IngressHandler {
-    tx: IngressSender,
-    local_id: PeerId,
-    tick: usize,
-    tick_interval: Duration,
-    cache: ReceiveCache,
-    last_tick: Instant,
-}
-
-impl IngressHandler {
-    fn new(tx: IngressSender, local_id: PeerId) -> Self {
-        let tick = MAX_INCOMING_PACKETS_PER_MINUTE_BY_IP / 2;
-        Self {
-            tx,
-            local_id,
-            tick,
-            tick_interval: Duration::from_secs(tick as u64),
-            cache: ReceiveCache::default(),
-            last_tick: Instant::now(),
-        }
-    }
-
-    async fn send(&self, event: IngressEvent) {
-        let _ = self.tx.send(event).await.map_err(|err| {
-            debug!(target: "discv4", %err, "failed send incoming packet");
-        });
-    }
-
-    /// Handles an incoming raw packet: decodes, rate-limits, deduplicates, and forwards to the
-    /// discv4 service. Used in shared-port mode to process unrecognized frames from discv5.
-    pub async fn handle_packet(&mut self, data: &[u8], src: SocketAddr) {
-        if self.last_tick.elapsed() >= self.tick_interval {
-            self.cache.tick_ips(self.tick);
-            self.last_tick = Instant::now();
-        }
-
-        // rate limit incoming packets by IP
-        if self.cache.inc_ip(src.ip()) > MAX_INCOMING_PACKETS_PER_MINUTE_BY_IP {
-            trace!(target: "discv4", ?src, "Too many incoming packets from IP.");
-            return
-        }
-
-        let event = match Message::decode(data) {
-            Ok(packet) => {
-                if packet.node_id == self.local_id {
-                    debug!(target: "discv4", ?src, "Received own packet.");
-                    return
+                // rate limit incoming packets by IP
+                if cache.inc_ip(remote_addr.ip()) > MAX_INCOMING_PACKETS_PER_MINUTE_BY_IP {
+                    trace!(target: "discv4", ?remote_addr, "Too many incoming packets from IP.");
+                    continue
                }

-                if self.cache.contains_packet(packet.hash) {
-                    debug!(target: "discv4", ?src, "Received duplicate packet.");
-                    return
+                let packet = &buf[..read];
+                match Message::decode(packet) {
+                    Ok(packet) => {
+                        if packet.node_id == local_id {
+                            // received our own message
+                            debug!(target: "discv4", ?remote_addr, "Received own packet.");
+                            continue
+                        }
+
+                        // skip if we've already received the same packet
+                        if cache.contains_packet(packet.hash) {
+                            debug!(target: "discv4", ?remote_addr, "Received duplicate packet.");
+                            continue
+                        }
+
+                        send(IngressEvent::Packet(remote_addr, packet)).await;
+                    }
+                    Err(err) => {
+                        trace!(target: "discv4", %err,"Failed to decode packet");
+                        send(IngressEvent::BadPacket(remote_addr, err, packet.to_vec())).await
+                    }
                }
-
-                IngressEvent::Packet(src, packet)
            }
-            Err(err) => {
-                trace!(target: "discv4", %err, "Failed to decode packet");
-                IngressEvent::BadPacket(src, err, data.to_vec())
-            }
-        };
+        }

-        self.send(event).await;
+        // reset the tracked ips if the interval has passed
+        if poll_fn(|cx| match interval.poll_tick(cx) {
+            Poll::Ready(_) => Poll::Ready(true),
+            Poll::Pending => Poll::Ready(false),
+        })
+        .await
+        {
+            cache.tick_ips(tick);
+        }
    }
 }

 /// A cache for received packets and their source address.
 ///
 /// This is used to discard duplicated packets and rate limit messages from the same source.
-#[derive(Debug)]
 struct ReceiveCache {
    /// keeps track of how many messages we've received from a given IP address since the last
    /// tick.
--- a/crates/net/discv5/src/config.rs
+++ b/crates/net/discv5/src/config.rs
@@ -308,18 +308,6 @@ impl Config {
        }
    }

-    /// Returns a mutable reference to the inner [`discv5::Config`]. This allows overriding
-    /// the listen config after the config has been built.
-    pub const fn discv5_config_mut(&mut self) -> &mut discv5::Config {
-        &mut self.discv5_config
-    }
-
-    /// Returns `true` if any socket in the discv5 listen config matches the given address.
-    pub fn has_matching_socket(&self, addr: SocketAddr) -> bool {
-        ipv4(&self.discv5_config.listen_config).is_some_and(|v4| SocketAddr::V4(v4) == addr) ||
-            ipv6(&self.discv5_config.listen_config).is_some_and(|v6| SocketAddr::V6(v6) == addr)
-    }
-
    /// Inserts a new boot node to the list of boot nodes.
    pub fn insert_boot_node(&mut self, boot_node: BootNode) {
        self.bootstrap_nodes.insert(boot_node);
@@ -345,11 +333,11 @@ impl Config {
    /// socket, if both IPv4 and v6 are configured. This socket will be advertised to peers in the
    /// local [`Enr`](discv5::enr::Enr).
    pub fn discovery_socket(&self) -> SocketAddr {
-        // Prefer v6 when both are configured (matches original `DualStack` behavior).
-        ipv6(&self.discv5_config.listen_config)
-            .map(SocketAddr::V6)
-            .or_else(|| ipv4(&self.discv5_config.listen_config).map(SocketAddr::V4))
-            .unwrap_or_else(|| SocketAddr::from((std::net::Ipv4Addr::UNSPECIFIED, 0)))
+        match self.discv5_config.listen_config {
+            ListenConfig::Ipv4 { ip, port } => (ip, port).into(),
+            ListenConfig::Ipv6 { ip, port } => (ip, port).into(),
+            ListenConfig::DualStack { ipv6, ipv6_port, .. } => (ipv6, ipv6_port).into(),
+        }
    }

    /// Returns the `RLPx` (TCP) socket contained in the [`discv5::Config`]. This socket will be
@@ -360,32 +348,24 @@ impl Config {
 }

 /// Returns the IPv4 discovery socket if one is configured.
-pub fn ipv4(listen_config: &ListenConfig) -> Option<SocketAddrV4> {
+pub const fn ipv4(listen_config: &ListenConfig) -> Option<SocketAddrV4> {
    match listen_config {
        ListenConfig::Ipv4 { ip, port } |
        ListenConfig::DualStack { ipv4: ip, ipv4_port: port, .. } => {
            Some(SocketAddrV4::new(*ip, *port))
        }
-        ListenConfig::FromSockets { ipv4: Some(s), .. } => match s.local_addr().ok()? {
-            SocketAddr::V4(addr) => Some(addr),
-            SocketAddr::V6(_) => None,
-        },
-        _ => None,
+        ListenConfig::Ipv6 { .. } => None,
    }
 }

 /// Returns the IPv6 discovery socket if one is configured.
-pub fn ipv6(listen_config: &ListenConfig) -> Option<SocketAddrV6> {
+pub const fn ipv6(listen_config: &ListenConfig) -> Option<SocketAddrV6> {
    match listen_config {
+        ListenConfig::Ipv4 { .. } => None,
        ListenConfig::Ipv6 { ip, port } |
        ListenConfig::DualStack { ipv6: ip, ipv6_port: port, .. } => {
            Some(SocketAddrV6::new(*ip, *port, 0, 0))
        }
-        ListenConfig::FromSockets { ipv6: Some(s), .. } => match s.local_addr().ok()? {
-            SocketAddr::V6(addr) => Some(addr),
-            SocketAddr::V4(_) => None,
-        },
-        _ => None,
    }
 }

--- a/crates/net/discv5/src/lib.rs
+++ b/crates/net/discv5/src/lib.rs
@@ -18,6 +18,7 @@ use std::{

 use ::enr::Enr;
 use alloy_primitives::bytes::Bytes;
+use discv5::ListenConfig;
 use enr::{discv4_id_to_discv5_id, EnrCombinedKeyWrapper};
 use futures::future::join_all;
 use itertools::Itertools;
@@ -224,7 +225,7 @@ impl Discv5 {
            bootstrap_lookup_interval,
            bootstrap_lookup_countdown,
            metrics.clone(),
-            Arc::downgrade(&discv5),
+            discv5.clone(),
        );

        Ok((
@@ -246,9 +247,7 @@ impl Discv5 {
        match update {
            discv5::Event::SocketUpdated(_) | discv5::Event::TalkRequest(_) |
            // `Discovered` not unique discovered peers
-            discv5::Event::Discovered(_) |
-            // Unrecognized frames are handled separately by the discovery layer
-            discv5::Event::UnrecognizedFrame(_) => None,
+            discv5::Event::Discovered(_) => None,
            discv5::Event::NodeInserted { .. } => {

                // node has been inserted into kbuckets
@@ -473,33 +472,39 @@ pub fn build_local_enr(

    let Config { discv5_config, fork, tcp_socket, other_enr_kv_pairs, .. } = config;

-    let socket = {
-        let v4 = crate::config::ipv4(&discv5_config.listen_config);
-        let v6 = crate::config::ipv6(&discv5_config.listen_config);
-
-        if let Some(addr) = v4 {
-            if *addr.ip() != Ipv4Addr::UNSPECIFIED {
-                builder.ip4(*addr.ip());
+    let socket = match discv5_config.listen_config {
+        ListenConfig::Ipv4 { ip, port } => {
+            if ip != Ipv4Addr::UNSPECIFIED {
+                builder.ip4(ip);
            }
-            builder.udp4(addr.port());
-        }
-        if let Some(addr) = v6 {
-            if *addr.ip() != Ipv6Addr::UNSPECIFIED {
-                builder.ip6(*addr.ip());
-            }
-            builder.udp6(addr.port());
-        }
-        // Advertise tcp4 when v4 is configured, else tcp6.
-        if v4.is_some() {
+            builder.udp4(port);
            builder.tcp4(tcp_socket.port());
-        } else if v6.is_some() {
-            builder.tcp6(tcp_socket.port());
-        }

-        // Prefer v6 when both are configured
-        v6.map(SocketAddr::V6)
-            .or_else(|| v4.map(SocketAddr::V4))
-            .unwrap_or_else(|| SocketAddr::from((Ipv4Addr::UNSPECIFIED, 0)))
+            (ip, port).into()
+        }
+        ListenConfig::Ipv6 { ip, port } => {
+            if ip != Ipv6Addr::UNSPECIFIED {
+                builder.ip6(ip);
+            }
+            builder.udp6(port);
+            builder.tcp6(tcp_socket.port());
+
+            (ip, port).into()
+        }
+        ListenConfig::DualStack { ipv4, ipv4_port, ipv6, ipv6_port } => {
+            if ipv4 != Ipv4Addr::UNSPECIFIED {
+                builder.ip4(ipv4);
+            }
+            builder.udp4(ipv4_port);
+            builder.tcp4(tcp_socket.port());
+
+            if ipv6 != Ipv6Addr::UNSPECIFIED {
+                builder.ip6(ipv6);
+            }
+            builder.udp6(ipv6_port);
+
+            (ipv6, ipv6_port).into()
+        }
    };

    let rlpx_ip_mode = if tcp_socket.is_ipv4() { IpMode::Ip4 } else { IpMode::Ip6 };
@@ -568,19 +573,14 @@ pub fn spawn_populate_kbuckets_bg(
    bootstrap_lookup_interval: u64,
    bootstrap_lookup_countdown: u64,
    metrics: Discv5Metrics,
-    discv5: std::sync::Weak<discv5::Discv5>,
+    discv5: Arc<discv5::Discv5>,
 ) {
+    let local_node_id = discv5.local_enr().node_id();
    let lookup_interval = Duration::from_secs(lookup_interval);
    let metrics = metrics.discovered_peers;
    let mut kbucket_index = MAX_KBUCKET_INDEX;
    let pulse_lookup_interval = Duration::from_secs(bootstrap_lookup_interval);
    task::spawn(async move {
-        let Some(discv5_handle) = discv5.upgrade() else {
-            return;
-        };
-        let local_node_id = discv5_handle.local_enr().node_id();
-        drop(discv5_handle);
-
        // make many fast lookup queries at bootstrap, trying to fill kbuckets at furthest
        // log2distance from local node
        for i in (0..bootstrap_lookup_countdown).rev() {
@@ -593,12 +593,7 @@ pub fn spawn_populate_kbuckets_bg(
                "starting bootstrap boost lookup query"
            );

-            {
-                let Some(discv5_handle) = discv5.upgrade() else {
-                    return;
-                };
-                lookup(target, &discv5_handle, &metrics).await;
-            }
+            lookup(target, &discv5, &metrics).await;

            tokio::time::sleep(pulse_lookup_interval).await;
        }
@@ -615,12 +610,7 @@ pub fn spawn_populate_kbuckets_bg(
                "starting periodic lookup query"
            );

-            {
-                let Some(discv5_handle) = discv5.upgrade() else {
-                    return;
-                };
-                lookup(target, &discv5_handle, &metrics).await;
-            }
+            lookup(target, &discv5, &metrics).await;

            if kbucket_index > DEFAULT_MIN_TARGET_KBUCKET_INDEX {
                // try to populate bucket one step closer
@@ -706,13 +696,8 @@ mod test {
    #![allow(deprecated)]
    use super::*;
    use ::enr::{CombinedKey, EnrKey};
-    use discv5::ListenConfig;
    use rand_08::thread_rng;
    use reth_chainspec::MAINNET;
-    use std::{
-        net::UdpSocket,
-        time::{Duration, Instant},
-    };
    use tracing::trace;

    fn discv5_noop() -> Discv5 {
@@ -751,61 +736,6 @@ mod test {
        Discv5::start(&secret_key, discv5_config).await.expect("should build discv5")
    }

-    async fn start_discovery_node_with_key(
-        secret_key: &SecretKey,
-        udp_port_discv5: u16,
-    ) -> Result<(Discv5, mpsc::Receiver<discv5::Event>), Error> {
-        let discv5_addr: SocketAddr = format!("127.0.0.1:{udp_port_discv5}").parse().unwrap();
-        let rlpx_addr: SocketAddr = "127.0.0.1:30303".parse().unwrap();
-
-        let discv5_listen_config = ListenConfig::from(discv5_addr);
-        let discv5_config = Config::builder(rlpx_addr)
-            .discv5_config(discv5::ConfigBuilder::new(discv5_listen_config).build())
-            .build();
-
-        Discv5::start(secret_key, discv5_config).await
-    }
-
-    fn unused_udp_port() -> u16 {
-        UdpSocket::bind("127.0.0.1:0").unwrap().local_addr().unwrap().port()
-    }
-
-    async fn wait_for_udp_port_release(port: u16, timeout: Duration) {
-        let deadline = Instant::now() + timeout;
-
-        loop {
-            match UdpSocket::bind(("127.0.0.1", port)) {
-                Ok(socket) => {
-                    drop(socket);
-                    return;
-                }
-                Err(err) if Instant::now() < deadline => {
-                    trace!(target: "net::discv5::test", %port, %err, "waiting for discv5 port release");
-                    tokio::time::sleep(Duration::from_millis(10)).await;
-                }
-                Err(err) => panic!("discv5 did not release port {port} before timeout: {err}"),
-            }
-        }
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn discv5_releases_port_on_drop() {
-        reth_tracing::init_test_tracing();
-
-        let secret_key = SecretKey::new(&mut thread_rng());
-        let port = unused_udp_port();
-
-        let (node, updates) =
-            start_discovery_node_with_key(&secret_key, port).await.expect("should start discv5");
-        drop(updates);
-        drop(node);
-
-        wait_for_udp_port_release(port, Duration::from_secs(1)).await;
-
-        let restarted = start_discovery_node_with_key(&secret_key, port).await;
-        assert!(restarted.is_ok(), "discv5 failed to rebind dropped port: {restarted:?}");
-    }
-
    #[tokio::test(flavor = "multi_thread")]
    async fn discv5() {
        reth_tracing::init_test_tracing();
--- a/crates/net/eth-wire-types/src/broadcast.rs
+++ b/crates/net/eth-wire-types/src/broadcast.rs
@@ -7,14 +7,13 @@ use alloy_primitives::{
    Bytes, TxHash, B256, U128,
 };
 use alloy_rlp::{
-    Decodable, Encodable, Header, RlpDecodable, RlpDecodableWrapper, RlpEncodable,
-    RlpEncodableWrapper,
+    Decodable, Encodable, RlpDecodable, RlpDecodableWrapper, RlpEncodable, RlpEncodableWrapper,
 };
 use core::{fmt::Debug, mem};
 use derive_more::{Constructor, Deref, DerefMut, From, IntoIterator};
 use reth_codecs_derive::{add_arbitrary_tests, generate_tests};
 use reth_ethereum_primitives::TransactionSigned;
-use reth_primitives_traits::{Block, InMemorySize, SignedTransaction};
+use reth_primitives_traits::{Block, SignedTransaction};

 /// This informs peers of new blocks that have appeared on the network.
 #[derive(
@@ -144,53 +143,6 @@ impl<T> From<Transactions<T>> for Vec<T> {
    }
 }

-impl<T: Decodable + InMemorySize> Transactions<T> {
-    /// Decodes the RLP list of transactions, stopping once the cumulative
-    /// [`InMemorySize`] of decoded transactions exceeds `memory_budget` bytes.
-    /// Any remaining transactions in the payload are skipped.
-    pub fn decode_with_memory_budget(
-        buf: &mut &[u8],
-        memory_budget: usize,
-    ) -> alloy_rlp::Result<Self> {
-        decode_list_with_memory_budget(buf, memory_budget).map(Self)
-    }
-}
-
-/// Decodes an RLP list, stopping once the cumulative [`InMemorySize`] of decoded items exceeds
-/// `memory_budget` bytes. Any remaining items in the payload are skipped.
-pub fn decode_list_with_memory_budget<T: Decodable + InMemorySize>(
-    buf: &mut &[u8],
-    memory_budget: usize,
-) -> alloy_rlp::Result<Vec<T>> {
-    let header = Header::decode(buf)?;
-    if !header.list {
-        return Err(alloy_rlp::Error::UnexpectedString);
-    }
-    if buf.len() < header.payload_length {
-        return Err(alloy_rlp::Error::InputTooShort);
-    }
-
-    let (payload, rest) = buf.split_at(header.payload_length);
-    let mut payload = payload;
-
-    let mut txs = Vec::new();
-    let mut total_size = 0usize;
-
-    while !payload.is_empty() {
-        let item = T::decode(&mut payload)?;
-        total_size = total_size.saturating_add(item.size());
-
-        if total_size > memory_budget {
-            break;
-        }
-
-        txs.push(item);
-    }
-
-    *buf = rest;
-    Ok(txs)
-}
-
 /// Same as [`Transactions`] but this is intended as egress message send from local to _many_ peers.
 ///
 /// The list of transactions is constructed on per-peers basis, but the underlying transaction
@@ -885,19 +837,6 @@ pub struct BlockRangeUpdate {
    pub latest_hash: B256,
 }

-impl InMemorySize for NewPooledTransactionHashes {
-    fn size(&self) -> usize {
-        match self {
-            Self::Eth66(msg) => msg.0.len() * core::mem::size_of::<B256>(),
-            Self::Eth68(msg) => {
-                msg.types.len() * core::mem::size_of::<u8>() +
-                    msg.sizes.len() * core::mem::size_of::<usize>() +
-                    msg.hashes.len() * core::mem::size_of::<B256>()
-            }
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
--- a/crates/net/eth-wire-types/src/message.rs
+++ b/crates/net/eth-wire-types/src/message.rs
@@ -28,15 +28,6 @@ use core::fmt::Debug;
 // https://github.com/ethereum/go-ethereum/blob/30602163d5d8321fbc68afdcbbaf2362b2641bde/eth/protocols/eth/protocol.go#L50
 pub const MAX_MESSAGE_SIZE: usize = 10 * 1024 * 1024;

-/// Multiplier applied to `max_message_size` to derive the in-memory budget for decoding
-/// `Transactions` and `PooledTransactions` messages.
-///
-/// Decoded transactions expand relative to their RLP encoding due to struct overhead and heap
-/// allocations. With many peers in flight this can cause significant memory pressure, so we
-/// stop decoding once the cumulative in-memory size of decoded transactions exceeds
-/// `max_message_size * TX_MEMORY_BUDGET_MULTIPLIER`. Remaining transactions are silently dropped.
-pub const TX_MEMORY_BUDGET_MULTIPLIER: usize = 2;
-
 /// Error when sending/receiving a message
 #[derive(thiserror::Error, Debug)]
 pub enum MessageError {
@@ -96,19 +87,6 @@ impl<N: NetworkPrimitives> ProtocolMessage<N> {
    ///
    /// This will enforce decoding according to the given [`EthVersion`] of the connection.
    pub fn decode_message(version: EthVersion, buf: &mut &[u8]) -> Result<Self, MessageError> {
-        Self::decode_message_with_tx_memory_budget(version, buf, usize::MAX)
-    }
-
-    /// Like [`Self::decode_message`], but caps the cumulative in-memory size of decoded
-    /// transactions in `Transactions` and `PooledTransactions` messages. Once exceeded,
-    /// remaining transactions are silently dropped.
-    ///
-    /// Use [`TX_MEMORY_BUDGET_MULTIPLIER`] to derive a reasonable default.
-    pub fn decode_message_with_tx_memory_budget(
-        version: EthVersion,
-        buf: &mut &[u8],
-        tx_memory_budget: usize,
-    ) -> Result<Self, MessageError> {
        let message_type = EthMessageID::decode(buf)?;

        // For EIP-7642 (https://github.com/ethereum/EIPs/blob/master/EIPS/eip-7642.md):
@@ -125,9 +103,7 @@ impl<N: NetworkPrimitives> ProtocolMessage<N> {
            EthMessageID::NewBlock => {
                EthMessage::NewBlock(Box::new(N::NewBlockPayload::decode(buf)?))
            }
-            EthMessageID::Transactions => EthMessage::Transactions(
-                Transactions::decode_with_memory_budget(buf, tx_memory_budget)?,
-            ),
+            EthMessageID::Transactions => EthMessage::Transactions(Transactions::decode(buf)?),
            EthMessageID::NewPooledTransactionHashes => {
                if version >= EthVersion::Eth68 {
                    EthMessage::NewPooledTransactionHashes68(NewPooledTransactionHashes68::decode(
@@ -147,9 +123,7 @@ impl<N: NetworkPrimitives> ProtocolMessage<N> {
                EthMessage::GetPooledTransactions(RequestPair::decode(buf)?)
            }
            EthMessageID::PooledTransactions => {
-                EthMessage::PooledTransactions(RequestPair::decode_with(buf, |buf| {
-                    PooledTransactions::decode_with_memory_budget(buf, tx_memory_budget)
-                })?)
+                EthMessage::PooledTransactions(RequestPair::decode(buf)?)
            }
            EthMessageID::GetNodeData => {
                if version >= EthVersion::Eth67 {
@@ -758,25 +732,6 @@ impl<T> RequestPair<T> {
        let Self { request_id, message } = self;
        RequestPair { request_id, message: f(message) }
    }
-
-    /// Decodes the request id and then decodes the message payload using `decode_msg`.
-    pub fn decode_with<F>(buf: &mut &[u8], decode_msg: F) -> alloy_rlp::Result<Self>
-    where
-        F: FnOnce(&mut &[u8]) -> alloy_rlp::Result<T>,
-    {
-        let header = Header::decode(buf)?;
-
-        let initial_length = buf.len();
-        let request_id = u64::decode(buf)?;
-        let message = decode_msg(buf)?;
-
-        let consumed_len = initial_length - buf.len();
-        if consumed_len != header.payload_length {
-            return Err(alloy_rlp::Error::UnexpectedLength)
-        }
-
-        Ok(Self { request_id, message })
-    }
 }

 /// Allows messages with request ids to be serialized into RLP bytes.
--- a/crates/net/eth-wire-types/src/transactions.rs
+++ b/crates/net/eth-wire-types/src/transactions.rs
@@ -1,14 +1,12 @@
 //! Implements the `GetPooledTransactions` and `PooledTransactions` message types.

-use crate::broadcast::decode_list_with_memory_budget;
 use alloc::vec::Vec;
 use alloy_consensus::transaction::PooledTransaction;
 use alloy_eips::eip2718::Encodable2718;
 use alloy_primitives::B256;
-use alloy_rlp::{Decodable, RlpDecodableWrapper, RlpEncodableWrapper};
+use alloy_rlp::{RlpDecodableWrapper, RlpEncodableWrapper};
 use derive_more::{Constructor, Deref, IntoIterator};
 use reth_codecs_derive::add_arbitrary_tests;
-use reth_primitives_traits::InMemorySize;

 /// A list of transaction hashes that the peer would like transaction bodies for.
 #[derive(
@@ -39,12 +37,6 @@ where
    }
 }

-impl InMemorySize for GetPooledTransactions {
-    fn size(&self) -> usize {
-        self.0.len() * core::mem::size_of::<B256>()
-    }
-}
-
 /// The response to [`GetPooledTransactions`], containing the transaction bodies associated with
 /// the requested hashes.
 ///
@@ -70,18 +62,6 @@ pub struct PooledTransactions<T = PooledTransaction>(
    pub Vec<T>,
 );

-impl<T: Decodable + InMemorySize> PooledTransactions<T> {
-    /// Decodes the RLP list of transactions, stopping once the cumulative
-    /// [`InMemorySize`] of decoded transactions exceeds `memory_budget` bytes.
-    /// Any remaining transactions in the payload are skipped.
-    pub fn decode_with_memory_budget(
-        buf: &mut &[u8],
-        memory_budget: usize,
-    ) -> alloy_rlp::Result<Self> {
-        decode_list_with_memory_budget(buf, memory_budget).map(Self)
-    }
-}
-
 impl<T: Encodable2718> PooledTransactions<T> {
    /// Returns an iterator over the transaction hashes in this response.
    pub fn hashes(&self) -> impl Iterator<Item = B256> + '_ {
--- a/crates/net/eth-wire/src/eth_snap_stream.rs
+++ b/crates/net/eth-wire/src/eth_snap_stream.rs
@@ -5,7 +5,7 @@

 use super::message::MAX_MESSAGE_SIZE;
 use crate::{
-    message::{EthBroadcastMessage, ProtocolBroadcastMessage, TX_MEMORY_BUDGET_MULTIPLIER},
+    message::{EthBroadcastMessage, ProtocolBroadcastMessage},
    EthMessage, EthMessageID, EthNetworkPrimitives, EthVersion, NetworkPrimitives, ProtocolMessage,
    RawCapabilityMessage, SnapProtocolMessage, SnapVersion,
 };
@@ -298,11 +298,7 @@ where
        // See also <https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/capability.rs#L272-L283>.
        if message_id <= EthMessageID::max(self.eth_version) {
            let mut buf = bytes.as_ref();
-            match ProtocolMessage::decode_message_with_tx_memory_budget(
-                self.eth_version,
-                &mut buf,
-                self.max_message_size * TX_MEMORY_BUDGET_MULTIPLIER,
-            ) {
+            match ProtocolMessage::decode_message(self.eth_version, &mut buf) {
                Ok(protocol_msg) => {
                    if matches!(protocol_msg.message, EthMessage::Status(_)) {
                        return Err(EthSnapStreamError::StatusNotInHandshake);
--- a/crates/net/eth-wire/src/ethstream.rs
+++ b/crates/net/eth-wire/src/ethstream.rs
@@ -7,10 +7,7 @@
 use crate::{
    errors::{EthHandshakeError, EthStreamError},
    handshake::EthereumEthHandshake,
-    message::{
-        EthBroadcastMessage, ProtocolBroadcastMessage, MAX_MESSAGE_SIZE,
-        TX_MEMORY_BUDGET_MULTIPLIER,
-    },
+    message::{EthBroadcastMessage, ProtocolBroadcastMessage, MAX_MESSAGE_SIZE},
    p2pstream::HANDSHAKE_TIMEOUT,
    CanDisconnect, DisconnectReason, EthMessage, EthNetworkPrimitives, EthVersion, ProtocolMessage,
    UnifiedStatus,
@@ -19,7 +16,7 @@ use alloy_primitives::bytes::{Bytes, BytesMut};
 use alloy_rlp::Encodable;
 use futures::{ready, Sink, SinkExt};
 use pin_project::pin_project;
-use reth_eth_wire_types::{EthMessageID, NetworkPrimitives, RawCapabilityMessage};
+use reth_eth_wire_types::{NetworkPrimitives, RawCapabilityMessage};
 use reth_ethereum_forks::ForkFilter;
 use std::{
    future::Future,
@@ -111,9 +108,6 @@ pub struct EthStreamInner<N> {
    version: EthVersion,
    /// Maximum allowed ETH message size.
    max_message_size: usize,
-    /// When true, `NewBlock` (0x07) and `NewBlockHashes` (0x01) messages are rejected before RLP
-    /// decoding to avoid any memory impact for non-PoW networks.
-    reject_block_announcements: bool,
    _pd: std::marker::PhantomData<N>,
 }

@@ -128,12 +122,7 @@ where

    /// Creates a new [`EthStreamInner`] with the given eth version and message size limit.
    pub const fn with_max_message_size(version: EthVersion, max_message_size: usize) -> Self {
-        Self {
-            version,
-            max_message_size,
-            reject_block_announcements: false,
-            _pd: std::marker::PhantomData,
-        }
+        Self { version, max_message_size, _pd: std::marker::PhantomData }
    }

    /// Returns the eth version
@@ -142,30 +131,13 @@ where
        self.version
    }

-    /// Sets whether to reject block announcement messages (`NewBlock`, `NewBlockHashes`) before
-    /// RLP decoding.
-    pub const fn set_reject_block_announcements(&mut self, reject: bool) {
-        self.reject_block_announcements = reject;
-    }
-
    /// Decodes incoming bytes into an [`EthMessage`].
    pub fn decode_message(&self, bytes: BytesMut) -> Result<EthMessage<N>, EthStreamError> {
        if bytes.len() > self.max_message_size {
            return Err(EthStreamError::MessageTooBig(bytes.len()));
        }

-        if self.reject_block_announcements &&
-            let Some(&id) = bytes.first() &&
-            (id == EthMessageID::NewBlock.to_u8() || id == EthMessageID::NewBlockHashes.to_u8())
-        {
-            return Err(EthStreamError::UnsupportedMessage { message_id: id });
-        }
-
-        let msg = match ProtocolMessage::decode_message_with_tx_memory_budget(
-            self.version,
-            &mut bytes.as_ref(),
-            self.max_message_size * TX_MEMORY_BUDGET_MULTIPLIER,
-        ) {
+        let msg = match ProtocolMessage::decode_message(self.version, &mut bytes.as_ref()) {
            Ok(m) => m,
            Err(err) => {
                let msg = if bytes.len() > 50 {
@@ -236,12 +208,6 @@ impl<S, N: NetworkPrimitives> EthStream<S, N> {
        self.eth.version()
    }

-    /// Sets whether to reject block announcement messages (`NewBlock`, `NewBlockHashes`) before
-    /// RLP decoding.
-    pub const fn set_reject_block_announcements(&mut self, reject: bool) {
-        self.eth.set_reject_block_announcements(reject);
-    }
-
    /// Returns the underlying stream.
    #[inline]
    pub const fn inner(&self) -> &S {
--- a/crates/net/network/Cargo.toml
+++ b/crates/net/network/Cargo.toml
@@ -50,7 +50,6 @@ reth-ethereum-primitives.workspace = true
 futures.workspace = true
 pin-project.workspace = true
 tokio = { workspace = true, features = ["io-util", "net", "macros", "rt-multi-thread", "time"] }
-socket2 = { workspace = true, features = ["all"] }
 tokio-stream.workspace = true
 tokio-util = { workspace = true, features = ["codec"] }

--- a/crates/net/network/src/builder.rs
+++ b/crates/net/network/src/builder.rs
@@ -2,7 +2,6 @@

 use crate::{
    eth_requests::EthRequestHandler,
-    metrics::NETWORK_POOL_TRANSACTIONS_SCOPE,
    transactions::{
        config::{
            AnnouncementFilteringPolicy, StrictEthAnnouncementFilter, TransactionPropagationKind,
@@ -13,9 +12,7 @@ use crate::{
    NetworkHandle, NetworkManager,
 };
 use reth_eth_wire::{EthNetworkPrimitives, NetworkPrimitives};
-use reth_metrics::common::mpsc::memory_bounded_channel;
 use reth_network_api::test_utils::PeersHandleProvider;
-use reth_storage_api::BalProvider;
 use reth_transaction_pool::TransactionPool;
 use tokio::sync::mpsc;

@@ -66,10 +63,7 @@ impl<Tx, Eth, N: NetworkPrimitives> NetworkBuilder<Tx, Eth, N> {
    pub fn request_handler<Client>(
        self,
        client: Client,
-    ) -> NetworkBuilder<Tx, EthRequestHandler<Client, N>, N>
-    where
-        Client: BalProvider,
-    {
+    ) -> NetworkBuilder<Tx, EthRequestHandler<Client, N>, N> {
        let Self { mut network, transactions, .. } = self;
        let (tx, rx) = mpsc::channel(ETH_REQUEST_CHANNEL_CAPACITY);
        network.set_eth_request_handler(tx);
@@ -124,10 +118,7 @@ impl<Tx, Eth, N: NetworkPrimitives> NetworkBuilder<Tx, Eth, N> {
        announcement_policy: A,
    ) -> NetworkBuilder<TransactionsManager<Pool, N>, Eth, N> {
        let Self { mut network, request_handler, .. } = self;
-        let (tx, rx) = memory_bounded_channel(
-            transactions_manager_config.tx_channel_memory_limit_bytes,
-            NETWORK_POOL_TRANSACTIONS_SCOPE,
-        );
+        let (tx, rx) = mpsc::unbounded_channel();
        network.set_transactions(tx);
        let handle = network.handle().clone();
        let policies = NetworkPolicies::new(propagation_policy, announcement_policy);
--- a/crates/net/network/src/config.rs
+++ b/crates/net/network/src/config.rs
@@ -20,9 +20,7 @@ use reth_eth_wire_types::message::MAX_MESSAGE_SIZE;
 use reth_ethereum_forks::{ForkFilter, Head};
 use reth_network_peers::{mainnet_nodes, pk2id, sepolia_nodes, PeerId, TrustedPeer};
 use reth_network_types::{PeersConfig, SessionsConfig};
-use reth_storage_api::{
-    noop::NoopProvider, BalProvider, BlockNumReader, BlockReader, HeaderProvider,
-};
+use reth_storage_api::{noop::NoopProvider, BlockNumReader, BlockReader, HeaderProvider};
 use reth_tasks::Runtime;
 use secp256k1::SECP256K1;
 use std::{collections::HashSet, net::SocketAddr, sync::Arc};
@@ -159,8 +157,7 @@ where
 impl<C, N> NetworkConfig<C, N>
 where
    N: NetworkPrimitives,
-    C: BalProvider
-        + BlockReader<Block = N::Block, Receipt = N::Receipt, Header = N::BlockHeader>
+    C: BlockReader<Block = N::Block, Receipt = N::Receipt, Header = N::BlockHeader>
        + HeaderProvider
        + Clone
        + Unpin
--- a/crates/net/network/src/discovery.rs
+++ b/crates/net/network/src/discovery.rs
@@ -23,7 +23,7 @@ use std::{
    sync::Arc,
    task::{ready, Context, Poll},
 };
-use tokio::{net::UdpSocket, sync::mpsc, task::JoinHandle};
+use tokio::{sync::mpsc, task::JoinHandle};
 use tokio_stream::{wrappers::ReceiverStream, Stream};
 use tracing::{debug, trace};

@@ -54,9 +54,6 @@ pub struct Discovery {
    discv5: Option<Discv5>,
    /// All KAD table updates from the discv5 service.
    discv5_updates: Option<ReceiverStream<discv5::Event>>,
-    /// Background task that, in shared-port mode, drains `UnrecognizedFrame`s from discv5 and
-    /// feeds them into the discv4 ingress so packets advance without polling `Discovery`.
-    _discv5_forwarder: Option<JoinHandle<()>>,
    /// Handler to interact with the DNS discovery service
    _dns_discovery: Option<DnsDiscoveryHandle>,
    /// Updates from the DNS discovery service.
@@ -79,138 +76,39 @@ impl Discovery {
        discovery_v4_addr: SocketAddr,
        sk: SecretKey,
        discv4_config: Option<Discv4Config>,
-        mut discv5_config: Option<reth_discv5::Config>, // contains discv5 listen address
+        discv5_config: Option<reth_discv5::Config>, // contains discv5 listen address
        dns_discovery_config: Option<DnsDiscoveryConfig>,
    ) -> Result<Self, NetworkError> {
        // setup discv4 with the discovery address and tcp port
        let local_enr =
            NodeRecord::from_secret_key(discovery_v4_addr, &sk).with_tcp_port(tcp_addr.port());

-        // For IPv6 we set IPV6_V6ONLY=true so an IPv4 sibling socket on the same port doesn't
-        // clash with the IPv6 one (Linux's default of V6ONLY=0 has IPv6 also claim the IPv4
-        // port via mapped addresses), matching how discv5 binds its `DualStack` sockets.
-        let bind_socket = async |addr: SocketAddr| {
-            let result = match addr {
-                SocketAddr::V4(_) => UdpSocket::bind(addr).await,
-                SocketAddr::V6(_) => {
-                    use socket2::{Domain, Protocol, Socket, Type};
-                    (|| {
-                        let socket = Socket::new(Domain::IPV6, Type::DGRAM, Some(Protocol::UDP))?;
-                        socket.set_only_v6(true)?;
-                        socket.set_nonblocking(true)?;
-                        socket.bind(&addr.into())?;
-                        UdpSocket::from_std(socket.into())
-                    })()
-                }
-            };
-            result
-                .map(Arc::new)
-                .map_err(|err| NetworkError::from_io_error(err, ServiceKind::Discovery(addr)))
-        };
-
-        // In shared-port mode, bind the shared socket and start discv4 without its own receive
-        // loop. Unrecognized frames from discv5 will be forwarded to the ingress handler.
-        let (discv4, discv4_updates, _discv4_service, discv4_ingress, shared_socket) =
-            if let Some(config) = discv4_config {
-                if let Some(discv5_config) = &mut discv5_config &&
-                    discv5_config.has_matching_socket(discovery_v4_addr)
-                {
-                    let socket = bind_socket(discovery_v4_addr).await?;
-
-                    let (discv4, mut discv4_service, ingress) = Discv4::bind_shared(
-                        socket.clone(),
-                        local_enr,
-                        sk,
-                        config,
-                    )
-                    .map_err(|err| {
+        let discv4_future = async {
+            let Some(disc_config) = discv4_config else { return Ok((None, None, None)) };
+            let (discv4, mut discv4_service) =
+                Discv4::bind(discovery_v4_addr, local_enr, sk, disc_config).await.map_err(
+                    |err| {
                        NetworkError::from_io_error(err, ServiceKind::Discovery(discovery_v4_addr))
-                    })?;
+                    },
+                )?;
+            let discv4_updates = discv4_service.update_stream();
+            // spawn the service
+            let discv4_service = discv4_service.spawn();

-                    let discv4_updates = discv4_service.update_stream();
-                    let discv4_service = discv4_service.spawn();
-                    debug!(target:"net", ?discovery_v4_addr, "started discovery v4 (shared port)");
-                    (
-                        Some(discv4),
-                        Some(discv4_updates),
-                        Some(discv4_service),
-                        Some(ingress),
-                        Some(socket),
-                    )
-                } else {
-                    let (discv4, mut discv4_service) =
-                        Discv4::bind(discovery_v4_addr, local_enr, sk, config).await.map_err(
-                            |err| {
-                                NetworkError::from_io_error(
-                                    err,
-                                    ServiceKind::Discovery(discovery_v4_addr),
-                                )
-                            },
-                        )?;
-                    let discv4_updates = discv4_service.update_stream();
-                    // spawn the service
-                    let discv4_service = discv4_service.spawn();
+            debug!(target:"net", ?discovery_v4_addr, "started discovery v4");

-                    debug!(target:"net", ?discovery_v4_addr, "started discovery v4");
-
-                    (Some(discv4), Some(discv4_updates), Some(discv4_service), None, None)
-                }
-            } else {
-                (None, None, None, None, None)
-            };
-
-        // Start discv5, wiring in the shared socket if in shared-port mode.
-        let (discv5, discv5_updates) = if let Some(mut config) = discv5_config {
-            if let Some(socket) = shared_socket {
-                let discv5_cfg = config.discv5_config_mut();
-
-                // The shared socket covers discv4's address family; bind the opposite family
-                // only if discv5 was configured for dual-stack.
-                let (mut ipv4, mut ipv6) = (None, None);
-                if discovery_v4_addr.is_ipv4() {
-                    ipv4 = Some(socket);
-                    if let Some(addr) = reth_discv5::config::ipv6(&discv5_cfg.listen_config) {
-                        ipv6 = Some(bind_socket(SocketAddr::V6(addr)).await?);
-                    }
-                } else {
-                    ipv6 = Some(socket);
-                    if let Some(addr) = reth_discv5::config::ipv4(&discv5_cfg.listen_config) {
-                        ipv4 = Some(bind_socket(SocketAddr::V4(addr)).await?);
-                    }
-                }
-
-                discv5_cfg.listen_config = discv5::ListenConfig::FromSockets { ipv4, ipv6 };
-            }
+            Ok((Some(discv4), Some(discv4_updates), Some(discv4_service)))
+        };

+        let discv5_future = async {
+            let Some(config) = discv5_config else { return Ok::<_, NetworkError>((None, None)) };
            let (discv5, discv5_updates) = Discv5::start(&sk, config).await?;
-            debug!(target:"net", discovery_v5_enr=?discv5.local_enr(), "started discovery v5");
-            (Some(discv5), Some(discv5_updates))
-        } else {
-            (None, None)
+            debug!(target:"net", discovery_v5_enr=? discv5.local_enr(), "started discovery v5");
+            Ok((Some(discv5), Some(discv5_updates.into())))
        };

-        // In shared-port mode, spawn a task that peels `UnrecognizedFrame` events off the discv5
-        // update stream and feeds them into discv4's ingress. Other events are forwarded through
-        // a new channel that `Discovery::poll` reads. This keeps both protocols moving without
-        // requiring the main `Discovery::poll` loop to be driven for packets to be routed.
-        let (discv5_updates, _discv5_forwarder) = match (discv4_ingress, discv5_updates) {
-            (Some(mut ingress), Some(mut updates)) => {
-                let (tx, rx) = mpsc::channel(updates.max_capacity());
-                let handle = tokio::spawn(async move {
-                    while let Some(event) = updates.recv().await {
-                        if let discv5::Event::UnrecognizedFrame(frame) = &event {
-                            ingress.handle_packet(&frame.packet, frame.src_address).await;
-                            continue;
-                        }
-                        if tx.send(event).await.is_err() {
-                            break;
-                        }
-                    }
-                });
-                (Some(ReceiverStream::new(rx)), Some(handle))
-            }
-            (_, updates) => (updates.map(ReceiverStream::new), None),
-        };
+        let ((discv4, discv4_updates, _discv4_service), (discv5, discv5_updates)) =
+            tokio::try_join!(discv4_future, discv5_future)?;

        // setup DNS discovery
        let (_dns_discovery, dns_discovery_updates, _dns_disc_service) =
@@ -234,7 +132,6 @@ impl Discovery {
            _discv4_service,
            discv5,
            discv5_updates,
-            _discv5_forwarder,
            discovered_nodes: LruMap::new(DEFAULT_MAX_CAPACITY_DISCOVERED_PEERS_CACHE),
            queued_events: Default::default(),
            _dns_disc_service,
@@ -412,9 +309,6 @@ impl Drop for Discovery {
        if let Some(handle) = self._discv4_service.take() {
            handle.abort();
        }
-        if let Some(handle) = self._discv5_forwarder.take() {
-            handle.abort();
-        }
        if let Some(handle) = self._dns_disc_service.take() {
            handle.abort();
        }
@@ -448,11 +342,10 @@ impl Discovery {
            },
            discv4: Default::default(),
            discv4_updates: Default::default(),
-            _discv4_service: Default::default(),
-            _discv5_forwarder: None,
            discv5: None,
            discv5_updates: None,
            queued_events: Default::default(),
+            _discv4_service: Default::default(),
            _dns_discovery: None,
            dns_discovery_updates: None,
            _dns_disc_service: None,
@@ -594,179 +487,4 @@ mod tests {
        assert_eq!(1, node_1.discovered_nodes.len());
        assert_eq!(1, node_2.discovered_nodes.len());
    }
-
-    /// Starts a discovery node with discv4 and discv5 sharing the same UDP port.
-    async fn start_shared_port_node(port: u16) -> Discovery {
-        let secret_key = SecretKey::new(&mut rand_08::thread_rng());
-        let disc_addr: SocketAddr = format!("127.0.0.1:{port}").parse().unwrap();
-        // Use a non-zero TCP port so the node record isn't filtered out by
-        // `on_node_record_update` (which drops peers with tcp port == 0).
-        let tcp_addr: SocketAddr = "127.0.0.1:30303".parse().unwrap();
-
-        let discv4_config = Discv4ConfigBuilder::default().external_ip_resolver(None).build();
-
-        let discv5_listen_config = discv5::ListenConfig::from(disc_addr);
-        let discv5_config = reth_discv5::Config::builder(tcp_addr)
-            .discv5_config(discv5::ConfigBuilder::new(discv5_listen_config).build())
-            .build();
-
-        // Both protocols use the same address, triggering shared-port mode
-        Discovery::new(
-            tcp_addr,
-            disc_addr,
-            secret_key,
-            Some(discv4_config),
-            Some(discv5_config),
-            None,
-        )
-        .await
-        .expect("should start with shared port")
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_shared_port_setup() {
-        reth_tracing::init_test_tracing();
-
-        // Use port 0 so the OS picks a free port
-        let node = start_shared_port_node(0).await;
-
-        // Both protocols should be active
-        assert!(node.discv4.is_some(), "discv4 should be running");
-        assert!(node.discv5.is_some(), "discv5 should be running");
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_shared_port_discv5_discovery() {
-        reth_tracing::init_test_tracing();
-
-        let mut node_1 = start_shared_port_node(0).await;
-        let mut node_2 = start_shared_port_node(0).await;
-
-        let discv5_enr_1 = node_1.discv5.as_ref().unwrap().with_discv5(|discv5| discv5.local_enr());
-        let discv5_enr_2 = node_2.discv5.as_ref().unwrap().with_discv5(|discv5| discv5.local_enr());
-
-        let peer_id_1 = enr_to_discv4_id(&discv5_enr_1).unwrap();
-        let peer_id_2 = enr_to_discv4_id(&discv5_enr_2).unwrap();
-
-        // Add node_2's ENR to node_1's discv5 kbuckets and trigger a ping to establish a session.
-        // send_ping awaits the PONG, so the handshake completes before we poll the Discovery
-        // stream. The discv5 service runs its own background task.
-        node_1.add_discv5_node(EnrCombinedKeyWrapper(discv5_enr_2.clone()).into()).unwrap();
-        node_1
-            .discv5
-            .as_ref()
-            .unwrap()
-            .with_discv5(|discv5| discv5.send_ping(discv5_enr_2))
-            .await
-            .unwrap();
-
-        // Both SessionEstablished events should now be buffered in the update channels.
-        // Drive both nodes concurrently to collect them.
-        let mut event_1 = None;
-        let mut event_2 = None;
-        let timeout = tokio::time::sleep(std::time::Duration::from_secs(5));
-        tokio::pin!(timeout);
-        loop {
-            tokio::select! {
-                ev = node_1.next(), if event_1.is_none() => {
-                    event_1 = ev;
-                }
-                ev = node_2.next(), if event_2.is_none() => {
-                    event_2 = ev;
-                }
-                _ = &mut timeout => {
-                    panic!("timed out waiting for discv5 discovery events");
-                }
-            }
-            if event_1.is_some() && event_2.is_some() {
-                break;
-            }
-        }
-
-        assert!(matches!(
-            event_1.unwrap(),
-            DiscoveryEvent::NewNode(DiscoveredEvent::EventQueued { peer_id, .. })
-                if peer_id == peer_id_2
-        ));
-        assert!(matches!(
-            event_2.unwrap(),
-            DiscoveryEvent::NewNode(DiscoveredEvent::EventQueued { peer_id, .. })
-                if peer_id == peer_id_1
-        ));
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_shared_port_discv4_discovery() {
-        reth_tracing::init_test_tracing();
-
-        let mut node_1 = start_shared_port_node(0).await;
-        let mut node_2 = start_shared_port_node(0).await;
-
-        let enr_1 = node_1.discv4.as_ref().unwrap().node_record();
-        let enr_2 = node_2.discv4.as_ref().unwrap().node_record();
-
-        // Introduce node_2 to node_1 via discv4
-        node_1.add_discv4_node(enr_2);
-
-        // Both nodes should discover each other via discv4 ping/pong
-        let event_1 = node_1.next().await.unwrap();
-        let event_2 = node_2.next().await.unwrap();
-
-        assert_eq!(
-            DiscoveryEvent::NewNode(DiscoveredEvent::EventQueued {
-                peer_id: enr_2.id,
-                addr: PeerAddr::new(enr_2.tcp_addr(), Some(enr_2.udp_addr())),
-                fork_id: None
-            }),
-            event_1
-        );
-        assert_eq!(
-            DiscoveryEvent::NewNode(DiscoveredEvent::EventQueued {
-                peer_id: enr_1.id,
-                addr: PeerAddr::new(enr_1.tcp_addr(), Some(enr_1.udp_addr())),
-                fork_id: None
-            }),
-            event_2
-        );
-    }
-
-    /// Verifies that shared-port mode binds correctly when discv5 is configured for dual-stack.
-    /// On Linux this exercises the IPv6 V6ONLY path: without it, the IPv4 sibling would clash
-    /// with the IPv6 socket bound to the same port.
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_shared_port_dual_stack() {
-        reth_tracing::init_test_tracing();
-
-        // Find a port that's free on the v4 wildcard so we can use it for both v4 and v6.
-        let probe = UdpSocket::bind("0.0.0.0:0").await.expect("probe bind");
-        let port = probe.local_addr().unwrap().port();
-        drop(probe);
-
-        let secret_key = SecretKey::new(&mut rand_08::thread_rng());
-        let v4_addr: SocketAddr = format!("0.0.0.0:{port}").parse().unwrap();
-        let tcp_addr: SocketAddr = "0.0.0.0:30303".parse().unwrap();
-
-        let discv4_config = Discv4ConfigBuilder::default().external_ip_resolver(None).build();
-
-        let discv5_listen_config = discv5::ListenConfig::DualStack {
-            ipv4: std::net::Ipv4Addr::UNSPECIFIED,
-            ipv4_port: port,
-            ipv6: std::net::Ipv6Addr::UNSPECIFIED,
-            ipv6_port: port,
-        };
-        let discv5_config = reth_discv5::Config::builder(tcp_addr)
-            .discv5_config(discv5::ConfigBuilder::new(discv5_listen_config).build())
-            .build();
-
-        Discovery::new(
-            tcp_addr,
-            v4_addr,
-            secret_key,
-            Some(discv4_config),
-            Some(discv5_config),
-            None,
-        )
-        .await
-        .expect("discovery should start with shared port + dual-stack");
-    }
 }
--- a/crates/net/network/src/eth_requests.rs
+++ b/crates/net/network/src/eth_requests.rs
@@ -18,7 +18,7 @@ use reth_network_api::test_utils::PeersHandle;
 use reth_network_p2p::error::RequestResult;
 use reth_network_peers::PeerId;
 use reth_primitives_traits::Block;
-use reth_storage_api::{BalProvider, BlockReader, GetBlockAccessListLimit, HeaderProvider};
+use reth_storage_api::{BlockReader, HeaderProvider};
 use std::{
    future::Future,
    pin::Pin,
@@ -46,11 +46,6 @@ pub const MAX_HEADERS_SERVE: usize = 1024;
 /// `SOFT_RESPONSE_LIMIT`.
 pub const MAX_BODIES_SERVE: usize = 1024;

-/// Maximum number of block access lists to serve.
-///
-/// Used to limit lookups.
-pub const MAX_BLOCK_ACCESS_LISTS_SERVE: usize = 1024;
-
 /// Maximum size of replies to data retrievals: 2MB
 pub const SOFT_RESPONSE_LIMIT: usize = 2 * 1024 * 1024;

@@ -287,6 +282,27 @@ where
        let _ = response.send(Ok(Receipts70 { last_block_incomplete, receipts }));
    }

+    /// Handles [`GetBlockAccessLists`] queries.
+    ///
+    /// EIP-8159 defines the final `BlockAccessLists` response semantics:
+    /// <https://eips.ethereum.org/EIPS/eip-8159>
+    fn on_block_access_lists_request(
+        &self,
+        _peer_id: PeerId,
+        request: GetBlockAccessLists,
+        response: oneshot::Sender<RequestResult<BlockAccessLists>>,
+    ) {
+        // TODO: BAL serving is not fully implemented yet. Per EIP-8159, unavailable BALs are
+        // returned as empty BAL entries while preserving request order, so we currently return
+        // one RLP-encoded empty BAL (`0xc0`) per requested hash.
+        let access_lists = request
+            .0
+            .into_iter()
+            .map(|_| Bytes::from_static(&[alloy_rlp::EMPTY_LIST_CODE]))
+            .collect();
+        let _ = response.send(Ok(BlockAccessLists(access_lists)));
+    }
+
    #[inline]
    fn get_receipts_response<T, F>(&self, request: GetReceipts, transform_fn: F) -> Vec<Vec<T>>
    where
@@ -316,57 +332,13 @@ where
    }
 }

-impl<C, N> EthRequestHandler<C, N>
-where
-    N: NetworkPrimitives,
-    C: BalProvider,
-{
-    /// Handles [`GetBlockAccessLists`] queries.
-    ///
-    /// EIP-8159 defines the final `BlockAccessLists` response semantics:
-    /// <https://eips.ethereum.org/EIPS/eip-8159>
-    fn on_block_access_lists_request(
-        &self,
-        _peer_id: PeerId,
-        mut request: GetBlockAccessLists,
-        response: oneshot::Sender<RequestResult<BlockAccessLists>>,
-    ) {
-        request.0.truncate(MAX_BLOCK_ACCESS_LISTS_SERVE);
-
-        let limit = GetBlockAccessListLimit::ResponseSizeSoftLimit(SOFT_RESPONSE_LIMIT);
-        let access_lists = self
-            .client
-            .bal_store()
-            .get_by_hashes_with_limit(&request.0, limit)
-            .unwrap_or_else(|_| empty_block_access_lists_with_limit(request.0.len(), limit));
-        let _ = response.send(Ok(BlockAccessLists(access_lists)));
-    }
-}
-
-/// Builds the error fallback response while still enforcing the BAL response soft limit.
-fn empty_block_access_lists_with_limit(count: usize, limit: GetBlockAccessListLimit) -> Vec<Bytes> {
-    let mut out = Vec::with_capacity(count);
-    let mut size = 0;
-    for _ in 0..count {
-        let bal = Bytes::from_static(&[0xc0]);
-        size += bal.len();
-        out.push(bal);
-
-        if limit.exceeds(size) {
-            break
-        }
-    }
-    out
-}
-
 /// An endless future.
 ///
 /// This should be spawned or used as part of `tokio::select!`.
 impl<C, N> Future for EthRequestHandler<C, N>
 where
    N: NetworkPrimitives,
-    C: BalProvider
-        + BlockReader<Block = N::Block, Receipt = N::Receipt>
+    C: BlockReader<Block = N::Block, Receipt = N::Receipt>
        + HeaderProvider<Header = N::BlockHeader>
        + Unpin,
 {
--- a/crates/net/network/src/fetch/client.rs
+++ b/crates/net/network/src/fetch/client.rs
@@ -6,7 +6,7 @@ use futures::{future, future::Either};
 use reth_eth_wire::{BlockAccessLists, EthNetworkPrimitives, NetworkPrimitives};
 use reth_network_api::test_utils::PeersHandle;
 use reth_network_p2p::{
-    block_access_lists::client::{BalRequirement, BlockAccessListsClient},
+    block_access_lists::client::BlockAccessListsClient,
    bodies::client::{BodiesClient, BodiesFut},
    download::DownloadClient,
    error::{PeerRequestResult, RequestError},
@@ -135,29 +135,11 @@ impl<N: NetworkPrimitives> BlockAccessListsClient for FetchClient<N> {
        &self,
        hashes: Vec<B256>,
        priority: Priority,
-    ) -> Self::Output {
-        self.get_block_access_lists_with_priority_and_requirement(
-            hashes,
-            priority,
-            BalRequirement::Mandatory,
-        )
-    }
-
-    fn get_block_access_lists_with_priority_and_requirement(
-        &self,
-        hashes: Vec<B256>,
-        priority: Priority,
-        requirement: BalRequirement,
    ) -> Self::Output {
        let (response, rx) = oneshot::channel();
        if self
            .request_tx
-            .send(DownloadRequest::GetBlockAccessLists {
-                request: hashes,
-                response,
-                priority,
-                requirement,
-            })
+            .send(DownloadRequest::GetBlockAccessLists { request: hashes, response, priority })
            .is_ok()
        {
            Box::pin(FlattenedResponse::from(rx))
--- a/crates/net/network/src/fetch/mod.rs
+++ b/crates/net/network/src/fetch/mod.rs
@@ -13,7 +13,6 @@ use reth_eth_wire::{
 };
 use reth_network_api::test_utils::PeersHandle;
 use reth_network_p2p::{
-    block_access_lists::client::BalRequirement,
    error::{EthResponseValidator, PeerRequestResult, RequestError, RequestResult},
    headers::client::HeadersRequest,
    priority::Priority,
@@ -160,10 +159,15 @@ impl<N: NetworkPrimitives> StateFetcher<N> {
    /// full history available
    fn next_best_peer(&self, requirement: BestPeerRequirements) -> Option<PeerId> {
        // filter out peers that aren't idle or don't meet the requirement
-        let mut idle = self
-            .peers
-            .iter()
-            .filter(|(_, peer)| peer.state.is_idle() && peer.satisfies(&requirement));
+        let mut idle = self.peers.iter().filter(|(_, peer)| {
+            peer.state.is_idle() &&
+                match &requirement {
+                    BestPeerRequirements::EthVersion(ver) => {
+                        peer.capabilities.supports_eth_at_least(ver)
+                    }
+                    _ => true,
+                }
+        });

        let mut best_peer = idle.next()?;

@@ -191,14 +195,6 @@ impl<N: NetworkPrimitives> StateFetcher<N> {
        Some(*best_peer.0)
    }

-    /// Returns whether any connected peer can serve BAL requests.
-    fn has_eth71_peer(&self) -> bool {
-        self.peers.values().any(|peer| {
-            !matches!(peer.state, PeerState::Closing) &&
-                peer.capabilities.supports_eth_at_least(&EthVersion::Eth71)
-        })
-    }
-
    /// Returns the next action to return
    fn poll_action(&mut self) -> PollAction {
        // we only check and not pop here since we don't know yet whether a peer is available.
@@ -212,15 +208,9 @@ impl<N: NetworkPrimitives> StateFetcher<N> {

        let request = self.queued_requests.pop_front().expect("not empty");
        let Some(peer_id) = self.next_best_peer(request.best_peer_requirements()) else {
-            // Optional BAL requests can lose their eth/71 peer while queued; complete them
-            // instead of waiting for future peer churn.
-            if request.is_optional_bal() && !self.has_eth71_peer() {
-                request.send_err_response(RequestError::UnsupportedCapability);
-            } else {
-                // no peer matches this request's requirements; requeue at the back so other
-                // queued requests get a chance on the next poll instead of head-of-line blocking.
-                self.queued_requests.push_back(request);
-            }
+            // no peer matches this request's requirements; requeue at the back so other
+            // queued requests get a chance on the next poll instead of head-of-line blocking.
+            self.queued_requests.push_back(request);
            return PollAction::NoPeersAvailable
        };

@@ -242,30 +232,21 @@ impl<N: NetworkPrimitives> StateFetcher<N> {
            loop {
                // poll incoming requests
                match self.download_requests_rx.poll_next_unpin(cx) {
-                    Poll::Ready(Some(request)) => {
-                        // Optional BAL requests should not wait for future peer churn if no
-                        // connected peer can serve them right now.
-                        if request.is_optional_bal() && !self.has_eth71_peer() {
-                            request.send_err_response(RequestError::UnsupportedCapability);
-                            continue
+                    Poll::Ready(Some(request)) => match request.get_priority() {
+                        Priority::High => {
+                            // find the first normal request and queue before, add this request to
+                            // the back of the high-priority queue
+                            let pos = self
+                                .queued_requests
+                                .iter()
+                                .position(|req| req.is_normal_priority())
+                                .unwrap_or(0);
+                            self.queued_requests.insert(pos, request);
                        }
-
-                        match request.get_priority() {
-                            Priority::High => {
-                                // find first normal request and queue before it; add this request
-                                // to the back of the high-priority queue
-                                let pos = self
-                                    .queued_requests
-                                    .iter()
-                                    .position(|req| req.is_normal_priority())
-                                    .unwrap_or(0);
-                                self.queued_requests.insert(pos, request);
-                            }
-                            Priority::Normal => {
-                                self.queued_requests.push_back(request);
-                            }
+                        Priority::Normal => {
+                            self.queued_requests.push_back(request);
                        }
-                    }
+                    },
                    Poll::Ready(None) => {
                        unreachable!("channel can't close")
                    }
@@ -288,15 +269,6 @@ impl<N: NetworkPrimitives> StateFetcher<N> {
            peer.state = req.peer_state();
        }

-        self.prepare_inflight_block_request(peer_id, req)
-    }
-
-    /// Tracks an inflight request and converts it into a peer request.
-    fn prepare_inflight_block_request(
-        &mut self,
-        peer_id: PeerId,
-        req: DownloadRequest<N>,
-    ) -> BlockRequest {
        match req {
            DownloadRequest::GetBlockHeaders { request, response, .. } => {
                let inflight = Request { request: request.clone(), response };
@@ -327,23 +299,12 @@ impl<N: NetworkPrimitives> StateFetcher<N> {
        }
    }

-    /// Returns a queued followup request the peer can serve.
-    ///
-    /// This is an immediate scheduling shortcut after a successful response. It skips queued
-    /// requests whose hard requirements do not match this peer, leaving them for the regular peer
-    /// selection path.
+    /// Returns a new followup request for the peer.
    ///
    /// Caution: this expects that the peer is _not_ closed.
    fn followup_request(&mut self, peer_id: PeerId) -> Option<BlockResponseOutcome> {
-        let peer = self.peers.get_mut(&peer_id)?;
-        let req_idx = self.queued_requests.iter().position(|req| {
-            // Find the first queued request this peer can serve.
-            peer.satisfies(&req.best_peer_requirements())
-        })?;
-        let req = self.queued_requests.remove(req_idx).expect("valid request index");
-
-        peer.state = req.peer_state();
-        let req = self.prepare_inflight_block_request(peer_id, req);
+        let req = self.queued_requests.pop_front()?;
+        let req = self.prepare_block_request(peer_id, req);
        Some(BlockResponseOutcome::Request(peer_id, req))
    }

@@ -515,16 +476,6 @@ impl Peer {
        self.range_info.as_ref().map(|info| info.range())
    }

-    /// Returns whether this peer can serve requests with the given hard requirements.
-    fn satisfies(&self, requirement: &BestPeerRequirements) -> bool {
-        match requirement {
-            BestPeerRequirements::EthVersion(ver) => self.capabilities.supports_eth_at_least(ver),
-            BestPeerRequirements::None |
-            BestPeerRequirements::FullBlock |
-            BestPeerRequirements::FullBlockRange(_) => true,
-        }
-    }
-
    /// Returns true if this peer has a better range than the other peer for serving the requested
    /// range.
    ///
@@ -651,7 +602,6 @@ pub(crate) enum DownloadRequest<N: NetworkPrimitives> {
        request: Vec<B256>,
        response: oneshot::Sender<PeerRequestResult<BlockAccessLists>>,
        priority: Priority,
-        requirement: BalRequirement,
    },
    /// Download receipts for the given block hashes and send response through channel
    GetReceipts {
@@ -689,21 +639,6 @@ impl<N: NetworkPrimitives> DownloadRequest<N> {
        self.get_priority().is_normal()
    }

-    /// Returns `true` if this is an optional BAL request.
-    const fn is_optional_bal(&self) -> bool {
-        matches!(self, Self::GetBlockAccessLists { requirement: BalRequirement::Optional, .. })
-    }
-
-    /// Sends an error response to the waiting caller.
-    fn send_err_response(self, err: RequestError) {
-        let _ = match self {
-            Self::GetBlockHeaders { response, .. } => response.send(Err(err)).ok(),
-            Self::GetBlockBodies { response, .. } => response.send(Err(err)).ok(),
-            Self::GetBlockAccessLists { response, .. } => response.send(Err(err)).ok(),
-            Self::GetReceipts { response, .. } => response.send(Err(err)).ok(),
-        };
-    }
-
    /// Returns the best peer requirements for this request.
    fn best_peer_requirements(&self) -> BestPeerRequirements {
        match self {
@@ -1469,98 +1404,6 @@ mod tests {
        assert!(matches!(outcome, Some(BlockResponseOutcome::Request(pid, _)) if pid == peer_id));
    }

-    #[tokio::test]
-    async fn test_followup_skips_request_peer_cannot_serve() {
-        let (mut fetcher, peer_id) = fetcher_with_peer();
-
-        let peer_71 = B512::random();
-        let caps_71 = Arc::new(Capabilities::from(vec![Capability::new("eth".into(), 71)]));
-        fetcher.new_active_peer(
-            peer_71,
-            B256::random(),
-            100,
-            caps_71,
-            Arc::new(AtomicU64::new(10)),
-            None,
-        );
-        fetcher.peers.get_mut(&peer_71).expect("peer exists").state = PeerState::GetBlockHeaders;
-
-        let (followup_tx, _followup_rx) = oneshot::channel();
-        fetcher.queued_requests.push_back(DownloadRequest::GetBlockAccessLists {
-            request: vec![B256::random()],
-            response: followup_tx,
-            priority: Priority::Normal,
-            requirement: BalRequirement::Optional,
-        });
-
-        let _rx = insert_inflight_receipts(&mut fetcher, peer_id);
-
-        let resp = ReceiptsResponse::new(vec![vec![]]);
-        assert!(fetcher.on_receipts_response(peer_id, Ok(resp)).is_none());
-        assert!(fetcher.peers[&peer_id].state.is_idle());
-        assert!(!fetcher.inflight_bals_requests.contains_key(&peer_id));
-        assert!(matches!(
-            fetcher.queued_requests.front(),
-            Some(DownloadRequest::GetBlockAccessLists {
-                requirement: BalRequirement::Optional,
-                ..
-            })
-        ));
-    }
-
-    #[tokio::test]
-    async fn test_followup_uses_first_satisfiable_request() {
-        let (mut fetcher, peer_id) = fetcher_with_peer();
-
-        let peer_71 = B512::random();
-        let caps_71 = Arc::new(Capabilities::from(vec![Capability::new("eth".into(), 71)]));
-        fetcher.new_active_peer(
-            peer_71,
-            B256::random(),
-            100,
-            caps_71,
-            Arc::new(AtomicU64::new(10)),
-            None,
-        );
-        fetcher.peers.get_mut(&peer_71).expect("peer exists").state = PeerState::GetBlockHeaders;
-
-        let (bal_tx, _bal_rx) = oneshot::channel();
-        fetcher.queued_requests.push_back(DownloadRequest::GetBlockAccessLists {
-            request: vec![B256::random()],
-            response: bal_tx,
-            priority: Priority::Normal,
-            requirement: BalRequirement::Optional,
-        });
-
-        let (bodies_tx, _bodies_rx) = oneshot::channel();
-        fetcher.queued_requests.push_back(DownloadRequest::GetBlockBodies {
-            request: vec![B256::random()],
-            response: bodies_tx,
-            priority: Priority::Normal,
-            range_hint: None,
-        });
-
-        let _rx = insert_inflight_receipts(&mut fetcher, peer_id);
-
-        let resp = ReceiptsResponse::new(vec![vec![]]);
-        let outcome = fetcher.on_receipts_response(peer_id, Ok(resp));
-
-        assert!(matches!(
-            outcome,
-            Some(BlockResponseOutcome::Request(pid, BlockRequest::GetBlockBodies(_))) if pid == peer_id
-        ));
-        assert!(fetcher.inflight_bodies_requests.contains_key(&peer_id));
-        assert!(matches!(fetcher.peers[&peer_id].state, PeerState::GetBlockBodies));
-        assert_eq!(fetcher.queued_requests.len(), 1);
-        assert!(matches!(
-            fetcher.queued_requests.front(),
-            Some(DownloadRequest::GetBlockAccessLists {
-                requirement: BalRequirement::Optional,
-                ..
-            })
-        ));
-    }
-
    #[tokio::test]
    async fn test_prepare_block_request_creates_inflight_receipts() {
        let (mut fetcher, peer_id) = fetcher_with_peer();
@@ -1698,7 +1541,6 @@ mod tests {
            request: vec![],
            response: tx,
            priority: Priority::Normal,
-            requirement: BalRequirement::Mandatory,
        });

        let waker = noop_waker();
@@ -1741,138 +1583,4 @@ mod tests {
            assert_eq!(peer_id, peer_71);
        }
    }
-
-    #[tokio::test]
-    async fn test_optional_bal_request_rejected_without_eth71_peer() {
-        use futures::task::noop_waker;
-        use std::task::{Context, Poll};
-
-        let manager = PeersManager::new(PeersConfig::default());
-        let mut fetcher =
-            StateFetcher::<EthNetworkPrimitives>::new(manager.handle(), Default::default());
-
-        let peer_old = B512::random();
-        let caps_old = Arc::new(Capabilities::new(vec![]));
-        fetcher.new_active_peer(
-            peer_old,
-            B256::random(),
-            100,
-            caps_old,
-            Arc::new(AtomicU64::new(10)),
-            None,
-        );
-
-        let (tx, rx) = oneshot::channel();
-        fetcher
-            .download_requests_tx
-            .send(DownloadRequest::GetBlockAccessLists {
-                request: vec![],
-                response: tx,
-                priority: Priority::Normal,
-                requirement: BalRequirement::Optional,
-            })
-            .unwrap();
-
-        let waker = noop_waker();
-        let mut cx = Context::from_waker(&waker);
-
-        assert!(matches!(fetcher.poll(&mut cx), Poll::Pending));
-        assert!(fetcher.queued_requests.is_empty());
-        assert_eq!(rx.await.unwrap().unwrap_err(), RequestError::UnsupportedCapability);
-    }
-
-    #[tokio::test]
-    async fn test_optional_bal_request_waits_for_busy_eth71_peer() {
-        use futures::task::noop_waker;
-        use std::task::{Context, Poll};
-
-        let manager = PeersManager::new(PeersConfig::default());
-        let mut fetcher =
-            StateFetcher::<EthNetworkPrimitives>::new(manager.handle(), Default::default());
-
-        let peer_71 = B512::random();
-        let caps_71 = Arc::new(Capabilities::from(vec![Capability::new("eth".into(), 71)]));
-        fetcher.new_active_peer(
-            peer_71,
-            B256::random(),
-            100,
-            caps_71,
-            Arc::new(AtomicU64::new(10)),
-            None,
-        );
-        fetcher.peers.get_mut(&peer_71).expect("peer exists").state = PeerState::GetBlockHeaders;
-
-        let (tx, _rx) = oneshot::channel();
-        fetcher
-            .download_requests_tx
-            .send(DownloadRequest::GetBlockAccessLists {
-                request: vec![],
-                response: tx,
-                priority: Priority::Normal,
-                requirement: BalRequirement::Optional,
-            })
-            .unwrap();
-
-        let waker = noop_waker();
-        let mut cx = Context::from_waker(&waker);
-
-        assert!(matches!(fetcher.poll(&mut cx), Poll::Pending));
-        assert_eq!(fetcher.queued_requests.len(), 1);
-    }
-
-    #[tokio::test]
-    async fn test_queued_optional_bal_request_rejected_after_eth71_disconnect() {
-        use futures::task::noop_waker;
-        use std::task::{Context, Poll};
-
-        let manager = PeersManager::new(PeersConfig::default());
-        let mut fetcher =
-            StateFetcher::<EthNetworkPrimitives>::new(manager.handle(), Default::default());
-
-        let peer_old = B512::random();
-        let caps_old = Arc::new(Capabilities::new(vec![]));
-        fetcher.new_active_peer(
-            peer_old,
-            B256::random(),
-            100,
-            caps_old,
-            Arc::new(AtomicU64::new(10)),
-            None,
-        );
-
-        let peer_71 = B512::random();
-        let caps_71 = Arc::new(Capabilities::from(vec![Capability::new("eth".into(), 71)]));
-        fetcher.new_active_peer(
-            peer_71,
-            B256::random(),
-            100,
-            caps_71,
-            Arc::new(AtomicU64::new(10)),
-            None,
-        );
-        fetcher.peers.get_mut(&peer_71).expect("peer exists").state = PeerState::GetBlockHeaders;
-
-        let (tx, rx) = oneshot::channel();
-        fetcher
-            .download_requests_tx
-            .send(DownloadRequest::GetBlockAccessLists {
-                request: vec![],
-                response: tx,
-                priority: Priority::Normal,
-                requirement: BalRequirement::Optional,
-            })
-            .unwrap();
-
-        let waker = noop_waker();
-        let mut cx = Context::from_waker(&waker);
-
-        assert!(matches!(fetcher.poll(&mut cx), Poll::Pending));
-        assert_eq!(fetcher.queued_requests.len(), 1);
-
-        fetcher.on_session_closed(&peer_71);
-
-        assert!(matches!(fetcher.poll(&mut cx), Poll::Pending));
-        assert!(fetcher.queued_requests.is_empty());
-        assert_eq!(rx.await.unwrap().unwrap_err(), RequestError::UnsupportedCapability);
-    }
 }
--- a/crates/net/network/src/manager.rs
+++ b/crates/net/network/src/manager.rs
@@ -26,7 +26,7 @@ use crate::{
    message::{NewBlockMessage, PeerMessage},
    metrics::{
        BackedOffPeersMetrics, ClosedSessionsMetrics, DirectionalDisconnectMetrics, NetworkMetrics,
-        PendingSessionFailureMetrics,
+        PendingSessionFailureMetrics, NETWORK_POOL_TRANSACTIONS_SCOPE,
    },
    network::{NetworkHandle, NetworkHandleMessage},
    peers::{BackoffReason, PeersManager},
@@ -44,7 +44,7 @@ use parking_lot::Mutex;
 use reth_chainspec::EnrForkIdEntry;
 use reth_eth_wire::{DisconnectReason, EthNetworkPrimitives, NetworkPrimitives};
 use reth_fs_util::{self as fs, FsPathError};
-use reth_metrics::common::mpsc::MemoryBoundedSender;
+use reth_metrics::common::mpsc::UnboundedMeteredSender;
 use reth_network_api::{
    events::{PeerEvent, SessionInfo},
    test_utils::PeersHandle,
@@ -118,7 +118,7 @@ pub struct NetworkManager<N: NetworkPrimitives = EthNetworkPrimitives> {
    event_sender: EventSender<NetworkEvent<PeerRequest<N>>>,
    /// Sender half to send events to the
    /// [`TransactionsManager`](crate::transactions::TransactionsManager) task, if configured.
-    to_transactions_manager: Option<MemoryBoundedSender<NetworkTransactionEvent<N>>>,
+    to_transactions_manager: Option<UnboundedMeteredSender<NetworkTransactionEvent<N>>>,
    /// Sender half to send events to the
    /// [`EthRequestHandler`](crate::eth_requests::EthRequestHandler) task, if configured.
    ///
@@ -175,7 +175,7 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
    /// [`TransactionsManager`](crate::transactions::TransactionsManager).
    pub fn with_transactions(
        mut self,
-        tx: MemoryBoundedSender<NetworkTransactionEvent<N>>,
+        tx: mpsc::UnboundedSender<NetworkTransactionEvent<N>>,
    ) -> Self {
        self.set_transactions(tx);
        self
@@ -183,8 +183,9 @@ impl<N: NetworkPrimitives> NetworkManager<N> {

    /// Sets the dedicated channel for events intended for the
    /// [`TransactionsManager`](crate::transactions::TransactionsManager).
-    pub fn set_transactions(&mut self, tx: MemoryBoundedSender<NetworkTransactionEvent<N>>) {
-        self.to_transactions_manager = Some(tx);
+    pub fn set_transactions(&mut self, tx: mpsc::UnboundedSender<NetworkTransactionEvent<N>>) {
+        self.to_transactions_manager =
+            Some(UnboundedMeteredSender::new(tx, NETWORK_POOL_TRANSACTIONS_SCOPE));
    }

    /// Sets the dedicated channel for events intended for the
@@ -317,7 +318,6 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
            extra_protocols,
            handshake,
            eth_max_message_size,
-            network_mode.is_stake(),
        );

        let state = NetworkState::new(
@@ -495,16 +495,8 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
    /// Sends an event to the [`TransactionsManager`](crate::transactions::TransactionsManager) if
    /// configured.
    fn notify_tx_manager(&self, event: NetworkTransactionEvent<N>) {
-        if let Some(ref tx) = self.to_transactions_manager &&
-            let Err(e) = tx.try_send(event)
-        {
-            match e {
-                TrySendError::Full(_) => {
-                    trace!(target: "net", "Transaction events channel at capacity, dropping event");
-                    self.metrics.total_dropped_tx_events_at_full_capacity.increment(1);
-                }
-                TrySendError::Closed(_) => {}
-            }
+        if let Some(ref tx) = self.to_transactions_manager {
+            let _ = tx.send(event);
        }
    }

@@ -772,7 +764,7 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
            NetworkHandleMessage::AddRlpxSubProtocol(proto) => self.add_rlpx_sub_protocol(proto),
            NetworkHandleMessage::GetTransactionsHandle(tx) => {
                if let Some(ref tx_inner) = self.to_transactions_manager {
-                    let _ = tx_inner.try_send(NetworkTransactionEvent::GetTransactionsHandle(tx));
+                    let _ = tx_inner.send(NetworkTransactionEvent::GetTransactionsHandle(tx));
                } else {
                    let _ = tx.send(None);
                }
--- a/crates/net/network/src/metrics.rs
+++ b/crates/net/network/src/metrics.rs
@@ -46,9 +46,6 @@ pub struct NetworkMetrics {
    /// Number of Eth Requests dropped due to channel being at full capacity
    pub(crate) total_dropped_eth_requests_at_full_capacity: Counter,

-    /// Number of transaction events dropped due to the tx manager channel being at full capacity
-    pub(crate) total_dropped_tx_events_at_full_capacity: Counter,
-
    /* ================ POLL DURATION ================ */

    /* -- Total poll duration of `NetworksManager` future -- */
@@ -580,9 +577,6 @@ pub struct AnnouncedTxTypesMetrics {

    /// Histogram for tracking frequency of EIP-7702 transaction type
    pub(crate) eip7702: Histogram,
-
-    /// Histogram for tracking frequency of unknown/other transaction types
-    pub(crate) other: Histogram,
 }

 /// Counts the number of transactions by their type in a block or collection.
@@ -605,9 +599,6 @@ pub struct TxTypesCounter {

    /// Count of transactions conforming to EIP-7702 (Restricted Storage Windows).
    pub(crate) eip7702: usize,
-
-    /// Count of unknown/other transaction types not matching any known EIP.
-    pub(crate) other: usize,
 }

 impl TxTypesCounter {
@@ -630,10 +621,6 @@ impl TxTypesCounter {
            }
        }
    }
-
-    pub(crate) const fn increase_other(&mut self) {
-        self.other += 1;
-    }
 }

 impl AnnouncedTxTypesMetrics {
@@ -645,6 +632,5 @@ impl AnnouncedTxTypesMetrics {
        self.eip1559.record(tx_types_counter.eip1559 as f64);
        self.eip4844.record(tx_types_counter.eip4844 as f64);
        self.eip7702.record(tx_types_counter.eip7702 as f64);
-        self.other.record(tx_types_counter.other as f64);
    }
 }
--- a/crates/net/network/src/session/active.rs
+++ b/crates/net/network/src/session/active.rs
@@ -79,9 +79,6 @@ const TIMEOUT_SCALING: u32 = 3;
 /// before reading any more messages from the remote peer, throttling the peer.
 const MAX_QUEUED_OUTGOING_RESPONSES: usize = 4;

-/// Minimum capacity to retain for buffered incoming requests from the remote peer.
-const MIN_RECEIVED_REQUESTS_CAPACITY: usize = 1;
-
 /// Soft limit for the total number of buffered outgoing broadcast items (e.g. transaction hashes).
 ///
 /// Many small broadcast messages carrying a single tx hash each are equivalent in cost to one
@@ -207,8 +204,8 @@ impl<N: NetworkPrimitives> ActiveSession<N> {

    /// Shrinks the capacity of the internal buffers.
    pub fn shrink_to_fit(&mut self) {
-        self.received_requests_from_remote.shrink_to(MIN_RECEIVED_REQUESTS_CAPACITY);
-        self.queued_outgoing.shrink_to(MAX_QUEUED_OUTGOING_RESPONSES);
+        self.received_requests_from_remote.shrink_to_fit();
+        self.queued_outgoing.shrink_to_fit();
    }

    /// Returns how many responses we've currently queued up.
@@ -1093,8 +1090,8 @@ impl<N: NetworkPrimitives> QueuedOutgoingMessages<N> {
        self.count.increment(1);
    }

-    pub(crate) fn shrink_to(&mut self, min_capacity: usize) {
-        self.messages.shrink_to(min_capacity);
+    pub(crate) fn shrink_to_fit(&mut self) {
+        self.messages.shrink_to_fit();
    }
 }

--- a/crates/net/network/src/session/conn.rs
+++ b/crates/net/network/src/session/conn.rs
@@ -93,15 +93,6 @@ impl<N: NetworkPrimitives> EthRlpxConnection<N> {
            Self::Satellite(conn) => conn.primary_mut().start_send_raw(msg),
        }
    }
-
-    /// Sets whether to reject block announcement messages (`NewBlock`, `NewBlockHashes`) before
-    /// RLP decoding to avoid memory amplification from deserializing blocks that will be discarded.
-    pub fn set_reject_block_announcements(&mut self, reject: bool) {
-        match self {
-            Self::EthOnly(conn) => conn.set_reject_block_announcements(reject),
-            Self::Satellite(conn) => conn.primary_mut().set_reject_block_announcements(reject),
-        }
-    }
 }

 impl<N: NetworkPrimitives> From<EthPeerConnection<N>> for EthRlpxConnection<N> {
--- a/crates/net/network/src/session/mod.rs
+++ b/crates/net/network/src/session/mod.rs
@@ -123,9 +123,6 @@ pub struct SessionManager<N: NetworkPrimitives> {
    /// Shared local range information that gets propagated to active sessions.
    /// This represents the range of blocks that this node can serve to other peers.
    local_range_info: BlockRangeInfo,
-    /// When true, block announcement messages (`NewBlock`, `NewBlockHashes`) are rejected before
-    /// RLP decoding on new sessions to avoid memory amplification.
-    reject_block_announcements: bool,
 }

 // === impl SessionManager ===
@@ -143,7 +140,6 @@ impl<N: NetworkPrimitives> SessionManager<N> {
        extra_protocols: RlpxSubProtocols,
        handshake: Arc<dyn EthRlpxHandshake>,
        eth_max_message_size: usize,
-        reject_block_announcements: bool,
    ) -> Self {
        let (pending_sessions_tx, pending_sessions_rx) = mpsc::channel(config.session_event_buffer);
        let (active_session_tx, active_session_rx) = mpsc::channel(config.session_event_buffer);
@@ -180,7 +176,6 @@ impl<N: NetworkPrimitives> SessionManager<N> {
            handshake,
            eth_max_message_size,
            local_range_info,
-            reject_block_announcements,
        }
    }

@@ -501,7 +496,7 @@ impl<N: NetworkPrimitives> SessionManager<N> {
                local_addr,
                peer_id,
                capabilities,
-                mut conn,
+                conn,
                status,
                direction,
                client_id,
@@ -568,10 +563,6 @@ impl<N: NetworkPrimitives> SessionManager<N> {
                    BlockRangeInfo::new(update.earliest, update.latest, update.latest_hash)
                });

-                if self.reject_block_announcements {
-                    conn.set_reject_block_announcements(true);
-                }
-
                let session = ActiveSession {
                    next_id: 0,
                    remote_peer_id: peer_id,
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dan Cline	f57b37442f	wip: add dm-delay simulation	2026-04-22 15:03:17 -04:00
Dan Cline	a7a8ed0ae1	wip: add latency simulation	2026-04-22 13:40:53 -04:00