diff --git a/.config/zepter.yaml b/.config/zepter.yaml
index f38688f8224..7aa1bd725ef 100644
--- a/.config/zepter.yaml
+++ b/.config/zepter.yaml
@@ -12,7 +12,7 @@ workflows:
         # Check that `A` activates the features of `B`.
         "propagate-feature",
         # These are the features to check:
-        "--features=std,op,dev,asm-keccak,jemalloc,jemalloc-prof,tracy-allocator,tracy,serde-bincode-compat,serde,test-utils,arbitrary,bench,alloy-compat,min-error-logs,min-warn-logs,min-info-logs,min-debug-logs,min-trace-logs,otlp,otlp-logs,js-tracer,portable,keccak-cache-global,trie-debug",
+        "--features=std,op,dev,asm-keccak,jemalloc,jemalloc-prof,tracy-allocator,tracy,serde-bincode-compat,serde,test-utils,arbitrary,bench,alloy-compat,min-error-logs,min-warn-logs,min-info-logs,min-debug-logs,min-trace-logs,otlp,otlp-logs,js-tracer,portable,keccak-cache-global,trie-debug,secp256k1",
         # Do not try to add a new section to `[features]` of `A` only because `B` exposes that feature. There are edge-cases where this is still needed, but we can add them manually.
         "--left-side-feature-missing=ignore",
         # Ignore the case that `A` it outside of the workspace. Otherwise it will report errors in external dependencies that we have no influence on.
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 1568a186acb..dd3bbafb412 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -45,7 +45,6 @@ crates/tracing-otlp/        @mattsse @Rjected
 crates/transaction-pool/    @mattsse @yongkangc
 crates/trie/                @Rjected @shekhirin @mediocregopher @yongkangc
 bin/reth/                   @mattsse @shekhirin @Rjected 
-bin/reth-bench/             @mattsse @Rjected @shekhirin @yongkangc 
 bin/reth-bench-compare/     @mediocregopher @shekhirin @yongkangc
 etc/                        @Rjected @shekhirin
 .github/                    @gakonst @DaniPopes
diff --git a/.github/config/bench-metrics-targets.json b/.github/config/bench-metrics-targets.json
new file mode 100644
index 00000000000..3e2140c6494
--- /dev/null
+++ b/.github/config/bench-metrics-targets.json
@@ -0,0 +1,97 @@
+{
+  "counters": [
+    {
+      "query": "sum(reth_database_transaction_opened_total{mode=\"read-write\"})",
+      "target": "decrease",
+      "floor_pct": 10.0,
+      "min_value_pct_total_latency": 0.0
+    },
+    {
+      "query": "sum(reth_database_transaction_opened_total{mode=\"read-only\"})",
+      "target": "decrease",
+      "floor_pct": 7.5,
+      "min_value_pct_total_latency": 0.0
+    }
+  ],
+  "histograms": [
+    {
+      "query": "reth_sync_block_validation_state_root_histogram",
+      "target": "decrease",
+      "floor_pct": 5.0,
+      "min_value_pct_total_latency": 5.0
+    },
+    {
+      "query": "reth_trie_proof_task_account_worker_idle_time_seconds",
+      "target": "increase",
+      "floor_pct": 7.5,
+      "min_value_pct_total_latency": 0.0
+    },
+    {
+      "query": "reth_trie_proof_task_storage_worker_idle_time_seconds",
+      "target": "increase",
+      "floor_pct": 5.0,
+      "min_value_pct_total_latency": 0.0
+    },
+    {
+      "query": "reth_tree_root_sparse_trie_idle_time_seconds",
+      "target": "increase",
+      "floor_pct": 7.5,
+      "min_value_pct_total_latency": 15.0
+    },
+    {
+      "query": "reth_tree_root_hashing_task_idle_time_seconds",
+      "target": "increase",
+      "floor_pct": 5.0,
+      "min_value_pct_total_latency": 0.0
+    },
+    {
+      "query": "reth_database_transaction_close_duration_seconds",
+      "target": "decrease",
+      "floor_pct": 5.0,
+      "min_value_pct_total_latency": 14.3
+    },
+    {
+      "query": "reth_pruner_duration_seconds",
+      "target": "decrease",
+      "floor_pct": 7.5,
+      "min_value_pct_total_latency": 0.0
+    },
+    {
+      "query": "reth_storage_providers_database_save_blocks_commit_mdbx",
+      "target": "decrease",
+      "floor_pct": 5.0,
+      "min_value_pct_total_latency": 13.6
+    },
+    {
+      "query": "reth_storage_providers_database_save_blocks_commit_rocksdb",
+      "target": "decrease",
+      "floor_pct": 2.5,
+      "min_value_pct_total_latency": 0.8
+    },
+    {
+      "query": "reth_storage_providers_database_save_blocks_mdbx",
+      "target": "decrease",
+      "floor_pct": 5.0,
+      "min_value_pct_total_latency": 0.0,
+      "unit": "seconds"
+    },
+    {
+      "query": "reth_storage_providers_database_save_blocks_rocksdb",
+      "target": "decrease",
+      "floor_pct": 2.5,
+      "min_value_pct_total_latency": 14.2
+    },
+    {
+      "query": "reth_storage_providers_database_save_blocks_sf",
+      "target": "decrease",
+      "floor_pct": 2.5,
+      "min_value_pct_total_latency": 5.4
+    },
+    {
+      "query": "reth_sync_block_validation_deferred_trie_compute_duration",
+      "target": "decrease",
+      "floor_pct": 2.5,
+      "min_value_pct_total_latency": 1.4
+    }
+  ]
+}
diff --git a/.github/scripts/bench-benchmarkoor-run.sh b/.github/scripts/bench-benchmarkoor-run.sh
new file mode 100755
index 00000000000..723806ab079
--- /dev/null
+++ b/.github/scripts/bench-benchmarkoor-run.sh
@@ -0,0 +1,872 @@
+#!/usr/bin/env bash
+#
+# Runs benchmarkoor-replay against a Reth datadir mounted by schelk.
+#
+# Usage:
+#   bench-benchmarkoor-run.sh prepare <binary> <output-dir>
+#   bench-benchmarkoor-run.sh run <label> <binary> <output-dir> <tests-jsonl>
+#   bench-benchmarkoor-run.sh restart-node <binary> <label> <output-dir> <phase> <log>
+#
+# The prepare mode starts Reth on the imported snapshot and replays benchmarkoor's
+# gas-bump/funding prerun. With BENCH_RESET_STRATEGY=schelk, it promotes that
+# state as the schelk baseline. With BENCH_RESET_STRATEGY=unwind, it leaves the
+# scratch volume mounted at the post-prerun head and later uses Reth unwind to
+# reset each test.
+#
+# The run mode resets to the post-prerun baseline for each test, starts Reth,
+# then delegates the measured setup/testing split to benchmarkoor-replay's native
+# `run-many --mode setup-then-testing --json` mode. The restart-node mode is
+# invoked by benchmarkoor-replay between setup and measured testing.
+set -euo pipefail
+
+MODE="${1:?mode is required}"
+shift
+
+: "${SCHELK_MOUNT:?SCHELK_MOUNT must be set}"
+: "${BENCHMARKOOR_BIN:?BENCHMARKOOR_BIN must be set}"
+: "${BENCHMARKOOR_SUITE:?BENCHMARKOOR_SUITE must be set}"
+: "${BENCHMARKOOR_CONTEXT:?BENCHMARKOOR_CONTEXT must be set}"
+: "${BENCHMARKOOR_FORK:?BENCHMARKOOR_FORK must be set}"
+: "${BENCHMARKOOR_TEST_TYPE:?BENCHMARKOOR_TEST_TYPE must be set}"
+: "${BENCHMARKOOR_METADATA_ROOT:?BENCHMARKOOR_METADATA_ROOT must be set}"
+: "${BENCHMARKOOR_CACHE:?BENCHMARKOOR_CACHE must be set}"
+
+SCRIPT_PATH="$(readlink -f "$0")"
+DATADIR="${SCHELK_MOUNT}/datadir"
+JWT_SECRET="${DATADIR}/jwt.hex"
+RETH_SCOPE="${RETH_SCOPE:-reth-benchmarkoor.scope}"
+ENGINE_URL="${BENCHMARKOOR_ENGINE_URL:-http://127.0.0.1:8551}"
+HTTP_URL="http://127.0.0.1:8545"
+ENGINE_HOST="127.0.0.1"
+ENGINE_PORT="8551"
+
+TAIL_PID=""
+CURRENT_LOG=""
+RESET_TIMINGS_FILE=""
+
+cleanup() {
+  if [ -n "${TAIL_PID:-}" ]; then
+    kill "$TAIL_PID" 2>/dev/null || true
+  fi
+  sudo systemctl stop "$RETH_SCOPE" 2>/dev/null || true
+  sudo systemctl reset-failed "$RETH_SCOPE" 2>/dev/null || true
+}
+
+if [ "$MODE" != "restart-node" ]; then
+  trap cleanup EXIT
+fi
+
+safe_name() {
+  printf '%s' "$1" | sed -E 's/[^A-Za-z0-9_.-]+/-/g; s/^-+//; s/-+$//' | cut -c1-180
+}
+
+now_ns() {
+  date +%s%N
+}
+
+elapsed_secs() {
+  local start_ns="$1"
+  local end_ns
+  end_ns="$(now_ns)"
+  awk -v ns="$(( end_ns - start_ns ))" 'BEGIN { printf "%.6f", ns / 1000000000 }'
+}
+
+record_reset_timing() {
+  local step="$1"
+  local elapsed_secs="$2"
+  local status="${3:-0}"
+
+  if [ -n "${RESET_TIMINGS_FILE:-}" ]; then
+    echo "Reset timing: ${step}=${elapsed_secs}s status=${status}"
+    jq -nc \
+      --arg step "$step" \
+      --argjson elapsed_secs "$elapsed_secs" \
+      --argjson status "$status" \
+      '{step: $step, elapsed_secs: $elapsed_secs, status: $status}' >> "$RESET_TIMINGS_FILE"
+  fi
+}
+
+time_reset_step() {
+  local step="$1"
+  shift
+
+  local start_ns elapsed status
+  start_ns="$(now_ns)"
+  set +e
+  "$@"
+  status="$?"
+  set -e
+  elapsed="$(elapsed_secs "$start_ns")"
+  record_reset_timing "$step" "$elapsed" "$status"
+  return "$status"
+}
+
+reset_strategy() {
+  case "${BENCH_RESET_STRATEGY:-schelk}" in
+    unwind | schelk) printf '%s\n' "${BENCH_RESET_STRATEGY:-schelk}" ;;
+    *)
+      echo "::error::BENCH_RESET_STRATEGY must be 'unwind' or 'schelk', got '${BENCH_RESET_STRATEGY}'"
+      exit 1
+      ;;
+  esac
+}
+
+ensure_jwt_secret() {
+  sudo mkdir -p "$DATADIR"
+  if ! sudo test -s "$JWT_SECRET"; then
+    local secret
+    secret="$(od -An -N32 -tx1 /dev/urandom | tr -d ' \n')"
+    printf '%s\n' "$secret" | sudo tee "$JWT_SECRET" >/dev/null
+    sudo chmod 0600 "$JWT_SECRET"
+  fi
+}
+
+drop_caches() {
+  time_reset_step "drop_caches.sync" sync
+  time_reset_step "drop_caches.write" sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches'
+  time_reset_step "drop_caches.free" free -h
+  time_reset_step "drop_caches.meminfo" grep Cached /proc/meminfo
+}
+
+rpc_call() {
+  local method="$1"
+  local params="${2:-[]}"
+  curl -sf "$HTTP_URL" -X POST \
+    -H 'Content-Type: application/json' \
+    -d "{\"jsonrpc\":\"2.0\",\"method\":\"${method}\",\"params\":${params},\"id\":1}"
+}
+
+wait_for_engine_port() {
+  local label="$1"
+  local phase="$2"
+  local deadline
+  deadline=$((SECONDS + 30))
+
+  while [ "$SECONDS" -lt "$deadline" ]; do
+    if timeout 0.1 bash -c "</dev/tcp/${ENGINE_HOST}/${ENGINE_PORT}" 2>/dev/null; then
+      return 0
+    fi
+    sleep 0.05
+  done
+
+  echo "::error::reth (${label}/${phase}) engine port ${ENGINE_HOST}:${ENGINE_PORT} did not open within 30s"
+  cat "$CURRENT_LOG"
+  exit 1
+}
+
+snapshot_block_number() {
+  local block="${BENCHMARKOOR_SUITE#*/}"
+  if [[ "$block" =~ ^[0-9]+$ ]]; then
+    printf '%s\n' "$block"
+  fi
+}
+
+wait_for_snapshot_pipeline() {
+  local expected_block timeout start_ns deadline
+  expected_block="$(snapshot_block_number)"
+  timeout="${BENCH_SNAPSHOT_PIPELINE_TIMEOUT_SECS:-300}"
+  start_ns="$(now_ns)"
+  deadline=$((SECONDS + timeout))
+
+  if [ -n "$expected_block" ]; then
+    echo "Waiting for Reth snapshot pipeline to finish at block ${expected_block}"
+  else
+    echo "Waiting for Reth snapshot pipeline to finish"
+  fi
+
+  while [ "$SECONDS" -lt "$deadline" ]; do
+    local sync_response block_response block_hex block_dec
+    sync_response="$(rpc_call eth_syncing 2>/dev/null || true)"
+    if jq -e '.result == false' <<< "$sync_response" >/dev/null 2>&1; then
+      block_response="$(rpc_call eth_blockNumber 2>/dev/null || true)"
+      block_hex="$(jq -er '.result' <<< "$block_response" 2>/dev/null || true)"
+      if [[ "$block_hex" =~ ^0x[0-9a-fA-F]+$ ]]; then
+        block_dec=$(( 16#${block_hex#0x} ))
+        if [ -z "$expected_block" ] || [ "$block_dec" -ge "$expected_block" ]; then
+          echo "Reth snapshot pipeline finished after $(elapsed_secs "$start_ns")s at block ${block_dec}"
+          return 0
+        fi
+      elif [ -z "$expected_block" ]; then
+        echo "Reth snapshot pipeline finished after $(elapsed_secs "$start_ns")s"
+        return 0
+      fi
+    fi
+    sleep 0.05
+  done
+
+  echo "::error::reth snapshot pipeline did not finish within ${timeout}s before benchmarkoor prerun"
+  cat "$CURRENT_LOG"
+  exit 1
+}
+
+prerun_head_file() {
+  if [ -n "${BENCH_PRERUN_HEAD_FILE:-}" ]; then
+    printf '%s\n' "$BENCH_PRERUN_HEAD_FILE"
+  elif [ -n "${BENCH_WORK_DIR:-}" ]; then
+    printf '%s\n' "${BENCH_WORK_DIR}/prerun-head.json"
+  else
+    printf '%s\n' "${SCHELK_MOUNT}/prerun-head.json"
+  fi
+}
+
+write_prerun_head_marker() {
+  local marker head_hex head_dec block_hash
+  marker="$(prerun_head_file)"
+  head_hex="$(rpc_call eth_blockNumber | jq -er '.result')"
+  head_dec=$(( 16#${head_hex#0x} ))
+  block_hash="$(rpc_call eth_getBlockByNumber "[\"${head_hex}\",false]" | jq -er '.result.hash')"
+  mkdir -p "$(dirname "$marker")"
+  jq -n \
+    --argjson number "$head_dec" \
+    --arg number_hex "$head_hex" \
+    --arg hash "$block_hash" \
+    '{number: $number, number_hex: $number_hex, hash: $hash}' > "$marker"
+  echo "Recorded post-prerun head ${head_dec} (${block_hash}) in ${marker}"
+}
+
+reth_db_capture() {
+  local binary="$1"
+  shift
+
+  local -a db_args=(db)
+  if [ -f "$DATADIR/genesis.json" ]; then
+    db_args+=(--chain "$DATADIR/genesis.json")
+  fi
+  db_args+=(--datadir "$DATADIR" "$@")
+
+  sudo "$binary" "${db_args[@]}" 2>&1
+}
+
+has_table_content() {
+  local output="$1"
+  [ -n "$output" ] && [[ "$output" != *"No content for the given table key"* ]]
+}
+
+has_header_content() {
+  local output="$1"
+  has_table_content "$output" && {
+    [[ "$output" == *"BlockHash"* ]] || [[ "$output" == *"parent_hash"* ]]
+  }
+}
+
+parse_stage_checkpoint_block() {
+  sed -nE 's/.*block_number: ([0-9]+).*/\1/p' | head -n 1
+}
+
+output_has_expected_hash() {
+  local output="$1"
+  local expected_hash="$2"
+  has_table_content "$output" && grep -qi "${expected_hash#0x}" <<< "$output"
+}
+
+finish_stage_matches() {
+  local binary="$1"
+  local expected_number="$2"
+  local finish finish_number
+  finish="$(reth_db_capture "$binary" stage-checkpoints get --stage finish || true)"
+  finish_number="$(parse_stage_checkpoint_block <<< "$finish")"
+  [ -n "$finish_number" ] && [ "$finish_number" -eq "$expected_number" ]
+}
+
+persisted_prerun_head_present() {
+  local binary="$1"
+  local expected_number="$2"
+  local expected_hash="$3"
+  local canonical header
+
+  header="$(reth_db_capture "$binary" get static-file headers "$expected_number" || true)"
+  if has_header_content "$header" && output_has_expected_hash "$header" "$expected_hash"; then
+    finish_stage_matches "$binary" "$expected_number"
+    return $?
+  fi
+
+  canonical="$(reth_db_capture "$binary" get mdbx CanonicalHeaders "$expected_number" || true)"
+  if output_has_expected_hash "$canonical" "$expected_hash"; then
+    header="$(reth_db_capture "$binary" get mdbx Headers "$expected_number" || true)"
+    if has_header_content "$header"; then
+      finish_stage_matches "$binary" "$expected_number"
+      return $?
+    fi
+  fi
+
+  return 1
+}
+
+print_prerun_persistence_diagnostics() {
+  local binary="$1"
+  local expected_number="$2"
+  echo "Static-file header:"
+  reth_db_capture "$binary" get static-file headers "$expected_number" || true
+  echo "Finish stage checkpoint:"
+  reth_db_capture "$binary" stage-checkpoints get --stage finish || true
+  echo "CanonicalHeaders:"
+  reth_db_capture "$binary" get mdbx CanonicalHeaders "$expected_number" || true
+  echo "MDBX header:"
+  reth_db_capture "$binary" get mdbx Headers "$expected_number" || true
+}
+
+wait_for_persisted_prerun_head() {
+  local binary="$1"
+  local required="${2:-true}"
+  local marker
+  marker="$(prerun_head_file)"
+  [ -f "$marker" ] || return 0
+
+  local expected_number expected_hash
+  expected_number="$(jq -er '.number' "$marker")"
+  expected_hash="$(jq -er '.hash' "$marker")"
+
+  for i in $(seq 1 120); do
+    if persisted_prerun_head_present "$binary" "$expected_number" "$expected_hash"; then
+      echo "Post-prerun head ${expected_number} (${expected_hash}) is persisted and committed after ${i}s"
+      return 0
+    fi
+    sleep 1
+  done
+
+  if [ "$required" != "true" ]; then
+    echo "Post-prerun head ${expected_number} (${expected_hash}) was not confirmed by static files and Finish checkpoint after 120s"
+    return 1
+  fi
+
+  echo "::error::Post-prerun head ${expected_number} (${expected_hash}) was not confirmed by static files and Finish checkpoint"
+  print_prerun_persistence_diagnostics "$binary" "$expected_number"
+  exit 1
+}
+
+reth_stage_unwind() {
+  local binary="$1"
+  local target="$2"
+
+  local -a unwind_args=(stage unwind)
+  if [ -f "$DATADIR/genesis.json" ]; then
+    unwind_args+=(--chain "$DATADIR/genesis.json")
+  fi
+  unwind_args+=(--datadir "$DATADIR" to-block "$target")
+
+  sudo "$binary" "${unwind_args[@]}"
+}
+
+unwind_to_prerun_head() {
+  local binary="$1"
+  local marker
+  marker="$(prerun_head_file)"
+  if [ ! -f "$marker" ]; then
+    echo "::error::Missing post-prerun head marker at ${marker}; cannot use unwind reset strategy"
+    exit 1
+  fi
+
+  local expected_number expected_hash start elapsed finish finish_number
+  expected_number="$(jq -er '.number' "$marker")"
+  expected_hash="$(jq -er '.hash' "$marker")"
+
+  start="$(now_ns)"
+  echo "Unwinding Reth datadir to post-prerun head ${expected_number} (${expected_hash})"
+  reth_stage_unwind "$binary" "$expected_number"
+  elapsed="$(elapsed_secs "$start")"
+
+  finish="$(reth_db_capture "$binary" stage-checkpoints get --stage finish || true)"
+  finish_number="$(parse_stage_checkpoint_block <<< "$finish")"
+  if [ "$finish_number" != "$expected_number" ]; then
+    echo "::error::Finish stage checkpoint is ${finish_number:-unknown}, expected ${expected_number} after unwind"
+    echo "$finish"
+    exit 1
+  fi
+  if ! persisted_prerun_head_present "$binary" "$expected_number" "$expected_hash"; then
+    echo "::error::Post-prerun head ${expected_number} (${expected_hash}) was not present after unwind"
+    print_prerun_persistence_diagnostics "$binary" "$expected_number"
+    exit 1
+  fi
+  echo "Unwind reset completed in ${elapsed}s"
+}
+
+stop_node() {
+  if [ -n "${TAIL_PID:-}" ]; then
+    kill "$TAIL_PID" 2>/dev/null || true
+    TAIL_PID=""
+  fi
+  sudo systemctl stop "$RETH_SCOPE" 2>/dev/null || true
+  sudo systemctl reset-failed "$RETH_SCOPE" 2>/dev/null || true
+}
+
+stop_node_required() {
+  if [ -n "${TAIL_PID:-}" ]; then
+    kill "$TAIL_PID" 2>/dev/null || true
+    TAIL_PID=""
+  fi
+
+  if sudo systemctl list-units --all --full --no-legend "$RETH_SCOPE" | grep -q "$RETH_SCOPE"; then
+    if ! sudo systemctl stop "$RETH_SCOPE"; then
+      echo "::error::Failed to stop reth systemd scope ${RETH_SCOPE}"
+      sudo systemctl status "$RETH_SCOPE" --no-pager || true
+      exit 1
+    fi
+  fi
+  sudo systemctl reset-failed "$RETH_SCOPE" 2>/dev/null || true
+}
+
+recover_schelk() {
+  time_reset_step "stop_node" stop_node
+  time_reset_step "schelk.recover" sudo schelk recover -y --kill
+  time_reset_step "schelk.mount" sudo schelk mount -y
+  if [ ! -d "$DATADIR/db" ] || [ ! -d "$DATADIR/static_files" ]; then
+    echo "::error::Failed to mount benchmark datadir at ${DATADIR}"
+    ls -la "$SCHELK_MOUNT" || true
+    ls -la "$DATADIR" || true
+    exit 1
+  fi
+  drop_caches
+}
+
+reset_to_prerun_state() {
+  local binary="$1"
+  local strategy
+  strategy="$(reset_strategy)"
+
+  case "$strategy" in
+    schelk)
+      recover_schelk
+      ;;
+    unwind)
+      time_reset_step "stop_node" stop_node_required
+      time_reset_step "reth.unwind" unwind_to_prerun_head "$binary"
+      drop_caches
+      ;;
+  esac
+}
+
+finalize_run_state() {
+  local binary="$1"
+  local strategy
+  strategy="$(reset_strategy)"
+
+  case "$strategy" in
+    schelk)
+      sudo schelk recover -y --kill || true
+      ;;
+    unwind)
+      stop_node_required
+      unwind_to_prerun_head "$binary"
+      ;;
+  esac
+}
+
+start_node() {
+  local binary="$1"
+  local label="$2"
+  local output_dir="$3"
+  local phase="$4"
+  local log_path="${5:-}"
+  local append_log="${6:-false}"
+  local follow_log="${7:-true}"
+
+  mkdir -p "${output_dir}/logs"
+  if [ -z "$log_path" ]; then
+    log_path="${output_dir}/logs/$(safe_name "${label}-${phase}").log"
+  fi
+  CURRENT_LOG="$log_path"
+  if [ "$append_log" = "true" ]; then
+    : >> "$CURRENT_LOG"
+  else
+    : > "$CURRENT_LOG"
+  fi
+
+  stop_node
+  ensure_jwt_secret
+
+  local online max_reth reth_cpus
+  online="$(nproc --all)"
+  max_reth=$(( online - 1 ))
+  if [ "${BENCH_CORES:-0}" -gt 0 ] && [ "$BENCH_CORES" -lt "$max_reth" ]; then
+    max_reth="$BENCH_CORES"
+  fi
+  if [ "$max_reth" -lt 1 ]; then
+    reth_cpus="0"
+  else
+    reth_cpus="1-${max_reth}"
+  fi
+
+  local -a reth_args=(
+    node
+    --datadir "$DATADIR"
+    --log.file.directory "$output_dir/reth-logs"
+    --engine.accept-execution-requests-hash
+    --http
+    --http.port 8545
+    --ws
+    --ws.api all
+    --authrpc.port 8551
+    --authrpc.jwtsecret "$JWT_SECRET"
+    --disable-discovery
+    --no-persist-peers
+  )
+
+  if [ -f "$DATADIR/genesis.json" ]; then
+    reth_args+=(--chain "$DATADIR/genesis.json")
+  fi
+
+  local node_help
+  node_help="$("$binary" node --help 2>/dev/null || true)"
+
+  if grep -qF -- '--debug.startup-sync-state-idle' <<< "$node_help"; then
+    reth_args+=(--debug.startup-sync-state-idle)
+  fi
+
+  if [[ "$phase" == "prerun" || "$phase" == *-setup ]] &&
+    grep -qF -- '--engine.persistence-threshold' <<< "$node_help" &&
+    grep -qF -- '--engine.persistence-backpressure-threshold' <<< "$node_help"; then
+    reth_args+=(--engine.persistence-threshold 0 --engine.persistence-backpressure-threshold 1)
+  fi
+
+  local extra_node_args=""
+  case "$label" in
+    baseline*) extra_node_args="${BENCH_BASELINE_ARGS:-}" ;;
+    feature*) extra_node_args="${BENCH_FEATURE_ARGS:-}" ;;
+  esac
+  if [ -n "$extra_node_args" ]; then
+    # shellcheck disable=SC2206
+    reth_args+=($extra_node_args)
+  fi
+
+  if [ -n "${BENCH_METRICS_ADDR:-}" ]; then
+    reth_args+=(--metrics "$BENCH_METRICS_ADDR")
+  fi
+
+  local mem_limit
+  mem_limit="${BENCH_MEMORY_MAX:-32G}"
+  if [ -z "$mem_limit" ] || [ "$mem_limit" = "0" ]; then
+    local total_mem_kb
+    total_mem_kb="$(awk '/^MemTotal:/ {print $2}' /proc/meminfo)"
+    mem_limit=$(( total_mem_kb * 95 / 100 * 1024 ))
+  fi
+
+  echo "Starting reth (${label}/${phase}) with AllowedCPUs=${reth_cpus}, MemoryMax=${mem_limit}"
+
+  sudo systemd-run --quiet --scope --collect --unit="$RETH_SCOPE" \
+    -p MemoryMax="$mem_limit" -p AllowedCPUs="$reth_cpus" \
+    nice -n -20 "$binary" "${reth_args[@]}" \
+    >> "$CURRENT_LOG" 2>&1 &
+
+  if [ "$follow_log" = "true" ]; then
+    stdbuf -oL tail -f "$CURRENT_LOG" | sed -u "s/^/[reth] /" &
+    TAIL_PID=$!
+  fi
+
+  wait_for_engine_port "$label" "$phase"
+}
+
+benchmarkoor_common_args() {
+  local binary="$1"
+  local schelk_bin="$2"
+  printf '%s\0' \
+    --suite "$BENCHMARKOOR_SUITE" \
+    --context "$BENCHMARKOOR_CONTEXT" \
+    --fork "$BENCHMARKOOR_FORK" \
+    --test-type "$BENCHMARKOOR_TEST_TYPE" \
+    --metadata-root "$BENCHMARKOOR_METADATA_ROOT" \
+    --cache-dir "$BENCHMARKOOR_CACHE" \
+    --engine-url "$ENGINE_URL" \
+    --jwt-secret "$JWT_SECRET" \
+    --reth-bin "$binary" \
+    --schelk-bin "$schelk_bin"
+}
+
+run_benchmarkoor() {
+  sudo env \
+    "PATH=$PATH" \
+    "SCHELK_MOUNT=$SCHELK_MOUNT" \
+    "RETH_SCOPE=$RETH_SCOPE" \
+    "BENCHMARKOOR_BIN=$BENCHMARKOOR_BIN" \
+    "BENCHMARKOOR_SUITE=$BENCHMARKOOR_SUITE" \
+    "BENCHMARKOOR_CONTEXT=$BENCHMARKOOR_CONTEXT" \
+    "BENCHMARKOOR_FORK=$BENCHMARKOOR_FORK" \
+    "BENCHMARKOOR_TEST_TYPE=$BENCHMARKOOR_TEST_TYPE" \
+    "BENCHMARKOOR_METADATA_ROOT=$BENCHMARKOOR_METADATA_ROOT" \
+    "BENCHMARKOOR_CACHE=$BENCHMARKOOR_CACHE" \
+    "BENCH_CORES=${BENCH_CORES:-6}" \
+    "BENCH_MEMORY_MAX=${BENCH_MEMORY_MAX:-32G}" \
+    "BENCH_RESET_STRATEGY=${BENCH_RESET_STRATEGY:-schelk}" \
+    "BENCH_PRERUN_HEAD_FILE=${BENCH_PRERUN_HEAD_FILE:-}" \
+    "BENCH_BASELINE_ARGS=${BENCH_BASELINE_ARGS:-}" \
+    "BENCH_FEATURE_ARGS=${BENCH_FEATURE_ARGS:-}" \
+    "BENCH_METRICS_ADDR=${BENCH_METRICS_ADDR:-}" \
+    nice -n -20 "$BENCHMARKOOR_BIN" "$@"
+}
+
+shell_command() {
+  printf '%q ' "$@"
+}
+
+benchmarkoor_failure_status() {
+  local native_out="$1"
+  if grep -q 'newPayload status is INVALID' "$native_out"; then
+    echo "invalid_newpayload"
+  else
+    echo "error"
+  fi
+}
+
+benchmarkoor_failure_phase() {
+  local native_out="$1"
+  if grep -q '/setup/' "$native_out"; then
+    echo "setup"
+  elif grep -q '/testing/' "$native_out"; then
+    echo "testing"
+  else
+    echo "unknown"
+  fi
+}
+
+benchmarkoor_error_summary() {
+  local native_out="$1"
+  { grep -E 'newPayload status is|JSON-RPC error|Error:|Caused by:' "$native_out" || true; } |
+    tail -n 12 |
+    sed -E 's/[[:space:]]+/ /g' |
+    paste -sd ' ' - |
+    cut -c1-1200
+}
+
+append_benchmarkoor_failure_result() {
+  local native_out="$1"
+  local test_name="$2"
+  local gas_bucket="$3"
+  local label="$4"
+  local run_type="$5"
+  local strategy="$6"
+  local reset_elapsed_secs="$7"
+  local reset_timings_json="$8"
+  local reset_timing_steps_json="$9"
+  local wall_elapsed_secs="${10}"
+  local benchmarkoor_status="${11}"
+  local results="${12}"
+
+  local status phase error_summary
+  status="$(benchmarkoor_failure_status "$native_out")"
+  phase="$(benchmarkoor_failure_phase "$native_out")"
+  error_summary="$(benchmarkoor_error_summary "$native_out")"
+  if [ -z "$error_summary" ]; then
+    error_summary="benchmarkoor-replay exited with status ${benchmarkoor_status}"
+  fi
+
+  jq -nc \
+    --arg suite "$BENCHMARKOOR_SUITE" \
+    --arg test "$test_name" \
+    --arg label "$label" \
+    --arg run_type "$run_type" \
+    --arg gas_bucket "$gas_bucket" \
+    --arg reset_strategy "$strategy" \
+    --arg status "$status" \
+    --arg phase "$phase" \
+    --arg error_summary "$error_summary" \
+    --argjson reset_elapsed_secs "$reset_elapsed_secs" \
+    --argjson reset_timings "$reset_timings_json" \
+    --argjson reset_timing_steps "$reset_timing_steps_json" \
+    --argjson wall_elapsed_secs "$wall_elapsed_secs" \
+    --argjson benchmarkoor_exit_code "$benchmarkoor_status" \
+    '{
+      kind: "run_many_result",
+      status: $status,
+      suite: $suite,
+      test: $test,
+      label: $label,
+      run_type: $run_type,
+      gas_bucket: $gas_bucket,
+      reset_strategy: $reset_strategy,
+      reset_elapsed_secs: $reset_elapsed_secs,
+      wall_elapsed_secs: $wall_elapsed_secs,
+      benchmarkoor_exit_code: $benchmarkoor_exit_code,
+      invalid_newpayload: ($status == "invalid_newpayload"),
+      invalid_newpayload_phase: (if $status == "invalid_newpayload" then $phase else null end),
+      error_summary: $error_summary,
+      gas: 0,
+      elapsed_ms: 0,
+      gas_per_second: null,
+      testing_gas_per_sec: null,
+      testing_gas_used: 0,
+      testing_elapsed: null,
+      reset_timings: $reset_timings,
+      reset_timing_steps: $reset_timing_steps
+    }' >> "$results"
+}
+
+if [ "$MODE" = "restart-node" ]; then
+  binary="${1:?binary is required}"
+  label="${2:?label is required}"
+  output_dir="${3:?output directory is required}"
+  phase="${4:?phase is required}"
+  log_path="${5:?log path is required}"
+  start_node "$binary" "$label" "$output_dir" "$phase" "$log_path" true false
+  exit 0
+fi
+
+if [ "$MODE" = "prepare" ]; then
+  binary="${1:?binary is required}"
+  output_dir="${2:?output directory is required}"
+  mkdir -p "$output_dir"
+  strategy="$(reset_strategy)"
+
+  recover_schelk
+  start_node "$binary" "prepare" "$output_dir" "prerun"
+  wait_for_snapshot_pipeline
+
+  sudo_schelk="${output_dir}/sudo-schelk"
+  cat > "$sudo_schelk" <<'SH'
+#!/usr/bin/env bash
+exec sudo schelk "$@" -y
+SH
+  chmod +x "$sudo_schelk"
+
+  mapfile -d '' common < <(benchmarkoor_common_args "$binary" "$sudo_schelk")
+  run_benchmarkoor "${common[@]}" baseline prepare --no-mount
+  write_prerun_head_marker
+
+  stop_node_required
+  wait_for_persisted_prerun_head "$binary" true
+  if [ "$strategy" = "schelk" ]; then
+    sudo schelk promote -y
+    echo "Promoted schelk baseline after benchmarkoor gas-bump/funding"
+  else
+    echo "Prepared unwind baseline after benchmarkoor gas-bump/funding"
+  fi
+  sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches'
+  exit 0
+fi
+
+if [ "$MODE" != "run" ]; then
+  echo "Usage: $0 prepare <binary> <output-dir> | run <label> <binary> <output-dir> <tests-jsonl> | restart-node <binary> <label> <output-dir> <phase> <log>"
+  exit 1
+fi
+
+label="${1:?label is required}"
+binary="${2:?binary is required}"
+output_dir="${3:?output directory is required}"
+tests_jsonl="${4:?tests jsonl is required}"
+results="${output_dir}/results.jsonl"
+mkdir -p "$output_dir/logs"
+: > "$results"
+
+strategy="$(reset_strategy)"
+mapfile -d '' common < <(benchmarkoor_common_args "$binary" "schelk")
+run_type="feature"
+if [[ "$label" == baseline* ]]; then
+  run_type="baseline"
+fi
+
+selected_count="$(grep -cve '^[[:space:]]*$' "$tests_jsonl" || true)"
+completed_count=0
+recorded_failure_count=0
+
+while IFS= read -r test_entry; do
+  [ -n "$test_entry" ] || continue
+  test_name="$(jq -r '.name' <<< "$test_entry")"
+  gas_bucket="$(jq -r '.gas_bucket // ""' <<< "$test_entry")"
+  test_slug="$(safe_name "$test_name")"
+  log_path="${output_dir}/logs/$(safe_name "${label}-${test_slug}").log"
+  native_out="${output_dir}/native-$(safe_name "$test_slug").jsonl"
+  reset_timings_file="${output_dir}/reset-timings-$(safe_name "${label}-${test_slug}").jsonl"
+  : > "$reset_timings_file"
+  before_count="$(wc -l < "$results" | tr -d ' ')"
+  test_start_ns="$(now_ns)"
+  reset_start_ns="$(now_ns)"
+
+  echo "=== ${label}: ${test_name} ==="
+  RESET_TIMINGS_FILE="$reset_timings_file"
+  reset_to_prerun_state "$binary"
+  reset_elapsed_secs="$(elapsed_secs "$reset_start_ns")"
+  reset_timing_steps_json="$(jq -sc '.' "$reset_timings_file")"
+  reset_timings_json="$(jq -sc 'map({(.step): .elapsed_secs}) | add // {}' "$reset_timings_file")"
+  RESET_TIMINGS_FILE=""
+  start_node "$binary" "$label" "$output_dir" "${test_slug}-setup" "$log_path" false true
+
+  restart_command="$(
+    shell_command "$SCRIPT_PATH" restart-node "$binary" "$label" "$output_dir" "${test_slug}-testing" "$log_path"
+  )"
+
+  set +e
+  run_benchmarkoor "${common[@]}" run-many \
+    --exact "$test_name" \
+    --limit 1 \
+    --repetitions 1 \
+    --mode setup-then-testing \
+    --no-schelk \
+    --drop-caches \
+    --restart-node-command "$restart_command" \
+    --json 2>&1 | tee "$native_out"
+  pipeline_status=("${PIPESTATUS[@]}")
+  set -e
+  benchmarkoor_status="${pipeline_status[0]}"
+  tee_status="${pipeline_status[1]}"
+  if [ "$tee_status" -ne 0 ]; then
+    echo "::error::tee failed while recording benchmarkoor output for ${test_name}"
+    exit 1
+  fi
+
+  wall_elapsed_secs="$(elapsed_secs "$test_start_ns")"
+  echo "=== ${label}: ${test_name} completed in ${wall_elapsed_secs}s (reset=${reset_elapsed_secs}s, strategy=${strategy}) ==="
+
+  jq -Rnc \
+    --arg label "$label" \
+    --arg run_type "$run_type" \
+    --arg gas_bucket "$gas_bucket" \
+    --arg reset_strategy "$strategy" \
+    --argjson reset_elapsed_secs "$reset_elapsed_secs" \
+    --argjson reset_timings "$reset_timings_json" \
+    --argjson reset_timing_steps "$reset_timing_steps_json" \
+    --argjson wall_elapsed_secs "$wall_elapsed_secs" \
+    'inputs | fromjson? | select(.kind == "run_many_result") |
+      . + {
+        status: (.status // "ok"),
+        invalid_newpayload: (.invalid_newpayload // false),
+        label: $label,
+        run_type: $run_type,
+        gas_bucket: $gas_bucket,
+        reset_strategy: $reset_strategy,
+        reset_elapsed_secs: $reset_elapsed_secs,
+        reset_timings: $reset_timings,
+        reset_timing_steps: $reset_timing_steps,
+        wall_elapsed_secs: $wall_elapsed_secs
+      }' \
+    "$native_out" >> "$results"
+
+  after_count="$(wc -l < "$results" | tr -d ' ')"
+  emitted_count=$(( after_count - before_count ))
+  if [ "$benchmarkoor_status" -ne 0 ]; then
+    echo "::warning::benchmarkoor-replay failed for ${test_name}; recording failure and continuing"
+    append_benchmarkoor_failure_result \
+      "$native_out" \
+      "$test_name" \
+      "$gas_bucket" \
+      "$label" \
+      "$run_type" \
+      "$strategy" \
+      "$reset_elapsed_secs" \
+      "$reset_timings_json" \
+      "$reset_timing_steps_json" \
+      "$wall_elapsed_secs" \
+      "$benchmarkoor_status" \
+      "$results"
+    recorded_failure_count=$(( recorded_failure_count + 1 ))
+  elif [ "$emitted_count" -le 0 ]; then
+    echo "::warning::benchmarkoor-replay did not emit a run_many_result for ${test_name}; recording failure and continuing"
+    append_benchmarkoor_failure_result \
+      "$native_out" \
+      "$test_name" \
+      "$gas_bucket" \
+      "$label" \
+      "$run_type" \
+      "$strategy" \
+      "$reset_elapsed_secs" \
+      "$reset_timings_json" \
+      "$reset_timing_steps_json" \
+      "$wall_elapsed_secs" \
+      0 \
+      "$results"
+    recorded_failure_count=$(( recorded_failure_count + 1 ))
+  fi
+
+  completed_count=$(( completed_count + 1 ))
+done < "$tests_jsonl"
+
+echo "Completed ${completed_count}/${selected_count} selected benchmarkoor test(s) for ${label}; recorded ${recorded_failure_count} replay failure(s)"
+finalize_run_state "$binary"
+echo "results=${results}"
diff --git a/.github/scripts/bench-benchmarkoor-snapshot.sh b/.github/scripts/bench-benchmarkoor-snapshot.sh
new file mode 100755
index 00000000000..99a5b47b546
--- /dev/null
+++ b/.github/scripts/bench-benchmarkoor-snapshot.sh
@@ -0,0 +1,289 @@
+#!/usr/bin/env bash
+#
+# Downloads a Reth snapshot from a MinIO manifest into the schelk scratch volume
+# and promotes it as the schelk baseline. The later prerun step promotes again
+# after gas-bump/funding.
+#
+# Required env:
+#   SCHELK_MOUNT
+#   BENCHMARKOOR_BIN
+#   BENCHMARKOOR_SUITE
+#   BENCHMARKOOR_CONTEXT
+#   BENCHMARKOOR_FORK
+#   BENCHMARKOOR_TEST_TYPE
+#   BENCHMARKOOR_METADATA_ROOT
+#   BENCHMARKOOR_CACHE
+#   BENCHMARKOOR_SNAPSHOT
+#   BENCH_RETH_BINARY
+#
+# Optional env:
+#   BENCHMARKOOR_SNAPSHOT_MC_ROOT  MinIO alias/root used when
+#                                  BENCHMARKOOR_SNAPSHOT is a bare prefix.
+set -euo pipefail
+
+: "${SCHELK_MOUNT:?SCHELK_MOUNT must be set}"
+: "${BENCHMARKOOR_BIN:?BENCHMARKOOR_BIN must be set}"
+: "${BENCHMARKOOR_SUITE:?BENCHMARKOOR_SUITE must be set}"
+: "${BENCHMARKOOR_CONTEXT:?BENCHMARKOOR_CONTEXT must be set}"
+: "${BENCHMARKOOR_FORK:?BENCHMARKOOR_FORK must be set}"
+: "${BENCHMARKOOR_TEST_TYPE:?BENCHMARKOOR_TEST_TYPE must be set}"
+: "${BENCHMARKOOR_METADATA_ROOT:?BENCHMARKOOR_METADATA_ROOT must be set}"
+: "${BENCHMARKOOR_CACHE:?BENCHMARKOOR_CACHE must be set}"
+: "${BENCHMARKOOR_SNAPSHOT:?BENCHMARKOOR_SNAPSHOT must be set}"
+: "${BENCH_RETH_BINARY:?BENCH_RETH_BINARY must be set}"
+
+DATADIR="${SCHELK_MOUNT}/datadir"
+SNAPSHOT_DIR="${BENCHMARKOOR_CACHE}/snapshots"
+mkdir -p "$SNAPSHOT_DIR"
+
+trim_slashes() {
+  printf '%s' "$1" | sed -E 's:/*$::'
+}
+
+copy_source_to_file() {
+  local source="$1"
+  local dest="$2"
+
+  if [ -f "$source" ]; then
+    cp "$source" "$dest"
+  elif [[ "$source" =~ ^https?:// ]]; then
+    curl -fsSL --retry 3 --retry-delay 5 "$source" -o "$dest"
+  else
+    mc cp "$source" "$dest"
+  fi
+}
+
+source_exists() {
+  local source="$1"
+  if [ -f "$source" ]; then
+    return 0
+  fi
+  if [[ "$source" =~ ^https?:// ]]; then
+    curl -fsI --retry 2 --retry-delay 2 "$source" >/dev/null 2>&1 ||
+      curl -fsSL --retry 2 --retry-delay 2 --range 0-0 "$source" -o /dev/null >/dev/null 2>&1
+    return $?
+  fi
+  mc stat "$source" >/dev/null 2>&1
+}
+
+mc_alias_url() {
+  local alias="$1"
+  mc alias export "$alias" 2>/dev/null | jq -r '.url // empty'
+}
+
+mc_object_http_url() {
+  local object="$1"
+  local alias rest alias_url
+
+  alias="${object%%/*}"
+  rest="${object#*/}"
+  alias_url="$(mc_alias_url "$alias" || true)"
+  if [ -z "$alias_url" ] || [ "$rest" = "$object" ]; then
+    return 1
+  fi
+
+  printf '%s/%s\n' "$(trim_slashes "$alias_url")" "$rest"
+}
+
+mc_manifest_base_url() {
+  local manifest_object="$1"
+  local alias rest alias_url
+
+  alias="${manifest_object%%/*}"
+  rest="${manifest_object#*/}"
+  alias_url="$(mc_alias_url "$alias" || true)"
+  if [ -z "$alias_url" ] || [ "$rest" = "$manifest_object" ]; then
+    return 1
+  fi
+
+  printf '%s/%s\n' "$(trim_slashes "$alias_url")" "$(dirname "$rest")"
+}
+
+resolve_manifest_object() {
+  local source="$1"
+  local root="${BENCHMARKOOR_SNAPSHOT_MC_ROOT:-minio}"
+  local candidate candidate_url found
+
+  if [ -d "$source" ] && [ -f "$(trim_slashes "$source")/manifest.json" ]; then
+    printf '%s\n' "$(trim_slashes "$source")/manifest.json"
+    return 0
+  fi
+
+  if [[ "$source" =~ ^https?:// ]]; then
+    if [[ "$(basename "$source")" == "manifest.json" ]]; then
+      candidate="$source"
+    else
+      candidate="$(trim_slashes "$source")/manifest.json"
+    fi
+    if source_exists "$candidate"; then
+      printf '%s\n' "$candidate"
+      return 0
+    fi
+    return 1
+  fi
+
+  if [[ "$(basename "$source")" == "manifest.json" ]] && source_exists "$source"; then
+    printf '%s\n' "$source"
+    return 0
+  fi
+  if [[ "$(basename "$source")" == "manifest.json" ]]; then
+    candidate_url="$(mc_object_http_url "$source" || true)"
+    if [ -n "$candidate_url" ] && source_exists "$candidate_url"; then
+      printf '%s\n' "$candidate_url"
+      return 0
+    fi
+  fi
+
+  candidate="$(trim_slashes "$source")/manifest.json"
+  if source_exists "$candidate"; then
+    printf '%s\n' "$candidate"
+    return 0
+  fi
+  candidate_url="$(mc_object_http_url "$candidate" || true)"
+  if [ -n "$candidate_url" ] && source_exists "$candidate_url"; then
+    printf '%s\n' "$candidate_url"
+    return 0
+  fi
+
+  if [[ "$source" != */* ]]; then
+    found="$(
+      mc find "$root" --name manifest.json 2>/dev/null |
+        grep -F "$source" |
+        sort |
+        tail -n 1 || true
+    )"
+    if [ -n "$found" ]; then
+      printf '%s\n' "$found"
+      return 0
+    fi
+  fi
+
+  return 1
+}
+
+log_manifest_lookup_diagnostics() {
+  local source="$1"
+  local root="${BENCHMARKOOR_SNAPSHOT_MC_ROOT:-minio}"
+  local trimmed candidate candidate_url alias alias_url parent
+
+  trimmed="$(trim_slashes "$source")"
+  if [[ "$(basename "$trimmed")" == "manifest.json" ]]; then
+    candidate="$trimmed"
+  else
+    candidate="${trimmed}/manifest.json"
+  fi
+
+  echo "::group::Snapshot manifest lookup diagnostics"
+  echo "BENCHMARKOOR_SNAPSHOT=${source}"
+  echo "BENCHMARKOOR_SNAPSHOT_MC_ROOT=${root}"
+  echo "Candidate manifest: ${candidate}"
+  candidate_url="$(mc_object_http_url "$candidate" || true)"
+  if [ -n "$candidate_url" ]; then
+    echo "Candidate manifest HTTP URL: ${candidate_url}"
+  fi
+
+  if [[ "$source" =~ ^https?:// ]]; then
+    echo "HTTP HEAD for candidate:"
+    curl -fsI --retry 2 --retry-delay 2 "$candidate" || true
+    echo "::endgroup::"
+    return 0
+  fi
+
+  if [ -n "$candidate_url" ]; then
+    echo "HTTP HEAD for candidate manifest URL:"
+    curl -fsI --retry 2 --retry-delay 2 "$candidate_url" || true
+  fi
+
+  alias="${candidate%%/*}"
+  alias_url="$(mc_alias_url "$alias" || true)"
+  if [ -n "$alias_url" ]; then
+    echo "MinIO alias '${alias}' URL: ${alias_url}"
+  else
+    echo "MinIO alias '${alias}' is not configured or has no exported URL"
+  fi
+
+  echo "mc stat candidate:"
+  mc stat "$candidate" || true
+
+  echo "mc ls snapshot prefix:"
+  mc ls "${trimmed}/" || true
+
+  parent="$(dirname "$trimmed")"
+  if [ "$parent" != "." ] && [ "$parent" != "$trimmed" ]; then
+    echo "mc ls parent prefix (${parent}/):"
+    mc ls "${parent}/" || true
+  fi
+
+  echo "Nearby manifest.json objects under ${root}:"
+  mc find "$root" --name manifest.json 2>/dev/null | grep -F "$(basename "$trimmed")" | head -20 || true
+  echo "::endgroup::"
+}
+
+network="${BENCHMARKOOR_SUITE%%/*}"
+block="${BENCHMARKOOR_SUITE#*/}"
+suite_slug="$(
+  printf '%s-%s-%s-%s-%s' \
+    "$network" "$block" "$BENCHMARKOOR_CONTEXT" "$BENCHMARKOOR_FORK" "$BENCHMARKOOR_TEST_TYPE" |
+    sed -E 's/[^A-Za-z0-9_-]+/-/g; s/^-+//; s/-+$//'
+)"
+
+sudo schelk recover -y --kill
+sudo schelk mount -y
+
+if ! manifest_object="$(resolve_manifest_object "$BENCHMARKOOR_SNAPSHOT")"; then
+  log_manifest_lookup_diagnostics "$BENCHMARKOOR_SNAPSHOT"
+  echo "::error::Could not find snapshot manifest for BENCHMARKOOR_SNAPSHOT=${BENCHMARKOOR_SNAPSHOT}"
+  echo "Pass a MinIO manifest path, a MinIO prefix containing manifest.json, or an HTTP(S) manifest URL."
+  exit 1
+fi
+
+manifest_raw="${SNAPSHOT_DIR}/${suite_slug}-manifest.raw.json"
+manifest_path="${SNAPSHOT_DIR}/${suite_slug}-manifest.json"
+copy_source_to_file "$manifest_object" "$manifest_raw"
+
+manifest_base_url=""
+if [[ "$manifest_object" =~ ^https?:// ]]; then
+  manifest_base_url="$(dirname "$manifest_object")"
+elif [[ "$manifest_object" == */* ]]; then
+  manifest_base_url="$(mc_manifest_base_url "$manifest_object" || true)"
+fi
+
+if [ -n "$manifest_base_url" ]; then
+  jq --arg base "$manifest_base_url" '.base_url = $base' "$manifest_raw" > "$manifest_path"
+else
+  cp "$manifest_raw" "$manifest_path"
+fi
+
+sudo rm -rf "$DATADIR"
+sudo mkdir -p "$DATADIR"
+sudo chown -R "$(id -u):$(id -g)" "$DATADIR"
+
+"$BENCH_RETH_BINARY" download \
+  --manifest-path "$manifest_path" \
+  -y \
+  --minimal \
+  --datadir "$DATADIR"
+
+"$BENCHMARKOOR_BIN" \
+  --suite "$BENCHMARKOOR_SUITE" \
+  --context "$BENCHMARKOOR_CONTEXT" \
+  --fork "$BENCHMARKOOR_FORK" \
+  --test-type "$BENCHMARKOOR_TEST_TYPE" \
+  --metadata-root "$BENCHMARKOOR_METADATA_ROOT" \
+  --cache-dir "$BENCHMARKOOR_CACHE" \
+  genesis download \
+  --datadir "$DATADIR"
+
+if [ ! -d "$DATADIR/db" ] || [ ! -d "$DATADIR/static_files" ]; then
+  echo "::error::Manifest download did not produce expected db/ and static_files/ directories"
+  ls -la "$DATADIR" || true
+  exit 1
+fi
+
+echo "Downloaded benchmarkoor snapshot from manifest: ${manifest_object}"
+
+sync
+sudo schelk promote -y --kill
+sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches'
+
+echo "Promoted benchmarkoor snapshot into schelk baseline"
diff --git a/.github/scripts/bench-benchmarkoor-summary.py b/.github/scripts/bench-benchmarkoor-summary.py
new file mode 100755
index 00000000000..435579b71f2
--- /dev/null
+++ b/.github/scripts/bench-benchmarkoor-summary.py
@@ -0,0 +1,313 @@
+#!/usr/bin/env python3
+"""Summarize benchmarkoor-replay gas/second results."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import statistics
+from collections import defaultdict
+from pathlib import Path
+
+
+def fmt_rate(value: float) -> str:
+    if value >= 1_000_000_000:
+        return f"{value / 1_000_000_000:.2f} Ggas/s"
+    if value >= 1_000_000:
+        return f"{value / 1_000_000:.2f} Mgas/s"
+    if value >= 1_000:
+        return f"{value / 1_000:.2f} Kgas/s"
+    return f"{value:.2f} gas/s"
+
+
+def fmt_duration(seconds: float) -> str:
+    if seconds >= 3600:
+        return f"{seconds / 3600:.2f} h"
+    if seconds >= 60:
+        return f"{seconds / 60:.2f} min"
+    return f"{seconds:.2f} s"
+
+
+def fmt_change(value: float | None) -> str:
+    if value is None or not math.isfinite(value):
+        return "n/a"
+    sign = "+" if value >= 0 else ""
+    return f"{sign}{value * 100:.2f}%"
+
+
+def md_escape(value: str) -> str:
+    return value.replace("|", "\\|").replace("\n", " ")
+
+
+def status_label(rows: list[dict]) -> str:
+    if not rows:
+        return "missing"
+
+    labels = []
+    if any(row.get("status", "ok") == "ok" for row in rows):
+        labels.append("ok")
+
+    for row in rows:
+        status = row.get("status", "ok")
+        if status == "ok":
+            continue
+        if status == "invalid_newpayload":
+            phase = row.get("invalid_newpayload_phase") or "unknown"
+            label = f"INVALID newPayload ({phase})"
+        else:
+            label = status
+        if label not in labels:
+            labels.append(label)
+
+    return "; ".join(labels)
+
+
+def median(values: list[float]) -> float:
+    return statistics.median(values) if values else 0.0
+
+
+def summarize_reset_timings(rows: list[dict]) -> dict[str, dict[str, dict[str, float]]]:
+    timing_values: dict[str, dict[str, list[float]]] = defaultdict(lambda: defaultdict(list))
+    for row in rows:
+        run_type = row.get("run_type")
+        timings = row.get("reset_timings")
+        if run_type not in ("baseline", "feature") or not isinstance(timings, dict):
+            continue
+        for step, value in timings.items():
+            try:
+                seconds = float(value)
+            except (TypeError, ValueError):
+                continue
+            if math.isfinite(seconds):
+                timing_values[run_type][step].append(seconds)
+
+    summary = {}
+    for run_type, steps in timing_values.items():
+        summary[run_type] = {}
+        for step, values in sorted(steps.items()):
+            summary[run_type][step] = {
+                "count": len(values),
+                "total_seconds": sum(values),
+                "median_seconds": median(values),
+                "mean_seconds": sum(values) / len(values),
+            }
+    return summary
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--results", required=True, type=Path)
+    parser.add_argument("--output-json", required=True, type=Path)
+    parser.add_argument("--output-markdown", required=True, type=Path)
+    parser.add_argument("--baseline-name", required=True)
+    parser.add_argument("--baseline-ref", required=True)
+    parser.add_argument("--feature-name", required=True)
+    parser.add_argument("--feature-ref", required=True)
+    parser.add_argument("--repo", required=True)
+    args = parser.parse_args()
+
+    rows = [
+        json.loads(line)
+        for line in args.results.read_text().splitlines()
+        if line.strip()
+    ]
+    if not rows:
+        raise SystemExit("no benchmark results found")
+
+    normalized = []
+    for row in rows:
+        row["status"] = row.get("status") or "ok"
+        row["invalid_newpayload"] = bool(row.get("invalid_newpayload", False))
+        if "gas_per_second" not in row:
+            row["gas_per_second"] = (
+                row.get("testing_gas_per_sec") or row.get("gas_per_sec") or 0.0
+            )
+        if "gas" not in row:
+            row["gas"] = row.get("testing_gas_used") or 0
+        if "elapsed_ms" not in row:
+            row["elapsed_ms"] = (row.get("testing_elapsed") or 0.0) * 1000.0
+        normalized.append(row)
+
+    by_test: dict[str, dict[str, list[dict]]] = defaultdict(lambda: defaultdict(list))
+    for row in normalized:
+        by_test[row["test"]][row["run_type"]].append(row)
+
+    tests = []
+    ratios = []
+    for test, groups in sorted(by_test.items()):
+        baseline_rates = [
+            float(row["gas_per_second"] or 0.0)
+            for row in groups.get("baseline", [])
+            if row.get("status") == "ok"
+        ]
+        feature_rates = [
+            float(row["gas_per_second"] or 0.0)
+            for row in groups.get("feature", [])
+            if row.get("status") == "ok"
+        ]
+        baseline_rate = median(baseline_rates)
+        feature_rate = median(feature_rates)
+        change = None
+        if baseline_rate > 0 and feature_rate > 0:
+            change = feature_rate / baseline_rate - 1.0
+            ratios.append(feature_rate / baseline_rate)
+        tests.append(
+            {
+                "test": test,
+                "gas_bucket": (groups.get("feature") or groups.get("baseline") or [{}])[0].get(
+                    "gas_bucket", ""
+                ),
+                "baseline_gas_per_second": baseline_rate,
+                "feature_gas_per_second": feature_rate,
+                "change": change,
+                "baseline_runs": len(baseline_rates),
+                "feature_runs": len(feature_rates),
+                "baseline_status": status_label(groups.get("baseline", [])),
+                "feature_status": status_label(groups.get("feature", [])),
+            }
+        )
+
+    failures = [row for row in normalized if row.get("status") != "ok"]
+    benchmark_rows = [row for row in normalized if row.get("status") == "ok"]
+    reset_timing_summary = summarize_reset_timings(normalized)
+
+    aggregate: dict[str, dict[str, float]] = {}
+    for run_type in ("baseline", "feature"):
+        type_rows = [row for row in benchmark_rows if row["run_type"] == run_type]
+        total_gas = sum(float(row["gas"] or 0.0) for row in type_rows)
+        total_seconds = sum(float(row["elapsed_ms"] or 0.0) / 1000.0 for row in type_rows)
+        total_wall_seconds = sum(
+            float(row.get("wall_elapsed_secs") or row.get("total_elapsed_secs") or 0.0)
+            for row in type_rows
+        )
+        aggregate[run_type] = {
+            "total_gas": total_gas,
+            "total_seconds": total_seconds,
+            "total_wall_seconds": total_wall_seconds,
+            "gas_per_second": total_gas / total_seconds if total_seconds > 0 else 0.0,
+        }
+
+    geomean_change = None
+    if ratios:
+        geomean = math.exp(sum(math.log(ratio) for ratio in ratios) / len(ratios))
+        geomean_change = geomean - 1.0
+
+    total_change = None
+    baseline_total = aggregate["baseline"]["gas_per_second"]
+    feature_total = aggregate["feature"]["gas_per_second"]
+    if baseline_total > 0 and feature_total > 0:
+        total_change = feature_total / baseline_total - 1.0
+    baseline_wall_total = aggregate["baseline"]["total_wall_seconds"]
+    feature_wall_total = aggregate["feature"]["total_wall_seconds"]
+    wall_time_change = None
+    if baseline_wall_total > 0 and feature_wall_total > 0:
+        wall_time_change = feature_wall_total / baseline_wall_total - 1.0
+
+    summary = {
+        "baseline": {"name": args.baseline_name, "ref": args.baseline_ref},
+        "feature": {"name": args.feature_name, "ref": args.feature_ref},
+        "aggregate": aggregate,
+        "changes": {
+            "geomean_gas_per_second": geomean_change,
+            "total_gas_per_second": total_change,
+            "total_wall_time": wall_time_change,
+        },
+        "reset_timing_summary": reset_timing_summary,
+        "tests": tests,
+        "failures": failures,
+        "raw_results": normalized,
+    }
+    args.output_json.parent.mkdir(parents=True, exist_ok=True)
+    args.output_json.write_text(json.dumps(summary, indent=2) + "\n")
+
+    commit_url = f"https://github.com/{args.repo}/commit"
+    diff_url = f"https://github.com/{args.repo}/compare/{args.baseline_ref}...{args.feature_ref}"
+    md = []
+    md.append("# Benchmarkoor Replay\n")
+    md.append(f"**Baseline:** [`{args.baseline_name}`]({commit_url}/{args.baseline_ref})\n")
+    md.append(
+        f"**Feature:** [`{args.feature_name}`]({commit_url}/{args.feature_ref}) ([diff]({diff_url}))\n"
+    )
+    md.append(f"**Tests:** {len(tests)}\n")
+    if failures:
+        md.append(f"**Recorded failures:** {len(failures)}\n")
+    md.append("\n")
+    md.append("| Metric | Baseline | Feature | Change |\n")
+    md.append("|--------|----------|---------|--------|\n")
+    md.append(
+        "| Total measured gas/sec | "
+        f"{fmt_rate(baseline_total)} | {fmt_rate(feature_total)} | {fmt_change(total_change)} |\n"
+    )
+    if baseline_wall_total > 0 or feature_wall_total > 0:
+        md.append(
+            "| Cumulative wall time | "
+            f"{fmt_duration(baseline_wall_total)} | {fmt_duration(feature_wall_total)} | "
+            f"{fmt_change(wall_time_change)} |\n"
+        )
+    md.append(
+        "| Per-test geomean gas/sec | "
+        f"n/a | n/a | {fmt_change(geomean_change)} |\n\n"
+    )
+    if reset_timing_summary:
+        steps = sorted(
+            {
+                step
+                for run_type in reset_timing_summary.values()
+                for step in run_type.keys()
+            }
+        )
+        md.append("## Reset Timing\n\n")
+        md.append("| Step | Baseline total | Baseline median | Feature total | Feature median |\n")
+        md.append("|------|----------------|-----------------|---------------|----------------|\n")
+        for step in steps:
+            baseline_timing = reset_timing_summary.get("baseline", {}).get(step)
+            feature_timing = reset_timing_summary.get("feature", {}).get(step)
+            baseline_total = (
+                fmt_duration(baseline_timing["total_seconds"]) if baseline_timing else "n/a"
+            )
+            baseline_median = (
+                fmt_duration(baseline_timing["median_seconds"]) if baseline_timing else "n/a"
+            )
+            feature_total = (
+                fmt_duration(feature_timing["total_seconds"]) if feature_timing else "n/a"
+            )
+            feature_median = (
+                fmt_duration(feature_timing["median_seconds"]) if feature_timing else "n/a"
+            )
+            md.append(
+                f"| `{md_escape(step)}` | {baseline_total} | {baseline_median} | "
+                f"{feature_total} | {feature_median} |\n"
+            )
+        md.append("\n")
+
+    md.append("| Test | Gas | Baseline | Feature | Change | Status |\n")
+    md.append("|------|-----|----------|---------|--------|--------|\n")
+    for item in tests:
+        md.append(
+            f"| `{item['test']}` | {item['gas_bucket'] or 'n/a'} | "
+            f"{fmt_rate(item['baseline_gas_per_second'])} | "
+            f"{fmt_rate(item['feature_gas_per_second'])} | "
+            f"{fmt_change(item['change'])} | "
+            f"B: {md_escape(item['baseline_status'])}<br>F: {md_escape(item['feature_status'])} |\n"
+        )
+
+    if failures:
+        md.append("\n## Recorded Failures\n\n")
+        md.append("| Run | Test | Status | Phase | Error |\n")
+        md.append("|-----|------|--------|-------|-------|\n")
+        for row in failures:
+            phase = row.get("invalid_newpayload_phase") or "unknown"
+            md.append(
+                f"| {md_escape(str(row.get('label', '')))} | "
+                f"`{md_escape(str(row.get('test', '')))}` | "
+                f"{md_escape(str(row.get('status', 'error')))} | "
+                f"{md_escape(str(phase))} | "
+                f"{md_escape(str(row.get('error_summary', '')))} |\n"
+            )
+
+    args.output_markdown.write_text("".join(md))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/scripts/bench-job-summary.js b/.github/scripts/bench-job-summary.js
index 21caf88c7d0..6187aad008f 100644
--- a/.github/scripts/bench-job-summary.js
+++ b/.github/scripts/bench-job-summary.js
@@ -1,4 +1,4 @@
-// Generates a rich GitHub Actions job summary for reth-bench results.
+// Generates a rich GitHub Actions job summary for benchmark results.
 //
 // Reads from environment:
 //   BENCH_WORK_DIR       – Directory containing summary.json
@@ -7,16 +7,39 @@
 //   BENCH_CORES          – CPU core limit (0 = all)
 //   BENCH_WARMUP_BLOCKS  – Number of warmup blocks
 //   BENCH_SAMPLY         – 'true' if samply profiling was enabled
-//   BENCH_ABBA           – 'true' if ABBA interleaved order was used
+//   BENCH_TRACING_CHROME – 'true' if Chrome trace recording was enabled
+//   BENCH_RUN_PAIRS      – Number of configured benchmark run pairs
 //
 // Usage from actions/github-script:
 //   const jobSummary = require('./.github/scripts/bench-job-summary.js');
-//   await jobSummary({ core, context, chartSha, grafanaUrl, runId });
+//   await jobSummary({ core, context, chartSha, grafanaUrl, logsUrl, tracesUrl, runId });
 
 const fs = require('fs');
-const { verdict, loadSamplyUrls, blocksLabel, metricRows, waitTimeRows } = require('./bench-utils');
+const {
+  verdict,
+  loadSamplyUrls,
+  loadTracingChromeUrls,
+  blocksLabel,
+  metricRows,
+  waitTimeRows,
+  fmtChange,
+} = require('./bench-utils');
 
-module.exports = async function ({ core, context, chartSha, grafanaUrl, runId }) {
+function fmtMetricValue(v) {
+  if (v === null || v === undefined || !Number.isFinite(v)) return 'n/a';
+  const abs = Math.abs(v);
+  if ((abs !== 0 && abs < 0.001) || abs >= 100000) return v.toExponential(3);
+  if (abs < 1) return v.toPrecision(3);
+  if (abs < 100) return v.toFixed(3).replace(/0+$/, '').replace(/\.$/, '');
+  return v.toFixed(1).replace(/\.0$/, '');
+}
+
+function fmtTargetMetricValue(metric, v) {
+  if (metric.unit === 'seconds') return `${(v * 1000).toFixed(2)}ms`;
+  return fmtMetricValue(v);
+}
+
+module.exports = async function ({ core, context, chartSha, grafanaUrl, logsUrl, tracesUrl, runId }) {
   let summary;
   try {
     summary = JSON.parse(fs.readFileSync(process.env.BENCH_WORK_DIR + '/summary.json', 'utf8'));
@@ -31,6 +54,10 @@ module.exports = async function ({ core, context, chartSha, grafanaUrl, runId })
   const commitUrl = `https://github.com/${repo}/commit`;
 
   const { emoji, label } = verdict(summary.changes);
+  const observability = summary.observability || {};
+  const resolvedGrafanaUrl = grafanaUrl || observability.grafana_url;
+  const resolvedLogsUrl = logsUrl || observability.logs_url;
+  const resolvedTracesUrl = tracesUrl || observability.traces_url;
   const baselineLink = `[\`${summary.baseline.name}\`](${commitUrl}/${summary.baseline.ref})`;
   const featureLink = `[\`${summary.feature.name}\`](${commitUrl}/${summary.feature.ref})`;
   const diffUrl = `https://github.com/${repo}/compare/${summary.baseline.ref}...${summary.feature.ref}`;
@@ -67,6 +94,23 @@ module.exports = async function ({ core, context, chartSha, grafanaUrl, runId })
     md += '\n';
   }
 
+  // Target metrics
+  const targetMetrics = summary.target_metrics;
+  const changedTargetMetrics = targetMetrics?.changed || [];
+  if (changedTargetMetrics.length > 0) {
+    md += `### Target Metrics\n\n`;
+    md += `| Metric | Baseline | Feature | Change |\n`;
+    md += `|--------|----------|---------|--------|\n`;
+    for (const metric of changedTargetMetrics) {
+      for (const statName of metric.display_stats || []) {
+        const change = metric.changes?.[statName];
+        if (!change || change.sig === 'neutral') continue;
+        md += `| \`${metric.name} ${statName}\` | ${fmtTargetMetricValue(metric, change.baseline)} | ${fmtTargetMetricValue(metric, change.feature)} | ${fmtChange(change)} |\n`;
+      }
+    }
+    md += '\n';
+  }
+
   // Charts
   if (chartSha) {
     const prNum = prNumber || '0';
@@ -91,9 +135,20 @@ module.exports = async function ({ core, context, chartSha, grafanaUrl, runId })
     md += `### Samply Profiles\n\n${samplyLinks.join('\n')}\n\n`;
   }
 
-  // Grafana
-  if (grafanaUrl) {
-    md += `### Grafana Dashboard\n\n[View real-time metrics](${grafanaUrl})\n\n`;
+  const tracingChromeUrls = loadTracingChromeUrls(process.env.BENCH_WORK_DIR);
+  const tracingChromeLinks = Object.entries(tracingChromeUrls)
+    .map(([run, url]) => `- **${run}**: [Perfetto](${url})`);
+  if (tracingChromeLinks.length > 0) {
+    md += `### Chrome Traces\n\n${tracingChromeLinks.join('\n')}\n\n`;
+  }
+
+  // Observability
+  const observabilityLinks = [];
+  if (resolvedGrafanaUrl) observabilityLinks.push(`- [Grafana Dashboard](${resolvedGrafanaUrl})`);
+  if (resolvedLogsUrl) observabilityLinks.push(`- [Logs](${resolvedLogsUrl})`);
+  if (resolvedTracesUrl) observabilityLinks.push(`- [Traces](${resolvedTracesUrl})`);
+  if (observabilityLinks.length > 0) {
+    md += `### Observability\n\n${observabilityLinks.join('\n')}\n\n`;
   }
 
   // Node errors
diff --git a/.github/scripts/bench-metrics-proxy.py b/.github/scripts/bench-metrics-proxy.py
deleted file mode 100644
index 2a6044a0eb8..00000000000
--- a/.github/scripts/bench-metrics-proxy.py
+++ /dev/null
@@ -1,276 +0,0 @@
-#!/usr/bin/env python3
-"""
-Prometheus metrics proxy that fetches from a local reth node and
-re-exposes with additional benchmark labels.
-
-Reads labels from a JSON file (updated by local-reth-bench.sh between runs)
-and injects them into every Prometheus metric line.
-
-Returns empty 200 when reth is not running (clean Grafana gaps).
-"""
-import argparse
-import ipaddress
-import json
-import subprocess
-import sys
-import time
-from http.server import HTTPServer, BaseHTTPRequestHandler
-from urllib.request import urlopen
-from urllib.error import URLError
-
-
-def read_labels(path):
-    try:
-        with open(path) as f:
-            return json.load(f)
-    except (FileNotFoundError, json.JSONDecodeError):
-        return {}
-
-
-def inject_labels(metrics_bytes, label_str, label_names):
-    """Inject labels into Prometheus text format.
-
-    Operates on bytes and uses simple string ops instead of regex
-    for speed on large payloads (reth exposes thousands of metrics).
-
-    Skips injecting into lines that already contain any of the label names
-    to avoid duplicate labels (which Prometheus rejects).
-    """
-    if not label_str:
-        return metrics_bytes
-
-    label_bytes = label_str.encode("utf-8")
-    # Pre-encode label names for fast duplicate detection
-    label_name_bytes = [n.encode("utf-8") for n in label_names]
-    out = []
-    for line in metrics_bytes.split(b"\n"):
-        # Skip comments and blank lines
-        if line.startswith(b"#") or not line:
-            out.append(line)
-            continue
-
-        brace = line.find(b"{")
-        space = line.find(b" ")
-
-        if space == -1:
-            # Malformed, pass through
-            out.append(line)
-        elif brace != -1 and brace < space:
-            # Has labels: metric{existing="val"} 123
-            close = line.find(b"}", brace)
-            if close == -1:
-                out.append(line)
-                continue
-
-            # Filter out labels that already exist in this line
-            existing = line[brace + 1:close]
-            inject = label_bytes
-            if existing:
-                for name in label_name_bytes:
-                    if name + b"=" in existing:
-                        # Rebuild inject string excluding this label
-                        inject = _remove_label(inject, name)
-                if not inject:
-                    out.append(line)
-                    continue
-
-            if close == brace + 1:
-                # Empty braces: metric{} 123
-                out.append(line[:close] + inject + line[close:])
-            else:
-                out.append(line[:close] + b"," + inject + line[close:])
-        else:
-            # No labels: metric 123
-            out.append(line[:space] + b"{" + label_bytes + b"}" + line[space:])
-
-    return b"\n".join(out)
-
-
-def _remove_label(label_bytes, name):
-    """Remove a single label (name=\"...\") from a comma-separated label string."""
-    parts = []
-    for part in label_bytes.split(b","):
-        if not part.startswith(name + b"="):
-            parts.append(part)
-    return b",".join(parts)
-
-
-def build_label_str(labels):
-    """Pre-format the label injection string: key1="val1",key2="val2" """
-    if not labels:
-        return ""
-    return ",".join(f'{k}="{v}"' for k, v in sorted(labels.items()))
-
-
-def build_elapsed_gauge(labels):
-    """Build a bench_elapsed_seconds gauge from run_start_epoch in labels."""
-    start = labels.get("run_start_epoch")
-    if not start:
-        return b""
-    try:
-        elapsed = time.time() - float(start)
-    except (ValueError, TypeError):
-        return b""
-    # Build labels excluding internal keys
-    display = {k: v for k, v in labels.items()
-               if k not in ("run_start_epoch", "reference_epoch")}
-    lstr = build_label_str(display)
-    return (
-        f"# HELP bench_elapsed_seconds Seconds since benchmark run started\n"
-        f"# TYPE bench_elapsed_seconds gauge\n"
-        f"bench_elapsed_seconds{{{lstr}}} {elapsed:.1f}\n"
-    ).encode("utf-8")
-
-
-def compute_timestamp_ms(labels):
-    """Compute a synthetic timestamp so all runs share a common time origin.
-
-    Returns the timestamp in milliseconds, or None if not enough info.
-    Uses: reference_epoch + (now - run_start_epoch) → all runs overlay at
-    the same Grafana time range.
-    """
-    ref = labels.get("reference_epoch")
-    start = labels.get("run_start_epoch")
-    if not ref or not start:
-        return None
-    try:
-        elapsed = time.time() - float(start)
-        return int((float(ref) + elapsed) * 1000)
-    except (ValueError, TypeError):
-        return None
-
-
-def inject_timestamps(metrics_bytes, timestamp_ms):
-    """Append a Prometheus timestamp (ms) to every data line.
-
-    Prometheus text format: metric{labels} value [timestamp_ms]
-    Adding timestamps causes Prometheus to store all runs' samples
-    at the same relative time, enabling natural overlay in Grafana.
-    """
-    if timestamp_ms is None:
-        return metrics_bytes
-
-    ts = str(timestamp_ms).encode("utf-8")
-    out = []
-    for line in metrics_bytes.split(b"\n"):
-        if line.startswith(b"#") or not line:
-            out.append(line)
-        else:
-            out.append(line + b" " + ts)
-    return b"\n".join(out)
-
-
-class MetricsHandler(BaseHTTPRequestHandler):
-    # Use HTTP/1.1 so Content-Length is respected and Prometheus
-    # doesn't have to rely on connection close to detect end of body.
-    protocol_version = "HTTP/1.1"
-
-    def do_GET(self):
-        src = self.client_address[0]
-        try:
-            resp = urlopen(self.server.upstream, timeout=2)
-            metrics = resp.read()
-        except (URLError, ConnectionError, OSError):
-            # reth not running — return empty 200
-            self._send(b"")
-            #print(f"  scrape from {src}: empty (reth not running)", flush=True)
-            return
-
-        all_labels = read_labels(self.server.labels_file)
-        # Internal keys — not injected as Prometheus labels
-        internal = ("run_start_epoch", "reference_epoch")
-        labels = {k: v for k, v in all_labels.items() if k not in internal}
-        label_str = build_label_str(labels)
-        label_names = sorted(labels.keys())
-
-        t0 = time.monotonic()
-        result = inject_labels(metrics, label_str, label_names)
-        result += build_elapsed_gauge(all_labels)
-        ts_ms = compute_timestamp_ms(all_labels)
-        result = inject_timestamps(result, ts_ms)
-        dt = time.monotonic() - t0
-
-        self._send(result)
-        print(f"  scrape from {src}: {len(metrics)} -> {len(result)} bytes, "
-              f"inject {dt*1000:.1f}ms", flush=True)
-
-    def _send(self, body):
-        self.send_response(200)
-        self.send_header("Content-Type", "text/plain; version=0.0.4")
-        self.send_header("Content-Length", str(len(body)))
-        self.send_header("Connection", "close")
-        self.end_headers()
-        if body:
-            self.wfile.write(body)
-
-    def log_message(self, format, *args):
-        pass  # suppress per-request logging
-
-
-def resolve_bind_address(subnet_cidr):
-    """Find the local IP address that belongs to the given subnet.
-
-    Uses ``ip -j addr show`` to enumerate interfaces and returns the first
-    address that falls within *subnet_cidr* (e.g. ``10.10.0.0/24``).
-    """
-    network = ipaddress.ip_network(subnet_cidr, strict=False)
-    try:
-        result = subprocess.run(
-            ["ip", "-j", "addr", "show"],
-            capture_output=True, text=True, check=True,
-        )
-        interfaces = json.loads(result.stdout)
-    except (subprocess.CalledProcessError, FileNotFoundError, json.JSONDecodeError) as exc:
-        print(f"Error: cannot enumerate interfaces: {exc}", file=sys.stderr)
-        sys.exit(1)
-
-    for iface in interfaces:
-        for addr_info in iface.get("addr_info", []):
-            try:
-                addr = ipaddress.ip_address(addr_info["local"])
-            except (KeyError, ValueError):
-                continue
-            if addr in network:
-                return str(addr)
-
-    print(f"Error: no interface address found in subnet {subnet_cidr}", file=sys.stderr)
-    sys.exit(1)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Prometheus metrics proxy with label injection")
-    parser.add_argument("--labels", default="/tmp/bench-metrics-labels.json",
-                        help="Path to JSON file with labels to inject (default: /tmp/bench-metrics-labels.json)")
-    parser.add_argument("--upstream", default="http://127.0.0.1:9100/",
-                        help="Upstream reth metrics URL (default: http://127.0.0.1:9100/)")
-
-    bind_group = parser.add_mutually_exclusive_group()
-    bind_group.add_argument("--bind", default=None,
-                            help="Address to bind the proxy (default: 0.0.0.0)")
-    bind_group.add_argument("--subnet", default=None,
-                            help="Auto-detect bind address from a local interface in this subnet (e.g. 10.10.0.0/24)")
-
-    parser.add_argument("--port", type=int, default=9090,
-                        help="Port to bind the proxy (default: 9090)")
-    args = parser.parse_args()
-
-    if args.subnet:
-        bind_addr = resolve_bind_address(args.subnet)
-    elif args.bind:
-        bind_addr = args.bind
-    else:
-        bind_addr = "0.0.0.0"
-
-    server = HTTPServer((bind_addr, args.port), MetricsHandler)
-    server.upstream = args.upstream
-    server.labels_file = args.labels
-
-    print(f"bench-metrics-proxy listening on {bind_addr}:{args.port}")
-    print(f"  upstream: {args.upstream}")
-    print(f"  labels:   {args.labels}")
-    sys.stdout.flush()
-    server.serve_forever()
-
-
-if __name__ == "__main__":
-    main()
diff --git a/.github/scripts/bench-reth-build.sh b/.github/scripts/bench-reth-build.sh
deleted file mode 100755
index 6127f23b765..00000000000
--- a/.github/scripts/bench-reth-build.sh
+++ /dev/null
@@ -1,76 +0,0 @@
-#!/usr/bin/env bash
-#
-# Builds reth binaries for benchmarking from local source only.
-#
-# Usage: bench-reth-build.sh <baseline|feature> <source-dir> <commit>
-#
-#   baseline — build the baseline binary at <commit> (merge-base)
-#              source-dir must be checked out at <commit>
-#   feature  — build the candidate binary + reth-bench at <commit>
-#              source-dir must be checked out at <commit>
-#
-# Outputs:
-#   baseline: <source-dir>/target/profiling/reth (or reth-bb if BENCH_BIG_BLOCKS=true)
-#   feature:  <source-dir>/target/profiling/reth (or reth-bb), reth-bench installed to cargo bin
-#
-# Optional env: BENCH_BIG_BLOCKS (true/false) — build reth-bb instead of reth
-set -euxo pipefail
-
-MODE="$1"
-SOURCE_DIR="$2"
-COMMIT="$3"
-
-BIG_BLOCKS="${BENCH_BIG_BLOCKS:-false}"
-# The node binary to build: reth-bb for big blocks, reth otherwise
-if [ "$BIG_BLOCKS" = "true" ]; then
-  NODE_BIN="reth-bb"
-  NODE_PKG="-p reth-bb"
-else
-  NODE_BIN="reth"
-  NODE_PKG="--bin reth"
-fi
-
-# Tracy support: when BENCH_TRACY is "on" or "full", add Tracy cargo features
-# and frame pointers for accurate stack traces.
-EXTRA_FEATURES=""
-EXTRA_RUSTFLAGS=""
-if [ "${BENCH_TRACY:-off}" != "off" ]; then
-  EXTRA_FEATURES="tracy,tracy-client/ondemand"
-  EXTRA_RUSTFLAGS=" -C force-frame-pointers=yes"
-fi
-
-# Build the requested node binary with the benchmark profile.
-build_node_binary() {
-  local features_arg=""
-  local workspace_arg=""
-
-  cd "$SOURCE_DIR"
-  if [ -n "$EXTRA_FEATURES" ]; then
-    # --workspace is needed for cross-package feature syntax (tracy-client/ondemand)
-    features_arg="--features ${EXTRA_FEATURES}"
-    workspace_arg="--workspace"
-  fi
-
-  # shellcheck disable=SC2086
-  RUSTFLAGS="-C target-cpu=native${EXTRA_RUSTFLAGS}" \
-    cargo build --locked --profile profiling $NODE_PKG $workspace_arg $features_arg
-}
-
-case "$MODE" in
-  baseline|main)
-    echo "Building baseline ${NODE_BIN} (${COMMIT}) from source..."
-    build_node_binary
-    ;;
-
-  feature|branch)
-    echo "Building feature ${NODE_BIN} (${COMMIT}) from source..."
-    rustup show active-toolchain || rustup default stable
-    build_node_binary
-    make -C "$SOURCE_DIR" install-reth-bench
-    ;;
-
-  *)
-    echo "Usage: $0 <baseline|feature> <source-dir> <commit>"
-    exit 1
-    ;;
-esac
diff --git a/.github/scripts/bench-reth-charts.py b/.github/scripts/bench-reth-charts.py
index 0fb935896a9..08c044cb3be 100644
--- a/.github/scripts/bench-reth-charts.py
+++ b/.github/scripts/bench-reth-charts.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Generate benchmark charts from reth-bench CSV output.
+"""Generate benchmark charts from benchmark CSV output.
 
 Usage:
     bench-engine-charts.py <combined_csv> --output-dir <dir> [--baseline <baseline_csv>]
diff --git a/.github/scripts/bench-reth-local.sh b/.github/scripts/bench-reth-local.sh
deleted file mode 100755
index 4d2565592d8..00000000000
--- a/.github/scripts/bench-reth-local.sh
+++ /dev/null
@@ -1,567 +0,0 @@
-#!/usr/bin/env bash
-#
-# local-reth-bench.sh — Run the reth Engine API benchmark locally.
-#
-# Replicates the CI bench.yml workflow (build, local snapshot validation, system tuning,
-# interleaved B-F-F-B execution, summary, charts) without any GitHub
-# Actions glue (no PR comments, no artifact upload, no Slack).
-#
-# Usage:
-#   local-reth-bench.sh <baseline-ref> <feature-ref> [options]
-#
-# Options:
-#   --blocks N      Number of blocks to benchmark (default: 500)
-#   --warmup N      Number of warmup blocks (default: 100)
-#   --cores N       Limit reth to N CPU cores, 0 = all available (default: 0)
-#   --samply        Enable samply profiling
-#   --tracy MODE    Tracy profiling: off, on, full (default: off)
-#   --tracy-filter F Tracy tracing filter (default: debug)
-#   --no-tune       Skip system tuning (useful on dev machines / macOS)
-#
-# Requires: the reth repo at RETH_REPO (default: ~/reth)
-#
-# Dependencies (install before first run):
-#   schelk, cpupower, taskset, stdbuf, python3, curl,
-#   make, uv, jq, Rust toolchain (cargo/rustup)
-# Optional:
-#   mc for Tracy profile upload
-#
-# The script delegates to the existing bench-reth-*.sh scripts in the reth
-# repo for the actual build, snapshot, and run steps.
-set -euxo pipefail
-
-# ── PATH ──────────────────────────────────────────────────────────────
-# Ensure cargo and user-local bins (uv) are visible
-export PATH="$HOME/.local/bin:$HOME/.cargo/bin:$PATH"
-
-# ── Defaults ──────────────────────────────────────────────────────────
-RETH_REPO="${RETH_REPO:-$HOME/reth}"
-BLOCKS=500
-WARMUP=100
-CORES=0
-SAMPLY=false
-TRACY="off"
-TRACY_FILTER="debug"
-TUNE=true
-BASELINE_REF=""
-FEATURE_REF=""
-
-# ── Parse arguments ──────────────────────────────────────────────────
-usage() {
-  cat <<EOF
-Usage: $(basename "$0") <baseline-ref> <feature-ref> [options]
-
-Options:
-  --blocks N         Number of blocks to benchmark (default: 500)
-  --warmup N         Number of warmup blocks (default: 100)
-  --cores N          Limit reth to N CPU cores (default: 0 = all)
-  --samply           Enable samply profiling
-  --tracy MODE       Tracy profiling: off, on, full (default: off)
-                       on   = tracing only (lower overhead)
-                       full = tracing + CPU sampling (higher overhead)
-  --tracy-filter F   Tracy tracing filter (default: debug)
-  --no-tune          Skip system tuning
-EOF
-  exit 1
-}
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --blocks)       BLOCKS="$2"; shift 2 ;;
-    --warmup)       WARMUP="$2"; shift 2 ;;
-    --cores)        CORES="$2"; shift 2 ;;
-    --samply)       SAMPLY=true; shift ;;
-    --tracy)        TRACY="$2"; shift 2 ;;
-    --tracy-filter) TRACY_FILTER="$2"; shift 2 ;;
-    --no-tune)      TUNE=false; shift ;;
-    --help|-h)  usage ;;
-    -*)         echo "Unknown option: $1"; usage ;;
-    *)
-      if [ -z "$BASELINE_REF" ]; then
-        BASELINE_REF="$1"
-      elif [ -z "$FEATURE_REF" ]; then
-        FEATURE_REF="$1"
-      else
-        echo "Unexpected argument: $1"; usage
-      fi
-      shift
-      ;;
-  esac
-done
-
-if [ -z "$BASELINE_REF" ] || [ -z "$FEATURE_REF" ]; then
-  echo "Error: both <baseline-ref> and <feature-ref> are required."
-  usage
-fi
-
-# Validate --tracy value
-case "$TRACY" in
-  off|on|full) ;;
-  *) echo "Error: --tracy must be off, on, or full (got: $TRACY)"; usage ;;
-esac
-
-# Samply + tracy=full are mutually exclusive (both use perf sampling)
-if [ "$SAMPLY" = "true" ] && [ "$TRACY" = "full" ]; then
-  echo "Warning: samply and tracy=full both use perf sampling; downgrading tracy to 'on'."
-  TRACY="on"
-fi
-
-# ── Check dependencies ───────────────────────────────────────────────
-missing=()
-for cmd in schelk cpupower taskset stdbuf python3 curl make uv jq cargo; do
-  command -v "$cmd" &>/dev/null || missing+=("$cmd")
-done
-if [ ${#missing[@]} -gt 0 ]; then
-  echo "Error: missing required tools: ${missing[*]}"
-  echo "See the CI 'Install dependencies' step in .github/workflows/bench.yml for install instructions."
-  exit 1
-fi
-
-if [ "$TRACY" != "off" ]; then
-  if ! command -v tracy-capture &>/dev/null; then
-    echo "Error: tracy-capture is required for --tracy $TRACY"
-    exit 1
-  fi
-fi
-
-# Ensure tools that run via sudo are in a sudo-visible path.
-# The bench scripts use `sudo schelk` / `sudo samply` but cargo installs
-# them to ~/.cargo/bin which sudo's secure_path doesn't include.
-for cmd in schelk samply; do
-  if command -v "$cmd" &>/dev/null && ! sudo sh -c "command -v $cmd" &>/dev/null; then
-    echo "Installing $cmd to /usr/local/bin (needed for sudo)..."
-    sudo install "$(command -v "$cmd")" /usr/local/bin/
-  fi
-done
-
-if [ ! -d "$RETH_REPO/.git" ]; then
-  echo "Error: RETH_REPO=$RETH_REPO is not a git repository."
-  echo "Set RETH_REPO or clone reth to ~/reth"
-  exit 1
-fi
-
-# ── Resolve paths ────────────────────────────────────────────────────
-SELF_DIR="$(cd "$(dirname "$0")" && pwd)"
-SCRIPTS_DIR="${RETH_REPO}/.github/scripts"
-BENCH_WORK_DIR="${RETH_REPO}/../bench-work-$(date +%Y%m%d-%H%M%S)"
-BASELINE_SRC="${RETH_REPO}/../reth-baseline"
-FEATURE_SRC="${RETH_REPO}/../reth-feature"
-
-mkdir -p "$BENCH_WORK_DIR"
-BENCH_WORK_DIR="$(cd "$BENCH_WORK_DIR" && pwd)"
-
-# ── Global cleanup trap (restores system tuning on any exit) ─────────
-TUNING_APPLIED=false
-CSTATE_PID=
-METRICS_PROXY_PID=
-cleanup_global() {
-  [ -n "$METRICS_PROXY_PID" ] && kill "$METRICS_PROXY_PID" 2>/dev/null || true
-  if [ "$TUNING_APPLIED" = true ]; then
-    echo
-    echo "▸ Restoring system settings..."
-    [ -n "$CSTATE_PID" ] && kill "$CSTATE_PID" 2>/dev/null || true
-    sudo systemctl start irqbalance cron atd 2>/dev/null || true
-    echo "  System settings restored."
-  fi
-}
-trap cleanup_global EXIT
-
-echo "═══════════════════════════════════════════════════════════"
-echo "  reth local benchmark"
-echo "═══════════════════════════════════════════════════════════"
-echo "  Baseline ref : $BASELINE_REF"
-echo "  Feature ref  : $FEATURE_REF"
-echo "  Blocks       : $BLOCKS"
-echo "  Warmup       : $WARMUP"
-echo "  Cores        : $CORES"
-echo "  Samply       : $SAMPLY"
-echo "  Tracy        : $TRACY"
-echo "  Tracy filter : $TRACY_FILTER"
-echo "  System tune  : $TUNE"
-echo "  Work dir     : $BENCH_WORK_DIR"
-echo "  Reth repo    : $RETH_REPO"
-echo "═══════════════════════════════════════════════════════════"
-echo
-
-# Enable sccache if available (matches CI's RUSTC_WRAPPER=sccache)
-if command -v sccache &>/dev/null; then
-  export RUSTC_WRAPPER="sccache"
-fi
-
-# Export env vars expected by the bench-reth-*.sh scripts
-export BENCH_BLOCKS="$BLOCKS"
-export BENCH_WARMUP_BLOCKS="$WARMUP"
-export BENCH_CORES="$CORES"
-export BENCH_SAMPLY="$SAMPLY"
-export BENCH_TRACY="$TRACY"
-export BENCH_TRACY_FILTER="$TRACY_FILTER"
-export BENCH_WORK_DIR
-export SCHELK_MOUNT="${SCHELK_MOUNT:-/reth-bench}"
-export BENCH_RPC_URL="${BENCH_RPC_URL:-https://ethereum.reth.rs/rpc}"
-export BENCH_METRICS_ADDR="127.0.0.1:9100"
-
-# ── Step 1: Resolve refs to full SHAs ────────────────────────────────
-echo "▸ Resolving git refs..."
-cd "$RETH_REPO"
-
-resolve_ref() {
-  local ref="$1"
-  git fetch origin "$ref" --quiet 2>/dev/null || true
-  git rev-parse "$ref" 2>/dev/null \
-    || git rev-parse "origin/$ref" 2>/dev/null \
-    || { echo "Error: cannot resolve ref '$ref'"; exit 1; }
-}
-
-BASELINE_SHA="$(resolve_ref "$BASELINE_REF")"
-FEATURE_SHA="$(resolve_ref "$FEATURE_REF")"
-echo "  Baseline SHA : $BASELINE_SHA"
-echo "  Feature SHA  : $FEATURE_SHA"
-echo
-
-# ── Step 2: Prepare source directories ───────────────────────────────
-echo "▸ Preparing source directories..."
-
-prepare_source() {
-  local src_dir="$1" ref="$2"
-  if [ -d "$src_dir" ]; then
-    git -C "$src_dir" fetch origin "$ref" 2>/dev/null || true
-  else
-    git clone --recurse-submodules "$RETH_REPO" "$src_dir"
-  fi
-  git -C "$src_dir" checkout "$ref" --force
-  git -C "$src_dir" submodule update --init --recursive
-}
-
-prepare_source "$BASELINE_SRC" "$BASELINE_SHA"
-prepare_source "$FEATURE_SRC" "$FEATURE_SHA"
-BASELINE_SRC="$(cd "$BASELINE_SRC" && pwd)"
-FEATURE_SRC="$(cd "$FEATURE_SRC" && pwd)"
-echo "  Baseline src : $BASELINE_SRC"
-echo "  Feature src  : $FEATURE_SRC"
-echo
-
-# ── Step 3: Validate local snapshot ──────────────────────────────────
-echo "▸ Validating local snapshot..."
-cd "$RETH_REPO"
-"${SCRIPTS_DIR}/bench-reth-snapshot.sh"
-echo "  Snapshot is ready."
-echo
-
-# ── Step 4: Build binaries in parallel ───────────────────────────────
-echo "▸ Building binaries (parallel)..."
-cd "$RETH_REPO"
-
-FAIL=0
-
-"${SCRIPTS_DIR}/bench-reth-build.sh" baseline "$BASELINE_SRC" "$BASELINE_SHA" &
-PID_BASELINE=$!
-
-"${SCRIPTS_DIR}/bench-reth-build.sh" feature "$FEATURE_SRC" "$FEATURE_SHA" &
-PID_FEATURE=$!
-
-wait $PID_BASELINE || FAIL=1
-wait $PID_FEATURE  || FAIL=1
-
-if [ $FAIL -ne 0 ]; then
-  echo "Error: one or more build tasks failed"
-  exit 1
-fi
-echo "  Binaries built successfully."
-echo
-
-# ── Step 5: System tuning (optional) ────────────────────────────────
-if [ "$TUNE" = "true" ]; then
-  echo "▸ Applying system tuning..."
-
-  sudo cpupower frequency-set -g performance 2>/dev/null || true
-
-  # Disable turbo boost (Intel + AMD)
-  echo 1 | sudo tee /sys/devices/system/cpu/intel_pstate/no_turbo 2>/dev/null || true
-  echo 0 | sudo tee /sys/devices/system/cpu/cpufreq/boost 2>/dev/null || true
-
-  sudo swapoff -a 2>/dev/null || true
-  echo 0 | sudo tee /proc/sys/kernel/randomize_va_space 2>/dev/null || true
-
-  # Disable SMT (hyperthreading)
-  for cpu in /sys/devices/system/cpu/cpu*/topology/thread_siblings_list; do
-    [ -f "$cpu" ] || continue
-    first=$(cut -d, -f1 < "$cpu" | cut -d- -f1)
-    current=$(echo "$cpu" | grep -o 'cpu[0-9]*' | grep -o '[0-9]*')
-    if [ "$current" != "$first" ]; then
-      echo 0 | sudo tee "/sys/devices/system/cpu/cpu${current}/online" 2>/dev/null || true
-    fi
-  done
-  echo "  Online CPUs: $(nproc)"
-
-  # Disable transparent huge pages
-  for p in /sys/kernel/mm/transparent_hugepage /sys/kernel/mm/transparent_hugepages; do
-    if [ -d "$p" ]; then
-      echo never | sudo tee "$p/enabled" 2>/dev/null || true
-      echo never | sudo tee "$p/defrag" 2>/dev/null || true
-      break
-    fi
-  done
-
-  # Prevent deep C-states
-  sudo sh -c 'exec 3<>/dev/cpu_dma_latency; echo -ne "\x00\x00\x00\x00" >&3; sleep infinity' &
-  CSTATE_PID=$!
-
-  # Pin IRQs to core 0
-  for irq in /proc/irq/*/smp_affinity_list; do
-    echo 0 | sudo tee "$irq" 2>/dev/null || true
-  done
-
-  # Stop noisy background services
-  sudo systemctl stop irqbalance cron atd unattended-upgrades snapd 2>/dev/null || true
-
-  TUNING_APPLIED=true
-
-  # Log environment for reproducibility (matches CI)
-  echo "  === Benchmark environment ==="
-  echo "  Kernel : $(uname -r)"
-  lscpu | grep -E 'Model name|CPU\(s\)|MHz|NUMA' | sed 's/^/  /'
-  echo "  Governor : $(cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor 2>/dev/null || echo unknown)"
-  echo "  Freq     : $(cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq 2>/dev/null || echo unknown)"
-  echo "  THP      : $(cat /sys/kernel/mm/transparent_hugepage/enabled 2>/dev/null || cat /sys/kernel/mm/transparent_hugepages/enabled 2>/dev/null || echo unknown)"
-  free -h | sed 's/^/  /'
-  echo "  System tuning applied."
-  echo
-fi
-
-# ── Step 5b: Tracefs mount (tracy=full only) ─────────────────────────
-if [ "$TRACY" = "full" ] && [ "$(uname)" = "Linux" ]; then
-  echo "▸ Mounting tracefs for Tracy full mode..."
-  sudo mount -t tracefs tracefs /sys/kernel/tracing -o mode=755 2>/dev/null || true
-fi
-
-# ── Tracy upload & viewer helpers ────────────────────────────────────
-TRACY_VIEWER_BASE="${TRACY_VIEWER_BASE:-}"
-
-tracy_viewer_url() {
-  local profile_url="$1"
-  if [ -z "$TRACY_VIEWER_BASE" ]; then
-    echo ""
-    return
-  fi
-  local encoded
-  encoded=$(python3 -c "import urllib.parse, sys; print(urllib.parse.quote(sys.argv[1], safe=''))" "$profile_url")
-  echo "${TRACY_VIEWER_BASE}?profile_url=${encoded}"
-}
-
-upload_tracy() {
-  local label="$1" output_dir="$2" sha="$3"
-  local tracy_file="$output_dir/tracy-profile.tracy"
-
-  if [ ! -f "$tracy_file" ]; then
-    echo "  Tracy: no profile found, skipping upload."
-    return
-  fi
-
-  local timestamp short_sha remote_name bucket mc_alias
-  timestamp=$(date +%Y%m%d-%H%M%S)
-  short_sha="${sha:0:7}"
-  remote_name="${label}-${short_sha}-${timestamp}.tracy"
-  bucket="${TRACY_BUCKET:-tracy-profiles}"
-  mc_alias="${MC_ALIAS:-minio}"
-  local minio_base="${TRACY_MINIO_URL:-http://minio.minio.svc.cluster.local:9000}"
-
-  echo "  Tracy: uploading profile..."
-  if mc cp "$tracy_file" "${mc_alias}/${bucket}/${remote_name}"; then
-    local url="${minio_base}/${bucket}/${remote_name}"
-    echo "$url" > "$output_dir/tracy_url.txt"
-    local viewer
-    viewer=$(tracy_viewer_url "$url")
-    if [ -n "$viewer" ]; then
-      echo "$viewer" > "$output_dir/tracy_viewer_url.txt"
-      echo "  Tracy: uploaded → $viewer"
-    else
-      echo "  Tracy: uploaded → $url"
-    fi
-  else
-    echo "  Tracy: upload failed (non-fatal)."
-  fi
-
-  # Delete large profile to free disk
-  rm -f "$tracy_file"
-}
-
-# ── Step 6: Pre-flight cleanup ───────────────────────────────────────
-echo "▸ Pre-flight cleanup..."
-pkill -f bench-metrics-proxy 2>/dev/null || true
-sudo systemctl stop "${RETH_SCOPE:-reth-bench.scope}" 2>/dev/null || true
-sudo systemctl reset-failed "${RETH_SCOPE:-reth-bench.scope}" 2>/dev/null || true
-sudo schelk recover -y --kill || sudo schelk full-recover -y || true
-echo
-
-# ── Step 7: Interleaved benchmark runs (B-F-F-B) ────────────────────
-# This ordering reduces systematic bias from thermal drift and cache warming.
-BASELINE_BIN="${BASELINE_SRC}/target/profiling/reth"
-FEATURE_BIN="${FEATURE_SRC}/target/profiling/reth"
-
-# Start metrics proxy (reth → label injection → Prometheus)
-LABELS_FILE="/tmp/bench-metrics-labels.json"
-echo '{}' > "$LABELS_FILE"
-METRICS_SUBNET="${METRICS_SUBNET:-10.10.0.0/24}"
-METRICS_PORT="${METRICS_PORT:-9090}"
-python3 "${SELF_DIR}/bench-metrics-proxy.py" \
-  --labels "$LABELS_FILE" \
-  --upstream "http://${BENCH_METRICS_ADDR}/" \
-  --subnet "$METRICS_SUBNET" \
-  --port "$METRICS_PORT" &
-METRICS_PROXY_PID=$!
-echo "▸ Metrics proxy started (PID $METRICS_PROXY_PID) on subnet ${METRICS_SUBNET}, port ${METRICS_PORT}"
-
-# Unique benchmark ID: local-<timestamp> for local runs, ci-<run_id> for CI
-BENCH_ID="local-$(basename "$BENCH_WORK_DIR" | sed 's/bench-work-//')"
-# Reference epoch: shared time origin so all runs overlay in Grafana.
-# The proxy maps each run's elapsed time onto this common origin.
-BENCH_REFERENCE_EPOCH=$(date +%s)
-
-write_labels() {
-  local run_label="$1" run_type="$2" ref="$3" sha="$4"
-  LAST_RUN_START=$(date +%s)
-  cat > "$LABELS_FILE" <<-EOF
-	{"benchmark_run":"${run_label}","run_type":"${run_type}","git_ref":"${ref}","bench_sha":"${sha}","benchmark_id":"${BENCH_ID}","run_start_epoch":"${LAST_RUN_START}","reference_epoch":"${BENCH_REFERENCE_EPOCH}"}
-	EOF
-}
-
-run_bench() {
-  local label="$1" binary="$2" output_dir="$3"
-  echo "▸ Running benchmark: ${label}..."
-  cd "$RETH_REPO"
-  if command -v taskset &>/dev/null; then
-    taskset -c 0 "${SCRIPTS_DIR}/bench-reth-run.sh" "$label" "$binary" "$output_dir"
-  else
-    "${SCRIPTS_DIR}/bench-reth-run.sh" "$label" "$binary" "$output_dir"
-  fi
-  echo "  ✓ ${label} complete."
-  echo
-}
-
-write_labels "baseline-1" "baseline" "$BASELINE_REF" "$BASELINE_SHA"
-run_bench "baseline-1" "$BASELINE_BIN" "$BENCH_WORK_DIR/baseline-1"
-
-write_labels "feature-1" "feature" "$FEATURE_REF" "$FEATURE_SHA"
-run_bench "feature-1"  "$FEATURE_BIN"  "$BENCH_WORK_DIR/feature-1"
-
-write_labels "feature-2" "feature" "$FEATURE_REF" "$FEATURE_SHA"
-run_bench "feature-2"  "$FEATURE_BIN"  "$BENCH_WORK_DIR/feature-2"
-
-write_labels "baseline-2" "baseline" "$BASELINE_REF" "$BASELINE_SHA"
-run_bench "baseline-2" "$BASELINE_BIN" "$BENCH_WORK_DIR/baseline-2"
-
-# ── Compute Grafana URL ──────────────────────────────────────────────
-GRAFANA_BASE_URL="https://tempoxyz.grafana.net/d/reth-bench-ghr/reth-bench-ghr"
-GRAFANA_DATASOURCE="ef57fux92e9z4e"
-LAST_RUN_DURATION=$(( $(date +%s) - LAST_RUN_START ))
-FROM_MS=$(( BENCH_REFERENCE_EPOCH * 1000 ))
-TO_MS=$(( (BENCH_REFERENCE_EPOCH + LAST_RUN_DURATION) * 1000 ))
-GRAFANA_URL="${GRAFANA_BASE_URL}?orgId=1&from=${FROM_MS}&to=${TO_MS}&timezone=browser&var-datasource=${GRAFANA_DATASOURCE}&var-job=reth-bench&var-benchmark_id=${BENCH_ID}&var-benchmark_run=\$__all"
-
-# ── Step 8: Scan logs for errors ─────────────────────────────────────
-echo "▸ Scanning logs for errors..."
-ERRORS_FILE="$BENCH_WORK_DIR/errors.md"
-found_errors=false
-for run_dir in baseline-1 feature-1 feature-2 baseline-2; do
-  LOG="$BENCH_WORK_DIR/$run_dir/node.log"
-  [ -f "$LOG" ] || continue
-  panics=$(grep -c -E 'panicked at' "$LOG" 2>/dev/null || true)
-  errors=$(grep -c ' ERROR ' "$LOG" 2>/dev/null || true)
-  if [ "$panics" -gt 0 ] || [ "$errors" -gt 0 ]; then
-    if [ "$found_errors" = false ]; then
-      printf '### ⚠️ Node Errors\n\n' >> "$ERRORS_FILE"
-      found_errors=true
-    fi
-    printf '<details><summary><b>%s</b>: %d panic(s), %d error(s)</summary>\n\n' \
-      "$run_dir" "$panics" "$errors" >> "$ERRORS_FILE"
-    if [ "$panics" -gt 0 ]; then
-      printf '**Panics:**\n```\n' >> "$ERRORS_FILE"
-      grep -E 'panicked at' "$LOG" | head -10 >> "$ERRORS_FILE"
-      printf '```\n' >> "$ERRORS_FILE"
-    fi
-    if [ "$errors" -gt 0 ]; then
-      printf '**Errors (first 20):**\n```\n' >> "$ERRORS_FILE"
-      grep ' ERROR ' "$LOG" | head -20 >> "$ERRORS_FILE"
-      printf '```\n' >> "$ERRORS_FILE"
-    fi
-    printf '\n</details>\n\n' >> "$ERRORS_FILE"
-  fi
-done
-if [ "$found_errors" = true ]; then
-  echo "  ⚠ Errors found — see $ERRORS_FILE"
-else
-  echo "  No errors found."
-fi
-echo
-
-# ── Step 9: Parse results ───────────────────────────────────────────
-echo "▸ Parsing results..."
-cd "$RETH_REPO"
-
-SUMMARY_ARGS=(
-  --output-summary "$BENCH_WORK_DIR/summary.json"
-  --output-markdown "$BENCH_WORK_DIR/comment.md"
-  --repo "paradigmxyz/reth"
-  --baseline-ref "$BASELINE_SHA"
-  --baseline-name "$BASELINE_REF"
-  --feature-name "$FEATURE_REF"
-  --feature-ref "$FEATURE_SHA"
-  --baseline-csv "$BENCH_WORK_DIR/baseline-1/combined_latency.csv" "$BENCH_WORK_DIR/baseline-2/combined_latency.csv"
-  --feature-csv "$BENCH_WORK_DIR/feature-1/combined_latency.csv" "$BENCH_WORK_DIR/feature-2/combined_latency.csv"
-  --gas-csv "$BENCH_WORK_DIR/feature-1/total_gas.csv"
-  --grafana-url "$GRAFANA_URL"
-)
-
-python3 "${SCRIPTS_DIR}/bench-reth-summary.py" "${SUMMARY_ARGS[@]}"
-echo
-
-# ── Step 10: Generate charts ─────────────────────────────────────────
-echo "▸ Generating charts..."
-CHART_ARGS=(
-  --output-dir "$BENCH_WORK_DIR/charts"
-  --feature "$BENCH_WORK_DIR/feature-1/combined_latency.csv" "$BENCH_WORK_DIR/feature-2/combined_latency.csv"
-  --baseline "$BENCH_WORK_DIR/baseline-1/combined_latency.csv" "$BENCH_WORK_DIR/baseline-2/combined_latency.csv"
-  --baseline-name "$BASELINE_REF"
-  --feature-name "$FEATURE_REF"
-)
-
-if python3 -c "import matplotlib" 2>/dev/null; then
-  python3 "${SCRIPTS_DIR}/bench-reth-charts.py" "${CHART_ARGS[@]}"
-elif command -v uv &>/dev/null; then
-  uv run --with matplotlib python3 "${SCRIPTS_DIR}/bench-reth-charts.py" "${CHART_ARGS[@]}"
-else
-  echo "  Warning: matplotlib not available, skipping chart generation."
-fi
-echo
-
-# ── Step 11: Upload Tracy profiles ────────────────────────────────────
-if [ "$TRACY" != "off" ]; then
-  echo "▸ Uploading Tracy profiles..."
-  upload_tracy "baseline-1" "$BENCH_WORK_DIR/baseline-1" "$BASELINE_SHA"
-  upload_tracy "feature-1"  "$BENCH_WORK_DIR/feature-1"  "$FEATURE_SHA"
-  upload_tracy "feature-2"  "$BENCH_WORK_DIR/feature-2"  "$FEATURE_SHA"
-  upload_tracy "baseline-2" "$BENCH_WORK_DIR/baseline-2" "$BASELINE_SHA"
-  echo
-fi
-
-# ── Done (system restore happens via EXIT trap) ─────────────────────
-echo "═══════════════════════════════════════════════════════════"
-echo "  Benchmark complete!"
-echo "═══════════════════════════════════════════════════════════"
-echo "  Results  : $BENCH_WORK_DIR/summary.json"
-echo "  Markdown : $BENCH_WORK_DIR/comment.md"
-echo "  Charts   : $BENCH_WORK_DIR/charts/"
-if [ -f "$ERRORS_FILE" ]; then
-  echo "  Errors   : $ERRORS_FILE"
-fi
-echo "  Grafana  : $GRAFANA_URL"
-if [ "$TRACY" != "off" ]; then
-  echo "  ─── Tracy Profiles ───"
-  for run_dir in baseline-1 feature-1 feature-2 baseline-2; do
-    url_file="$BENCH_WORK_DIR/$run_dir/tracy_viewer_url.txt"
-    if [ -f "$url_file" ]; then
-      echo "  $run_dir : $(cat "$url_file")"
-    fi
-  done
-fi
-echo "═══════════════════════════════════════════════════════════"
diff --git a/.github/scripts/bench-reth-run.sh b/.github/scripts/bench-reth-run.sh
deleted file mode 100755
index 7c272ad74ea..00000000000
--- a/.github/scripts/bench-reth-run.sh
+++ /dev/null
@@ -1,357 +0,0 @@
-#!/usr/bin/env bash
-#
-# Runs a single reth-bench cycle: mount snapshot → start node → warmup →
-# benchmark → stop node → recover snapshot.
-#
-# Usage: bench-reth-run.sh <label> <binary> <output-dir>
-#
-# Required env: SCHELK_MOUNT, BENCH_RPC_URL, BENCH_BLOCKS, BENCH_WARMUP_BLOCKS
-# Optional env: BENCH_BIG_BLOCKS (true/false), BENCH_WORK_DIR (for big blocks path)
-#               BENCH_BAL (false/true/feature/baseline; only used with big blocks)
-#               BENCH_WAIT_TIME (duration like 500ms, default empty)
-#               BENCH_BASELINE_ARGS (extra reth node args for baseline runs)
-#               BENCH_FEATURE_ARGS (extra reth node args for feature runs)
-#               BENCH_OTLP_TRACES_ENDPOINT (OTLP HTTP endpoint for traces, e.g. https://host/insert/opentelemetry/v1/traces)
-#               BENCH_OTLP_LOGS_ENDPOINT (OTLP HTTP endpoint for logs, e.g. https://host/insert/opentelemetry/v1/logs)
-#               BENCH_OTLP_DISABLED (true to skip OTLP export even if endpoints are set)
-set -euxo pipefail
-
-LABEL="$1"
-BINARY="$2"
-OUTPUT_DIR="$3"
-DATADIR_NAME="datadir"
-if [ "${BENCH_BIG_BLOCKS:-false}" = "true" ]; then
-  DATADIR_NAME="datadir-big-blocks"
-fi
-DATADIR="$SCHELK_MOUNT/$DATADIR_NAME"
-mkdir -p "$OUTPUT_DIR"
-LOG="${OUTPUT_DIR}/node.log"
-
-RETH_SCOPE="${RETH_SCOPE:-reth-bench.scope}"
-
-cleanup() {
-  kill "$TAIL_PID" 2>/dev/null || true
-  # Stop tracy-capture first (SIGINT makes it disconnect and flush to disk)
-  # Must happen before killing reth, otherwise reth keeps streaming data.
-  if [ -n "${TRACY_PID:-}" ] && kill -0 "$TRACY_PID" 2>/dev/null; then
-    echo "Stopping tracy-capture..."
-    kill -INT "$TRACY_PID" 2>/dev/null || true
-    for i in $(seq 1 30); do
-      kill -0 "$TRACY_PID" 2>/dev/null || break
-      if [ $((i % 10)) -eq 0 ]; then
-        echo "Waiting for tracy-capture to finish writing... (${i}s)"
-      fi
-      sleep 1
-    done
-    if kill -0 "$TRACY_PID" 2>/dev/null; then
-      echo "tracy-capture still running after 30s, killing..."
-      kill -9 "$TRACY_PID" 2>/dev/null || true
-    fi
-    wait "$TRACY_PID" 2>/dev/null || true
-  fi
-  if sudo systemctl is-active "$RETH_SCOPE" >/dev/null 2>&1; then
-    if [ "${BENCH_SAMPLY:-false}" = "true" ]; then
-      # Send SIGINT to the inner reth process by exact name (not -f which
-      # would also match samply's cmdline containing "reth"). Samply will
-      # capture reth's exit and save the profile.
-      sudo pkill -INT -x reth 2>/dev/null || true
-      # Wait for samply to finish writing the profile and exit
-      for i in $(seq 1 120); do
-        sudo pgrep -x samply > /dev/null 2>&1 || break
-        if [ $((i % 10)) -eq 0 ]; then
-          echo "Waiting for samply to finish writing profile... (${i}s)"
-        fi
-        sleep 1
-      done
-      if sudo pgrep -x samply > /dev/null 2>&1; then
-        echo "Samply still running after 120s, sending SIGTERM..."
-        sudo pkill -x samply 2>/dev/null || true
-      fi
-    fi
-    # Stop the entire systemd scope — kills all processes in the cgroup.
-    # This is reliable regardless of process reparenting or PID wrapper issues.
-    sudo systemctl stop "$RETH_SCOPE" 2>/dev/null || true
-    sleep 1
-  fi
-  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
-  # 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
-}
-TAIL_PID=
-TRACY_PID=
-trap cleanup EXIT
-
-# Clean up stale state from a previous cancelled run.
-# Stop any leftover reth process in the scope, then recover schelk state.
-sudo systemctl stop "$RETH_SCOPE" 2>/dev/null || true
-sudo systemctl reset-failed "$RETH_SCOPE" 2>/dev/null || true
-sudo schelk recover -y --kill || sudo schelk full-recover -y || true
-
-# Mount
-sudo schelk mount -y || true
-if [ ! -d "$DATADIR/db" ] || [ ! -d "$DATADIR/static_files" ]; then
-  echo "::error::Failed to mount benchmark datadir at ${DATADIR}"
-  ls -la "$SCHELK_MOUNT" || true
-  ls -la "$DATADIR" || true
-  exit 1
-fi
-sync
-sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches'
-echo "=== Cache state after drop ==="
-free -h
-grep Cached /proc/meminfo
-
-# Start reth
-# CPU layout: core 0 = OS/IRQs/reth-bench/aux, cores 1+ = reth node
-RETH_BENCH="$(which reth-bench)"
-ONLINE=$(nproc --all)
-MAX_RETH=$(( ONLINE - 1 ))
-if [ "${BENCH_CORES:-0}" -gt 0 ] && [ "$BENCH_CORES" -lt "$MAX_RETH" ]; then
-  MAX_RETH=$BENCH_CORES
-fi
-RETH_CPUS="1-${MAX_RETH}"
-
-BIG_BLOCKS="${BENCH_BIG_BLOCKS:-false}"
-
-RETH_ARGS=(
-  node
-  --datadir "$DATADIR"
-  --log.file.directory "$OUTPUT_DIR/reth-logs"
-  --engine.accept-execution-requests-hash
-  --http
-  --http.port 8545
-  --ws
-  --ws.api all
-  --authrpc.port 8551
-  --disable-discovery
-  --no-persist-peers
-)
-
-# Gate flag on binary support (older baselines may not have it).
-# Uses --help which exits immediately via clap without node init.
-SYNC_STATE_IDLE=false
-if "$BINARY" node --help 2>/dev/null | grep -qF -- '--debug.startup-sync-state-idle'; then
-  RETH_ARGS+=(--debug.startup-sync-state-idle)
-  SYNC_STATE_IDLE=true
-fi
-
-# Append per-label extra node args (baseline or feature)
-EXTRA_NODE_ARGS=""
-case "$LABEL" in
-  baseline*) EXTRA_NODE_ARGS="${BENCH_BASELINE_ARGS:-}" ;;
-  feature*)  EXTRA_NODE_ARGS="${BENCH_FEATURE_ARGS:-}" ;;
-esac
-if [ -n "$EXTRA_NODE_ARGS" ]; then
-  # Word-split the string into individual args
-  # shellcheck disable=SC2206
-  RETH_ARGS+=($EXTRA_NODE_ARGS)
-fi
-
-if [ -n "${BENCH_METRICS_ADDR:-}" ]; then
-  RETH_ARGS+=(--metrics "$BENCH_METRICS_ADDR")
-fi
-
-# OTLP traces and logs export
-if [ "${BENCH_OTLP_DISABLED:-false}" != "true" ]; then
-  if [ -n "${BENCH_OTLP_TRACES_ENDPOINT:-}" ]; then
-    RETH_ARGS+=(--tracing-otlp="${BENCH_OTLP_TRACES_ENDPOINT}" --tracing-otlp.service-name=reth-bench)
-  fi
-  if [ -n "${BENCH_OTLP_LOGS_ENDPOINT:-}" ]; then
-    RETH_ARGS+=(--logs-otlp="${BENCH_OTLP_LOGS_ENDPOINT}" --logs-otlp.filter=debug)
-  fi
-fi
-
-# Tracy profiling: add --log.tracy flags and set environment
-if [ "${BENCH_TRACY:-off}" != "off" ]; then
-  RETH_ARGS+=(--log.tracy --log.tracy.filter "${BENCH_TRACY_FILTER:-debug}")
-  if [ "${BENCH_TRACY}" = "on" ]; then
-    export TRACY_NO_SYS_TRACE=1
-  elif [ "${BENCH_TRACY}" = "full" ]; then
-    export TRACY_SAMPLING_HZ="${BENCH_TRACY_SAMPLING_HZ:-1}"
-  fi
-fi
-
-SUDO_ENV=()
-if [ -n "${OTEL_RESOURCE_ATTRIBUTES:-}" ]; then
-  SUDO_ENV+=("OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES}")
-  SUDO_ENV+=("OTEL_BSP_MAX_QUEUE_SIZE=65536" "OTEL_BLRP_MAX_QUEUE_SIZE=65536")
-fi
-
-# Limit reth memory to 95% of available RAM to prevent OOM kills
-TOTAL_MEM_KB=$(awk '/^MemTotal:/ {print $2}' /proc/meminfo)
-MEM_LIMIT=$(( TOTAL_MEM_KB * 95 / 100 * 1024 ))
-echo "Memory limit: $(( MEM_LIMIT / 1024 / 1024 ))MB (95% of $(( TOTAL_MEM_KB / 1024 ))MB)"
-
-if [ "${BENCH_SAMPLY:-false}" = "true" ]; then
-  RETH_ARGS+=(--log.samply)
-  SAMPLY="$(which samply)"
-  sudo systemd-run --quiet --scope --collect --unit="$RETH_SCOPE" \
-    -p MemoryMax="$MEM_LIMIT" -p AllowedCPUs="$RETH_CPUS" \
-    env "${SUDO_ENV[@]}" nice -n -20 \
-    "$SAMPLY" record --save-only --presymbolicate --rate 10000 \
-    --output "$OUTPUT_DIR/samply-profile.json.gz" \
-    -- "$BINARY" "${RETH_ARGS[@]}" \
-    > "$LOG" 2>&1 &
-else
-  sudo systemd-run --quiet --scope --collect --unit="$RETH_SCOPE" \
-    -p MemoryMax="$MEM_LIMIT" -p AllowedCPUs="$RETH_CPUS" \
-    env "${SUDO_ENV[@]}" nice -n -20 "$BINARY" "${RETH_ARGS[@]}" \
-    > "$LOG" 2>&1 &
-fi
-stdbuf -oL tail -f "$LOG" | sed -u "s/^/[reth] /" &
-TAIL_PID=$!
-
-for i in $(seq 1 60); do
-  if curl -sf http://127.0.0.1:8545 -X POST \
-    -H 'Content-Type: application/json' \
-    -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
-    > /dev/null 2>&1; then
-    echo "reth (${LABEL}) RPC is up after ${i}s"
-    break
-  fi
-  if [ "$i" -eq 60 ]; then
-    echo "::error::reth (${LABEL}) failed to start within 60s"
-    cat "$LOG"
-    exit 1
-  fi
-  sleep 1
-done
-
-# Wait for the pipeline to finish (eth_syncing returns false) so the
-# engine is in live mode and can accept newPayload calls.
-# Only possible when --debug.startup-sync-state-idle is supported.
-if [ "$SYNC_STATE_IDLE" = "true" ]; then
-  for i in $(seq 1 300); do
-    SYNC_RESULT=$(curl -sf http://127.0.0.1:8545 -X POST \
-      -H 'Content-Type: application/json' \
-      -d '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}' 2>/dev/null || true)
-    if [ -n "$SYNC_RESULT" ] && jq -e '.result == false' <<< "$SYNC_RESULT" > /dev/null 2>&1; then
-      echo "reth (${LABEL}) pipeline finished after ${i}s, engine is live"
-      break
-    fi
-    if [ "$i" -eq 300 ]; then
-      echo "::error::reth (${LABEL}) pipeline did not finish within 300s"
-      cat "$LOG"
-      exit 1
-    fi
-    sleep 1
-  done
-else
-  echo "reth (${LABEL}) binary does not support --debug.startup-sync-state-idle, skipping sync wait"
-fi
-
-# Run reth-bench with high priority but as the current user so output
-# files are not root-owned (avoids EACCES on next checkout).
-BENCH_NICE="sudo nice -n -20 sudo -u $(id -un)"
-
-# Build optional flags
-EXTRA_BENCH_ARGS=(--reth-new-payload)
-if [ -n "${BENCH_WAIT_TIME:-}" ]; then
-  EXTRA_BENCH_ARGS+=(--wait-time "$BENCH_WAIT_TIME")
-fi
-
-if [ "$BIG_BLOCKS" = "true" ]; then
-  # Big blocks mode: replay pre-generated payloads
-  BIG_BLOCKS_DIR="${BENCH_BIG_BLOCKS_DIR:-${BENCH_WORK_DIR}/big-blocks}"
-  BENCH_BAL_MODE="${BENCH_BAL:-false}"
-
-  BB_BENCH_ARGS=(--reth-new-payload)
-  if [ -n "${BENCH_WAIT_TIME:-}" ]; then
-    BB_BENCH_ARGS+=(--wait-time "$BENCH_WAIT_TIME")
-  fi
-  case "$BENCH_BAL_MODE" in
-    false)
-      ;;
-    true)
-      BB_BENCH_ARGS+=(--bal)
-      ;;
-    baseline)
-      if [[ "$LABEL" == baseline* ]]; then
-        BB_BENCH_ARGS+=(--bal)
-      fi
-      ;;
-    feature)
-      if [[ "$LABEL" == feature* ]]; then
-        BB_BENCH_ARGS+=(--bal)
-      fi
-      ;;
-    *)
-      echo "::error::Unknown BENCH_BAL value: $BENCH_BAL_MODE"
-      exit 1
-      ;;
-  esac
-
-  # Warmup
-  WARMUP="${BENCH_WARMUP_BLOCKS:-50}"
-  if [ "$WARMUP" -gt 0 ] 2>/dev/null; then
-    echo "Running big blocks warmup (${WARMUP} payloads)..."
-    $BENCH_NICE "$RETH_BENCH" replay-payloads \
-      "${BB_BENCH_ARGS[@]}" \
-      --count "$WARMUP" \
-      --payload-dir "$BIG_BLOCKS_DIR/payloads" \
-      --engine-rpc-url http://127.0.0.1:8551 \
-      --jwt-secret "$DATADIR/jwt.hex" 2>&1 | sed -u "s/^/[bench] /"
-  fi
-
-  # Start tracy-capture after warmup so profile only covers the benchmark
-  if [ "${BENCH_TRACY:-off}" != "off" ]; then
-    echo "Starting tracy-capture..."
-    tracy-capture -f -o "$OUTPUT_DIR/tracy-profile.tracy" &
-    TRACY_PID=$!
-    sleep 0.5  # give tracy-capture time to connect
-  fi
-
-  # Benchmark — skip warmup payloads so they aren't measured
-  BB_SKIP=0
-  if [ "$WARMUP" -gt 0 ] 2>/dev/null; then
-    BB_SKIP="$WARMUP"
-  fi
-  if [ "${BENCH_BLOCKS:-0}" -gt 0 ] 2>/dev/null; then
-    BB_BENCH_ARGS+=(--count "$BENCH_BLOCKS")
-  fi
-
-  echo "Running big blocks benchmark (replay-payloads, skip=${BB_SKIP})..."
-  $BENCH_NICE "$RETH_BENCH" replay-payloads \
-    "${BB_BENCH_ARGS[@]}" \
-    --skip "$BB_SKIP" \
-    --payload-dir "$BIG_BLOCKS_DIR/payloads" \
-    --engine-rpc-url http://127.0.0.1:8551 \
-    --jwt-secret "$DATADIR/jwt.hex" \
-    --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
-
-  # Start tracy-capture after warmup so profile only covers the benchmark
-  if [ "${BENCH_TRACY:-off}" != "off" ]; then
-    echo "Starting tracy-capture..."
-    tracy-capture -f -o "$OUTPUT_DIR/tracy-profile.tracy" &
-    TRACY_PID=$!
-    sleep 0.5  # give tracy-capture time to connect
-  fi
-
-  # Benchmark
-  $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_BLOCKS" \
-    "${EXTRA_BENCH_ARGS[@]}" \
-    --output "$OUTPUT_DIR" 2>&1 | sed -u "s/^/[bench] /"
-fi
-
-# cleanup runs via trap
diff --git a/.github/scripts/bench-reth-snapshot.sh b/.github/scripts/bench-reth-snapshot.sh
index 5d8b883e544..fa118cfa17c 100755
--- a/.github/scripts/bench-reth-snapshot.sh
+++ b/.github/scripts/bench-reth-snapshot.sh
@@ -1,25 +1,74 @@
 #!/usr/bin/env bash
 #
-# Validates that the benchmark snapshot has already been populated into the
-# local schelk volume.
+# Ensures the benchmark snapshot in the schelk volume matches the expected
+# manifest. If the local manifest marker differs from the remote manifest, the
+# snapshot is replaced via `reth download` and promoted as the new schelk
+# baseline.
 #
 # Usage: bench-reth-snapshot.sh [--check]
-#   --check   Exit 0 if the local snapshot is ready, 10 if it is missing.
+#   --check   Exit 0 if the local snapshot is current, 10 if it needs refresh.
 #
 # Required env:
-#   SCHELK_MOUNT – schelk mount point (e.g. /reth-bench)
+#   SCHELK_MOUNT       - schelk mount point (e.g. /reth-bench)
+#   BENCH_RETH_BINARY  - path to the reth-compatible binary (required to refresh)
+#
 # Optional env:
-#   BENCH_BIG_BLOCKS   – true when validating the big-blocks snapshot datadir
-#   BENCH_SNAPSHOT_NAME – expected snapshot label for log/error output
-set -euxo pipefail
+#   BENCH_BIG_BLOCKS            - true when syncing the big-blocks datadir
+#   BENCH_SNAPSHOT_MANIFEST_URL - exact manifest URL to sync from (normal blocks)
+#   BENCH_BIG_BLOCKS_SNAPSHOT_ROOT - weekly snapshot root URL
+#   BENCH_BIG_BLOCKS_SNAPSHOT_PREFIX - weekly snapshot name prefix
+#   BENCH_BIG_BLOCKS_SNAPSHOT_AGE_WEEKS - snapshot age in weeks (default: 2)
+#   BENCH_SNAPSHOT_NAME         - expected snapshot label for log/error output
+set -euo pipefail
 
 : "${SCHELK_MOUNT:?SCHELK_MOUNT must be set}"
 
+if [ "${1:-}" != "" ] && [ "${1:-}" != "--check" ]; then
+  echo "Usage: $0 [--check]"
+  exit 1
+fi
+
+CHECK_ONLY=false
+if [ "${1:-}" = "--check" ]; then
+  CHECK_ONLY=true
+fi
+
 DATADIR_NAME="datadir"
 if [ "${BENCH_BIG_BLOCKS:-false}" = "true" ]; then
   DATADIR_NAME="datadir-big-blocks"
 fi
 DATADIR="$SCHELK_MOUNT/$DATADIR_NAME"
+LOCAL_MANIFEST="$DATADIR/manifest.json"
+
+resolve_big_blocks_manifest() {
+  local age_weeks="${BENCH_BIG_BLOCKS_SNAPSHOT_AGE_WEEKS:-2}"
+  local root="${BENCH_BIG_BLOCKS_SNAPSHOT_ROOT:-http://10.10.0.50:9000/reth-snapshots}"
+  local prefix="${BENCH_BIG_BLOCKS_SNAPSHOT_PREFIX:-reth-1-minimal-stable-weekly}"
+
+  if ! [[ "$age_weeks" =~ ^[0-9]+$ ]]; then
+    echo "::error::BENCH_BIG_BLOCKS_SNAPSHOT_AGE_WEEKS must be a non-negative integer"
+    exit 1
+  fi
+
+  local snapshot_week
+  if ! snapshot_week="$(date -u -d "${age_weeks} weeks ago" '+%G-W%V')"; then
+    echo "::error::Failed to resolve ${age_weeks}-week-old big-block snapshot week"
+    exit 1
+  fi
+
+  local snapshot_name="${prefix}-${snapshot_week}"
+  BENCH_SNAPSHOT_NAME="${BENCH_SNAPSHOT_NAME:-$snapshot_name}"
+  MANIFEST_URL="${root%/}/${snapshot_name}/manifest.json"
+}
+
+if [ "${BENCH_BIG_BLOCKS:-false}" = "true" ]; then
+  resolve_big_blocks_manifest
+else
+  : "${BENCH_SNAPSHOT_MANIFEST_URL:?BENCH_SNAPSHOT_MANIFEST_URL must be set}"
+  MANIFEST_URL="$BENCH_SNAPSHOT_MANIFEST_URL"
+fi
+
+MANIFEST_BASE_URL="${MANIFEST_URL%/*}"
 
 describe_snapshot() {
   if [ -n "${BENCH_SNAPSHOT_NAME:-}" ]; then
@@ -31,26 +80,101 @@ describe_snapshot() {
   fi
 }
 
+EXPECTED_SNAPSHOT="$(describe_snapshot)"
+
+sudo schelk recover -y --kill || sudo schelk full-recover -y || true
+sudo schelk mount -y
+
+REMOTE_MANIFEST="$(mktemp "${TMPDIR:-/tmp}/reth-bench-remote-manifest.XXXXXX")"
+REMOTE_CANONICAL="$(mktemp "${TMPDIR:-/tmp}/reth-bench-remote-canonical.XXXXXX")"
+LOCAL_CANONICAL="$(mktemp "${TMPDIR:-/tmp}/reth-bench-local-canonical.XXXXXX")"
+DOWNLOAD_MANIFEST="$(mktemp "${TMPDIR:-/tmp}/reth-bench-download-manifest.XXXXXX")"
+trap 'rm -f "$REMOTE_MANIFEST" "$REMOTE_CANONICAL" "$LOCAL_CANONICAL" "$DOWNLOAD_MANIFEST"' EXIT
+
 snapshot_ready() {
   [ -d "$DATADIR/db" ] && [ -d "$DATADIR/static_files" ]
 }
 
-EXPECTED_SNAPSHOT="$(describe_snapshot)"
+sha256_file() {
+  if command -v sha256sum >/dev/null 2>&1; then
+    sha256sum "$1" | awk '{print $1}'
+  else
+    shasum -a 256 "$1" | awk '{print $1}'
+  fi
+}
 
-sudo schelk recover -y --kill || sudo schelk full-recover -y || true
-sudo schelk mount -y || true
+echo "Using ${EXPECTED_SNAPSHOT} manifest: ${MANIFEST_URL}"
+
+if ! curl -fsSL --retry 3 --retry-delay 5 --connect-timeout 10 "$MANIFEST_URL" -o "$REMOTE_MANIFEST"; then
+  echo "::error::Failed to fetch snapshot manifest from ${MANIFEST_URL}"
+  exit 2
+fi
+
+if ! jq -S . "$REMOTE_MANIFEST" > "$REMOTE_CANONICAL"; then
+  echo "::error::Snapshot manifest is not valid JSON"
+  exit 2
+fi
+REMOTE_HASH="$(sha256_file "$REMOTE_CANONICAL")"
+
+LOCAL_HASH=""
+LOCAL_MATCH=false
+if [ -f "$LOCAL_MANIFEST" ] && jq -S . "$LOCAL_MANIFEST" > "$LOCAL_CANONICAL"; then
+  LOCAL_HASH="$(sha256_file "$LOCAL_CANONICAL")"
+  if cmp -s "$REMOTE_CANONICAL" "$LOCAL_CANONICAL"; then
+    LOCAL_MATCH=true
+  fi
+fi
 
-if snapshot_ready; then
-  echo "Found local ${EXPECTED_SNAPSHOT} at ${DATADIR}"
+if [ "$LOCAL_MATCH" = true ] && snapshot_ready; then
+  echo "Snapshot is up-to-date (manifest hash: ${REMOTE_HASH:0:16})"
   exit 0
 fi
 
-echo "::error::Missing local ${EXPECTED_SNAPSHOT} at ${DATADIR}. Benchmarks no longer download snapshots; pre-populate the local schelk data first."
-ls -la "$SCHELK_MOUNT" || true
-ls -la "$DATADIR" || true
+if ! snapshot_ready; then
+  echo "Snapshot needs refresh: missing expected db/ or static_files/ under ${DATADIR}"
+elif [ ! -f "$LOCAL_MANIFEST" ]; then
+  echo "Snapshot needs refresh: missing local manifest marker at ${LOCAL_MANIFEST}"
+elif [ -z "$LOCAL_HASH" ]; then
+  echo "Snapshot needs refresh: local manifest marker is not valid JSON"
+else
+  echo "Snapshot needs refresh (local: ${LOCAL_HASH:0:16}, remote: ${REMOTE_HASH:0:16})"
+fi
 
-if [ "${1:-}" = "--check" ]; then
+if [ "$CHECK_ONLY" = true ]; then
   exit 10
 fi
 
-exit 1
+RETH="${BENCH_RETH_BINARY:?BENCH_RETH_BINARY must be set when refreshing the snapshot}"
+if [ ! -x "$RETH" ]; then
+  echo "::error::reth binary not found or not executable at ${RETH}"
+  exit 1
+fi
+
+# Force archive URLs to resolve relative to the configured manifest endpoint.
+# Some published manifests carry a base_url that is valid for publishers but
+# not for benchmark runners.
+jq --arg base "$MANIFEST_BASE_URL" '.base_url = $base' "$REMOTE_MANIFEST" > "$DOWNLOAD_MANIFEST"
+
+sudo rm -rf "$DATADIR"
+sudo mkdir -p "$DATADIR"
+# reth download runs as the current user and needs write access.
+sudo chown -R "$(id -u):$(id -g)" "$DATADIR"
+
+"$RETH" download \
+  --manifest-path "$DOWNLOAD_MANIFEST" \
+  -y \
+  --minimal \
+  --datadir "$DATADIR"
+
+if ! snapshot_ready; then
+  echo "::error::Snapshot download did not produce expected directory layout (missing db/ or static_files/)"
+  ls -la "$DATADIR" || true
+  exit 1
+fi
+
+cp "$REMOTE_MANIFEST" "$LOCAL_MANIFEST"
+
+sync
+sudo schelk promote -y
+
+echo "Snapshot promoted to schelk baseline (manifest hash: ${REMOTE_HASH:0:16})"
diff --git a/.github/scripts/bench-reth-summary.py b/.github/scripts/bench-reth-summary.py
index 300006cad6c..9b942a183af 100755
--- a/.github/scripts/bench-reth-summary.py
+++ b/.github/scripts/bench-reth-summary.py
@@ -1,31 +1,60 @@
 #!/usr/bin/env python3
-"""Parse reth-bench CSV output and generate a summary JSON + markdown comparison.
+"""Parse benchmark CSV output and generate a summary JSON + markdown comparison.
 
 Usage:
-    bench-reth-summary.py <combined_csv> <gas_csv> \
+    bench-reth-summary.py \
         --output-summary <summary.json> \
         --output-markdown <comment.md> \
-        --baseline-csv <baseline_combined.csv> \
+        --baseline-csv <baseline_combined.csv> [<baseline_combined.csv> ...] \
         [--repo <owner/repo>] \
         [--baseline-ref <sha>] \
         [--feature-name <name>] \
         [--feature-sha <sha>]
 
-Generates a paired statistical comparison between baseline and feature.
-Matches blocks by number and computes per-block diffs to cancel out gas
-variance. Fails if baseline or feature CSV is missing or empty.
+Generates a statistical comparison between baseline and feature. Point estimates
+use pooled baseline and feature rows. Confidence intervals use whole-run cluster
+bootstrapping when multiple runs are available. Fails if baseline or feature CSV
+is missing or empty.
 """
 
+from __future__ import annotations
+
 import argparse
 import csv
+from datetime import datetime, timezone
 import json
 import math
+import os
+from pathlib import Path
 import random
+import re
 import sys
+import time
+from urllib.parse import quote
 
-GIGAGAS = 1_000_000_000
-T_CRITICAL = 1.96  # two-tailed 95% confidence
 BOOTSTRAP_ITERATIONS = 10_000
+EPSILON = 1e-9
+P99_MIN_VERDICT_BLOCKS = 125
+PERSIST_WAIT_MIN_VERDICT_MS = 0.5
+PERSIST_WAIT_MIN_TOTAL_PCT = 0.1
+TARGET_METRIC_BLOCK_HEIGHT_QUERY = "reth_blockchain_tree_canonical_chain_height"
+TARGET_METRIC_COUNTER_STATS = ("mean",)
+TARGET_METRIC_MIN_PAIRED_OBSERVATIONS = 30
+SELECTOR_RE = re.compile(
+    r"^(?P<name>[a-zA-Z_:][a-zA-Z0-9_:]*)(?:\{(?P<labels>[^}]*)\})?$"
+)
+PRACTICAL_FLOOR_PCT = {
+    "mean": 1.20,
+    "p50": 1.20,
+    "p90": 1.35,
+    "p99": 5.0,
+    "mgas_s": 1.20,
+    "wall_clock": 0.70,
+    "persist_wait": 5.0,
+}
+LOGS_DATASOURCE_UID = "cfk1hzy08xekgd"
+TRACES_DATASOURCE_UID = "dfk1hrnxca9s0a"
+GRAFANA_EXPLORE_URL = "https://tempoxyz.grafana.net/explore"
 
 
 def _opt_int(row: dict, key: str) -> int | None:
@@ -46,10 +75,7 @@ def parse_combined_csv(path: str) -> list[dict]:
                 {
                     "block_number": int(row["block_number"]),
                     "gas_used": int(row["gas_used"]),
-                    "gas_limit": int(row["gas_limit"]),
-                    "transaction_count": int(row["transaction_count"]),
                     "new_payload_latency_us": int(row["new_payload_latency"]),
-                    "fcu_latency_us": int(row["fcu_latency"]),
                     "total_latency_us": int(row["total_latency"]),
                     "persistence_wait_us": _opt_int(row, "persistence_wait"),
                     "execution_cache_wait_us": _opt_int(row, "execution_cache_wait"),
@@ -59,22 +85,6 @@ def parse_combined_csv(path: str) -> list[dict]:
     return rows
 
 
-def parse_gas_csv(path: str) -> list[dict]:
-    """Parse total_gas.csv into a list of per-block dicts."""
-    rows = []
-    with open(path) as f:
-        reader = csv.DictReader(f)
-        for row in reader:
-            rows.append(
-                {
-                    "block_number": int(row["block_number"]),
-                    "gas_used": int(row["gas_used"]),
-                    "time_us": int(row["time"]),
-                }
-            )
-    return rows
-
-
 def stddev(values: list[float], mean: float) -> float:
     if len(values) < 2:
         return 0.0
@@ -89,6 +99,131 @@ def percentile(sorted_vals: list[float], pct: int) -> float:
     return sorted_vals[idx]
 
 
+def parse_label_string(text: str | None) -> dict[str, str]:
+    if not text:
+        return {}
+
+    labels = {}
+    parts = []
+    current = []
+    in_quotes = False
+    escaped = False
+    for ch in text:
+        if escaped:
+            current.append(ch)
+            escaped = False
+            continue
+        if ch == "\\":
+            current.append(ch)
+            escaped = True
+            continue
+        if ch == '"':
+            current.append(ch)
+            in_quotes = not in_quotes
+            continue
+        if ch == "," and not in_quotes:
+            parts.append("".join(current).strip())
+            current = []
+            continue
+        current.append(ch)
+    if current:
+        parts.append("".join(current).strip())
+
+    for part in parts:
+        if not part:
+            continue
+        key, value = part.split("=", 1)
+        labels[key.strip()] = bytes(value.strip()[1:-1], "utf-8").decode("unicode_escape")
+    return labels
+
+
+def parse_target_metric_query(query: str) -> tuple[str, str, dict[str, str]]:
+    query = query.strip()
+    aggregate = "single"
+    inner = query
+    if query.startswith("sum(") and query.endswith(")"):
+        aggregate = "sum"
+        inner = query[4:-1].strip()
+
+    match = SELECTOR_RE.match(inner)
+    if not match:
+        raise ValueError(f"Unsupported target metric query: {query}")
+    return aggregate, match.group("name"), parse_label_string(match.group("labels"))
+
+
+def format_label_value(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def format_target_metric_query(metric_name: str, labels: dict[str, str]) -> str:
+    if not labels:
+        return metric_name
+    encoded_labels = ",".join(
+        f'{key}="{format_label_value(value)}"' for key, value in sorted(labels.items())
+    )
+    return f"{metric_name}{{{encoded_labels}}}"
+
+
+def histogram_counter_query(query: str, suffix: str) -> str:
+    aggregate, metric_name, label_filters = parse_target_metric_query(query)
+    if aggregate != "single":
+        raise ValueError(f"Histogram target metric queries must not use sum(...): {query}")
+    return format_target_metric_query(f"{metric_name}_{suffix}", label_filters)
+
+
+def target_metric_query_encodes_seconds(query: str) -> bool:
+    _aggregate, metric_name, _label_filters = parse_target_metric_query(query)
+    return "_seconds" in metric_name
+
+
+def target_metric_counter_encodes_seconds(query: str) -> bool:
+    return target_metric_query_encodes_seconds(query)
+
+
+def target_metric_min_value_pct_total_latency(config: dict) -> float | None:
+    value = config.get("min_value_pct_total_latency")
+    if value is None:
+        return None
+    value = float(value)
+    if value < 0.0:
+        raise ValueError("min_value_pct_total_latency must be non-negative")
+    return value
+
+
+def query_matches_sample(sample: dict, metric_name: str, label_filters: dict[str, str]) -> bool:
+    return sample["name"] == metric_name and all(
+        sample["labels"].get(key) == value for key, value in label_filters.items()
+    )
+
+
+def query_samples(samples: list[dict], query: str) -> tuple[str, list[dict]]:
+    aggregate, metric_name, label_filters = parse_target_metric_query(query)
+    matches = [
+        sample
+        for sample in samples
+        if query_matches_sample(sample, metric_name, label_filters)
+    ]
+    return aggregate, matches
+
+
+def evaluate_query(samples: list[dict], query: str, allow_missing: bool = False) -> float:
+    aggregate, matched_samples = query_samples(samples, query)
+    matches = [sample["value"] for sample in matched_samples]
+
+    if not matches:
+        if allow_missing:
+            return 0.0
+        raise ValueError(f"Query matched no samples: {query}")
+
+    if aggregate == "sum":
+        return float(sum(matches))
+    if len(matches) > 1:
+        raise ValueError(
+            f"Query matched {len(matches)} samples; use sum(...) or label filters: {query}"
+        )
+    return float(matches[0])
+
+
 def compute_stats(combined: list[dict]) -> dict:
     """Compute per-run statistics from parsed CSV data."""
     n = len(combined)
@@ -133,6 +268,24 @@ def compute_stats(combined: list[dict]) -> dict:
     }
 
 
+def compute_point_stats(runs: list[list[dict]]) -> dict:
+    """Compute displayed point estimates for one side of a comparison.
+
+    Cluster CIs estimate percentile changes from one percentile value per run.
+    Match that estimator for displayed percentile point estimates instead of
+    pooling repeated block rows into one percentile sample.
+    """
+    combined = [row for run in runs for row in run]
+    stats = compute_stats(combined)
+    if len(runs) < 2:
+        return stats
+
+    per_run_stats = [compute_stats(run) for run in runs if run]
+    for key in ("p50_ms", "p90_ms", "p99_ms"):
+        stats[key] = _mean([run_stats[key] for run_stats in per_run_stats])
+    return stats
+
+
 def compute_wait_stats(combined: list[dict], field: str) -> dict:
     """Compute mean/p50/p95 for a wait time field (in ms)."""
     values_ms = []
@@ -196,110 +349,164 @@ def _paired_data(
     return pairs, lat_diffs_ms, mgas_diffs, total_lat_diffs_ms, persist_diffs_ms
 
 
-def compute_paired_stats(
+def _bootstrap_ci(rng: random.Random, diffs: list[float], n_iter: int = BOOTSTRAP_ITERATIONS) -> float:
+    """Compute 95% bootstrap CI half-width for the mean of *diffs*."""
+    if len(diffs) < 2:
+        return 0.0
+    n = len(diffs)
+    boot_means = sorted(
+        sum(rng.choices(diffs, k=n)) / n for _ in range(n_iter)
+    )
+    lo = int(n_iter * 0.025)
+    hi = int(n_iter * 0.975)
+    return (boot_means[hi] - boot_means[lo]) / 2
+
+
+def _bootstrap_percentile_ci(
+    rng: random.Random,
+    pairs: list[tuple[float, float]],
+    pct: int,
+    n_iter: int = BOOTSTRAP_ITERATIONS,
+) -> float:
+    """Compute 95% bootstrap CI half-width for a difference-of-percentiles."""
+    if len(pairs) < 2:
+        return 0.0
+    n = len(pairs)
+    boot_diffs = []
+    for _ in range(n_iter):
+        sample = rng.choices(pairs, k=n)
+        b_sorted = sorted(p[0] for p in sample)
+        f_sorted = sorted(p[1] for p in sample)
+        boot_diffs.append(percentile(f_sorted, pct) - percentile(b_sorted, pct))
+    boot_diffs.sort()
+    lo = int(n_iter * 0.025)
+    hi = int(n_iter * 0.975)
+    return (boot_diffs[hi] - boot_diffs[lo]) / 2
+
+
+def _ci_half_width(samples: list[float]) -> float:
+    """Return the 95% CI half-width from sorted bootstrap samples."""
+    if len(samples) < 2:
+        return 0.0
+    samples.sort()
+    n = len(samples)
+    lo = int(n * 0.025)
+    hi = int(n * 0.975)
+    return (samples[hi] - samples[lo]) / 2
+
+
+def _mean(values: list[float]) -> float:
+    return sum(values) / len(values) if values else 0.0
+
+
+def _per_run_metric_values(runs: list[list[dict]]) -> dict[str, list[float]]:
+    """Compute one metric value per benchmark run for cluster bootstrap."""
+    values = {
+        "mean_ms": [],
+        "p50_ms": [],
+        "p90_ms": [],
+        "p99_ms": [],
+        "mgas": [],
+        "wall_clock_ms": [],
+        "persist_ms": [],
+    }
+    for run in runs:
+        stats = compute_stats(run)
+        values["mean_ms"].append(stats["mean_ms"])
+        values["p50_ms"].append(stats["p50_ms"])
+        values["p90_ms"].append(stats["p90_ms"])
+        values["p99_ms"].append(stats["p99_ms"])
+        values["mgas"].append(stats["mean_mgas_s"])
+        values["wall_clock_ms"].append(stats["mean_total_lat_ms"])
+        values["persist_ms"].append(stats["mean_persist_ms"])
+    return values
+
+
+def _cluster_bootstrap_ci(
+    rng: random.Random,
     baseline_runs: list[list[dict]],
     feature_runs: list[list[dict]],
-) -> dict:
-    """Compute paired statistics between baseline and feature runs.
+    n_iter: int = BOOTSTRAP_ITERATIONS,
+) -> dict[str, float]:
+    """Compute run-cluster bootstrap CIs.
 
-    Each pair (baseline_runs[i], feature_runs[i]) produces per-block diffs.
-    All diffs are pooled for the final CI.
+    Each bootstrap sample resamples whole baseline and feature runs with
+    replacement. This estimates run-to-run noise without expanding reused
+    baseline/feature runs into independent block-level datapoints.
     """
-    all_pairs = []
-    all_lat_diffs = []
-    all_mgas_diffs = []
-    all_total_lat_diffs = []
-    all_persist_diffs = []
-    blocks_per_pair = []
-    for baseline, feature in zip(baseline_runs, feature_runs):
-        pairs, lat_diffs, mgas_diffs, total_lat_diffs, persist_diffs = _paired_data(baseline, feature)
-        all_pairs.extend(pairs)
-        all_lat_diffs.extend(lat_diffs)
-        all_mgas_diffs.extend(mgas_diffs)
-        all_total_lat_diffs.extend(total_lat_diffs)
-        all_persist_diffs.extend(persist_diffs)
-        blocks_per_pair.append(len(pairs))
-
-    if not all_lat_diffs:
-        return {}
+    metrics = ("mean_ms", "p50_ms", "p90_ms", "p99_ms", "mgas", "wall_clock_ms", "persist_ms")
+    empty = {metric: 0.0 for metric in metrics}
+    if len(baseline_runs) < 2 or len(feature_runs) < 2:
+        return empty
+
+    baseline_values = _per_run_metric_values(baseline_runs)
+    feature_values = _per_run_metric_values(feature_runs)
+    samples = {metric: [] for metric in metrics}
+    baseline_count = len(baseline_runs)
+    feature_count = len(feature_runs)
+
+    for _ in range(n_iter):
+        baseline_indexes = [rng.randrange(baseline_count) for _ in range(baseline_count)]
+        feature_indexes = [rng.randrange(feature_count) for _ in range(feature_count)]
+        for metric in metrics:
+            baseline_sample = [baseline_values[metric][i] for i in baseline_indexes]
+            feature_sample = [feature_values[metric][i] for i in feature_indexes]
+            samples[metric].append(_mean(feature_sample) - _mean(baseline_sample))
 
-    n = len(all_lat_diffs)
-    mean_diff = sum(all_lat_diffs) / n
-    std_diff = stddev(all_lat_diffs, mean_diff)
-    se = std_diff / math.sqrt(n) if n > 0 else 0.0
-    ci = T_CRITICAL * se
+    return {metric: _ci_half_width(samples[metric]) for metric in metrics}
 
-    # Bootstrap CI on difference-of-percentiles (resample paired blocks)
-    base_lats = sorted([p[0] for p in all_pairs])
-    feature_lats = sorted([p[1] for p in all_pairs])
-    p50_diff = percentile(feature_lats, 50) - percentile(base_lats, 50)
-    p90_diff = percentile(feature_lats, 90) - percentile(base_lats, 90)
-    p99_diff = percentile(feature_lats, 99) - percentile(base_lats, 99)
 
+def compute_ci_stats(
+    baseline_runs: list[list[dict]],
+    feature_runs: list[list[dict]],
+) -> dict:
+    """Compute confidence interval half-widths for displayed changes.
+
+    Multiple-run comparisons resample whole runs so reused blocks are not
+    treated as independent observations. Single-run comparisons fall back to
+    block-level bootstrap over matched block numbers.
+    """
+    if not baseline_runs or not feature_runs:
+        return {}
+
+    blocks = max(len(run) for run in baseline_runs + feature_runs)
     rng = random.Random(42)
-    p50_boot, p90_boot, p99_boot = [], [], []
-    for _ in range(BOOTSTRAP_ITERATIONS):
-        sample = rng.choices(all_pairs, k=n)
-        b_sorted = sorted(p[0] for p in sample)
-        f_sorted = sorted(p[1] for p in sample)
-        p50_boot.append(percentile(f_sorted, 50) - percentile(b_sorted, 50))
-        p90_boot.append(percentile(f_sorted, 90) - percentile(b_sorted, 90))
-        p99_boot.append(percentile(f_sorted, 99) - percentile(b_sorted, 99))
-    p50_boot.sort()
-    p90_boot.sort()
-    p99_boot.sort()
-    lo = int(BOOTSTRAP_ITERATIONS * 0.025)
-    hi = int(BOOTSTRAP_ITERATIONS * 0.975)
-
-    mean_mgas_diff = sum(all_mgas_diffs) / len(all_mgas_diffs) if all_mgas_diffs else 0.0
-    std_mgas_diff = stddev(all_mgas_diffs, mean_mgas_diff) if len(all_mgas_diffs) > 1 else 0.0
-    mgas_se = std_mgas_diff / math.sqrt(len(all_mgas_diffs)) if all_mgas_diffs else 0.0
-    mgas_ci = T_CRITICAL * mgas_se
-
-    mean_total_diff = sum(all_total_lat_diffs) / len(all_total_lat_diffs) if all_total_lat_diffs else 0.0
-    std_total_diff = stddev(all_total_lat_diffs, mean_total_diff) if len(all_total_lat_diffs) > 1 else 0.0
-    total_se = std_total_diff / math.sqrt(len(all_total_lat_diffs)) if all_total_lat_diffs else 0.0
-    wall_clock_ci_ms = T_CRITICAL * total_se
-
-    mean_persist_diff = sum(all_persist_diffs) / len(all_persist_diffs) if all_persist_diffs else 0.0
-    std_persist_diff = stddev(all_persist_diffs, mean_persist_diff) if len(all_persist_diffs) > 1 else 0.0
-    persist_se = std_persist_diff / math.sqrt(len(all_persist_diffs)) if all_persist_diffs else 0.0
-    persist_ci_ms = T_CRITICAL * persist_se
+
+    if len(baseline_runs) >= 2 and len(feature_runs) >= 2:
+        cluster_ci = _cluster_bootstrap_ci(rng, baseline_runs, feature_runs)
+        ci = cluster_ci["mean_ms"]
+        p50_ci = cluster_ci["p50_ms"]
+        p90_ci = cluster_ci["p90_ms"]
+        p99_ci = cluster_ci["p99_ms"]
+        mgas_ci = cluster_ci["mgas"]
+        wall_clock_ci_ms = cluster_ci["wall_clock_ms"]
+        persist_ci_ms = cluster_ci["persist_ms"]
+    else:
+        pairs, all_lat_diffs, all_mgas_diffs, all_total_lat_diffs, all_persist_diffs = (
+            _paired_data(baseline_runs[0], feature_runs[0])
+        )
+        if not all_lat_diffs:
+            return {}
+        ci = _bootstrap_ci(rng, all_lat_diffs)
+        p50_ci = _bootstrap_percentile_ci(rng, pairs, 50)
+        p90_ci = _bootstrap_percentile_ci(rng, pairs, 90)
+        p99_ci = _bootstrap_percentile_ci(rng, pairs, 99)
+        mgas_ci = _bootstrap_ci(rng, all_mgas_diffs) if all_mgas_diffs else 0.0
+        wall_clock_ci_ms = _bootstrap_ci(rng, all_total_lat_diffs) if all_total_lat_diffs else 0.0
+        persist_ci_ms = _bootstrap_ci(rng, all_persist_diffs) if all_persist_diffs else 0.0
 
     return {
-        "n": n,
-        "mean_diff_ms": mean_diff,
         "ci_ms": ci,
-        "p50_diff_ms": p50_diff,
-        "p50_ci_ms": (p50_boot[hi] - p50_boot[lo]) / 2,
-        "p90_diff_ms": p90_diff,
-        "p90_ci_ms": (p90_boot[hi] - p90_boot[lo]) / 2,
-        "p99_diff_ms": p99_diff,
-        "p99_ci_ms": (p99_boot[hi] - p99_boot[lo]) / 2,
-        "mean_mgas_diff": mean_mgas_diff,
+        "p50_ci_ms": p50_ci,
+        "p90_ci_ms": p90_ci,
+        "p99_ci_ms": p99_ci,
         "mgas_ci": mgas_ci,
         "wall_clock_ci_ms": wall_clock_ci_ms,
         "persist_ci_ms": persist_ci_ms,
-        "blocks": max(blocks_per_pair),
+        "blocks": blocks,
     }
 
 
-
-def format_duration(seconds: float) -> str:
-    if seconds >= 60:
-        return f"{seconds / 60:.1f}min"
-    return f"{seconds}s"
-
-
-def format_gas(gas: int) -> str:
-    if gas >= GIGAGAS:
-        return f"{gas / GIGAGAS:.1f}G"
-    if gas >= 1_000_000:
-        return f"{gas / 1_000_000:.1f}M"
-    return f"{gas:,}"
-
-
-
 def fmt_ms(v: float) -> str:
     return f"{v:.2f}ms"
 
@@ -312,6 +519,23 @@ def fmt_s(v: float) -> str:
     return f"{v:.2f}s"
 
 
+def fmt_metric_value(v: float) -> str:
+    abs_v = abs(v)
+    if abs_v == 0:
+        return "0"
+    if abs_v < 0.001:
+        return f"{v:.4g}"
+    if abs_v >= 1 and abs(v - round(v)) <= 0.00005:
+        return f"{round(v):.0f}"
+    return f"{v:.4f}".rstrip("0").rstrip(".")
+
+
+def fmt_target_metric_value(metric: dict, v: float) -> str:
+    if metric.get("unit") == "seconds":
+        return fmt_ms(v * 1_000.0)
+    return fmt_metric_value(v)
+
+
 def display_bal_mode(bal_mode: str | None) -> str | None:
     if not bal_mode or bal_mode == "false":
         return None
@@ -320,29 +544,75 @@ def display_bal_mode(bal_mode: str | None) -> str | None:
     return bal_mode
 
 
-def significance(pct: float, ci_pct: float, lower_is_better: bool) -> str:
-    """Return significance label: 'good', 'bad', or 'neutral'."""
-    significant = abs(pct) > ci_pct
-    if not significant:
-        return "neutral"
-    elif (pct < 0) == lower_is_better:
+def practical_floor_pct(metric: str, _baseline_value: float) -> float:
+    """Return the practical significance floor as a percent of baseline."""
+    return PRACTICAL_FLOOR_PCT.get(metric, 0.0)
+
+
+def significance(pct: float, ci_pct: float, floor_pct: float, lower_is_better: bool) -> str:
+    """Return significance label: 'good', 'bad', or 'neutral'.
+
+    A result is only significant if the whole confidence interval clears a
+    practical significance floor. The floor is the same for every run shape;
+    higher run counts only tighten the CI.
+    """
+    improvement_pct = -pct if lower_is_better else pct
+    if improvement_pct - ci_pct > floor_pct:
         return "good"
-    else:
+    if improvement_pct + ci_pct < -floor_pct:
         return "bad"
+    return "neutral"
+
+
+def persist_wait_is_material(stats: dict) -> bool:
+    threshold = max(
+        PERSIST_WAIT_MIN_VERDICT_MS,
+        stats["mean_total_lat_ms"] * PERSIST_WAIT_MIN_TOTAL_PCT / 100.0,
+    )
+    return stats["mean_persist_ms"] >= threshold
+
 
+def informational_reason(
+    metric: str,
+    ci_stats: dict,
+    baseline_stats: dict,
+    feature_stats: dict,
+) -> str | None:
+    if metric == "p99" and ci_stats["blocks"] < P99_MIN_VERDICT_BLOCKS:
+        return f"informational <{P99_MIN_VERDICT_BLOCKS} blocks"
+    if (
+        metric == "persist_wait" and
+        not persist_wait_is_material(baseline_stats) and
+        not persist_wait_is_material(feature_stats)
+    ):
+        return (
+            f"informational <max({PERSIST_WAIT_MIN_VERDICT_MS:.1f}ms, "
+            f"{PERSIST_WAIT_MIN_TOTAL_PCT:.1f}% total latency)"
+        )
+    return None
 
-def change_str(pct: float, ci_pct: float, lower_is_better: bool) -> str:
-    """Format change% with paired CI significance.
 
-    Significant if the CI doesn't cross zero (i.e. |pct| > ci_pct).
+def change_str(
+    pct: float,
+    ci_pct: float,
+    floor_pct: float,
+    lower_is_better: bool,
+    informational: str | None = None,
+) -> str:
+    """Format change% with CI significance.
+
+    Significant if the confidence interval clears the practical floor.
     """
-    sig = significance(pct, ci_pct, lower_is_better)
+    sig = "neutral" if informational else significance(pct, ci_pct, floor_pct, lower_is_better)
     emoji = {"good": "✅", "bad": "❌", "neutral": "⚪"}[sig]
-    return f"{pct:+.2f}% {emoji} (±{ci_pct:.2f}%)"
+    details = [f"±{ci_pct:.2f}%", f"floor {floor_pct:.2f}%"]
+    if informational:
+        details.append("informational")
+    return f"{pct:+.2f}% {emoji} ({', '.join(details)})"
 
 
 def compute_changes(
-    baseline_stats: dict, feature_stats: dict, paired_stats: dict
+    baseline_stats: dict, feature_stats: dict, ci_stats: dict
 ) -> dict:
     """Pre-compute change percentages and significance for each metric."""
     def pct(base: float, feat: float) -> float:
@@ -363,19 +633,1024 @@ def ci_pct(ci_ms: float, base_ms: float) -> float:
     changes = {}
     for name, stat_key, ci_key, base_key, lower_is_better in metrics:
         p = pct(baseline_stats[stat_key], feature_stats[stat_key])
-        c = ci_pct(paired_stats[ci_key], baseline_stats[base_key])
+        c = ci_pct(ci_stats[ci_key], baseline_stats[base_key])
+        floor = practical_floor_pct(name, baseline_stats[base_key])
+        informational = informational_reason(name, ci_stats, baseline_stats, feature_stats)
+        sig = significance(p, c, floor, lower_is_better)
         changes[name] = {
             "pct": round(p, 4),
             "ci_pct": round(c, 4),
-            "sig": significance(p, c, lower_is_better),
+            "floor_pct": round(floor, 4),
+            "sig": "neutral" if informational else sig,
         }
+        if informational:
+            changes[name]["informational"] = True
+            changes[name]["informational_reason"] = informational
+            changes[name]["raw_sig"] = sig
     return changes
 
 
+def target_metric_identity_key(labels: dict[str, str]) -> tuple[tuple[str, str], ...]:
+    return tuple(sorted(labels.items()))
+
+
+def target_metric_candidate_identity_labels(
+    query: str,
+    sample_labels: dict[str, str],
+) -> dict[str, str]:
+    _aggregate, _metric_name, label_filters = parse_target_metric_query(query)
+    return {
+        key: value
+        for key, value in sorted(sample_labels.items())
+        if key not in label_filters
+    }
+
+
+def target_metric_variable_identity_label_keys(
+    scrapes: list[dict],
+    query: str,
+) -> set[str]:
+    aggregate, _metric_name, _label_filters = parse_target_metric_query(query)
+    if aggregate == "sum":
+        return set()
+
+    matched_labels = []
+    candidate_keys = set()
+    for scrape in scrapes:
+        _aggregate, matched_samples = query_samples(scrape["samples"], query)
+        for sample in matched_samples:
+            labels = target_metric_candidate_identity_labels(query, sample["labels"])
+            matched_labels.append(labels)
+            candidate_keys.update(labels)
+
+    return {
+        key
+        for key in candidate_keys
+        if len({labels.get(key) for labels in matched_labels}) > 1
+    }
+
+
+def target_metric_identity_labels(
+    query: str,
+    sample_labels: dict[str, str],
+    identity_label_keys: set[str],
+) -> dict[str, str]:
+    candidate_labels = target_metric_candidate_identity_labels(query, sample_labels)
+    return {
+        key: value
+        for key, value in candidate_labels.items()
+        if key in identity_label_keys
+    }
+
+
+def target_metric_display_query(query: str, identity_labels: dict[str, str] | None = None) -> str:
+    _, metric_name, label_filters = parse_target_metric_query(query)
+    display_labels = dict(label_filters)
+    if identity_labels:
+        display_labels.update(identity_labels)
+    return re.sub(r"\s+", "", format_target_metric_query(metric_name, display_labels))
+
+
+def group_query_samples_by_identity(
+    samples: list[dict],
+    query: str,
+    identity_label_keys: set[str],
+) -> tuple[str, dict]:
+    aggregate, matched_samples = query_samples(samples, query)
+    groups = {}
+    if aggregate == "sum":
+        if matched_samples:
+            groups[()] = {"identity_labels": {}, "samples": matched_samples}
+        return aggregate, groups
+
+    for sample in matched_samples:
+        identity_labels = target_metric_identity_labels(
+            query,
+            sample["labels"],
+            identity_label_keys,
+        )
+        key = target_metric_identity_key(identity_labels)
+        group = groups.setdefault(key, {"identity_labels": identity_labels, "samples": []})
+        group["samples"].append(sample)
+    return aggregate, groups
+
+
+def grouped_sample_value(group: dict | None, aggregate: str, allow_missing: bool = False) -> float:
+    if not group or not group["samples"]:
+        if allow_missing:
+            return 0.0
+        raise ValueError("Target metric sample group was empty")
+
+    values = [float(sample["value"]) for sample in group["samples"]]
+    if aggregate == "sum":
+        return sum(values)
+    return sum(values) / len(values)
+
+
+def collect_metric_identities(grouped_scrapes: list[dict]) -> dict[tuple[tuple[str, str], ...], dict[str, str]]:
+    identities = {}
+    for grouped in grouped_scrapes:
+        for key, group in grouped.items():
+            identities.setdefault(key, group["identity_labels"])
+    return identities
+
+
+def format_target_metric_identity(query: str, identity_labels: dict[str, str]) -> str:
+    return target_metric_display_query(query, identity_labels)
+
+
+def load_target_metric_range(path: str) -> dict:
+    range_path = Path(path).with_name("target-metrics-range.json")
+    with open(range_path) as f:
+        metadata = json.load(f)
+    if not metadata.get("benchmark_id"):
+        raise ValueError(f"Missing benchmark_id in {range_path}")
+    metadata["benchmark_run"] = run_label_from_path(path)
+    if metadata.get("duration_ms", 0) <= 0:
+        raise ValueError(f"Non-positive target metric scrape range in {range_path}")
+    return metadata
+
+
+def load_target_metric_scrapes(path: str) -> list[dict]:
+    scrape_path = Path(path).with_name("target-metrics-scrapes.jsonl")
+    scrapes_by_unix_ms = {}
+    with open(scrape_path) as f:
+        for line_number, line in enumerate(f, start=1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                sample = json.loads(line)
+            except json.JSONDecodeError as err:
+                raise ValueError(f"Invalid target metric scrape JSON in {scrape_path}:{line_number}: {err}") from err
+            if not isinstance(sample, dict):
+                raise ValueError(f"Invalid target metric sample in {scrape_path}:{line_number}")
+            if not all(key in sample for key in ("name", "labels", "value", "offset_ms", "unix_ms")):
+                raise ValueError(f"Incomplete target metric scrape record in {scrape_path}:{line_number}")
+            if not isinstance(sample["name"], str) or not isinstance(sample["labels"], dict):
+                raise ValueError(f"Invalid target metric scrape record in {scrape_path}:{line_number}")
+
+            unix_ms = int(sample["unix_ms"])
+            offset_ms = int(sample["offset_ms"])
+
+            scrape = scrapes_by_unix_ms.setdefault(unix_ms, {"unix_ms": unix_ms, "_offset_ms": offset_ms, "samples": []})
+            if scrape["_offset_ms"] != offset_ms:
+                raise ValueError(
+                    f"Mismatched target metric sample offsets for scrape {unix_ms} in {scrape_path}"
+                )
+            scrape["samples"].append(
+                {
+                    "name": sample["name"],
+                    "labels": dict(sorted(sample["labels"].items())),
+                    "value": float(sample["value"]),
+                }
+            )
+    scrapes = sorted(scrapes_by_unix_ms.values(), key=lambda scrape: int(scrape["unix_ms"]))
+    for scrape in scrapes:
+        del scrape["_offset_ms"]
+    if not scrapes:
+        raise ValueError(f"No target metric scrapes found in {scrape_path}")
+    return scrapes
+
+
+def compute_target_metric_series_stats(values: list[float]) -> dict[str, float]:
+    if not values:
+        raise ValueError("Target metric series was empty")
+    sorted_values = sorted(values)
+    return {
+        "mean": sum(values) / len(values),
+        "p50": percentile(sorted_values, 50),
+        "p90": percentile(sorted_values, 90),
+        "p99": percentile(sorted_values, 99),
+    }
+
+
+def counter_target_metric_stat_value(values: list[float], stat_name: str) -> float:
+    if stat_name == "mean":
+        return sum(values) / len(values)
+    if stat_name == "p50":
+        return percentile(sorted(values), 50)
+    if stat_name == "p90":
+        return percentile(sorted(values), 90)
+    if stat_name == "p99":
+        return percentile(sorted(values), 99)
+    raise ValueError(f"Unsupported target metric statistic: {stat_name}")
+
+
+def paired_target_metric_observations(
+    baseline_run: dict, feature_run: dict
+) -> list[tuple[float, float]]:
+    pairs = []
+    baseline_by_block = {
+        observation["block_height"]: observation["value"]
+        for observation in baseline_run["_observations"]
+    }
+    feature_by_block = {
+        observation["block_height"]: observation["value"]
+        for observation in feature_run["_observations"]
+    }
+    for block_height in sorted(set(baseline_by_block) & set(feature_by_block)):
+        pairs.append((baseline_by_block[block_height], feature_by_block[block_height]))
+    return pairs
+
+
+def target_metric_stat_diff(pairs: list[tuple[float, float]], stat_name: str) -> float:
+    baseline_values = [baseline for baseline, _feature in pairs]
+    feature_values = [feature for _baseline, feature in pairs]
+    return (
+        counter_target_metric_stat_value(feature_values, stat_name)
+        - counter_target_metric_stat_value(baseline_values, stat_name)
+    )
+
+
+def target_metric_run_stat_value(run: dict, stat_name: str) -> float:
+    value = run.get(stat_name)
+    if isinstance(value, dict):
+        return float(value["value"])
+    if value is not None:
+        return float(value)
+    if "value" in run:
+        return float(run["value"])
+    if "_values" in run:
+        return counter_target_metric_stat_value([float(v) for v in run["_values"]], stat_name)
+    raise ValueError(f"Unsupported target metric run statistic: {stat_name}")
+
+
+def _target_metric_cluster_ci(
+    rng: random.Random,
+    baseline_values: list[float],
+    feature_values: list[float],
+    n_iter: int = BOOTSTRAP_ITERATIONS,
+) -> float:
+    if len(baseline_values) < 2 or len(feature_values) < 2:
+        return 0.0
+
+    samples = []
+    baseline_count = len(baseline_values)
+    feature_count = len(feature_values)
+    for _ in range(n_iter):
+        baseline_sample = [
+            baseline_values[rng.randrange(baseline_count)]
+            for _ in range(baseline_count)
+        ]
+        feature_sample = [
+            feature_values[rng.randrange(feature_count)]
+            for _ in range(feature_count)
+        ]
+        samples.append(_mean(feature_sample) - _mean(baseline_sample))
+    return _ci_half_width(samples)
+
+
+def _target_metric_single_run_ci(
+    rng: random.Random,
+    baseline_run: dict,
+    feature_run: dict,
+    stat_name: str,
+    n_iter: int = BOOTSTRAP_ITERATIONS,
+) -> tuple[float, int]:
+    pairs = paired_target_metric_observations(baseline_run, feature_run)
+    if not pairs:
+        return 0.0, 0
+
+    boot_diffs = []
+    for _ in range(n_iter):
+        sample = rng.choices(pairs, k=len(pairs))
+        boot_diffs.append(target_metric_stat_diff(sample, stat_name))
+    return _ci_half_width(boot_diffs), len(pairs)
+
+
+def compute_target_metric_change(
+    baseline_runs: list[dict],
+    feature_runs: list[dict],
+    query: str,
+    target: str,
+    stat_name: str,
+    floor_pct: float,
+    min_value_pct_total_latency: float | None,
+    block_latency_ms: float,
+) -> dict:
+    if not baseline_runs or not feature_runs:
+        return {
+            "baseline": None,
+            "feature": None,
+            "diff": 0.0,
+            "pct": 0.0,
+            "ci": 0.0,
+            "ci_pct": 0.0,
+            "floor_pct": floor_pct,
+            "sig": "neutral",
+            "significance_reason": "requires baseline and feature runs",
+            "informational": True,
+            "informational_reason": "requires baseline and feature runs",
+        }
+
+    baseline_values = [
+        target_metric_run_stat_value(run, stat_name) for run in baseline_runs
+    ]
+    feature_values = [
+        target_metric_run_stat_value(run, stat_name) for run in feature_runs
+    ]
+    baseline_value = _mean(baseline_values)
+    feature_value = _mean(feature_values)
+    diff = feature_value - baseline_value
+
+    rng = random.Random(f"{query}:{stat_name}")
+    paired_observations = 0
+    significance_reason = None
+    if len(baseline_values) >= 2 and len(feature_values) >= 2:
+        ci = _target_metric_cluster_ci(rng, baseline_values, feature_values)
+        ci_method = "run_cluster_bootstrap"
+    else:
+        ci, paired_observations = _target_metric_single_run_ci(
+            rng, baseline_runs[0], feature_runs[0], stat_name
+        )
+        ci_method = "paired_scrape_bootstrap"
+        if paired_observations < TARGET_METRIC_MIN_PAIRED_OBSERVATIONS:
+            significance_reason = (
+                f"requires at least {TARGET_METRIC_MIN_PAIRED_OBSERVATIONS} paired observations"
+            )
+
+    pct = (diff / baseline_value * 100.0) if abs(baseline_value) > EPSILON else 0.0
+    ci_pct = (ci / abs(baseline_value) * 100.0) if abs(baseline_value) > EPSILON else 0.0
+    raw_sig = significance(
+        pct,
+        ci_pct,
+        floor_pct,
+        lower_is_better=target == "decrease",
+    )
+    sig = raw_sig
+    informational_reason = None
+    materiality_details = None
+    if min_value_pct_total_latency is not None and min_value_pct_total_latency > 0.0:
+        threshold_ms = block_latency_ms * min_value_pct_total_latency / 100.0
+        baseline_ms = abs(baseline_value) * 1_000.0
+        feature_ms = abs(feature_value) * 1_000.0
+        materiality_details = {
+            "min_value_pct_total_latency": round(min_value_pct_total_latency, 6),
+            "threshold_ms": round(threshold_ms, 6),
+            "baseline_ms": round(baseline_ms, 6),
+            "feature_ms": round(feature_ms, 6),
+            "block_latency_ms": round(block_latency_ms, 6),
+        }
+        if raw_sig != "neutral" and max(baseline_ms, feature_ms) < threshold_ms:
+            informational_reason = (
+                f"requires value >= {min_value_pct_total_latency:.3g}% total latency"
+            )
+            sig = "neutral"
+    if significance_reason:
+        sig = "neutral"
+    result = {
+        "baseline": baseline_value,
+        "feature": feature_value,
+        "diff": round(diff, 6),
+        "pct": round(pct, 4),
+        "ci": round(ci, 6),
+        "ci_pct": round(ci_pct, 4),
+        "floor_pct": round(floor_pct, 4),
+        "sig": sig,
+        "ci_method": ci_method,
+        "runs": {
+            "baseline": len(baseline_values),
+            "feature": len(feature_values),
+        },
+    }
+    if paired_observations:
+        result["paired_observations"] = paired_observations
+    if materiality_details:
+        result["materiality"] = materiality_details
+    if informational_reason:
+        result["informational"] = True
+        result["informational_reason"] = informational_reason
+        result["raw_sig"] = raw_sig
+    if significance_reason:
+        result["significance_reason"] = significance_reason
+        result["informational"] = True
+        result["informational_reason"] = significance_reason
+        result["raw_sig"] = raw_sig
+    return result
+
+
+def query_counter_target_metric_run(
+    relevant_scrapes: list[dict],
+    counter: dict,
+    run_label: str,
+    metadata: dict,
+    identity_label_keys: set[str],
+) -> dict[tuple[tuple[str, str], ...], dict]:
+    query = counter["query"]
+    aggregate, _metric_name, _label_filters = parse_target_metric_query(query)
+    grouped_scrapes = [
+        group_query_samples_by_identity(scrape["samples"], query, identity_label_keys)[1]
+        for scrape in relevant_scrapes
+    ]
+    identities = collect_metric_identities(grouped_scrapes)
+    if not identities:
+        raise ValueError(f"Target metric '{query}' in run '{run_label}' had no sampled values")
+
+    results = {}
+    for identity_key, identity_labels in sorted(identities.items()):
+        interval_observations = []
+        counter_increase = 0.0
+        block_height_delta = 0.0
+        display_query = format_target_metric_identity(query, identity_labels)
+        for previous_scrape, current_scrape, previous_groups, current_groups in zip(
+            relevant_scrapes,
+            relevant_scrapes[1:],
+            grouped_scrapes,
+            grouped_scrapes[1:],
+        ):
+            current_counter_value = grouped_sample_value(
+                current_groups.get(identity_key), aggregate, allow_missing=True
+            )
+            previous_counter_value = grouped_sample_value(
+                previous_groups.get(identity_key), aggregate, allow_missing=True
+            )
+            current_block_height = float(current_scrape["block_height"])
+            previous_block_height = float(previous_scrape["block_height"])
+            interval_block_height_delta = current_block_height - previous_block_height
+            if interval_block_height_delta <= EPSILON:
+                continue
+
+            interval_counter_delta = current_counter_value - previous_counter_value
+            if interval_counter_delta < -EPSILON:
+                raise ValueError(
+                    f"Target metric '{display_query}' decreased within run '{run_label}', which is not valid for counters"
+                )
+
+            counter_increase += interval_counter_delta
+            block_height_delta += interval_block_height_delta
+            interval_observations.append(
+                {
+                    "block_height": current_block_height,
+                    "value": interval_counter_delta / interval_block_height_delta,
+                }
+            )
+
+        if not interval_observations:
+            raise ValueError(
+                f"Target metric '{display_query}' in run '{run_label}' had no positive block-height scrape intervals"
+            )
+
+        stats = compute_target_metric_series_stats(
+            [observation["value"] for observation in interval_observations]
+        )
+        results[identity_key] = {
+            "query": query,
+            "display_query": display_query,
+            "identity_labels": identity_labels,
+            "target": counter["target"],
+            "counter_increase": counter_increase,
+            "block_height_delta": block_height_delta,
+            "mean": stats["mean"],
+            "p50": stats["p50"],
+            "p90": stats["p90"],
+            "p99": stats["p99"],
+            "intervals": len(interval_observations),
+            "scrapes": len(relevant_scrapes),
+            "duration_ms": int(metadata["duration_ms"]),
+            "range_start_ms": int(metadata["range_start_ms"]),
+            "range_end_ms": int(metadata["range_end_ms"]),
+            "benchmark_id": metadata["benchmark_id"],
+            "benchmark_run": metadata["benchmark_run"],
+            "_values": [observation["value"] for observation in interval_observations],
+            "_observations": interval_observations,
+        }
+    return results
+
+
+def query_histogram_target_metric_run(
+    relevant_scrapes: list[dict],
+    histogram: dict,
+    run_label: str,
+    metadata: dict,
+    identity_label_keys: set[str],
+) -> dict[tuple[tuple[str, str], ...], dict]:
+    sum_query = histogram_counter_query(histogram["query"], "sum")
+    sum_grouped_scrapes = [
+        group_query_samples_by_identity(scrape["samples"], sum_query, identity_label_keys)[1]
+        for scrape in relevant_scrapes
+    ]
+    mean_identities = collect_metric_identities(sum_grouped_scrapes)
+
+    metrics_by_identity = {}
+    for identity_key, identity_labels in sorted(mean_identities.items()):
+        per_block_observations = []
+        has_histogram_activity = False
+        pending_sum_delta = 0.0
+        total_sum_delta = 0.0
+        total_block_delta = 0.0
+        display_query = format_target_metric_identity(histogram["query"], identity_labels)
+        for previous_scrape, current_scrape, previous_sum_groups, current_sum_groups in zip(
+            relevant_scrapes,
+            relevant_scrapes[1:],
+            sum_grouped_scrapes,
+            sum_grouped_scrapes[1:],
+        ):
+            current_sum = grouped_sample_value(current_sum_groups.get(identity_key), "single", allow_missing=True)
+            previous_sum = grouped_sample_value(previous_sum_groups.get(identity_key), "single", allow_missing=True)
+            current_block_height = float(current_scrape["block_height"])
+            previous_block_height = float(previous_scrape["block_height"])
+            block_delta = current_block_height - previous_block_height
+            sum_delta = current_sum - previous_sum
+            if sum_delta < -EPSILON:
+                raise ValueError(
+                    f"Histogram target metric '{display_query}' sum decreased within run '{run_label}'"
+                )
+            if sum_delta > EPSILON:
+                has_histogram_activity = True
+                pending_sum_delta += sum_delta
+                total_sum_delta += sum_delta
+
+            if block_delta <= EPSILON:
+                continue
+
+            total_block_delta += block_delta
+            per_block_observations.append(
+                {
+                    "block_height": current_block_height,
+                    "sum_delta": pending_sum_delta,
+                    "block_delta": block_delta,
+                    "value": pending_sum_delta / block_delta,
+                }
+            )
+            pending_sum_delta = 0.0
+
+        if pending_sum_delta > EPSILON and per_block_observations:
+            last_observation = per_block_observations[-1]
+            last_observation["sum_delta"] += pending_sum_delta
+            last_observation["value"] = (
+                last_observation["sum_delta"] / last_observation["block_delta"]
+            )
+
+        if not has_histogram_activity or not per_block_observations or total_block_delta <= EPSILON:
+            continue
+
+        stats = compute_target_metric_series_stats(
+            [observation["value"] for observation in per_block_observations]
+        )
+        stats["mean"] = total_sum_delta / total_block_delta
+        metrics_by_identity[identity_key] = {
+            "query": histogram["query"],
+            "display_query": display_query,
+            "identity_labels": identity_labels,
+            "target": histogram["target"],
+            "mean": {
+                "query": f"delta({sum_query}) / delta({TARGET_METRIC_BLOCK_HEIGHT_QUERY})",
+                "value": stats["mean"],
+                "samples": len(per_block_observations),
+                "scrapes": len(relevant_scrapes),
+                "duration_ms": int(metadata["duration_ms"]),
+                "range_start_ms": int(metadata["range_start_ms"]),
+                "range_end_ms": int(metadata["range_end_ms"]),
+                "benchmark_id": metadata["benchmark_id"],
+                "benchmark_run": metadata["benchmark_run"],
+                "_values": [observation["value"] for observation in per_block_observations],
+                "_observations": per_block_observations,
+            },
+        }
+
+    return metrics_by_identity
+
+
+def load_target_metric_run_context(path: str) -> dict:
+    run_label = run_label_from_path(path)
+    metadata = load_target_metric_range(path)
+    scrapes = load_target_metric_scrapes(path)
+    range_start_ms = int(metadata["range_start_ms"])
+    range_end_ms = int(metadata["range_end_ms"])
+    relevant_scrapes = [
+        scrape
+        for scrape in scrapes
+        if range_start_ms <= int(scrape["unix_ms"]) <= range_end_ms
+    ]
+    if len(relevant_scrapes) < 2:
+        raise ValueError(
+            f"Target metric scrapes for run '{run_label}' only had {len(relevant_scrapes)} samples inside the benchmark window"
+        )
+    for scrape in relevant_scrapes:
+        scrape["block_height"] = evaluate_query(scrape["samples"], TARGET_METRIC_BLOCK_HEIGHT_QUERY)
+    return {
+        "run_label": run_label,
+        "metadata": metadata,
+        "relevant_scrapes": relevant_scrapes,
+    }
+
+
+def collect_target_metric_identity_label_keys(
+    run_contexts: list[dict],
+    config: dict,
+) -> dict[str, set[str]]:
+    identity_label_keys_by_query = {}
+
+    for counter in config.get("counters", []):
+        query = counter["query"]
+        identity_label_keys_by_query[query] = set().union(
+            *(
+                target_metric_variable_identity_label_keys(
+                    context["relevant_scrapes"],
+                    query,
+                )
+                for context in run_contexts
+            )
+        )
+
+    for histogram in config.get("histograms", []):
+        query = histogram_counter_query(histogram["query"], "sum")
+        identity_label_keys_by_query[query] = set().union(
+            *(
+                target_metric_variable_identity_label_keys(
+                    context["relevant_scrapes"],
+                    query,
+                )
+                for context in run_contexts
+            )
+        )
+
+    return identity_label_keys_by_query
+
+
+def query_target_metric_run(
+    run_context: dict,
+    config: dict,
+    identity_label_keys_by_query: dict[str, set[str]],
+) -> tuple[str, dict[str, dict[str, dict]]]:
+    run_label = run_context["run_label"]
+    metadata = run_context["metadata"]
+    relevant_scrapes = run_context["relevant_scrapes"]
+
+    counters = {}
+    for counter in config.get("counters", []):
+        query = counter["query"]
+        counters[counter["query"]] = query_counter_target_metric_run(
+            relevant_scrapes,
+            counter,
+            run_label,
+            metadata,
+            identity_label_keys_by_query[query],
+        )
+
+    histograms = {}
+    for histogram in config.get("histograms", []):
+        query = histogram_counter_query(histogram["query"], "sum")
+        histograms[histogram["query"]] = query_histogram_target_metric_run(
+            relevant_scrapes,
+            histogram,
+            run_label,
+            metadata,
+            identity_label_keys_by_query[query],
+        )
+
+    return run_label, {"counters": counters, "histograms": histograms}
+
+
+def run_label_from_path(path: str) -> str:
+    return Path(path).parent.name or Path(path).stem
+
+
+def summarize_target_metric_runs(run_items: list[dict], fields: tuple[str, ...]) -> dict:
+    summary = {field: sum(item[field] for item in run_items) / len(run_items) for field in fields}
+    summary["runs"] = run_items
+    return summary
+
+
+def summarize_target_metric_change(changes: dict[str, dict], display_stats: tuple[str, ...]) -> dict:
+    significant = [name for name in display_stats if changes[name]["sig"] != "neutral"]
+    if not significant:
+        sig = "neutral"
+    elif any(changes[name]["sig"] == "bad" for name in significant):
+        sig = "bad"
+    else:
+        sig = "good"
+    return {
+        "sig": sig,
+        "significant_stats": significant,
+    }
+
+
+def collect_query_metric_identities(
+    runs: list[tuple[str, dict[str, dict[str, dict]]]], kind: str, query: str
+) -> dict[tuple[tuple[str, str], ...], dict[str, str]]:
+    identities = {}
+    for run_label, run_data in runs:
+        if query not in run_data[kind]:
+            raise ValueError(f"Missing target metric '{query}' in run '{run_label}'")
+        for identity_key, metric in run_data[kind][query].items():
+            identities.setdefault(identity_key, metric["identity_labels"])
+    return identities
+
+
+def target_metric_pair_rows(
+    baseline_values: list[dict],
+    feature_values: list[dict],
+    pair_stats: tuple[str, ...],
+    include_mean_values: bool,
+) -> list[dict] | None:
+    if len(baseline_values) <= 1 or len(feature_values) <= 1:
+        return None
+
+    rows = []
+    for baseline_item, feature_item in zip(baseline_values, feature_values):
+        row = {
+            "baseline_run": baseline_item["run"],
+            "feature_run": feature_item["run"],
+        }
+        if include_mean_values:
+            row["baseline_mean"] = baseline_item["mean"]
+            row["feature_mean"] = feature_item["mean"]
+        row.update(
+            {
+                f"{stat_name}_diff": feature_item[stat_name] - baseline_item[stat_name]
+                for stat_name in pair_stats
+            }
+        )
+        rows.append(row)
+    return rows
+
+
+def build_target_metric_entry(
+    kind: str,
+    configured_query: str,
+    display_query: str,
+    identity_labels: dict[str, str],
+    target: str,
+    display_stats: tuple[str, ...],
+    summary_fields: tuple[str, ...],
+    baseline_values: list[dict],
+    feature_values: list[dict],
+    baseline_runs_by_stat: dict[str, list[dict]],
+    feature_runs_by_stat: dict[str, list[dict]],
+    pair_stats: tuple[str, ...],
+    floor_pct: float,
+    min_value_pct_total_latency: float | None,
+    block_latency_ms: float,
+    include_pair_mean_values: bool = False,
+    unit: str | None = None,
+) -> dict:
+    changes = {
+        stat_name: compute_target_metric_change(
+            baseline_runs_by_stat[stat_name],
+            feature_runs_by_stat[stat_name],
+            display_query,
+            target,
+            stat_name,
+            floor_pct,
+            min_value_pct_total_latency,
+            block_latency_ms,
+        )
+        for stat_name in display_stats
+    }
+    metric_unit = unit or (
+        "seconds" if target_metric_query_encodes_seconds(configured_query) else None
+    )
+    entry = {
+        "kind": kind,
+        "name": display_query,
+        "query": display_query,
+        "configured_query": configured_query,
+        "identity_labels": identity_labels,
+        "target": target,
+        "floor_pct": floor_pct,
+        "display_stats": list(display_stats),
+        "baseline": summarize_target_metric_runs(baseline_values, summary_fields),
+        "feature": summarize_target_metric_runs(feature_values, summary_fields),
+        "changes": changes,
+        "change": summarize_target_metric_change(changes, display_stats),
+    }
+    if metric_unit:
+        entry["unit"] = metric_unit
+    if min_value_pct_total_latency is not None:
+        entry["materiality"] = {
+            "min_value_pct_total_latency": min_value_pct_total_latency,
+        }
+
+    pairs = target_metric_pair_rows(
+        baseline_values, feature_values, pair_stats, include_pair_mean_values
+    )
+    if pairs:
+        entry["pairs"] = pairs
+    return entry
+
+
+def compute_target_metric_summary(
+    config_path: str,
+    baseline_csv_paths: list[str],
+    feature_csv_paths: list[str],
+    baseline_stats: dict,
+    feature_stats: dict,
+) -> dict:
+    with open(config_path) as f:
+        config = json.load(f)
+
+    baseline_run_contexts = [
+        load_target_metric_run_context(path) for path in baseline_csv_paths
+    ]
+    feature_run_contexts = [
+        load_target_metric_run_context(path) for path in feature_csv_paths
+    ]
+    identity_label_keys_by_query = collect_target_metric_identity_label_keys(
+        baseline_run_contexts + feature_run_contexts,
+        config,
+    )
+    baseline_runs = [
+        query_target_metric_run(context, config, identity_label_keys_by_query)
+        for context in baseline_run_contexts
+    ]
+    feature_runs = [
+        query_target_metric_run(context, config, identity_label_keys_by_query)
+        for context in feature_run_contexts
+    ]
+    block_latency_ms = max(
+        float(baseline_stats["mean_total_lat_ms"]),
+        float(feature_stats["mean_total_lat_ms"]),
+    )
+
+    metrics = []
+    for counter in config.get("counters", []):
+        query = counter["query"]
+        target = counter["target"]
+        floor_pct = float(counter.get("floor_pct", 0.0))
+        counter_min_value_pct_total_latency = target_metric_min_value_pct_total_latency(counter)
+        counter_encodes_seconds = target_metric_counter_encodes_seconds(query)
+        if (
+            counter_min_value_pct_total_latency is not None and
+            counter_min_value_pct_total_latency > 0.0 and
+            not counter_encodes_seconds
+        ):
+            raise ValueError(
+                f"Counter target metric '{query}' sets min_value_pct_total_latency "
+                "but does not encode seconds"
+            )
+        if not counter_encodes_seconds:
+            counter_min_value_pct_total_latency = None
+        display_stats = TARGET_METRIC_COUNTER_STATS
+        summary_fields = ("mean", "p50", "p90", "p99")
+        identities = collect_query_metric_identities(
+            baseline_runs + feature_runs, "counters", query
+        )
+
+        for identity_key, identity_labels in sorted(identities.items()):
+            baseline_values = []
+            feature_values = []
+            baseline_runs_for_stats = []
+            feature_runs_for_stats = []
+            display_query = format_target_metric_identity(query, identity_labels)
+
+            for run_label, run_data in baseline_runs:
+                if identity_key not in run_data["counters"][query]:
+                    raise ValueError(
+                        f"Missing target metric '{display_query}' in baseline run '{run_label}'"
+                    )
+                run_metric = run_data["counters"][query][identity_key]
+                baseline_runs_for_stats.append(run_metric)
+                baseline_values.append(
+                    {
+                        "run": run_label,
+                        "mean": float(run_metric["mean"]),
+                        "p50": float(run_metric["p50"]),
+                        "p90": float(run_metric["p90"]),
+                        "p99": float(run_metric["p99"]),
+                        "counter_increase": float(run_metric["counter_increase"]),
+                        "block_height_delta": float(run_metric["block_height_delta"]),
+                        "intervals": int(run_metric["intervals"]),
+                        "scrapes": int(run_metric["scrapes"]),
+                        "duration_ms": int(run_metric["duration_ms"]),
+                    }
+                )
+            for run_label, run_data in feature_runs:
+                if identity_key not in run_data["counters"][query]:
+                    raise ValueError(
+                        f"Missing target metric '{display_query}' in feature run '{run_label}'"
+                    )
+                run_metric = run_data["counters"][query][identity_key]
+                feature_runs_for_stats.append(run_metric)
+                feature_values.append(
+                    {
+                        "run": run_label,
+                        "mean": float(run_metric["mean"]),
+                        "p50": float(run_metric["p50"]),
+                        "p90": float(run_metric["p90"]),
+                        "p99": float(run_metric["p99"]),
+                        "counter_increase": float(run_metric["counter_increase"]),
+                        "block_height_delta": float(run_metric["block_height_delta"]),
+                        "intervals": int(run_metric["intervals"]),
+                        "scrapes": int(run_metric["scrapes"]),
+                        "duration_ms": int(run_metric["duration_ms"]),
+                    }
+                )
+
+            metrics.append(
+                build_target_metric_entry(
+                    kind="counter",
+                    configured_query=query,
+                    display_query=display_query,
+                    identity_labels=identity_labels,
+                    target=target,
+                    display_stats=display_stats,
+                    summary_fields=summary_fields,
+                    baseline_values=baseline_values,
+                    feature_values=feature_values,
+                    baseline_runs_by_stat={
+                        stat_name: baseline_runs_for_stats for stat_name in display_stats
+                    },
+                    feature_runs_by_stat={
+                        stat_name: feature_runs_for_stats for stat_name in display_stats
+                    },
+                    pair_stats=summary_fields,
+                    floor_pct=floor_pct,
+                    min_value_pct_total_latency=counter_min_value_pct_total_latency,
+                    block_latency_ms=block_latency_ms,
+                    include_pair_mean_values=True,
+                    unit=counter.get("unit"),
+                )
+            )
+
+    for histogram in config.get("histograms", []):
+        query = histogram["query"]
+        target = histogram["target"]
+        floor_pct = float(histogram.get("floor_pct", 0.0))
+        histogram_min_value_pct_total_latency = target_metric_min_value_pct_total_latency(
+            histogram
+        )
+        display_stats = ("mean",)
+        identities = collect_query_metric_identities(
+            baseline_runs + feature_runs, "histograms", query
+        )
+
+        for identity_key, identity_labels in sorted(identities.items()):
+            baseline_values = []
+            feature_values = []
+            display_query = format_target_metric_identity(query, identity_labels)
+            baseline_run_metrics = []
+            feature_run_metrics = []
+            if not all(
+                identity_key in run_data["histograms"][query]
+                for _run_label, run_data in baseline_runs + feature_runs
+            ):
+                continue
+
+            for run_label, run_data in baseline_runs:
+                run_metric = run_data["histograms"][query][identity_key]
+                baseline_run_metrics.append((run_label, run_metric))
+
+            for run_label, run_data in feature_runs:
+                run_metric = run_data["histograms"][query][identity_key]
+                feature_run_metrics.append((run_label, run_metric))
+
+            baseline_runs_for_stats = {stat_name: [] for stat_name in display_stats}
+            feature_runs_for_stats = {stat_name: [] for stat_name in display_stats}
+
+            for run_label, run_metric in baseline_run_metrics:
+                run_values = {"run": run_label}
+                for stat_name in display_stats:
+                    run_stat = run_metric[stat_name]
+                    baseline_runs_for_stats[stat_name].append(run_stat)
+                    run_values[stat_name] = float(run_stat["value"])
+                baseline_values.append(run_values)
+
+            for run_label, run_metric in feature_run_metrics:
+                run_values = {"run": run_label}
+                for stat_name in display_stats:
+                    run_stat = run_metric[stat_name]
+                    feature_runs_for_stats[stat_name].append(run_stat)
+                    run_values[stat_name] = float(run_stat["value"])
+                feature_values.append(run_values)
+
+            metrics.append(
+                build_target_metric_entry(
+                    kind="histogram",
+                    configured_query=query,
+                    display_query=display_query,
+                    identity_labels=identity_labels,
+                    target=target,
+                    display_stats=display_stats,
+                    summary_fields=display_stats,
+                    baseline_values=baseline_values,
+                    feature_values=feature_values,
+                    baseline_runs_by_stat=baseline_runs_for_stats,
+                    feature_runs_by_stat=feature_runs_for_stats,
+                    pair_stats=display_stats,
+                    floor_pct=floor_pct,
+                    min_value_pct_total_latency=histogram_min_value_pct_total_latency,
+                    block_latency_ms=block_latency_ms,
+                    unit=histogram.get("unit"),
+                )
+            )
+
+    changed = [metric for metric in metrics if metric["change"]["significant_stats"]]
+    return {
+        "config": config_path,
+        "block_latency_ms": round(block_latency_ms, 6),
+        "metrics": metrics,
+        "changed": changed,
+        "improvements": [metric["name"] for metric in changed if metric["change"]["sig"] == "good"],
+        "regressions": [metric["name"] for metric in changed if metric["change"]["sig"] == "bad"],
+    }
+
+
 def generate_comparison_table(
     run1: dict,
     run2: dict,
-    paired: dict,
+    ci_stats: dict,
     repo: str,
     baseline_ref: str,
     baseline_name: str,
@@ -385,17 +1660,18 @@ def generate_comparison_table(
     warmup_blocks: str | None = None,
     wait_time: str | None = None,
     bal_mode: str | None = None,
+    run_pairs: int | None = None,
 ) -> str:
     """Generate a markdown comparison table between baseline and feature."""
-    n = paired["blocks"]
+    n = ci_stats["blocks"]
 
     def pct(base: float, feat: float) -> float:
         return (feat - base) / base * 100.0 if base > 0 else 0.0
 
-    mean_pct = pct(run1["mean_ms"], run2["mean_ms"])
     gas_pct = pct(run1["mean_mgas_s"], run2["mean_mgas_s"])
     wall_pct = pct(run1["wall_clock_s"], run2["wall_clock_s"])
 
+    mean_pct = pct(run1["mean_ms"], run2["mean_ms"])
     p50_pct = pct(run1["p50_ms"], run2["p50_ms"])
     p90_pct = pct(run1["p90_ms"], run2["p90_ms"])
     p99_pct = pct(run1["p99_ms"], run2["p99_ms"])
@@ -403,15 +1679,25 @@ def pct(base: float, feat: float) -> float:
     persist_pct = pct(run1["mean_persist_ms"], run2["mean_persist_ms"])
 
     # Bootstrap CIs as % of baseline percentile
-    p50_ci_pct = paired["p50_ci_ms"] / run1["p50_ms"] * 100.0 if run1["p50_ms"] > 0 else 0.0
-    p90_ci_pct = paired["p90_ci_ms"] / run1["p90_ms"] * 100.0 if run1["p90_ms"] > 0 else 0.0
-    p99_ci_pct = paired["p99_ci_ms"] / run1["p99_ms"] * 100.0 if run1["p99_ms"] > 0 else 0.0
-
-    # CI as a percentage of baseline mean
-    lat_ci_pct = paired["ci_ms"] / run1["mean_ms"] * 100.0 if run1["mean_ms"] > 0 else 0.0
-    mgas_ci_pct = paired["mgas_ci"] / run1["mean_mgas_s"] * 100.0 if run1["mean_mgas_s"] > 0 else 0.0
-    wall_ci_pct = paired["wall_clock_ci_ms"] / run1["mean_total_lat_ms"] * 100.0 if run1["mean_total_lat_ms"] > 0 else 0.0
-    persist_ci_pct = paired["persist_ci_ms"] / run1["mean_persist_ms"] * 100.0 if run1["mean_persist_ms"] > 0 else 0.0
+    mean_ci_pct = ci_stats["ci_ms"] / run1["mean_ms"] * 100.0 if run1["mean_ms"] > 0 else 0.0
+    p50_ci_pct = ci_stats["p50_ci_ms"] / run1["p50_ms"] * 100.0 if run1["p50_ms"] > 0 else 0.0
+    p90_ci_pct = ci_stats["p90_ci_ms"] / run1["p90_ms"] * 100.0 if run1["p90_ms"] > 0 else 0.0
+    p99_ci_pct = ci_stats["p99_ci_ms"] / run1["p99_ms"] * 100.0 if run1["p99_ms"] > 0 else 0.0
+
+    # CI as a percentage of baseline
+    mgas_ci_pct = ci_stats["mgas_ci"] / run1["mean_mgas_s"] * 100.0 if run1["mean_mgas_s"] > 0 else 0.0
+    wall_ci_pct = ci_stats["wall_clock_ci_ms"] / run1["mean_total_lat_ms"] * 100.0 if run1["mean_total_lat_ms"] > 0 else 0.0
+    persist_ci_pct = ci_stats["persist_ci_ms"] / run1["mean_persist_ms"] * 100.0 if run1["mean_persist_ms"] > 0 else 0.0
+
+    mean_floor = practical_floor_pct("mean", run1["mean_ms"])
+    p50_floor = practical_floor_pct("p50", run1["p50_ms"])
+    p90_floor = practical_floor_pct("p90", run1["p90_ms"])
+    p99_floor = practical_floor_pct("p99", run1["p99_ms"])
+    mgas_floor = practical_floor_pct("mgas_s", run1["mean_mgas_s"])
+    wall_floor = practical_floor_pct("wall_clock", run1["mean_total_lat_ms"])
+    persist_floor = practical_floor_pct("persist_wait", run1["mean_persist_ms"])
+    p99_informational = informational_reason("p99", ci_stats, run1, run2)
+    persist_informational = informational_reason("persist_wait", ci_stats, run1, run2)
 
     base_url = f"https://github.com/{repo}/commit"
     baseline_label = f"[`{baseline_name}`]({base_url}/{baseline_ref})"
@@ -420,19 +1706,20 @@ def pct(base: float, feat: float) -> float:
     lines = [
         f"| Metric | {baseline_label} | {feature_label} | Change |",
         "|--------|------|--------|--------|",
-        f"| Mean | {fmt_ms(run1['mean_ms'])} | {fmt_ms(run2['mean_ms'])} | {change_str(mean_pct, lat_ci_pct, lower_is_better=True)} |",
-        f"| StdDev | {fmt_ms(run1['stddev_ms'])} | {fmt_ms(run2['stddev_ms'])} | |",
-        f"| P50 | {fmt_ms(run1['p50_ms'])} | {fmt_ms(run2['p50_ms'])} | {change_str(p50_pct, p50_ci_pct, lower_is_better=True)} |",
-        f"| P90 | {fmt_ms(run1['p90_ms'])} | {fmt_ms(run2['p90_ms'])} | {change_str(p90_pct, p90_ci_pct, lower_is_better=True)} |",
-        f"| P99 | {fmt_ms(run1['p99_ms'])} | {fmt_ms(run2['p99_ms'])} | {change_str(p99_pct, p99_ci_pct, lower_is_better=True)} |",
-        f"| Mgas/s | {fmt_mgas(run1['mean_mgas_s'])} | {fmt_mgas(run2['mean_mgas_s'])} | {change_str(gas_pct, mgas_ci_pct, lower_is_better=False)} |",
-        f"| Wall Clock | {fmt_s(run1['wall_clock_s'])} | {fmt_s(run2['wall_clock_s'])} | {change_str(wall_pct, wall_ci_pct, lower_is_better=True)} |",
-        f"| Persist Wait | {fmt_ms(run1['mean_persist_ms'])} | {fmt_ms(run2['mean_persist_ms'])} | {change_str(persist_pct, persist_ci_pct, lower_is_better=True)} |",
+        f"| Mean | {fmt_ms(run1['mean_ms'])} | {fmt_ms(run2['mean_ms'])} | {change_str(mean_pct, mean_ci_pct, mean_floor, lower_is_better=True)} |",
+        f"| P50 | {fmt_ms(run1['p50_ms'])} | {fmt_ms(run2['p50_ms'])} | {change_str(p50_pct, p50_ci_pct, p50_floor, lower_is_better=True)} |",
+        f"| P90 | {fmt_ms(run1['p90_ms'])} | {fmt_ms(run2['p90_ms'])} | {change_str(p90_pct, p90_ci_pct, p90_floor, lower_is_better=True)} |",
+        f"| P99 | {fmt_ms(run1['p99_ms'])} | {fmt_ms(run2['p99_ms'])} | {change_str(p99_pct, p99_ci_pct, p99_floor, lower_is_better=True, informational=p99_informational)} |",
+        f"| Mgas/s | {fmt_mgas(run1['mean_mgas_s'])} | {fmt_mgas(run2['mean_mgas_s'])} | {change_str(gas_pct, mgas_ci_pct, mgas_floor, lower_is_better=False)} |",
+        f"| Wall Clock | {fmt_s(run1['wall_clock_s'])} | {fmt_s(run2['wall_clock_s'])} | {change_str(wall_pct, wall_ci_pct, wall_floor, lower_is_better=True)} |",
+        f"| Persist Wait | {fmt_ms(run1['mean_persist_ms'])} | {fmt_ms(run2['mean_persist_ms'])} | {change_str(persist_pct, persist_ci_pct, persist_floor, lower_is_better=True, informational=persist_informational)} |",
         "",
     ]
     meta_parts = [f"{n} {'big blocks' if big_blocks else 'blocks'}"]
     if warmup_blocks:
         meta_parts.append(f"{warmup_blocks} warmup")
+    if run_pairs:
+        meta_parts.append(f"{run_pairs} run pairs")
     if wait_time:
         meta_parts.append(f"wait time: {wait_time}")
     display_mode = display_bal_mode(bal_mode)
@@ -464,14 +1751,175 @@ def generate_wait_time_table(
     return "\n".join(lines)
 
 
+def generate_target_metric_table(target_metrics: dict | None) -> str:
+    if not target_metrics:
+        return ""
+
+    changed = target_metrics.get("changed", [])
+    if not changed:
+        return ""
+
+    lines = [
+        "### Target Metrics",
+        "",
+        "| Metric | Baseline | Feature | Change |",
+        "|--------|----------|---------|--------|",
+    ]
+    row_count = 0
+    for metric in changed:
+        for stat_name in metric.get("display_stats", []):
+            change = metric["changes"][stat_name]
+            if change["sig"] == "neutral":
+                continue
+            row_count += 1
+            lines.append(
+                "| `{}` | {} | {} | {} |".format(
+                    f"{metric['name']} {stat_name}",
+                    fmt_target_metric_value(metric, change["baseline"]),
+                    fmt_target_metric_value(metric, change["feature"]),
+                    target_metric_change_str(change),
+                )
+            )
+
+    if row_count == 0:
+        return ""
+
+    return "\n".join(lines)
+
+
+def target_metric_change_str(change: dict) -> str:
+    sig = "neutral" if change.get("informational") else change.get("sig", "neutral")
+    emoji = {"good": "✅", "bad": "❌", "neutral": "⚪"}[sig]
+    details = [f"±{change['ci_pct']:.2f}%", f"floor {change['floor_pct']:.2f}%"]
+    if materiality := change.get("materiality"):
+        details.append(f"materiality {materiality['threshold_ms']:.2f}ms")
+    if change.get("informational"):
+        details.append("informational")
+    return (
+        f"{change['pct']:+.2f}% {emoji} "
+        f"({', '.join(details)})"
+    )
+
+
+def iso_from_epoch_ms(epoch_ms: int) -> str:
+    dt = datetime.fromtimestamp(epoch_ms / 1000, tz=timezone.utc)
+    return dt.isoformat(timespec="milliseconds").replace("+00:00", "Z")
+
+
+def grafana_explore_url(panes: dict) -> str:
+    encoded = quote(json.dumps(panes, separators=(",", ":")), safe="")
+    return f"{GRAFANA_EXPLORE_URL}?schemaVersion=1&panes={encoded}&orgId=1"
+
+
+def build_grafana_logs_url(benchmark_id: str, from_ms: int, to_ms: int) -> str:
+    return grafana_explore_url({
+        "pw4": {
+            "datasource": LOGS_DATASOURCE_UID,
+            "queries": [{
+                "refId": "A",
+                "datasource": {
+                    "type": "victoriametrics-logs-datasource",
+                    "uid": LOGS_DATASOURCE_UID,
+                },
+                "editorMode": "code",
+                "expr": f"benchmark_id:{benchmark_id}",
+                "queryType": "instant",
+            }],
+            "range": {
+                "from": iso_from_epoch_ms(from_ms),
+                "to": iso_from_epoch_ms(to_ms),
+            },
+            "panelsState": {
+                "logs": {
+                    "sortOrder": "Descending",
+                    "columns": ["Time", "Line"],
+                    "visualisationType": "table",
+                    "labelFieldName": "labels",
+                },
+            },
+            "compact": False,
+        },
+    })
+
+
+def build_grafana_traces_url(benchmark_id: str, from_ms: int, to_ms: int) -> str:
+    return grafana_explore_url({
+        "g39": {
+            "datasource": TRACES_DATASOURCE_UID,
+            "queries": [{
+                "refId": "A",
+                "datasource": {"type": "tempo", "uid": TRACES_DATASOURCE_UID},
+                "queryType": "traceqlSearch",
+                "serviceMapUseNativeHistograms": False,
+                "filters": [{
+                    "id": "benchmark-id",
+                    "operator": "=",
+                    "scope": "resource",
+                    "tag": "benchmark_id",
+                    "value": [benchmark_id],
+                    "valueType": "string",
+                    "isCustomValue": True,
+                }],
+                "query": "{resource.benchmark_id=" + json.dumps(benchmark_id) + "}",
+            }],
+            "range": {
+                "from": iso_from_epoch_ms(from_ms),
+                "to": iso_from_epoch_ms(to_ms),
+            },
+            "panelsState": {"logs": {"visualisationType": "table"}},
+            "compact": False,
+        },
+    })
+
+
+def resolve_observability_range(
+    from_ms: int | None = None,
+    to_ms: int | None = None,
+) -> tuple[int | None, int | None]:
+    if from_ms is None:
+        reference_epoch = os.environ.get("BENCH_REFERENCE_EPOCH")
+        if reference_epoch:
+            try:
+                from_ms = int(float(reference_epoch) * 1000)
+            except ValueError:
+                from_ms = None
+
+    if to_ms is None and from_ms is not None:
+        to_ms = int(time.time() * 1000)
+
+    return from_ms, to_ms
+
+
+def generate_observability_section(summary: dict) -> list[str]:
+    observability = summary.get("observability") or {}
+    links = [
+        ("Grafana Dashboard", observability.get("grafana_url")),
+        ("Logs", observability.get("logs_url")),
+        ("Traces", observability.get("traces_url")),
+    ]
+    links = [(label, url) for label, url in links if url]
+
+    if not links:
+        return []
+
+    lines = ["", "### Observability", ""]
+    for label, url in links:
+        lines.append(f"- [{label}]({url})")
+    return lines
+
+
 def generate_markdown(
     summary: dict, comparison_table: str,
     wait_time_tables: list[str] | None = None,
+    target_metric_table: str = "",
     behind_baseline: int = 0, repo: str = "", baseline_ref: str = "", baseline_name: str = "",
-    grafana_url: str | None = None,
+    derek_command: str | None = None,
 ) -> str:
     """Generate a markdown comment body."""
-    lines = ["## Benchmark Results", ""]
+    lines = ["## Benchmark Results", "", "## Configuration"]
+    if derek_command:
+        lines.append(f"- Derek command: `{derek_command}`")
+    lines.append("")
     if behind_baseline > 0:
         s = "s" if behind_baseline > 1 else ""
         diff_link = f"https://github.com/{repo}/compare/{baseline_ref[:12]}...{baseline_name}"
@@ -488,23 +1936,24 @@ def generate_markdown(
                 lines.append(table)
                 lines.append("")
         lines.append("</details>")
-    if grafana_url:
+    if target_metric_table:
         lines.append("")
-        lines.append(f"**[Grafana Dashboard]({grafana_url})**")
+        lines.append(target_metric_table)
+    lines.extend(generate_observability_section(summary))
     return "\n".join(lines)
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Parse reth-bench ABBA results")
+    parser = argparse.ArgumentParser(description="Parse benchmark run-pair results")
     parser.add_argument(
         "--baseline-csv", nargs="+", required=True,
-        help="Baseline combined_latency.csv files (A1, A2)",
+        help="Baseline combined_latency.csv files",
     )
     parser.add_argument(
         "--feature-csv", "--branch-csv", nargs="+", required=True,
-        help="Feature combined_latency.csv files (B1, B2)",
+        help="Feature combined_latency.csv files",
     )
-    parser.add_argument("--gas-csv", required=True, help="Path to total_gas.csv")
+    parser.add_argument("--gas-csv", default=None, help=argparse.SUPPRESS)
     parser.add_argument(
         "--output-summary", required=True, help="Output JSON summary path"
     )
@@ -521,11 +1970,23 @@ def main():
     parser.add_argument("--warmup-blocks", default=None, help="Number of warmup blocks")
     parser.add_argument("--wait-time", default=None, help="Wait time interval used between blocks")
     parser.add_argument("--bal-mode", default=None, help="BAL mode (true, feature, baseline)")
+    parser.add_argument("--benchmark-id", default=os.environ.get("BENCH_ID"), help="Benchmark ID used for OTLP labels")
     parser.add_argument("--grafana-url", default=None, help="Grafana dashboard URL for this benchmark run")
+    parser.add_argument("--logs-url", default=None, help="Grafana Explore URL for benchmark logs")
+    parser.add_argument("--traces-url", default=None, help="Grafana Explore URL for benchmark traces")
+    parser.add_argument("--observability-from-ms", type=int, default=None, help="Grafana observability range start in epoch milliseconds")
+    parser.add_argument("--observability-to-ms", type=int, default=None, help="Grafana observability range end in epoch milliseconds")
+    parser.add_argument("--target-metrics-config", default=None, help="Target metrics config path")
+    parser.add_argument(
+        "--derek-command",
+        default=os.environ.get("DEREK_BENCH_COMMAND"),
+        help="Full derek bench command",
+    )
+    parser.add_argument("--run-pairs", type=int, default=None, help="Configured number of benchmark run pairs")
     args = parser.parse_args()
 
-    if len(args.baseline_csv) != len(args.feature_csv):
-        print("Must provide equal number of baseline and feature CSVs", file=sys.stderr)
+    if args.run_pairs is not None and args.run_pairs < 1:
+        print("--run-pairs must be greater than zero", file=sys.stderr)
         sys.exit(1)
 
     baseline_runs = []
@@ -543,17 +2004,15 @@ def main():
             sys.exit(1)
         feature_runs.append(data)
 
-    gas = parse_gas_csv(args.gas_csv)
-
     all_baseline = [r for run in baseline_runs for r in run]
     all_feature = [r for run in feature_runs for r in run]
 
-    baseline_stats = compute_stats(all_baseline)
-    feature_stats = compute_stats(all_feature)
-    paired_stats = compute_paired_stats(baseline_runs, feature_runs)
+    baseline_stats = compute_point_stats(baseline_runs)
+    feature_stats = compute_point_stats(feature_runs)
+    ci_stats = compute_ci_stats(baseline_runs, feature_runs)
 
-    if not paired_stats:
-        print("No common blocks between baseline and feature runs", file=sys.stderr)
+    if not ci_stats:
+        print("No comparable baseline and feature results", file=sys.stderr)
         sys.exit(1)
 
     baseline_ref = args.baseline_ref or "main"
@@ -565,7 +2024,7 @@ def main():
     comparison_table = generate_comparison_table(
         baseline_stats,
         feature_stats,
-        paired_stats,
+        ci_stats,
         repo=args.repo,
         baseline_ref=baseline_ref,
         baseline_name=baseline_name,
@@ -575,9 +2034,12 @@ def main():
         warmup_blocks=args.warmup_blocks,
         wait_time=args.wait_time,
         bal_mode=bal_mode,
+        run_pairs=args.run_pairs,
+    )
+    print(
+        f"Generated comparison ({ci_stats['blocks']} blocks, "
+        f"mean CI ± {ci_stats['ci_ms']:.3f}ms)"
     )
-    print(f"Generated comparison ({paired_stats['n']} paired blocks, "
-          f"mean diff {paired_stats['mean_diff_ms']:+.3f}ms ± {paired_stats['ci_ms']:.3f}ms)")
 
     base_url = f"https://github.com/{args.repo}/commit"
     baseline_label = f"[`{baseline_name}`]({base_url}/{baseline_ref})"
@@ -603,10 +2065,24 @@ def main():
         if table:
             wait_time_tables.append(table)
 
+
+    target_metric_summary = None
+    target_metric_table = ""
+    if args.target_metrics_config:
+        target_metric_summary = compute_target_metric_summary(
+            args.target_metrics_config,
+            args.baseline_csv,
+            args.feature_csv,
+            baseline_stats,
+            feature_stats,
+        )
+        target_metric_table = generate_target_metric_table(target_metric_summary)
+
     summary = {
-        "blocks": paired_stats["blocks"],
+        "blocks": ci_stats["blocks"],
         "big_blocks": args.big_blocks,
         "warmup_blocks": args.warmup_blocks,
+        "run_pairs": args.run_pairs,
         "wait_time": args.wait_time,
         "bal_mode": bal_mode,
         "baseline": {
@@ -619,10 +2095,42 @@ def main():
             "ref": feature_sha,
             "stats": feature_stats,
         },
-        "paired": paired_stats,
-        "changes": compute_changes(baseline_stats, feature_stats, paired_stats),
+        "changes": compute_changes(baseline_stats, feature_stats, ci_stats),
         "wait_times": wait_time_data,
     }
+    if args.benchmark_id:
+        summary["benchmark_id"] = args.benchmark_id
+    observability_from_ms, observability_to_ms = resolve_observability_range(
+        args.observability_from_ms,
+        args.observability_to_ms,
+    )
+    logs_url = args.logs_url
+    traces_url = args.traces_url
+    if args.benchmark_id and observability_from_ms and observability_to_ms:
+        logs_url = logs_url or build_grafana_logs_url(
+            args.benchmark_id,
+            observability_from_ms,
+            observability_to_ms,
+        )
+        traces_url = traces_url or build_grafana_traces_url(
+            args.benchmark_id,
+            observability_from_ms,
+            observability_to_ms,
+        )
+    observability = {
+        key: value for key, value in {
+            "benchmark_id": args.benchmark_id,
+            "from_ms": observability_from_ms,
+            "to_ms": observability_to_ms,
+            "grafana_url": args.grafana_url,
+            "logs_url": logs_url,
+            "traces_url": traces_url,
+        }.items() if value
+    }
+    if observability:
+        summary["observability"] = observability
+    if target_metric_summary:
+        summary["target_metrics"] = target_metric_summary
     with open(args.output_summary, "w") as f:
         json.dump(summary, f, indent=2)
     print(f"Summary written to {args.output_summary}")
@@ -630,11 +2138,12 @@ def main():
     markdown = generate_markdown(
         summary, comparison_table,
         wait_time_tables=wait_time_tables,
+        target_metric_table=target_metric_table,
         behind_baseline=args.behind_baseline,
         repo=args.repo,
         baseline_ref=baseline_ref,
         baseline_name=baseline_name,
-        grafana_url=args.grafana_url,
+        derek_command=args.derek_command,
     )
 
     with open(args.output_markdown, "w") as f:
diff --git a/.github/scripts/bench-slack-notify.js b/.github/scripts/bench-slack-notify.js
index e6a78a3a0fc..e71a9b8aa68 100644
--- a/.github/scripts/bench-slack-notify.js
+++ b/.github/scripts/bench-slack-notify.js
@@ -1,4 +1,4 @@
-// Sends Slack notifications for reth-bench results.
+// Sends Slack notifications for benchmark results.
 //
 // Reads from environment:
 //   SLACK_BENCH_BOT_TOKEN  – Slack Bot User OAuth Token (xoxb-...)
@@ -10,6 +10,7 @@
 //   BENCH_BASELINE_ARGS    – Extra CLI args for the baseline reth node
 //   BENCH_FEATURE_ARGS     – Extra CLI args for the feature reth node
 //   BENCH_SAMPLY           – 'true' if samply profiling was enabled
+//   BENCH_TRACING_CHROME   – 'true' if Chrome trace recording was enabled
 //
 // Usage from actions/github-script:
 //   const notify = require('./.github/scripts/bench-slack-notify.js');
@@ -18,7 +19,16 @@
 
 const fs = require('fs');
 const path = require('path');
-const { fmtChange, fmtMs, verdict, loadSamplyUrls, blocksLabel, metricRows, waitTimeRows } = require('./bench-utils');
+const {
+  fmtChange,
+  fmtMs,
+  verdict,
+  isWin,
+  loadSamplyUrls,
+  loadTracingChromeUrls,
+  blocksLabel,
+  metricRows,
+} = require('./bench-utils');
 
 const SLACK_API = 'https://slack.com/api/chat.postMessage';
 
@@ -62,6 +72,26 @@ function cell(text) {
   return { type: 'raw_text', text: s || ' ' };
 }
 
+function profileLinks(samplyUrls, prefix) {
+  return Object.entries(samplyUrls)
+    .filter(([run]) => run.startsWith(`${prefix}-`))
+    .sort(([a], [b]) => a.localeCompare(b, undefined, { numeric: true }))
+    .map(([run, url]) => {
+      const index = run.slice(prefix.length + 1);
+      return `<${url}|Samply ${index}>`;
+    });
+}
+
+function chromeTraceLinks(tracingChromeUrls, prefix) {
+  return Object.entries(tracingChromeUrls)
+    .filter(([run]) => run.startsWith(`${prefix}-`))
+    .sort(([a], [b]) => a.localeCompare(b, undefined, { numeric: true }))
+    .map(([run, url]) => {
+      const index = run.slice(prefix.length + 1);
+      return `<${url}|Chrome ${index}>`;
+    });
+}
+
 // Slack shortcodes for verdict (Block Kit header doesn't support unicode emoji)
 const SLACK_VERDICT = {
   '⚠️': ':warning:',
@@ -70,34 +100,72 @@ const SLACK_VERDICT = {
   '⚪': ':white_circle:',
 };
 
-function buildSuccessBlocks({ summary, prNumber, actor, actorSlackId, jobUrl, repo, samplyUrls }) {
+function benchConfigLine() {
+  const parts = [];
+  const add = (label, value, defaultValue = '') => {
+    if (value && value !== defaultValue) {
+      parts.push(`\`${label}=${value}\``);
+    }
+  };
+
+  add('blocks', process.env.BENCH_BLOCKS);
+  add('warmup', process.env.BENCH_WARMUP_BLOCKS);
+  add('big-blocks', process.env.BENCH_BIG_BLOCKS, 'false');
+  add('big-blocks-target-gas', process.env.BENCH_BIG_BLOCKS_TARGET_GAS);
+  add('bal', process.env.BENCH_BAL, 'false');
+  add('samply', process.env.BENCH_SAMPLY, 'false');
+  add('tracing-chrome', process.env.BENCH_TRACING_CHROME, 'false');
+  add('slack', process.env.BENCH_SLACK, 'always');
+  add('cores', process.env.BENCH_CORES, '0');
+  add('run-pairs', process.env.BENCH_RUN_PAIRS);
+  add('run-order', process.env.BENCH_RUN_ORDER);
+  add('otlp', process.env.BENCH_OTLP, 'true');
+  add('wait-time', process.env.BENCH_WAIT_TIME);
+  add('baseline-args', process.env.BENCH_BASELINE_ARGS);
+  add('feature-args', process.env.BENCH_FEATURE_ARGS);
+
+  return parts.length ? `*Workflow:* ${parts.join(' ')}` : '';
+}
+
+function buildSuccessBlocks({
+  summary,
+  prNumber,
+  actor,
+  actorSlackId,
+  jobUrl,
+  repo,
+  samplyUrls,
+  tracingChromeUrls,
+}) {
   const { emoji, label } = verdict(summary.changes);
   const headerEmoji = SLACK_VERDICT[emoji] || emoji;
 
   const prUrl = prNumber ? `https://github.com/${repo}/pull/${prNumber}` : '';
   const commitUrl = `https://github.com/${repo}/commit`;
+  const repoLink = `<https://github.com/${repo}|Reth>`;
   const baselineLink = `<${commitUrl}/${summary.baseline.ref}|${summary.baseline.name}>`;
   const featureLink = `<${commitUrl}/${summary.feature.ref}|${summary.feature.name}>`;
 
   // Meta line
-  const metaParts = [];
+  const metaParts = [`*Repo:* ${repoLink}`];
   if (prNumber) metaParts.push(`*<${prUrl}|PR #${prNumber}>*`);
   metaParts.push(`triggered by ${actorSlackId ? `<@${actorSlackId}>` : `@${actor}`}`);
 
   // Baseline/feature lines with samply profile links
   let baselineLine = `*Baseline:* ${baselineLink}`;
-  const bl1 = samplyUrls['baseline-1'];
-  const bl2 = samplyUrls['baseline-2'];
-  if (bl1) baselineLine += ` | <${bl1}|Samply 1>`;
-  if (bl2) baselineLine += ` | <${bl2}|Samply 2>`;
+  const baselineProfiles = profileLinks(samplyUrls, 'baseline');
+  if (baselineProfiles.length) baselineLine += ` | ${baselineProfiles.join(' | ')}`;
+  const baselineTraces = chromeTraceLinks(tracingChromeUrls, 'baseline');
+  if (baselineTraces.length) baselineLine += ` | ${baselineTraces.join(' | ')}`;
 
   let featureLine = `*Feature:* ${featureLink}`;
-  const fl1 = samplyUrls['feature-1'];
-  const fl2 = samplyUrls['feature-2'];
-  if (fl1) featureLine += ` | <${fl1}|Samply 1>`;
-  if (fl2) featureLine += ` | <${fl2}|Samply 2>`;
+  const featureProfiles = profileLinks(samplyUrls, 'feature');
+  if (featureProfiles.length) featureLine += ` | ${featureProfiles.join(' | ')}`;
+  const featureTraces = chromeTraceLinks(tracingChromeUrls, 'feature');
+  if (featureTraces.length) featureLine += ` | ${featureTraces.join(' | ')}`;
 
   const countsLine = blocksLabel(summary).map(p => `*${p.key}:* ${p.value}`).join(' | ');
+  const configLine = benchConfigLine();
 
   const baselineArgs = process.env.BENCH_BASELINE_ARGS || '';
   const featureArgs = process.env.BENCH_FEATURE_ARGS || '';
@@ -105,7 +173,9 @@ function buildSuccessBlocks({ summary, prNumber, actor, actorSlackId, jobUrl, re
   if (baselineArgs) argsLines.push(`*Baseline Args:* \`${baselineArgs}\``);
   if (featureArgs) argsLines.push(`*Feature Args:* \`${featureArgs}\``);
 
-  const sectionText = [metaParts.join(' | '), '', baselineLine, featureLine, ...argsLines, countsLine].join('\n');
+  const sectionText = [metaParts.join(' | '), configLine, '', baselineLine, featureLine, ...argsLines, countsLine]
+    .filter(line => line !== '')
+    .join('\n');
 
   // Action buttons
   const diffUrl = `https://github.com/${repo}/compare/${summary.baseline.ref}...${summary.feature.ref}`;
@@ -156,36 +226,20 @@ function buildSuccessBlocks({ summary, prNumber, actor, actorSlackId, jobUrl, re
     },
   ];
 
-  // Wait times as a separate table block (sent as threaded reply due to Slack one-table limit)
-  const threadBlocks = [];
-  const wtRows = waitTimeRows(summary);
-  if (wtRows.length > 0) {
-    const waitTableRows = [
-      [cell('Wait Time'), cell('Baseline'), cell('Feature')],
-      ...wtRows.map(r => [cell(r.title), cell(r.baseline), cell(r.feature)]),
-    ];
-    threadBlocks.push({
-      type: 'table',
-      column_settings: [
-        { align: 'left' },
-        { align: 'right' },
-        { align: 'right' },
-      ],
-      rows: waitTableRows,
-    });
-  }
-
-  return { blocks, threadBlocks };
+  return blocks;
 }
 
 function buildFailureBlocks({ prNumber, actor, actorSlackId, jobUrl, repo, failedStep }) {
   const prUrl = prNumber ? `https://github.com/${repo}/pull/${prNumber}` : '';
+  const repoLink = `<https://github.com/${repo}|Reth>`;
   const actorMention = actorSlackId ? `<@${actorSlackId}>` : `@${actor}`;
   const parts = [
+    `*Repo:* ${repoLink}`,
     prNumber ? `*<${prUrl}|PR #${prNumber}>*` : '',
     `by ${actorMention}`,
     `failed while *${failedStep}*`,
   ].filter(Boolean);
+  const configLine = benchConfigLine();
 
   const buttons = [
     {
@@ -203,7 +257,7 @@ function buildFailureBlocks({ prNumber, actor, actorSlackId, jobUrl, repo, faile
     },
     {
       type: 'section',
-      text: { type: 'mrkdwn', text: parts.join(' | ') },
+      text: { type: 'mrkdwn', text: [parts.join(' | '), configLine].filter(Boolean).join('\n') },
     },
     {
       type: 'actions',
@@ -234,42 +288,41 @@ async function success({ core, context }) {
     `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`;
 
   const samplyUrls = loadSamplyUrls(process.env.BENCH_WORK_DIR);
+  const tracingChromeUrls = loadTracingChromeUrls(process.env.BENCH_WORK_DIR);
 
   const slackUsers = loadSlackUsers(process.env.GITHUB_WORKSPACE || '.');
   const actorSlackId = slackUsers[actor];
 
-  const { blocks, threadBlocks } = buildSuccessBlocks({ summary, prNumber, actor, actorSlackId, jobUrl, repo, samplyUrls });
+  const blocks = buildSuccessBlocks({
+    summary,
+    prNumber,
+    actor,
+    actorSlackId,
+    jobUrl,
+    repo,
+    samplyUrls,
+    tracingChromeUrls,
+  });
   const text = `Bench: ${summary.baseline.name} vs ${summary.feature.name}`;
 
-  async function sendWithThread(ch) {
-    const res = await postToSlack(token, ch, blocks, text, core);
-    if (res.ok && res.ts && threadBlocks.length > 0) {
-      for (const tb of threadBlocks) {
-        await postToSlack(token, ch, [tb], 'Wait time breakdown', core, res.ts);
-      }
-    }
-  }
-
   const slackMode = process.env.BENCH_SLACK || 'always';
 
-  // Post to public channel if any metric shows significant improvement or regression
+  // Post to public channel only when the overall verdict is a win.
   const channel = process.env.SLACK_BENCH_CHANNEL;
   let postedToChannel = false;
   if (channel) {
-    const changes = summary.changes || {};
-    const hasImprovement = Object.values(changes).some(c => c.sig === 'good');
-    if (hasImprovement) {
-      await sendWithThread(channel);
+    if (isWin(summary.changes)) {
+      await postToSlack(token, channel, blocks, text, core);
       postedToChannel = true;
     } else {
-      core.info('No significant improvement, skipping public channel notification');
+      core.info('No unambiguous improvement, skipping public channel notification');
     }
   }
 
-  // In on-win mode, only notify on improvement — skip DM fallback entirely
+  // In on-win mode, only notify on unambiguous improvement. Mixed results are not wins.
   if (slackMode === 'on-win') {
     if (!postedToChannel) {
-      core.info('on-win mode: no improvement detected, skipping all notifications');
+      core.info('on-win mode: no unambiguous improvement detected, skipping all notifications');
     }
     return;
   }
@@ -277,7 +330,7 @@ async function success({ core, context }) {
   // DM the actor only when results were not posted to the public channel
   if (!postedToChannel) {
     if (actorSlackId) {
-      await sendWithThread(actorSlackId);
+      await postToSlack(token, actorSlackId, blocks, text, core);
     } else {
       core.info(`No Slack user mapping for GitHub user '${actor}', skipping DM`);
     }
@@ -315,4 +368,4 @@ async function failure({ core, context, failedStep }) {
   // Only DM for failures, don't post to public channel
 }
 
-module.exports = { success, failure };
+module.exports = { success, failure, benchConfigLine, buildSuccessBlocks, buildFailureBlocks };
diff --git a/.github/scripts/bench-target-metric-sample-filter.py b/.github/scripts/bench-target-metric-sample-filter.py
new file mode 100644
index 00000000000..c30ac48772a
--- /dev/null
+++ b/.github/scripts/bench-target-metric-sample-filter.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""Build a low-pass filter for target metric sample archives."""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+
+TARGET_METRIC_BLOCK_HEIGHT_QUERY = "reth_blockchain_tree_canonical_chain_height"
+SELECTOR_RE = re.compile(
+    r"^(?P<name>[a-zA-Z_:][a-zA-Z0-9_:]*)(?:\{(?P<labels>[^}]*)\})?$"
+)
+
+
+def parse_metric_name(query: str) -> str:
+    query = query.strip()
+    if query.startswith("sum(") and query.endswith(")"):
+        query = query[4:-1].strip()
+
+    match = SELECTOR_RE.match(query)
+    if not match:
+        raise ValueError(f"Unsupported target metric query: {query}")
+    return match.group("name")
+
+
+def histogram_sum_name(query: str) -> str:
+    name = parse_metric_name(query)
+    if name.endswith("_sum"):
+        return name
+    return f"{name}_sum"
+
+
+def target_metric_sample_names(config: dict) -> list[str]:
+    names = {TARGET_METRIC_BLOCK_HEIGHT_QUERY}
+
+    for counter in config.get("counters", []):
+        names.add(parse_metric_name(counter["query"]))
+
+    for histogram in config.get("histograms", []):
+        names.add(histogram_sum_name(histogram["query"]))
+
+    return sorted(names)
+
+
+def main() -> int:
+    if len(sys.argv) != 2:
+        print("usage: bench-target-metric-sample-filter.py <target-metrics-config>", file=sys.stderr)
+        return 2
+
+    with open(sys.argv[1]) as f:
+        config = json.load(f)
+
+    names = target_metric_sample_names(config)
+    name_pattern = "|".join(re.escape(name) for name in names)
+
+    print(rf'"name"[[:space:]]*:[[:space:]]*"({name_pattern})"')
+    print(json.dumps(names, separators=(",", ":")))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/.github/scripts/bench-txgen-build.sh b/.github/scripts/bench-txgen-build.sh
new file mode 100755
index 00000000000..4c040558064
--- /dev/null
+++ b/.github/scripts/bench-txgen-build.sh
@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+#
+# Builds the node binary used by benchmark workflows.
+#
+# Usage: bench-txgen-build.sh <baseline|feature> <source-dir> <commit>
+#
+# Big-block benchmarks build reth-bb because txgen replays reth-bb's extended
+# payload format.
+set -euxo pipefail
+
+MODE="$1"
+SOURCE_DIR="$2"
+COMMIT="$3"
+
+BIG_BLOCKS="${BENCH_BIG_BLOCKS:-false}"
+if [ "$BIG_BLOCKS" = "true" ]; then
+  NODE_BIN="reth-bb"
+  NODE_PKG="-p reth-bb"
+else
+  NODE_BIN="reth"
+  NODE_PKG="--bin reth"
+fi
+
+EXTRA_FEATURES=""
+EXTRA_RUSTFLAGS=""
+if [ "${BENCH_TRACY:-off}" != "off" ]; then
+  EXTRA_FEATURES="tracy,tracy-client/ondemand"
+  EXTRA_RUSTFLAGS=" -C force-frame-pointers=yes"
+fi
+
+build_node_binary() {
+  local features_arg=""
+  local workspace_arg=""
+
+  cd "$SOURCE_DIR"
+  if [ -n "$EXTRA_FEATURES" ]; then
+    features_arg="--features ${EXTRA_FEATURES}"
+    workspace_arg="--workspace"
+  fi
+
+  # shellcheck disable=SC2086
+  RUSTFLAGS="-C target-cpu=native${EXTRA_RUSTFLAGS}" \
+    cargo build --locked --profile profiling $NODE_PKG $workspace_arg $features_arg
+}
+
+case "$MODE" in
+  baseline|main)
+    echo "Building baseline ${NODE_BIN} (${COMMIT}) from source for txgen benchmark..."
+    build_node_binary
+    ;;
+
+  feature|branch)
+    echo "Building feature ${NODE_BIN} (${COMMIT}) from source for txgen benchmark..."
+    rustup show active-toolchain || rustup default stable
+    build_node_binary
+    ;;
+
+  *)
+    echo "Usage: $0 <baseline|feature> <source-dir> <commit>"
+    exit 1
+    ;;
+esac
diff --git a/.github/scripts/bench-txgen-extract.sh b/.github/scripts/bench-txgen-extract.sh
new file mode 100755
index 00000000000..39131424021
--- /dev/null
+++ b/.github/scripts/bench-txgen-extract.sh
@@ -0,0 +1,173 @@
+#!/usr/bin/env bash
+#
+# Pre-extracts txgen payloads (normal or big blocks) so they can be reused
+# across multiple benchmark runs instead of re-fetching from the remote RPC
+# every time.
+#
+# Starts a throwaway reth node to discover the snapshot's chain tip, extracts
+# payloads from BENCH_RPC_URL, then stops the node and recovers the snapshot.
+#
+# Usage: bench-txgen-extract.sh <binary> <output-dir>
+#
+# On success, writes:
+#   <output-dir>/all-blocks.ndjson   (or all-big-blocks.ndjson)
+#   <output-dir>/warmup-blocks.ndjson
+#   <output-dir>/benchmark-blocks.ndjson
+#
+# Required env: SCHELK_MOUNT, BENCH_RPC_URL, BENCH_BLOCKS, BENCH_WARMUP_BLOCKS
+# Optional env: BENCH_BIG_BLOCKS, BENCH_BIG_BLOCKS_TARGET_GAS, BENCH_BAL
+set -euxo pipefail
+
+BINARY="$1"
+OUTPUT_DIR="$2"
+
+BIG_BLOCKS="${BENCH_BIG_BLOCKS:-false}"
+BAL_MODE="${BENCH_BAL:-false}"
+INCLUDE_BAL=false
+if [ "$BAL_MODE" != "false" ] && [ -n "$BAL_MODE" ]; then
+  INCLUDE_BAL=true
+fi
+
+DATADIR_NAME="datadir"
+if [ "$BIG_BLOCKS" = "true" ]; then
+  DATADIR_NAME="datadir-big-blocks"
+fi
+DATADIR="$SCHELK_MOUNT/$DATADIR_NAME"
+
+RETH_SCOPE="${RETH_SCOPE:-reth-bench.scope}"
+
+mkdir -p "$OUTPUT_DIR"
+
+cleanup() {
+  sudo systemctl stop "$RETH_SCOPE" 2>/dev/null || true
+  sudo systemctl reset-failed "$RETH_SCOPE" 2>/dev/null || true
+  kill "${TAIL_PID:-}" 2>/dev/null || true
+  sudo schelk recover -y --kill || true
+}
+TAIL_PID=
+trap cleanup EXIT
+
+# Mount snapshot
+sudo systemctl stop "$RETH_SCOPE" 2>/dev/null || true
+sudo systemctl reset-failed "$RETH_SCOPE" 2>/dev/null || true
+sudo schelk recover -y --kill || sudo schelk full-recover -y || true
+sudo schelk mount -y || true
+if [ ! -d "$DATADIR/db" ] || [ ! -d "$DATADIR/static_files" ]; then
+  echo "::error::Failed to mount benchmark datadir at ${DATADIR}"
+  exit 1
+fi
+
+# Start a lightweight reth node just to query the chain tip.
+RETH_ARGS=(
+  node
+  --datadir "$DATADIR"
+  --http
+  --http.port 8545
+  --disable-discovery
+  --no-persist-peers
+)
+
+if "$BINARY" node --help 2>/dev/null | grep -qF -- '--debug.startup-sync-state-idle'; then
+  RETH_ARGS+=(--debug.startup-sync-state-idle)
+fi
+
+LOG="$OUTPUT_DIR/extract-node.log"
+sudo systemd-run --quiet --scope --collect --unit="$RETH_SCOPE" \
+  nice -n -20 "$BINARY" "${RETH_ARGS[@]}" \
+  > "$LOG" 2>&1 &
+stdbuf -oL tail -f "$LOG" | sed -u "s/^/[reth-extract] /" &
+TAIL_PID=$!
+
+# Wait for RPC
+for i in $(seq 1 60); do
+  if curl -sf http://127.0.0.1:8545 -X POST \
+    -H 'Content-Type: application/json' \
+    -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
+    > /dev/null 2>&1; then
+    echo "reth (extract) RPC is up after ${i}s"
+    break
+  fi
+  if [ "$i" -eq 60 ]; then
+    echo "::error::reth (extract) failed to start within 60s"
+    cat "$LOG"
+    exit 1
+  fi
+  sleep 1
+done
+
+HEAD_JSON=$(curl -sf http://127.0.0.1:8545 -X POST \
+  -H 'Content-Type: application/json' \
+  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}')
+HEAD_HEX=$(jq -r '.result' <<< "$HEAD_JSON")
+HEAD_DEC=$((16#${HEAD_HEX#0x}))
+echo "Snapshot chain tip: ${HEAD_DEC}"
+
+# Stop the throwaway node and recover snapshot before extraction.
+sudo systemctl stop "$RETH_SCOPE" 2>/dev/null || true
+sudo systemctl reset-failed "$RETH_SCOPE" 2>/dev/null || true
+kill "${TAIL_PID:-}" 2>/dev/null || true
+TAIL_PID=
+sudo schelk recover -y --kill || true
+
+# --- Extract payloads from the remote RPC ---
+
+TXGEN_ETHEREUM="$(which txgen-ethereum)"
+WARMUP="${BENCH_WARMUP_BLOCKS:-0}"
+BLOCKS="${BENCH_BLOCKS:?BENCH_BLOCKS must be set}"
+TOTAL=$(( WARMUP + BLOCKS ))
+if [ "$BLOCKS" -le 0 ] || [ "$TOTAL" -le 0 ]; then
+  echo "::error::BENCH_BLOCKS must be greater than 0"
+  exit 1
+fi
+
+ALL_BLOCKS="$OUTPUT_DIR/all-blocks.ndjson"
+WARMUP_FILE="$OUTPUT_DIR/warmup-blocks.ndjson"
+BENCHMARK_FILE="$OUTPUT_DIR/benchmark-blocks.ndjson"
+
+if [ "$BIG_BLOCKS" = "true" ]; then
+  ALL_BLOCKS="$OUTPUT_DIR/all-big-blocks.ndjson"
+  WARMUP_FILE="$OUTPUT_DIR/warmup-big-blocks.ndjson"
+  BENCHMARK_FILE="$OUTPUT_DIR/measured-big-blocks.ndjson"
+fi
+
+EXTRACT_FROM=$(( HEAD_DEC + 1 ))
+TXGEN_EXTRACT_ARGS=()
+if [ "$INCLUDE_BAL" = "true" ]; then
+  TXGEN_EXTRACT_ARGS+=(--bal)
+fi
+if [ "$BIG_BLOCKS" = "true" ]; then
+  echo "Extracting ${TOTAL} big blocks from ${EXTRACT_FROM} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured, bal=${INCLUDE_BAL})"
+  "$TXGEN_ETHEREUM" extract-big-blocks \
+    --rpc "$BENCH_RPC_URL" \
+    --from "$EXTRACT_FROM" \
+    --count "$TOTAL" \
+    --target-gas "${BENCH_BIG_BLOCKS_TARGET_GAS:-1G}" \
+    "${TXGEN_EXTRACT_ARGS[@]}" \
+    -o "$ALL_BLOCKS"
+else
+  EXTRACT_TO=$(( HEAD_DEC + TOTAL ))
+  echo "Extracting blocks ${EXTRACT_FROM}..${EXTRACT_TO} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured, bal=${INCLUDE_BAL})"
+  "$TXGEN_ETHEREUM" extract \
+    --rpc "$BENCH_RPC_URL" \
+    --from "$EXTRACT_FROM" \
+    --to "$EXTRACT_TO" \
+    "${TXGEN_EXTRACT_ARGS[@]}" \
+    -o "$ALL_BLOCKS"
+fi
+
+# Split into warmup and measured files
+if [ "$WARMUP" -gt 0 ] 2>/dev/null; then
+  head -n "$WARMUP" "$ALL_BLOCKS" > "$WARMUP_FILE"
+else
+  : > "$WARMUP_FILE"
+fi
+awk -v warmup="$WARMUP" 'NR > warmup { print }' "$ALL_BLOCKS" > "$BENCHMARK_FILE"
+
+if [ "$INCLUDE_BAL" = "true" ] && [ "$BAL_MODE" != "true" ]; then
+  echo "Writing no-BAL payload variants for selective BAL mode (${BAL_MODE})"
+  for file in "$ALL_BLOCKS" "$WARMUP_FILE" "$BENCHMARK_FILE"; do
+    jq -c 'del(.bal, .merged_block_access_list)' "$file" > "${file%.ndjson}-no-bal.ndjson"
+  done
+fi
+
+echo "Extraction complete: $(wc -l < "$ALL_BLOCKS") payloads in ${OUTPUT_DIR}"
diff --git a/.github/scripts/bench-txgen-install.sh b/.github/scripts/bench-txgen-install.sh
new file mode 100755
index 00000000000..e3b2ced9180
--- /dev/null
+++ b/.github/scripts/bench-txgen-install.sh
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+#
+# Installs the txgen tools used by the benchmark workflows.
+#
+# Optional env:
+#   TXGEN_REPO  – txgen repository URL (default: https://github.com/tempoxyz/txgen)
+set -euxo pipefail
+
+TXGEN_REPO="${TXGEN_REPO:-https://github.com/tempoxyz/txgen}"
+
+# txgen is private. Prefer the deploy key secret; fall back to token auth for
+# local/manual runs. Use the git CLI so cargo honors the auth configuration.
+if [ -n "${TXGEN_DEPLOY_KEY:-}" ]; then
+  set +x
+  mkdir -p "$HOME/.ssh"
+  printf '%s\n' "$TXGEN_DEPLOY_KEY" > "$HOME/.ssh/txgen_deploy_key"
+  chmod 600 "$HOME/.ssh/txgen_deploy_key"
+  ssh-keyscan github.com >> "$HOME/.ssh/known_hosts" 2>/dev/null
+  export GIT_SSH_COMMAND="ssh -i $HOME/.ssh/txgen_deploy_key -o IdentitiesOnly=yes"
+  set -x
+  TXGEN_REPO="${TXGEN_SSH_REPO:-ssh://git@github.com/tempoxyz/txgen.git}"
+elif [ -n "${TXGEN_TOKEN:-${GH_PROJECT_TOKEN:-${DEREK_PAT:-${DEREK_TOKEN:-}}}}" ]; then
+  AUTH_TOKEN="${TXGEN_TOKEN:-${GH_PROJECT_TOKEN:-${DEREK_PAT:-${DEREK_TOKEN:-}}}}"
+  set +x
+  git config --global url."https://x-access-token:${AUTH_TOKEN}@github.com/".insteadOf "https://github.com/"
+  set -x
+fi
+export CARGO_NET_GIT_FETCH_WITH_CLI=true
+
+cargo install --git "$TXGEN_REPO" --locked txgen-ethereum bench-cli
diff --git a/.github/scripts/bench-txgen-report-to-reth-csv.py b/.github/scripts/bench-txgen-report-to-reth-csv.py
new file mode 100755
index 00000000000..6501abe617a
--- /dev/null
+++ b/.github/scripts/bench-txgen-report-to-reth-csv.py
@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""Convert txgen `bench send-blocks` JSON into legacy benchmark CSVs.
+
+The benchmark rendering pipeline still consumes `combined_latency.csv` and
+`total_gas.csv`. This adapter lets the txgen runner reuse the existing
+summary/charts/slack code while we migrate those consumers to txgen JSON.
+"""
+
+import argparse
+import csv
+import json
+from pathlib import Path
+
+
+def opt_int(value, default=None):
+    if value is None:
+        return default
+    return int(value)
+
+
+def block_latency_us(block: dict) -> tuple[int, int, int]:
+    # txgen currently records server newPayload latency in microseconds but
+    # client-side forkchoiceUpdated latency in milliseconds.
+    new_payload_us = opt_int(block.get("new_payload_server_latency_us"))
+    if new_payload_us is None:
+        new_payload_us = opt_int(block.get("new_payload_ms"), 0) * 1000
+    fcu_us = opt_int(block.get("forkchoice_updated_ms"), 0) * 1000
+    return new_payload_us, fcu_us, new_payload_us + fcu_us
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Convert txgen JSON report to benchmark CSVs")
+    parser.add_argument("report", help="txgen JSON report path")
+    parser.add_argument("output_dir", help="directory for combined_latency.csv and total_gas.csv")
+    args = parser.parse_args()
+
+    report_path = Path(args.report)
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    with report_path.open() as f:
+        report = json.load(f)
+
+    blocks = report.get("blocks") or []
+    if not blocks:
+        raise SystemExit(f"txgen report {report_path} does not contain any blocks")
+
+    combined_path = output_dir / "combined_latency.csv"
+    with combined_path.open("w", newline="") as f:
+        writer = csv.DictWriter(
+            f,
+            fieldnames=[
+                "block_number",
+                "gas_limit",
+                "transaction_count",
+                "gas_used",
+                "new_payload_latency",
+                "fcu_latency",
+                "total_latency",
+                "persistence_wait",
+                "execution_cache_wait",
+                "sparse_trie_wait",
+            ],
+        )
+        writer.writeheader()
+        for block in blocks:
+            new_payload_us, fcu_us, total_us = block_latency_us(block)
+            writer.writerow(
+                {
+                    "block_number": block["number"],
+                    "gas_limit": block["gas_limit"],
+                    "transaction_count": block["tx_count"],
+                    "gas_used": block["gas_used"],
+                    "new_payload_latency": new_payload_us,
+                    "fcu_latency": fcu_us,
+                    "total_latency": total_us,
+                    "persistence_wait": block.get("persistence_wait_us") or 0,
+                    "execution_cache_wait": block.get("execution_cache_wait_us") or 0,
+                    "sparse_trie_wait": block.get("sparse_trie_wait_us") or 0,
+                }
+            )
+
+    total_gas_path = output_dir / "total_gas.csv"
+    elapsed_us = 0
+    with total_gas_path.open("w", newline="") as f:
+        writer = csv.DictWriter(
+            f,
+            fieldnames=["block_number", "transaction_count", "gas_used", "time"],
+        )
+        writer.writeheader()
+        for block in blocks:
+            _, _, total_us = block_latency_us(block)
+            elapsed_us += total_us
+            writer.writerow(
+                {
+                    "block_number": block["number"],
+                    "transaction_count": block["tx_count"],
+                    "gas_used": block["gas_used"],
+                    "time": elapsed_us,
+                }
+            )
+
+    print(f"Wrote legacy CSVs from {report_path} to {output_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/scripts/bench-txgen-run.sh b/.github/scripts/bench-txgen-run.sh
new file mode 100755
index 00000000000..66877b319b0
--- /dev/null
+++ b/.github/scripts/bench-txgen-run.sh
@@ -0,0 +1,552 @@
+#!/usr/bin/env bash
+#
+# Runs a single txgen-backed Engine API benchmark cycle:
+# mount snapshot → start node → extract source blocks → warmup → send-blocks →
+# convert txgen JSON report into legacy benchmark CSVs.
+#
+# Usage: bench-txgen-run.sh <label> <binary> <output-dir>
+#
+# Required env: SCHELK_MOUNT, BENCH_RPC_URL, BENCH_BLOCKS, BENCH_WARMUP_BLOCKS
+# Optional env: BENCH_BIG_BLOCKS, BENCH_BIG_BLOCKS_TARGET_GAS, BENCH_BAL,
+#               BENCH_WORK_DIR, BENCH_WAIT_TIME, BENCH_BASELINE_ARGS,
+#               BENCH_FEATURE_ARGS, BENCH_OTLP_TRACES_ENDPOINT,
+#               BENCH_OTLP_LOGS_ENDPOINT, BENCH_OTLP_DISABLED,
+#               BENCH_TRACING_CHROME, BENCH_TRACY,
+#               BENCH_TRACY_FILTER, BENCH_TRACY_SAMPLING_HZ,
+#               TXGEN_PAYLOADS_DIR (pre-extracted payloads; skips extraction),
+#               BENCH_TARGET_METRICS_SCRAPE_INTERVAL_MS (optional txgen override)
+set -euxo pipefail
+
+LABEL="$1"
+BINARY="$2"
+OUTPUT_DIR="$3"
+
+# Resolve git SHA for this run label
+GIT_SHA=""
+case "$LABEL" in
+  baseline*) GIT_SHA="${BASELINE_REF:-}" ;;
+  feature*)  GIT_SHA="${FEATURE_REF:-}" ;;
+esac
+
+# Resolve git-ref: tag if tagged, otherwise branch name, otherwise raw SHA
+GIT_REF="$GIT_SHA"
+if [ -n "$GIT_SHA" ]; then
+  TAG_NAME=$(git tag --points-at "$GIT_SHA" 2>/dev/null | head -1)
+  if [ -n "$TAG_NAME" ]; then
+    GIT_REF="$TAG_NAME"
+  else
+    BRANCH_NAME=$(git branch -r --points-at "$GIT_SHA" 2>/dev/null | sed 's|^ *origin/||' | head -1)
+    if [ -n "$BRANCH_NAME" ]; then
+      GIT_REF="$BRANCH_NAME"
+    fi
+  fi
+fi
+
+DATADIR_NAME="datadir"
+BIG_BLOCKS="${BENCH_BIG_BLOCKS:-false}"
+if [ "$BIG_BLOCKS" = "true" ]; then
+  DATADIR_NAME="datadir-big-blocks"
+fi
+DATADIR="$SCHELK_MOUNT/$DATADIR_NAME"
+mkdir -p "$OUTPUT_DIR"
+LOG="${OUTPUT_DIR}/node.log"
+TARGET_METRICS_RANGE="$OUTPUT_DIR/target-metrics-range.json"
+
+RETH_SCOPE="${RETH_SCOPE:-reth-bench.scope}"
+BENCH_TARGET_METRICS_SCRAPE_INTERVAL_MS="${BENCH_TARGET_METRICS_SCRAPE_INTERVAL_MS:-}"
+
+capture_unix_time_ms() {
+  python3 -c 'import time; print(time.time_ns() // 1_000_000)'
+}
+
+record_target_metric_range() {
+  local start_ms="$1"
+  local end_ms="$2"
+  if [ -z "${BENCH_TARGET_METRICS_CONFIG:-}" ]; then
+    return 0
+  fi
+
+  python3 - "$TARGET_METRICS_RANGE" "$start_ms" "$end_ms" "${BENCH_ID:-}" "$(basename "$OUTPUT_DIR")" <<'PY'
+import json
+import sys
+
+output_path, start_ms, end_ms, benchmark_id, benchmark_run = sys.argv[1:6]
+start_ms = int(start_ms)
+end_ms = int(end_ms)
+
+with open(output_path, "w") as f:
+    json.dump(
+        {
+            "benchmark_id": benchmark_id,
+            "benchmark_run": benchmark_run,
+            "range_start_ms": start_ms,
+            "range_end_ms": end_ms,
+            "duration_ms": end_ms - start_ms,
+        },
+        f,
+        indent=2,
+    )
+    f.write("\n")
+PY
+}
+
+extract_target_metric_scrapes() {
+  local samples_path="$1"
+  local output_path="$2"
+  local filter_output
+  local -a filter_lines
+  local sample_grep
+  local sample_names_json
+  local prefiltered_path
+  local -a pipe_status
+
+  : > "$output_path"
+
+  if [ ! -f "$samples_path" ]; then
+    echo "::error::Target metrics enabled but samples archive is missing: $samples_path"
+    return 1
+  fi
+
+  filter_output="$(python3 .github/scripts/bench-target-metric-sample-filter.py "$BENCH_TARGET_METRICS_CONFIG")"
+  mapfile -t filter_lines <<< "$filter_output"
+  sample_grep="${filter_lines[0]}"
+  sample_names_json="${filter_lines[1]}"
+  prefiltered_path="${output_path}.prefiltered"
+
+  set +e
+  gzip -dc "$samples_path" | grep -E -- "$sample_grep" > "$prefiltered_path"
+  pipe_status=("${PIPESTATUS[@]}")
+  set -e
+
+  if [ "${pipe_status[0]}" -ne 0 ]; then
+    echo "::error::Failed to decompress samples archive: $samples_path"
+    rm -f "$prefiltered_path"
+    return "${pipe_status[0]}"
+  fi
+  if [ "${pipe_status[1]}" -ne 0 ] && [ "${pipe_status[1]}" -ne 1 ]; then
+    echo "::error::Failed to prefilter target metric samples from: $samples_path"
+    rm -f "$prefiltered_path"
+    return "${pipe_status[1]}"
+  fi
+
+  jq -c --argjson metric_names "$sample_names_json" \
+    '. as $sample | select(($metric_names | index($sample.name)) != null)' \
+    "$prefiltered_path" > "$output_path"
+  rm -f "$prefiltered_path"
+
+  echo "Filtered $(wc -l < "$output_path" | tr -d ' ') target metric samples from $samples_path"
+}
+
+bal_enabled_for_label() {
+  case "${BENCH_BAL:-false}" in
+    false|"")
+      echo false
+      ;;
+    true)
+      echo true
+      ;;
+    feature)
+      if [[ "$LABEL" == feature* ]]; then echo true; else echo false; fi
+      ;;
+    baseline)
+      if [[ "$LABEL" == baseline* ]]; then echo true; else echo false; fi
+      ;;
+    *)
+      echo "::error::Unknown BENCH_BAL value: ${BENCH_BAL}" >&2
+      return 1
+      ;;
+  esac
+}
+
+USE_BAL="$(bal_enabled_for_label)"
+echo "BAL replay for ${LABEL}: ${USE_BAL} (mode=${BENCH_BAL:-false})"
+
+cleanup() {
+  kill "${TAIL_PID:-}" 2>/dev/null || true
+  if [ -n "${TRACY_PID:-}" ] && kill -0 "$TRACY_PID" 2>/dev/null; then
+    echo "Stopping tracy-capture..."
+    kill -INT "$TRACY_PID" 2>/dev/null || true
+    for i in $(seq 1 30); do
+      kill -0 "$TRACY_PID" 2>/dev/null || break
+      if [ $((i % 10)) -eq 0 ]; then
+        echo "Waiting for tracy-capture to finish writing... (${i}s)"
+      fi
+      sleep 1
+    done
+    if kill -0 "$TRACY_PID" 2>/dev/null; then
+      echo "tracy-capture still running after 30s, killing..."
+      kill -9 "$TRACY_PID" 2>/dev/null || true
+    fi
+    wait "$TRACY_PID" 2>/dev/null || true
+  fi
+  if sudo systemctl is-active "$RETH_SCOPE" >/dev/null 2>&1; then
+    if [ "${BENCH_SAMPLY:-false}" = "true" ]; then
+      sudo pkill -INT -x reth 2>/dev/null || true
+      sudo pkill -INT -x reth-bb 2>/dev/null || true
+      for i in $(seq 1 120); do
+        sudo pgrep -x samply > /dev/null 2>&1 || break
+        if [ $((i % 10)) -eq 0 ]; then
+          echo "Waiting for samply to finish writing profile... (${i}s)"
+        fi
+        sleep 1
+      done
+      sudo pkill -x samply 2>/dev/null || true
+    fi
+    sudo systemctl stop "$RETH_SCOPE" 2>/dev/null || true
+    sleep 1
+  fi
+  sudo systemctl reset-failed "$RETH_SCOPE" 2>/dev/null || true
+  sudo chown -R "$(id -un):$(id -gn)" "$OUTPUT_DIR" 2>/dev/null || true
+  sudo schelk recover -y --kill || true
+}
+TAIL_PID=
+TRACY_PID=
+trap cleanup EXIT
+
+sudo systemctl stop "$RETH_SCOPE" 2>/dev/null || true
+sudo systemctl reset-failed "$RETH_SCOPE" 2>/dev/null || true
+sudo schelk recover -y --kill || sudo schelk full-recover -y || true
+
+sudo schelk mount -y || true
+if [ ! -d "$DATADIR/db" ] || [ ! -d "$DATADIR/static_files" ]; then
+  echo "::error::Failed to mount benchmark datadir at ${DATADIR}"
+  ls -la "$SCHELK_MOUNT" || true
+  ls -la "$DATADIR" || true
+  exit 1
+fi
+sync
+sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches'
+echo "=== Cache state after drop ==="
+free -h
+grep Cached /proc/meminfo
+
+ONLINE=$(getconf _NPROCESSORS_ONLN)
+MAX_RETH=$(( ONLINE - 1 ))
+if [ "${BENCH_CORES:-0}" -gt 0 ] && [ "$BENCH_CORES" -lt "$MAX_RETH" ]; then
+  MAX_RETH=$BENCH_CORES
+fi
+RETH_CPUS="1-${MAX_RETH}"
+
+RETH_ARGS=(
+  node
+  --datadir "$DATADIR"
+  --log.file.directory "$OUTPUT_DIR/reth-logs"
+  --engine.accept-execution-requests-hash
+  --http
+  --http.port 8545
+  --ws
+  --ws.api all
+  --authrpc.port 8551
+  --disable-discovery
+  --no-persist-peers
+)
+
+SYNC_STATE_IDLE=false
+if "$BINARY" node --help 2>/dev/null | grep -qF -- '--debug.startup-sync-state-idle'; then
+  RETH_ARGS+=(--debug.startup-sync-state-idle)
+  SYNC_STATE_IDLE=true
+fi
+
+EXTRA_NODE_ARGS=""
+case "$LABEL" in
+  baseline*) EXTRA_NODE_ARGS="${BENCH_BASELINE_ARGS:-}" ;;
+  feature*)  EXTRA_NODE_ARGS="${BENCH_FEATURE_ARGS:-}" ;;
+esac
+if [ -n "$EXTRA_NODE_ARGS" ]; then
+  # shellcheck disable=SC2206
+  RETH_ARGS+=($EXTRA_NODE_ARGS)
+fi
+
+if [ -n "${BENCH_METRICS_ADDR:-}" ]; then
+  RETH_ARGS+=(--metrics "$BENCH_METRICS_ADDR")
+fi
+
+if [ "${BENCH_OTLP_DISABLED:-false}" != "true" ]; then
+  if [ -n "${BENCH_OTLP_TRACES_ENDPOINT:-}" ]; then
+    RETH_ARGS+=(--tracing-otlp="${BENCH_OTLP_TRACES_ENDPOINT}" --tracing-otlp.service-name=reth-bench --tracing-otlp.service-version="${LABEL}")
+  fi
+  if [ -n "${BENCH_OTLP_LOGS_ENDPOINT:-}" ]; then
+    RETH_ARGS+=(--logs-otlp="${BENCH_OTLP_LOGS_ENDPOINT}" --logs-otlp.filter=debug)
+  fi
+fi
+
+if [ "${BENCH_TRACY:-off}" != "off" ]; then
+  RETH_ARGS+=(--log.tracy --log.tracy.filter "${BENCH_TRACY_FILTER:-debug}")
+  if [ "${BENCH_TRACY}" = "on" ]; then
+    export TRACY_NO_SYS_TRACE=1
+  elif [ "${BENCH_TRACY}" = "full" ]; then
+    export TRACY_SAMPLING_HZ="${BENCH_TRACY_SAMPLING_HZ:-1}"
+  fi
+fi
+
+SUDO_ENV=()
+if [ -n "${OTEL_RESOURCE_ATTRIBUTES:-}" ]; then
+  SUDO_ENV+=("OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES}")
+  SUDO_ENV+=("OTEL_BSP_MAX_QUEUE_SIZE=65536" "OTEL_BLRP_MAX_QUEUE_SIZE=65536")
+fi
+
+TOTAL_MEM_KB=$(awk '/^MemTotal:/ {print $2}' /proc/meminfo)
+MEM_LIMIT=$(( TOTAL_MEM_KB * 95 * 1024 / 100 ))
+echo "Memory limit: $(( MEM_LIMIT / 1024 / 1024 ))MB (95% of $(( TOTAL_MEM_KB / 1024 ))MB)"
+
+if [ "${BENCH_SAMPLY:-false}" = "true" ]; then
+  RETH_ARGS+=(--log.samply)
+fi
+
+if [ "${BENCH_TRACING_CHROME:-false}" = "true" ]; then
+  if "$BINARY" node --log.tracing-chrome --log.tracing-chrome.file "$OUTPUT_DIR/tracing-chrome-profile.json" --help >/dev/null 2>&1; then
+    RETH_ARGS+=(
+      --log.tracing-chrome
+      --log.tracing-chrome.file "$OUTPUT_DIR/tracing-chrome-profile.json"
+    )
+  else
+    echo "Chrome trace recording requested, but ${LABEL} binary rejected --log.tracing-chrome; skipping"
+  fi
+fi
+
+if [ "${BENCH_SAMPLY:-false}" = "true" ]; then
+  SAMPLY="$(which samply)"
+  # shellcheck disable=SC2024
+  sudo systemd-run --quiet --scope --collect --unit="$RETH_SCOPE" \
+    -p MemoryMax="$MEM_LIMIT" -p AllowedCPUs="$RETH_CPUS" \
+    env "${SUDO_ENV[@]}" nice -n -20 \
+    "$SAMPLY" record --save-only --presymbolicate --rate 10000 \
+    --output "$OUTPUT_DIR/samply-profile.json.gz" \
+    -- "$BINARY" "${RETH_ARGS[@]}" \
+    > "$LOG" 2>&1 &
+else
+  # shellcheck disable=SC2024
+  sudo systemd-run --quiet --scope --collect --unit="$RETH_SCOPE" \
+    -p MemoryMax="$MEM_LIMIT" -p AllowedCPUs="$RETH_CPUS" \
+    env "${SUDO_ENV[@]}" nice -n -20 "$BINARY" "${RETH_ARGS[@]}" \
+    > "$LOG" 2>&1 &
+fi
+stdbuf -oL tail -f "$LOG" | sed -u "s/^/[reth] /" &
+TAIL_PID=$!
+
+for i in $(seq 1 60); do
+  if curl -sf http://127.0.0.1:8545 -X POST \
+    -H 'Content-Type: application/json' \
+    -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
+    > /dev/null 2>&1; then
+    echo "reth (${LABEL}) RPC is up after ${i}s"
+    break
+  fi
+  if [ "$i" -eq 60 ]; then
+    echo "::error::reth (${LABEL}) failed to start within 60s"
+    cat "$LOG"
+    exit 1
+  fi
+  sleep 1
+done
+
+if [ "$SYNC_STATE_IDLE" = "true" ]; then
+  for i in $(seq 1 300); do
+    SYNC_RESULT=$(curl -sf http://127.0.0.1:8545 -X POST \
+      -H 'Content-Type: application/json' \
+      -d '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}' 2>/dev/null || true)
+    if [ -n "$SYNC_RESULT" ] && jq -e '.result == false' <<< "$SYNC_RESULT" > /dev/null 2>&1; then
+      echo "reth (${LABEL}) pipeline finished after ${i}s, engine is live"
+      break
+    fi
+    if [ "$i" -eq 300 ]; then
+      echo "::error::reth (${LABEL}) pipeline did not finish within 300s"
+      cat "$LOG"
+      exit 1
+    fi
+    sleep 1
+  done
+else
+  echo "reth (${LABEL}) binary does not support --debug.startup-sync-state-idle, skipping sync wait"
+fi
+
+TXGEN_BENCH="$(which bench)"
+BENCH_NICE="sudo nice -n -20 sudo -u $(id -un)"
+TXGEN_SEND_ARGS=()
+if [ -n "${BENCH_WAIT_TIME:-}" ]; then
+  TXGEN_SEND_ARGS+=(--wait-time "$BENCH_WAIT_TIME")
+fi
+
+WARMUP="${BENCH_WARMUP_BLOCKS:-0}"
+BLOCKS="${BENCH_BLOCKS:?BENCH_BLOCKS must be set}"
+TOTAL=$(( WARMUP + BLOCKS ))
+if [ "$BLOCKS" -le 0 ] || [ "$TOTAL" -le 0 ]; then
+  echo "::error::BENCH_BLOCKS must be greater than 0"
+  exit 1
+fi
+
+TXGEN_DIR="$OUTPUT_DIR/txgen"
+mkdir -p "$TXGEN_DIR"
+
+# Use pre-extracted payloads if available, otherwise extract inline.
+if [ -n "${TXGEN_PAYLOADS_DIR:-}" ] && [ -d "$TXGEN_PAYLOADS_DIR" ]; then
+  echo "Using pre-extracted payloads from ${TXGEN_PAYLOADS_DIR}"
+  if [ "$BIG_BLOCKS" = "true" ]; then
+    WARMUP_BLOCKS="$TXGEN_PAYLOADS_DIR/warmup-big-blocks.ndjson"
+    BENCHMARK_BLOCKS="$TXGEN_PAYLOADS_DIR/measured-big-blocks.ndjson"
+  else
+    WARMUP_BLOCKS="$TXGEN_PAYLOADS_DIR/warmup-blocks.ndjson"
+    BENCHMARK_BLOCKS="$TXGEN_PAYLOADS_DIR/benchmark-blocks.ndjson"
+  fi
+  if [ "$USE_BAL" != "true" ]; then
+    WARMUP_NO_BAL="${WARMUP_BLOCKS%.ndjson}-no-bal.ndjson"
+    BENCHMARK_NO_BAL="${BENCHMARK_BLOCKS%.ndjson}-no-bal.ndjson"
+    if [ -f "$BENCHMARK_NO_BAL" ]; then
+      WARMUP_BLOCKS="$WARMUP_NO_BAL"
+      BENCHMARK_BLOCKS="$BENCHMARK_NO_BAL"
+    fi
+  fi
+  echo "Selected txgen payloads: warmup=${WARMUP_BLOCKS}, benchmark=${BENCHMARK_BLOCKS}"
+  if [ ! -f "$BENCHMARK_BLOCKS" ]; then
+    echo "::error::Pre-extracted payloads missing: ${BENCHMARK_BLOCKS}"
+    exit 1
+  fi
+else
+  TXGEN_ETHEREUM="$(which txgen-ethereum)"
+  HEAD_JSON=$(curl -sf http://127.0.0.1:8545 -X POST \
+    -H 'Content-Type: application/json' \
+    -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}')
+  HEAD_HEX=$(jq -r '.result' <<< "$HEAD_JSON")
+  HEAD_DEC=$((16#${HEAD_HEX#0x}))
+
+  ALL_BLOCKS="$TXGEN_DIR/all-blocks.ndjson"
+  WARMUP_BLOCKS="$TXGEN_DIR/warmup-blocks.ndjson"
+  BENCHMARK_BLOCKS="$TXGEN_DIR/benchmark-blocks.ndjson"
+  if [ "$BIG_BLOCKS" = "true" ]; then
+    ALL_BLOCKS="$TXGEN_DIR/all-big-blocks.ndjson"
+    WARMUP_BLOCKS="$TXGEN_DIR/warmup-big-blocks.ndjson"
+    BENCHMARK_BLOCKS="$TXGEN_DIR/measured-big-blocks.ndjson"
+  fi
+
+  EXTRACT_FROM=$(( HEAD_DEC + 1 ))
+  TXGEN_EXTRACT_ARGS=()
+  if [ "$USE_BAL" = "true" ]; then
+    TXGEN_EXTRACT_ARGS+=(--bal)
+  fi
+  if [ "$BIG_BLOCKS" = "true" ]; then
+    echo "Extracting ${TOTAL} big blocks from ${EXTRACT_FROM} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured, bal=${USE_BAL})"
+    "$TXGEN_ETHEREUM" extract-big-blocks \
+      --rpc "$BENCH_RPC_URL" \
+      --from "$EXTRACT_FROM" \
+      --count "$TOTAL" \
+      --target-gas "${BENCH_BIG_BLOCKS_TARGET_GAS:-1G}" \
+      "${TXGEN_EXTRACT_ARGS[@]}" \
+      -o "$ALL_BLOCKS"
+  else
+    EXTRACT_TO=$(( HEAD_DEC + TOTAL ))
+    echo "Extracting blocks ${EXTRACT_FROM}..${EXTRACT_TO} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured, bal=${USE_BAL})"
+    "$TXGEN_ETHEREUM" extract \
+      --rpc "$BENCH_RPC_URL" \
+      --from "$EXTRACT_FROM" \
+      --to "$EXTRACT_TO" \
+      "${TXGEN_EXTRACT_ARGS[@]}" \
+      -o "$ALL_BLOCKS"
+  fi
+
+  if [ "$WARMUP" -gt 0 ] 2>/dev/null; then
+    head -n "$WARMUP" "$ALL_BLOCKS" > "$WARMUP_BLOCKS"
+  else
+    : > "$WARMUP_BLOCKS"
+  fi
+  awk -v warmup="$WARMUP" 'NR > warmup { print }' "$ALL_BLOCKS" > "$BENCHMARK_BLOCKS"
+fi
+
+if [ "$WARMUP" -gt 0 ] 2>/dev/null; then
+  echo "Running txgen warmup (${WARMUP} blocks)..."
+  $BENCH_NICE "$TXGEN_BENCH" send-blocks \
+    --engine http://127.0.0.1:8551 \
+    --jwt-secret "$DATADIR/jwt.hex" \
+    --input "$WARMUP_BLOCKS" \
+    "${TXGEN_SEND_ARGS[@]}" \
+    --wait-for-persistence never \
+    --report json:"$TXGEN_DIR/warmup-report.json" 2>&1 | sed -u "s/^/[bench] /"
+else
+  echo "Skipping warmup (0 blocks)..."
+fi
+
+if [ "${BENCH_TRACY:-off}" != "off" ]; then
+  echo "Starting tracy-capture..."
+  tracy-capture -f -o "$OUTPUT_DIR/tracy-profile.tracy" &
+  TRACY_PID=$!
+  sleep 0.5
+fi
+
+# TODO(txgen): expose microsecond client-side FCU latency to avoid ms rounding.
+TARGET_METRICS_START_MS=""
+CLICKHOUSE_REPORT=()
+if [ -n "${CLICKHOUSE_URL:-}" ]; then
+  CLICKHOUSE_REPORT=(--report "clickhouse:$CLICKHOUSE_URL")
+fi
+
+METRICS_ARGS=()
+PROMETHEUS_REPORT=()
+PROMETHEUS_METADATA=()
+METRICS_URL_ADDED=false
+if [ -n "${BENCH_TARGET_METRICS_CONFIG:-}" ] || [ -n "${BENCH_VICTORIAMETRICS_URL:-}" ]; then
+  if [ -z "${BENCH_METRICS_ADDR:-}" ]; then
+    echo "::error::BENCH_METRICS_ADDR is required when benchmark metrics are enabled"
+    exit 1
+  fi
+
+  METRICS_ARGS+=(--metrics-url "http://${BENCH_METRICS_ADDR}/metrics")
+  METRICS_URL_ADDED=true
+fi
+
+if [ -n "${BENCH_TARGET_METRICS_CONFIG:-}" ]; then
+  TARGET_METRICS_START_MS="$(capture_unix_time_ms)"
+  if [ "$METRICS_URL_ADDED" = true ] && [ -n "$BENCH_TARGET_METRICS_SCRAPE_INTERVAL_MS" ]; then
+    METRICS_ARGS+=(--scrape-interval-ms "$BENCH_TARGET_METRICS_SCRAPE_INTERVAL_MS")
+  fi
+fi
+
+if [ -n "${BENCH_VICTORIAMETRICS_URL:-}" ]; then
+  if [ "$METRICS_URL_ADDED" != true ] && [ -n "${BENCH_METRICS_ADDR:-}" ]; then
+    METRICS_ARGS+=(--metrics-url "http://${BENCH_METRICS_ADDR}/metrics")
+  fi
+  PROMETHEUS_REPORT+=(--report "victoriametrics:$BENCH_VICTORIAMETRICS_URL")
+
+  if [ -n "${BENCH_LABELS_FILE:-}" ] && [ -f "$BENCH_LABELS_FILE" ]; then
+    BENCHMARK_START=$(jq -r '.run_start_epoch // empty' "$BENCH_LABELS_FILE")
+    if [ -n "$BENCHMARK_START" ]; then
+      METRICS_ARGS+=(--metrics-align "$BENCHMARK_START")
+    fi
+
+    for key in benchmark_run run_type benchmark_id run_start_epoch reference_epoch bench_sha; do
+      value=$(jq -r --arg key "$key" '.[$key] // empty' "$BENCH_LABELS_FILE")
+      if [ -n "$value" ]; then
+        PROMETHEUS_METADATA+=(-m "$key=$value")
+      fi
+    done
+  fi
+fi
+
+echo "Running txgen measured benchmark (${BLOCKS} blocks)..."
+$BENCH_NICE "$TXGEN_BENCH" send-blocks \
+  --engine http://127.0.0.1:8551 \
+  --jwt-secret "$DATADIR/jwt.hex" \
+  --input "$BENCHMARK_BLOCKS" \
+  "${TXGEN_SEND_ARGS[@]}" \
+  "${METRICS_ARGS[@]}" \
+  --wait-for-persistence never \
+  --report json:"$OUTPUT_DIR/report.json" \
+  "${CLICKHOUSE_REPORT[@]}" \
+  "${PROMETHEUS_REPORT[@]}" \
+  -m "git-sha=$GIT_SHA" \
+  -m "git-ref=$GIT_REF" \
+  -m "job=github-reth-bench" \
+  -m "platform=ethereum" \
+  -m "scenario=replay" \
+  -m "bal-mode=${BENCH_BAL:-false}" \
+  -m "bal-enabled=$USE_BAL" \
+  "${PROMETHEUS_METADATA[@]}" 2>&1 | sed -u "s/^/[bench] /"
+
+if [ -n "$TARGET_METRICS_START_MS" ]; then
+  TARGET_METRICS_END_MS="$(capture_unix_time_ms)"
+  record_target_metric_range "$TARGET_METRICS_START_MS" "$TARGET_METRICS_END_MS"
+  rm -f "$OUTPUT_DIR/target-metrics-scrapes.jsonl"
+  extract_target_metric_scrapes \
+    "$OUTPUT_DIR/report.samples.ndjson.gz" \
+    "$OUTPUT_DIR/target-metrics-scrapes.jsonl"
+fi
+
+python3 .github/scripts/bench-txgen-report-to-reth-csv.py "$OUTPUT_DIR/report.json" "$OUTPUT_DIR"
diff --git a/.github/scripts/bench-update-status.js b/.github/scripts/bench-update-status.js
index 79bd50f6ca0..2748553b5e1 100644
--- a/.github/scripts/bench-update-status.js
+++ b/.github/scripts/bench-update-status.js
@@ -1,4 +1,4 @@
-// Updates the reth-bench PR comment with current status.
+// Updates the benchmark PR comment with current status.
 //
 // Reads from environment:
 //   BENCH_COMMENT_ID  – GitHub comment ID to update
diff --git a/.github/scripts/bench-update-status.sh b/.github/scripts/bench-update-status.sh
new file mode 100755
index 00000000000..b26db9ae44a
--- /dev/null
+++ b/.github/scripts/bench-update-status.sh
@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# Updates the benchmark PR comment with current status via the GitHub API.
+#
+# Usage: bench-update-status.sh "Running benchmark: feature (1/2)..."
+#
+# Reads from environment:
+#   BENCH_COMMENT_ID  – GitHub comment ID to update
+#   BENCH_GH_TOKEN    – GitHub token for API auth
+#   BENCH_ACTOR       – User who triggered the benchmark
+#   BENCH_JOB_URL     – URL to the Actions job page
+#   BENCH_CONFIG      – Config line (blocks, warmup, refs)
+#   GITHUB_REPOSITORY – owner/repo
+
+set -euo pipefail
+
+STATUS="$1"
+
+if [ -z "${BENCH_COMMENT_ID:-}" ] || [ -z "${BENCH_GH_TOKEN:-}" ]; then
+  exit 0
+fi
+
+BODY=$(printf 'cc @%s\n\n🚀 Benchmark started! [View job](%s)\n\n⏳ **Status:** %s\n\n%s' \
+  "${BENCH_ACTOR:-}" "${BENCH_JOB_URL:-}" "$STATUS" "${BENCH_CONFIG:-}")
+
+PAYLOAD=$(jq -n --arg body "$BODY" '{body: $body}')
+
+curl -sS -X PATCH \
+  "https://api.github.com/repos/${GITHUB_REPOSITORY}/issues/comments/${BENCH_COMMENT_ID}" \
+  -H "Authorization: token ${BENCH_GH_TOKEN}" \
+  -H "Accept: application/vnd.github+json" \
+  -d "$PAYLOAD" > /dev/null || echo "Warning: failed to update PR comment status"
diff --git a/.github/scripts/bench-utils.js b/.github/scripts/bench-utils.js
index 393c402fb25..dc98bfb20be 100644
--- a/.github/scripts/bench-utils.js
+++ b/.github/scripts/bench-utils.js
@@ -1,4 +1,4 @@
-// Shared utilities for reth-bench result rendering.
+// Shared utilities for benchmark result rendering.
 //
 // Used by bench-job-summary.js and bench-slack-notify.js.
 
@@ -14,12 +14,20 @@ function fmtS(v) { return v.toFixed(2) + 's'; }
 function fmtChange(ch) {
   if (!ch || (!ch.pct && !ch.ci_pct)) return '';
   const pctStr = `${ch.pct >= 0 ? '+' : ''}${ch.pct.toFixed(2)}%`;
-  const ciStr = ch.ci_pct ? ` (±${ch.ci_pct.toFixed(2)}%)` : '';
-  return `${pctStr}${ciStr} ${SIG_EMOJI[ch.sig]}`;
+  const details = [];
+  if (ch.ci_pct) details.push(`±${ch.ci_pct.toFixed(2)}%`);
+  if (ch.floor_pct) details.push(`floor ${ch.floor_pct.toFixed(2)}%`);
+  if (ch.materiality?.threshold_ms) {
+    details.push(`materiality ${ch.materiality.threshold_ms.toFixed(2)}ms`);
+  }
+  if (ch.informational) details.push('informational');
+  const detailStr = details.length ? ` (${details.join(', ')})` : '';
+  const sig = ch.informational ? 'neutral' : ch.sig;
+  return `${pctStr}${detailStr} ${SIG_EMOJI[sig]}`;
 }
 
 function verdict(changes) {
-  const vals = Object.values(changes);
+  const vals = Object.values(changes).filter(v => !v.informational);
   const hasBad = vals.some(v => v.sig === 'bad');
   const hasGood = vals.some(v => v.sig === 'good');
   if (hasBad && hasGood) return { emoji: '⚠️', label: 'Mixed Results' };
@@ -28,11 +36,32 @@ function verdict(changes) {
   return { emoji: '⚪', label: 'No Difference' };
 }
 
+function isWin(changes) {
+  const vals = Object.values(changes || {}).filter(v => !v.informational);
+  return vals.some(v => v.sig === 'good') && !vals.some(v => v.sig === 'bad');
+}
+
 function loadSamplyUrls(workDir) {
+  return loadProfileUrls(workDir, 'samply-profile-url.txt');
+}
+
+function loadTracingChromeUrls(workDir) {
+  return loadProfileUrls(workDir, 'tracing-chrome-profile-url.txt');
+}
+
+function loadProfileUrls(workDir, fileName) {
   const urls = {};
-  for (const run of ['baseline-1', 'baseline-2', 'feature-1', 'feature-2']) {
+  let runs = [];
+  try {
+    runs = fs.readdirSync(workDir)
+      .filter(run => /^(baseline|feature)-\d+$/.test(run))
+      .sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+  } catch {
+    return urls;
+  }
+  for (const run of runs) {
     try {
-      const url = fs.readFileSync(path.join(workDir, run, 'samply-profile-url.txt'), 'utf8').trim();
+      const url = fs.readFileSync(path.join(workDir, run, fileName), 'utf8').trim();
       if (url) urls[run] = url;
     } catch {}
   }
@@ -66,10 +95,14 @@ function blocksLabel(summary) {
   const cores = process.env.BENCH_CORES || '0';
   if (cores !== '0') parts.push({ key: 'Cores', value: cores });
   if (summary.wait_time) parts.push({ key: 'Wait time', value: summary.wait_time });
+  const runPairs = summary.run_pairs || process.env.BENCH_RUN_PAIRS || '';
+  if (runPairs) {
+    parts.push({ key: 'Run pairs', value: runPairs });
+  }
   return parts;
 }
 
-// The 7 metric rows shared by all renderers.
+// The metric rows shared by all renderers.
 // Returns an array of { label, baseline, feature, change } objects.
 function metricRows(summary) {
   const b = summary.baseline.stats;
@@ -105,7 +138,9 @@ module.exports = {
   fmtS,
   fmtChange,
   verdict,
+  isWin,
   loadSamplyUrls,
+  loadTracingChromeUrls,
   blocksLabel,
   metricRows,
   waitTimeRows,
diff --git a/.github/scripts/check_wasm.sh b/.github/scripts/check_wasm.sh
index fbc01acfa1a..5f47c627cba 100755
--- a/.github/scripts/check_wasm.sh
+++ b/.github/scripts/check_wasm.sh
@@ -9,7 +9,6 @@ readarray -t crates < <(
 exclude_crates=(
   # The following require investigation if they can be fixed
   reth-basic-payload-builder
-  reth-bench
   reth-bench-compare
   reth-cli
   reth-cli-commands
@@ -77,6 +76,16 @@ exclude_crates=(
   reth-era-utils # tokio
   reth-tracing-otlp
   reth-node-ethstats
+  # The following pull in C libraries (secp256k1-sys, zstd-sys) that cannot compile to wasm
+  reth-cli-util       # secp256k1-sys via enr
+  reth-db             # zstd-sys via reth-nippy-jar
+  reth-db-api         # zstd-sys via reth-codecs -> reth-zstd-compressors
+  reth-ecies          # secp256k1-sys via enr
+  reth-network-api    # secp256k1-sys via enr
+  reth-nippy-jar      # zstd-sys (direct dependency)
+  reth-node-types     # zstd-sys via reth-codecs -> reth-zstd-compressors
+  reth-rpc-server-types # secp256k1-sys via reth-network-api -> enr
+  reth-trie-db        # zstd-sys via reth-codecs -> reth-zstd-compressors
 )
 
 any_failed=0
diff --git a/.github/scripts/configure-git-token-user.sh b/.github/scripts/configure-git-token-user.sh
new file mode 100755
index 00000000000..59bde1afa01
--- /dev/null
+++ b/.github/scripts/configure-git-token-user.sh
@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+#
+# Configures a git repository to commit as the GitHub user associated with a token.
+#
+# Usage: configure-git-token-user.sh <repo-dir> <github-token>
+set -euo pipefail
+
+REPO_DIR="${1:?repo dir is required}"
+GITHUB_TOKEN="${2:?github token is required}"
+
+GITHUB_USER=$(curl -fsSL \
+  -H "Authorization: Bearer ${GITHUB_TOKEN}" \
+  -H "Accept: application/vnd.github+json" \
+  -H "X-GitHub-Api-Version: 2022-11-28" \
+  https://api.github.com/user)
+GIT_USER_NAME=$(jq -r '.login' <<< "${GITHUB_USER}")
+GIT_USER_ID=$(jq -r '.id' <<< "${GITHUB_USER}")
+
+git -C "${REPO_DIR}" config user.name "${GIT_USER_NAME}"
+git -C "${REPO_DIR}" config user.email "${GIT_USER_ID}+${GIT_USER_NAME}@users.noreply.github.com"
diff --git a/.github/scripts/hive/build_simulators.sh b/.github/scripts/hive/build_simulators.sh
index 8024a192be4..c87b3be58d9 100755
--- a/.github/scripts/hive/build_simulators.sh
+++ b/.github/scripts/hive/build_simulators.sh
@@ -5,12 +5,12 @@ 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"
+        eels_fixtures="https://github.com/ethereum/execution-spec-tests/releases/download/bal@v7.1.1/fixtures_bal.tar.gz"
+        eels_branch="devnets/bal/7"
         ;;
     osaka)
         eels_fixtures="https://github.com/ethereum/execution-spec-tests/releases/download/v5.3.0/fixtures_develop.tar.gz"
-        eels_branch="forks/osaka"
+        eels_branch="mainnet"
         ;;
     *)
         echo "unknown hive fixture variant: ${fixture_variant}"
diff --git a/.github/scripts/hive/expected_failures.yaml b/.github/scripts/hive/expected_failures.yaml
index 62788f24c1f..773da3d7d5a 100644
--- a/.github/scripts/hive/expected_failures.yaml
+++ b/.github/scripts/hive/expected_failures.yaml
@@ -2,7 +2,9 @@
 rpc-compat:
   - debug_getRawBlock/get-invalid-number (reth)
   - debug_getRawTransaction/get-invalid-hash (reth)
-
+  - debug_getRawReceipts/get-invalid-number (reth)
+  - debug_getRawHeader/get-invalid-number (reth)
+  - debug_getRawReceipts/get-block-n (reth)
   - eth_getStorageAt/get-storage-invalid-key-too-large (reth)
   - eth_getStorageAt/get-storage-invalid-key (reth)
   - eth_getTransactionReceipt/get-legacy-contract (reth)
diff --git a/.github/scripts/hive/print_client_logs.sh b/.github/scripts/hive/print_client_logs.sh
new file mode 100755
index 00000000000..5fe5c7229e2
--- /dev/null
+++ b/.github/scripts/hive/print_client_logs.sh
@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+shopt -s nullglob
+
+truncate_lines() {
+    cut -c 1-2000
+}
+
+for log in hivetests/workspace/logs/reth/client-*.log; do
+    lines="$(wc -l < "$log")"
+    bytes="$(wc -c < "$log")"
+
+    echo "::group::$log"
+    echo "lines=${lines} bytes=${bytes}"
+
+    echo "first 200 lines:"
+    sed -n '1,200p' "$log" | truncate_lines
+
+    echo "error context:"
+    rg -n -i -C 20 \
+        'panic|fatal|error|warn|oom|out of memory|killed|no route to host|connection refused|cannot allocate' \
+        "$log" | head -n 2000 | truncate_lines || true
+
+    echo "last 300 lines:"
+    tail -n 300 "$log" | truncate_lines
+
+    echo "::endgroup::"
+done
diff --git a/.github/workflows/bench-benchmarkoor.yml b/.github/workflows/bench-benchmarkoor.yml
new file mode 100644
index 00000000000..a6e84cfabbb
--- /dev/null
+++ b/.github/workflows/bench-benchmarkoor.yml
@@ -0,0 +1,719 @@
+# Runs benchmarkoor-replay fixtures against a PR/branch and compares them with main.
+#
+# Unlike the normal reth benchmark workflow, this prepares a post gas-bump/funding
+# baseline with benchmarkoor-replay. Each selected test then resets to that
+# baseline, runs setup outside the measured window, restarts Reth, drops Linux
+# page cache, and measures only the testing fixture replay.
+
+on:
+  workflow_dispatch:
+    inputs:
+      pr:
+        description: "PR number to benchmark"
+        required: false
+        default: ""
+        type: string
+      feature:
+        description: "Feature git ref (default: dispatched ref, ignored when pr is set)"
+        required: false
+        default: ""
+        type: string
+      baseline:
+        description: "Baseline git ref"
+        required: false
+        default: "main"
+        type: string
+      download_ref:
+        description: "Reth git ref used only for snapshot download"
+        required: false
+        default: "pull/24027/head"
+        type: string
+      suite:
+        description: "benchmarkoor-replay suite"
+        required: false
+        default: "perf-devnet-3/24358000"
+        type: string
+      context:
+        description: "benchmarkoor context"
+        required: false
+        default: "repricing"
+        type: string
+      fork:
+        description: "benchmarkoor fork"
+        required: false
+        default: "amsterdam"
+        type: string
+      test_type:
+        description: "benchmarkoor test type"
+        required: false
+        default: "stateful"
+        type: string
+      snapshot:
+        description: "Snapshot manifest URL, MinIO manifest path, or MinIO prefix"
+        required: false
+        default: "minio/reth-snapshots/perfnet-24358000-full/"
+        type: string
+      fixture_url:
+        description: "Fixture archive URL/path override (empty uses suite default)"
+        required: false
+        default: ""
+        type: string
+      exact_test:
+        description: "Exact benchmarkoor test filename"
+        required: false
+        default: ""
+        type: string
+      contains:
+        description: "Substring test selector"
+        required: false
+        default: "test_account_access"
+        type: string
+      pattern:
+        description: "Regex test selector"
+        required: false
+        default: ""
+        type: string
+      opcode:
+        description: "Opcode selector"
+        required: false
+        default: ""
+        type: string
+      gas_bucket:
+        description: "Gas bucket selector, for example 210M"
+        required: false
+        default: ""
+        type: string
+      cache_strategy:
+        description: "Cache strategy selector, for example NO_CACHE"
+        required: false
+        default: ""
+        type: string
+      account_mode:
+        description: "Account mode selector, for example EXISTING_EOA"
+        required: false
+        default: ""
+        type: string
+      limit:
+        description: "Maximum matching tests to run (0 = all)"
+        required: false
+        default: "20"
+        type: string
+      repetitions:
+        description: "Runs per side: 1 or 2"
+        required: false
+        default: "1"
+        type: choice
+        options:
+          - "1"
+          - "2"
+      cores:
+        description: "Limit reth to N CPU cores (0 = all available)"
+        required: false
+        default: "6"
+        type: string
+      reset_strategy:
+        description: "Reset state between tests"
+        required: false
+        default: "schelk"
+        type: choice
+        options:
+          - "schelk"
+          - "unwind"
+      baseline_args:
+        description: "Extra CLI args for the baseline reth node"
+        required: false
+        default: ""
+        type: string
+      feature_args:
+        description: "Extra CLI args for the feature reth node"
+        required: false
+        default: ""
+        type: string
+      benchmarkoor_replay_path:
+        description: "Optional local benchmarkoor-replay checkout on the runner"
+        required: false
+        default: "~/projects/benchmarkoor-replay"
+        type: string
+      metadata_root:
+        description: "Optional local benchmarkoor-tests config root"
+        required: false
+        default: "~/projects/benchmarkoor-tests/configs"
+        type: string
+
+env:
+  CARGO_TERM_COLOR: always
+  RUSTC_WRAPPER: "sccache"
+
+name: bench-benchmarkoor
+
+permissions: {}
+
+jobs:
+  benchmarkoor:
+    name: bench-benchmarkoor
+    runs-on: [self-hosted, Linux, X64, available]
+    permissions:
+      contents: read
+    timeout-minutes: 180
+    env:
+      SCHELK_MOUNT: /reth-bench
+      RETH_SCOPE: reth-benchmarkoor.scope
+      BENCH_WORK_DIR: ${{ github.workspace }}/bench-work
+      BENCH_CORES: ${{ inputs.cores || '6' }}
+      BENCH_MEMORY_MAX: "32G"
+      BENCH_RESET_STRATEGY: ${{ inputs.reset_strategy || 'schelk' }}
+      BENCH_BASELINE_ARGS: ${{ inputs.baseline_args || '' }}
+      BENCH_FEATURE_ARGS: ${{ inputs.feature_args || '' }}
+      BENCH_METRICS_ADDR: "127.0.0.1:9001"
+      BENCHMARKOOR_SUITE: ${{ inputs.suite || 'perf-devnet-3/24358000' }}
+      BENCHMARKOOR_CONTEXT: ${{ inputs.context || 'repricing' }}
+      BENCHMARKOOR_FORK: ${{ inputs.fork || 'amsterdam' }}
+      BENCHMARKOOR_TEST_TYPE: ${{ inputs.test_type || 'stateful' }}
+      BENCHMARKOOR_METADATA_ROOT: ${{ inputs.metadata_root || '~/projects/benchmarkoor-tests/configs' }}
+      BENCHMARKOOR_SNAPSHOT: ${{ inputs.snapshot || 'minio/reth-snapshots/perfnet-24358000-full/' }}
+      BENCHMARKOOR_SNAPSHOT_MC_ROOT: "minio"
+      BENCHMARKOOR_REPLAY_PATH: ${{ inputs.benchmarkoor_replay_path || '~/projects/benchmarkoor-replay' }}
+      BENCHMARKOOR_CACHE: ${{ github.workspace }}/bench-work/benchmarkoor-cache
+    steps:
+      - name: Clean up previous bench-work
+        run: sudo rm -rf "$BENCH_WORK_DIR" 2>/dev/null || true
+
+      - name: Print runner OS and kernel
+        run: |
+          set -euo pipefail
+          echo "::group::Runner OS"
+          uname -a
+          echo "kernel=$(uname -r)"
+          if [ -f /etc/os-release ]; then
+            cat /etc/os-release
+          fi
+          lsb_release -a 2>/dev/null || true
+          echo "::endgroup::"
+
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+          submodules: true
+          fetch-depth: 0
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - uses: mozilla-actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9
+        continue-on-error: true
+
+      - name: Install dependencies
+        env:
+          DEREK_TOKEN: ${{ secrets.DEREK_TOKEN }}
+        run: |
+          set -euo pipefail
+          mkdir -p "$HOME/.local/bin"
+
+          sudo apt-get update -qq
+          sudo apt-get install -y --no-install-recommends \
+            python3 make jq zstd curl dmsetup \
+            linux-tools-"$(uname -r)" || \
+            sudo apt-get install -y --no-install-recommends linux-tools-generic
+
+          if ! command -v mc &>/dev/null; then
+            curl -sSfL https://dl.min.io/client/mc/release/linux-amd64/mc -o "$HOME/.local/bin/mc"
+            chmod +x "$HOME/.local/bin/mc"
+          fi
+
+          if [ -n "${DEREK_TOKEN:-}" ]; then
+            git config --global url."https://x-access-token:${DEREK_TOKEN}@github.com/".insteadOf "https://github.com/"
+          fi
+
+          if ! command -v era_invalidate &>/dev/null; then
+            git clone --depth 1 https://github.com/jthornber/thin-provisioning-tools /tmp/tpt
+            sudo make -C /tmp/tpt install
+            rm -rf /tmp/tpt
+          fi
+
+          if ! sudo sh -c 'command -v schelk' &>/dev/null; then
+            cargo install --git https://github.com/tempoxyz/schelk --locked
+            sudo install "$HOME/.cargo/bin/schelk" /usr/local/bin/
+          fi
+
+      - name: Check dependencies
+        run: |
+          set -euo pipefail
+          export PATH="$HOME/.local/bin:$HOME/.cargo/bin:$PATH"
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
+          missing=()
+          for cmd in mc schelk cpupower taskset stdbuf python3 curl make jq cargo; do
+            command -v "$cmd" &>/dev/null || missing+=("$cmd")
+          done
+          if [ ${#missing[@]} -gt 0 ]; then
+            echo "::error::Missing required tools: ${missing[*]}"
+            exit 1
+          fi
+
+      - name: Install benchmarkoor-replay
+        env:
+          BENCHMARKOOR_REPLAY_DEPLOY_KEY: ${{ secrets.BENCHMARKOOR_REPLAY_DEPLOY_KEY }}
+          BENCHMARKOOR_REPLAY_TOKEN: ${{ secrets.BENCHMARKOOR_REPLAY_TOKEN }}
+          GH_PROJECT_TOKEN: ${{ secrets.GH_PROJECT_TOKEN }}
+          DEREK_TOKEN: ${{ secrets.DEREK_TOKEN }}
+        run: |
+          set -euo pipefail
+
+          replay_path="$BENCHMARKOOR_REPLAY_PATH"
+          case "$replay_path" in
+            "~") replay_path="$HOME" ;;
+            "~/"*) replay_path="$HOME/${replay_path#"~/"}" ;;
+          esac
+          if [ -d "$replay_path" ]; then
+            if git -C "$replay_path" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+              git -C "$replay_path" fetch origin main --quiet
+              git -C "$replay_path" checkout --force origin/main
+            fi
+          else
+            replay_path="${RUNNER_TEMP:-/tmp}/benchmarkoor-replay"
+            rm -rf "$replay_path"
+
+            if [ -n "${BENCHMARKOOR_REPLAY_DEPLOY_KEY:-}" ]; then
+              mkdir -p "$HOME/.ssh"
+              printf '%s\n' "$BENCHMARKOOR_REPLAY_DEPLOY_KEY" > "$HOME/.ssh/benchmarkoor_replay_deploy_key"
+              chmod 600 "$HOME/.ssh/benchmarkoor_replay_deploy_key"
+              ssh-keyscan github.com >> "$HOME/.ssh/known_hosts" 2>/dev/null || true
+              GIT_SSH_COMMAND="ssh -i $HOME/.ssh/benchmarkoor_replay_deploy_key -o IdentitiesOnly=yes -o StrictHostKeyChecking=accept-new" \
+                git clone --depth 1 git@github.com:tempoxyz/benchmarkoor-replay.git "$replay_path" || rm -rf "$replay_path"
+            fi
+
+            auth_token="${BENCHMARKOOR_REPLAY_TOKEN:-${GH_PROJECT_TOKEN:-${DEREK_TOKEN:-}}}"
+            if [ ! -d "$replay_path" ] && [ -n "$auth_token" ]; then
+              git clone --depth 1 "https://x-access-token:${auth_token}@github.com/tempoxyz/benchmarkoor-replay" "$replay_path" || rm -rf "$replay_path"
+            fi
+
+            if [ ! -d "$replay_path" ]; then
+              rm -rf "$replay_path"
+              GIT_SSH_COMMAND="ssh -o BatchMode=yes -o StrictHostKeyChecking=accept-new" \
+                git clone --depth 1 git@github.com:tempoxyz/benchmarkoor-replay.git "$replay_path" || {
+                  echo "::error::benchmarkoor-replay was not found at ${BENCHMARKOOR_REPLAY_PATH} and could not be cloned. Install it under ~/projects/benchmarkoor-replay on the runner, grant GH_PROJECT_TOKEN/DEREK_TOKEN read access to tempoxyz/benchmarkoor-replay, or add BENCHMARKOOR_REPLAY_DEPLOY_KEY/BENCHMARKOOR_REPLAY_TOKEN."
+                  exit 1
+                }
+            fi
+          fi
+
+          cargo install --path "$replay_path" --locked --force
+          BENCHMARKOOR_BIN="$(command -v benchmarkoor-replay)"
+          "$BENCHMARKOOR_BIN" run-many --help | grep -q -- 'setup-then-testing'
+          echo "BENCHMARKOOR_BIN=${BENCHMARKOOR_BIN}" >> "$GITHUB_ENV"
+
+      - name: Prepare benchmarkoor metadata
+        run: |
+          set -euo pipefail
+
+          metadata_root="$BENCHMARKOOR_METADATA_ROOT"
+          case "$metadata_root" in
+            "~") metadata_root="$HOME" ;;
+            "~/"*) metadata_root="$HOME/${metadata_root#"~/"}" ;;
+          esac
+          if [ ! -d "$metadata_root" ]; then
+            tests_path="$BENCH_WORK_DIR/benchmarkoor-tests"
+            rm -rf "$tests_path"
+            git clone --depth 1 https://github.com/ethpandaops/benchmarkoor-tests "$tests_path"
+            metadata_root="$tests_path/configs"
+          fi
+
+          if [ ! -d "$metadata_root" ]; then
+            echo "::error::benchmarkoor metadata root not found at ${metadata_root}"
+            exit 1
+          fi
+
+          echo "BENCHMARKOOR_METADATA_ROOT=${metadata_root}" >> "$GITHUB_ENV"
+
+      - name: Resolve refs
+        id: refs
+        env:
+          INPUT_PR: ${{ inputs.pr || '' }}
+          INPUT_FEATURE: ${{ inputs.feature || '' }}
+          INPUT_BASELINE: ${{ inputs.baseline || 'main' }}
+          INPUT_DOWNLOAD: ${{ inputs.download_ref || 'pull/24027/head' }}
+        run: |
+          set -euo pipefail
+          git fetch origin main --quiet
+
+          resolve_ref() {
+            local ref="$1"
+            if [[ "$ref" =~ ^pull/[0-9]+/(head|merge)$ ]]; then
+              git fetch origin "$ref" --quiet
+              git rev-parse --verify "FETCH_HEAD^{commit}"
+              return 0
+            fi
+            git fetch origin "$ref" --quiet 2>/dev/null || true
+            if git rev-parse --verify --quiet "${ref}^{commit}" >/dev/null; then
+              git rev-parse --verify "${ref}^{commit}"
+            else
+              git rev-parse --verify "origin/${ref}^{commit}"
+            fi
+          }
+
+          if [ -n "$INPUT_PR" ]; then
+            git fetch origin "pull/${INPUT_PR}/head:refs/remotes/pr/${INPUT_PR}" --quiet
+            FEATURE_REF="$(git rev-parse "refs/remotes/pr/${INPUT_PR}")"
+            FEATURE_NAME="pr-${INPUT_PR}"
+          elif [ -n "$INPUT_FEATURE" ]; then
+            FEATURE_REF="$(resolve_ref "$INPUT_FEATURE")"
+            FEATURE_NAME="$INPUT_FEATURE"
+          else
+            FEATURE_REF="$(git rev-parse HEAD)"
+            FEATURE_NAME="${GITHUB_REF_NAME}"
+          fi
+
+          BASELINE_NAME="${INPUT_BASELINE:-main}"
+          BASELINE_REF="$(resolve_ref "$BASELINE_NAME")"
+          DOWNLOAD_NAME="${INPUT_DOWNLOAD:-pull/24027/head}"
+          DOWNLOAD_REF="$(resolve_ref "$DOWNLOAD_NAME")"
+
+          {
+            printf 'feature-ref=%s\n' "$FEATURE_REF"
+            printf 'feature-name=%s\n' "$FEATURE_NAME"
+            printf 'baseline-ref=%s\n' "$BASELINE_REF"
+            printf 'baseline-name=%s\n' "$BASELINE_NAME"
+            printf 'download-ref=%s\n' "$DOWNLOAD_REF"
+            printf 'download-name=%s\n' "$DOWNLOAD_NAME"
+          } >> "$GITHUB_OUTPUT"
+
+      - name: Prepare source dirs
+        run: |
+          set -euo pipefail
+          prepare_source_dir() {
+            local dir="$1"
+            local ref="$2"
+            local fetch_ref="${3:-}"
+
+            if [ -d "$dir" ]; then
+              git -C "$dir" reset --hard HEAD
+              git -C "$dir" clean -fdx
+            else
+              git clone . "$dir"
+            fi
+            if [ -n "$fetch_ref" ]; then
+              git -C "$dir" fetch origin "$fetch_ref" --quiet || true
+            else
+              git -C "$dir" fetch origin "$ref" --quiet || true
+            fi
+
+            git -C "$dir" checkout --force "$ref"
+            git -C "$dir" submodule update --init --recursive
+          }
+
+          prepare_source_dir ../reth-baseline "${{ steps.refs.outputs.baseline-ref }}"
+          prepare_source_dir ../reth-feature "${{ steps.refs.outputs.feature-ref }}"
+          prepare_source_dir ../reth-download "${{ steps.refs.outputs.download-ref }}" "${{ steps.refs.outputs.download-name }}"
+
+      - name: Build binaries
+        id: build
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          DEREK_PAT: ${{ secrets.DEREK_PAT }}
+          DEREK_TOKEN: ${{ secrets.DEREK_TOKEN }}
+          BENCH_REPO: ${{ github.repository }}
+          BENCH_BIG_BLOCKS: "false"
+        run: |
+          set -euo pipefail
+          BASELINE_DIR="$(cd ../reth-baseline && pwd)"
+          FEATURE_DIR="$(cd ../reth-feature && pwd)"
+          DOWNLOAD_DIR="$(cd ../reth-download && pwd)"
+
+          .github/scripts/bench-txgen-build.sh baseline "$BASELINE_DIR" "${{ steps.refs.outputs.baseline-ref }}" &
+          PID_BASELINE=$!
+          .github/scripts/bench-txgen-build.sh feature "$FEATURE_DIR" "${{ steps.refs.outputs.feature-ref }}" &
+          PID_FEATURE=$!
+          .github/scripts/bench-txgen-build.sh baseline "$DOWNLOAD_DIR" "${{ steps.refs.outputs.download-ref }}" &
+          PID_DOWNLOAD=$!
+
+          FAIL=0
+          wait $PID_BASELINE || FAIL=1
+          wait $PID_FEATURE || FAIL=1
+          wait $PID_DOWNLOAD || FAIL=1
+          if [ $FAIL -ne 0 ]; then
+            echo "::error::One or more build tasks failed"
+            exit 1
+          fi
+
+      - name: Download fixtures
+        env:
+          FIXTURE_URL: ${{ inputs.fixture_url || '' }}
+        run: |
+          set -euo pipefail
+          args=(
+            --suite "$BENCHMARKOOR_SUITE"
+            --context "$BENCHMARKOOR_CONTEXT"
+            --fork "$BENCHMARKOOR_FORK"
+            --test-type "$BENCHMARKOOR_TEST_TYPE"
+            --metadata-root "$BENCHMARKOOR_METADATA_ROOT"
+            --cache-dir "$BENCHMARKOOR_CACHE"
+            fixtures download
+          )
+          if [ -n "$FIXTURE_URL" ]; then
+            args+=(--url "$FIXTURE_URL")
+          fi
+          "$BENCHMARKOOR_BIN" "${args[@]}"
+
+      - name: Resolve test set
+        id: tests
+        env:
+          EXACT_TEST: ${{ inputs.exact_test || '' }}
+          CONTAINS: ${{ inputs.contains || 'test_account_access' }}
+          PATTERN: ${{ inputs.pattern || '' }}
+          OPCODE: ${{ inputs.opcode || '' }}
+          GAS_BUCKET: ${{ inputs.gas_bucket || '' }}
+          CACHE_STRATEGY: ${{ inputs.cache_strategy || '' }}
+          ACCOUNT_MODE: ${{ inputs.account_mode || '' }}
+          LIMIT: ${{ inputs.limit || '20' }}
+        run: |
+          set -euo pipefail
+          if ! [[ "$LIMIT" =~ ^[0-9]+$ ]]; then
+            echo "::error::limit must be a non-negative integer"
+            exit 1
+          fi
+
+          INDEX="$(find "$BENCHMARKOOR_CACHE/fixtures" -name index.json -print -quit)"
+          if [ -z "$INDEX" ]; then
+            echo "::error::benchmarkoor fixture index not found"
+            exit 1
+          fi
+          TESTS_FILE="$BENCH_WORK_DIR/tests.jsonl"
+          mkdir -p "$BENCH_WORK_DIR"
+
+          jq -c \
+            --arg exact "$EXACT_TEST" \
+            --arg contains "$CONTAINS" \
+            --arg pattern "$PATTERN" \
+            --arg opcode "$OPCODE" \
+            --arg gas_bucket "$GAS_BUCKET" \
+            --arg cache_strategy "$CACHE_STRATEGY" \
+            --arg account_mode "$ACCOUNT_MODE" \
+            --argjson limit "$LIMIT" '
+            def searchable:
+              [.name, (.setup.rel_path // ""), (.testing.rel_path // ""), (.cleanup.rel_path // "")]
+              | join(" ");
+            def matches_exact($v):
+              .name == $v or (.setup.name // "") == $v or (.setup.rel_path // "") == $v or
+              (.testing.name // "") == $v or (.testing.rel_path // "") == $v or
+              (.cleanup.name // "") == $v or (.cleanup.rel_path // "") == $v;
+            def norm: ascii_downcase;
+            [
+              .tests[]
+              | select(.setup != null and .testing != null)
+              | select($exact == "" or matches_exact($exact))
+              | select($contains == "" or (searchable | contains($contains)))
+              | select($pattern == "" or (searchable | test($pattern)))
+              | select($opcode == "" or ((.metadata.opcode // "" | norm) == ($opcode | norm)))
+              | select($gas_bucket == "" or ((.metadata.gas_bucket // "" | norm) == ($gas_bucket | norm)))
+              | select($cache_strategy == "" or ((.metadata.cache_strategy // "" | norm) == ($cache_strategy | norm)))
+              | select($account_mode == "" or ((.metadata.account_mode // "" | norm) == ($account_mode | norm)))
+            ] | if $limit > 0 then .[: $limit] else . end
+            | .[]
+            | {name, gas_bucket: .metadata.gas_bucket, opcode: .metadata.opcode, cache_strategy: .metadata.cache_strategy, account_mode: .metadata.account_mode}
+            ' "$INDEX" > "$TESTS_FILE"
+
+          COUNT="$(wc -l < "$TESTS_FILE" | tr -d ' ')"
+          if [ "$COUNT" -eq 0 ]; then
+            echo "::error::No benchmarkoor tests matched the requested selectors"
+            exit 1
+          fi
+          echo "Selected ${COUNT} test(s):"
+          jq -r '.name' "$TESTS_FILE"
+
+          {
+            echo "index=$INDEX"
+            echo "tests-file=$TESTS_FILE"
+            echo "count=$COUNT"
+          } >> "$GITHUB_OUTPUT"
+          echo "BENCHMARKOOR_INDEX=$INDEX" >> "$GITHUB_ENV"
+          echo "BENCHMARKOOR_TESTS_FILE=$TESTS_FILE" >> "$GITHUB_ENV"
+
+      - name: Check block discard support
+        run: |
+          set -euo pipefail
+          echo "::group::Block discard capabilities"
+          lsblk -D -o NAME,TYPE,SIZE,DISC-GRAN,DISC-MAX,DISC-ZERO,MOUNTPOINTS || true
+          echo
+
+          if sudo test -f /var/lib/schelk/state.json; then
+            echo "schelk state:"
+            sudo jq . /var/lib/schelk/state.json || true
+            echo
+          fi
+
+          found=0
+          for queue in /sys/block/{ram*,brd*,loop*,nvme*,dm-*}/queue; do
+            [ -d "$queue" ] || continue
+            found=1
+            dev="$(basename "$(dirname "$queue")")"
+            max="$(cat "$queue/discard_max_bytes" 2>/dev/null || printf 'missing')"
+            gran="$(cat "$queue/discard_granularity" 2>/dev/null || printf 'missing')"
+            zeroes="$(cat "$queue/discard_zeroes_data" 2>/dev/null || printf 'missing')"
+            printf '%s: discard_max_bytes=%s discard_granularity=%s discard_zeroes_data=%s\n' \
+              "$dev" "$max" "$gran" "$zeroes"
+            if [[ "$dev" == ram* || "$dev" == brd* ]]; then
+              if [[ "$max" =~ ^[0-9]+$ ]] && [ "$max" -gt 0 ]; then
+                echo "::notice::/dev/${dev} advertises discard support with discard_max_bytes=${max}"
+              else
+                echo "::notice::/dev/${dev} does not advertise discard support; discard_max_bytes=${max}"
+              fi
+            fi
+          done
+
+          if [ "$found" -eq 0 ]; then
+            echo "::notice::No matching sysfs block queues found for discard diagnostics"
+          fi
+          echo "::endgroup::"
+
+      - name: Import snapshot into schelk
+        id: snapshot
+        run: |
+          set -euo pipefail
+          DOWNLOAD_RETH_BINARY="$(pwd)/../reth-download/target/profiling/reth"
+          echo "Using download reth from ${{ steps.refs.outputs.download-name }} (${{ steps.refs.outputs.download-ref }})"
+          "$DOWNLOAD_RETH_BINARY" --version
+          BENCH_RETH_BINARY="$DOWNLOAD_RETH_BINARY" \
+            .github/scripts/bench-benchmarkoor-snapshot.sh
+
+      - name: System setup
+        run: |
+          set -euo pipefail
+          echo passive | sudo tee /sys/devices/system/cpu/amd_pstate/status 2>/dev/null || true
+          sudo cpupower frequency-set -g performance || true
+          sudo swapoff -a || true
+          echo 0 | sudo tee /proc/sys/kernel/randomize_va_space || true
+          for cpu in /sys/devices/system/cpu/cpu*/topology/thread_siblings_list; do
+            first=$(cut -d, -f1 < "$cpu" | cut -d- -f1)
+            current=$(echo "$cpu" | grep -o 'cpu[0-9]*' | grep -o '[0-9]*')
+            if [ "$current" != "$first" ]; then
+              echo 0 | sudo tee "/sys/devices/system/cpu/cpu${current}/online" || true
+            fi
+          done
+          for p in /sys/kernel/mm/transparent_hugepage /sys/kernel/mm/transparent_hugepages; do
+            [ -d "$p" ] && echo never | sudo tee "$p/enabled" && echo never | sudo tee "$p/defrag" && break
+          done || true
+          sudo pkill -f '^bench-cpu-dma-latency' 2>/dev/null || true
+          sudo bash -c 'exec 3<>/dev/cpu_dma_latency; printf "\0\0\0\0" >&3; exec -a bench-cpu-dma-latency sleep infinity' &
+          echo "BENCH_CPU_DMA_LATENCY_PID=$!" >> "$GITHUB_ENV"
+          for irq in /proc/irq/*/smp_affinity_list; do
+            echo 0 | sudo tee "$irq" 2>/dev/null || true
+          done
+          sudo systemctl stop \
+            irqbalance cron atd unattended-upgrades snapd \
+            prometheus-node-exporter-apt.timer prometheus-node-exporter-apt.service \
+            prometheus-node-exporter-nvme.timer prometheus-node-exporter-nvme.service \
+            prometheus-node-exporter-ipmitool-sensor.timer prometheus-node-exporter-ipmitool-sensor.service \
+            sysstat-collect.timer sysstat-collect.service \
+            sysstat-summary.timer sysstat-summary.service \
+            2>/dev/null || true
+          uname -r
+          lscpu | grep -E 'Model name|CPU\(s\)|MHz|NUMA'
+          free -h
+
+      - name: Checkpoint after gas bump and funding
+        run: |
+          set -euo pipefail
+          taskset -c 0 .github/scripts/bench-benchmarkoor-run.sh \
+            prepare \
+            "$(pwd)/../reth-feature/target/profiling/reth" \
+            "$BENCH_WORK_DIR/prerun"
+
+      - name: Run benchmarkoor comparison
+        env:
+          BENCHMARKOOR_REPETITIONS: ${{ inputs.repetitions || '1' }}
+        run: |
+          set -euo pipefail
+          BASELINE_BIN="$(pwd)/../reth-baseline/target/profiling/reth"
+          FEATURE_BIN="$(pwd)/../reth-feature/target/profiling/reth"
+
+          if [ "$BENCHMARKOOR_REPETITIONS" = "2" ]; then
+            RUNS=(
+              "feature-1:$FEATURE_BIN"
+              "baseline-1:$BASELINE_BIN"
+              "baseline-2:$BASELINE_BIN"
+              "feature-2:$FEATURE_BIN"
+            )
+          else
+            RUNS=(
+              "baseline-1:$BASELINE_BIN"
+              "feature-1:$FEATURE_BIN"
+            )
+          fi
+
+          for item in "${RUNS[@]}"; do
+            label="${item%%:*}"
+            binary="${item#*:}"
+            taskset -c 0 .github/scripts/bench-benchmarkoor-run.sh \
+              run "$label" "$binary" "$BENCH_WORK_DIR/$label" "$BENCHMARKOOR_TESTS_FILE"
+          done
+
+      - name: Parse results
+        id: results
+        if: success()
+        run: |
+          set -euo pipefail
+          RESULTS="$BENCH_WORK_DIR/results.jsonl"
+          TMP_RESULTS="$BENCH_WORK_DIR/results.merged.jsonl"
+          rm -f "$RESULTS" "$TMP_RESULTS"
+          mapfile -d '' RESULT_FILES < <(find "$BENCH_WORK_DIR" -path '*/results.jsonl' -print0)
+          if [ "${#RESULT_FILES[@]}" -eq 0 ]; then
+            echo "::error::No per-run benchmarkoor results found"
+            exit 1
+          fi
+          cat "${RESULT_FILES[@]}" > "$TMP_RESULTS"
+          mv "$TMP_RESULTS" "$RESULTS"
+          python3 .github/scripts/bench-benchmarkoor-summary.py \
+            --results "$RESULTS" \
+            --output-json "$BENCH_WORK_DIR/summary.json" \
+            --output-markdown "$BENCH_WORK_DIR/summary.md" \
+            --repo "${{ github.repository }}" \
+            --baseline-name "${{ steps.refs.outputs.baseline-name }}" \
+            --baseline-ref "${{ steps.refs.outputs.baseline-ref }}" \
+            --feature-name "${{ steps.refs.outputs.feature-name }}" \
+            --feature-ref "${{ steps.refs.outputs.feature-ref }}"
+
+      - name: Write job summary
+        if: success()
+        run: cat "$BENCH_WORK_DIR/summary.md" >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Scan logs for errors
+        if: "!cancelled()"
+        run: |
+          set -euo pipefail
+          ERRORS_FILE="$BENCH_WORK_DIR/errors.md"
+          found=false
+          while IFS= read -r -d '' log; do
+            panics=$(grep -c -E 'panicked at' "$log" || true)
+            errors=$(grep -c ' ERROR ' "$log" || true)
+            if [ "$panics" -gt 0 ] || [ "$errors" -gt 0 ]; then
+              if [ "$found" = false ]; then
+                printf '### Node Errors\n\n' >> "$ERRORS_FILE"
+                found=true
+              fi
+              printf '<details><summary><b>%s</b>: %d panic(s), %d error(s)</summary>\n\n' "$log" "$panics" "$errors" >> "$ERRORS_FILE"
+              grep -E 'panicked at| ERROR ' "$log" | head -30 >> "$ERRORS_FILE" || true
+              printf '\n</details>\n\n' >> "$ERRORS_FILE"
+            fi
+          done < <(find "$BENCH_WORK_DIR" -name '*.log' -print0)
+
+      - name: Upload results
+        if: "!cancelled()"
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: benchmarkoor-results
+          path: ${{ env.BENCH_WORK_DIR }}
+
+      - name: Clean build outputs
+        if: always()
+        run: sudo rm -rf ../reth-baseline/target ../reth-feature/target "$BENCH_WORK_DIR" 2>/dev/null || true
+
+      - name: Restore system settings
+        if: always()
+        run: |
+          if [ -n "${BENCH_CPU_DMA_LATENCY_PID:-}" ]; then
+            sudo kill "$BENCH_CPU_DMA_LATENCY_PID" 2>/dev/null || true
+          fi
+          sudo pkill -f '^bench-cpu-dma-latency' 2>/dev/null || true
+          sudo systemctl stop "$RETH_SCOPE" 2>/dev/null || true
+          sudo systemctl reset-failed "$RETH_SCOPE" 2>/dev/null || true
+          sudo schelk recover -y --kill || true
+          sudo systemctl start irqbalance cron atd 2>/dev/null || true
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 3996a18e6c0..489a3c83a43 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -47,6 +47,16 @@ on:
           - nightly
           - hourly
           - release
+      blocks:
+        description: "Number of blocks to benchmark"
+        required: false
+        default: "2000"
+        type: string
+      warmup:
+        description: "Number of warmup blocks (default: one-quarter of blocks)"
+        required: false
+        default: ""
+        type: string
 
 env:
   CARGO_TERM_COLOR: always
@@ -76,6 +86,8 @@ jobs:
       nightly-created: ${{ steps.refs.outputs.nightly-created }}
       long-running: ${{ steps.refs.outputs.long-running }}
       release-tag: ${{ steps.refs.outputs.release-tag }}
+      blocks: ${{ steps.bench-config.outputs.blocks }}
+      warmup: ${{ steps.bench-config.outputs.warmup }}
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
@@ -104,6 +116,30 @@ jobs:
           echo "mode=$MODE" >> "$GITHUB_OUTPUT"
           echo "Detected mode: $MODE"
 
+      - name: Resolve benchmark config
+        id: bench-config
+        env:
+          INPUT_BLOCKS: ${{ inputs.blocks || '2000' }}
+          INPUT_WARMUP: ${{ inputs.warmup || '' }}
+        run: |
+          if ! [[ "$INPUT_BLOCKS" =~ ^[0-9]+$ ]]; then
+            echo "::error::blocks must be a non-negative integer"
+            exit 1
+          fi
+          if [ -n "$INPUT_WARMUP" ] && ! [[ "$INPUT_WARMUP" =~ ^[0-9]+$ ]]; then
+            echo "::error::warmup must be a non-negative integer"
+            exit 1
+          fi
+
+          if [ -z "$INPUT_WARMUP" ]; then
+            INPUT_WARMUP=$(( INPUT_BLOCKS / 4 ))
+          fi
+
+          {
+            echo "blocks=$INPUT_BLOCKS"
+            echo "warmup=$INPUT_WARMUP"
+          } >> "$GITHUB_OUTPUT"
+
       - name: Resolve refs
         id: refs
         env:
@@ -254,28 +290,38 @@ jobs:
       actions: read
     timeout-minutes: 120
     env:
-      BENCH_RPC_URL: https://ethereum.reth.rs/rpc
+      BENCH_RPC_URL: http://ethereum-mainnet-stable-reth-greedy-goose:8545
       SCHELK_MOUNT: /reth-bench
       RETH_SCOPE: reth-bench.scope
       BENCH_WORK_DIR: ${{ github.workspace }}/bench-work
       BENCH_PR: ""
       BENCH_MODE: ${{ needs.resolve-refs.outputs.mode }}
       BENCH_ACTOR: "${{ needs.resolve-refs.outputs.mode }}-regression"
-      BENCH_BLOCKS: "2000"
-      BENCH_WARMUP_BLOCKS: "500"
+      BENCH_BLOCKS: ${{ needs.resolve-refs.outputs.blocks }}
+      BENCH_WARMUP_BLOCKS: ${{ needs.resolve-refs.outputs.warmup }}
       BENCH_SAMPLY: "false"
       BENCH_CORES: "0"
       BENCH_BIG_BLOCKS: "false"
       BENCH_WAIT_TIME: ""
       BENCH_BASELINE_ARGS: ""
       BENCH_FEATURE_ARGS: ""
-      BENCH_ABBA: "true"
+      BENCH_RUN_PAIRS: "2"
       BENCH_COMMENT_ID: ""
       BENCH_SLACK: ${{ github.event_name == 'workflow_dispatch' && inputs.slack || 'always' }}
-      BENCH_METRICS_ADDR: "127.0.0.1:9100"
-      BENCH_OTLP_DISABLED: "true"
+      BENCH_TARGET_METRICS_CONFIG: .github/config/bench-metrics-targets.json
+      BENCH_NODE_BIN: reth
+      BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
+      BENCH_METRICS_ADDR: "127.0.0.1:9001"
+      BENCH_TARGET_METRICS_SCRAPE_INTERVAL_MS: "200"
+      BENCH_OTLP_DISABLED: ${{ needs.resolve-refs.outputs.mode == 'release' && 'true' || 'false' }}
+      BENCH_OTLP_TRACES_ENDPOINT: ${{ needs.resolve-refs.outputs.mode != 'release' && secrets.BENCH_OTLP_TRACES_ENDPOINT || '' }}
+      BENCH_OTLP_LOGS_ENDPOINT: ${{ needs.resolve-refs.outputs.mode != 'release' && secrets.BENCH_OTLP_LOGS_ENDPOINT || '' }}
       BASELINE_REF: ${{ needs.resolve-refs.outputs.baseline-ref }}
       FEATURE_REF: ${{ needs.resolve-refs.outputs.feature-ref }}
+      CLICKHOUSE_URL: ${{ secrets.CLICKHOUSE_URL }}
+      CLICKHOUSE_USER: ${{ secrets.CLICKHOUSE_USER }}
+      CLICKHOUSE_PASSWORD: ${{ secrets.CLICKHOUSE_PASSWORD }}
+      BENCH_VICTORIAMETRICS_URL: ${{ secrets.BENCH_VICTORIAMETRICS_URL }}
     steps:
       - name: Clean up previous bench-work
         run: sudo rm -rf "$BENCH_WORK_DIR" 2>/dev/null || true
@@ -319,6 +365,12 @@ jobs:
             linux-tools-"$(uname -r)" || \
             sudo apt-get install -y --no-install-recommends linux-tools-generic
 
+          # mc (MinIO client)
+          if ! command -v mc &>/dev/null; then
+            curl -sSfL https://dl.min.io/client/mc/release/linux-amd64/mc -o "$HOME/.local/bin/mc"
+            chmod +x "$HOME/.local/bin/mc"
+          fi
+
           # uv (Python package manager)
           if ! command -v uv &>/dev/null; then
             curl -LsSf https://astral.sh/uv/install.sh | env UV_INSTALL_DIR="$HOME/.local/bin" sh
@@ -346,7 +398,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 mc schelk cpupower taskset stdbuf python3 curl make uv jq; do
             command -v "$cmd" &>/dev/null || missing+=("$cmd")
           done
           if [ ${#missing[@]} -gt 0 ]; then
@@ -372,10 +424,6 @@ jobs:
           echo "feature-name=${BENCH_MODE}-${FEATURE_SHORT}" >> "$GITHUB_OUTPUT"
           echo "feature-ref=$FEATURE_REF" >> "$GITHUB_OUTPUT"
 
-      - name: Validate local snapshot
-        id: snapshot-check
-        run: .github/scripts/bench-reth-snapshot.sh
-
       - name: Prepare source dirs
         run: |
           prepare_source_dir() {
@@ -401,14 +449,22 @@ jobs:
         id: build
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TXGEN_DEPLOY_KEY: ${{ secrets.TXGEN_DEPLOY_KEY }}
+          TXGEN_TOKEN: ${{ secrets.TXGEN_TOKEN }}
+          GH_PROJECT_TOKEN: ${{ secrets.GH_PROJECT_TOKEN }}
+          DEREK_PAT: ${{ secrets.DEREK_PAT }}
+          DEREK_TOKEN: ${{ secrets.DEREK_TOKEN }}
           BENCH_REPO: ${{ github.repository }}
         run: |
           BASELINE_DIR="$(cd ../reth-baseline && pwd)"
           FEATURE_DIR="$(cd ../reth-feature && pwd)"
 
-          .github/scripts/bench-reth-build.sh baseline "${BASELINE_DIR}" "$BASELINE_REF" &
+          .github/scripts/bench-txgen-install.sh
+          BUILD_SCRIPT=.github/scripts/bench-txgen-build.sh
+
+          "$BUILD_SCRIPT" baseline "${BASELINE_DIR}" "$BASELINE_REF" &
           PID_BASELINE=$!
-          .github/scripts/bench-reth-build.sh feature "${FEATURE_DIR}" "$FEATURE_REF" &
+          "$BUILD_SCRIPT" feature "${FEATURE_DIR}" "$FEATURE_REF" &
           PID_FEATURE=$!
 
           FAIL=0
@@ -419,6 +475,12 @@ jobs:
             exit 1
           fi
 
+      - name: Sync snapshot
+        id: snapshot-check
+        run: |
+          BENCH_RETH_BINARY="$(pwd)/../reth-feature/target/profiling/${BENCH_NODE_BIN}" \
+            .github/scripts/bench-reth-snapshot.sh
+
       # System tuning for reproducible benchmarks
       - name: System setup
         run: |
@@ -441,14 +503,24 @@ jobs:
           for p in /sys/kernel/mm/transparent_hugepage /sys/kernel/mm/transparent_hugepages; do
             [ -d "$p" ] && echo never | sudo tee "$p/enabled" && echo never | sudo tee "$p/defrag" && break
           done || true
+          # Replace any stale PM QoS holders left behind by earlier benchmark jobs.
+          sudo pkill -f '^bench-cpu-dma-latency' 2>/dev/null || true
           # Prevent deep C-states
-          sudo sh -c 'exec 3<>/dev/cpu_dma_latency; echo -ne "\x00\x00\x00\x00" >&3; sleep infinity' &
+          sudo bash -c 'exec 3<>/dev/cpu_dma_latency; printf "\0\0\0\0" >&3; exec -a bench-cpu-dma-latency sleep infinity' &
+          echo "BENCH_CPU_DMA_LATENCY_PID=$!" >> "$GITHUB_ENV"
           # Move all IRQs to core 0
           for irq in /proc/irq/*/smp_affinity_list; do
             echo 0 | sudo tee "$irq" 2>/dev/null || true
           done
           # Stop noisy background services
-          sudo systemctl stop irqbalance cron atd unattended-upgrades snapd 2>/dev/null || true
+          sudo systemctl stop \
+            irqbalance cron atd unattended-upgrades snapd \
+            prometheus-node-exporter-apt.timer prometheus-node-exporter-apt.service \
+            prometheus-node-exporter-nvme.timer prometheus-node-exporter-nvme.service \
+            prometheus-node-exporter-ipmitool-sensor.timer prometheus-node-exporter-ipmitool-sensor.service \
+            sysstat-collect.timer sysstat-collect.service \
+            sysstat-summary.timer sysstat-summary.service \
+            2>/dev/null || true
           echo "=== Benchmark environment ==="
           uname -r
           lscpu | grep -E 'Model name|CPU\(s\)|MHz|NUMA'
@@ -465,25 +537,30 @@ jobs:
           rm -rf "$BENCH_WORK_DIR"
           mkdir -p "$BENCH_WORK_DIR"
 
-      - name: Start metrics proxy
+      - name: Initialize benchmark metrics labels
         run: |
+          if [ -n "${BENCH_VICTORIAMETRICS_URL:-}" ]; then
+            echo "::add-mask::$BENCH_VICTORIAMETRICS_URL"
+          fi
+
           BENCH_ID="${BENCH_MODE}-${{ github.run_id }}"
           BENCH_REFERENCE_EPOCH=$(date +%s)
           echo "BENCH_ID=${BENCH_ID}" >> "$GITHUB_ENV"
           echo "BENCH_REFERENCE_EPOCH=${BENCH_REFERENCE_EPOCH}" >> "$GITHUB_ENV"
 
-          LABELS_FILE="/tmp/bench-metrics-labels.json"
+          LABELS_FILE="$(mktemp "${RUNNER_TEMP:-/tmp}/bench-metrics-labels.XXXXXX")"
           echo '{}' > "$LABELS_FILE"
           echo "BENCH_LABELS_FILE=${LABELS_FILE}" >> "$GITHUB_ENV"
 
-          python3 .github/scripts/bench-metrics-proxy.py \
-            --labels "$LABELS_FILE" \
-            --upstream "http://${BENCH_METRICS_ADDR}/" \
-            --subnet 10.10.0.0/24 \
-            --port 9090 &
-          PROXY_PID=$!
-          echo "BENCH_METRICS_PROXY_PID=${PROXY_PID}" >> "$GITHUB_ENV"
-          echo "Metrics proxy started (PID $PROXY_PID)"
+      # Extract txgen payloads once so they are reused across all benchmark
+      # runs instead of re-fetching from the remote RPC for every run.
+      - name: Extract txgen payloads
+        run: |
+          PAYLOADS_DIR="$BENCH_WORK_DIR/txgen-payloads"
+          .github/scripts/bench-txgen-extract.sh \
+            "../reth-feature/target/profiling/${BENCH_NODE_BIN}" \
+            "$PAYLOADS_DIR"
+          echo "TXGEN_PAYLOADS_DIR=${PAYLOADS_DIR}" >> "$GITHUB_ENV"
 
       # Interleaved run order (B-F-F-B) to reduce systematic bias
       - name: "Run benchmark: baseline (1/2)"
@@ -492,7 +569,7 @@ jobs:
           cat > "$BENCH_LABELS_FILE" <<LABELS
           {"benchmark_run":"baseline-1","run_type":"baseline","git_ref":"${BASELINE_REF}","bench_sha":"${BASELINE_REF}","benchmark_id":"${BENCH_ID}","run_start_epoch":"$(date +%s)","reference_epoch":"${BENCH_REFERENCE_EPOCH}"}
           LABELS
-          taskset -c 0 .github/scripts/bench-reth-run.sh baseline ../reth-baseline/target/profiling/reth "$BENCH_WORK_DIR/baseline-1"
+          taskset -c 0 .github/scripts/bench-txgen-run.sh baseline "../reth-baseline/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/baseline-1"
 
       - name: "Run benchmark: feature (1/2)"
         id: run-feature-1
@@ -500,7 +577,7 @@ jobs:
           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":"$(date +%s)","reference_epoch":"${BENCH_REFERENCE_EPOCH}"}
           LABELS
-          taskset -c 0 .github/scripts/bench-reth-run.sh feature ../reth-feature/target/profiling/reth "$BENCH_WORK_DIR/feature-1"
+          taskset -c 0 .github/scripts/bench-txgen-run.sh feature "../reth-feature/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/feature-1"
 
       - name: "Run benchmark: feature (2/2)"
         id: run-feature-2
@@ -508,7 +585,7 @@ jobs:
           cat > "$BENCH_LABELS_FILE" <<LABELS
           {"benchmark_run":"feature-2","run_type":"feature","git_ref":"${FEATURE_REF}","bench_sha":"${FEATURE_REF}","benchmark_id":"${BENCH_ID}","run_start_epoch":"$(date +%s)","reference_epoch":"${BENCH_REFERENCE_EPOCH}"}
           LABELS
-          taskset -c 0 .github/scripts/bench-reth-run.sh feature ../reth-feature/target/profiling/reth "$BENCH_WORK_DIR/feature-2"
+          taskset -c 0 .github/scripts/bench-txgen-run.sh feature "../reth-feature/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/feature-2"
 
       - name: "Run benchmark: baseline (2/2)"
         id: run-baseline-2
@@ -518,18 +595,15 @@ jobs:
           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/reth "$BENCH_WORK_DIR/baseline-2"
+          taskset -c 0 .github/scripts/bench-txgen-run.sh baseline "../reth-baseline/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/baseline-2"
 
-      - name: Stop metrics proxy & generate Grafana URL
+      - name: Generate Grafana URL
         id: metrics
         if: "!cancelled()"
         run: |
-          kill "$BENCH_METRICS_PROXY_PID" 2>/dev/null || true
-
-          LAST_RUN_DURATION=$(( $(date +%s) - BENCH_LAST_RUN_START ))
           FROM_MS=$(( BENCH_REFERENCE_EPOCH * 1000 ))
-          TO_MS=$(( (BENCH_REFERENCE_EPOCH + LAST_RUN_DURATION) * 1000 ))
-          GRAFANA_URL="https://tempoxyz.grafana.net/d/reth-bench-ghr/reth-bench-ghr?orgId=1&from=${FROM_MS}&to=${TO_MS}&timezone=browser&var-datasource=ef57fux92e9z4e&var-job=reth-bench&var-benchmark_id=${BENCH_ID}&var-benchmark_run=\$__all"
+          TO_MS=$(( $(date +%s) * 1000 ))
+          GRAFANA_URL="https://tempoxyz.grafana.net/d/reth-bench-ghr/reth-bench-ghr?orgId=1&from=${FROM_MS}&to=${TO_MS}&timezone=browser&var-datasource=efk1hcn87dnnkd&var-job=github-reth-bench&var-benchmark_id=${BENCH_ID}&var-benchmark_run=\$__all"
           echo "grafana-url=${GRAFANA_URL}" >> "$GITHUB_OUTPUT"
           echo "Grafana URL: ${GRAFANA_URL}"
 
@@ -587,12 +661,15 @@ jobs:
           FEATURE_CSVS="$FEATURE_CSVS $BENCH_WORK_DIR/feature-2/combined_latency.csv"
           SUMMARY_ARGS="$SUMMARY_ARGS --baseline-csv $BASELINE_CSVS"
           SUMMARY_ARGS="$SUMMARY_ARGS --feature-csv $FEATURE_CSVS"
-          SUMMARY_ARGS="$SUMMARY_ARGS --gas-csv $BENCH_WORK_DIR/feature-1/total_gas.csv"
+          SUMMARY_ARGS="$SUMMARY_ARGS --run-pairs $BENCH_RUN_PAIRS"
 
           GRAFANA_URL='${{ steps.metrics.outputs.grafana-url }}'
           if [ -n "$GRAFANA_URL" ]; then
             SUMMARY_ARGS="$SUMMARY_ARGS --grafana-url $GRAFANA_URL"
           fi
+          if [ -n "${BENCH_TARGET_METRICS_CONFIG:-}" ]; then
+            SUMMARY_ARGS="$SUMMARY_ARGS --target-metrics-config $BENCH_TARGET_METRICS_CONFIG"
+          fi
           # shellcheck disable=SC2086
           python3 .github/scripts/bench-reth-summary.py $SUMMARY_ARGS
 
@@ -662,12 +739,12 @@ jobs:
             git init "${TMP_DIR}"
             git -C "${TMP_DIR}" remote add origin "${CHARTS_REPO}"
           fi
+          .github/scripts/configure-git-token-user.sh "${TMP_DIR}" "${DEREK_TOKEN}"
 
           mkdir -p "${TMP_DIR}/${CHART_DIR}"
           cp "$BENCH_WORK_DIR"/charts/*.png "${TMP_DIR}/${CHART_DIR}/"
           git -C "${TMP_DIR}" add "${CHART_DIR}"
-          git -C "${TMP_DIR}" -c user.name="github-actions" -c user.email="github-actions@github.com" \
-            commit -m "nightly bench charts for run ${RUN_ID}"
+          git -C "${TMP_DIR}" commit -m "nightly bench charts for run ${RUN_ID}"
           git -C "${TMP_DIR}" push origin HEAD:main
           echo "sha=$(git -C "${TMP_DIR}" rev-parse HEAD)" >> "$GITHUB_OUTPUT"
           rm -rf "${TMP_DIR}"
@@ -760,7 +837,7 @@ jobs:
         with:
           script: |
             const fs = require('fs');
-            const { verdict, fmtChange, fmtMs, metricRows, waitTimeRows, blocksLabel } = require('./.github/scripts/bench-utils');
+            const { verdict, fmtChange, fmtMs, metricRows, waitTimeRows, blocksLabel, isWin } = require('./.github/scripts/bench-utils');
 
             const token = process.env.SLACK_BENCH_BOT_TOKEN;
             const channel = process.env.SLACK_BENCH_CHANNEL;
@@ -782,11 +859,10 @@ jobs:
             const mode = process.env.BENCH_MODE || 'nightly';
             const slackMode = process.env.BENCH_SLACK || 'always';
             const hasRegression = Object.values(changes).some(c => c.sig === 'bad');
-            const hasImprovement = Object.values(changes).some(c => c.sig === 'good');
 
-            // on-win mode: only notify on improvements
-            if (slackMode === 'on-win' && !hasImprovement) {
-              core.info('on-win mode: no improvement detected, skipping Slack notification');
+            // on-win mode: only notify on unambiguous improvements. Mixed results are not wins.
+            if (slackMode === 'on-win' && !isWin(changes)) {
+              core.info('on-win mode: no unambiguous improvement detected, skipping Slack notification');
               return;
             }
 
@@ -919,8 +995,8 @@ jobs:
             if (!token || !channel) return;
 
             const steps_status = [
-              ['validating local snapshot', '${{ steps.snapshot-check.outcome }}'],
               ['building binaries', '${{ steps.build.outcome }}'],
+              ['syncing snapshot', '${{ steps.snapshot-check.outcome }}'],
               ['running baseline benchmark (1/2)', '${{ steps.run-baseline-1.outcome }}'],
               ['running feature benchmark (1/2)', '${{ steps.run-feature-1.outcome }}'],
               ['running feature benchmark (2/2)', '${{ steps.run-feature-2.outcome }}'],
@@ -977,6 +1053,10 @@ jobs:
       - name: Restore system settings
         if: always()
         run: |
+          if [ -n "${BENCH_CPU_DMA_LATENCY_PID:-}" ]; then
+            sudo kill "$BENCH_CPU_DMA_LATENCY_PID" 2>/dev/null || true
+          fi
+          sudo pkill -f '^bench-cpu-dma-latency' 2>/dev/null || true
           sudo systemctl start irqbalance cron atd 2>/dev/null || true
 
   # ---------------------------------------------------------------------------
@@ -988,6 +1068,12 @@ jobs:
     name: save-state
     runs-on: ubuntu-latest
     steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+          sparse-checkout: .github/scripts
+          sparse-checkout-cone-mode: true
+
       - name: Push state to charts repo
         env:
           DEREK_TOKEN: ${{ secrets.DEREK_TOKEN }}
@@ -1003,12 +1089,12 @@ jobs:
             git init "${TMP_DIR}"
             git -C "${TMP_DIR}" remote add origin "${CHARTS_REPO}"
           fi
+          .github/scripts/configure-git-token-user.sh "${TMP_DIR}" "${DEREK_TOKEN}"
 
           mkdir -p "${TMP_DIR}/state"
           echo "${FEATURE_REF}" > "${TMP_DIR}/state/${MODE}-last-feature-ref"
           git -C "${TMP_DIR}" add state/
           git -C "${TMP_DIR}" diff --cached --quiet && echo "No state change" && exit 0
-          git -C "${TMP_DIR}" -c user.name="github-actions" -c user.email="github-actions@github.com" \
-            commit -m "bench: update ${MODE} state to ${FEATURE_REF}"
+          git -C "${TMP_DIR}" commit -m "bench: update ${MODE} state to ${FEATURE_REF}"
           git -C "${TMP_DIR}" push origin HEAD:state
           rm -rf "${TMP_DIR}"
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 3274d26d471..9be06605c4b 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -1,6 +1,6 @@
 # Runs benchmarks.
 #
-# The reth-bench job replays real blocks via the Engine API against a reth node
+# The bench job replays real blocks via the Engine API against a reth node
 # backed by a local snapshot managed with schelk.
 #
 # It runs the baseline binary and the feature (candidate) binary on the
@@ -12,15 +12,15 @@ on:
   workflow_dispatch:
     inputs:
       blocks:
-        description: "Number of blocks to benchmark"
+        description: "Number of blocks to benchmark (default: 500, big blocks: 30)"
         required: false
-        default: "500"
+        default: ""
         type: string
       big_blocks:
-        description: "Use big blocks mode (pre-generated merged payloads with reth-bb)"
+        description: "Use big blocks mode: false, true, or target gas like 100M/2G"
         required: false
         default: "false"
-        type: boolean
+        type: string
       bal:
         description: "Replay block access lists during big-block benchmarks"
         required: false
@@ -32,9 +32,9 @@ on:
           - "feature"
           - "baseline"
       warmup:
-        description: "Number of warmup blocks"
+        description: "Number of warmup blocks (default: one-quarter of blocks)"
         required: false
-        default: "200"
+        default: ""
         type: string
       baseline:
         description: "Baseline git ref (default: merge-base)"
@@ -66,6 +66,11 @@ on:
         required: false
         default: "false"
         type: boolean
+      tracing_chrome:
+        description: "Enable Chrome trace recording"
+        required: false
+        default: "false"
+        type: boolean
       cores:
         description: "Limit reth to N CPU cores (0 = all available)"
         required: false
@@ -81,32 +86,37 @@ on:
           - on-win
           - on-error
           - never
-      abba:
-        description: "Run ABBA (FBBF) interleaved order; false = single FB pass"
+      run_pairs:
+        description: "Number of benchmark run pairs (default: 6, big blocks: 10)"
         required: false
-        default: "true"
-        type: boolean
+        default: ""
+        type: string
       otlp:
         description: "Export OTLP traces and logs"
         required: false
         default: "true"
         type: boolean
+      metrics:
+        description: "Upload txgen metrics to VictoriaMetrics"
+        required: false
+        default: "false"
+        type: boolean
 
 env:
   CARGO_TERM_COLOR: always
   RUSTC_WRAPPER: "sccache"
-  BENCH_RUNNERS: 2
+  BENCH_RUNNERS: 4
 
 name: bench
 
 permissions: {}
 
 jobs:
-  reth-bench-ack:
+  bench-ack:
     if: |
       (github.event_name == 'issue_comment' && github.event.issue.pull_request && (startsWith(github.event.comment.body, '@decofe bench') || startsWith(github.event.comment.body, 'derek bench'))) ||
       github.event_name == 'workflow_dispatch'
-    name: reth-bench-ack
+    name: bench-ack
     runs-on: ubuntu-latest
     permissions:
       contents: read
@@ -121,34 +131,57 @@ jobs:
       baseline-name: ${{ steps.args.outputs.baseline-name }}
       feature-name: ${{ steps.args.outputs.feature-name }}
       samply: ${{ steps.args.outputs.samply }}
+      tracing-chrome: ${{ steps.args.outputs.tracing-chrome }}
       slack: ${{ steps.args.outputs.slack }}
+      metrics: ${{ steps.args.outputs.metrics }}
       cores: ${{ steps.args.outputs.cores }}
       big-blocks: ${{ steps.args.outputs.big-blocks }}
+      big-blocks-target-gas: ${{ steps.args.outputs.big-blocks-target-gas }}
       bal: ${{ steps.args.outputs.bal }}
       wait-time: ${{ steps.args.outputs.wait-time }}
       baseline-args: ${{ steps.args.outputs.baseline-args }}
       feature-args: ${{ steps.args.outputs.feature-args }}
-      abba: ${{ steps.args.outputs.abba }}
+      run-pairs: ${{ steps.args.outputs.run-pairs }}
+      run-order: ${{ steps.args.outputs.run-order }}
       otlp: ${{ steps.args.outputs.otlp }}
+      node-bin: ${{ steps.args.outputs.node-bin }}
       comment-id: ${{ steps.ack.outputs.comment-id }}
+      pr-head-sha: ${{ steps.args.outputs.pr-head-sha }}
+      pr-head-ref: ${{ steps.args.outputs.pr-head-ref }}
+      pr-head-repo: ${{ steps.args.outputs.pr-head-repo }}
     steps:
       - name: Check org membership
         if: github.event_name == 'issue_comment'
         uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
+          github-token: ${{ secrets.DEREK_BENCH_ACK_TOKEN }}
           script: |
-            const user = context.payload.comment.user.login;
-            try {
-              const { status } = await github.rest.orgs.checkMembershipForUser({
-                org: 'paradigmxyz',
-                username: user,
-              });
-              if (status !== 204 && status !== 302) {
-                core.setFailed(`@${user} is not a member of paradigmxyz`);
+            const org = 'paradigmxyz';
+            const allowedUsers = new Set(['rkrasiuk']);
+            const checkMembership = async (username) => {
+              if (allowedUsers.has(username)) return true;
+              try {
+                const { status } = await github.rest.orgs.checkMembershipForUser({ org, username });
+                return status === 204 || status === 302;
+              } catch {
+                return false;
               }
-            } catch (e) {
-              core.setFailed(`@${user} is not a member of paradigmxyz`);
+            };
+
+            const commenter = context.payload.comment.user.login;
+            if (!await checkMembership(commenter)) {
+              core.setFailed(`@${commenter} is not a member of ${org}`);
+              return;
+            }
+
+            const { data: pr } = await github.rest.pulls.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: context.issue.number,
+            });
+            const prAuthor = pr.user.login;
+            if (!await checkMembership(prAuthor)) {
+              core.setFailed(`PR author @${prAuthor} is not a member of ${org}`);
             }
 
       - name: Parse arguments
@@ -159,24 +192,55 @@ jobs:
           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="..."]`';
-            let pr, actor, blocks, warmup, baseline, feature, samply, cores, bigBlocks, bal;
+            const usage = '`@decofe bench [blocks=N] [big-blocks[=true|false|100M|2G]] [bal=true|false|feature|baseline] [warmup=N] [baseline=REF] [feature=REF] [samply] [tracing-chrome] [slack=always|on-win|on-error|never] [cores=N] [run-pairs=N] [otlp=true|false] [metrics[=true|false]] [wait-time=DURATION] [baseline-args="..."] [feature-args="..."]`';
+            let pr, actor, blocks, warmup, baseline, feature, samply, tracingChrome, cores, bigBlocks, bal;
+            let bigBlocksTargetGas = '';
+            let explicitBlocks = false;
             let explicitWarmup = false;
+            let explicitRunPairs = false;
+
+            const parseBigBlocks = (value) => {
+              value = String(value || 'false');
+              if (value === 'true') return { enabled: 'true', targetGas: '' };
+              if (value === 'false') return { enabled: 'false', targetGas: '' };
+              if (/^\d+([kKmMgG])?$/.test(value)) return { enabled: 'true', targetGas: value };
+              return null;
+            };
+            const defaultBlocks = (isBigBlocks) => isBigBlocks ? '30' : '500';
+            const defaultWarmup = (blockCount) => String(Math.floor(Number(blockCount) / 4));
+            const defaultRunPairs = (isBigBlocks) => isBigBlocks ? '10' : '6';
+            const benchRunOrder = (runPairs) => {
+              const n = Number(runPairs);
+              if (!Number.isInteger(n) || n < 1) {
+                throw new Error('run pairs must be a positive integer');
+              }
+              return n % 2 === 0 ? 'ABBA'.repeat(n / 2) : 'AB'.repeat(n);
+            };
 
             if (context.eventName === 'workflow_dispatch') {
               actor = '${{ github.actor }}';
-              blocks = '${{ github.event.inputs.blocks }}' || '500';
-              warmup = '${{ github.event.inputs.warmup }}' || '200';
-              if (warmup !== '200') explicitWarmup = true;
+              blocks = '${{ github.event.inputs.blocks }}' || '';
+              explicitBlocks = blocks !== '';
+              warmup = '${{ github.event.inputs.warmup }}' || '';
+              explicitWarmup = warmup !== '';
               baseline = '${{ github.event.inputs.baseline }}';
               feature = '${{ github.event.inputs.feature }}';
               samply = '${{ github.event.inputs.samply }}' === 'true' ? 'true' : 'false';
+              tracingChrome = '${{ github.event.inputs.tracing_chrome }}' === 'true' ? 'true' : 'false';
               var slack = '${{ github.event.inputs.slack }}' || 'never';
               cores = '${{ github.event.inputs.cores }}' || '0';
-              bigBlocks = '${{ github.event.inputs.big_blocks }}' === 'true' ? 'true' : 'false';
+              const parsedBigBlocks = parseBigBlocks('${{ github.event.inputs.big_blocks }}');
+              if (!parsedBigBlocks) {
+                core.setFailed(`Invalid big_blocks value: ${{ github.event.inputs.big_blocks }} (must be false, true, or a gas value like 100M or 2G)`);
+                return;
+              }
+              bigBlocks = parsedBigBlocks.enabled;
+              bigBlocksTargetGas = parsedBigBlocks.targetGas;
               bal = '${{ github.event.inputs.bal }}' || 'false';
-              var abba = '${{ github.event.inputs.abba }}' !== 'false' ? 'true' : 'false';
-              var otlp = '${{ github.event.inputs.otlp }}' !== 'false' ? 'true' : 'false';
+              var runPairs = '${{ github.event.inputs.run_pairs }}' || '';
+              explicitRunPairs = runPairs !== '';
+              var otlp = '${{ github.event.inputs.otlp }}' === 'false' ? 'false' : 'true';
+              var metrics = '${{ github.event.inputs.metrics }}' === 'true' ? 'true' : 'false';
               var waitTime = '${{ github.event.inputs.wait_time }}' || '';
               var baselineNodeArgs = '${{ github.event.inputs.baseline_args }}' || '';
               var featureNodeArgs = '${{ github.event.inputs.feature_args }}' || '';
@@ -199,14 +263,13 @@ jobs:
               actor = context.payload.comment.user.login;
 
               const body = context.payload.comment.body.trim();
-              const intArgs = new Set(['warmup', 'cores', 'blocks']);
+              const intArgs = new Set(['warmup', 'cores', 'blocks', 'run-pairs']);
               const refArgs = new Set(['baseline', 'feature']);
-              const boolArgs = new Set(['samply', 'big-blocks']);
-              const boolDefaultTrue = new Set(['abba', 'otlp']);
+              const boolArgs = new Set(['samply', 'tracing-chrome', 'otlp', 'metrics']);
               const enumArgs = new Map([['bal', validBalModes], ['slack', validSlackModes]]);
               const durationArgs = new Set(['wait-time']);
               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: '', warmup: '', baseline: '', feature: '', samply: 'false', 'tracing-chrome': 'false', slack: 'always', 'big-blocks': 'false', bal: 'false', cores: '0', 'run-pairs': '', otlp: 'true', metrics: 'false', 'wait-time': '', 'baseline-args': '', 'feature-args': '' };
               const unknown = [];
               const invalid = [];
               const args = body.replace(/^(?:@decofe|derek) bench\s*/, '');
@@ -218,9 +281,9 @@ jobs:
               for (const part of parts) {
                 const eq = part.indexOf('=');
                 if (eq === -1) {
-                  if (boolArgs.has(part)) {
+                  if (part === 'big-blocks') {
                     defaults[part] = 'true';
-                  } else if (boolDefaultTrue.has(part)) {
+                  } else if (boolArgs.has(part)) {
                     defaults[part] = 'true';
                   } else {
                     unknown.push(part);
@@ -233,7 +296,14 @@ jobs:
                 if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
                   value = value.slice(1, -1);
                 }
-                if (boolArgs.has(key) || boolDefaultTrue.has(key)) {
+                if (key === 'big-blocks') {
+                  const parsed = parseBigBlocks(value);
+                  if (parsed) {
+                    defaults[key] = value;
+                  } else {
+                    invalid.push(`\`${key}=${value}\` (must be false, true, or a gas value like 100M or 2G)`);
+                  }
+                } else if (boolArgs.has(key)) {
                   if (value === 'true' || value === 'false') {
                     defaults[key] = value;
                   } else {
@@ -256,7 +326,9 @@ jobs:
                     invalid.push(`\`${key}=${value}\` (must be a positive integer)`);
                   } else {
                     defaults[key] = value;
+                    if (key === 'blocks') explicitBlocks = true;
                     if (key === 'warmup') explicitWarmup = true;
+                    if (key === 'run-pairs') explicitRunPairs = true;
                   }
                 } else if (refArgs.has(key)) {
                   if (!value) {
@@ -289,56 +361,74 @@ jobs:
               baseline = defaults.baseline;
               feature = defaults.feature;
               samply = defaults.samply;
+              tracingChrome = defaults['tracing-chrome'];
               var slack = defaults.slack;
               cores = defaults.cores;
-              bigBlocks = defaults['big-blocks'];
+              const parsedBigBlocks = parseBigBlocks(defaults['big-blocks']);
+              bigBlocks = parsedBigBlocks.enabled;
+              bigBlocksTargetGas = parsedBigBlocks.targetGas;
               bal = defaults.bal;
-              var abba = defaults.abba;
+              var runPairs = defaults['run-pairs'];
               var otlp = defaults.otlp;
+              var metrics = defaults.metrics;
               var waitTime = defaults['wait-time'];
               var baselineNodeArgs = defaults['baseline-args'];
               var featureNodeArgs = defaults['feature-args'];
             }
 
-            // Default warmup to 20 for big-blocks mode unless explicitly set
-            if (bigBlocks === 'true' && !explicitWarmup) {
-              warmup = '20';
+            const isBigBlocks = bigBlocks === 'true';
+            if (!explicitBlocks) {
+              blocks = defaultBlocks(isBigBlocks);
+            }
+            if (!explicitRunPairs) {
+              runPairs = defaultRunPairs(isBigBlocks);
             }
+            if (!/^\d+$/.test(blocks)) {
+              core.setFailed(`Invalid blocks value: ${blocks} (must be a positive integer)`);
+              return;
+            }
+            if (explicitWarmup && !/^\d+$/.test(warmup)) {
+              core.setFailed(`Invalid warmup value: ${warmup} (must be a positive integer)`);
+              return;
+            }
+            if (!explicitWarmup) {
+              warmup = defaultWarmup(blocks);
+            }
+            if (!/^[1-9]\d*$/.test(runPairs)) {
+              core.setFailed(`Invalid run-pairs value: ${runPairs} (must be a positive integer greater than zero)`);
+              return;
+            }
+            const runOrder = benchRunOrder(runPairs);
 
             if (!validBalModes.has(bal)) {
               core.setFailed(`Invalid bal mode: ${bal}`);
               return;
             }
-            if (bal !== 'false' && bigBlocks !== 'true') {
-              const msg = `❌ **Invalid bench command**\n\n\`bal\` requires \`big-blocks=true\`.\n\n**Usage:** ${usage}`;
-              if (context.eventName === 'issue_comment') {
-                await github.rest.issues.createComment({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  issue_number: context.issue.number,
-                  body: msg,
-                });
-              }
-              core.setFailed(msg);
-              return;
+
+            const releaseRef = (ref) => /^v\d+\.\d+\.\d+/.test(ref || '');
+            if (releaseRef(baseline) || releaseRef(feature) || '${{ github.ref_type }}' === 'tag') {
+              otlp = 'false';
             }
 
             // Resolve display names for baseline/feature
             let baselineName = baseline || 'main';
             let featureName = feature;
-            if (!featureName) {
-              if (pr) {
-                const { data: prData } = await github.rest.pulls.get({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  pull_number: parseInt(pr),
-                });
-                featureName = prData.head.ref;
-              } else {
-                featureName = '${{ github.ref_name }}';
-              }
+            if (pr) {
+              const { data: prData } = await github.rest.pulls.get({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                pull_number: parseInt(pr),
+              });
+              core.setOutput('pr-head-sha', prData.head.sha);
+              core.setOutput('pr-head-ref', prData.head.ref);
+              core.setOutput('pr-head-repo', prData.head.repo.full_name);
+              if (!featureName) featureName = prData.head.ref;
+            } else {
+              if (!featureName) featureName = '${{ github.ref_name }}';
             }
 
+            const nodeBin = bigBlocks === 'true' ? 'reth-bb' : 'reth';
+
             core.setOutput('pr', pr || '');
             core.setOutput('actor', actor);
             core.setOutput('blocks', blocks);
@@ -348,15 +438,20 @@ jobs:
             core.setOutput('baseline-name', baselineName);
             core.setOutput('feature-name', featureName);
             core.setOutput('samply', samply);
+            core.setOutput('tracing-chrome', tracingChrome);
             core.setOutput('slack', slack);
             core.setOutput('cores', cores);
             core.setOutput('big-blocks', bigBlocks);
+            core.setOutput('big-blocks-target-gas', bigBlocksTargetGas);
             core.setOutput('bal', bal);
             core.setOutput('wait-time', waitTime);
             core.setOutput('baseline-args', baselineNodeArgs);
             core.setOutput('feature-args', featureNodeArgs);
-            core.setOutput('abba', abba);
+            core.setOutput('run-pairs', runPairs);
+            core.setOutput('run-order', runOrder);
             core.setOutput('otlp', otlp);
+            core.setOutput('metrics', metrics);
+            core.setOutput('node-bin', nodeBin);
 
       - name: Acknowledge request
         id: ack
@@ -414,16 +509,19 @@ jobs:
             const baseline = '${{ steps.args.outputs.baseline-name }}';
             const feature = '${{ steps.args.outputs.feature-name }}';
             const samply = '${{ steps.args.outputs.samply }}' === 'true';
+            const tracingChrome = '${{ steps.args.outputs.tracing-chrome }}' === 'true';
             const slack = '${{ steps.args.outputs.slack }}' || 'always';
             const bigBlocks = '${{ steps.args.outputs.big-blocks }}' === 'true';
             const bal = '${{ steps.args.outputs.bal }}' || 'false';
             const samplyNote = samply ? ', samply: `enabled`' : '';
+            const tracingChromeNote = tracingChrome ? ', tracing-chrome: `enabled`' : '';
             const slackNote = slack !== 'always' ? `, slack: \`${slack}\`` : '';
-            const balNote = bigBlocks && bal !== 'false' ? `, BAL: \`${bal}\`` : '';
+            const balNote = bal !== 'false' ? `, BAL: \`${bal}\`` : '';
             const cores = '${{ steps.args.outputs.cores }}';
             const coresNote = cores && cores !== '0' ? `, cores: \`${cores}\`` : '';
-            const abbaEnabled = '${{ steps.args.outputs.abba }}' !== 'false';
-            const abbaNote = !abbaEnabled ? ', abba: `disabled`' : '';
+            const runPairs = '${{ steps.args.outputs.run-pairs }}' || '6';
+            const runOrder = '${{ steps.args.outputs.run-order }}';
+            const runPairsNote = `, run-pairs: \`${runPairs}\`${runOrder ? ` (${runOrder})` : ''}`;
             const otlpEnabled = '${{ steps.args.outputs.otlp }}' !== 'false';
             const otlpNote = !otlpEnabled ? ', otlp: `disabled`' : '';
             const waitTimeVal = '${{ steps.args.outputs.wait-time }}';
@@ -432,8 +530,8 @@ jobs:
             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 blocksDesc = bigBlocks ? `${blocks} big blocks, ${warmup} warmup blocks` : `${blocks} blocks, ${warmup} warmup blocks`;
+            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${tracingChromeNote}${slackNote}${balNote}${coresNote}${runPairsNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
 
             const { data: comment } = await github.rest.issues.createComment({
               owner: context.repo.owner,
@@ -458,16 +556,19 @@ jobs:
             const baseline = '${{ steps.args.outputs.baseline-name }}';
             const feature = '${{ steps.args.outputs.feature-name }}';
             const samply = '${{ steps.args.outputs.samply }}' === 'true';
+            const tracingChrome = '${{ steps.args.outputs.tracing-chrome }}' === 'true';
             const slack = '${{ steps.args.outputs.slack }}' || 'always';
             const bigBlocks = '${{ steps.args.outputs.big-blocks }}' === 'true';
             const bal = '${{ steps.args.outputs.bal }}' || 'false';
             const samplyNote = samply ? ', samply: `enabled`' : '';
+            const tracingChromeNote = tracingChrome ? ', tracing-chrome: `enabled`' : '';
             const slackNote = slack !== 'always' ? `, slack: \`${slack}\`` : '';
-            const balNote = bigBlocks && bal !== 'false' ? `, BAL: \`${bal}\`` : '';
+            const balNote = bal !== 'false' ? `, BAL: \`${bal}\`` : '';
             const cores = '${{ steps.args.outputs.cores }}';
             const coresNote = cores && cores !== '0' ? `, cores: \`${cores}\`` : '';
-            const abbaEnabled = '${{ steps.args.outputs.abba }}' !== 'false';
-            const abbaNote = !abbaEnabled ? ', abba: `disabled`' : '';
+            const runPairs = '${{ steps.args.outputs.run-pairs }}' || '6';
+            const runOrder = '${{ steps.args.outputs.run-order }}';
+            const runPairsNote = `, run-pairs: \`${runPairs}\`${runOrder ? ` (${runOrder})` : ''}`;
             const otlpEnabled = '${{ steps.args.outputs.otlp }}' !== 'false';
             const otlpNote = !otlpEnabled ? ', otlp: `disabled`' : '';
             const waitTimeVal = '${{ steps.args.outputs.wait-time }}';
@@ -476,8 +577,8 @@ jobs:
             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 blocksDesc = bigBlocks ? `${blocks} big blocks, ${warmup} warmup blocks` : `${blocks} blocks, ${warmup} warmup blocks`;
+            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${tracingChromeNote}${slackNote}${balNote}${coresNote}${runPairsNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
             const runUrl = `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`;
 
             const numRunners = parseInt(process.env.BENCH_RUNNERS) || 1;
@@ -526,38 +627,49 @@ jobs:
               }
             }
 
-  reth-bench:
-    needs: reth-bench-ack
-    name: reth-bench
+  bench-txgen:
+    needs: bench-ack
+    name: bench-txgen
     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
+      BENCH_RPC_URL: http://ethereum-mainnet-stable-reth-greedy-goose:8545
       SCHELK_MOUNT: /reth-bench
       RETH_SCOPE: reth-bench.scope
       BENCH_WORK_DIR: ${{ github.workspace }}/bench-work
-      BENCH_PR: ${{ needs.reth-bench-ack.outputs.pr }}
-      BENCH_ACTOR: ${{ needs.reth-bench-ack.outputs.actor }}
-      BENCH_BLOCKS: ${{ needs.reth-bench-ack.outputs.blocks }}
-      BENCH_WARMUP_BLOCKS: ${{ needs.reth-bench-ack.outputs.warmup }}
-      BENCH_SAMPLY: ${{ needs.reth-bench-ack.outputs.samply }}
-      BENCH_CORES: ${{ needs.reth-bench-ack.outputs.cores }}
-      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_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 }}
-      BENCH_OTLP: ${{ needs.reth-bench-ack.outputs.otlp }}
-      BENCH_COMMENT_ID: ${{ needs.reth-bench-ack.outputs.comment-id }}
-      BENCH_SLACK: ${{ needs.reth-bench-ack.outputs.slack }}
-      BENCH_NODE_BIN: ${{ needs.reth-bench-ack.outputs.big-blocks == 'true' && 'reth-bb' || 'reth' }}
-      BENCH_METRICS_ADDR: "127.0.0.1:9100"
-      BENCH_OTLP_TRACES_ENDPOINT: ${{ needs.reth-bench-ack.outputs.otlp != 'false' && secrets.BENCH_OTLP_TRACES_ENDPOINT || '' }}
-      BENCH_OTLP_LOGS_ENDPOINT: ${{ needs.reth-bench-ack.outputs.otlp != 'false' && secrets.BENCH_OTLP_LOGS_ENDPOINT || '' }}
+      BENCH_PR: ${{ needs.bench-ack.outputs.pr }}
+      BENCH_PR_HEAD_SHA: ${{ needs.bench-ack.outputs.pr-head-sha }}
+      BENCH_PR_HEAD_REF: ${{ needs.bench-ack.outputs.pr-head-ref }}
+      BENCH_PR_HEAD_REPO: ${{ needs.bench-ack.outputs.pr-head-repo }}
+      BENCH_ACTOR: ${{ needs.bench-ack.outputs.actor }}
+      BENCH_BLOCKS: ${{ needs.bench-ack.outputs.blocks }}
+      BENCH_WARMUP_BLOCKS: ${{ needs.bench-ack.outputs.warmup }}
+      BENCH_SAMPLY: ${{ needs.bench-ack.outputs.samply }}
+      BENCH_TRACING_CHROME: ${{ needs.bench-ack.outputs.tracing-chrome }}
+      BENCH_CORES: ${{ needs.bench-ack.outputs.cores }}
+      BENCH_BIG_BLOCKS: ${{ needs.bench-ack.outputs.big-blocks }}
+      BENCH_BIG_BLOCKS_TARGET_GAS: ${{ needs.bench-ack.outputs.big-blocks-target-gas }}
+      BENCH_BAL: ${{ needs.bench-ack.outputs.bal }}
+      BENCH_WAIT_TIME: ${{ needs.bench-ack.outputs.wait-time }}
+      BENCH_BASELINE_ARGS: ${{ needs.bench-ack.outputs.baseline-args }}
+      BENCH_FEATURE_ARGS: ${{ needs.bench-ack.outputs.feature-args }}
+      BENCH_RUN_PAIRS: ${{ needs.bench-ack.outputs.run-pairs }}
+      BENCH_RUN_ORDER: ${{ needs.bench-ack.outputs.run-order }}
+      BENCH_OTLP: ${{ needs.bench-ack.outputs.otlp }}
+      BENCH_METRICS: ${{ needs.bench-ack.outputs.metrics }}
+      BENCH_COMMENT_ID: ${{ needs.bench-ack.outputs.comment-id }}
+      BENCH_SLACK: ${{ needs.bench-ack.outputs.slack }}
+      BENCH_NODE_BIN: ${{ needs.bench-ack.outputs.node-bin }}
+      BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
+      BENCH_METRICS_ADDR: "127.0.0.1:9001"
+      BENCH_TARGET_METRICS_CONFIG: .github/config/bench-metrics-targets.json
+      BENCH_TARGET_METRICS_SCRAPE_INTERVAL_MS: "200"
+      BENCH_OTLP_TRACES_ENDPOINT: ${{ needs.bench-ack.outputs.otlp != 'false' && secrets.BENCH_OTLP_TRACES_ENDPOINT || '' }}
+      BENCH_OTLP_LOGS_ENDPOINT: ${{ needs.bench-ack.outputs.otlp != 'false' && secrets.BENCH_OTLP_LOGS_ENDPOINT || '' }}
+      BENCH_VICTORIAMETRICS_URL: ${{ needs.bench-ack.outputs.metrics == 'true' && secrets.BENCH_VICTORIAMETRICS_URL || '' }}
     steps:
       - name: Clean up previous bench-work
         run: sudo rm -rf "$BENCH_WORK_DIR" 2>/dev/null || true
@@ -568,22 +680,23 @@ jobs:
         with:
           script: |
             if (!process.env.BENCH_PR) {
+              core.setOutput('repository', '${{ github.repository }}');
               core.setOutput('ref', '${{ github.ref }}');
               return;
             }
-            const { data: pr } = await github.rest.pulls.get({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              pull_number: parseInt(process.env.BENCH_PR),
-            });
-            // Always use head SHA — the merge ref (refs/pull/N/merge) may not
-            // exist if the PR has conflicts, was force-pushed, or was
-            // merged/closed between this step and checkout.
-            core.info(`PR #${process.env.BENCH_PR} (${pr.state}), using head SHA ${pr.head.sha}`);
-            core.setOutput('ref', pr.head.sha);
+            const sha = process.env.BENCH_PR_HEAD_SHA;
+            if (!sha) {
+              core.setFailed('BENCH_PR_HEAD_SHA is not set — ack job must pin the PR head SHA');
+              return;
+            }
+            const repository = process.env.BENCH_PR_HEAD_REPO || '${{ github.repository }}';
+            core.info(`PR #${process.env.BENCH_PR}, using ${repository}@${sha}`);
+            core.setOutput('repository', repository);
+            core.setOutput('ref', sha);
 
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
+          repository: ${{ steps.checkout-ref.outputs.repository }}
           persist-credentials: false
           submodules: true
           fetch-depth: 0
@@ -600,26 +713,30 @@ jobs:
               repo: context.repo.repo,
               run_id: context.runId,
             });
-            const job = jobs.jobs.find(j => j.name === 'reth-bench');
+            const expectedJobName = 'bench-txgen';
+            const job = jobs.jobs.find(j => j.name === expectedJobName);
             const jobUrl = job ? job.html_url : `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`;
             core.exportVariable('BENCH_JOB_URL', jobUrl);
 
             const blocks = process.env.BENCH_BLOCKS;
             const warmup = process.env.BENCH_WARMUP_BLOCKS;
-            const baseline = '${{ needs.reth-bench-ack.outputs.baseline-name }}';
-            const feature = '${{ needs.reth-bench-ack.outputs.feature-name }}';
+            const baseline = '${{ needs.bench-ack.outputs.baseline-name }}';
+            const feature = '${{ needs.bench-ack.outputs.feature-name }}';
             const samply = process.env.BENCH_SAMPLY === 'true';
+            const tracingChrome = process.env.BENCH_TRACING_CHROME === 'true';
             const slack = process.env.BENCH_SLACK || 'always';
             const bigBlocks = process.env.BENCH_BIG_BLOCKS === 'true';
             const bal = process.env.BENCH_BAL || 'false';
             const samplyNote = samply ? ', samply: `enabled`' : '';
+            const tracingChromeNote = tracingChrome ? ', tracing-chrome: `enabled`' : '';
             const slackNote = slack !== 'always' ? `, slack: \`${slack}\`` : '';
-            const balNote = bigBlocks && bal !== 'false' ? `, BAL: \`${bal}\`` : '';
+            const balNote = bal !== 'false' ? `, BAL: \`${bal}\`` : '';
             const cores = process.env.BENCH_CORES || '0';
             const coresNote = cores && cores !== '0' ? `, cores: \`${cores}\`` : '';
-            const abbaEnabled = (process.env.BENCH_ABBA || 'true') !== 'false';
-            const abbaNote = !abbaEnabled ? ', abba: `disabled`' : '';
-            const otlpEnabled = (process.env.BENCH_OTLP || 'true') !== 'false';
+            const runPairs = process.env.BENCH_RUN_PAIRS || '6';
+            const runOrder = process.env.BENCH_RUN_ORDER || '';
+            const runPairsNote = `, run-pairs: \`${runPairs}\`${runOrder ? ` (${runOrder})` : ''}`;
+            const otlpEnabled = (process.env.BENCH_OTLP || 'false') !== 'false';
             const otlpNote = !otlpEnabled ? ', otlp: `disabled`' : '';
             const waitTimeVal = process.env.BENCH_WAIT_TIME || '';
             const waitTimeNote = waitTimeVal ? `, wait-time: \`${waitTimeVal}\`` : '';
@@ -627,8 +744,8 @@ jobs:
             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}`);
+            const blocksDesc = bigBlocks ? `${blocks} big blocks, ${warmup} warmup blocks` : `${blocks} blocks, ${warmup} warmup blocks`;
+            core.exportVariable('BENCH_CONFIG', `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${tracingChromeNote}${slackNote}${balNote}${coresNote}${runPairsNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`);
 
             const { buildBody } = require('./.github/scripts/bench-update-status.js');
             await github.rest.issues.updateComment({
@@ -643,6 +760,27 @@ jobs:
         continue-on-error: true
       - uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
 
+      - name: Mask OTLP endpoints
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          script: |
+            for (const envName of ['BENCH_OTLP_TRACES_ENDPOINT', 'BENCH_OTLP_LOGS_ENDPOINT']) {
+              const endpoint = process.env[envName] || '';
+              if (!endpoint) {
+                continue;
+              }
+
+              core.setSecret(endpoint);
+              try {
+                const url = new URL(endpoint);
+                url.username = '';
+                url.password = '';
+                core.setSecret(url.toString());
+              } catch {
+                // The CLI parser will report malformed endpoints later; this step only masks.
+              }
+            }
+
       - name: Install dependencies
         env:
           DEREK_TOKEN: ${{ secrets.DEREK_TOKEN }}
@@ -656,6 +794,12 @@ jobs:
             linux-tools-"$(uname -r)" || \
             sudo apt-get install -y --no-install-recommends linux-tools-generic
 
+          # mc (MinIO client)
+          if ! command -v mc &>/dev/null; then
+            curl -sSfL https://dl.min.io/client/mc/release/linux-amd64/mc -o "$HOME/.local/bin/mc"
+            chmod +x "$HOME/.local/bin/mc"
+          fi
+
           # uv (Python package manager)
           if ! command -v uv &>/dev/null; then
             curl -LsSf https://astral.sh/uv/install.sh | env UV_INSTALL_DIR="$HOME/.local/bin" sh
@@ -690,7 +834,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 mc schelk cpupower taskset stdbuf python3 curl make uv jq; do
             command -v "$cmd" &>/dev/null || missing+=("$cmd")
           done
           if [ ${#missing[@]} -gt 0 ]; then
@@ -706,13 +850,10 @@ jobs:
         with:
           script: |
             if (process.env.BENCH_PR) {
-              const { data: pr } = await github.rest.pulls.get({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                pull_number: parseInt(process.env.BENCH_PR),
-              });
-              core.setOutput('head-ref', pr.head.ref);
-              core.setOutput('head-sha', pr.head.sha);
+              const ref = process.env.BENCH_PR_HEAD_REF || '${{ github.ref_name }}';
+              const sha = process.env.BENCH_PR_HEAD_SHA || '${{ github.sha }}';
+              core.setOutput('head-ref', ref);
+              core.setOutput('head-sha', sha);
             } else {
               core.setOutput('head-ref', '${{ github.ref_name }}');
               core.setOutput('head-sha', '${{ github.sha }}');
@@ -726,8 +867,8 @@ jobs:
             const { execSync } = require('child_process');
             const run = (cmd) => execSync(cmd, { encoding: 'utf8' }).trim();
 
-            const baselineArg = '${{ needs.reth-bench-ack.outputs.baseline }}';
-            const featureArg = '${{ needs.reth-bench-ack.outputs.feature }}';
+            const baselineArg = '${{ needs.bench-ack.outputs.baseline }}';
+            const featureArg = '${{ needs.bench-ack.outputs.feature }}';
 
             let baselineRef, baselineName, featureRef, featureName;
 
@@ -766,46 +907,6 @@ jobs:
             core.setOutput('feature-ref', featureRef);
             core.setOutput('feature-name', featureName);
 
-      - name: Validate local big blocks
-        if: env.BENCH_BIG_BLOCKS == 'true'
-        id: big-blocks-check
-        run: |
-          set -euo pipefail
-          BIG_BLOCKS_DIR="$HOME/.reth-bench-big-blocks"
-          PAYLOAD_DIR="$BIG_BLOCKS_DIR/payloads"
-          MANIFEST="$BIG_BLOCKS_DIR/manifest.json"
-          echo "BENCH_BIG_BLOCKS_DIR=${BIG_BLOCKS_DIR}" >> "$GITHUB_ENV"
-
-          if [ ! -f "$MANIFEST" ]; then
-            echo "::error::Missing local big-blocks manifest at $MANIFEST"
-            exit 1
-          fi
-
-          BASE_SNAPSHOT=$(jq -r '.base_snapshot // empty' "$MANIFEST")
-          if [ -z "$BASE_SNAPSHOT" ]; then
-            echo "::error::Big-blocks manifest missing base_snapshot field"
-            exit 1
-          fi
-
-          if [ ! -d "$PAYLOAD_DIR" ]; then
-            echo "::error::Missing local big-block payload directory at $PAYLOAD_DIR"
-            exit 1
-          fi
-
-          PAYLOAD_COUNT=$(find "$PAYLOAD_DIR" -name '*.json' | wc -l)
-          if [ "$PAYLOAD_COUNT" -eq 0 ]; then
-            echo "::error::No payload files found in $PAYLOAD_DIR"
-            exit 1
-          fi
-
-          echo "Big-blocks base snapshot: $BASE_SNAPSHOT"
-          echo "Payload files: $PAYLOAD_COUNT"
-          echo "BENCH_SNAPSHOT_NAME=${BASE_SNAPSHOT}" >> "$GITHUB_ENV"
-
-      - name: Validate local snapshot
-        id: snapshot-check
-        run: .github/scripts/bench-reth-snapshot.sh
-
       - name: Prepare source dirs
         run: |
           prepare_source_dir() {
@@ -833,14 +934,21 @@ jobs:
         id: build
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TXGEN_DEPLOY_KEY: ${{ secrets.TXGEN_DEPLOY_KEY }}
+          TXGEN_TOKEN: ${{ secrets.TXGEN_TOKEN }}
+          GH_PROJECT_TOKEN: ${{ secrets.GH_PROJECT_TOKEN }}
+          DEREK_PAT: ${{ secrets.DEREK_PAT }}
+          DEREK_TOKEN: ${{ secrets.DEREK_TOKEN }}
           BENCH_REPO: ${{ github.repository }}
         run: |
           BASELINE_DIR="$(cd ../reth-baseline && pwd)"
           FEATURE_DIR="$(cd ../reth-feature && pwd)"
 
-          .github/scripts/bench-reth-build.sh baseline "${BASELINE_DIR}" "${{ steps.refs.outputs.baseline-ref }}" &
+          .github/scripts/bench-txgen-install.sh
+
+          .github/scripts/bench-txgen-build.sh baseline "${BASELINE_DIR}" "${{ steps.refs.outputs.baseline-ref }}" &
           PID_BASELINE=$!
-          .github/scripts/bench-reth-build.sh feature "${FEATURE_DIR}" "${{ steps.refs.outputs.feature-ref }}" &
+          .github/scripts/bench-txgen-build.sh feature "${FEATURE_DIR}" "${{ steps.refs.outputs.feature-ref }}" &
           PID_FEATURE=$!
 
           FAIL=0
@@ -851,6 +959,12 @@ jobs:
             exit 1
           fi
 
+      - name: Sync snapshot
+        id: snapshot-check
+        run: |
+          BENCH_RETH_BINARY="$(pwd)/../reth-feature/target/profiling/${BENCH_NODE_BIN}" \
+            .github/scripts/bench-reth-snapshot.sh
+
       # System tuning for reproducible benchmarks
       - name: System setup
         run: |
@@ -900,7 +1014,14 @@ jobs:
             echo 0 | sudo tee "$irq" 2>/dev/null || true
           done
           # Stop noisy background services
-          sudo systemctl stop irqbalance cron atd unattended-upgrades snapd 2>/dev/null || true
+          sudo systemctl stop \
+            irqbalance cron atd unattended-upgrades snapd \
+            prometheus-node-exporter-apt.timer prometheus-node-exporter-apt.service \
+            prometheus-node-exporter-nvme.timer prometheus-node-exporter-nvme.service \
+            prometheus-node-exporter-ipmitool-sensor.timer prometheus-node-exporter-ipmitool-sensor.service \
+            sysstat-collect.timer sysstat-collect.service \
+            sysstat-summary.timer sysstat-summary.service \
+            2>/dev/null || true
           # Log environment for reproducibility
           echo "=== Benchmark environment ==="
           uname -r
@@ -921,110 +1042,236 @@ jobs:
           rm -rf "$BENCH_WORK_DIR"
           mkdir -p "$BENCH_WORK_DIR"
 
-      - name: Start metrics proxy
+      - name: Initialize benchmark metrics labels
         run: |
+          if [ -n "${BENCH_VICTORIAMETRICS_URL:-}" ]; then
+            echo "::add-mask::$BENCH_VICTORIAMETRICS_URL"
+          fi
+
+          quote_arg() {
+            local value="$1"
+            if [[ "$value" =~ ^[A-Za-z0-9._/:=@+-]+$ ]]; then
+              printf '%s' "$value"
+            else
+              printf "'%s'" "${value//\'/\'\\\'\'}"
+            fi
+          }
+
+          derek_cmd=(derek bench)
+          [ "$BENCH_BIG_BLOCKS" = "true" ] && derek_cmd+=(big-blocks="${BENCH_BIG_BLOCKS_TARGET_GAS:-true}")
+          derek_cmd+=(
+            blocks="$BENCH_BLOCKS"
+            warmup="$BENCH_WARMUP_BLOCKS"
+            baseline="${{ needs.bench-ack.outputs.baseline-name }}"
+            feature="${{ needs.bench-ack.outputs.feature-name }}"
+            bal="$BENCH_BAL"
+            cores="$BENCH_CORES"
+            run-pairs="$BENCH_RUN_PAIRS"
+            otlp="$BENCH_OTLP"
+            metrics="$BENCH_METRICS"
+            slack="$BENCH_SLACK"
+          )
+          [ "$BENCH_SAMPLY" = "true" ] && derek_cmd+=(samply)
+          [ "$BENCH_TRACING_CHROME" = "true" ] && derek_cmd+=(tracing-chrome)
+          [ -n "$BENCH_WAIT_TIME" ] && derek_cmd+=(wait-time="$BENCH_WAIT_TIME")
+          [ -n "$BENCH_BASELINE_ARGS" ] && derek_cmd+=(baseline-args="$BENCH_BASELINE_ARGS")
+          [ -n "$BENCH_FEATURE_ARGS" ] && derek_cmd+=(feature-args="$BENCH_FEATURE_ARGS")
+          DEREK_BENCH_COMMAND=""
+          for arg in "${derek_cmd[@]}"; do
+            if [ -n "$DEREK_BENCH_COMMAND" ]; then
+              DEREK_BENCH_COMMAND+=" "
+            fi
+            DEREK_BENCH_COMMAND+="$(quote_arg "$arg")"
+          done
+          echo "DEREK_BENCH_COMMAND=${DEREK_BENCH_COMMAND}" >> "$GITHUB_ENV"
+
           BENCH_ID="ci-${{ github.run_id }}"
           BENCH_REFERENCE_EPOCH=$(date +%s)
           echo "BENCH_ID=${BENCH_ID}" >> "$GITHUB_ENV"
           echo "BENCH_REFERENCE_EPOCH=${BENCH_REFERENCE_EPOCH}" >> "$GITHUB_ENV"
 
-          LABELS_FILE="/tmp/bench-metrics-labels.json"
+          LABELS_FILE="$(mktemp "${RUNNER_TEMP:-/tmp}/bench-metrics-labels.XXXXXX")"
           echo '{}' > "$LABELS_FILE"
           echo "BENCH_LABELS_FILE=${LABELS_FILE}" >> "$GITHUB_ENV"
 
-          python3 .github/scripts/bench-metrics-proxy.py \
-            --labels "$LABELS_FILE" \
-            --upstream "http://${BENCH_METRICS_ADDR}/" \
-            --subnet 10.10.0.0/24 \
-            --port 9090 &
-          PROXY_PID=$!
-          echo "BENCH_METRICS_PROXY_PID=${PROXY_PID}" >> "$GITHUB_ENV"
-          echo "Metrics proxy started (PID $PROXY_PID)"
-
-      - name: Update status (running benchmarks)
-        if: success() && env.BENCH_COMMENT_ID
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
-        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
-      # 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 }}"
+      # Extract txgen payloads once so they are reused across all benchmark
+      # runs instead of re-fetching from the remote RPC for every run.
+      - name: Extract txgen payloads
         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
+          PAYLOADS_DIR="$BENCH_WORK_DIR/txgen-payloads"
+          .github/scripts/bench-txgen-extract.sh \
+            "../reth-feature/target/profiling/${BENCH_NODE_BIN}" \
+            "$PAYLOADS_DIR"
+          echo "TXGEN_PAYLOADS_DIR=${PAYLOADS_DIR}" >> "$GITHUB_ENV"
+
+      # Interleaved run order (A=feature, B=baseline) to reduce systematic bias
+      # from thermal drift and cache warming.
+      - name: Run benchmarks
+        id: run-benchmarks
         env:
           BASELINE_REF: ${{ steps.refs.outputs.baseline-ref }}
-          OTEL_RESOURCE_ATTRIBUTES: "benchmark_id=${{ env.BENCH_ID }},benchmark_run=baseline-1,run_type=baseline,git_ref=${{ steps.refs.outputs.baseline-ref }}"
+          FEATURE_REF: ${{ steps.refs.outputs.feature-ref }}
+          BENCH_GH_TOKEN: ${{ secrets.DEREK_PAT }}
         run: |
-          LAST_RUN_START=$(date +%s)
-          echo "BENCH_LAST_RUN_START=${LAST_RUN_START}" >> "$GITHUB_ENV"
-          cat > "$BENCH_LABELS_FILE" <<LABELS
-          {"benchmark_run":"baseline-1","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-1"
+          set -euo pipefail
 
-      - 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"
+          build_run_order() {
+            local run_pairs="$1"
+            if ! [[ "$run_pairs" =~ ^[1-9][0-9]*$ ]]; then
+              echo "run pairs must be a positive integer" >&2
+              return 1
+            fi
+            if [ $((run_pairs % 2)) -eq 0 ]; then
+              printf 'ABBA%.0s' $(seq 1 $((run_pairs / 2)))
+            else
+              printf 'AB%.0s' $(seq 1 "$run_pairs")
+            fi
+            echo
+          }
 
-      - name: "Run benchmark: feature (2/2)"
-        if: env.BENCH_ABBA != 'false'
-        id: run-feature-2
-        env:
-          FEATURE_REF: ${{ steps.refs.outputs.feature-ref }}
-          OTEL_RESOURCE_ATTRIBUTES: "benchmark_id=${{ env.BENCH_ID }},benchmark_run=feature-2,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-2","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}"}
+          RUN_ORDER="$(build_run_order "${BENCH_RUN_PAIRS:-6}")"
+          echo "BENCH_RUN_ORDER=${RUN_ORDER}" >> "$GITHUB_ENV"
+          echo "${RUN_ORDER}" > "$BENCH_WORK_DIR/run_order.txt"
+          echo "Run order: ${RUN_ORDER} (A=feature, B=baseline)"
+
+          run_total="${#RUN_ORDER}"
+          run_progress=0
+          feature_index=0
+          baseline_index=0
+
+          for ((i = 0; i < ${#RUN_ORDER}; i++)); do
+            side="${RUN_ORDER:i:1}"
+            if [ "$side" = "A" ]; then
+              run_type="feature"
+              feature_index=$((feature_index + 1))
+              run_index="$feature_index"
+              ref="$FEATURE_REF"
+              binary="../reth-feature/target/profiling/${BENCH_NODE_BIN}"
+            elif [ "$side" = "B" ]; then
+              run_type="baseline"
+              baseline_index=$((baseline_index + 1))
+              run_index="$baseline_index"
+              ref="$BASELINE_REF"
+              binary="../reth-baseline/target/profiling/${BENCH_NODE_BIN}"
+            else
+              echo "::error::Invalid run-order entry '${side}'"
+              exit 1
+            fi
+
+            run_progress=$((run_progress + 1))
+            run_label="${run_type}-${run_index}"
+            .github/scripts/bench-update-status.sh "Running benchmark: ${run_label} (${run_progress}/${run_total})..."
+            LAST_RUN_START=$(date +%s)
+            echo "BENCH_LAST_RUN_START=${LAST_RUN_START}" >> "$GITHUB_ENV"
+            export OTEL_RESOURCE_ATTRIBUTES="benchmark_id=${BENCH_ID},benchmark_run=${run_label},run_type=${run_type},git_ref=${ref}"
+            cat > "$BENCH_LABELS_FILE" <<LABELS
+          {"benchmark_run":"${run_label}","run_type":"${run_type}","git_ref":"${ref}","bench_sha":"${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-2"
+            taskset -c 0 .github/scripts/bench-txgen-run.sh "$run_type" "$binary" "$BENCH_WORK_DIR/${run_label}"
+          done
+
+          .github/scripts/bench-update-status.sh "Finalizing results..."
 
-      - name: Stop metrics proxy & generate Grafana URL
+      - name: Generate observability URLs
         id: metrics
         if: "!cancelled()"
         run: |
-          kill "$BENCH_METRICS_PROXY_PID" 2>/dev/null || true
-
-          LAST_RUN_DURATION=$(( $(date +%s) - BENCH_LAST_RUN_START ))
           FROM_MS=$(( BENCH_REFERENCE_EPOCH * 1000 ))
-          TO_MS=$(( (BENCH_REFERENCE_EPOCH + LAST_RUN_DURATION) * 1000 ))
-          GRAFANA_URL="https://tempoxyz.grafana.net/d/reth-bench-ghr/reth-bench-ghr?orgId=1&from=${FROM_MS}&to=${TO_MS}&timezone=browser&var-datasource=ef57fux92e9z4e&var-job=reth-bench&var-benchmark_id=${BENCH_ID}&var-benchmark_run=\$__all"
+          TO_MS=$(( $(date +%s) * 1000 ))
+          GRAFANA_URL="https://tempoxyz.grafana.net/d/reth-bench-ghr/reth-bench-ghr?orgId=1&from=${FROM_MS}&to=${TO_MS}&timezone=browser&var-datasource=efk1hcn87dnnkd&var-job=github-reth-bench&var-benchmark_id=${BENCH_ID}&var-benchmark_run=\$__all"
+          OBSERVABILITY_URLS="$(python3 - "$BENCH_ID" "$FROM_MS" "$TO_MS" <<'PY'
+          from datetime import datetime, timezone
+          import json
+          import sys
+          from urllib.parse import quote
+
+          bench_id, from_ms, to_ms = sys.argv[1:4]
+          logs_uid = "cfk1hzy08xekgd"
+          traces_uid = "dfk1hrnxca9s0a"
+
+          def iso_from_epoch_ms(ms):
+              dt = datetime.fromtimestamp(int(ms) / 1000, tz=timezone.utc)
+              return dt.isoformat(timespec="milliseconds").replace("+00:00", "Z")
+
+          from_time = iso_from_epoch_ms(from_ms)
+          to_time = iso_from_epoch_ms(to_ms)
+
+          def explore_url(panes):
+              encoded = quote(json.dumps(panes, separators=(",", ":")), safe="")
+              return f"https://tempoxyz.grafana.net/explore?schemaVersion=1&panes={encoded}&orgId=1"
+
+          logs_pane = {
+              "pw4": {
+                  "datasource": logs_uid,
+                  "queries": [{
+                      "refId": "A",
+                      "datasource": {"type": "victoriametrics-logs-datasource", "uid": logs_uid},
+                      "editorMode": "code",
+                      "expr": f"benchmark_id:{bench_id}",
+                      "queryType": "instant",
+                  }],
+                  "range": {"from": from_time, "to": to_time},
+                  "panelsState": {
+                      "logs": {
+                          "sortOrder": "Descending",
+                          "columns": ["Time", "Line"],
+                          "visualisationType": "table",
+                          "labelFieldName": "labels",
+                      },
+                  },
+                  "compact": False,
+              },
+          }
+          traceql_query = "{resource.benchmark_id=" + json.dumps(bench_id) + "}"
+          traces_pane = {
+              "g39": {
+                  "datasource": traces_uid,
+                  "queries": [{
+                      "refId": "A",
+                      "datasource": {"type": "tempo", "uid": traces_uid},
+                      "queryType": "traceqlSearch",
+                      "serviceMapUseNativeHistograms": False,
+                      "filters": [
+                          {
+                              "id": "benchmark-id",
+                              "operator": "=",
+                              "scope": "resource",
+                              "tag": "benchmark_id",
+                              "value": [bench_id],
+                              "valueType": "string",
+                              "isCustomValue": True,
+                          },
+                      ],
+                      "query": traceql_query,
+                  }],
+                  "range": {"from": from_time, "to": to_time},
+                  "panelsState": {"logs": {"visualisationType": "table"}},
+                  "compact": False,
+              },
+          }
+
+          print(explore_url(logs_pane))
+          print(explore_url(traces_pane))
+          PY
+          )"
+          LOGS_URL="$(printf '%s\n' "$OBSERVABILITY_URLS" | sed -n '1p')"
+          TRACES_URL="$(printf '%s\n' "$OBSERVABILITY_URLS" | sed -n '2p')"
           echo "grafana-url=${GRAFANA_URL}" >> "$GITHUB_OUTPUT"
+          echo "logs-url=${LOGS_URL}" >> "$GITHUB_OUTPUT"
+          echo "traces-url=${TRACES_URL}" >> "$GITHUB_OUTPUT"
+          echo "observability-from-ms=${FROM_MS}" >> "$GITHUB_OUTPUT"
+          echo "observability-to-ms=${TO_MS}" >> "$GITHUB_OUTPUT"
           echo "Grafana URL: ${GRAFANA_URL}"
+          echo "Logs URL: ${LOGS_URL}"
+          echo "Traces URL: ${TRACES_URL}"
 
       - name: Scan logs for errors
         if: "!cancelled()"
         run: |
           ERRORS_FILE="$BENCH_WORK_DIR/errors.md"
           found=false
-          for run_dir in baseline-1 feature-1 feature-2 baseline-2; do
+          mapfile -t RUN_DIRS < <(find "$BENCH_WORK_DIR" -mindepth 1 -maxdepth 1 -type d \( -name 'baseline-*' -o -name 'feature-*' \) -printf '%f\n' | sort -V)
+          for run_dir in "${RUN_DIRS[@]}"; do
             LOG="$BENCH_WORK_DIR/$run_dir/node.log"
             if [ ! -f "$LOG" ]; then continue; fi
 
@@ -1057,7 +1304,8 @@ jobs:
           PROFILER_API="https://api.profiler.firefox.com"
           PROFILER_ACCEPT="Accept: application/vnd.firefox-profiler+json;version=1.0"
 
-          for run_dir in baseline-1 baseline-2 feature-1 feature-2; do
+          mapfile -t RUN_DIRS < <(find "$BENCH_WORK_DIR" -mindepth 1 -maxdepth 1 -type d \( -name 'baseline-*' -o -name 'feature-*' \) -printf '%f\n' | sort -V)
+          for run_dir in "${RUN_DIRS[@]}"; do
             PROFILE="$BENCH_WORK_DIR/$run_dir/samply-profile.json.gz"
             if [ ! -f "$PROFILE" ]; then continue; fi
 
@@ -1096,6 +1344,13 @@ jobs:
           done
 
       # Results & charts
+      - name: Upload raw results
+        if: success()
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: bench-raw-results
+          path: ${{ env.BENCH_WORK_DIR }}
+
       - name: Parse results
         id: results
         if: success()
@@ -1119,15 +1374,15 @@ jobs:
           SUMMARY_ARGS="$SUMMARY_ARGS --baseline-name ${BASELINE_NAME}"
           SUMMARY_ARGS="$SUMMARY_ARGS --feature-name ${FEATURE_NAME}"
           SUMMARY_ARGS="$SUMMARY_ARGS --feature-ref ${FEATURE_REF}"
-          BASELINE_CSVS="$BENCH_WORK_DIR/baseline-1/combined_latency.csv"
-          FEATURE_CSVS="$BENCH_WORK_DIR/feature-1/combined_latency.csv"
-          if [ "${BENCH_ABBA:-true}" = "true" ]; then
-            BASELINE_CSVS="$BASELINE_CSVS $BENCH_WORK_DIR/baseline-2/combined_latency.csv"
-            FEATURE_CSVS="$FEATURE_CSVS $BENCH_WORK_DIR/feature-2/combined_latency.csv"
+          mapfile -t BASELINE_CSVS < <(find "$BENCH_WORK_DIR" -path "$BENCH_WORK_DIR/baseline-*/combined_latency.csv" -type f | sort -V)
+          mapfile -t FEATURE_CSVS < <(find "$BENCH_WORK_DIR" -path "$BENCH_WORK_DIR/feature-*/combined_latency.csv" -type f | sort -V)
+          if [ "${#BASELINE_CSVS[@]}" -eq 0 ] || [ "${#FEATURE_CSVS[@]}" -eq 0 ]; then
+            echo "::error::Missing baseline or feature benchmark CSVs"
+            exit 1
           fi
-          SUMMARY_ARGS="$SUMMARY_ARGS --baseline-csv $BASELINE_CSVS"
-          SUMMARY_ARGS="$SUMMARY_ARGS --feature-csv $FEATURE_CSVS"
-          SUMMARY_ARGS="$SUMMARY_ARGS --gas-csv $BENCH_WORK_DIR/feature-1/total_gas.csv"
+          SUMMARY_ARGS="$SUMMARY_ARGS --baseline-csv ${BASELINE_CSVS[*]}"
+          SUMMARY_ARGS="$SUMMARY_ARGS --feature-csv ${FEATURE_CSVS[*]}"
+          SUMMARY_ARGS="$SUMMARY_ARGS --run-pairs ${BENCH_RUN_PAIRS:-6}"
           if [ "$BEHIND_BASELINE" -gt 0 ]; then
             SUMMARY_ARGS="$SUMMARY_ARGS --behind-baseline $BEHIND_BASELINE"
           fi
@@ -1143,10 +1398,30 @@ jobs:
           if [ -n "${BENCH_BAL:-}" ] && [ "${BENCH_BAL}" != "false" ]; then
             SUMMARY_ARGS="$SUMMARY_ARGS --bal-mode $BENCH_BAL"
           fi
+          if [ -n "${BENCH_ID:-}" ]; then
+            SUMMARY_ARGS="$SUMMARY_ARGS --benchmark-id $BENCH_ID"
+          fi
           GRAFANA_URL='${{ steps.metrics.outputs.grafana-url }}'
-          if [ -n "$GRAFANA_URL" ]; then
+          if [ "${BENCH_METRICS:-false}" = "true" ] && [ -n "$GRAFANA_URL" ]; then
             SUMMARY_ARGS="$SUMMARY_ARGS --grafana-url $GRAFANA_URL"
           fi
+          LOGS_URL='${{ steps.metrics.outputs.logs-url }}'
+          if [ -n "$LOGS_URL" ]; then
+            SUMMARY_ARGS="$SUMMARY_ARGS --logs-url $LOGS_URL"
+          fi
+          TRACES_URL='${{ steps.metrics.outputs.traces-url }}'
+          if [ -n "$TRACES_URL" ]; then
+            SUMMARY_ARGS="$SUMMARY_ARGS --traces-url $TRACES_URL"
+          fi
+          OBSERVABILITY_FROM_MS='${{ steps.metrics.outputs.observability-from-ms }}'
+          OBSERVABILITY_TO_MS='${{ steps.metrics.outputs.observability-to-ms }}'
+          if [ -n "$OBSERVABILITY_FROM_MS" ] && [ -n "$OBSERVABILITY_TO_MS" ]; then
+            SUMMARY_ARGS="$SUMMARY_ARGS --observability-from-ms $OBSERVABILITY_FROM_MS"
+            SUMMARY_ARGS="$SUMMARY_ARGS --observability-to-ms $OBSERVABILITY_TO_MS"
+          fi
+          if [ -n "${BENCH_TARGET_METRICS_CONFIG:-}" ]; then
+            SUMMARY_ARGS="$SUMMARY_ARGS --target-metrics-config $BENCH_TARGET_METRICS_CONFIG"
+          fi
           # shellcheck disable=SC2086
           python3 .github/scripts/bench-reth-summary.py $SUMMARY_ARGS
 
@@ -1157,14 +1432,14 @@ jobs:
           FEATURE_NAME: ${{ steps.refs.outputs.feature-name }}
         run: |
           CHART_ARGS="--output-dir $BENCH_WORK_DIR/charts"
-          FEATURE_CSVS="$BENCH_WORK_DIR/feature-1/combined_latency.csv"
-          BASELINE_CSVS="$BENCH_WORK_DIR/baseline-1/combined_latency.csv"
-          if [ "${BENCH_ABBA:-true}" = "true" ]; then
-            FEATURE_CSVS="$FEATURE_CSVS $BENCH_WORK_DIR/feature-2/combined_latency.csv"
-            BASELINE_CSVS="$BASELINE_CSVS $BENCH_WORK_DIR/baseline-2/combined_latency.csv"
+          mapfile -t FEATURE_CSVS < <(find "$BENCH_WORK_DIR" -path "$BENCH_WORK_DIR/feature-*/combined_latency.csv" -type f | sort -V)
+          mapfile -t BASELINE_CSVS < <(find "$BENCH_WORK_DIR" -path "$BENCH_WORK_DIR/baseline-*/combined_latency.csv" -type f | sort -V)
+          if [ "${#BASELINE_CSVS[@]}" -eq 0 ] || [ "${#FEATURE_CSVS[@]}" -eq 0 ]; then
+            echo "::error::Missing baseline or feature benchmark CSVs"
+            exit 1
           fi
-          CHART_ARGS="$CHART_ARGS --feature $FEATURE_CSVS"
-          CHART_ARGS="$CHART_ARGS --baseline $BASELINE_CSVS"
+          CHART_ARGS="$CHART_ARGS --feature ${FEATURE_CSVS[*]}"
+          CHART_ARGS="$CHART_ARGS --baseline ${BASELINE_CSVS[*]}"
           CHART_ARGS="$CHART_ARGS --baseline-name ${BASELINE_NAME}"
           CHART_ARGS="$CHART_ARGS --feature-name ${FEATURE_NAME}"
           # shellcheck disable=SC2086
@@ -1174,10 +1449,10 @@ jobs:
         if: "!cancelled()"
         uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
-          name: bench-reth-results
+          name: bench-results
           path: ${{ env.BENCH_WORK_DIR }}
 
-      - name: Push charts
+      - name: Push benchmark artifacts
         id: push-charts
         if: success()
         env:
@@ -1189,40 +1464,80 @@ jobs:
           CHARTS_REPO="https://x-access-token:${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
+          if git clone --depth 1 --filter=blob:none --sparse "${CHARTS_REPO}" "${TMP_DIR}" 2>/dev/null; then
+            git -C "${TMP_DIR}" sparse-checkout set --no-cone "${CHART_DIR}"
             true
           else
             git init "${TMP_DIR}"
             git -C "${TMP_DIR}" remote add origin "${CHARTS_REPO}"
           fi
+          .github/scripts/configure-git-token-user.sh "${TMP_DIR}" "${DEREK_TOKEN}"
 
           mkdir -p "${TMP_DIR}/${CHART_DIR}"
           cp "$BENCH_WORK_DIR"/charts/*.png "${TMP_DIR}/${CHART_DIR}/"
+          if [ "${BENCH_TRACING_CHROME:-false}" = "true" ]; then
+            TRACE_DIR="${CHART_DIR}/tracing-chrome"
+            mkdir -p "${TMP_DIR}/${TRACE_DIR}"
+            mapfile -t RUN_DIRS < <(find "$BENCH_WORK_DIR" -mindepth 1 -maxdepth 1 -type d \( -name 'baseline-*' -o -name 'feature-*' \) -printf '%f\n' | sort -V)
+            for run_dir in "${RUN_DIRS[@]}"; do
+              TRACE="$BENCH_WORK_DIR/$run_dir/tracing-chrome-profile.json"
+              if [ ! -f "$TRACE" ]; then continue; fi
+
+              TRACE_SIZE=$(du -h "$TRACE" | cut -f1)
+              echo "Adding $run_dir Chrome trace (${TRACE_SIZE}) to benchmark artifacts..."
+              gzip -c "$TRACE" > "${TMP_DIR}/${TRACE_DIR}/${run_dir}.json.gz"
+            done
+          fi
           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
+            echo "Artifacts for ${CHART_DIR} are already present, skipping push"
+            PUSH_SHA="$(git -C "${TMP_DIR}" rev-parse HEAD)"
+          else
+            git -C "${TMP_DIR}" commit -m "bench artifacts 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 benchmark artifacts 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
+
+            PUSH_SHA="$(git -C "${TMP_DIR}" rev-parse HEAD)"
           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
+          if [ "${BENCH_TRACING_CHROME:-false}" = "true" ]; then
+            RAW_BASE="https://raw.githubusercontent.com/decofe/reth-bench-charts/${PUSH_SHA}/${CHART_DIR}/tracing-chrome"
+            mapfile -t RUN_DIRS < <(find "$BENCH_WORK_DIR" -mindepth 1 -maxdepth 1 -type d \( -name 'baseline-*' -o -name 'feature-*' \) -printf '%f\n' | sort -V)
+            for run_dir in "${RUN_DIRS[@]}"; do
+              if [ ! -f "${TMP_DIR}/${CHART_DIR}/tracing-chrome/${run_dir}.json.gz" ]; then continue; fi
+
+              RAW_URL="${RAW_BASE}/${run_dir}.json.gz"
+              PERFETTO_URL="$(python3 - "$RAW_URL" "${run_dir}.json.gz" <<'PY'
+          import sys
+          from urllib.parse import quote
+
+          raw_url, file_name = sys.argv[1:3]
+          print(
+              "https://ui.perfetto.dev/#!/?url="
+              + quote(raw_url, safe="")
+              + "&fileName="
+              + quote(file_name, safe="")
+          )
+          PY
+          )"
+              echo "$PERFETTO_URL" > "$BENCH_WORK_DIR/$run_dir/tracing-chrome-profile-url.txt"
+              echo "Perfetto URL for $run_dir: $PERFETTO_URL"
+            done
+          fi
 
-          echo "sha=$(git -C "${TMP_DIR}" rev-parse HEAD)" >> "$GITHUB_OUTPUT"
+          echo "sha=${PUSH_SHA}" >> "$GITHUB_OUTPUT"
           rm -rf "${TMP_DIR}"
 
       - name: Compare & comment
@@ -1262,26 +1577,27 @@ 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 { loadSamplyUrls } = require('./.github/scripts/bench-utils');
+              const samplyUrls = loadSamplyUrls(process.env.BENCH_WORK_DIR);
               const links = [];
-              for (const run of runs) {
-                try {
-                  const url = fs.readFileSync(`${process.env.BENCH_WORK_DIR}/${run}/samply-profile-url.txt`, 'utf8').trim();
-                  if (url) {
-                    links.push(`- **${run}**: [Firefox Profiler](${url})`);
-                  }
-                } catch (e) {}
+              for (const [run, url] of Object.entries(samplyUrls)) {
+                links.push(`- **${run}**: [Firefox Profiler](${url})`);
               }
               if (links.length > 0) {
                 comment += `\n\n### Samply Profiles\n\n${links.join('\n')}\n`;
               }
             }
 
-            // Grafana dashboard link
-            const grafanaUrl = '${{ steps.metrics.outputs.grafana-url }}';
-            if (grafanaUrl) {
-              comment += `\n\n### Grafana Dashboard\n\n[View real-time metrics](${grafanaUrl})\n`;
+            if (process.env.BENCH_TRACING_CHROME === 'true') {
+              const { loadTracingChromeUrls } = require('./.github/scripts/bench-utils');
+              const tracingChromeUrls = loadTracingChromeUrls(process.env.BENCH_WORK_DIR);
+              const links = [];
+              for (const [run, url] of Object.entries(tracingChromeUrls)) {
+                links.push(`- **${run}**: [Perfetto](${url})`);
+              }
+              if (links.length > 0) {
+                comment += `\n\n### Chrome Traces\n\n${links.join('\n')}\n`;
+              }
             }
 
             // Node errors (panics / ERROR logs)
@@ -1315,7 +1631,8 @@ jobs:
               core,
               context,
               chartSha: '${{ steps.push-charts.outputs.sha }}',
-              grafanaUrl: '${{ steps.metrics.outputs.grafana-url }}',
+              logsUrl: '${{ steps.metrics.outputs.logs-url }}',
+              tracesUrl: '${{ steps.metrics.outputs.traces-url }}',
               runId: '${{ github.run_id }}',
             });
 
@@ -1336,16 +1653,11 @@ jobs:
         with:
           github-token: ${{ secrets.DEREK_PAT }}
           script: |
-            const abba = (process.env.BENCH_ABBA || 'true') !== 'false';
-            const bigBlocks = process.env.BENCH_BIG_BLOCKS === 'true';
             const steps_status = [
-              ...(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 }}']] : []),
-              ...(abba ? [['running feature benchmark (2/2)', '${{ steps.run-feature-2.outcome }}']] : []),
+              ['syncing snapshot', '${{ steps.snapshot-check.outcome }}'],
+              ['running benchmarks', '${{ steps.run-benchmarks.outcome }}'],
+              ['parsing results', '${{ steps.results.outcome }}'],
             ];
             const failed = steps_status.find(([, o]) => o === 'failure');
             const failedStep = failed ? failed[0] : 'unknown step';
@@ -1374,16 +1686,11 @@ jobs:
           SLACK_BENCH_CHANNEL: ${{ secrets.SLACK_BENCH_CHANNEL }}
         with:
           script: |
-            const abba = (process.env.BENCH_ABBA || 'true') !== 'false';
-            const bigBlocks = process.env.BENCH_BIG_BLOCKS === 'true';
             const steps_status = [
-              ...(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 }}']] : []),
-              ...(abba ? [['running feature benchmark (2/2)', '${{ steps.run-feature-2.outcome }}']] : []),
+              ['syncing snapshot', '${{ steps.snapshot-check.outcome }}'],
+              ['running benchmarks', '${{ steps.run-benchmarks.outcome }}'],
+              ['parsing results', '${{ steps.results.outcome }}'],
             ];
             const failed = steps_status.find(([, o]) => o === 'failure');
             const failedStep = failed ? failed[0] : 'unknown step';
diff --git a/.github/workflows/book.yml b/.github/workflows/book.yml
index 142e5111482..363c5a34b70 100644
--- a/.github/workflows/book.yml
+++ b/.github/workflows/book.yml
@@ -45,6 +45,11 @@ jobs:
       - name: Build Vocs
         run: |
           cd docs/vocs/ && bun run build
+          test -f docs/dist/public/index.html
+          test -f docs/dist/public/overview/index.html
+          test -f docs/dist/public/sdk/index.html
+          test -f docs/dist/public/logo.png
+          test -f docs/dist/public/reth-prod.png
           echo "Vocs Build Complete"
 
       - name: Setup Pages
@@ -53,7 +58,7 @@ jobs:
       - name: Upload artifact
         uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0
         with:
-          path: "./docs/vocs/docs/dist"
+          path: "./docs/vocs/docs/dist/public"
 
   deploy:
     # Only deploy if a push to main
diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml
index 9d70351bbc1..0a50fb8b371 100644
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -48,7 +48,6 @@ jobs:
             --workspace \
             --exclude 'example-*' \
             --exclude 'exex-subscription' \
-            --exclude 'reth-bench' \
             --exclude 'ef-tests' \
             --exclude 'reth' \
             -E 'binary(e2e_testsuite)'
diff --git a/.github/workflows/fetch-grafana-dashboard.yml b/.github/workflows/fetch-grafana-dashboard.yml
index d6e1bd9ee5d..ffd5b9fd5c9 100644
--- a/.github/workflows/fetch-grafana-dashboard.yml
+++ b/.github/workflows/fetch-grafana-dashboard.yml
@@ -66,7 +66,9 @@ jobs:
           git checkout -b "$BRANCH"
           git add "$TARGET"
           git commit -m "chore: update Grafana dashboard ${FILENAME}"
-          git push origin "$BRANCH"
+          gh auth setup-git
+          git push --set-upstream origin "$BRANCH"
           gh pr create \
+            --head "$BRANCH" \
             --title "chore: update Grafana dashboard ${FILENAME}" \
             --body "Automated export from Grafana (dashboard UID: \`${DASHBOARD_UID}\`, target: \`${TARGET}\`)."
diff --git a/.github/workflows/hive.yml b/.github/workflows/hive.yml
index 29db6d87c7b..aaea0423d2f 100644
--- a/.github/workflows/hive.yml
+++ b/.github/workflows/hive.yml
@@ -270,8 +270,7 @@ jobs:
 
       - name: Print reth client logs
         if: ${{ failure() }}
-        run: |
-          cat hivetests/workspace/logs/reth/client-*.log
+        run: .github/scripts/hive/print_client_logs.sh
 
   test-osaka:
     timeout-minutes: 120
@@ -450,8 +449,7 @@ jobs:
 
       - name: Print reth client logs
         if: ${{ failure() }}
-        run: |
-          cat hivetests/workspace/logs/reth/client-*.log
+        run: .github/scripts/hive/print_client_logs.sh
   notify-on-error:
     needs:
       - test-amsterdam
diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index f6303710c55..6c370b2ae24 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -54,7 +54,7 @@ jobs:
         run: |
           cargo nextest run \
             --no-fail-fast \
-            --locked --features "asm-keccak ${{ matrix.network }}" \
+            --locked --features "asm-keccak" \
             --workspace --exclude ef-tests \
             -E "kind(test) and not binary(e2e_testsuite)"
 
@@ -71,7 +71,7 @@ jobs:
           jobs: ${{ toJSON(needs) }}
 
   era-files:
-    name: era1 file integration tests once a day
+    name: era/era1/ere file integration tests once a day
     if: github.event_name == 'schedule' && github.repository == 'paradigmxyz/reth'
     runs-on: ubuntu-latest
     permissions:
@@ -89,5 +89,5 @@ jobs:
       - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
         with:
           cache-on-failure: true
-      - name: run era1 files integration tests
+      - name: run era/era1/ere files integration tests
         run: cargo nextest run --no-fail-fast --release --package reth-era --test it -- --ignored
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 076a7a7fee9..14fe9c446b1 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -24,7 +24,7 @@ jobs:
         include:
           - type: ethereum
             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"
+            features: "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:
@@ -258,7 +258,7 @@ jobs:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
-      - uses: crate-ci/typos@02ea592e44b3a53c302f697cddca7641cd051c3d # v1.45.0
+      - uses: crate-ci/typos@aca895bf05aec0cb7dffa6f94495e923224d9f17 # v1.46.2
 
   check-toml:
     runs-on: ubuntu-latest
diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
index 66ef4863448..44c6b11eb9b 100644
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@@ -29,4 +29,5 @@ jobs:
           close-issue-message: "This issue was closed because it has been inactive for 7 days since being marked as stale."
           exempt-all-milestones: true
           exempt-all-assignees: true
+          operations-per-run: 1000
           repo-token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/unit.yml b/.github/workflows/unit.yml
index 547ef5858aa..ed6ab1c7ad9 100644
--- a/.github/workflows/unit.yml
+++ b/.github/workflows/unit.yml
@@ -32,7 +32,7 @@ jobs:
         type: [ethereum]
         include:
           - type: ethereum
-            features: asm-keccak ethereum
+            features: asm-keccak
             exclude_args: ""
     timeout-minutes: 30
     steps:
diff --git a/.gitignore b/.gitignore
index 64a561a3dd9..4a44168e7c9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -60,6 +60,9 @@ book/sources/Cargo.lock
 # vocs node_modules
 docs/vocs/node_modules
 
+# Generated by Waku/Vocs route typegen
+docs/vocs/docs/pages.gen.ts
+
 # Cargo chef recipe file
 recipe.json
 
diff --git a/Cargo.lock b/Cargo.lock
index 54d76a731c1..76ebf6ab7bf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -23,7 +23,7 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
 dependencies = [
- "crypto-common",
+ "crypto-common 0.1.7",
  "generic-array",
 ]
 
@@ -121,42 +121,16 @@ dependencies = [
 
 [[package]]
 name = "alloy-consensus"
-version = "1.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f16daaf7e1f95f62c6c3bf8a3fc3d78b08ae9777810c0bb5e94966c7cd57ef0"
-dependencies = [
- "alloy-eips 1.8.3",
- "alloy-primitives",
- "alloy-rlp",
- "alloy-serde 1.8.3",
- "alloy-trie",
- "alloy-tx-macros 1.8.3",
- "auto_impl",
- "borsh",
- "c-kzg",
- "derive_more",
- "either",
- "k256",
- "once_cell",
- "secp256k1 0.30.0",
- "serde",
- "serde_json",
- "serde_with",
- "thiserror 2.0.18",
-]
-
-[[package]]
-name = "alloy-consensus"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3d64da86c616b5092ea64eea648f311bbd58630a0b384c42d699175d6f9122b"
+checksum = "83447eeb17816e172f1dfc0db1f9dc0b7c5d069bd1f7cecbecceb382bf931015"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "alloy-trie",
- "alloy-tx-macros 2.0.4",
+ "alloy-tx-macros",
  "arbitrary",
  "auto_impl",
  "borsh",
@@ -175,26 +149,26 @@ dependencies = [
 
 [[package]]
 name = "alloy-consensus-any"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fd98696ca3617d3a9ba1a6f2011880cbfd5618228dab6400c9f8bca457859a8"
+checksum = "5406343e306856dc2be762700e98a16904de45dee14a07f233e742ce68daff2f"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "arbitrary",
  "serde",
 ]
 
 [[package]]
 name = "alloy-contract"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3df0aadc569a8b277808a7d0ad0e421180654ea36a3c59e9ed2bb968c9a1cd"
+checksum = "3ae8b60d71b92824e095b4003ff01fd2bc923017b7568997c5f459240e83499c"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-dyn-abi",
  "alloy-json-abi",
  "alloy-network",
@@ -213,9 +187,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-dyn-abi"
-version = "1.5.7"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc2db5c583aaef0255aa63a4fe827f826090142528bba48d1bf4119b62780cad"
+checksum = "a475bb02d9cef2dbb99065c1664ab3fe1f9352e21d6d5ed3f02cdbfc06ed1abc"
 dependencies = [
  "alloy-json-abi",
  "alloy-primitives",
@@ -225,7 +199,7 @@ dependencies = [
  "itoa",
  "serde",
  "serde_json",
- "winnow 0.7.15",
+ "winnow 1.0.1",
 ]
 
 [[package]]
@@ -276,9 +250,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-eip7928"
-version = "0.3.4"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "407510740da514b694fecb44d8b3cebdc60d448f70cc5d24743e8ba273448a6e"
+checksum = "6b827a6d7784fe3eb3489d40699407a4cdcce74271421a01bdffe60cf573bb16"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
@@ -286,44 +260,37 @@ dependencies = [
  "borsh",
  "once_cell",
  "serde",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "alloy-eips"
-version = "1.8.3"
+name = "alloy-eip7928"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6ef28c9fdad22d4eec52d894f5f2673a0895f1e5ef196734568e68c0f6caca8"
+checksum = "4d93ce7e41bcd2b9ee2c1d92c223c1be4a274d387538d6d3f956b768986ce451"
 dependencies = [
- "alloy-eip2124",
- "alloy-eip2930",
- "alloy-eip7702",
- "alloy-eip7928",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 1.8.3",
- "auto_impl",
+ "arbitrary",
  "borsh",
- "c-kzg",
- "derive_more",
- "either",
+ "once_cell",
  "serde",
- "serde_with",
- "sha2",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
 name = "alloy-eips"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64c0456f5f7a4497e9342d20f528e30f5288ddfa0d6a012bd5044afee46cd8a0"
+checksum = "0dca4c89ace90684b4b77366d00631ed498c9af962079af2a5dbc593a0618a77"
 dependencies = [
  "alloy-eip2124",
  "alloy-eip2930",
  "alloy-eip7702",
- "alloy-eip7928",
+ "alloy-eip7928 0.3.7",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "arbitrary",
  "auto_impl",
  "borsh",
@@ -339,11 +306,11 @@ dependencies = [
 
 [[package]]
 name = "alloy-evm"
-version = "0.34.0"
-source = "git+https://github.com/streamingfast/evm.git?branch=sf%2Fv0.34.0#49b4c64c3bc768ef687fdba27b0d9bada749d3e9"
+version = "0.36.0"
+source = "git+https://github.com/streamingfast/evm.git?branch=sf%2Fv0.36.0#4d8888f94cb28388fd3b223ac3dfdcaf41ef4583"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-hardforks 0.4.7",
  "alloy-primitives",
  "alloy-rpc-types-engine",
@@ -358,28 +325,13 @@ dependencies = [
 
 [[package]]
 name = "alloy-genesis"
-version = "1.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbf9480307b09d22876efb67d30cadd9013134c21f3a17ec9f93fd7536d38024"
-dependencies = [
- "alloy-eips 1.8.3",
- "alloy-primitives",
- "alloy-serde 1.8.3",
- "alloy-trie",
- "borsh",
- "serde",
- "serde_with",
-]
-
-[[package]]
-name = "alloy-genesis"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a71ff8b55d2b8aa05259f474cae7dea0e4991724dc18936b81cb23ec492a0c2a"
+checksum = "ab0e0fe9e6d1120ad7bb9254c3fc2b9bc80a8df42a033fb626be6559c13d5153"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-primitives",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "alloy-trie",
  "borsh",
  "serde",
@@ -415,9 +367,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-json-abi"
-version = "1.5.7"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9dbe713da0c737d9e5e387b0ba790eb98b14dd207fe53eef50e19a5a8ec3dac"
+checksum = "7c36c9d7f9021601b04bfef14a4b64849f6d73116a4e91e071d7fbfe10247901"
 dependencies = [
  "alloy-primitives",
  "alloy-sol-type-parser",
@@ -427,9 +379,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-json-rpc"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19e352478b756bad5d7203148e4b461861282ea2ded3da406ba24868b52cd098"
+checksum = "ec0a82e56b1843bce483942d54fcadea92e676f1bde162e93c7d3b621fabc4e1"
 dependencies = [
  "alloy-primitives",
  "alloy-sol-types",
@@ -442,19 +394,19 @@ dependencies = [
 
 [[package]]
 name = "alloy-network"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed08ae169869e08370ed121612e0d3dadac33d1a256e9f2465926b23f0bd7d95"
+checksum = "a7db7b095b0b1db1d18ce7e91dcd2e82007f2d52bfb8125e6b64633a74a06bc3"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-consensus-any",
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-json-rpc",
  "alloy-network-primitives",
  "alloy-primitives",
  "alloy-rpc-types-any",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "alloy-signer",
  "alloy-sol-types",
  "async-trait",
@@ -468,24 +420,24 @@ dependencies = [
 
 [[package]]
 name = "alloy-network-primitives"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02e6c7ad28afe348a9a9c5624b67ee5b3607b8de98d5816b3056ecdfa6fa2697"
+checksum = "cd28d9bfd11729037d194f2b1d43db8642eb3f342032691f4ca96bb745479c3c"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "serde",
 ]
 
 [[package]]
 name = "alloy-node-bindings"
-version = "2.0.0"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85195890fcee519312718dc8418035935ad0d57f57943ca82689732432a702c9"
+checksum = "c3f2f7dac66147d165063c670dabca7b34807428130bef4583a7976523140f8d"
 dependencies = [
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "alloy-hardforks 0.2.13",
  "alloy-network",
  "alloy-primitives",
@@ -503,9 +455,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-primitives"
-version = "1.5.7"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3b431b4e72cd8bd0ec7a50b4be18e73dab74de0dba180eef171055e5d5926e"
+checksum = "4885c1409b6936c4898e646ef58baf6ec54edaf6d8179f79df805a7b85b7cf3e"
 dependencies = [
  "alloy-rlp",
  "arbitrary",
@@ -516,31 +468,32 @@ dependencies = [
  "fixed-cache",
  "foldhash 0.2.0",
  "getrandom 0.4.2",
- "hashbrown 0.16.1",
+ "hashbrown 0.17.0",
  "indexmap 2.14.0",
  "itoa",
  "k256",
  "keccak-asm",
  "paste",
  "proptest",
- "proptest-derive",
+ "proptest-derive 0.8.0",
  "rand 0.9.4",
  "rapidhash",
  "ruint",
  "rustc-hash",
+ "secp256k1 0.31.1",
  "serde",
- "sha3",
+ "sha3 0.11.0",
 ]
 
 [[package]]
 name = "alloy-provider"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93a7c17472b55482d4734154c2f5ed13f72e03f6752cebb927f6a2d8b52e646c"
+checksum = "8955ab30418343de57b356de2ea60200f9fb8016a7ea3bc7f5c6176f01a8b1cf"
 dependencies = [
  "alloy-chains",
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-json-rpc",
  "alloy-network",
  "alloy-network-primitives",
@@ -548,7 +501,6 @@ dependencies = [
  "alloy-pubsub",
  "alloy-rpc-client",
  "alloy-rpc-types-debug",
- "alloy-rpc-types-engine",
  "alloy-rpc-types-eth",
  "alloy-rpc-types-trace",
  "alloy-signer",
@@ -567,7 +519,7 @@ dependencies = [
  "lru",
  "parking_lot",
  "pin-project",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "serde",
  "serde_json",
  "thiserror 2.0.18",
@@ -579,9 +531,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-pubsub"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8d86958b02bca85103d64fa60d7b364a8b017c6e40f2b02c3f50ca22964a738"
+checksum = "7cd85cfea1fa8ebd20d3475e961fe3a3624c0eb4659ea137715c0c83c8aeaff0"
 dependencies = [
  "alloy-json-rpc",
  "alloy-primitives",
@@ -623,9 +575,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-client"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5beb5c2fe6b960c8e8b038e69fd502a90a2e930afa4770efb748b163b0767729"
+checksum = "24f461f091dc8f657e73b5dea18fd63d5c7049720cd252f1eade4a7ebed6a7e1"
 dependencies = [
  "alloy-json-rpc",
  "alloy-primitives",
@@ -636,7 +588,7 @@ dependencies = [
  "alloy-transport-ws",
  "futures",
  "pin-project",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "serde",
  "serde_json",
  "tokio",
@@ -649,24 +601,24 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ee1257a278f6d293e05c5162c5940a1561b1aa85ded0028b464c81de37ebfa5"
+checksum = "052c031d1f7c5611997056bbcb8814e5cbf20f7efeee8c3de690555172038cf2"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "serde",
 ]
 
 [[package]]
 name = "alloy-rpc-types-admin"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2144d5b2866e651796eac0a997d3b5a056449c12e0d91be3184129e0c722885"
+checksum = "ef669b370940e7945a3a384cc4024038cd69ee658b71270d59c20b78dd8d20d4"
 dependencies = [
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "alloy-primitives",
  "serde",
  "serde_json",
@@ -674,38 +626,38 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-anvil"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df32156f085e74eac942b6103744be49b817c302341aaa8cb0c1c88dc29228d9"
+checksum = "2ff111a54268dc0bbd3b17f98571a7e27cc661dc081ad2999d91888647eb2e11"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "serde",
 ]
 
 [[package]]
 name = "alloy-rpc-types-any"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a234bfbdf7a76c3d13808f729af5321852de3dedcaa6fc6d5f54787aaf54c6a"
+checksum = "0a6561ed4759c974d9c144500a59e3fb8c1d87327a12900d5ce455c0cae6dcb6"
 dependencies = [
  "alloy-consensus-any",
  "alloy-network-primitives",
  "alloy-primitives",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "serde",
  "serde_json",
 ]
 
 [[package]]
 name = "alloy-rpc-types-beacon"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "296450f5e76bece0116c939b9437b0421a5da9c5d40031bf4cf9b38d3d94e475"
+checksum = "9a62f6ce2d95f59ed310bd90d5fd1566a29d1ec45cc219abbc5dcc807d31f136"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "derive_more",
@@ -721,9 +673,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-debug"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ab075ac1c25bcf697f133b7cd92e2fb26afe213e872ef79fdf77f0d7bcb3793"
+checksum = "48b9ad6eee93dd35a9ec0a6c1c6b180892a900ee17a6ed6500921552dd71e846"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
@@ -734,15 +686,15 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-engine"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73b12366c96f4013e1aeebc96c6b56e5f33f07853c42ea2f485045c0c157a4a1"
+checksum = "7eba59e1c069f168a01982f42a57797736923b76aa854194df4930be17867e1c"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "arbitrary",
  "derive_more",
  "ethereum_ssz",
@@ -755,17 +707,17 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-eth"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56a282daf869eeb7383d3d5c2deb35b0b3fb45ecb329513af4090fc61245ee18"
+checksum = "175a2a5b6017d7f61b5e4b800d21215fe8e94fe729d00828e13bb6d93dcf3492"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-consensus-any",
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-network-primitives",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "alloy-sol-types",
  "arbitrary",
  "itertools 0.14.0",
@@ -777,28 +729,28 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-mev"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7adc1243d55744a66b3a6cbbbba96436e8df5d248f2ee8186bef4238ef704ec7"
+checksum = "ed1004c1d68bfaee001712f83356f88031ab74a727b8560fb7fc738d1281ebe5"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "serde",
  "serde_json",
 ]
 
 [[package]]
 name = "alloy-rpc-types-trace"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6184b5d14152b68b0bb8beb621339d94f0b761a37958bb365fbf7c00922125c2"
+checksum = "514b4b1ce3354f65067b4fc7eb75358e0f2ec8be3340c96dea65d6894f9ca435"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "serde",
  "serde_json",
  "thiserror 2.0.18",
@@ -806,32 +758,21 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-txpool"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f00b631c361e7c7baaf4f1f5a9877730f3507fed2acb9d4b34841b8184b2ec28"
+checksum = "76e34a42ebb4a71ab0bfdebc6d2f3c7bf809f01edf154d08fed159d10d1ef1d4"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "serde",
 ]
 
 [[package]]
 name = "alloy-serde"
-version = "1.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11ece63b89294b8614ab3f483560c08d016930f842bf36da56bf0b764a15c11e"
-dependencies = [
- "alloy-primitives",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "alloy-serde"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0eada2558e921b39dfcead33c487364df9b31374f5733c1c9d2c891c4529933"
+checksum = "cc21a8772af7d78bba286726aa245bd2ff81cd9abe230afea2e91578996831c9"
 dependencies = [
  "alloy-primitives",
  "arbitrary",
@@ -841,9 +782,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-signer"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41eb29f7a8adcd8941fbb8e134022a133e6f8dfd345f2e3b7109599f8a7dca08"
+checksum = "8ffbce94c50dd9d4d1f83e044c5595bbd3ada981bd3057ce28b3a5470e77385d"
 dependencies = [
  "alloy-primitives",
  "async-trait",
@@ -856,11 +797,11 @@ dependencies = [
 
 [[package]]
 name = "alloy-signer-local"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef839e7ce9b59aa60fa9a175e97986c6145c888d643b0f1fb0a3e7b8e56a2e2"
+checksum = "e48366d2c42b8d95ef951101bafa28486590f21b7a1e68b6b2d069746557bbe3"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-network",
  "alloy-primitives",
  "alloy-signer",
@@ -875,9 +816,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-sol-macro"
-version = "1.5.7"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab81bab693da9bb79f7a95b64b394718259fdd7e41dceeced4cad57cb71c4f6a"
+checksum = "840128ed2b2971d6d4668a553fe403a82683d3acc646c73e75887e7157408033"
 dependencies = [
  "alloy-sol-macro-expander",
  "alloy-sol-macro-input",
@@ -889,9 +830,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-sol-macro-expander"
-version = "1.5.7"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "489f1620bb7e2483fb5819ed01ab6edc1d2f93939dce35a5695085a1afd1d699"
+checksum = "63ec265e5d65d725175f6ca7711c970824c90ef9c0d1f1973711d4150ee612dd"
 dependencies = [
  "alloy-sol-macro-input",
  "const-hex",
@@ -900,16 +841,16 @@ dependencies = [
  "proc-macro-error2",
  "proc-macro2",
  "quote",
- "sha3",
+ "sha3 0.11.0",
  "syn 2.0.117",
  "syn-solidity",
 ]
 
 [[package]]
 name = "alloy-sol-macro-input"
-version = "1.5.7"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56cef806ad22d4392c5fc83cf8f2089f988eb99c7067b4e0c6f1971fc1cca318"
+checksum = "89bf01077f18650876cfa682eb1f949967b5cde03f1a51c955c469d2c9b4aa67"
 dependencies = [
  "const-hex",
  "dunce",
@@ -923,19 +864,19 @@ dependencies = [
 
 [[package]]
 name = "alloy-sol-type-parser"
-version = "1.5.7"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6df77fea9d6a2a75c0ef8d2acbdfd92286cc599983d3175ccdc170d3433d249"
+checksum = "857b470ecdd2ed38beaf82ad1a38c516a8ff75266750f38b9eeed001d575241b"
 dependencies = [
  "serde",
- "winnow 0.7.15",
+ "winnow 1.0.1",
 ]
 
 [[package]]
 name = "alloy-sol-types"
-version = "1.5.7"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64612d29379782a5dde6f4b6570d9c756d734d760c0c94c254d361e678a6591f"
+checksum = "384cf252de0db2dec52821eac037a7f57e2aa33fe5b900ce6fe39973402341f1"
 dependencies = [
  "alloy-json-abi",
  "alloy-primitives",
@@ -945,9 +886,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ac7a80c0bac3e44559d53d002e34c461dc2f23262b42cafec019bc70551abbe"
+checksum = "86052fdcec72d37ca4aa4b66254601e7453c45a6e1c70aa4561033d002fb80cc"
 dependencies = [
  "alloy-json-rpc",
  "auto_impl",
@@ -968,14 +909,14 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport-http"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eed3ed3300a998f88639ed619fdbbd88bd82865e00c6a8ecb796c99eb12358f6"
+checksum = "b273587487921274f4f5d0ef2c7ef36944dcbb75a4e2318e69eae822bd263f91"
 dependencies = [
  "alloy-json-rpc",
  "alloy-transport",
  "itertools 0.14.0",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "serde_json",
  "tower",
  "tracing",
@@ -984,9 +925,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport-ipc"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1075d9d30fd4d71e50000fd4afb19ed2664ceab20c2a29f3889a6e988329e02d"
+checksum = "bfb89df168b24773ef603af14f2449c05a7d3f27d05d3eceaea6bf96cccae168"
 dependencies = [
  "alloy-json-rpc",
  "alloy-pubsub",
@@ -1004,9 +945,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport-ws"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e3bff84b2b2a46eb34cc522dc3f889a2867c70be90a377421429b662b3ec4ce"
+checksum = "33e32e0b47d3b3bf5770b7c132090c614b008d307c5e1544f1925f5b7e9e9af6"
 dependencies = [
  "alloy-pubsub",
  "alloy-transport",
@@ -1034,7 +975,7 @@ dependencies = [
  "derive_more",
  "nybbles",
  "proptest",
- "proptest-derive",
+ "proptest-derive 0.7.0",
  "serde",
  "smallvec",
  "thiserror 2.0.18",
@@ -1043,21 +984,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-tx-macros"
-version = "1.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d69722eddcdf1ce096c3ab66cf8116999363f734eb36fe94a148f4f71c85da84"
-dependencies = [
- "darling 0.23.0",
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
-
-[[package]]
-name = "alloy-tx-macros"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99fce0350197dcd4ba4e9a7dd43915d908c0eb0e7352755791709a705e1c76b6"
+checksum = "01a0035943b75fe1e249f52e688492d7a1b1826bc2d19b8e1d5d3c24a2ad8f50"
 dependencies = [
  "darling 0.23.0",
  "proc-macro2",
@@ -1116,7 +1045,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1127,7 +1056,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1493,9 +1422,9 @@ checksum = "9b34d609dfbaf33d6889b2b7106d3ca345eacad44200913df5ba02bfd31d2ba9"
 
 [[package]]
 name = "async-compression"
-version = "0.4.41"
+version = "0.4.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0f9ee0f6e02ffd7ad5816e9464499fba7b3effd01123b515c41d1697c43dad1"
+checksum = "e79b3f8a79cccc2898f31920fc69f304859b3bd567490f75ebf51ae1c792a9ac"
 dependencies = [
  "compression-codecs",
  "compression-core",
@@ -1794,9 +1723,9 @@ dependencies = [
 
 [[package]]
 name = "blake3"
-version = "1.8.4"
+version = "1.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d2d5991425dfd0785aed03aedcf0b321d61975c9b5b3689c774a2610ae0b51e"
+checksum = "0aa83c34e62843d924f905e0f5c866eb1dd6545fc4d719e803d9ba6030371fce"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -1815,6 +1744,15 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "block-buffer"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdd35008169921d80bc60d3d0ab416eecb028c4cd653352907921d95084790be"
+dependencies = [
+ "hybrid-array",
+]
+
 [[package]]
 name = "block-padding"
 version = "0.3.3"
@@ -2198,9 +2136,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.60"
+version = "1.2.62"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
+checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -2235,6 +2173,17 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
+[[package]]
+name = "chacha20"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "rand_core 0.10.1",
+]
+
 [[package]]
 name = "chrono"
 version = "0.4.44"
@@ -2282,7 +2231,7 @@ version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
 dependencies = [
- "crypto-common",
+ "crypto-common 0.1.7",
  "inout",
 ]
 
@@ -2460,37 +2409,10 @@ dependencies = [
  "ripemd",
  "serde",
  "sha2",
- "sha3",
+ "sha3 0.10.8",
  "thiserror 1.0.69",
 ]
 
-[[package]]
-name = "color-eyre"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5920befb47832a6d61ee3a3a846565cfa39b331331e68a3b1d1116630f2f26d"
-dependencies = [
- "backtrace",
- "color-spantrace",
- "eyre",
- "indenter",
- "once_cell",
- "owo-colors",
- "tracing-error",
-]
-
-[[package]]
-name = "color-spantrace"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8b88ea9df13354b55bc7234ebcce36e6ef896aca2e42a15de9e10edce01b427"
-dependencies = [
- "once_cell",
- "owo-colors",
- "tracing-core",
- "tracing-error",
-]
-
 [[package]]
 name = "colorchoice"
 version = "1.0.5"
@@ -2544,9 +2466,9 @@ dependencies = [
 
 [[package]]
 name = "compression-codecs"
-version = "0.4.37"
+version = "0.4.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb7b51a7d9c967fc26773061ba86150f19c50c0d65c887cb1fbe295fd16619b7"
+checksum = "ce2548391e9c1929c21bf6aa2680af86fe4c1b33e6cea9ac1cfeec0bd11218cf"
 dependencies = [
  "brotli",
  "compression-core",
@@ -2558,9 +2480,9 @@ dependencies = [
 
 [[package]]
 name = "compression-core"
-version = "0.4.31"
+version = "0.4.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d"
+checksum = "cc14f565cf027a105f7a44ccf9e5b424348421a1d8952a8fc9d499d313107789"
 
 [[package]]
 name = "concat-kdf"
@@ -2654,6 +2576,16 @@ dependencies = [
  "unicode-segmentation",
 ]
 
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.10.1"
@@ -2834,24 +2766,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "csv"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
-dependencies = [
- "csv-core",
- "itoa",
- "ryu",
- "serde_core",
-]
-
-[[package]]
-name = "csv-core"
-version = "0.1.13"
+name = "crypto-common"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
+checksum = "77727bb15fa921304124b128af125e7e3b968275d1b108b379190264f4423710"
 dependencies = [
- "memchr",
+ "hybrid-array",
 ]
 
 [[package]]
@@ -2894,9 +2814,9 @@ dependencies = [
 name = "custom-hardforks"
 version = "0.1.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-primitives",
  "reth-chainspec",
  "reth-network-peers",
@@ -2975,9 +2895,9 @@ dependencies = [
 
 [[package]]
 name = "dashmap"
-version = "6.1.0"
+version = "6.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
+checksum = "e6361d5c062261c78a176addb82d4c821ae42bed6089de0e12603cd25de2059c"
 dependencies = [
  "arbitrary",
  "cfg-if",
@@ -2991,9 +2911,9 @@ dependencies = [
 
 [[package]]
 name = "data-encoding"
-version = "2.10.0"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea"
+checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8"
 
 [[package]]
 name = "data-encoding-macro"
@@ -3160,12 +3080,22 @@ version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
- "block-buffer",
+ "block-buffer 0.10.4",
  "const-oid",
- "crypto-common",
+ "crypto-common 0.1.7",
  "subtle",
 ]
 
+[[package]]
+name = "digest"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+dependencies = [
+ "block-buffer 0.12.0",
+ "crypto-common 0.2.1",
+]
+
 [[package]]
 name = "dirs-next"
 version = "2.0.0"
@@ -3330,7 +3260,7 @@ dependencies = [
 
 [[package]]
 name = "ef-test-runner"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "clap",
  "ef-tests",
@@ -3338,11 +3268,11 @@ dependencies = [
 
 [[package]]
 name = "ef-tests"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
  "rayon",
@@ -3370,9 +3300,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.15.0"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
 dependencies = [
  "serde",
 ]
@@ -3431,22 +3361,10 @@ dependencies = [
  "rand 0.8.6",
  "secp256k1 0.30.0",
  "serde",
- "sha3",
+ "sha3 0.10.8",
  "zeroize",
 ]
 
-[[package]]
-name = "enum-as-inner"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
-
 [[package]]
 name = "enum-ordinalize"
 version = "4.3.2"
@@ -3500,7 +3418,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3529,9 +3447,9 @@ dependencies = [
 
 [[package]]
 name = "ethereum_ssz"
-version = "0.10.3"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368a4a4e4273b0135111fe9464e35465067766a8f664615b5a86338b73864407"
+checksum = "e462875ad8693755ea8913d6e905715c76ea4836e2254e18c9cf0f7a8f8c2a13"
 dependencies = [
  "alloy-primitives",
  "ethereum_serde_utils",
@@ -3544,9 +3462,9 @@ dependencies = [
 
 [[package]]
 name = "ethereum_ssz_derive"
-version = "0.10.3"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2cd82c68120c89361e1a457245cf212f7d9f541bffaffed530c8f2d54a160b2"
+checksum = "daf022360bdbe9456eda5f35718a50476d5b2a0d51a97ed4eae27420737a6fba"
 dependencies = [
  "darling 0.23.0",
  "proc-macro2",
@@ -3554,18 +3472,29 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "evmap"
+version = "11.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b8874945f036109c72242964c1174cf99434e30cfa45bf45fedc983f50046f8"
+dependencies = [
+ "hashbag",
+ "left-right",
+ "smallvec",
+]
+
 [[package]]
 name = "example-beacon-api-sidecar-fetcher"
 version = "0.1.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-beacon",
  "clap",
  "eyre",
  "futures-util",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-ethereum",
  "serde",
  "serde_json",
@@ -3580,7 +3509,7 @@ dependencies = [
  "bytes",
  "clap",
  "futures-util",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-ethereum",
  "serde_json",
  "tokio",
@@ -3638,7 +3567,7 @@ dependencies = [
 name = "example-custom-beacon-withdrawals"
 version = "0.0.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-evm",
  "alloy-sol-types",
  "eyre",
@@ -3649,7 +3578,7 @@ dependencies = [
 name = "example-custom-dev-node"
 version = "0.0.0"
 dependencies = [
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "alloy-primitives",
  "eyre",
  "futures-util",
@@ -3662,7 +3591,7 @@ dependencies = [
 name = "example-custom-engine-types"
 version = "0.0.0"
 dependencies = [
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rpc-types",
  "eyre",
@@ -3681,7 +3610,7 @@ name = "example-custom-evm"
 version = "0.0.0"
 dependencies = [
  "alloy-evm",
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "alloy-primitives",
  "eyre",
  "reth-ethereum",
@@ -3693,7 +3622,7 @@ dependencies = [
 name = "example-custom-inspector"
 version = "0.0.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-evm",
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -3715,7 +3644,7 @@ dependencies = [
 name = "example-custom-payload-builder"
 version = "0.0.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "eyre",
  "futures-util",
  "reth-basic-payload-builder",
@@ -3749,6 +3678,22 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "example-custom-state-root"
+version = "0.0.0"
+dependencies = [
+ "alloy-genesis",
+ "alloy-network",
+ "alloy-primitives",
+ "alloy-rpc-types-engine",
+ "eyre",
+ "reth-engine-tree",
+ "reth-ethereum",
+ "reth-trie",
+ "serde_json",
+ "tokio",
+]
+
 [[package]]
 name = "example-db-access"
 version = "0.0.0"
@@ -3772,7 +3717,7 @@ dependencies = [
 
 [[package]]
 name = "example-full-contract-state"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "eyre",
@@ -3783,7 +3728,7 @@ dependencies = [
 name = "example-manual-p2p"
 version = "0.0.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "eyre",
  "futures",
  "reth-discv4",
@@ -3854,7 +3799,7 @@ dependencies = [
 name = "example-polygon-p2p"
 version = "0.0.0"
 dependencies = [
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "reth-discv4",
  "reth-ethereum",
  "reth-tracing",
@@ -3869,7 +3814,7 @@ name = "example-precompile-cache"
 version = "0.0.0"
 dependencies = [
  "alloy-evm",
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "alloy-primitives",
  "eyre",
  "parking_lot",
@@ -3905,7 +3850,7 @@ dependencies = [
 
 [[package]]
 name = "exex-subscription"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "clap",
@@ -4008,13 +3953,13 @@ checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
 [[package]]
 name = "firehose-tracer"
-version = "5.1.1"
+version = "5.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31cba6984a9c8246604055d93b0ce721c9e21effb931fb94e21f692a33c78491"
+checksum = "45902d2ed9ce2b946d44f20703a94522d49db4c9119ea2f043f6f14a031e9c3b"
 dependencies = [
- "alloy-consensus 1.8.3",
- "alloy-eips 1.8.3",
- "alloy-genesis 1.8.3",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
  "base64-simd",
@@ -4031,9 +3976,9 @@ dependencies = [
 
 [[package]]
 name = "fixed-cache"
-version = "0.1.8"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c41c7aa69c00ebccf06c3fa7ffe2a6cf26a58b5fe4deabfe646285ff48136a8f"
+checksum = "2fe63500644ef0269fe6b744e7e5dc5c20b5eebf3d881bc2be53f194636f6583"
 dependencies = [
  "equivalent",
  "rapidhash",
@@ -4339,6 +4284,7 @@ dependencies = [
  "cfg-if",
  "libc",
  "r-efi 6.0.0",
+ "rand_core 0.10.1",
  "wasip2",
  "wasip3",
 ]
@@ -4480,6 +4426,12 @@ dependencies = [
  "byteorder",
 ]
 
+[[package]]
+name = "hashbag"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7040a10f52cba493ddb09926e15d10a9d8a28043708a405931fe4c6f19fac064"
+
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -4517,8 +4469,6 @@ dependencies = [
  "allocator-api2",
  "equivalent",
  "foldhash 0.2.0",
- "serde",
- "serde_core",
 ]
 
 [[package]]
@@ -4526,6 +4476,11 @@ name = "hashbrown"
 version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
+dependencies = [
+ "foldhash 0.2.0",
+ "serde",
+ "serde_core",
+]
 
 [[package]]
 name = "hashlink"
@@ -4588,48 +4543,72 @@ dependencies = [
 ]
 
 [[package]]
-name = "hickory-proto"
-version = "0.25.2"
+name = "hickory-net"
+version = "0.26.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8a6fe56c0038198998a6f217ca4e7ef3a5e51f46163bd6dd60b5c71ca6c6502"
+checksum = "e2295ed2f9c31e471e1428a8f88a3f0e1f4b27c15049592138d1eebe9c35b183"
 dependencies = [
  "async-trait",
  "cfg-if",
  "data-encoding",
- "enum-as-inner",
  "futures-channel",
  "futures-io",
  "futures-util",
+ "hickory-proto",
+ "idna",
+ "ipnet",
+ "jni 0.22.4",
+ "rand 0.10.1",
+ "thiserror 2.0.18",
+ "tinyvec",
+ "tokio",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "hickory-proto"
+version = "0.26.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bab31817bfb44672a252e97fe81cd0c18d1b2cf892108922f6818820df8c643"
+dependencies = [
+ "data-encoding",
  "idna",
  "ipnet",
+ "jni 0.22.4",
  "once_cell",
- "rand 0.9.4",
+ "prefix-trie",
+ "rand 0.10.1",
  "ring",
  "serde",
  "thiserror 2.0.18",
  "tinyvec",
- "tokio",
  "tracing",
  "url",
 ]
 
 [[package]]
 name = "hickory-resolver"
-version = "0.25.2"
+version = "0.26.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc62a9a99b0bfb44d2ab95a7208ac952d31060efc16241c87eaf36406fecf87a"
+checksum = "f0d58d28879ceecde6607729660c2667a081ccdc082e082675042793960f178c"
 dependencies = [
  "cfg-if",
  "futures-util",
+ "hickory-net",
  "hickory-proto",
  "ipconfig",
+ "ipnet",
+ "jni 0.22.4",
  "moka",
+ "ndk-context",
  "once_cell",
  "parking_lot",
- "rand 0.9.4",
+ "rand 0.10.1",
  "resolv-conf",
  "serde",
  "smallvec",
+ "system-configuration",
  "thiserror 2.0.18",
  "tokio",
  "tracing",
@@ -4726,6 +4705,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "hybrid-array"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9155a582abd142abc056962c29e3ce5ff2ad5469f4246b537ed42c5deba857da"
+dependencies = [
+ "typenum",
+]
+
 [[package]]
 name = "hyper"
 version = "1.9.0"
@@ -5118,9 +5106,9 @@ dependencies = [
 
 [[package]]
 name = "interprocess"
-version = "2.4.1"
+version = "2.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce4c3c8f298ee3d5467f2616384e3560c750226cc3c620e5456d3b95783156f6"
+checksum = "069323743400cb7ab06a8fe5c1ed911d36b6919ec531661d034c89083629595b"
 dependencies = [
  "doctest-file",
  "futures-core",
@@ -5158,14 +5146,7 @@ name = "ipnet"
 version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
-
-[[package]]
-name = "iri-string"
-version = "0.7.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25e659a4bb38e810ebc252e53b5814ff908a8c58c2a9ce2fae1bbec24cbf4e20"
 dependencies = [
- "memchr",
  "serde",
 ]
 
@@ -5177,7 +5158,7 @@ checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
 dependencies = [
  "hermit-abi",
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -5252,6 +5233,36 @@ dependencies = [
  "windows-sys 0.45.0",
 ]
 
+[[package]]
+name = "jni"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498"
+dependencies = [
+ "cfg-if",
+ "combine",
+ "jni-macros",
+ "jni-sys 0.4.1",
+ "log",
+ "simd_cesu8",
+ "thiserror 2.0.18",
+ "walkdir",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "jni-macros"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rustc_version 0.4.1",
+ "simd_cesu8",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "jni-sys"
 version = "0.3.1"
@@ -5526,6 +5537,16 @@ dependencies = [
  "cpufeatures 0.2.17",
 ]
 
+[[package]]
+name = "keccak"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e24a010dd405bd7ed803e5253182815b41bf2e6a80cc3bfc066658e03a198aa"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+]
+
 [[package]]
 name = "keccak-asm"
 version = "0.1.6"
@@ -5583,11 +5604,22 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
 
+[[package]]
+name = "left-right"
+version = "0.11.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f0c21e4c8ff95f487fb34e6f9182875f42c84cef966d29216bf115d9bba835a"
+dependencies = [
+ "crossbeam-utils",
+ "loom",
+ "slab",
+]
+
 [[package]]
 name = "libc"
-version = "0.2.185"
+version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
 [[package]]
 name = "libgit2-sys"
@@ -5816,9 +5848,9 @@ checksum = "dae608c151f68243f2b000364e1f7b186d9c29845f7d2d85bd31b9ad77ad552b"
 
 [[package]]
 name = "macro-string"
-version = "0.1.4"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b27834086c65ec3f9387b096d66e99f221cf081c2b738042aa252bcd41204e3"
+checksum = "59a9dbbfc75d2688ed057456ce8a3ee3f48d12eec09229f560f3643b9f275653"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5884,12 +5916,12 @@ dependencies = [
 
 [[package]]
 name = "metrics"
-version = "0.24.3"
+version = "0.24.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d5312e9ba3771cfa961b585728215e3d972c950a3eed9252aa093d6301277e8"
+checksum = "89550ee9f79e88fef3119de263694973a8adb26c21d75322164fb8c493039fe2"
 dependencies = [
- "ahash",
  "portable-atomic",
+ "rapidhash",
 ]
 
 [[package]]
@@ -5905,11 +5937,12 @@ dependencies = [
 
 [[package]]
 name = "metrics-exporter-prometheus"
-version = "0.18.1"
+version = "0.18.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3589659543c04c7dc5526ec858591015b87cd8746583b51b48ef4353f99dbcda"
+checksum = "1db0d8f1fc9e62caebd0319e11eaec5822b0186c171568f0480b46a0137f9108"
 dependencies = [
  "base64 0.22.1",
+ "evmap",
  "indexmap 2.14.0",
  "metrics",
  "metrics-util",
@@ -5935,9 +5968,9 @@ dependencies = [
 
 [[package]]
 name = "metrics-util"
-version = "0.20.1"
+version = "0.20.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdfb1365fea27e6dd9dc1dbc19f570198bc86914533ad639dae939635f096be4"
+checksum = "96f8722f8562635f92f8ed992f26df0532266eb03d5202607c20c0d7e9745e13"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
@@ -5948,6 +5981,7 @@ dependencies = [
  "quanta",
  "rand 0.9.4",
  "rand_xoshiro",
+ "rapidhash",
  "sketches-ddsketch",
 ]
 
@@ -6080,6 +6114,12 @@ dependencies = [
  "unsigned-varint",
 ]
 
+[[package]]
+name = "ndk-context"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
+
 [[package]]
 name = "nix"
 version = "0.31.2"
@@ -6111,6 +6151,15 @@ dependencies = [
  "minimal-lexical",
 ]
 
+[[package]]
+name = "nonmax"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "610a5acd306ec67f907abe5567859a3c693fb9886eb1f012ab8f2a47bef3db51"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "notify"
 version = "8.2.0"
@@ -6153,7 +6202,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -6462,12 +6511,6 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
 
-[[package]]
-name = "owo-colors"
-version = "4.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d211803b9b6b570f68772237e415a029d5a50c65d382910b879fb19d3271f94d"
-
 [[package]]
 name = "p256"
 version = "0.13.2"
@@ -6645,18 +6688,18 @@ dependencies = [
 
 [[package]]
 name = "pin-project"
-version = "1.1.11"
+version = "1.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1749c7ed4bcaf4c3d0a3efc28538844fb29bcdd7d2b67b2be7e20ba861ff517"
+checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.1.11"
+version = "1.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b20ed30f105399776b9c883e68e536ef602a16ae6f596d2c473591d6ad64c6"
+checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -6803,6 +6846,17 @@ dependencies = [
  "zerocopy",
 ]
 
+[[package]]
+name = "prefix-trie"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23370be78b7e5bcbb0cab4a02047eb040279a693c78daad04c2c5f1c24a83503"
+dependencies = [
+ "either",
+ "ipnet",
+ "num-traits",
+]
+
 [[package]]
 name = "pretty_assertions"
 version = "1.4.1"
@@ -6947,6 +7001,17 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "proptest-derive"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c57924a81864dddafba92e1bf92f9bf82f97096c44489548a60e888e1547549b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "prost"
 version = "0.14.3"
@@ -7115,6 +7180,17 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "rand"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
+dependencies = [
+ "chacha20",
+ "getrandom 0.4.2",
+ "rand_core 0.10.1",
+]
+
 [[package]]
 name = "rand_chacha"
 version = "0.3.1"
@@ -7154,6 +7230,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "rand_core"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+
 [[package]]
 name = "rand_xorshift"
 version = "0.4.0"
@@ -7410,9 +7492,9 @@ dependencies = [
 
 [[package]]
 name = "reqwest"
-version = "0.13.2"
+version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
+checksum = "62e0021ea2c22aed41653bc7e1419abb2c97e038ff2c33d0e1309e49a97deec0"
 dependencies = [
  "base64 0.22.1",
  "bytes",
@@ -7458,7 +7540,7 @@ checksum = "1e061d1b48cb8d38042de4ae0a7a6401009d6143dc80d2e2d6f31f0bdd6470c7"
 
 [[package]]
 name = "reth"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-evm",
  "alloy-node-bindings",
@@ -7502,18 +7584,20 @@ dependencies = [
  "reth-tasks",
  "reth-transaction-pool",
  "serde_json",
+ "tar",
  "tempfile",
  "tokio",
  "toml",
  "tracing",
+ "zstd",
 ]
 
 [[package]]
 name = "reth-basic-payload-builder"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "futures-core",
  "futures-util",
@@ -7536,10 +7620,10 @@ dependencies = [
 
 [[package]]
 name = "reth-bb"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-evm",
  "alloy-hardforks 0.4.7",
  "alloy-primitives",
@@ -7582,60 +7666,12 @@ dependencies = [
  "tracing",
 ]
 
-[[package]]
-name = "reth-bench"
-version = "2.2.0"
-dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eip7928",
- "alloy-eips 2.0.4",
- "alloy-json-rpc",
- "alloy-primitives",
- "alloy-provider",
- "alloy-pubsub",
- "alloy-rlp",
- "alloy-rpc-client",
- "alloy-rpc-types-engine",
- "alloy-transport",
- "alloy-transport-http",
- "alloy-transport-ipc",
- "alloy-transport-ws",
- "async-trait",
- "clap",
- "color-eyre",
- "csv",
- "eyre",
- "futures",
- "humantime",
- "reqwest 0.13.2",
- "reth-chainspec",
- "reth-cli",
- "reth-cli-runner",
- "reth-cli-util",
- "reth-engine-primitives",
- "reth-ethereum-cli",
- "reth-ethereum-primitives",
- "reth-fs-util",
- "reth-node-api",
- "reth-node-core",
- "reth-primitives-traits",
- "reth-rpc-api",
- "reth-tracing",
- "serde",
- "serde_json",
- "thiserror 2.0.18",
- "tokio",
- "tower",
- "tracing",
- "url",
-]
-
 [[package]]
 name = "reth-chain-state"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-signer",
  "alloy-signer-local",
@@ -7652,6 +7688,7 @@ dependencies = [
  "reth-metrics",
  "reth-primitives-traits",
  "reth-storage-api",
+ "reth-tasks",
  "reth-testing-utils",
  "reth-trie",
  "revm-database",
@@ -7664,13 +7701,13 @@ dependencies = [
 
 [[package]]
 name = "reth-chainspec"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-chains",
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-evm",
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-trie",
@@ -7684,9 +7721,9 @@ dependencies = [
 
 [[package]]
 name = "reth-cli"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "clap",
  "eyre",
  "reth-cli-runner",
@@ -7696,11 +7733,11 @@ dependencies = [
 
 [[package]]
 name = "reth-cli-commands"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-chains",
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "arbitrary",
@@ -7722,7 +7759,7 @@ dependencies = [
  "proptest-arbitrary-interop",
  "ratatui",
  "rayon",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-chainspec",
  "reth-cli",
  "reth-cli-runner",
@@ -7785,7 +7822,7 @@ dependencies = [
 
 [[package]]
 name = "reth-cli-runner"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "reth-tasks",
  "tokio",
@@ -7794,9 +7831,9 @@ dependencies = [
 
 [[package]]
 name = "reth-cli-util"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-primitives",
  "cfg-if",
  "eyre",
@@ -7816,13 +7853,13 @@ dependencies = [
 
 [[package]]
 name = "reth-codecs"
-version = "0.3.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fce542a96bf888f31854803e80b3340bc233927743aa580838014e8a88fe0d66"
+checksum = "98afe24504bdbdf20f746794e1708886c21cb4a59826652c9047cba7dfc716d4"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-trie",
  "arbitrary",
@@ -7837,9 +7874,9 @@ dependencies = [
 
 [[package]]
 name = "reth-codecs-derive"
-version = "0.3.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "634c90f1cc0f9887680ca785b0b21aa961070b9465917bf65afaec56a6d005bb"
+checksum = "aeb02fa6170f3d13e621f1c05d0c6baa867e0b8ba9f841455114443bd2411a4e"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -7848,7 +7885,7 @@ dependencies = [
 
 [[package]]
 name = "reth-config"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "eyre",
@@ -7866,9 +7903,10 @@ dependencies = [
 
 [[package]]
 name = "reth-consensus"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
+ "alloy-eip7928 0.4.1",
  "alloy-primitives",
  "auto_impl",
  "reth-execution-types",
@@ -7878,10 +7916,10 @@ dependencies = [
 
 [[package]]
 name = "reth-consensus-common"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "rand 0.9.4",
  "reth-chainspec",
@@ -7892,10 +7930,10 @@ dependencies = [
 
 [[package]]
 name = "reth-consensus-debug-client"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-json-rpc",
  "alloy-primitives",
  "alloy-provider",
@@ -7905,9 +7943,8 @@ dependencies = [
  "derive_more",
  "eyre",
  "futures",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-node-api",
- "reth-primitives-traits",
  "reth-tracing",
  "ringbuffer",
  "serde",
@@ -7917,9 +7954,9 @@ dependencies = [
 
 [[package]]
 name = "reth-db"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-primitives",
  "arbitrary",
  "assert_matches",
@@ -7953,9 +7990,9 @@ dependencies = [
 
 [[package]]
 name = "reth-db-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-primitives",
  "arbitrary",
  "arrayvec",
@@ -7981,10 +8018,10 @@ dependencies = [
 
 [[package]]
 name = "reth-db-common"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-genesis",
  "alloy-primitives",
  "boyer-moore-magiclen",
  "eyre",
@@ -8012,9 +8049,9 @@ dependencies = [
 
 [[package]]
 name = "reth-db-models"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-primitives",
  "arbitrary",
  "bytes",
@@ -8028,7 +8065,7 @@ dependencies = [
 
 [[package]]
 name = "reth-discv4"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
@@ -8054,7 +8091,7 @@ dependencies = [
 
 [[package]]
 name = "reth-discv5"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
@@ -8079,7 +8116,7 @@ dependencies = [
 
 [[package]]
 name = "reth-dns-discovery"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-chains",
  "alloy-primitives",
@@ -8107,10 +8144,10 @@ dependencies = [
 
 [[package]]
 name = "reth-downloaders"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "assert_matches",
@@ -8145,10 +8182,10 @@ dependencies = [
 
 [[package]]
 name = "reth-e2e-test-utils"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-network",
  "alloy-primitives",
  "alloy-provider",
@@ -8201,7 +8238,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ecies"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "aes",
  "alloy-primitives",
@@ -8228,9 +8265,9 @@ dependencies = [
 
 [[package]]
 name = "reth-engine-local"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "eyre",
@@ -8250,10 +8287,10 @@ dependencies = [
 
 [[package]]
 name = "reth-engine-primitives"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "auto_impl",
@@ -8274,11 +8311,11 @@ dependencies = [
 
 [[package]]
 name = "reth-engine-tree"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eip7928",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-evm",
  "alloy-primitives",
  "alloy-rlp",
@@ -8336,6 +8373,7 @@ dependencies = [
  "reth-trie-parallel",
  "reth-trie-sparse",
  "revm",
+ "revm-database-interface",
  "revm-primitives",
  "revm-state",
  "schnellru",
@@ -8347,9 +8385,11 @@ dependencies = [
 
 [[package]]
 name = "reth-engine-util"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
+ "alloy-primitives",
+ "alloy-rlp",
  "alloy-rpc-types-engine",
  "eyre",
  "futures",
@@ -8374,17 +8414,17 @@ dependencies = [
 
 [[package]]
 name = "reth-era"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "ethereum_ssz",
  "ethereum_ssz_derive",
  "eyre",
  "rand 0.9.4",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-era-downloader",
  "reth-ethereum-primitives",
  "sha2",
@@ -8397,14 +8437,14 @@ dependencies = [
 
 [[package]]
 name = "reth-era-downloader"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "bytes",
  "eyre",
  "futures",
  "futures-util",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-era",
  "reth-fs-util",
  "sha2",
@@ -8415,18 +8455,19 @@ dependencies = [
 
 [[package]]
 name = "reth-era-utils"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-primitives",
  "bytes",
  "eyre",
  "futures-util",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-db-api",
  "reth-db-common",
  "reth-era",
  "reth-era-downloader",
+ "reth-ethereum-primitives",
  "reth-etl",
  "reth-fs-util",
  "reth-primitives-traits",
@@ -8441,7 +8482,7 @@ dependencies = [
 
 [[package]]
 name = "reth-errors"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "reth-consensus",
  "reth-execution-errors",
@@ -8451,11 +8492,11 @@ dependencies = [
 
 [[package]]
 name = "reth-eth-wire"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-chains",
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "arbitrary",
@@ -8489,13 +8530,13 @@ dependencies = [
 
 [[package]]
 name = "reth-eth-wire-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-chains",
- "alloy-consensus 2.0.4",
- "alloy-eip7928",
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-hardforks 0.4.7",
  "alloy-primitives",
  "alloy-rlp",
@@ -8515,7 +8556,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-rpc-types-engine",
  "alloy-rpc-types-eth",
@@ -8555,7 +8596,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum-cli"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "clap",
  "eyre",
@@ -8578,10 +8619,10 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum-consensus"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "reth-chainspec",
  "reth-consensus",
@@ -8594,9 +8635,9 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum-engine-primitives"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "reth-engine-primitives",
@@ -8610,7 +8651,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum-forks"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eip2124",
  "alloy-hardforks 0.4.7",
@@ -8623,10 +8664,10 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum-payload-builder"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-engine",
@@ -8652,10 +8693,10 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum-primitives"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-eth",
@@ -8673,7 +8714,7 @@ dependencies = [
 
 [[package]]
 name = "reth-etl"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "rayon",
@@ -8683,10 +8724,11 @@ dependencies = [
 
 [[package]]
 name = "reth-evm"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-evm",
  "alloy-primitives",
  "auto_impl",
@@ -8707,12 +8749,12 @@ dependencies = [
 
 [[package]]
 name = "reth-evm-ethereum"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-evm",
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "reth-chainspec",
@@ -8729,7 +8771,7 @@ dependencies = [
 
 [[package]]
 name = "reth-execution-cache"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "fixed-cache",
@@ -8747,7 +8789,7 @@ dependencies = [
 
 [[package]]
 name = "reth-execution-errors"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-evm",
  "alloy-primitives",
@@ -8759,10 +8801,10 @@ dependencies = [
 
 [[package]]
 name = "reth-execution-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-evm",
  "alloy-primitives",
  "alloy-rlp",
@@ -8780,11 +8822,11 @@ dependencies = [
 
 [[package]]
 name = "reth-exex"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-primitives",
  "eyre",
  "futures",
@@ -8825,9 +8867,9 @@ dependencies = [
 
 [[package]]
 name = "reth-exex-test-utils"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "eyre",
  "futures-util",
  "reth-chainspec",
@@ -8856,9 +8898,9 @@ dependencies = [
 
 [[package]]
 name = "reth-exex-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-primitives",
  "arbitrary",
  "bincode",
@@ -8873,12 +8915,13 @@ dependencies = [
 
 [[package]]
 name = "reth-firehose"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-evm",
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
  "eyre",
@@ -8900,11 +8943,11 @@ dependencies = [
 
 [[package]]
 name = "reth-firehose-tests"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
  "base64 0.22.1",
@@ -8926,7 +8969,7 @@ dependencies = [
 
 [[package]]
 name = "reth-fs-util"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -8935,10 +8978,10 @@ dependencies = [
 
 [[package]]
 name = "reth-invalid-block-hooks"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-debug",
@@ -8968,7 +9011,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ipc"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "bytes",
  "futures",
@@ -8990,7 +9033,7 @@ dependencies = [
 
 [[package]]
 name = "reth-libmdbx"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "bitflags 2.11.1",
  "byteorder",
@@ -9007,7 +9050,7 @@ dependencies = [
 
 [[package]]
 name = "reth-mdbx-sys"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "bindgen",
  "cc",
@@ -9015,7 +9058,7 @@ dependencies = [
 
 [[package]]
 name = "reth-metrics"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "futures",
  "metrics",
@@ -9027,7 +9070,7 @@ dependencies = [
 
 [[package]]
 name = "reth-net-banlist"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "ipnet",
@@ -9035,11 +9078,11 @@ dependencies = [
 
 [[package]]
 name = "reth-net-nat"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "futures-util",
  "if-addrs",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-tracing",
  "serde_with",
  "thiserror 2.0.18",
@@ -9049,11 +9092,11 @@ dependencies = [
 
 [[package]]
 name = "reth-network"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
  "aquamarine",
@@ -9111,9 +9154,9 @@ dependencies = [
 
 [[package]]
 name = "reth-network-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-primitives",
  "alloy-rpc-types-admin",
  "alloy-rpc-types-eth",
@@ -9135,10 +9178,10 @@ dependencies = [
 
 [[package]]
 name = "reth-network-p2p"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "auto_impl",
  "derive_more",
@@ -9157,7 +9200,7 @@ dependencies = [
 
 [[package]]
 name = "reth-network-peers"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
@@ -9174,7 +9217,7 @@ dependencies = [
 
 [[package]]
 name = "reth-network-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eip2124",
  "humantime-serde",
@@ -9187,7 +9230,7 @@ dependencies = [
 
 [[package]]
 name = "reth-nippy-jar"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "anyhow",
  "bincode",
@@ -9205,7 +9248,7 @@ dependencies = [
 
 [[package]]
 name = "reth-node-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-rpc-types-engine",
  "eyre",
@@ -9228,10 +9271,10 @@ dependencies = [
 
 [[package]]
 name = "reth-node-builder"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-provider",
  "alloy-rpc-types",
@@ -9300,10 +9343,10 @@ dependencies = [
 
 [[package]]
 name = "reth-node-core"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "clap",
@@ -9356,12 +9399,12 @@ dependencies = [
 
 [[package]]
 name = "reth-node-ethereum"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-contract",
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-network",
  "alloy-primitives",
  "alloy-provider",
@@ -9371,10 +9414,15 @@ dependencies = [
  "alloy-rpc-types-trace",
  "alloy-signer",
  "alloy-sol-types",
+ "enr",
+ "ethereum_ssz",
  "eyre",
  "futures",
+ "http-body-util",
+ "jsonrpsee",
  "jsonrpsee-core",
  "rand 0.9.4",
+ "reqwest 0.13.3",
  "reth-chainspec",
  "reth-db",
  "reth-e2e-test-utils",
@@ -9400,6 +9448,7 @@ dependencies = [
  "reth-rpc-builder",
  "reth-rpc-eth-api",
  "reth-rpc-eth-types",
+ "reth-rpc-layer",
  "reth-rpc-server-types",
  "reth-stages-types",
  "reth-tasks",
@@ -9412,13 +9461,14 @@ dependencies = [
  "similar-asserts",
  "tempfile",
  "tokio",
+ "tower",
 ]
 
 [[package]]
 name = "reth-node-ethstats"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-primitives",
  "chrono",
  "futures-util",
@@ -9439,10 +9489,10 @@ dependencies = [
 
 [[package]]
 name = "reth-node-events"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "derive_more",
@@ -9462,7 +9512,7 @@ dependencies = [
 
 [[package]]
 name = "reth-node-metrics"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "bytes",
  "eyre",
@@ -9477,7 +9527,7 @@ dependencies = [
  "metrics-util",
  "pprof_util",
  "procfs",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-fs-util",
  "reth-metrics",
  "reth-tasks",
@@ -9491,7 +9541,7 @@ dependencies = [
 
 [[package]]
 name = "reth-node-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "reth-chainspec",
  "reth-db-api",
@@ -9502,9 +9552,9 @@ dependencies = [
 
 [[package]]
 name = "reth-payload-builder"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-primitives",
  "alloy-rpc-types",
  "derive_more",
@@ -9525,7 +9575,7 @@ dependencies = [
 
 [[package]]
 name = "reth-payload-builder-primitives"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "pin-project",
  "reth-payload-primitives",
@@ -9536,17 +9586,16 @@ dependencies = [
 
 [[package]]
 name = "reth-payload-primitives"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-engine",
  "assert_matches",
  "auto_impl",
  "either",
- "reth-chain-state",
  "reth-chainspec",
  "reth-errors",
  "reth-execution-types",
@@ -9561,31 +9610,31 @@ dependencies = [
 
 [[package]]
 name = "reth-payload-util"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-primitives",
  "reth-transaction-pool",
 ]
 
 [[package]]
 name = "reth-payload-validator"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-rpc-types-engine",
  "reth-primitives-traits",
 ]
 
 [[package]]
 name = "reth-primitives-traits"
-version = "0.3.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ee12e304adbacbb32248c9806ebafbe1e2811fbfefe53c5e5b710a8438b7ec0"
+checksum = "8c2ce8506295bfbc570855a035fe11d6beec1db922ee4d5d1a44f568e6c8b6f1"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-eth",
@@ -9612,11 +9661,12 @@ dependencies = [
 
 [[package]]
 name = "reth-provider"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "assert_matches",
@@ -9648,6 +9698,7 @@ dependencies = [
  "reth-storage-errors",
  "reth-tasks",
  "reth-testing-utils",
+ "reth-tokio-util",
  "reth-tracing",
  "reth-trie",
  "reth-trie-db",
@@ -9655,18 +9706,19 @@ dependencies = [
  "revm-database-interface",
  "revm-state",
  "rocksdb",
+ "smallvec",
  "strum",
  "tempfile",
  "tokio",
+ "tokio-stream",
  "tracing",
 ]
 
 [[package]]
 name = "reth-prune"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
  "alloy-primitives",
  "assert_matches",
  "itertools 0.14.0",
@@ -9696,11 +9748,11 @@ dependencies = [
 
 [[package]]
 name = "reth-prune-db"
-version = "2.2.0"
+version = "2.3.0"
 
 [[package]]
 name = "reth-prune-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "arbitrary",
@@ -9720,9 +9772,9 @@ dependencies = [
 
 [[package]]
 name = "reth-revm"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-debug",
@@ -9736,13 +9788,13 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-dyn-abi",
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-evm",
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "alloy-network",
  "alloy-primitives",
  "alloy-rlp",
@@ -9756,7 +9808,7 @@ dependencies = [
  "alloy-rpc-types-mev",
  "alloy-rpc-types-trace",
  "alloy-rpc-types-txpool",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "alloy-signer",
  "alloy-signer-local",
  "async-trait",
@@ -9798,7 +9850,6 @@ dependencies = [
  "reth-storage-api",
  "reth-tasks",
  "reth-testing-utils",
- "reth-tracing",
  "reth-transaction-pool",
  "reth-trie-common",
  "revm",
@@ -9816,10 +9867,10 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-json-rpc",
  "alloy-primitives",
  "alloy-rpc-types",
@@ -9832,7 +9883,7 @@ dependencies = [
  "alloy-rpc-types-mev",
  "alloy-rpc-types-trace",
  "alloy-rpc-types-txpool",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "jsonrpsee",
  "reth-chain-state",
  "reth-engine-primitives",
@@ -9846,9 +9897,9 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-api-testing-util"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-eth",
  "alloy-rpc-types-trace",
@@ -9865,9 +9916,9 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-builder"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-network",
  "alloy-primitives",
  "alloy-provider",
@@ -9880,7 +9931,7 @@ dependencies = [
  "jsonrpsee",
  "metrics",
  "pin-project",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-chain-state",
  "reth-chainspec",
  "reth-consensus",
@@ -9923,9 +9974,9 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-convert"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-evm",
  "alloy-json-rpc",
  "alloy-network",
@@ -9943,9 +9994,9 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-e2e-tests"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-genesis 2.0.4",
+ "alloy-genesis",
  "alloy-rpc-types-engine",
  "eyre",
  "futures-util",
@@ -9963,9 +10014,9 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-engine-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-engine",
@@ -9999,12 +10050,12 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-eth-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-dyn-abi",
- "alloy-eip7928",
- "alloy-eips 2.0.4",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-evm",
  "alloy-json-rpc",
  "alloy-network",
@@ -10012,7 +10063,7 @@ dependencies = [
  "alloy-rlp",
  "alloy-rpc-types-eth",
  "alloy-rpc-types-mev",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "async-trait",
  "auto_impl",
  "dyn-clone",
@@ -10027,6 +10078,7 @@ dependencies = [
  "reth-network-api",
  "reth-node-api",
  "reth-primitives-traits",
+ "reth-prune-types",
  "reth-revm",
  "reth-rpc-convert",
  "reth-rpc-eth-types",
@@ -10044,15 +10096,18 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-eth-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-chains",
+ "alloy-consensus",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-evm",
  "alloy-network",
  "alloy-primitives",
  "alloy-rpc-client",
  "alloy-rpc-types-eth",
+ "alloy-serde",
  "alloy-sol-types",
  "alloy-transport",
  "derive_more",
@@ -10062,9 +10117,10 @@ dependencies = [
  "jsonrpsee-types",
  "metrics",
  "rand 0.9.4",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-chain-state",
  "reth-chainspec",
+ "reth-db-models",
  "reth-errors",
  "reth-ethereum-primitives",
  "reth-evm",
@@ -10092,7 +10148,7 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-layer"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-rpc-types-engine",
  "http",
@@ -10100,7 +10156,7 @@ dependencies = [
  "jsonrpsee",
  "jsonrpsee-http-client",
  "pin-project",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "tokio",
  "tower",
  "tower-http",
@@ -10109,9 +10165,9 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-server-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "jsonrpsee-core",
@@ -10124,11 +10180,11 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-traits"
-version = "0.3.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "860fe223501a76ff14aa3bf164f739f31008c2a2905ac85708bfd88f042e6151"
+checksum = "947a4e5cec5166505ea078c9164f06bf691fd83d3850e72851b58a9f1900cb6d"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-network",
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -10139,11 +10195,11 @@ dependencies = [
 
 [[package]]
 name = "reth-stages"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
  "assert_matches",
@@ -10155,7 +10211,7 @@ dependencies = [
  "paste",
  "rand 0.9.4",
  "rayon",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-chainspec",
  "reth-codecs",
  "reth-config",
@@ -10201,9 +10257,9 @@ dependencies = [
 
 [[package]]
 name = "reth-stages-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-primitives",
  "aquamarine",
  "assert_matches",
@@ -10235,7 +10291,7 @@ dependencies = [
 
 [[package]]
 name = "reth-stages-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "arbitrary",
@@ -10251,7 +10307,7 @@ dependencies = [
 
 [[package]]
 name = "reth-static-file"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "assert_matches",
@@ -10274,7 +10330,7 @@ dependencies = [
 
 [[package]]
 name = "reth-static-file-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "clap",
@@ -10292,10 +10348,11 @@ dependencies = [
 
 [[package]]
 name = "reth-storage-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "auto_impl",
@@ -10308,16 +10365,19 @@ dependencies = [
  "reth-prune-types",
  "reth-stages-types",
  "reth-storage-errors",
+ "reth-tokio-util",
  "reth-trie-common",
  "revm-database",
  "serde_json",
+ "tokio",
+ "tokio-stream",
 ]
 
 [[package]]
 name = "reth-storage-errors"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "derive_more",
@@ -10332,10 +10392,10 @@ dependencies = [
 
 [[package]]
 name = "reth-storage-rpc-provider"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-network",
  "alloy-primitives",
  "alloy-provider",
@@ -10361,7 +10421,7 @@ dependencies = [
 
 [[package]]
 name = "reth-tasks"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "crossbeam-utils",
  "dashmap",
@@ -10381,11 +10441,11 @@ dependencies = [
 
 [[package]]
 name = "reth-testing-utils"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
  "rand 0.8.6",
@@ -10397,7 +10457,7 @@ dependencies = [
 
 [[package]]
 name = "reth-tokio-util"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "tokio",
  "tokio-stream",
@@ -10406,7 +10466,7 @@ dependencies = [
 
 [[package]]
 name = "reth-tracing"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "clap",
  "eyre",
@@ -10414,6 +10474,7 @@ dependencies = [
  "rolling-file",
  "tracing",
  "tracing-appender",
+ "tracing-chrome",
  "tracing-journald",
  "tracing-logfmt",
  "tracing-samply",
@@ -10424,8 +10485,9 @@ dependencies = [
 
 [[package]]
 name = "reth-tracing-otlp"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
+ "base64 0.22.1",
  "clap",
  "eyre",
  "opentelemetry",
@@ -10441,10 +10503,10 @@ dependencies = [
 
 [[package]]
 name = "reth-transaction-pool"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "aquamarine",
@@ -10492,10 +10554,10 @@ dependencies = [
 
 [[package]]
 name = "reth-trie"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-eips 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-trie",
@@ -10525,14 +10587,15 @@ dependencies = [
 
 [[package]]
 name = "reth-trie-common"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
- "alloy-genesis 2.0.4",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.4",
+ "alloy-serde",
  "alloy-trie",
  "arbitrary",
  "arrayvec",
@@ -10557,9 +10620,9 @@ dependencies = [
 
 [[package]]
 name = "reth-trie-db"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-consensus 2.0.4",
+ "alloy-consensus",
  "alloy-primitives",
  "alloy-rlp",
  "metrics",
@@ -10588,9 +10651,9 @@ dependencies = [
 
 [[package]]
 name = "reth-trie-parallel"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
- "alloy-eip7928",
+ "alloy-eip7928 0.4.1",
  "alloy-evm",
  "alloy-primitives",
  "alloy-rlp",
@@ -10622,13 +10685,14 @@ dependencies = [
 
 [[package]]
 name = "reth-trie-sparse"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
  "alloy-trie",
  "arbitrary",
  "assert_matches",
+ "either",
  "itertools 0.14.0",
  "metrics",
  "pretty_assertions",
@@ -10655,18 +10719,18 @@ dependencies = [
 
 [[package]]
 name = "reth-zstd-compressors"
-version = "0.3.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c12fafa33d2f420a9d39249a3e0357b1928d09429f30758b85280409092873b2"
+checksum = "395b92a7cf863f70bd109e35f70a2fe36033187de06f6840e0ccf61c8008375d"
 dependencies = [
  "zstd",
 ]
 
 [[package]]
 name = "revm"
-version = "38.0.0"
+version = "40.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91202d39dbe8e8d10e9e8f2b76c30da68ecd1d25be69ba6d853ad0d03a3a398a"
+checksum = "823da6e5509bb8e5dcd91295870e494917a030ad506fc83301f3f08ad8b15b17"
 dependencies = [
  "revm-bytecode",
  "revm-context",
@@ -10683,9 +10747,9 @@ dependencies = [
 
 [[package]]
 name = "revm-bytecode"
-version = "10.0.0"
+version = "11.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdbb3a3d735efa94c91f2ef6bf20a35f99a77bc78f3e25bd758336901bdf9661"
+checksum = "d8b378c2653331fe60969d9745e802cd773d82a20d8aaced914dfcf26ab8f0d9"
 dependencies = [
  "bitvec",
  "phf",
@@ -10695,9 +10759,9 @@ dependencies = [
 
 [[package]]
 name = "revm-context"
-version = "16.0.1"
+version = "18.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5f68d928d8b228e0faeb1c6ed75c4fde7d124f1ddf9119b67e7a0ad4041237d"
+checksum = "bafa298114f3cab706945de14c04e73e6e6d7896302e4183dae273f968e52f80"
 dependencies = [
  "bitvec",
  "cfg-if",
@@ -10712,9 +10776,9 @@ dependencies = [
 
 [[package]]
 name = "revm-context-interface"
-version = "17.0.1"
+version = "19.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3758e6167c4ba7a59a689c519a047edaefcd4c37d74f279b93ed87bc8aece4"
+checksum = "db9c13f1dfc79425931fd184b6bd373dfac7baba50859b01107d5c0e20549cbb"
 dependencies = [
  "alloy-eip2930",
  "alloy-eip7702",
@@ -10728,11 +10792,12 @@ dependencies = [
 
 [[package]]
 name = "revm-database"
-version = "13.0.1"
+version = "15.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c281a1f11d3bcb8c0bba1199ed6bcb001d1aeb3d4fb366819e14f88723989a4e"
+checksum = "a69c3ce73454a09ef89a66177239d7c4f5f697227ae27254c99451866603b19d"
 dependencies = [
- "alloy-eips 1.8.3",
+ "alloy-eips",
+ "derive_more",
  "revm-bytecode",
  "revm-database-interface",
  "revm-primitives",
@@ -10742,9 +10807,9 @@ dependencies = [
 
 [[package]]
 name = "revm-database-interface"
-version = "11.0.1"
+version = "12.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d89efb9832a4e3742bb4ded5f7fe5bf905e8860e69427d4dfec153484fc6d304"
+checksum = "4a2656187f9f9c22ef9dd9300ed71aeaeca3506a6a0a229a07f264649b960d68"
 dependencies = [
  "auto_impl",
  "either",
@@ -10756,9 +10821,9 @@ dependencies = [
 
 [[package]]
 name = "revm-handler"
-version = "18.1.0"
+version = "20.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "783e903d6922b7f5f9a940d1bb229530502d2924b1aed9d5ca5a94ebf065d460"
+checksum = "3ce1d66037ca1394128313bb995fa9f50d834927a389386bb34f8f0ef914648f"
 dependencies = [
  "auto_impl",
  "derive-where",
@@ -10775,9 +10840,9 @@ dependencies = [
 
 [[package]]
 name = "revm-inspector"
-version = "19.0.0"
+version = "21.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8216ad58422090d0daa9eb430e0a081f7ad07e7fd30681dee71f8420c99624e0"
+checksum = "9fe3635d3411e8318849546570ca0220e783443319e28f5397c9f80b05bf4344"
 dependencies = [
  "auto_impl",
  "either",
@@ -10793,9 +10858,9 @@ dependencies = [
 
 [[package]]
 name = "revm-inspectors"
-version = "0.39.0"
+version = "0.40.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "731b682530a732ef9c189ef831589128e2ce34d4a306c956322ae2dffe009715"
+checksum = "15e0cdc845c8dbf41255c9add80923b45df7bf1dd0473e41483ac398005dba12"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -10813,9 +10878,9 @@ dependencies = [
 
 [[package]]
 name = "revm-interpreter"
-version = "35.0.1"
+version = "37.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ece9f41b69658c15d748288a4dbdfc06a63f3ce93d983af440de3f1631dce6a"
+checksum = "bae56c57ddca1f5c4abd443f826f1b3e49a86a528e7e1ea0fc207cdc4671a37e"
 dependencies = [
  "revm-bytecode",
  "revm-context-interface",
@@ -10826,9 +10891,9 @@ dependencies = [
 
 [[package]]
 name = "revm-precompile"
-version = "34.0.0"
+version = "36.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a346a8cc6c8c39bd65306641c692191299c0a7b63d38810e39e8fe9b92378660"
+checksum = "191db865091e07ecb80b12ce3048192c76071ca3d2b0a315b111b271cd4ced37"
 dependencies = [
  "ark-bls12-381",
  "ark-bn254",
@@ -10852,24 +10917,24 @@ dependencies = [
 
 [[package]]
 name = "revm-primitives"
-version = "23.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c99bda77d9661521ba0b4bc04558c6692074f01e65dd420fa3b893033d9b8a2"
+checksum = "fe5102d804892908d4ebf68da29b8562895922dffa26c230ff2c4dadcf93916f"
 dependencies = [
  "alloy-primitives",
- "num_enum",
  "once_cell",
  "serde",
 ]
 
 [[package]]
 name = "revm-state"
-version = "11.0.1"
+version = "12.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c32490ed687dba31c3c882beb8c20408bdd30ef96690d8f145b0ee9a87040bfe"
+checksum = "40eff6067185cf80932e06f6a9c8045b012ecb6f99a8d6edc618ec2792373e14"
 dependencies = [
- "alloy-eip7928",
+ "alloy-eip7928 0.4.1",
  "bitflags 2.11.1",
+ "nonmax",
  "revm-bytecode",
  "revm-primitives",
  "serde",
@@ -11080,7 +11145,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -11127,9 +11192,9 @@ version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19787cda76408ec5404443dc8b31795c87cd8fec49762dc75fa727740d34acc1"
 dependencies = [
- "core-foundation",
+ "core-foundation 0.10.1",
  "core-foundation-sys",
- "jni",
+ "jni 0.21.1",
  "log",
  "once_cell",
  "rustls",
@@ -11148,9 +11213,9 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
 dependencies = [
- "core-foundation",
+ "core-foundation 0.10.1",
  "core-foundation-sys",
- "jni",
+ "jni 0.21.1",
  "log",
  "once_cell",
  "rustls",
@@ -11160,7 +11225,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs 1.0.7",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -11348,7 +11413,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
 dependencies = [
  "bitflags 2.11.1",
- "core-foundation",
+ "core-foundation 0.10.1",
  "core-foundation-sys",
  "libc",
  "security-framework-sys",
@@ -11495,11 +11560,12 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.18.0"
+version = "3.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd5414fad8e6907dbdd5bc441a50ae8d6e26151a03b1de04d89a5576de61d01f"
+checksum = "e72c1c2cb7b223fafb600a619537a871c2818583d619401b785e7c0b746ccde2"
 dependencies = [
  "base64 0.22.1",
+ "bs58",
  "chrono",
  "hex",
  "indexmap 1.9.3",
@@ -11514,9 +11580,9 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.18.0"
+version = "3.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3db8978e608f1fe7357e211969fd9abdcae80bac1ba7a3369bb7eb6b404eb65"
+checksum = "b90c488738ecb4fb0262f41f43bc40efc5868d9fb744319ddf5f5317f417bfac"
 dependencies = [
  "darling 0.23.0",
  "proc-macro2",
@@ -11563,7 +11629,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
 dependencies = [
  "digest 0.10.7",
- "keccak",
+ "keccak 0.1.6",
+]
+
+[[package]]
+name = "sha3"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be176f1a57ce4e3d31c1a166222d9768de5954f811601fb7ca06fc8203905ce1"
+dependencies = [
+ "digest 0.11.3",
+ "keccak 0.2.0",
 ]
 
 [[package]]
@@ -11638,6 +11714,22 @@ version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
 
+[[package]]
+name = "simd_cesu8"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94f90157bb87cddf702797c5dadfa0be7d266cdf49e22da2fcaa32eff75b2c33"
+dependencies = [
+ "rustc_version 0.4.1",
+ "simdutf8",
+]
+
+[[package]]
+name = "simdutf8"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
+
 [[package]]
 name = "similar"
 version = "2.7.0"
@@ -11749,7 +11841,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -11842,6 +11934,12 @@ version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
+[[package]]
+name = "symlink"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7973cce6668464ea31f176d85b13c7ab3bba2cb3b77a2ed26abd7801688010a"
+
 [[package]]
 name = "syn"
 version = "1.0.109"
@@ -11866,9 +11964,9 @@ dependencies = [
 
 [[package]]
 name = "syn-solidity"
-version = "1.5.7"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53f425ae0b12e2f5ae65542e00898d500d4d318b4baf09f40fd0d410454e9947"
+checksum = "ec005042c7d952febc1a3ef5b0f6674e9054aa836877a31c90b20e25b3d31744"
 dependencies = [
  "paste",
  "proc-macro2",
@@ -11910,6 +12008,27 @@ dependencies = [
  "windows 0.62.2",
 ]
 
+[[package]]
+name = "system-configuration"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.9.4",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "tag_ptr"
 version = "0.1.0"
@@ -11930,9 +12049,9 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "tar"
-version = "0.4.45"
+version = "0.4.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22692a6476a21fa75fdfc11d452fda482af402c008cdbaf3476414e122040973"
+checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840"
 dependencies = [
  "filetime",
  "libc",
@@ -11949,7 +12068,7 @@ dependencies = [
  "getrandom 0.4.2",
  "once_cell",
  "rustix",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -12217,9 +12336,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.52.1"
+version = "1.52.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b67dee974fe86fd92cc45b7a95fdd2f99a36a6d7b0d431a231178d3d670bbcc6"
+checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe"
 dependencies = [
  "bytes",
  "libc",
@@ -12416,9 +12535,9 @@ dependencies = [
 
 [[package]]
 name = "tower-http"
-version = "0.6.8"
+version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
+checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840"
 dependencies = [
  "async-compression",
  "base64 0.22.1",
@@ -12431,7 +12550,6 @@ dependencies = [
  "http-body-util",
  "http-range-header",
  "httpdate",
- "iri-string",
  "mime",
  "mime_guess",
  "percent-encoding",
@@ -12442,6 +12560,7 @@ dependencies = [
  "tower-layer",
  "tower-service",
  "tracing",
+ "url",
  "uuid",
 ]
 
@@ -12471,11 +12590,12 @@ dependencies = [
 
 [[package]]
 name = "tracing-appender"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "786d480bce6247ab75f005b14ae1624ad978d3029d9113f0a22fa1ac773faeaf"
+checksum = "050686193eb999b4bb3bc2acfa891a13da00f79734704c4b8b4ef1a10b368a3c"
 dependencies = [
  "crossbeam-channel",
+ "symlink",
  "thiserror 2.0.18",
  "time",
  "tracing-subscriber 0.3.23",
@@ -12493,23 +12613,24 @@ dependencies = [
 ]
 
 [[package]]
-name = "tracing-core"
-version = "0.1.36"
+name = "tracing-chrome"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+checksum = "bf0a738ed5d6450a9fb96e86a23ad808de2b727fd1394585da5cdd6788ffe724"
 dependencies = [
- "once_cell",
- "valuable",
+ "serde_json",
+ "tracing-core",
+ "tracing-subscriber 0.3.23",
 ]
 
 [[package]]
-name = "tracing-error"
-version = "0.2.1"
+name = "tracing-core"
+version = "0.1.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b1581020d7a273442f5b45074a6a57d5757ad0a47dac0e9f0bd57b81936f3db"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
 dependencies = [
- "tracing",
- "tracing-subscriber 0.3.23",
+ "once_cell",
+ "valuable",
 ]
 
 [[package]]
@@ -12729,9 +12850,9 @@ checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
 
 [[package]]
 name = "typenum"
-version = "1.19.0"
+version = "1.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"
 
 [[package]]
 name = "ucd-trie"
@@ -12816,7 +12937,7 @@ version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
 dependencies = [
- "crypto-common",
+ "crypto-common 0.1.7",
  "subtle",
 ]
 
@@ -13224,7 +13345,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -13679,9 +13800,6 @@ name = "winnow"
 version = "0.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
-dependencies = [
- "memchr",
-]
 
 [[package]]
 name = "winnow"
diff --git a/Cargo.toml b/Cargo.toml
index 240e82938c9..6d97bfdf9ba 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace.package]
-version = "2.2.0"
+version = "2.3.0"
 edition = "2024"
 rust-version = "1.93"
 license = "MIT OR Apache-2.0"
@@ -10,7 +10,6 @@ exclude = [".github/"]
 [workspace]
 members = [
     "bin/reth-bb/",
-    "bin/reth-bench/",
     "bin/reth/",
     "crates/storage/rpc-provider/",
     "crates/chain-state/",
@@ -124,6 +123,7 @@ members = [
     "examples/beacon-api-sse/",
     "examples/bsc-p2p",
     "examples/custom-dev-node/",
+    "examples/custom-state-root/",
     "examples/custom-engine-types/",
     "examples/custom-evm/",
     "examples/custom-hardforks/",
@@ -321,15 +321,14 @@ incremental = false
 reth = { path = "bin/reth" }
 reth-storage-rpc-provider = { path = "crates/storage/rpc-provider" }
 reth-basic-payload-builder = { path = "crates/payload/basic" }
-reth-bench = { path = "bin/reth-bench" }
 reth-chain-state = { path = "crates/chain-state" }
 reth-chainspec = { path = "crates/chainspec", default-features = false }
 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.4.1", default-features = false }
+reth-codecs-derive = "0.4.1"
 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 }
@@ -397,7 +396,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.4.1", 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 }
@@ -413,7 +412,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.4.1", 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 }
@@ -424,7 +423,7 @@ reth-storage-errors = { path = "crates/storage/errors", default-features = false
 reth-tasks = { path = "crates/tasks" }
 reth-testing-utils = { path = "testing/testing-utils" }
 reth-tokio-util = { path = "crates/tokio-util" }
-reth-tracing = { path = "crates/tracing", default-features = false }
+reth-tracing = { path = "crates/tracing" }
 reth-tracing-otlp = { path = "crates/tracing-otlp" }
 reth-transaction-pool = { path = "crates/transaction-pool" }
 reth-trie = { path = "crates/trie/trie" }
@@ -432,73 +431,62 @@ 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.4.1", default-features = false }
 
 # revm
-revm = { version = "38.0.0", default-features = false }
-revm-bytecode = { version = "10.0.0", default-features = false }
-revm-database = { version = "13.0.0", default-features = false }
-revm-state = { version = "11.0.0", default-features = false }
-revm-primitives = { version = "23.0.0", default-features = false }
-revm-interpreter = { version = "35.0.0", default-features = false }
-revm-database-interface = { version = "11.0.0", default-features = false }
-revm-inspectors = "0.39.0"
+revm = { version = "40.0.3", default-features = false }
+revm-bytecode = { version = "11.0.0", default-features = false }
+revm-database = { version = "15.0.0", default-features = false }
+revm-state = { version = "12.0.0", default-features = false }
+revm-primitives = { version = "24.0.0", default-features = false }
+revm-interpreter = { version = "37.0.0", default-features = false }
+revm-database-interface = { version = "12.0.0", default-features = false }
+revm-inspectors = "0.40.1"
 
 # eth
-alloy-dyn-abi = "1.5.6"
-alloy-primitives = { version = "1.5.6", default-features = false, features = [
-    "map-foldhash",
-] }
-alloy-sol-types = { version = "1.5.6", default-features = false }
+alloy-dyn-abi = "1.6.0"
+alloy-primitives = { version = "1.6.0", default-features = false, features = ["map-foldhash"] }
+alloy-sol-types = { version = "1.6.0", 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-rlp = { version = "0.3.13", default-features = false, features = [
-    "core-net",
-] }
+alloy-eip7928 = { version = "0.4.0", default-features = false, features = ["rlp"] }
+alloy-evm = { version = "0.36.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.5", default-features = false }
+alloy-contract = { version = "2.0.5", default-features = false }
+alloy-eips = { version = "2.0.5", default-features = false }
+alloy-genesis = { version = "2.0.5", default-features = false }
+alloy-json-rpc = { version = "2.0.5", default-features = false }
+alloy-network = { version = "2.0.5", default-features = false }
+alloy-network-primitives = { version = "2.0.5", default-features = false }
+alloy-provider = { version = "2.0.5", features = ["reqwest", "debug-api"], default-features = false }
+alloy-pubsub = { version = "2.0.5", default-features = false }
+alloy-rpc-client = { version = "2.0.5", default-features = false }
+alloy-rpc-types = { version = "2.0.5", features = ["eth"], default-features = false }
+alloy-rpc-types-admin = { version = "2.0.5", default-features = false }
+alloy-rpc-types-anvil = { version = "2.0.5", default-features = false }
+alloy-rpc-types-beacon = { version = "2.0.5", default-features = false }
+alloy-rpc-types-debug = { version = "2.0.5", default-features = false }
+alloy-rpc-types-engine = { version = "2.0.5", default-features = false }
+alloy-rpc-types-eth = { version = "2.0.5", default-features = false }
+alloy-rpc-types-mev = { version = "2.0.5", default-features = false }
+alloy-rpc-types-trace = { version = "2.0.5", default-features = false }
+alloy-rpc-types-txpool = { version = "2.0.5", default-features = false }
+alloy-serde = { version = "2.0.5", default-features = false }
+alloy-signer = { version = "2.0.5", default-features = false }
+alloy-signer-local = { version = "2.0.5", default-features = false }
+alloy-transport = { version = "2.0.5" }
+alloy-transport-http = { version = "2.0.5", features = ["reqwest-rustls-tls"], default-features = false }
+alloy-transport-ipc = { version = "2.0.5", default-features = false }
+alloy-transport-ws = { version = "2.0.5", default-features = false }
 
 # misc
-either = { version = "1.15.0", default-features = false }
+either = { version = "1.16.0", default-features = false }
 arrayvec = { version = "0.7.6", default-features = false }
 aquamarine = "0.6"
 auto_impl = "1"
@@ -515,7 +503,7 @@ brotli = "8"
 cfg-if = "1.0"
 clap = "4"
 color-eyre = "0.6"
-dashmap = "6.0"
+dashmap = "6.2"
 derive_more = { version = "2", default-features = false, features = ["full"] }
 dirs-next = "2.0.0"
 dyn-clone = "1.0.17"
@@ -556,15 +544,13 @@ strum = { version = "0.27", default-features = false }
 strum_macros = "0.27"
 syn = "2.0"
 thiserror = { version = "2.0.0", default-features = false }
-tar = "0.4.44"
-tracing = { version = "0.1.0", default-features = false, features = [
-    "attributes",
-] }
-tracing-appender = "0.2"
+tar = "0.4.46"
+tracing = { version = "0.1.0", default-features = false, features = ["attributes"] }
+tracing-appender = "0.2.5"
 url = { version = "2.3", default-features = false }
 zstd = "0.13"
 byteorder = "1"
-fixed-cache = { version = "0.1.7", features = ["stats"] }
+fixed-cache = { version = "0.1.10", features = ["stats"] }
 moka = "0.12"
 tar-no-std = { version = "0.4.2", default-features = false }
 miniz_oxide = { version = "0.9.0", default-features = false }
@@ -573,16 +559,16 @@ chrono = "0.4.41"
 # metrics
 metrics = "0.24.0"
 metrics-derive = "0.1.1"
-metrics-exporter-prometheus = { version = "0.18.0", default-features = false }
+metrics-exporter-prometheus = { version = "0.18.3", default-features = false }
 metrics-process = "2.1.0"
-metrics-util = { default-features = false, version = "0.20.0" }
+metrics-util = { default-features = false, version = "0.20.3" }
 
 # proc-macros
 proc-macro2 = "1.0"
 quote = "1.0"
 
 # tokio
-tokio = { version = "1.51.1", default-features = false }
+tokio = { version = "1.52.3", default-features = false }
 tokio-stream = "0.1.11"
 tokio-tungstenite = "0.28.0"
 tokio-util = { version = "0.7.4", features = ["codec"] }
@@ -596,11 +582,8 @@ futures-core = "0.3"
 futures-util = { version = "0.3", default-features = false }
 hyper = "1.9"
 hyper-util = "0.1.5"
-pin-project = "1.0.12"
-reqwest = { version = "0.13", default-features = false, features = [
-    "rustls",
-    "stream",
-] }
+pin-project = "1.1.12"
+reqwest = { version = "0.13", default-features = false, features = ["rustls", "stream"] }
 tracing-futures = "0.2"
 tower = "0.5"
 tower-http = "0.6"
@@ -663,8 +646,8 @@ rstest = "0.26.1"
 test-case = "3"
 
 # ssz encoding
-ethereum_ssz = "0.10.1"
-ethereum_ssz_derive = "0.10.1"
+ethereum_ssz = "0.10.4"
+ethereum_ssz_derive = "0.10.4"
 
 # allocators
 jemalloc_pprof = { version = "0.8", default-features = false }
@@ -679,7 +662,7 @@ ahash = "0.8"
 anyhow = "1.0"
 bindgen = { version = "0.72", default-features = false }
 block-padding = "0.3"
-cc = "1.2.15"
+cc = "1.2.62"
 cipher = "0.4.3"
 comfy-table = "7.0"
 concat-kdf = "0.1.0"
@@ -694,11 +677,11 @@ data-encoding = "2"
 delegate = "0.13"
 digest = "0.10.5"
 hash-db = "=0.15.2"
-hickory-resolver = "0.25.0"
+hickory-resolver = "0.26.1"
 hmac = "0.12.1"
 human_bytes = "0.4.1"
 indexmap = "2"
-interprocess = "2.2.0"
+interprocess = "2.4.2"
 lz4_flex = { version = "0.12", default-features = false }
 memmap2 = "0.9.4"
 num-traits = "0.2.15"
@@ -717,6 +700,7 @@ sysinfo = { version = "0.38", default-features = false }
 tracing-journald = "0.3"
 tracing-logfmt = "0.3.7"
 tracing-samply = "0.1"
+tracing-chrome = "0.7.2"
 tracing-subscriber = { version = "0.3", default-features = false }
 tracing-tracy = "0.11"
 triehash = "0.8"
@@ -738,7 +722,7 @@ reth-firehose-tests = { path = "crates/firehose-tests" }
 ## Firehose additions
 # SF fork of alloy-evm that routes system calls (EIP-4788, EIP-2935, etc.) through the Inspector.
 # See https://github.com/alloy-rs/evm/pull/323 for the upstream PR.
-alloy-evm = { git = "https://github.com/streamingfast/evm.git", branch = "sf/v0.34.0" }
+alloy-evm = { git = "https://github.com/streamingfast/evm.git", branch = "sf/v0.36.0" }
 
 ## Firehose additions
 # This is needed otherwise we get flooding of debug logs around a problem that seems to happen in Reth directly.
diff --git a/Makefile b/Makefile
index fd04a20d35c..238ded99eaa 100644
--- a/Makefile
+++ b/Makefile
@@ -192,18 +192,6 @@ $(EEST_TESTS_DIR):
 ef-tests: $(EF_TESTS_DIR) $(EEST_TESTS_DIR) ## Runs Legacy and EEST tests.
 	cargo nextest run --no-fail-fast -p ef-tests --release --features ef-tests
 
-##@ reth-bench
-
-.PHONY: reth-bench
-reth-bench: ## Build the reth-bench binary into the `target` directory.
-	cargo build --manifest-path bin/reth-bench/Cargo.toml --features "$(FEATURES)" --profile "$(PROFILE)"
-
-.PHONY: install-reth-bench
-install-reth-bench: ## Build and install the reth binary under `$(CARGO_HOME)/bin`.
-	cargo install --path bin/reth-bench --bin reth-bench --force --locked \
-		--features "$(FEATURES)" \
-		--profile "$(PROFILE)"
-
 ##@ Other
 
 .PHONY: clean
@@ -245,7 +233,7 @@ maxperf: ## Builds `reth` with the most aggressive optimisations.
 
 .PHONY: maxperf-no-asm
 maxperf-no-asm: ## Builds `reth` with the most aggressive optimisations, minus the "asm-keccak" feature.
-	RUSTFLAGS="-C target-cpu=native" cargo build --profile maxperf --no-default-features --features jemalloc,min-debug-logs,otlp,otlp-logs,reth-revm/portable,js-tracer,keccak-cache-global,rocksdb
+	RUSTFLAGS="-C target-cpu=native" cargo build --profile maxperf --no-default-features --features jemalloc,min-trace-logs,otlp,otlp-logs,reth-revm/portable,js-tracer,keccak-cache-global,rocksdb
 
 fmt:
 	cargo +nightly fmt
diff --git a/README.md b/README.md
index 37e6a9bcd93..a5599f82df7 100644
--- a/README.md
+++ b/README.md
@@ -28,7 +28,7 @@ Reth (short for Rust Ethereum, [pronunciation](https://x.com/kelvinfichter/statu
 
 1. **Modularity**: Every component is built to be used as a library: well-tested, documented and benchmarked. Import crates, mix and match, and innovate on top of them. Learn more about the project's components [here](./docs/repo/layout.md).
 2. **Performance**: Built with Rust, [Alloy](https://github.com/alloy-rs/alloy/), [revm](https://github.com/bluealloy/revm/), and [Foundry](https://github.com/foundry-rs/foundry/) — battle-tested and optimized for speed. Check the [ethPandaOps Lab Dashboard](https://lab.ethpandaops.io/ethereum/execution/timings) for a third-party comparison against other Ethereum clients.
-Here's what that looks like in practice, measured with [reth-bench](https://github.com/paradigmxyz/reth/tree/main/bin/reth-bench) on Ethereum Mainnet:
+Here's what that looks like in practice on Ethereum Mainnet:
 
 ![](./assets/reth-perf.png)
 
diff --git a/SECURITY.md b/SECURITY.md
index 7521d62e959..78e361d3ce7 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -2,4 +2,4 @@
 
 ## Report a Vulnerability
 
-Contact [security@ithaca.xyz](mailto:security@ithaca.xyz).
+Contact [security@tempo.xyz](mailto:security@tempo.xyz).
diff --git a/bin/reth-bb/Cargo.toml b/bin/reth-bb/Cargo.toml
index d0e5526bb45..41de839a59e 100644
--- a/bin/reth-bb/Cargo.toml
+++ b/bin/reth-bb/Cargo.toml
@@ -70,7 +70,24 @@ default = [
     "reth-cli-util/jemalloc",
     "asm-keccak",
     "keccak-cache-global",
-    "min-debug-logs",
+    "min-trace-logs",
+    "otlp",
+    "otlp-logs",
+    "reth-revm/portable",
+    "js-tracer",
+]
+
+otlp = [
+    "reth-ethereum-cli/otlp",
+    "reth-node-core/otlp",
+]
+otlp-logs = [
+    "reth-ethereum-cli/otlp-logs",
+    "reth-node-core/otlp-logs",
+]
+js-tracer = [
+    "reth-node-builder/js-tracer",
+    "reth-node-ethereum/js-tracer",
 ]
 
 jemalloc = [
@@ -101,6 +118,11 @@ min-debug-logs = [
     "reth-ethereum-cli/min-debug-logs",
     "reth-node-core/min-debug-logs",
 ]
+min-trace-logs = [
+    "tracing/release_max_level_trace",
+    "reth-ethereum-cli/min-trace-logs",
+    "reth-node-core/min-trace-logs",
+]
 
 [[bin]]
 name = "reth-bb"
diff --git a/bin/reth-bb/README.md b/bin/reth-bb/README.md
index 8a2c27e585e..2aefdcb78a7 100644
--- a/bin/reth-bb/README.md
+++ b/bin/reth-bb/README.md
@@ -14,36 +14,45 @@ reth-bb extends the standard Ethereum node with:
 
 ## Quick start
 
-The full workflow has four steps: **build** binaries, **generate** big blocks,  **start** reth-bb, and **replay** the payloads.
+The full workflow has five steps: **build** reth-bb, **install** txgen tools, **extract** big-block payloads, **start** reth-bb, and **replay** the payloads.
 
 ### Prerequisites
 
 - A synced reth datadir for the target chain (e.g. hoodi)
 - Rust toolchain
+- An archive RPC endpoint that supports `debug_getRawBlock`
 
-### 1. Build
+### 1. Build reth-bb
 
 ```bash
-cargo build --profile profiling -p reth-bb -p reth-bench
+cargo build --profile profiling -p reth-bb
 ```
 
-### 2. Generate big blocks
+### 2. Install txgen tools
 
-Fetch consecutive blocks from an RPC and merge them until a target gas is reached. Use `--from-block` set to the block number following the one the node is currently synced to (i.e. the next block the node would process):
+Install `txgen-ethereum` for big-block extraction and `bench` for Engine API replay from [tempoxyz/txgen](https://github.com/tempoxyz/txgen):
 
 ```bash
-reth-bench generate-big-block \
-    --rpc-url https://rpc.hoodi.ethpandaops.io \
-    --chain hoodi \
-    --from-block 910020 \
+cargo install --git https://github.com/tempoxyz/txgen txgen-ethereum --locked
+cargo install --git https://github.com/tempoxyz/txgen bench-cli --locked
+```
+
+### 3. Extract big-block payloads
+
+Merge source blocks into synthetic big-block payloads, starting at the block following the one the node is currently synced to (i.e. the next block the node would process):
+
+```bash
+txgen-ethereum extract-big-blocks \
+    --rpc https://rpc.hoodi.ethpandaops.io \
+    --from 910020 \
+    --count 5 \
     --target-gas 2G \
-    --num-big-blocks 5 \
-    --output-dir /tmp/payloads
+    --output /tmp/big-blocks.ndjson
 ```
 
-This produces one JSON file per big block in the output directory.
+This produces an NDJSON file containing one reth-bb-compatible big-block payload per line. `--target-gas` accepts bare units or `K`, `M`, `G` suffixes.
 
-### 3. Start reth-bb
+### 4. Start reth-bb
 
 ```bash
 reth-bb node \
@@ -54,14 +63,15 @@ reth-bb node \
     -d
 ```
 
-### 4. Replay payloads
+### 5. Replay payloads
 
 ```bash
-reth-bench replay-payloads \
-    --engine-rpc-url http://localhost:8551 \
+bench send-blocks \
+    --engine http://localhost:8551 \
     --jwt-secret /tmp/jwt.hex \
-    --payload-dir /tmp/payloads \
-    --reth-new-payload
+    --input /tmp/big-blocks.ndjson \
+    --wait-for-persistence every:2 \
+    --report json:/tmp/reth-bb-report.json
 ```
 
-The `--reth-new-payload` flag is required for big blocks — it uses the `reth_newPayload` endpoint which carries the multi-segment execution metadata.
+`bench send-blocks` submits each payload through reth's custom `reth_newPayload` and `reth_forkchoiceUpdated` Engine API methods.
diff --git a/bin/reth-bb/src/evm.rs b/bin/reth-bb/src/evm.rs
index a4cd0761be2..e17273e6f8e 100644
--- a/bin/reth-bb/src/evm.rs
+++ b/bin/reth-bb/src/evm.rs
@@ -12,7 +12,7 @@ use alloy_eips::eip7685::Requests;
 use alloy_evm::{
     block::{
         BlockExecutionError, BlockExecutionResult, BlockExecutor, BlockExecutorFactory,
-        ExecutableTx, GasOutput, OnStateHook, StateChangeSource, StateDB,
+        ExecutableTx, GasOutput, StateDB,
     },
     eth::{EthBlockExecutionCtx, EthBlockExecutor, EthEvmContext, EthTxResult},
     precompiles::PrecompilesMap,
@@ -29,7 +29,6 @@ use revm::{
     primitives::hardfork::SpecId,
     Inspector,
 };
-use std::sync::{Arc, Mutex};
 use tracing::{debug, trace};
 
 // ---------------------------------------------------------------------------
@@ -37,10 +36,10 @@ use tracing::{debug, trace};
 // ---------------------------------------------------------------------------
 
 /// Runtime state for segment boundary tracking.
-#[derive(Clone)]
-pub(crate) struct BbEvmPlan {
+#[derive(Debug, Clone)]
+pub struct BbEvmPlan<'a> {
     /// The segment boundaries and environments.
-    pub(crate) segments: Vec<BigBlockSegment>,
+    pub(crate) segments: Vec<BigBlockSegment<'a>>,
     /// Index of the next segment to switch to (starts at 1).
     pub(crate) next_segment: usize,
     /// Number of user transactions executed so far.
@@ -50,9 +49,9 @@ pub(crate) struct BbEvmPlan {
     pub(crate) block_hashes_to_seed: Vec<(u64, B256)>,
 }
 
-impl BbEvmPlan {
+impl<'a> BbEvmPlan<'a> {
     /// Creates a new `BbEvmPlan` from segments and hardfork flags.
-    pub(crate) fn new(segments: Vec<BigBlockSegment>) -> Self {
+    pub(crate) fn new(segments: Vec<BigBlockSegment<'a>>) -> Self {
         // Pre-compute all inter-segment block hashes.
         let mut block_hashes_to_seed = Vec::new();
         for seg in segments.iter().skip(1) {
@@ -76,22 +75,12 @@ impl BbEvmPlan {
             .collect()
     }
 
+    /// Returns the segment that contains the transaction at `tx_index`.
     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 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("BbEvmPlan")
-            .field("segments", &self.segments)
-            .field("next_segment", &self.next_segment)
-            .field("tx_counter", &self.tx_counter)
-            .field("block_hashes_to_seed", &self.block_hashes_to_seed)
-            .finish()
-    }
-}
-
 // ---------------------------------------------------------------------------
 // BbBlockExecutor — handles segment boundaries
 // ---------------------------------------------------------------------------
@@ -104,8 +93,36 @@ impl std::fmt::Debug for BbEvmPlan {
 pub(crate) type BlockHashSeeder<DB> = fn(&mut DB, &[(u64, B256)]);
 
 /// Function pointer that reads the BAL index from the DB.
+///
+/// Injected from `ConfigureEvm::create_executor` where the concrete
+/// `State<DB>` type is known. `BbBlockExecutor` calls this lazily on first
+/// use to decide which segment to start at: `0` means canonical execution
+/// from segment 0, `n > 0` means a BAL worker that runs only the n-th
+/// transaction (in whichever segment contains it).
 pub(crate) type BalIndexReader<DB> = fn(&DB) -> u64;
 
+/// Function pointer that bumps the BAL index in the DB.
+///
+/// Injected from `ConfigureEvm::create_executor` like the other DB callbacks
+/// so `BbBlockExecutor` can advance `bal_index` between sub-events of a
+/// segment boundary (post-N's `finish()` and pre-N+1's
+/// `apply_pre_execution_changes()`) without requiring additional trait bounds
+/// on `DB`. The renumbering scheme places these on consecutive `bal_indexes` so
+/// workers reading the BAL overlay see post-N's writes via the strict
+/// less-than `BalWrites::get` semantic.
+pub(crate) type BalIndexBumper<DB> = fn(&mut DB);
+
+/// Function pointer that overwrites the BAL index in the DB.
+///
+/// Used in `BbBlockExecutor::initialize` to map a worker's incoming
+/// `bal_index = i + 1` (the standard "tx i + 1" convention from
+/// `execute_block_in_pool`) onto the renumbered space `i + 1 + 2k`, where
+/// `k` is the segment index containing tx `i`. Renumbering reserves two
+/// extra `bal_indexes` per segment boundary (one for each segment's
+/// post-execution and one for the next segment's pre-execution), so workers'
+/// strict less-than reads can see those boundary writes.
+pub(crate) type BalIndexSetter<DB> = fn(&mut DB, u64);
+
 /// Block executor that wraps [`EthBlockExecutor`] and handles segment-boundary
 /// changes for big-block execution.
 ///
@@ -124,7 +141,7 @@ where
 {
     /// The inner executor. `None` transiently during `apply_segment_boundary`.
     inner: Option<EthBlockExecutor<'a, EthEvm<DB, I, P>, Spec, RethReceiptBuilder>>,
-    plan: Option<BbEvmPlan>,
+    plan: BbEvmPlan<'a>,
     /// Requests accumulated from segments that have been finished at
     /// boundaries. Merged into the final result in `finish()`.
     accumulated_requests: Requests,
@@ -134,15 +151,19 @@ where
     /// Cumulative blob gas used by all segments that have been finished at
     /// boundaries.
     blob_gas_used_offset: u64,
-    /// Shared state hook that survives inner executor finish/reconstruct
-    /// cycles at segment boundaries. Each inner executor receives a
-    /// forwarding hook that delegates to this shared instance.
-    shared_hook: Arc<Mutex<Option<Box<dyn OnStateHook>>>>,
     /// 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.
+    /// Callback to read `bal_index` from the DB. See [`BalIndexReader`].
     bal_index_reader: Option<BalIndexReader<DB>>,
+    /// Callback to bump `bal_index` on the DB. See [`BalIndexBumper`]. Used at
+    /// segment boundaries to put post-N's writes and pre-N+1's writes on
+    /// consecutive `bal_indexes`.
+    bal_index_bumper: Option<BalIndexBumper<DB>>,
+    /// Callback to set `bal_index` on the DB. See [`BalIndexSetter`]. Used in
+    /// [`Self::initialize`] to renumber a worker's incoming `bal_index` into
+    /// the boundary-padded space.
+    bal_index_setter: Option<BalIndexSetter<DB>>,
     /// Whether the executor has selected its starting segment.
     initialized: bool,
 }
@@ -163,91 +184,91 @@ where
     >,
     TxEnv: FromRecoveredTx<TransactionSigned> + FromTxWithEncoded<TransactionSigned>,
 {
+    #[expect(clippy::too_many_arguments)]
     pub(crate) fn new(
         evm: EthEvm<DB, I, P>,
-        ctx: EthBlockExecutionCtx<'a>,
+        plan: BbEvmPlan<'a>,
         spec: Spec,
         receipt_builder: RethReceiptBuilder,
-        plan: Option<BbEvmPlan>,
         block_hash_seeder: Option<BlockHashSeeder<DB>>,
         bal_index_reader: Option<BalIndexReader<DB>>,
+        bal_index_bumper: Option<BalIndexBumper<DB>>,
+        bal_index_setter: Option<BalIndexSetter<DB>>,
     ) -> Self {
-        let inner = EthBlockExecutor::new(evm, ctx, spec, receipt_builder);
+        let inner = EthBlockExecutor::new(evm, plan.segments[0].ctx.clone(), spec, receipt_builder);
         Self {
             inner: Some(inner),
             plan,
             accumulated_requests: Requests::default(),
             gas_used_offset: 0,
             blob_gas_used_offset: 0,
-            shared_hook: Arc::new(Mutex::new(None)),
             block_hash_seeder,
             bal_index_reader,
+            bal_index_bumper,
+            bal_index_setter,
             initialized: false,
         }
     }
 
+    /// Idempotent first-use init. Reads `bal_index` from the DB to pick the
+    /// starting segment, swaps the inner executor's env/ctx to that segment,
+    /// and reseeds the block hash cache for its window.
+    ///
+    /// `bal_index == 0` selects segment 0 — canonical execution that walks
+    /// all segments via `maybe_apply_boundary`. `bal_index > 0` selects the
+    /// segment containing the `(bal_index - 1)`-th transaction and drops the
+    /// plan so segment boundaries don't fire — a BAL worker only runs one
+    /// transaction in its segment.
     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 segment_idx = if let Some(bal_index) = self
+            .bal_index_reader
+            .map(|reader| reader(self.inner().evm().db()))
+            .filter(|bal_index| *bal_index > 0)
+        {
+            let segment_idx = self.plan.segment_index_for_tx((bal_index - 1) as usize);
+
+            // Renumber the worker's bal_index from the raw "tx i + 1"
+            // convention to "tx i + 1 + 2k" where k is the segment index.
+            // This reserves two `bal_indexes` per crossed segment boundary
+            // (one for post-N's `finish()`, one for pre-N+1's
+            // `apply_pre_execution_changes`) so worker reads via
+            // `BalWrites::get` see those writes via the strict less-than
+            // semantic.
+            if let Some(setter) = self.bal_index_setter {
+                let renumbered = bal_index + 2 * segment_idx as u64;
+                setter(self.inner_mut().evm_mut().db_mut(), renumbered);
+            }
 
-        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];
+            segment_idx
+        } else {
+            if self.initialized {
+                return Ok(());
+            }
 
-        // 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.
+            self.initialized = true;
+            0
+        };
+        let segment = &self.plan.segments[segment_idx];
         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 inner = self.inner.as_mut().expect("inner executor must exist");
         let evm_ctx = inner.evm.ctx_mut();
         evm_ctx.block = block_env;
         evm_ctx.cfg = cfg_env;
-        inner.ctx = ctx;
+        inner.ctx = segment.ctx.clone();
 
         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();
-        Some(Box::new(move |source: StateChangeSource, state: &revm::state::EvmState| {
-            if let Some(hook) = shared.lock().unwrap().as_mut() {
-                hook.on_state(source, state);
-            }
-        }))
-    }
-
     const fn inner(&self) -> &EthBlockExecutor<'a, EthEvm<DB, I, P>, Spec, RethReceiptBuilder> {
         self.inner.as_ref().expect("inner executor must exist")
     }
@@ -260,32 +281,12 @@ where
 
     fn reseed_block_hashes_for(&mut self, block_number: u64) {
         let Some(seeder) = self.block_hash_seeder else { return };
-        let hashes = match &self.plan {
-            Some(plan) => plan.hashes_for_block(block_number),
-            None => return,
-        };
+        let hashes = self.plan.hashes_for_block(block_number);
         seeder(self.inner_mut().evm_mut().db_mut(), &hashes);
     }
 
-    fn maybe_apply_boundary(&mut self) -> Result<(), BlockExecutionError> {
-        loop {
-            let plan = match &self.plan {
-                Some(p) => p,
-                None => return Ok(()),
-            };
-
-            if plan.next_segment >= plan.segments.len() ||
-                plan.tx_counter != plan.segments[plan.next_segment].start_tx
-            {
-                return Ok(());
-            }
-
-            self.apply_segment_boundary()?;
-        }
-    }
-
     fn apply_segment_boundary(&mut self) -> Result<(), BlockExecutionError> {
-        let plan = self.plan.as_mut().expect("plan must exist");
+        let plan = &mut self.plan;
         let seg_idx = plan.next_segment;
         let prev_seg_idx = seg_idx - 1;
 
@@ -300,42 +301,38 @@ where
         // that finish() applies the correct withdrawals and post-execution
         // system calls for that segment.
         let prev_segment = &plan.segments[prev_seg_idx];
-        let prev_ctx = EthBlockExecutionCtx {
-            parent_hash: prev_segment.ctx.parent_hash,
-            parent_beacon_block_root: prev_segment.ctx.parent_beacon_block_root,
-            ommers: prev_segment.ctx.ommers,
-            withdrawals: prev_segment.ctx.withdrawals.clone(),
-            extra_data: prev_segment.ctx.extra_data.clone(),
-            tx_count_hint: prev_segment.ctx.tx_count_hint,
-            slot_number: prev_segment.ctx.slot_number,
-        };
 
         // Clone the next segment's data before we consume inner.
         let new_segment = &plan.segments[seg_idx];
         let new_block_env = new_segment.evm_env.block_env.clone();
         let mut new_cfg_env = new_segment.evm_env.cfg_env.clone();
         new_cfg_env.disable_base_fee = true;
-        let new_ctx = EthBlockExecutionCtx {
-            parent_hash: new_segment.ctx.parent_hash,
-            parent_beacon_block_root: new_segment.ctx.parent_beacon_block_root,
-            ommers: new_segment.ctx.ommers,
-            withdrawals: new_segment.ctx.withdrawals.clone(),
-            extra_data: new_segment.ctx.extra_data.clone(),
-            tx_count_hint: new_segment.ctx.tx_count_hint,
-            slot_number: new_segment.ctx.slot_number,
-        };
 
         plan.next_segment += 1;
 
         // Finish the inner executor for the completed segment. This applies
         // post-execution system calls (EIP-7002/7251) and withdrawal balance
-        // increments via EthBlockExecutor::finish().
+        // increments via EthBlockExecutor::finish() at the current bal_index
+        // (= K, the boundary's "post-N slot").
         let mut inner = self.inner.take().expect("inner executor must exist");
-        inner.ctx = prev_ctx;
+        inner.ctx = prev_segment.ctx.clone();
         let spec = inner.spec.clone();
         let receipt_builder = inner.receipt_builder;
+
+        if let Some(bumper) = self.bal_index_bumper {
+            bumper(inner.evm_mut().db_mut());
+        }
+
         let (mut evm, result) = inner.finish()?;
 
+        // Renumbering: bump bal_index so the new segment's
+        // `apply_pre_execution_changes` writes land at K+1 instead of colliding
+        // with post-N at K. Without this, BAL workers querying at K can't see
+        // either boundary write via `BalWrites::get`'s strict less-than.
+        if let Some(bumper) = self.bal_index_bumper {
+            bumper(evm.db_mut());
+        }
+
         // Receipts already have globally-correct cumulative_gas_used (fixed
         // up in commit_transaction). Update the offset with this segment's
         // gas so that subsequent segments' receipts are adjusted correctly.
@@ -365,29 +362,22 @@ where
         // Build a new inner executor for the next segment. gas_used starts
         // at 0 so the per-transaction gas check uses this segment's real
         // gas_limit correctly.
-        let mut new_inner = EthBlockExecutor::new(evm, new_ctx, spec, receipt_builder);
+        let mut new_inner =
+            EthBlockExecutor::new(evm, new_segment.ctx.clone(), spec, receipt_builder);
 
         // Carry forward receipts from prior segments.
         new_inner.receipts = result.receipts;
 
-        // Re-install the forwarding state hook so the parallel state root
-        // task continues to receive state changes.
-        if self.shared_hook.lock().unwrap().is_some() {
-            new_inner.set_state_hook(self.forwarding_hook());
-        }
-
         self.inner = Some(new_inner);
 
         // Reseed the block hash cache for the new segment's 256-block window
         // before applying pre-execution changes (which may use BLOCKHASH).
-        let new_block_number = self.plan.as_ref().unwrap().segments[seg_idx]
-            .evm_env
-            .block_env
-            .number
-            .saturating_to::<u64>();
+        let new_block_number =
+            self.plan.segments[seg_idx].evm_env.block_env.number.saturating_to::<u64>();
         self.reseed_block_hashes_for(new_block_number);
 
-        // Apply pre-execution changes for the new segment (EIP-2935, EIP-4788).
+        // Apply pre-execution changes for the new segment (EIP-2935, EIP-4788)
+        // at bal_index K+1.
         self.inner_mut().apply_pre_execution_changes()?;
 
         trace!(target: "engine::bb::evm", "Started segment {seg_idx}");
@@ -418,8 +408,11 @@ 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.
+        // Init swaps the EVM's block_env and executor ctx to the starting
+        // segment's values so the EIP-2935/EIP-4788 system calls use the
+        // correct block number and parent hash. Without this the outer big
+        // block header's (synthetic) block_number would be used, writing to
+        // wrong EIP-2935 slots and corrupting state.
         self.initialize()?;
         self.inner_mut().apply_pre_execution_changes()
     }
@@ -429,14 +422,10 @@ where
         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);
 
         // Fix up cumulative_gas_used on the just-committed receipt so that
@@ -449,9 +438,14 @@ where
             receipt.cumulative_gas_used += offset;
         }
 
-        if let Some(plan) = &mut self.plan {
-            plan.tx_counter += 1;
+        self.plan.tx_counter += 1;
+
+        while self.plan.next_segment < self.plan.segments.len() &&
+            self.plan.tx_counter == self.plan.segments[self.plan.next_segment].start_tx
+        {
+            self.apply_segment_boundary().expect("must succeed");
         }
+
         gas_used
     }
 
@@ -461,18 +455,17 @@ where
         // Swap the inner executor's ctx to the last segment's ctx so that
         // EthBlockExecutor::finish() applies the correct withdrawal balance
         // increments and post-execution system calls.
-        if let Some(last_seg) = self.plan.as_ref().map(|p| p.segments.last().unwrap()) {
-            let last_ctx = EthBlockExecutionCtx {
-                parent_hash: last_seg.ctx.parent_hash,
-                parent_beacon_block_root: last_seg.ctx.parent_beacon_block_root,
-                ommers: last_seg.ctx.ommers,
-                withdrawals: last_seg.ctx.withdrawals.clone(),
-                extra_data: last_seg.ctx.extra_data.clone(),
-                tx_count_hint: last_seg.ctx.tx_count_hint,
-                slot_number: last_seg.ctx.slot_number,
-            };
-            self.inner_mut().ctx = last_ctx;
-        }
+        let last_seg = self.plan.segments.last().unwrap();
+        let last_ctx = EthBlockExecutionCtx {
+            parent_hash: last_seg.ctx.parent_hash,
+            parent_beacon_block_root: last_seg.ctx.parent_beacon_block_root,
+            ommers: last_seg.ctx.ommers,
+            withdrawals: last_seg.ctx.withdrawals.clone(),
+            extra_data: last_seg.ctx.extra_data.clone(),
+            tx_count_hint: last_seg.ctx.tx_count_hint,
+            slot_number: last_seg.ctx.slot_number,
+        };
+        self.inner_mut().ctx = last_ctx;
         let inner = self.inner.take().expect("inner executor must exist");
         let (evm, mut result) = inner.finish()?;
 
@@ -506,19 +499,6 @@ where
         Ok((evm, result))
     }
 
-    fn set_state_hook(&mut self, hook: Option<Box<dyn OnStateHook>>) {
-        if self.plan.is_some() {
-            // Store the real hook in the shared slot and give the inner
-            // executor a lightweight forwarder. This way the hook survives
-            // inner executor finish/reconstruct cycles at segment boundaries.
-            *self.shared_hook.lock().unwrap() = hook;
-            let fwd = self.forwarding_hook();
-            self.inner_mut().set_state_hook(fwd);
-        } else {
-            self.inner_mut().set_state_hook(hook);
-        }
-    }
-
     fn evm_mut(&mut self) -> &mut Self::Evm {
         self.inner_mut().evm_mut()
     }
@@ -543,17 +523,15 @@ pub struct BbBlockExecutorFactory<Spec> {
     receipt_builder: RethReceiptBuilder,
     spec: Spec,
     evm_factory: EthEvmFactory,
-    /// Staged plan cloned into each [`BbBlockExecutor`].
-    pub(crate) staged_plan: Arc<Mutex<Option<BbEvmPlan>>>,
 }
 
 impl<Spec> BbBlockExecutorFactory<Spec> {
-    pub fn new(
+    pub const fn new(
         receipt_builder: RethReceiptBuilder,
         spec: Spec,
         evm_factory: EthEvmFactory,
     ) -> Self {
-        Self { receipt_builder, spec, evm_factory, staged_plan: Arc::new(Mutex::new(None)) }
+        Self { receipt_builder, spec, evm_factory }
     }
 
     pub const fn evm_factory(&self) -> &EthEvmFactory {
@@ -568,39 +546,29 @@ impl<Spec> BbBlockExecutorFactory<Spec> {
         &self.receipt_builder
     }
 
-    pub(crate) fn stage_plan(&self, plan: BbEvmPlan) {
-        *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()
-    }
-
     pub(crate) fn create_executor_with_seeder<'a, DB, I>(
         &'a self,
         evm: EthEvm<DB, I, PrecompilesMap>,
-        ctx: EthBlockExecutionCtx<'a>,
+        plan: BbEvmPlan<'a>,
         block_hash_seeder: Option<BlockHashSeeder<DB>>,
         bal_index_reader: Option<BalIndexReader<DB>>,
+        bal_index_bumper: Option<BalIndexBumper<DB>>,
+        bal_index_setter: Option<BalIndexSetter<DB>>,
     ) -> BbBlockExecutor<'a, DB, I, PrecompilesMap, &'a Spec>
     where
         Spec: alloy_evm::eth::spec::EthExecutorSpec,
-        DB: StateDB + 'a,
-        I: Inspector<EthEvmContext<DB>> + 'a,
+        DB: StateDB,
+        I: Inspector<EthEvmContext<DB>>,
     {
-        let plan = self.peek_plan();
         BbBlockExecutor::new(
             evm,
-            ctx,
+            plan,
             &self.spec,
             self.receipt_builder,
-            plan,
             block_hash_seeder,
             bal_index_reader,
+            bal_index_bumper,
+            bal_index_setter,
         )
     }
 }
@@ -611,7 +579,7 @@ where
     TxEnv: FromRecoveredTx<TransactionSigned> + FromTxWithEncoded<TransactionSigned>,
 {
     type EvmFactory = EthEvmFactory;
-    type ExecutionCtx<'a> = EthBlockExecutionCtx<'a>;
+    type ExecutionCtx<'a> = BbEvmPlan<'a>;
     type Transaction = TransactionSigned;
     type Receipt = Receipt;
     type TxExecutionResult = EthTxResult<
@@ -628,13 +596,12 @@ where
     fn create_executor<'a, DB, I>(
         &'a self,
         evm: EthEvm<DB, I, PrecompilesMap>,
-        ctx: EthBlockExecutionCtx<'a>,
+        ctx: BbEvmPlan<'a>,
     ) -> Self::Executor<'a, DB, I>
     where
         DB: StateDB,
         I: Inspector<EthEvmContext<DB>>,
     {
-        let plan = self.peek_plan();
-        BbBlockExecutor::new(evm, ctx, &self.spec, self.receipt_builder, plan, None, None)
+        BbBlockExecutor::new(evm, ctx, &self.spec, self.receipt_builder, None, None, None, None)
     }
 }
diff --git a/bin/reth-bb/src/evm_config.rs b/bin/reth-bb/src/evm_config.rs
index c371f6afce6..5370376eaab 100644
--- a/bin/reth-bb/src/evm_config.rs
+++ b/bin/reth-bb/src/evm_config.rs
@@ -6,12 +6,13 @@
 //! cfg env) and applies pre/post execution changes for each segment.
 
 pub(crate) use reth_engine_primitives::BigBlockData;
+use reth_engine_primitives::ExecutionPayload as _;
+use reth_storage_errors::any::AnyError;
+use revm_primitives::Bytes;
 
-use crate::{
-    evm::{BalIndexReader, BbBlockExecutorFactory, BbEvmPlan},
-    BigBlockMap,
-};
+use crate::evm::{BalIndexReader, BbBlockExecutorFactory, BbEvmPlan};
 use alloy_consensus::Header;
+use alloy_eips::Decodable2718;
 use alloy_evm::{
     eth::{spec::EthExecutorSpec, EthBlockExecutionCtx},
     EthEvmFactory,
@@ -21,16 +22,15 @@ use alloy_rpc_types::engine::ExecutionData;
 use core::convert::Infallible;
 use reth_chainspec::{ChainSpec, EthChainSpec};
 use reth_ethereum_forks::Hardforks;
-use reth_ethereum_primitives::EthPrimitives;
+use reth_ethereum_primitives::{Block, EthPrimitives};
 use reth_evm::{
-    ConfigureEngineEvm, ConfigureEvm, Database, EvmEnv, EvmEnvFor, ExecutableTxIterator,
-    ExecutionCtxFor, NextBlockEnvAttributes,
+    execute::BlockAssembler, ConfigureEngineEvm, ConfigureEvm, Database, EvmEnv, EvmEnvFor,
+    ExecutableTxIterator, ExecutionCtxFor, NextBlockEnvAttributes,
 };
-use reth_evm_ethereum::{EthBlockAssembler, EthEvmConfig, RethReceiptBuilder};
-use reth_primitives_traits::{SealedBlock, SealedHeader};
-use revm::primitives::hardfork::SpecId;
+use reth_evm_ethereum::{EthEvmConfig, RethReceiptBuilder};
+use reth_primitives_traits::{SealedBlock, SealedHeader, SignedTransaction, TxTy};
+use revm::{primitives::hardfork::SpecId, state::bal::BlockAccessIndex};
 use std::sync::Arc;
-use tracing::debug;
 
 // ---------------------------------------------------------------------------
 // Execution plan types
@@ -38,13 +38,13 @@ use tracing::debug;
 
 /// A single execution segment within a big block.
 #[derive(Debug, Clone)]
-pub(crate) struct BigBlockSegment {
+pub(crate) struct BigBlockSegment<'a> {
     /// Transaction index at which this segment starts.
     pub start_tx: usize,
     /// The EVM environment for this segment.
     pub evm_env: EvmEnv,
     /// The execution context for this segment.
-    pub ctx: EthBlockExecutionCtx<'static>,
+    pub ctx: EthBlockExecutionCtx<'a>,
 }
 
 // ---------------------------------------------------------------------------
@@ -53,9 +53,9 @@ pub(crate) struct BigBlockSegment {
 
 /// EVM configuration for big-block execution.
 ///
-/// 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
+/// Wraps [`EthEvmConfig`]. When a big-block payload is received, the plan is
+/// staged on the [`BbBlockExecutorFactory`]
+/// 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`].
@@ -63,17 +63,15 @@ pub(crate) struct BigBlockSegment {
 pub struct BbEvmConfig<C = ChainSpec> {
     /// The inner Ethereum EVM configuration (used for env computation).
     pub inner: EthEvmConfig<C>,
-    /// Shared map of pending big-block metadata.
-    pub pending: BigBlockMap,
     /// Block executor factory for big-block execution.
     executor_factory: BbBlockExecutorFactory<Arc<C>>,
     /// Block assembler.
-    block_assembler: EthBlockAssembler<C>,
+    block_assembler: BbBlockAssembler,
 }
 
 impl<C> BbEvmConfig<C> {
     /// Creates a new big-block EVM configuration.
-    pub fn new(inner: EthEvmConfig<C>, pending: BigBlockMap) -> Self
+    pub fn new(inner: EthEvmConfig<C>) -> Self
     where
         C: Clone,
     {
@@ -83,9 +81,8 @@ impl<C> BbEvmConfig<C> {
             chain_spec,
             EthEvmFactory::default(),
         );
-        let block_assembler = inner.block_assembler.clone();
 
-        Self { inner, pending, executor_factory, block_assembler }
+        Self { inner, executor_factory, block_assembler: Default::default() }
     }
 }
 
@@ -106,8 +103,34 @@ 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()
+/// Reads the BAL index from a `&mut State<DB>`.
+///
+/// Used as a [`BalIndexReader`] callback so the
+/// generic [`BbBlockExecutor`](crate::evm::BbBlockExecutor) can pick its
+/// starting segment without a trait bound on `DB`.
+const fn read_bal_index<DB>(state: &&mut revm::database::State<DB>) -> u64 {
+    state.bal_state.bal_index().get()
+}
+
+/// Bumps the BAL index on a `&mut State<DB>`.
+///
+/// Used as a [`BalIndexBumper`](crate::evm::BalIndexBumper) callback so the
+/// generic [`BbBlockExecutor`](crate::evm::BbBlockExecutor) can advance
+/// `bal_index` between sub-events of a segment boundary (post-N's `finish()`
+/// and pre-N+1's `apply_pre_execution_changes()`) without a trait bound on
+/// `DB`.
+const fn bump_bal_index<DB: revm::Database>(state: &mut &mut revm::database::State<DB>) {
+    state.bump_bal_index();
+}
+
+/// Sets the BAL index on a `&mut State<DB>`.
+///
+/// Used as a [`BalIndexSetter`](crate::evm::BalIndexSetter) callback so
+/// [`BbBlockExecutor::initialize`](crate::evm::BbBlockExecutor) can renumber
+/// a worker's incoming `bal_index = i + 1` into the boundary-padded space
+/// `i + 1 + 2*k` (where `k` is the worker's segment index).
+const fn set_bal_index<DB: revm::Database>(state: &mut &mut revm::database::State<DB>, index: u64) {
+    state.set_bal_index(BlockAccessIndex::new(index));
 }
 
 // ---------------------------------------------------------------------------
@@ -122,7 +145,7 @@ where
     type Error = Infallible;
     type NextBlockEnvCtx = NextBlockEnvAttributes;
     type BlockExecutorFactory = BbBlockExecutorFactory<Arc<C>>;
-    type BlockAssembler = EthBlockAssembler<C>;
+    type BlockAssembler = BbBlockAssembler;
 
     fn block_executor_factory(&self) -> &Self::BlockExecutorFactory {
         &self.executor_factory
@@ -146,29 +169,23 @@ where
 
     fn context_for_block<'a>(
         &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)
+        _block: &'a SealedBlock<reth_ethereum_primitives::Block>,
+    ) -> Result<BbEvmPlan<'a>, Self::Error> {
+        unreachable!("big blocks EVM should only be used from within the engine pipeline")
     }
 
     fn context_for_next_block(
         &self,
-        parent: &SealedHeader,
-        attributes: Self::NextBlockEnvCtx,
-    ) -> Result<EthBlockExecutionCtx<'_>, Self::Error> {
-        self.inner.context_for_next_block(parent, attributes)
+        _parent: &SealedHeader,
+        _attributes: Self::NextBlockEnvCtx,
+    ) -> Result<BbEvmPlan<'_>, Self::Error> {
+        unreachable!("big blocks EVM should only be used from within the engine pipeline")
     }
 
     fn create_executor<'a, DB, I>(
         &'a self,
         evm: reth_evm::EvmFor<Self, &'a mut revm::database::State<DB>, I>,
-        ctx: EthBlockExecutionCtx<'a>,
+        ctx: BbEvmPlan<'a>,
     ) -> alloy_evm::block::BlockExecutorFor<
         'a,
         Self::BlockExecutorFactory,
@@ -183,12 +200,42 @@ where
             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`.
+        // the generic executor can manipulate `bal_index` and reseed block
+        // hashes without a trait bound on `DB`.
+        self.executor_factory.create_executor_with_seeder(
+            evm,
+            ctx,
+            Some(seed_state_block_hashes::<DB>),
+            bal_index_reader,
+            Some(bump_bal_index::<DB>),
+            Some(set_bal_index::<DB>),
+        )
+    }
+
+    fn create_executor_with_state<'ctx, 'db, DB, I>(
+        &'ctx self,
+        evm: reth_evm::EvmFor<Self, &'db mut revm::database::State<DB>, I>,
+        ctx: BbEvmPlan<'ctx>,
+    ) -> alloy_evm::block::BlockExecutorFor<
+        'ctx,
+        Self::BlockExecutorFactory,
+        &'db mut revm::database::State<DB>,
+        I,
+    >
+    where
+        DB: Database,
+        I: reth_evm::InspectorFor<Self, &'db mut revm::database::State<DB>>,
+    {
+        let bal_index_reader: Option<BalIndexReader<&'db mut revm::database::State<DB>>> =
+            Some(read_bal_index::<DB>);
+
         self.executor_factory.create_executor_with_seeder(
             evm,
             ctx,
             Some(seed_state_block_hashes::<DB>),
             bal_index_reader,
+            Some(bump_bal_index::<DB>),
+            Some(set_bal_index::<DB>),
         )
     }
 }
@@ -197,110 +244,93 @@ where
 // ConfigureEngineEvm — intercepts payload methods for big blocks
 // ---------------------------------------------------------------------------
 
-impl<C> ConfigureEngineEvm<ExecutionData> for BbEvmConfig<C>
+impl<C> ConfigureEngineEvm<BigBlockData<ExecutionData>> for BbEvmConfig<C>
 where
     C: EthExecutorSpec + EthChainSpec<Header = Header> + Hardforks + 'static,
 {
-    fn evm_env_for_payload(&self, payload: &ExecutionData) -> Result<EvmEnvFor<Self>, Self::Error> {
-        let payload_hash = payload.block_hash();
-        let has_plan = self.pending.lock().unwrap().contains_key(&payload_hash);
-
-        if has_plan {
-            // Compute the env from the first segment BEFORE removing the
-            // entry (stage_plan_for_payload removes it).
-            let first_exec_data = {
-                let pending = self.pending.lock().unwrap();
-                let bb_data = pending.get(&payload_hash).unwrap();
-                bb_data.env_switches[0].1.clone()
-            };
-            let mut env = self.inner.evm_env_for_payload(&first_exec_data)?;
-
-            // Disable basefee validation: transactions from different
-            // original blocks may have gas prices below the big block's
-            // effective basefee.
-            env.cfg_env.disable_base_fee = true;
-
-            // Now stage the plan on the factory (removes the entry).
-            self.stage_plan_for_payload(&payload_hash);
-
-            Ok(env)
-        } else {
-            self.executor_factory.clear_staged_plan();
-            self.inner.evm_env_for_payload(payload)
-        }
+    fn evm_env_for_payload(
+        &self,
+        payload: &BigBlockData<ExecutionData>,
+    ) -> Result<EvmEnvFor<Self>, Self::Error> {
+        // Compute the env from the first segment BEFORE removing the
+        // entry (stage_plan_for_payload removes it).
+        let first_exec_data = &payload.env_switches[0];
+        let mut env = self.inner.evm_env_for_payload(first_exec_data)?;
+
+        // Disable basefee validation: transactions from different
+        // original blocks may have gas prices below the big block's
+        // effective basefee.
+        env.cfg_env.disable_base_fee = true;
+        env.block_env.gas_limit = payload.gas_limit();
+
+        Ok(env)
     }
 
     fn context_for_payload<'a>(
         &self,
-        payload: &'a ExecutionData,
+        payload: &'a BigBlockData<ExecutionData>,
     ) -> Result<ExecutionCtxFor<'a, Self>, Self::Error> {
-        self.inner.context_for_payload(payload)
+        let mut current_tx = 0;
+        let segments: Vec<_> = payload
+            .env_switches
+            .iter()
+            .map(|exec_data| {
+                let start_tx = current_tx;
+                let mut evm_env = self.inner.evm_env_for_payload(exec_data)?;
+                evm_env.cfg_env.disable_base_fee = true;
+                let ctx = self.inner.context_for_payload(exec_data)?;
+                current_tx += exec_data.payload.transactions().len();
+                Ok(BigBlockSegment { start_tx, evm_env, ctx })
+            })
+            .collect::<Result<_, Self::Error>>()?;
+
+        let mut plan = BbEvmPlan::new(segments);
+
+        // Add prior block hashes to the seeding list.
+        plan.block_hashes_to_seed.extend(payload.prior_block_hashes.clone());
+        plan.block_hashes_to_seed.sort_unstable_by_key(|(n, _)| *n);
+
+        Ok(plan)
     }
 
     fn tx_iterator_for_payload(
         &self,
-        payload: &ExecutionData,
+        payload: &BigBlockData<ExecutionData>,
     ) -> Result<impl ExecutableTxIterator<Self>, Self::Error> {
-        self.inner.tx_iterator_for_payload(payload)
+        let transactions = payload
+            .env_switches
+            .iter()
+            .flat_map(|exec_data| exec_data.payload.transactions().clone())
+            .collect::<Vec<_>>();
+
+        let convert = |tx: Bytes| {
+            let tx =
+                TxTy::<Self::Primitives>::decode_2718_exact(tx.as_ref()).map_err(AnyError::new)?;
+            let signer = tx.try_recover().map_err(AnyError::new)?;
+            Ok::<_, AnyError>(tx.with_signer(signer))
+        };
+
+        Ok((transactions, convert))
     }
 }
 
-// ---------------------------------------------------------------------------
-// Plan construction and staging
-// ---------------------------------------------------------------------------
+#[derive(Debug, Default, Clone)]
+pub struct BbBlockAssembler;
 
-impl<C> BbEvmConfig<C>
-where
-    C: EthExecutorSpec + EthChainSpec<Header = Header> + Hardforks + 'static,
+impl<Spec: EthExecutorSpec + 'static> BlockAssembler<BbBlockExecutorFactory<Spec>>
+    for BbBlockAssembler
 {
-    /// Takes the big-block plan for a payload hash, builds a [`BbEvmPlan`],
-    /// and stages it on the factory.
-    ///
-    /// Must be called before `evm_with_env` is invoked for this payload.
-    /// 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)?;
+    type Block = Block;
 
-        let segments: Vec<_> = bb
-            .env_switches
-            .into_iter()
-            .map(|(start_tx, exec_data)| {
-                let evm_env = self.inner.evm_env_for_payload(&exec_data).unwrap();
-                let ctx = self.inner.context_for_payload(&exec_data).unwrap();
-                let ctx = EthBlockExecutionCtx {
-                    tx_count_hint: ctx.tx_count_hint,
-                    parent_hash: ctx.parent_hash,
-                    parent_beacon_block_root: ctx.parent_beacon_block_root,
-                    ommers: &[],
-                    withdrawals: ctx.withdrawals.map(|w| std::borrow::Cow::Owned(w.into_owned())),
-                    extra_data: ctx.extra_data,
-                    slot_number: ctx.slot_number,
-                };
-                BigBlockSegment { start_tx, evm_env, ctx }
-            })
-            .collect();
-
-        debug!(
-            target: "engine::bb",
-            ?payload_hash,
-            segments = segments.len(),
-            seed_hashes = bb.prior_block_hashes.len(),
-            "Staging multi-segment plan"
-        );
-
-        let mut plan = BbEvmPlan::new(segments);
-
-        // Add prior block hashes to the seeding list.
-        plan.block_hashes_to_seed.extend(bb.prior_block_hashes);
-
-        plan.block_hashes_to_seed.sort_unstable_by_key(|(n, _)| *n);
-
-        Some(plan)
+    fn assemble_block(
+        &self,
+        _input: reth_evm::execute::BlockAssemblerInput<
+            '_,
+            '_,
+            BbBlockExecutorFactory<Spec>,
+            <Self::Block as reth_node_api::Block>::Header,
+        >,
+    ) -> Result<Self::Block, reth_errors::BlockExecutionError> {
+        unreachable!("block building is not supported for big blocks EVM")
     }
 }
diff --git a/bin/reth-bb/src/main.rs b/bin/reth-bb/src/main.rs
index 9bf967e67bd..3e02da66d0a 100644
--- a/bin/reth-bb/src/main.rs
+++ b/bin/reth-bb/src/main.rs
@@ -7,243 +7,111 @@ static ALLOC: reth_cli_util::allocator::Allocator = reth_cli_util::allocator::ne
 mod evm;
 mod evm_config;
 
-use alloy_primitives::B256;
-
-use alloy_rpc_types::engine::{ExecutionData, ForkchoiceState, ForkchoiceUpdated};
-use async_trait::async_trait;
+use alloy_rpc_types::engine::ExecutionData;
 use clap::Parser;
 use evm_config::{BbEvmConfig, BigBlockData};
-use jsonrpsee::core::RpcResult;
-use reth_chainspec::{ChainSpec, EthereumHardforks, Hardforks};
+use reth_chainspec::{ChainSpec, EthereumHardforks};
 use reth_consensus::noop::NoopConsensus;
-use reth_engine_primitives::ConsensusEngineHandle;
 use reth_ethereum_cli::{chainspec::EthereumChainSpecParser, interface::Cli};
-use reth_ethereum_primitives::EthPrimitives;
+use reth_ethereum_primitives::{Block, EthPrimitives};
 use reth_evm_ethereum::EthEvmConfig;
-use reth_node_api::{AddOnsContext, FullNodeComponents, NodeTypes, PayloadTypes};
+use reth_node_api::{
+    AddOnsContext, FullNodeComponents, NewPayloadError, NodeTypes, PayloadTypes, PayloadValidator,
+};
 use reth_node_builder::{
     components::{
         BasicPayloadServiceBuilder, ComponentsBuilder, ConsensusBuilder, ExecutorBuilder,
     },
     node::FullNodeTypes,
-    rpc::{
-        BasicEngineApiBuilder, BasicEngineValidatorBuilder, EngineApiBuilder, EngineValidatorAddOn,
-        EngineValidatorBuilder, PayloadValidatorBuilder, RethRpcAddOns, RpcAddOns, RpcHandle,
-        RpcHooks,
-    },
-    BuilderContext, Node,
+    rpc::{NoopEngineApiBuilder, PayloadValidatorBuilder, RpcAddOns},
+    BuilderContext, Node, NodeAdapter,
 };
+use reth_node_core::args::DefaultEngineValues;
 use reth_node_ethereum::{
-    EthEngineTypes, EthereumEngineValidatorBuilder, EthereumEthApiBuilder, EthereumNetworkBuilder,
+    EthPayloadTypes, EthereumEngineValidator, EthereumEthApiBuilder, EthereumNetworkBuilder,
     EthereumNode, EthereumPayloadBuilder, EthereumPoolBuilder,
 };
-use reth_payload_primitives::ExecutionPayload;
 use reth_primitives_traits::SealedBlock;
 use reth_provider::EthStorage;
-use reth_rpc_api::{RethNewPayloadInput, RethPayloadStatus};
-use reth_rpc_engine_api::EngineApiError;
-use std::{
-    collections::HashMap,
-    sync::{Arc, Mutex},
-};
-use tracing::{info, trace};
-
-/// Shared map for big block data, keyed by payload hash.
-pub type BigBlockMap = Arc<Mutex<HashMap<B256, BigBlockData<ExecutionData>>>>;
-
-// ---------------------------------------------------------------------------
-// Custom RPC trait for big-block payloads
-// ---------------------------------------------------------------------------
-
-/// Big-block extension of the `reth_` engine API.
-#[jsonrpsee::proc_macros::rpc(server, namespace = "reth")]
-pub trait BbRethEngineApi {
-    /// `reth_newPayload` with optional big-block data.
-    #[method(name = "newPayload")]
-    async fn reth_new_payload(
-        &self,
-        payload: RethNewPayloadInput<ExecutionData>,
-        wait_for_persistence: Option<bool>,
-        wait_for_caches: Option<bool>,
-        big_block_data: Option<BigBlockData<ExecutionData>>,
-    ) -> RpcResult<RethPayloadStatus>;
-
-    /// `reth_forkchoiceUpdated` – pass-through.
-    #[method(name = "forkchoiceUpdated")]
-    async fn reth_forkchoice_updated(
-        &self,
-        forkchoice_state: ForkchoiceState,
-    ) -> RpcResult<ForkchoiceUpdated>;
-}
-
-/// Server-side implementation of `BbRethEngineApi`.
-#[derive(Debug)]
-struct BbRethEngineApiHandler {
-    pending: BigBlockMap,
-    engine: ConsensusEngineHandle<EthEngineTypes>,
+use revm_primitives::Bytes;
+use tracing::info;
+
+#[derive(Debug, Clone, Default)]
+pub struct BbPayloadTypes;
+
+impl PayloadTypes for BbPayloadTypes {
+    type ExecutionData = BigBlockData<ExecutionData>;
+    type BuiltPayload = <EthPayloadTypes as PayloadTypes>::BuiltPayload;
+    type PayloadAttributes = <EthPayloadTypes as PayloadTypes>::PayloadAttributes;
+
+    fn block_to_payload(
+        _block: SealedBlock<
+                <<Self::BuiltPayload as reth_node_api::BuiltPayload>::Primitives as reth_node_api::NodePrimitives>::Block,
+            >,
+        _bal: Option<Bytes>,
+    ) -> Self::ExecutionData {
+        unreachable!()
+    }
 }
 
-#[async_trait]
-impl BbRethEngineApiServer for BbRethEngineApiHandler {
-    async fn reth_new_payload(
-        &self,
-        input: RethNewPayloadInput<ExecutionData>,
-        wait_for_persistence: Option<bool>,
-        wait_for_caches: Option<bool>,
-        big_block_data: Option<BigBlockData<ExecutionData>>,
-    ) -> RpcResult<RethPayloadStatus> {
-        let wait_for_persistence = wait_for_persistence.unwrap_or(true);
-        let wait_for_caches = wait_for_caches.unwrap_or(true);
-        trace!(
-            target: "rpc::engine",
-            wait_for_persistence,
-            wait_for_caches,
-            has_big_block_data = big_block_data.is_some(),
-            "Serving bb reth_newPayload"
-        );
-
-        let payload = match input {
-            RethNewPayloadInput::ExecutionData(data) => data,
-            RethNewPayloadInput::BlockRlp(rlp) => {
-                let block = alloy_rlp::Decodable::decode(&mut rlp.as_ref())
-                    .map_err(|err| EngineApiError::Internal(Box::new(err)))?;
-                <EthEngineTypes as PayloadTypes>::block_to_payload(SealedBlock::new_unhashed(block))
-            }
-        };
-
-        if let Some(data) = big_block_data {
-            let hash = ExecutionPayload::block_hash(&payload);
-            self.pending.lock().unwrap().insert(hash, data);
-        }
+#[derive(Debug, Default, Clone)]
+pub struct BbEngineValidatorBuilder;
 
-        let (status, timings) = self
-            .engine
-            .reth_new_payload(payload, wait_for_persistence, wait_for_caches)
-            .await
-            .map_err(EngineApiError::from)?;
-
-        Ok(RethPayloadStatus {
-            status,
-            latency_us: timings.latency.as_micros() as u64,
-            persistence_wait_us: timings.persistence_wait.as_micros() as u64,
-            execution_cache_wait_us: timings.execution_cache_wait.map(|d| d.as_micros() as u64),
-            sparse_trie_wait_us: timings.sparse_trie_wait.map(|d| d.as_micros() as u64),
-        })
-    }
+impl<Node> PayloadValidatorBuilder<Node> for BbEngineValidatorBuilder
+where
+    Node: FullNodeComponents<Types = BbNode>,
+{
+    type Validator = BbEngineValidator;
 
-    async fn reth_forkchoice_updated(
-        &self,
-        forkchoice_state: ForkchoiceState,
-    ) -> RpcResult<ForkchoiceUpdated> {
-        trace!(target: "rpc::engine", "Serving reth_forkchoiceUpdated");
-        self.engine
-            .fork_choice_updated(forkchoice_state, None)
-            .await
-            .map_err(|e| EngineApiError::from(e).into())
+    async fn build(self, ctx: &AddOnsContext<'_, Node>) -> eyre::Result<Self::Validator> {
+        Ok(BbEngineValidator { inner: EthereumEngineValidator::new(ctx.config.chain.clone()) })
     }
 }
 
-// ---------------------------------------------------------------------------
-// Node add-ons wrapper
-// ---------------------------------------------------------------------------
-
-/// Add-ons for the big-block node.
-#[derive(Debug)]
-pub struct BbAddOns {
-    pending: BigBlockMap,
+#[derive(Debug, Clone)]
+pub struct BbEngineValidator {
+    inner: EthereumEngineValidator,
 }
 
-impl BbAddOns {
-    const fn new(pending: BigBlockMap) -> Self {
-        Self { pending }
-    }
+impl PayloadValidator<BbPayloadTypes> for BbEngineValidator {
+    type Block = Block;
 
-    fn make_rpc_add_ons<N: FullNodeComponents>(
+    fn convert_payload_to_block(
         &self,
-    ) -> RpcAddOns<
-        N,
-        EthereumEthApiBuilder,
-        EthereumEngineValidatorBuilder,
-        BasicEngineApiBuilder<EthereumEngineValidatorBuilder>,
-        BasicEngineValidatorBuilder<EthereumEngineValidatorBuilder>,
-    >
-    where
-        EthereumEthApiBuilder: reth_node_builder::rpc::EthApiBuilder<N>,
-    {
-        RpcAddOns::new(
-            EthereumEthApiBuilder::default(),
-            EthereumEngineValidatorBuilder::default(),
-            BasicEngineApiBuilder::default(),
-            BasicEngineValidatorBuilder::default(),
-            Default::default(),
-            Default::default(),
-        )
-    }
-}
-
-impl<N> reth_node_api::NodeAddOns<N> for BbAddOns
-where
-    N: FullNodeComponents<
-        Types: NodeTypes<
-            ChainSpec: EthereumHardforks + Hardforks + Clone + 'static,
-            Payload = EthEngineTypes,
-            Primitives = EthPrimitives,
-        >,
-    >,
-    EthereumEthApiBuilder: reth_node_builder::rpc::EthApiBuilder<N>,
-    EthereumEngineValidatorBuilder: PayloadValidatorBuilder<N>,
-    BasicEngineApiBuilder<EthereumEngineValidatorBuilder>: EngineApiBuilder<N>,
-    BasicEngineValidatorBuilder<EthereumEngineValidatorBuilder>: EngineValidatorBuilder<N>,
-{
-    type Handle =
-        RpcHandle<N, <EthereumEthApiBuilder as reth_node_builder::rpc::EthApiBuilder<N>>::EthApi>;
-
-    async fn launch_add_ons(self, ctx: AddOnsContext<'_, N>) -> eyre::Result<Self::Handle> {
-        let engine_handle = ctx.beacon_engine_handle.clone();
-        let pending = self.pending.clone();
-        let rpc_add_ons = self.make_rpc_add_ons::<N>();
-
-        rpc_add_ons
-            .launch_add_ons_with(ctx, move |container| {
-                let handler = BbRethEngineApiHandler { pending, engine: engine_handle };
-                let bb_module = BbRethEngineApiServer::into_rpc(handler);
-                container.auth_module.replace_auth_methods(bb_module.remove_context())?;
-                Ok(())
+        payload: BigBlockData<ExecutionData>,
+    ) -> Result<SealedBlock<Block>, NewPayloadError> {
+        let mut blocks = payload
+            .env_switches
+            .into_iter()
+            .map(|data| {
+                PayloadValidator::<EthPayloadTypes>::convert_payload_to_block(&self.inner, data)
             })
-            .await
-    }
-}
+            .collect::<Result<Vec<SealedBlock<Block>>, NewPayloadError>>()?;
 
-impl<N> RethRpcAddOns<N> for BbAddOns
-where
-    N: FullNodeComponents<
-        Types: NodeTypes<
-            ChainSpec: EthereumHardforks + Hardforks + Clone + 'static,
-            Payload = EthEngineTypes,
-            Primitives = EthPrimitives,
-        >,
-    >,
-    EthereumEthApiBuilder: reth_node_builder::rpc::EthApiBuilder<N>,
-    EthereumEngineValidatorBuilder: PayloadValidatorBuilder<N>,
-    BasicEngineApiBuilder<EthereumEngineValidatorBuilder>: EngineApiBuilder<N>,
-    BasicEngineValidatorBuilder<EthereumEngineValidatorBuilder>: EngineValidatorBuilder<N>,
-{
-    type EthApi = <EthereumEthApiBuilder as reth_node_builder::rpc::EthApiBuilder<N>>::EthApi;
+        let (mut block, hash) = blocks.pop().unwrap().split();
 
-    fn hooks_mut(&mut self) -> &mut RpcHooks<N, Self::EthApi> {
-        unimplemented!("BbAddOns does not support dynamic hook mutation")
-    }
-}
+        // Override the block number
+        block.header.number = payload.block_number;
 
-impl<N> EngineValidatorAddOn<N> for BbAddOns
-where
-    N: FullNodeComponents,
-    BasicEngineValidatorBuilder<EthereumEngineValidatorBuilder>: EngineValidatorBuilder<N>,
-{
-    type ValidatorBuilder = BasicEngineValidatorBuilder<EthereumEngineValidatorBuilder>;
+        // Set block's parent hash to the parent of the first block in this batch so that engine
+        // tree state is consistent.
+        if let Some(first) = blocks.first() {
+            block.header.parent_hash = first.parent_hash;
+        }
 
-    fn engine_validator_builder(&self) -> Self::ValidatorBuilder {
-        BasicEngineValidatorBuilder::default()
+        // Update block's gas usage to make sure metrics are correct
+        block.header.gas_used += blocks.iter().map(|b| b.gas_used).sum::<u64>();
+
+        // Prepend transactions from previous blocks to make sure that persistence indices are
+        // correct.
+        block.body.transactions = blocks
+            .into_iter()
+            .flat_map(|b| b.into_body().transactions)
+            .chain(core::mem::take(&mut block.body.transactions))
+            .collect();
+
+        // Use `new_unchecked` to preserve the hash
+        Ok(SealedBlock::new_unchecked(block, hash))
     }
 }
 
@@ -252,10 +120,9 @@ where
 // ---------------------------------------------------------------------------
 
 /// Executor builder that creates a [`BbEvmConfig`].
-#[derive(Debug)]
-pub struct BbExecutorBuilder {
-    pending: BigBlockMap,
-}
+#[derive(Debug, Default)]
+#[non_exhaustive]
+pub struct BbExecutorBuilder;
 
 impl<Node> ExecutorBuilder<Node> for BbExecutorBuilder
 where
@@ -271,7 +138,7 @@ where
     type EVM = BbEvmConfig<<Node::Types as NodeTypes>::ChainSpec>;
 
     async fn build_evm(self, ctx: &BuilderContext<Node>) -> eyre::Result<Self::EVM> {
-        Ok(BbEvmConfig::new(EthEvmConfig::new(ctx.chain_spec()), self.pending))
+        Ok(BbEvmConfig::new(EthEvmConfig::new(ctx.chain_spec())))
     }
 }
 
@@ -280,22 +147,15 @@ where
 // ---------------------------------------------------------------------------
 
 /// Node type for big block execution.
-#[derive(Debug, Clone)]
-pub struct BbNode {
-    pending: BigBlockMap,
-}
-
-impl BbNode {
-    const fn new(pending: BigBlockMap) -> Self {
-        Self { pending }
-    }
-}
+#[derive(Debug, Clone, Default)]
+#[non_exhaustive]
+pub struct BbNode;
 
 impl NodeTypes for BbNode {
     type Primitives = EthPrimitives;
     type ChainSpec = ChainSpec;
     type Storage = EthStorage;
-    type Payload = EthEngineTypes;
+    type Payload = BbPayloadTypes;
 }
 
 impl<N> Node<N> for BbNode
@@ -311,16 +171,21 @@ where
         BbConsensusBuilder,
     >;
 
-    type AddOns = BbAddOns;
+    type AddOns = RpcAddOns<
+        NodeAdapter<N>,
+        EthereumEthApiBuilder,
+        BbEngineValidatorBuilder,
+        NoopEngineApiBuilder,
+    >;
 
     fn components_builder(&self) -> Self::ComponentsBuilder {
         EthereumNode::components()
-            .executor(BbExecutorBuilder { pending: self.pending.clone() })
+            .executor(BbExecutorBuilder::default())
             .consensus(BbConsensusBuilder)
     }
 
     fn add_ons(&self) -> Self::AddOns {
-        BbAddOns::new(self.pending.clone())
+        Default::default()
     }
 }
 
@@ -354,11 +219,11 @@ fn main() {
         unsafe { std::env::set_var("RUST_BACKTRACE", "1") };
     }
 
-    let pending: BigBlockMap = Arc::new(Mutex::new(HashMap::new()));
+    let _ = DefaultEngineValues::default().with_bal_parallel_execution_disabled(false).try_init();
 
     if let Err(err) = Cli::<EthereumChainSpecParser>::parse().run(async move |builder, _| {
         info!(target: "reth::cli", "Launching big block node");
-        let handle = builder.launch_node(BbNode::new(pending.clone())).await?;
+        let handle = builder.launch_node(BbNode::default()).await?;
 
         handle.wait_for_node_exit().await
     }) {
diff --git a/bin/reth-bench/Cargo.toml b/bin/reth-bench/Cargo.toml
deleted file mode 100644
index f74e34f7d8b..00000000000
--- a/bin/reth-bench/Cargo.toml
+++ /dev/null
@@ -1,142 +0,0 @@
-[package]
-name = "reth-bench"
-version.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-homepage.workspace = true
-repository.workspace = true
-description = "Benchmarking for ethereum nodes"
-default-run = "reth-bench"
-
-[lints]
-workspace = true
-
-[dependencies]
-# reth
-reth-chainspec.workspace = true
-reth-cli.workspace = true
-reth-cli-runner.workspace = true
-reth-cli-util.workspace = true
-reth-engine-primitives.workspace = true
-reth-ethereum-cli.workspace = true
-reth-ethereum-primitives.workspace = true
-reth-fs-util.workspace = true
-reth-node-api.workspace = true
-reth-node-core.workspace = true
-reth-primitives-traits.workspace = true
-reth-rpc-api.workspace = true
-
-reth-tracing.workspace = true
-
-# alloy
-alloy-consensus.workspace = true
-alloy-eip7928 = { workspace = true, features = ["rlp"] }
-alloy-eips.workspace = true
-alloy-json-rpc.workspace = true
-alloy-rlp.workspace = true
-
-alloy-primitives = { workspace = true, features = ["rand"] }
-alloy-provider = { workspace = true, features = ["engine-api", "pubsub", "reqwest-rustls-tls"], default-features = false }
-alloy-pubsub.workspace = true
-alloy-rpc-client = { workspace = true, features = ["pubsub"] }
-alloy-rpc-types-engine = { workspace = true, features = ["kzg"] }
-alloy-transport-http.workspace = true
-alloy-transport-ipc.workspace = true
-alloy-transport-ws.workspace = true
-alloy-transport.workspace = true
-
-# reqwest
-reqwest.workspace = true
-
-# tower
-tower.workspace = true
-
-# tracing
-tracing.workspace = true
-
-# serde
-serde.workspace = true
-serde_json.workspace = true
-
-# url parsing
-url.workspace = true
-
-# async
-async-trait.workspace = true
-futures.workspace = true
-tokio = { workspace = true, features = ["sync", "macros", "time", "rt-multi-thread"] }
-
-# misc
-clap = { workspace = true, features = ["derive", "env"] }
-eyre.workspace = true
-color-eyre.workspace = true
-thiserror.workspace = true
-humantime.workspace = true
-
-# for writing data
-csv.workspace = true
-
-[dev-dependencies]
-
-[features]
-default = ["jemalloc"]
-
-asm-keccak = [
-    "reth-node-core/asm-keccak",
-    "reth-ethereum-cli/asm-keccak",
-    "alloy-primitives/asm-keccak",
-]
-
-jemalloc = [
-    "reth-cli-util/jemalloc",
-    "reth-node-core/jemalloc",
-    "reth-ethereum-cli/jemalloc",
-]
-jemalloc-prof = [
-    "reth-cli-util/jemalloc-prof",
-    "reth-ethereum-cli/jemalloc-prof",
-]
-tracy-allocator = [
-    "reth-cli-util/tracy-allocator",
-    "tracy",
-    "reth-ethereum-cli/tracy-allocator",
-]
-tracy = [
-    "reth-node-core/tracy",
-    "reth-tracing/tracy",
-    "reth-ethereum-cli/tracy",
-]
-
-min-error-logs = [
-    "tracing/release_max_level_error",
-    "reth-node-core/min-error-logs",
-    "reth-ethereum-cli/min-error-logs",
-]
-min-warn-logs = [
-    "tracing/release_max_level_warn",
-    "reth-node-core/min-warn-logs",
-    "reth-ethereum-cli/min-warn-logs",
-]
-min-info-logs = [
-    "tracing/release_max_level_info",
-    "reth-node-core/min-info-logs",
-    "reth-ethereum-cli/min-info-logs",
-]
-min-debug-logs = [
-    "tracing/release_max_level_debug",
-    "reth-node-core/min-debug-logs",
-    "reth-ethereum-cli/min-debug-logs",
-]
-min-trace-logs = [
-    "tracing/release_max_level_trace",
-    "reth-node-core/min-trace-logs",
-    "reth-ethereum-cli/min-trace-logs",
-]
-
-# no-op feature flag for CI matrices
-ethereum = []
-
-[[bin]]
-name = "reth-bench"
-path = "src/main.rs"
diff --git a/bin/reth-bench/README.md b/bin/reth-bench/README.md
deleted file mode 100644
index aa63c6ec336..00000000000
--- a/bin/reth-bench/README.md
+++ /dev/null
@@ -1,159 +0,0 @@
-# Benchmarking reth live sync with `reth-bench`
-
-The binary contained in this directory, `reth-bench`, is a tool that can be used to benchmark the performance of the reth live sync. `reth-bench` is a general tool, and can be used for benchmarking node performance, as long as the node supports the engine API.
-
-### A recap on node synchronization
-Reth uses two primary methods for synchronizing the chain:
- * Historical sync, which is used to synchronize the chain from genesis to a known finalized block. This involves re-executing the entire chain history.
- * Live sync, which is used to synchronize the chain from a finalized block to the current head. This involves processing new blocks as they are produced.
-
-Benchmarking historical sync for reth is fairly easy, because historical sync is a long-running, deterministic process.
-Reth specifically contains the `--debug.tip` argument, which allows for running the historical sync pipeline to a specific block.
-However, reth's historical sync applies optimizations that are not always possible when syncing new blocks.
-
-
-Live sync, on the other hand, is a more complex process that is harder to benchmark. It is also more sensitive to network conditions of the CL.
-In order to benchmark live sync, we need to simulate a CL in a controlled manner, so reth can use the same code paths it would when syncing new blocks.
-
-### The `reth-bench` tool
-The `reth-bench` tool is designed to benchmark performance of reth live sync.
-It can also be used for debugging client spec implementations, as it replays historical blocks by mocking a CL client.
-Performance is measured by latency and gas used in a block, as well as the computed gas used per second.
-As long as the data is representative of real-world load, or closer to worst-case load test, the gas per second gives a rough sense of how much throughput the node would be able to handle.
-
-## Prerequisites
-
-If you will be collecting CPU profiles, make sure `reth` is compiled with the `profiling` profile.
-Otherwise, running `make maxperf` at the root of the repo should be sufficient for collecting accurate performance metrics.
-
-## Command Usage
-
-`reth-bench` contains different commands to benchmark different patterns of engine API calls.
-The `reth-bench new-payload-fcu` command is the most representative of ethereum mainnet live sync, alternating between sending `engine_newPayload` calls and `engine_forkchoiceUpdated` calls.
-
-The `new-payload-fcu` command supports two optional waiting modes that can be used together or independently:
-- `--wait-time <duration>`: Fixed sleep interval between blocks (e.g., `--wait-time 100ms` or `--wait-time 400` for 400ms)
-- `--wait-for-persistence`: Waits for blocks to be persisted using the `reth_subscribePersistedBlock` subscription
-
-Both `new-payload-fcu` and `new-payload-only` support `--rpc-block-fetch-retries <RETRIES>`
-to control how many times block fetches are retried after an RPC failure. The default is `10`.
-Use `--rpc-block-fetch-retries forever` to keep retrying indefinitely.
-
-When using `--wait-for-persistence`, the benchmark waits after every `(threshold + 1)` blocks, where the threshold defaults to the engine's persistence threshold (2). This can be customized with `--persistence-threshold <N>`.
-
-By default, the WebSocket URL for persistence subscriptions is derived from `--engine-rpc-url` (converting to ws:// on port 8546). Use `--ws-rpc-url` to override this.
-
-Below is an overview of how to run a benchmark:
-
-### Setup
-
-Make sure `reth` is running in the background with the proper configuration. This setup involves ensuring the node is at the correct state, setting up profiling tools, and possibly more depending on the purpose of the benchmark.
-
-Any consensus layer client configured to connect to `reth` should be shut down, as all the engine API interactions during benchmarking will be driven by `reth-bench`.
-
-Depending on the block range you want to use in the benchmark you may need to unwind your node.
-The head of the node should be behind the lowest block in the range.
-
-Starting with a synced ethereum mainnet node, to run a benchmark starting at block 21,000,000, the node would need to be unwound first:
-```bash
-reth stage unwind to-block 21000000
-```
-
-The following `reth-bench` command would then start the benchmark at block 21,000,000:
-```bash
-reth-bench new-payload-fcu --rpc-url <rpc-url> --from 21000000 --to <end_block> --jwt-secret <jwt_file_path>
-```
-
-Finally, make sure that reth is built using a build profile suitable for what you are trying to measure.
-For example, if the purpose of the benchmark is to load test and measure `reth`'s maximum speed, it would be compiled with the `maxperf` profile:
-```bash
-make maxperf
-```
-
-If the purpose of the benchmark is for analyzing flamegraphs for a specific routine using `perf` or `samply`, it should be compiled with the `profiling` profile:
-```bash
-make profiling
-```
-
-If the purpose of the benchmark is to obtain `jemalloc` memory profiles that can then be analyzed by `jeprof`, it should be compiled with the `profiling` profile and the `jemalloc-prof` feature:
-```bash
-RUSTFLAGS="-C target-cpu=native" cargo build --profile profiling --features "jemalloc-prof"
-```
-
-> [!NOTE]
-> Jemalloc memory profiling currently only works on linux.
-
-Finally, if the purpose of the benchmark is to profile the node when `snmalloc` is configured as the default allocator, it would be built with the following
-command:
-```bash
-RUSTFLAGS="-C target-cpu=native" cargo build --profile profiling --no-default-features --features "snmalloc-native,asm-keccak,min-debug-logs"
-```
-
-### Run the Benchmark:
-First, start the reth node. Here is an example that runs `reth` compiled with the `profiling` profile, runs `samply`, and configures `reth` to run with metrics enabled:
-```bash
-samply record -p 3001 target/profiling/reth node --metrics localhost:9001 --authrpc.jwtsecret <jwt_file_path>
-```
-
-```bash
-reth-bench new-payload-fcu --rpc-url <rpc-url> --from <start_block> --to <end_block> --jwt-secret <jwt_file_path>
-```
-
-Replace `<start_block>`, `<end_block>`, and `<jwt_file_path>` with the appropriate values for your testing environment. `<rpc-url>` should be the URL of an RPC endpoint that can provide the blocks that will be used during the execution.
-This should NOT be the node that is being used for the benchmark. The node behind `--rpc-url` will be used as a data source for fetching real blocks, so they can be replayed in
-the benchmark. The node being benchmarked will not have these blocks.
-Note that this assumes that the benchmark node's engine API is running on `http://127.0.0.1:8551`, which is set as a default value in `reth-bench`. To configure this value, use the `--engine-rpc-url` flag.
-
-#### Using the `--advance` argument
-
-The `--advance` argument allows you to benchmark a relative number of blocks from the current head, without manually specifying `--from` and `--to`.
-
-```bash
-# Benchmark the next 10 blocks from the current head
-reth-bench new-payload-fcu --advance 10 --jwt-secret <jwt_file_path> --rpc-url <rpc-url>
-
-# Benchmark the next 50 blocks with a different subcommand
-reth-bench new-payload-only --advance 50 --jwt-secret <jwt_file_path> --rpc-url <rpc-url>
-```
-
-### Observe Outputs
-
-After running the command, `reth-bench` will output benchmark results, showing processing speeds and gas usage, which are useful metrics for analyzing the node's performance.
-Note that the `GGas/s` metric does _not_ include just execution, it currently measures the total `newPayload` latency, over the total gas used in the block.
-
-Example output:
-```
-2024-05-30T00:45:20.806691Z  INFO Running benchmark using data from RPC URL: http://<rpc-url>:8545
-// ... logs per block
-2024-05-30T00:45:34.203172Z  INFO Total Ggas/s: 0.15 total_duration=5.085704882s total_gas_used=741620668.0
-```
-
-### Stop and Review
-
-Once the benchmark completes, terminate the `reth` process and review the logs and performance metrics collected, if any.
-
-If using `samply`, the `reth` node should be stopped (using Ctrl+C or `kill`). The `samply` tool will output the following on the command line:
-```bash
-All tasks terminated.
-Local server listening at http://127.0.0.1:3001
-Press Ctrl+C to stop.
-```
-As long as the `reth` node was compiled using the `profiling` profile, or with any other profile that includes debug symbols, the URL can be used to analyze flamegraphs, stack
-charts, and other formats useful for analyzing the sampled stack data. There should also be an "Upload local profile" button on the `samply` web interface that can be used to
-upload the profile and receive a permalink that can be shared.
-This can be extremely useful for providing data and context to team members to justify an optimization, or to share with others to help diagnose a performance issue.
-
-If `prometheus` is set up and scraping a `reth` node that has `--metrics` enabled, other metrics can be analyzed, like execution latency, state root latency, memory and CPU
-usage over time, and many other metrics that are useful for diagnosing performance issues.
-
-### Repeat
-
-To reproduce the benchmark, first re-set the node to the block that the benchmark started at, using `reth stage unwind` as mentioned above, and repeat all of the above steps.
-
-## Additional Considerations
-
-- **RPC Configuration**: The RPC endpoints should be accessible and configured correctly, specifically the RPC endpoint must support `eth_getBlockByNumber` and support fetching full transactions. The benchmark will make one RPC query per block as fast as possible, so ensure the RPC endpoint does not rate limit or block requests after a certain volume.
-- **Reproducibility**: Ensure that the node is at the same state before attempting to retry a benchmark. The `new-payload-fcu` command specifically will commit to the database, so the node must be rolled back using `reth stage unwind` to reproducibly retry benchmarks.
-- **Profiling tools**: If you are collecting CPU profiles, tools like [`samply`](https://github.com/mstange/samply) and [`perf`](https://perf.wiki.kernel.org/index.php/Main_Page) can be useful for analyzing node performance.
-- **Benchmark Data**: `reth-bench` additionally contains a `--output` flag, which will output gas used benchmarks across the benchmark range in CSV format. This may be useful for further data analysis.
-- **Platform Information**: To ensure accurate and reproducible benchmarking, document the platform details, including hardware specifications, OS version, and any other relevant information before publishing any benchmarks.
diff --git a/bin/reth-bench/scripts/compare_newpayload_latency.py b/bin/reth-bench/scripts/compare_newpayload_latency.py
deleted file mode 100755
index f434d034b9a..00000000000
--- a/bin/reth-bench/scripts/compare_newpayload_latency.py
+++ /dev/null
@@ -1,384 +0,0 @@
-#!/usr/bin/env -S uv run
-# /// script
-# requires-python = ">=3.8"
-# dependencies = [
-#     "pandas",
-#     "matplotlib",
-#     "numpy",
-# ]
-# ///
-
-# A simple script which plots graphs comparing two combined_latency.csv files
-# output by reth-bench. The graphs which are plotted are:
-#
-# - A histogram of the percent change between latencies, bucketed by 1%
-#   increments.
-#
-# - A simple line graph plotting the latencies of the two files against each
-#   other.
-#
-# - A gas per second (gas/s) chart showing throughput over time.
-
-
-import argparse
-import pandas as pd
-import matplotlib.pyplot as plt
-import numpy as np
-import sys
-import os
-from matplotlib.ticker import FuncFormatter
-
-def get_output_filename(base_path, suffix=None):
-    """Generate output filename with optional suffix."""
-    if suffix is None:
-        return base_path
-    
-    # Split the base path into directory, name, and extension
-    dir_name = os.path.dirname(base_path)
-    base_name = os.path.basename(base_path)
-    name, ext = os.path.splitext(base_name)
-    
-    # Create new filename with suffix
-    new_name = f"{name}_{suffix}{ext}"
-    return os.path.join(dir_name, new_name) if dir_name else new_name
-
-def format_gas_units(value, pos):
-    """Format gas values with appropriate units (gas, Kgas, Mgas, Ggas, Tgas)."""
-    if value == 0:
-        return '0'
-    
-    # Define unit thresholds and labels
-    units = [
-        (1e12, 'Tgas'),  # Teragas
-        (1e9, 'Ggas'),   # Gigagas
-        (1e6, 'Mgas'),   # Megagas
-        (1e3, 'Kgas'),   # Kilogas
-        (1, 'gas')       # gas
-    ]
-    
-    abs_value = abs(value)
-    for threshold, unit in units:
-        if abs_value >= threshold:
-            scaled_value = value / threshold
-            # Format with appropriate precision
-            if scaled_value >= 100:
-                return f'{scaled_value:.0f}{unit}/s'
-            elif scaled_value >= 10:
-                return f'{scaled_value:.1f}{unit}/s'
-            else:
-                return f'{scaled_value:.2f}{unit}/s'
-    
-    return f'{value:.0f}gas/s'
-
-def moving_average(data, window_size):
-    """Calculate moving average with given window size."""
-    if window_size <= 1:
-        return data
-    
-    # Use pandas for efficient rolling mean calculation
-    series = pd.Series(data)
-    return series.rolling(window=window_size, center=True, min_periods=1).mean().values
-
-def main():
-    parser = argparse.ArgumentParser(description='Generate histogram of total_latency percent differences between two CSV files')
-    parser.add_argument('baseline_csv', help='First CSV file, used as the baseline/control')
-    parser.add_argument('comparison_csv', help='Second CSV file, which is being compared to the baseline')
-    parser.add_argument('-o', '--output', default='latency.png', help='Output image file (default: latency.png)')
-    parser.add_argument('--graphs', default='all', help='Comma-separated list of graphs to plot: histogram, line, gas, all (default: all)')
-    parser.add_argument('--average', type=int, metavar='N', help='Apply moving average over N blocks to smooth line and gas charts')
-    parser.add_argument('--separate', action='store_true', help='Output each chart as a separate file')
-
-    args = parser.parse_args()
-
-    # Parse graph selection
-    if args.graphs.lower() == 'all':
-        selected_graphs = {'histogram', 'line', 'gas'}
-    else:
-        selected_graphs = set(graph.strip().lower() for graph in args.graphs.split(','))
-        valid_graphs = {'histogram', 'line', 'gas'}
-        invalid_graphs = selected_graphs - valid_graphs
-        if invalid_graphs:
-            print(f"Error: Invalid graph types: {', '.join(invalid_graphs)}. Valid options are: histogram, line, gas, all", file=sys.stderr)
-            sys.exit(1)
-
-    try:
-        df1 = pd.read_csv(args.baseline_csv)
-        df2 = pd.read_csv(args.comparison_csv)
-    except FileNotFoundError as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-    except Exception as e:
-        print(f"Error reading CSV files: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    if 'total_latency' not in df1.columns:
-        print(f"Error: 'total_latency' column not found in {args.baseline_csv}", file=sys.stderr)
-        sys.exit(1)
-
-    if 'total_latency' not in df2.columns:
-        print(f"Error: 'total_latency' column not found in {args.comparison_csv}", file=sys.stderr)
-        sys.exit(1)
-
-    # Check for gas_used column if gas graph is selected
-    if 'gas' in selected_graphs:
-        if 'gas_used' not in df1.columns:
-            print(f"Error: 'gas_used' column not found in {args.baseline_csv} (required for gas graph)", file=sys.stderr)
-            sys.exit(1)
-        if 'gas_used' not in df2.columns:
-            print(f"Error: 'gas_used' column not found in {args.comparison_csv} (required for gas graph)", file=sys.stderr)
-            sys.exit(1)
-
-    if len(df1) != len(df2):
-        print("Warning: CSV files have different number of rows. Using minimum length.", file=sys.stderr)
-        min_len = min(len(df1), len(df2))
-        df1 = df1.head(min_len)
-        df2 = df2.head(min_len)
-
-    # Convert from microseconds to milliseconds for better readability
-    latency1 = df1['total_latency'].values / 1000.0
-    latency2 = df2['total_latency'].values / 1000.0
-
-    # Handle division by zero
-    with np.errstate(divide='ignore', invalid='ignore'):
-        percent_diff = ((latency2 - latency1) / latency1) * 100
-
-    # Remove infinite and NaN values
-    percent_diff = percent_diff[np.isfinite(percent_diff)]
-
-    if len(percent_diff) == 0:
-        print("Error: No valid percent differences could be calculated", file=sys.stderr)
-        sys.exit(1)
-
-    # Calculate statistics once for use in graphs and output
-    mean_diff = np.mean(percent_diff)
-    median_diff = np.median(percent_diff)
-
-    # Determine number of subplots and create figure
-    num_plots = len(selected_graphs)
-    if num_plots == 0:
-        print("Error: No valid graphs selected", file=sys.stderr)
-        sys.exit(1)
-
-    # Store output filenames
-    output_files = []
-    
-    if args.separate:
-        # We'll create individual figures for each graph
-        pass
-    else:
-        # Create combined figure
-        if num_plots == 1:
-            fig, ax = plt.subplots(1, 1, figsize=(12, 6))
-            axes = [ax]
-        else:
-            fig, axes = plt.subplots(num_plots, 1, figsize=(12, 6 * num_plots))
-
-    plot_idx = 0
-
-    # Plot histogram if selected
-    if 'histogram' in selected_graphs:
-        if args.separate:
-            fig, ax = plt.subplots(1, 1, figsize=(12, 6))
-        else:
-            ax = axes[plot_idx]
-            
-        min_diff = np.floor(percent_diff.min())
-        max_diff = np.ceil(percent_diff.max())
-
-        # Create histogram with 1% buckets
-        bins = np.arange(min_diff, max_diff + 1, 1)
-
-        ax.hist(percent_diff, bins=bins, edgecolor='black', alpha=0.7)
-        ax.set_xlabel('Percent Difference (%)')
-        ax.set_ylabel('Number of Blocks')
-        ax.set_title(f'Total Latency Percent Difference Histogram\n({args.baseline_csv} vs {args.comparison_csv})')
-        ax.grid(True, alpha=0.3)
-
-        # Add statistics to the histogram
-        ax.axvline(mean_diff, color='red', linestyle='--', label=f'Mean: {mean_diff:.2f}%')
-        ax.axvline(median_diff, color='orange', linestyle='--', label=f'Median: {median_diff:.2f}%')
-        ax.legend()
-        
-        if args.separate:
-            plt.tight_layout()
-            output_file = get_output_filename(args.output, 'histogram')
-            plt.savefig(output_file, dpi=300, bbox_inches='tight')
-            output_files.append(output_file)
-            plt.close(fig)
-        else:
-            plot_idx += 1
-
-    # Plot line graph if selected
-    if 'line' in selected_graphs:
-        if args.separate:
-            fig, ax = plt.subplots(1, 1, figsize=(12, 6))
-        else:
-            ax = axes[plot_idx]
-            
-        # Determine comparison color based on median change. The median being
-        # negative means processing time got faster, so that becomes green.
-        comparison_color = 'green' if median_diff < 0 else 'red'
-
-        # Apply moving average if requested
-        plot_latency1 = latency1[:len(percent_diff)]
-        plot_latency2 = latency2[:len(percent_diff)]
-        
-        if args.average:
-            plot_latency1 = moving_average(plot_latency1, args.average)
-            plot_latency2 = moving_average(plot_latency2, args.average)
-        if 'block_number' in df1.columns and 'block_number' in df2.columns:
-            block_numbers = df1['block_number'].values[:len(percent_diff)]
-            ax.plot(block_numbers, plot_latency1, 'orange', alpha=0.7, label=f'Baseline ({args.baseline_csv})')
-            ax.plot(block_numbers, plot_latency2, comparison_color, alpha=0.7, label=f'Comparison ({args.comparison_csv})')
-            ax.set_xlabel('Block Number')
-            ax.set_ylabel('Total Latency (ms)')
-            title = 'Total Latency vs Block Number'
-            if args.average:
-                title += f' ({args.average}-block moving average)'
-            ax.set_title(title)
-            ax.grid(True, alpha=0.3)
-            ax.legend()
-        else:
-            # If no block_number column, use index
-            indices = np.arange(len(percent_diff))
-            ax.plot(indices, plot_latency1, 'orange', alpha=0.7, label=f'Baseline ({args.baseline_csv})')
-            ax.plot(indices, plot_latency2, comparison_color, alpha=0.7, label=f'Comparison ({args.comparison_csv})')
-            ax.set_xlabel('Block Index')
-            ax.set_ylabel('Total Latency (ms)')
-            title = 'Total Latency vs Block Index'
-            if args.average:
-                title += f' ({args.average}-block moving average)'
-            ax.set_title(title)
-            ax.grid(True, alpha=0.3)
-            ax.legend()
-        
-        if args.separate:
-            plt.tight_layout()
-            output_file = get_output_filename(args.output, 'line')
-            plt.savefig(output_file, dpi=300, bbox_inches='tight')
-            output_files.append(output_file)
-            plt.close(fig)
-        else:
-            plot_idx += 1
-
-    # Plot gas/s graph if selected
-    if 'gas' in selected_graphs:
-        if args.separate:
-            fig, ax = plt.subplots(1, 1, figsize=(12, 6))
-        else:
-            ax = axes[plot_idx]
-            
-        # Calculate gas per second (gas/s)
-        # latency is in microseconds, so convert to seconds for gas/s calculation
-        gas1 = df1['gas_used'].values[:len(percent_diff)]
-        gas2 = df2['gas_used'].values[:len(percent_diff)]
-        
-        # Convert latency from microseconds to seconds
-        latency1_sec = df1['total_latency'].values[:len(percent_diff)] / 1_000_000.0
-        latency2_sec = df2['total_latency'].values[:len(percent_diff)] / 1_000_000.0
-        
-        # Calculate gas per second
-        gas_per_sec1 = gas1 / latency1_sec
-        gas_per_sec2 = gas2 / latency2_sec
-        
-        # Store original values for statistics before averaging
-        original_gas_per_sec1 = gas_per_sec1.copy()
-        original_gas_per_sec2 = gas_per_sec2.copy()
-        
-        # Apply moving average if requested
-        if args.average:
-            gas_per_sec1 = moving_average(gas_per_sec1, args.average)
-            gas_per_sec2 = moving_average(gas_per_sec2, args.average)
-        
-        # Calculate median gas/s for color determination (use original values)
-        median_gas_per_sec1 = np.median(original_gas_per_sec1)
-        median_gas_per_sec2 = np.median(original_gas_per_sec2)
-        comparison_color = 'green' if median_gas_per_sec2 > median_gas_per_sec1 else 'red'
-        
-        if 'block_number' in df1.columns and 'block_number' in df2.columns:
-            block_numbers = df1['block_number'].values[:len(percent_diff)]
-            ax.plot(block_numbers, gas_per_sec1, 'orange', alpha=0.7, label=f'Baseline ({args.baseline_csv})')
-            ax.plot(block_numbers, gas_per_sec2, comparison_color, alpha=0.7, label=f'Comparison ({args.comparison_csv})')
-            ax.set_xlabel('Block Number')
-            ax.set_ylabel('Gas Throughput')
-            title = 'Gas Throughput vs Block Number'
-            if args.average:
-                title += f' ({args.average}-block moving average)'
-            ax.set_title(title)
-            ax.grid(True, alpha=0.3)
-            ax.legend()
-            
-            # Format Y-axis with gas units
-            formatter = FuncFormatter(format_gas_units)
-            ax.yaxis.set_major_formatter(formatter)
-        else:
-            # If no block_number column, use index
-            indices = np.arange(len(percent_diff))
-            ax.plot(indices, gas_per_sec1, 'orange', alpha=0.7, label=f'Baseline ({args.baseline_csv})')
-            ax.plot(indices, gas_per_sec2, comparison_color, alpha=0.7, label=f'Comparison ({args.comparison_csv})')
-            ax.set_xlabel('Block Index')
-            ax.set_ylabel('Gas Throughput')
-            title = 'Gas Throughput vs Block Index'
-            if args.average:
-                title += f' ({args.average}-block moving average)'
-            ax.set_title(title)
-            ax.grid(True, alpha=0.3)
-            ax.legend()
-            
-            # Format Y-axis with gas units
-            formatter = FuncFormatter(format_gas_units)
-            ax.yaxis.set_major_formatter(formatter)
-        
-        if args.separate:
-            plt.tight_layout()
-            output_file = get_output_filename(args.output, 'gas')
-            plt.savefig(output_file, dpi=300, bbox_inches='tight')
-            output_files.append(output_file)
-            plt.close(fig)
-        else:
-            plot_idx += 1
-
-    # Save combined figure if not using separate files
-    if not args.separate:
-        plt.tight_layout()
-        plt.savefig(args.output, dpi=300, bbox_inches='tight')
-        output_files.append(args.output)
-
-    # Create graph type description for output message
-    graph_types = []
-    if 'histogram' in selected_graphs:
-        graph_types.append('histogram')
-    if 'line' in selected_graphs:
-        graph_types.append('latency graph')
-    if 'gas' in selected_graphs:
-        graph_types.append('gas/s graph')
-    graph_desc = ' and '.join(graph_types)
-    
-    # Print output file(s) information
-    if args.separate:
-        print(f"Saved {len(output_files)} separate files:")
-        for output_file in output_files:
-            print(f"  - {output_file}")
-    else:
-        print(f"{graph_desc.capitalize()} saved to {args.output}")
-
-    # Always print statistics
-    print(f"\nStatistics:")
-    print(f"Mean percent difference: {mean_diff:.2f}%")
-    print(f"Median percent difference: {median_diff:.2f}%")
-    print(f"Standard deviation: {np.std(percent_diff):.2f}%")
-    print(f"Min: {percent_diff.min():.2f}%")
-    print(f"Max: {percent_diff.max():.2f}%")
-    print(f"Total blocks analyzed: {len(percent_diff)}")
-    
-    # Print gas/s statistics if gas data is available
-    if 'gas' in selected_graphs:
-        # Use original values for statistics (not averaged)
-        print(f"\nGas/s Statistics:")
-        print(f"Baseline median gas/s: {median_gas_per_sec1:,.0f}")
-        print(f"Comparison median gas/s: {median_gas_per_sec2:,.0f}")
-        gas_diff_percent = ((median_gas_per_sec2 - median_gas_per_sec1) / median_gas_per_sec1) * 100
-        print(f"Gas/s percent change: {gas_diff_percent:+.2f}%")
-
-if __name__ == '__main__':
-    main()
diff --git a/bin/reth-bench/src/authenticated_transport.rs b/bin/reth-bench/src/authenticated_transport.rs
deleted file mode 100644
index eba9514ae9d..00000000000
--- a/bin/reth-bench/src/authenticated_transport.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-//! This contains an authenticated rpc transport that can be used to send engine API newPayload
-//! requests.
-
-use std::sync::Arc;
-
-use alloy_json_rpc::{RequestPacket, ResponsePacket};
-use alloy_pubsub::{PubSubConnect, PubSubFrontend};
-use alloy_rpc_types_engine::{Claims, JwtSecret};
-use alloy_transport::{
-    utils::guess_local_url, Authorization, BoxTransport, TransportConnect, TransportError,
-    TransportErrorKind, TransportFut,
-};
-use alloy_transport_http::{reqwest::Url, Http, ReqwestTransport};
-use alloy_transport_ipc::IpcConnect;
-use alloy_transport_ws::WsConnect;
-use futures::FutureExt;
-use reqwest::header::HeaderValue;
-use std::task::{Context, Poll};
-use tokio::sync::RwLock;
-use tower::Service;
-
-/// An enum representing the different transports that can be used to connect to a runtime.
-/// Only meant to be used internally by [`AuthenticatedTransport`].
-#[derive(Clone, Debug)]
-pub enum InnerTransport {
-    /// HTTP transport
-    Http(ReqwestTransport),
-    /// `WebSocket` transport
-    Ws(PubSubFrontend),
-    /// IPC transport
-    Ipc(PubSubFrontend),
-}
-
-impl InnerTransport {
-    /// Connects to a transport based on the given URL and JWT. Returns an [`InnerTransport`] and
-    /// the [`Claims`] generated from the jwt.
-    async fn connect(
-        url: Url,
-        jwt: JwtSecret,
-    ) -> Result<(Self, Claims), AuthenticatedTransportError> {
-        match url.scheme() {
-            "http" | "https" => Self::connect_http(url, jwt),
-            "ws" | "wss" => Self::connect_ws(url, jwt).await,
-            "file" => Ok((Self::connect_ipc(url).await?, Claims::default())),
-            _ => Err(AuthenticatedTransportError::BadScheme(url.scheme().to_string())),
-        }
-    }
-
-    /// Connects to an HTTP [`alloy_transport_http::Http`] transport. Returns an [`InnerTransport`]
-    /// and the [Claims] generated from the jwt.
-    fn connect_http(
-        url: Url,
-        jwt: JwtSecret,
-    ) -> Result<(Self, Claims), AuthenticatedTransportError> {
-        let mut client_builder = reqwest::Client::builder();
-        let mut headers = reqwest::header::HeaderMap::new();
-
-        // Add the JWT to the headers if we can decode it.
-        let (auth, claims) =
-            build_auth(jwt).map_err(|e| AuthenticatedTransportError::InvalidJwt(e.to_string()))?;
-
-        let mut auth_value: HeaderValue =
-            HeaderValue::from_str(&auth.to_string()).expect("Header should be valid string");
-        auth_value.set_sensitive(true);
-
-        headers.insert(reqwest::header::AUTHORIZATION, auth_value);
-        client_builder = client_builder.default_headers(headers);
-
-        let client =
-            client_builder.build().map_err(AuthenticatedTransportError::HttpConstructionError)?;
-
-        let inner = Self::Http(Http::with_client(client, url));
-        Ok((inner, claims))
-    }
-
-    /// Connects to a `WebSocket` [`alloy_transport_ws::WsConnect`] transport. Returns an
-    /// [`InnerTransport`] and the [`Claims`] generated from the jwt.
-    async fn connect_ws(
-        url: Url,
-        jwt: JwtSecret,
-    ) -> Result<(Self, Claims), AuthenticatedTransportError> {
-        // Add the JWT to the headers if we can decode it.
-        let (auth, claims) =
-            build_auth(jwt).map_err(|e| AuthenticatedTransportError::InvalidJwt(e.to_string()))?;
-
-        let inner = WsConnect::new(url.clone())
-            .with_auth(auth)
-            .into_service()
-            .await
-            .map(Self::Ws)
-            .map_err(|e| AuthenticatedTransportError::TransportError(e, url.to_string()))?;
-
-        Ok((inner, claims))
-    }
-
-    /// Connects to an IPC [`alloy_transport_ipc::IpcConnect`] transport. Returns an
-    /// [`InnerTransport`]. Does not return any [`Claims`] because IPC does not require them.
-    async fn connect_ipc(url: Url) -> Result<Self, AuthenticatedTransportError> {
-        // IPC, even for engine, typically does not require auth because it's local
-        IpcConnect::new(url.to_string())
-            .into_service()
-            .await
-            .map(InnerTransport::Ipc)
-            .map_err(|e| AuthenticatedTransportError::TransportError(e, url.to_string()))
-    }
-}
-
-/// An authenticated transport that can be used to send requests that contain a jwt bearer token.
-#[derive(Debug, Clone)]
-pub struct AuthenticatedTransport {
-    /// The inner actual transport used.
-    ///
-    /// Also contains the current claims being used. This is used to determine whether or not we
-    /// should create another client.
-    inner_and_claims: Arc<RwLock<(InnerTransport, Claims)>>,
-    /// The current jwt is being used. This is so we can recreate claims.
-    jwt: JwtSecret,
-    /// The current URL is being used. This is so we can recreate the client if needed.
-    url: Url,
-}
-
-/// An error that can occur when creating an authenticated transport.
-#[derive(Debug, thiserror::Error)]
-pub enum AuthenticatedTransportError {
-    /// The URL is invalid.
-    #[error("The URL is invalid")]
-    InvalidUrl,
-    /// Failed to lock transport
-    #[error("Failed to lock transport")]
-    LockFailed,
-    /// The JWT is invalid.
-    #[error("The JWT is invalid: {0}")]
-    InvalidJwt(String),
-    /// The transport failed to connect.
-    #[error("The transport failed to connect to {1}, transport error: {0}")]
-    TransportError(TransportError, String),
-    /// The http client could not be built.
-    #[error("The http client could not be built")]
-    HttpConstructionError(reqwest::Error),
-    /// The scheme is invalid.
-    #[error("The URL scheme is invalid: {0}")]
-    BadScheme(String),
-}
-
-impl AuthenticatedTransport {
-    /// Create a new builder with the given URL.
-    pub async fn connect(url: Url, jwt: JwtSecret) -> Result<Self, AuthenticatedTransportError> {
-        let (inner, claims) = InnerTransport::connect(url.clone(), jwt).await?;
-        Ok(Self { inner_and_claims: Arc::new(RwLock::new((inner, claims))), jwt, url })
-    }
-
-    /// Sends a request using the underlying transport.
-    ///
-    /// For sending the actual request, this action is delegated down to the underlying transport
-    /// through Tower's [`tower::Service::call`]. See tower's [`tower::Service`] trait for more
-    /// information.
-    fn request(&self, req: RequestPacket) -> TransportFut<'static> {
-        let this = self.clone();
-
-        Box::pin(async move {
-            let mut inner_and_claims = this.inner_and_claims.write().await;
-
-            // shift the iat forward by one second so there is some buffer time
-            let mut shifted_claims = inner_and_claims.1;
-            shifted_claims.iat -= 30;
-
-            // if the claims are out of date, reset the inner transport
-            if !shifted_claims.is_within_time_window() {
-                let (new_inner, new_claims) =
-                    InnerTransport::connect(this.url.clone(), this.jwt).await.map_err(|e| {
-                        TransportError::Transport(TransportErrorKind::Custom(Box::new(e)))
-                    })?;
-                *inner_and_claims = (new_inner, new_claims);
-            }
-
-            match inner_and_claims.0 {
-                InnerTransport::Http(ref mut http) => http.call(req),
-                InnerTransport::Ws(ref mut ws) => ws.call(req),
-                InnerTransport::Ipc(ref mut ipc) => ipc.call(req),
-            }
-            .await
-        })
-    }
-}
-
-fn build_auth(secret: JwtSecret) -> eyre::Result<(Authorization, Claims)> {
-    // Generate claims (iat with current timestamp), this happens by default using the Default trait
-    // for Claims.
-    let claims = Claims::default();
-    let token = secret.encode(&claims)?;
-    let auth = Authorization::Bearer(token);
-
-    Ok((auth, claims))
-}
-
-/// This specifies how to connect to an authenticated transport.
-#[derive(Clone, Debug)]
-pub struct AuthenticatedTransportConnect {
-    /// The URL to connect to.
-    url: Url,
-    /// The JWT secret is used to authenticate the transport.
-    jwt: JwtSecret,
-}
-
-impl AuthenticatedTransportConnect {
-    /// Create a new builder with the given URL.
-    pub const fn new(url: Url, jwt: JwtSecret) -> Self {
-        Self { url, jwt }
-    }
-}
-
-impl TransportConnect for AuthenticatedTransportConnect {
-    fn is_local(&self) -> bool {
-        guess_local_url(&self.url)
-    }
-
-    async fn get_transport(&self) -> Result<BoxTransport, TransportError> {
-        Ok(BoxTransport::new(
-            AuthenticatedTransport::connect(self.url.clone(), self.jwt)
-                .map(|res| match res {
-                    Ok(transport) => Ok(transport),
-                    Err(err) => {
-                        Err(TransportError::Transport(TransportErrorKind::Custom(Box::new(err))))
-                    }
-                })
-                .await?,
-        ))
-    }
-}
-
-impl tower::Service<RequestPacket> for AuthenticatedTransport {
-    type Response = ResponsePacket;
-    type Error = TransportError;
-    type Future = TransportFut<'static>;
-
-    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, req: RequestPacket) -> Self::Future {
-        self.request(req)
-    }
-}
-
-impl tower::Service<RequestPacket> for &AuthenticatedTransport {
-    type Response = ResponsePacket;
-    type Error = TransportError;
-    type Future = TransportFut<'static>;
-
-    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, req: RequestPacket) -> Self::Future {
-        self.request(req)
-    }
-}
diff --git a/bin/reth-bench/src/bench/context.rs b/bin/reth-bench/src/bench/context.rs
deleted file mode 100644
index 4df7e5f534c..00000000000
--- a/bin/reth-bench/src/bench/context.rs
+++ /dev/null
@@ -1,178 +0,0 @@
-//! This contains the [`BenchContext`], which is information that all replay-based benchmarks need.
-//! The initialization code is also the same, so this can be shared across benchmark commands.
-
-use crate::{authenticated_transport::AuthenticatedTransportConnect, bench_mode::BenchMode};
-use alloy_eips::BlockNumberOrTag;
-use alloy_provider::{network::AnyNetwork, Provider, RootProvider};
-use alloy_rpc_client::ClientBuilder;
-use alloy_rpc_types_engine::JwtSecret;
-use alloy_transport::layers::{RateLimitRetryPolicy, RetryBackoffLayer};
-use reqwest::Url;
-use reth_node_core::args::{BenchmarkArgs, WaitForPersistence};
-use tracing::info;
-
-/// This is intended to be used by benchmarks that replay blocks from an RPC.
-///
-/// It contains an authenticated provider for engine API queries, a block provider for block
-/// queries, a [`BenchMode`] to determine whether the benchmark should run for a closed or open
-/// range of blocks, and the next block to fetch.
-pub(crate) struct BenchContext {
-    /// The auth provider is used for engine API queries.
-    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,
-    /// The next block to fetch.
-    pub(crate) next_block: u64,
-    /// Whether to use `reth_newPayload` endpoint instead of `engine_newPayload*`.
-    pub(crate) use_reth_namespace: bool,
-    /// Whether to fetch and replay RLP-encoded blocks.
-    pub(crate) rlp_blocks: bool,
-    /// Controls when `reth_newPayload` waits for persistence.
-    pub(crate) wait_for_persistence: WaitForPersistence,
-    /// Whether to skip waiting for caches (pass `wait_for_caches: false`).
-    pub(crate) no_wait_for_caches: bool,
-}
-
-impl BenchContext {
-    /// This is the initialization code for most benchmarks, taking in a [`BenchmarkArgs`] and
-    /// returning the providers needed to run a benchmark.
-    pub(crate) async fn new(bench_args: &BenchmarkArgs, rpc_url: String) -> eyre::Result<Self> {
-        info!(target: "reth-bench", "Running benchmark using data from RPC URL: {}", rpc_url);
-
-        // Ensure that output directory exists and is a directory
-        if let Some(output) = &bench_args.output {
-            if output.is_file() {
-                return Err(eyre::eyre!("Output path must be a directory"));
-            }
-            // Create the directory if it doesn't exist
-            if !output.exists() {
-                std::fs::create_dir_all(output)?;
-                info!(target: "reth-bench", "Created output directory: {:?}", output);
-            }
-        }
-
-        // set up alloy client for blocks, retrying on any errors, whether HTTP or OS
-        let retry_policy = RateLimitRetryPolicy::default().or(|_| true);
-        let max_retries = bench_args.rpc_block_fetch_retries.as_max_retries();
-        let client = ClientBuilder::default()
-            .layer(RetryBackoffLayer::new_with_policy(max_retries, 800, u64::MAX, retry_policy))
-            .http(rpc_url.parse()?);
-        let block_provider = RootProvider::<AnyNetwork>::new(client);
-
-        // construct the authenticated provider
-        let auth_jwt = bench_args
-            .auth_jwtsecret
-            .clone()
-            .ok_or_else(|| eyre::eyre!("--jwt-secret must be provided for authenticated RPC"))?;
-
-        // fetch jwt from file
-        //
-        // the jwt is hex encoded so we will decode it after
-        let jwt = std::fs::read_to_string(auth_jwt)?;
-        let jwt = JwtSecret::from_hex(jwt)?;
-
-        // get engine url
-        let auth_url = Url::parse(&bench_args.engine_rpc_url)?;
-
-        // construct the authed transport
-        info!(target: "reth-bench", "Connecting to Engine RPC at {} for replay", auth_url);
-        let auth_transport = AuthenticatedTransportConnect::new(auth_url, jwt);
-        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:
-        //     - `from = head + 1`
-        //     - `to = head + advance`
-        // - If only `--to` is provided, fetches the latest block from the engine and sets:
-        //     - `from = head`
-        // - Otherwise, uses the values from `--from` and `--to`.
-        let (from, to) = if let Some(advance) = bench_args.advance {
-            if advance == 0 {
-                return Err(eyre::eyre!("--advance must be greater than 0"));
-            }
-
-            let head_block = auth_provider
-                .get_block_by_number(BlockNumberOrTag::Latest)
-                .await?
-                .ok_or_else(|| eyre::eyre!("Failed to fetch latest block for --advance"))?;
-            let head_number = head_block.header.number;
-            (Some(head_number), Some(head_number + advance))
-        } else if bench_args.from.is_none() && bench_args.to.is_some() {
-            let head_block = auth_provider
-                .get_block_by_number(BlockNumberOrTag::Latest)
-                .await?
-                .ok_or_else(|| eyre::eyre!("Failed to fetch latest block from engine"))?;
-            let head_number = head_block.header.number;
-            info!(target: "reth-bench", "No --from provided, derived from engine head: {}", head_number);
-            (Some(head_number), bench_args.to)
-        } else {
-            (bench_args.from, bench_args.to)
-        };
-
-        // If `--to` are not provided, we will run the benchmark continuously,
-        // starting at the latest block.
-        let latest_block = block_provider
-            .get_block_by_number(BlockNumberOrTag::Latest)
-            .full()
-            .await?
-            .ok_or_else(|| eyre::eyre!("Failed to fetch latest block from RPC"))?;
-        let mut benchmark_mode = BenchMode::new(from, to, latest_block.into_inner().number());
-
-        let first_block = match benchmark_mode {
-            BenchMode::Continuous(start) => {
-                block_provider.get_block_by_number(start.into()).full().await?.ok_or_else(|| {
-                    eyre::eyre!("Failed to fetch block {} from RPC for continuous mode", start)
-                })?
-            }
-            BenchMode::Range(ref mut range) => {
-                match range.next() {
-                    Some(block_number) => {
-                        // fetch first block in range
-                        block_provider
-                            .get_block_by_number(block_number.into())
-                            .full()
-                            .await?
-                            .ok_or_else(|| {
-                                eyre::eyre!("Failed to fetch block {} from RPC", block_number)
-                            })?
-                    }
-                    None => {
-                        return Err(eyre::eyre!(
-                            "Benchmark mode range is empty, please provide a larger range"
-                        ));
-                    }
-                }
-            }
-        };
-
-        let next_block = first_block.header.number + 1;
-        let rlp_blocks = bench_args.rlp_blocks;
-        let wait_for_persistence =
-            bench_args.wait_for_persistence.unwrap_or(WaitForPersistence::Never);
-        let use_reth_namespace = bench_args.reth_new_payload || rlp_blocks;
-        let no_wait_for_caches = bench_args.no_wait_for_caches;
-        Ok(Self {
-            auth_provider,
-            block_provider,
-            local_rpc_provider,
-            benchmark_mode,
-            next_block,
-            use_reth_namespace,
-            rlp_blocks,
-            wait_for_persistence,
-            no_wait_for_caches,
-        })
-    }
-}
diff --git a/bin/reth-bench/src/bench/generate_big_block.rs b/bin/reth-bench/src/bench/generate_big_block.rs
deleted file mode 100644
index 5826cce7712..00000000000
--- a/bin/reth-bench/src/bench/generate_big_block.rs
+++ /dev/null
@@ -1,903 +0,0 @@
-//! Command for generating large blocks by merging transactions from consecutive real blocks.
-//!
-//! This command fetches consecutive blocks from an RPC until a target gas usage is reached,
-//! takes block 0 as the "base" payload, concatenates transactions from subsequent blocks,
-//! and saves the result to disk as a [`BigBlockPayload`] JSON file containing the merged
-//! [`ExecutionData`] and environment switches at each block boundary.
-
-use alloy_consensus::{TxEnvelope, TxReceipt};
-use alloy_eips::{
-    eip1559::BaseFeeParams,
-    eip7840::BlobParams,
-    eip7928::{AccountChanges, BlockAccessList, SlotChanges},
-    Typed2718,
-};
-use alloy_primitives::{Bloom, Bytes, B256};
-use alloy_provider::{network::AnyNetwork, Provider, RootProvider};
-use alloy_rpc_client::ClientBuilder;
-use alloy_rpc_types_engine::{
-    CancunPayloadFields, ExecutionData, ExecutionPayload, ExecutionPayloadSidecar,
-    PraguePayloadFields,
-};
-use clap::Parser;
-use eyre::Context;
-use reth_chainspec::EthChainSpec;
-use reth_cli::chainspec::ChainSpecParser;
-use reth_cli_runner::CliContext;
-use reth_engine_primitives::BigBlockData;
-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 tracing::{info, warn};
-
-use crate::bench::helpers::fetch_block_access_list;
-
-/// A single transaction with its gas used and raw encoded bytes.
-#[derive(Debug, Clone)]
-pub struct RawTransaction {
-    /// The actual gas used by the transaction (from receipt).
-    pub gas_used: u64,
-    /// The transaction type (e.g., 3 for EIP-4844 blob txs).
-    pub tx_type: u8,
-    /// The raw RLP-encoded transaction bytes.
-    pub raw: Bytes,
-}
-
-/// Abstraction over sources of transactions for big block generation.
-///
-/// Implementors provide transactions from different sources (RPC, database, files, etc.)
-pub trait TransactionSource {
-    /// Fetch transactions from a specific block number.
-    ///
-    /// Returns `Ok(None)` if the block doesn't exist.
-    /// Returns `Ok(Some((transactions, gas_used)))` with the block's transactions and total gas.
-    fn fetch_block_transactions(
-        &self,
-        block_number: u64,
-    ) -> impl Future<Output = eyre::Result<Option<(Vec<RawTransaction>, u64)>>> + Send;
-}
-
-/// RPC-based transaction source that fetches from a remote node.
-#[derive(Debug)]
-pub struct RpcTransactionSource {
-    provider: RootProvider<AnyNetwork>,
-}
-
-impl RpcTransactionSource {
-    /// Create a new RPC transaction source.
-    pub const fn new(provider: RootProvider<AnyNetwork>) -> Self {
-        Self { provider }
-    }
-
-    /// Create from an RPC URL with retry backoff.
-    pub fn from_url(rpc_url: &str) -> eyre::Result<Self> {
-        let client = ClientBuilder::default()
-            .layer(alloy_transport::layers::RetryBackoffLayer::new(10, 800, u64::MAX))
-            .http(rpc_url.parse()?);
-        let provider = RootProvider::<AnyNetwork>::new(client);
-        Ok(Self { provider })
-    }
-}
-
-impl TransactionSource for RpcTransactionSource {
-    async fn fetch_block_transactions(
-        &self,
-        block_number: u64,
-    ) -> eyre::Result<Option<(Vec<RawTransaction>, u64)>> {
-        // Fetch block and receipts in parallel
-        let (block, receipts) = tokio::try_join!(
-            self.provider.get_block_by_number(block_number.into()).full(),
-            self.provider.get_block_receipts(block_number.into())
-        )?;
-
-        let Some(block) = block else {
-            return Ok(None);
-        };
-
-        let Some(receipts) = receipts else {
-            return Err(eyre::eyre!("Receipts not found for block {}", block_number));
-        };
-
-        let block_gas_used = block.header.gas_used;
-
-        // Convert cumulative gas from receipts to per-tx gas_used
-        let mut prev_cumulative = 0u64;
-        let transactions: Vec<RawTransaction> = block
-            .transactions
-            .txns()
-            .zip(receipts.iter())
-            .map(|(tx, receipt)| {
-                let cumulative = receipt.inner.inner.inner.receipt.cumulative_gas_used;
-                let gas_used = cumulative - prev_cumulative;
-                prev_cumulative = cumulative;
-
-                let with_encoded = tx.inner.inner.clone().into_encoded();
-                RawTransaction {
-                    gas_used,
-                    tx_type: tx.inner.ty(),
-                    raw: with_encoded.encoded_bytes().clone(),
-                }
-            })
-            .collect();
-
-        Ok(Some((transactions, block_gas_used)))
-    }
-}
-
-/// Collects transactions from a source up to a target gas usage.
-#[derive(Debug)]
-pub struct TransactionCollector<S> {
-    source: S,
-    target_gas: u64,
-}
-
-impl<S: TransactionSource> TransactionCollector<S> {
-    /// Create a new transaction collector.
-    pub const fn new(source: S, target_gas: u64) -> Self {
-        Self { source, target_gas }
-    }
-
-    /// Collect transactions starting from the given block number.
-    ///
-    /// Skips blob transactions (type 3) and collects until target gas is reached.
-    /// Returns a `CollectionResult` with transactions, gas info, and next block.
-    pub async fn collect(&self, start_block: u64) -> eyre::Result<CollectionResult> {
-        self.collect_gas(start_block, self.target_gas).await
-    }
-
-    /// Collect transactions up to a specific gas target.
-    ///
-    /// This is used both for initial collection and for retry top-ups.
-    pub async fn collect_gas(
-        &self,
-        start_block: u64,
-        gas_target: u64,
-    ) -> eyre::Result<CollectionResult> {
-        let mut transactions: Vec<RawTransaction> = Vec::new();
-        let mut total_gas: u64 = 0;
-        let mut current_block = start_block;
-
-        while total_gas < gas_target {
-            let Some((block_txs, _)) = self.source.fetch_block_transactions(current_block).await?
-            else {
-                tracing::warn!(target: "reth-bench", block = current_block, "Block not found, stopping");
-                break;
-            };
-
-            for tx in block_txs {
-                // Skip blob transactions (EIP-4844, type 3)
-                if tx.tx_type == 3 {
-                    continue;
-                }
-
-                if total_gas + tx.gas_used <= gas_target {
-                    total_gas += tx.gas_used;
-                    transactions.push(tx);
-                }
-
-                if total_gas >= gas_target {
-                    break;
-                }
-            }
-
-            current_block += 1;
-
-            // Stop early if remaining gas is under 1M (close enough to target)
-            let remaining_gas = gas_target.saturating_sub(total_gas);
-            if remaining_gas < 1_000_000 {
-                break;
-            }
-        }
-
-        info!(
-            target: "reth-bench",
-            total_txs = transactions.len(),
-            gas_sent = total_gas,
-            next_block = current_block,
-            "Finished collecting transactions"
-        );
-
-        Ok(CollectionResult { transactions, gas_sent: total_gas, next_block: current_block })
-    }
-}
-
-/// Result of collecting transactions from blocks.
-#[derive(Debug)]
-pub struct CollectionResult {
-    /// Collected transactions with their gas info.
-    pub transactions: Vec<RawTransaction>,
-    /// Total gas sent (sum of historical `gas_used` for all collected txs).
-    pub gas_sent: u64,
-    /// Next block number to continue collecting from.
-    pub next_block: u64,
-}
-
-/// A merged big block payload with environment switches at block boundaries.
-#[derive(Debug, Serialize, Deserialize)]
-pub struct BigBlockPayload {
-    /// The primary execution data with all concatenated transactions.
-    pub execution_data: ExecutionData,
-    /// Big block data containing environment switches and prior block hashes.
-    #[serde(default)]
-    pub big_block_data: BigBlockData<ExecutionData>,
-    /// Flattened BAL across all constituent blocks, if requested during generation.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub block_access_list: Option<BlockAccessList>,
-}
-
-/// `reth bench generate-big-block` command
-///
-/// Generates a large block by fetching consecutive blocks from an RPC, merging their
-/// transactions into a single payload, and saving the result to disk.
-#[derive(Debug, Parser)]
-pub struct Command {
-    /// The RPC URL to use for fetching blocks.
-    #[arg(long, value_name = "RPC_URL")]
-    rpc_url: String,
-
-    /// The chain name or path to a chain spec JSON file.
-    #[arg(long, value_name = "CHAIN", default_value = "mainnet")]
-    chain: String,
-
-    /// Block number to start from.
-    #[arg(long, value_name = "FROM_BLOCK")]
-    from_block: u64,
-
-    /// Target gas usage per big block. Consecutive real blocks are merged until
-    /// this gas target is reached (or exceeded by the last included block).
-    /// Accepts optional suffixes: K (thousand), M (million), G (billion).
-    #[arg(long, value_name = "TARGET_GAS", value_parser = super::helpers::parse_gas_limit)]
-    target_gas: u64,
-
-    /// Number of sequential big blocks to generate.
-    ///
-    /// Each big block merges real blocks until `--target-gas` is reached.
-    /// Sequential big blocks are chained: block N+1's `parent_hash` is set to
-    /// block N's computed hash.
-    #[arg(long, value_name = "NUM_BIG_BLOCKS", default_value = "1")]
-    num_big_blocks: u64,
-
-    /// Output directory for generated payloads.
-    #[arg(long, value_name = "OUTPUT_DIR")]
-    output_dir: std::path::PathBuf,
-
-    /// Query `eth_getBlockAccessListByBlockNumber` for each fetched block and persist
-    /// the flattened BAL on the stored payload.
-    #[arg(long, default_value_t = false)]
-    bal: bool,
-}
-
-impl Command {
-    /// Execute the `generate-big-block` command.
-    pub async fn execute(self, _ctx: CliContext) -> eyre::Result<()> {
-        if self.target_gas == 0 {
-            return Err(eyre::eyre!("--target-gas must be greater than 0"));
-        }
-        if self.num_big_blocks == 0 {
-            return Err(eyre::eyre!("--num-big-blocks must be at least 1"));
-        }
-
-        // Resolve chain spec for blob params lookup
-        let chain_spec = EthereumChainSpecParser::parse(&self.chain)
-            .wrap_err_with(|| format!("Failed to parse chain spec: {}", self.chain))?;
-
-        info!(
-            target: "reth-bench",
-            from_block = self.from_block,
-            target_gas = self.target_gas,
-            num_big_blocks = self.num_big_blocks,
-            include_bal = self.bal,
-            chain = %chain_spec.chain(),
-            output_dir = %self.output_dir.display(),
-            "Generating big block payloads"
-        );
-
-        // Create output directory
-        std::fs::create_dir_all(&self.output_dir).wrap_err_with(|| {
-            format!("Failed to create output directory: {:?}", self.output_dir)
-        })?;
-
-        // Set up RPC provider
-        let client = ClientBuilder::default()
-            .layer(alloy_transport::layers::RetryBackoffLayer::new(10, 800, u64::MAX))
-            .http(self.rpc_url.parse()?);
-        let provider = RootProvider::<AnyNetwork>::new(client);
-
-        let mut prev_big_block_hash: Option<B256> = None;
-        let mut accumulated_block_hashes: Vec<(u64, B256)> = Vec::new();
-
-        // Track previous big block's merged header fields for deriving basefee and
-        // excess_blob_gas on subsequent big blocks.
-        struct PrevBigBlockHeader {
-            gas_used: u64,
-            gas_limit: u64,
-            base_fee_per_gas: u64,
-            blob_gas_used: u64,
-            excess_blob_gas: u64,
-        }
-        let mut prev_big_block_header: Option<PrevBigBlockHeader> = None;
-
-        // 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;
-
-            // 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();
-            let mut accumulated_block_gas: u64 = 0;
-
-            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, "Fetching block");
-
-                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,
-                            "Block not found — reached chain tip"
-                        );
-                        reached_chain_tip = true;
-                        break;
-                    }
-                    Err(e) => return Err(e.into()),
-                };
-
-                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 =
-                    execution_data.payload.as_v3().map(|v3| v3.blob_gas_used).unwrap_or(0);
-
-                info!(
-                    target: "reth-bench",
-                    block_number,
-                    gas_used = block_gas,
-                    blob_gas_used = block_blob_gas,
-                    tx_count = execution_data.payload.transactions().len(),
-                    receipts = consensus_receipts.len(),
-                    "Fetched block"
-                );
-
-                accumulated_block_gas += block_gas;
-                blocks.push(execution_data);
-                block_receipts.push(consensus_receipts);
-                block_access_lists.push(block_access_list);
-                next_block += 1;
-            }
-
-            // If we hit the chain tip without fetching any blocks, stop generating.
-            if blocks.is_empty() {
-                warn!(
-                    target: "reth-bench",
-                    big_block = big_block_idx,
-                    requested = self.num_big_blocks,
-                    "No blocks available, stopping generation early"
-                );
-                break;
-            }
-
-            // Block 0 is the base
-            let mut base = blocks.remove(0);
-            let base_receipts = block_receipts.remove(0);
-            let mut merged_block_access_list = block_access_lists.remove(0);
-            let mut env_switches = Vec::new();
-
-            // Accumulate all receipts with corrected cumulative_gas_used.
-            // Each block's receipts have cumulative gas relative to that block;
-            // we add the prior blocks' total gas to make them globally correct.
-            let mut all_receipts: Vec<Receipt> = Vec::new();
-            let mut cumulative_gas_offset: u64 = 0;
-            {
-                // Base block receipts (block 0) — no offset needed
-                let base_block_gas = base.payload.as_v1().gas_used;
-                all_receipts.extend(base_receipts.into_iter().map(|mut r| {
-                    r.cumulative_gas_used += cumulative_gas_offset;
-                    r
-                }));
-                cumulative_gas_offset += base_block_gas;
-            }
-
-            if !blocks.is_empty() {
-                // Store the original unmutated base block as env_switch at index 0.
-                // This preserves the real gas_limit, basefee, etc. for segment 0's
-                // EVM environment, which would otherwise be lost when we mutate the
-                // base payload header below.
-                env_switches.push((0, base.clone()));
-
-                let mut cumulative_tx_count = base.payload.transactions().len();
-
-                // Collect state from the last block for header fields
-                let last = blocks.last().unwrap();
-                let last_v1 = last.payload.as_v1();
-                let final_state_root = last_v1.state_root;
-
-                let mut total_gas_used = base.payload.as_v1().gas_used;
-                let mut total_gas_limit = base.payload.as_v1().gas_limit;
-
-                // Concatenate transactions from subsequent blocks and build env_switches
-                for ((block_data, receipts), block_access_list) in
-                    blocks.into_iter().zip(block_receipts).zip(block_access_lists)
-                {
-                    let block_v1 = block_data.payload.as_v1();
-                    let block_gas = block_v1.gas_used;
-                    total_gas_used += block_gas;
-                    total_gas_limit += block_v1.gas_limit;
-
-                    if let Some(block_access_list) = block_access_list {
-                        merge_block_access_list(
-                            merged_block_access_list.get_or_insert_with(Default::default),
-                            block_access_list,
-                            cumulative_tx_count as u64,
-                        );
-                    }
-
-                    // Accumulate receipts with corrected cumulative_gas_used
-                    all_receipts.extend(receipts.into_iter().map(|mut r| {
-                        r.cumulative_gas_used += cumulative_gas_offset;
-                        r
-                    }));
-                    cumulative_gas_offset += block_gas;
-
-                    // Record environment switch at this block boundary
-                    env_switches.push((cumulative_tx_count, block_data.clone()));
-
-                    // Append this block's transactions to the base payload
-                    let txs = block_data.payload.transactions().clone();
-                    cumulative_tx_count += txs.len();
-                    base.payload.transactions_mut().extend(txs);
-                }
-
-                // Compute merged receipts_root and logs_bloom from all accumulated
-                // receipts (with globally-correct cumulative_gas_used).
-                let receipts_with_bloom: Vec<_> =
-                    all_receipts.iter().map(|r| r.with_bloom_ref()).collect();
-                let merged_receipts_root = proofs::calculate_receipt_root(&receipts_with_bloom);
-                let merged_logs_bloom =
-                    receipts_with_bloom.iter().fold(Bloom::ZERO, |bloom, r| bloom | *r.bloom_ref());
-
-                // Mutate the base payload header
-                let base_v1 = base.payload.as_v1_mut();
-                base_v1.state_root = final_state_root;
-                base_v1.gas_used = total_gas_used;
-                base_v1.gas_limit = total_gas_limit;
-                base_v1.receipts_root = merged_receipts_root;
-                base_v1.logs_bloom = merged_logs_bloom;
-            }
-
-            // Chain sequential big blocks: set parent_hash, block_number, basefee,
-            // and excess_blob_gas for sequential continuity. The engine validates
-            // each big block against its parent, so these fields must be
-            // derivable from the previous big block's merged header.
-            if let Some(prev_hash) = prev_big_block_hash {
-                base.payload.as_v1_mut().parent_hash = prev_hash;
-                // First big block keeps its original block number (from_block).
-                // Subsequent big blocks increment from there.
-                base.payload.as_v1_mut().block_number = self.from_block + big_block_idx;
-            }
-            if let Some(prev) = &prev_big_block_header {
-                // Derive basefee from the previous big block's merged header using
-                // the standard EIP-1559 formula so validate_against_parent_eip1559_base_fee passes.
-                let next_base_fee = alloy_eips::calc_next_block_base_fee(
-                    prev.gas_used,
-                    prev.gas_limit,
-                    prev.base_fee_per_gas,
-                    BaseFeeParams::ethereum(),
-                );
-                base.payload.as_v1_mut().base_fee_per_gas =
-                    alloy_primitives::U256::from(next_base_fee);
-
-                // Derive excess_blob_gas from the previous big block's merged header
-                // so validate_against_parent_4844 passes.
-                let timestamp = base.payload.as_v1().timestamp;
-                let blob_params = chain_spec
-                    .blob_params_at_timestamp(timestamp)
-                    .unwrap_or_else(BlobParams::cancun);
-                let next_excess_blob_gas = blob_params.next_block_excess_blob_gas_osaka(
-                    prev.excess_blob_gas,
-                    prev.blob_gas_used,
-                    prev.base_fee_per_gas,
-                );
-                if let Some(v3) = base.payload.as_v3_mut() {
-                    v3.excess_blob_gas = next_excess_blob_gas;
-                }
-            }
-
-            // Merge blob data from all constituent blocks: sum blob_gas_used
-            // and concatenate versioned hashes so the sidecar matches the blob
-            // transactions in the merged payload body.
-            {
-                let mut all_versioned_hashes: Vec<B256> =
-                    base.sidecar.cancun().map(|c| c.versioned_hashes.clone()).unwrap_or_default();
-                let mut total_blob_gas =
-                    base.payload.as_v3().map(|v3| v3.blob_gas_used).unwrap_or(0);
-                // Skip env_switch[0] (base block clone) to avoid double-counting
-                for (_, switch_data) in env_switches.iter().skip(1) {
-                    if let Some(cancun) = switch_data.sidecar.cancun() {
-                        all_versioned_hashes.extend_from_slice(&cancun.versioned_hashes);
-                    }
-                    if let Some(v3) = switch_data.payload.as_v3() {
-                        total_blob_gas += v3.blob_gas_used;
-                    }
-                }
-                if let Some(v3) = base.payload.as_v3_mut() {
-                    v3.blob_gas_used = total_blob_gas;
-                }
-                let cancun = base.sidecar.cancun().map(|c| CancunPayloadFields {
-                    versioned_hashes: all_versioned_hashes,
-                    parent_beacon_block_root: c.parent_beacon_block_root,
-                });
-                // For merged blocks, set an empty requests hash in the Prague sidecar.
-                // The correct requests_hash cannot be computed from RPC data alone
-                // (raw execution layer requests are not exposed via eth_getBlockByNumber).
-                // Use --testing.skip-requests-hash-check when validating big block payloads.
-                let prague = base
-                    .sidecar
-                    .prague()
-                    .map(|_| PraguePayloadFields::new(alloy_eips::eip7685::Requests::default()));
-                base.sidecar = match (cancun, prague) {
-                    (Some(c), Some(p)) => ExecutionPayloadSidecar::v4(c, p),
-                    (Some(c), None) => ExecutionPayloadSidecar::v3(c),
-                    _ => ExecutionPayloadSidecar::none(),
-                };
-            }
-
-            // Compute the real block hash from the mutated payload
-            let block_hash = compute_payload_block_hash(&base)?;
-            base.payload.as_v1_mut().block_hash = block_hash;
-            prev_big_block_hash = Some(block_hash);
-
-            // Record this big block's merged header fields so the next big block
-            // can derive its basefee and excess_blob_gas correctly.
-            {
-                let v1 = base.payload.as_v1();
-                prev_big_block_header = Some(PrevBigBlockHeader {
-                    gas_used: v1.gas_used,
-                    gas_limit: v1.gas_limit,
-                    base_fee_per_gas: v1.base_fee_per_gas.to::<u64>(),
-                    blob_gas_used: base.payload.as_v3().map(|v3| v3.blob_gas_used).unwrap_or(0),
-                    excess_blob_gas: base.payload.as_v3().map(|v3| v3.excess_blob_gas).unwrap_or(0),
-                });
-            }
-
-            let big_block = BigBlockPayload {
-                execution_data: base,
-                big_block_data: BigBlockData {
-                    env_switches,
-                    prior_block_hashes: accumulated_block_hashes.clone(),
-                },
-                block_access_list: merged_block_access_list,
-            };
-
-            // Accumulate real block hashes from this big block's env_switches for
-            // subsequent big blocks' BLOCKHASH lookups. Cap at 256 entries since the
-            // BLOCKHASH opcode only looks back 256 blocks.
-            for (_, switch_data) in &big_block.big_block_data.env_switches {
-                let block_number = switch_data.payload.as_v1().block_number;
-                let block_hash = switch_data.payload.as_v1().block_hash;
-                accumulated_block_hashes.push((block_number, block_hash));
-            }
-            if accumulated_block_hashes.len() > 256 {
-                let excess = accumulated_block_hashes.len() - 256;
-                accumulated_block_hashes.drain(..excess);
-            }
-
-            // Save to disk
-            let range_end = next_block - 1;
-            let filename = format!("big_block_{range_start}_to_{range_end}.json");
-            let filepath = self.output_dir.join(&filename);
-            let json = serde_json::to_string_pretty(&big_block)?;
-            std::fs::write(&filepath, &json)
-                .wrap_err_with(|| format!("Failed to write payload to {:?}", filepath))?;
-
-            info!(
-                target: "reth-bench",
-                path = %filepath.display(),
-                block_hash = %block_hash,
-                total_txs = big_block.execution_data.payload.transactions().len(),
-                total_gas_used = big_block.execution_data.payload.as_v1().gas_used,
-                env_switches = big_block.big_block_data.env_switches.len(),
-                prior_block_hashes = big_block.big_block_data.prior_block_hashes.len(),
-                bal_accounts = big_block.block_access_list.as_ref().map_or(0, Vec::len),
-                "Big block payload saved"
-            );
-
-            if reached_chain_tip {
-                warn!(
-                    target: "reth-bench",
-                    generated = big_block_idx + 1,
-                    requested = self.num_big_blocks,
-                    "Reached chain tip, stopping generation early"
-                );
-                break;
-            }
-        }
-
-        Ok(())
-    }
-}
-
-fn merge_block_access_list(
-    merged: &mut BlockAccessList,
-    incoming: BlockAccessList,
-    tx_index_offset: u64,
-) {
-    let mut account_positions = merged
-        .iter()
-        .enumerate()
-        .map(|(idx, account)| (account.address, idx))
-        .collect::<HashMap<_, _>>();
-
-    for mut account_changes in incoming {
-        shift_account_changes(&mut account_changes, tx_index_offset);
-
-        if let Some(&idx) = account_positions.get(&account_changes.address) {
-            merge_account_changes(&mut merged[idx], account_changes);
-        } else {
-            account_positions.insert(account_changes.address, merged.len());
-            merged.push(account_changes);
-        }
-    }
-}
-
-fn shift_account_changes(account_changes: &mut AccountChanges, tx_index_offset: u64) {
-    for slot_changes in &mut account_changes.storage_changes {
-        for change in &mut slot_changes.changes {
-            change.block_access_index += tx_index_offset;
-        }
-    }
-    for change in &mut account_changes.balance_changes {
-        change.block_access_index += tx_index_offset;
-    }
-    for change in &mut account_changes.nonce_changes {
-        change.block_access_index += tx_index_offset;
-    }
-    for change in &mut account_changes.code_changes {
-        change.block_access_index += tx_index_offset;
-    }
-}
-
-fn merge_account_changes(existing: &mut AccountChanges, incoming: AccountChanges) {
-    merge_slot_changes(&mut existing.storage_changes, incoming.storage_changes);
-    existing.storage_reads.extend(incoming.storage_reads);
-    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>) {
-    let mut slot_positions = existing
-        .iter()
-        .enumerate()
-        .map(|(idx, slot_changes)| (slot_changes.slot, idx))
-        .collect::<HashMap<_, _>>();
-
-    for slot_changes in incoming {
-        if let Some(&idx) = slot_positions.get(&slot_changes.slot) {
-            existing[idx].changes.extend(slot_changes.changes);
-        } else {
-            slot_positions.insert(slot_changes.slot, existing.len());
-            existing.push(slot_changes);
-        }
-    }
-}
-
-/// Computes the block hash for an [`ExecutionData`] by converting it to a raw block
-/// and hashing the header.
-pub fn compute_payload_block_hash(data: &ExecutionData) -> eyre::Result<B256> {
-    let block = data
-        .payload
-        .clone()
-        .into_block_with_sidecar_raw(&data.sidecar)
-        .wrap_err("failed to convert payload to block for hash computation")?;
-    Ok(block.header.hash_slow())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use alloy_eips::eip7928::{BalanceChange, CodeChange, NonceChange, StorageChange};
-    use alloy_primitives::{Address, U256};
-
-    #[test]
-    fn merge_block_access_list_offsets_and_merges_accounts() {
-        let shared = Address::repeat_byte(0x11);
-        let other = Address::repeat_byte(0x22);
-
-        let mut merged = vec![AccountChanges {
-            address: shared,
-            storage_changes: vec![SlotChanges::new(
-                U256::from(1),
-                vec![StorageChange::new(0, U256::from(10))],
-            )],
-            storage_reads: vec![U256::from(3)],
-            balance_changes: vec![BalanceChange::new(1, U256::from(100))],
-            nonce_changes: vec![NonceChange::new(2, 7)],
-            code_changes: vec![],
-        }];
-
-        let incoming = vec![
-            AccountChanges {
-                address: shared,
-                storage_changes: vec![
-                    SlotChanges::new(U256::from(1), vec![StorageChange::new(1, U256::from(20))]),
-                    SlotChanges::new(U256::from(2), vec![StorageChange::new(2, U256::from(30))]),
-                ],
-                storage_reads: vec![U256::from(4)],
-                balance_changes: vec![BalanceChange::new(0, U256::from(150))],
-                nonce_changes: vec![NonceChange::new(2, 8)],
-                code_changes: vec![CodeChange::new(1, Bytes::from_static(&[0xaa]))],
-            },
-            AccountChanges {
-                address: other,
-                storage_changes: vec![SlotChanges::new(
-                    U256::from(9),
-                    vec![StorageChange::new(0, U256::from(90))],
-                )],
-                storage_reads: vec![],
-                balance_changes: vec![],
-                nonce_changes: vec![],
-                code_changes: vec![],
-            },
-        ];
-
-        merge_block_access_list(&mut merged, incoming, 3);
-
-        assert_eq!(merged.len(), 2);
-
-        let shared = &merged[0];
-        assert_eq!(shared.storage_reads, vec![U256::from(3), U256::from(4)]);
-        assert_eq!(
-            shared
-                .balance_changes
-                .iter()
-                .map(|change| change.block_access_index)
-                .collect::<Vec<_>>(),
-            vec![1, 3]
-        );
-        assert_eq!(
-            shared.nonce_changes.iter().map(|change| change.block_access_index).collect::<Vec<_>>(),
-            vec![2, 5]
-        );
-        assert_eq!(shared.code_changes[0].block_access_index, 4);
-
-        let slot_one = shared
-            .storage_changes
-            .iter()
-            .find(|slot_changes| slot_changes.slot == U256::from(1))
-            .unwrap();
-        assert_eq!(
-            slot_one.changes.iter().map(|change| change.block_access_index).collect::<Vec<_>>(),
-            vec![0, 4]
-        );
-
-        let slot_two = shared
-            .storage_changes
-            .iter()
-            .find(|slot_changes| slot_changes.slot == U256::from(2))
-            .unwrap();
-        assert_eq!(slot_two.changes[0].block_access_index, 5);
-
-        let other = &merged[1];
-        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)
-        }));
-    }
-}
diff --git a/bin/reth-bench/src/bench/helpers.rs b/bin/reth-bench/src/bench/helpers.rs
deleted file mode 100644
index 582577a459a..00000000000
--- a/bin/reth-bench/src/bench/helpers.rs
+++ /dev/null
@@ -1,154 +0,0 @@
-//! Common helpers for reth-bench commands.
-
-use alloy_eips::{eip7928::BlockAccessList, BlockNumberOrTag};
-use alloy_provider::{network::AnyNetwork, Provider, RootProvider};
-use eyre::Result;
-use std::{
-    io::{BufReader, Read},
-    time::Duration,
-};
-
-/// Read input from either a file path or stdin.
-pub(crate) fn read_input(path: Option<&str>) -> Result<String> {
-    Ok(match path {
-        Some(path) => reth_fs_util::read_to_string(path)?,
-        None => String::from_utf8(
-            BufReader::new(std::io::stdin()).bytes().collect::<Result<Vec<_>, _>>()?,
-        )?,
-    })
-}
-
-/// Load JWT secret from either a file or use the provided string directly.
-pub(crate) fn load_jwt_secret(jwt_secret: Option<&str>) -> Result<Option<String>> {
-    match jwt_secret {
-        Some(secret) => {
-            // Try to read as file first
-            match std::fs::read_to_string(secret) {
-                Ok(contents) => Ok(Some(contents.trim().to_string())),
-                // If file read fails, use the string directly
-                Err(_) => Ok(Some(secret.to_string())),
-            }
-        }
-        None => Ok(None),
-    }
-}
-
-/// Parses a gas limit value with optional suffix: K for thousand, M for million, G for billion.
-///
-/// Examples: "30000000", "30M", "1G", "2G"
-pub(crate) fn parse_gas_limit(s: &str) -> eyre::Result<u64> {
-    let s = s.trim();
-    if s.is_empty() {
-        return Err(eyre::eyre!("empty value"));
-    }
-
-    let (num_str, multiplier) = if let Some(prefix) = s.strip_suffix(['G', 'g']) {
-        (prefix, 1_000_000_000u64)
-    } else if let Some(prefix) = s.strip_suffix(['M', 'm']) {
-        (prefix, 1_000_000u64)
-    } else if let Some(prefix) = s.strip_suffix(['K', 'k']) {
-        (prefix, 1_000u64)
-    } else {
-        (s, 1u64)
-    };
-
-    let base: u64 = num_str.trim().parse()?;
-    base.checked_mul(multiplier).ok_or_else(|| eyre::eyre!("value overflow"))
-}
-
-/// Parses a duration string, treating bare integers as milliseconds.
-///
-/// Accepts either a `humantime` duration string (e.g. `"100ms"`, `"2s"`) or a plain
-/// integer which is interpreted as milliseconds (e.g. `"400"` → 400ms).
-pub(crate) fn parse_duration(s: &str) -> eyre::Result<Duration> {
-    match humantime::parse_duration(s) {
-        Ok(d) => Ok(d),
-        Err(_) => {
-            let millis: u64 =
-                s.trim().parse().map_err(|_| eyre::eyre!("invalid duration: {s:?}"))?;
-            Ok(Duration::from_millis(millis))
-        }
-    }
-}
-
-/// Fetches the block access list for a given block number using the provided provider.
-pub(crate) async fn fetch_block_access_list(
-    provider: &RootProvider<AnyNetwork>,
-    block_number: u64,
-) -> eyre::Result<BlockAccessList> {
-    provider
-        .client()
-        .request("eth_getBlockAccessListByBlockNumber", (BlockNumberOrTag::Number(block_number),))
-        .await
-        .map_err(Into::into)
-        .and_then(|block_access_list: Option<BlockAccessList>| {
-            block_access_list.ok_or_else(|| eyre::eyre!("BAL not found for block {block_number}"))
-        })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_gas_limit_plain_number() {
-        assert_eq!(parse_gas_limit("30000000").unwrap(), 30_000_000);
-        assert_eq!(parse_gas_limit("1").unwrap(), 1);
-        assert_eq!(parse_gas_limit("0").unwrap(), 0);
-    }
-
-    #[test]
-    fn test_parse_gas_limit_k_suffix() {
-        assert_eq!(parse_gas_limit("1K").unwrap(), 1_000);
-        assert_eq!(parse_gas_limit("30k").unwrap(), 30_000);
-        assert_eq!(parse_gas_limit("100K").unwrap(), 100_000);
-    }
-
-    #[test]
-    fn test_parse_gas_limit_m_suffix() {
-        assert_eq!(parse_gas_limit("1M").unwrap(), 1_000_000);
-        assert_eq!(parse_gas_limit("30m").unwrap(), 30_000_000);
-        assert_eq!(parse_gas_limit("100M").unwrap(), 100_000_000);
-    }
-
-    #[test]
-    fn test_parse_gas_limit_g_suffix() {
-        assert_eq!(parse_gas_limit("1G").unwrap(), 1_000_000_000);
-        assert_eq!(parse_gas_limit("2g").unwrap(), 2_000_000_000);
-        assert_eq!(parse_gas_limit("10G").unwrap(), 10_000_000_000);
-    }
-
-    #[test]
-    fn test_parse_gas_limit_with_whitespace() {
-        assert_eq!(parse_gas_limit(" 1G ").unwrap(), 1_000_000_000);
-        assert_eq!(parse_gas_limit("2 M").unwrap(), 2_000_000);
-    }
-
-    #[test]
-    fn test_parse_gas_limit_errors() {
-        assert!(parse_gas_limit("").is_err());
-        assert!(parse_gas_limit("abc").is_err());
-        assert!(parse_gas_limit("G").is_err());
-        assert!(parse_gas_limit("-1G").is_err());
-    }
-
-    #[test]
-    fn test_parse_duration_with_unit() {
-        assert_eq!(parse_duration("100ms").unwrap(), Duration::from_millis(100));
-        assert_eq!(parse_duration("2s").unwrap(), Duration::from_secs(2));
-        assert_eq!(parse_duration("1m").unwrap(), Duration::from_secs(60));
-    }
-
-    #[test]
-    fn test_parse_duration_bare_millis() {
-        assert_eq!(parse_duration("400").unwrap(), Duration::from_millis(400));
-        assert_eq!(parse_duration("0").unwrap(), Duration::from_millis(0));
-        assert_eq!(parse_duration("1000").unwrap(), Duration::from_millis(1000));
-    }
-
-    #[test]
-    fn test_parse_duration_errors() {
-        assert!(parse_duration("abc").is_err());
-        assert!(parse_duration("").is_err());
-    }
-}
diff --git a/bin/reth-bench/src/bench/metrics_scraper.rs b/bin/reth-bench/src/bench/metrics_scraper.rs
deleted file mode 100644
index 3228df7a345..00000000000
--- a/bin/reth-bench/src/bench/metrics_scraper.rs
+++ /dev/null
@@ -1,156 +0,0 @@
-//! Prometheus metrics scraper for reth-bench.
-//!
-//! Scrapes a node's Prometheus metrics endpoint after each block to record
-//! execution and state root durations with block-level granularity.
-
-use csv::Writer;
-use eyre::Context;
-use reqwest::Client;
-use serde::Serialize;
-use std::{path::Path, time::Duration};
-use tracing::info;
-
-/// Suffix for the metrics CSV output file.
-pub(crate) const METRICS_OUTPUT_SUFFIX: &str = "metrics.csv";
-
-/// A single row of scraped prometheus metrics for one block.
-#[derive(Debug, Clone, Serialize)]
-pub(crate) struct MetricsRow {
-    /// The block number.
-    pub(crate) block_number: u64,
-    /// EVM execution duration in seconds (from `sync_execution_execution_duration` gauge).
-    pub(crate) execution_duration_secs: Option<f64>,
-    /// State root computation duration in seconds (from
-    /// `sync_block_validation_state_root_duration` gauge).
-    pub(crate) state_root_duration_secs: Option<f64>,
-}
-
-/// Scrapes a Prometheus metrics endpoint after each block to collect
-/// execution and state root durations.
-pub(crate) struct MetricsScraper {
-    /// The full URL of the Prometheus metrics endpoint.
-    url: String,
-    /// Reusable HTTP client.
-    client: Client,
-    /// Collected metrics rows, one per block.
-    rows: Vec<MetricsRow>,
-}
-
-impl MetricsScraper {
-    /// Creates a new scraper if a URL is provided.
-    pub(crate) fn maybe_new(url: Option<String>) -> Option<Self> {
-        url.map(|url| {
-            info!(target: "reth-bench", %url, "Prometheus metrics scraping enabled");
-            let client = Client::builder()
-                .timeout(Duration::from_secs(5))
-                .build()
-                .expect("failed to build reqwest client");
-            Self { url, client, rows: Vec::new() }
-        })
-    }
-
-    /// Scrapes the metrics endpoint and records values for the given block.
-    pub(crate) async fn scrape_after_block(&mut self, block_number: u64) -> eyre::Result<()> {
-        let text = self
-            .client
-            .get(&self.url)
-            .send()
-            .await
-            .wrap_err("failed to fetch metrics endpoint")?
-            .error_for_status()
-            .wrap_err("metrics endpoint returned error status")?
-            .text()
-            .await
-            .wrap_err("failed to read metrics response body")?;
-
-        let execution = parse_gauge(&text, "sync_execution_execution_duration");
-        let state_root = parse_gauge(&text, "sync_block_validation_state_root_duration");
-
-        self.rows.push(MetricsRow {
-            block_number,
-            execution_duration_secs: execution,
-            state_root_duration_secs: state_root,
-        });
-        Ok(())
-    }
-
-    /// Writes collected metrics to a CSV file in the output directory.
-    pub(crate) fn write_csv(&self, output_dir: &Path) -> eyre::Result<()> {
-        let path = output_dir.join(METRICS_OUTPUT_SUFFIX);
-        info!(target: "reth-bench", "Writing scraped metrics to file: {:?}", path);
-        let mut writer = Writer::from_path(&path)?;
-        for row in &self.rows {
-            writer.serialize(row)?;
-        }
-        writer.flush()?;
-        Ok(())
-    }
-}
-
-/// Parses a Prometheus gauge value from exposition-format text.
-///
-/// Searches for lines starting with `name` followed by either a space or `{`
-/// (for labeled metrics), then parses the numeric value. Returns the last
-/// matching sample to handle metrics emitted with multiple label sets.
-fn parse_gauge(text: &str, name: &str) -> Option<f64> {
-    let mut result = None;
-    for line in text.lines() {
-        let line = line.trim();
-        if line.is_empty() || line.starts_with('#') {
-            continue;
-        }
-
-        if !line.starts_with(name) {
-            continue;
-        }
-
-        // Ensure we match the full metric name, not a prefix of another metric.
-        let rest = &line[name.len()..];
-        if !rest.starts_with(' ') && !rest.starts_with('{') {
-            continue;
-        }
-
-        // Format: `metric_name{labels} value [timestamp]` or `metric_name value [timestamp]`
-        // Value is always the second whitespace-separated token.
-        let mut parts = line.split_whitespace();
-        if let Some(value_str) = parts.nth(1) &&
-            let Ok(v) = value_str.parse::<f64>()
-        {
-            result = Some(v);
-        }
-    }
-    result
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_gauge_simple() {
-        let text = r#"# HELP sync_execution_execution_duration Duration of execution
-# TYPE sync_execution_execution_duration gauge
-sync_execution_execution_duration 0.123456
-"#;
-        assert_eq!(parse_gauge(text, "sync_execution_execution_duration"), Some(0.123456));
-    }
-
-    #[test]
-    fn test_parse_gauge_missing() {
-        let text = "some_other_metric 1.0\n";
-        assert_eq!(parse_gauge(text, "sync_execution_execution_duration"), None);
-    }
-
-    #[test]
-    fn test_parse_gauge_with_labels() {
-        let text = "sync_block_validation_state_root_duration{instance=\"node1\"} 0.5\n";
-        assert_eq!(parse_gauge(text, "sync_block_validation_state_root_duration"), Some(0.5));
-    }
-
-    #[test]
-    fn test_parse_gauge_prefix_no_false_match() {
-        let text =
-            "sync_execution_execution_duration_total 99.0\nsync_execution_execution_duration 0.5\n";
-        assert_eq!(parse_gauge(text, "sync_execution_execution_duration"), Some(0.5));
-    }
-}
diff --git a/bin/reth-bench/src/bench/mod.rs b/bin/reth-bench/src/bench/mod.rs
deleted file mode 100644
index 79e21d5fca9..00000000000
--- a/bin/reth-bench/src/bench/mod.rs
+++ /dev/null
@@ -1,125 +0,0 @@
-//! `reth benchmark` command. Collection of various benchmarking routines.
-
-use clap::{Parser, Subcommand};
-use reth_cli_runner::CliContext;
-use reth_node_core::args::LogArgs;
-use reth_tracing::FileWorkerGuard;
-
-mod context;
-mod generate_big_block;
-pub(crate) mod helpers;
-pub use generate_big_block::{
-    compute_payload_block_hash, BigBlockPayload, RawTransaction, RpcTransactionSource,
-    TransactionCollector, TransactionSource,
-};
-pub(crate) mod metrics_scraper;
-mod new_payload_fcu;
-mod new_payload_only;
-mod output;
-mod replay_payloads;
-mod send_invalid_payload;
-mod send_payload;
-
-/// `reth bench` command
-#[derive(Debug, Parser)]
-pub struct BenchmarkCommand {
-    #[command(subcommand)]
-    command: Subcommands,
-
-    #[command(flatten)]
-    logs: LogArgs,
-}
-
-/// `reth benchmark` subcommands
-#[derive(Subcommand, Debug)]
-pub enum Subcommands {
-    /// Benchmark which calls `newPayload`, then `forkchoiceUpdated`.
-    NewPayloadFcu(new_payload_fcu::Command),
-
-    /// Benchmark which only calls subsequent `newPayload` calls.
-    NewPayloadOnly(new_payload_only::Command),
-
-    /// Command for generating and sending an `engine_newPayload` request constructed from an RPC
-    /// block.
-    ///
-    /// This command takes a JSON block input (either from a file or stdin) and generates
-    /// an execution payload that can be used with the `engine_newPayloadV*` API.
-    ///
-    /// One powerful use case is pairing this command with the `cast block` command, for example:
-    ///
-    /// `cast block latest --full --json | reth-bench send-payload --rpc-url localhost:5000
-    /// --jwt-secret $(cat ~/.local/share/reth/mainnet/jwt.hex)`
-    SendPayload(send_payload::Command),
-
-    /// Generate a large block by merging consecutive blocks from an RPC.
-    ///
-    /// Fetches N consecutive blocks, takes block 0 as the base payload, concatenates
-    /// transactions from blocks 1..N-1, and saves the result to disk as a JSON file
-    /// containing the merged execution data and environment switches at block boundaries.
-    ///
-    /// Example:
-    ///
-    /// `reth-bench generate-big-block --rpc-url http://localhost:8545 --from-block 20000000
-    /// --count 10 --output-dir ./payloads`
-    GenerateBigBlock(generate_big_block::Command),
-
-    /// Replay pre-generated payloads from a directory.
-    ///
-    /// This command reads payload files from a previous `generate-big-block` run and replays
-    /// them in sequence using `newPayload` followed by `forkchoiceUpdated`.
-    ///
-    /// Example:
-    ///
-    /// `reth-bench replay-payloads --payload-dir ./payloads --engine-rpc-url
-    /// http://localhost:8551 --jwt-secret ~/.local/share/reth/mainnet/jwt.hex`
-    ReplayPayloads(replay_payloads::Command),
-
-    /// Generate and send an invalid `engine_newPayload` request for testing.
-    ///
-    /// Takes a valid block and modifies fields to make it invalid, allowing you to test
-    /// Engine API rejection behavior. Block hash is recalculated after modifications
-    /// unless `--invalid-block-hash` or `--skip-hash-recalc` is used.
-    ///
-    /// Example:
-    ///
-    /// `cast block latest --full --json | reth-bench send-invalid-payload --rpc-url localhost:5000
-    /// --jwt-secret $(cat ~/.local/share/reth/mainnet/jwt.hex) --invalid-state-root`
-    SendInvalidPayload(Box<send_invalid_payload::Command>),
-}
-
-impl BenchmarkCommand {
-    /// Execute `benchmark` command
-    pub async fn execute(self, ctx: CliContext) -> eyre::Result<()> {
-        // Initialize tracing
-        let _guard = self.init_tracing()?;
-
-        match self.command {
-            Subcommands::NewPayloadFcu(command) => command.execute(ctx).await,
-            Subcommands::NewPayloadOnly(command) => command.execute(ctx).await,
-            Subcommands::SendPayload(command) => command.execute(ctx).await,
-            Subcommands::GenerateBigBlock(command) => command.execute(ctx).await,
-            Subcommands::ReplayPayloads(command) => command.execute(ctx).await,
-            Subcommands::SendInvalidPayload(command) => (*command).execute(ctx).await,
-        }
-    }
-
-    /// Initializes tracing with the configured options.
-    ///
-    /// If file logging is enabled, this function returns a guard that must be kept alive to ensure
-    /// that all logs are flushed to disk.
-    ///
-    /// Always enables log target display (`RUST_LOG_TARGET=1`) so that the `reth-bench` target
-    /// is visible in output, making it easy to distinguish reth-bench logs from reth logs when
-    /// both are streamed to the same console or file.
-    pub fn init_tracing(&self) -> eyre::Result<Option<FileWorkerGuard>> {
-        // Always show the log target so "reth-bench" is visible in the output.
-        if std::env::var_os("RUST_LOG_TARGET").is_none() {
-            // SAFETY: This is called early during single-threaded initialization, before any
-            // threads are spawned and before the tracing subscriber is set up.
-            unsafe { std::env::set_var("RUST_LOG_TARGET", "1") };
-        }
-
-        let guard = self.logs.init_tracing()?;
-        Ok(guard)
-    }
-}
diff --git a/bin/reth-bench/src/bench/new_payload_fcu.rs b/bin/reth-bench/src/bench/new_payload_fcu.rs
deleted file mode 100644
index a3de7c4f1f5..00000000000
--- a/bin/reth-bench/src/bench/new_payload_fcu.rs
+++ /dev/null
@@ -1,640 +0,0 @@
-//! Runs the `reth bench` command, calling first newPayload for each block, then calling
-//! forkchoiceUpdated.
-
-use crate::{
-    bench::{
-        context::BenchContext,
-        helpers::{fetch_block_access_list, parse_duration},
-        metrics_scraper::MetricsScraper,
-        output::{
-            write_benchmark_results, CombinedResult, NewPayloadResult, TotalGasOutput, TotalGasRow,
-        },
-    },
-    valid_payload::{
-        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 clap::Parser;
-use eyre::{bail, ensure, 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};
-
-/// `reth benchmark new-payload-fcu` command
-#[derive(Debug, Parser)]
-pub struct Command {
-    /// The RPC url to use for getting data.
-    #[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
-    /// milliseconds (e.g. `400`).
-    #[arg(long, value_name = "WAIT_TIME", value_parser = parse_duration, verbatim_doc_comment)]
-    wait_time: Option<Duration>,
-
-    /// Engine persistence threshold used for deciding when to wait for persistence.
-    ///
-    /// The benchmark waits after every `(threshold + 1)` blocks. By default this
-    /// matches the engine's `DEFAULT_PERSISTENCE_THRESHOLD` (2), so waits occur
-    /// at blocks 3, 6, 9, etc.
-    #[arg(
-        long = "persistence-threshold",
-        value_name = "PERSISTENCE_THRESHOLD",
-        default_value_t = DEFAULT_PERSISTENCE_THRESHOLD,
-        verbatim_doc_comment
-    )]
-    persistence_threshold: u64,
-
-    /// Timeout for waiting on persistence at each checkpoint.
-    ///
-    /// Must be long enough to account for the persistence thread being blocked
-    /// by pruning after the previous save.
-    #[arg(
-        long = "persistence-timeout",
-        value_name = "PERSISTENCE_TIMEOUT",
-        value_parser = parse_duration,
-        default_value = "120s",
-        verbatim_doc_comment
-    )]
-    persistence_timeout: Duration,
-
-    /// The size of the block buffer (channel capacity) for prefetching blocks from the RPC
-    /// endpoint.
-    #[arg(
-        long = "rpc-block-buffer-size",
-        value_name = "RPC_BLOCK_BUFFER_SIZE",
-        default_value = "20",
-        verbatim_doc_comment
-    )]
-    rpc_block_buffer_size: usize,
-
-    /// Weather to enable bal by default or not.
-    #[arg(long, default_value = "false", verbatim_doc_comment)]
-    enable_bal: bool,
-
-    #[command(flatten)]
-    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,
-            wait_for_persistence,
-            no_wait_for_caches,
-        } = BenchContext::new(&self.benchmark, self.rpc_url).await?;
-
-        let total_blocks = benchmark_mode.total_blocks();
-
-        let mut metrics_scraper = MetricsScraper::maybe_new(self.benchmark.metrics_url.clone());
-
-        if use_reth_namespace {
-            info!("Using reth_newPayload and reth_forkchoiceUpdated endpoints");
-        }
-
-        let buffer_size = self.rpc_block_buffer_size;
-
-        let mut blocks = Box::pin(
-            stream::iter((next_block..)
-                .take_while(|next_block| {
-                    benchmark_mode.contains(*next_block)
-                }))
-                .map(|next_block| {
-                    let block_provider = block_provider.clone();
-                    async move {
-                        let block_res = block_provider
-                            .get_block_by_number(next_block.into())
-                            .full()
-                            .await
-                            .wrap_err_with(|| {
-                                format!("Failed to fetch block by number {next_block}")
-                            });
-                        let block =
-                            match block_res.and_then(|opt| opt.ok_or_eyre("Block not found")) {
-                                Ok(block) => block,
-                                Err(e) => {
-                                    tracing::error!(target: "reth-bench", "Failed to fetch block {next_block}: {e}");
-                                    return Err(e)
-                                }
-                            };
-
-                        let rlp = if rlp_blocks {
-                            let rlp = match block_provider
-                                .debug_get_raw_block(next_block.into())
-                                .await
-                            {
-                                Ok(rlp) => rlp,
-                                Err(e) => {
-                                    tracing::error!(target: "reth-bench", "Failed to fetch raw block {next_block}: {e}");
-                                    return Err(e.into())
-                                }
-                            };
-                            Some(rlp)
-                        } else {
-                            None
-                        };
-
-                        let head_block_hash = block.header.hash;
-                        let safe_block_hash = block_provider
-                            .get_block_by_number(block.header.number.saturating_sub(32).into());
-
-                        let finalized_block_hash = block_provider
-                            .get_block_by_number(block.header.number.saturating_sub(64).into());
-
-                        let (safe, finalized) =
-                            tokio::join!(safe_block_hash, finalized_block_hash);
-
-                        let safe_block_hash = match safe {
-                            Ok(Some(block)) => block.header.hash,
-                            Ok(None) | Err(_) => head_block_hash,
-                        };
-
-                        let finalized_block_hash = match finalized {
-                            Ok(Some(block)) => block.header.hash,
-                            Ok(None) | Err(_) => head_block_hash,
-                        };
-
-                        Ok((block, head_block_hash, safe_block_hash, finalized_block_hash, rlp))
-                    }
-                })
-                .buffered(buffer_size),
-        );
-
-        let mut results = Vec::new();
-        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?;
-            total_wait_time += wait_start.elapsed();
-            result
-        } {
-            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 {
-                head_block_hash: head,
-                safe_block_hash: safe,
-                finalized_block_hash: finalized,
-            };
-
-            let bal = if rlp.is_none() &&
-                (block.header.block_access_list_hash.is_some() || self.enable_bal)
-            {
-                Some(fetch_block_access_list(&block_provider, block.header.number).await?)
-            } else {
-                None
-            };
-
-            let (version, params) = block_to_new_payload(
-                block,
-                rlp,
-                use_reth_namespace,
-                wait_for_persistence,
-                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 {
-                gas_used,
-                latency: np_latency,
-                persistence_wait: server_timings
-                    .as_ref()
-                    .map(|t| t.persistence_wait)
-                    .unwrap_or_default(),
-                execution_cache_wait: server_timings
-                    .as_ref()
-                    .map(|t| t.execution_cache_wait)
-                    .unwrap_or_default(),
-                sparse_trie_wait: server_timings
-                    .as_ref()
-                    .map(|t| t.sparse_trie_wait)
-                    .unwrap_or_default(),
-            };
-
-            let fcu_start = Instant::now();
-            call_forkchoice_updated_with_reth(&auth_provider, version, canonical_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 combined_result = CombinedResult {
-                block_number,
-                gas_limit,
-                transaction_count,
-                new_payload_result,
-                fcu_latency,
-                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;
-            let current_duration = total_benchmark_duration.elapsed() - total_wait_time;
-            let progress = match total_blocks {
-                Some(total) => format!("{blocks_processed}/{total}"),
-                None => format!("{blocks_processed}"),
-            };
-            info!(target: "reth-bench", progress, %combined_result);
-
-            if let Some(scraper) = metrics_scraper.as_mut() &&
-                let Err(err) = scraper.scrape_after_block(block_number).await
-            {
-                warn!(target: "reth-bench", %err, block_number, "Failed to scrape metrics");
-            }
-
-            if let Some(wait_time) = self.wait_time {
-                let remaining = wait_time.saturating_sub(start.elapsed());
-                if !remaining.is_zero() {
-                    tokio::time::sleep(remaining).await;
-                }
-            }
-
-            let gas_row =
-                TotalGasRow { block_number, transaction_count, gas_used, time: current_duration };
-            results.push((gas_row, combined_result));
-        }
-
-        let (gas_output_results, combined_results): (Vec<TotalGasRow>, Vec<CombinedResult>) =
-            results.into_iter().unzip();
-
-        if let Some(ref path) = self.benchmark.output {
-            write_benchmark_results(path, &gas_output_results, &combined_results)?;
-        }
-
-        if let (Some(path), Some(scraper)) = (&self.benchmark.output, &metrics_scraper) {
-            scraper.write_csv(path)?;
-        }
-
-        let gas_output =
-            TotalGasOutput::with_combined_results(gas_output_results, &combined_results)?;
-
-        info!(
-            target: "reth-bench",
-            total_gas_used = gas_output.total_gas_used,
-            total_duration = ?gas_output.total_duration,
-            execution_duration = ?gas_output.execution_duration,
-            blocks_processed = gas_output.blocks_processed,
-            wall_clock_ggas_per_second = format_args!("{:.4}", gas_output.total_gigagas_per_second()),
-            execution_ggas_per_second = format_args!("{:.4}", gas_output.execution_gigagas_per_second()),
-            "Benchmark complete"
-        );
-
-        Ok(())
-    }
-}
-
-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)
-}
diff --git a/bin/reth-bench/src/bench/new_payload_only.rs b/bin/reth-bench/src/bench/new_payload_only.rs
deleted file mode 100644
index d315fbfdabf..00000000000
--- a/bin/reth-bench/src/bench/new_payload_only.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-//! Runs the `reth bench` command, sending only newPayload, without a forkchoiceUpdated call.
-
-use crate::{
-    bench::{
-        context::BenchContext,
-        helpers::fetch_block_access_list,
-        metrics_scraper::MetricsScraper,
-        output::{
-            NewPayloadResult, TotalGasOutput, TotalGasRow, GAS_OUTPUT_SUFFIX,
-            NEW_PAYLOAD_OUTPUT_SUFFIX,
-        },
-    },
-    valid_payload::{block_to_new_payload, call_new_payload_with_reth},
-};
-use alloy_provider::{ext::DebugApi, Provider};
-use clap::Parser;
-use csv::Writer;
-use eyre::{Context, OptionExt};
-use reth_cli_runner::CliContext;
-use reth_node_core::args::BenchmarkArgs;
-use std::time::{Duration, Instant};
-use tracing::{debug, info};
-
-/// `reth benchmark new-payload-only` command
-#[derive(Debug, Parser)]
-pub struct Command {
-    /// The RPC url to use for getting data.
-    #[arg(long, value_name = "RPC_URL", verbatim_doc_comment)]
-    rpc_url: String,
-
-    /// The size of the block buffer (channel capacity) for prefetching blocks from the RPC
-    /// endpoint.
-    #[arg(
-        long = "rpc-block-buffer-size",
-        value_name = "RPC_BLOCK_BUFFER_SIZE",
-        default_value = "20",
-        verbatim_doc_comment
-    )]
-    rpc_block_buffer_size: usize,
-
-    #[command(flatten)]
-    benchmark: BenchmarkArgs,
-}
-
-impl Command {
-    /// Execute `benchmark new-payload-only` command
-    pub async fn execute(self, _ctx: CliContext) -> eyre::Result<()> {
-        let BenchContext {
-            benchmark_mode,
-            block_provider,
-            auth_provider,
-            mut next_block,
-            use_reth_namespace,
-            rlp_blocks,
-            wait_for_persistence,
-            no_wait_for_caches,
-            ..
-        } = BenchContext::new(&self.benchmark, self.rpc_url).await?;
-
-        let total_blocks = benchmark_mode.total_blocks();
-
-        let mut metrics_scraper = MetricsScraper::maybe_new(self.benchmark.metrics_url.clone());
-
-        if use_reth_namespace {
-            info!("Using reth_newPayload endpoint");
-        }
-
-        let buffer_size = self.rpc_block_buffer_size;
-
-        // Use a oneshot channel to propagate errors from the spawned task
-        let (error_sender, mut error_receiver) = tokio::sync::oneshot::channel();
-        let (sender, mut receiver) = tokio::sync::mpsc::channel(buffer_size);
-
-        let block_provider_clone = block_provider.clone();
-        tokio::task::spawn(async move {
-            let block_provider = block_provider_clone;
-            while benchmark_mode.contains(next_block) {
-                let block_res = block_provider
-                    .get_block_by_number(next_block.into())
-                    .full()
-                    .await
-                    .wrap_err_with(|| format!("Failed to fetch block by number {next_block}"));
-                let block = match block_res.and_then(|opt| opt.ok_or_eyre("Block not found")) {
-                    Ok(block) => block,
-                    Err(e) => {
-                        tracing::error!(target: "reth-bench", "Failed to fetch block {next_block}: {e}");
-                        let _ = error_sender.send(e);
-                        break;
-                    }
-                };
-
-                let rlp = if rlp_blocks {
-                    let Ok(rlp) = block_provider.debug_get_raw_block(next_block.into()).await
-                    else {
-                        tracing::error!(target: "reth-bench", "Failed to fetch raw block {next_block}");
-                        let _ = error_sender
-                            .send(eyre::eyre!("Failed to fetch raw block {next_block}"));
-                        break;
-                    };
-                    Some(rlp)
-                } else {
-                    None
-                };
-
-                next_block += 1;
-                if let Err(e) = sender.send((block, rlp)).await {
-                    tracing::error!(target: "reth-bench", "Failed to send block data: {e}");
-                    break;
-                }
-            }
-        });
-
-        let mut results = Vec::new();
-        let mut blocks_processed = 0u64;
-        let total_benchmark_duration = Instant::now();
-        let mut total_wait_time = Duration::ZERO;
-
-        while let Some((block, rlp)) = {
-            let wait_start = Instant::now();
-            let result = receiver.recv().await;
-            total_wait_time += wait_start.elapsed();
-            result
-        } {
-            let block_number = block.header.number;
-            let transaction_count = block.transactions.len() as u64;
-            let gas_used = block.header.gas_used;
-
-            debug!(target: "reth-bench", number=?block.header.number, "Sending payload to engine");
-
-            let bal = if rlp.is_none() && block.header.block_access_list_hash.is_some() {
-                Some(fetch_block_access_list(&block_provider, block.header.number).await?)
-            } else {
-                None
-            };
-
-            let (version, params) = block_to_new_payload(
-                block,
-                rlp,
-                use_reth_namespace,
-                wait_for_persistence,
-                no_wait_for_caches,
-                bal,
-            )?;
-
-            let start = Instant::now();
-            let server_timings =
-                call_new_payload_with_reth(&auth_provider, version, params).await?;
-
-            let latency =
-                server_timings.as_ref().map(|t| t.latency).unwrap_or_else(|| start.elapsed());
-            let new_payload_result = NewPayloadResult {
-                gas_used,
-                latency,
-                persistence_wait: server_timings
-                    .as_ref()
-                    .map(|t| t.persistence_wait)
-                    .unwrap_or_default(),
-                execution_cache_wait: server_timings
-                    .as_ref()
-                    .map(|t| t.execution_cache_wait)
-                    .unwrap_or_default(),
-                sparse_trie_wait: server_timings
-                    .as_ref()
-                    .map(|t| t.sparse_trie_wait)
-                    .unwrap_or_default(),
-            };
-            blocks_processed += 1;
-            let progress = match total_blocks {
-                Some(total) => format!("{blocks_processed}/{total}"),
-                None => format!("{blocks_processed}"),
-            };
-            info!(target: "reth-bench", progress, %new_payload_result);
-
-            // current duration since the start of the benchmark minus the time
-            // waiting for blocks
-            let current_duration = total_benchmark_duration.elapsed() - total_wait_time;
-
-            // record the current result
-            let row =
-                TotalGasRow { block_number, transaction_count, gas_used, time: current_duration };
-            results.push((row, new_payload_result));
-
-            if let Some(scraper) = metrics_scraper.as_mut() &&
-                let Err(err) = scraper.scrape_after_block(block_number).await
-            {
-                tracing::warn!(target: "reth-bench", %err, block_number, "Failed to scrape metrics");
-            }
-        }
-
-        // Check if the spawned task encountered an error
-        if let Ok(error) = error_receiver.try_recv() {
-            return Err(error);
-        }
-
-        let (gas_output_results, new_payload_results): (_, Vec<NewPayloadResult>) =
-            results.into_iter().unzip();
-
-        // write the csv output to files
-        if let Some(path) = self.benchmark.output {
-            // first write the new payload results to a file
-            let output_path = path.join(NEW_PAYLOAD_OUTPUT_SUFFIX);
-            info!(target: "reth-bench", "Writing newPayload call latency output to file: {:?}", output_path);
-            let mut writer = Writer::from_path(output_path)?;
-            for result in new_payload_results {
-                writer.serialize(result)?;
-            }
-            writer.flush()?;
-
-            // now write the gas output to a file
-            let output_path = path.join(GAS_OUTPUT_SUFFIX);
-            info!(target: "reth-bench", "Writing total gas output to file: {:?}", output_path);
-            let mut writer = Writer::from_path(output_path)?;
-            for row in &gas_output_results {
-                writer.serialize(row)?;
-            }
-            writer.flush()?;
-
-            if let Some(scraper) = &metrics_scraper {
-                scraper.write_csv(&path)?;
-            }
-
-            info!(target: "reth-bench", "Finished writing benchmark output files to {:?}.", path);
-        }
-
-        // accumulate the results and calculate the overall Ggas/s
-        let gas_output = TotalGasOutput::new(gas_output_results)?;
-        info!(
-            target: "reth-bench",
-            total_duration=?gas_output.total_duration,
-            total_gas_used=?gas_output.total_gas_used,
-            blocks_processed=?gas_output.blocks_processed,
-            "Total Ggas/s: {:.4}",
-            gas_output.total_gigagas_per_second()
-        );
-
-        Ok(())
-    }
-}
diff --git a/bin/reth-bench/src/bench/output.rs b/bin/reth-bench/src/bench/output.rs
deleted file mode 100644
index bb77d34e1f6..00000000000
--- a/bin/reth-bench/src/bench/output.rs
+++ /dev/null
@@ -1,318 +0,0 @@
-//! Contains various benchmark output formats, either for logging or for
-//! serialization to / from files.
-
-use csv::Writer;
-use eyre::OptionExt;
-use reth_primitives_traits::constants::GIGAGAS;
-use serde::{ser::SerializeStruct, Serialize};
-use std::{fs, path::Path, time::Duration};
-use tracing::info;
-
-/// This is the suffix for gas output csv files.
-pub(crate) const GAS_OUTPUT_SUFFIX: &str = "total_gas.csv";
-
-/// This is the suffix for combined output csv files.
-pub(crate) const COMBINED_OUTPUT_SUFFIX: &str = "combined_latency.csv";
-
-/// This is the suffix for new payload output csv files.
-pub(crate) const NEW_PAYLOAD_OUTPUT_SUFFIX: &str = "new_payload_latency.csv";
-
-/// This represents the results of a single `newPayload` call in the benchmark, containing the gas
-/// used and the `newPayload` latency.
-#[derive(Debug)]
-pub(crate) struct NewPayloadResult {
-    /// The gas used in the `newPayload` call.
-    pub(crate) gas_used: u64,
-    /// The latency of the `newPayload` call.
-    pub(crate) latency: Duration,
-    /// Time spent waiting on persistence (backpressure + explicit wait).
-    pub(crate) persistence_wait: Duration,
-    /// Time spent waiting for execution cache lock.
-    pub(crate) execution_cache_wait: Duration,
-    /// Time spent waiting for sparse trie lock.
-    pub(crate) sparse_trie_wait: Duration,
-}
-
-impl NewPayloadResult {
-    /// Returns the gas per second processed in the `newPayload` call.
-    pub(crate) fn gas_per_second(&self) -> f64 {
-        self.gas_used as f64 / self.latency.as_secs_f64()
-    }
-}
-
-impl std::fmt::Display for NewPayloadResult {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "New payload processed at {:.4} Ggas/s, used {} total gas. Latency: {:?}",
-            self.gas_per_second() / GIGAGAS as f64,
-            self.gas_used,
-            self.latency
-        )
-    }
-}
-
-/// This is another [`Serialize`] implementation for the [`NewPayloadResult`] struct, serializing
-/// the duration as microseconds because the csv writer would fail otherwise.
-impl Serialize for NewPayloadResult {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::ser::Serializer,
-    {
-        // convert the time to microseconds
-        let time = self.latency.as_micros();
-        let mut state = serializer.serialize_struct("NewPayloadResult", 5)?;
-        state.serialize_field("gas_used", &self.gas_used)?;
-        state.serialize_field("latency", &time)?;
-        state.serialize_field("persistence_wait", &self.persistence_wait.as_micros())?;
-        state.serialize_field("execution_cache_wait", &self.execution_cache_wait.as_micros())?;
-        state.serialize_field("sparse_trie_wait", &self.sparse_trie_wait.as_micros())?;
-        state.end()
-    }
-}
-
-/// This represents the combined results of a `newPayload` call and a `forkchoiceUpdated` call in
-/// the benchmark, containing the gas used, the `newPayload` latency, and the `forkchoiceUpdated`
-/// latency.
-#[derive(Debug)]
-pub(crate) struct CombinedResult {
-    /// The block number of the block being processed.
-    pub(crate) block_number: u64,
-    /// The gas limit of the block.
-    pub(crate) gas_limit: u64,
-    /// The number of transactions in the block.
-    pub(crate) transaction_count: u64,
-    /// The `newPayload` result.
-    pub(crate) new_payload_result: NewPayloadResult,
-    /// The latency of the `forkchoiceUpdated` call.
-    pub(crate) fcu_latency: Duration,
-    /// The latency of both calls combined.
-    pub(crate) total_latency: Duration,
-}
-
-impl CombinedResult {
-    /// Returns the gas per second, including the `newPayload` _and_ `forkchoiceUpdated` duration.
-    pub(crate) fn combined_gas_per_second(&self) -> f64 {
-        self.new_payload_result.gas_used as f64 / self.total_latency.as_secs_f64()
-    }
-}
-
-impl std::fmt::Display for CombinedResult {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let np = &self.new_payload_result;
-        write!(
-            f,
-            "Block {} processed at {:.4} Ggas/s, used {} total gas. Combined: {:.4} Ggas/s. fcu: {:?}, newPayload: {:?}",
-            self.block_number,
-            np.gas_per_second() / GIGAGAS as f64,
-            np.gas_used,
-            self.combined_gas_per_second() / GIGAGAS as f64,
-            self.fcu_latency,
-            np.latency,
-        )?;
-        if !np.execution_cache_wait.is_zero() {
-            write!(f, ", execution cache wait: {:?}", np.execution_cache_wait)?;
-        }
-        if !np.sparse_trie_wait.is_zero() {
-            write!(f, ", trie cache wait: {:?}", np.sparse_trie_wait)?;
-        }
-        if !np.persistence_wait.is_zero() {
-            write!(f, ", persistence wait: {:?}", np.persistence_wait)?;
-        }
-        Ok(())
-    }
-}
-
-/// This is a [`Serialize`] implementation for the [`CombinedResult`] struct, serializing the
-/// durations as microseconds because the csv writer would fail otherwise.
-impl Serialize for CombinedResult {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::ser::Serializer,
-    {
-        // convert the time to microseconds
-        let fcu_latency = self.fcu_latency.as_micros();
-        let new_payload_latency = self.new_payload_result.latency.as_micros();
-        let total_latency = self.total_latency.as_micros();
-        let mut state = serializer.serialize_struct("CombinedResult", 10)?;
-
-        // flatten the new payload result because this is meant for CSV writing
-        state.serialize_field("block_number", &self.block_number)?;
-        state.serialize_field("gas_limit", &self.gas_limit)?;
-        state.serialize_field("transaction_count", &self.transaction_count)?;
-        state.serialize_field("gas_used", &self.new_payload_result.gas_used)?;
-        state.serialize_field("new_payload_latency", &new_payload_latency)?;
-        state.serialize_field("fcu_latency", &fcu_latency)?;
-        state.serialize_field("total_latency", &total_latency)?;
-        state.serialize_field(
-            "persistence_wait",
-            &self.new_payload_result.persistence_wait.as_micros(),
-        )?;
-        state.serialize_field(
-            "execution_cache_wait",
-            &self.new_payload_result.execution_cache_wait.as_micros(),
-        )?;
-        state.serialize_field(
-            "sparse_trie_wait",
-            &self.new_payload_result.sparse_trie_wait.as_micros(),
-        )?;
-        state.end()
-    }
-}
-
-/// This represents a row of total gas data in the benchmark.
-#[derive(Debug)]
-pub(crate) struct TotalGasRow {
-    /// The block number of the block being processed.
-    pub(crate) block_number: u64,
-    /// The number of transactions in the block.
-    pub(crate) transaction_count: u64,
-    /// The total gas used in the block.
-    pub(crate) gas_used: u64,
-    /// Time since the start of the benchmark.
-    pub(crate) time: Duration,
-}
-
-/// This represents the aggregated output, meant to show gas per second metrics, of a benchmark run.
-#[derive(Debug)]
-pub(crate) struct TotalGasOutput {
-    /// The total gas used in the benchmark.
-    pub(crate) total_gas_used: u64,
-    /// The total wall-clock duration of the benchmark (includes wait times).
-    pub(crate) total_duration: Duration,
-    /// The total execution-only duration (excludes wait times).
-    pub(crate) execution_duration: Duration,
-    /// The number of blocks processed.
-    pub(crate) blocks_processed: u64,
-}
-
-impl TotalGasOutput {
-    /// Create a new [`TotalGasOutput`] from gas rows only.
-    ///
-    /// Use this when execution-only timing is not available (e.g., `new_payload_only`).
-    /// `execution_duration` will equal `total_duration`.
-    pub(crate) fn new(rows: Vec<TotalGasRow>) -> eyre::Result<Self> {
-        let total_duration = rows.last().map(|row| row.time).ok_or_eyre("empty results")?;
-        let blocks_processed = rows.len() as u64;
-        let total_gas_used: u64 = rows.into_iter().map(|row| row.gas_used).sum();
-
-        Ok(Self {
-            total_gas_used,
-            total_duration,
-            execution_duration: total_duration,
-            blocks_processed,
-        })
-    }
-
-    /// Create a new [`TotalGasOutput`] from gas rows and combined results.
-    ///
-    /// - `rows`: Used for total gas and wall-clock duration
-    /// - `combined_results`: Used for execution-only duration (sum of `total_latency`)
-    pub(crate) fn with_combined_results(
-        rows: Vec<TotalGasRow>,
-        combined_results: &[CombinedResult],
-    ) -> eyre::Result<Self> {
-        let total_duration = rows.last().map(|row| row.time).ok_or_eyre("empty results")?;
-        let blocks_processed = rows.len() as u64;
-        let total_gas_used: u64 = rows.into_iter().map(|row| row.gas_used).sum();
-
-        // Sum execution-only time from combined results
-        let execution_duration: Duration = combined_results.iter().map(|r| r.total_latency).sum();
-
-        Ok(Self { total_gas_used, total_duration, execution_duration, blocks_processed })
-    }
-
-    /// Return the total gigagas per second based on wall-clock time.
-    pub(crate) fn total_gigagas_per_second(&self) -> f64 {
-        self.total_gas_used as f64 / self.total_duration.as_secs_f64() / GIGAGAS as f64
-    }
-
-    /// Return the execution-only gigagas per second (excludes wait times).
-    pub(crate) fn execution_gigagas_per_second(&self) -> f64 {
-        self.total_gas_used as f64 / self.execution_duration.as_secs_f64() / GIGAGAS as f64
-    }
-}
-
-/// Write benchmark results to CSV files.
-///
-/// Writes two files to the output directory:
-/// - `combined_latency.csv`: Per-block latency results
-/// - `total_gas.csv`: Per-block gas usage over time
-pub(crate) fn write_benchmark_results(
-    output_dir: &Path,
-    gas_results: &[TotalGasRow],
-    combined_results: &[CombinedResult],
-) -> eyre::Result<()> {
-    fs::create_dir_all(output_dir)?;
-
-    let output_path = output_dir.join(COMBINED_OUTPUT_SUFFIX);
-    info!(target: "reth-bench", "Writing engine api call latency output to file: {:?}", output_path);
-    let mut writer = Writer::from_path(&output_path)?;
-    for result in combined_results {
-        writer.serialize(result)?;
-    }
-    writer.flush()?;
-
-    let output_path = output_dir.join(GAS_OUTPUT_SUFFIX);
-    info!(target: "reth-bench", "Writing total gas output to file: {:?}", output_path);
-    let mut writer = Writer::from_path(&output_path)?;
-    for row in gas_results {
-        writer.serialize(row)?;
-    }
-    writer.flush()?;
-
-    info!(target: "reth-bench", "Finished writing benchmark output files to {:?}.", output_dir);
-    Ok(())
-}
-
-/// This serializes the `time` field of the [`TotalGasRow`] to microseconds.
-///
-/// This is essentially just for the csv writer, which would have headers
-impl Serialize for TotalGasRow {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::ser::Serializer,
-    {
-        // convert the time to microseconds
-        let time = self.time.as_micros();
-        let mut state = serializer.serialize_struct("TotalGasRow", 4)?;
-        state.serialize_field("block_number", &self.block_number)?;
-        state.serialize_field("transaction_count", &self.transaction_count)?;
-        state.serialize_field("gas_used", &self.gas_used)?;
-        state.serialize_field("time", &time)?;
-        state.end()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use csv::Writer;
-    use std::io::BufRead;
-
-    #[test]
-    fn test_write_total_gas_row_csv() {
-        let row = TotalGasRow {
-            block_number: 1,
-            transaction_count: 10,
-            gas_used: 1_000,
-            time: Duration::from_secs(1),
-        };
-
-        let mut writer = Writer::from_writer(vec![]);
-        writer.serialize(row).unwrap();
-        let result = writer.into_inner().unwrap();
-
-        // parse into Lines
-        let mut result = result.as_slice().lines();
-
-        // assert header
-        let expected_first_line = "block_number,transaction_count,gas_used,time";
-        let first_line = result.next().unwrap().unwrap();
-        assert_eq!(first_line, expected_first_line);
-
-        let expected_second_line = "1,10,1000,1000000";
-        let second_line = result.next().unwrap().unwrap();
-        assert_eq!(second_line, expected_second_line);
-    }
-}
diff --git a/bin/reth-bench/src/bench/replay_payloads.rs b/bin/reth-bench/src/bench/replay_payloads.rs
deleted file mode 100644
index 7dfeb6d8fcc..00000000000
--- a/bin/reth-bench/src/bench/replay_payloads.rs
+++ /dev/null
@@ -1,552 +0,0 @@
-//! Command for replaying pre-generated payloads from disk.
-
-use crate::{
-    authenticated_transport::AuthenticatedTransportConnect,
-    bench::{
-        generate_big_block::{compute_payload_block_hash, BigBlockPayload},
-        helpers::parse_duration,
-        metrics_scraper::MetricsScraper,
-        output::{
-            write_benchmark_results, CombinedResult, NewPayloadResult, TotalGasOutput, TotalGasRow,
-        },
-    },
-    valid_payload::{call_forkchoice_updated_with_reth, call_new_payload_with_reth},
-};
-use alloy_eip7928::bal::Bal;
-use alloy_eips::eip7928::BlockAccessList;
-use alloy_primitives::B256;
-use alloy_provider::{network::AnyNetwork, Provider, RootProvider};
-use alloy_rpc_client::ClientBuilder;
-use alloy_rpc_types_engine::{
-    CancunPayloadFields, ExecutionData, ExecutionPayload, ExecutionPayloadEnvelopeV6,
-    ExecutionPayloadSidecar, ExecutionPayloadV4, ForkchoiceState, JwtSecret, PraguePayloadFields,
-};
-use clap::Parser;
-use eyre::Context;
-use reth_cli_runner::CliContext;
-use reth_engine_primitives::BigBlockData;
-use reth_node_api::EngineApiMessageVersion;
-use reth_node_core::args::WaitForPersistence;
-use reth_rpc_api::RethNewPayloadInput;
-use std::{
-    path::PathBuf,
-    time::{Duration, Instant},
-};
-use tracing::{debug, info, warn};
-use url::Url;
-
-/// `reth bench replay-payloads` command
-///
-/// Replays pre-generated payloads from a directory by calling `newPayload` followed by
-/// `forkchoiceUpdated` for each payload in sequence.
-#[derive(Debug, Parser)]
-pub struct Command {
-    /// The engine RPC URL (with JWT authentication).
-    #[arg(long, value_name = "ENGINE_RPC_URL", default_value = "http://localhost:8551")]
-    engine_rpc_url: String,
-
-    /// Path to the JWT secret file for engine API authentication.
-    #[arg(long, value_name = "JWT_SECRET")]
-    jwt_secret: PathBuf,
-
-    /// Directory containing payload files (`payload_block_N.json`).
-    #[arg(long, value_name = "PAYLOAD_DIR")]
-    payload_dir: PathBuf,
-
-    /// Optional limit on the number of payloads to replay.
-    /// If not specified, replays all payloads in the directory.
-    #[arg(long, value_name = "COUNT")]
-    count: Option<usize>,
-
-    /// Skip the first N payloads.
-    #[arg(long, value_name = "SKIP", default_value = "0")]
-    skip: usize,
-
-    /// Deprecated: gas ramp is no longer needed. This flag is accepted but ignored.
-    #[arg(long, value_name = "GAS_RAMP_DIR", hide = true)]
-    gas_ramp_dir: Option<PathBuf>,
-
-    /// Optional output directory for benchmark results (CSV files).
-    #[arg(long, value_name = "OUTPUT")]
-    output: Option<PathBuf>,
-
-    /// How long to wait after a forkchoice update before sending the next payload.
-    ///
-    /// Accepts a duration string (e.g. `100ms`, `2s`) or a bare integer treated as
-    /// milliseconds (e.g. `400`).
-    #[arg(long, value_name = "WAIT_TIME", value_parser = parse_duration, verbatim_doc_comment)]
-    wait_time: Option<Duration>,
-
-    /// Use `reth_newPayload` endpoint instead of `engine_newPayload*`.
-    ///
-    /// The `reth_newPayload` endpoint is a reth-specific extension that takes `ExecutionData`
-    /// directly, waits for persistence and cache updates to complete before processing,
-    /// and returns server-side timing breakdowns (latency, persistence wait, cache wait).
-    #[arg(long, default_value = "false", verbatim_doc_comment)]
-    reth_new_payload: bool,
-
-    /// Forward embedded block access lists to `reth_newPayload` when payload files contain them.
-    ///
-    /// Disabled by default so the same payload set can be replayed with or without BALs.
-    ///
-    /// Requires `--reth-new-payload`.
-    #[arg(long, default_value = "false", verbatim_doc_comment, requires = "reth_new_payload")]
-    bal: bool,
-
-    /// Control when `reth_newPayload` waits for in-flight persistence.
-    ///
-    /// Accepts `always` (default — wait on every block), `never`, or a number N
-    /// to wait every N blocks and skip the rest.
-    ///
-    /// Requires `--reth-new-payload`.
-    #[arg(
-        long = "wait-for-persistence",
-        value_name = "MODE",
-        num_args = 0..=1,
-        default_missing_value = "always",
-        value_parser = clap::value_parser!(WaitForPersistence),
-        requires = "reth_new_payload",
-        verbatim_doc_comment
-    )]
-    wait_for_persistence: Option<WaitForPersistence>,
-
-    /// Skip waiting for execution cache and sparse trie locks before processing.
-    ///
-    /// Only works with `--reth-new-payload`. When set, passes `wait_for_caches: false`
-    /// to the `reth_newPayload` endpoint.
-    #[arg(long, default_value = "false", verbatim_doc_comment, requires = "reth_new_payload")]
-    no_wait_for_caches: bool,
-
-    /// Optional Prometheus metrics endpoint to scrape after each block.
-    ///
-    /// When provided, reth-bench will fetch metrics from this URL after each
-    /// payload, recording per-block execution and state root durations.
-    /// Results are written to `metrics.csv` in the output directory.
-    #[arg(long = "metrics-url", value_name = "URL", verbatim_doc_comment)]
-    metrics_url: Option<String>,
-}
-
-/// A loaded payload ready for execution.
-struct LoadedPayload {
-    /// The index (from filename).
-    index: u64,
-    /// The execution data for the block.
-    execution_data: ExecutionData,
-    /// The block hash.
-    block_hash: B256,
-    /// Big block data containing environment switches and prior block hashes.
-    big_block_data: BigBlockData<ExecutionData>,
-    /// Optional BAL flattened into the payload file.
-    block_access_list: Option<BlockAccessList>,
-}
-
-impl Command {
-    /// Execute the `replay-payloads` command.
-    pub async fn execute(self, _ctx: CliContext) -> eyre::Result<()> {
-        info!(target: "reth-bench", payload_dir = %self.payload_dir.display(), "Replaying payloads");
-
-        // Log mode configuration
-        if let Some(duration) = self.wait_time {
-            info!(target: "reth-bench", "Using wait-time mode with {}ms minimum interval between blocks", duration.as_millis());
-        }
-        if self.reth_new_payload {
-            info!("Using reth_newPayload and reth_forkchoiceUpdated endpoints");
-            if self.bal {
-                info!(target: "reth-bench", "Forwarding embedded block_access_list data");
-            }
-        }
-
-        let mut metrics_scraper = MetricsScraper::maybe_new(self.metrics_url.clone());
-
-        // Set up authenticated engine provider
-        let jwt =
-            std::fs::read_to_string(&self.jwt_secret).wrap_err("Failed to read JWT secret file")?;
-        let jwt = JwtSecret::from_hex(jwt.trim())?;
-        let auth_url = Url::parse(&self.engine_rpc_url)?;
-
-        info!(target: "reth-bench", "Connecting to Engine RPC at {}", auth_url);
-        let auth_transport = AuthenticatedTransportConnect::new(auth_url.clone(), jwt);
-        let auth_client = ClientBuilder::default().connect_with(auth_transport).await?;
-        let auth_provider = RootProvider::<AnyNetwork>::new(auth_client);
-
-        // Get parent block (latest canonical block) - we need this for the first FCU
-        let parent_block = auth_provider
-            .get_block_by_number(alloy_eips::BlockNumberOrTag::Latest)
-            .await?
-            .ok_or_else(|| eyre::eyre!("Failed to fetch latest block"))?;
-
-        let initial_parent_hash = parent_block.header.hash;
-        let initial_parent_number = parent_block.header.number;
-
-        info!(
-            target: "reth-bench",
-            parent_hash = %initial_parent_hash,
-            parent_number = initial_parent_number,
-            "Using initial parent block"
-        );
-
-        // Warn if deprecated --gas-ramp-dir is passed
-        if self.gas_ramp_dir.is_some() {
-            warn!(
-                target: "reth-bench",
-                "--gas-ramp-dir is deprecated and ignored."
-            );
-        }
-
-        // Load all payloads upfront to avoid I/O delays between phases
-        let payloads = self.load_payloads()?;
-        if payloads.is_empty() {
-            return Err(eyre::eyre!("No payload files found in {:?}", self.payload_dir));
-        }
-        info!(target: "reth-bench", count = payloads.len(), "Loaded main payloads from disk");
-
-        let has_env_switches = payloads.iter().any(|p| !p.big_block_data.env_switches.is_empty());
-        let has_block_access_lists = payloads.iter().any(|p| {
-            p.block_access_list.as_ref().is_some_and(|bal: &BlockAccessList| !bal.is_empty())
-        });
-
-        // If any payload has env_switches but we're not using reth_newPayload, warn the user
-        if !self.reth_new_payload {
-            if has_env_switches {
-                warn!(
-                    target: "reth-bench",
-                    "Payloads contain env_switches but --reth-new-payload is not set. \
-                     env_switches are only supported with reth_newPayload and will be ignored."
-                );
-            }
-            if has_block_access_lists {
-                warn!(
-                    target: "reth-bench",
-                    "Payloads contain block_access_list data but --reth-new-payload is not set. \
-                     BALs are only forwarded with reth_newPayload and will be ignored."
-                );
-            }
-        } else if has_block_access_lists && !self.bal {
-            info!(
-                target: "reth-bench",
-                "Payloads contain block_access_list data but --bal is not set. BALs will be ignored."
-            );
-        }
-
-        let mut parent_hash = initial_parent_hash;
-
-        let mut results = Vec::new();
-        let total_benchmark_duration = Instant::now();
-
-        for (i, payload) in payloads.iter().enumerate() {
-            let execution_data = &payload.execution_data;
-            let mut block_hash = payload.block_hash;
-            let v1 = execution_data.payload.as_v1();
-
-            let gas_used = v1.gas_used;
-            let gas_limit = v1.gas_limit;
-            let block_number = v1.block_number;
-            let transaction_count = v1.transactions.len() as u64;
-
-            debug!(
-                target: "reth-bench",
-                payload = i + 1,
-                total = payloads.len(),
-                index = payload.index,
-                block_hash = %block_hash,
-                "Executing payload (newPayload + FCU)"
-            );
-
-            let start = Instant::now();
-
-            debug!(
-                target: "reth-bench",
-                method = "engine_newPayloadV4",
-                block_hash = %block_hash,
-                "Sending newPayload"
-            );
-
-            let (version, params) = if self.reth_new_payload {
-                let big_block_data_param = if payload.big_block_data.env_switches.is_empty() &&
-                    payload.big_block_data.prior_block_hashes.is_empty()
-                {
-                    None
-                } else {
-                    Some(payload.big_block_data.clone())
-                };
-                let wait_for_persistence = self
-                    .wait_for_persistence
-                    .unwrap_or(WaitForPersistence::Never)
-                    .rpc_value(block_number);
-
-                // Inject sidecar BAL into the inline V4 payload field when --bal is set.
-                // If the payload is not already V4 we upgrade it (V3→V4) so the BAL
-                // can be carried inline. This changes the block hash, so we recompute
-                // it and patch parent_hash to maintain the chain.
-                let mut execution_data = execution_data.clone();
-                if self.bal &&
-                    let Some(bal) = &payload.block_access_list
-                {
-                    let encoded_bal: alloy_primitives::Bytes =
-                        alloy_rlp::encode(Bal::from(bal.clone())).into();
-
-                    // Upgrade to V4 if necessary, then set the BAL field.
-                    if execution_data.payload.as_v4().is_none() {
-                        execution_data.payload = upgrade_to_v4(execution_data.payload, encoded_bal);
-                    } else {
-                        execution_data.payload.as_v4_mut().unwrap().block_access_list = encoded_bal;
-                    }
-
-                    // Patch parent_hash so this block chains off the (possibly
-                    // rehashed) previous block.
-                    execution_data.payload.as_v1_mut().parent_hash = parent_hash;
-
-                    // Recompute block hash after payload modification and update
-                    // the hash stored in the payload itself.
-                    block_hash = compute_payload_block_hash(&execution_data)?;
-                    execution_data.payload.as_v1_mut().block_hash = block_hash;
-                }
-
-                (
-                    None,
-                    serde_json::to_value((
-                        RethNewPayloadInput::ExecutionData(execution_data),
-                        wait_for_persistence,
-                        self.no_wait_for_caches.then_some(false),
-                        big_block_data_param,
-                    ))?,
-                )
-            } else {
-                let requests =
-                    execution_data.sidecar.requests().cloned().unwrap_or_default().to_vec();
-                (
-                    Some(EngineApiMessageVersion::V6),
-                    serde_json::to_value((
-                        execution_data.payload.clone(),
-                        Vec::<B256>::new(),
-                        B256::ZERO,
-                        requests,
-                    ))?,
-                )
-            };
-
-            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 {
-                gas_used,
-                latency: np_latency,
-                persistence_wait: server_timings
-                    .as_ref()
-                    .map(|t| t.persistence_wait)
-                    .unwrap_or_default(),
-                execution_cache_wait: server_timings
-                    .as_ref()
-                    .map(|t| t.execution_cache_wait)
-                    .unwrap_or_default(),
-                sparse_trie_wait: server_timings
-                    .as_ref()
-                    .map(|t| t.sparse_trie_wait)
-                    .unwrap_or_default(),
-            };
-
-            let fcu_state = ForkchoiceState {
-                head_block_hash: block_hash,
-                safe_block_hash: parent_hash,
-                finalized_block_hash: parent_hash,
-            };
-
-            let fcu_start = Instant::now();
-            call_forkchoice_updated_with_reth(&auth_provider, version, fcu_state).await?;
-            let fcu_latency = fcu_start.elapsed();
-
-            let total_latency =
-                if server_timings.is_some() { np_latency + fcu_latency } else { start.elapsed() };
-
-            let combined_result = CombinedResult {
-                block_number,
-                gas_limit,
-                transaction_count,
-                new_payload_result,
-                fcu_latency,
-                total_latency,
-            };
-
-            let current_duration = total_benchmark_duration.elapsed();
-            let progress = format!("{}/{}", i + 1, payloads.len());
-            info!(target: "reth-bench", progress, %combined_result);
-
-            if let Some(scraper) = metrics_scraper.as_mut() &&
-                let Err(err) = scraper.scrape_after_block(block_number).await
-            {
-                tracing::warn!(target: "reth-bench", %err, block_number, "Failed to scrape metrics");
-            }
-
-            if let Some(wait_time) = self.wait_time {
-                let remaining = wait_time.saturating_sub(start.elapsed());
-                if !remaining.is_zero() {
-                    tokio::time::sleep(remaining).await;
-                }
-            }
-
-            let gas_row =
-                TotalGasRow { block_number, transaction_count, gas_used, time: current_duration };
-            results.push((gas_row, combined_result));
-
-            parent_hash = block_hash;
-        }
-
-        let (gas_output_results, combined_results): (Vec<TotalGasRow>, Vec<CombinedResult>) =
-            results.into_iter().unzip();
-
-        if let Some(ref path) = self.output {
-            write_benchmark_results(path, &gas_output_results, &combined_results)?;
-        }
-
-        if let (Some(path), Some(scraper)) = (&self.output, &metrics_scraper) {
-            scraper.write_csv(path)?;
-        }
-
-        let gas_output =
-            TotalGasOutput::with_combined_results(gas_output_results, &combined_results)?;
-        info!(
-            target: "reth-bench",
-            total_gas_used = gas_output.total_gas_used,
-            total_duration = ?gas_output.total_duration,
-            execution_duration = ?gas_output.execution_duration,
-            blocks_processed = gas_output.blocks_processed,
-            wall_clock_ggas_per_second = format_args!("{:.4}", gas_output.total_gigagas_per_second()),
-            execution_ggas_per_second = format_args!("{:.4}", gas_output.execution_gigagas_per_second()),
-            "Benchmark complete"
-        );
-
-        Ok(())
-    }
-
-    /// Load and parse all payload files from the directory.
-    ///
-    /// Tries to load each file as a [`BigBlockPayload`] first (which includes `env_switches`),
-    /// falling back to [`ExecutionPayloadEnvelopeV6`] for backwards compatibility.
-    fn load_payloads(&self) -> eyre::Result<Vec<LoadedPayload>> {
-        let mut payloads = Vec::new();
-
-        // Read directory entries — match both legacy "payload_block_*.json" and new
-        // "big_block_*.json" formats
-        let entries: Vec<_> = std::fs::read_dir(&self.payload_dir)
-            .wrap_err_with(|| format!("Failed to read directory {:?}", self.payload_dir))?
-            .filter_map(|e| e.ok())
-            .filter(|e| {
-                let name = e.file_name();
-                let name_str = name.to_string_lossy();
-                e.path().extension().and_then(|s| s.to_str()) == Some("json") &&
-                    (name_str.starts_with("payload_block_") ||
-                        name_str.starts_with("big_block_"))
-            })
-            .collect();
-
-        // Parse filenames to get indices and sort.
-        // Supports "payload_block_N.json" and "big_block_FROM_to_TO.json" naming.
-        let mut indexed_paths: Vec<(u64, PathBuf)> = entries
-            .into_iter()
-            .filter_map(|e| {
-                let name = e.file_name();
-                let name_str = name.to_string_lossy();
-                let index = if let Some(rest) = name_str.strip_prefix("payload_block_") {
-                    rest.strip_suffix(".json")?.parse::<u64>().ok()?
-                } else {
-                    let rest = name_str.strip_prefix("big_block_")?;
-                    // "big_block_FROM_to_TO.json" — use FROM as the index
-                    let rest = rest.strip_suffix(".json")?;
-                    rest.split("_to_").next()?.parse::<u64>().ok()?
-                };
-                Some((index, e.path()))
-            })
-            .collect();
-
-        indexed_paths.sort_by_key(|(idx, _)| *idx);
-
-        // Apply skip and count
-        let indexed_paths: Vec<_> = indexed_paths.into_iter().skip(self.skip).collect();
-        let indexed_paths: Vec<_> = match self.count {
-            Some(count) => indexed_paths.into_iter().take(count).collect(),
-            None => indexed_paths,
-        };
-
-        // Load each payload
-        for (index, path) in indexed_paths {
-            let content = std::fs::read_to_string(&path)
-                .wrap_err_with(|| format!("Failed to read {:?}", path))?;
-
-            // Try BigBlockPayload first, then fall back to legacy ExecutionPayloadEnvelopeV4
-            let (execution_data, big_block_data, block_access_list) = if let Ok(big_block) =
-                serde_json::from_str::<BigBlockPayload>(&content)
-            {
-                (big_block.execution_data, big_block.big_block_data, big_block.block_access_list)
-            } else {
-                let envelope: ExecutionPayloadEnvelopeV6 = serde_json::from_str(&content)
-                    .wrap_err_with(|| format!("Failed to parse {:?}", path))?;
-                let execution_data = ExecutionData {
-                    payload: envelope.execution_payload.clone().into(),
-                    sidecar: ExecutionPayloadSidecar::v4(
-                        CancunPayloadFields {
-                            versioned_hashes: Vec::new(),
-                            parent_beacon_block_root: B256::ZERO,
-                        },
-                        PraguePayloadFields {
-                            requests: envelope.execution_requests.clone().into(),
-                        },
-                    ),
-                };
-                (execution_data, BigBlockData::default(), None)
-            };
-
-            let block_hash = execution_data.payload.as_v1().block_hash;
-
-            debug!(
-                target: "reth-bench",
-                index = index,
-                block_hash = %block_hash,
-                env_switches = big_block_data.env_switches.len(),
-                prior_block_hashes = big_block_data.prior_block_hashes.len(),
-                bal_accounts = block_access_list.as_ref().map_or(0, Vec::len),
-                path = %path.display(),
-                "Loaded payload"
-            );
-
-            payloads.push(LoadedPayload {
-                index,
-                execution_data,
-                block_hash,
-                big_block_data,
-                block_access_list,
-            });
-        }
-
-        Ok(payloads)
-    }
-}
-
-/// Upgrades an [`ExecutionPayload`] to V4 by wrapping the inner V3 payload (constructing
-/// default V2/V3 layers for V1 payloads if needed) and setting the provided BAL bytes.
-fn upgrade_to_v4(
-    payload: ExecutionPayload,
-    block_access_list: alloy_primitives::Bytes,
-) -> ExecutionPayload {
-    use alloy_rpc_types_engine::{ExecutionPayloadV2, ExecutionPayloadV3};
-
-    let v3 = match payload {
-        ExecutionPayload::V4(_) => unreachable!("caller checks as_v4().is_none()"),
-        ExecutionPayload::V3(v3) => v3,
-        ExecutionPayload::V2(v2) => {
-            ExecutionPayloadV3 { payload_inner: v2, blob_gas_used: 0, excess_blob_gas: 0 }
-        }
-        ExecutionPayload::V1(v1) => ExecutionPayloadV3 {
-            payload_inner: ExecutionPayloadV2 { payload_inner: v1, withdrawals: Vec::new() },
-            blob_gas_used: 0,
-            excess_blob_gas: 0,
-        },
-    };
-
-    ExecutionPayload::V4(ExecutionPayloadV4 {
-        payload_inner: v3,
-        block_access_list,
-        slot_number: 0,
-    })
-}
diff --git a/bin/reth-bench/src/bench/send_invalid_payload/invalidation.rs b/bin/reth-bench/src/bench/send_invalid_payload/invalidation.rs
deleted file mode 100644
index 12d33d186ed..00000000000
--- a/bin/reth-bench/src/bench/send_invalid_payload/invalidation.rs
+++ /dev/null
@@ -1,250 +0,0 @@
-use alloy_eips::eip4895::Withdrawal;
-use alloy_primitives::{Address, Bloom, Bytes, B256, U256};
-use alloy_rpc_types_engine::{
-    ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3, ExecutionPayloadV4,
-};
-
-/// Configuration for invalidating payload fields
-#[derive(Debug, Default)]
-pub(super) struct InvalidationConfig {
-    // Explicit value overrides (Option<T>)
-    pub(super) parent_hash: Option<B256>,
-    pub(super) fee_recipient: Option<Address>,
-    pub(super) state_root: Option<B256>,
-    pub(super) receipts_root: Option<B256>,
-    pub(super) logs_bloom: Option<Bloom>,
-    pub(super) prev_randao: Option<B256>,
-    pub(super) block_number: Option<u64>,
-    pub(super) gas_limit: Option<u64>,
-    pub(super) gas_used: Option<u64>,
-    pub(super) timestamp: Option<u64>,
-    pub(super) extra_data: Option<Bytes>,
-    pub(super) base_fee_per_gas: Option<u64>,
-    pub(super) block_hash: Option<B256>,
-    pub(super) blob_gas_used: Option<u64>,
-    pub(super) excess_blob_gas: Option<u64>,
-    pub(super) slot_number: Option<u64>,
-
-    // Auto-invalidation flags
-    pub(super) invalidate_parent_hash: bool,
-    pub(super) invalidate_state_root: bool,
-    pub(super) invalidate_receipts_root: bool,
-    pub(super) invalidate_gas_used: bool,
-    pub(super) invalidate_block_number: bool,
-    pub(super) invalidate_timestamp: bool,
-    pub(super) invalidate_base_fee: bool,
-    pub(super) invalidate_transactions: bool,
-    pub(super) invalidate_block_hash: bool,
-    pub(super) invalidate_withdrawals: bool,
-    pub(super) invalidate_blob_gas_used: bool,
-    pub(super) invalidate_excess_blob_gas: bool,
-    pub(super) invalidate_block_access_list: bool,
-    pub(super) invalidate_slot_number: bool,
-}
-
-impl InvalidationConfig {
-    /// Returns true if `block_hash` is being explicitly set or auto-invalidated.
-    /// When true, the caller should skip recalculating the block hash since it will be overwritten.
-    pub(super) const fn should_skip_hash_recalc(&self) -> bool {
-        self.block_hash.is_some() || self.invalidate_block_hash
-    }
-
-    /// Applies invalidations to a V1 payload, returns list of what was changed.
-    pub(super) fn apply_to_payload_v1(&self, payload: &mut ExecutionPayloadV1) -> Vec<String> {
-        let mut changes = Vec::new();
-
-        // Explicit value overrides
-        if let Some(parent_hash) = self.parent_hash {
-            payload.parent_hash = parent_hash;
-            changes.push(format!("parent_hash = {parent_hash}"));
-        }
-
-        if let Some(fee_recipient) = self.fee_recipient {
-            payload.fee_recipient = fee_recipient;
-            changes.push(format!("fee_recipient = {fee_recipient}"));
-        }
-
-        if let Some(state_root) = self.state_root {
-            payload.state_root = state_root;
-            changes.push(format!("state_root = {state_root}"));
-        }
-
-        if let Some(receipts_root) = self.receipts_root {
-            payload.receipts_root = receipts_root;
-            changes.push(format!("receipts_root = {receipts_root}"));
-        }
-
-        if let Some(logs_bloom) = self.logs_bloom {
-            payload.logs_bloom = logs_bloom;
-            changes.push("logs_bloom = <custom>".to_string());
-        }
-
-        if let Some(prev_randao) = self.prev_randao {
-            payload.prev_randao = prev_randao;
-            changes.push(format!("prev_randao = {prev_randao}"));
-        }
-
-        if let Some(block_number) = self.block_number {
-            payload.block_number = block_number;
-            changes.push(format!("block_number = {block_number}"));
-        }
-
-        if let Some(gas_limit) = self.gas_limit {
-            payload.gas_limit = gas_limit;
-            changes.push(format!("gas_limit = {gas_limit}"));
-        }
-
-        if let Some(gas_used) = self.gas_used {
-            payload.gas_used = gas_used;
-            changes.push(format!("gas_used = {gas_used}"));
-        }
-
-        if let Some(timestamp) = self.timestamp {
-            payload.timestamp = timestamp;
-            changes.push(format!("timestamp = {timestamp}"));
-        }
-
-        if let Some(ref extra_data) = self.extra_data {
-            payload.extra_data = extra_data.clone();
-            changes.push(format!("extra_data = {} bytes", extra_data.len()));
-        }
-
-        if let Some(base_fee_per_gas) = self.base_fee_per_gas {
-            payload.base_fee_per_gas = U256::from_limbs([base_fee_per_gas, 0, 0, 0]);
-            changes.push(format!("base_fee_per_gas = {base_fee_per_gas}"));
-        }
-
-        if let Some(block_hash) = self.block_hash {
-            payload.block_hash = block_hash;
-            changes.push(format!("block_hash = {block_hash}"));
-        }
-
-        // Auto-invalidation flags
-        if self.invalidate_parent_hash {
-            let random_hash = B256::random();
-            payload.parent_hash = random_hash;
-            changes.push(format!("parent_hash = {random_hash} (auto-invalidated: random)"));
-        }
-
-        if self.invalidate_state_root {
-            payload.state_root = B256::ZERO;
-            changes.push("state_root = ZERO (auto-invalidated: empty trie root)".to_string());
-        }
-
-        if self.invalidate_receipts_root {
-            payload.receipts_root = B256::ZERO;
-            changes.push("receipts_root = ZERO (auto-invalidated)".to_string());
-        }
-
-        if self.invalidate_gas_used {
-            let invalid_gas = payload.gas_limit + 1;
-            payload.gas_used = invalid_gas;
-            changes.push(format!("gas_used = {invalid_gas} (auto-invalidated: exceeds gas_limit)"));
-        }
-
-        if self.invalidate_block_number {
-            let invalid_number = payload.block_number + 999;
-            payload.block_number = invalid_number;
-            changes.push(format!("block_number = {invalid_number} (auto-invalidated: huge gap)"));
-        }
-
-        if self.invalidate_timestamp {
-            payload.timestamp = 0;
-            changes.push("timestamp = 0 (auto-invalidated: impossibly old)".to_string());
-        }
-
-        if self.invalidate_base_fee {
-            payload.base_fee_per_gas = U256::ZERO;
-            changes
-                .push("base_fee_per_gas = 0 (auto-invalidated: invalid post-London)".to_string());
-        }
-
-        if self.invalidate_transactions {
-            let invalid_tx = Bytes::from_static(&[0xff, 0xff, 0xff]);
-            payload.transactions.insert(0, invalid_tx);
-            changes.push("transactions = prepended invalid RLP (auto-invalidated)".to_string());
-        }
-
-        if self.invalidate_block_hash {
-            let random_hash = B256::random();
-            payload.block_hash = random_hash;
-            changes.push(format!("block_hash = {random_hash} (auto-invalidated: random)"));
-        }
-
-        changes
-    }
-
-    /// Applies invalidations to a V2 payload, returns list of what was changed.
-    pub(super) fn apply_to_payload_v2(&self, payload: &mut ExecutionPayloadV2) -> Vec<String> {
-        let mut changes = self.apply_to_payload_v1(&mut payload.payload_inner);
-
-        // Handle withdrawals invalidation (V2+)
-        if self.invalidate_withdrawals {
-            let fake_withdrawal = Withdrawal {
-                index: u64::MAX,
-                validator_index: u64::MAX,
-                address: Address::ZERO,
-                amount: u64::MAX,
-            };
-            payload.withdrawals.push(fake_withdrawal);
-            changes.push("withdrawals = added fake withdrawal (auto-invalidated)".to_string());
-        }
-
-        changes
-    }
-
-    /// Applies invalidations to a V3 payload, returns list of what was changed.
-    pub(super) fn apply_to_payload_v3(&self, payload: &mut ExecutionPayloadV3) -> Vec<String> {
-        let mut changes = self.apply_to_payload_v2(&mut payload.payload_inner);
-
-        // Explicit overrides for V3 fields
-        if let Some(blob_gas_used) = self.blob_gas_used {
-            payload.blob_gas_used = blob_gas_used;
-            changes.push(format!("blob_gas_used = {blob_gas_used}"));
-        }
-
-        if let Some(excess_blob_gas) = self.excess_blob_gas {
-            payload.excess_blob_gas = excess_blob_gas;
-            changes.push(format!("excess_blob_gas = {excess_blob_gas}"));
-        }
-
-        // Auto-invalidation for V3 fields
-        if self.invalidate_blob_gas_used {
-            payload.blob_gas_used = u64::MAX;
-            changes.push("blob_gas_used = MAX (auto-invalidated)".to_string());
-        }
-
-        if self.invalidate_excess_blob_gas {
-            payload.excess_blob_gas = u64::MAX;
-            changes.push("excess_blob_gas = MAX (auto-invalidated)".to_string());
-        }
-
-        changes
-    }
-
-    /// Applies invalidations to a V4 payload, returns list of what was changed.
-    pub(super) fn apply_to_payload_v4(&self, payload: &mut ExecutionPayloadV4) -> Vec<String> {
-        let mut changes = self.apply_to_payload_v3(&mut payload.payload_inner);
-
-        // Explicit override for slot_number
-        if let Some(slot_number) = self.slot_number {
-            payload.slot_number = slot_number;
-            changes.push(format!("slot_number = {slot_number}"));
-        }
-
-        // Handle block access list invalidation (V4+)
-        if self.invalidate_block_access_list {
-            let fake_bal = Bytes::from_static(&[0x01, 0x02, 0x03]);
-            payload.block_access_list = fake_bal.clone();
-            changes.push(format!("block_access_list = {fake_bal} (auto-invalidated)"));
-        }
-
-        // Handle slot number invalidation (V4+)
-        if self.invalidate_slot_number {
-            payload.slot_number = u64::MAX;
-            changes.push("slot_number = MAX (auto-invalidated)".to_string());
-        }
-
-        changes
-    }
-}
diff --git a/bin/reth-bench/src/bench/send_invalid_payload/mod.rs b/bin/reth-bench/src/bench/send_invalid_payload/mod.rs
deleted file mode 100644
index 1c2b9f21d4b..00000000000
--- a/bin/reth-bench/src/bench/send_invalid_payload/mod.rs
+++ /dev/null
@@ -1,401 +0,0 @@
-//! Command for sending invalid payloads to test Engine API rejection.
-
-mod invalidation;
-use alloy_rpc_client::ClientBuilder;
-use invalidation::InvalidationConfig;
-
-use crate::bench::helpers::fetch_block_access_list;
-
-use super::helpers::{load_jwt_secret, read_input};
-use alloy_consensus::TxEnvelope;
-use alloy_primitives::{Address, Bytes, B256};
-use alloy_provider::{
-    network::{AnyNetwork, AnyRpcBlock},
-    RootProvider,
-};
-use alloy_rpc_types_engine::ExecutionPayload;
-use clap::Parser;
-use eyre::{OptionExt, Result};
-use reth_cli_runner::CliContext;
-use std::io::Write;
-
-/// Command for generating and sending an invalid `engine_newPayload` request.
-///
-/// Takes a valid block and modifies fields to make it invalid for testing
-/// Engine API rejection behavior. Block hash is recalculated after modifications
-/// unless `--invalidate-block-hash` or `--skip-hash-recalc` is used.
-#[derive(Debug, Parser)]
-pub struct Command {
-    // ==================== Input Options ====================
-    /// Path to the JSON file containing the block. If not specified, stdin will be used.
-    #[arg(short, long, help_heading = "Input Options")]
-    path: Option<String>,
-
-    /// The engine RPC URL to use.
-    #[arg(
-        short,
-        long,
-        help_heading = "Input Options",
-        required_if_eq_any([("mode", "execute"), ("mode", "cast")]),
-        required_unless_present("mode")
-    )]
-    rpc_url: Option<String>,
-
-    /// The JWT secret to use. Can be either a path to a file containing the secret or the secret
-    /// itself.
-    #[arg(short, long, help_heading = "Input Options")]
-    jwt_secret: Option<String>,
-
-    /// The newPayload version to use (3 or 4).
-    #[arg(long, default_value_t = 3, help_heading = "Input Options")]
-    new_payload_version: u8,
-
-    /// The output mode to use.
-    #[arg(long, value_enum, default_value = "execute", help_heading = "Input Options")]
-    mode: Mode,
-
-    // ==================== Explicit Value Overrides ====================
-    /// Override the parent hash with a specific value.
-    #[arg(long, value_name = "HASH", help_heading = "Explicit Value Overrides")]
-    parent_hash: Option<B256>,
-
-    /// Override the fee recipient (coinbase) with a specific address.
-    #[arg(long, value_name = "ADDR", help_heading = "Explicit Value Overrides")]
-    fee_recipient: Option<Address>,
-
-    /// Override the state root with a specific value.
-    #[arg(long, value_name = "HASH", help_heading = "Explicit Value Overrides")]
-    state_root: Option<B256>,
-
-    /// Override the receipts root with a specific value.
-    #[arg(long, value_name = "HASH", help_heading = "Explicit Value Overrides")]
-    receipts_root: Option<B256>,
-
-    /// Override the block number with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    block_number: Option<u64>,
-
-    /// Override the gas limit with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    gas_limit: Option<u64>,
-
-    /// Override the gas used with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    gas_used: Option<u64>,
-
-    /// Override the timestamp with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    timestamp: Option<u64>,
-
-    /// Override the base fee per gas with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    base_fee_per_gas: Option<u64>,
-
-    /// Override the block hash with a specific value (skips hash recalculation).
-    #[arg(long, value_name = "HASH", help_heading = "Explicit Value Overrides")]
-    block_hash: Option<B256>,
-
-    /// Override the blob gas used with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    blob_gas_used: Option<u64>,
-
-    /// Override the excess blob gas with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    excess_blob_gas: Option<u64>,
-
-    /// Override the parent beacon block root with a specific value.
-    #[arg(long, value_name = "HASH", help_heading = "Explicit Value Overrides")]
-    parent_beacon_block_root: Option<B256>,
-
-    /// Override the requests hash with a specific value (EIP-7685).
-    #[arg(long, value_name = "HASH", help_heading = "Explicit Value Overrides")]
-    requests_hash: Option<B256>,
-
-    /// Override the slot number with a specific value.
-    #[arg(long, value_name = "U64", help_heading = "Explicit Value Overrides")]
-    slot_number: Option<u64>,
-    // ==================== Auto-Invalidation Flags ====================
-    /// Invalidate the parent hash by setting it to a random value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_parent_hash: bool,
-
-    /// Invalidate the state root by setting it to a random value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_state_root: bool,
-
-    /// Invalidate the receipts root by setting it to a random value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_receipts_root: bool,
-
-    /// Invalidate the gas used by setting it to an incorrect value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_gas_used: bool,
-
-    /// Invalidate the block number by setting it to an incorrect value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_block_number: bool,
-
-    /// Invalidate the timestamp by setting it to an incorrect value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_timestamp: bool,
-
-    /// Invalidate the base fee by setting it to an incorrect value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_base_fee: bool,
-
-    /// Invalidate the transactions by modifying them.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_transactions: bool,
-
-    /// Invalidate the block hash by not recalculating it after modifications.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_block_hash: bool,
-
-    /// Invalidate the withdrawals by modifying them.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_withdrawals: bool,
-
-    /// Invalidate the blob gas used by setting it to an incorrect value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_blob_gas_used: bool,
-
-    /// Invalidate the excess blob gas by setting it to an incorrect value.
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_excess_blob_gas: bool,
-
-    /// Invalidate the requests hash by setting it to a random value (EIP-7685).
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_requests_hash: bool,
-
-    /// Invalidate the block access list by setting it to a random value (EIP-7928).
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_block_access_list: bool,
-
-    /// Invalidate the slot number by setting it to an random value.(EIP-7843).
-    #[arg(long, default_value_t = false, help_heading = "Auto-Invalidation Flags")]
-    invalidate_slot_number: bool,
-
-    // ==================== Meta Flags ====================
-    /// Skip block hash recalculation after modifications.
-    #[arg(long, default_value_t = false, help_heading = "Meta Flags")]
-    skip_hash_recalc: bool,
-
-    /// Print what would be done without actually sending the payload.
-    #[arg(long, default_value_t = false, help_heading = "Meta Flags")]
-    dry_run: bool,
-}
-
-#[derive(Debug, Clone, clap::ValueEnum)]
-enum Mode {
-    /// Execute the `cast` command. This works with blocks of any size, because it pipes the
-    /// payload into the `cast` command.
-    Execute,
-    /// Print the `cast` command. Caution: this may not work with large blocks because of the
-    /// command length limit.
-    Cast,
-    /// Print the JSON payload. Can be piped into `cast` command if the block is small enough.
-    Json,
-}
-
-impl Command {
-    /// Build `InvalidationConfig` from command flags
-    const fn build_invalidation_config(&self) -> InvalidationConfig {
-        InvalidationConfig {
-            parent_hash: self.parent_hash,
-            fee_recipient: self.fee_recipient,
-            state_root: self.state_root,
-            receipts_root: self.receipts_root,
-            logs_bloom: None,
-            prev_randao: None,
-            block_number: self.block_number,
-            gas_limit: self.gas_limit,
-            gas_used: self.gas_used,
-            timestamp: self.timestamp,
-            extra_data: None,
-            base_fee_per_gas: self.base_fee_per_gas,
-            block_hash: self.block_hash,
-            blob_gas_used: self.blob_gas_used,
-            excess_blob_gas: self.excess_blob_gas,
-            slot_number: self.slot_number,
-            invalidate_parent_hash: self.invalidate_parent_hash,
-            invalidate_state_root: self.invalidate_state_root,
-            invalidate_receipts_root: self.invalidate_receipts_root,
-            invalidate_gas_used: self.invalidate_gas_used,
-            invalidate_block_number: self.invalidate_block_number,
-            invalidate_timestamp: self.invalidate_timestamp,
-            invalidate_base_fee: self.invalidate_base_fee,
-            invalidate_transactions: self.invalidate_transactions,
-            invalidate_block_hash: self.invalidate_block_hash,
-            invalidate_withdrawals: self.invalidate_withdrawals,
-            invalidate_blob_gas_used: self.invalidate_blob_gas_used,
-            invalidate_excess_blob_gas: self.invalidate_excess_blob_gas,
-            invalidate_block_access_list: self.invalidate_block_access_list,
-            invalidate_slot_number: self.invalidate_slot_number,
-        }
-    }
-
-    /// Execute the command
-    pub async fn execute(self, _ctx: CliContext) -> Result<()> {
-        let block_json = read_input(self.path.as_deref())?;
-        let jwt_secret = load_jwt_secret(self.jwt_secret.as_deref())?;
-
-        let block = serde_json::from_str::<AnyRpcBlock>(&block_json)?
-            .into_inner()
-            .map_header(|header| header.map(|h| h.into_header_with_defaults()))
-            .try_map_transactions(|tx| -> eyre::Result<TxEnvelope> {
-                tx.try_into().map_err(|_| eyre::eyre!("unsupported tx type"))
-            })?
-            .into_consensus();
-
-        let config = self.build_invalidation_config();
-
-        let parent_beacon_block_root =
-            self.parent_beacon_block_root.or(block.header.parent_beacon_block_root);
-        let blob_versioned_hashes =
-            block.body.blob_versioned_hashes_iter().copied().collect::<Vec<_>>();
-        let use_v4 = block.header.requests_hash.is_some();
-        let use_v5 = block.header.block_access_list_hash.is_some();
-        let requests_hash = self.requests_hash.or(block.header.requests_hash);
-
-        let mut execution_payload = if use_v5 {
-            let encoded_bal = self.fetch_encoded_block_access_list(block.header.number).await?;
-            ExecutionPayload::from_block_slow_with_bal(&block, encoded_bal).0
-        } else {
-            ExecutionPayload::from_block_slow(&block).0
-        };
-
-        let changes = match &mut execution_payload {
-            ExecutionPayload::V1(p) => config.apply_to_payload_v1(p),
-            ExecutionPayload::V2(p) => config.apply_to_payload_v2(p),
-            ExecutionPayload::V3(p) => config.apply_to_payload_v3(p),
-            ExecutionPayload::V4(p) => config.apply_to_payload_v4(p),
-        };
-
-        let skip_recalc = self.skip_hash_recalc || config.should_skip_hash_recalc();
-        if !skip_recalc {
-            let new_hash = match execution_payload.clone().into_block_raw() {
-                Ok(block) => block.header.hash_slow(),
-                Err(e) => {
-                    eprintln!(
-                        "Warning: Could not recalculate block hash: {e}. Using original hash."
-                    );
-                    match &execution_payload {
-                        ExecutionPayload::V1(p) => p.block_hash,
-                        ExecutionPayload::V2(p) => p.payload_inner.block_hash,
-                        ExecutionPayload::V3(p) => p.payload_inner.payload_inner.block_hash,
-                        ExecutionPayload::V4(p) => {
-                            p.payload_inner.payload_inner.payload_inner.block_hash
-                        }
-                    }
-                }
-            };
-
-            match &mut execution_payload {
-                ExecutionPayload::V1(p) => p.block_hash = new_hash,
-                ExecutionPayload::V2(p) => p.payload_inner.block_hash = new_hash,
-                ExecutionPayload::V3(p) => p.payload_inner.payload_inner.block_hash = new_hash,
-                ExecutionPayload::V4(p) => {
-                    p.payload_inner.payload_inner.payload_inner.block_hash = new_hash
-                }
-            }
-        }
-
-        if self.dry_run {
-            println!("=== Dry Run ===");
-            println!("Changes that would be applied:");
-            for change in &changes {
-                println!("  - {}", change);
-            }
-            if changes.is_empty() {
-                println!("  (no changes)");
-            }
-            if skip_recalc {
-                println!("  - Block hash recalculation: SKIPPED");
-            } else {
-                println!("  - Block hash recalculation: PERFORMED");
-            }
-            println!("\nResulting payload JSON:");
-            let json = serde_json::to_string_pretty(&execution_payload)?;
-            println!("{}", json);
-            return Ok(());
-        }
-
-        let json_request = if use_v4 {
-            serde_json::to_string(&(
-                execution_payload,
-                blob_versioned_hashes,
-                parent_beacon_block_root,
-                requests_hash.unwrap_or_default(),
-            ))?
-        } else {
-            serde_json::to_string(&(
-                execution_payload,
-                blob_versioned_hashes,
-                parent_beacon_block_root,
-            ))?
-        };
-
-        match self.mode {
-            Mode::Execute => {
-                let mut command = std::process::Command::new("cast");
-                let method = if use_v5 {
-                    "engine_newPayloadV5"
-                } else if use_v4 {
-                    "engine_newPayloadV4"
-                } else {
-                    "engine_newPayloadV3"
-                };
-                command.arg("rpc").arg(method).arg("--raw");
-                if let Some(rpc_url) = self.rpc_url {
-                    command.arg("--rpc-url").arg(rpc_url);
-                }
-                if let Some(secret) = &jwt_secret {
-                    command.arg("--jwt-secret").arg(secret);
-                }
-
-                let mut process = command.stdin(std::process::Stdio::piped()).spawn()?;
-
-                process
-                    .stdin
-                    .take()
-                    .ok_or_eyre("stdin not available")?
-                    .write_all(json_request.as_bytes())?;
-
-                process.wait()?;
-            }
-            Mode::Cast => {
-                let mut cmd = format!(
-                    "cast rpc engine_newPayloadV{} --raw '{}'",
-                    self.new_payload_version, json_request
-                );
-
-                if let Some(rpc_url) = self.rpc_url {
-                    cmd += &format!(" --rpc-url {rpc_url}");
-                }
-                if let Some(secret) = &jwt_secret {
-                    cmd += &format!(" --jwt-secret {secret}");
-                }
-
-                println!("{cmd}");
-            }
-            Mode::Json => {
-                println!("{json_request}");
-            }
-        }
-
-        Ok(())
-    }
-
-    async fn fetch_encoded_block_access_list(&self, block_number: u64) -> Result<Bytes> {
-        let rpc_url = self
-            .rpc_url
-            .as_deref()
-            .ok_or_eyre("--rpc-url is required to fetch the block access list for V5 payloads")?;
-        let client = ClientBuilder::default()
-            .layer(alloy_transport::layers::RetryBackoffLayer::new(10, 800, u64::MAX))
-            .http(rpc_url.parse()?);
-        let provider = RootProvider::<AnyNetwork>::new(client);
-        let bal = fetch_block_access_list(&provider, block_number).await?;
-        Ok(alloy_rlp::encode(bal).into())
-    }
-}
diff --git a/bin/reth-bench/src/bench/send_payload.rs b/bin/reth-bench/src/bench/send_payload.rs
deleted file mode 100644
index 02ddd57fe1b..00000000000
--- a/bin/reth-bench/src/bench/send_payload.rs
+++ /dev/null
@@ -1,180 +0,0 @@
-use super::helpers::{fetch_block_access_list, load_jwt_secret, read_input};
-use alloy_consensus::TxEnvelope;
-use alloy_primitives::Bytes;
-use alloy_provider::{
-    network::{AnyNetwork, AnyRpcBlock},
-    RootProvider,
-};
-use alloy_rpc_client::ClientBuilder;
-use alloy_rpc_types_engine::ExecutionPayload;
-use clap::Parser;
-use eyre::{OptionExt, Result};
-use reth_cli_runner::CliContext;
-use std::io::Write;
-
-/// Command for generating and sending an `engine_newPayload` request constructed from an RPC
-/// block.
-#[derive(Debug, Parser)]
-pub struct Command {
-    /// Path to the json file to parse. If not specified, stdin will be used.
-    #[arg(short, long)]
-    path: Option<String>,
-
-    /// The engine RPC url to use.
-    #[arg(
-        short,
-        long,
-        // Required if `mode` is `execute` or `cast`.
-        required_if_eq_any([("mode", "execute"), ("mode", "cast")]),
-        // If `mode` is not specified, then `execute` is used, so we need to require it.
-        required_unless_present("mode")
-    )]
-    rpc_url: Option<String>,
-
-    /// The JWT secret to use. Can be either a path to a file containing the secret or the secret
-    /// itself.
-    #[arg(short, long)]
-    jwt_secret: Option<String>,
-
-    #[arg(long, default_value_t = 3)]
-    new_payload_version: u8,
-
-    /// The mode to use.
-    #[arg(long, value_enum, default_value = "execute")]
-    mode: Mode,
-}
-
-#[derive(Debug, Clone, clap::ValueEnum)]
-enum Mode {
-    /// Execute the `cast` command. This works with blocks of any size, because it pipes the
-    /// payload into the `cast` command.
-    Execute,
-    /// Print the `cast` command. Caution: this may not work with large blocks because of the
-    /// command length limit.
-    Cast,
-    /// Print the JSON payload. Can be piped into `cast` command if the block is small enough.
-    Json,
-}
-
-impl Command {
-    /// Execute the generate payload command
-    pub async fn execute(self, _ctx: CliContext) -> Result<()> {
-        // Load block
-        let block_json = read_input(self.path.as_deref())?;
-
-        // Load JWT secret
-        let jwt_secret = load_jwt_secret(self.jwt_secret.as_deref())?;
-
-        // Parse the block
-        let block = serde_json::from_str::<AnyRpcBlock>(&block_json)?
-            .into_inner()
-            .map_header(|header| header.map(|h| h.into_header_with_defaults()))
-            .try_map_transactions(|tx| -> eyre::Result<TxEnvelope> {
-                tx.try_into().map_err(|_| eyre::eyre!("unsupported tx type"))
-            })?
-            .into_consensus();
-
-        let use_v4 = block.header.requests_hash.is_some();
-        let use_v5 = block.header.block_access_list_hash.is_some();
-
-        // Extract parent beacon block root
-        let parent_beacon_block_root = block.header.parent_beacon_block_root;
-
-        // Extract blob versioned hashes
-        let blob_versioned_hashes =
-            block.body.blob_versioned_hashes_iter().copied().collect::<Vec<_>>();
-
-        // V5 payloads must carry the full RLP-encoded block access list, not just the hash stored
-        // in the header.
-        let execution_payload = if use_v5 {
-            let encoded_bal = self.fetch_encoded_block_access_list(block.header.number).await?;
-            ExecutionPayload::from_block_slow_with_bal(&block, encoded_bal).0
-        } else {
-            ExecutionPayload::from_block_slow(&block).0
-        };
-
-        // Create JSON request data
-        let json_request = if use_v4 {
-            serde_json::to_string(&(
-                execution_payload,
-                blob_versioned_hashes,
-                parent_beacon_block_root,
-                block.header.requests_hash.unwrap_or_default(),
-            ))?
-        } else {
-            serde_json::to_string(&(
-                execution_payload,
-                blob_versioned_hashes,
-                parent_beacon_block_root,
-            ))?
-        };
-
-        // Print output or execute command
-        match self.mode {
-            Mode::Execute => {
-                // Create cast command
-                let mut command = std::process::Command::new("cast");
-                let method = if use_v5 {
-                    "engine_newPayloadV5"
-                } else if use_v4 {
-                    "engine_newPayloadV4"
-                } else {
-                    "engine_newPayloadV3"
-                };
-                command.arg("rpc").arg(method).arg("--raw");
-                if let Some(rpc_url) = self.rpc_url {
-                    command.arg("--rpc-url").arg(rpc_url);
-                }
-                if let Some(secret) = &jwt_secret {
-                    command.arg("--jwt-secret").arg(secret);
-                }
-
-                // Start cast process
-                let mut process = command.stdin(std::process::Stdio::piped()).spawn()?;
-
-                // Write to cast's stdin
-                process
-                    .stdin
-                    .take()
-                    .ok_or_eyre("stdin not available")?
-                    .write_all(json_request.as_bytes())?;
-
-                // Wait for cast to finish
-                process.wait()?;
-            }
-            Mode::Cast => {
-                let mut cmd = format!(
-                    "cast rpc engine_newPayloadV{} --raw '{}'",
-                    self.new_payload_version, json_request
-                );
-
-                if let Some(rpc_url) = self.rpc_url {
-                    cmd += &format!(" --rpc-url {rpc_url}");
-                }
-                if let Some(secret) = &jwt_secret {
-                    cmd += &format!(" --jwt-secret {secret}");
-                }
-
-                println!("{cmd}");
-            }
-            Mode::Json => {
-                println!("{json_request}");
-            }
-        }
-
-        Ok(())
-    }
-
-    async fn fetch_encoded_block_access_list(&self, block_number: u64) -> Result<Bytes> {
-        let rpc_url = self
-            .rpc_url
-            .as_deref()
-            .ok_or_eyre("--rpc-url is required to fetch the block access list for V5 payloads")?;
-        let client = ClientBuilder::default()
-            .layer(alloy_transport::layers::RetryBackoffLayer::new(10, 800, u64::MAX))
-            .http(rpc_url.parse()?);
-        let provider = RootProvider::<AnyNetwork>::new(client);
-        let bal = fetch_block_access_list(&provider, block_number).await?;
-        Ok(alloy_rlp::encode(bal).into())
-    }
-}
diff --git a/bin/reth-bench/src/bench_mode.rs b/bin/reth-bench/src/bench_mode.rs
deleted file mode 100644
index f040246b2aa..00000000000
--- a/bin/reth-bench/src/bench_mode.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-//! The benchmark mode defines whether the benchmark should run for a closed or open range of
-//! blocks.
-use std::ops::RangeInclusive;
-
-/// Whether or not the benchmark should run as a continuous stream of payloads.
-#[derive(Debug, PartialEq, Eq)]
-pub enum BenchMode {
-    /// Run the benchmark as a continuous stream of payloads, until the benchmark is interrupted.
-    Continuous(u64),
-    /// Run the benchmark for a specific range of blocks.
-    Range(RangeInclusive<u64>),
-}
-
-impl BenchMode {
-    /// Check if the block number is in the range
-    pub fn contains(&self, block_number: u64) -> bool {
-        match self {
-            Self::Continuous(start) => block_number >= *start,
-            Self::Range(range) => range.contains(&block_number),
-        }
-    }
-
-    /// Returns the total number of blocks in the benchmark, if known.
-    ///
-    /// For [`BenchMode::Range`] this is the length of the range.
-    /// For [`BenchMode::Continuous`] the total is unbounded, so `None` is returned.
-    pub const fn total_blocks(&self) -> Option<u64> {
-        match self {
-            Self::Continuous(_) => None,
-            Self::Range(range) => {
-                Some(range.end().saturating_sub(*range.start()).saturating_add(1))
-            }
-        }
-    }
-
-    /// Create a [`BenchMode`] from optional `from` and `to` fields.
-    ///
-    /// If only `--to` is provided, `from` is derived as `latest_block + 1`.
-    pub const fn new(from: Option<u64>, to: Option<u64>, latest_block: u64) -> Self {
-        // If neither `--from` nor `--to` are provided, we will run the benchmark continuously,
-        // starting at the latest block.
-        match (from, to) {
-            (Some(from), Some(to)) => Self::Range(from..=to),
-            (None, None) => Self::Continuous(latest_block),
-            (Some(start), None) => Self::Continuous(start),
-            (None, Some(to)) => Self::Range(latest_block + 1..=to),
-        }
-    }
-}
diff --git a/bin/reth-bench/src/main.rs b/bin/reth-bench/src/main.rs
deleted file mode 100644
index 608007e0867..00000000000
--- a/bin/reth-bench/src/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-//! # reth-benchmark
-//!
-//! This is a tool that converts existing blocks into a stream of blocks for benchmarking purposes.
-//! These blocks are then fed into reth as a stream of execution payloads.
-
-#![doc(
-    html_logo_url = "https://raw.githubusercontent.com/paradigmxyz/reth/main/assets/reth-docs.png",
-    html_favicon_url = "https://avatars0.githubusercontent.com/u/97369466?s=256",
-    issue_tracker_base_url = "https://github.com/paradigmxyz/reth/issues/"
-)]
-#![cfg_attr(not(test), warn(unused_crate_dependencies))]
-#![cfg_attr(docsrs, feature(doc_cfg))]
-
-#[global_allocator]
-static ALLOC: reth_cli_util::allocator::Allocator = reth_cli_util::allocator::new_allocator();
-
-#[cfg(all(feature = "jemalloc", unix))]
-use reth_cli_util::allocator::tikv_jemalloc_sys as _;
-
-pub mod authenticated_transport;
-pub mod bench;
-pub mod bench_mode;
-pub mod valid_payload;
-
-use bench::BenchmarkCommand;
-use clap::Parser;
-use reth_cli_runner::CliRunner;
-
-fn main() -> eyre::Result<()> {
-    // Enable backtraces unless a RUST_BACKTRACE value has already been explicitly provided.
-    if std::env::var_os("RUST_BACKTRACE").is_none() {
-        unsafe {
-            std::env::set_var("RUST_BACKTRACE", "1");
-        }
-    }
-
-    color_eyre::install()?;
-
-    // Run until either exit or sigint or sigterm
-    let runner = CliRunner::try_default_runtime()?;
-    runner.run_command_until_exit(|ctx| BenchmarkCommand::parse().execute(ctx))?;
-
-    Ok(())
-}
diff --git a/bin/reth-bench/src/valid_payload.rs b/bin/reth-bench/src/valid_payload.rs
deleted file mode 100644
index 70cc239bd57..00000000000
--- a/bin/reth-bench/src/valid_payload.rs
+++ /dev/null
@@ -1,494 +0,0 @@
-//! This is an extension trait for any provider that implements the engine API, to wait for a VALID
-//! response. This is useful for benchmarking, as it allows us to wait for a payload to be valid
-//! before sending additional calls.
-
-use alloy_consensus::TxEnvelope;
-use alloy_eips::eip7928::BlockAccessList;
-use alloy_primitives::Bytes;
-use alloy_provider::{ext::EngineApi, network::AnyRpcBlock, Network, Provider};
-use alloy_rpc_types_engine::{
-    ExecutionData, ExecutionPayload, ExecutionPayloadInputV2, ExecutionPayloadSidecar,
-    ForkchoiceState, ForkchoiceUpdated, PayloadAttributes, PayloadStatus,
-};
-use alloy_transport::TransportResult;
-use reth_node_api::EngineApiMessageVersion;
-use reth_node_core::args::WaitForPersistence;
-use reth_rpc_api::RethNewPayloadInput;
-use serde::Deserialize;
-use std::time::Duration;
-use tracing::{debug, error};
-
-/// An extension trait for providers that implement the engine API, to wait for a VALID response.
-#[async_trait::async_trait]
-pub trait EngineApiValidWaitExt<N>: Send + Sync {
-    /// Calls `engine_forkChoiceUpdatedV1` with the given [`ForkchoiceState`] and optional
-    /// [`PayloadAttributes`], and waits until the response is VALID.
-    async fn fork_choice_updated_v1_wait(
-        &self,
-        fork_choice_state: ForkchoiceState,
-        payload_attributes: Option<PayloadAttributes>,
-    ) -> TransportResult<ForkchoiceUpdated>;
-
-    /// Calls `engine_forkChoiceUpdatedV2` with the given [`ForkchoiceState`] and optional
-    /// [`PayloadAttributes`], and waits until the response is VALID.
-    async fn fork_choice_updated_v2_wait(
-        &self,
-        fork_choice_state: ForkchoiceState,
-        payload_attributes: Option<PayloadAttributes>,
-    ) -> TransportResult<ForkchoiceUpdated>;
-
-    /// Calls `engine_forkChoiceUpdatedV3` with the given [`ForkchoiceState`] and optional
-    /// [`PayloadAttributes`], and waits until the response is VALID.
-    async fn fork_choice_updated_v3_wait(
-        &self,
-        fork_choice_state: ForkchoiceState,
-        payload_attributes: Option<PayloadAttributes>,
-    ) -> TransportResult<ForkchoiceUpdated>;
-
-    /// Calls `engine_forkChoiceUpdatedV4` with the given [`ForkchoiceState`] and optional
-    /// [`PayloadAttributes`], and waits until the response is VALID.
-    async fn fork_choice_updated_v4_wait(
-        &self,
-        fork_choice_state: ForkchoiceState,
-        payload_attributes: Option<PayloadAttributes>,
-    ) -> TransportResult<ForkchoiceUpdated>;
-}
-
-#[async_trait::async_trait]
-impl<N, P> EngineApiValidWaitExt<N> for P
-where
-    N: Network,
-    P: Provider<N> + EngineApi<N>,
-{
-    async fn fork_choice_updated_v1_wait(
-        &self,
-        fork_choice_state: ForkchoiceState,
-        payload_attributes: Option<PayloadAttributes>,
-    ) -> TransportResult<ForkchoiceUpdated> {
-        debug!(
-            target: "reth-bench",
-            method = "engine_forkchoiceUpdatedV1",
-            ?fork_choice_state,
-            ?payload_attributes,
-            "Sending forkchoiceUpdated"
-        );
-
-        let mut status =
-            self.fork_choice_updated_v1(fork_choice_state, payload_attributes.clone()).await?;
-
-        while !status.is_valid() {
-            if status.is_invalid() {
-                error!(
-                    target: "reth-bench",
-                    ?status,
-                    ?fork_choice_state,
-                    ?payload_attributes,
-                    "Invalid forkchoiceUpdatedV1 message",
-                );
-                panic!("Invalid forkchoiceUpdatedV1: {status:?}");
-            }
-            if status.is_syncing() {
-                return Err(alloy_json_rpc::RpcError::UnsupportedFeature(
-                    "invalid range: no canonical state found for parent of requested block",
-                ))
-            }
-            status =
-                self.fork_choice_updated_v1(fork_choice_state, payload_attributes.clone()).await?;
-        }
-
-        Ok(status)
-    }
-
-    async fn fork_choice_updated_v2_wait(
-        &self,
-        fork_choice_state: ForkchoiceState,
-        payload_attributes: Option<PayloadAttributes>,
-    ) -> TransportResult<ForkchoiceUpdated> {
-        debug!(
-            target: "reth-bench",
-            method = "engine_forkchoiceUpdatedV2",
-            ?fork_choice_state,
-            ?payload_attributes,
-            "Sending forkchoiceUpdated"
-        );
-
-        let mut status =
-            self.fork_choice_updated_v2(fork_choice_state, payload_attributes.clone()).await?;
-
-        while !status.is_valid() {
-            if status.is_invalid() {
-                error!(
-                    target: "reth-bench",
-                    ?status,
-                    ?fork_choice_state,
-                    ?payload_attributes,
-                    "Invalid forkchoiceUpdatedV2 message",
-                );
-                panic!("Invalid forkchoiceUpdatedV2: {status:?}");
-            }
-            if status.is_syncing() {
-                return Err(alloy_json_rpc::RpcError::UnsupportedFeature(
-                    "invalid range: no canonical state found for parent of requested block",
-                ))
-            }
-            status =
-                self.fork_choice_updated_v2(fork_choice_state, payload_attributes.clone()).await?;
-        }
-
-        Ok(status)
-    }
-
-    async fn fork_choice_updated_v3_wait(
-        &self,
-        fork_choice_state: ForkchoiceState,
-        payload_attributes: Option<PayloadAttributes>,
-    ) -> TransportResult<ForkchoiceUpdated> {
-        debug!(
-            target: "reth-bench",
-            method = "engine_forkchoiceUpdatedV3",
-            ?fork_choice_state,
-            ?payload_attributes,
-            "Sending forkchoiceUpdated"
-        );
-
-        let mut status =
-            self.fork_choice_updated_v3(fork_choice_state, payload_attributes.clone()).await?;
-
-        while !status.is_valid() {
-            if status.is_invalid() {
-                error!(
-                    target: "reth-bench",
-                    ?status,
-                    ?fork_choice_state,
-                    ?payload_attributes,
-                    "Invalid forkchoiceUpdatedV3 message",
-                );
-                panic!("Invalid forkchoiceUpdatedV3: {status:?}");
-            }
-            status =
-                self.fork_choice_updated_v3(fork_choice_state, payload_attributes.clone()).await?;
-        }
-
-        Ok(status)
-    }
-
-    async fn fork_choice_updated_v4_wait(
-        &self,
-        fork_choice_state: ForkchoiceState,
-        payload_attributes: Option<PayloadAttributes>,
-    ) -> TransportResult<ForkchoiceUpdated> {
-        debug!(
-            target: "reth-bench",
-            method = "engine_forkchoiceUpdatedV3",
-            ?fork_choice_state,
-            ?payload_attributes,
-            "Sending forkchoiceUpdated"
-        );
-
-        let mut status =
-            self.fork_choice_updated_v4(fork_choice_state, payload_attributes.clone()).await?;
-
-        while !status.is_valid() {
-            if status.is_invalid() {
-                error!(
-                    target: "reth-bench",
-                    ?status,
-                    ?fork_choice_state,
-                    ?payload_attributes,
-                    "Invalid forkchoiceUpdatedV4 message",
-                );
-                panic!("Invalid forkchoiceUpdatedV4: {status:?}");
-            }
-            status =
-                self.fork_choice_updated_v4(fork_choice_state, payload_attributes.clone()).await?;
-        }
-
-        Ok(status)
-    }
-}
-
-/// Converts an RPC block into versioned engine API params and an [`ExecutionData`].
-///
-/// Returns `(version, versioned_params, execution_data)`.
-///
-/// `wait_for_persistence` controls how `wait_for_persistence` is passed to
-/// `reth_newPayload` on a per-block basis.
-pub(crate) fn block_to_new_payload(
-    block: AnyRpcBlock,
-    rlp: Option<Bytes>,
-    reth_new_payload: bool,
-    wait_for_persistence: WaitForPersistence,
-    no_wait_for_caches: bool,
-    bal: Option<BlockAccessList>,
-) -> eyre::Result<(Option<EngineApiMessageVersion>, serde_json::Value)> {
-    let block_number = block.header.number;
-    let wait_for_persistence = wait_for_persistence.rpc_value(block_number);
-
-    if let Some(rlp) = rlp {
-        return Ok((
-            None,
-            serde_json::to_value((
-                RethNewPayloadInput::<ExecutionData>::BlockRlp(rlp),
-                wait_for_persistence,
-                no_wait_for_caches.then_some(false),
-            ))?,
-        ));
-    }
-
-    let block = 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 block_access_list = alloy_rlp::encode(bal.unwrap_or_default());
-
-    let (payload, sidecar) =
-        ExecutionPayload::from_block_slow_with_bal(&block, block_access_list.into());
-    let (version, params, execution_data) = payload_to_new_payload(payload, sidecar, None)?;
-
-    if reth_new_payload {
-        Ok((
-            None,
-            serde_json::to_value((
-                RethNewPayloadInput::ExecutionData(execution_data),
-                wait_for_persistence,
-                no_wait_for_caches.then_some(false),
-            ))?,
-        ))
-    } else {
-        Ok((Some(version), params))
-    }
-}
-
-/// Converts an execution payload and sidecar into versioned engine API params and an
-/// [`ExecutionData`].
-///
-/// Returns `(version, versioned_params, execution_data)`.
-pub(crate) fn payload_to_new_payload(
-    payload: ExecutionPayload,
-    sidecar: ExecutionPayloadSidecar,
-    target_version: Option<EngineApiMessageVersion>,
-) -> eyre::Result<(EngineApiMessageVersion, serde_json::Value, ExecutionData)> {
-    let execution_data = ExecutionData { payload: payload.clone(), sidecar: sidecar.clone() };
-
-    let (version, params) = match payload {
-        ExecutionPayload::V4(payload) => {
-            let cancun = sidecar
-                .cancun()
-                .ok_or_else(|| eyre::eyre!("missing cancun sidecar for V4 payload"))?;
-            let version = target_version.unwrap_or(EngineApiMessageVersion::V6);
-            let requests = sidecar.prague().map(|p| p.requests.clone()).unwrap_or_default();
-            (
-                version,
-                serde_json::to_value((
-                    payload,
-                    cancun.versioned_hashes.clone(),
-                    cancun.parent_beacon_block_root,
-                    requests,
-                ))?,
-            )
-        }
-        ExecutionPayload::V3(payload) => {
-            let cancun = sidecar
-                .cancun()
-                .ok_or_else(|| eyre::eyre!("missing cancun sidecar for V3 payload"))?;
-
-            if let Some(prague) = sidecar.prague() {
-                let version = target_version.unwrap_or(EngineApiMessageVersion::V4);
-                let requests = prague.requests.clone();
-                (
-                    version,
-                    serde_json::to_value((
-                        payload,
-                        cancun.versioned_hashes.clone(),
-                        cancun.parent_beacon_block_root,
-                        requests,
-                    ))?,
-                )
-            } else {
-                (
-                    EngineApiMessageVersion::V3,
-                    serde_json::to_value((
-                        payload,
-                        cancun.versioned_hashes.clone(),
-                        cancun.parent_beacon_block_root,
-                    ))?,
-                )
-            }
-        }
-        ExecutionPayload::V2(payload) => {
-            let input = ExecutionPayloadInputV2 {
-                execution_payload: payload.payload_inner,
-                withdrawals: Some(payload.withdrawals),
-            };
-
-            (EngineApiMessageVersion::V2, serde_json::to_value((input,))?)
-        }
-        ExecutionPayload::V1(payload) => {
-            (EngineApiMessageVersion::V1, serde_json::to_value((payload,))?)
-        }
-    };
-
-    Ok((version, params, execution_data))
-}
-
-/// Calls the correct `engine_newPayload` method depending on the given execution payload and its
-/// versioned variant. Returns the [`EngineApiMessageVersion`] depending on the payload's version.
-///
-/// # Panics
-/// If the given payload is a V3 payload, but a parent beacon block root is provided as `None`.
-#[allow(dead_code)]
-pub(crate) async fn call_new_payload<N: Network, P: Provider<N>>(
-    provider: P,
-    version: Option<EngineApiMessageVersion>,
-    params: serde_json::Value,
-) -> eyre::Result<Option<NewPayloadTimingBreakdown>> {
-    call_new_payload_with_reth(provider, version, params).await
-}
-
-/// Response from `reth_newPayload` endpoint, which includes server-measured latency.
-#[derive(Debug, Deserialize)]
-struct RethPayloadStatus {
-    latency_us: u64,
-    #[serde(default)]
-    persistence_wait_us: u64,
-    #[serde(default)]
-    execution_cache_wait_us: u64,
-    #[serde(default)]
-    sparse_trie_wait_us: u64,
-}
-
-/// Server-side timing breakdown from `reth_newPayload` endpoint.
-#[derive(Debug, Clone, Copy, Default)]
-pub(crate) struct NewPayloadTimingBreakdown {
-    /// Server-side execution latency.
-    pub(crate) latency: Duration,
-    /// Time spent waiting on persistence (backpressure + explicit wait).
-    pub(crate) persistence_wait: Duration,
-    /// Time spent waiting for execution cache lock.
-    pub(crate) execution_cache_wait: Duration,
-    /// Time spent waiting for sparse trie lock.
-    pub(crate) sparse_trie_wait: Duration,
-}
-
-/// Calls either `engine_newPayload*` or `reth_newPayload` depending on whether
-/// `version` is provided.
-///
-/// When `version` is `None`, uses `reth_newPayload` endpoint with provided params.
-///
-/// Returns the server-reported timing breakdown when using the reth namespace, or `None` for
-/// the standard engine namespace.
-pub(crate) async fn call_new_payload_with_reth<N: Network, P: Provider<N>>(
-    provider: P,
-    version: Option<EngineApiMessageVersion>,
-    params: serde_json::Value,
-) -> eyre::Result<Option<NewPayloadTimingBreakdown>> {
-    let method = version.map(|v| v.method_name()).unwrap_or("reth_newPayload");
-
-    debug!(target: "reth-bench", method, "Sending newPayload");
-
-    let resp = loop {
-        let resp: serde_json::Value = provider.client().request(method, &params).await?;
-        let status = PayloadStatus::deserialize(&resp)?;
-
-        if status.is_valid() {
-            break resp;
-        }
-        if status.is_invalid() {
-            return Err(eyre::eyre!("Invalid {method}: {status:?}"));
-        }
-        if status.is_syncing() {
-            return Err(eyre::eyre!(
-                "invalid range: no canonical state found for parent of requested block"
-            ));
-        }
-    };
-
-    if version.is_some() {
-        return Ok(None);
-    }
-
-    let resp: RethPayloadStatus = serde_json::from_value(resp)?;
-
-    Ok(Some(NewPayloadTimingBreakdown {
-        latency: Duration::from_micros(resp.latency_us),
-        persistence_wait: Duration::from_micros(resp.persistence_wait_us),
-        execution_cache_wait: Duration::from_micros(resp.execution_cache_wait_us),
-        sparse_trie_wait: Duration::from_micros(resp.sparse_trie_wait_us),
-    }))
-}
-
-/// Calls the correct `engine_forkchoiceUpdated` method depending on the given
-/// `EngineApiMessageVersion`, using the provided forkchoice state and payload attributes for the
-/// actual engine api message call.
-///
-/// Note: For Prague (V4), we still use forkchoiceUpdatedV3 as there is no V4.
-pub(crate) async fn call_forkchoice_updated<N, P: EngineApiValidWaitExt<N>>(
-    provider: P,
-    message_version: EngineApiMessageVersion,
-    forkchoice_state: ForkchoiceState,
-    payload_attributes: Option<PayloadAttributes>,
-) -> TransportResult<ForkchoiceUpdated> {
-    // FCU V3 is used for both Cancun and Prague (there is no FCU V4)
-    match message_version {
-        EngineApiMessageVersion::V6 => {
-            provider.fork_choice_updated_v4_wait(forkchoice_state, payload_attributes).await
-        }
-        EngineApiMessageVersion::V3 | EngineApiMessageVersion::V4 | EngineApiMessageVersion::V5 => {
-            provider.fork_choice_updated_v3_wait(forkchoice_state, payload_attributes).await
-        }
-        EngineApiMessageVersion::V2 => {
-            provider.fork_choice_updated_v2_wait(forkchoice_state, payload_attributes).await
-        }
-        EngineApiMessageVersion::V1 => {
-            provider.fork_choice_updated_v1_wait(forkchoice_state, payload_attributes).await
-        }
-    }
-}
-
-/// Calls either `reth_forkchoiceUpdated` or the standard `engine_forkchoiceUpdated*` depending
-/// on `use_reth`.
-///
-/// When `use_reth` is true, uses the `reth_forkchoiceUpdated` endpoint which sends a regular FCU
-/// with no payload attributes.
-pub(crate) async fn call_forkchoice_updated_with_reth<
-    N: Network,
-    P: Provider<N> + EngineApiValidWaitExt<N>,
->(
-    provider: P,
-    message_version: Option<EngineApiMessageVersion>,
-    forkchoice_state: ForkchoiceState,
-) -> TransportResult<ForkchoiceUpdated> {
-    if let Some(message_version) = message_version {
-        call_forkchoice_updated(provider, message_version, forkchoice_state, None).await
-    } else {
-        let method = "reth_forkchoiceUpdated";
-        let reth_params = serde_json::to_value((forkchoice_state,))
-            .expect("ForkchoiceState serialization cannot fail");
-
-        debug!(target: "reth-bench", method, "Sending forkchoiceUpdated");
-
-        loop {
-            let resp: ForkchoiceUpdated = provider.client().request(method, &reth_params).await?;
-
-            if resp.is_valid() {
-                break Ok(resp)
-            }
-
-            if resp.is_invalid() {
-                error!(target: "reth-bench", ?resp, "Invalid {method}");
-                return Err(alloy_json_rpc::RpcError::LocalUsageError(Box::new(
-                    std::io::Error::other(format!("Invalid {method}: {resp:?}")),
-                )))
-            }
-            if resp.is_syncing() {
-                return Err(alloy_json_rpc::RpcError::UnsupportedFeature(
-                    "invalid range: no canonical state found for parent of requested block",
-                ))
-            }
-        }
-    }
-}
diff --git a/bin/reth/Cargo.toml b/bin/reth/Cargo.toml
index 50523abf794..288f44db4a4 100644
--- a/bin/reth/Cargo.toml
+++ b/bin/reth/Cargo.toml
@@ -76,14 +76,16 @@ reth-firehose.workspace = true
 reth-ethereum-forks.workspace = true
 
 [dev-dependencies]
-alloy-node-bindings = "2.0.0"
+alloy-node-bindings = "2.0.5"
 alloy-provider = { workspace = true, features = ["reqwest"] }
 alloy-rpc-types-eth.workspace = true
 backon.workspace = true
 serde_json.workspace = true
+tar.workspace = true
 tempfile.workspace = true
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 toml.workspace = true
+zstd.workspace = true
 
 [features]
 default = [
@@ -94,7 +96,7 @@ default = [
     "js-tracer",
     "keccak-cache-global",
     "asm-keccak",
-    "min-debug-logs",
+    "min-trace-logs",
 ]
 
 otlp = [
diff --git a/bin/reth/tests/it/main.rs b/bin/reth/tests/it/main.rs
index 8925168a1a9..d71390501d6 100644
--- a/bin/reth/tests/it/main.rs
+++ b/bin/reth/tests/it/main.rs
@@ -1,6 +1,6 @@
 #![allow(missing_docs)]
 
-use std::process::Command;
+use std::{fs, path::Path, process::Command};
 
 const RETH: &str = env!("CARGO_BIN_EXE_reth");
 
@@ -40,6 +40,23 @@ fn spawn_dev() -> (alloy_node_bindings::RethInstance, tempfile::TempDir) {
     (instance, datadir)
 }
 
+fn create_tar_zst_snapshot(path: &Path) {
+    let file = fs::File::create(path).expect("failed to create snapshot archive");
+    let encoder = zstd::Encoder::new(file, 0).expect("failed to create zstd encoder");
+    let mut archive = tar::Builder::new(encoder);
+
+    let contents = b"new snapshot data";
+    let mut header = tar::Header::new_gnu();
+    header.set_path("db/new.snapshot").expect("failed to set archive path");
+    header.set_size(contents.len() as u64);
+    header.set_mode(0o644);
+    header.set_cksum();
+    archive.append(&header, contents.as_slice()).expect("failed to append archive file");
+
+    let encoder = archive.into_inner().expect("failed to finish tar archive");
+    encoder.finish().expect("failed to finish zstd archive");
+}
+
 // ── Original tests (from PR #22069) ──────────────────────────────────────────
 
 #[test]
@@ -165,6 +182,57 @@ fn prune_help() {
 fn download_help() {
     let stdout = reth_ok(&["download", "--help"]);
     assert!(stdout.contains("--chain"), "stdout: {stdout}");
+    assert!(stdout.contains("--force"), "stdout: {stdout}");
+}
+
+#[test]
+fn download_force_removes_only_snapshot_paths() {
+    let tempdir = tempfile::tempdir().expect("failed to create temp dir");
+    let datadir = tempdir.path().join("datadir");
+    let archive_path = tempdir.path().join("snapshot.tar.zst");
+
+    fs::create_dir_all(datadir.join("db")).expect("failed to create old db dir");
+    fs::create_dir_all(datadir.join("rocksdb")).expect("failed to create old rocksdb dir");
+    fs::create_dir_all(datadir.join("static_files")).expect("failed to create old static dir");
+    fs::create_dir_all(datadir.join("custom-dir")).expect("failed to create custom dir");
+    fs::write(datadir.join("db/old.mdbx"), b"old db").expect("failed to write old db file");
+    fs::write(datadir.join("rocksdb/old"), b"old rocksdb").expect("failed to write old rocksdb");
+    fs::write(datadir.join("static_files/old"), b"old static")
+        .expect("failed to write old static file");
+    fs::write(datadir.join("reth.toml"), b"old config").expect("failed to write old config");
+    fs::write(datadir.join("discovery-secret"), b"secret").expect("failed to write secret");
+    fs::write(datadir.join("known-peers.json"), br#"["peer"]"#)
+        .expect("failed to write known peers");
+    fs::write(datadir.join("custom-file"), b"custom").expect("failed to write custom file");
+    fs::write(datadir.join("custom-dir/file"), b"custom dir")
+        .expect("failed to write custom dir file");
+    create_tar_zst_snapshot(&archive_path);
+
+    let datadir_arg = datadir.to_str().expect("datadir should be utf8");
+    let archive_url = format!("file://{}", archive_path.display());
+    reth_ok(&["download", "--datadir", datadir_arg, "--url", &archive_url, "--force"]);
+
+    assert_eq!(
+        fs::read(datadir.join("db/new.snapshot")).expect("missing extracted snapshot file"),
+        b"new snapshot data"
+    );
+    assert!(!datadir.join("db/old.mdbx").exists(), "old db file should be removed");
+    assert!(!datadir.join("rocksdb/old").exists(), "old rocksdb file should be removed");
+    assert!(!datadir.join("static_files/old").exists(), "old static file should be removed");
+    assert!(!datadir.join("reth.toml").exists(), "old config file should be removed");
+    assert_eq!(
+        fs::read(datadir.join("discovery-secret")).expect("missing preserved discovery secret"),
+        b"secret"
+    );
+    assert_eq!(
+        fs::read(datadir.join("known-peers.json")).expect("missing preserved known peers"),
+        br#"["peer"]"#
+    );
+    assert_eq!(fs::read(datadir.join("custom-file")).expect("missing custom file"), b"custom");
+    assert_eq!(
+        fs::read(datadir.join("custom-dir/file")).expect("missing custom dir file"),
+        b"custom dir"
+    );
 }
 
 #[test]
diff --git a/crates/chain-state/Cargo.toml b/crates/chain-state/Cargo.toml
index a4ce20fd434..ab85cc8fce9 100644
--- a/crates/chain-state/Cargo.toml
+++ b/crates/chain-state/Cargo.toml
@@ -20,6 +20,7 @@ reth-metrics.workspace = true
 reth-ethereum-primitives.workspace = true
 reth-primitives-traits = { workspace = true, features = ["dashmap"] }
 reth-storage-api.workspace = true
+reth-tasks = { workspace = true, features = ["rayon"], optional = true }
 reth-trie.workspace = true
 
 # ethereum
@@ -83,5 +84,6 @@ test-utils = [
     "reth-primitives-traits/test-utils",
     "reth-trie/test-utils",
     "reth-ethereum-primitives/test-utils",
+    "reth-tasks?/test-utils",
 ]
-rayon = ["dep:rayon"]
+rayon = ["dep:rayon", "dep:reth-tasks"]
diff --git a/crates/chain-state/src/deferred_trie.rs b/crates/chain-state/src/deferred_trie.rs
index 5f1a8e72552..cd4b31a7e2c 100644
--- a/crates/chain-state/src/deferred_trie.rs
+++ b/crates/chain-state/src/deferred_trie.rs
@@ -1,56 +1,63 @@
-use alloy_primitives::B256;
-use parking_lot::Mutex;
 use reth_metrics::{metrics::Counter, Metrics};
 use reth_trie::{
     updates::{TrieUpdates, TrieUpdatesSorted},
-    HashedPostState, HashedPostStateSorted, TrieInputSorted,
+    HashedPostState, HashedPostStateSorted,
 };
 use std::{
     fmt,
-    sync::{Arc, LazyLock},
+    sync::{Arc, LazyLock, OnceLock},
 };
 use tracing::{debug_span, instrument};
 
-/// Shared handle to asynchronously populated trie data.
+/// Shared handle to asynchronously populated sorted per-block trie data.
 ///
-/// Uses a try-lock + fallback computation approach for deadlock-free access.
-/// If the deferred task hasn't completed, computes trie data synchronously
-/// from stored unsorted inputs rather than blocking.
+/// The corresponding [`DeferredTrieDataProducer`] owns the unsorted inputs and publishes the sorted
+/// data when the background task completes. Callers wait for that result instead of computing it
+/// synchronously.
 #[derive(Clone)]
 pub struct DeferredTrieData {
-    /// Shared deferred state holding either raw inputs (pending) or computed result (ready).
-    state: Arc<Mutex<DeferredState>>,
+    /// Shared deferred result populated by the corresponding [`DeferredTrieDataProducer`].
+    value: Arc<OnceLock<ComputedTrieData>>,
 }
 
-/// Sorted trie data computed for an executed block.
-/// These represent the complete set of sorted trie data required to persist
-/// block state for, and generate proofs on top of, a block.
+/// Producer consumed by a spawned task to compute sorted trie data for a [`DeferredTrieData`]
+/// handle.
+#[must_use = "DeferredTrieDataProducer must be consumed with compute_and_publish to wake trie data waiters"]
+pub struct DeferredTrieDataProducer {
+    /// Shared result initialized exactly once by this producer.
+    value: Arc<OnceLock<ComputedTrieData>>,
+    /// Unsorted inputs consumed when the producer computes trie data.
+    inputs: PendingInputs,
+}
+
+impl fmt::Debug for DeferredTrieDataProducer {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("DeferredTrieDataProducer")
+            .field("inputs", &self.inputs)
+            .finish_non_exhaustive()
+    }
+}
+
+impl DeferredTrieDataProducer {
+    /// Computes sorted trie data, publishes it to waiters, and returns it to the task owner.
+    pub fn compute_and_publish(self) -> ComputedTrieData {
+        let Self { value, inputs } = self;
+        let computed = DeferredTrieData::sort(inputs.hashed_state, inputs.trie_updates);
+        let _ = value.set(computed.clone());
+        computed
+    }
+}
+
+/// Sorted trie data computed for one executed block.
+///
+/// Cumulative overlays are intentionally managed by
+/// [`StateTrieOverlayManager`](crate::StateTrieOverlayManager), not by each block.
 #[derive(Clone, Debug, Default)]
 pub struct ComputedTrieData {
     /// Sorted hashed post-state produced by execution.
     pub hashed_state: Arc<HashedPostStateSorted>,
     /// Sorted trie updates produced by state root computation.
     pub trie_updates: Arc<TrieUpdatesSorted>,
-    /// Trie input bundled with its anchor hash, if available.
-    pub anchored_trie_input: Option<AnchoredTrieInput>,
-}
-
-/// Trie input bundled with its anchor hash.
-///
-/// The `trie_input` contains the **cumulative** overlay of all in-memory ancestor blocks,
-/// not just this block's changes. Child blocks reuse the parent's overlay in O(1) by
-/// cloning the Arc-wrapped data.
-///
-/// The `anchor_hash` is metadata indicating which persisted base state this overlay
-/// sits on top of. It is CRITICAL for overlay reuse decisions: an overlay built on top
-/// of Anchor A cannot be reused for a block anchored to Anchor B, as it would result
-/// in an incorrect state.
-#[derive(Clone, Debug)]
-pub struct AnchoredTrieInput {
-    /// The persisted ancestor hash this trie input is anchored to.
-    pub anchor_hash: B256,
-    /// Cumulative trie input overlay from all in-memory ancestors.
-    pub trie_input: Arc<TrieInputSorted>,
 }
 
 /// Metrics for deferred trie computation.
@@ -59,22 +66,13 @@ pub struct AnchoredTrieInput {
 struct DeferredTrieMetrics {
     /// Number of times deferred trie data was ready (async task completed first).
     deferred_trie_async_ready: Counter,
-    /// Number of times deferred trie data required synchronous computation (fallback path).
-    deferred_trie_sync_fallback: Counter,
+    /// Number of times deferred trie data required waiting for the publishing task.
+    deferred_trie_task_wait: Counter,
 }
 
 static DEFERRED_TRIE_METRICS: LazyLock<DeferredTrieMetrics> =
     LazyLock::new(DeferredTrieMetrics::default);
 
-/// Internal state for deferred trie data.
-enum DeferredState {
-    /// Data is not yet available; raw inputs stored for fallback computation.
-    /// Wrapped in `Option` to allow taking ownership during computation.
-    Pending(Option<PendingInputs>),
-    /// Data has been computed and is ready.
-    Ready(ComputedTrieData),
-}
-
 /// Inputs kept while a deferred trie computation is pending.
 #[derive(Clone, Debug)]
 struct PendingInputs {
@@ -82,86 +80,41 @@ struct PendingInputs {
     hashed_state: Arc<HashedPostState>,
     /// Unsorted trie updates from state root computation.
     trie_updates: Arc<TrieUpdates>,
-    /// The persisted ancestor hash this trie input is anchored to.
-    anchor_hash: B256,
-    /// Deferred trie data from ancestor blocks for merging.
-    ancestors: Vec<DeferredTrieData>,
 }
 
 impl fmt::Debug for DeferredTrieData {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let state = self.state.lock();
-        match &*state {
-            DeferredState::Pending(_) => {
-                f.debug_struct("DeferredTrieData").field("state", &"pending").finish()
-            }
-            DeferredState::Ready(_) => {
-                f.debug_struct("DeferredTrieData").field("state", &"ready").finish()
-            }
-        }
+        f.debug_struct("DeferredTrieData")
+            .field("state", &if self.value.get().is_some() { "ready" } else { "pending" })
+            .finish()
     }
 }
 
 impl DeferredTrieData {
-    /// Create a new pending handle with fallback inputs for synchronous computation.
-    ///
-    /// If the async task hasn't completed when `wait_cloned` is called, the trie data
-    /// will be computed synchronously from these inputs. This eliminates deadlock risk.
-    ///
-    /// # Arguments
-    /// * `hashed_state` - Unsorted hashed post-state from execution
-    /// * `trie_updates` - Unsorted trie updates from state root computation
-    /// * `anchor_hash` - The persisted ancestor hash this trie input is anchored to
-    /// * `ancestors` - Deferred trie data from ancestor blocks for merging
+    /// Create a new pending handle and task that will publish the computed trie data.
     pub fn pending(
         hashed_state: Arc<HashedPostState>,
         trie_updates: Arc<TrieUpdates>,
-        anchor_hash: B256,
-        ancestors: Vec<Self>,
-    ) -> Self {
-        Self {
-            state: Arc::new(Mutex::new(DeferredState::Pending(Some(PendingInputs {
-                hashed_state,
-                trie_updates,
-                anchor_hash,
-                ancestors,
-            })))),
-        }
+    ) -> (Self, DeferredTrieDataProducer) {
+        let value = Arc::new(OnceLock::new());
+        (
+            Self { value: Arc::clone(&value) },
+            DeferredTrieDataProducer {
+                value,
+                inputs: PendingInputs { hashed_state, trie_updates },
+            },
+        )
     }
 
     /// Create a handle that is already populated with the given [`ComputedTrieData`].
-    ///
-    /// Useful when trie data is available immediately.
-    /// [`Self::wait_cloned`] will return without any computation.
     pub fn ready(bundle: ComputedTrieData) -> Self {
-        Self { state: Arc::new(Mutex::new(DeferredState::Ready(bundle))) }
+        Self { value: Arc::new(OnceLock::from(bundle)) }
     }
 
-    /// Sort block execution outputs and build a [`TrieInputSorted`] overlay.
-    ///
-    /// The trie input overlay accumulates sorted hashed state (account/storage changes) and
-    /// trie node updates from all in-memory ancestor blocks. This overlay is required for:
-    /// - Computing state roots on top of in-memory blocks
-    /// - Generating storage/account proofs for unpersisted state
-    ///
-    /// # Process
-    /// 1. Sort the current block's hashed state and trie updates
-    /// 2. Reuse parent's cached overlay if available (O(1) - the common case)
-    /// 3. Otherwise, rebuild overlay from ancestors (rare fallback)
-    /// 4. Extend the overlay with this block's sorted data
-    ///
-    /// Used by both the async background task and the synchronous fallback path.
-    ///
-    /// # Arguments
-    /// * `hashed_state` - Unsorted hashed post-state (account/storage changes) from execution
-    /// * `trie_updates` - Unsorted trie node updates from state root computation
-    /// * `anchor_hash` - The persisted ancestor hash this trie input is anchored to
-    /// * `ancestors` - Deferred trie data from ancestor blocks for merging (oldest -> newest)
-    pub fn sort_and_build_trie_input(
+    /// Sorts block execution outputs.
+    pub fn sort(
         hashed_state: Arc<HashedPostState>,
         trie_updates: Arc<TrieUpdates>,
-        anchor_hash: B256,
-        ancestors: &[Self],
     ) -> ComputedTrieData {
         let _span = debug_span!(target: "engine::tree::deferred_trie", "sort_inputs").entered();
 
@@ -189,173 +142,10 @@ impl DeferredTrieData {
             },
         );
 
-        drop(_span);
-
-        let _span = debug_span!(target: "engine::tree::deferred_trie", "build_overlay").entered();
-
-        // Reuse parent's overlay if available and anchors match.
-        // We can only reuse the parent's overlay if it was built on top of the same
-        // persisted anchor. If the anchor has changed (e.g., due to persistence),
-        // the parent's overlay is relative to an old state and cannot be used.
-        let overlay = if let Some(parent) = ancestors.last() {
-            let parent_data = parent.wait_cloned();
-
-            match &parent_data.anchored_trie_input {
-                // Case 1: Parent has cached overlay AND anchors match.
-                Some(AnchoredTrieInput { anchor_hash: parent_anchor, trie_input })
-                    if *parent_anchor == anchor_hash =>
-                {
-                    // O(1): Reuse parent's overlay, extend with current block's data.
-                    let mut overlay = TrieInputSorted::new(
-                        Arc::clone(&trie_input.nodes),
-                        Arc::clone(&trie_input.state),
-                        Default::default(), // prefix_sets are per-block, not cumulative
-                    );
-                    let _span =
-                        debug_span!(target: "engine::tree::deferred_trie", "extend_overlay")
-                            .entered();
-                    // Only trigger COW clone if there's actually data to add.
-                    #[cfg(feature = "rayon")]
-                    {
-                        rayon::join(
-                            || {
-                                if !sorted_hashed_state.is_empty() {
-                                    Arc::make_mut(&mut overlay.state)
-                                        .extend_ref_and_sort(&sorted_hashed_state);
-                                }
-                            },
-                            || {
-                                if !sorted_trie_updates.is_empty() {
-                                    Arc::make_mut(&mut overlay.nodes)
-                                        .extend_ref_and_sort(&sorted_trie_updates);
-                                }
-                            },
-                        );
-                    }
-                    #[cfg(not(feature = "rayon"))]
-                    {
-                        if !sorted_hashed_state.is_empty() {
-                            Arc::make_mut(&mut overlay.state)
-                                .extend_ref_and_sort(&sorted_hashed_state);
-                        }
-                        if !sorted_trie_updates.is_empty() {
-                            Arc::make_mut(&mut overlay.nodes)
-                                .extend_ref_and_sort(&sorted_trie_updates);
-                        }
-                    }
-                    overlay
-                }
-                // Case 2: Parent exists but anchor mismatch or no cached overlay.
-                // We must rebuild from the ancestors list (which only contains unpersisted blocks).
-                _ => Self::merge_ancestors_into_overlay(
-                    ancestors,
-                    &sorted_hashed_state,
-                    &sorted_trie_updates,
-                ),
-            }
-        } else {
-            // Case 3: No in-memory ancestors (first block after persisted anchor).
-            // Build overlay with just this block's data.
-            Self::merge_ancestors_into_overlay(&[], &sorted_hashed_state, &sorted_trie_updates)
-        };
-
-        ComputedTrieData::with_trie_input(
-            Arc::new(sorted_hashed_state),
-            Arc::new(sorted_trie_updates),
-            anchor_hash,
-            Arc::new(overlay),
-        )
-    }
-
-    /// Merge all ancestors and current block's data into a single overlay.
-    ///
-    /// This is a rare fallback path, only used when no ancestor has a cached
-    /// `anchored_trie_input` (e.g., blocks created via alternative constructors).
-    /// In normal operation, the parent always has a cached overlay and this
-    /// function is never called.
-    ///
-    /// When the `rayon` feature is enabled:
-    /// 1. Collects ancestor data (states and updates)
-    /// 2. Merges states and trie updates in parallel using k-way merge
-    #[cfg(feature = "rayon")]
-    fn merge_ancestors_into_overlay(
-        ancestors: &[Self],
-        sorted_hashed_state: &HashedPostStateSorted,
-        sorted_trie_updates: &TrieUpdatesSorted,
-    ) -> TrieInputSorted {
-        // Early exit: no ancestors means just wrap current block's data
-        if ancestors.is_empty() {
-            return TrieInputSorted::new(
-                Arc::new(sorted_trie_updates.clone()),
-                Arc::new(sorted_hashed_state.clone()),
-                Default::default(),
-            );
-        }
-
-        // Collect ancestor data in reverse (newest to oldest) for merge_slice
-        let (states, updates): (Vec<_>, Vec<_>) = ancestors
-            .iter()
-            .rev()
-            .map(|a| {
-                // Note: we can assume that this trie data has already been computed
-                let data = a.wait_cloned();
-                (data.hashed_state, data.trie_updates)
-            })
-            .unzip();
-
-        // Merge state and nodes in parallel using k-way merge
-        let (state, nodes) = rayon::join(
-            || {
-                let mut merged = HashedPostStateSorted::merge_slice(&states);
-                merged.extend_ref_and_sort(sorted_hashed_state);
-                merged
-            },
-            || {
-                let mut merged = TrieUpdatesSorted::merge_slice(&updates);
-                merged.extend_ref_and_sort(sorted_trie_updates);
-                merged
-            },
-        );
-
-        TrieInputSorted::new(Arc::new(nodes), Arc::new(state), Default::default())
+        ComputedTrieData::new(Arc::new(sorted_hashed_state), Arc::new(sorted_trie_updates))
     }
 
-    /// Sequential fallback when rayon is not available.
-    #[cfg(not(feature = "rayon"))]
-    fn merge_ancestors_into_overlay(
-        ancestors: &[Self],
-        sorted_hashed_state: &HashedPostStateSorted,
-        sorted_trie_updates: &TrieUpdatesSorted,
-    ) -> TrieInputSorted {
-        let _span = debug_span!(target: "engine::tree::deferred_trie", "merge_ancestors", num_ancestors = ancestors.len()).entered();
-        let mut overlay = TrieInputSorted::default();
-
-        let state_mut = Arc::make_mut(&mut overlay.state);
-        let nodes_mut = Arc::make_mut(&mut overlay.nodes);
-
-        for ancestor in ancestors {
-            let ancestor_data = ancestor.wait_cloned();
-            state_mut.extend_ref_and_sort(ancestor_data.hashed_state.as_ref());
-            nodes_mut.extend_ref_and_sort(ancestor_data.trie_updates.as_ref());
-        }
-
-        state_mut.extend_ref_and_sort(sorted_hashed_state);
-        nodes_mut.extend_ref_and_sort(sorted_trie_updates);
-
-        overlay
-    }
-
-    /// Returns trie data, computing synchronously if the async task hasn't completed.
-    ///
-    /// - If the async task has completed (`Ready`), returns the cached result.
-    /// - If pending, computes synchronously from stored inputs.
-    ///
-    /// Deadlock is avoided as long as the provided ancestors form a true ancestor chain (a DAG):
-    /// - Each block only waits on its ancestors (blocks on the path to the persisted root)
-    /// - Sibling blocks (forks) are never in each other's ancestor lists
-    /// - A block never waits on its descendants
-    ///
-    /// Given that invariant, circular wait dependencies are impossible.
+    /// Returns trie data, waiting for the async publishing task if it has not completed.
     #[instrument(level = "debug", target = "engine::tree::deferred_trie", skip_all)]
     pub fn wait_cloned(&self) -> ComputedTrieData {
         #[cfg(feature = "rayon")]
@@ -363,611 +153,141 @@ impl DeferredTrieData {
             rayon::current_thread_index().is_none(),
             "wait_cloned must not be called from a rayon worker thread"
         );
-        let mut state = self.state.lock();
-        match &mut *state {
-            // If the deferred trie data is ready, return the cached result.
-            DeferredState::Ready(bundle) => {
+        let bundle = match self.value.get() {
+            Some(bundle) => {
                 DEFERRED_TRIE_METRICS.deferred_trie_async_ready.increment(1);
-                bundle.clone()
+                bundle
             }
-            // If the deferred trie data is pending, compute the trie data synchronously and return
-            // the result. This is the fallback path if the async task hasn't completed.
-            DeferredState::Pending(maybe_inputs) => {
-                DEFERRED_TRIE_METRICS.deferred_trie_sync_fallback.increment(1);
-
-                let inputs = maybe_inputs.take().expect("inputs must be present in Pending state");
-
-                let computed = Self::sort_and_build_trie_input(
-                    inputs.hashed_state,
-                    inputs.trie_updates,
-                    inputs.anchor_hash,
-                    &inputs.ancestors,
-                );
-                *state = DeferredState::Ready(computed.clone());
-
-                // Release lock before inputs (and its ancestors) drop to avoid holding it
-                // while their potential last Arc refs drop (which could trigger recursive locking)
-                drop(state);
-
-                computed
+            None => {
+                DEFERRED_TRIE_METRICS.deferred_trie_task_wait.increment(1);
+                self.value.wait()
             }
-        }
+        };
+
+        bundle.clone()
     }
 }
 
 impl ComputedTrieData {
-    /// Construct a bundle that includes trie input anchored to a persisted ancestor.
-    pub const fn with_trie_input(
-        hashed_state: Arc<HashedPostStateSorted>,
-        trie_updates: Arc<TrieUpdatesSorted>,
-        anchor_hash: B256,
-        trie_input: Arc<TrieInputSorted>,
-    ) -> Self {
-        Self {
-            hashed_state,
-            trie_updates,
-            anchored_trie_input: Some(AnchoredTrieInput { anchor_hash, trie_input }),
-        }
-    }
-
-    /// Construct a bundle without trie input or anchor information.
-    ///
-    /// Unlike [`Self::with_trie_input`], this constructor omits the accumulated trie input overlay
-    /// and its anchor hash. Use this when the trie input is not needed, such as in block builders
-    /// or sequencers that don't require proof generation on top of in-memory state.
-    ///
-    /// The trie input anchor identifies the persisted block hash from which the in-memory overlay
-    /// was built. Without it, consumers cannot determine which on-disk state to combine with.
-    pub const fn without_trie_input(
+    /// Construct sorted trie data for one block.
+    pub const fn new(
         hashed_state: Arc<HashedPostStateSorted>,
         trie_updates: Arc<TrieUpdatesSorted>,
     ) -> Self {
-        Self { hashed_state, trie_updates, anchored_trie_input: None }
-    }
-
-    /// Returns the anchor hash, if present.
-    pub fn anchor_hash(&self) -> Option<B256> {
-        self.anchored_trie_input.as_ref().map(|anchored| anchored.anchor_hash)
-    }
-
-    /// Returns the trie input, if present.
-    pub fn trie_input(&self) -> Option<&Arc<TrieInputSorted>> {
-        self.anchored_trie_input.as_ref().map(|anchored| &anchored.trie_input)
+        Self { hashed_state, trie_updates }
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy_primitives::{map::B256Map, U256};
+    use alloy_primitives::{map::B256Map, B256, U256};
     use reth_primitives_traits::Account;
-    use reth_trie::updates::TrieUpdates;
+    use reth_trie::{updates::TrieUpdates, HashedStorage};
     use std::{
-        sync::Arc,
         thread,
         time::{Duration, Instant},
     };
 
-    fn empty_bundle() -> ComputedTrieData {
-        ComputedTrieData {
-            hashed_state: Arc::default(),
-            trie_updates: Arc::default(),
-            anchored_trie_input: None,
-        }
-    }
-
-    fn empty_pending() -> DeferredTrieData {
-        empty_pending_with_anchor(B256::ZERO)
-    }
-
-    fn empty_pending_with_anchor(anchor: B256) -> DeferredTrieData {
+    fn empty_pending() -> (DeferredTrieData, DeferredTrieDataProducer) {
         DeferredTrieData::pending(
             Arc::new(HashedPostState::default()),
             Arc::new(TrieUpdates::default()),
-            anchor,
-            Vec::new(),
         )
     }
 
-    /// Verifies that a ready handle returns immediately without computation.
     #[test]
     fn ready_returns_immediately() {
-        let bundle = empty_bundle();
+        let bundle = ComputedTrieData::default();
         let deferred = DeferredTrieData::ready(bundle.clone());
 
-        let start = Instant::now();
         let result = deferred.wait_cloned();
-        let elapsed = start.elapsed();
 
-        assert_eq!(result.hashed_state, bundle.hashed_state);
-        assert_eq!(result.trie_updates, bundle.trie_updates);
-        assert_eq!(result.anchor_hash(), bundle.anchor_hash());
-        assert!(elapsed < Duration::from_millis(20));
+        assert_eq!(result.hashed_state.total_len(), bundle.hashed_state.total_len());
+        assert_eq!(result.trie_updates.total_len(), bundle.trie_updates.total_len());
     }
 
-    /// Verifies that a pending handle computes trie data synchronously via fallback.
     #[test]
-    fn pending_computes_fallback() {
-        let deferred = empty_pending();
+    fn pending_waits_for_task_and_caches_result() {
+        let (deferred, task) = empty_pending();
 
-        // wait_cloned should compute from inputs without blocking
-        let start = Instant::now();
-        let result = deferred.wait_cloned();
-        let elapsed = start.elapsed();
-
-        // Should return quickly (fallback computation)
-        assert!(elapsed < Duration::from_millis(100));
-        assert!(result.hashed_state.is_empty());
-    }
-
-    /// Verifies that fallback computation result is cached for subsequent calls.
-    #[test]
-    fn fallback_result_is_cached() {
-        let deferred = empty_pending();
-
-        // First call computes and should stash the result
+        let published = task.compute_and_publish();
         let first = deferred.wait_cloned();
-        // Second call should reuse the cached result (same Arc pointer)
         let second = deferred.wait_cloned();
 
+        assert!(Arc::ptr_eq(&published.hashed_state, &first.hashed_state));
+        assert!(Arc::ptr_eq(&published.trie_updates, &first.trie_updates));
         assert!(Arc::ptr_eq(&first.hashed_state, &second.hashed_state));
         assert!(Arc::ptr_eq(&first.trie_updates, &second.trie_updates));
-        assert_eq!(first.anchor_hash(), second.anchor_hash());
-    }
-
-    /// Verifies that concurrent `wait_cloned` calls result in only one computation,
-    /// with all callers receiving the same cached result.
-    #[test]
-    fn concurrent_wait_cloned_computes_once() {
-        let deferred = empty_pending();
-
-        // Spawn multiple threads that all call wait_cloned concurrently
-        let handles: Vec<_> = (0..10)
-            .map(|_| {
-                let d = deferred.clone();
-                thread::spawn(move || d.wait_cloned())
-            })
-            .collect();
-
-        // Collect all results
-        let results: Vec<_> = handles.into_iter().map(|h| h.join().unwrap()).collect();
-
-        // All results should share the same Arc pointers (same computed result)
-        let first = &results[0];
-        for result in &results[1..] {
-            assert!(Arc::ptr_eq(&first.hashed_state, &result.hashed_state));
-            assert!(Arc::ptr_eq(&first.trie_updates, &result.trie_updates));
-        }
-    }
-
-    /// Tests that ancestor trie data is merged during fallback computation and that the
-    /// resulting `ComputedTrieData` uses the current block's anchor hash, not the ancestor's.
-    #[test]
-    fn ancestors_are_merged() {
-        // Create ancestor with some data
-        let ancestor_bundle = ComputedTrieData {
-            hashed_state: Arc::default(),
-            trie_updates: Arc::default(),
-            anchored_trie_input: Some(AnchoredTrieInput {
-                anchor_hash: B256::with_last_byte(1),
-                trie_input: Arc::new(TrieInputSorted::default()),
-            }),
-        };
-        let ancestor = DeferredTrieData::ready(ancestor_bundle);
-
-        // Create pending with ancestor
-        let deferred = DeferredTrieData::pending(
-            Arc::new(HashedPostState::default()),
-            Arc::new(TrieUpdates::default()),
-            B256::with_last_byte(2),
-            vec![ancestor],
-        );
-
-        let result = deferred.wait_cloned();
-        // Should have the current block's anchor, not the ancestor's
-        assert_eq!(result.anchor_hash(), Some(B256::with_last_byte(2)));
-    }
-
-    /// Ensures ancestor overlays are merged oldest -> newest so latest state wins (no overwrite by
-    /// older ancestors).
-    #[test]
-    fn ancestors_merge_in_chronological_order() {
-        let key = B256::with_last_byte(1);
-        // Oldest ancestor sets nonce to 1
-        let oldest_state = HashedPostStateSorted::new(
-            vec![(key, Some(Account { nonce: 1, balance: U256::ZERO, bytecode_hash: None }))],
-            B256Map::default(),
-        );
-        // Newest ancestor overwrites nonce to 2
-        let newest_state = HashedPostStateSorted::new(
-            vec![(key, Some(Account { nonce: 2, balance: U256::ZERO, bytecode_hash: None }))],
-            B256Map::default(),
-        );
-
-        let oldest = ComputedTrieData {
-            hashed_state: Arc::new(oldest_state),
-            trie_updates: Arc::default(),
-            anchored_trie_input: None,
-        };
-        let newest = ComputedTrieData {
-            hashed_state: Arc::new(newest_state),
-            trie_updates: Arc::default(),
-            anchored_trie_input: None,
-        };
-
-        // Pass ancestors oldest -> newest; newest should take precedence
-        let deferred = DeferredTrieData::pending(
-            Arc::new(HashedPostState::default()),
-            Arc::new(TrieUpdates::default()),
-            B256::ZERO,
-            vec![DeferredTrieData::ready(oldest), DeferredTrieData::ready(newest)],
-        );
-
-        let result = deferred.wait_cloned();
-        let overlay_state = &result.anchored_trie_input.as_ref().unwrap().trie_input.state.accounts;
-        assert_eq!(overlay_state.len(), 1);
-        let (_, account) = &overlay_state[0];
-        assert_eq!(account.unwrap().nonce, 2);
-    }
-
-    /// Helper to create a ready block with anchored trie input containing specific state.
-    fn ready_block_with_state(
-        anchor_hash: B256,
-        accounts: Vec<(B256, Option<Account>)>,
-    ) -> DeferredTrieData {
-        let hashed_state = Arc::new(HashedPostStateSorted::new(accounts, B256Map::default()));
-        let trie_updates = Arc::default();
-        let mut overlay = TrieInputSorted::default();
-        Arc::make_mut(&mut overlay.state).extend_ref_and_sort(hashed_state.as_ref());
-
-        DeferredTrieData::ready(ComputedTrieData {
-            hashed_state,
-            trie_updates,
-            anchored_trie_input: Some(AnchoredTrieInput {
-                anchor_hash,
-                trie_input: Arc::new(overlay),
-            }),
-        })
-    }
-
-    /// Verifies that first block after anchor (no ancestors) creates empty base overlay.
-    #[test]
-    fn first_block_after_anchor_creates_empty_base() {
-        let anchor = B256::with_last_byte(1);
-        let key = B256::with_last_byte(42);
-        let account = Account { nonce: 1, balance: U256::ZERO, bytecode_hash: None };
-
-        // First block after anchor - no ancestors
-        let first_block = DeferredTrieData::pending(
-            Arc::new(HashedPostState::default().with_accounts([(key, Some(account))])),
-            Arc::new(TrieUpdates::default()),
-            anchor,
-            vec![], // No ancestors
-        );
-
-        let result = first_block.wait_cloned();
-
-        // Should have overlay with just this block's data
-        let overlay = result.anchored_trie_input.as_ref().unwrap();
-        assert_eq!(overlay.anchor_hash, anchor);
-        assert_eq!(overlay.trie_input.state.accounts.len(), 1);
-        let (found_key, found_account) = &overlay.trie_input.state.accounts[0];
-        assert_eq!(*found_key, key);
-        assert_eq!(found_account.unwrap().nonce, 1);
     }
 
-    /// Verifies that parent's overlay is reused regardless of anchor.
     #[test]
-    fn reuses_parent_overlay() {
-        let anchor = B256::with_last_byte(1);
-        let key = B256::with_last_byte(42);
-        let account = Account { nonce: 100, balance: U256::ZERO, bytecode_hash: None };
+    fn pending_wait_blocks_until_task_publishes() {
+        let (deferred, task) = empty_pending();
 
-        // Create parent with anchored trie input
-        let parent = ready_block_with_state(anchor, vec![(key, Some(account))]);
+        let handle = thread::spawn(move || deferred.wait_cloned());
+        thread::sleep(Duration::from_millis(20));
+        assert!(!handle.is_finished());
 
-        // Create child - should reuse parent's overlay
-        let child = DeferredTrieData::pending(
-            Arc::new(HashedPostState::default()),
-            Arc::new(TrieUpdates::default()),
-            anchor,
-            vec![parent],
-        );
+        let published = task.compute_and_publish();
+        let result = handle.join().unwrap();
 
-        let result = child.wait_cloned();
-
-        // Verify parent's account is in the overlay
-        let overlay = result.anchored_trie_input.as_ref().unwrap();
-        assert_eq!(overlay.anchor_hash, anchor);
-        assert_eq!(overlay.trie_input.state.accounts.len(), 1);
-        let (found_key, found_account) = &overlay.trie_input.state.accounts[0];
-        assert_eq!(*found_key, key);
-        assert_eq!(found_account.unwrap().nonce, 100);
+        assert!(Arc::ptr_eq(&published.hashed_state, &result.hashed_state));
+        assert!(Arc::ptr_eq(&published.trie_updates, &result.trie_updates));
     }
 
-    /// Verifies that parent's overlay is NOT reused when anchor changes (after persist).
-    /// The overlay data is dependent on the anchor, so it must be rebuilt from the
-    /// remaining ancestors.
     #[test]
-    fn rebuilds_overlay_when_anchor_changes() {
-        let old_anchor = B256::with_last_byte(1);
-        let new_anchor = B256::with_last_byte(2);
-        let key = B256::with_last_byte(42);
-        let account = Account { nonce: 50, balance: U256::ZERO, bytecode_hash: None };
-
-        // Create parent with OLD anchor
-        let parent = ready_block_with_state(old_anchor, vec![(key, Some(account))]);
-
-        // Create child with NEW anchor (simulates after persist)
-        // Should NOT reuse parent's overlay because anchor changed
-        let child = DeferredTrieData::pending(
-            Arc::new(HashedPostState::default()),
-            Arc::new(TrieUpdates::default()),
-            new_anchor,
-            vec![parent],
-        );
-
-        let result = child.wait_cloned();
-
-        // Verify result uses new anchor
-        let overlay = result.anchored_trie_input.as_ref().unwrap();
-        assert_eq!(overlay.anchor_hash, new_anchor);
-
-        // Crucially, since we provided `parent` in ancestors but it has a different anchor,
-        // the code falls back to `merge_ancestors_into_overlay`.
-        // `merge_ancestors_into_overlay` reads `parent.hashed_state` (which has the account).
-        // So the account IS present, but it was obtained via REBUILD, not REUSE.
-        // We can check `DEFERRED_TRIE_METRICS` if we want to be sure, but functionally:
-        assert_eq!(overlay.trie_input.state.accounts.len(), 1);
-        let (found_key, found_account) = &overlay.trie_input.state.accounts[0];
-        assert_eq!(*found_key, key);
-        assert_eq!(found_account.unwrap().nonce, 50);
+    fn concurrent_waits_share_published_result() {
+        let (deferred, task) = empty_pending();
+        let deferred2 = deferred.clone();
+
+        let handle = thread::spawn(move || deferred2.wait_cloned());
+        let published = task.compute_and_publish();
+        let result1 = deferred.wait_cloned();
+        let result2 = handle.join().unwrap();
+
+        assert!(Arc::ptr_eq(&published.hashed_state, &result1.hashed_state));
+        assert!(Arc::ptr_eq(&published.trie_updates, &result1.trie_updates));
+        assert!(Arc::ptr_eq(&result1.hashed_state, &result2.hashed_state));
+        assert!(Arc::ptr_eq(&result1.trie_updates, &result2.trie_updates));
     }
 
-    /// Verifies that parent without `anchored_trie_input` triggers rebuild path.
     #[test]
-    fn rebuilds_when_parent_has_no_anchored_input() {
-        let anchor = B256::with_last_byte(1);
-        let key = B256::with_last_byte(42);
-        let account = Account { nonce: 25, balance: U256::ZERO, bytecode_hash: None };
-
-        // Create parent WITHOUT anchored trie input (e.g., from without_trie_input constructor)
-        let parent_state =
-            HashedPostStateSorted::new(vec![(key, Some(account))], B256Map::default());
-        let parent = DeferredTrieData::ready(ComputedTrieData {
-            hashed_state: Arc::new(parent_state),
-            trie_updates: Arc::default(),
-            anchored_trie_input: None, // No anchored input
-        });
-
-        // Create child - should rebuild from parent's hashed_state
-        let child = DeferredTrieData::pending(
-            Arc::new(HashedPostState::default()),
-            Arc::new(TrieUpdates::default()),
-            anchor,
-            vec![parent],
-        );
-
-        let result = child.wait_cloned();
-
-        // Verify overlay is built and contains parent's data
-        let overlay = result.anchored_trie_input.as_ref().unwrap();
-        assert_eq!(overlay.anchor_hash, anchor);
-        assert_eq!(overlay.trie_input.state.accounts.len(), 1);
-    }
-
-    /// Verifies that a chain of blocks with matching anchors builds correct cumulative overlay.
-    #[test]
-    fn chain_of_blocks_builds_cumulative_overlay() {
-        let anchor = B256::with_last_byte(1);
-        let key1 = B256::with_last_byte(1);
-        let key2 = B256::with_last_byte(2);
-        let key3 = B256::with_last_byte(3);
-
-        // Block 1: sets account at key1
-        let block1 = ready_block_with_state(
-            anchor,
-            vec![(key1, Some(Account { nonce: 1, balance: U256::ZERO, bytecode_hash: None }))],
-        );
-
-        // Block 2: adds account at key2, ancestor is block1
-        let block2_hashed = HashedPostState::default().with_accounts([(
-            key2,
-            Some(Account { nonce: 2, balance: U256::ZERO, bytecode_hash: None }),
-        )]);
-        let block2 = DeferredTrieData::pending(
-            Arc::new(block2_hashed),
-            Arc::new(TrieUpdates::default()),
-            anchor,
-            vec![block1.clone()],
-        );
-        // Compute block2's trie data
-        let block2_computed = block2.wait_cloned();
-        let block2_ready = DeferredTrieData::ready(block2_computed);
-
-        // Block 3: adds account at key3, ancestor is block2 (which includes block1)
-        let block3_hashed = HashedPostState::default().with_accounts([(
-            key3,
-            Some(Account { nonce: 3, balance: U256::ZERO, bytecode_hash: None }),
-        )]);
-        let block3 = DeferredTrieData::pending(
-            Arc::new(block3_hashed),
-            Arc::new(TrieUpdates::default()),
-            anchor,
-            vec![block1, block2_ready],
-        );
-
-        let result = block3.wait_cloned();
-
-        // Verify all three accounts are in the cumulative overlay
-        let overlay = result.anchored_trie_input.as_ref().unwrap();
-        assert_eq!(overlay.trie_input.state.accounts.len(), 3);
-
-        // Accounts should be sorted by key (B256 ordering)
-        let accounts = &overlay.trie_input.state.accounts;
-        assert!(accounts.iter().any(|(k, a)| *k == key1 && a.unwrap().nonce == 1));
-        assert!(accounts.iter().any(|(k, a)| *k == key2 && a.unwrap().nonce == 2));
-        assert!(accounts.iter().any(|(k, a)| *k == key3 && a.unwrap().nonce == 3));
-    }
-
-    /// Verifies that child block's state overwrites parent's state for the same key.
-    #[test]
-    fn child_state_overwrites_parent() {
-        let anchor = B256::with_last_byte(1);
-        let key = B256::with_last_byte(42);
-
-        // Parent sets nonce to 10
-        let parent = ready_block_with_state(
-            anchor,
-            vec![(key, Some(Account { nonce: 10, balance: U256::ZERO, bytecode_hash: None }))],
-        );
-
-        // Child overwrites nonce to 99
-        let child_hashed = HashedPostState::default().with_accounts([(
-            key,
-            Some(Account { nonce: 99, balance: U256::ZERO, bytecode_hash: None }),
-        )]);
-        let child = DeferredTrieData::pending(
-            Arc::new(child_hashed),
-            Arc::new(TrieUpdates::default()),
-            anchor,
-            vec![parent],
-        );
-
-        let result = child.wait_cloned();
+    fn sorts_non_empty_inputs() {
+        let hashed_address = B256::with_last_byte(1);
+        let hashed_slot = B256::with_last_byte(2);
+        let hashed_state = HashedPostState::default()
+            .with_accounts([(hashed_address, Some(Account::default()))])
+            .with_storages([(
+                hashed_address,
+                HashedStorage::from_iter(false, [(hashed_slot, U256::from(1))]),
+            )]);
+
+        let (deferred, task) =
+            DeferredTrieData::pending(Arc::new(hashed_state), Arc::new(TrieUpdates::default()));
+        let _ = task.compute_and_publish();
+        let result = deferred.wait_cloned();
 
-        // Verify child's value wins (extend_ref uses later value)
-        let overlay = result.anchored_trie_input.as_ref().unwrap();
-        // Note: extend_ref may result in duplicate keys; check the last occurrence
-        let accounts = &overlay.trie_input.state.accounts;
-        let last_account = accounts.iter().rfind(|(k, _)| *k == key).unwrap();
-        assert_eq!(last_account.1.unwrap().nonce, 99);
+        assert_eq!(result.hashed_state.total_len(), 2);
+        assert_eq!(result.trie_updates.total_len(), 0);
     }
 
-    /// Stress test: verify O(N) behavior by building a chain of many blocks.
-    /// This test ensures the fix doesn't regress - previously this would be O(N²).
     #[test]
-    fn long_chain_builds_in_linear_time() {
-        let anchor = B256::with_last_byte(1);
-        let num_blocks = 50; // Enough to notice O(N²) vs O(N) difference
-
-        let mut ancestors: Vec<DeferredTrieData> = Vec::new();
-
-        let start = Instant::now();
-
-        for i in 0..num_blocks {
-            let key = B256::with_last_byte(i as u8);
-            let account = Account { nonce: i as u64, balance: U256::ZERO, bytecode_hash: None };
-            let hashed = HashedPostState::default().with_accounts([(key, Some(account))]);
-
-            let block = DeferredTrieData::pending(
-                Arc::new(hashed),
-                Arc::new(TrieUpdates::default()),
-                anchor,
-                ancestors.clone(),
-            );
-
-            // Compute and add to ancestors for next iteration
-            let computed = block.wait_cloned();
-            ancestors.push(DeferredTrieData::ready(computed));
+    fn wait_does_not_block_after_first_compute() {
+        let mut accounts = B256Map::default();
+        for i in 0..100 {
+            accounts.insert(B256::with_last_byte(i), Some(Account::default()));
         }
-
-        let elapsed = start.elapsed();
-
-        // With O(N) fix, 50 blocks should complete quickly (< 1 second)
-        // With O(N²), this would take significantly longer
-        assert!(
-            elapsed < Duration::from_secs(2),
-            "Chain of {num_blocks} blocks took {:?}, possible O(N²) regression",
-            elapsed
-        );
-
-        // Verify final overlay has all accounts
-        let final_result = ancestors.last().unwrap().wait_cloned();
-        let overlay = final_result.anchored_trie_input.as_ref().unwrap();
-        assert_eq!(overlay.trie_input.state.accounts.len(), num_blocks);
-    }
-
-    /// Verifies that a multi-ancestor overlay is rebuilt when anchor changes.
-    /// This simulates the "persist prefix then keep building" scenario where:
-    /// 1. A chain of blocks is built with anchor A
-    /// 2. Some blocks are persisted, changing anchor to B
-    /// 3. New blocks must rebuild the overlay from the remaining ancestors
-    #[test]
-    fn multi_ancestor_overlay_rebuilt_after_anchor_change() {
-        let old_anchor = B256::with_last_byte(1);
-        let new_anchor = B256::with_last_byte(2);
-        let key1 = B256::with_last_byte(1);
-        let key2 = B256::with_last_byte(2);
-        let key3 = B256::with_last_byte(3);
-        let key4 = B256::with_last_byte(4);
-
-        // Build a chain of 3 blocks with old_anchor
-        let block1 = ready_block_with_state(
-            old_anchor,
-            vec![(key1, Some(Account { nonce: 1, balance: U256::ZERO, bytecode_hash: None }))],
-        );
-
-        let block2_hashed = HashedPostState::default().with_accounts([(
-            key2,
-            Some(Account { nonce: 2, balance: U256::ZERO, bytecode_hash: None }),
-        )]);
-        let block2 = DeferredTrieData::pending(
-            Arc::new(block2_hashed),
+        let (deferred, task) = DeferredTrieData::pending(
+            Arc::new(HashedPostState { accounts, storages: Default::default() }),
             Arc::new(TrieUpdates::default()),
-            old_anchor,
-            vec![block1.clone()],
         );
-        let block2_ready = DeferredTrieData::ready(block2.wait_cloned());
-
-        let block3_hashed = HashedPostState::default().with_accounts([(
-            key3,
-            Some(Account { nonce: 3, balance: U256::ZERO, bytecode_hash: None }),
-        )]);
-        let block3 = DeferredTrieData::pending(
-            Arc::new(block3_hashed),
-            Arc::new(TrieUpdates::default()),
-            old_anchor,
-            vec![block1.clone(), block2_ready.clone()],
-        );
-        let block3_ready = DeferredTrieData::ready(block3.wait_cloned());
-
-        // Verify block3's overlay has all 3 accounts with old_anchor
-        let block3_overlay = block3_ready.wait_cloned().anchored_trie_input.unwrap();
-        assert_eq!(block3_overlay.anchor_hash, old_anchor);
-        assert_eq!(block3_overlay.trie_input.state.accounts.len(), 3);
-
-        // Now simulate persist: create block4 with NEW anchor but same ancestors.
-        // To verify correct rebuilding, we must provide ALL unpersisted ancestors.
-        // If we only provided block3, the rebuild would only see block3's state.
-        // We pass block1, block2, block3 to simulate that they are all still in memory
-        // but the anchor check forces a rebuild (e.g. artificial anchor change).
-        let block4_hashed = HashedPostState::default().with_accounts([(
-            key4,
-            Some(Account { nonce: 4, balance: U256::ZERO, bytecode_hash: None }),
-        )]);
-        let block4 = DeferredTrieData::pending(
-            Arc::new(block4_hashed),
-            Arc::new(TrieUpdates::default()),
-            new_anchor, // Different anchor - simulates post-persist
-            vec![block1, block2_ready, block3_ready],
-        );
-
-        let result = block4.wait_cloned();
 
-        // Verify:
-        // 1. New anchor is used in result
-        assert_eq!(result.anchor_hash(), Some(new_anchor));
-
-        // 2. All 4 accounts are in the overlay (rebuilt from ancestors + extended)
-        let overlay = result.anchored_trie_input.as_ref().unwrap();
-        assert_eq!(overlay.trie_input.state.accounts.len(), 4);
+        let _ = task.compute_and_publish();
+        let _ = deferred.wait_cloned();
+        let start = Instant::now();
+        let _ = deferred.wait_cloned();
 
-        // 3. All accounts have correct values
-        let accounts = &overlay.trie_input.state.accounts;
-        assert!(accounts.iter().any(|(k, a)| *k == key1 && a.unwrap().nonce == 1));
-        assert!(accounts.iter().any(|(k, a)| *k == key2 && a.unwrap().nonce == 2));
-        assert!(accounts.iter().any(|(k, a)| *k == key3 && a.unwrap().nonce == 3));
-        assert!(accounts.iter().any(|(k, a)| *k == key4 && a.unwrap().nonce == 4));
+        assert!(start.elapsed() < Duration::from_millis(10));
     }
 }
diff --git a/crates/chain-state/src/in_memory.rs b/crates/chain-state/src/in_memory.rs
index ecdece9a337..c62b7d6e69f 100644
--- a/crates/chain-state/src/in_memory.rs
+++ b/crates/chain-state/src/in_memory.rs
@@ -17,10 +17,7 @@ use reth_primitives_traits::{
     SignedTransaction,
 };
 use reth_storage_api::StateProviderBox;
-use reth_trie::{
-    updates::TrieUpdatesSorted, HashedPostStateSorted, LazyTrieData, SortedTrieData,
-    TrieInputSorted,
-};
+use reth_trie::{updates::TrieUpdatesSorted, HashedPostStateSorted, LazyTrieData, SortedTrieData};
 use std::{collections::BTreeMap, sync::Arc, time::Instant};
 use tokio::sync::{broadcast, watch};
 
@@ -806,13 +803,12 @@ impl<N: NodePrimitives> ExecutedBlock<N> {
     /// This is useful if the trie data is populated somewhere else, e.g. asynchronously
     /// after the block was validated.
     ///
-    /// The [`DeferredTrieData`] handle allows expensive trie operations (sorting hashed state,
-    /// sorting trie updates, and building the accumulated trie input overlay) to be performed
-    /// outside the critical validation path. This can improve latency for time-sensitive
-    /// operations like block validation.
+    /// The [`DeferredTrieData`] handle allows expensive trie operations (sorting hashed state and
+    /// trie updates) to be performed outside the critical validation path by a background task.
+    /// This can improve latency for time-sensitive operations like block validation.
     ///
-    /// If the data hasn't been populated when [`Self::trie_data()`] is called, computation
-    /// occurs synchronously from stored inputs, so there is no blocking or deadlock risk.
+    /// If the data hasn't been populated when [`Self::trie_data()`] is called, the caller waits
+    /// for the background task to publish it.
     ///
     /// Use [`Self::new()`] instead when trie data is already computed and available immediately.
     pub const fn with_deferred_trie_data(
@@ -841,11 +837,11 @@ impl<N: NodePrimitives> ExecutedBlock<N> {
         &self.execution_output
     }
 
-    /// Returns the trie data, computing it synchronously if not already cached.
+    /// Returns the trie data, waiting for the background task if not already cached.
     ///
     /// Uses `OnceLock::get_or_init` internally:
     /// - If already computed: returns cached result immediately
-    /// - If not computed: first caller computes, others wait for that result
+    /// - If not computed: first caller waits for the publishing task, others wait for that result
     #[inline]
     #[tracing::instrument(level = "debug", target = "engine::tree", name = "trie_data", skip_all)]
     pub fn trie_data(&self) -> ComputedTrieData {
@@ -855,8 +851,7 @@ impl<N: NodePrimitives> ExecutedBlock<N> {
     /// Returns a clone of the deferred trie data handle.
     ///
     /// A handle is a lightweight reference that can be passed to descendants without
-    /// forcing trie data to be computed immediately. The actual work runs when
-    /// `wait_cloned()` is called by a consumer (e.g. when merging overlays).
+    /// forcing trie data to be observed immediately. The actual work runs in the background task.
     #[inline]
     pub fn trie_data_handle(&self) -> DeferredTrieData {
         self.trie_data.clone()
@@ -864,7 +859,7 @@ impl<N: NodePrimitives> ExecutedBlock<N> {
 
     /// Returns the hashed state result of the execution outcome.
     ///
-    /// May compute trie data synchronously if the deferred task hasn't completed.
+    /// May wait for trie data if the deferred task hasn't completed.
     #[inline]
     pub fn hashed_state(&self) -> Arc<HashedPostStateSorted> {
         self.trie_data().hashed_state
@@ -872,26 +867,12 @@ impl<N: NodePrimitives> ExecutedBlock<N> {
 
     /// Returns the trie updates resulting from the execution outcome.
     ///
-    /// May compute trie data synchronously if the deferred task hasn't completed.
+    /// May wait for trie data if the deferred task hasn't completed.
     #[inline]
     pub fn trie_updates(&self) -> Arc<TrieUpdatesSorted> {
         self.trie_data().trie_updates
     }
 
-    /// Returns the trie input anchored to the persisted ancestor.
-    ///
-    /// May compute trie data synchronously if the deferred task hasn't completed.
-    #[inline]
-    pub fn trie_input(&self) -> Option<Arc<TrieInputSorted>> {
-        self.trie_data().trie_input().cloned()
-    }
-
-    /// Returns the anchor hash of the trie input, if present.
-    #[inline]
-    pub fn anchor_hash(&self) -> Option<B256> {
-        self.trie_data().anchor_hash()
-    }
-
     /// Returns a [`BlockNumber`] of the block.
     #[inline]
     pub fn block_number(&self) -> BlockNumber {
diff --git a/crates/chain-state/src/lazy_overlay.rs b/crates/chain-state/src/lazy_overlay.rs
deleted file mode 100644
index ecf9a9c92ac..00000000000
--- a/crates/chain-state/src/lazy_overlay.rs
+++ /dev/null
@@ -1,327 +0,0 @@
-//! Lazy overlay computation for trie input.
-//!
-//! This module provides [`LazyOverlay`], a type that computes the [`TrieInputSorted`]
-//! lazily on first access. This allows execution to start before the trie overlay
-//! is fully computed.
-
-use crate::{EthPrimitives, ExecutedBlock};
-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 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>>,
-}
-
-/// 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.
-///
-/// # Fast Path vs Slow Path
-///
-/// - **Fast path**: If the tip block's cached `anchored_trie_input` is ready and its `anchor_hash`
-///   matches our expected anchor, we can reuse it directly (O(1)).
-/// - **Slow path**: Otherwise, we merge all ancestor blocks' trie data into a new overlay.
-#[derive(Clone)]
-pub struct LazyOverlay<N: NodePrimitives = EthPrimitives> {
-    /// Computed results, cached by requested anchor hash.
-    inner: Arc<DashMap<B256, Arc<TrieInputSorted>>>,
-    /// Inputs for lazy computation.
-    inputs: LazyOverlayInputs<N>,
-}
-
-impl<N: NodePrimitives> std::fmt::Debug for LazyOverlay<N> {
-    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("num_blocks", &self.inputs.blocks.len())
-            .field("cached_anchors", &self.inner.len())
-            .finish()
-    }
-}
-
-impl<N: NodePrimitives> LazyOverlay<N> {
-    /// Create a new lazy overlay from in-memory blocks.
-    ///
-    /// # 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"
-        );
-
-        Self { inner: Default::default(), inputs: LazyOverlayInputs { blocks } }
-    }
-
-    /// Returns the number of in-memory blocks this overlay covers.
-    pub const fn num_blocks(&self) -> usize {
-        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 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.
-    ///
-    /// 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
-            }
-        }
-    }
-
-    /// 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);
-        (Arc::clone(&input.nodes), Arc::clone(&input.state))
-    }
-
-    /// Compute the trie input overlay.
-    fn compute(&self, anchor_hash: B256) -> Arc<TrieInputSorted> {
-        let blocks = &self.inputs.blocks;
-        if blocks.is_empty() {
-            return Default::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.
-        if let Some(tip) = blocks.first() {
-            let data = tip.trie_data();
-            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);
-                }
-                debug!(
-                    target: "chain_state::lazy_overlay",
-                    computed_anchor = %anchored.anchor_hash,
-                    %anchor_hash,
-                    "Anchor mismatch, falling back to merge"
-                );
-            }
-        }
-
-        // 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))
-    }
-
-    /// Merge all blocks' trie data into a single [`TrieInputSorted`].
-    ///
-    /// Blocks are ordered newest to oldest.
-    fn merge_blocks(blocks: &[ExecutedBlock<N>]) -> 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),
-        );
-
-        TrieInputSorted { state, nodes, prefix_sets: Default::default() }
-    }
-}
-
-#[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;
-
-    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 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 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]);
-
-        assert!(!overlay.is_computed(anchor_hash));
-        let _ = overlay.get(anchor_hash);
-        assert!(overlay.is_computed(anchor_hash));
-    }
-
-    #[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);
-
-        let prefix = overlay.get(prefix_anchor);
-        let full = overlay.get(full_anchor);
-
-        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);
-    }
-}
diff --git a/crates/chain-state/src/lib.rs b/crates/chain-state/src/lib.rs
index 4bea662dfcd..6912fee626b 100644
--- a/crates/chain-state/src/lib.rs
+++ b/crates/chain-state/src/lib.rs
@@ -17,8 +17,8 @@ pub use in_memory::*;
 mod deferred_trie;
 pub use deferred_trie::*;
 
-mod lazy_overlay;
-pub use lazy_overlay::*;
+mod state_trie_overlay;
+pub use state_trie_overlay::*;
 
 mod noop;
 
diff --git a/crates/chain-state/src/notifications.rs b/crates/chain-state/src/notifications.rs
index 3fd9d9a1c76..3132715c014 100644
--- a/crates/chain-state/src/notifications.rs
+++ b/crates/chain-state/src/notifications.rs
@@ -1,6 +1,6 @@
 //! Canonical chain state notification trait and types.
 
-use alloy_eips::{eip2718::Encodable2718, BlockNumHash};
+use alloy_eips::BlockNumHash;
 use derive_more::{Deref, DerefMut};
 use reth_execution_types::{BlockReceipts, Chain};
 use reth_primitives_traits::{NodePrimitives, RecoveredBlock, SealedHeader};
@@ -157,10 +157,7 @@ impl<N: NodePrimitives> CanonStateNotification<N> {
     ///
     /// The boolean in the tuple (2nd element) denotes whether the receipt was from the reverted
     /// chain segment.
-    pub fn block_receipts(&self) -> Vec<(BlockReceipts<N::Receipt>, bool)>
-    where
-        N::SignedTx: Encodable2718,
-    {
+    pub fn block_receipts(&self) -> Vec<(BlockReceipts<N::Receipt>, bool)> {
         let mut receipts = Vec::new();
 
         // get old receipts
diff --git a/crates/chain-state/src/state_trie_overlay.rs b/crates/chain-state/src/state_trie_overlay.rs
new file mode 100644
index 00000000000..00d6b75e3d0
--- /dev/null
+++ b/crates/chain-state/src/state_trie_overlay.rs
@@ -0,0 +1,852 @@
+//! Flattened state trie overlays for in-memory blocks.
+//!
+//! Payload validation needs a view of the state trie as of an in-memory parent block even when that
+//! parent has not been persisted yet. [`StateTrieOverlayManager`] tracks those in-memory blocks and
+//! builds reusable flattened state trie overlays on demand.
+
+use crate::{EthPrimitives, ExecutedBlock};
+use alloy_primitives::B256;
+use reth_metrics::{
+    metrics::{Counter, Histogram},
+    Metrics,
+};
+use reth_primitives_traits::{
+    dashmap::{mapref::entry::Entry, DashMap},
+    AlloyBlockHeader, NodePrimitives,
+};
+#[cfg(feature = "rayon")]
+use reth_tasks::WorkerPool;
+use reth_trie::{updates::TrieUpdatesSorted, HashedPostStateSorted, TrieInputSorted};
+use std::{
+    fmt,
+    sync::{Arc, OnceLock},
+    time::Instant,
+};
+use tracing::{debug, trace};
+
+/// Manages flattened state trie overlays for in-memory blocks.
+///
+/// The manager owns the in-memory block graph and a cache of flattened state trie overlays keyed by
+/// `(anchor_hash, tip_hash)`.
+#[derive(Clone)]
+pub struct StateTrieOverlayManager<N: NodePrimitives = EthPrimitives> {
+    blocks: Arc<DashMap<B256, ExecutedBlock<N>>>,
+    overlays: Arc<DashMap<OverlayCacheKey, OverlayCacheEntry>>,
+    #[cfg(feature = "rayon")]
+    worker_pool: Option<Arc<WorkerPool>>,
+    metrics: StateTrieOverlayMetrics,
+}
+
+/// Metrics for state trie overlay management.
+#[derive(Clone, Metrics)]
+#[metrics(scope = "sync.block_validation.state_trie_overlay")]
+struct StateTrieOverlayMetrics {
+    /// Duration of overlay computation in seconds.
+    overlay_computation_duration_seconds: Histogram,
+    /// Number of requests satisfied by an existing overlay cache entry.
+    overlay_cache_reuses: Counter,
+    /// Number of overlay cache entries populated by computing an overlay.
+    overlay_cache_fills: Counter,
+}
+
+impl<N: NodePrimitives> Default for StateTrieOverlayManager<N> {
+    fn default() -> Self {
+        Self {
+            blocks: Default::default(),
+            overlays: Default::default(),
+            #[cfg(feature = "rayon")]
+            worker_pool: None,
+            metrics: Default::default(),
+        }
+    }
+}
+
+impl<N: NodePrimitives> std::fmt::Debug for StateTrieOverlayManager<N> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("StateTrieOverlayManager")
+            .field("blocks", &self.blocks.len())
+            .field("overlays", &self.overlays.len())
+            .finish()
+    }
+}
+
+impl<N: NodePrimitives> StateTrieOverlayManager<N> {
+    /// Create a new [`StateTrieOverlayManager`] backed by the given worker pool.
+    #[cfg(feature = "rayon")]
+    pub fn new(worker_pool: Arc<WorkerPool>) -> Self {
+        Self {
+            blocks: Default::default(),
+            overlays: Default::default(),
+            worker_pool: Some(worker_pool),
+            metrics: Default::default(),
+        }
+    }
+
+    /// Inserts an executed in-memory block into the state trie overlay manager.
+    #[tracing::instrument(
+        level = "trace",
+        target = "chain_state::state_trie_overlay",
+        skip_all,
+        fields(
+            block_hash = %block.recovered_block().hash(),
+            parent_hash = %block.recovered_block().parent_hash(),
+            duplicate = false,
+        )
+    )]
+    pub fn insert_block(&self, block: ExecutedBlock<N>) {
+        let hash = block.recovered_block().hash();
+        let parent_hash = block.recovered_block().parent_hash();
+        let span = tracing::Span::current();
+
+        // First add the block to the live graph; duplicate inserts do not need cache work.
+        match self.blocks.entry(hash) {
+            Entry::Occupied(_) => {
+                span.record("duplicate", true);
+                debug!(
+                    target: "chain_state::state_trie_overlay",
+                    %hash,
+                    %parent_hash,
+                    "state trie overlay block already inserted"
+                );
+                return
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(block);
+            }
+        }
+
+        // Snapshot matching parent overlays before spawning so DashMap iteration guards are
+        // dropped.
+        let cached_parent_overlays = self
+            .overlays
+            .iter()
+            .filter_map(|entry| {
+                let key = *entry.key();
+                (key.tip_hash == parent_hash && entry.value().is_ready()).then_some(key.anchor_hash)
+            })
+            .collect::<Vec<_>>();
+
+        debug!(
+            target: "chain_state::state_trie_overlay",
+            %hash,
+            %parent_hash,
+            "inserted block into state trie overlay manager"
+        );
+        if cached_parent_overlays.is_empty() {
+            return
+        }
+
+        #[cfg(feature = "rayon")]
+        let Some(worker_pool) = self.worker_pool.clone() else {
+            return
+        };
+
+        #[cfg(not(feature = "rayon"))]
+        let _ = cached_parent_overlays;
+
+        #[cfg(feature = "rayon")]
+        {
+            let parent_span = span;
+            for anchor_hash in cached_parent_overlays {
+                let manager = <Self as Clone>::clone(self);
+                let parent_span = parent_span.clone();
+                worker_pool.spawn(move || {
+                    let _span = tracing::trace_span!(
+                        target: "chain_state::state_trie_overlay",
+                        parent: parent_span,
+                        "precompute_state_trie_overlay",
+                        tip_hash = %hash,
+                        anchor_hash = %anchor_hash,
+                    )
+                    .entered();
+                    let _ = manager.precompute_overlay(hash, anchor_hash);
+                });
+            }
+        }
+    }
+
+    /// Removes blocks from the live block graph and prunes cached overlays that can no longer be
+    /// built from the remaining blocks.
+    #[tracing::instrument(
+        level = "trace",
+        target = "chain_state::state_trie_overlay",
+        skip_all,
+        fields(
+            block_count = tracing::field::Empty,
+            removed_blocks = tracing::field::Empty,
+            pruned_overlays = tracing::field::Empty,
+        )
+    )]
+    pub fn remove_blocks(&self, hashes: impl IntoIterator<Item = B256>) {
+        let span = tracing::Span::current();
+
+        // Remove blocks first, then prune overlays against the remaining block graph.
+        let mut block_count = 0usize;
+        let mut removed_blocks = 0usize;
+        let mut pruned_overlays = 0usize;
+        for hash in hashes {
+            block_count += 1;
+            removed_blocks += self.blocks.remove(&hash).is_some() as usize;
+        }
+        span.record("block_count", block_count);
+        span.record("removed_blocks", removed_blocks);
+
+        if removed_blocks > 0 {
+            let overlays_before = self.overlays.len();
+            let blocks = Arc::clone(&self.blocks);
+            self.overlays.retain(|key, _| {
+                key.tip_hash != key.anchor_hash &&
+                    Self::anchor_for_parent_in(blocks.as_ref(), key.tip_hash, key.anchor_hash) ==
+                        Some(key.anchor_hash)
+            });
+            pruned_overlays = overlays_before.saturating_sub(self.overlays.len());
+            span.record("pruned_overlays", pruned_overlays);
+        }
+        debug!(
+            target: "chain_state::state_trie_overlay",
+            block_count,
+            removed_blocks,
+            pruned_overlays,
+            "removed blocks from state trie overlay manager"
+        );
+    }
+
+    /// Returns the flattened overlay from `anchor_hash` to `parent_hash`.
+    #[tracing::instrument(
+        level = "trace",
+        target = "chain_state::state_trie_overlay",
+        skip_all,
+        fields(tip_hash = %parent_hash, anchor_hash = %anchor_hash)
+    )]
+    pub fn overlay_for_parent(
+        &self,
+        parent_hash: B256,
+        anchor_hash: B256,
+    ) -> Result<(Arc<TrieUpdatesSorted>, Arc<HashedPostStateSorted>), StateTrieOverlayError> {
+        debug!(
+            target: "chain_state::state_trie_overlay",
+            tip_hash = %parent_hash,
+            %anchor_hash,
+            "loading state trie overlay for parent"
+        );
+        let input = self.get_overlay(parent_hash, anchor_hash)?;
+        Ok((Arc::clone(&input.nodes), Arc::clone(&input.state)))
+    }
+
+    #[cfg(feature = "rayon")]
+    fn precompute_overlay(
+        &self,
+        tip_hash: B256,
+        anchor_hash: B256,
+    ) -> Result<(), StateTrieOverlayError> {
+        let _ = self.get_overlay_inner(tip_hash, anchor_hash, OverlayLookupMode::Precompute)?;
+        Ok(())
+    }
+
+    #[tracing::instrument(
+        level = "trace",
+        target = "chain_state::state_trie_overlay",
+        skip_all,
+        fields(
+            tip_hash = %tip_hash,
+            anchor_hash = %anchor_hash,
+            cache_reused = tracing::field::Empty,
+            block_count = tracing::field::Empty,
+            parent_overlay_reused = tracing::field::Empty,
+        )
+    )]
+    fn get_overlay(
+        &self,
+        tip_hash: B256,
+        anchor_hash: B256,
+    ) -> Result<Arc<TrieInputSorted>, StateTrieOverlayError> {
+        self.get_overlay_inner(tip_hash, anchor_hash, OverlayLookupMode::Required)
+            .map(|input| input.expect("required overlay lookups always return an overlay"))
+    }
+
+    fn get_overlay_inner(
+        &self,
+        tip_hash: B256,
+        anchor_hash: B256,
+        mode: OverlayLookupMode,
+    ) -> Result<Option<Arc<TrieInputSorted>>, StateTrieOverlayError> {
+        let key = OverlayCacheKey { anchor_hash, tip_hash };
+        let span = tracing::Span::current();
+
+        if let Some(entry) = self.overlays.get(&key).map(|entry| entry.value().clone()) {
+            return Ok(match entry {
+                OverlayCacheEntry::Ready(input) => {
+                    self.metrics.overlay_cache_reuses.increment(1);
+                    span.record("cache_reused", true);
+                    Some(input)
+                }
+                OverlayCacheEntry::Computing(waiter) => {
+                    span.record("cache_reused", true);
+                    if mode == OverlayLookupMode::Precompute {
+                        None
+                    } else {
+                        self.metrics.overlay_cache_reuses.increment(1);
+                        Some(waiter.wait())
+                    }
+                }
+            })
+        }
+        span.record("cache_reused", false);
+
+        // Resolve the block path and any cached parent overlay before locking the child entry.
+        let mut hash = tip_hash;
+        let mut blocks = Vec::new();
+        loop {
+            let block =
+                self.blocks.get(&hash).ok_or(StateTrieOverlayError { tip_hash, anchor_hash })?;
+            let parent_hash = block.recovered_block().parent_hash();
+            blocks.push(block.clone());
+
+            if parent_hash == anchor_hash {
+                break
+            }
+            hash = parent_hash;
+        }
+        span.record("block_count", blocks.len());
+        let parent_input = blocks.first().and_then(|block| {
+            let parent_hash = block.recovered_block().parent_hash();
+            (parent_hash != anchor_hash)
+                .then(|| {
+                    self.overlays
+                        .get(&OverlayCacheKey { anchor_hash, tip_hash: parent_hash })
+                        .and_then(|entry| entry.value().ready())
+                })
+                .flatten()
+        });
+        span.record("parent_overlay_reused", parent_input.is_some());
+        let compute_input = match parent_input {
+            Some(parent_input) => {
+                ComputeOverlayInput::ExtendCached { block: blocks.swap_remove(0), parent_input }
+            }
+            None => ComputeOverlayInput::MergeBlocks(blocks),
+        };
+
+        enum CacheAction {
+            Ready(Arc<TrieInputSorted>),
+            Wait(Arc<OverlayWaiter>),
+            Compute(Arc<OverlayWaiter>),
+            Skip,
+        }
+
+        let action = match self.overlays.entry(key) {
+            Entry::Occupied(entry) => match entry.get().clone() {
+                OverlayCacheEntry::Ready(input) => {
+                    self.metrics.overlay_cache_reuses.increment(1);
+                    span.record("cache_reused", true);
+                    CacheAction::Ready(input)
+                }
+                OverlayCacheEntry::Computing(waiter) => {
+                    span.record("cache_reused", true);
+                    if mode == OverlayLookupMode::Precompute {
+                        CacheAction::Skip
+                    } else {
+                        self.metrics.overlay_cache_reuses.increment(1);
+                        CacheAction::Wait(waiter)
+                    }
+                }
+            },
+            Entry::Vacant(entry) => {
+                self.metrics.overlay_cache_fills.increment(1);
+                let waiter = Arc::new(OverlayWaiter::new());
+                entry.insert(OverlayCacheEntry::Computing(Arc::clone(&waiter)));
+                CacheAction::Compute(waiter)
+            }
+        };
+
+        match action {
+            CacheAction::Ready(input) => Ok(Some(input)),
+            CacheAction::Wait(waiter) => Ok(Some(waiter.wait())),
+            CacheAction::Skip => Ok(None),
+            CacheAction::Compute(waiter) => {
+                let input = self.compute_overlay(compute_input, anchor_hash, span);
+                waiter.finish(Arc::clone(&input));
+
+                if let Entry::Occupied(mut entry) = self.overlays.entry(key) {
+                    // The entry may have been pruned while the overlay was computing. Only cache
+                    // the result if the map still points at the waiter installed by this task.
+                    let should_publish = match entry.get() {
+                        OverlayCacheEntry::Computing(existing) => Arc::ptr_eq(existing, &waiter),
+                        OverlayCacheEntry::Ready(_) => false,
+                    };
+                    if should_publish {
+                        entry.insert(OverlayCacheEntry::Ready(Arc::clone(&input)));
+                    }
+                }
+
+                Ok(Some(input))
+            }
+        }
+    }
+
+    /// Returns `preferred_anchor` if it is on the parent chain, otherwise the first missing parent.
+    ///
+    /// Returns `None` if `parent_hash` is not `preferred_anchor` and the manager does not contain a
+    /// block for `parent_hash`, meaning there is no in-memory parent chain to inspect.
+    pub fn anchor_for_parent(&self, parent_hash: B256, preferred_anchor: B256) -> Option<B256> {
+        Self::anchor_for_parent_in(self.blocks.as_ref(), parent_hash, preferred_anchor)
+    }
+
+    fn anchor_for_parent_in(
+        blocks: &DashMap<B256, ExecutedBlock<N>>,
+        parent_hash: B256,
+        preferred_anchor: B256,
+    ) -> Option<B256> {
+        if parent_hash == preferred_anchor {
+            return Some(preferred_anchor)
+        }
+
+        let mut hash = parent_hash;
+
+        loop {
+            let block_parent_hash = blocks.get(&hash)?.recovered_block().parent_hash();
+            if block_parent_hash == preferred_anchor {
+                return Some(block_parent_hash)
+            }
+            if !blocks.contains_key(&block_parent_hash) {
+                return Some(block_parent_hash)
+            }
+            hash = block_parent_hash;
+        }
+    }
+
+    fn compute_overlay(
+        &self,
+        compute_input: ComputeOverlayInput<N>,
+        anchor_hash: B256,
+        _span: tracing::Span,
+    ) -> Arc<TrieInputSorted> {
+        #[cfg(feature = "rayon")]
+        {
+            if let Some(worker_pool) = &self.worker_pool {
+                let compute_span = _span;
+                let metrics = self.metrics.clone();
+                return Arc::new(worker_pool.install_fn(move || {
+                    let _guard = compute_span.enter();
+                    compute_overlay(compute_input, anchor_hash, &metrics)
+                }))
+            }
+        }
+
+        Arc::new(compute_overlay(compute_input, anchor_hash, &self.metrics))
+    }
+}
+
+/// Error returned when a state trie overlay cannot be built from the manager's current block set.
+#[derive(Debug)]
+pub struct StateTrieOverlayError {
+    /// Requested in-memory tip hash.
+    tip_hash: B256,
+    /// Requested anchor hash.
+    anchor_hash: B256,
+}
+
+impl fmt::Display for StateTrieOverlayError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "state trie overlay for tip {} cannot be anchored to {} with current blocks",
+            self.tip_hash, self.anchor_hash
+        )
+    }
+}
+
+impl std::error::Error for StateTrieOverlayError {}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+struct OverlayCacheKey {
+    anchor_hash: B256,
+    tip_hash: B256,
+}
+
+#[derive(Clone)]
+enum OverlayCacheEntry {
+    Ready(Arc<TrieInputSorted>),
+    Computing(Arc<OverlayWaiter>),
+}
+
+impl OverlayCacheEntry {
+    const fn is_ready(&self) -> bool {
+        matches!(self, Self::Ready(_))
+    }
+
+    fn ready(&self) -> Option<Arc<TrieInputSorted>> {
+        match self {
+            Self::Ready(input) => Some(Arc::clone(input)),
+            Self::Computing(_) => None,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum OverlayLookupMode {
+    Required,
+    Precompute,
+}
+
+struct OverlayWaiter {
+    input: OnceLock<Arc<TrieInputSorted>>,
+}
+
+impl OverlayWaiter {
+    const fn new() -> Self {
+        Self { input: OnceLock::new() }
+    }
+
+    fn wait(&self) -> Arc<TrieInputSorted> {
+        Arc::clone(self.input.wait())
+    }
+
+    fn finish(&self, computed: Arc<TrieInputSorted>) {
+        let _ = self.input.set(computed);
+    }
+}
+
+enum ComputeOverlayInput<N: NodePrimitives> {
+    ExtendCached { block: ExecutedBlock<N>, parent_input: Arc<TrieInputSorted> },
+    MergeBlocks(Vec<ExecutedBlock<N>>),
+}
+
+#[tracing::instrument(
+    level = "trace",
+    target = "chain_state::state_trie_overlay",
+    skip_all,
+    fields(
+        anchor_hash = %anchor_hash,
+        block_count = tracing::field::Empty,
+        parent_overlay = tracing::field::Empty,
+        elapsed_us = tracing::field::Empty,
+    )
+)]
+fn compute_overlay<N: NodePrimitives>(
+    input: ComputeOverlayInput<N>,
+    anchor_hash: B256,
+    metrics: &StateTrieOverlayMetrics,
+) -> TrieInputSorted {
+    let started_at = Instant::now();
+    let block_count = match &input {
+        ComputeOverlayInput::ExtendCached { .. } => 1,
+        ComputeOverlayInput::MergeBlocks(blocks) => blocks.len(),
+    };
+    let parent_overlay = matches!(&input, ComputeOverlayInput::ExtendCached { .. });
+    tracing::Span::current().record("block_count", block_count);
+    tracing::Span::current().record("parent_overlay", parent_overlay);
+
+    let overlay = match input {
+        ComputeOverlayInput::ExtendCached { block, parent_input } => {
+            let trie_data = block.trie_data();
+
+            trace!(
+                target: "chain_state::state_trie_overlay",
+                %anchor_hash,
+                head = %block.recovered_block().hash(),
+                "extending cached parent state trie overlay"
+            );
+
+            let mut overlay = parent_input.as_ref().clone();
+            extend_overlay(&mut overlay, &trie_data.hashed_state, &trie_data.trie_updates);
+            overlay
+        }
+        ComputeOverlayInput::MergeBlocks(blocks) => merge_blocks(blocks),
+    };
+
+    let elapsed = started_at.elapsed();
+    metrics.overlay_computation_duration_seconds.record(elapsed.as_secs_f64());
+    tracing::Span::current().record("elapsed_us", elapsed.as_micros() as u64);
+    debug!(
+        target: "chain_state::state_trie_overlay",
+        %anchor_hash,
+        block_count,
+        parent_overlay,
+        ?elapsed,
+        "computed state trie overlay"
+    );
+
+    overlay
+}
+
+fn merge_blocks<N: NodePrimitives>(blocks: Vec<ExecutedBlock<N>>) -> TrieInputSorted {
+    let trie_data = blocks.iter().map(ExecutedBlock::trie_data).collect::<Vec<_>>();
+
+    #[cfg(feature = "rayon")]
+    let (nodes, state) = rayon::join(
+        || {
+            TrieUpdatesSorted::merge_batch(
+                trie_data.iter().map(|data| Arc::clone(&data.trie_updates)),
+            )
+        },
+        || {
+            HashedPostStateSorted::merge_batch(
+                trie_data.iter().map(|data| Arc::clone(&data.hashed_state)),
+            )
+        },
+    );
+
+    #[cfg(not(feature = "rayon"))]
+    let (nodes, state) = (
+        TrieUpdatesSorted::merge_batch(trie_data.iter().map(|data| Arc::clone(&data.trie_updates))),
+        HashedPostStateSorted::merge_batch(
+            trie_data.iter().map(|data| Arc::clone(&data.hashed_state)),
+        ),
+    );
+
+    TrieInputSorted::new(nodes, state, Default::default())
+}
+
+fn extend_overlay(
+    overlay: &mut TrieInputSorted,
+    hashed_state: &HashedPostStateSorted,
+    trie_updates: &TrieUpdatesSorted,
+) {
+    #[cfg(feature = "rayon")]
+    {
+        rayon::join(
+            || {
+                if !hashed_state.is_empty() {
+                    Arc::make_mut(&mut overlay.state).extend_ref_and_sort(hashed_state);
+                }
+            },
+            || {
+                if !trie_updates.is_empty() {
+                    Arc::make_mut(&mut overlay.nodes).extend_ref_and_sort(trie_updates);
+                }
+            },
+        );
+    }
+
+    #[cfg(not(feature = "rayon"))]
+    {
+        if !hashed_state.is_empty() {
+            Arc::make_mut(&mut overlay.state).extend_ref_and_sort(hashed_state);
+        }
+        if !trie_updates.is_empty() {
+            Arc::make_mut(&mut overlay.nodes).extend_ref_and_sort(trie_updates);
+        }
+    }
+}
+
+#[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};
+    #[cfg(feature = "rayon")]
+    use std::time::Instant;
+    use std::{
+        sync::{mpsc, Arc},
+        thread,
+        time::Duration,
+    };
+
+    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::new(Arc::new(hashed_state), Arc::new(TrieUpdatesSorted::default())),
+        )
+    }
+
+    fn test_blocks() -> Vec<ExecutedBlock<EthPrimitives>> {
+        TestBlockBuilder::eth()
+            .get_executed_blocks(1..4)
+            .enumerate()
+            .map(|(index, block)| with_unique_state(&block, index as u8 + 1))
+            .collect()
+    }
+
+    #[test]
+    fn errors_for_unknown_parent() {
+        let manager = StateTrieOverlayManager::<EthPrimitives>::default();
+        let parent = B256::random();
+        let anchor = B256::random();
+
+        let err = manager.overlay_for_parent(parent, anchor).unwrap_err();
+
+        assert_eq!(err.tip_hash, parent);
+        assert_eq!(err.anchor_hash, anchor);
+    }
+
+    #[test]
+    fn builds_managed_overlay_for_inserted_blocks() {
+        let manager = StateTrieOverlayManager::default();
+        let blocks = test_blocks();
+        for block in &blocks {
+            manager.insert_block(block.clone());
+        }
+
+        let anchor_hash = blocks[0].recovered_block().parent_hash();
+
+        let (_, state) =
+            manager.overlay_for_parent(blocks[2].recovered_block().hash(), anchor_hash).unwrap();
+        assert_eq!(state.accounts.len(), 3);
+
+        let short_anchor = blocks[1].recovered_block().hash();
+        let (_, short) =
+            manager.overlay_for_parent(blocks[2].recovered_block().hash(), short_anchor).unwrap();
+        assert_eq!(short.accounts.len(), 1);
+        let (_, cached_short) =
+            manager.overlay_for_parent(blocks[2].recovered_block().hash(), short_anchor).unwrap();
+        assert!(Arc::ptr_eq(&short, &cached_short));
+    }
+
+    #[test]
+    fn returns_anchor_for_in_memory_parent() {
+        let manager = StateTrieOverlayManager::default();
+        let blocks = test_blocks();
+        for block in &blocks {
+            manager.insert_block(block.clone());
+        }
+
+        assert_eq!(
+            manager.anchor_for_parent(blocks[2].recovered_block().hash(), B256::random()),
+            Some(blocks[0].recovered_block().parent_hash())
+        );
+
+        manager.remove_blocks([blocks[0].recovered_block().hash()]);
+        assert_eq!(
+            manager.anchor_for_parent(
+                blocks[2].recovered_block().hash(),
+                blocks[0].recovered_block().hash()
+            ),
+            Some(blocks[0].recovered_block().hash())
+        );
+    }
+
+    #[test]
+    fn prefers_anchor_in_parent_chain() {
+        let manager = StateTrieOverlayManager::default();
+        let blocks = test_blocks();
+        for block in &blocks {
+            manager.insert_block(block.clone());
+        }
+
+        let db_tip_hash = blocks[1].recovered_block().hash();
+        assert_eq!(
+            manager.anchor_for_parent(blocks[2].recovered_block().hash(), db_tip_hash),
+            Some(db_tip_hash)
+        );
+    }
+
+    #[test]
+    fn required_lookup_waits_for_in_progress_overlay() {
+        let manager = StateTrieOverlayManager::<EthPrimitives>::default();
+        let key = OverlayCacheKey {
+            anchor_hash: B256::with_last_byte(1),
+            tip_hash: B256::with_last_byte(2),
+        };
+        let waiter = Arc::new(OverlayWaiter::new());
+        manager.overlays.insert(key, OverlayCacheEntry::Computing(Arc::clone(&waiter)));
+
+        let (tx, rx) = mpsc::channel();
+        thread::spawn(move || {
+            let res =
+                manager.overlay_for_parent(key.tip_hash, key.anchor_hash).map(|(_, state)| state);
+            tx.send(res).unwrap();
+        });
+
+        assert!(matches!(
+            rx.recv_timeout(Duration::from_millis(50)),
+            Err(mpsc::RecvTimeoutError::Timeout)
+        ));
+
+        waiter.finish(Arc::new(TrieInputSorted::default()));
+
+        let state = rx.recv_timeout(Duration::from_secs(1)).unwrap().unwrap();
+        assert!(state.is_empty());
+    }
+
+    #[cfg(feature = "rayon")]
+    #[test]
+    fn precompute_skips_in_progress_overlay() {
+        let manager = StateTrieOverlayManager::<EthPrimitives>::new(Arc::new(WorkerPool::new(
+            1,
+            "test-ovly",
+        )));
+        let key = OverlayCacheKey {
+            anchor_hash: B256::with_last_byte(1),
+            tip_hash: B256::with_last_byte(2),
+        };
+        manager.overlays.insert(key, OverlayCacheEntry::Computing(Arc::new(OverlayWaiter::new())));
+
+        let (tx, rx) = mpsc::channel();
+        thread::spawn(move || {
+            tx.send(manager.precompute_overlay(key.tip_hash, key.anchor_hash)).unwrap();
+        });
+
+        rx.recv_timeout(Duration::from_secs(1)).unwrap().unwrap();
+    }
+
+    #[cfg(feature = "rayon")]
+    #[test]
+    fn insert_block_prepares_child_overlay_from_cached_parent() {
+        let manager = StateTrieOverlayManager::new(Arc::new(WorkerPool::new(2, "test-ovly")));
+        let blocks = test_blocks();
+
+        manager.insert_block(blocks[0].clone());
+
+        let anchor_hash = blocks[0].recovered_block().parent_hash();
+        let parent_hash = blocks[0].recovered_block().hash();
+        manager.overlay_for_parent(parent_hash, anchor_hash).unwrap();
+
+        let child_hash = blocks[1].recovered_block().hash();
+        manager.insert_block(blocks[1].clone());
+
+        let child_key = OverlayCacheKey { anchor_hash, tip_hash: child_hash };
+        let deadline = Instant::now() + Duration::from_secs(5);
+        while !manager.overlays.contains_key(&child_key) {
+            assert!(
+                Instant::now() < deadline,
+                "timed out waiting for optimistically prepared child overlay"
+            );
+            thread::sleep(Duration::from_millis(10));
+        }
+
+        let (_, state) = manager.overlay_for_parent(child_hash, anchor_hash).unwrap();
+        assert_eq!(state.accounts.len(), 2);
+    }
+
+    #[test]
+    fn prunes_cached_overlays_after_removing_blocks() {
+        let manager = StateTrieOverlayManager::default();
+        let blocks = test_blocks();
+        for block in &blocks {
+            manager.insert_block(block.clone());
+        }
+
+        let original_anchor = blocks[0].recovered_block().parent_hash();
+        manager.overlay_for_parent(blocks[2].recovered_block().hash(), original_anchor).unwrap();
+
+        manager.remove_blocks([
+            blocks[0].recovered_block().hash(),
+            blocks[1].recovered_block().hash(),
+        ]);
+
+        let anchor_hash = blocks[1].recovered_block().hash();
+        assert!(manager
+            .overlay_for_parent(blocks[2].recovered_block().hash(), original_anchor)
+            .is_err());
+
+        let (_, state) =
+            manager.overlay_for_parent(blocks[2].recovered_block().hash(), anchor_hash).unwrap();
+        assert_eq!(state.accounts.len(), 1);
+    }
+}
diff --git a/crates/cli/commands/src/common.rs b/crates/cli/commands/src/common.rs
index f7324efde41..fd7b5aacb35 100644
--- a/crates/cli/commands/src/common.rs
+++ b/crates/cli/commands/src/common.rs
@@ -27,7 +27,8 @@ use reth_provider::{
         BlockchainProvider, NodeTypesForProvider, RocksDBProvider, StaticFileProvider,
         StaticFileProviderBuilder,
     },
-    ProviderFactory, StaticFileProviderFactory, StorageSettings,
+    BalConfig, BalStoreHandle, InMemoryBalStore, ProviderFactory, StaticFileProviderFactory,
+    StorageSettings,
 };
 use reth_stages::{sets::DefaultStages, Pipeline, PipelineTarget};
 use reth_static_file::StaticFileProducer;
@@ -195,6 +196,11 @@ impl<C: ChainSpecParser> EnvironmentArgs<C> {
     where
         C: ChainSpecParser<ChainSpec = N::ChainSpec>,
     {
+        let balstore_cache_size =
+            self.db.balstore_cache_size.unwrap_or(BalConfig::DEFAULT_IN_MEMORY_RETENTION_DISTANCE);
+        let bal_store = BalStoreHandle::new(InMemoryBalStore::new(
+            BalConfig::with_in_memory_retention_distance(balstore_cache_size),
+        ));
         let factory = ProviderFactory::<NodeTypesWithDBAdapter<N, DatabaseEnv>>::new(
             db,
             self.chain.clone(),
@@ -203,7 +209,8 @@ impl<C: ChainSpecParser> EnvironmentArgs<C> {
             runtime,
         )?
         .with_prune_modes(config.prune.segments.clone())
-        .with_minimum_pruning_distance(config.prune.minimum_pruning_distance);
+        .with_minimum_pruning_distance(config.prune.minimum_pruning_distance)
+        .with_bal_store(bal_store);
 
         // Check for consistency between database and static files.
         if !access.is_read_only_inconsistent() &&
diff --git a/crates/cli/commands/src/db/list.rs b/crates/cli/commands/src/db/list.rs
index 77a321eff8f..59c7fd8549b 100644
--- a/crates/cli/commands/src/db/list.rs
+++ b/crates/cli/commands/src/db/list.rs
@@ -1,6 +1,6 @@
 use super::tui::DbListTUI;
 use alloy_primitives::hex;
-use clap::Parser;
+use clap::{builder::RangedU64ValueParser, Parser};
 use eyre::WrapErr;
 use reth_chainspec::EthereumHardforks;
 use reth_db::{transaction::DbTx, DatabaseEnv};
@@ -22,7 +22,7 @@ pub struct Command {
     #[arg(long, short, default_value_t = false)]
     reverse: bool,
     /// How many items to take from the walker
-    #[arg(long, short, default_value_t = 5)]
+    #[arg(long, short, default_value_t = 5, value_parser = RangedU64ValueParser::<usize>::new().range(1..))]
     len: usize,
     /// Search parameter for both keys and values. Prefix it with `0x` to search for binary data,
     /// and text otherwise.
@@ -143,3 +143,22 @@ impl<N: NodeTypes> TableViewer<()> for ListTableViewer<'_, N> {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn command_rejects_zero_len() {
+        let result = Command::try_parse_from(["list", "Headers", "--len", "0"]);
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn command_accepts_positive_len() {
+        let command = Command::try_parse_from(["list", "Headers", "--len", "10"]).unwrap();
+
+        assert_eq!(command.len, 10);
+    }
+}
diff --git a/crates/cli/commands/src/db/migrate_v2.rs b/crates/cli/commands/src/db/migrate_v2.rs
index 072fe0d419e..8bb31a89b56 100644
--- a/crates/cli/commands/src/db/migrate_v2.rs
+++ b/crates/cli/commands/src/db/migrate_v2.rs
@@ -1,8 +1,4 @@
 //! `reth db migrate-v2` command for migrating v1 storage layout to v2.
-//!
-//! Migrates data that cannot be recomputed (changesets + receipts) from MDBX to
-//! static files, clears recomputable tables (senders, indices, trie, plain
-//! state), compacts MDBX, then runs the pipeline to rebuild them.
 
 use crate::common::CliNodeTypes;
 use alloy_primitives::Address;
@@ -21,15 +17,16 @@ use reth_db_api::{
 };
 use reth_node_builder::NodeTypesWithDBAdapter;
 use reth_provider::{
-    providers::ProviderNodeTypes, DBProvider, DatabaseProviderFactory, MetadataProvider,
-    MetadataWriter, ProviderFactory, PruneCheckpointReader, StageCheckpointWriter,
-    StaticFileProviderFactory, StaticFileWriter, StorageSettings,
+    providers::ProviderNodeTypes, BlockNumReader, DBProvider, DatabaseProviderFactory,
+    MetadataProvider, MetadataWriter, ProviderFactory, PruneCheckpointReader,
+    RocksDBProviderFactory, StageCheckpointWriter, StaticFileProviderFactory, StaticFileWriter,
+    StorageSettings,
 };
 use reth_prune_types::PruneSegment;
 use reth_stages_types::{StageCheckpoint, StageId};
 use reth_static_file_types::StaticFileSegment;
 use reth_storage_api::StageCheckpointReader;
-use tracing::info;
+use tracing::{info, warn};
 
 /// `reth db migrate-v2` command
 #[derive(Debug, Parser)]
@@ -88,7 +85,12 @@ impl Command {
         // === Phase 2: Migrate receipts → static files ===
         Self::migrate_receipts::<NodeTypesWithDBAdapter<N, DatabaseEnv>>(&provider_factory, tip)?;
 
-        // === Phase 3: Flip metadata to v2 ===
+        // === Phase 3: Migrate indices → RocksDB ===
+        Self::migrate_to_rocksdb::<_, tables::TransactionHashNumbers>(&provider_factory)?;
+        Self::migrate_to_rocksdb::<_, tables::AccountsHistory>(&provider_factory)?;
+        Self::migrate_to_rocksdb::<_, tables::StoragesHistory>(&provider_factory)?;
+
+        // === Phase 4: Flip metadata to v2 ===
         info!(target: "reth::cli", "Writing StorageSettings v2 metadata");
         {
             let provider_rw = provider_factory.database_provider_rw()?;
@@ -97,10 +99,10 @@ impl Command {
         }
         info!(target: "reth::cli", "Storage settings updated to v2");
 
-        // === Phase 4: Clear recomputable tables ===
-        Self::clear_recomputable_tables(&provider_factory)?;
+        // === Phase 5: Clear migrated and recomputable MDBX tables ===
+        Self::clear_migrated_and_recomputable_tables(&provider_factory)?;
 
-        // === Phase 5: Compact MDBX (before pipeline, so it runs on a smaller DB) ===
+        // === Phase 6: Compact MDBX (before pipeline, so it runs on a smaller DB) ===
         let db_path = provider_factory.db_ref().path();
         Self::compact_mdbx(provider_factory.db_ref())?;
 
@@ -110,7 +112,7 @@ impl Command {
         let compact_path = db_path.with_file_name("db_compact");
         Self::swap_compacted_db(&db_path, &compact_path)?;
 
-        // === Phase 6: Reopen DB and run pipeline ===
+        // === Phase 7: Reopen DB and run pipeline ===
         // The caller will reopen the environment and run the pipeline.
         // We return here — the pipeline step is handled in mod.rs after
         // reopening the database with the compacted copy.
@@ -274,12 +276,38 @@ impl Command {
         Ok(())
     }
 
-    /// Clears tables that can be recomputed by the pipeline and resets their
-    /// stage checkpoints.
-    fn clear_recomputable_tables<N: ProviderNodeTypes>(
+    fn migrate_to_rocksdb<N: ProviderNodeTypes, T: Table>(
+        factory: &ProviderFactory<N>,
+    ) -> eyre::Result<()> {
+        info!(target: "reth::cli", table = T::NAME, "Migrating MDBX table → RocksDB");
+
+        let provider = factory.provider()?.disable_long_read_transaction_safety();
+        let mut cursor = provider.tx_ref().cursor_read::<T>()?;
+
+        let rocksdb = factory.rocksdb_provider();
+        rocksdb.clear::<T>()?;
+        let mut batch = rocksdb.batch_with_auto_commit();
+
+        let mut count = 0u64;
+        for entry in cursor.walk(None)? {
+            let (key, value) = entry?;
+            batch.put::<T>(key, &value)?;
+            count += 1;
+        }
+
+        batch.commit()?;
+        rocksdb.flush(&[T::NAME])?;
+
+        info!(target: "reth::cli", table = T::NAME, count, "MDBX table migrated to RocksDB");
+        Ok(())
+    }
+
+    /// Clears MDBX tables that were migrated to v2 backends or can be recomputed by the pipeline,
+    /// and resets only the recomputed stage checkpoints.
+    fn clear_migrated_and_recomputable_tables<N: ProviderNodeTypes>(
         factory: &ProviderFactory<N>,
     ) -> eyre::Result<()> {
-        info!(target: "reth::cli", "Clearing recomputable MDBX tables");
+        info!(target: "reth::cli", "Clearing migrated and recomputable MDBX tables");
         let db = factory.db_ref();
 
         macro_rules! clear_table {
@@ -298,7 +326,7 @@ impl Command {
         // Senders — rebuilt by SenderRecovery
         clear_table!(tables::TransactionSenders);
 
-        // Indices — rebuilt by TransactionLookup / IndexAccountHistory / IndexStorageHistory
+        // Indices — migrated to RocksDB
         clear_table!(tables::TransactionHashNumbers);
         clear_table!(tables::AccountsHistory);
         clear_table!(tables::StoragesHistory);
@@ -314,18 +342,45 @@ impl Command {
         // Reset stage checkpoints so the pipeline rebuilds everything
         info!(target: "reth::cli", "Resetting stage checkpoints");
         let provider_rw = factory.database_provider_rw()?;
-        for stage in [
-            StageId::SenderRecovery,
-            StageId::TransactionLookup,
-            StageId::IndexAccountHistory,
-            StageId::IndexStorageHistory,
-            StageId::MerkleExecute,
-            StageId::MerkleUnwind,
-        ] {
+        for stage in [StageId::SenderRecovery, StageId::MerkleExecute, StageId::MerkleUnwind] {
             provider_rw.save_stage_checkpoint(stage, StageCheckpoint::new(0))?;
             info!(target: "reth::cli", %stage, "Checkpoint reset to 0");
         }
         provider_rw.save_stage_checkpoint_progress(StageId::MerkleExecute, vec![])?;
+
+        if provider_rw.last_block_number()? > 0 {
+            let first_indices_entry = provider_rw
+                .tx_ref()
+                .cursor_read::<tables::BlockBodyIndices>()?
+                .seek(1)?
+                .map(|(block, _)| block)
+                .ok_or_else(|| eyre::eyre!("no block body indices found"))?;
+
+            // If the first block body indices entry is not block 1, it means that the v1 database
+            // was likely initialized with dummy blocks coming from a dummy chain generated by
+            // `setup_without_evm`.
+            //
+            // In that case, sender recovery starts from the first block that has a corresponding
+            // block body indices entry.
+            if first_indices_entry > 1 {
+                provider_rw.save_stage_checkpoint(
+                    StageId::SenderRecovery,
+                    StageCheckpoint::new(first_indices_entry - 1),
+                )?;
+
+                // Make sure that senders static files segment is at the correct height.
+                let static_file_provider = provider_rw.static_file_provider();
+                let mut senders_writer =
+                    static_file_provider.latest_writer(StaticFileSegment::TransactionSenders)?;
+                senders_writer.ensure_at_block(first_indices_entry - 1)?;
+                senders_writer.commit()?;
+
+                warn!(
+                    target: "reth::cli",
+                    "Missing block body indices data for first {first_indices_entry} blocks, initializing sender recovery with the first block that has a corresponding block body indices entry"
+                );
+            }
+        }
         provider_rw.commit()?;
 
         info!(target: "reth::cli", "Recomputable tables cleared");
diff --git a/crates/cli/commands/src/db/repair_trie.rs b/crates/cli/commands/src/db/repair_trie.rs
index fcda895c33b..602f8bbb4b4 100644
--- a/crates/cli/commands/src/db/repair_trie.rs
+++ b/crates/cli/commands/src/db/repair_trie.rs
@@ -1,3 +1,4 @@
+use alloy_consensus::BlockHeader as AlloyBlockHeader;
 use clap::Parser;
 use metrics::{self, Counter};
 use reth_chainspec::EthChainSpec;
@@ -18,7 +19,9 @@ use reth_node_metrics::{
     server::{MetricServer, MetricServerConfig},
     version::VersionInfo,
 };
-use reth_provider::{providers::ProviderNodeTypes, ChainSpecProvider, StageCheckpointReader};
+use reth_provider::{
+    providers::ProviderNodeTypes, ChainSpecProvider, HeaderProvider, StageCheckpointReader,
+};
 use reth_stages::StageId;
 use reth_storage_api::StorageSettingsCache;
 use reth_tasks::TaskExecutor;
@@ -27,7 +30,8 @@ use reth_trie::{
     Nibbles,
 };
 use reth_trie_db::{
-    DatabaseHashedCursorFactory, DatabaseTrieCursorFactory, StorageTrieEntryLike, TrieTableAdapter,
+    DatabaseHashedCursorFactory, DatabaseStateRoot, DatabaseTrieCursorFactory,
+    StorageTrieEntryLike, TrieTableAdapter,
 };
 use std::{
     net::SocketAddr,
@@ -215,7 +219,7 @@ fn verify_and_repair<N: ProviderNodeTypes>(tool: &DbTool<N>) -> eyre::Result<()>
     verify_checkpoints(provider_rw.as_ref())?;
 
     let inconsistent_nodes = reth_trie_db::with_adapter!(tool.provider_factory, |A| {
-        do_verify_and_repair::<_, A>(&mut provider_rw)?
+        do_verify_and_repair::<_, A>(&mut provider_rw, finish_checkpoint.block_number)?
     });
 
     if inconsistent_nodes == 0 {
@@ -230,6 +234,7 @@ fn verify_and_repair<N: ProviderNodeTypes>(tool: &DbTool<N>) -> eyre::Result<()>
 
 fn do_verify_and_repair<N: ProviderNodeTypes, A: TrieTableAdapter>(
     provider_rw: &mut reth_provider::DatabaseProviderRW<N::DB, N>,
+    block_number: u64,
 ) -> eyre::Result<usize>
 where
     <N::DB as reth_db_api::database::Database>::TXMut: DbTxMut + DbTx,
@@ -329,9 +334,48 @@ where
         }
     }
 
+    drop(account_trie_cursor);
+    drop(storage_trie_cursor);
+
+    if inconsistent_nodes > 0 {
+        // Refuse to commit repaired trie tables unless they reproduce the canonical tip state
+        // root.
+        verify_repaired_state_root::<_, A>(provider_rw, block_number)?;
+    }
+
     Ok(inconsistent_nodes as usize)
 }
 
+fn verify_repaired_state_root<N: ProviderNodeTypes, A: TrieTableAdapter>(
+    provider_rw: &reth_provider::DatabaseProviderRW<N::DB, N>,
+    block_number: u64,
+) -> eyre::Result<()>
+where
+    <N::DB as reth_db_api::database::Database>::TXMut: DbTxMut + DbTx,
+{
+    type DbStateRoot<'a, TX, A> = reth_trie::StateRoot<
+        DatabaseTrieCursorFactory<&'a TX, A>,
+        DatabaseHashedCursorFactory<&'a TX>,
+    >;
+
+    let expected_state_root = provider_rw
+        .header_by_number(block_number)?
+        .ok_or_else(|| {
+            eyre::eyre!("Missing canonical header at database block tip {block_number}")
+        })?
+        .state_root();
+
+    let computed_state_root = DbStateRoot::<_, A>::from_tx(provider_rw.tx_ref()).root()?;
+
+    if computed_state_root != expected_state_root {
+        return Err(eyre::eyre!(
+            "Repaired trie state root mismatch at block {block_number}: computed {computed_state_root}, header {expected_state_root}",
+        ))
+    }
+
+    Ok(())
+}
+
 /// Output progress information based on the last seen account path.
 fn output_progress(last_account: Nibbles, start_time: Instant, inconsistent_nodes: u64) {
     // Calculate percentage based on position in the trie path space
diff --git a/crates/cli/commands/src/download/mod.rs b/crates/cli/commands/src/download/mod.rs
index f3ab259b8d3..5cedbe4ad7e 100644
--- a/crates/cli/commands/src/download/mod.rs
+++ b/crates/cli/commands/src/download/mod.rs
@@ -122,6 +122,9 @@ use tui::{run_selector, SelectorOutput};
 
 const RETH_SNAPSHOTS_BASE_URL: &str = "https://snapshots-r2.reth.rs";
 const RETH_SNAPSHOTS_API_URL: &str = "https://snapshots.reth.rs/api/snapshots";
+const RETH_SNAPSHOTS_SOURCE: &str = "https://snapshots.reth.rs (default)";
+const SNAPSHOT_API_PATH: &str = "/api/snapshots";
+const FORCE_REMOVED_DATADIR_PATHS: &[&str] = &["db", "rocksdb", "static_files", "reth.toml"];
 
 /// Maximum number of simultaneous HTTP downloads across the entire snapshot job.
 const MAX_CONCURRENT_DOWNLOADS: usize = 8;
@@ -185,7 +188,7 @@ impl DownloadDefaults {
     pub fn default_download_defaults() -> Self {
         Self {
             available_snapshots: vec![
-                Cow::Borrowed("https://snapshots.reth.rs (default)"),
+                Cow::Borrowed(RETH_SNAPSHOTS_SOURCE),
                 Cow::Borrowed("https://publicnode.com/snapshots (full nodes & testnets)"),
             ],
             default_base_url: Cow::Borrowed(RETH_SNAPSHOTS_BASE_URL),
@@ -214,7 +217,7 @@ impl DownloadDefaults {
             "Specify a snapshot URL or let the command propose a default one.\n\n\
              Browse available snapshots at {}\n\
              or use --list-snapshots to see them from the CLI.\n\nAvailable snapshot sources:\n",
-            self.snapshot_api_url.trim_end_matches("/api/snapshots"),
+            self.snapshot_source_url(),
         );
 
         for source in &self.available_snapshots {
@@ -237,7 +240,11 @@ impl DownloadDefaults {
     }
 
     fn mainnet_only_discovery(&self) -> bool {
-        self.snapshot_api_url == RETH_SNAPSHOTS_API_URL
+        self.snapshot_api_url.trim_end_matches('/') == RETH_SNAPSHOTS_API_URL
+    }
+
+    fn snapshot_source_url(&self) -> &str {
+        snapshot_source_url_from_api(&self.snapshot_api_url)
     }
 
     /// Add a snapshot source to the list
@@ -265,8 +272,35 @@ impl DownloadDefaults {
     }
 
     /// Set the snapshot discovery API URL.
+    ///
+    /// Generated help uses the API root as the default snapshot source unless a custom
+    /// chain-aware base URL or source list was already provided.
     pub fn with_snapshot_api_url(mut self, url: impl Into<Cow<'static, str>>) -> Self {
         self.snapshot_api_url = url.into();
+
+        let source_url = self.snapshot_source_url().to_string();
+        if self.default_chain_aware_base_url.is_none() {
+            self.default_chain_aware_base_url = Some(Cow::Owned(source_url.clone()));
+        }
+        for source in &mut self.available_snapshots {
+            if source.as_ref() == RETH_SNAPSHOTS_SOURCE {
+                *source = Cow::Owned(format!("{source_url} (default)"));
+            }
+        }
+
+        self
+    }
+
+    /// Set one default snapshot source URL for discovery and generated CLI references.
+    ///
+    /// The provided URL is the public snapshot root, such as `https://snapshots.example.com`.
+    /// The discovery API is derived as `{url}/api/snapshots`.
+    pub fn with_snapshot_source_url(mut self, url: impl Into<Cow<'static, str>>) -> Self {
+        let source_url = normalize_snapshot_source_url(url.into());
+        self.available_snapshots = vec![Cow::Owned(format!("{} (default)", source_url.as_ref()))];
+        self.default_base_url = source_url.clone();
+        self.default_chain_aware_base_url = Some(source_url.clone());
+        self.snapshot_api_url = Cow::Owned(format!("{}{SNAPSHOT_API_PATH}", source_url.as_ref()));
         self
     }
 
@@ -277,6 +311,17 @@ impl DownloadDefaults {
     }
 }
 
+fn snapshot_source_url_from_api(api_url: &str) -> &str {
+    api_url.trim_end_matches('/').trim_end_matches(SNAPSHOT_API_PATH)
+}
+
+fn normalize_snapshot_source_url(url: Cow<'static, str>) -> Cow<'static, str> {
+    match url {
+        Cow::Borrowed(url) => Cow::Borrowed(snapshot_source_url_from_api(url)),
+        Cow::Owned(url) => Cow::Owned(snapshot_source_url_from_api(&url).to_string()),
+    }
+}
+
 impl Default for DownloadDefaults {
     /// Returns the built-in download defaults.
     fn default() -> Self {
@@ -375,6 +420,10 @@ pub struct DownloadCommand<C: ChainSpecParser> {
     #[arg(long, short = 'y')]
     non_interactive: bool,
 
+    /// Overwrite existing snapshot data by removing db, rocksdb, static_files, and reth.toml.
+    #[arg(long, conflicts_with = "list")]
+    force: bool,
+
     /// Enable resumable two-phase downloads (download to disk first, then extract).
     ///
     /// Archives are downloaded to a `.part` file with HTTP Range resume support
@@ -404,11 +453,6 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> DownloadCo
     pub async fn execute<N>(self) -> Result<()> {
         let chain = self.env.chain.chain();
         let chain_id = chain.id();
-        let data_dir = self.env.datadir.clone().resolve_datadir(chain);
-        fs::create_dir_all(&data_dir)?;
-
-        let cancel_token = CancellationToken::new();
-        let _cancel_guard = cancel_token.drop_guard();
 
         // --list: print available snapshots and exit
         if self.list {
@@ -417,8 +461,19 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> DownloadCo
             return Ok(());
         }
 
+        let data_dir = self.env.datadir.clone().resolve_datadir(chain);
+
+        let cancel_token = CancellationToken::new();
+        let _cancel_guard = cancel_token.drop_guard();
+
         // Legacy single-URL mode: download one archive and extract it
         if let Some(ref url) = self.url {
+            let target_dir = data_dir.data_dir();
+            if self.force {
+                clear_existing_datadir(target_dir)?;
+            }
+            fs::create_dir_all(target_dir)?;
+
             let request_limiter = DownloadRequestLimiter::new(self.download_concurrency.max(1));
             info!(target: "reth::cli",
                 dir = ?data_dir.data_dir(),
@@ -449,6 +504,10 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> DownloadCo
 
         let target_dir = data_dir.data_dir();
         let planned_downloads = collect_planned_archives(&manifest, &selections)?;
+        if self.force {
+            clear_existing_datadir(target_dir)?;
+        }
+        fs::create_dir_all(target_dir)?;
         let startup_summary = summarize_download_startup(&planned_downloads.archives, target_dir)?;
         info!(target: "reth::cli",
             reusable = startup_summary.reusable,
@@ -760,7 +819,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> DownloadCo
                          \t--manifest-path <PATH>\n\
                          \t-u <SNAPSHOT-URL>\n\n\
                          Use --list to inspect snapshots exposed by {}.",
-                        defaults.snapshot_api_url.trim_end_matches("/api/snapshots"),
+                        defaults.snapshot_source_url(),
                     );
                 }
 
@@ -803,6 +862,30 @@ fn selection_from_prune_mode(mode: Option<PruneMode>, snapshot_block: u64) -> Co
     }
 }
 
+/// Removes existing snapshot data that is managed by `reth download`.
+fn clear_existing_datadir(target_dir: &Path) -> Result<()> {
+    if !target_dir.try_exists()? {
+        return Ok(());
+    }
+
+    info!(target: "reth::cli", dir = ?target_dir, "Clearing existing snapshot data");
+    for entry in FORCE_REMOVED_DATADIR_PATHS {
+        let path = target_dir.join(entry);
+        if !path.try_exists()? {
+            continue;
+        }
+
+        let metadata = fs::metadata(&path)?;
+        if metadata.is_dir() {
+            fs::remove_dir_all(&path)?;
+        } else if metadata.is_file() {
+            fs::remove_file(&path)?;
+        }
+    }
+
+    Ok(())
+}
+
 /// If all data components (txs, receipts, changesets) are `All`, automatically
 /// include hidden archive-only components when available in the manifest.
 fn inject_archive_only_components(
@@ -875,6 +958,14 @@ fn current_binary_name() -> String {
         .unwrap_or_else(|| "reth".to_string())
 }
 
+fn download_command() -> String {
+    download_command_for_binary(&current_binary_name())
+}
+
+fn download_command_for_binary(binary_name: &str) -> String {
+    format!("{binary_name} download")
+}
+
 fn startup_chain_arg<C>(chain_spec: &C::ChainSpec) -> Option<String>
 where
     C: ChainSpecParser,
@@ -995,12 +1086,54 @@ mod tests {
 
     #[test]
     fn test_custom_snapshot_api_keeps_selected_chain_help() {
-        let help = DownloadDefaults::default()
-            .with_snapshot_api_url("https://snapshots.tempoxyz.dev/api/snapshots")
-            .long_help();
+        let defaults = DownloadDefaults::default()
+            .with_snapshot_api_url("https://snapshots.tempoxyz.dev/api/snapshots");
+        let help = defaults.long_help();
 
+        assert_eq!(
+            defaults.default_chain_aware_base_url.as_deref(),
+            Some("https://snapshots.tempoxyz.dev")
+        );
+        assert!(help.contains("Browse available snapshots at https://snapshots.tempoxyz.dev"));
+        assert!(help.contains("- https://snapshots.tempoxyz.dev (default)"));
         assert!(help.contains("selected chain"));
         assert!(!help.contains("Ethereum mainnet"));
+        assert!(!help.contains("snapshots.reth.rs"));
+    }
+
+    #[test]
+    fn test_snapshot_source_url_sets_generated_references() {
+        let defaults =
+            DownloadDefaults::default().with_snapshot_source_url("https://snapshots.tempoxyz.dev/");
+        let help = defaults.long_help();
+
+        assert_eq!(defaults.snapshot_api_url, "https://snapshots.tempoxyz.dev/api/snapshots");
+        assert_eq!(defaults.default_base_url, "https://snapshots.tempoxyz.dev");
+        assert_eq!(
+            defaults.default_chain_aware_base_url.as_deref(),
+            Some("https://snapshots.tempoxyz.dev")
+        );
+        assert_eq!(
+            defaults.available_snapshots.iter().map(|source| source.as_ref()).collect::<Vec<_>>(),
+            vec!["https://snapshots.tempoxyz.dev (default)"]
+        );
+        assert!(!defaults.mainnet_only_discovery());
+        assert!(help.contains("Browse available snapshots at https://snapshots.tempoxyz.dev"));
+        assert!(help.contains("from https://snapshots.tempoxyz.dev."));
+    }
+
+    #[test]
+    fn test_snapshot_api_url_trailing_slash_sets_source_url() {
+        let defaults = DownloadDefaults::default()
+            .with_snapshot_api_url("https://snapshots.tempoxyz.dev/api/snapshots/");
+        let help = defaults.long_help();
+
+        assert_eq!(
+            defaults.default_chain_aware_base_url.as_deref(),
+            Some("https://snapshots.tempoxyz.dev")
+        );
+        assert!(help.contains("Browse available snapshots at https://snapshots.tempoxyz.dev"));
+        assert!(help.contains("- https://snapshots.tempoxyz.dev (default)"));
     }
 
     #[test]
@@ -1186,4 +1319,9 @@ mod tests {
 
         assert_eq!(command, "tempo node --chain holesky");
     }
+
+    #[test]
+    fn download_command_uses_binary_name() {
+        assert_eq!(download_command_for_binary("tempo"), "tempo download");
+    }
 }
diff --git a/crates/cli/commands/src/download/source.rs b/crates/cli/commands/src/download/source.rs
index 3a5a68921ed..c8ef9433e11 100644
--- a/crates/cli/commands/src/download/source.rs
+++ b/crates/cli/commands/src/download/source.rs
@@ -1,4 +1,6 @@
-use super::{manifest::SnapshotManifest, progress::DownloadProgress, DownloadDefaults};
+use super::{
+    download_command, manifest::SnapshotManifest, progress::DownloadProgress, DownloadDefaults,
+};
 use eyre::{Result, WrapErr};
 use reqwest::Client;
 use reth_fs_util as fs;
@@ -37,6 +39,7 @@ impl SnapshotApiEntry {
 pub(crate) async fn discover_manifest_url(chain_id: u64) -> Result<String> {
     let defaults = DownloadDefaults::get_global();
     let api_url = &*defaults.snapshot_api_url;
+    let snapshot_source_url = defaults.snapshot_source_url();
 
     info!(target: "reth::cli", %api_url, %chain_id, "Discovering latest snapshot manifest");
 
@@ -50,7 +53,7 @@ pub(crate) async fn discover_manifest_url(chain_id: u64) -> Result<String> {
              use a direct snapshot URL with -u from:\n\
              \t- {}\n\n\
              Use --list to see all available snapshots.",
-                api_url.trim_end_matches("/api/snapshots"),
+                snapshot_source_url,
             )
         })?;
 
@@ -101,11 +104,8 @@ pub(crate) async fn fetch_snapshot_api_entries(chain_id: u64) -> Result<Vec<Snap
 pub(crate) fn print_snapshot_listing(entries: &[SnapshotApiEntry], chain_id: u64) {
     let modular: Vec<_> = entries.iter().filter(|entry| entry.is_modular()).collect();
 
-    let api_url = &*DownloadDefaults::get_global().snapshot_api_url;
-    println!(
-        "Available snapshots for chain {chain_id} ({}):\n",
-        api_url.trim_end_matches("/api/snapshots"),
-    );
+    let snapshot_source_url = DownloadDefaults::get_global().snapshot_source_url();
+    println!("Available snapshots for chain {chain_id} ({}):\n", snapshot_source_url,);
     println!("{:<12}  {:>10}  {:<10}  {:>10}  MANIFEST URL", "DATE", "BLOCK", "PROFILE", "SIZE");
     println!("{}", "-".repeat(100));
 
@@ -130,7 +130,8 @@ pub(crate) fn print_snapshot_listing(entries: &[SnapshotApiEntry], chain_id: u64
 
     println!(
         "\nTo download a specific snapshot, copy its manifest URL and run:\n  \
-         reth download --manifest-url <URL>"
+         {} --manifest-url <URL>",
+        download_command()
     );
 }
 
@@ -155,8 +156,9 @@ pub(crate) async fn fetch_manifest_from_source(source: &str) -> Result<SnapshotM
                             "Failed to fetch snapshot manifest from {source}\n\n\
                              The manifest endpoint may not be available for this snapshot source.\n\
                              You can use a direct snapshot URL instead:\n\n\
-                             \treth download -u <snapshot-url>\n\n\
-                             Available snapshot sources:\n{sources}"
+                             \t{} -u <snapshot-url>\n\n\
+                             Available snapshot sources:\n{sources}",
+                            download_command()
                         )
                     })?;
                 Ok(response.json().await?)
diff --git a/crates/cli/commands/src/download/tui.rs b/crates/cli/commands/src/download/tui.rs
index 36dfd76a9e2..30234b08a02 100644
--- a/crates/cli/commands/src/download/tui.rs
+++ b/crates/cli/commands/src/download/tui.rs
@@ -1,4 +1,5 @@
 use crate::download::{
+    download_command,
     manifest::{ComponentSelection, SnapshotComponentType, SnapshotManifest},
     DownloadProgress, SelectionPreset,
 };
@@ -368,7 +369,7 @@ fn render(f: &mut Frame<'_>, app: &mut SelectorApp) {
     };
     let header = Paragraph::new(format!(" Select snapshot components to download{}", block_info))
         .style(Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD))
-        .block(Block::default().borders(Borders::ALL).title("reth download"));
+        .block(Block::default().borders(Borders::ALL).title(download_command()));
     f.render_widget(header, chunks[0]);
 
     // Component list
diff --git a/crates/cli/commands/src/import_core.rs b/crates/cli/commands/src/import_core.rs
index 48f9e27738a..a792a824022 100644
--- a/crates/cli/commands/src/import_core.rs
+++ b/crates/cli/commands/src/import_core.rs
@@ -131,14 +131,25 @@ where
     let mut bad_block_number: Option<u64> = None;
     let mut last_valid_block_number: Option<u64> = None;
 
-    while let Some(file_client) =
-        reader.next_chunk::<BlockTy<N>>(consensus.clone(), Some(sealed_header)).await?
+    let skip_invalid_blocks = !import_config.fail_on_invalid_block;
+    while let Some(file_client) = reader
+        .next_chunk_with_invalid_block_handling::<BlockTy<N>>(
+            consensus.clone(),
+            Some(sealed_header.clone()),
+            skip_invalid_blocks,
+        )
+        .await?
     {
         // create a new FileClient from chunk read from file
         info!(target: "reth::import",
             "Importing chain file chunk"
         );
 
+        if file_client.headers_len() == 0 {
+            debug!(target: "reth::import", "Skipping chain file chunk without valid blocks");
+            continue;
+        }
+
         let tip = file_client.tip().ok_or(eyre::eyre!("file client has no tip"))?;
         info!(target: "reth::import", "Chain file chunk read");
 
diff --git a/crates/cli/commands/src/import_era.rs b/crates/cli/commands/src/import_era.rs
index d0eeebe2293..628415b8e44 100644
--- a/crates/cli/commands/src/import_era.rs
+++ b/crates/cli/commands/src/import_era.rs
@@ -84,7 +84,11 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> ImportEraC
         if let Some(path) = self.import.path {
             let stream = read_dir(path, next_block)?;
 
-            era::import(stream, &provider_factory, &mut hash_collector)?;
+            era::import::<era::Era1, _, _, _, _, _, _>(
+                stream,
+                &provider_factory,
+                &mut hash_collector,
+            )?;
         } else {
             let url = match self.import.url {
                 Some(url) => url,
@@ -99,7 +103,11 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> ImportEraC
             let client = EraClient::new(Client::new(), url, folder);
             let stream = EraStream::new(client, config);
 
-            era::import(stream, &provider_factory, &mut hash_collector)?;
+            era::import::<era::Era1, _, _, _, _, _, _>(
+                stream,
+                &provider_factory,
+                &mut hash_collector,
+            )?;
         }
 
         Ok(())
diff --git a/crates/cli/commands/src/node.rs b/crates/cli/commands/src/node.rs
index 3731562a257..eac2569c801 100644
--- a/crates/cli/commands/src/node.rs
+++ b/crates/cli/commands/src/node.rs
@@ -205,7 +205,8 @@ where
         let db_path = data_dir.db();
 
         tracing::info!(target: "reth::cli", path = ?db_path, "Opening database");
-        let database = init_db(db_path.clone(), self.db.database_args())?.with_metrics();
+        let database = init_db(db_path.clone(), self.db.database_args())?
+            .with_metrics_if(self.db.metrics_enabled());
 
         if with_unused_ports {
             node_config = node_config.with_unused_ports();
diff --git a/crates/cli/commands/src/re_execute.rs b/crates/cli/commands/src/re_execute.rs
index 5923fde9f3c..6512ee02763 100644
--- a/crates/cli/commands/src/re_execute.rs
+++ b/crates/cli/commands/src/re_execute.rs
@@ -195,7 +195,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
                         };
 
                         if let Err(err) = consensus
-                            .validate_block_post_execution(&block, &result, None)
+                            .validate_block_post_execution(&block, &result, None,None)
                             .wrap_err_with(|| {
                                 format!(
                                     "Failed to validate block {} {}",
@@ -257,7 +257,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
 
                             return Err(err);
                         }
-                        let _ = stats_tx.send(block.gas_used());
+                        let _ = stats_tx.send((block.number(), block.gas_used()));
 
                         // Reset DB once in a while to avoid OOM or read tx timeouts
                         if executor.size_hint() > 5_000_000 ||
@@ -294,6 +294,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
         let instant = Instant::now();
         let mut total_executed_blocks = 0;
         let mut total_executed_gas = 0;
+        let mut latest_executed_block = None;
 
         let mut last_logged_gas = 0;
         let mut last_logged_blocks = 0;
@@ -304,9 +305,11 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
 
         loop {
             tokio::select! {
-                Some(gas_used) = stats_rx.recv() => {
+                Some((block_number, gas_used)) = stats_rx.recv() => {
                     total_executed_blocks += 1;
                     total_executed_gas += gas_used;
+                    latest_executed_block =
+                        Some(latest_executed_block.unwrap_or(block_number).max(block_number));
                 }
                 Some((block, err)) = info_rx.recv() => {
                     error!(?err, block=?block.num_hash(), "Invalid block");
@@ -331,6 +334,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
                         info!(
                             throughput=?format_gas_throughput(gas_executed, last_logged_time.elapsed()),
                             progress=format!("{progress:.2}%"),
+                            ?latest_executed_block,
                             "Executed {blocks_executed} blocks"
                         );
                     }
@@ -347,6 +351,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
                 start_block = min_block,
                 end_block = max_block,
                 %total_executed_blocks,
+                ?latest_executed_block,
                 throughput=?format_gas_throughput(total_executed_gas, instant.elapsed()),
                 "Re-executed successfully"
             );
@@ -355,6 +360,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
                 start_block = min_block,
                 end_block = max_block,
                 %total_executed_blocks,
+                ?latest_executed_block,
                 invalid_block_count = invalid_blocks.len(),
                 ?invalid_blocks,
                 throughput=?format_gas_throughput(total_executed_gas, instant.elapsed()),
diff --git a/crates/cli/commands/src/test_vectors/compact.rs b/crates/cli/commands/src/test_vectors/compact.rs
index f4636f5f83b..5f83308510a 100644
--- a/crates/cli/commands/src/test_vectors/compact.rs
+++ b/crates/cli/commands/src/test_vectors/compact.rs
@@ -194,7 +194,7 @@ where
     T: for<'a> Arbitrary<'a> + reth_codecs::Compact,
 {
     let type_name = type_name::<T>();
-    print!("{}", &type_name);
+    print!("{}", type_name);
 
     let mut bytes = std::iter::repeat_n(0u8, 256).collect::<Vec<u8>>();
     let mut compact_buffer = vec![];
@@ -230,7 +230,7 @@ where
 
     serde_json::to_writer(
         std::io::BufWriter::new(
-            std::fs::File::create(format!("{VECTORS_FOLDER}/{}.json", &type_name)).unwrap(),
+            std::fs::File::create(format!("{VECTORS_FOLDER}/{}.json", type_name)).unwrap(),
         ),
         &values,
     )?;
@@ -247,10 +247,10 @@ where
     T: reth_codecs::Compact,
 {
     let type_name = type_name::<T>();
-    print!("{}", &type_name);
+    print!("{}", type_name);
 
     // Read the file where the vectors are stored
-    let file_path = format!("{VECTORS_FOLDER}/{}.json", &type_name);
+    let file_path = format!("{VECTORS_FOLDER}/{}.json", type_name);
     let file =
         File::open(&file_path).wrap_err_with(|| format!("Failed to open vector {type_name}."))?;
     let reader = BufReader::new(file);
diff --git a/crates/consensus/consensus/Cargo.toml b/crates/consensus/consensus/Cargo.toml
index 4d2c0ac0768..5fa7c181525 100644
--- a/crates/consensus/consensus/Cargo.toml
+++ b/crates/consensus/consensus/Cargo.toml
@@ -18,6 +18,7 @@ reth-primitives-traits.workspace = true
 # ethereum
 alloy-primitives.workspace = true
 alloy-consensus.workspace = true
+alloy-eip7928.workspace = true
 
 # misc
 auto_impl.workspace = true
@@ -29,10 +30,8 @@ std = [
     "reth-primitives-traits/std",
     "alloy-primitives/std",
     "alloy-consensus/std",
-    "reth-primitives-traits/std",
     "reth-execution-types/std",
     "thiserror/std",
+    "alloy-eip7928/std",
 ]
-test-utils = [
-    "reth-primitives-traits/test-utils",
-]
+test-utils = ["reth-primitives-traits/test-utils"]
diff --git a/crates/consensus/consensus/src/lib.rs b/crates/consensus/consensus/src/lib.rs
index 6040d5ca79d..59ab0354b38 100644
--- a/crates/consensus/consensus/src/lib.rs
+++ b/crates/consensus/consensus/src/lib.rs
@@ -38,6 +38,7 @@ use alloc::{
     vec::Vec,
 };
 use alloy_consensus::Header;
+use alloy_eip7928::BlockAccessListGasError;
 use alloy_primitives::{BlockHash, BlockNumber, Bloom, B256};
 use core::{error::Error, fmt::Display};
 
@@ -85,6 +86,7 @@ pub trait FullConsensus<N: NodePrimitives>: Consensus<N::Block> {
         block: &RecoveredBlock<N::Block>,
         result: &BlockExecutionResult<N::Receipt>,
         receipt_root_bloom: Option<ReceiptRootBloom>,
+        block_access_list_hash: Option<B256>,
     ) -> Result<(), ConsensusError>;
 }
 
@@ -328,6 +330,14 @@ pub enum ConsensusError {
     #[error("missing requests hash")]
     RequestsHashMissing,
 
+    /// Error when the block access list hash is missing.
+    #[error("missing block access list hash")]
+    BlockAccessListHashMissing,
+
+    /// Error when the slot number is missing.
+    #[error("missing slot number")]
+    SlotNumberMissing,
+
     /// Error when an unexpected withdrawals root is encountered.
     #[error("unexpected withdrawals root")]
     WithdrawalsRootUnexpected,
@@ -336,6 +346,14 @@ pub enum ConsensusError {
     #[error("unexpected requests hash")]
     RequestsHashUnexpected,
 
+    /// Error when an unexpected block access list hash is encountered.
+    #[error("unexpected block access list hash")]
+    BlockAccessListHashUnexpected,
+
+    /// Error when an unexpected slot number is encountered.
+    #[error("unexpected slot number")]
+    SlotNumberUnexpected,
+
     /// Error when withdrawals are missing.
     #[error("missing withdrawals")]
     BodyWithdrawalsMissing,
@@ -474,6 +492,15 @@ pub enum ConsensusError {
     /// EIP-7825: Transaction gas limit exceeds maximum allowed
     #[error(transparent)]
     TransactionGasLimitTooHigh(Box<TxGasLimitTooHighErr>),
+    /// EIP-7928: Error when an unexpected block access list cost is encountered.
+    #[error(transparent)]
+    BlockAccessListCostMoreThanGasLimit(Box<BlockAccessListGasError>),
+    /// EIP-7928: Error when the block access list hash doesn't match the expected value.
+    #[error("block access list hash mismatch: {0}")]
+    BlockAccessListHashMismatch(GotExpectedBoxed<B256>),
+    /// EIP-7928: Error when the block access list cannot be decoded or converted.
+    #[error("invalid block access list: {0}")]
+    BlockAccessListInvalid(String),
     /// Any additional consensus error, for example L2-specific errors.
     #[error(transparent)]
     Other(#[from] Arc<dyn Error + Send + Sync>),
@@ -531,6 +558,12 @@ impl From<TxGasLimitTooHighErr> for ConsensusError {
     }
 }
 
+impl From<BlockAccessListGasError> for ConsensusError {
+    fn from(value: BlockAccessListGasError) -> Self {
+        Self::BlockAccessListCostMoreThanGasLimit(Box::new(value))
+    }
+}
+
 /// `HeaderConsensusError` combines a `ConsensusError` with the `SealedHeader` it relates to.
 #[derive(thiserror::Error, Debug)]
 #[error("Consensus error: {0}, Invalid header: {1:?}")]
diff --git a/crates/consensus/consensus/src/noop.rs b/crates/consensus/consensus/src/noop.rs
index 08fe08e96e3..8f7520cf374 100644
--- a/crates/consensus/consensus/src/noop.rs
+++ b/crates/consensus/consensus/src/noop.rs
@@ -20,6 +20,7 @@
 
 use crate::{Consensus, ConsensusError, FullConsensus, HeaderValidator, ReceiptRootBloom};
 use alloc::sync::Arc;
+use alloy_primitives::B256;
 use reth_execution_types::BlockExecutionResult;
 use reth_primitives_traits::{Block, NodePrimitives, RecoveredBlock, SealedBlock, SealedHeader};
 
@@ -77,6 +78,7 @@ impl<N: NodePrimitives> FullConsensus<N> for NoopConsensus {
         _block: &RecoveredBlock<N::Block>,
         _result: &BlockExecutionResult<N::Receipt>,
         _receipt_root_bloom: Option<ReceiptRootBloom>,
+        _block_access_list_hash: Option<B256>,
     ) -> Result<(), ConsensusError> {
         Ok(())
     }
diff --git a/crates/consensus/consensus/src/test_utils.rs b/crates/consensus/consensus/src/test_utils.rs
index b2a1fc71f0e..fd7644c479f 100644
--- a/crates/consensus/consensus/src/test_utils.rs
+++ b/crates/consensus/consensus/src/test_utils.rs
@@ -1,4 +1,5 @@
 use crate::{Consensus, ConsensusError, FullConsensus, HeaderValidator, ReceiptRootBloom};
+use alloy_primitives::B256;
 use core::sync::atomic::{AtomicBool, Ordering};
 use reth_execution_types::BlockExecutionResult;
 use reth_primitives_traits::{Block, NodePrimitives, RecoveredBlock, SealedBlock, SealedHeader};
@@ -52,6 +53,7 @@ impl<N: NodePrimitives> FullConsensus<N> for TestConsensus {
         _block: &RecoveredBlock<N::Block>,
         _result: &BlockExecutionResult<N::Receipt>,
         _receipt_root_bloom: Option<ReceiptRootBloom>,
+        _block_access_list_hash: Option<B256>,
     ) -> Result<(), ConsensusError> {
         if self.fail_validation() {
             Err(ConsensusError::BaseFeeMissing)
diff --git a/crates/consensus/debug-client/Cargo.toml b/crates/consensus/debug-client/Cargo.toml
index 86d3145a12f..2fdb84a46e9 100644
--- a/crates/consensus/debug-client/Cargo.toml
+++ b/crates/consensus/debug-client/Cargo.toml
@@ -14,10 +14,9 @@ workspace = true
 # reth
 reth-node-api.workspace = true
 reth-tracing.workspace = true
-reth-primitives-traits.workspace = true
 
 # ethereum
-alloy-consensus = { workspace = true, features = ["serde"] }
+alloy-consensus.workspace = true
 alloy-eips.workspace = true
 alloy-provider = { workspace = true, features = ["ws"] }
 alloy-transport.workspace = true
diff --git a/crates/consensus/debug-client/src/client.rs b/crates/consensus/debug-client/src/client.rs
index cb50708494f..00acd4b0922 100644
--- a/crates/consensus/debug-client/src/client.rs
+++ b/crates/consensus/debug-client/src/client.rs
@@ -1,35 +1,34 @@
-use alloy_consensus::Sealable;
 use alloy_primitives::B256;
-use reth_node_api::{
-    BuiltPayload, ConsensusEngineHandle, ExecutionPayload, NodePrimitives, PayloadTypes,
-};
-use reth_primitives_traits::{Block, SealedBlock};
+use reth_node_api::{ConsensusEngineHandle, ExecutionPayload, PayloadTypes};
 use reth_tracing::tracing::warn;
 use ringbuffer::{AllocRingBuffer, RingBuffer};
 use std::future::Future;
 use tokio::sync::mpsc;
 
-/// Supplies consensus client with new blocks sent in `tx` and a callback to find specific blocks
-/// by number to fetch past finalized and safe blocks.
+/// Supplies consensus client with new execution payloads sent in `tx` and a callback to find
+/// specific payloads by number to fetch past finalized and safe block hashes.
 #[auto_impl::auto_impl(&, Arc, Box)]
-pub trait BlockProvider: Send + Sync + 'static {
-    /// The block type.
-    type Block: Block;
+pub trait PayloadProvider: Send + Sync + 'static {
+    /// The execution payload data type.
+    type ExecutionData: ExecutionPayload;
 
-    /// Runs a block provider to send new blocks to the given sender.
+    /// Runs a provider to send new execution payloads to the given sender.
     ///
     /// Note: This is expected to be spawned in a separate task, and as such it should ignore
     /// errors.
-    fn subscribe_blocks(&self, tx: mpsc::Sender<Self::Block>) -> impl Future<Output = ()> + Send;
+    fn subscribe_payloads(
+        &self,
+        tx: mpsc::Sender<Self::ExecutionData>,
+    ) -> impl Future<Output = ()> + Send;
 
-    /// Get a past block by number.
-    fn get_block(
+    /// Get a past execution payload by block number.
+    fn get_payload(
         &self,
         block_number: u64,
-    ) -> impl Future<Output = eyre::Result<Self::Block>> + Send;
+    ) -> impl Future<Output = eyre::Result<Self::ExecutionData>> + Send;
 
     /// Get previous block hash using previous block hash buffer. If it isn't available (buffer
-    /// started more recently than `offset`), fetch it using `get_block`.
+    /// started more recently than `offset`), fetch it using `get_payload`.
     fn get_or_fetch_previous_block(
         &self,
         previous_block_hashes: &AllocRingBuffer<B256>,
@@ -46,23 +45,23 @@ pub trait BlockProvider: Send + Sync + 'static {
                 Some(number) => number,
                 None => return Ok(B256::default()),
             };
-            let block = self.get_block(previous_block_number).await?;
-            Ok(block.header().hash_slow())
+            let payload = self.get_payload(previous_block_number).await?;
+            Ok(payload.block_hash())
         }
     }
 }
 
-/// Debug consensus client that sends FCUs and new payloads using recent blocks from an external
+/// Debug consensus client that sends FCUs and new payloads using recent payloads from an external
 /// provider like Etherscan or an RPC endpoint.
 #[derive(Debug)]
-pub struct DebugConsensusClient<P: BlockProvider, T: PayloadTypes> {
+pub struct DebugConsensusClient<P: PayloadProvider, T: PayloadTypes> {
     /// Handle to execution client.
     engine_handle: ConsensusEngineHandle<T>,
-    /// Provider to get consensus blocks from.
+    /// Provider to get consensus payloads from.
     block_provider: P,
 }
 
-impl<P: BlockProvider, T: PayloadTypes> DebugConsensusClient<P, T> {
+impl<P: PayloadProvider, T: PayloadTypes> DebugConsensusClient<P, T> {
     /// Create a new debug consensus client with the given handle to execution
     /// client and block provider.
     pub const fn new(engine_handle: ConsensusEngineHandle<T>, block_provider: P) -> Self {
@@ -72,25 +71,23 @@ impl<P: BlockProvider, T: PayloadTypes> DebugConsensusClient<P, T> {
 
 impl<P, T> DebugConsensusClient<P, T>
 where
-    P: BlockProvider + Clone,
-    T: PayloadTypes<BuiltPayload: BuiltPayload<Primitives: NodePrimitives<Block = P::Block>>>,
+    P: PayloadProvider<ExecutionData = T::ExecutionData> + Clone,
+    T: PayloadTypes,
 {
     /// Spawn the client to start sending FCUs and new payloads by periodically fetching recent
-    /// blocks.
+    /// payloads.
     pub async fn run(self) {
         let mut previous_block_hashes = AllocRingBuffer::new(65);
-        let mut block_stream = {
-            let (tx, rx) = mpsc::channel::<P::Block>(64);
+        let mut payload_stream = {
+            let (tx, rx) = mpsc::channel::<P::ExecutionData>(64);
             let block_provider = self.block_provider.clone();
             tokio::spawn(async move {
-                block_provider.subscribe_blocks(tx).await;
+                block_provider.subscribe_payloads(tx).await;
             });
             rx
         };
 
-        while let Some(block) = block_stream.recv().await {
-            let payload = T::block_to_payload(SealedBlock::new_unhashed(block));
-
+        while let Some(payload) = payload_stream.recv().await {
             let block_hash = payload.block_hash();
             let block_number = payload.block_number();
 
diff --git a/crates/consensus/debug-client/src/lib.rs b/crates/consensus/debug-client/src/lib.rs
index 16dc9d34578..971fc4aa0e7 100644
--- a/crates/consensus/debug-client/src/lib.rs
+++ b/crates/consensus/debug-client/src/lib.rs
@@ -1,6 +1,6 @@
 //! Debug consensus client.
 //!
-//! This is a worker that sends FCUs and new payloads by fetching recent blocks from an external
+//! This is a worker that sends FCUs and new payloads by fetching recent payloads from an external
 //! provider like Etherscan or an RPC endpoint. This allows to quickly test the execution client
 //! without running a consensus node.
 
@@ -15,5 +15,5 @@
 mod client;
 mod providers;
 
-pub use client::{BlockProvider, DebugConsensusClient};
+pub use client::{DebugConsensusClient, PayloadProvider};
 pub use providers::{EtherscanBlockProvider, RpcBlockProvider};
diff --git a/crates/consensus/debug-client/src/providers/etherscan.rs b/crates/consensus/debug-client/src/providers/etherscan.rs
index ea21d95e73d..fba239d7dda 100644
--- a/crates/consensus/debug-client/src/providers/etherscan.rs
+++ b/crates/consensus/debug-client/src/providers/etherscan.rs
@@ -1,8 +1,8 @@
-use crate::BlockProvider;
-use alloy_consensus::BlockHeader;
+use crate::PayloadProvider;
 use alloy_eips::BlockNumberOrTag;
 use alloy_json_rpc::{Response, ResponsePayload};
 use reqwest::Client;
+use reth_node_api::ExecutionPayload;
 use reth_tracing::tracing::{debug, warn};
 use serde::{de::DeserializeOwned, Serialize};
 use std::{sync::Arc, time::Duration};
@@ -10,17 +10,17 @@ use tokio::{sync::mpsc, time::interval};
 
 /// Block provider that fetches new blocks from Etherscan API.
 #[derive(derive_more::Debug, Clone)]
-pub struct EtherscanBlockProvider<RpcBlock, PrimitiveBlock> {
+pub struct EtherscanBlockProvider<RpcBlock, ExecutionData> {
     http_client: Client,
     base_url: String,
     api_key: String,
     chain_id: u64,
     interval: Duration,
     #[debug(skip)]
-    convert: Arc<dyn Fn(RpcBlock) -> PrimitiveBlock + Send + Sync>,
+    convert: Arc<dyn Fn(RpcBlock) -> ExecutionData + Send + Sync>,
 }
 
-impl<RpcBlock, PrimitiveBlock> EtherscanBlockProvider<RpcBlock, PrimitiveBlock>
+impl<RpcBlock, ExecutionData> EtherscanBlockProvider<RpcBlock, ExecutionData>
 where
     RpcBlock: Serialize + DeserializeOwned,
 {
@@ -29,7 +29,7 @@ where
         base_url: String,
         api_key: String,
         chain_id: u64,
-        convert: impl Fn(RpcBlock) -> PrimitiveBlock + Send + Sync + 'static,
+        convert: impl Fn(RpcBlock) -> ExecutionData + Send + Sync + 'static,
     ) -> Self {
         Self {
             http_client: Client::new(),
@@ -50,12 +50,12 @@ where
     /// Load block using Etherscan API. Note: only `BlockNumberOrTag::Latest`,
     /// `BlockNumberOrTag::Earliest`, `BlockNumberOrTag::Pending`, `BlockNumberOrTag::Number(u64)`
     /// are supported.
-    pub async fn load_block(
+    pub async fn load_payload(
         &self,
         block_number_or_tag: BlockNumberOrTag,
-    ) -> eyre::Result<PrimitiveBlock> {
+    ) -> eyre::Result<ExecutionData> {
         let tag = match block_number_or_tag {
-            BlockNumberOrTag::Number(num) => format!("{num:#02x}"),
+            BlockNumberOrTag::Number(num) => format!("{num:#x}"),
             tag => tag.to_string(),
         };
 
@@ -88,20 +88,20 @@ where
     }
 }
 
-impl<RpcBlock, PrimitiveBlock> BlockProvider for EtherscanBlockProvider<RpcBlock, PrimitiveBlock>
+impl<RpcBlock, ExecutionData> PayloadProvider for EtherscanBlockProvider<RpcBlock, ExecutionData>
 where
     RpcBlock: Serialize + DeserializeOwned + 'static,
-    PrimitiveBlock: reth_primitives_traits::Block + 'static,
+    ExecutionData: ExecutionPayload,
 {
-    type Block = PrimitiveBlock;
+    type ExecutionData = ExecutionData;
 
-    async fn subscribe_blocks(&self, tx: mpsc::Sender<Self::Block>) {
+    async fn subscribe_payloads(&self, tx: mpsc::Sender<Self::ExecutionData>) {
         let mut last_block_number: Option<u64> = None;
         let mut interval = interval(self.interval);
         loop {
             interval.tick().await;
-            let block = match self.load_block(BlockNumberOrTag::Latest).await {
-                Ok(block) => block,
+            let payload = match self.load_payload(BlockNumberOrTag::Latest).await {
+                Ok(payload) => payload,
                 Err(err) => {
                     warn!(
                         target: "consensus::debug-client",
@@ -111,12 +111,12 @@ where
                     continue
                 }
             };
-            let block_number = block.header().number();
+            let block_number = payload.block_number();
             if Some(block_number) == last_block_number {
                 continue;
             }
 
-            if tx.send(block).await.is_err() {
+            if tx.send(payload).await.is_err() {
                 // Channel closed.
                 break;
             }
@@ -125,7 +125,7 @@ where
         }
     }
 
-    async fn get_block(&self, block_number: u64) -> eyre::Result<Self::Block> {
-        self.load_block(BlockNumberOrTag::Number(block_number)).await
+    async fn get_payload(&self, block_number: u64) -> eyre::Result<Self::ExecutionData> {
+        self.load_payload(BlockNumberOrTag::Number(block_number)).await
     }
 }
diff --git a/crates/consensus/debug-client/src/providers/rpc.rs b/crates/consensus/debug-client/src/providers/rpc.rs
index 91a3aef1f3e..76f7aaa63fa 100644
--- a/crates/consensus/debug-client/src/providers/rpc.rs
+++ b/crates/consensus/debug-client/src/providers/rpc.rs
@@ -1,8 +1,14 @@
-use crate::BlockProvider;
-use alloy_provider::{ConnectionConfig, Network, Provider, ProviderBuilder, WebSocketConfig};
+use crate::PayloadProvider;
+use alloy_consensus::BlockHeader;
+use alloy_eips::BlockId;
+use alloy_provider::{
+    network::{primitives::HeaderResponse, BlockResponse, Network},
+    ConnectionConfig, Provider, ProviderBuilder, WebSocketConfig,
+};
+use alloy_rpc_types_engine::PayloadExtras;
 use alloy_transport::TransportResult;
 use futures::{Stream, StreamExt};
-use reth_node_api::Block;
+use reth_node_api::ExecutionPayload;
 use reth_tracing::tracing::{debug, warn};
 use std::sync::Arc;
 use tokio::sync::mpsc::Sender;
@@ -10,19 +16,20 @@ use tokio::sync::mpsc::Sender;
 /// Block provider that fetches new blocks from an RPC endpoint using a connection that supports
 /// RPC subscriptions.
 #[derive(derive_more::Debug, Clone)]
-pub struct RpcBlockProvider<N: Network, PrimitiveBlock> {
+pub struct RpcBlockProvider<N: Network, ExecutionData> {
     #[debug(skip)]
     provider: Arc<dyn Provider<N>>,
     url: String,
+    fetch_block_access_list: bool,
     #[debug(skip)]
-    convert: Arc<dyn Fn(N::BlockResponse) -> PrimitiveBlock + Send + Sync>,
+    convert: Arc<dyn Fn(N::BlockResponse, PayloadExtras) -> ExecutionData + Send + Sync>,
 }
 
-impl<N: Network, PrimitiveBlock> RpcBlockProvider<N, PrimitiveBlock> {
+impl<N: Network, ExecutionData> RpcBlockProvider<N, ExecutionData> {
     /// Create a new RPC block provider with the given RPC URL.
     pub async fn new(
         rpc_url: &str,
-        convert: impl Fn(N::BlockResponse) -> PrimitiveBlock + Send + Sync + 'static,
+        convert: impl Fn(N::BlockResponse, PayloadExtras) -> ExecutionData + Send + Sync + 'static,
     ) -> eyre::Result<Self> {
         Ok(Self {
             provider: Arc::new(
@@ -39,10 +46,17 @@ impl<N: Network, PrimitiveBlock> RpcBlockProvider<N, PrimitiveBlock> {
                     .await?,
             ),
             url: rpc_url.to_string(),
+            fetch_block_access_list: true,
             convert: Arc::new(convert),
         })
     }
 
+    /// Disables fetching raw block access list bytes.
+    pub const fn without_block_access_lists(mut self) -> Self {
+        self.fetch_block_access_list = false;
+        self
+    }
+
     /// Obtains a full block stream.
     ///
     /// This first attempts to obtain an `eth_subscribe` subscription, if that fails because the
@@ -64,15 +78,48 @@ impl<N: Network, PrimitiveBlock> RpcBlockProvider<N, PrimitiveBlock> {
             }
         }
     }
+
+    /// Fetches optional payload side data for blocks that advertise a block access list hash.
+    ///
+    /// Block access lists are best effort here: RPC providers may not support
+    /// `eth_getBlockAccessListByHash`, so failed or missing responses fall back to empty extras.
+    async fn payload_extras(&self, header: &N::HeaderResponse) -> PayloadExtras {
+        if !self.fetch_block_access_list {
+            return PayloadExtras::default()
+        }
+
+        let block_hash = header.hash();
+        if header.block_access_list_hash().is_none() {
+            return PayloadExtras::default()
+        };
+
+        let block_access_list = self
+            .provider
+            .get_block_access_list_raw(BlockId::from(block_hash))
+            .await
+            .inspect_err(|err| {
+                warn!(
+                    target: "consensus::debug-client",
+                    %err,
+                    url=%self.url,
+                    %block_hash,
+                    "Failed to fetch block access list",
+                );
+            })
+            .ok()
+            .flatten();
+
+        PayloadExtras::from(block_access_list)
+    }
 }
 
-impl<N: Network, PrimitiveBlock> BlockProvider for RpcBlockProvider<N, PrimitiveBlock>
+impl<N: Network, ExecutionData> PayloadProvider for RpcBlockProvider<N, ExecutionData>
 where
-    PrimitiveBlock: Block + 'static,
+    ExecutionData: ExecutionPayload,
 {
-    type Block = PrimitiveBlock;
+    type ExecutionData = ExecutionData;
 
-    async fn subscribe_blocks(&self, tx: Sender<Self::Block>) {
+    async fn subscribe_payloads(&self, tx: Sender<Self::ExecutionData>) {
         loop {
             let Ok(mut stream) = self.full_block_stream().await.inspect_err(|err| {
                 warn!(
@@ -94,7 +141,9 @@ where
             while let Some(res) = stream.next().await {
                 match res {
                     Ok(block) => {
-                        if tx.send((self.convert)(block)).await.is_err() {
+                        let extras = self.payload_extras(block.header()).await;
+                        let payload = (self.convert)(block, extras);
+                        if tx.send(payload).await.is_err() {
                             // Channel closed - receiver dropped, exit completely.
                             return;
                         }
@@ -118,13 +167,14 @@ where
         }
     }
 
-    async fn get_block(&self, block_number: u64) -> eyre::Result<Self::Block> {
+    async fn get_payload(&self, block_number: u64) -> eyre::Result<Self::ExecutionData> {
         let block = self
             .provider
             .get_block_by_number(block_number.into())
             .full()
             .await?
             .ok_or_else(|| eyre::eyre!("block not found by number {}", block_number))?;
-        Ok((self.convert)(block))
+        let extras = self.payload_extras(block.header()).await;
+        Ok((self.convert)(block, extras))
     }
 }
diff --git a/crates/e2e-test-utils/src/node.rs b/crates/e2e-test-utils/src/node.rs
index d83443c7db0..df4dbe95c9c 100644
--- a/crates/e2e-test-utils/src/node.rs
+++ b/crates/e2e-test-utils/src/node.rs
@@ -309,11 +309,7 @@ where
     /// Submits a payload to the engine.
     pub async fn submit_payload(&self, payload: Payload::BuiltPayload) -> eyre::Result<B256> {
         let block_hash = payload.block().hash();
-        self.inner
-            .add_ons_handle
-            .beacon_engine_handle
-            .new_payload(Payload::block_to_payload(payload.block().clone()))
-            .await?;
+        self.inner.add_ons_handle.beacon_engine_handle.new_payload(payload.into()).await?;
 
         Ok(block_hash)
     }
diff --git a/crates/e2e-test-utils/src/payload.rs b/crates/e2e-test-utils/src/payload.rs
index 47c533e9769..fe0d4452c9f 100644
--- 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::{BlockBody, PayloadAttributes, PayloadKind};
+use reth_node_api::{PayloadAttributes, PayloadKind};
 use reth_payload_builder::{PayloadBuilderHandle, PayloadId};
 use reth_payload_builder_primitives::Events;
-use reth_payload_primitives::{BuiltPayload, PayloadTypes};
+use reth_payload_primitives::PayloadTypes;
 use tokio_stream::wrappers::BroadcastStream;
 
 /// Helper for payload operations
@@ -53,27 +53,11 @@ 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) {
-        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;
-        }
+        self.payload_builder
+            .resolve_kind(payload_id, PayloadKind::WaitForPending)
+            .await
+            .unwrap()
+            .unwrap();
     }
 
     /// Expects the next event to be a built payload event or panics
diff --git a/crates/e2e-test-utils/src/testsuite/README.md b/crates/e2e-test-utils/src/testsuite/README.md
index 3d4d346cc41..6e9f789b67f 100644
--- a/crates/e2e-test-utils/src/testsuite/README.md
+++ b/crates/e2e-test-utils/src/testsuite/README.md
@@ -36,7 +36,6 @@ harness = true
 cargo nextest run --workspace \
   --exclude 'example-*' \
   --exclude 'exex-subscription' \
-  --exclude 'reth-bench' \
   --exclude 'ef-tests' \
   --exclude 'reth' \
   -E 'binary(e2e_testsuite)'
diff --git a/crates/engine/execution-cache/src/cached_state.rs b/crates/engine/execution-cache/src/cached_state.rs
index ca7fba04934..411329c2ff9 100644
--- a/crates/engine/execution-cache/src/cached_state.rs
+++ b/crates/engine/execution-cache/src/cached_state.rs
@@ -85,23 +85,27 @@ type FixedCache<K, V, H = DefaultHashBuilder> = fixed_cache::Cache<K, V, H, Epoc
 
 /// A wrapper of a state provider and a shared cache.
 ///
-/// The const generic `PREWARM` controls whether every cache miss is populated. This is only
-/// relevant for pre-warm transaction execution with the intention to pre-populate the cache with
-/// data for regular block execution. During regular block execution the cache doesn't need to be
-/// populated because the actual EVM database `State` also caches
-/// internally during block execution and the cache is then updated after the block with the entire
-/// [`BundleState`] output of that block which contains all accessed accounts, code, storage. See
-/// also [`ExecutionCache::insert_state`].
+/// [`CacheFillMode`] controls whether misses populate the shared cache. This is used by background
+/// prewarmers and speculative execution workers that intentionally seed the cache for other
+/// readers. Canonical execution usually leaves this disabled because the EVM database `State`
+/// already caches reads during the block, and the shared cache is updated after the block from the
+/// final [`BundleState`]. See also [`ExecutionCache::insert_state`].
+///
+/// Normal cache hit/miss metrics are recorded when [`CachedStateMetrics`] is provided. Slow-block
+/// [`CacheStats`] are controlled separately by [`Self::new_with_mode`].
 #[derive(Debug)]
-pub struct CachedStateProvider<S, const PREWARM: bool = false> {
+pub struct CachedStateProvider<S> {
     /// The state provider
     state_provider: S,
 
     /// The caches used for the provider
     caches: ExecutionCache,
 
-    /// Metrics for the cached state provider
-    metrics: CachedStateMetrics,
+    /// Metrics for the cached state provider.
+    metrics: Option<CachedStateMetrics>,
+
+    /// Whether cache misses should populate the shared execution cache.
+    fill_mode: CacheFillMode,
 
     /// Optional cache statistics for detailed block logging. Only tracked when slow block
     /// threshold is configured.
@@ -110,35 +114,102 @@ pub struct CachedStateProvider<S, const PREWARM: bool = false> {
 
 impl<S> CachedStateProvider<S> {
     /// Creates a new [`CachedStateProvider`] from an [`ExecutionCache`], state provider, and
-    /// [`CachedStateMetrics`].
+    /// optional [`CachedStateMetrics`].
     pub const fn new(
         state_provider: S,
         caches: ExecutionCache,
-        metrics: CachedStateMetrics,
+        metrics: Option<CachedStateMetrics>,
     ) -> Self {
-        Self { state_provider, caches, metrics, cache_stats: None }
+        Self::new_with_mode(state_provider, caches, CacheFillMode::LookupOnly, metrics, None)
     }
-}
 
-impl<S> CachedStateProvider<S, true> {
-    /// Creates a new [`CachedStateProvider`] with prewarming enabled.
-    pub const fn new_prewarm(
+    /// Creates a cache-filling [`CachedStateProvider`].
+    ///
+    /// Doesn't accept metrics because prewarming path does not need to report hit/misses.
+    pub const fn new_prewarm(state_provider: S, caches: ExecutionCache) -> Self {
+        Self::new_with_mode(state_provider, caches, CacheFillMode::FillOnMiss, None, None)
+    }
+
+    /// Creates a [`CachedStateProvider`] with explicit cache fill behavior and optional
+    /// block-local cache stats.
+    pub const fn new_with_mode(
         state_provider: S,
         caches: ExecutionCache,
-        metrics: CachedStateMetrics,
+        fill_mode: CacheFillMode,
+        metrics: Option<CachedStateMetrics>,
+        cache_stats: Option<Arc<CacheStats>>,
     ) -> Self {
-        Self { state_provider, caches, metrics, cache_stats: None }
+        Self { state_provider, caches, metrics, fill_mode, cache_stats }
+    }
+
+    fn record_account_hit(&self) {
+        if let Some(metrics) = &self.metrics {
+            metrics.account_cache_hits.increment(1);
+        }
+        if let Some(stats) = &self.cache_stats {
+            stats.record_account_hit();
+        }
     }
-}
 
-impl<S, const PREWARM: bool> CachedStateProvider<S, PREWARM> {
-    /// Enables cache statistics tracking for detailed block logging.
-    pub fn with_cache_stats(mut self, stats: Option<Arc<CacheStats>>) -> Self {
-        self.cache_stats = stats;
-        self
+    fn record_account_miss(&self) {
+        if let Some(metrics) = &self.metrics {
+            metrics.account_cache_misses.increment(1);
+        }
+        if let Some(stats) = &self.cache_stats {
+            stats.record_account_miss();
+        }
+    }
+
+    fn record_storage_hit(&self) {
+        if let Some(metrics) = &self.metrics {
+            metrics.storage_cache_hits.increment(1);
+        }
+        if let Some(stats) = &self.cache_stats {
+            stats.record_storage_hit();
+        }
+    }
+
+    fn record_storage_miss(&self) {
+        if let Some(metrics) = &self.metrics {
+            metrics.storage_cache_misses.increment(1);
+        }
+        if let Some(stats) = &self.cache_stats {
+            stats.record_storage_miss();
+        }
+    }
+
+    fn record_code_hit(&self) {
+        if let Some(metrics) = &self.metrics {
+            metrics.code_cache_hits.increment(1);
+        }
+        if let Some(stats) = &self.cache_stats {
+            stats.record_code_hit();
+        }
+    }
+
+    fn record_code_miss(&self) {
+        if let Some(metrics) = &self.metrics {
+            metrics.code_cache_misses.increment(1);
+        }
+        if let Some(stats) = &self.cache_stats {
+            stats.record_code_miss();
+        }
+    }
+
+    const fn should_fill_on_miss(&self) -> bool {
+        matches!(self.fill_mode, CacheFillMode::FillOnMiss)
     }
 }
 
+/// Whether cache misses should populate the shared execution cache.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CacheFillMode {
+    /// Only read existing cache entries.
+    LookupOnly,
+    /// Insert values loaded from the underlying provider.
+    FillOnMiss,
+}
+
 /// Represents the status of a key in the cache.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum CachedStatus<T> {
@@ -187,6 +258,23 @@ pub struct CachedStateMetrics {
     /// Code cache misses
     code_cache_misses: Gauge,
 
+    /// Storage cache hits
+    storage_cache_hits: Gauge,
+
+    /// Storage cache misses
+    storage_cache_misses: Gauge,
+
+    /// Account cache hits
+    account_cache_hits: Gauge,
+
+    /// Account cache misses
+    account_cache_misses: Gauge,
+}
+
+/// Metrics for shared execution cache state.
+#[derive(Metrics, Clone)]
+#[metrics(scope = "sync.caching")]
+pub struct CachedStateCacheMetrics {
     /// Code cache size (number of entries)
     code_cache_size: Gauge,
 
@@ -196,12 +284,6 @@ pub struct CachedStateMetrics {
     /// Code cache collisions (hash collisions causing eviction)
     code_cache_collisions: Gauge,
 
-    /// Storage cache hits
-    storage_cache_hits: Gauge,
-
-    /// Storage cache misses
-    storage_cache_misses: Gauge,
-
     /// Storage cache size (number of entries)
     storage_cache_size: Gauge,
 
@@ -211,12 +293,6 @@ pub struct CachedStateMetrics {
     /// Storage cache collisions (hash collisions causing eviction)
     storage_cache_collisions: Gauge,
 
-    /// Account cache hits
-    account_cache_hits: Gauge,
-
-    /// Account cache misses
-    account_cache_misses: Gauge,
-
     /// Account cache size (number of entries)
     account_cache_size: Gauge,
 
@@ -233,17 +309,14 @@ impl CachedStateMetrics {
         // code cache
         self.code_cache_hits.set(0);
         self.code_cache_misses.set(0);
-        self.code_cache_collisions.set(0);
 
         // storage cache
         self.storage_cache_hits.set(0);
         self.storage_cache_misses.set(0);
-        self.storage_cache_collisions.set(0);
 
         // account cache
         self.account_cache_hits.set(0);
         self.account_cache_misses.set(0);
-        self.account_cache_collisions.set(0);
     }
 
     /// Returns a new zeroed-out instance of [`CachedStateMetrics`] with a `source` label
@@ -429,121 +502,95 @@ impl<K: PartialEq, V> StatsHandler<K, V> for CacheStatsHandler {
     }
 }
 
-impl<S: AccountReader, const PREWARM: bool> AccountReader for CachedStateProvider<S, PREWARM> {
+impl<S: AccountReader> AccountReader for CachedStateProvider<S> {
     fn basic_account(&self, address: &Address) -> ProviderResult<Option<Account>> {
-        if PREWARM {
+        if self.should_fill_on_miss() {
             match self.caches.get_or_try_insert_account_with(*address, || {
                 self.state_provider.basic_account(address)
             })? {
-                // During prewarm we only record stats (not prometheus metrics)
                 CachedStatus::NotCached(value) => {
-                    if let Some(stats) = &self.cache_stats {
-                        stats.record_account_miss();
-                    }
+                    self.record_account_miss();
                     Ok(value)
                 }
                 CachedStatus::Cached(value) => {
-                    if let Some(stats) = &self.cache_stats {
-                        stats.record_account_hit();
-                    }
+                    self.record_account_hit();
                     Ok(value)
                 }
             }
         } else if let Some(account) = self.caches.0.account_cache.get(address) {
-            self.metrics.account_cache_hits.increment(1);
-            if let Some(stats) = &self.cache_stats {
-                stats.record_account_hit();
-            }
+            self.record_account_hit();
             Ok(account)
         } else {
-            self.metrics.account_cache_misses.increment(1);
-            if let Some(stats) = &self.cache_stats {
-                stats.record_account_miss();
-            }
+            self.record_account_miss();
             self.state_provider.basic_account(address)
         }
     }
 }
 
-impl<S: StateProvider, const PREWARM: bool> StateProvider for CachedStateProvider<S, PREWARM> {
+#[inline]
+fn nonzero_storage_value(value: StorageValue) -> Option<StorageValue> {
+    if value.is_zero() {
+        None
+    } else {
+        Some(value)
+    }
+}
+
+impl<S: StateProvider> StateProvider for CachedStateProvider<S> {
     fn storage(
         &self,
         account: Address,
         storage_key: StorageKey,
     ) -> ProviderResult<Option<StorageValue>> {
-        if PREWARM {
+        if self.should_fill_on_miss() {
             match self.caches.get_or_try_insert_storage_with(account, storage_key, || {
                 self.state_provider.storage(account, storage_key).map(Option::unwrap_or_default)
             })? {
-                // During prewarm we only record stats (not prometheus metrics)
                 CachedStatus::NotCached(value) => {
-                    if let Some(stats) = &self.cache_stats {
-                        stats.record_storage_miss();
-                    }
-                    Ok(Some(value).filter(|v| !v.is_zero()))
+                    self.record_storage_miss();
+                    Ok(nonzero_storage_value(value))
                 }
                 CachedStatus::Cached(value) => {
-                    if let Some(stats) = &self.cache_stats {
-                        stats.record_storage_hit();
-                    }
-                    Ok(Some(value).filter(|v| !v.is_zero()))
+                    self.record_storage_hit();
+                    Ok(nonzero_storage_value(value))
                 }
             }
         } else if let Some(value) = self.caches.0.storage_cache.get(&(account, storage_key)) {
-            self.metrics.storage_cache_hits.increment(1);
-            if let Some(stats) = &self.cache_stats {
-                stats.record_storage_hit();
-            }
-            Ok(Some(value).filter(|v| !v.is_zero()))
+            self.record_storage_hit();
+            Ok(nonzero_storage_value(value))
         } else {
-            self.metrics.storage_cache_misses.increment(1);
-            if let Some(stats) = &self.cache_stats {
-                stats.record_storage_miss();
-            }
+            self.record_storage_miss();
             self.state_provider.storage(account, storage_key)
         }
     }
 }
 
-impl<S: BytecodeReader, const PREWARM: bool> BytecodeReader for CachedStateProvider<S, PREWARM> {
+impl<S: BytecodeReader> BytecodeReader for CachedStateProvider<S> {
     fn bytecode_by_hash(&self, code_hash: &B256) -> ProviderResult<Option<Bytecode>> {
-        if PREWARM {
+        if self.should_fill_on_miss() {
             match self.caches.get_or_try_insert_code_with(*code_hash, || {
                 self.state_provider.bytecode_by_hash(code_hash)
             })? {
-                // During prewarm we only record stats (not prometheus metrics)
                 CachedStatus::NotCached(code) => {
-                    if let Some(stats) = &self.cache_stats {
-                        stats.record_code_miss();
-                    }
+                    self.record_code_miss();
                     Ok(code)
                 }
                 CachedStatus::Cached(code) => {
-                    if let Some(stats) = &self.cache_stats {
-                        stats.record_code_hit();
-                    }
+                    self.record_code_hit();
                     Ok(code)
                 }
             }
         } else if let Some(code) = self.caches.0.code_cache.get(code_hash) {
-            self.metrics.code_cache_hits.increment(1);
-            if let Some(stats) = &self.cache_stats {
-                stats.record_code_hit();
-            }
+            self.record_code_hit();
             Ok(code)
         } else {
-            self.metrics.code_cache_misses.increment(1);
-            if let Some(stats) = &self.cache_stats {
-                stats.record_code_miss();
-            }
+            self.record_code_miss();
             self.state_provider.bytecode_by_hash(code_hash)
         }
     }
 }
 
-impl<S: StateRootProvider, const PREWARM: bool> StateRootProvider
-    for CachedStateProvider<S, PREWARM>
-{
+impl<S: StateRootProvider> StateRootProvider for CachedStateProvider<S> {
     fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
         self.state_provider.state_root(hashed_state)
     }
@@ -567,9 +614,7 @@ impl<S: StateRootProvider, const PREWARM: bool> StateRootProvider
     }
 }
 
-impl<S: StateProofProvider, const PREWARM: bool> StateProofProvider
-    for CachedStateProvider<S, PREWARM>
-{
+impl<S: StateProofProvider> StateProofProvider for CachedStateProvider<S> {
     fn proof(
         &self,
         input: TrieInput,
@@ -597,9 +642,7 @@ impl<S: StateProofProvider, const PREWARM: bool> StateProofProvider
     }
 }
 
-impl<S: StorageRootProvider, const PREWARM: bool> StorageRootProvider
-    for CachedStateProvider<S, PREWARM>
-{
+impl<S: StorageRootProvider> StorageRootProvider for CachedStateProvider<S> {
     fn storage_root(
         &self,
         address: Address,
@@ -627,7 +670,7 @@ impl<S: StorageRootProvider, const PREWARM: bool> StorageRootProvider
     }
 }
 
-impl<S: BlockHashReader, const PREWARM: bool> BlockHashReader for CachedStateProvider<S, PREWARM> {
+impl<S: BlockHashReader> BlockHashReader for CachedStateProvider<S> {
     fn block_hash(&self, number: alloy_primitives::BlockNumber) -> ProviderResult<Option<B256>> {
         self.state_provider.block_hash(number)
     }
@@ -641,9 +684,7 @@ impl<S: BlockHashReader, const PREWARM: bool> BlockHashReader for CachedStatePro
     }
 }
 
-impl<S: HashedPostStateProvider, const PREWARM: bool> HashedPostStateProvider
-    for CachedStateProvider<S, PREWARM>
-{
+impl<S: HashedPostStateProvider> HashedPostStateProvider for CachedStateProvider<S> {
     fn hashed_post_state(&self, bundle_state: &reth_revm::db::BundleState) -> HashedPostState {
         self.state_provider.hashed_post_state(bundle_state)
     }
@@ -916,7 +957,7 @@ impl ExecutionCache {
 
     /// Updates the provided metrics with the current stats from the cache's stats handlers,
     /// and resets the hit/miss/collision counters.
-    pub fn update_metrics(&self, metrics: &CachedStateMetrics) {
+    pub fn update_metrics(&self, metrics: &CachedStateCacheMetrics) {
         metrics.code_cache_size.set(self.0.code_stats.size() as f64);
         metrics.code_cache_capacity.set(self.0.code_stats.capacity() as f64);
         metrics.code_cache_collisions.set(self.0.code_stats.collisions() as f64);
@@ -976,7 +1017,7 @@ impl SavedCache {
     }
 
     /// Updates the cache metrics (size/capacity/collisions) from the stats handlers.
-    pub fn update_metrics(&self, metrics: Option<&CachedStateMetrics>) {
+    pub fn update_metrics(&self, metrics: Option<&CachedStateCacheMetrics>) {
         if let Some(metrics) = metrics {
             self.caches.update_metrics(metrics);
         }
@@ -1019,7 +1060,7 @@ mod tests {
         let state_provider = CachedStateProvider::new(
             provider,
             caches,
-            CachedStateMetrics::zeroed(CachedStateMetricsSource::Test),
+            Some(CachedStateMetrics::zeroed(CachedStateMetricsSource::Test)),
         );
 
         let res = state_provider.storage(address, storage_key);
@@ -1042,7 +1083,7 @@ mod tests {
         let state_provider = CachedStateProvider::new(
             provider,
             caches,
-            CachedStateMetrics::zeroed(CachedStateMetricsSource::Test),
+            Some(CachedStateMetrics::zeroed(CachedStateMetricsSource::Test)),
         );
 
         let res = state_provider.storage(address, storage_key);
diff --git a/crates/engine/local/src/miner.rs b/crates/engine/local/src/miner.rs
index 882c4b0828b..ff131b35152 100644
--- a/crates/engine/local/src/miner.rs
+++ b/crates/engine/local/src/miner.rs
@@ -261,8 +261,7 @@ where
         };
 
         let header = payload.block().sealed_header().clone();
-        let payload = T::block_to_payload(payload.block().clone());
-        let res = self.to_engine.new_payload(payload).await?;
+        let res = self.to_engine.new_payload(payload.into()).await?;
 
         if !res.is_valid() {
             eyre::bail!("Invalid payload")
diff --git a/crates/engine/primitives/Cargo.toml b/crates/engine/primitives/Cargo.toml
index aca33f4aff6..dd14824fb43 100644
--- a/crates/engine/primitives/Cargo.toml
+++ b/crates/engine/primitives/Cargo.toml
@@ -12,10 +12,10 @@ workspace = true
 
 [dependencies]
 # reth
-reth-evm.workspace = true
+reth-evm = { workspace = true, optional = true }
 reth-execution-types.workspace = true
 reth-payload-primitives.workspace = true
-reth-payload-builder-primitives.workspace = true
+reth-payload-builder-primitives = { workspace = true, optional = true }
 reth-primitives-traits.workspace = true
 reth-ethereum-primitives.workspace = true
 reth-chain-state.workspace = true
@@ -41,6 +41,8 @@ thiserror.workspace = true
 default = ["std"]
 trie-debug = []
 std = [
+    "dep:reth-evm",
+    "dep:reth-payload-builder-primitives",
     "reth-execution-types/std",
     "reth-ethereum-primitives/std",
     "reth-primitives-traits/std",
@@ -53,5 +55,5 @@ std = [
     "tokio",
     "serde/std",
     "thiserror/std",
-    "reth-evm/std",
+    "reth-evm?/std",
 ]
diff --git a/crates/engine/primitives/src/config.rs b/crates/engine/primitives/src/config.rs
index 2607d62d205..dd1b97804eb 100644
--- a/crates/engine/primitives/src/config.rs
+++ b/crates/engine/primitives/src/config.rs
@@ -185,11 +185,10 @@ pub struct TreeConfig {
     /// with block building on latency-sensitive chains.
     suppress_persistence_during_build: bool,
     /// Whether to disable BAL (Block Access List, EIP-7928) based parallel execution.
-    /// When disabled, falls back to transaction-based prewarming even when a BAL is available.
+    /// When disabled, uses the sequential execution path even when a BAL is available.
     disable_bal_parallel_execution: bool,
     /// Whether to disable BAL-driven parallel state root computation.
-    /// When disabled, the BAL hashed post state is not sent to the multiproof task for
-    /// early parallel state root computation.
+    /// Only valid when BAL parallel execution is also disabled.
     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
@@ -239,7 +238,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")]
@@ -316,7 +315,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")]
@@ -738,12 +737,12 @@ impl TreeConfig {
         self
     }
 
-    /// Returns whether BAL batched IO is disabled.
+    /// Returns whether BAL state prefetching during prewarm is disabled.
     pub const fn disable_bal_batch_io(&self) -> bool {
         self.disable_bal_batch_io
     }
 
-    /// Setter for whether to disable BAL batched IO.
+    /// Setter for whether to disable BAL state prefetching during prewarm.
     pub const fn without_bal_batch_io(mut self, disable_bal_batch_io: bool) -> Self {
         self.disable_bal_batch_io = disable_bal_batch_io;
         self
diff --git a/crates/engine/primitives/src/event.rs b/crates/engine/primitives/src/event.rs
index 702382c71c5..d75efcfb08d 100644
--- a/crates/engine/primitives/src/event.rs
+++ b/crates/engine/primitives/src/event.rs
@@ -1,7 +1,7 @@
 //! Events emitted by the beacon consensus engine.
 
 use crate::ForkchoiceStatus;
-use alloc::boxed::Box;
+use alloc::{boxed::Box, string::String};
 use alloy_consensus::BlockHeader;
 use alloy_eips::BlockNumHash;
 use alloy_rpc_types_engine::ForkchoiceState;
@@ -31,7 +31,12 @@ pub enum ConsensusEngineEvent<N: NodePrimitives = EthPrimitives> {
     /// A canonical chain was committed, and the elapsed time committing the data
     CanonicalChainCommitted(Box<SealedHeader<N::BlockHeader>>, Duration),
     /// The consensus engine processed an invalid block.
-    InvalidBlock(Box<SealedBlock<N::Block>>),
+    InvalidBlock {
+        /// The invalid block.
+        block: Box<SealedBlock<N::Block>>,
+        /// The validation error that caused the block to be rejected.
+        error: String,
+    },
     /// A slow block was detected after persistence, with its timing statistics.
     SlowBlock(SlowBlockInfo),
 }
@@ -69,8 +74,8 @@ where
             Self::CanonicalChainCommitted(block, duration) => {
                 write!(f, "CanonicalChainCommitted({:?}, {duration:?})", block.num_hash())
             }
-            Self::InvalidBlock(block) => {
-                write!(f, "InvalidBlock({:?})", block.num_hash())
+            Self::InvalidBlock { block, error } => {
+                write!(f, "InvalidBlock({:?}, {error})", block.num_hash())
             }
             Self::BlockReceived(num_hash) => {
                 write!(f, "BlockReceived({num_hash:?})")
diff --git a/crates/engine/primitives/src/forkchoice.rs b/crates/engine/primitives/src/forkchoice.rs
index 69cb5990711..533bbeb41bb 100644
--- a/crates/engine/primitives/src/forkchoice.rs
+++ b/crates/engine/primitives/src/forkchoice.rs
@@ -21,7 +21,8 @@ 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.set_valid(state);
+            self.last_syncing = None;
+            self.last_valid = Some(state);
         } else if status.is_syncing() {
             self.last_syncing = Some(state);
         }
@@ -30,11 +31,24 @@ impl ForkchoiceStateTracker {
         self.latest = Some(received);
     }
 
-    const fn set_valid(&mut self, state: ForkchoiceState) {
-        // we no longer need to sync to this state.
+    /// 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) {
         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;
+        }
     }
 
     /// Returns the [`ForkchoiceStatus`] of the latest received FCU.
diff --git a/crates/engine/primitives/src/message.rs b/crates/engine/primitives/src/message.rs
index 430beee3f1b..c57edf64c60 100644
--- a/crates/engine/primitives/src/message.rs
+++ b/crates/engine/primitives/src/message.rs
@@ -1,9 +1,11 @@
 use crate::{
     error::BeaconForkChoiceUpdateError, BeaconOnNewPayloadError, ExecutionPayload, ForkchoiceStatus,
 };
+use alloy_eips::eip4895::Withdrawal;
+use alloy_primitives::{Bytes, B256};
 use alloy_rpc_types_engine::{
-    ForkChoiceUpdateResult, ForkchoiceState, ForkchoiceUpdateError, ForkchoiceUpdated, PayloadId,
-    PayloadStatus, PayloadStatusEnum,
+    ExecutionData, ForkChoiceUpdateResult, ForkchoiceState, ForkchoiceUpdateError,
+    ForkchoiceUpdated, PayloadId, PayloadStatus, PayloadStatusEnum,
 };
 use core::{
     fmt::{self, Display},
@@ -173,16 +175,61 @@ pub struct BigBlockData<ExecutionData> {
     ///
     /// The first entry at index 0 represents the **original unmutated** base block's
     /// `ExecutionData`, which must be used to derive the initial EVM environment.
-    pub env_switches: Vec<(usize, ExecutionData)>,
+    pub env_switches: Vec<ExecutionData>,
     /// Block number → real block hash for blocks covered by previous big blocks in a sequence.
     /// When replaying chained big blocks, the BLOCKHASH opcode needs real hashes for blocks
     /// that were merged into earlier big blocks (and thus not individually persisted).
     pub prior_block_hashes: Vec<(u64, alloy_primitives::B256)>,
+    /// Block number for this big block.
+    pub block_number: u64,
+    /// Merged block access list for this big block.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub merged_block_access_list: Option<Bytes>,
 }
 
-impl<T> Default for BigBlockData<T> {
-    fn default() -> Self {
-        Self { env_switches: Vec::new(), prior_block_hashes: Vec::new() }
+impl ExecutionPayload for BigBlockData<ExecutionData> {
+    fn parent_hash(&self) -> B256 {
+        self.env_switches[0].parent_hash()
+    }
+
+    fn block_hash(&self) -> B256 {
+        self.env_switches.last().unwrap().block_hash()
+    }
+
+    fn block_number(&self) -> u64 {
+        self.block_number
+    }
+
+    fn withdrawals(&self) -> Option<&Vec<Withdrawal>> {
+        self.env_switches[0].withdrawals()
+    }
+
+    fn block_access_list(&self) -> Option<&Bytes> {
+        self.merged_block_access_list.as_ref()
+    }
+
+    fn parent_beacon_block_root(&self) -> Option<B256> {
+        self.env_switches[0].parent_beacon_block_root()
+    }
+
+    fn timestamp(&self) -> u64 {
+        self.env_switches[0].timestamp()
+    }
+
+    fn gas_used(&self) -> u64 {
+        self.env_switches.iter().map(|data| data.gas_used()).sum()
+    }
+
+    fn gas_limit(&self) -> u64 {
+        self.env_switches.iter().map(|data| data.gas_limit()).sum()
+    }
+
+    fn transaction_count(&self) -> usize {
+        self.env_switches.iter().map(|data| data.transaction_count()).sum()
+    }
+
+    fn slot_number(&self) -> Option<u64> {
+        self.env_switches[0].payload.slot_number()
     }
 }
 
diff --git a/crates/engine/tree/Cargo.toml b/crates/engine/tree/Cargo.toml
index c398ef2e4a0..62df71cf8a5 100644
--- a/crates/engine/tree/Cargo.toml
+++ b/crates/engine/tree/Cargo.toml
@@ -49,6 +49,7 @@ alloy-rpc-types-engine.workspace = true
 
 revm.workspace = true
 revm-primitives.workspace = true
+revm-state.workspace = true
 
 # common
 futures.workspace = true
@@ -96,8 +97,7 @@ reth-tracing.workspace = true
 reth-node-ethereum.workspace = true
 reth-e2e-test-utils.workspace = true
 
-# revm
-revm-state.workspace = true
+revm-database-interface.workspace = true
 
 assert_matches.workspace = true
 eyre.workspace = true
@@ -132,9 +132,9 @@ test-utils = [
     "reth-trie-parallel/test-utils",
     "reth-ethereum-primitives/test-utils",
     "reth-node-ethereum/test-utils",
-    "reth-evm-ethereum/test-utils",
     "reth-tasks/test-utils",
     "reth-execution-cache/test-utils",
+    "reth-evm-ethereum/test-utils",
 ]
 trie-debug = [
     "reth-trie-sparse/trie-debug",
diff --git a/crates/engine/tree/src/engine.rs b/crates/engine/tree/src/engine.rs
index 154b3b01e4f..f7951426da1 100644
--- a/crates/engine/tree/src/engine.rs
+++ b/crates/engine/tree/src/engine.rs
@@ -8,10 +8,9 @@ use crate::{
 use alloy_primitives::{map::B256Set, B256};
 use crossbeam_channel::Sender;
 use futures::{Stream, StreamExt};
-use reth_chain_state::ExecutedBlock;
 use reth_engine_primitives::{BeaconEngineMessage, ConsensusEngineEvent};
 use reth_ethereum_primitives::EthPrimitives;
-use reth_payload_primitives::PayloadTypes;
+use reth_payload_primitives::{BuiltPayloadExecutedBlock, PayloadTypes};
 use reth_primitives_traits::{Block, NodePrimitives, SealedBlock};
 use std::{
     fmt::Display,
@@ -233,7 +232,7 @@ impl EngineApiKind {
         matches!(self, Self::Ethereum)
     }
 
-    /// Returns true if this is the ethereum variant
+    /// Returns true if this is the opstack variant
     pub const fn is_opstack(&self) -> bool {
         matches!(self, Self::OpStack)
     }
@@ -245,15 +244,15 @@ pub enum EngineApiRequest<T: PayloadTypes, N: NodePrimitives> {
     /// A request received from the consensus engine.
     Beacon(BeaconEngineMessage<T>),
     /// Request to insert an already executed block, e.g. via payload building.
-    InsertExecutedBlock(ExecutedBlock<N>),
+    InsertExecutedBlock(BuiltPayloadExecutedBlock<N>),
 }
 
 impl<T: PayloadTypes, N: NodePrimitives> Display for EngineApiRequest<T, N> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Beacon(msg) => msg.fmt(f),
-            Self::InsertExecutedBlock(block) => {
-                write!(f, "InsertExecutedBlock({:?})", block.recovered_block().num_hash())
+            Self::InsertExecutedBlock(payload) => {
+                write!(f, "InsertExecutedBlock({:?})", payload.recovered_block.num_hash())
             }
         }
     }
diff --git a/crates/engine/tree/src/persistence.rs b/crates/engine/tree/src/persistence.rs
index da778e1a30f..1087a3e8291 100644
--- a/crates/engine/tree/src/persistence.rs
+++ b/crates/engine/tree/src/persistence.rs
@@ -6,8 +6,8 @@ use reth_errors::ProviderError;
 use reth_ethereum_primitives::EthPrimitives;
 use reth_primitives_traits::{FastInstant as Instant, NodePrimitives};
 use reth_provider::{
-    providers::ProviderNodeTypes, BlockExecutionWriter, BlockHashReader, ChainStateBlockWriter,
-    DBProvider, DatabaseProviderFactory, ProviderFactory, SaveBlocksMode,
+    providers::ProviderNodeTypes, BalProvider, BlockExecutionWriter, BlockHashReader,
+    ChainStateBlockWriter, DBProvider, DatabaseProviderFactory, ProviderFactory, SaveBlocksMode,
 };
 use reth_prune::{PrunerError, PrunerWithFactory};
 use reth_stages_api::{MetricEvent, MetricEventsSender};
@@ -21,7 +21,7 @@ use std::{
     time::Duration,
 };
 use thiserror::Error;
-use tracing::{debug, error, instrument};
+use tracing::{debug, error, instrument, warn};
 
 /// Unified result of any persistence operation.
 #[derive(Debug)]
@@ -113,6 +113,7 @@ where
                         let _ = self
                             .sync_metrics_tx
                             .send(MetricEvent::SyncHeight { height: block_number });
+                        self.maybe_run_pruner(block_number)?;
                     }
                 }
                 PersistenceAction::SaveFinalizedBlock(finalized_block) => {
@@ -178,22 +179,10 @@ where
             }
 
             provider_rw.commit()?;
+            let _ = self.provider.bal_store().flush().inspect_err(|err| {
+                warn!(target: "engine::persistence", last=?last_block, ?err, "Failed to flush BAL store");
+            });
             debug!(target: "engine::persistence", first=?first_block, last=?last_block, "Saved range of blocks");
-
-            // Run the pruner in a separate provider so it reads committed RocksDB state
-            // that includes the history entries written by save_blocks above.
-            //
-            // The pruner reads the indices from rocksdb, filters it, and writes to indices, so it
-            // must be able to read anything written by save_blocks.
-            if self.pruner.is_pruning_needed(last.number) {
-                debug!(target: "engine::persistence", block_num=?last.number, "Running pruner");
-                let prune_start = Instant::now();
-                let provider_rw = self.provider.database_provider_rw()?;
-                let _ = self.pruner.run_with_provider(&provider_rw, last.number)?;
-                provider_rw.commit()?;
-                debug!(target: "engine::persistence", tip=?last.number, "Finished pruning after saving blocks");
-                self.metrics.prune_before_duration_seconds.record(prune_start.elapsed());
-            }
         }
 
         let elapsed = start_time.elapsed();
@@ -202,6 +191,30 @@ where
 
         Ok(PersistenceResult { last_block, commit_duration: Some(elapsed) })
     }
+
+    fn maybe_run_pruner(&mut self, block_number: u64) -> Result<(), PersistenceError> {
+        // The durable save is already committed at this point, so pruning can happen after we
+        // acknowledge the save without extending the synchronous persistence wait.
+        if self.pruner.is_pruning_needed(block_number) {
+            debug!(target: "engine::persistence", block_num=?block_number, "Running pruner");
+            let prune_start = Instant::now();
+            let provider_rw = self.provider.database_provider_rw()?;
+            let _ = self.pruner.run_with_provider(&provider_rw, block_number)?;
+            provider_rw.commit()?;
+            let pruned_bals = self
+                .provider
+                .bal_store()
+                .prune(block_number)
+                .inspect_err(|err| {
+                    warn!(target: "engine::persistence", tip=?block_number, ?err, "Failed to prune BAL store");
+                })
+                .unwrap_or_default();
+            debug!(target: "engine::persistence", tip=?block_number, pruned_bals, "Finished pruning after saving blocks");
+            self.metrics.prune_before_duration_seconds.record(prune_start.elapsed());
+        }
+
+        Ok(())
+    }
 }
 
 /// One of the errors that can happen when using the persistence service.
@@ -374,16 +387,19 @@ impl Drop for ServiceGuard {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy_primitives::{B256, U256};
+    use alloy_eips::NumHash;
+    use alloy_primitives::{keccak256, BlockHash, BlockNumber, Bytes, Sealed, B256, U256};
     use reth_chain_state::test_utils::TestBlockBuilder;
     use reth_exex_types::FinishedExExHeight;
     use reth_provider::{
         providers::{ProviderFactoryBuilder, ReadOnlyConfig},
         test_utils::{create_test_provider_factory, MockNodeTypes},
-        AccountReader, ChainSpecProvider, HeaderProvider, StorageSettingsCache,
-        TryIntoHistoricalStateProvider,
+        AccountReader, BalConfig, BalNotificationStream, BalStore, BalStoreHandle,
+        ChainSpecProvider, HeaderProvider, InMemoryBalStore, ProviderError, ProviderResult,
+        SealedBal, StorageSettingsCache, TryIntoHistoricalStateProvider,
     };
     use reth_prune::Pruner;
+    use reth_prune_types::PruneMode;
     use tokio::sync::mpsc::unbounded_channel;
 
     fn default_persistence_handle() -> PersistenceHandle<EthPrimitives> {
@@ -399,6 +415,86 @@ mod tests {
         PersistenceHandle::<EthPrimitives>::spawn_service(provider, pruner, sync_metrics_tx)
     }
 
+    #[test]
+    fn test_pruner_prunes_bal_store() {
+        reth_tracing::init_test_tracing();
+
+        let old_hash = B256::random();
+        let retained_hash = B256::random();
+        let old_bal = Bytes::from_static(b"old");
+        let retained_bal = Bytes::from_static(b"retained");
+        let bal_store = BalStoreHandle::new(InMemoryBalStore::new(
+            BalConfig::with_in_memory_retention(PruneMode::Before(2)),
+        ));
+
+        bal_store
+            .insert(
+                NumHash::new(1, old_hash),
+                Sealed::new_unchecked(old_bal.clone(), keccak256(&old_bal)),
+            )
+            .unwrap();
+        bal_store
+            .insert(
+                NumHash::new(2, retained_hash),
+                Sealed::new_unchecked(retained_bal.clone(), keccak256(&retained_bal)),
+            )
+            .unwrap();
+
+        let provider = create_test_provider_factory().with_bal_store(bal_store.clone());
+        let (_finished_exex_height_tx, finished_exex_height_rx) =
+            tokio::sync::watch::channel(FinishedExExHeight::NoExExs);
+        let pruner =
+            Pruner::new_with_factory(provider.clone(), vec![], 0, 0, None, finished_exex_height_rx);
+        let (_db_service_tx, db_service_rx) = std::sync::mpsc::channel();
+        let (sync_metrics_tx, _sync_metrics_rx) = unbounded_channel();
+        let mut service = PersistenceService::new(provider, db_service_rx, pruner, sync_metrics_tx);
+
+        service.maybe_run_pruner(2).unwrap();
+
+        assert_eq!(
+            bal_store.get_by_hashes(&[old_hash, retained_hash]).unwrap(),
+            vec![None, Some(retained_bal)]
+        );
+    }
+
+    #[test]
+    fn test_pruner_ignores_bal_store_prune_error() {
+        reth_tracing::init_test_tracing();
+
+        let provider = create_test_provider_factory()
+            .with_bal_store(BalStoreHandle::new(FailingPruneBalStore));
+        let (_finished_exex_height_tx, finished_exex_height_rx) =
+            tokio::sync::watch::channel(FinishedExExHeight::NoExExs);
+        let pruner =
+            Pruner::new_with_factory(provider.clone(), vec![], 0, 0, None, finished_exex_height_rx);
+        let (_db_service_tx, db_service_rx) = std::sync::mpsc::channel();
+        let (sync_metrics_tx, _sync_metrics_rx) = unbounded_channel();
+        let mut service = PersistenceService::new(provider, db_service_rx, pruner, sync_metrics_tx);
+
+        service.maybe_run_pruner(2).unwrap();
+    }
+
+    #[derive(Debug)]
+    struct FailingPruneBalStore;
+
+    impl BalStore for FailingPruneBalStore {
+        fn insert(&self, _num_hash: NumHash, _bal: SealedBal) -> ProviderResult<()> {
+            Ok(())
+        }
+
+        fn prune(&self, _tip: BlockNumber) -> ProviderResult<usize> {
+            Err(ProviderError::other(std::io::Error::other("BAL store prune failed")))
+        }
+
+        fn get_by_hashes(&self, block_hashes: &[BlockHash]) -> ProviderResult<Vec<Option<Bytes>>> {
+            Ok(vec![None; block_hashes.len()])
+        }
+
+        fn bal_stream(&self) -> BalNotificationStream {
+            BalStoreHandle::noop().bal_stream()
+        }
+    }
+
     #[test]
     fn test_save_blocks_empty() {
         reth_tracing::init_test_tracing();
diff --git a/crates/engine/tree/src/tree/error.rs b/crates/engine/tree/src/tree/error.rs
index 8899542af64..de04e4338a2 100644
--- a/crates/engine/tree/src/tree/error.rs
+++ b/crates/engine/tree/src/tree/error.rs
@@ -1,5 +1,6 @@
 //! Internal errors for the tree module.
 
+use crate::tree::payload_processor::bal::BalExecutionError;
 use alloy_consensus::BlockHeader;
 use reth_consensus::ConsensusError;
 use reth_errors::{BlockExecutionError, BlockValidationError, ProviderError};
@@ -121,6 +122,17 @@ pub enum InsertBlockErrorKind {
     Other(#[from] Box<dyn core::error::Error + Send + Sync + 'static>),
 }
 
+impl From<BalExecutionError> for InsertBlockErrorKind {
+    fn from(e: BalExecutionError) -> Self {
+        match e {
+            BalExecutionError::Consensus(inner) => Self::Consensus(inner),
+            BalExecutionError::Execution(inner) => Self::Execution(inner),
+            BalExecutionError::Provider(inner) => Self::Provider(inner),
+            BalExecutionError::Other(inner) => Self::Other(inner),
+        }
+    }
+}
+
 impl InsertBlockErrorKind {
     /// Returns an [`InsertBlockValidationError`] if the error is caused by an invalid block.
     ///
diff --git a/crates/engine/tree/src/tree/instrumented_state.rs b/crates/engine/tree/src/tree/instrumented_state.rs
index d7f0d2ea1bf..c14c859f77a 100644
--- a/crates/engine/tree/src/tree/instrumented_state.rs
+++ b/crates/engine/tree/src/tree/instrumented_state.rs
@@ -74,11 +74,20 @@ where
     /// Creates a new [`InstrumentedStateProvider`] from a state provider with the provided label
     /// for metrics.
     pub fn new(state_provider: S, source: &'static str) -> Self {
-        Self {
+        Self::with_stats(
             state_provider,
-            metrics: StateProviderMetrics::new_with_labels(&[("source", source)]),
-            stats: Arc::new(StateProviderStats::default()),
-        }
+            StateProviderMetrics::with_source(source),
+            Arc::new(StateProviderStats::default()),
+        )
+    }
+
+    /// Creates a new [`InstrumentedStateProvider`] that writes into shared statistics.
+    pub(crate) const fn with_stats(
+        state_provider: S,
+        metrics: StateProviderMetrics,
+        stats: Arc<StateProviderStats>,
+    ) -> Self {
+        Self { state_provider, metrics, stats }
     }
 
     /// Returns a shared reference to the accumulated fetch statistics.
@@ -87,26 +96,6 @@ where
     }
 }
 
-impl<S> Drop for InstrumentedStateProvider<S> {
-    fn drop(&mut self) {
-        let total_storage_fetch_latency = self.stats.total_storage_fetch_latency.duration();
-        self.metrics.total_storage_fetch_latency.record(total_storage_fetch_latency);
-        self.metrics
-            .total_storage_fetch_latency_gauge
-            .set(total_storage_fetch_latency.as_secs_f64());
-
-        let total_code_fetch_latency = self.stats.total_code_fetch_latency.duration();
-        self.metrics.total_code_fetch_latency.record(total_code_fetch_latency);
-        self.metrics.total_code_fetch_latency_gauge.set(total_code_fetch_latency.as_secs_f64());
-
-        let total_account_fetch_latency = self.stats.total_account_fetch_latency.duration();
-        self.metrics.total_account_fetch_latency.record(total_account_fetch_latency);
-        self.metrics
-            .total_account_fetch_latency_gauge
-            .set(total_account_fetch_latency.as_secs_f64());
-    }
-}
-
 /// Metrics for the instrumented state provider
 #[derive(Metrics, Clone)]
 #[metrics(scope = "sync.state_provider")]
@@ -144,6 +133,28 @@ pub(crate) struct StateProviderMetrics {
     total_account_fetch_latency_gauge: Gauge,
 }
 
+impl StateProviderMetrics {
+    /// Creates state-provider metrics with the given source label.
+    pub(crate) fn with_source(source: &'static str) -> Self {
+        Self::new_with_labels(&[("source", source)])
+    }
+
+    /// Records accumulated fetch latency totals.
+    pub(crate) fn record_totals(&self, stats: &StateProviderStats) {
+        let total_storage_fetch_latency = stats.total_storage_fetch_latency.duration();
+        self.total_storage_fetch_latency.record(total_storage_fetch_latency);
+        self.total_storage_fetch_latency_gauge.set(total_storage_fetch_latency.as_secs_f64());
+
+        let total_code_fetch_latency = stats.total_code_fetch_latency.duration();
+        self.total_code_fetch_latency.record(total_code_fetch_latency);
+        self.total_code_fetch_latency_gauge.set(total_code_fetch_latency.as_secs_f64());
+
+        let total_account_fetch_latency = stats.total_account_fetch_latency.duration();
+        self.total_account_fetch_latency.record(total_account_fetch_latency);
+        self.total_account_fetch_latency_gauge.set(total_account_fetch_latency.as_secs_f64());
+    }
+}
+
 impl<S: AccountReader> AccountReader for InstrumentedStateProvider<S> {
     fn basic_account(&self, address: &Address) -> ProviderResult<Option<Account>> {
         let start = Instant::now();
diff --git a/crates/engine/tree/src/tree/metrics.rs b/crates/engine/tree/src/tree/metrics.rs
index f8a96e3c6bb..018f422e22e 100644
--- a/crates/engine/tree/src/tree/metrics.rs
+++ b/crates/engine/tree/src/tree/metrics.rs
@@ -537,10 +537,6 @@ pub struct BlockValidationMetrics {
     pub hashed_post_state_size: Histogram,
     /// Size of `TrieUpdatesSorted` (`total_len`)
     pub trie_updates_sorted_size: Histogram,
-    /// Size of `AnchoredTrieInput` overlay `TrieUpdatesSorted` (`total_len`)
-    pub anchored_overlay_trie_updates_size: Histogram,
-    /// Size of `AnchoredTrieInput` overlay `HashedPostStateSorted` (`total_len`)
-    pub anchored_overlay_hashed_state_size: Histogram,
 }
 
 impl BlockValidationMetrics {
diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index 7837063decc..177e841d4f4 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -7,14 +7,14 @@ use crate::{
 };
 use alloy_consensus::BlockHeader;
 use alloy_eips::{eip1898::BlockWithParent, merge::EPOCH_SLOTS, BlockNumHash, NumHash};
-use alloy_primitives::B256;
+use alloy_primitives::{map::B256Map, B256};
 use alloy_rpc_types_engine::{
     ForkchoiceState, PayloadStatus, PayloadStatusEnum, PayloadValidationError,
 };
 use error::{InsertBlockError, InsertBlockFatalError, InsertBlockValidationError};
 use reth_chain_state::{
     CanonicalInMemoryState, ComputedTrieData, ExecutedBlock, ExecutionTimingStats,
-    MemoryOverlayStateProvider, NewCanonicalChain,
+    MemoryOverlayStateProvider, NewCanonicalChain, StateTrieOverlayManager,
 };
 use reth_consensus::{Consensus, FullConsensus};
 use reth_engine_primitives::{
@@ -36,11 +36,11 @@ use reth_provider::{
 };
 use reth_revm::database::StateProviderDatabase;
 use reth_stages_api::ControlFlow;
-use reth_tasks::{spawn_os_thread, utils::increase_thread_priority};
+use reth_tasks::{spawn_os_thread, utils::increase_thread_priority, WorkerPool};
 use reth_trie_db::ChangesetCache;
 use revm::interpreter::debug_unreachable;
 use state::TreeState;
-use std::{collections::HashMap, fmt::Debug, ops, sync::Arc, time::Duration};
+use std::{fmt::Debug, ops, sync::Arc, time::Duration};
 
 use crossbeam_channel::{Receiver, Sender};
 use tokio::sync::{
@@ -61,6 +61,7 @@ pub mod precompile_cache;
 #[cfg(test)]
 mod tests;
 mod trie_updates;
+pub mod types;
 
 use crate::{persistence::PersistenceResult, tree::error::AdvancePersistenceError};
 pub use block_buffer::BlockBuffer;
@@ -71,9 +72,10 @@ pub use payload_validator::{BasicEngineValidator, EngineValidator};
 pub use persistence_state::PersistenceState;
 pub use reth_engine_primitives::TreeConfig;
 pub use reth_execution_cache::{
-    CachedStateMetrics, CachedStateMetricsSource, CachedStateProvider, ExecutionCache,
-    PayloadExecutionCache, SavedCache,
+    CachedStateCacheMetrics, CachedStateMetrics, CachedStateMetricsSource, CachedStateProvider,
+    ExecutionCache, PayloadExecutionCache, SavedCache,
 };
+pub use types::{ValidationOutcome, ValidationOutput};
 
 pub mod state;
 
@@ -154,6 +156,7 @@ impl<N: NodePrimitives> EngineApiTreeState<N> {
         invalid_header_hit_eviction_threshold: u8,
         canonical_block: BlockNumHash,
         engine_kind: EngineApiKind,
+        state_trie_overlay_worker_pool: Arc<WorkerPool>,
     ) -> Self {
         Self {
             invalid_headers: InvalidHeaderCache::new(
@@ -161,7 +164,11 @@ impl<N: NodePrimitives> EngineApiTreeState<N> {
                 invalid_header_hit_eviction_threshold,
             ),
             buffer: BlockBuffer::new(block_buffer_limit),
-            tree_state: TreeState::new(canonical_block, engine_kind),
+            tree_state: TreeState::new(
+                canonical_block,
+                engine_kind,
+                StateTrieOverlayManager::new(state_trie_overlay_worker_pool),
+            ),
             forkchoice_state_tracker: ForkchoiceStateTracker::default(),
         }
     }
@@ -308,7 +315,7 @@ where
     /// Timing statistics for executed blocks, keyed by block hash.
     /// Stored here (not in `ExecutedBlock`) to avoid leaking observability concerns into the block
     /// type. Entries are removed when blocks are persisted or invalidated.
-    execution_timing_stats: HashMap<B256, Box<ExecutionTimingStats>>,
+    execution_timing_stats: B256Map<Box<ExecutionTimingStats>>,
     /// Set when an FCU with payload attributes is received, cleared on the next FCU without.
     /// Suppresses persistence cycles during payload building.
     building_payload: bool,
@@ -402,7 +409,7 @@ where
             engine_kind,
             evm_config,
             changeset_cache,
-            execution_timing_stats: HashMap::new(),
+            execution_timing_stats: B256Map::default(),
             building_payload: false,
             runtime,
         }
@@ -443,6 +450,7 @@ where
             config.invalid_header_hit_eviction_threshold(),
             header.num_hash(),
             kind,
+            runtime.state_trie_overlay_worker_pool(),
         );
 
         let task = Self::new(
@@ -1503,20 +1511,8 @@ where
         );
         self.changeset_cache.evict(eviction_threshold);
 
-        // Invalidate cached overlay since the anchor has changed
-        self.state.tree_state.invalidate_cached_overlay();
-
         self.on_new_persisted_block()?;
 
-        // 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() {
-            self.runtime.spawn_blocking_named("prepare-overlay", move || {
-                let _ = prepared.overlay.get(prepared.anchor_hash);
-            });
-        }
-
         self.purge_timing_stats(last_persisted_block_number, commit_duration);
 
         Ok(())
@@ -1548,16 +1544,32 @@ where
             },
             FromEngine::Request(request) => {
                 match request {
-                    EngineApiRequest::InsertExecutedBlock(block) => {
-                        let block_num_hash = block.recovered_block().num_hash();
+                    EngineApiRequest::InsertExecutedBlock(payload) => {
+                        let block_num_hash = payload.recovered_block.num_hash();
                         if block_num_hash.number <= self.state.tree_state.canonical_block_number() {
                             // outdated block that can be skipped
                             return Ok(ops::ControlFlow::Continue(()))
                         }
 
+                        if self.state.tree_state.contains_hash(&block_num_hash.hash) {
+                            // block already known to the tree (e.g. delivered via newPayload first)
+                            return Ok(ops::ControlFlow::Continue(()))
+                        }
+
                         debug!(target: "engine::tree", block=?block_num_hash, "inserting already executed block");
                         let now = Instant::now();
 
+                        let block = match self
+                            .payload_validator
+                            .on_inserted_executed_block(payload, &self.state)
+                        {
+                            Ok(block) => block,
+                            Err(err) => {
+                                warn!(target: "engine::tree", %err, block=?block_num_hash, "Failed to insert already executed block");
+                                return Ok(ops::ControlFlow::Continue(()))
+                            }
+                        };
+
                         // if the parent is the canonical head, we can insert the block as the
                         // pending block
                         if self.state.tree_state.canonical_block_hash() ==
@@ -1568,7 +1580,6 @@ where
                         }
 
                         self.state.tree_state.insert_executed(block.clone());
-                        self.payload_validator.on_inserted_executed_block(block.clone());
                         self.metrics.engine.inserted_already_executed_blocks.increment(1);
                         self.emit_event(EngineApiEvent::BeaconConsensus(
                             ConsensusEngineEvent::CanonicalBlockAdded(block, now.elapsed()),
@@ -1783,7 +1794,19 @@ where
         };
 
         // backfill height is the block number that the backfill finished at
-        let Some(backfill_height) = backfill_height else { return Ok(()) };
+        let Some(backfill_height) = backfill_height else {
+            // Backfill made no progress (no P2P peers or no blocks to download).  This is the
+            // normal situation for OP Stack nodes that receive all blocks exclusively via the
+            // engine API and never via P2P.  The blocks that arrived as engine_newPayload during
+            // the backfill window are sitting in the block buffer.  Try to connect them to the
+            // current canonical head now so they are executed and Firehose-traced.  This is safe
+            // for non-OP-Stack chains too: any buffered blocks whose parent state is available
+            // will be connected; those without parent state are re-buffered, unchanged.
+            let current_head = self.state.tree_state.current_canonical_head;
+            debug!(target: "engine::tree", ?current_head, "backfill made no progress, trying to connect buffered blocks");
+            self.try_connect_buffered_blocks(current_head)?;
+            return Ok(());
+        };
 
         // state house keeping after backfill sync
         // remove all executed blocks below the backfill height
@@ -1831,33 +1854,33 @@ where
             self.canonical_in_memory_state.set_canonical_head(new_head);
         }
 
-        // check if we need to run backfill again by comparing the most recent finalized height to
-        // the backfill height
+        // check if we need to run backfill again by comparing the most recent backfill target
+        // height to the backfill height
         let Some(sync_target_state) = self.state.forkchoice_state_tracker.sync_target_state()
         else {
             return Ok(())
         };
-        if sync_target_state.finalized_block_hash.is_zero() {
-            // no finalized block, can't check distance
+        if !self.engine_kind.is_opstack() && sync_target_state.finalized_block_hash.is_zero() {
+            // no finalized block, can't check distance on non-OP Stack chains
             return Ok(())
         }
-        // get the block number of the finalized block, if we have it
-        let newest_finalized = self
-            .state
-            .buffer
-            .block(&sync_target_state.finalized_block_hash)
-            .map(|block| block.number());
+        let target_hash = self.backfill_target_hash(sync_target_state);
+        if target_hash.is_zero() {
+            return Ok(())
+        }
+        // get the block number of the backfill target block, if we have it buffered
+        let newest_target = self.state.buffer.block(&target_hash).map(|block| block.number());
 
-        // The block number that the backfill finished at - if the progress or newest
-        // finalized is None then we can't check the distance anyways.
+        // The block number that the backfill finished at - if the progress or newest target is
+        // None then we can't check the distance anyways.
         //
-        // If both are Some, we perform another distance check and return the desired
-        // backfill target
+        // If both are Some, we perform another distance check and return the desired backfill
+        // target
         if let Some(backfill_target) =
-            ctrl.block_number().zip(newest_finalized).and_then(|(progress, finalized_number)| {
+            ctrl.block_number().zip(newest_target).and_then(|(progress, target_number)| {
                 // Determines whether or not we should run backfill again, in case
                 // the new gap is still large enough and requires running backfill again
-                self.backfill_sync_target(progress, finalized_number, None)
+                self.backfill_sync_target(progress, target_number, None)
             })
         {
             // request another backfill run
@@ -1917,9 +1940,37 @@ 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 {
@@ -2144,9 +2195,7 @@ where
 
         let sorted_hashed_state = Arc::new(hashed_state.into_sorted());
         let sorted_trie_updates = Arc::new(trie_updates);
-        // Skip building trie input and anchor for DB-loaded blocks.
-        let trie_data =
-            ComputedTrieData::without_trie_input(sorted_hashed_state, sorted_trie_updates);
+        let trie_data = ComputedTrieData::new(sorted_hashed_state, sorted_trie_updates);
 
         let execution_output = Arc::new(BlockExecutionOutput {
             state: execution_output.bundle,
@@ -2307,7 +2356,10 @@ where
 
         // insert the head block into the invalid header cache
         self.state.invalid_headers.insert_with_invalid_ancestor(head.hash(), invalid);
-        self.emit_event(ConsensusEngineEvent::InvalidBlock(Box::new(head)));
+        self.emit_event(ConsensusEngineEvent::InvalidBlock {
+            block: Box::new(head),
+            error: PayloadValidationError::LinksToRejectedPayload.to_string(),
+        });
 
         Ok(status)
     }
@@ -2484,85 +2536,83 @@ where
         }
     }
 
-    /// Returns the target hash to sync to if the distance from the local tip to the block is
-    /// greater than the threshold and we're not synced to the finalized block yet (if we've seen
-    /// that block already).
+    /// Returns the block hash that backfill should target.
     ///
-    /// If this is invoked after a new block has been downloaded, the downloaded block could be the
-    /// (missing) finalized block.
+    /// Defaults to the finalized block hash. On OP Stack, the CL finalizes in large batches and the
+    /// finalized hash can lag the canonical tip by a wide margin, so backfill targets the head.
+    ///
+    /// The zero-finalized optimistic-sync fallback for non-OP Stack chains is handled by
+    /// [`Self::backfill_sync_target`].
+    const fn backfill_target_hash(&self, state: ForkchoiceState) -> B256 {
+        if self.engine_kind.is_opstack() {
+            state.head_block_hash
+        } else {
+            state.finalized_block_hash
+        }
+    }
+
+    /// Returns the target hash to sync to if the distance from the local tip is greater than the
+    /// threshold and we're not yet synced to the backfill target (see
+    /// [`Self::backfill_target_hash`]).
+    ///
+    /// If this is invoked after a new block has been downloaded, the downloaded block could be
+    /// the (missing) target block.
     fn backfill_sync_target(
         &self,
         canonical_tip_num: u64,
         target_block_number: u64,
         downloaded_block: Option<BlockNumHash>,
     ) -> Option<B256> {
-        let sync_target_state = self.state.forkchoice_state_tracker.sync_target_state();
-
-        // check if the downloaded block is the tracked finalized block
-        let exceeds_backfill_threshold =
-            match (downloaded_block.as_ref(), sync_target_state.as_ref()) {
-                // if we downloaded the finalized block we can now check how far we're off
-                (Some(downloaded_block), Some(state))
-                    if downloaded_block.hash == state.finalized_block_hash =>
-                {
-                    self.exceeds_backfill_run_threshold(canonical_tip_num, downloaded_block.number)
+        let state = self.state.forkchoice_state_tracker.sync_target_state()?;
+        let target_hash = self.backfill_target_hash(state);
+
+        // check if the downloaded block is the tracked backfill target
+        let exceeds_backfill_threshold = match downloaded_block.as_ref() {
+            // if we downloaded the target block we can now check how far we're off
+            Some(downloaded_block) if downloaded_block.hash == target_hash => {
+                self.exceeds_backfill_run_threshold(canonical_tip_num, downloaded_block.number)
+            }
+            _ => match self.state.buffer.block(&target_hash) {
+                // if we have buffered the target block, we should check how far we're off
+                Some(buffered_target) => {
+                    self.exceeds_backfill_run_threshold(canonical_tip_num, buffered_target.number())
                 }
-                _ => match sync_target_state
-                    .as_ref()
-                    .and_then(|state| self.state.buffer.block(&state.finalized_block_hash))
-                {
-                    Some(buffered_finalized) => {
-                        // if we have buffered the finalized block, we should check how far we're
-                        // off
-                        self.exceeds_backfill_run_threshold(
-                            canonical_tip_num,
-                            buffered_finalized.number(),
-                        )
-                    }
-                    None => {
-                        // check if the distance exceeds the threshold for backfill sync
-                        self.exceeds_backfill_run_threshold(canonical_tip_num, target_block_number)
-                    }
-                },
-            };
+                // check if the distance exceeds the threshold for backfill sync
+                None => self.exceeds_backfill_run_threshold(canonical_tip_num, target_block_number),
+            },
+        };
 
-        // if the number of missing blocks is greater than the max, trigger backfill
-        if exceeds_backfill_threshold && let Some(state) = sync_target_state {
-            // if we have already canonicalized the finalized block, we should skip backfill
-            match self.provider.header_by_hash_or_number(state.finalized_block_hash.into()) {
-                Err(err) => {
-                    warn!(target: "engine::tree", %err, "Failed to get finalized block header");
-                }
-                Ok(None) => {
-                    // ensure the finalized block is known (not the zero hash)
-                    if !state.finalized_block_hash.is_zero() {
-                        // we don't have the block yet and the distance exceeds the allowed
-                        // threshold
-                        return Some(state.finalized_block_hash)
-                    }
+        if !exceeds_backfill_threshold {
+            return None
+        }
 
-                    // OPTIMISTIC SYNCING
-                    //
-                    // It can happen when the node is doing an
-                    // optimistic sync, where the CL has no knowledge of the finalized hash,
-                    // but is expecting the EL to sync as high
-                    // as possible before finalizing.
-                    //
-                    // This usually doesn't happen on ETH mainnet since CLs use the more
-                    // secure checkpoint syncing.
-                    //
-                    // However, optimism chains will do this. The risk of a reorg is however
-                    // low.
-                    debug!(target: "engine::tree", hash=?state.head_block_hash, "Setting head hash as an optimistic backfill target.");
-                    return Some(state.head_block_hash)
-                }
-                Ok(Some(_)) => {
-                    // we're fully synced to the finalized block
-                }
+        // if we have already canonicalized the target block, we should skip backfill
+        match self.provider.header_by_hash_or_number(target_hash.into()) {
+            Err(err) => {
+                warn!(target: "engine::tree", %err, "Failed to get backfill target block header");
+                None
             }
+            // we don't have the block yet and the distance exceeds the allowed threshold
+            Ok(None) if !target_hash.is_zero() => Some(target_hash),
+            Ok(None) => {
+                // OPTIMISTIC SYNCING
+                //
+                // It can happen when the node is doing an
+                // optimistic sync, where the CL has no knowledge of the finalized hash,
+                // but is expecting the EL to sync as high
+                // as possible before finalizing.
+                //
+                // This usually doesn't happen on ETH mainnet since CLs use the more
+                // secure checkpoint syncing.
+                //
+                // However, optimism chains will do this. The risk of a reorg is however
+                // low.
+                debug!(target: "engine::tree", hash=?state.head_block_hash, "Setting head hash as an optimistic backfill target.");
+                Some(state.head_block_hash)
+            }
+            // we're fully synced to the target block
+            Ok(Some(_)) => None,
         }
-
-        None
     }
 
     /// This method tries to detect whether on-disk and in-memory states have diverged. It might
@@ -2877,12 +2927,7 @@ where
         &mut self,
         block_id: BlockWithParent,
         input: Input,
-        execute: impl FnOnce(
-            &mut V,
-            Input,
-            TreeCtx<'_, N>,
-        )
-            -> Result<(ExecutedBlock<N>, Option<Box<ExecutionTimingStats>>), Err>,
+        execute: impl FnOnce(&mut V, Input, TreeCtx<'_, N>) -> Result<ValidationOutput<N>, Err>,
         convert_to_block: impl FnOnce(&mut Self, Input) -> Result<SealedBlock<N::Block>, Err>,
     ) -> Result<InsertPayloadOk, Err>
     where
@@ -2952,7 +2997,8 @@ where
 
         let start = Instant::now();
 
-        let (executed, timing_stats) = execute(&mut self.payload_validator, input, ctx)?;
+        let ValidationOutput { executed_block: executed, execution_timing_stats: timing_stats } =
+            execute(&mut self.payload_validator, input, ctx)?;
 
         // Emit slow block event immediately after execution so it appears even when
         // persistence hasn't completed yet (e.g. blocks arriving faster than persistence).
@@ -3040,9 +3086,10 @@ where
         } else {
             self.state.invalid_headers.insert(block.block_with_parent());
         }
-        self.emit_event(EngineApiEvent::BeaconConsensus(ConsensusEngineEvent::InvalidBlock(
-            Box::new(block),
-        )));
+        self.emit_event(EngineApiEvent::BeaconConsensus(ConsensusEngineEvent::InvalidBlock {
+            block: Box::new(block),
+            error: validation_err.to_string(),
+        }));
 
         Ok(PayloadStatus::new(
             PayloadStatusEnum::Invalid { validation_error: validation_err.to_string() },
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/error.rs b/crates/engine/tree/src/tree/payload_processor/bal/error.rs
new file mode 100644
index 00000000000..ffd3b7310eb
--- /dev/null
+++ b/crates/engine/tree/src/tree/payload_processor/bal/error.rs
@@ -0,0 +1,32 @@
+//! Errors for the BAL execution path.
+
+use alloy_evm::block::BlockExecutionError;
+use reth_consensus::ConsensusError;
+use reth_provider::ProviderError;
+
+/// Errors surfaced by `execute_block`.
+#[derive(Debug, thiserror::Error)]
+pub enum BalExecutionError {
+    /// Block violated consensus rules while running the BAL path.
+    #[error(transparent)]
+    Consensus(#[from] ConsensusError),
+    /// Worker or canonical EVM failure.
+    #[error("evm execution failed: {0}")]
+    Execution(#[from] BlockExecutionError),
+    /// Provider setup failed before EVM execution could start.
+    #[error("provider setup failed: {0}")]
+    Provider(#[from] ProviderError),
+    /// BAL execution failed before it reached EVM execution.
+    #[error(transparent)]
+    Other(#[from] Box<dyn core::error::Error + Send + Sync + 'static>),
+}
+
+impl BalExecutionError {
+    /// Create an [`Self::Other`] error from any boxed-error-compatible value.
+    pub(crate) fn other<E>(error: E) -> Self
+    where
+        E: Into<Box<dyn core::error::Error + Send + Sync + 'static>>,
+    {
+        Self::Other(error.into())
+    }
+}
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
new file mode 100644
index 00000000000..734cac8153c
--- /dev/null
+++ b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
@@ -0,0 +1,1238 @@
+//! BAL executor.
+//!
+//! Read `execute_block` as two execution paths over the same parent state.
+//!
+//! Worker states run transactions speculatively. Each worker gets one fresh cache-filling database
+//! from `make_db(true)`, installs the received BAL, sets the transaction BAL index for each
+//! streamed transaction, and returns uncommitted transaction results.
+//!
+//! The canonical state owns block effects. It runs the normal pre/post block hooks, commits
+//! worker results in transaction order, tracks block gas admission, and builds the BAL that this
+//! execution actually produced.
+//!
+//! The rebuilt BAL is returned to the outer payload validator for consensus post-execution
+//! validation. This module only logs the first divergence between the received BAL and the BAL
+//! rebuilt from canonical execution.
+
+use super::{ordered_outputs::ordered_worker_outputs, worker, BalExecutionError};
+use alloy_eip7928::{
+    bal::{Bal as AlloyBal, DecodedBal},
+    compute_block_access_list_hash, BlockAccessList,
+};
+use alloy_evm::{
+    block::{BlockExecutionError, BlockExecutor, BlockValidationError, TxResult},
+    Evm,
+};
+use alloy_primitives::Address;
+use crossbeam_channel::{Receiver, Sender};
+use reth_evm::{execute::ExecutableTxFor, ConfigureEvm, Database, EvmEnvFor, ExecutionCtxFor};
+use reth_primitives_traits::ReceiptTy;
+use reth_provider::BlockExecutionOutput;
+use reth_tasks::Runtime;
+use revm::{
+    bytecode::BytecodeDecodeError,
+    context::{result::ResultAndState, Block},
+    database::{states::bundle_state::BundleRetention, State},
+};
+use revm_state::bal::Bal as RevmBal;
+use std::sync::Arc;
+
+use crate::tree::payload_processor::receipt_root_task::IndexedReceipt;
+
+/// Executes one block on the BAL path using the runtime's persistent BAL worker pool.
+#[expect(clippy::too_many_arguments, clippy::type_complexity)]
+pub fn execute_block<'a, Evm, Tx, Err, DB, MakeDb>(
+    runtime: &Runtime,
+    evm_config: &'a Evm,
+    make_db: &'a MakeDb,
+    input_bal: Arc<DecodedBal>,
+    evm_env: EvmEnvFor<Evm>,
+    ctx: ExecutionCtxFor<'a, Evm>,
+    transaction_count: usize,
+    txs: Receiver<(usize, Result<Tx, Err>)>,
+    receipt_tx: Sender<IndexedReceipt<ReceiptTy<Evm::Primitives>>>,
+) -> Result<
+    (BlockExecutionOutput<ReceiptTy<Evm::Primitives>>, Vec<Address>, BlockAccessList),
+    BalExecutionError,
+>
+where
+    Evm: ConfigureEvm + 'static,
+    Tx: ExecutableTxFor<Evm> + Send + 'a,
+    Err: core::error::Error + Send + Sync + 'static,
+    DB: Database + Send + 'a,
+    MakeDb: Fn(bool) -> Result<DB, BalExecutionError> + Sync + 'a,
+    ReceiptTy<Evm::Primitives>: Clone,
+{
+    let worker_pool = runtime.bal_streaming_pool();
+    let worker_count = worker_pool.current_num_threads().max(1).min(transaction_count);
+
+    worker_pool.in_place_scope(|scope| {
+        execute_block_inner(
+            scope,
+            evm_config,
+            make_db,
+            input_bal,
+            evm_env,
+            ctx,
+            transaction_count,
+            txs,
+            receipt_tx,
+            worker_count,
+        )
+    })
+}
+
+#[expect(clippy::too_many_arguments, clippy::type_complexity)]
+fn execute_block_inner<'scope, Evm, Tx, Err, DB, MakeDb>(
+    scope: &rayon::Scope<'scope>,
+    evm_config: &'scope Evm,
+    make_db: &'scope MakeDb,
+    input_bal: Arc<DecodedBal>,
+    evm_env: EvmEnvFor<Evm>,
+    ctx: ExecutionCtxFor<'scope, Evm>,
+    transaction_count: usize,
+    txs: Receiver<(usize, Result<Tx, Err>)>,
+    receipt_tx: Sender<IndexedReceipt<ReceiptTy<Evm::Primitives>>>,
+    worker_count: usize,
+) -> Result<
+    (BlockExecutionOutput<ReceiptTy<Evm::Primitives>>, Vec<Address>, BlockAccessList),
+    BalExecutionError,
+>
+where
+    Evm: ConfigureEvm + 'scope,
+    Tx: ExecutableTxFor<Evm> + Send + 'scope,
+    Err: core::error::Error + Send + Sync + 'static,
+    DB: Database + Send + 'scope,
+    MakeDb: Fn(bool) -> Result<DB, BalExecutionError> + Sync + 'scope,
+    ReceiptTy<Evm::Primitives>: Clone,
+{
+    let bal = input_bal.as_bal();
+    let input_bal_revm = convert_alloy_to_revm_bal(bal)?;
+
+    let block_gas_limit = evm_env.block_env.gas_limit();
+    let enable_amsterdam_eip8037 = evm_env.cfg_env.enable_amsterdam_eip8037;
+    let tx_gas_limit_cap = evm_env.cfg_env.tx_gas_limit_cap;
+    let mut canonical_state = State::builder()
+        .with_database(make_db(false)?)
+        .with_bundle_update()
+        .with_bal_builder()
+        .build();
+
+    let (block_result, senders) = {
+        let (result_tx, result_rx) = crossbeam_channel::unbounded();
+        let (abort_guard, abort_rx) = AbortGuard::new();
+
+        for _ in 0..worker_count {
+            worker::spawn_worker(
+                scope,
+                txs.clone(),
+                abort_rx.clone(),
+                result_tx.clone(),
+                evm_config,
+                make_db,
+                Arc::clone(&input_bal_revm),
+                evm_env.clone(),
+                ctx.clone(),
+            );
+        }
+        drop(result_tx);
+
+        let mut gas_tracker =
+            BlockGasTracker::new(block_gas_limit, enable_amsterdam_eip8037, tx_gas_limit_cap);
+        let evm = evm_config.evm_with_env(&mut canonical_state, evm_env);
+        let mut canonical_executor = evm_config.create_executor_with_state(evm, ctx.clone());
+
+        canonical_executor.apply_pre_execution_changes()?;
+        let mut senders = Vec::with_capacity(transaction_count);
+        let mut last_sent_len = 0usize;
+        for output in ordered_worker_outputs(&result_rx, transaction_count) {
+            let output = output?;
+
+            gas_tracker.validate_tx_limit(output.tx_gas_limit)?;
+            gas_tracker.record_result(output.result.result());
+            canonical_executor.evm_mut().db_mut().bump_bal_index();
+
+            let _ = canonical_executor.commit_transaction(output.result);
+            senders.push(output.signer);
+
+            let current_len = canonical_executor.receipts().len();
+            if current_len > last_sent_len {
+                last_sent_len = current_len;
+                if let Some(receipt) = canonical_executor.receipts().last() {
+                    let tx_index = current_len - 1;
+                    let _ = receipt_tx.send(IndexedReceipt::new(tx_index, receipt.clone()));
+                }
+            }
+        }
+        drop(abort_guard);
+
+        canonical_executor.evm_mut().db_mut().bump_bal_index();
+        let block_result = canonical_executor.apply_post_execution_changes()?;
+        (block_result, senders)
+    };
+
+    let built_bal = take_built_bal_and_log_divergence(&mut canonical_state, bal);
+
+    canonical_state.merge_transitions(BundleRetention::Reverts);
+    Ok((
+        BlockExecutionOutput { state: canonical_state.take_bundle(), result: block_result },
+        senders,
+        built_bal,
+    ))
+}
+
+fn convert_alloy_to_revm_bal(bal: &AlloyBal) -> Result<Arc<RevmBal>, BalExecutionError> {
+    // Convert the BAL from alloy to a BAL that can be consumed by revm, that is more amenable
+    // for state lookups.
+    //
+    // This is failable.
+    //
+    // This is due to bytecodes. A transaction can attempt to deploy illegal bytecodes, e.g. due to
+    // EIP-3541 or more specifically due to EIP-7702.
+    //
+    // During serial execution this check happens before the bytecode is deployed and if the check
+    // is triggered then the execution is reverted, and as such no actual code change event takes
+    // place. Therefore, if we do observe such a bytecode in a BAL then that means the BAL is
+    // invalid as no legal execution should've led to this bytecode deployment.
+    let alloy_bal: Vec<_> = Vec::<_>::from(bal.clone());
+    let received_bal_revm = RevmBal::try_from(alloy_bal).map_err(|e| {
+        let e: BytecodeDecodeError = e;
+        BalExecutionError::Consensus(reth_consensus::ConsensusError::BlockAccessListInvalid(
+            format!("{e:?}"),
+        ))
+    })?;
+    Ok(Arc::new(received_bal_revm))
+}
+
+fn take_built_bal_and_log_divergence<DB>(
+    canonical_state: &mut State<DB>,
+    received_bal: &AlloyBal,
+) -> BlockAccessList
+where
+    DB: Database,
+{
+    let built_bal = canonical_state.take_built_alloy_bal().expect("with_bal_builder set");
+    if tracing::enabled!(target: "engine::tree::payload_processor::bal", tracing::Level::DEBUG) &&
+        built_bal.as_slice() != received_bal.as_slice()
+    {
+        let rebuilt = compute_block_access_list_hash(built_bal.as_slice());
+        let expected = compute_block_access_list_hash(received_bal.as_slice());
+        let div = received_bal.diff(built_bal.as_slice());
+        tracing::debug!(
+            target: "engine::tree::payload_processor::bal",
+            %rebuilt,
+            %expected,
+            %div,
+            "first BAL divergence",
+        );
+    }
+
+    built_bal
+}
+
+/// Closes the abort channel on drop, waking scoped workers before the scope exits.
+struct AbortGuard {
+    _tx: Sender<()>,
+}
+
+impl AbortGuard {
+    fn new() -> (Self, Receiver<()>) {
+        let (tx, rx) = crossbeam_channel::bounded(0);
+        (Self { _tx: tx }, rx)
+    }
+}
+
+/// Mirrors `EthBlockExecutor`'s cumulative gas admission check in the ordered BAL commit loop.
+#[derive(Debug)]
+struct BlockGasTracker {
+    block_gas_limit: u64,
+    enable_amsterdam_eip8037: bool,
+    tx_gas_limit_cap: Option<u64>,
+    cumulative_tx_gas_used: u64,
+    block_regular_gas_used: u64,
+}
+
+impl BlockGasTracker {
+    const fn new(
+        block_gas_limit: u64,
+        enable_amsterdam_eip8037: bool,
+        tx_gas_limit_cap: Option<u64>,
+    ) -> Self {
+        Self {
+            block_gas_limit,
+            enable_amsterdam_eip8037,
+            tx_gas_limit_cap,
+            cumulative_tx_gas_used: 0,
+            block_regular_gas_used: 0,
+        }
+    }
+
+    fn validate_tx_limit(&self, tx_gas_limit: u64) -> Result<(), BlockExecutionError> {
+        let block_gas_used = if self.enable_amsterdam_eip8037 {
+            self.block_regular_gas_used
+        } else {
+            self.cumulative_tx_gas_used
+        };
+        let block_available_gas = self.block_gas_limit.saturating_sub(block_gas_used);
+        let tx_min_gas_limit =
+            self.tx_gas_limit_cap.map_or(tx_gas_limit, |cap| tx_gas_limit.min(cap));
+
+        if tx_min_gas_limit > block_available_gas {
+            return Err(BlockValidationError::TransactionGasLimitMoreThanAvailableBlockGas {
+                transaction_gas_limit: tx_gas_limit,
+                block_available_gas,
+            }
+            .into());
+        }
+
+        Ok(())
+    }
+
+    const fn record_result<H>(&mut self, result: &ResultAndState<H>) {
+        let gas = result.result.gas();
+        self.cumulative_tx_gas_used = self.cumulative_tx_gas_used.saturating_add(gas.tx_gas_used());
+        self.block_regular_gas_used =
+            self.block_regular_gas_used.saturating_add(gas.block_regular_gas_used());
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy_consensus::{BlockHeader, Header};
+    use alloy_eip7928::{bal::Bal as AlloyBal, BlockAccessList};
+    use alloy_eips::{
+        eip2935::{HISTORY_STORAGE_ADDRESS, HISTORY_STORAGE_CODE},
+        eip4788::{BEACON_ROOTS_ADDRESS, BEACON_ROOTS_CODE},
+        eip7002::{WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_PREDEPLOY_CODE},
+    };
+    use alloy_primitives::{keccak256, B256, U256};
+    use reth_ethereum_primitives::{Block, BlockBody, Receipt, TransactionSigned};
+    use reth_evm_ethereum::EthEvmConfig;
+    use reth_primitives_traits::{Block as _, Recovered, SealedBlock};
+    use reth_revm::db::BundleState;
+    use reth_tasks::Runtime;
+    use revm::{
+        database::{CacheDB, EmptyDB},
+        state::{AccountInfo, Bytecode},
+    };
+    use std::convert::Infallible;
+
+    /// Wraps a `BlockAccessList` into an `Arc<DecodedBal>` by RLP-encoding the BAL.
+    fn to_arc_decoded(bal: BlockAccessList) -> Arc<DecodedBal> {
+        let alloy_bal: AlloyBal = bal.into();
+        let raw = alloy_rlp::encode(&alloy_bal).into();
+        Arc::new(DecodedBal::new(alloy_bal, raw))
+    }
+
+    /// Builds an in-memory canonical DB pre-populated with the post-Cancun system contracts
+    /// that `apply_pre_execution_changes` calls: beacon roots (EIP-4788), withdrawal requests
+    /// (EIP-7002), and historical block hashes (EIP-2935).
+    fn system_contracts_db() -> CacheDB<EmptyDB> {
+        let mut db = CacheDB::<EmptyDB>::new(Default::default());
+        db.insert_account_info(
+            BEACON_ROOTS_ADDRESS,
+            AccountInfo {
+                balance: U256::ZERO,
+                nonce: 1,
+                code_hash: keccak256(BEACON_ROOTS_CODE.clone()),
+                code: Some(Bytecode::new_raw(BEACON_ROOTS_CODE.clone())),
+                account_id: None,
+            },
+        );
+        db.insert_account_info(
+            WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS,
+            AccountInfo {
+                balance: U256::ZERO,
+                nonce: 1,
+                code_hash: keccak256(WITHDRAWAL_REQUEST_PREDEPLOY_CODE.clone()),
+                code: Some(Bytecode::new_raw(WITHDRAWAL_REQUEST_PREDEPLOY_CODE.clone())),
+                account_id: None,
+            },
+        );
+        db.insert_account_info(
+            HISTORY_STORAGE_ADDRESS,
+            AccountInfo {
+                balance: U256::ZERO,
+                nonce: 1,
+                code_hash: keccak256(HISTORY_STORAGE_CODE.clone()),
+                code: Some(Bytecode::new_raw(HISTORY_STORAGE_CODE.clone())),
+                account_id: None,
+            },
+        );
+        db
+    }
+
+    /// Builds a minimal sealed block (empty body, Amsterdam-ready header) for tests.
+    fn empty_amsterdam_block(header_bal_hash: B256) -> SealedBlock<Block> {
+        empty_amsterdam_block_with_gas_limit(header_bal_hash, 30_000_000)
+    }
+
+    fn empty_amsterdam_block_with_gas_limit(
+        header_bal_hash: B256,
+        gas_limit: u64,
+    ) -> SealedBlock<Block> {
+        let header = Header {
+            timestamp: 1,
+            number: 1,
+            gas_limit,
+            parent_beacon_block_root: Some(B256::ZERO),
+            withdrawals_root: Some(alloy_consensus::EMPTY_ROOT_HASH),
+            requests_hash: Some(alloy_eips::eip7685::EMPTY_REQUESTS_HASH),
+            excess_blob_gas: Some(0),
+            blob_gas_used: Some(0),
+            block_access_list_hash: Some(header_bal_hash),
+            ..Header::default()
+        };
+        let block = Block {
+            header,
+            body: BlockBody {
+                transactions: vec![],
+                ommers: vec![],
+                withdrawals: Some(vec![].into()),
+            },
+        };
+        block.seal_slow()
+    }
+
+    /// Runs only the canonical phases (pre-exec → post-exec, no txs) against a fresh
+    /// `system_contracts_db()` to compute the composed BAL a block produces. Used to build
+    /// the "reference" received BAL for the happy-path test below.
+    ///
+    /// This intentionally mirrors what `execute_block` does internally,
+    /// but without any hash check — the output is the BAL itself, not a pass/fail signal.
+    fn reference_bal_for_empty_block(evm_config: &EthEvmConfig) -> BlockAccessList {
+        use revm::database::State as RevmState;
+
+        let db = system_contracts_db();
+        let mut state =
+            RevmState::builder().with_database(db).with_bundle_update().with_bal_builder().build();
+
+        // Any header_bal_hash on the reference block is fine — we don't check it here.
+        let block = empty_amsterdam_block(B256::ZERO);
+        {
+            let mut executor =
+                evm_config.executor_for_block(&mut state, &block).expect("build executor");
+            executor.apply_pre_execution_changes().expect("pre-exec");
+            executor.evm_mut().db_mut().bump_bal_index();
+            executor.apply_post_execution_changes().expect("post-exec");
+        }
+        state.take_built_alloy_bal().expect("with_bal_builder was set")
+    }
+
+    #[test]
+    fn empty_block_happy_path_round_trip() {
+        // Two-pass end-to-end:
+        //   1. Build the canonical BAL an empty Amsterdam block produces (via
+        //      `reference_bal_for_empty_block`).
+        //   2. Hash it, stamp the header, and run `execute_block` with that BAL. Every check must
+        //      pass (A, B, D, F).
+        let evm_config = EthEvmConfig::mainnet();
+
+        let input_bal = reference_bal_for_empty_block(&evm_config);
+        let bal_hash = alloy_eip7928::compute_block_access_list_hash(&input_bal);
+        // Sanity: reference BAL is non-empty (system calls populated it).
+        assert!(!input_bal.is_empty(), "empty BAL means system calls didn't record state");
+
+        let block = empty_amsterdam_block(bal_hash);
+
+        let result = run_execute_block(
+            &Runtime::test(),
+            evm_config,
+            db_factory(system_contracts_db()),
+            to_arc_decoded(input_bal),
+            &block,
+            Vec::<Recovered<TransactionSigned>>::new(),
+        );
+
+        match result {
+            Ok(output) => {
+                assert!(output.receipts.is_empty(), "empty block → no receipts");
+            }
+            Err(e) => panic!("expected success, got {e:?}"),
+        }
+    }
+
+    fn db_factory(
+        db: CacheDB<EmptyDB>,
+    ) -> impl Fn() -> Result<CacheDB<EmptyDB>, BalExecutionError> + Sync {
+        move || Ok(db.clone())
+    }
+
+    fn tx_stream<Tx>(txs: Vec<Tx>) -> Receiver<(usize, Result<Tx, Infallible>)> {
+        let (tx, rx) = crossbeam_channel::unbounded();
+        for (index, transaction) in txs.into_iter().enumerate() {
+            tx.send((index, Ok(transaction))).unwrap();
+        }
+        rx
+    }
+
+    fn run_execute_block<Tx, DB, MakeDb>(
+        runtime: &Runtime,
+        evm_config: EthEvmConfig,
+        make_db: MakeDb,
+        input_bal: Arc<DecodedBal>,
+        block: &SealedBlock<Block>,
+        txs: Vec<Tx>,
+    ) -> Result<BlockExecutionOutput<Receipt>, BalExecutionError>
+    where
+        Tx: ExecutableTxFor<EthEvmConfig> + Send,
+        DB: Database + Send,
+        MakeDb: Fn() -> Result<DB, BalExecutionError> + Sync,
+    {
+        run_execute_block_full(runtime, evm_config, make_db, input_bal, block, txs)
+            .map(|(output, _)| output)
+    }
+
+    fn run_execute_block_full<Tx, DB, MakeDb>(
+        runtime: &Runtime,
+        evm_config: EthEvmConfig,
+        make_db: MakeDb,
+        input_bal: Arc<DecodedBal>,
+        block: &SealedBlock<Block>,
+        txs: Vec<Tx>,
+    ) -> Result<(BlockExecutionOutput<Receipt>, BlockAccessList), BalExecutionError>
+    where
+        Tx: ExecutableTxFor<EthEvmConfig> + Send,
+        DB: Database + Send,
+        MakeDb: Fn() -> Result<DB, BalExecutionError> + Sync,
+    {
+        let transaction_count = txs.len();
+        let (receipt_tx, _receipt_rx) = crossbeam_channel::unbounded();
+        let evm_env = evm_config.evm_env(block.header()).unwrap();
+        let execution_ctx = evm_config.context_for_block(block).unwrap();
+        let make_db = |_: bool| make_db();
+        execute_block(
+            runtime,
+            &evm_config,
+            &make_db,
+            input_bal,
+            evm_env,
+            execution_ctx,
+            transaction_count,
+            tx_stream(txs),
+            receipt_tx,
+        )
+        .map(|(output, _, built_bal)| (output, built_bal))
+    }
+
+    /// Inserts `AccountInfo { nonce: 0, balance }` for `addr` into the canonical DB.
+    fn insert_funded(db: &mut CacheDB<EmptyDB>, addr: alloy_primitives::Address, balance: U256) {
+        db.insert_account_info(
+            addr,
+            AccountInfo { nonce: 0, balance, code_hash: B256::ZERO, code: None, account_id: None },
+        );
+    }
+
+    /// Runs the canonical path on a block with real txs (no hash check) and returns the
+    /// composed BAL. Used to build the reference BAL for happy-path multi-tx tests.
+    fn reference_bal_for_block<Tx>(
+        evm_config: &EthEvmConfig,
+        mut db: CacheDB<EmptyDB>,
+        block: &SealedBlock<Block>,
+        txs: Vec<Tx>,
+    ) -> BlockAccessList
+    where
+        Tx: ExecutableTxFor<EthEvmConfig>,
+    {
+        use revm::database::State as RevmState;
+
+        let mut state = RevmState::builder()
+            .with_database(&mut db)
+            .with_bundle_update()
+            .with_bal_builder()
+            .build();
+
+        {
+            let mut executor =
+                evm_config.executor_for_block(&mut state, block).expect("build executor");
+            executor.apply_pre_execution_changes().expect("pre-exec");
+            for (i, tx) in txs.into_iter().enumerate() {
+                executor.evm_mut().db_mut().bump_bal_index();
+                executor
+                    .execute_transaction(tx)
+                    .unwrap_or_else(|e| panic!("tx {i} failed during reference build: {e:?}"));
+            }
+            executor.evm_mut().db_mut().bump_bal_index();
+            executor.apply_post_execution_changes().expect("post-exec");
+        }
+        state.take_built_alloy_bal().expect("with_bal_builder was set")
+    }
+
+    #[test]
+    fn multi_tx_happy_path_round_trip() {
+        // End-to-end with two value transfers from distinct senders to the same recipient.
+        //
+        // 1. Fund alice and bob in a fresh canonical DB.
+        // 2. Sign tx1 (alice → carol, 100 wei) and tx2 (bob → carol, 200 wei).
+        // 3. Build the reference BAL by running the block through a canonical executor with
+        //    `with_bal_builder`.
+        // 4. Feed that BAL into `execute_block` and assert 2 receipts + no rejections.
+        use alloy_consensus::TxLegacy;
+        use alloy_primitives::TxKind;
+        use reth_chainspec::MAINNET;
+        use reth_ethereum_primitives::Transaction;
+        use reth_primitives_traits::crypto::secp256k1::public_key_to_address;
+        use reth_testing_utils::generators::{generate_key, rng, sign_tx_with_key_pair};
+
+        let evm_config = EthEvmConfig::mainnet();
+        let carol: alloy_primitives::Address = alloy_primitives::Address::from([0xCA; 20]);
+        let sender_balance = U256::from(alloy_consensus::constants::ETH_TO_WEI);
+
+        // Generate keypairs + derive sender addresses.
+        let alice_kp = generate_key(&mut rng());
+        let alice = public_key_to_address(alice_kp.public_key());
+        let bob_kp = generate_key(&mut rng());
+        let bob = public_key_to_address(bob_kp.public_key());
+
+        // Pre-block DB: system contracts + funded senders.
+        let mut pre_block_db = system_contracts_db();
+        insert_funded(&mut pre_block_db, alice, sender_balance);
+        insert_funded(&mut pre_block_db, bob, sender_balance);
+
+        // Sign txs.
+        let chain_id = MAINNET.chain.id();
+        let gas_price = 1u128; // flat low price; block has no base fee in our test header.
+        let tx1 = sign_tx_with_key_pair(
+            alice_kp,
+            Transaction::Legacy(TxLegacy {
+                chain_id: Some(chain_id),
+                nonce: 0,
+                gas_price,
+                gas_limit: 21_000,
+                to: TxKind::Call(carol),
+                value: U256::from(100u64),
+                input: Default::default(),
+            }),
+        );
+        let tx2 = sign_tx_with_key_pair(
+            bob_kp,
+            Transaction::Legacy(TxLegacy {
+                chain_id: Some(chain_id),
+                nonce: 0,
+                gas_price,
+                gas_limit: 21_000,
+                to: TxKind::Call(carol),
+                value: U256::from(200u64),
+                input: Default::default(),
+            }),
+        );
+        let recovered1 = Recovered::new_unchecked(tx1, alice);
+        let recovered2 = Recovered::new_unchecked(tx2, bob);
+
+        // Reference BAL: run the block canonically through a separate executor.
+        let block_for_ref = empty_amsterdam_block(B256::ZERO);
+        let reference_bal = reference_bal_for_block::<Recovered<TransactionSigned>>(
+            &evm_config,
+            {
+                // Separate fresh DB for the reference run so we don't pollute canonical_db.
+                let mut db = system_contracts_db();
+                db.insert_account_info(
+                    alice,
+                    AccountInfo {
+                        nonce: 0,
+                        balance: sender_balance,
+                        code_hash: B256::ZERO,
+                        code: None,
+                        account_id: None,
+                    },
+                );
+                db.insert_account_info(
+                    bob,
+                    AccountInfo {
+                        nonce: 0,
+                        balance: sender_balance,
+                        code_hash: B256::ZERO,
+                        code: None,
+                        account_id: None,
+                    },
+                );
+                db
+            },
+            &block_for_ref,
+            vec![recovered1.clone(), recovered2.clone()],
+        );
+        assert!(!reference_bal.is_empty(), "expected BAL entries from pre-exec + txs");
+
+        let bal_hash = alloy_eip7928::compute_block_access_list_hash(&reference_bal);
+        let block = empty_amsterdam_block(bal_hash);
+
+        let result = run_execute_block(
+            &Runtime::test(),
+            evm_config,
+            db_factory(pre_block_db),
+            to_arc_decoded(reference_bal),
+            &block,
+            vec![recovered1, recovered2],
+        );
+
+        match result {
+            Ok(output) => {
+                assert_eq!(output.receipts.len(), 2, "expected 2 receipts");
+                assert!(output.gas_used >= 2 * 21_000, "expected at least 42k gas used");
+            }
+            Err(e) => panic!("expected success, got {e:?}"),
+        }
+    }
+
+    // ============================================================================
+    // Shadow-mode harness — runs a block through the serial `BasicBlockExecutor`
+    // and the BAL path, asserts byte-equal outputs.
+    // ============================================================================
+
+    /// Output of one path in a shadow run. Both serial and BAL paths produce this shape so
+    /// the harness can compare field-by-field.
+    #[derive(Debug)]
+    struct ShadowOutput {
+        bundle_state: BundleState,
+        receipts: Vec<reth_ethereum_primitives::Receipt>,
+        gas_used: u64,
+        requests: alloy_eips::eip7685::Requests,
+    }
+
+    /// Runs the block through the serial path and captures its full output.
+    ///
+    /// Uses a manual state + executor (not `BasicBlockExecutor::execute_one`) so we can both
+    /// (a) capture the composed BAL for the BAL-path input and (b) pull the bundle out after.
+    fn run_serial_path(
+        evm_config: &EthEvmConfig,
+        canonical_db: CacheDB<EmptyDB>,
+        block: &SealedBlock<Block>,
+        txs: &[Recovered<TransactionSigned>],
+    ) -> (ShadowOutput, BlockAccessList) {
+        use revm::database::State as RevmState;
+
+        let mut state = RevmState::builder()
+            .with_database(canonical_db)
+            .with_bundle_update()
+            .with_bal_builder()
+            .build();
+
+        let block_result = {
+            let mut executor =
+                evm_config.executor_for_block(&mut state, block).expect("build serial executor");
+            executor.apply_pre_execution_changes().expect("serial pre-exec");
+            for (i, tx) in txs.iter().cloned().enumerate() {
+                executor.evm_mut().db_mut().bump_bal_index();
+                executor
+                    .execute_transaction(tx)
+                    .unwrap_or_else(|e| panic!("serial tx {i} failed: {e:?}"));
+            }
+            executor.evm_mut().db_mut().bump_bal_index();
+            executor.apply_post_execution_changes().expect("serial post-exec")
+        };
+
+        let bal = state.take_built_alloy_bal().expect("with_bal_builder was set");
+        state.merge_transitions(BundleRetention::Reverts);
+        let bundle_state = state.take_bundle();
+
+        (
+            ShadowOutput {
+                bundle_state,
+                receipts: block_result.receipts,
+                gas_used: block_result.gas_used,
+                requests: block_result.requests,
+            },
+            bal,
+        )
+    }
+
+    /// Shadow harness. Runs the block through both paths; asserts byte-equal outputs.
+    fn assert_shadow_equal(
+        evm_config: EthEvmConfig,
+        canonical_db_template: CacheDB<EmptyDB>,
+        block_header_only: SealedBlock<Block>,
+        txs: Vec<Recovered<TransactionSigned>>,
+    ) {
+        // Serial run: also produces the reference BAL we'll feed to the BAL path.
+        let (serial, reference_bal) =
+            run_serial_path(&evm_config, canonical_db_template.clone(), &block_header_only, &txs);
+
+        // BAL path: stamp the hash of the reference BAL onto the header.
+        let bal_hash = alloy_eip7928::compute_block_access_list_hash(&reference_bal);
+        let block =
+            empty_amsterdam_block_with_gas_limit(bal_hash, block_header_only.header().gas_limit());
+
+        let bal_out = run_execute_block(
+            &Runtime::test(),
+            evm_config,
+            db_factory(canonical_db_template),
+            to_arc_decoded(reference_bal),
+            &block,
+            txs,
+        )
+        .unwrap_or_else(|e| panic!("BAL path failed: {e:?}"));
+
+        // Byte-equal assertions. Any divergence surfaces the specific field that broke.
+        assert_eq!(
+            serial.receipts, bal_out.receipts,
+            "receipts diverge between serial and BAL paths",
+        );
+        assert_eq!(
+            serial.gas_used, bal_out.gas_used,
+            "gas_used differs: serial {} vs bal {}",
+            serial.gas_used, bal_out.gas_used,
+        );
+        assert_eq!(
+            serial.requests, bal_out.requests,
+            "requests (EIP-7685) diverge between serial and BAL paths",
+        );
+        assert_eq!(
+            serial.bundle_state, bal_out.state,
+            "bundle_state diverges — the canonical state transitions don't match",
+        );
+    }
+
+    #[test]
+    fn shadow_empty_block() {
+        // System calls only — no txs. Both paths should produce identical system-call
+        // side effects in their BundleState (beacon roots storage, history storage, etc.).
+        assert_shadow_equal(
+            EthEvmConfig::mainnet(),
+            system_contracts_db(),
+            empty_amsterdam_block(B256::ZERO),
+            Vec::new(),
+        );
+    }
+
+    #[test]
+    fn shadow_multi_value_transfer() {
+        // Two senders → same recipient. Byte-equal across paths means: worker-produced
+        // diffs commit identically to a directly-executed serial path.
+        use alloy_consensus::TxLegacy;
+        use alloy_primitives::TxKind;
+        use reth_chainspec::MAINNET;
+        use reth_ethereum_primitives::Transaction;
+        use reth_primitives_traits::crypto::secp256k1::public_key_to_address;
+        use reth_testing_utils::generators::{generate_key, rng, sign_tx_with_key_pair};
+
+        let evm_config = EthEvmConfig::mainnet();
+        let carol: alloy_primitives::Address = alloy_primitives::Address::from([0xCA; 20]);
+        let sender_balance = U256::from(alloy_consensus::constants::ETH_TO_WEI);
+
+        let alice_kp = generate_key(&mut rng());
+        let alice = public_key_to_address(alice_kp.public_key());
+        let bob_kp = generate_key(&mut rng());
+        let bob = public_key_to_address(bob_kp.public_key());
+
+        let mut db = system_contracts_db();
+        insert_funded(&mut db, alice, sender_balance);
+        insert_funded(&mut db, bob, sender_balance);
+
+        let chain_id = MAINNET.chain.id();
+        let make_tx = |kp, to, value, nonce: u64| {
+            sign_tx_with_key_pair(
+                kp,
+                Transaction::Legacy(TxLegacy {
+                    chain_id: Some(chain_id),
+                    nonce,
+                    gas_price: 1,
+                    gas_limit: 21_000,
+                    to: TxKind::Call(to),
+                    value: U256::from(value),
+                    input: Default::default(),
+                }),
+            )
+        };
+        let tx1 = Recovered::new_unchecked(make_tx(alice_kp, carol, 100u64, 0), alice);
+        let tx2 = Recovered::new_unchecked(make_tx(bob_kp, carol, 200u64, 0), bob);
+
+        assert_shadow_equal(evm_config, db, empty_amsterdam_block(B256::ZERO), vec![tx1, tx2]);
+    }
+
+    #[test]
+    fn rejects_tx_gas_limit_that_exceeds_remaining_block_gas() {
+        // Each worker sees an empty block, so both transactions fit individually. The ordered
+        // commit loop must still reject tx2 because tx1's committed gas leaves too little
+        // block gas for tx2's gas limit.
+        use alloy_consensus::TxLegacy;
+        use alloy_evm::block::BlockValidationError;
+        use alloy_primitives::TxKind;
+        use reth_chainspec::MAINNET;
+        use reth_ethereum_primitives::Transaction;
+        use reth_primitives_traits::crypto::secp256k1::public_key_to_address;
+        use reth_testing_utils::generators::{generate_key, rng, sign_tx_with_key_pair};
+
+        let evm_config = EthEvmConfig::mainnet();
+        let carol: alloy_primitives::Address = alloy_primitives::Address::from([0xCA; 20]);
+        let sender_balance = U256::from(alloy_consensus::constants::ETH_TO_WEI);
+        let block_gas_limit = 1_000_000;
+        let tx_gas_limit = 990_000;
+
+        let alice_kp = generate_key(&mut rng());
+        let alice = public_key_to_address(alice_kp.public_key());
+        let bob_kp = generate_key(&mut rng());
+        let bob = public_key_to_address(bob_kp.public_key());
+
+        let mut pre_block_db = system_contracts_db();
+        insert_funded(&mut pre_block_db, alice, sender_balance);
+        insert_funded(&mut pre_block_db, bob, sender_balance);
+
+        let chain_id = MAINNET.chain.id();
+        let make_tx = |kp, value| {
+            sign_tx_with_key_pair(
+                kp,
+                Transaction::Legacy(TxLegacy {
+                    chain_id: Some(chain_id),
+                    nonce: 0,
+                    gas_price: 1,
+                    gas_limit: tx_gas_limit,
+                    to: TxKind::Call(carol),
+                    value: U256::from(value),
+                    input: Default::default(),
+                }),
+            )
+        };
+        let tx1 = Recovered::new_unchecked(make_tx(alice_kp, 100u64), alice);
+        let tx2 = Recovered::new_unchecked(make_tx(bob_kp, 200u64), bob);
+
+        // Build the reference BAL under a generous gas limit so both workers can execute.
+        // Replaying the same BAL under `block_gas_limit` below should reject in the ordered
+        // commit loop before tx2 is committed.
+        let reference_block = empty_amsterdam_block(B256::ZERO);
+        let reference_bal = reference_bal_for_block(
+            &evm_config,
+            pre_block_db.clone(),
+            &reference_block,
+            vec![tx1.clone(), tx2.clone()],
+        );
+        let bal_hash = alloy_eip7928::compute_block_access_list_hash(&reference_bal);
+        let low_gas_block = empty_amsterdam_block_with_gas_limit(bal_hash, block_gas_limit);
+
+        let result = run_execute_block(
+            &Runtime::test(),
+            evm_config,
+            db_factory(pre_block_db),
+            to_arc_decoded(reference_bal),
+            &low_gas_block,
+            vec![tx1, tx2],
+        );
+
+        match result {
+            Err(BalExecutionError::Execution(err)) => assert!(matches!(
+                err.as_validation(),
+                Some(BlockValidationError::TransactionGasLimitMoreThanAvailableBlockGas { .. })
+            )),
+            Err(err) => panic!("expected block gas validation error, got {err:?}"),
+            Ok(_) => panic!("expected block gas validation error, got Ok"),
+        }
+    }
+
+    #[test]
+    fn shadow_tx_with_revert() {
+        // A tx that reverts in a deployed contract. Both paths must produce identical receipts
+        // (success = false, gas charged, state rolled back except for gas payment + nonce bump).
+        //
+        // Deploys `0x60006000fd` (PUSH1 0 PUSH1 0 REVERT) at `revert_contract`. Sender calls
+        // it; the call reverts; fees + nonce still apply.
+        use alloy_consensus::TxLegacy;
+        use alloy_primitives::{Bytes, TxKind};
+        use reth_chainspec::MAINNET;
+        use reth_ethereum_primitives::Transaction;
+        use reth_primitives_traits::crypto::secp256k1::public_key_to_address;
+        use reth_testing_utils::generators::{generate_key, rng, sign_tx_with_key_pair};
+        use revm::primitives::keccak256;
+
+        let evm_config = EthEvmConfig::mainnet();
+        let revert_contract: alloy_primitives::Address =
+            alloy_primitives::Address::from([0xDE; 20]);
+        let sender_balance = U256::from(alloy_consensus::constants::ETH_TO_WEI);
+
+        let alice_kp = generate_key(&mut rng());
+        let alice = public_key_to_address(alice_kp.public_key());
+
+        // Deploy the revert contract bytecode.
+        let revert_code: Bytes = Bytes::from_static(&[0x60, 0x00, 0x60, 0x00, 0xfd]);
+        let code_hash = keccak256(&revert_code);
+        let mut db = system_contracts_db();
+        insert_funded(&mut db, alice, sender_balance);
+        db.insert_account_info(
+            revert_contract,
+            AccountInfo {
+                nonce: 1,
+                balance: U256::ZERO,
+                code_hash,
+                code: Some(Bytecode::new_raw(revert_code)),
+                account_id: None,
+            },
+        );
+
+        let tx = Recovered::new_unchecked(
+            sign_tx_with_key_pair(
+                alice_kp,
+                Transaction::Legacy(TxLegacy {
+                    chain_id: Some(MAINNET.chain.id()),
+                    nonce: 0,
+                    gas_price: 1,
+                    gas_limit: 50_000,
+                    to: TxKind::Call(revert_contract),
+                    value: U256::ZERO,
+                    input: Default::default(),
+                }),
+            ),
+            alice,
+        );
+
+        assert_shadow_equal(evm_config, db, empty_amsterdam_block(B256::ZERO), vec![tx]);
+    }
+
+    #[test]
+    fn shadow_tx_with_sstore() {
+        // Tx calls a deployed contract that does `SSTORE(0, 0x42)`. The storage write must
+        // commit identically across serial and BAL paths even though the canonical state applies
+        // a diff produced by a worker EVM.
+        //
+        // Bytecode: PUSH1 0x42, PUSH1 0x00, SSTORE, STOP → `0x60 0x42 0x60 0x00 0x55 0x00`.
+        use alloy_consensus::TxLegacy;
+        use alloy_primitives::{Bytes, TxKind};
+        use reth_chainspec::MAINNET;
+        use reth_ethereum_primitives::Transaction;
+        use reth_primitives_traits::crypto::secp256k1::public_key_to_address;
+        use reth_testing_utils::generators::{generate_key, rng, sign_tx_with_key_pair};
+        use revm::primitives::keccak256;
+
+        let evm_config = EthEvmConfig::mainnet();
+        let sstore_contract: alloy_primitives::Address =
+            alloy_primitives::Address::from([0x55; 20]);
+        let sender_balance = U256::from(alloy_consensus::constants::ETH_TO_WEI);
+
+        let alice_kp = generate_key(&mut rng());
+        let alice = public_key_to_address(alice_kp.public_key());
+
+        // Deploy the SSTORE contract.
+        let sstore_code: Bytes = Bytes::from_static(&[0x60, 0x42, 0x60, 0x00, 0x55, 0x00]);
+        let code_hash = keccak256(&sstore_code);
+        let mut db = system_contracts_db();
+        insert_funded(&mut db, alice, sender_balance);
+        db.insert_account_info(
+            sstore_contract,
+            AccountInfo {
+                nonce: 1,
+                balance: U256::ZERO,
+                code_hash,
+                code: Some(Bytecode::new_raw(sstore_code)),
+                account_id: None,
+            },
+        );
+
+        let tx = Recovered::new_unchecked(
+            sign_tx_with_key_pair(
+                alice_kp,
+                Transaction::Legacy(TxLegacy {
+                    chain_id: Some(MAINNET.chain.id()),
+                    nonce: 0,
+                    gas_price: 1,
+                    gas_limit: 100_000,
+                    to: TxKind::Call(sstore_contract),
+                    value: U256::ZERO,
+                    input: Default::default(),
+                }),
+            ),
+            alice,
+        );
+
+        assert_shadow_equal(evm_config, db, empty_amsterdam_block(B256::ZERO), vec![tx]);
+    }
+
+    #[test]
+    fn returns_built_bal_for_final_hash_mismatch() {
+        // Build the BAL an empty block actually produces, then append a phantom address
+        // that execution never touches. The rebuilt BAL omits it, and the outer consensus
+        // validator is responsible for comparing that rebuilt hash to the header commitment.
+        use alloy_eip7928::AccountChanges;
+
+        let evm_config = EthEvmConfig::mainnet();
+
+        // Real BAL the block would produce.
+        let real_bal = reference_bal_for_empty_block(&evm_config);
+        assert!(!real_bal.is_empty(), "reference BAL must be non-empty");
+
+        // Tamper: append a phantom address not accessed during execution.
+        let phantom = alloy_primitives::Address::from([0xFF; 20]);
+        let mut tampered_entries: Vec<AccountChanges> = real_bal;
+        tampered_entries.push(AccountChanges::new(phantom));
+        let tampered_bal: alloy_eip7928::bal::Bal = alloy_eip7928::bal::Bal::new(tampered_entries);
+
+        // Stamp the tampered BAL's hash on the block header.
+        let tampered_block_access_list: BlockAccessList = tampered_bal.clone().into();
+        let tampered_hash =
+            alloy_eip7928::compute_block_access_list_hash(&tampered_block_access_list);
+        let block = empty_amsterdam_block(tampered_hash);
+
+        let received = {
+            let raw = alloy_rlp::encode(&tampered_bal).into();
+            Arc::new(DecodedBal::new(tampered_bal, raw))
+        };
+
+        let result = run_execute_block_full(
+            &Runtime::test(),
+            evm_config,
+            db_factory(system_contracts_db()),
+            received,
+            &block,
+            Vec::<Recovered<TransactionSigned>>::new(),
+        );
+
+        match result {
+            Ok((_, built_bal)) => {
+                let rebuilt = alloy_eip7928::compute_block_access_list_hash(&built_bal);
+                assert_ne!(rebuilt, tampered_hash, "rebuilt and header hashes must differ");
+            }
+            Err(e) => panic!("expected success with rebuilt BAL, got {e:?}"),
+        }
+    }
+
+    #[test]
+    fn canonical_make_db_failure() {
+        // A make_db that always fails must surface as Provider before any workers are
+        // spawned or the BAL is processed.
+        let evm_config = EthEvmConfig::mainnet();
+        let block = empty_amsterdam_block(B256::ZERO);
+
+        let failing_make_db = || -> Result<CacheDB<EmptyDB>, BalExecutionError> {
+            Err(reth_provider::ProviderError::BestBlockNotFound.into())
+        };
+
+        let result = run_execute_block(
+            &Runtime::test(),
+            evm_config,
+            failing_make_db,
+            to_arc_decoded(BlockAccessList::default()),
+            &block,
+            Vec::<Recovered<TransactionSigned>>::new(),
+        );
+
+        assert!(
+            matches!(result, Err(BalExecutionError::Provider(_))),
+            "expected Provider error from canonical make_db failure, got {result:?}",
+        );
+    }
+
+    #[test]
+    fn worker_tx_recovery_error_becomes_other_error() {
+        // A tx recovery failure fed into the worker channel must surface as
+        // BalExecutionError::Other. Uses execute_block directly since tx_stream hardcodes
+        // Infallible and cannot inject errors.
+        let evm_config = EthEvmConfig::mainnet();
+        let block = empty_amsterdam_block(B256::ZERO);
+
+        let (tx_tx, tx_rx) = crossbeam_channel::unbounded::<(
+            usize,
+            Result<Recovered<TransactionSigned>, std::io::Error>,
+        )>();
+        tx_tx.send((0, Err(std::io::Error::other("sig fail")))).unwrap();
+        drop(tx_tx);
+
+        let (receipt_tx, _receipt_rx) = crossbeam_channel::unbounded();
+        let evm_env = evm_config.evm_env(block.header()).unwrap();
+        let execution_ctx = evm_config.context_for_block(&block).unwrap();
+        let make_db = db_factory(system_contracts_db());
+        let make_db = |_: bool| make_db();
+
+        let result = execute_block(
+            &Runtime::test(),
+            &evm_config,
+            &make_db,
+            to_arc_decoded(BlockAccessList::default()),
+            evm_env,
+            execution_ctx,
+            1, // transaction_count = 1 → exactly one worker spawned
+            tx_rx,
+            receipt_tx,
+        );
+
+        assert!(
+            matches!(result, Err(BalExecutionError::Other(_))),
+            "expected Other error from tx recovery failure, got {result:?}",
+        );
+    }
+
+    #[test]
+    fn gas_tracker_non_amsterdam_uses_cumulative_gas() {
+        // All-state-gas results keep block_regular_gas_used at 0, so a second tx that fits
+        // within the block limit but not the remaining cumulative budget proves that
+        // non-Amsterdam reads cumulative_tx_gas_used while Amsterdam does not.
+        use revm::context::result::{
+            ExecResultAndState, ExecutionResult, Output, ResultGas, SuccessReason,
+        };
+        use revm_state::EvmState;
+
+        let block_gas_limit = 1_000_000u64;
+        let first_tx_gas = 600_000u64;
+        let second_tx_gas_limit = 500_000u64; // fits in total limit but not after cumulative deduction
+
+        let gas = ResultGas::new_with_state_gas(first_tx_gas, 0, 0, first_tx_gas);
+        let fake_result: ResultAndState<revm::context::result::HaltReason> =
+            ExecResultAndState::new(
+                ExecutionResult::Success {
+                    reason: SuccessReason::Return,
+                    gas,
+                    logs: vec![],
+                    output: Output::Call(Default::default()),
+                },
+                EvmState::default(),
+            );
+
+        // Non-Amsterdam: block_available_gas = 1_000_000 - 600_000 = 400_000 → reject 500_000.
+        let mut non_amsterdam = BlockGasTracker::new(block_gas_limit, false, None);
+        non_amsterdam.record_result(&fake_result);
+        assert!(
+            non_amsterdam.validate_tx_limit(second_tx_gas_limit).is_err(),
+            "non-Amsterdam tracker must reject tx that exceeds remaining cumulative gas",
+        );
+
+        // Amsterdam: block_available_gas = 1_000_000 - 0 = 1_000_000 → accept 500_000.
+        let mut amsterdam = BlockGasTracker::new(block_gas_limit, true, None);
+        amsterdam.record_result(&fake_result);
+        assert!(
+            amsterdam.validate_tx_limit(second_tx_gas_limit).is_ok(),
+            "Amsterdam tracker must accept the same tx since block_regular_gas_used stays 0",
+        );
+    }
+
+    #[test]
+    fn gas_tracker_caps_oversized_tx_gas_limit_at_tx_gas_limit_cap() {
+        // A tx with gas_limit above TX_GAS_LIMIT_CAP (EIP-7825) is admitted when the
+        // capped value fits in the remaining block gas and rejected when it does not.
+        use revm::{
+            context::result::{
+                ExecResultAndState, ExecutionResult, Output, ResultGas, SuccessReason,
+            },
+            primitives::eip7825::TX_GAS_LIMIT_CAP,
+        };
+        use revm_state::EvmState;
+
+        let block_gas_limit = 30_000_000u64;
+        let oversized = TX_GAS_LIMIT_CAP + 1_000_000; // 17_777_216 — above the cap
+
+        // Case 1: fresh block, no prior gas consumed.
+        // tx_min_gas_limit = TX_GAS_LIMIT_CAP (16_777_216) ≤ block_available_gas (30M) → Ok.
+        let tracker = BlockGasTracker::new(block_gas_limit, false, Some(TX_GAS_LIMIT_CAP));
+        assert!(
+            tracker.validate_tx_limit(oversized).is_ok(),
+            "oversized tx must pass when capped limit fits in block gas",
+        );
+
+        // Case 2: prior tx consumed 20M, leaving 10M available.
+        // tx_min_gas_limit = TX_GAS_LIMIT_CAP (16_777_216) > block_available_gas (10M) → Err.
+        let prior_gas = 20_000_000u64;
+        let gas = ResultGas::new_with_state_gas(prior_gas, 0, 0, prior_gas);
+        let fake_result: ResultAndState<revm::context::result::HaltReason> =
+            ExecResultAndState::new(
+                ExecutionResult::Success {
+                    reason: SuccessReason::Return,
+                    gas,
+                    logs: vec![],
+                    output: Output::Call(Default::default()),
+                },
+                EvmState::default(),
+            );
+
+        let mut tracker = BlockGasTracker::new(block_gas_limit, false, Some(TX_GAS_LIMIT_CAP));
+        tracker.record_result(&fake_result);
+        assert!(
+            tracker.validate_tx_limit(oversized).is_err(),
+            "oversized tx must be rejected when capped limit exceeds remaining block gas",
+        );
+    }
+}
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/mod.rs b/crates/engine/tree/src/tree/payload_processor/bal/mod.rs
new file mode 100644
index 00000000000..beef5832931
--- /dev/null
+++ b/crates/engine/tree/src/tree/payload_processor/bal/mod.rs
@@ -0,0 +1,18 @@
+//! BAL-driven parallel block execution.
+//!
+//! The engine uses this path when an Amsterdam block carries a decoded EIP-7928
+//! Block-Level Access List (BAL). Workers execute transactions against revm's BAL state. The
+//! main thread commits worker results to a canonical executor in transaction order.
+//!
+//! Consensus validation checks the BAL item-cost bound before this path runs. This path validates
+//! the rebuilt block-level BAL hash after post-execution. It does not yet run per-transaction
+//! fragment checks. It does not yet report rich undeclared-access diagnostics.
+
+mod ordered_outputs;
+mod worker;
+
+pub mod error;
+pub mod execute;
+
+pub use error::BalExecutionError;
+pub use execute::execute_block;
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/ordered_outputs.rs b/crates/engine/tree/src/tree/payload_processor/bal/ordered_outputs.rs
new file mode 100644
index 00000000000..bed19ef85f4
--- /dev/null
+++ b/crates/engine/tree/src/tree/payload_processor/bal/ordered_outputs.rs
@@ -0,0 +1,210 @@
+//! Ordering adapter for speculative BAL worker results.
+
+use super::{
+    worker::{BalWorkerError, BalWorkerOutput},
+    BalExecutionError,
+};
+use crossbeam_channel::Receiver;
+
+#[derive(Debug, thiserror::Error)]
+pub(super) enum OrderedWorkerOutputError {
+    /// A worker returned an error.
+    #[error(transparent)]
+    Worker(#[from] BalWorkerError),
+    /// The result channel closed before every transaction had an output.
+    #[error("BAL worker result channel closed while waiting for ordered outputs")]
+    ResultChannelClosed,
+}
+
+impl From<OrderedWorkerOutputError> for BalExecutionError {
+    fn from(err: OrderedWorkerOutputError) -> Self {
+        match err {
+            OrderedWorkerOutputError::Worker(err) => err.into(),
+            other => Self::other(other),
+        }
+    }
+}
+
+/// Returns a blocking iterator over worker outputs in transaction order.
+///
+/// Workers may finish transactions out of order. This adapter buffers future-indexed outputs and
+/// yields each output only when every earlier transaction has been yielded. It owns no execution
+/// state and performs no canonical commit work.
+///
+/// Behavior:
+/// - each yielded `Ok` output has the next transaction index
+/// - worker errors are forwarded unchanged
+/// - closed channels before `total` outputs yield `Err`
+/// - out-of-bounds and duplicate indices panic because they violate the internal worker/dispatcher
+///   index invariant
+/// - after the first error, the iterator is exhausted
+pub(super) fn ordered_worker_outputs<R>(
+    result_rx: &Receiver<Result<BalWorkerOutput<R>, BalWorkerError>>,
+    total: usize,
+) -> impl Iterator<Item = Result<BalWorkerOutput<R>, OrderedWorkerOutputError>> + '_ {
+    OrderedWorkerOutputs::new(result_rx, total)
+}
+
+struct OrderedWorkerOutputs<'a, R> {
+    result_rx: &'a Receiver<Result<BalWorkerOutput<R>, BalWorkerError>>,
+    pending: Vec<Option<BalWorkerOutput<R>>>,
+    next: usize,
+    total: usize,
+    failed: bool,
+}
+
+impl<'a, R> OrderedWorkerOutputs<'a, R> {
+    fn new(
+        result_rx: &'a Receiver<Result<BalWorkerOutput<R>, BalWorkerError>>,
+        total: usize,
+    ) -> Self {
+        Self {
+            result_rx,
+            pending: (0..total).map(|_| None).collect(),
+            next: 0,
+            total,
+            failed: false,
+        }
+    }
+}
+
+impl<R> Iterator for OrderedWorkerOutputs<'_, R> {
+    type Item = Result<BalWorkerOutput<R>, OrderedWorkerOutputError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.failed || self.next >= self.total {
+            return None;
+        }
+
+        loop {
+            if let Some(output) = self.pending[self.next].take() {
+                self.next += 1;
+                return Some(Ok(output));
+            }
+
+            let output = match self.result_rx.recv() {
+                Ok(Ok(output)) => output,
+                Ok(Err(err)) => {
+                    self.failed = true;
+                    return Some(Err(err.into()));
+                }
+                Err(_) => {
+                    self.failed = true;
+                    return Some(Err(OrderedWorkerOutputError::ResultChannelClosed));
+                }
+            };
+
+            let index = output.index;
+            assert!(
+                index < self.total,
+                "BAL worker returned out-of-bounds transaction index {index}; total={}",
+                self.total
+            );
+            assert!(
+                index >= self.next && self.pending[index].is_none(),
+                "BAL worker returned duplicate transaction index {index}",
+            );
+
+            self.pending[index] = Some(output);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::tree::payload_processor::bal::BalExecutionError;
+    use alloy_primitives::Address;
+
+    fn output(index: usize, result: u64) -> BalWorkerOutput<u64> {
+        BalWorkerOutput { index, signer: Address::ZERO, tx_gas_limit: 0, result }
+    }
+
+    fn expect_err_contains<R>(
+        result: Result<BalWorkerOutput<R>, OrderedWorkerOutputError>,
+        text: &str,
+    ) {
+        let Err(err) = result else {
+            panic!("expected ordered worker output error");
+        };
+        assert!(err.to_string().contains(text), "expected `{err}` to contain `{text}`");
+    }
+
+    #[test]
+    fn yields_outputs_in_transaction_order() {
+        let (tx, rx) = crossbeam_channel::unbounded();
+        tx.send(Ok(output(2, 20))).unwrap();
+        tx.send(Ok(output(0, 0))).unwrap();
+        tx.send(Ok(output(1, 10))).unwrap();
+        drop(tx);
+
+        let results = ordered_worker_outputs(&rx, 3)
+            .map(|output| output.expect("ordered output").result)
+            .collect::<Vec<_>>();
+
+        assert_eq!(results, vec![0, 10, 20]);
+    }
+
+    #[test]
+    fn forwards_worker_errors_and_then_stops() {
+        let (tx, rx) = crossbeam_channel::unbounded();
+        tx.send(Err(BalWorkerError::Setup(BalExecutionError::Execution(
+            alloy_evm::block::BlockExecutionError::msg("worker failed"),
+        ))))
+        .unwrap();
+        drop(tx);
+
+        let mut outputs = ordered_worker_outputs::<u64>(&rx, 1);
+
+        expect_err_contains(outputs.next().expect("first item"), "worker failed");
+        assert!(outputs.next().is_none());
+    }
+
+    #[test]
+    fn rejects_closed_channel_before_all_outputs_arrive() {
+        let (tx, rx) = crossbeam_channel::unbounded();
+        drop(tx);
+
+        let mut outputs = ordered_worker_outputs::<u64>(&rx, 1);
+
+        expect_err_contains(outputs.next().expect("first item"), "waiting for ordered outputs");
+        assert!(outputs.next().is_none());
+    }
+
+    #[test]
+    #[should_panic(expected = "out-of-bounds transaction index")]
+    fn panics_on_out_of_bounds_index() {
+        let (tx, rx) = crossbeam_channel::unbounded();
+        tx.send(Ok(output(1, 10))).unwrap();
+        drop(tx);
+
+        let mut outputs = ordered_worker_outputs(&rx, 1);
+        let _ = outputs.next();
+    }
+
+    #[test]
+    #[should_panic(expected = "duplicate transaction index")]
+    fn panics_on_duplicate_pending_index() {
+        let (tx, rx) = crossbeam_channel::unbounded();
+        tx.send(Ok(output(1, 10))).unwrap();
+        tx.send(Ok(output(1, 11))).unwrap();
+        drop(tx);
+
+        let mut outputs = ordered_worker_outputs(&rx, 2);
+        let _ = outputs.next();
+    }
+
+    #[test]
+    #[should_panic(expected = "duplicate transaction index")]
+    fn panics_on_duplicate_already_yielded_index() {
+        let (tx, rx) = crossbeam_channel::unbounded();
+        tx.send(Ok(output(0, 0))).unwrap();
+        tx.send(Ok(output(0, 1))).unwrap();
+        drop(tx);
+
+        let mut outputs = ordered_worker_outputs(&rx, 2);
+
+        assert_eq!(outputs.next().expect("first item").expect("first output").result, 0);
+        let _ = outputs.next();
+    }
+}
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/worker.rs b/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
new file mode 100644
index 00000000000..8801589a01d
--- /dev/null
+++ b/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
@@ -0,0 +1,114 @@
+use super::BalExecutionError;
+use alloy_consensus::Transaction;
+use alloy_eip7928::BlockAccessIndex;
+use alloy_evm::{
+    block::{BlockExecutionError, BlockExecutor, BlockExecutorFactory},
+    Evm,
+};
+use alloy_primitives::Address;
+use crossbeam_channel::{Receiver, Sender};
+use reth_evm::{execute::ExecutableTxFor, ConfigureEvm, Database, EvmEnvFor, ExecutionCtxFor};
+use revm::database::State;
+use revm_state::bal::Bal as RevmBal;
+use std::sync::Arc;
+
+#[derive(Debug, thiserror::Error)]
+pub(super) enum BalWorkerError {
+    /// Worker state or provider setup failed.
+    #[error("BAL worker setup failed: {0}")]
+    Setup(#[source] BalExecutionError),
+    /// Transaction recovery or conversion failed before EVM execution.
+    #[error("BAL worker transaction conversion failed: {0}")]
+    Transaction(Box<dyn core::error::Error + Send + Sync + 'static>),
+    /// EVM transaction execution failed.
+    #[error("BAL worker EVM execution failed: {0}")]
+    Execution(BlockExecutionError),
+}
+
+impl From<BalWorkerError> for BalExecutionError {
+    fn from(err: BalWorkerError) -> Self {
+        match err {
+            BalWorkerError::Setup(err) => err,
+            BalWorkerError::Transaction(err) => Self::Other(err),
+            BalWorkerError::Execution(err) => Self::Execution(err),
+        }
+    }
+}
+
+pub(super) struct BalWorkerOutput<R> {
+    pub(super) index: usize,
+    pub(super) signer: Address,
+    pub(super) tx_gas_limit: u64,
+    pub(super) result: R,
+}
+
+type WorkerExecutorResult<Cfg> =
+    <<Cfg as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::TxExecutionResult;
+
+type WorkerResultSender<Cfg> =
+    Sender<Result<BalWorkerOutput<WorkerExecutorResult<Cfg>>, BalWorkerError>>;
+
+#[expect(clippy::too_many_arguments)]
+pub(super) fn spawn_worker<'scope, Evm, Tx, Err, DB, MakeDb>(
+    scope: &rayon::Scope<'scope>,
+    tx_rx: Receiver<(usize, Result<Tx, Err>)>,
+    abort_rx: Receiver<()>,
+    result_tx: WorkerResultSender<Evm>,
+    evm_config: &'scope Evm,
+    make_db: &'scope MakeDb,
+    received_bal_revm: Arc<RevmBal>,
+    evm_env: EvmEnvFor<Evm>,
+    ctx: ExecutionCtxFor<'scope, Evm>,
+) where
+    Evm: ConfigureEvm + 'scope,
+    Tx: ExecutableTxFor<Evm> + Send + 'scope,
+    Err: core::error::Error + Send + Sync + 'static,
+    DB: Database + Send + 'scope,
+    MakeDb: Fn(bool) -> Result<DB, BalExecutionError> + Sync + 'scope,
+{
+    scope.spawn(move |_| {
+        let worker_result = (|| -> Result<(), BalWorkerError> {
+            // Create a database with fill_on_miss=true ensuring misses
+            // are inserted for the other workers.
+            let database = make_db(true).map_err(BalWorkerError::Setup)?;
+            let mut worker_state = State::builder()
+                .with_database(database)
+                .with_bal(received_bal_revm)
+                .with_bundle_update()
+                .build();
+            let evm = evm_config.evm_with_env(&mut worker_state, evm_env);
+            let mut executor = evm_config.create_executor_with_state(evm, ctx.clone());
+
+            loop {
+                let (index, tx) = crossbeam_channel::select_biased! {
+                    recv(abort_rx) -> _ => break,
+                    recv(tx_rx) -> msg => match msg {
+                        Ok(ix_tx) => ix_tx,
+                        Err(_) => break,
+                    },
+                };
+                let tx = tx.map_err(|e| BalWorkerError::Transaction(Box::new(e)))?;
+                let signer = *tx.signer();
+                let tx_gas_limit = tx.tx().gas_limit();
+
+                executor.evm_mut().db_mut().set_bal_index(BlockAccessIndex::new(index as u64 + 1));
+                let result = executor
+                    .execute_transaction_without_commit(tx)
+                    .map_err(BalWorkerError::Execution)?;
+
+                if result_tx
+                    .send(Ok(BalWorkerOutput { index, signer, tx_gas_limit, result }))
+                    .is_err()
+                {
+                    break;
+                }
+            }
+
+            Ok(())
+        })();
+
+        if let Err(err) = worker_result {
+            let _ = result_tx.send(Err(err));
+        }
+    });
+}
diff --git a/crates/engine/tree/src/tree/payload_processor/bal_prewarm_pool.rs b/crates/engine/tree/src/tree/payload_processor/bal_prewarm_pool.rs
new file mode 100644
index 00000000000..13d3415dc79
--- /dev/null
+++ b/crates/engine/tree/src/tree/payload_processor/bal_prewarm_pool.rs
@@ -0,0 +1,159 @@
+use alloy_primitives::{Address, StorageKey};
+use reth_execution_cache::{CachedStateProvider, ExecutionCache};
+use reth_provider::{
+    AccountReader, BytecodeReader, ProviderResult, StateProvider, StateProviderBox,
+};
+use std::{
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+    thread::JoinHandle,
+};
+use tracing::trace;
+
+/// Builds a fresh `StateProviderBox` over the block's parent state. Type-erased so the pool is not
+/// generic over the provider factory; each worker builds its own per block.
+type BuildProviderFn = dyn Fn() -> ProviderResult<StateProviderBox> + Send + Sync;
+
+/// A single warm request: a whole account (basic account + its bytecode) or one storage slot.
+enum PrewarmTarget {
+    Account(Address),
+    Storage(Address, StorageKey),
+}
+
+/// A message in a worker's queue. The per-block lifecycle is explicit and ordered (the queue is
+/// FIFO): one `BeginBlock`, then the worker's share of `Warm`s, then one `EndBlock`.
+enum PrewarmMsg {
+    /// Open a read txn for the new block: build a provider over the parent state and hold it.
+    BeginBlock { build: Arc<BuildProviderFn>, caches: ExecutionCache },
+    /// Warm one target into the held provider's cache. Ignored if no provider is held.
+    Warm(PrewarmTarget),
+    /// Drop the held provider (and its read txn).
+    EndBlock,
+}
+
+/// Long-lived pool of blocking threads that warm the BAL read-set into the shared execution cache.
+#[derive(Debug)]
+pub(crate) struct BalPrewarmPool {
+    /// One queue per worker. `BeginBlock`/`EndBlock` are broadcast to all; `Warm`s round-robin.
+    workers: Vec<crossbeam_channel::Sender<PrewarmMsg>>,
+    /// Round-robin cursor for distributing warm requests across workers.
+    next: AtomicUsize,
+    _handles: Vec<JoinHandle<()>>,
+}
+
+impl BalPrewarmPool {
+    /// Spawns `num_threads` long-lived blocking worker threads. Owned by the
+    /// [`PayloadProcessor`](super::PayloadProcessor); the threads exit when the pool is dropped.
+    pub(crate) fn new(num_threads: usize) -> Arc<Self> {
+        let mut workers = Vec::with_capacity(num_threads);
+        let mut handles = Vec::with_capacity(num_threads);
+        for i in 0..num_threads {
+            let (tx, rx) = crossbeam_channel::unbounded::<PrewarmMsg>();
+            workers.push(tx);
+            handles.push(
+                std::thread::Builder::new()
+                    .name(format!("bal-prewarm-{i:03}"))
+                    .spawn(move || prewarm_loop(rx))
+                    .expect("spawn bal-prewarm thread"),
+            );
+        }
+        trace!(target: "engine::tree::bal_prewarm_pool", num_threads, "BalPrewarmPool spawned");
+        Arc::new(Self { workers, next: AtomicUsize::new(0), _handles: handles })
+    }
+
+    /// Begins a block: hands every worker the provider builder and shared cache so each opens its
+    /// own read txn over the parent state. Pair with [`end_block`](Self::end_block).
+    pub(crate) fn begin_block(&self, build: Arc<BuildProviderFn>, caches: ExecutionCache) {
+        for worker in &self.workers {
+            let _ = worker
+                .send(PrewarmMsg::BeginBlock { build: build.clone(), caches: caches.clone() });
+        }
+    }
+
+    /// Fire-and-forget: warm an account (basic account + bytecode) on some worker.
+    pub(crate) fn warm_account(&self, addr: Address) {
+        self.send_warm(PrewarmTarget::Account(addr));
+    }
+
+    /// Fire-and-forget: warm one storage slot on some worker.
+    pub(crate) fn warm_storage(&self, addr: Address, slot: StorageKey) {
+        self.send_warm(PrewarmTarget::Storage(addr, slot));
+    }
+
+    /// Ends the block: every worker drops its provider (and read txn) once it has drained the warm
+    /// requests queued ahead of this message.
+    pub(crate) fn end_block(&self) {
+        for worker in &self.workers {
+            let _ = worker.send(PrewarmMsg::EndBlock);
+        }
+    }
+
+    fn send_warm(&self, target: PrewarmTarget) {
+        let i = self.next.fetch_add(1, Ordering::Relaxed) % self.workers.len();
+        let _ = self.workers[i].send(PrewarmMsg::Warm(target));
+    }
+}
+
+/// Number of warming threads.
+///
+/// The work performed on those threads boils down mostly to MDBX reads. An MDBX read consists of
+/// a tree traversal and major page faults causing I/O.
+///
+/// In order to utilize the parallelism of `NVMe` we have to give it enough work, or equally,
+/// maintain a high queue depth. Modern `NVMe` devices require in between 64-128 requests in-flight
+/// to achieve its peak performance. Ideally we don't grow past that but it's OK to do so, it just
+/// means that a request is going to wait in the `NVMe` queue rather than in memory.
+///
+/// MDBX piggy-backs on the OS page cache for its buffers. Oftentimes, the hit rate reaches 90-99%
+/// hit rate. At that point, the workload can be classified as CPU-bound. In that case, having
+/// a high number of threads is counterproductive due to the effects of context switching, core
+/// migration, contention, etc.
+///
+/// However, that overhead is considered negligible compared to the benefits of fully utilizing
+/// `NVMe` resources. For example, with request latency of 100µs, 100k IO requests the expected
+/// time to finish is 312.5ms at QD=32 and 156.26ms at QD=64.
+///
+/// This should explain why this particular value is picked.
+pub(crate) const DEFAULT_BAL_PREWARM_THREADS: usize = 128;
+
+fn prewarm_loop(rx: crossbeam_channel::Receiver<PrewarmMsg>) {
+    // The provider (and its MDBX read txn) held for the current block, between `BeginBlock` and
+    // `EndBlock`. `None` while idle, so no read txn is pinned across the inter-block gap.
+    let mut provider: Option<CachedStateProvider<StateProviderBox>> = None;
+
+    // Blocks when idle; the channel disconnects (and the loop ends) when the pool is dropped.
+    while let Ok(msg) = rx.recv() {
+        match msg {
+            PrewarmMsg::BeginBlock { build, caches } => {
+                provider = match (build)() {
+                    Ok(inner) => Some(CachedStateProvider::new_prewarm(inner, caches)),
+                    Err(err) => {
+                        trace!(target: "engine::tree::bal_prewarm_pool", %err, "failed to build provider");
+                        None
+                    }
+                };
+            }
+            PrewarmMsg::Warm(target) => {
+                let Some(provider) = provider.as_ref() else { continue };
+                match target {
+                    PrewarmTarget::Account(addr) => {
+                        if let Ok(Some(account)) = provider.basic_account(&addr) &&
+                            let Some(code_hash) = account.bytecode_hash &&
+                            code_hash != alloy_consensus::constants::KECCAK_EMPTY
+                        {
+                            let _ = provider.bytecode_by_hash(&code_hash);
+                        }
+                    }
+                    PrewarmTarget::Storage(addr, slot) => {
+                        let _ = provider.storage(addr, slot);
+                    }
+                }
+            }
+            PrewarmMsg::EndBlock => {
+                provider = None;
+            }
+        }
+    }
+}
diff --git a/crates/engine/tree/src/tree/payload_processor/mod.rs b/crates/engine/tree/src/tree/payload_processor/mod.rs
index c21b541deb8..911d754c305 100644
--- a/crates/engine/tree/src/tree/payload_processor/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/mod.rs
@@ -4,8 +4,9 @@ use super::precompile_cache::PrecompileCacheMap;
 use crate::tree::{
     payload_processor::prewarm::{PrewarmCacheTask, PrewarmContext, PrewarmMode, PrewarmTaskEvent},
     sparse_trie::SparseTrieCacheTask,
-    CacheWaitDurations, CachedStateMetrics, CachedStateMetricsSource, ExecutionCache,
-    PayloadExecutionCache, SavedCache, StateProviderBuilder, TreeConfig, WaitForCaches,
+    CacheWaitDurations, CachedStateCacheMetrics, CachedStateMetrics, CachedStateMetricsSource,
+    ExecutionCache, PayloadExecutionCache, SavedCache, StateProviderBuilder, TreeConfig,
+    WaitForCaches,
 };
 use alloy_eip7928::bal::DecodedBal;
 use alloy_eips::{eip1898::BlockWithParent, eip4895::Withdrawal};
@@ -26,7 +27,9 @@ use reth_provider::{
 };
 use reth_revm::db::BundleState;
 use reth_tasks::{utils::increase_thread_priority, ForEachOrdered, Runtime};
-use reth_trie::{hashed_cursor::HashedCursorFactory, trie_cursor::TrieCursorFactory};
+use reth_trie::{
+    hashed_cursor::HashedCursorFactory, trie_cursor::TrieCursorFactory, HashedPostState,
+};
 use reth_trie_parallel::{
     proof_task::{ProofTaskCtx, ProofWorkerHandle},
     root::ParallelStateRootError,
@@ -39,11 +42,13 @@ use std::{
     sync::{
         atomic::{AtomicBool, AtomicUsize},
         mpsc::{self, channel},
-        Arc,
+        Arc, OnceLock,
     },
 };
 use tracing::{debug, debug_span, instrument, trace, warn, Span};
 
+pub mod bal;
+pub(crate) mod bal_prewarm_pool;
 pub mod multiproof;
 mod preserved_sparse_trie;
 pub mod prewarm;
@@ -80,12 +85,32 @@ pub const SPARSE_TRIE_MAX_VALUES_SHRINK_CAPACITY: usize = 1_000_000;
 pub const SMALL_BLOCK_TX_THRESHOLD: usize = 5;
 
 /// Type alias for [`PayloadHandle`] returned by payload processor spawn methods.
+type IteratorTx<Evm, I> = RecoveredTx<TxEnvFor<Evm>, <I as ExecutableTxIterator<Evm>>::Recovered>;
+
 type IteratorPayloadHandle<Evm, I, N> = PayloadHandle<
-    WithTxEnv<TxEnvFor<Evm>, <I as ExecutableTxIterator<Evm>>::Recovered>,
+    IteratorTx<Evm, I>,
     <I as ExecutableTxTuple>::Error,
     <N as NodePrimitives>::Receipt,
 >;
 
+type IteratorPrewarmTxReceiver<Evm, I> =
+    PrewarmTxReceiver<TxEnvFor<Evm>, <I as ExecutableTxIterator<Evm>>::Recovered>;
+
+type IteratorExecuteTxReceiver<Evm, I> = ExecuteTxReceiver<
+    TxEnvFor<Evm>,
+    <I as ExecutableTxIterator<Evm>>::Recovered,
+    <I as ExecutableTxTuple>::Error,
+>;
+
+type RecoveredTx<TxEnv, Recovered> = WithTxEnv<TxEnv, Recovered>;
+type IndexedTxResult<Tx, Err> = (usize, Result<Tx, Err>);
+type IndexedTxReceiver<Tx, Err> = CrossbeamReceiver<IndexedTxResult<Tx, Err>>;
+type IndexedTxSender<Tx, Err> = CrossbeamSender<IndexedTxResult<Tx, Err>>;
+type PrewarmTxReceiver<TxEnv, Recovered> = mpsc::Receiver<(usize, RecoveredTx<TxEnv, Recovered>)>;
+type ExecuteTxReceiver<TxEnv, Recovered, Err> =
+    IndexedTxReceiver<RecoveredTx<TxEnv, Recovered>, Err>;
+type ExecuteTxSender<TxEnv, Recovered, Err> = IndexedTxSender<RecoveredTx<TxEnv, Recovered>, Err>;
+
 /// Entrypoint for executing the payload.
 #[derive(Debug)]
 pub struct PayloadProcessor<Evm>
@@ -98,6 +123,8 @@ where
     execution_cache: PayloadExecutionCache,
     /// Metrics for the execution cache.
     cache_metrics: Option<CachedStateMetrics>,
+    /// Metrics for shared execution cache state.
+    cache_state_metrics: Option<CachedStateCacheMetrics>,
     /// Metrics for trie operations
     trie_metrics: MultiProofTaskMetrics,
     /// Cross-block cache size in bytes.
@@ -122,12 +149,14 @@ where
     sparse_trie_max_hot_accounts: usize,
     /// Whether sparse trie cache pruning is fully disabled.
     disable_sparse_trie_cache_pruning: bool,
-    /// Whether to disable BAL-based parallel execution (falls back to tx-based prewarming).
-    disable_bal_parallel_execution: bool,
     /// Whether to disable BAL-driven parallel state root computation.
+    /// Only valid when BAL parallel execution is also disabled.
     disable_bal_parallel_state_root: bool,
-    /// Whether BAL batched IO is disabled.
+    /// Whether BAL state prefetching during prewarm is disabled.
     disable_bal_batch_io: bool,
+    /// Dedicated blocking pool for warming the BAL read-set, created lazily on the first BAL block
+    /// (see [`Self::bal_prewarm_pool`]). Its threads exit when the processor is dropped.
+    bal_prewarm_pool: OnceLock<Arc<bal_prewarm_pool::BalPrewarmPool>>,
 }
 
 impl<N, Evm> PayloadProcessor<Evm>
@@ -163,11 +192,23 @@ where
             disable_sparse_trie_cache_pruning: config.disable_sparse_trie_cache_pruning(),
             cache_metrics: (!config.disable_cache_metrics())
                 .then(|| CachedStateMetrics::zeroed(CachedStateMetricsSource::Engine)),
-            disable_bal_parallel_execution: config.disable_bal_parallel_execution(),
+            cache_state_metrics: (!config.disable_cache_metrics())
+                .then(CachedStateCacheMetrics::default),
             disable_bal_parallel_state_root: config.disable_bal_parallel_state_root(),
             disable_bal_batch_io: config.disable_bal_batch_io(),
+            bal_prewarm_pool: OnceLock::new(),
         }
     }
+
+    /// Returns the dedicated BAL read-set prewarm pool, spawning its blocking worker threads on
+    /// first use (only the BAL parallel execution path calls this).
+    fn bal_prewarm_pool(&self) -> Arc<bal_prewarm_pool::BalPrewarmPool> {
+        self.bal_prewarm_pool
+            .get_or_init(|| {
+                bal_prewarm_pool::BalPrewarmPool::new(bal_prewarm_pool::DEFAULT_BAL_PREWARM_THREADS)
+            })
+            .clone()
+    }
 }
 
 impl<Evm> WaitForCaches for PayloadProcessor<Evm>
@@ -250,6 +291,7 @@ where
         provider_builder: StateProviderBuilder<N, P>,
         multiproof_provider_factory: F,
         config: &TreeConfig,
+        parallel_bal_execution: bool,
     ) -> IteratorPayloadHandle<Evm, I, N>
     where
         P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
@@ -272,12 +314,21 @@ where
             halve_workers,
             config,
         );
-        let install_state_hook = env.decoded_bal.is_none();
+        // BAL blocks only bypass the normal execution state hook when the validator decided that
+        // the parallel BAL executor will consume this block. If not, treat the BAL as absent here
+        // so the block follows today's sequential execution and transaction-prewarm path.
+        //
+        // In the parallel BAL path, prewarm owns BAL-derived sparse-trie updates and optional
+        // BAL state prefetching. State-cache disabled mode still uses the BAL executor, but
+        // `saved_cache` is absent below, so prewarm skips cache-backed state prefetching.
+        // `disable_bal_batch_io` controls the prefetch half when a cache exists.
+        let install_state_hook = !parallel_bal_execution;
         let prewarm_handle = self.spawn_caching_with(
             env,
             prewarm_rx,
             provider_builder,
             Some(state_root_handle.updates_tx().clone()),
+            parallel_bal_execution,
         );
 
         PayloadHandle {
@@ -304,7 +355,8 @@ where
     {
         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, false);
         PayloadHandle {
             state_root_handle: None,
             install_state_hook: false,
@@ -349,16 +401,18 @@ where
         let proof_handle = ProofWorkerHandle::new(&self.executor, task_ctx, halve_workers);
 
         let (state_root_tx, state_root_rx) = channel();
+        let (hashed_state_tx, hashed_state_rx) = channel();
 
         self.spawn_sparse_trie_task(
             proof_handle,
             state_root_tx,
+            hashed_state_tx,
             from_multi_proof,
             parent_state_root,
             config.multiproof_chunk_size(),
         );
 
-        StateRootHandle::new(parent_state_root, updates_tx, state_root_rx)
+        StateRootHandle::new(parent_state_root, updates_tx, state_root_rx, hashed_state_rx)
     }
 
     /// Transaction count threshold below which proof workers are halved, since fewer transactions
@@ -388,18 +442,14 @@ where
     /// sequential iteration to avoid rayon overhead. For larger blocks, uses rayon parallel
     /// iteration with [`ForEachOrdered`] to convert transactions in parallel while streaming
     /// results to execution in the original transaction order.
-    #[expect(clippy::type_complexity)]
     #[instrument(level = "debug", target = "engine::tree::payload_processor", skip_all)]
     fn spawn_tx_iterator<I: ExecutableTxIterator<Evm>>(
         &self,
         transactions: I,
         transaction_count: usize,
-    ) -> (
-        mpsc::Receiver<(usize, WithTxEnv<TxEnvFor<Evm>, I::Recovered>)>,
-        mpsc::Receiver<Result<WithTxEnv<TxEnvFor<Evm>, I::Recovered>, I::Error>>,
-    ) {
+    ) -> (IteratorPrewarmTxReceiver<Evm, I>, IteratorExecuteTxReceiver<Evm, I>) {
         let (prewarm_tx, prewarm_rx) = mpsc::sync_channel(transaction_count);
-        let (execute_tx, execute_rx) = mpsc::sync_channel(transaction_count);
+        let (execute_tx, execute_rx) = crossbeam_channel::bounded(transaction_count);
 
         if transaction_count == 0 {
             // Empty block — nothing to do.
@@ -443,12 +493,11 @@ where
                     })
                     .for_each_ordered_in(executor.cpu_pool(), |(idx, tx)| {
                         let tx = tx.map(|tx| {
-                            let (tx_env, tx) = tx.into_parts();
-                            let tx = WithTxEnv { tx_env, tx: Arc::new(tx) };
+                            let tx = WithTxEnv::new(tx);
                             let _ = prewarm_tx.send((idx, tx.clone()));
                             tx
                         });
-                        let _ = execute_tx.send(tx);
+                        let _ = execute_tx.send((idx, tx));
                         trace!(target: "engine::tree::payload_processor", idx, "yielded transaction");
                         });
                         });
@@ -458,37 +507,46 @@ where
     }
 
     /// Spawn prewarming optionally wired to the sparse trie task for target updates.
-    #[instrument(
-        level = "debug",
-        target = "engine::tree::payload_processor",
-        skip_all,
-        fields(bal=%env.decoded_bal.is_some())
-    )]
+    ///
+    /// `parallel_bal_execution` is true when the BAL execute path will execute this block. In
+    /// that case prewarm runs in BAL mode: it streams BAL-derived sparse-trie updates and,
+    /// unless `disable_bal_batch_io` is set, prefetches BAL-declared state into the shared cache.
+    #[instrument(level = "debug", target = "engine::tree::payload_processor", skip_all)]
     fn spawn_caching_with<P>(
         &self,
         env: ExecutionEnv<Evm>,
         transactions: mpsc::Receiver<(usize, impl ExecutableTxFor<Evm> + Clone + Send + 'static)>,
         provider_builder: StateProviderBuilder<N, P>,
         to_sparse_trie_task: Option<CrossbeamSender<StateRootMessage>>,
+        parallel_bal_execution: bool,
     ) -> CacheTaskHandle<N::Receipt>
     where
         P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
     {
-        let skip_prewarm =
-            self.disable_transaction_prewarming || env.transaction_count < SMALL_BLOCK_TX_THRESHOLD;
-
+        let mode = if parallel_bal_execution {
+            PrewarmMode::BlockAccessList(
+                env.decoded_bal.clone().expect("BAL dispatch implies decoded BAL"),
+            )
+        } else if self.disable_transaction_prewarming ||
+            env.transaction_count < SMALL_BLOCK_TX_THRESHOLD
+        {
+            PrewarmMode::Skipped
+        } else {
+            PrewarmMode::Transactions(transactions)
+        };
         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,
             evm_config: self.evm_config.clone(),
             saved_cache: saved_cache.clone(),
             provider: provider_builder,
+            bal_prewarm_pool: parallel_bal_execution.then(|| self.bal_prewarm_pool()),
             metrics: PrewarmMetrics::default(),
             cache_metrics: self.cache_metrics.clone(),
+            cache_state_metrics: self.cache_state_metrics.clone(),
             terminate_execution: Arc::new(AtomicBool::new(false)),
             executed_tx_index: Arc::clone(&executed_tx_index),
             precompile_cache_disabled: self.precompile_cache_disabled,
@@ -505,17 +563,7 @@ where
         );
         {
             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 {
-                    PrewarmMode::Transactions(transactions)
-                };
                 prewarm_task.run(mode, to_prewarm_task);
             });
         }
@@ -555,6 +603,7 @@ where
         &self,
         proof_worker_handle: ProofWorkerHandle,
         state_root_tx: mpsc::Sender<Result<StateRootComputeOutcome, ParallelStateRootError>>,
+        hashed_state_tx: mpsc::Sender<HashedPostState>,
         from_multi_proof: CrossbeamReceiver<StateRootMessage>,
         parent_state_root: B256,
         chunk_size: usize,
@@ -603,6 +652,7 @@ where
             let mut task = SparseTrieCacheTask::new_with_trie(
                 &executor,
                 from_multi_proof,
+                hashed_state_tx,
                 proof_worker_handle,
                 trie_metrics.clone(),
                 sparse_state_trie,
@@ -692,7 +742,7 @@ where
         block_with_parent: BlockWithParent,
         bundle_state: &BundleState,
     ) {
-        let cache_metrics = self.cache_metrics.clone();
+        let cache_state_metrics = self.cache_state_metrics.clone();
         self.execution_cache.update_with_guard(|cached| {
             if cached.as_ref().is_some_and(|c| c.executed_block_hash() != block_with_parent.parent) {
                 debug!(
@@ -703,6 +753,16 @@ where
                 return
             }
 
+            if let Some(cache) = cached.as_ref().filter(|cache| !cache.is_available()) {
+                debug!(
+                    target: "engine::caching",
+                    parent_hash = %block_with_parent.parent,
+                    usage_count = cache.usage_count(),
+                    "Execution cache is in use, skip updating cache with new state for inserted executed block",
+                );
+                return
+            }
+
             // Take existing cache (if any) or create fresh caches
             let caches = match cached.take() {
                 Some(existing) => existing.cache().clone(),
@@ -716,7 +776,7 @@ where
                 debug!(target: "engine::caching", "cleared execution cache on update error");
                 return
             }
-            new_cache.update_metrics(cache_metrics.as_ref());
+            new_cache.update_metrics(cache_state_metrics.as_ref());
 
             // Replace with the updated cache
             *cached = Some(new_cache);
@@ -730,7 +790,7 @@ fn convert_serial<RawTx, Tx, TxEnv, InnerTx, Recovered, Err, C>(
     iter: impl Iterator<Item = RawTx>,
     convert: &C,
     prewarm_tx: &mpsc::SyncSender<(usize, WithTxEnv<TxEnv, Recovered>)>,
-    execute_tx: &mpsc::SyncSender<Result<WithTxEnv<TxEnv, Recovered>, Err>>,
+    execute_tx: &ExecuteTxSender<TxEnv, Recovered, Err>,
 ) where
     Tx: ExecutableTxParts<TxEnv, InnerTx, Recovered = Recovered>,
     TxEnv: Clone,
@@ -738,14 +798,11 @@ fn convert_serial<RawTx, Tx, TxEnv, InnerTx, Recovered, Err, C>(
 {
     for (idx, raw_tx) in iter.enumerate() {
         let tx = convert.convert(raw_tx);
-        let tx = tx.map(|tx| {
-            let (tx_env, tx) = tx.into_parts();
-            WithTxEnv { tx_env, tx: Arc::new(tx) }
-        });
+        let tx = tx.map(|tx| WithTxEnv::new(tx));
         if let Ok(tx) = &tx {
             let _ = prewarm_tx.send((idx, tx.clone()));
         }
-        let _ = execute_tx.send(tx);
+        let _ = execute_tx.send((idx, tx));
         trace!(target: "engine::tree::payload_processor", idx, "yielded transaction");
     }
 }
@@ -762,8 +819,8 @@ pub struct PayloadHandle<Tx, Err, R> {
     install_state_hook: bool,
     // must include the receiver of the state root wired to the sparse trie
     prewarm_handle: CacheTaskHandle<R>,
-    /// Stream of block transactions
-    transactions: mpsc::Receiver<Result<Tx, Err>>,
+    /// Stream of block transactions and their indices in the block.
+    transactions: IndexedTxReceiver<Tx, Err>,
     /// Span for tracing
     _span: Span,
 }
@@ -798,13 +855,20 @@ impl<Tx, Err, R: Send + Sync + 'static> PayloadHandle<Tx, Err, R> {
 
     /// Returns a state hook to stream execution state updates to the sparse trie cache task.
     ///
-    /// Returns `None` when execution should not send state updates, such as BAL-driven execution.
+    /// Returns `None` when BAL-driven hashed state streaming feeds the sparse trie task.
     pub fn state_hook(&self) -> Option<impl OnStateHook> {
         self.install_state_hook
             .then(|| self.state_root_handle.as_ref().map(|handle| handle.state_hook()))
             .flatten()
     }
 
+    /// Returns a clone of the sender that streams updates into the sparse-trie task. The BAL
+    /// execute path uses this to spawn its own sparse-trie streaming task fed from the
+    /// snapshot.
+    pub fn sparse_trie_updates_tx(&self) -> Option<CrossbeamSender<StateRootMessage>> {
+        self.state_root_handle.as_ref().map(|handle| handle.updates_tx().clone())
+    }
+
     /// Returns a clone of the caches used by prewarming
     pub fn caches(&self) -> Option<ExecutionCache> {
         self.prewarm_handle.saved_cache.as_ref().map(|cache| cache.cache().clone())
@@ -846,7 +910,17 @@ impl<Tx, Err, R: Send + Sync + 'static> PayloadHandle<Tx, Err, R> {
 
     /// Returns iterator yielding transactions from the stream.
     pub fn iter_transactions(&mut self) -> impl Iterator<Item = Result<Tx, Err>> + '_ {
-        self.transactions.iter()
+        self.transactions.iter().map(|(_, tx)| tx)
+    }
+
+    /// Returns a clone of the indexed transaction receiver.
+    pub fn clone_transaction_receiver(&self) -> IndexedTxReceiver<Tx, Err> {
+        self.transactions.clone()
+    }
+
+    /// Takes the hashed state receiver out of the handle for use with custom waiting logic
+    pub fn take_hashed_state_rx(&mut self) -> Option<mpsc::Receiver<HashedPostState>> {
+        self.state_root_handle.as_mut().map(|handle| handle.take_hashed_state_rx())
     }
 }
 
@@ -966,13 +1040,13 @@ mod tests {
         ExecutionCache, PayloadExecutionCache, SavedCache, StateProviderBuilder, TreeConfig,
     };
     use alloy_eips::eip1898::{BlockNumHash, BlockWithParent};
-    use alloy_evm::block::StateChangeSource;
     use rand::Rng;
     use reth_chainspec::ChainSpec;
     use reth_db_common::init::init_genesis;
     use reth_ethereum_primitives::{EthPrimitives, TransactionSigned};
     use reth_evm::OnStateHook;
     use reth_evm_ethereum::EthEvmConfig;
+    use reth_execution_cache::CachedStatus;
     use reth_primitives_traits::{Account, Recovered, StorageEntry};
     use reth_provider::{
         providers::{BlockchainProvider, OverlayBuilder, OverlayStateProviderFactory},
@@ -984,7 +1058,7 @@ mod tests {
     use reth_trie::{test_utils::state_root, HashedPostState};
     use reth_trie_db::ChangesetCache;
     use revm_primitives::{Address, HashMap, B256, KECCAK_EMPTY, U256};
-    use revm_state::{AccountInfo, AccountStatus, EvmState, EvmStorageSlot};
+    use revm_state::{AccountInfo, AccountStatus, EvmState, EvmStorageSlot, TransactionId};
     use std::sync::Arc;
 
     fn make_saved_cache(hash: B256) -> SavedCache {
@@ -1132,6 +1206,65 @@ mod tests {
         assert!(cached3.is_none(), "New block cache should not be created on mismatch");
     }
 
+    #[test]
+    fn on_inserted_executed_block_does_not_mutate_checked_out_parent_cache() {
+        let payload_processor = PayloadProcessor::new(
+            reth_tasks::Runtime::test(),
+            EthEvmConfig::new(Arc::new(ChainSpec::default())),
+            &TreeConfig::default(),
+            PrecompileCacheMap::default(),
+        );
+
+        let parent_hash = B256::from([1u8; 32]);
+        payload_processor
+            .execution_cache
+            .update_with_guard(|slot| *slot = Some(make_saved_cache(parent_hash)));
+
+        // Checking out the cache bumps its usage_guard refcount, marking the slot as in-use.
+        // The returned SavedCache shares the same underlying ExecutionCache Arc as the slot,
+        // so any writes through the slot are observable here
+        let checked_out = payload_processor
+            .execution_cache
+            .get_cache_for(parent_hash)
+            .expect("expected parent cache checkout to succeed");
+
+        let polluted_address = Address::random();
+        let bundle_state = BundleState::builder(2..=2)
+            .state_present_account_info(
+                polluted_address,
+                AccountInfo {
+                    balance: U256::from(1337),
+                    nonce: 7,
+                    code_hash: KECCAK_EMPTY,
+                    code: None,
+                    account_id: None,
+                },
+            )
+            .build();
+
+        // Make parent match the cached slot so we bypass the parent-mismatch guard and exercise
+        // the in-use guard specifically.
+        let block_with_parent = BlockWithParent {
+            block: BlockNumHash { hash: B256::from([2u8; 32]), number: 2 },
+            parent: parent_hash,
+        };
+
+        payload_processor.on_inserted_executed_block(block_with_parent, &bundle_state);
+
+        // The closure runs only on a cache miss, so NotCached(None) means polluted_address was
+        // absent and Cached(Some(_)) means it was written by on_inserted_executed_block.
+        let account = checked_out
+            .cache()
+            .get_or_try_insert_account_with(polluted_address, || Ok::<_, ()>(None))
+            .expect("cache read should succeed");
+
+        assert_eq!(
+            account,
+            CachedStatus::NotCached(None),
+            "checked-out parent cache should not observe state from inserted local block"
+        );
+    }
+
     fn create_mock_state_updates(num_accounts: usize, updates_per_account: usize) -> Vec<EvmState> {
         let mut rng = generators::rng();
         let all_addresses: Vec<Address> = (0..num_accounts).map(|_| rng.random()).collect();
@@ -1153,25 +1286,23 @@ mod tests {
                             EvmStorageSlot::new_changed(
                                 U256::ZERO,
                                 U256::from(rng.random::<u64>()),
-                                0,
+                                TransactionId::ZERO,
                             ),
                         );
                     }
                 }
 
-                let account = revm_state::Account {
-                    info: AccountInfo {
-                        balance: U256::from(rng.random::<u64>()),
-                        nonce: rng.random::<u64>(),
-                        code_hash: KECCAK_EMPTY,
-                        code: Some(Default::default()),
-                        account_id: None,
-                    },
-                    original_info: Box::new(AccountInfo::default()),
-                    storage,
-                    status: AccountStatus::Touched,
-                    transaction_id: 0,
+                let mut account = revm_state::Account::default();
+                account.info = AccountInfo {
+                    balance: U256::from(rng.random::<u64>()),
+                    nonce: rng.random::<u64>(),
+                    code_hash: KECCAK_EMPTY,
+                    code: Some(Default::default()),
+                    account_id: None,
                 };
+                account.storage = storage;
+                account.status = AccountStatus::Touched;
+                account.transaction_id = TransactionId::ZERO;
 
                 state_update.insert(address, account);
             }
@@ -1255,12 +1386,13 @@ mod tests {
                 OverlayBuilder::<EthPrimitives>::new(genesis_hash, ChangesetCache::new()),
             ),
             &TreeConfig::default(),
+            false,
         );
 
         let mut state_hook = handle.state_hook().expect("state hook is None");
 
-        for (i, update) in state_updates.into_iter().enumerate() {
-            state_hook.on_state(StateChangeSource::Transaction(i), &update);
+        for update in state_updates {
+            state_hook.on_state(&update);
         }
         drop(state_hook);
 
diff --git a/crates/engine/tree/src/tree/payload_processor/multiproof.rs b/crates/engine/tree/src/tree/payload_processor/multiproof.rs
index b8f68ee5abf..f643e9e9f82 100644
--- a/crates/engine/tree/src/tree/payload_processor/multiproof.rs
+++ b/crates/engine/tree/src/tree/payload_processor/multiproof.rs
@@ -4,8 +4,8 @@ use metrics::{Gauge, Histogram};
 use reth_metrics::Metrics;
 
 pub use reth_trie_parallel::state_root_task::{
-    evm_state_to_hashed_post_state, Source, StateHookSender, StateRootComputeOutcome,
-    StateRootHandle, StateRootMessage,
+    evm_state_to_hashed_post_state, StateHookSender, StateRootComputeOutcome, StateRootHandle,
+    StateRootMessage,
 };
 
 /// The default max targets, for limiting the number of account and storage proof targets to be
@@ -68,9 +68,10 @@ pub(crate) fn dispatch_with_chunking<T, I>(
 ) where
     I: IntoIterator<Item = T>,
 {
+    let has_full_chunks = chunking_len >= chunk_size.saturating_mul(2);
     let should_chunk = chunking_len > max_targets_for_chunking ||
-        has_multiple_idle_account_workers ||
-        has_multiple_idle_storage_workers;
+        (has_full_chunks &&
+            (has_multiple_idle_account_workers || has_multiple_idle_storage_workers));
 
     if should_chunk && chunking_len > chunk_size {
         for chunk in chunker(items, chunk_size) {
diff --git a/crates/engine/tree/src/tree/payload_processor/prewarm.rs b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
index 04c0671de3f..7c80afc6fd2 100644
--- a/crates/engine/tree/src/tree/payload_processor/prewarm.rs
+++ b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
@@ -11,16 +11,17 @@
 //! 2. Prewarming tasks execute transactions in parallel using shared caches
 //! 3. When actual block execution happens, it benefits from the warmed cache
 
+use super::bal_prewarm_pool::BalPrewarmPool;
 use crate::tree::{
     payload_processor::multiproof::StateRootMessage,
     precompile_cache::{CachedPrecompile, PrecompileCacheMap},
-    CachedStateMetrics, CachedStateProvider, ExecutionEnv, PayloadExecutionCache, SavedCache,
-    StateProviderBuilder,
+    CachedStateCacheMetrics, CachedStateMetrics, CachedStateProvider, ExecutionEnv,
+    PayloadExecutionCache, SavedCache, StateProviderBuilder,
 };
 use alloy_consensus::transaction::TxHashRef;
 use alloy_eip7928::bal::DecodedBal;
 use alloy_eips::eip4895::Withdrawal;
-use alloy_primitives::{keccak256, StorageKey, B256};
+use alloy_primitives::{keccak256, B256};
 use crossbeam_channel::Sender as CrossbeamSender;
 use metrics::{Counter, Gauge, Histogram};
 use rayon::prelude::*;
@@ -28,8 +29,7 @@ use reth_evm::{execute::ExecutableTxFor, ConfigureEvm, Evm, EvmFor, RecoveredTx,
 use reth_metrics::Metrics;
 use reth_primitives_traits::{FastInstant as Instant, NodePrimitives};
 use reth_provider::{
-    AccountReader, BlockExecutionOutput, BlockReader, StateProvider, StateProviderFactory,
-    StateReader,
+    AccountReader, BlockExecutionOutput, BlockReader, StateProviderFactory, StateReader,
 };
 use reth_revm::{database::StateProviderDatabase, state::EvmState};
 use reth_tasks::{pool::WorkerPool, Runtime};
@@ -279,7 +279,7 @@ where
 
         let Self {
             execution_cache,
-            ctx: PrewarmContext { env, metrics, cache_metrics, saved_cache, .. },
+            ctx: PrewarmContext { env, metrics, cache_state_metrics, saved_cache, .. },
             ..
         } = self;
         let hash = env.hash;
@@ -301,7 +301,7 @@ where
                     return;
                 }
 
-                new_cache.update_metrics(cache_metrics.as_ref());
+                new_cache.update_metrics(cache_state_metrics.as_ref());
 
                 if valid_block_rx.recv().is_ok() {
                     // Replace the shared cache with the new one; the previous cache (if any) is
@@ -325,9 +325,10 @@ where
     /// Runs BAL-based prewarming and sparse-trie work inline.
     ///
     /// Spawns two halves concurrently on separate pools, then waits for both to complete:
-    /// 1. Storage prefetch on the prewarming pool to populate the execution cache.
-    /// 2. Hashed state streaming on the BAL streaming pool so storage updates can reach the sparse
+    /// 1. Hashed state streaming on the BAL streaming pool so storage updates can reach the sparse
     ///    trie before account reads finish.
+    /// 2. Storage prefetch on the prewarming pool to populate the execution cache, unless BAL batch
+    ///    I/O is disabled.
     #[instrument(level = "debug", target = "engine::tree::payload_processor::prewarm", skip_all)]
     fn run_bal_prewarm(
         &self,
@@ -354,7 +355,6 @@ where
         let to_sparse_trie_task = self.to_sparse_trie_task.clone();
         let executor = self.executor.clone();
         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);
@@ -362,7 +362,7 @@ where
         let (stream_tx, stream_rx) = oneshot::channel();
 
         if let Some(to_sparse_trie_task) = to_sparse_trie_task {
-            let stream_ctx = ctx.clone();
+            let ctx = ctx.clone();
             executor.bal_streaming_pool().spawn(move || {
                 let branch_span = debug_span!(
                     target: "engine::tree::payload_processor::prewarm",
@@ -370,26 +370,21 @@ where
                     "bal_hashed_state_stream",
                     bal_accounts = stream_bal.as_bal().len(),
                 );
-                let provider_parent_span = branch_span.clone();
+                let 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| {
+                stream_bal.as_bal().par_iter().for_each(|account_changes| {
+                    WorkerPool::with_worker_mut(|worker| {
+                        let provider =
+                            worker.get_or_init::<Option<Box<dyn AccountReader>>>(|| None);
                         ctx.send_bal_hashed_state(
-                            parent_span,
+                            &parent_span,
                             provider,
                             account_changes,
                             &to_sparse_trie_task,
                         );
-                    },
-                );
+                    });
+                });
 
                 let _ = to_sparse_trie_task.send(StateRootMessage::FinishedStateUpdates);
                 let _ = stream_tx.send(());
@@ -398,35 +393,38 @@ where
             let _ = stream_tx.send(());
         }
 
-        if ctx.saved_cache.is_some() {
-            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(),
-                );
-                let provider_parent_span = branch_span.clone();
-                let _span = branch_span.entered();
-
-                prefetch_bal.as_bal().par_iter().for_each_init(
-                    || {
-                        (
-                            ctx.clone(),
-                            None::<CachedStateProvider<reth_provider::StateProviderBox, true>>,
-                            provider_parent_span.clone(),
-                        )
-                    },
-                    |(ctx, provider, parent_span), account| {
-                        if ctx.should_stop() {
-                            return;
-                        }
-                        ctx.prefetch_bal_storage(parent_span, provider, account);
-                    },
-                );
-
-                let _ = prefetch_tx.send(());
-            });
+        if let Some(saved_cache) = ctx.saved_cache &&
+            !ctx.disable_bal_batch_io &&
+            let Some(pool) = ctx.bal_prewarm_pool.as_ref()
+        {
+            // If
+            //
+            // - BAL path is enabled (and so bal_prewarm_pool is present),
+            // - dispatch_bal_batch_io is false
+            // - execution cache is not disabled
+            //
+            // we launch prewarming sequence of the BAL read set here. The BAL read-set consists
+            // of the accounts, their code if present, and declared storages (both storage_reads
+            // and storage_changes).
+            //
+            // This runs side-by-side with the parallel transaction execution reducing the time it
+            // spends blocking on the data.
+            let caches = saved_cache.cache().clone();
+            let provider_builder = ctx.provider.clone();
+            let build = Arc::new(move || provider_builder.build());
+
+            pool.begin_block(build, caches);
+            for account in prefetch_bal.as_bal() {
+                pool.warm_account(account.address);
+                for change in &account.storage_changes {
+                    pool.warm_storage(account.address, change.slot.into());
+                }
+                for &slot in &account.storage_reads {
+                    pool.warm_storage(account.address, slot.into());
+                }
+            }
+            pool.end_block();
+            let _ = prefetch_tx.send(());
         } else {
             let _ = prefetch_tx.send(());
         }
@@ -438,6 +436,10 @@ where
             .blocking_recv()
             .expect("BAL hashed-state streaming task dropped without signaling completion");
 
+        // Drop the per-thread providers
+        executor.bal_streaming_pool().clear();
+        executor.prewarming_pool().clear();
+
         let _ = actions_tx.send(PrewarmTaskEvent::FinishedTxExecution { executed_transactions: 0 });
     }
 
@@ -528,11 +530,16 @@ where
     pub saved_cache: Option<SavedCache>,
     /// Provider to obtain the state
     pub provider: StateProviderBuilder<N, P>,
+    /// Dedicated blocking pool for warming the BAL read-set. `Some` only on the BAL parallel
+    /// execution path; the pool is owned by the [`PayloadProcessor`](super::PayloadProcessor).
+    pub(crate) bal_prewarm_pool: Option<Arc<BalPrewarmPool>>,
     /// The metrics for the prewarm task.
     pub metrics: PrewarmMetrics,
     /// Metrics for the execution cache.
     /// Metrics for the execution cache. `None` disables metrics recording.
     pub cache_metrics: Option<CachedStateMetrics>,
+    /// Metrics for shared execution cache state. `None` disables metrics recording.
+    pub cache_state_metrics: Option<CachedStateCacheMetrics>,
     /// An atomic bool that tells prewarm tasks to not start any more execution.
     pub terminate_execution: Arc<AtomicBool>,
     /// Shared counter tracking the next transaction index to be executed by the main execution
@@ -544,8 +551,9 @@ where
     /// The precompile cache map.
     pub precompile_cache_map: PrecompileCacheMap<SpecFor<Evm>>,
     /// Whether to disable BAL-driven parallel state root computation.
+    /// Only valid when BAL parallel execution is also disabled.
     pub disable_bal_parallel_state_root: bool,
-    /// Whether BAL batched IO is disabled.
+    /// Whether BAL state prefetching during prewarm is disabled.
     pub disable_bal_batch_io: bool,
 }
 
@@ -578,11 +586,7 @@ where
         // Use the caches to create a new provider with caching
         if let Some(saved_cache) = &self.saved_cache {
             let caches = saved_cache.cache().clone();
-            state_provider = Box::new(CachedStateProvider::new_prewarm(
-                state_provider,
-                caches,
-                self.cache_metrics.clone().unwrap_or_default(),
-            ));
+            state_provider = Box::new(CachedStateProvider::new_prewarm(state_provider, caches));
         }
 
         let state_provider = StateProviderDatabase::new(state_provider);
@@ -669,7 +673,7 @@ where
                 target: "engine::tree::payload_processor::prewarm",
                 parent: parent_span,
                 "bal_hashed_state_provider_init",
-                has_saved_cache = self.saved_cache.is_some(),
+                has_saved_cache = !self.disable_bal_batch_io && self.saved_cache.is_some(),
             )
             .entered();
 
@@ -684,15 +688,13 @@ where
                     return;
                 }
             };
-            let boxed: Box<dyn AccountReader> = if let Some(saved) = &self.saved_cache {
-                let caches = saved.cache().clone();
-                Box::new(CachedStateProvider::new_prewarm(
-                    inner,
-                    caches,
-                    self.cache_metrics.clone().unwrap_or_default(),
-                ))
-            } else {
-                Box::new(inner)
+            let boxed: Box<dyn AccountReader> = match (self.disable_bal_batch_io, &self.saved_cache)
+            {
+                (false, Some(saved)) => {
+                    let caches = saved.cache().clone();
+                    Box::new(CachedStateProvider::new_prewarm(inner, caches))
+                }
+                _ => Box::new(inner),
             };
             *provider = Some(boxed);
         }
@@ -742,76 +744,14 @@ where
 
         let _ = to_sparse_trie_task.send(StateRootMessage::HashedStateUpdate(hashed_state));
     }
-
-    /// Prefetches storage slots for a single BAL account into the cache.
-    ///
-    /// Account reads are handled separately by [`Self::send_bal_hashed_state`], so this method
-    /// only
-    /// warms storage.
-    ///
-    /// The `provider` is lazily initialized on first call and reused across accounts on the same
-    /// thread.
-    fn prefetch_bal_storage(
-        &self,
-        parent_span: &Span,
-        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())
-        {
-            return;
-        }
-
-        let state_provider = match provider {
-            Some(p) => p,
-            slot @ None => {
-                let _span = debug_span!(
-                    target: "engine::tree::payload_processor::prewarm",
-                    parent: parent_span,
-                    "bal_prefetch_provider_init",
-                )
-                .entered();
-
-                let built = match self.provider.build() {
-                    Ok(p) => p,
-                    Err(err) => {
-                        trace!(
-                            target: "engine::tree::payload_processor::prewarm",
-                            %err,
-                            "Failed to build state provider in BAL prewarm thread"
-                        );
-                        return;
-                    }
-                };
-                let saved_cache =
-                    self.saved_cache.as_ref().expect("BAL prewarm should only run with cache");
-                let caches = saved_cache.cache().clone();
-                slot.insert(CachedStateProvider::new_prewarm(
-                    built,
-                    caches,
-                    self.cache_metrics.clone().unwrap_or_default(),
-                ))
-            }
-        };
-
-        let start = Instant::now();
-
-        for slot in &account.storage_changes {
-            let _ = state_provider.storage(account.address, StorageKey::from(slot.slot));
-        }
-        for &slot in &account.storage_reads {
-            let _ = state_provider.storage(account.address, StorageKey::from(slot));
-        }
-
-        self.metrics.bal_slot_iteration_duration.record(start.elapsed().as_secs_f64());
-    }
 }
 
 /// Returns a set of [`MultiProofTargetsV2`] and the total amount of storage targets, based on the
 /// given state.
 fn multiproof_targets_from_state(state: EvmState) -> (MultiProofTargetsV2, usize) {
     let mut targets = MultiProofTargetsV2::default();
+    targets.account_targets.reserve(state.len());
+    targets.storage_targets.reserve(state.len());
     let mut storage_target_count = 0;
     for (addr, account) in state {
         // if the account was not touched, or if the account was selfdestructed, do not
@@ -826,7 +766,10 @@ fn multiproof_targets_from_state(state: EvmState) -> (MultiProofTargetsV2, usize
         }
 
         let hashed_address = keccak256(addr);
-        targets.account_targets.push(hashed_address.into());
+
+        if account.info != account.original_info() {
+            targets.account_targets.push(hashed_address.into());
+        }
 
         let mut storage_slots = Vec::with_capacity(account.storage.len());
         for (key, slot) in account.storage {
diff --git a/crates/engine/tree/src/tree/payload_processor/receipt_root_task.rs b/crates/engine/tree/src/tree/payload_processor/receipt_root_task.rs
index cd0563bf9fd..263b61693ee 100644
--- a/crates/engine/tree/src/tree/payload_processor/receipt_root_task.rs
+++ b/crates/engine/tree/src/tree/payload_processor/receipt_root_task.rs
@@ -7,13 +7,15 @@
 //! computed root.
 
 use alloy_eips::Encodable2718;
-use alloy_primitives::{Bloom, B256};
+use alloy_primitives::{map::HashMap, Bloom, B256};
 use crossbeam_channel::Receiver;
 use reth_primitives_traits::Receipt;
 use reth_trie_common::ordered_root::OrderedTrieRootEncodedBuilder;
 use tokio::sync::oneshot;
 use tracing::debug_span;
 
+const RECEIPT_ENCODE_BUF_INITIAL_CAPACITY: usize = 512;
+
 /// Receipt with index, ready to be sent to the background task for encoding and trie building.
 #[derive(Debug, Clone)]
 pub struct IndexedReceipt<R> {
@@ -65,7 +67,9 @@ impl<R: Receipt> ReceiptRootTaskHandle<R> {
     ///
     /// * `receipts_len` - The total number of receipts expected. This is needed to correctly order
     ///   the trie keys according to RLP encoding rules.
-    pub fn run(self, receipts_len: usize) {
+    pub fn run(self, receipts_len: impl Into<Option<usize>>) {
+        let receipts_len = receipts_len.into();
+
         let _span = debug_span!(
             target: "engine::tree::payload_processor",
             "receipt_root",
@@ -73,49 +77,57 @@ impl<R: Receipt> ReceiptRootTaskHandle<R> {
         )
         .entered();
 
-        let mut builder = OrderedTrieRootEncodedBuilder::new(receipts_len);
+        let mut builder = OrderedTrieRootEncodedBuilder::new();
         let mut aggregated_bloom = Bloom::ZERO;
-        let mut encode_buf = Vec::new();
-        let mut received_count = 0usize;
+        let mut encode_buf = Vec::with_capacity(RECEIPT_ENCODE_BUF_INITIAL_CAPACITY);
+        let mut next = 0usize;
+        let mut pending = HashMap::new();
 
-        for indexed_receipt in self.receipt_rx {
-            let receipt_with_bloom = indexed_receipt.receipt.with_bloom_ref();
+        let mut push = |receipt: R| {
+            let receipt_with_bloom = receipt.with_bloom_ref();
 
             encode_buf.clear();
             receipt_with_bloom.encode_2718(&mut encode_buf);
 
             aggregated_bloom |= *receipt_with_bloom.bloom_ref();
-            match builder.push(indexed_receipt.index, &encode_buf) {
-                Ok(()) => {
-                    received_count += 1;
-                }
-                Err(err) => {
-                    // If a duplicate or out-of-bounds index is streamed, skip it and
-                    // fall back to computing the receipt root from the full receipts
-                    // vector later.
-                    tracing::error!(
-                        target: "engine::tree::payload_processor",
-                        index = indexed_receipt.index,
-                        ?err,
-                        "Receipt root task received invalid receipt index, skipping"
-                    );
+            builder.push_next(&encode_buf);
+        };
+
+        for indexed_receipt in self.receipt_rx {
+            if indexed_receipt.index == next {
+                push(indexed_receipt.receipt);
+                next += 1;
+
+                while let Some(receipt) = pending.remove(&next) {
+                    push(receipt);
+                    next += 1;
                 }
+            } else {
+                pending.insert(indexed_receipt.index, indexed_receipt.receipt);
             }
         }
 
-        let Ok(root) = builder.finalize() else {
-            // Finalize fails if we didn't receive exactly `receipts_len` receipts. This can
-            // happen if execution was aborted early (e.g., invalid transaction encountered).
-            // We return without sending a result, allowing the caller to handle the abort.
+        if receipts_len.is_some_and(|len| len != next) {
             tracing::error!(
                 target: "engine::tree::payload_processor",
                 expected = receipts_len,
-                received = received_count,
+                received = next,
                 "Receipt root task received incomplete receipts, execution likely aborted"
             );
             return;
-        };
-        let _ = self.result_tx.send((root, aggregated_bloom));
+        }
+
+        if !pending.is_empty() {
+            tracing::error!(
+                target: "engine::tree::payload_processor",
+                received = next,
+                pending = pending.len(),
+                "Receipt root task received gapped receipts"
+            );
+            return;
+        }
+
+        let _ = self.result_tx.send((builder.finalize(), aggregated_bloom));
     }
 }
 
diff --git a/crates/engine/tree/src/tree/payload_processor/sparse_trie.rs b/crates/engine/tree/src/tree/payload_processor/sparse_trie.rs
index 16a05d8745c..fb7680a8a5b 100644
--- a/crates/engine/tree/src/tree/payload_processor/sparse_trie.rs
+++ b/crates/engine/tree/src/tree/payload_processor/sparse_trie.rs
@@ -34,9 +34,6 @@ use reth_trie_sparse::{
 use revm_primitives::{hash_map::Entry, B256Map};
 use tracing::{debug, debug_span, error, instrument, trace_span};
 
-/// Maximum number of pending/prewarm updates that we accumulate in memory before actually applying.
-const MAX_PENDING_UPDATES: usize = 100;
-
 /// Sparse trie task implementation that uses in-memory sparse trie data to schedule proof fetching.
 pub(super) struct SparseTrieCacheTask<A = ConfigurableSparseTrie, S = ConfigurableSparseTrie> {
     /// Sender for proof results.
@@ -45,6 +42,8 @@ pub(super) struct SparseTrieCacheTask<A = ConfigurableSparseTrie, S = Configurab
     proof_result_rx: CrossbeamReceiver<ProofResultMessage>,
     /// Receives updates from execution and prewarming.
     updates: CrossbeamReceiver<SparseTrieTaskMessage>,
+    /// Sender half for the channel to send final hashed state to.
+    final_hashed_state_tx: Option<std::sync::mpsc::Sender<HashedPostState>>,
     /// `SparseStateTrie` used for computing the state root.
     trie: SparseStateTrie<A, S>,
     /// The parent block's state root.
@@ -106,6 +105,12 @@ pub(super) struct SparseTrieCacheTask<A = ConfigurableSparseTrie, S = Configurab
     /// Number of pending execution/prewarming updates received but not yet passed to
     /// `update_leaves`.
     pending_updates: usize,
+    /// Combined final hashed state.
+    ///
+    /// Sparse trie task observes and hashes all state updates, allowing it to cheaply construct a
+    /// final [`HashedPostState`] and share it with main engine thread without requiring any extra
+    /// hashing work.
+    final_hashed_state: HashedPostState,
 
     /// Metrics for the sparse trie.
     metrics: MultiProofTaskMetrics,
@@ -117,9 +122,11 @@ where
     S: SparseTrie + Default + Clone,
 {
     /// Creates a new sparse trie, pre-populating with an existing [`SparseStateTrie`].
+    #[expect(clippy::too_many_arguments)]
     pub(super) fn new_with_trie(
         executor: &Runtime,
         updates: CrossbeamReceiver<StateRootMessage>,
+        final_hashed_state_tx: std::sync::mpsc::Sender<HashedPostState>,
         proof_worker_handle: ProofWorkerHandle,
         metrics: MultiProofTaskMetrics,
         trie: SparseStateTrie<A, S>,
@@ -141,6 +148,7 @@ where
             proof_result_rx,
             updates: hashed_state_rx,
             proof_worker_handle,
+            final_hashed_state_tx: Some(final_hashed_state_tx),
             trie,
             parent_state_root,
             chunk_size,
@@ -160,6 +168,7 @@ where
             storage_cache_misses: 0,
             pending_targets: Default::default(),
             pending_updates: Default::default(),
+            final_hashed_state: Default::default(),
             metrics,
         }
     }
@@ -181,7 +190,7 @@ where
                 StateRootMessage::PrefetchProofs(targets) => {
                     SparseTrieTaskMessage::PrefetchProofs(targets)
                 }
-                StateRootMessage::StateUpdate(_, state) => {
+                StateRootMessage::StateUpdate(state) => {
                     let _span = trace_span!(target: "engine::tree::payload_processor::sparse_trie", "hashing_state_update", n = state.len()).entered();
                     let hashed = evm_state_to_hashed_post_state(state);
                     SparseTrieTaskMessage::HashedState(hashed)
@@ -344,9 +353,8 @@ where
                 if self.proof_result_rx.is_empty() {
                     self.trie.calculate_subtries();
                 }
-            } else if self.updates.is_empty() || self.pending_updates > MAX_PENDING_UPDATES {
-                // If we don't have any pending updates OR we've accumulated a lot already, apply
-                // them to the trie,
+            } else if self.updates.is_empty() {
+                // If we don't have any pending updates, apply them to the trie,
                 t = Instant::now();
                 self.process_new_updates()?;
                 self.metrics.sparse_trie_process_updates_duration_histogram.record(t.elapsed());
@@ -415,7 +423,14 @@ where
             SparseTrieTaskMessage::HashedState(hashed_state) => {
                 self.on_hashed_state_update(hashed_state)
             }
-            SparseTrieTaskMessage::FinishedStateUpdates => self.finished_state_updates = true,
+            SparseTrieTaskMessage::FinishedStateUpdates => {
+                let _ = self
+                    .final_hashed_state_tx
+                    .take()
+                    .unwrap()
+                    .send(core::mem::take(&mut self.final_hashed_state));
+                self.finished_state_updates = true
+            }
         }
     }
 
@@ -453,13 +468,13 @@ where
         skip_all
     )]
     fn on_hashed_state_update(&mut self, hashed_state_update: HashedPostState) {
-        for (address, storage) in hashed_state_update.storages {
+        for (&address, storage) in &hashed_state_update.storages {
             if !storage.storage.is_empty() {
                 // Look up outer maps once per address instead of once per slot.
                 let new_updates = self.new_storage_updates.entry(address).or_default();
                 let mut existing_updates = self.storage_updates.get_mut(&address);
 
-                for (slot, value) in storage.storage {
+                for (&slot, &value) in &storage.storage {
                     self.trie.record_slot_touch(address, slot);
 
                     let encoded = if value.is_zero() {
@@ -485,7 +500,7 @@ where
             self.pending_account_updates.entry(address).or_insert(None);
         }
 
-        for (address, account) in hashed_state_update.accounts {
+        for (&address, &account) in &hashed_state_update.accounts {
             self.trie.record_account_touch(address);
 
             // Track account as touched.
@@ -498,6 +513,8 @@ where
             // it will be updated in the accounts trie.
             self.pending_account_updates.insert(address, Some(account));
         }
+
+        self.final_hashed_state.extend(hashed_state_update);
     }
 
     fn on_proof_result(
@@ -1009,6 +1026,7 @@ mod tests {
         let mut task = SparseTrieCacheTask::new_with_trie(
             &runtime,
             updates_rx,
+            std::sync::mpsc::channel().0,
             proof_worker_handle,
             MultiProofTaskMetrics::default(),
             trie,
diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index a72320e21aa..99286751412 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -40,27 +40,26 @@
 
 use crate::tree::{
     error::{InsertBlockError, InsertBlockErrorKind, InsertPayloadError},
-    instrumented_state::{InstrumentedStateProvider, StateProviderStats},
+    instrumented_state::{InstrumentedStateProvider, StateProviderMetrics, StateProviderStats},
     multiproof::{StateRootComputeOutcome, StateRootHandle},
     payload_processor::PayloadProcessor,
     precompile_cache::{CachedPrecompile, CachedPrecompileMetrics, PrecompileCacheMap},
+    types::{InsertPayloadResult, ValidationOutput},
     CacheWaitDurations, CachedStateProvider, EngineApiMetrics, EngineApiTreeState, ExecutionEnv,
     PayloadHandle, StateProviderBuilder, StateProviderDatabase, TreeConfig, WaitForCaches,
 };
 use alloy_consensus::transaction::{Either, TxHashRef};
-use alloy_eip7928::{
-    bal::{Bal, DecodedBal},
-    BlockAccessList,
-};
+use alloy_eip7928::{bal::DecodedBal, compute_block_access_list_hash, BlockAccessList};
 use alloy_eips::{eip1898::BlockWithParent, eip4895::Withdrawal, NumHash};
 use alloy_evm::Evm;
 use alloy_primitives::{map::B256Set, B256};
+use reth_tasks::LazyHandle;
 #[cfg(feature = "trie-debug")]
 use reth_trie_sparse::debug_recorder::TrieDebugRecorder;
 
 use crate::tree::payload_processor::receipt_root_task::{IndexedReceipt, ReceiptRootTaskHandle};
 use reth_chain_state::{
-    CanonicalInMemoryState, DeferredTrieData, ExecutedBlock, ExecutionTimingStats, LazyOverlay,
+    CanonicalInMemoryState, DeferredTrieData, ExecutedBlock, ExecutionTimingStats,
 };
 use reth_consensus::{ConsensusError, FullConsensus, ReceiptRootBloom};
 use reth_engine_primitives::{
@@ -71,16 +70,17 @@ use reth_evm::{
     block::BlockExecutor, execute::ExecutableTxFor, ConfigureEvm, EvmEnvFor, ExecutionCtxFor,
     OnStateHook, SpecFor,
 };
-use reth_execution_cache::{CacheStats, SavedCache};
+use reth_execution_cache::{CacheFillMode, CacheStats, SavedCache};
 use reth_payload_primitives::{
-    BuiltPayload, InvalidPayloadAttributesError, NewPayloadError, PayloadTypes,
+    BuiltPayload, BuiltPayloadExecutedBlock, InvalidPayloadAttributesError, NewPayloadError,
+    PayloadTypes,
 };
 use reth_primitives_traits::{
     AlloyBlockHeader, BlockBody, BlockTy, FastInstant as Instant, GotExpected, NodePrimitives,
     RecoveredBlock, SealedBlock, SealedHeader, SignerRecoverable, TxTy,
 };
 use reth_provider::{
-    providers::{OverlayBuilder, OverlayStateProviderFactory},
+    providers::{OverlayBuilder, OverlayStateProvider, OverlayStateProviderFactory},
     BlockExecutionOutput, BlockNumReader, BlockReader, ChangeSetReader, DatabaseProviderFactory,
     DatabaseProviderROFactory, HashedPostStateProvider, ProviderError, PruneCheckpointReader,
     StageCheckpointReader, StateProvider, StateProviderBox, StateProviderFactory, StateReader,
@@ -101,20 +101,24 @@ use std::{
     },
     time::Duration,
 };
-use tracing::{debug, debug_span, error, info, instrument, trace, warn, Span};
+use tracing::{debug, debug_span, error, info, instrument, trace, warn, Level, Span};
 
-/// Output of block or payload validation.
-pub type ValidationOutcome<N, E = InsertPayloadError<BlockTy<N>>> =
-    Result<(ExecutedBlock<N>, Option<Box<ExecutionTimingStats>>), E>;
+pub use crate::tree::types::ValidationOutcome;
 
 /// Handle to a [`HashedPostState`] computed on a background thread.
-type LazyHashedPostState = reth_tasks::LazyHandle<HashedPostState>;
+type LazyHashedPostState = reth_tasks::LazyHandle<Arc<HashedPostState>>;
 
-/// Result type for block validation with optional timing stats.
-type InsertPayloadResult<N> = Result<
-    (ExecutedBlock<N>, Option<Box<ExecutionTimingStats>>),
-    InsertPayloadError<<N as NodePrimitives>::Block>,
->;
+/// Multiplier over the parent's gas limit beyond which a block's claimed gas usage cannot be
+/// legitimate. Gas limit can change by at most 1/1024 per block, so anything over this is rejected
+/// without entering execution.
+const MAX_EXPECTED_GAS_USAGE_MULTIPLIER: u64 = 2;
+
+/// Worker name for deferred trie data and changeset provider preparation.
+const DEFERRED_TRIE_WORKER_NAME: &str = "deferred-trie";
+
+type ReceiptRootSender<N> =
+    crossbeam_channel::Sender<IndexedReceipt<<N as NodePrimitives>::Receipt>>;
+type ReceiptRootReceiver = tokio::sync::oneshot::Receiver<(B256, alloy_primitives::Bloom)>;
 
 /// Context providing access to tree state during validation.
 ///
@@ -200,6 +204,8 @@ where
     changeset_cache: ChangesetCache,
     /// Task runtime for spawning parallel work.
     runtime: reth_tasks::Runtime,
+    /// Custom state root computation function.
+    custom_state_root: Option<CustomStateRoot<Evm::Primitives>>,
 }
 
 impl<N, P, Evm, V> BasicEngineValidator<P, Evm, V>
@@ -255,9 +261,16 @@ where
             validator,
             changeset_cache,
             runtime,
+            custom_state_root: None,
         }
     }
 
+    /// Sets a custom state root computation handler.
+    pub fn with_custom_state_root(mut self, custom_state_root: CustomStateRoot<N>) -> Self {
+        self.custom_state_root = Some(custom_state_root);
+        self
+    }
+
     /// Converts a [`BlockOrPayload`] to a recovered block.
     #[instrument(level = "debug", target = "engine::tree::payload_validator", skip_all)]
     pub fn convert_to_block<T: PayloadTypes<BuiltPayload: BuiltPayload<Primitives = N>>>(
@@ -328,48 +341,6 @@ where
         }
     }
 
-    /// Handles execution errors by checking if header validation errors should take precedence.
-    ///
-    /// When an execution error occurs, this function checks if there are any header validation
-    /// errors that should be reported instead, as header validation errors have higher priority.
-    fn handle_execution_error<T: PayloadTypes<BuiltPayload: BuiltPayload<Primitives = N>>>(
-        &self,
-        input: BlockOrPayload<T>,
-        execution_err: InsertBlockErrorKind,
-        parent_block: &SealedHeader<N::BlockHeader>,
-    ) -> InsertPayloadResult<N>
-    where
-        V: PayloadValidator<T, Block = N::Block>,
-    {
-        debug!(
-            target: "engine::tree::payload_validator",
-            ?execution_err,
-            block = ?input.num_hash(),
-            "Block execution failed, checking for header validation errors"
-        );
-
-        // If execution failed, we should first check if there are any header validation
-        // errors that take precedence over the execution error
-        let block = self.convert_to_block(input)?;
-
-        // Validate block consensus rules which includes header validation
-        if let Err(consensus_err) = self.validate_block_inner(&block, None) {
-            // Header validation error takes precedence over execution error
-            return Err(InsertBlockError::new(block, consensus_err.into()).into())
-        }
-
-        // Also validate against the parent
-        if let Err(consensus_err) =
-            self.consensus.validate_header_against_parent(block.sealed_header(), parent_block)
-        {
-            // Parent validation error takes precedence over execution error
-            return Err(InsertBlockError::new(block, consensus_err.into()).into())
-        }
-
-        // No header validation errors, return the original execution error
-        Err(InsertBlockError::new(block, execution_err).into())
-    }
-
     /// Validates a block that has already been converted from a payload.
     ///
     /// This method performs:
@@ -396,47 +367,28 @@ where
         Evm: ConfigureEngineEvm<T::ExecutionData, Primitives = N>,
         TxTy<N>: reth_firehose::mapper::SignatureFields,
     {
-        // Spawn payload conversion on a background thread so it runs concurrently with the
-        // rest of the function (setup + execution). For payloads this overlaps the cost of
-        // RLP decoding + header hashing.
-        let is_payload = matches!(&input, BlockOrPayload::Payload(_));
-        let mut convert_to_block_handle = match &input {
-            BlockOrPayload::Payload(_) => {
-                let payload_clone = input.clone();
-                let validator = self.validator.clone();
-                let handle = self.payload_processor.executor().spawn_blocking_named(
-                    "payload-convert",
-                    move || {
-                        let BlockOrPayload::Payload(payload) = payload_clone else {
-                            unreachable!()
-                        };
-                        validator.convert_payload_to_block(payload)
-                    },
-                );
-                Some(handle)
+        let parent_hash = input.parent_hash();
+
+        // Fetch parent block. This goes to memory most of the time unless the parent block is
+        // beyond the in-memory buffer.
+        let parent_block = match self.sealed_header_by_hash(parent_hash, ctx.state()) {
+            Ok(Some(parent_block)) => parent_block,
+            Ok(None) => {
+                return Err(InsertBlockError::new(
+                    self.convert_to_block(input)?,
+                    ProviderError::HeaderNotFound(parent_hash.into()).into(),
+                )
+                .into())
+            }
+            Err(e) => {
+                return Err(InsertBlockError::new(self.convert_to_block(input)?, e.into()).into())
             }
-            BlockOrPayload::Block(_) => None,
         };
 
-        // Returns the sealed block, either by awaiting the background conversion task (for
-        // payloads) or by extracting the already-converted block directly.
-        //
-        // Dispatches on the variant of the `input` it is handed rather than on the variant seen at
-        // spawn time, which makes it callable more than once: the Firehose preamble below resolves
-        // the block eagerly and rebuilds `input` as a `Block`, so the later call site returns the
-        // already-sealed block directly instead of touching the (already-consumed) conversion
-        // handle.
-        let mut convert_to_block =
-            move |input: BlockOrPayload<T>| -> Result<SealedBlock<N::Block>, NewPayloadError> {
-                match input {
-                    BlockOrPayload::Block(block) => Ok(block),
-                    BlockOrPayload::Payload(_) => convert_to_block_handle
-                        .take()
-                        .expect("sole handle")
-                        .try_into_inner()
-                        .expect("sole handle"),
-                }
-            };
+        // Spawn payload conversion and basic validation on a background thread so it runs
+        // concurrently with the rest of the function (setup + execution). For payloads this
+        // overlaps the cost of RLP decoding + header hashing.
+        let validated_block = self.spawn_convert_and_validate(&input, parent_block.clone());
 
         /// A helper macro that returns the block in case there was an error
         /// This macro is used for early returns before block conversion
@@ -445,7 +397,7 @@ where
                 match $expr {
                     Ok(val) => val,
                     Err(e) => {
-                        let block = convert_to_block(input)?;
+                        let block = validated_block.try_into_inner().expect("sole handle")?;
                         return Err(InsertBlockError::new(block, e.into()).into())
                     }
                 }
@@ -466,7 +418,17 @@ where
             };
         }
 
-        let parent_hash = input.parent_hash();
+        // If the gas usage is suspiciously high (multiple times higher than parent's gas limit), be
+        // cautious and block on pre-execution checks of the block.
+        if input.gas_used() > parent_block.gas_limit() * MAX_EXPECTED_GAS_USAGE_MULTIPLIER {
+            // Call `.get()` to await the pre-execution checks and exit early if they fail.
+            if validated_block.get().is_err() {
+                return Err(validated_block
+                    .try_into_inner()
+                    .expect("sole handle")
+                    .expect_err("Err result checked"))
+            }
+        }
 
         trace!(target: "engine::tree::payload_validator", "Fetching block state provider");
         let _enter =
@@ -476,25 +438,13 @@ where
         else {
             // this is pre-validated in the tree
             return Err(InsertBlockError::new(
-                convert_to_block(input)?,
+                validated_block.try_into_inner().expect("sole handle")?,
                 ProviderError::HeaderNotFound(parent_hash.into()).into(),
             )
             .into())
         };
-        let mut state_provider = ensure_ok!(provider_builder.build());
         drop(_enter);
 
-        // Fetch parent block. This goes to memory most of the time unless the parent block is
-        // beyond the in-memory buffer.
-        let Some(parent_block) = ensure_ok!(self.sealed_header_by_hash(parent_hash, ctx.state()))
-        else {
-            return Err(InsertBlockError::new(
-                convert_to_block(input)?,
-                ProviderError::HeaderNotFound(parent_hash.into()).into(),
-            )
-            .into())
-        };
-
         let evm_env = debug_span!(target: "engine::tree::payload_validator", "evm_env")
             .in_scope(|| self.evm_env_for(&input))
             .map_err(NewPayloadError::other)?;
@@ -502,9 +452,13 @@ where
         // 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_err(|err| ConsensusError::BlockAccessListInvalid(err.to_string())))
         .map(Arc::new);
 
+        if let Some(decoded_bal) = decoded_bal.as_deref() {
+            ensure_ok!(Self::validate_received_bal_gas(decoded_bal, input.gas_limit()));
+        }
+
         let env = ExecutionEnv {
             evm_env,
             hash: input.hash(),
@@ -528,102 +482,156 @@ where
         // Get an iterator over the transactions in the payload
         let txs = self.tx_iterator_for(&input)?;
 
-        // 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_builder = Self::overlay_builder_for_parent(
+            parent_hash,
+            ctx.state(),
+            self.changeset_cache.clone(),
+        );
         let overlay_factory =
             OverlayStateProviderFactory::new(provider_factory.clone(), overlay_builder.clone());
+        let changeset_provider = self.spawn_changeset_provider_task(overlay_factory.clone());
+
+        let parallel_bal_execution = ensure_ok!(self.bal_path_eligible(env.decoded_bal.as_deref()));
 
         // Spawn the appropriate processor based on strategy
         let mut handle = ensure_ok!(self.spawn_payload_processor(
             env.clone(),
             txs,
             provider_builder.clone(),
-            overlay_factory.clone(),
-            strategy,
+            overlay_factory,
+            &strategy,
+            parallel_bal_execution,
         ));
 
         // Create optional cache stats for detailed block logging
         let slow_block_enabled = self.config.slow_block_threshold().is_some();
         let cache_stats = slow_block_enabled.then(|| Arc::new(CacheStats::default()));
+        let instrument_state_provider = slow_block_enabled || self.config.state_provider_metrics();
+        let state_provider_metrics =
+            instrument_state_provider.then(|| StateProviderMetrics::with_source("engine"));
+        let state_provider_stats =
+            instrument_state_provider.then(|| Arc::new(StateProviderStats::default()));
+        let execution_cache = handle.caches().map(|caches| (caches, handle.cache_metrics()));
+
+        // This state provider factory is parametrized by:
+        //
+        // 1. fill_on_miss?
+        // 2. instrument_state_provider?
+        //
+        // `fill_on_miss` controls whether the loaded value after a cache miss will be inserted
+        // back into the cache. On a glance it seems to be always useful to do this. However,
+        // in practice, for the serial/non-BAL execution, it's not needed and is net negative:
+        //
+        // - It's not necessary because the revm machinery provides layer of caching itself. That
+        //   means a value for a miss will be recorded in revm's cache.
+        // - Inserting back into the cache is not free.
+        // - After execution, the execution post-state will be dumped into the execution cache as
+        //   whole anyway.
+        //
+        // Therefore, there `fill_on_miss` is going to be false for those paths.
+        //
+        // The second parameter `instrument_state_provider` controls whether we should
+        // instrument the state provider with metrics.
+        let make_state_provider = |fill_on_miss: bool| -> ProviderResult<StateProviderBox> {
+            let provider = provider_builder.build()?;
+            let mut provider = if let Some((caches, cache_metrics)) = &execution_cache {
+                let fill_mode = if fill_on_miss {
+                    CacheFillMode::FillOnMiss
+                } else {
+                    CacheFillMode::LookupOnly
+                };
+                Box::new(CachedStateProvider::new_with_mode(
+                    provider,
+                    caches.clone(),
+                    fill_mode,
+                    cache_metrics.clone(),
+                    cache_stats.clone(),
+                )) as StateProviderBox
+            } else {
+                provider
+            };
 
-        // Use cached state provider before executing, used in execution after prewarming threads
-        // complete
-        if let Some((caches, cache_metrics)) = handle.caches().zip(handle.cache_metrics()) {
-            state_provider = Box::new(
-                CachedStateProvider::new(state_provider, caches, cache_metrics)
-                    .with_cache_stats(cache_stats.clone()),
-            );
-        };
+            if instrument_state_provider {
+                let stats = state_provider_stats
+                    .as_ref()
+                    .expect("instrumented state provider requires shared stats");
+                let metrics = state_provider_metrics
+                    .as_ref()
+                    .expect("instrumented state provider requires metrics");
+                provider = Box::new(InstrumentedStateProvider::with_stats(
+                    provider,
+                    metrics.clone(),
+                    Arc::clone(stats),
+                ));
+            }
 
-        let state_provider_stats = if slow_block_enabled || self.config.state_provider_metrics() {
-            let instrumented_state_provider =
-                InstrumentedStateProvider::new(state_provider, "engine");
-            let stats = slow_block_enabled.then(|| instrumented_state_provider.stats());
-            state_provider = Box::new(instrumented_state_provider);
-            stats
-        } else {
-            None
+            Ok(provider)
         };
 
-        // Firehose: when the tracer is active, resolve the sealed block synchronously so we can
-        // start the block-level tracer guard before execution. The guard emits
-        // `on_block_start`/`on_genesis_block` now and defers `on_block_end(None)` until
-        // `mark_verified()` runs after post-execution validation.
+        // Firehose: start a block tracer guard for the live engine path.
         //
-        // If any early return is taken between here and `mark_verified()`, the guard's Drop emits
-        // `on_block_end(Some(err))` so invalid blocks are never flushed downstream.
+        // If any early return is taken between here and `mark_verified()`, the guard's Drop
+        // emits `on_block_end(Some(err))` so invalid blocks are never flushed downstream.
         //
         // `finalized` is `None` on the live engine path: the consensus layer hasn't necessarily
-        // advanced the finalized head by the time we're validating a payload. The pipeline
-        // (staged-sync) path advertises the finalized ref itself.
-        //
-        // We resolve the block eagerly here and rebuild `input` as a `Block` variant so the later
-        // `convert_to_block(input)?` site becomes a cheap unwrap of the already-sealed block.
+        // advanced the finalized head by the time we're validating a payload.
         //
-        // Block 1 is the genesis marker: `start` emits `on_genesis_block` as a standalone event and
-        // does NOT leave the tracer in "block state", so wrapping the executor would panic in
-        // `on_system_call_start`. Let the guard drop (a no-op for genesis) and fall through to the
-        // non-Firehose execution path.
-        let (mut fh_tracer, input): (Option<reth_firehose::FirehoseBlockTracer>, _) =
+        // Block 1 is the genesis marker: `start` emits `on_genesis_block` as a
+        // standalone event and does NOT leave the tracer in "block state", so wrapping the
+        // executor would panic in `on_system_call_start`. When the converted block is not yet
+        // available (get() not ready or error), fall through to the non-Firehose path.
+        let mut fh_tracer: Option<reth_firehose::FirehoseBlockTracer> =
             if reth_firehose::is_tracer_initialized() {
-                let sealed = convert_to_block(input)?;
-                let tracer = reth_firehose::FirehoseBlockTracer::start::<N>(&sealed, None);
-                let fh_tracer = (!tracer.is_genesis()).then_some(tracer);
-                (fh_tracer, BlockOrPayload::Block(sealed))
+                // get() blocks until the background conversion/validation task completes and
+                // returns a reference to the Result<SealedBlock, _>.
+                match validated_block.get().as_ref() {
+                    Ok(sealed) => {
+                        let tracer = reth_firehose::FirehoseBlockTracer::start::<N>(sealed, None);
+                        (!tracer.is_genesis()).then_some(tracer)
+                    }
+                    Err(_) => None,
+                }
             } else {
-                (None, input)
+                None
             };
 
         // Execute the block and handle any execution errors.
         // The receipt root task is spawned before execution and receives receipts incrementally
         // as transactions complete, allowing parallel computation during execution.
-        //
-        // Two entry points exist for the same work: `execute_block` is the upstream-pristine path
-        // and `execute_and_trace_block` is its Firehose-enabled twin. We pick based on whether a
-        // live tracer guard is available for this block (see the Firehose preamble above for when
-        // the guard is `None` — notably the block-1 genesis marker).
         let execute_block_start = Instant::now();
-        let (output, senders, receipt_root_rx) = match fh_tracer.as_mut() {
-            Some(tracer) => {
-                match self.execute_and_trace_block(state_provider, env, &input, tracer, &mut handle)
-                {
-                    Ok(output) => output,
-                    Err(err) => return self.handle_execution_error(input, err, &parent_block),
-                }
+        let execution_result = if let Some(ref mut tracer) = fh_tracer {
+            // Firehose-traced execution path: re-executes with FirehoseInspector so live
+            // blocks from the engine tree (newPayload/FCU path) emit tracer events. The tracer
+            // guard is kept alive until mark_verified() below; any early return (via the
+            // ensure_ok! on execution_result) drops the guard which calls on_block_end(Some(err)).
+            //
+            // BAL parallel execution is incompatible with sequential Firehose tracing, so this
+            // path never produces a BlockAccessList.
+            match make_state_provider(false) {
+                Ok(state_provider) => self
+                    .execute_and_trace_block(state_provider, env, &input, &mut handle, tracer)
+                    .map(|(output, senders, receipt_root_rx)| {
+                        (output, senders, receipt_root_rx, None)
+                    }),
+                Err(err) => Err(err.into()),
+            }
+        } else if parallel_bal_execution {
+            self.execute_block_bal(env, &input, &handle, &make_state_provider)
+        } else {
+            let state_provider = make_state_provider(false);
+            match state_provider {
+                Ok(state_provider) => self.execute_block(state_provider, env, &input, &mut handle),
+                Err(err) => Err(err.into()),
             }
-            None => match self.execute_block(state_provider, env, &input, &mut handle) {
-                Ok(output) => output,
-                Err(err) => return self.handle_execution_error(input, err, &parent_block),
-            },
         };
         let execution_duration = execute_block_start.elapsed();
+        if let (Some(metrics), Some(stats)) = (&state_provider_metrics, &state_provider_stats) {
+            metrics.record_totals(stats);
+        }
+        let (output, senders, receipt_root_rx, built_bal) = ensure_ok!(execution_result);
 
         // After executing the block we can stop prewarming transactions
         handle.stop_prewarming_execution();
@@ -642,28 +650,23 @@ where
         // (keccak256 hashing of all changed addresses and storage slots).
         let hashed_state_output = output.clone();
         let hashed_state_provider = self.provider.clone();
-        let hashed_state: LazyHashedPostState =
+        let mut hashed_state_rx = handle.take_hashed_state_rx();
+        let mut hashed_state: LazyHashedPostState =
             self.payload_processor.executor().spawn_blocking_named("hash-post-state", move || {
                 let _span = debug_span!(
                     target: "engine::tree::payload_validator",
                     "hashed_post_state",
                 )
                 .entered();
-                hashed_state_provider.hashed_post_state(&hashed_state_output.state)
+                let state = if let Some(Ok(state)) = hashed_state_rx.as_mut().map(|rx| rx.recv()) {
+                    state
+                } else {
+                    hashed_state_provider.hashed_post_state(&hashed_state_output.state)
+                };
+                Arc::new(state)
             });
 
-        let block = convert_to_block(input)?;
-        let transaction_root = is_payload.then(|| {
-            let body = block.body().clone();
-            let parent_span = Span::current();
-            let num_hash = block.num_hash();
-            self.payload_processor.executor().spawn_blocking_named("payload-tx-root", move || {
-                let _span =
-                    debug_span!(target: "engine::tree::payload_validator", parent: parent_span, "payload_tx_root", block = ?num_hash)
-                        .entered();
-                body.calculate_tx_root()
-            })
-        });
+        let block = validated_block.try_into_inner().expect("sole handle")?;
         let block = block.with_senders(senders);
 
         // Wait for the receipt root computation to complete.
@@ -684,26 +687,31 @@ where
                 })
                 .ok()
         };
-        let transaction_root = transaction_root.map(|handle| {
-            let _span =
-                debug_span!(target: "engine::tree::payload_validator", "wait_payload_tx_root")
-                    .entered();
-            handle.try_into_inner().expect("sole handle")
-        });
 
-        let hashed_state = ensure_ok_post_block!(
+        ensure_ok_post_block!(
             self.validate_post_execution(
                 &block,
                 &parent_block,
                 &output,
                 &mut ctx,
-                transaction_root,
                 receipt_root_bloom,
-                hashed_state,
+                built_bal
             ),
             block
         );
 
+        // Run the hashed state validation hook but don't propagate the error yet. If the state root
+        // task fails, we might need to re-run this check against a fallback state.
+        let mut hashed_state_validate_result = debug_span!(target: "engine::tree::payload_validator", "validate_block_post_execution_with_hashed_state").in_scope(|| {
+            // Wait for the background keccak256 hashing task to complete. This blocks until
+            // all changed addresses and storage slots have been hashed.
+            let hashed_state_ref =
+                debug_span!(target: "engine::tree::payload_validator", "wait_hashed_post_state")
+                    .in_scope(|| hashed_state.get());
+
+            self.validator.validate_block_post_execution_with_hashed_state(hashed_state_ref, &block)
+        });
+
         let root_time = Instant::now();
         let mut maybe_state_root = None;
         let mut state_root_task_failed = false;
@@ -718,18 +726,21 @@ where
                     self.await_state_root_with_timeout(
                         &mut handle,
                         provider_builder.clone(),
-                        &hashed_state,
+                        output.clone(),
                     ),
                     block
                 );
 
-                match task_result {
-                    Ok(StateRootComputeOutcome {
-                        state_root,
-                        trie_updates,
-                        #[cfg(feature = "trie-debug")]
-                        debug_recorders,
-                    }) => {
+                let maybe_new_hashed_state = match task_result {
+                    Ok((
+                        StateRootComputeOutcome {
+                            state_root,
+                            trie_updates,
+                            #[cfg(feature = "trie-debug")]
+                            debug_recorders,
+                        },
+                        maybe_new_hashed_state,
+                    )) => {
                         let elapsed = root_time.elapsed();
                         info!(target: "engine::tree::payload_validator", ?state_root, ?elapsed, "State root task finished");
 
@@ -744,7 +755,7 @@ where
                                 provider_builder.clone(),
                                 provider_factory,
                                 overlay_builder,
-                                &hashed_state,
+                                &output,
                                 trie_updates.as_ref().clone(),
                             );
                             #[cfg(feature = "trie-debug")]
@@ -773,11 +784,28 @@ where
                             );
                             state_root_task_failed = true;
                         }
+
+                        maybe_new_hashed_state
                     }
                     Err(error) => {
                         debug!(target: "engine::tree::payload_validator", %error, "State root task failed");
                         state_root_task_failed = true;
+                        None
                     }
+                };
+
+                // If the state root task failed or we got a new hashed state from the fallback that
+                // won the race, we need to replace the hashed state handle and re-run the
+                // validation.
+                if maybe_new_hashed_state.is_some() || state_root_task_failed {
+                    hashed_state = maybe_new_hashed_state.unwrap_or_else(|| {
+                        LazyHandle::ready(Arc::new(self.provider.hashed_post_state(&output.state)))
+                    });
+                    hashed_state_validate_result =
+                        self.validator.validate_block_post_execution_with_hashed_state(
+                            hashed_state.get(),
+                            &block,
+                        );
                 }
             }
             StateRootStrategy::Parallel => {
@@ -803,6 +831,18 @@ where
                 }
             }
             StateRootStrategy::Synchronous => {}
+            StateRootStrategy::Custom(custom) => {
+                let (state_root, trie_updates) = ensure_ok_post_block!(
+                    custom(CustomStateRootInput {
+                        block: &block,
+                        parent_block: &parent_block,
+                        output: &output,
+                        hashed_state: &hashed_state,
+                    }),
+                    block
+                );
+                maybe_state_root = Some((state_root, Arc::new(trie_updates), root_time.elapsed()));
+            }
         }
 
         // Determine the state root.
@@ -835,6 +875,12 @@ where
             (root, Arc::new(updates), root_time.elapsed())
         };
 
+        if let Err(err) = hashed_state_validate_result {
+            // call post-block hook
+            self.on_invalid_block(&parent_block, &block, &output, None, ctx.state_mut());
+            return Err(InsertBlockError::new(block.into_sealed_block(), err.into()).into())
+        }
+
         self.metrics.block_validation.record_state_root(&trie_output, root_elapsed.as_secs_f64());
         self.metrics
             .record_state_root_gas_bucket(block.header().gas_used(), root_elapsed.as_secs_f64());
@@ -864,7 +910,7 @@ where
             .into())
         }
 
-        let timing_stats = state_provider_stats.map(|stats| {
+        let timing_stats = state_provider_stats.filter(|_| slow_block_enabled).map(|stats| {
             self.calculate_timing_stats(
                 &block,
                 stats,
@@ -879,12 +925,13 @@ where
             let _ = valid_block_tx.send(());
         }
 
-        // Create the overlay provider NOW, while we're on the engine loop thread and trie changeset
-        // eviction cannot race with us. If we deferred this to the background task, persistence
-        // could advance and evict changeset cache entries between factory creation and the task
-        // actually running, causing expensive DB fallback computations when building the overlay.
-        let changeset_provider =
-            ensure_ok_post_block!(overlay_factory.database_provider_ro(), block);
+        let changeset_provider = ensure_ok_post_block!(
+            changeset_provider
+                .try_into_inner()
+                .ok()
+                .expect("changeset provider handle is not cloned"),
+            block
+        );
 
         // All post-execution validations passed — flush the Firehose block. Placed after the last
         // fallible step so any earlier failure instead drops the guard (emitting
@@ -894,14 +941,92 @@ where
         }
 
         let executed_block = self.spawn_deferred_trie_task(
-            block,
+            Arc::new(block),
             output,
-            &ctx,
             hashed_state,
             trie_output,
             changeset_provider,
         );
-        Ok((executed_block, timing_stats))
+        Ok(ValidationOutput::new(executed_block, timing_stats))
+    }
+
+    /// Spawns a background task to convert a [`BlockOrPayload`] into a [`SealedBlock`] and perform
+    /// basic consensus validations on it.
+    #[expect(clippy::type_complexity)]
+    pub fn spawn_convert_and_validate<T>(
+        &self,
+        input: &BlockOrPayload<T>,
+        parent: SealedHeader<N::BlockHeader>,
+    ) -> LazyHandle<Result<SealedBlock<N::Block>, InsertPayloadError<N::Block>>>
+    where
+        T: PayloadTypes<BuiltPayload: BuiltPayload<Primitives = N>>,
+        V: PayloadValidator<T, Block = N::Block> + Clone,
+    {
+        let input = input.clone();
+        let validator = self.validator.clone();
+        let consensus = self.consensus.clone();
+        let parent_span = Span::current();
+        self.payload_processor.executor().spawn_blocking_named("payload-convert", move || {
+            let _span = debug_span!(
+                target: "engine::tree::payload_validator",
+                parent: parent_span,
+                "convert_and_validate",
+            )
+            .entered();
+            let block = match input {
+                BlockOrPayload::Block(block) => block,
+                BlockOrPayload::Payload(payload) => {
+                    validator.convert_payload_to_block(payload)?
+                }
+            };
+
+            if let Err(e) = consensus.validate_header(block.sealed_header()) {
+                error!(target: "engine::tree::payload_validator", ?block, "Failed to validate header {}: {e}", block.hash());
+                return Err(InsertBlockError::consensus_error(e, block).into())
+            }
+
+            // now validate against the parent
+            let _enter = debug_span!(target: "engine::tree::payload_validator", "validate_header_against_parent").entered();
+            if let Err(e) = consensus.validate_header_against_parent(block.sealed_header(), &parent)
+            {
+                warn!(target: "engine::tree::payload_validator", ?block, "Failed to validate header {} against parent: {e}", block.hash());
+                return Err(InsertBlockError::consensus_error(e, block).into())
+            }
+            drop(_enter);
+
+            if let Err(e) =
+                consensus.validate_block_pre_execution_with_tx_root(&block, None)
+            {
+                error!(target: "engine::tree::payload_validator", ?block, "Failed to validate block {}: {e}", block.hash());
+                return Err(InsertBlockError::consensus_error(e, block).into())
+            }
+
+            Ok(block)
+        })
+    }
+
+    /// Spawns a background task that creates the changeset provider used by the deferred trie
+    /// producer.
+    ///
+    /// This is started before execution so overlay construction can run concurrently with payload
+    /// validation, then awaited before the deferred trie producer is spawned.
+    fn spawn_changeset_provider_task(
+        &self,
+        overlay_factory: OverlayStateProviderFactory<P, N>,
+    ) -> LazyHandle<ProviderResult<OverlayStateProvider<P::Provider>>> {
+        let parent_span = Span::current();
+        self.payload_processor.executor().spawn_blocking_named(
+            DEFERRED_TRIE_WORKER_NAME,
+            move || {
+                let _span = debug_span!(
+                    target: "engine::tree::payload_validator",
+                    parent: parent_span,
+                    "changeset_provider",
+                )
+                .entered();
+                overlay_factory.database_provider_ro()
+            },
+        )
     }
 
     /// Return sealed block header from database or in-memory state by hash.
@@ -920,27 +1045,11 @@ where
         }
     }
 
-    /// Validate if block is correct and satisfies all the consensus rules that concern the header
-    /// and block body itself.
-    #[instrument(level = "debug", target = "engine::tree::payload_validator", skip_all)]
-    fn validate_block_inner(
-        &self,
-        block: &SealedBlock<N::Block>,
-        transaction_root: Option<B256>,
+    fn validate_received_bal_gas(
+        decoded_bal: &DecodedBal,
+        gas_limit: u64,
     ) -> Result<(), ConsensusError> {
-        if let Err(e) = self.consensus.validate_header(block.sealed_header()) {
-            error!(target: "engine::tree::payload_validator", ?block, "Failed to validate header {}: {e}", block.hash());
-            return Err(e)
-        }
-
-        if let Err(e) =
-            self.consensus.validate_block_pre_execution_with_tx_root(block, transaction_root)
-        {
-            error!(target: "engine::tree::payload_validator", ?block, "Failed to validate block {}: {e}", block.hash());
-            return Err(e)
-        }
-
-        Ok(())
+        decoded_bal.as_bal().validate_gas_limit(gas_limit).map_err(ConsensusError::from)
     }
 
     /// Executes a block with the given state provider.
@@ -962,7 +1071,8 @@ where
         (
             BlockExecutionOutput<N::Receipt>,
             Vec<Address>,
-            tokio::sync::oneshot::Receiver<(B256, alloy_primitives::Bloom)>,
+            ReceiptRootReceiver,
+            Option<BlockAccessList>,
         ),
         InsertBlockErrorKind,
     >
@@ -975,10 +1085,12 @@ where
     {
         debug!(target: "engine::tree::payload_validator", "Executing block");
 
+        let has_bal = env.decoded_bal.is_some();
         let mut db = debug_span!(target: "engine::tree", "build_state_db").in_scope(|| {
             State::builder()
                 .with_database(StateProviderDatabase::new(state_provider))
                 .with_bundle_update()
+                .with_bal_builder_if(has_bal)
                 .build()
         });
 
@@ -1012,20 +1124,11 @@ where
             );
         }
 
-        // Spawn background task to compute receipt root and logs bloom incrementally.
-        // Unbounded channel is used since tx count bounds capacity anyway (max ~30k txs per block).
-        let receipts_len = input.transaction_count();
-        let (receipt_tx, receipt_rx) = crossbeam_channel::unbounded();
-        let (result_tx, result_rx) = tokio::sync::oneshot::channel();
-        let task_handle = ReceiptRootTaskHandle::new(receipt_rx, result_tx);
-        self.payload_processor
-            .executor()
-            .spawn_blocking_named("receipt-root", move || task_handle.run(receipts_len));
-
         let transaction_count = input.transaction_count();
+        let (receipt_tx, result_rx) = self.spawn_receipt_root_task(transaction_count);
         let executed_tx_index = Arc::clone(handle.executed_tx_index());
-        let executor = executor.with_state_hook(
-            handle.state_hook().map(|hook| Box::new(hook) as Box<dyn OnStateHook>),
+        executor.evm_mut().db_mut().set_state_hook(
+            handle.state_hook().map(|hook| Box::new(hook) as Box<dyn OnStateHook + 'static>),
         );
 
         let execution_start = Instant::now();
@@ -1037,6 +1140,7 @@ where
             handle.iter_transactions(),
             &receipt_tx,
             &executed_tx_index,
+            has_bal,
         )?;
         drop(receipt_tx);
 
@@ -1051,6 +1155,7 @@ where
         debug_span!(target: "engine::tree", "merge_transitions")
             .in_scope(|| db.merge_transitions(BundleRetention::Reverts));
 
+        let built_bal = if has_bal { db.take_built_alloy_bal() } else { None };
         let output = BlockExecutionOutput { result, state: db.take_bundle() };
 
         let execution_duration = execution_start.elapsed();
@@ -1058,38 +1163,32 @@ where
         self.metrics.record_block_execution_gas_bucket(output.result.gas_used, execution_duration);
         debug!(target: "engine::tree::payload_validator", elapsed = ?execution_duration, "Executed block");
 
-        Ok((output, senders, result_rx))
+        Ok((output, senders, result_rx, built_bal))
     }
 
     /// Firehose-enabled twin of [`Self::execute_block`].
     ///
-    /// This is a copy of `execute_block` with two surgical differences:
-    ///   - the EVM is constructed via `evm_with_env_and_inspector` with a `FirehoseInspector`
+    /// This is a near line-for-line copy of `execute_block` with two surgical differences:
+    ///   - the EVM is constructed via `evm_with_env_and_inspector` with a [`FirehoseInspector`]
     ///     borrowed from the supplied `tracer`;
     ///   - the resulting executor is wrapped in a
     ///     [`reth_firehose::executor::FirehoseWrappedExecutor`] so system-call boundaries and
     ///     withdrawals are funnelled into the tracer.
     ///
-    /// MAINTENANCE CONTRACT: keep this function in sync with [`Self::execute_block`]. Any change to
-    /// the upstream logic (new metrics, error handling, ordering of pre/post steps, etc.) must be
-    /// mirrored here. The intent of duplicating rather than branching is to keep the diff against
-    /// upstream minimal and localized: upstream's `execute_block` stays pristine, and the
+    /// MAINTENANCE CONTRACT: keep this function in sync with [`Self::execute_block`]. Any change
+    /// to the upstream logic (new metrics, error handling, ordering of pre/post steps, etc.) must
+    /// be mirrored here. The intent of duplicating rather than branching is to keep the diff
+    /// against upstream minimal and localized: upstream's `execute_block` stays pristine, and the
     /// Firehose-specific wiring lives here.
-    #[instrument(level = "debug", target = "engine::tree::payload_validator", skip_all)]
-    #[expect(clippy::type_complexity)]
     fn execute_and_trace_block<S, Err, T>(
         &mut self,
         state_provider: S,
         env: ExecutionEnv<Evm>,
         input: &BlockOrPayload<T>,
-        tracer: &mut reth_firehose::FirehoseBlockTracer,
         handle: &mut PayloadHandle<impl ExecutableTxFor<Evm>, Err, N::Receipt>,
+        tracer: &mut reth_firehose::FirehoseBlockTracer,
     ) -> Result<
-        (
-            BlockExecutionOutput<N::Receipt>,
-            Vec<Address>,
-            tokio::sync::oneshot::Receiver<(B256, alloy_primitives::Bloom)>,
-        ),
+        (BlockExecutionOutput<N::Receipt>, Vec<Address>, ReceiptRootReceiver),
         InsertBlockErrorKind,
     >
     where
@@ -1102,6 +1201,9 @@ where
     {
         debug!(target: "engine::tree::payload_validator", "Executing block (with Firehose tracing)");
 
+        // Note: BAL is not enabled on the Firehose tracing path because the FirehoseWrappedExecutor
+        // intercepts each transaction — the BAL parallel execution path is incompatible with the
+        // sequential Firehose tracing approach.
         let mut db = debug_span!(target: "engine::tree", "build_state_db").in_scope(|| {
             State::builder()
                 .with_database(StateProviderDatabase::new(state_provider))
@@ -1109,25 +1211,27 @@ where
                 .build()
         });
 
-        // Firehose-specific: install the inspector on the EVM and wrap the executor so that
-        // system-call boundaries and withdrawals are forwarded to the tracer. Withdrawals are
-        // pre-materialized here because the wrapper emits them as part of the end-of-block event.
-        let withdrawals =
-            input.withdrawals().map(|w| alloy_eips::eip4895::Withdrawals::new(w.to_vec()));
-        let (spec_id, mut executor) = {
+        let (spec_id, inner_executor) = {
             let _span = debug_span!(target: "engine::tree", "create_evm").entered();
             let spec_id = *env.evm_env.spec_id();
+            // Firehose-specific: install the inspector on the EVM so system-call boundaries and
+            // per-tx events are forwarded to the tracer.
             let inspector = tracer.inspector();
             let evm = self.evm_config.evm_with_env_and_inspector(&mut db, env.evm_env, inspector);
             let ctx = self
                 .execution_ctx_for(input)
                 .map_err(|e| InsertBlockErrorKind::Other(Box::new(e)))?;
             let inner = self.evm_config.create_executor(evm, ctx);
-            let executor =
-                reth_firehose::executor::FirehoseWrappedExecutor::new(inner, withdrawals);
-            (spec_id, executor)
+            (spec_id, inner)
         };
 
+        // Firehose-specific: wrap the inner executor so EIP-4895 withdrawal balance changes and
+        // system-call boundaries are emitted as tracer events.
+        let withdrawals =
+            input.withdrawals().map(|w| alloy_eips::eip4895::Withdrawals::new(w.to_vec()));
+        let mut executor =
+            reth_firehose::executor::FirehoseWrappedExecutor::new(inner_executor, withdrawals);
+
         if !self.config.precompile_cache_disabled() {
             let _span = debug_span!(target: "engine::tree", "setup_precompile_cache").entered();
             executor.evm_mut().precompiles_mut().map_cacheable_precompiles(
@@ -1147,31 +1251,24 @@ where
             );
         }
 
-        // Spawn background task to compute receipt root and logs bloom incrementally.
-        // Unbounded channel is used since tx count bounds capacity anyway (max ~30k txs per block).
-        let receipts_len = input.transaction_count();
-        let (receipt_tx, receipt_rx) = crossbeam_channel::unbounded();
-        let (result_tx, result_rx) = tokio::sync::oneshot::channel();
-        let task_handle = ReceiptRootTaskHandle::new(receipt_rx, result_tx);
-        self.payload_processor
-            .executor()
-            .spawn_blocking_named("receipt-root", move || task_handle.run(receipts_len));
-
         let transaction_count = input.transaction_count();
+        let (receipt_tx, result_rx) = self.spawn_receipt_root_task(transaction_count);
         let executed_tx_index = Arc::clone(handle.executed_tx_index());
-        let executor = executor.with_state_hook(
-            handle.state_hook().map(|hook| Box::new(hook) as Box<dyn OnStateHook>),
+        executor.evm_mut().db_mut().set_state_hook(
+            handle.state_hook().map(|hook| Box::new(hook) as Box<dyn OnStateHook + 'static>),
         );
 
         let execution_start = Instant::now();
 
-        // Execute all transactions and finalize
+        // Execute all transactions and finalize. BAL bumping is not needed here since we
+        // are not building a BAL in the Firehose tracing path.
         let (executor, senders) = self.execute_transactions(
             executor,
             transaction_count,
             handle.iter_transactions(),
             &receipt_tx,
             &executed_tx_index,
+            false, // has_bal: Firehose path does not build a BAL
         )?;
         drop(receipt_tx);
 
@@ -1196,6 +1293,115 @@ where
         Ok((output, senders, result_rx))
     }
 
+    /// Returns true when the BAL execute path should be used for this block.
+    // TODO: extend with stronger gating before enabling on mainnet:
+    //   - Fork check: `Amsterdam.active_at_timestamp(env.evm_env.timestamp)`. Today a BAL only
+    //     exists post-Amsterdam, so the BAL-presence check is a sufficient proxy. It is a proxy,
+    //     not a guarantee.
+    //   - Tx-count threshold (`bal_execute_path_min_tx_count`): below the parallelism break-even
+    //     point, provider setup and worker scheduling overhead can exceed the gain. Tune
+    //     empirically once workers are parallel; meaningless while the commit loop is sequential.
+    fn bal_path_eligible(&self, bal: Option<&DecodedBal>) -> Result<bool, InsertBlockErrorKind> {
+        let has_bal = bal.is_some();
+        let parallel_execution = has_bal && !self.config.disable_bal_parallel_execution();
+        if parallel_execution && self.config.disable_bal_parallel_state_root() {
+            return Err(InsertBlockErrorKind::Other(
+                "disabling parallel state root is impossible when parallel execution is enabled"
+                    .into(),
+            ));
+        }
+
+        Ok(parallel_execution)
+    }
+
+    /// Executes the block on the BAL path. Mirrors the return shape of [`Self::execute_block`]
+    /// so the dispatch site stays uniform.
+    ///
+    /// Inside, this:
+    /// 1. Creates a shared parent-state cache handle for provider-backed workers.
+    /// 2. Relies on BAL prewarm to stream sparse-trie updates and optional state prefetches.
+    /// 3. Spawns the receipt-root task.
+    /// 4. Calls [`crate::tree::payload_processor::bal::execute_block`].
+    /// 5. Returns the rebuilt BAL for post-execution consensus validation.
+    #[instrument(level = "debug", target = "engine::tree::payload_validator", skip_all)]
+    #[expect(clippy::type_complexity)]
+    fn execute_block_bal<Tx, Err, MakeStateProvider, T>(
+        &self,
+        env: ExecutionEnv<Evm>,
+        input: &BlockOrPayload<T>,
+        handle: &PayloadHandle<Tx, Err, N::Receipt>,
+        make_state_provider: &MakeStateProvider,
+    ) -> Result<
+        (
+            BlockExecutionOutput<N::Receipt>,
+            Vec<Address>,
+            ReceiptRootReceiver,
+            Option<BlockAccessList>,
+        ),
+        InsertBlockErrorKind,
+    >
+    where
+        Tx: ExecutableTxFor<Evm> + Send,
+        Err: core::error::Error + Send + Sync + 'static,
+        MakeStateProvider: Fn(bool) -> ProviderResult<StateProviderBox> + Sync,
+        Evm: ConfigureEngineEvm<T::ExecutionData, Primitives = N>,
+        T: PayloadTypes<BuiltPayload: BuiltPayload<Primitives = N>>,
+        V: PayloadValidator<T, Block = N::Block>,
+    {
+        debug!(target: "engine::tree::payload_validator", "Executing block via BAL path");
+
+        let (receipt_tx, result_rx) = self.spawn_receipt_root_task(env.transaction_count);
+        let input_bal = env.decoded_bal.ok_or_else(|| {
+            InsertBlockErrorKind::Other("BAL execute path: no decoded BAL available".into())
+        })?;
+
+        let make_db = |fill_on_miss| {
+            let provider = make_state_provider(fill_on_miss)
+                .map_err(crate::tree::payload_processor::bal::BalExecutionError::Provider)?;
+            Ok(StateProviderDatabase::new(provider))
+        };
+        let execution_start = Instant::now();
+        let ctx =
+            self.execution_ctx_for(input).map_err(|e| InsertBlockErrorKind::Other(Box::new(e)))?;
+        let (output, senders, built_bal) = crate::tree::payload_processor::bal::execute_block(
+            &self.runtime,
+            &self.evm_config,
+            &make_db,
+            input_bal,
+            env.evm_env,
+            ctx,
+            env.transaction_count,
+            handle.clone_transaction_receiver(),
+            receipt_tx,
+        )?;
+        let execution_duration = execution_start.elapsed();
+
+        self.metrics.record_block_execution(&output, execution_duration);
+        self.metrics.record_block_execution_gas_bucket(output.result.gas_used, execution_duration);
+        debug!(
+            target: "engine::tree::payload_validator",
+            elapsed = ?execution_duration,
+            "Executed block via BAL path",
+        );
+
+        Ok((output, senders, result_rx, Some(built_bal)))
+    }
+
+    fn spawn_receipt_root_task(
+        &self,
+        receipts_len: usize,
+    ) -> (ReceiptRootSender<N>, ReceiptRootReceiver) {
+        // Unbounded channel is used since tx count bounds capacity anyway.
+        let (receipt_tx, receipt_rx) = crossbeam_channel::unbounded();
+        let (result_tx, result_rx) = tokio::sync::oneshot::channel();
+        let task_handle = ReceiptRootTaskHandle::new(receipt_rx, result_tx);
+        self.payload_processor
+            .executor()
+            .spawn_blocking_named("receipt-root", move || task_handle.run(receipts_len));
+
+        (receipt_tx, result_rx)
+    }
+
     /// Executes transactions and collects senders, streaming receipts to a background task.
     ///
     /// This method handles:
@@ -1205,18 +1411,20 @@ where
     /// - Collecting transaction senders for later use
     ///
     /// Returns the executor (for finalization) and the collected senders.
-    fn execute_transactions<E, Tx, InnerTx, Err>(
+    fn execute_transactions<'a, E, Tx, InnerTx, Err, DB>(
         &self,
         mut executor: E,
         transaction_count: usize,
         transactions: impl Iterator<Item = Result<Tx, Err>>,
         receipt_tx: &crossbeam_channel::Sender<IndexedReceipt<N::Receipt>>,
         executed_tx_index: &AtomicUsize,
+        has_bal: bool,
     ) -> Result<(E, Vec<Address>), BlockExecutionError>
     where
-        E: BlockExecutor<Receipt = N::Receipt>,
+        E: BlockExecutor<Receipt = N::Receipt, Evm: alloy_evm::Evm<DB = &'a mut State<DB>>>,
         Tx: alloy_evm::block::ExecutableTx<E> + alloy_evm::RecoveredTx<InnerTx>,
         InnerTx: TxHashRef,
+        DB: revm::Database + 'a,
         Err: core::error::Error + Send + Sync + 'static,
     {
         let mut senders = Vec::with_capacity(transaction_count);
@@ -1227,6 +1435,11 @@ where
             .in_scope(|| executor.apply_pre_execution_changes())?;
         self.metrics.record_pre_execution(pre_exec_start.elapsed());
 
+        // Bump BAL index after pre-execution changes (EIP-7928: index 0 is pre-execution)
+        if has_bal {
+            executor.evm_mut().db_mut().bump_bal_index();
+        }
+
         // Execute transactions
         let exec_span = debug_span!(target: "engine::tree", "execution").entered();
         let mut transactions = transactions.into_iter();
@@ -1247,13 +1460,17 @@ where
 
             senders.push(tx_signer);
 
-            let _enter = debug_span!(
-                target: "engine::tree",
-                "execute tx",
-                tx_index = senders.len() - 1,
-            )
-            .entered();
-            trace!(target: "engine::tree", "Executing transaction");
+            let _enter = tracing::enabled!(target: "engine::tree", Level::TRACE).then(|| {
+                tracing::trace_span!(
+                    target: "engine::tree",
+                    "execute tx",
+                    tx_index = senders.len() - 1,
+                )
+                .entered()
+            });
+            if tracing::enabled!(target: "engine::tree", Level::TRACE) {
+                trace!(target: "engine::tree", "Executing transaction");
+            }
 
             let tx_start = Instant::now();
             executor.execute_transaction(tx)?;
@@ -1271,7 +1488,12 @@ where
                     let _ = receipt_tx.send(IndexedReceipt::new(tx_index, receipt.clone()));
                 }
             }
+            // Bump BAL index after each transaction (EIP-7928)
+            if has_bal {
+                executor.evm_mut().db_mut().bump_bal_index();
+            }
         }
+
         drop(exec_span);
 
         Ok((executor, senders))
@@ -1299,10 +1521,9 @@ 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_builder =
+            overlay_builder.with_extended_hashed_state_overlay(hashed_state.clone_into_sorted());
+        let overlay_factory = OverlayStateProviderFactory::new(provider_factory, overlay_builder);
         ParallelStateRoot::new(overlay_factory, prefix_sets, self.runtime.clone())
             .incremental_root_with_updates()
     }
@@ -1316,7 +1537,7 @@ where
         state_provider: StateProviderBox,
         hashed_state: &LazyHashedPostState,
     ) -> ProviderResult<(B256, TrieUpdates)> {
-        state_provider.state_root_with_updates(hashed_state.get().clone())
+        state_provider.state_root_with_updates(hashed_state.get().as_ref().clone())
     }
 
     /// Awaits the state root from the background task, with an optional timeout fallback.
@@ -1342,16 +1563,18 @@ where
         &self,
         handle: &mut PayloadHandle<Tx, Err, R>,
         state_provider_builder: StateProviderBuilder<N, P>,
-        hashed_state: &LazyHashedPostState,
-    ) -> ProviderResult<Result<StateRootComputeOutcome, ParallelStateRootError>> {
+        output: Arc<BlockExecutionOutput<R>>,
+    ) -> ProviderResult<
+        Result<(StateRootComputeOutcome, Option<LazyHashedPostState>), ParallelStateRootError>,
+    > {
         let Some(timeout) = self.config.state_root_task_timeout() else {
-            return Ok(handle.state_root());
+            return Ok(handle.state_root().map(|outcome| (outcome, None)));
         };
 
         let task_rx = handle.take_state_root_rx();
 
         match task_rx.recv_timeout(timeout) {
-            Ok(result) => Ok(result),
+            Ok(result) => Ok(result.map(|outcome| (outcome, None))),
             Err(RecvTimeoutError::Disconnected) => {
                 Ok(Err(ParallelStateRootError::Other("sparse trie task dropped".to_string())))
             }
@@ -1363,13 +1586,16 @@ where
                 );
                 self.metrics.block_validation.state_root_task_timeout_total.increment(1);
 
-                let (seq_tx, seq_rx) =
-                    std::sync::mpsc::channel::<ProviderResult<(B256, TrieUpdates)>>();
+                let (seq_tx, seq_rx) = std::sync::mpsc::channel();
 
-                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 hashed_state =
+                            LazyHandle::ready(Arc::new(provider.hashed_post_state(&output.state)));
+                        let (state_root, trie_updates) =
+                            Self::compute_state_root_serial(provider, &hashed_state)?;
+
+                        Ok((state_root, trie_updates, hashed_state))
                     });
                     let _ = seq_tx.send(result);
                 });
@@ -1384,7 +1610,7 @@ where
                                 source = "task",
                                 "State root timeout race won"
                             );
-                            return Ok(result);
+                            return Ok(result.map(|outcome| (outcome, None)));
                         }
                         Err(RecvTimeoutError::Disconnected) => {
                             debug!(
@@ -1396,13 +1622,16 @@ where
                                     "both state root computations failed",
                                 ))
                             })?;
-                            let (state_root, trie_updates) = result?;
-                            return Ok(Ok(StateRootComputeOutcome {
-                                state_root,
-                                trie_updates: Arc::new(trie_updates),
-                                #[cfg(feature = "trie-debug")]
-                                debug_recorders: Vec::new(),
-                            }));
+                            let (state_root, trie_updates, hashed_state) = result?;
+                            return Ok(Ok((
+                                StateRootComputeOutcome {
+                                    state_root,
+                                    trie_updates: Arc::new(trie_updates),
+                                    #[cfg(feature = "trie-debug")]
+                                    debug_recorders: Vec::new(),
+                                },
+                                Some(hashed_state),
+                            )));
                         }
                         Err(RecvTimeoutError::Timeout) => {}
                     }
@@ -1413,13 +1642,16 @@ where
                             source = "sequential",
                             "State root timeout race won"
                         );
-                        let (state_root, trie_updates) = result?;
-                        return Ok(Ok(StateRootComputeOutcome {
-                            state_root,
-                            trie_updates: Arc::new(trie_updates),
-                            #[cfg(feature = "trie-debug")]
-                            debug_recorders: Vec::new(),
-                        }));
+                        let (state_root, trie_updates, hashed_state) = result?;
+                        return Ok(Ok((
+                            StateRootComputeOutcome {
+                                state_root,
+                                trie_updates: Arc::new(trie_updates),
+                                #[cfg(feature = "trie-debug")]
+                                debug_recorders: Vec::new(),
+                            },
+                            Some(hashed_state),
+                        )));
                     }
                 }
             }
@@ -1437,15 +1669,15 @@ where
         state_provider_builder: StateProviderBuilder<N, P>,
         provider_factory: P,
         overlay_builder: OverlayBuilder<N>,
-        hashed_state: &LazyHashedPostState,
+        output: &BlockExecutionOutput<N::Receipt>,
         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 state_provider_builder.build().and_then(|provider| {
+            let hashed_state = Arc::new(provider.hashed_post_state(&output.state));
+            Self::compute_state_root_serial(provider, &LazyHandle::ready(hashed_state))
+        }) {
             Ok((serial_root, serial_trie_updates)) => {
                 debug!(
                     target: "engine::tree::payload_validator",
@@ -1544,65 +1776,40 @@ where
     ///
     /// The `hashed_state` handle wraps the background hashed post state computation.
     #[instrument(level = "debug", target = "engine::tree::payload_validator", skip_all)]
-    #[expect(clippy::too_many_arguments)]
     fn validate_post_execution<T: PayloadTypes<BuiltPayload: BuiltPayload<Primitives = N>>>(
         &self,
         block: &RecoveredBlock<N::Block>,
         parent_block: &SealedHeader<N::BlockHeader>,
         output: &BlockExecutionOutput<N::Receipt>,
         ctx: &mut TreeCtx<'_, N>,
-        transaction_root: Option<B256>,
         receipt_root_bloom: Option<ReceiptRootBloom>,
-        hashed_state: LazyHashedPostState,
-    ) -> Result<LazyHashedPostState, InsertBlockErrorKind>
+        built_bal: Option<BlockAccessList>,
+    ) -> Result<(), InsertBlockErrorKind>
     where
         V: PayloadValidator<T, Block = N::Block>,
     {
         let start = Instant::now();
 
         trace!(target: "engine::tree::payload_validator", block=?block.num_hash(), "Validating block consensus");
-        // validate block consensus rules
-        if let Err(e) = self.validate_block_inner(block, transaction_root) {
-            return Err(e.into())
-        }
-
-        // now validate against the parent
-        let _enter = debug_span!(target: "engine::tree::payload_validator", "validate_header_against_parent").entered();
-        if let Err(e) =
-            self.consensus.validate_header_against_parent(block.sealed_header(), parent_block)
-        {
-            warn!(target: "engine::tree::payload_validator", ?block, "Failed to validate header {} against parent: {e}", block.hash());
-            return Err(e.into())
-        }
-        drop(_enter);
 
         // Validate block post-execution rules
         let _enter =
             debug_span!(target: "engine::tree::payload_validator", "validate_block_post_execution")
                 .entered();
-        if let Err(err) =
-            self.consensus.validate_block_post_execution(block, output, receipt_root_bloom)
-        {
-            // call post-block hook
-            self.on_invalid_block(parent_block, block, output, None, ctx.state_mut());
-            return Err(err.into())
-        }
-        drop(_enter);
-
-        // Wait for the background keccak256 hashing task to complete. This blocks until
-        // all changed addresses and storage slots have been hashed.
-        let hashed_state_ref =
-            debug_span!(target: "engine::tree::payload_validator", "wait_hashed_post_state")
-                .in_scope(|| hashed_state.get());
+        let block_access_list_hash =
+            built_bal.as_ref().map(|bal| compute_block_access_list_hash(bal));
 
-        let _enter = debug_span!(target: "engine::tree::payload_validator", "validate_block_post_execution_with_hashed_state").entered();
-        if let Err(err) =
-            self.validator.validate_block_post_execution_with_hashed_state(hashed_state_ref, block)
-        {
+        if let Err(err) = self.consensus.validate_block_post_execution(
+            block,
+            output,
+            receipt_root_bloom,
+            block_access_list_hash,
+        ) {
             // call post-block hook
             self.on_invalid_block(parent_block, block, output, None, ctx.state_mut());
             return Err(err.into())
         }
+        drop(_enter);
 
         // record post-execution validation duration
         self.metrics
@@ -1610,7 +1817,7 @@ where
             .post_execution_validation_duration
             .record(start.elapsed().as_secs_f64());
 
-        Ok(hashed_state)
+        Ok(())
     }
 
     /// Spawns a payload processor task based on the state root strategy.
@@ -1632,7 +1839,7 @@ where
         level = "debug",
         target = "engine::tree::payload_validator",
         skip_all,
-        fields(?strategy)
+        fields(?strategy, parallel_bal_execution)
     )]
     fn spawn_payload_processor<T: ExecutableTxIterator<Evm>>(
         &mut self,
@@ -1640,7 +1847,8 @@ where
         txs: T,
         provider_builder: StateProviderBuilder<N, P>,
         overlay_factory: OverlayStateProviderFactory<P, N>,
-        strategy: StateRootStrategy,
+        strategy: &StateRootStrategy<N>,
+        parallel_bal_execution: bool,
     ) -> Result<
         PayloadHandle<
             impl ExecutableTxFor<Evm> + use<N, P, Evm, V, T>,
@@ -1660,6 +1868,7 @@ where
                     provider_builder,
                     overlay_factory,
                     &self.config,
+                    parallel_bal_execution,
                 );
 
                 // record prewarming initialization duration
@@ -1670,7 +1879,9 @@ where
 
                 Ok(handle)
             }
-            StateRootStrategy::Parallel | StateRootStrategy::Synchronous => {
+            StateRootStrategy::Parallel |
+            StateRootStrategy::Synchronous |
+            StateRootStrategy::Custom(_) => {
                 let start = Instant::now();
                 let handle =
                     self.payload_processor.spawn_cache_exclusive(env, txs, provider_builder);
@@ -1721,8 +1932,10 @@ where
     ///
     /// Note: Use state root task only if prefix sets are empty, otherwise proof generation is
     /// too expensive because it requires walking all paths in every proof.
-    const fn plan_state_root_computation(&self) -> StateRootStrategy {
-        if self.config.state_root_fallback() {
+    fn plan_state_root_computation(&self) -> StateRootStrategy<N> {
+        if let Some(custom_state_root) = &self.custom_state_root {
+            StateRootStrategy::Custom(custom_state_root.clone())
+        } else if self.config.state_root_fallback() {
             StateRootStrategy::Synchronous
         } else if self.config.use_state_root_task() {
             StateRootStrategy::StateRootTask
@@ -1747,96 +1960,45 @@ where
         self.invalid_block_hook.on_invalid_block(parent_header, block, output, trie_updates);
     }
 
-    /// Creates a [`LazyOverlay`] for the parent block without blocking.
-    ///
-    /// Returns a lazy overlay that will compute the trie input on first access, and the anchor
-    /// block hash (the highest persisted ancestor). This allows execution to start immediately
-    /// while the trie input computation is deferred until the overlay is actually needed.
-    ///
-    /// If parent is on disk (no in-memory blocks), returns `None` for the lazy overlay.
-    ///
-    /// Uses a cached overlay if available for the canonical head (the common case).
-    fn get_parent_lazy_overlay(
+    /// Returns an overlay builder configured for a payload parent.
+    fn overlay_builder_for_parent(
         parent_hash: B256,
         state: &EngineApiTreeState<N>,
-    ) -> (Option<LazyOverlay<N>>, 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![]));
-
-        if blocks.is_empty() {
-            debug!(target: "engine::tree::payload_validator", "Parent found on disk, no lazy overlay needed");
-            return (None, anchor_hash);
-        }
-
-        // Try to use the cached overlay if it matches both parent hash and anchor
-        if let Some(cached) = state.tree_state.get_cached_overlay(parent_hash, anchor_hash) {
-            debug!(
-                target: "engine::tree::payload_validator",
-                %parent_hash,
-                %anchor_hash,
-                "Using cached canonical overlay"
-            );
-            return (Some(cached.overlay.clone()), cached.anchor_hash);
-        }
-
-        debug!(
-            target: "engine::tree::payload_validator",
-            %anchor_hash,
-            num_blocks = blocks.len(),
-            "Creating lazy overlay for in-memory blocks"
-        );
-
-        (Some(LazyOverlay::new(blocks)), anchor_hash)
+        changeset_cache: ChangesetCache,
+    ) -> OverlayBuilder<N> {
+        OverlayBuilder::new(parent_hash, changeset_cache)
+            .with_state_trie_overlay_manager(state.tree_state.state_trie_overlays.clone())
     }
 
     /// Spawns a background task to compute and sort trie data for the executed block.
     ///
-    /// This function creates a [`DeferredTrieData`] handle with fallback inputs and spawns a
-    /// blocking task that calls `wait_cloned()` to:
+    /// This function creates a [`DeferredTrieData`] handle and spawns a blocking task that:
     /// 1. Sort the block's hashed state and trie updates
-    /// 2. Merge ancestor overlays and extend with the sorted data
-    /// 3. Create an [`AnchoredTrieInput`](reth_chain_state::AnchoredTrieInput) for efficient future
-    ///    trie computations
-    /// 4. Cache the result so subsequent calls return immediately
+    /// 2. Publishes the result so subsequent calls return immediately
     ///
-    /// If the background task hasn't completed when `trie_data()` is called, `wait_cloned()`
-    /// computes from the stored inputs, eliminating deadlock risk and duplicate computation.
+    /// If the background task hasn't completed when `trie_data()` is called, callers wait for the
+    /// publishing task instead of computing synchronously.
     ///
     /// The validation hot path can return immediately after state root verification,
-    /// while consumers (DB writes, overlay providers, proofs) get trie data either
-    /// from the completed task or via fallback computation.
+    /// while consumers (DB writes, overlay providers, proofs) get trie data from the completed
+    /// task.
     fn spawn_deferred_trie_task(
         &self,
-        block: RecoveredBlock<N::Block>,
+        block: Arc<RecoveredBlock<N::Block>>,
         execution_outcome: Arc<BlockExecutionOutput<N::Receipt>>,
-        ctx: &TreeCtx<'_, N>,
         hashed_state: LazyHashedPostState,
         trie_output: Arc<TrieUpdates>,
         changeset_provider: impl TrieCursorFactory + Send + 'static,
     ) -> ExecutedBlock<N> {
-        // Capture parent hash and ancestor overlays for deferred trie input construction.
-        let (anchor_hash, overlay_blocks) = ctx
-            .state()
-            .tree_state
-            .blocks_by_hash(block.parent_hash())
-            .unwrap_or_else(|| (block.parent_hash(), Vec::new()));
-
-        // Collect lightweight ancestor trie data handles. We don't call trie_data() here;
-        // the merge and any fallback sorting happens in the compute_trie_input_task.
-        let ancestors: Vec<DeferredTrieData> =
-            overlay_blocks.iter().rev().map(|b| b.trie_data_handle()).collect();
-
-        // Create deferred handle with fallback inputs in case the background task hasn't completed.
+        // Create deferred handle and task that owns the unsorted inputs.
         // Resolve the lazy handle into Arc<HashedPostState>. By this point the hashed state has
         // already been computed and used for state root verification, so .get() returns instantly.
         let hashed_state = match hashed_state.try_into_inner() {
-            Ok(state) => Arc::new(state),
-            Err(handle) => Arc::new(handle.get().clone()),
+            Ok(state) => state,
+            Err(handle) => handle.get().clone(),
         };
-        let deferred_trie_data =
-            DeferredTrieData::pending(hashed_state, trie_output, anchor_hash, ancestors);
-        let deferred_handle_task = deferred_trie_data.clone();
+        let (deferred_trie_data, deferred_trie_task) =
+            DeferredTrieData::pending(hashed_state, trie_output);
         let block_validation_metrics = self.metrics.block_validation.clone();
 
         // Capture block info and cache handle for changeset computation
@@ -1848,8 +2010,8 @@ where
         // The guard ensures the pending entry is cancelled if the task panics.
         let pending_changeset_guard = self.changeset_cache.register_pending(block_hash);
 
-        // Spawn background task to compute trie data. Calling `wait_cloned` will compute from
-        // the stored inputs and cache the result, so subsequent calls return immediately.
+        // Spawn background task to compute trie data. The task publishes the sorted result before
+        // computing changesets, so trie data waiters do not block on changeset computation.
         let compute_trie_input_task = move || {
             let _span = debug_span!(
                 target: "engine::tree::payload_validator",
@@ -1860,7 +2022,7 @@ where
 
             let result = panic::catch_unwind(AssertUnwindSafe(|| {
                 let compute_start = Instant::now();
-                let computed = deferred_handle_task.wait_cloned();
+                let computed = deferred_trie_task.compute_and_publish();
                 block_validation_metrics
                     .deferred_trie_compute_duration
                     .record(compute_start.elapsed().as_secs_f64());
@@ -1872,15 +2034,6 @@ where
                 block_validation_metrics
                     .trie_updates_sorted_size
                     .record(computed.trie_updates.total_len() as f64);
-                if let Some(anchored) = &computed.anchored_trie_input {
-                    block_validation_metrics
-                        .anchored_overlay_trie_updates_size
-                        .record(anchored.trie_input.nodes.total_len() as f64);
-                    block_validation_metrics
-                        .anchored_overlay_hashed_state_size
-                        .record(anchored.trie_input.state.total_len() as f64);
-                }
-
                 // Compute and cache changesets using the computed trie_updates.
                 // Use the pre-created provider to avoid races with changeset cache
                 // eviction that can happen between task spawn and execution.
@@ -1905,7 +2058,7 @@ where
                             target: "engine::tree::changeset",
                             ?block_number,
                             ?e,
-                            "Failed to compute changesets in deferred trie task"
+                            "Failed to compute changesets for deferred trie producer"
                         );
                     }
                 }
@@ -1914,7 +2067,7 @@ where
             if result.is_err() {
                 error!(
                     target: "engine::tree::payload_validator",
-                    "Deferred trie task panicked; fallback computation will be used when trie data is accessed"
+                    "Deferred trie task panicked"
                 );
             }
         };
@@ -1922,13 +2075,9 @@ where
         // Spawn task that computes trie data asynchronously.
         self.payload_processor
             .executor()
-            .spawn_blocking_named("trie-input", compute_trie_input_task);
+            .spawn_blocking_named(DEFERRED_TRIE_WORKER_NAME, compute_trie_input_task);
 
-        ExecutedBlock::with_deferred_trie_data(
-            Arc::new(block),
-            execution_outcome,
-            deferred_trie_data,
-        )
+        ExecutedBlock::with_deferred_trie_data(block, execution_outcome, deferred_trie_data)
     }
 
     fn calculate_timing_stats(
@@ -2068,14 +2217,16 @@ where
 }
 
 /// Strategy describing how to compute the state root.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum StateRootStrategy {
+#[derive(derive_more::Debug, Clone)]
+enum StateRootStrategy<N: NodePrimitives> {
     /// Use the state root task (background sparse trie computation).
     StateRootTask,
     /// Run the parallel state root computation on the calling thread.
     Parallel,
     /// Fall back to synchronous computation via the state provider.
     Synchronous,
+    /// Custom state root computation strategy.
+    Custom(#[debug(skip)] CustomStateRoot<N>),
 }
 
 /// Type that validates the payloads processed by the engine.
@@ -2132,7 +2283,11 @@ pub trait EngineValidator<
     ///
     /// This is invoked when blocks are inserted via `InsertExecutedBlock` (e.g., locally built
     /// blocks by sequencers) to allow implementations to update internal state such as caches.
-    fn on_inserted_executed_block(&self, block: ExecutedBlock<N>);
+    fn on_inserted_executed_block(
+        &self,
+        block: BuiltPayloadExecutedBlock<N>,
+        state: &EngineApiTreeState<N>,
+    ) -> ProviderResult<ExecutedBlock<N>>;
 
     /// Returns [`SavedCache`] for the given block hash.
     fn cache_for(&self, _block_hash: B256) -> Option<SavedCache>;
@@ -2202,11 +2357,33 @@ where
         self.validate_block_with_state(BlockOrPayload::Block(block), ctx)
     }
 
-    fn on_inserted_executed_block(&self, block: ExecutedBlock<N>) {
+    fn on_inserted_executed_block(
+        &self,
+        block: BuiltPayloadExecutedBlock<N>,
+        state: &EngineApiTreeState<N>,
+    ) -> ProviderResult<ExecutedBlock<N>> {
         self.payload_processor.on_inserted_executed_block(
             block.recovered_block.block_with_parent(),
             &block.execution_output.state,
         );
+
+        let overlay_factory = OverlayStateProviderFactory::new(
+            self.provider.clone(),
+            Self::overlay_builder_for_parent(
+                block.recovered_block.parent_hash(),
+                state,
+                self.changeset_cache.clone(),
+            ),
+        );
+        let changeset_provider = overlay_factory.database_provider_ro()?;
+
+        Ok(self.spawn_deferred_trie_task(
+            block.recovered_block,
+            block.execution_output,
+            LazyHashedPostState::ready(block.hashed_state),
+            block.trie_updates,
+            changeset_provider,
+        ))
     }
 
     fn cache_for(&self, block_hash: B256) -> Option<SavedCache> {
@@ -2219,11 +2396,9 @@ where
         parent_state_root: B256,
         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),
+            Self::overlay_builder_for_parent(parent_hash, state, self.changeset_cache.clone()),
         );
 
         Some(self.payload_processor.spawn_state_root(
@@ -2295,14 +2470,14 @@ impl<T: PayloadTypes> BlockOrPayload<T> {
         }
     }
 
-    /// Returns the block access list embedded in a payload, if present.
-    pub fn block_access_list(&self) -> Option<Result<BlockAccessList, alloy_rlp::Error>> {
-        match self {
-            Self::Payload(payload) => payload.block_access_list().map(|block_access_list| {
-                alloy_rlp::decode_exact::<Bal>(block_access_list.as_ref()).map(Bal::into_inner)
-            }),
-            Self::Block(_) => None,
-        }
+    /// Returns true if this is a payload.
+    pub const fn is_payload(&self) -> bool {
+        matches!(self, Self::Payload(_))
+    }
+
+    /// Returns true if this is a block.
+    pub const fn is_block(&self) -> bool {
+        matches!(self, Self::Block(_))
     }
 
     /// Returns the decoded block access list, if present and successfully decoded.
@@ -2360,3 +2535,24 @@ impl<T: PayloadTypes> BlockOrPayload<T> {
         }
     }
 }
+
+/// Input for [`CustomStateRoot`].
+#[derive(Debug, Clone)]
+pub struct CustomStateRootInput<'a, N: NodePrimitives> {
+    /// The block being validated.
+    pub block: &'a SealedBlock<N::Block>,
+    /// The parent block.
+    pub parent_block: &'a SealedHeader<N::BlockHeader>,
+    /// The execution output.
+    pub output: &'a BlockExecutionOutput<N::Receipt>,
+    /// The hashed state.
+    pub hashed_state: &'a LazyHashedPostState,
+}
+
+/// A custom state root computation handler.
+pub type CustomStateRoot<N> = Arc<
+    dyn Fn(CustomStateRootInput<'_, N>) -> ProviderResult<(B256, TrieUpdates)>
+        + Send
+        + Sync
+        + 'static,
+>;
diff --git a/crates/engine/tree/src/tree/precompile_cache.rs b/crates/engine/tree/src/tree/precompile_cache.rs
index 79a42ca8d72..5be11ebcde0 100644
--- a/crates/engine/tree/src/tree/precompile_cache.rs
+++ b/crates/engine/tree/src/tree/precompile_cache.rs
@@ -52,7 +52,6 @@ where
     fn default() -> Self {
         Self(
             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
diff --git a/crates/engine/tree/src/tree/state.rs b/crates/engine/tree/src/tree/state.rs
index a5b3e40d0b0..a1b8d13d0ad 100644
--- 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::{EthPrimitives, ExecutedBlock, StateTrieOverlayManager};
 use reth_primitives_traits::{AlloyBlockHeader, NodePrimitives, SealedHeader};
 use std::{
     collections::{btree_map, hash_map, BTreeMap, VecDeque},
@@ -38,30 +38,39 @@ pub struct TreeState<N: NodePrimitives = EthPrimitives> {
     pub(crate) current_canonical_head: BlockNumHash,
     /// The engine API variant of this handler
     pub(crate) engine_kind: EngineApiKind,
-    /// Pre-computed lazy overlay for the canonical head.
-    ///
-    /// 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>>,
+    /// Flattened state trie overlays for in-memory blocks.
+    pub(crate) state_trie_overlays: StateTrieOverlayManager<N>,
 }
 
 impl<N: NodePrimitives> TreeState<N> {
     /// Returns a new, empty tree state that points to the given canonical head.
-    pub fn new(current_canonical_head: BlockNumHash, engine_kind: EngineApiKind) -> Self {
+    pub fn new(
+        current_canonical_head: BlockNumHash,
+        engine_kind: EngineApiKind,
+        state_trie_overlays: StateTrieOverlayManager<N>,
+    ) -> Self {
         Self {
             blocks_by_hash: B256Map::default(),
             blocks_by_number: BTreeMap::new(),
             current_canonical_head,
             parent_to_child: B256Map::default(),
             engine_kind,
-            cached_canonical_overlay: None,
+            state_trie_overlays,
         }
     }
 
     /// Resets the state and points to the given canonical head.
     pub fn reset(&mut self, current_canonical_head: BlockNumHash) {
-        *self = Self::new(current_canonical_head, self.engine_kind);
+        let engine_kind = self.engine_kind;
+        let removed_hashes = self.blocks_by_hash.keys().copied().collect::<Vec<_>>();
+        if !removed_hashes.is_empty() {
+            self.state_trie_overlays.remove_blocks(removed_hashes);
+        }
+        self.blocks_by_hash.clear();
+        self.blocks_by_number.clear();
+        self.parent_to_child.clear();
+        self.current_canonical_head = current_canonical_head;
+        self.engine_kind = engine_kind;
     }
 
     /// Returns the number of executed blocks stored.
@@ -101,64 +110,6 @@ impl<N: NodePrimitives> TreeState<N> {
         Some((parent_hash, blocks))
     }
 
-    /// Prepares a cached lazy overlay for the current canonical head.
-    ///
-    /// 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>> {
-        let canonical_hash = self.current_canonical_head.hash;
-
-        // Get blocks leading to the canonical head
-        let Some((anchor_hash, blocks)) = self.blocks_by_hash(canonical_hash) else {
-            // Canonical head not in memory (persisted), no overlay needed
-            self.cached_canonical_overlay = None;
-            return None;
-        };
-
-        let num_blocks = blocks.len();
-        let prepared = PreparedCanonicalOverlay {
-            parent_hash: canonical_hash,
-            overlay: LazyOverlay::new(blocks),
-            anchor_hash,
-        };
-        self.cached_canonical_overlay = Some(prepared.clone());
-
-        debug!(
-            target: "engine::tree",
-            %canonical_hash,
-            %anchor_hash,
-            num_blocks,
-            "Prepared cached canonical overlay"
-        );
-
-        Some(prepared)
-    }
-
-    /// Returns the cached overlay if it matches the requested parent hash and anchor.
-    ///
-    /// Both parent hash and anchor hash must match to ensure the overlay is valid.
-    /// This prevents using a stale overlay after persistence has advanced the anchor.
-    pub fn get_cached_overlay(
-        &self,
-        parent_hash: B256,
-        expected_anchor: B256,
-    ) -> Option<&PreparedCanonicalOverlay<N>> {
-        self.cached_canonical_overlay.as_ref().filter(|cached| {
-            cached.parent_hash == parent_hash && cached.anchor_hash == expected_anchor
-        })
-    }
-
-    /// Invalidates the cached overlay.
-    ///
-    /// Should be called when the anchor changes (e.g., after persistence).
-    pub(crate) fn invalidate_cached_overlay(&mut self) {
-        self.cached_canonical_overlay = None;
-    }
-
     /// Insert executed block into the state.
     pub fn insert_executed(&mut self, executed: ExecutedBlock<N>) {
         let hash = executed.recovered_block().hash();
@@ -169,11 +120,13 @@ impl<N: NodePrimitives> TreeState<N> {
             return;
         }
 
+        let overlay_block = executed.clone();
         self.blocks_by_hash.insert(hash, executed.clone());
 
         self.blocks_by_number.entry(block_number).or_default().push(executed);
 
         self.parent_to_child.entry(parent_hash).or_default().insert(hash);
+        self.state_trie_overlays.insert_block(overlay_block);
     }
 
     /// Remove single executed block by its hash.
@@ -234,7 +187,12 @@ impl<N: NodePrimitives> TreeState<N> {
 
     /// Removes canonical blocks below the upper bound, only if the last persisted hash is
     /// part of the canonical chain.
-    pub fn remove_canonical_until(&mut self, upper_bound: BlockNumber, last_persisted_hash: B256) {
+    fn remove_canonical_until(
+        &mut self,
+        upper_bound: BlockNumber,
+        last_persisted_hash: B256,
+        removed_hashes: &mut Vec<B256>,
+    ) {
         debug!(target: "engine::tree", ?upper_bound, ?last_persisted_hash, "Removing canonical blocks from the tree");
 
         // If the last persisted hash is not canonical, then we don't want to remove any canonical
@@ -249,9 +207,12 @@ impl<N: NodePrimitives> TreeState<N> {
         while let Some(executed) = self.blocks_by_hash.get(&current_block) {
             current_block = executed.recovered_block().parent_hash();
             if executed.recovered_block().number() <= upper_bound {
+                let hash = executed.recovered_block().hash();
                 let num_hash = executed.recovered_block().num_hash();
                 debug!(target: "engine::tree", ?num_hash, "Attempting to remove block walking back from the head");
-                self.remove_by_hash(executed.recovered_block().hash());
+                if self.remove_by_hash(hash).is_some() {
+                    removed_hashes.push(hash);
+                }
             }
         }
         debug!(target: "engine::tree", ?upper_bound, ?last_persisted_hash, "Removed canonical blocks from the tree");
@@ -259,7 +220,11 @@ impl<N: NodePrimitives> TreeState<N> {
 
     /// Removes all blocks that are below the finalized block, as well as removing non-canonical
     /// sidechains that fork from below the finalized block.
-    pub fn prune_finalized_sidechains(&mut self, finalized_num_hash: BlockNumHash) {
+    fn prune_finalized_sidechains(
+        &mut self,
+        finalized_num_hash: BlockNumHash,
+        removed_hashes: &mut Vec<B256>,
+    ) {
         let BlockNumHash { number: finalized_num, hash: finalized_hash } = finalized_num_hash;
 
         // We remove disconnected sidechains in three steps:
@@ -278,6 +243,7 @@ impl<N: NodePrimitives> TreeState<N> {
         for hash in blocks_to_remove {
             if let Some((removed, _)) = self.remove_by_hash(hash) {
                 debug!(target: "engine::tree", num_hash=?removed.recovered_block().num_hash(), "Removed finalized sidechain block");
+                removed_hashes.push(hash);
             }
         }
 
@@ -304,6 +270,7 @@ impl<N: NodePrimitives> TreeState<N> {
         while let Some(block) = blocks_to_remove.pop_front() {
             if let Some((removed, children)) = self.remove_by_hash(block) {
                 debug!(target: "engine::tree", num_hash=?removed.recovered_block().num_hash(), "Removed finalized sidechain child block");
+                removed_hashes.push(block);
                 blocks_to_remove.extend(children);
             }
         }
@@ -344,16 +311,18 @@ impl<N: NodePrimitives> TreeState<N> {
         // * remove all canonical blocks below the upper bound
         // * fetch the number of the finalized hash, removing any sidechains that are __below__ the
         // finalized block
-        self.remove_canonical_until(upper_bound.number, last_persisted_hash);
+        let mut removed_hashes = Vec::new();
+        self.remove_canonical_until(upper_bound.number, last_persisted_hash, &mut removed_hashes);
 
         // Now, we have removed canonical blocks (assuming the upper bound is above the finalized
         // block) and only have sidechains below the finalized block.
         if let Some(finalized_num_hash) = finalized_num_hash {
-            self.prune_finalized_sidechains(finalized_num_hash);
+            self.prune_finalized_sidechains(finalized_num_hash, &mut removed_hashes);
         }
 
-        // Invalidate the cached overlay since blocks were removed and the anchor may have changed
-        self.invalidate_cached_overlay();
+        if !removed_hashes.is_empty() {
+            self.state_trie_overlays.remove_blocks(removed_hashes);
+        }
     }
 
     /// Updates the canonical head to the given block.
@@ -375,6 +344,20 @@ impl<N: NodePrimitives> TreeState<N> {
     pub const fn canonical_block_number(&self) -> BlockNumber {
         self.canonical_head().number
     }
+
+    /// Returns a reference to the [`StateTrieOverlayManager`] that tracks flattened trie overlays
+    /// for all current in-memory blocks.
+    ///
+    /// **Added by StreamingFast for Firehose/op-reth.**
+    /// `OpFirehoseEngineValidator` (in `reth-optimism-firehose`) is an external re-implementation
+    /// of `BasicEngineValidator` that adds Firehose live-tracing hooks. Because it lives outside
+    /// this crate it cannot access `pub(crate)` fields directly. This accessor lets it call
+    /// `.with_state_trie_overlay_manager(state.tree_state().state_trie_overlays().clone())`
+    /// in its `overlay_builder_for_parent` helper — the exact same pattern `BasicEngineValidator`
+    /// uses internally — so there is no behavioral divergence between the two validators.
+    pub fn state_trie_overlays(&self) -> &StateTrieOverlayManager<N> {
+        &self.state_trie_overlays
+    }
 }
 
 #[cfg(test)]
@@ -421,39 +404,6 @@ impl<N: NodePrimitives> TreeState<N> {
     }
 }
 
-/// Pre-computed lazy overlay for the canonical head block.
-///
-/// This is prepared **optimistically** when the canonical head changes, allowing
-/// 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
-/// 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.
-///
-/// # Invalidation
-///
-/// The cached overlay is invalidated when:
-/// - Persistence completes (anchor changes)
-/// - The canonical head changes to a different block
-#[derive(Debug, Clone)]
-pub struct PreparedCanonicalOverlay<N: NodePrimitives = EthPrimitives> {
-    /// 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.
-    ///
-    /// 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>,
-    /// 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).
-    pub anchor_hash: B256,
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -461,7 +411,11 @@ mod tests {
 
     #[test]
     fn test_tree_state_normal_descendant() {
-        let mut tree_state = TreeState::new(BlockNumHash::default(), EngineApiKind::Ethereum);
+        let mut tree_state = TreeState::new(
+            BlockNumHash::default(),
+            EngineApiKind::Ethereum,
+            StateTrieOverlayManager::default(),
+        );
         let blocks: Vec<_> = TestBlockBuilder::eth().get_executed_blocks(1..4).collect();
 
         tree_state.insert_executed(blocks[0].clone());
@@ -484,7 +438,11 @@ mod tests {
 
     #[tokio::test]
     async fn test_tree_state_insert_executed() {
-        let mut tree_state = TreeState::new(BlockNumHash::default(), EngineApiKind::Ethereum);
+        let mut tree_state = TreeState::new(
+            BlockNumHash::default(),
+            EngineApiKind::Ethereum,
+            StateTrieOverlayManager::default(),
+        );
         let blocks: Vec<_> = TestBlockBuilder::eth().get_executed_blocks(1..4).collect();
 
         tree_state.insert_executed(blocks[0].clone());
@@ -510,7 +468,11 @@ mod tests {
 
     #[tokio::test]
     async fn test_tree_state_insert_executed_with_reorg() {
-        let mut tree_state = TreeState::new(BlockNumHash::default(), EngineApiKind::Ethereum);
+        let mut tree_state = TreeState::new(
+            BlockNumHash::default(),
+            EngineApiKind::Ethereum,
+            StateTrieOverlayManager::default(),
+        );
         let mut test_block_builder = TestBlockBuilder::eth();
         let blocks: Vec<_> = test_block_builder.get_executed_blocks(1..6).collect();
 
@@ -550,7 +512,11 @@ mod tests {
     #[tokio::test]
     async fn test_tree_state_remove_before() {
         let start_num_hash = BlockNumHash::default();
-        let mut tree_state = TreeState::new(start_num_hash, EngineApiKind::Ethereum);
+        let mut tree_state = TreeState::new(
+            start_num_hash,
+            EngineApiKind::Ethereum,
+            StateTrieOverlayManager::default(),
+        );
         let blocks: Vec<_> = TestBlockBuilder::eth().get_executed_blocks(1..6).collect();
 
         for block in &blocks {
@@ -600,7 +566,11 @@ mod tests {
     #[tokio::test]
     async fn test_tree_state_remove_before_finalized() {
         let start_num_hash = BlockNumHash::default();
-        let mut tree_state = TreeState::new(start_num_hash, EngineApiKind::Ethereum);
+        let mut tree_state = TreeState::new(
+            start_num_hash,
+            EngineApiKind::Ethereum,
+            StateTrieOverlayManager::default(),
+        );
         let blocks: Vec<_> = TestBlockBuilder::eth().get_executed_blocks(1..6).collect();
 
         for block in &blocks {
@@ -650,7 +620,11 @@ mod tests {
     #[tokio::test]
     async fn test_tree_state_remove_before_lower_finalized() {
         let start_num_hash = BlockNumHash::default();
-        let mut tree_state = TreeState::new(start_num_hash, EngineApiKind::Ethereum);
+        let mut tree_state = TreeState::new(
+            start_num_hash,
+            EngineApiKind::Ethereum,
+            StateTrieOverlayManager::default(),
+        );
         let blocks: Vec<_> = TestBlockBuilder::eth().get_executed_blocks(1..6).collect();
 
         for block in &blocks {
diff --git a/crates/engine/tree/src/tree/tests.rs b/crates/engine/tree/src/tree/tests.rs
index 552a21d11a5..4d70ef50634 100644
--- a/crates/engine/tree/src/tree/tests.rs
+++ b/crates/engine/tree/src/tree/tests.rs
@@ -19,7 +19,9 @@ use alloy_rpc_types_engine::{
     ExecutionData, ExecutionPayloadSidecar, ExecutionPayloadV1, ForkchoiceState,
 };
 use assert_matches::assert_matches;
-use reth_chain_state::{test_utils::TestBlockBuilder, BlockState, ComputedTrieData};
+use reth_chain_state::{
+    test_utils::TestBlockBuilder, BlockState, ComputedTrieData, StateTrieOverlayManager,
+};
 use reth_chainspec::{ChainSpec, HOLESKY, MAINNET};
 use reth_engine_primitives::{EngineApiValidator, ForkchoiceStatus, NoopInvalidBlockHook};
 use reth_ethereum_consensus::EthBeaconConsensus;
@@ -186,6 +188,7 @@ impl TestHarness {
         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 runtime = reth_tasks::Runtime::test();
 
         let header = chain_spec.genesis_header().clone();
         let header = SealedHeader::seal_slow(header);
@@ -195,6 +198,7 @@ impl TestHarness {
             tree_config.invalid_header_hit_eviction_threshold(),
             header.num_hash(),
             EngineApiKind::Ethereum,
+            runtime.state_trie_overlay_worker_pool(),
         );
         let canonical_in_memory_state = CanonicalInMemoryState::with_head(header, None, None);
 
@@ -211,7 +215,7 @@ impl TestHarness {
             TreeConfig::default(),
             Box::new(NoopInvalidBlockHook::default()),
             changeset_cache.clone(),
-            reth_tasks::Runtime::test(),
+            runtime.clone(),
         );
 
         let tree = EngineApiTreeHandler::new(
@@ -228,7 +232,7 @@ impl TestHarness {
             EngineApiKind::Ethereum,
             evm_config,
             changeset_cache,
-            reth_tasks::Runtime::test(),
+            runtime,
         );
 
         let block_builder = TestBlockBuilder::default().with_chain_spec((*chain_spec).clone());
@@ -263,13 +267,18 @@ impl TestHarness {
             parent_hash = hash;
         }
 
+        let state_trie_overlays = StateTrieOverlayManager::default();
+        for block in &blocks {
+            state_trie_overlays.insert_block(block.clone());
+        }
+
         self.tree.state.tree_state = TreeState {
             blocks_by_hash,
             blocks_by_number,
             current_canonical_head: blocks.last().unwrap().recovered_block().num_hash(),
             parent_to_child,
             engine_kind: EngineApiKind::Ethereum,
-            cached_canonical_overlay: None,
+            state_trie_overlays,
         };
 
         let last_executed_block = blocks.last().unwrap().clone();
@@ -2254,3 +2263,320 @@ 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());
+}
+
+// --- Backfill target selection tests ---
+//
+// Cover `backfill_target_hash` and its consumer `backfill_sync_target`, exercised end-to-end
+// via `on_disconnected_downloaded_block`. The OP Stack branch targets head; the Ethereum
+// branch targets finalized. When the CL has no finalized hash yet, the optimistic fallback to
+// head is handled by `backfill_sync_target`.
+
+#[test]
+fn test_backfill_target_hash_eth_returns_finalized() {
+    let test_harness = TestHarness::new(MAINNET.clone());
+    let head = B256::from([0xAA; 32]);
+    let finalized = B256::from([0xBB; 32]);
+    let state = ForkchoiceState {
+        head_block_hash: head,
+        safe_block_hash: B256::ZERO,
+        finalized_block_hash: finalized,
+    };
+
+    assert_eq!(test_harness.tree.backfill_target_hash(state), finalized);
+}
+
+#[test]
+fn test_backfill_target_hash_eth_returns_zero_finalized() {
+    let test_harness = TestHarness::new(MAINNET.clone());
+    let head = B256::from([0xAA; 32]);
+    let state = ForkchoiceState {
+        head_block_hash: head,
+        safe_block_hash: B256::ZERO,
+        finalized_block_hash: B256::ZERO,
+    };
+
+    assert_eq!(test_harness.tree.backfill_target_hash(state), B256::ZERO);
+}
+
+#[test]
+fn test_backfill_target_hash_opstack_returns_head() {
+    let mut test_harness = TestHarness::new(MAINNET.clone());
+    test_harness.tree.engine_kind = EngineApiKind::OpStack;
+    let head = B256::from([0xAA; 32]);
+    let finalized = B256::from([0xBB; 32]);
+    let state = ForkchoiceState {
+        head_block_hash: head,
+        safe_block_hash: B256::ZERO,
+        finalized_block_hash: finalized,
+    };
+
+    // OP Stack: finalized can lag far behind the canonical tip; target head regardless.
+    assert_eq!(test_harness.tree.backfill_target_hash(state), head);
+}
+
+#[test]
+fn test_backfill_sync_target_without_sync_state_returns_none() {
+    let test_harness = TestHarness::new(MAINNET.clone());
+    assert_eq!(
+        test_harness.tree.backfill_sync_target(0, MIN_BLOCKS_FOR_PIPELINE_RUN + 100, None),
+        None
+    );
+}
+
+/// On OP Stack, a disconnected downloaded block whose missing parent is far ahead of the
+/// canonical tip should trigger a backfill targeting `head_block_hash`, not finalized.
+#[test]
+fn test_on_disconnected_downloaded_block_opstack_targets_head() {
+    let mut test_harness = TestHarness::new(MAINNET.clone());
+    test_harness.tree.engine_kind = EngineApiKind::OpStack;
+
+    let head_hash = B256::from([0xAA; 32]);
+    let finalized_hash = B256::from([0xBB; 32]);
+    test_harness.tree.state.forkchoice_state_tracker.set_latest(
+        ForkchoiceState {
+            head_block_hash: head_hash,
+            safe_block_hash: B256::ZERO,
+            finalized_block_hash: finalized_hash,
+        },
+        ForkchoiceStatus::Syncing,
+    );
+
+    let canonical_head = BlockNumHash::new(0, B256::ZERO);
+    let downloaded_block =
+        BlockNumHash::new(MIN_BLOCKS_FOR_PIPELINE_RUN + 100, B256::from([0xCC; 32]));
+    let missing_parent =
+        BlockNumHash::new(MIN_BLOCKS_FOR_PIPELINE_RUN + 99, B256::from([0xDD; 32]));
+
+    let event = test_harness.tree.on_disconnected_downloaded_block(
+        downloaded_block,
+        missing_parent,
+        canonical_head,
+    );
+
+    match event {
+        Some(TreeEvent::BackfillAction(BackfillAction::Start(target))) => {
+            assert_eq!(
+                target.sync_target(),
+                Some(head_hash),
+                "OP Stack backfill should target head, not finalized"
+            );
+        }
+        other => panic!("Expected BackfillAction(Start), got: {other:?}"),
+    }
+}
+
+/// On Ethereum, a disconnected downloaded block whose missing parent is far ahead of the
+/// canonical tip should trigger a backfill targeting `finalized_block_hash`.
+#[test]
+fn test_on_disconnected_downloaded_block_eth_targets_finalized() {
+    let mut test_harness = TestHarness::new(MAINNET.clone());
+
+    let head_hash = B256::from([0xAA; 32]);
+    let finalized_hash = B256::from([0xBB; 32]);
+    test_harness.tree.state.forkchoice_state_tracker.set_latest(
+        ForkchoiceState {
+            head_block_hash: head_hash,
+            safe_block_hash: B256::ZERO,
+            finalized_block_hash: finalized_hash,
+        },
+        ForkchoiceStatus::Syncing,
+    );
+
+    let canonical_head = BlockNumHash::new(0, B256::ZERO);
+    let downloaded_block =
+        BlockNumHash::new(MIN_BLOCKS_FOR_PIPELINE_RUN + 100, B256::from([0xCC; 32]));
+    let missing_parent =
+        BlockNumHash::new(MIN_BLOCKS_FOR_PIPELINE_RUN + 99, B256::from([0xDD; 32]));
+
+    let event = test_harness.tree.on_disconnected_downloaded_block(
+        downloaded_block,
+        missing_parent,
+        canonical_head,
+    );
+
+    match event {
+        Some(TreeEvent::BackfillAction(BackfillAction::Start(target))) => {
+            assert_eq!(
+                target.sync_target(),
+                Some(finalized_hash),
+                "Ethereum backfill should target finalized"
+            );
+        }
+        other => panic!("Expected BackfillAction(Start), got: {other:?}"),
+    }
+}
+
+/// On Ethereum, a zero finalized hash means optimistic sync. The helper still selects finalized,
+/// but the sync-target builder falls back to `head_block_hash`.
+#[test]
+fn test_on_disconnected_downloaded_block_eth_zero_finalized_targets_head() {
+    let mut test_harness = TestHarness::new(MAINNET.clone());
+
+    let head_hash = B256::from([0xAA; 32]);
+    test_harness.tree.state.forkchoice_state_tracker.set_latest(
+        ForkchoiceState {
+            head_block_hash: head_hash,
+            safe_block_hash: B256::ZERO,
+            finalized_block_hash: B256::ZERO,
+        },
+        ForkchoiceStatus::Syncing,
+    );
+
+    let canonical_head = BlockNumHash::new(0, B256::ZERO);
+    let downloaded_block =
+        BlockNumHash::new(MIN_BLOCKS_FOR_PIPELINE_RUN + 100, B256::from([0xCC; 32]));
+    let missing_parent =
+        BlockNumHash::new(MIN_BLOCKS_FOR_PIPELINE_RUN + 99, B256::from([0xDD; 32]));
+
+    let event = test_harness.tree.on_disconnected_downloaded_block(
+        downloaded_block,
+        missing_parent,
+        canonical_head,
+    );
+
+    match event {
+        Some(TreeEvent::BackfillAction(BackfillAction::Start(target))) => {
+            assert_eq!(
+                target.sync_target(),
+                Some(head_hash),
+                "Ethereum optimistic backfill should target head when finalized is zero"
+            );
+        }
+        other => panic!("Expected BackfillAction(Start), got: {other:?}"),
+    }
+}
+
+/// Verifies that the post-backfill recheck path in `on_backfill_sync_finished` retriggers a
+/// new backfill targeting whichever block `backfill_target_hash` resolves to — head on OP
+/// Stack, finalized on Ethereum — when that block is buffered far ahead of where the
+/// just-finished pipeline landed.
+async fn assert_post_backfill_recheck_retriggers_to_buffered_target(engine_kind: EngineApiKind) {
+    reth_tracing::init_test_tracing();
+
+    let chain_spec = MAINNET.clone();
+    let mut test_harness = TestHarness::new(chain_spec.clone());
+    test_harness.tree.engine_kind = engine_kind;
+
+    let base_chain: Vec<_> = test_harness.block_builder.get_executed_blocks(0..1).collect();
+    test_harness = test_harness.with_blocks(base_chain.clone());
+    test_harness
+        .fcu_to(base_chain.last().unwrap().recovered_block().hash(), ForkchoiceStatus::Valid)
+        .await;
+
+    // Long unsynced chain. The last block is what the helper should resolve to.
+    let main_chain = test_harness
+        .block_builder
+        .create_fork(base_chain[0].recovered_block(), MIN_BLOCKS_FOR_PIPELINE_RUN + 50);
+    let target_block = main_chain.last().unwrap().clone();
+    let target_hash = target_block.hash();
+
+    // Buffer the target block — the recheck looks up the helper's resolved hash in the buffer
+    // to decide whether to retrigger.
+    test_harness.tree.state.buffer.insert_block(target_block.clone_sealed_block());
+
+    // Place the buffered hash in the FCU slot the helper picks for this chain type, and put
+    // an unrelated hash (not in buffer) in the other slot to keep the two slots distinct.
+    let other_hash = B256::from([0xFF; 32]);
+    let (head_block_hash, finalized_block_hash) = if engine_kind.is_opstack() {
+        (target_hash, other_hash)
+    } else {
+        (other_hash, target_hash)
+    };
+    test_harness.tree.state.forkchoice_state_tracker.set_latest(
+        ForkchoiceState { head_block_hash, safe_block_hash: head_block_hash, finalized_block_hash },
+        ForkchoiceStatus::Syncing,
+    );
+
+    // Simulate backfill finishing far below the buffered target (gap > threshold).
+    let backfill_finished_block_number = MIN_BLOCKS_FOR_PIPELINE_RUN + 1;
+    let backfill_tip_block = main_chain[(backfill_finished_block_number - 1) as usize].clone();
+    test_harness.provider.add_block(backfill_tip_block.hash(), backfill_tip_block.into_block());
+    let backfill_finished = FromOrchestrator::BackfillSyncFinished(ControlFlow::Continue {
+        block_number: backfill_finished_block_number,
+    });
+    let _ = test_harness.tree.on_engine_message(FromEngine::Event(backfill_finished)).unwrap();
+
+    let event = test_harness.from_tree_rx.recv().await.unwrap();
+    match event {
+        EngineApiEvent::BackfillAction(BackfillAction::Start(emitted_target)) => {
+            assert_eq!(
+                emitted_target.sync_target(),
+                Some(target_hash),
+                "post-backfill recheck should retrigger backfill to the buffered target"
+            );
+        }
+        _ => panic!("Expected BackfillAction(Start), got: {event:#?}"),
+    }
+}
+
+#[tokio::test]
+async fn test_on_backfill_sync_finished_opstack_retriggers_backfill_to_buffered_head() {
+    assert_post_backfill_recheck_retriggers_to_buffered_target(EngineApiKind::OpStack).await;
+}
+
+#[tokio::test]
+async fn test_on_backfill_sync_finished_eth_retriggers_backfill_to_buffered_finalized() {
+    assert_post_backfill_recheck_retriggers_to_buffered_target(EngineApiKind::Ethereum).await;
+}
diff --git a/crates/engine/tree/src/tree/types.rs b/crates/engine/tree/src/tree/types.rs
new file mode 100644
index 00000000000..e6098caf0b2
--- /dev/null
+++ b/crates/engine/tree/src/tree/types.rs
@@ -0,0 +1,31 @@
+//! Shared types for blockchain tree validation.
+
+use crate::tree::error::InsertPayloadError;
+use reth_chain_state::{ExecutedBlock, ExecutionTimingStats};
+use reth_primitives_traits::{BlockTy, NodePrimitives};
+
+/// Result of block or payload validation.
+pub type ValidationOutcome<N, E = InsertPayloadError<BlockTy<N>>> = Result<ValidationOutput<N>, E>;
+
+/// Result type for block validation with optional timing stats.
+pub(crate) type InsertPayloadResult<N> =
+    Result<ValidationOutput<N>, InsertPayloadError<<N as NodePrimitives>::Block>>;
+
+/// Output of block or payload validation.
+#[derive(Clone, Debug)]
+pub struct ValidationOutput<N: NodePrimitives> {
+    /// The executed block produced by validation.
+    pub executed_block: ExecutedBlock<N>,
+    /// Optional execution timing stats collected during validation.
+    pub execution_timing_stats: Option<Box<ExecutionTimingStats>>,
+}
+
+impl<N: NodePrimitives> ValidationOutput<N> {
+    /// Creates a new validation output.
+    pub const fn new(
+        executed_block: ExecutedBlock<N>,
+        execution_timing_stats: Option<Box<ExecutionTimingStats>>,
+    ) -> Self {
+        Self { executed_block, execution_timing_stats }
+    }
+}
diff --git a/crates/engine/util/Cargo.toml b/crates/engine/util/Cargo.toml
index ca7382c192c..aa2f0ba9d1e 100644
--- a/crates/engine/util/Cargo.toml
+++ b/crates/engine/util/Cargo.toml
@@ -24,6 +24,8 @@ reth-storage-api.workspace = true
 reth-payload-primitives.workspace = true
 
 # alloy
+alloy-primitives.workspace = true
+alloy-rlp.workspace = true
 alloy-rpc-types-engine.workspace = true
 alloy-consensus.workspace = true
 
diff --git a/crates/engine/util/src/reorg.rs b/crates/engine/util/src/reorg.rs
index 13390cef433..8a91827c759 100644
--- a/crates/engine/util/src/reorg.rs
+++ b/crates/engine/util/src/reorg.rs
@@ -1,6 +1,7 @@
 //! Stream wrapper that simulates reorgs.
 
 use alloy_consensus::{BlockHeader, Transaction};
+use alloy_primitives::Bytes;
 use alloy_rpc_types_engine::{ForkchoiceState, PayloadStatus};
 use futures::{stream::FuturesUnordered, Stream, StreamExt, TryFutureExt};
 use itertools::Either;
@@ -158,7 +159,7 @@ where
                     // forkchoice state. We will rely on CL to reorg us back to canonical chain.
                     // TODO: This is an expensive blocking operation, ideally it's spawned as a task
                     // so that the stream could yield the control back.
-                    let reorg_block = match create_reorg_head(
+                    let (reorg_block, encoded_bal) = match create_reorg_head(
                         this.provider,
                         this.evm_config,
                         this.payload_validator,
@@ -194,7 +195,7 @@ where
                         BeaconEngineMessage::NewPayload { payload, tx },
                         // Reorg payload
                         BeaconEngineMessage::NewPayload {
-                            payload: T::block_to_payload(reorg_block),
+                            payload: T::block_to_payload(reorg_block, encoded_bal),
                             tx: reorg_payload_tx,
                         },
                         // Reorg forkchoice state
@@ -222,13 +223,14 @@ where
     }
 }
 
+#[allow(clippy::type_complexity)]
 fn create_reorg_head<Provider, Evm, T, Validator>(
     provider: &Provider,
     evm_config: &Evm,
     payload_validator: &Validator,
     mut depth: usize,
     next_payload: T::ExecutionData,
-) -> RethResult<SealedBlock<BlockTy<Evm::Primitives>>>
+) -> RethResult<(SealedBlock<BlockTy<Evm::Primitives>>, Option<Bytes>)>
 where
     Provider: BlockReader<Header = HeaderTy<Evm::Primitives>, Block = BlockTy<Evm::Primitives>>
         + StateProviderFactory
@@ -265,10 +267,12 @@ where
     debug!(target: "engine::stream::reorg", number = reorg_target.header().number(), hash = %previous_hash, "Selected reorg target");
 
     // Configure state
+    let has_bal = reorg_target.header().block_access_list_hash().is_some();
     let state_provider = provider.state_by_block_hash(reorg_target.header().parent_hash())?;
     let mut state = State::builder()
         .with_database_ref(StateProviderDatabase::new(&state_provider))
         .with_bundle_update()
+        .with_bal_builder_if(has_bal)
         .build();
 
     let ctx = evm_config.context_for_block(&reorg_target).map_err(RethError::other)?;
@@ -302,7 +306,10 @@ where
         cumulative_gas_used += gas_used;
     }
 
-    let BlockBuilderOutcome { block, .. } = builder.finish(&state_provider, None)?;
+    let BlockBuilderOutcome { block, block_access_list, .. } =
+        builder.finish(&state_provider, None)?;
 
-    Ok(block.into_sealed_block())
+    let encoded_bal: Option<Bytes> = block_access_list.map(|bal| alloy_rlp::encode(&bal).into());
+
+    Ok((block.into_sealed_block(), encoded_bal))
 }
diff --git a/crates/era-downloader/src/client.rs b/crates/era-downloader/src/client.rs
index 2bb1ea034c8..3b4de3c3674 100644
--- a/crates/era-downloader/src/client.rs
+++ b/crates/era-downloader/src/client.rs
@@ -107,7 +107,7 @@ impl<Http: HttpClient + Clone> EraClient<Http> {
                 }
             }
 
-            if self.era_type == EraFileType::Era1 {
+            if self.era_type.has_checksums() {
                 self.assert_checksum(number, actual_checksum?)
                     .await
                     .map_err(|e| eyre!("{e} for {file_name} at {}", path.display()))?;
@@ -162,11 +162,14 @@ impl<Http: HttpClient + Clone> EraClient<Http> {
     pub async fn files_count(&self) -> usize {
         let mut count = 0usize;
 
-        let file_extension = self.era_type.extension().trim_start_matches('.');
-
         if let Ok(mut dir) = fs::read_dir(&self.folder).await {
             while let Ok(Some(entry)) = dir.next_entry().await {
-                if entry.path().extension() == Some(file_extension.as_ref()) {
+                if let Some(ext) = entry.path().extension().and_then(|ext| ext.to_str()) &&
+                    self.era_type
+                        .extensions()
+                        .iter()
+                        .any(|valid| valid.trim_start_matches('.') == ext)
+                {
                     count += 1;
                 }
             }
@@ -183,8 +186,8 @@ impl<Http: HttpClient + Clone> EraClient<Http> {
         let index_path = self.folder.to_path_buf().join(INDEX_HTML_FILE);
         let checksums_path = self.folder.to_path_buf().join(Self::CHECKSUMS);
 
-        // Only for era1, we download also checksums file
-        if self.era_type == EraFileType::Era1 {
+        // Only for files that ship checksums (era1, ere) we also download the checksums file.
+        if self.era_type.has_checksums() {
             let checksums_url = self.url.join(Self::CHECKSUMS)?;
             try_join!(
                 self.download_file_to_path(self.url.clone(), &index_path),
@@ -211,14 +214,8 @@ impl<Http: HttpClient + Clone> EraClient<Http> {
         let file = File::create(&path).await?;
         let mut writer = io::BufWriter::new(file);
 
-        let ext = self.era_type.extension();
-        let ext_len = ext.len();
-
         while let Some(line) = lines.next_line().await? {
-            if let Some(j) = line.find(ext) &&
-                let Some(i) = line[..j].rfind(|c: char| !c.is_alphanumeric() && c != '-')
-            {
-                let era = &line[i + 1..j + ext_len];
+            if let Some(era) = extract_era_filename(&line, self.era_type.extensions()) {
                 writer.write_all(era.as_bytes()).await?;
                 writer.write_all(b"\n").await?;
             }
@@ -258,7 +255,7 @@ impl<Http: HttpClient + Clone> EraClient<Http> {
 
         match File::open(path).await {
             Ok(file) => {
-                if self.era_type == EraFileType::Era1 {
+                if self.era_type.has_checksums() {
                     let number = self
                         .file_name_to_number(name)
                         .ok_or_else(|| eyre!("Cannot parse ERA number from {name}"))?;
@@ -272,7 +269,7 @@ impl<Http: HttpClient + Clone> EraClient<Http> {
 
                     Ok(is_verified)
                 } else {
-                    // For era files, we skip checksum verification, as checksum.txt does not exist
+                    // For era files there is no checksums.txt, so verification is skipped.
                     Ok(true)
                 }
             }
@@ -330,6 +327,20 @@ impl<Http: HttpClient + Clone> EraClient<Http> {
     }
 }
 
+/// Extracts an era filename ending in one of `extensions` from a single index line.
+///
+/// `extensions` are tried in order; pass them longest-first so `.ere` never matches inside `.erae`.
+fn extract_era_filename<'a>(line: &'a str, extensions: &[&str]) -> Option<&'a str> {
+    for ext in extensions {
+        if let Some(j) = line.find(ext) &&
+            let Some(i) = line[..j].rfind(|c: char| !c.is_alphanumeric() && c != '-')
+        {
+            return Some(&line[i + 1..j + ext.len()]);
+        }
+    }
+    None
+}
+
 async fn checksum(mut reader: impl AsyncRead + Unpin) -> eyre::Result<Vec<u8>> {
     let mut hasher = Sha256::new();
 
@@ -377,6 +388,24 @@ mod tests {
         assert_eq!(actual_number, expected_number);
     }
 
+    // `.erae` lines must yield the full `.erae` name, never the `.ere` prefix inside it.
+    #[test_case(
+        "<a href=\"mainnet-00000-a6860fef.erae\">", &[".erae", ".ere"],
+        Some("mainnet-00000-a6860fef.erae"); "erae anchor not clipped to ere"
+    )]
+    #[test_case(
+        "    \"name\": \"mainnet-00001-05c64fc4.erae\",", &[".erae", ".ere"],
+        Some("mainnet-00001-05c64fc4.erae"); "erae json entry"
+    )]
+    #[test_case(
+        "<a href=\"mainnet-00600-a81ae85f.era1\">", &[".era1"],
+        Some("mainnet-00600-a81ae85f.era1"); "era1 anchor"
+    )]
+    #[test_case("<a href=\"checksums.txt\">", &[".erae", ".ere"], None; "no era file on line")]
+    fn test_extract_era_filename(line: &str, exts: &[&str], expected: Option<&str>) {
+        assert_eq!(extract_era_filename(line, exts), expected);
+    }
+
     #[test]
     fn test_with_era_type_overrides_auto_detection() {
         // URL without "era1" auto-detects as Era
diff --git a/crates/era-downloader/tests/it/download.rs b/crates/era-downloader/tests/it/download.rs
index bf6b956c691..131e0213c3e 100644
--- a/crates/era-downloader/tests/it/download.rs
+++ b/crates/era-downloader/tests/it/download.rs
@@ -1,5 +1,5 @@
 //! Tests fetching a file
-use crate::StubClient;
+use crate::{StubClient, ERE_ETHPANDAOPS_URL};
 use reqwest::Url;
 use reth_era_downloader::EraClient;
 use std::str::FromStr;
@@ -49,6 +49,45 @@ async fn test_getting_file_after_fetching_file_list(url: &str) {
     assert_eq!(actual_count, expected_count);
 }
 
+#[test_case(ERE_ETHPANDAOPS_URL; "ethpandaops")]
+#[tokio::test]
+async fn test_getting_ere_file_url_after_fetching_file_list(url: &str) {
+    let base_url = Url::from_str(url).unwrap();
+    let folder = tempdir().unwrap();
+    let folder = folder.path();
+    let client = EraClient::new(StubClient, base_url.clone(), folder);
+
+    client.fetch_file_list().await.unwrap();
+
+    let expected_url = Some(base_url.join("mainnet-00000-a6860fef.erae").unwrap());
+    let actual_url = client.url(0).await.unwrap();
+
+    assert_eq!(actual_url, expected_url);
+}
+
+#[test_case(ERE_ETHPANDAOPS_URL; "ethpandaops")]
+#[tokio::test]
+async fn test_getting_ere_file_after_fetching_file_list(url: &str) {
+    let base_url = Url::from_str(url).unwrap();
+    let folder = tempdir().unwrap();
+    let folder = folder.path();
+    let mut client = EraClient::new(StubClient, base_url, folder);
+
+    client.fetch_file_list().await.unwrap();
+
+    let url = client.url(0).await.unwrap().unwrap();
+
+    let expected_count = 0;
+    let actual_count = client.files_count().await;
+    assert_eq!(actual_count, expected_count);
+
+    client.download_to_file(url).await.unwrap();
+
+    let expected_count = 1;
+    let actual_count = client.files_count().await;
+    assert_eq!(actual_count, expected_count);
+}
+
 #[test_case("https://mainnet.era.nimbus.team/"; "nimbus")]
 #[tokio::test]
 async fn test_getting_era_file_url_after_fetching_file_list(url: &str) {
diff --git a/crates/era-downloader/tests/it/list.rs b/crates/era-downloader/tests/it/list.rs
index 3da10102c31..ff67a9d171c 100644
--- a/crates/era-downloader/tests/it/list.rs
+++ b/crates/era-downloader/tests/it/list.rs
@@ -1,5 +1,5 @@
 //! Tests fetching a list of files
-use crate::StubClient;
+use crate::{StubClient, ERE_ETHPANDAOPS_URL};
 use reqwest::Url;
 use reth_era_downloader::EraClient;
 use std::str::FromStr;
@@ -24,6 +24,22 @@ async fn test_getting_era1_file_name_after_fetching_file_list(url: &str) {
     assert_eq!(actual, expected);
 }
 
+#[test_case(ERE_ETHPANDAOPS_URL; "ethpandaops")]
+#[tokio::test]
+async fn test_getting_ere_file_name_after_fetching_file_list(url: &str) {
+    let url = Url::from_str(url).unwrap();
+    let folder = tempdir().unwrap();
+    let folder = folder.path();
+    let client = EraClient::new(StubClient, url, folder);
+
+    client.fetch_file_list().await.unwrap();
+
+    let actual = client.number_to_file_name(1).await.unwrap();
+    let expected = Some("mainnet-00001-05c64fc4.erae".to_owned());
+
+    assert_eq!(actual, expected);
+}
+
 #[test_case("https://mainnet.era.nimbus.team/"; "nimbus")]
 #[tokio::test]
 async fn test_getting_era_file_name_after_fetching_file_list(url: &str) {
diff --git a/crates/era-downloader/tests/it/main.rs b/crates/era-downloader/tests/it/main.rs
index fb5f33ab711..3934bd6c238 100644
--- a/crates/era-downloader/tests/it/main.rs
+++ b/crates/era-downloader/tests/it/main.rs
@@ -13,20 +13,30 @@ use futures::Stream;
 use reqwest::IntoUrl;
 use reth_era_downloader::HttpClient;
 
-pub(crate) const ERA1_NIMBUS: &[u8] = include_bytes!("../res/era1-nimbus.html");
-pub(crate) const ERA1_ETH_PORTAL: &[u8] = include_bytes!("../res/ethportal.html");
-pub(crate) const ERA1_ITHACA: &[u8] = include_bytes!("../res/era1-ithaca.html");
-pub(crate) const ERA1_CHECKSUMS: &[u8] = include_bytes!("../res/checksums.txt");
+pub(crate) const ERA1_NIMBUS: &[u8] = include_bytes!("../res/era1/nimbus.html");
+pub(crate) const ERA1_ETH_PORTAL: &[u8] = include_bytes!("../res/era1/ethportal.html");
+pub(crate) const ERA1_ITHACA: &[u8] = include_bytes!("../res/era1/ithaca.html");
+pub(crate) const ERA1_CHECKSUMS: &[u8] = include_bytes!("../res/era1/checksums.txt");
 pub(crate) const ERA1_MAINNET_0: &[u8] =
-    include_bytes!("../res/era1-files/mainnet-00000-5ec1ffb8.era1");
+    include_bytes!("../res/era1/files/mainnet-00000-5ec1ffb8.era1");
 pub(crate) const ERA1_MAINNET_1: &[u8] =
-    include_bytes!("../res/era1-files/mainnet-00001-a5364e9a.era1");
+    include_bytes!("../res/era1/files/mainnet-00001-a5364e9a.era1");
 
-pub(crate) const ERA_NIMBUS: &[u8] = include_bytes!("../res/era-nimbus.html");
+pub(crate) const ERA_NIMBUS: &[u8] = include_bytes!("../res/era/nimbus.html");
 pub(crate) const ERA_MAINNET_0: &[u8] =
-    include_bytes!("../res/era-files/mainnet-00000-4b363db9.era");
+    include_bytes!("../res/era/files/mainnet-00000-4b363db9.era");
 pub(crate) const ERA_MAINNET_1: &[u8] =
-    include_bytes!("../res/era-files/mainnet-00001-40cf2f3c.era");
+    include_bytes!("../res/era/files/mainnet-00001-40cf2f3c.era");
+
+/// Base URL of the ethPandaOps `erae` directory the ere test fixtures are served from.
+pub(crate) const ERE_ETHPANDAOPS_URL: &str = "https://data.ethpandaops.io/erae/mainnet/";
+
+pub(crate) const ERE_ETHPANDAOPS: &[u8] = include_bytes!("../res/ere/ethpandaops.html");
+pub(crate) const ERE_CHECKSUMS: &[u8] = include_bytes!("../res/ere/checksums.txt");
+pub(crate) const ERE_MAINNET_0: &[u8] =
+    include_bytes!("../res/ere/files/mainnet-00000-a6860fef.erae");
+pub(crate) const ERE_MAINNET_1: &[u8] =
+    include_bytes!("../res/ere/files/mainnet-00001-05c64fc4.erae");
 
 /// An HTTP client pre-programmed with canned answers to received calls.
 /// Panics if it receives an unknown call.
@@ -58,6 +68,17 @@ impl HttpClient for StubClient {
             "https://era.ithaca.xyz/era1/mainnet-00001-a5364e9a.era1" => {
                 Bytes::from_static(ERA1_MAINNET_1)
             }
+            // Ere urls
+            "https://data.ethpandaops.io/erae/mainnet/" => Bytes::from_static(ERE_ETHPANDAOPS),
+            "https://data.ethpandaops.io/erae/mainnet/checksums.txt" => {
+                Bytes::from_static(ERE_CHECKSUMS)
+            }
+            "https://data.ethpandaops.io/erae/mainnet/mainnet-00000-a6860fef.erae" => {
+                Bytes::from_static(ERE_MAINNET_0)
+            }
+            "https://data.ethpandaops.io/erae/mainnet/mainnet-00001-05c64fc4.erae" => {
+                Bytes::from_static(ERE_MAINNET_1)
+            }
             // Era urls
             "https://mainnet.era.nimbus.team/" => Bytes::from_static(ERA_NIMBUS),
             "https://mainnet.era.nimbus.team/mainnet-00000-4b363db9.era" => {
diff --git a/crates/era-downloader/tests/it/stream.rs b/crates/era-downloader/tests/it/stream.rs
index 878e5807899..d901004ce66 100644
--- a/crates/era-downloader/tests/it/stream.rs
+++ b/crates/era-downloader/tests/it/stream.rs
@@ -1,5 +1,5 @@
 //! Tests downloading files and streaming their filenames
-use crate::StubClient;
+use crate::{StubClient, ERE_ETHPANDAOPS_URL};
 use futures_util::StreamExt;
 use reqwest::Url;
 use reth_era_downloader::{EraClient, EraStream, EraStreamConfig};
@@ -33,6 +33,28 @@ async fn test_streaming_files_after_fetching_file_list(url: &str) {
     assert_eq!(actual_file.as_ref(), expected_file.as_ref());
 }
 
+#[test_case(ERE_ETHPANDAOPS_URL; "ethpandaops")]
+#[tokio::test]
+async fn test_streaming_ere_files_after_fetching_file_list(url: &str) {
+    let base_url = Url::from_str(url).unwrap();
+    let folder = tempdir().unwrap();
+    let folder = folder.path();
+    let client = EraClient::new(StubClient, base_url, folder);
+
+    let mut stream = EraStream::new(
+        client,
+        EraStreamConfig::default().with_max_files(2).with_max_concurrent_downloads(1),
+    );
+
+    let expected_file = folder.join("mainnet-00000-a6860fef.erae").into_boxed_path();
+    let actual_file = stream.next().await.unwrap().unwrap();
+    assert_eq!(actual_file.as_ref(), expected_file.as_ref());
+
+    let expected_file = folder.join("mainnet-00001-05c64fc4.erae").into_boxed_path();
+    let actual_file = stream.next().await.unwrap().unwrap();
+    assert_eq!(actual_file.as_ref(), expected_file.as_ref());
+}
+
 #[tokio::test]
 async fn test_streaming_era1_files_after_fetching_file_list_into_missing_folder_fails() {
     let base_url = Url::from_str("https://era.ithaca.xyz/era1/index.html").unwrap();
diff --git a/crates/era-downloader/tests/res/era-files/mainnet-00000-4b363db9.era b/crates/era-downloader/tests/res/era/files/mainnet-00000-4b363db9.era
similarity index 100%
rename from crates/era-downloader/tests/res/era-files/mainnet-00000-4b363db9.era
rename to crates/era-downloader/tests/res/era/files/mainnet-00000-4b363db9.era
diff --git a/crates/era-downloader/tests/res/era-files/mainnet-00001-40cf2f3c.era b/crates/era-downloader/tests/res/era/files/mainnet-00001-40cf2f3c.era
similarity index 100%
rename from crates/era-downloader/tests/res/era-files/mainnet-00001-40cf2f3c.era
rename to crates/era-downloader/tests/res/era/files/mainnet-00001-40cf2f3c.era
diff --git a/crates/era-downloader/tests/res/era-nimbus.html b/crates/era-downloader/tests/res/era/nimbus.html
similarity index 100%
rename from crates/era-downloader/tests/res/era-nimbus.html
rename to crates/era-downloader/tests/res/era/nimbus.html
diff --git a/crates/era-downloader/tests/res/checksums.txt b/crates/era-downloader/tests/res/era1/checksums.txt
similarity index 100%
rename from crates/era-downloader/tests/res/checksums.txt
rename to crates/era-downloader/tests/res/era1/checksums.txt
diff --git a/crates/era-downloader/tests/res/ethportal.html b/crates/era-downloader/tests/res/era1/ethportal.html
similarity index 100%
rename from crates/era-downloader/tests/res/ethportal.html
rename to crates/era-downloader/tests/res/era1/ethportal.html
diff --git a/crates/era-downloader/tests/res/era1-files/mainnet-00000-5ec1ffb8.era1 b/crates/era-downloader/tests/res/era1/files/mainnet-00000-5ec1ffb8.era1
similarity index 100%
rename from crates/era-downloader/tests/res/era1-files/mainnet-00000-5ec1ffb8.era1
rename to crates/era-downloader/tests/res/era1/files/mainnet-00000-5ec1ffb8.era1
diff --git a/crates/era-downloader/tests/res/era1-files/mainnet-00001-a5364e9a.era1 b/crates/era-downloader/tests/res/era1/files/mainnet-00001-a5364e9a.era1
similarity index 100%
rename from crates/era-downloader/tests/res/era1-files/mainnet-00001-a5364e9a.era1
rename to crates/era-downloader/tests/res/era1/files/mainnet-00001-a5364e9a.era1
diff --git a/crates/era-downloader/tests/res/era1-ithaca.html b/crates/era-downloader/tests/res/era1/ithaca.html
similarity index 100%
rename from crates/era-downloader/tests/res/era1-ithaca.html
rename to crates/era-downloader/tests/res/era1/ithaca.html
diff --git a/crates/era-downloader/tests/res/era1-nimbus.html b/crates/era-downloader/tests/res/era1/nimbus.html
similarity index 100%
rename from crates/era-downloader/tests/res/era1-nimbus.html
rename to crates/era-downloader/tests/res/era1/nimbus.html
diff --git a/crates/era-downloader/tests/res/ere/checksums.txt b/crates/era-downloader/tests/res/ere/checksums.txt
new file mode 100644
index 00000000000..f0588b0f3e2
--- /dev/null
+++ b/crates/era-downloader/tests/res/ere/checksums.txt
@@ -0,0 +1,2 @@
+0x8d74beec1be996322ad76813bafb92d40839895d6dd7ee808b17ca201eac98be
+0xa2bbdb2de53523b8099b37013f251546f3d65dbe7a0774fa41af0a4176992fd4
diff --git a/crates/era-downloader/tests/res/ere/ethpandaops.html b/crates/era-downloader/tests/res/ere/ethpandaops.html
new file mode 100644
index 00000000000..00903fe5afe
--- /dev/null
+++ b/crates/era-downloader/tests/res/ere/ethpandaops.html
@@ -0,0 +1,12074 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Ethereum Mainnet Execution Layer Archives (eraE)</title>
+</head>
+<body>
+    <div class="container">
+        <h1>Ethereum Mainnet Execution Layer Archive</h1>
+
+        <div class="intro">
+            This repository contains the complete Ethereum Mainnet execution layer history in eraE format,
+            from genesis through both the pre-merge (PoW) and post-merge (PoS) eras. These files
+            enable historical inspection, client bootstrapping, and independent verification of
+            Ethereum Mainnet's execution layer chain.
+        </div>
+
+        <div class="links">
+            <a href="https://hackmd.io/pIZlxnitSciV5wUgW6W20w" class="link-card">
+                <h3>eraE Specification</h3>
+                <p>Technical specification for the eraE archive format used to store execution layer data</p>
+            </a>
+        </div>
+
+        <details>
+            <summary>
+                <span>📁 Available eraE Files</span>
+                <span id="fileCount">Loading...</span>
+            </summary>
+            <div class="files-container">
+                <ul class="file-list" id="fileList">
+                    <!-- Files will be populated here -->
+                </ul>
+            </div>
+            <div class="stats" id="stats">
+                <!-- Stats will be populated here -->
+            </div>
+        </details>
+    </div>
+
+    <div style="margin-top: 20px; text-align: center; font-size: 0.95rem; color: #666;">
+        Hosted by <a href="https://ethpandaops.io" style="color: #3b82f6; text-decoration: none;">ethPandaOps</a> 🐼
+    </div>
+
+    <script nonce="MTkzMDE2MTI3NiwyMjI2NTgxMjc5">
+        // File data - replace with actual eraE file entries
+        const files = [
+  {
+    "name": "checksums.txt",
+    "size": 200531
+  },
+  {
+    "name": "checksums_sha256.txt",
+    "size": 281342
+  },
+  {
+    "name": "mainnet-00000-a6860fef.erae",
+    "size": 4087953
+  },
+  {
+    "name": "mainnet-00001-05c64fc4.erae",
+    "size": 3844572
+  },
+  {
+    "name": "mainnet-00002-6e06861f.erae",
+    "size": 3845902
+  },
+  {
+    "name": "mainnet-00003-14c8639d.erae",
+    "size": 3883042
+  },
+  {
+    "name": "mainnet-00004-6caa0e29.erae",
+    "size": 3854539
+  },
+  {
+    "name": "mainnet-00005-7b9f62b3.erae",
+    "size": 4118262
+  },
+  {
+    "name": "mainnet-00006-15cd356c.erae",
+    "size": 4560212
+  },
+  {
+    "name": "mainnet-00007-fbd10bce.erae",
+    "size": 4302077
+  },
+  {
+    "name": "mainnet-00008-3eae1fdb.erae",
+    "size": 4757224
+  },
+  {
+    "name": "mainnet-00009-68798682.erae",
+    "size": 4668302
+  },
+  {
+    "name": "mainnet-00010-2f99f7af.erae",
+    "size": 4668627
+  },
+  {
+    "name": "mainnet-00011-b1d06af3.erae",
+    "size": 4437319
+  },
+  {
+    "name": "mainnet-00012-a5a013e6.erae",
+    "size": 4557518
+  },
+  {
+    "name": "mainnet-00013-fc961ee1.erae",
+    "size": 4546473
+  },
+  {
+    "name": "mainnet-00014-096a06a2.erae",
+    "size": 4794927
+  },
+  {
+    "name": "mainnet-00015-45211a15.erae",
+    "size": 4698988
+  },
+  {
+    "name": "mainnet-00016-7e590630.erae",
+    "size": 4858618
+  },
+  {
+    "name": "mainnet-00017-01ca7fdb.erae",
+    "size": 5027641
+  },
+  {
+    "name": "mainnet-00018-38ff2243.erae",
+    "size": 5130979
+  },
+  {
+    "name": "mainnet-00019-6cced5c9.erae",
+    "size": 4907554
+  },
+  {
+    "name": "mainnet-00020-de1c2d35.erae",
+    "size": 5340037
+  },
+  {
+    "name": "mainnet-00021-e7f31591.erae",
+    "size": 5686785
+  },
+  {
+    "name": "mainnet-00022-87925138.erae",
+    "size": 5476337
+  },
+  {
+    "name": "mainnet-00023-7b665fb9.erae",
+    "size": 5154737
+  },
+  {
+    "name": "mainnet-00024-8854a3b3.erae",
+    "size": 5358788
+  },
+  {
+    "name": "mainnet-00025-fa1f88f4.erae",
+    "size": 5326736
+  },
+  {
+    "name": "mainnet-00026-06df797c.erae",
+    "size": 5343574
+  },
+  {
+    "name": "mainnet-00027-13223f3e.erae",
+    "size": 5343770
+  },
+  {
+    "name": "mainnet-00028-76f2e4b1.erae",
+    "size": 5430797
+  },
+  {
+    "name": "mainnet-00029-8b0515b7.erae",
+    "size": 5295451
+  },
+  {
+    "name": "mainnet-00030-71617e00.erae",
+    "size": 5412111
+  },
+  {
+    "name": "mainnet-00031-5d69dd41.erae",
+    "size": 5239919
+  },
+  {
+    "name": "mainnet-00032-2b015ef9.erae",
+    "size": 5715986
+  },
+  {
+    "name": "mainnet-00033-bcdef16e.erae",
+    "size": 5693070
+  },
+  {
+    "name": "mainnet-00034-ee6cb1be.erae",
+    "size": 5467946
+  },
+  {
+    "name": "mainnet-00035-3b15cda2.erae",
+    "size": 5401990
+  },
+  {
+    "name": "mainnet-00036-33090ad8.erae",
+    "size": 5437396
+  },
+  {
+    "name": "mainnet-00037-1351f3aa.erae",
+    "size": 5454304
+  },
+  {
+    "name": "mainnet-00038-b0c1fc7f.erae",
+    "size": 5538287
+  },
+  {
+    "name": "mainnet-00039-b6983eaf.erae",
+    "size": 5347372
+  },
+  {
+    "name": "mainnet-00040-3ff6a229.erae",
+    "size": 5576063
+  },
+  {
+    "name": "mainnet-00041-2b359ee9.erae",
+    "size": 5556602
+  },
+  {
+    "name": "mainnet-00042-c4e1dfb5.erae",
+    "size": 5768688
+  },
+  {
+    "name": "mainnet-00043-2f3bcefc.erae",
+    "size": 5603901
+  },
+  {
+    "name": "mainnet-00044-87a3505e.erae",
+    "size": 5464428
+  },
+  {
+    "name": "mainnet-00045-e1a6faaf.erae",
+    "size": 5629546
+  },
+  {
+    "name": "mainnet-00046-38bb454c.erae",
+    "size": 5765853
+  },
+  {
+    "name": "mainnet-00047-0a6fb8da.erae",
+    "size": 5740936
+  },
+  {
+    "name": "mainnet-00048-d2df9db0.erae",
+    "size": 5621858
+  },
+  {
+    "name": "mainnet-00049-8188ffcc.erae",
+    "size": 5775606
+  },
+  {
+    "name": "mainnet-00050-3bb47df2.erae",
+    "size": 5463553
+  },
+  {
+    "name": "mainnet-00051-d6aef157.erae",
+    "size": 5640834
+  },
+  {
+    "name": "mainnet-00052-d136ee77.erae",
+    "size": 5928389
+  },
+  {
+    "name": "mainnet-00053-295a9977.erae",
+    "size": 5663413
+  },
+  {
+    "name": "mainnet-00054-c3377a36.erae",
+    "size": 5783677
+  },
+  {
+    "name": "mainnet-00055-f8dc87be.erae",
+    "size": 6131706
+  },
+  {
+    "name": "mainnet-00056-79c01c6d.erae",
+    "size": 5967632
+  },
+  {
+    "name": "mainnet-00057-08788e5e.erae",
+    "size": 5879744
+  },
+  {
+    "name": "mainnet-00058-59272971.erae",
+    "size": 5882309
+  },
+  {
+    "name": "mainnet-00059-fbca4f8d.erae",
+    "size": 5828816
+  },
+  {
+    "name": "mainnet-00060-e40811f9.erae",
+    "size": 5843153
+  },
+  {
+    "name": "mainnet-00061-a1240b24.erae",
+    "size": 7860370
+  },
+  {
+    "name": "mainnet-00062-eb4bf270.erae",
+    "size": 6447328
+  },
+  {
+    "name": "mainnet-00063-c30456d6.erae",
+    "size": 6843258
+  },
+  {
+    "name": "mainnet-00064-415897bb.erae",
+    "size": 6704645
+  },
+  {
+    "name": "mainnet-00065-fc73e4ff.erae",
+    "size": 5986546
+  },
+  {
+    "name": "mainnet-00066-06402652.erae",
+    "size": 5970172
+  },
+  {
+    "name": "mainnet-00067-aac04823.erae",
+    "size": 5789509
+  },
+  {
+    "name": "mainnet-00068-4e53f203.erae",
+    "size": 6120845
+  },
+  {
+    "name": "mainnet-00069-850d9de0.erae",
+    "size": 5920003
+  },
+  {
+    "name": "mainnet-00070-d668c1c6.erae",
+    "size": 5869639
+  },
+  {
+    "name": "mainnet-00071-d01158ae.erae",
+    "size": 6018011
+  },
+  {
+    "name": "mainnet-00072-7a45664a.erae",
+    "size": 5861509
+  },
+  {
+    "name": "mainnet-00073-a88ee2e4.erae",
+    "size": 5962812
+  },
+  {
+    "name": "mainnet-00074-5139af87.erae",
+    "size": 5777862
+  },
+  {
+    "name": "mainnet-00075-3e981e52.erae",
+    "size": 6124113
+  },
+  {
+    "name": "mainnet-00076-bc17557f.erae",
+    "size": 5925400
+  },
+  {
+    "name": "mainnet-00077-6270327b.erae",
+    "size": 5759274
+  },
+  {
+    "name": "mainnet-00078-d8adf3c0.erae",
+    "size": 6027616
+  },
+  {
+    "name": "mainnet-00079-98aa5029.erae",
+    "size": 6150348
+  },
+  {
+    "name": "mainnet-00080-88a8d9f7.erae",
+    "size": 5805401
+  },
+  {
+    "name": "mainnet-00081-3a1ff940.erae",
+    "size": 5890546
+  },
+  {
+    "name": "mainnet-00082-45d5aaff.erae",
+    "size": 6572585
+  },
+  {
+    "name": "mainnet-00083-8903e6d3.erae",
+    "size": 6346771
+  },
+  {
+    "name": "mainnet-00084-8427f20c.erae",
+    "size": 10864258
+  },
+  {
+    "name": "mainnet-00085-c360ff73.erae",
+    "size": 9897461
+  },
+  {
+    "name": "mainnet-00086-eb36f9a2.erae",
+    "size": 7726109
+  },
+  {
+    "name": "mainnet-00087-a11d2ed7.erae",
+    "size": 7219242
+  },
+  {
+    "name": "mainnet-00088-54194f85.erae",
+    "size": 8007294
+  },
+  {
+    "name": "mainnet-00089-8d52bf9c.erae",
+    "size": 13727793
+  },
+  {
+    "name": "mainnet-00090-e73a31ec.erae",
+    "size": 8942744
+  },
+  {
+    "name": "mainnet-00091-69477c62.erae",
+    "size": 8030512
+  },
+  {
+    "name": "mainnet-00092-d5a10a45.erae",
+    "size": 11611260
+  },
+  {
+    "name": "mainnet-00093-2353bb18.erae",
+    "size": 9376005
+  },
+  {
+    "name": "mainnet-00094-976a94d9.erae",
+    "size": 11155198
+  },
+  {
+    "name": "mainnet-00095-d463f62d.erae",
+    "size": 6952628
+  },
+  {
+    "name": "mainnet-00096-8487d210.erae",
+    "size": 7211236
+  },
+  {
+    "name": "mainnet-00097-a7a8fbb8.erae",
+    "size": 9234408
+  },
+  {
+    "name": "mainnet-00098-c61411db.erae",
+    "size": 12740970
+  },
+  {
+    "name": "mainnet-00099-21f59cbc.erae",
+    "size": 8999191
+  },
+  {
+    "name": "mainnet-00100-0bbf015f.erae",
+    "size": 8673840
+  },
+  {
+    "name": "mainnet-00101-a064813b.erae",
+    "size": 7879841
+  },
+  {
+    "name": "mainnet-00102-50aa8059.erae",
+    "size": 9926345
+  },
+  {
+    "name": "mainnet-00103-2e925bf8.erae",
+    "size": 7954446
+  },
+  {
+    "name": "mainnet-00104-e5227ffd.erae",
+    "size": 7374297
+  },
+  {
+    "name": "mainnet-00105-ca48e1ae.erae",
+    "size": 7336669
+  },
+  {
+    "name": "mainnet-00106-d42b268d.erae",
+    "size": 8550957
+  },
+  {
+    "name": "mainnet-00107-08930bcd.erae",
+    "size": 7846335
+  },
+  {
+    "name": "mainnet-00108-784134ee.erae",
+    "size": 7735668
+  },
+  {
+    "name": "mainnet-00109-066c9db3.erae",
+    "size": 8117461
+  },
+  {
+    "name": "mainnet-00110-e1cf8848.erae",
+    "size": 9994766
+  },
+  {
+    "name": "mainnet-00111-aaff4d00.erae",
+    "size": 11378368
+  },
+  {
+    "name": "mainnet-00112-4b7e2e7f.erae",
+    "size": 10133241
+  },
+  {
+    "name": "mainnet-00113-02a72074.erae",
+    "size": 9404614
+  },
+  {
+    "name": "mainnet-00114-e9f79eca.erae",
+    "size": 8694682
+  },
+  {
+    "name": "mainnet-00115-5bdae3b5.erae",
+    "size": 8407341
+  },
+  {
+    "name": "mainnet-00116-b0a86039.erae",
+    "size": 8735303
+  },
+  {
+    "name": "mainnet-00117-2bc4f58d.erae",
+    "size": 12553847
+  },
+  {
+    "name": "mainnet-00118-74eeb316.erae",
+    "size": 8794492
+  },
+  {
+    "name": "mainnet-00119-635de3cd.erae",
+    "size": 8612054
+  },
+  {
+    "name": "mainnet-00120-da25b7bc.erae",
+    "size": 9788388
+  },
+  {
+    "name": "mainnet-00121-bda0f165.erae",
+    "size": 9563038
+  },
+  {
+    "name": "mainnet-00122-a59f27c4.erae",
+    "size": 9180002
+  },
+  {
+    "name": "mainnet-00123-b66c8c64.erae",
+    "size": 9081648
+  },
+  {
+    "name": "mainnet-00124-68d2f6c4.erae",
+    "size": 9791250
+  },
+  {
+    "name": "mainnet-00125-2f07b09d.erae",
+    "size": 9348736
+  },
+  {
+    "name": "mainnet-00126-ec84eba3.erae",
+    "size": 8608746
+  },
+  {
+    "name": "mainnet-00127-2dcaf9a8.erae",
+    "size": 9101770
+  },
+  {
+    "name": "mainnet-00128-2f062f06.erae",
+    "size": 9424937
+  },
+  {
+    "name": "mainnet-00129-16dcab85.erae",
+    "size": 10133525
+  },
+  {
+    "name": "mainnet-00130-2451c15f.erae",
+    "size": 9286381
+  },
+  {
+    "name": "mainnet-00131-b00c5197.erae",
+    "size": 9760151
+  },
+  {
+    "name": "mainnet-00132-d607ad19.erae",
+    "size": 10410768
+  },
+  {
+    "name": "mainnet-00133-1c41daa8.erae",
+    "size": 10764095
+  },
+  {
+    "name": "mainnet-00134-2f45f75e.erae",
+    "size": 11206266
+  },
+  {
+    "name": "mainnet-00135-7add54f1.erae",
+    "size": 11199973
+  },
+  {
+    "name": "mainnet-00136-77cb3ab6.erae",
+    "size": 10583487
+  },
+  {
+    "name": "mainnet-00137-4cdb60ea.erae",
+    "size": 11036942
+  },
+  {
+    "name": "mainnet-00138-2d6a8bd0.erae",
+    "size": 10766359
+  },
+  {
+    "name": "mainnet-00139-84909eae.erae",
+    "size": 12031735
+  },
+  {
+    "name": "mainnet-00140-2a0d979a.erae",
+    "size": 12063162
+  },
+  {
+    "name": "mainnet-00141-2eb8394d.erae",
+    "size": 11072044
+  },
+  {
+    "name": "mainnet-00142-c917d675.erae",
+    "size": 12403094
+  },
+  {
+    "name": "mainnet-00143-731df5d8.erae",
+    "size": 12466385
+  },
+  {
+    "name": "mainnet-00144-348311e8.erae",
+    "size": 12053757
+  },
+  {
+    "name": "mainnet-00145-6b5d45b3.erae",
+    "size": 12716568
+  },
+  {
+    "name": "mainnet-00146-96e69dbd.erae",
+    "size": 11870552
+  },
+  {
+    "name": "mainnet-00147-09730e57.erae",
+    "size": 15379426
+  },
+  {
+    "name": "mainnet-00148-4f341407.erae",
+    "size": 12608155
+  },
+  {
+    "name": "mainnet-00149-2384d88d.erae",
+    "size": 12321371
+  },
+  {
+    "name": "mainnet-00150-2e3705c0.erae",
+    "size": 12320192
+  },
+  {
+    "name": "mainnet-00151-126e861b.erae",
+    "size": 13255577
+  },
+  {
+    "name": "mainnet-00152-a0061d77.erae",
+    "size": 12228217
+  },
+  {
+    "name": "mainnet-00153-c74c1039.erae",
+    "size": 11870956
+  },
+  {
+    "name": "mainnet-00154-f35962e3.erae",
+    "size": 10833619
+  },
+  {
+    "name": "mainnet-00155-3f800151.erae",
+    "size": 12561380
+  },
+  {
+    "name": "mainnet-00156-ef048701.erae",
+    "size": 12863385
+  },
+  {
+    "name": "mainnet-00157-52e91ed7.erae",
+    "size": 11471532
+  },
+  {
+    "name": "mainnet-00158-0c7d1f12.erae",
+    "size": 13083879
+  },
+  {
+    "name": "mainnet-00159-bf420f65.erae",
+    "size": 11273148
+  },
+  {
+    "name": "mainnet-00160-2c457a99.erae",
+    "size": 11270328
+  },
+  {
+    "name": "mainnet-00161-dea95b9f.erae",
+    "size": 12138782
+  },
+  {
+    "name": "mainnet-00162-5687d341.erae",
+    "size": 12500941
+  },
+  {
+    "name": "mainnet-00163-9b6d512b.erae",
+    "size": 11729965
+  },
+  {
+    "name": "mainnet-00164-78d502cf.erae",
+    "size": 11375715
+  },
+  {
+    "name": "mainnet-00165-f434fccb.erae",
+    "size": 12850460
+  },
+  {
+    "name": "mainnet-00166-5e81cdaf.erae",
+    "size": 11443206
+  },
+  {
+    "name": "mainnet-00167-b7f43d1c.erae",
+    "size": 12478951
+  },
+  {
+    "name": "mainnet-00168-93b9ae7a.erae",
+    "size": 11601069
+  },
+  {
+    "name": "mainnet-00169-6fe8447c.erae",
+    "size": 10832185
+  },
+  {
+    "name": "mainnet-00170-b1e8d76a.erae",
+    "size": 11965478
+  },
+  {
+    "name": "mainnet-00171-0caa7d3d.erae",
+    "size": 12606485
+  },
+  {
+    "name": "mainnet-00172-ee68ce3b.erae",
+    "size": 11388423
+  },
+  {
+    "name": "mainnet-00173-838ee23c.erae",
+    "size": 12804267
+  },
+  {
+    "name": "mainnet-00174-c40ed830.erae",
+    "size": 13783075
+  },
+  {
+    "name": "mainnet-00175-17429090.erae",
+    "size": 13701032
+  },
+  {
+    "name": "mainnet-00176-6c097e6d.erae",
+    "size": 13764888
+  },
+  {
+    "name": "mainnet-00177-a314a5ec.erae",
+    "size": 13094544
+  },
+  {
+    "name": "mainnet-00178-338cabb6.erae",
+    "size": 13958466
+  },
+  {
+    "name": "mainnet-00179-f0a96534.erae",
+    "size": 13088887
+  },
+  {
+    "name": "mainnet-00180-d5297258.erae",
+    "size": 13074235
+  },
+  {
+    "name": "mainnet-00181-a6ea168b.erae",
+    "size": 13868615
+  },
+  {
+    "name": "mainnet-00182-a1c808d0.erae",
+    "size": 13389699
+  },
+  {
+    "name": "mainnet-00183-97817bb1.erae",
+    "size": 15035135
+  },
+  {
+    "name": "mainnet-00184-76575ad2.erae",
+    "size": 16900301
+  },
+  {
+    "name": "mainnet-00185-c20769ef.erae",
+    "size": 13994951
+  },
+  {
+    "name": "mainnet-00186-712d66d3.erae",
+    "size": 13197796
+  },
+  {
+    "name": "mainnet-00187-ce3d42e6.erae",
+    "size": 14622748
+  },
+  {
+    "name": "mainnet-00188-78234170.erae",
+    "size": 14787200
+  },
+  {
+    "name": "mainnet-00189-07045eca.erae",
+    "size": 14553290
+  },
+  {
+    "name": "mainnet-00190-4a98f366.erae",
+    "size": 13927320
+  },
+  {
+    "name": "mainnet-00191-d9d618b2.erae",
+    "size": 13830507
+  },
+  {
+    "name": "mainnet-00192-dbbb7760.erae",
+    "size": 14133509
+  },
+  {
+    "name": "mainnet-00193-2c0b99d2.erae",
+    "size": 15708867
+  },
+  {
+    "name": "mainnet-00194-fd07dee8.erae",
+    "size": 15530846
+  },
+  {
+    "name": "mainnet-00195-8cd03400.erae",
+    "size": 20047627
+  },
+  {
+    "name": "mainnet-00196-1bca7d5a.erae",
+    "size": 15149673
+  },
+  {
+    "name": "mainnet-00197-f271e195.erae",
+    "size": 14513167
+  },
+  {
+    "name": "mainnet-00198-1c284a2f.erae",
+    "size": 13455456
+  },
+  {
+    "name": "mainnet-00199-876aaa47.erae",
+    "size": 13690787
+  },
+  {
+    "name": "mainnet-00200-1fb1b510.erae",
+    "size": 12581910
+  },
+  {
+    "name": "mainnet-00201-5062d839.erae",
+    "size": 12680859
+  },
+  {
+    "name": "mainnet-00202-20d06d85.erae",
+    "size": 14351779
+  },
+  {
+    "name": "mainnet-00203-5609d4c3.erae",
+    "size": 13428049
+  },
+  {
+    "name": "mainnet-00204-472e7c50.erae",
+    "size": 13711016
+  },
+  {
+    "name": "mainnet-00205-130d281e.erae",
+    "size": 13123401
+  },
+  {
+    "name": "mainnet-00206-3463d01e.erae",
+    "size": 13597855
+  },
+  {
+    "name": "mainnet-00207-2ea17b04.erae",
+    "size": 15491354
+  },
+  {
+    "name": "mainnet-00208-da9a82d2.erae",
+    "size": 14978956
+  },
+  {
+    "name": "mainnet-00209-c7fd5630.erae",
+    "size": 16403231
+  },
+  {
+    "name": "mainnet-00210-21ce3ad6.erae",
+    "size": 21463658
+  },
+  {
+    "name": "mainnet-00211-2ed01193.erae",
+    "size": 15950143
+  },
+  {
+    "name": "mainnet-00212-f5ea6706.erae",
+    "size": 15447113
+  },
+  {
+    "name": "mainnet-00213-ad29d81e.erae",
+    "size": 16334052
+  },
+  {
+    "name": "mainnet-00214-b4df19c9.erae",
+    "size": 13952845
+  },
+  {
+    "name": "mainnet-00215-ea1a543b.erae",
+    "size": 13983142
+  },
+  {
+    "name": "mainnet-00216-8a7d0dab.erae",
+    "size": 12960956
+  },
+  {
+    "name": "mainnet-00217-4a2abc0a.erae",
+    "size": 13142857
+  },
+  {
+    "name": "mainnet-00218-1ffbe39b.erae",
+    "size": 13598795
+  },
+  {
+    "name": "mainnet-00219-57d8cb65.erae",
+    "size": 19221094
+  },
+  {
+    "name": "mainnet-00220-86cf4fa0.erae",
+    "size": 12764814
+  },
+  {
+    "name": "mainnet-00221-69893282.erae",
+    "size": 13247485
+  },
+  {
+    "name": "mainnet-00222-de9f45df.erae",
+    "size": 13077653
+  },
+  {
+    "name": "mainnet-00223-c15ec758.erae",
+    "size": 12567128
+  },
+  {
+    "name": "mainnet-00224-9d3e8f87.erae",
+    "size": 13014624
+  },
+  {
+    "name": "mainnet-00225-7a83ee2e.erae",
+    "size": 14165597
+  },
+  {
+    "name": "mainnet-00226-8ce3db95.erae",
+    "size": 13559566
+  },
+  {
+    "name": "mainnet-00227-0b04116b.erae",
+    "size": 12569700
+  },
+  {
+    "name": "mainnet-00228-354a0d75.erae",
+    "size": 12935722
+  },
+  {
+    "name": "mainnet-00229-d1719a43.erae",
+    "size": 13358210
+  },
+  {
+    "name": "mainnet-00230-31198842.erae",
+    "size": 13329444
+  },
+  {
+    "name": "mainnet-00231-2f067876.erae",
+    "size": 12411696
+  },
+  {
+    "name": "mainnet-00232-4dc74344.erae",
+    "size": 11844307
+  },
+  {
+    "name": "mainnet-00233-3aacbe89.erae",
+    "size": 14149405
+  },
+  {
+    "name": "mainnet-00234-7800a51c.erae",
+    "size": 15451191
+  },
+  {
+    "name": "mainnet-00235-ee2be473.erae",
+    "size": 15484089
+  },
+  {
+    "name": "mainnet-00236-a89b7c9c.erae",
+    "size": 14694645
+  },
+  {
+    "name": "mainnet-00237-e0d58999.erae",
+    "size": 17339525
+  },
+  {
+    "name": "mainnet-00238-2b097628.erae",
+    "size": 17023814
+  },
+  {
+    "name": "mainnet-00239-b409f12e.erae",
+    "size": 16852746
+  },
+  {
+    "name": "mainnet-00240-b8519c98.erae",
+    "size": 15801066
+  },
+  {
+    "name": "mainnet-00241-7b0634b1.erae",
+    "size": 14584822
+  },
+  {
+    "name": "mainnet-00242-6edbf825.erae",
+    "size": 14913724
+  },
+  {
+    "name": "mainnet-00243-a43fee51.erae",
+    "size": 15708892
+  },
+  {
+    "name": "mainnet-00244-e29e593c.erae",
+    "size": 15958864
+  },
+  {
+    "name": "mainnet-00245-ed30e896.erae",
+    "size": 14669622
+  },
+  {
+    "name": "mainnet-00246-5760e358.erae",
+    "size": 14183237
+  },
+  {
+    "name": "mainnet-00247-21c38c8d.erae",
+    "size": 13718589
+  },
+  {
+    "name": "mainnet-00248-1f05fc4d.erae",
+    "size": 14295311
+  },
+  {
+    "name": "mainnet-00249-fdb08c79.erae",
+    "size": 15855628
+  },
+  {
+    "name": "mainnet-00250-4e688b3f.erae",
+    "size": 15147112
+  },
+  {
+    "name": "mainnet-00251-c3922b84.erae",
+    "size": 13822329
+  },
+  {
+    "name": "mainnet-00252-54f167a5.erae",
+    "size": 13794795
+  },
+  {
+    "name": "mainnet-00253-e24de416.erae",
+    "size": 13571135
+  },
+  {
+    "name": "mainnet-00254-10b347e0.erae",
+    "size": 15232114
+  },
+  {
+    "name": "mainnet-00255-b64287bf.erae",
+    "size": 15816982
+  },
+  {
+    "name": "mainnet-00256-f5885041.erae",
+    "size": 13548957
+  },
+  {
+    "name": "mainnet-00257-7f808bae.erae",
+    "size": 14044255
+  },
+  {
+    "name": "mainnet-00258-d6f6c352.erae",
+    "size": 14921142
+  },
+  {
+    "name": "mainnet-00259-02dd17fd.erae",
+    "size": 17870320
+  },
+  {
+    "name": "mainnet-00260-57126b2f.erae",
+    "size": 16250132
+  },
+  {
+    "name": "mainnet-00261-66cbc12b.erae",
+    "size": 15072169
+  },
+  {
+    "name": "mainnet-00262-388f543b.erae",
+    "size": 14712656
+  },
+  {
+    "name": "mainnet-00263-1ecc6560.erae",
+    "size": 15173965
+  },
+  {
+    "name": "mainnet-00264-0609e470.erae",
+    "size": 15195443
+  },
+  {
+    "name": "mainnet-00265-cfbb23b4.erae",
+    "size": 14818888
+  },
+  {
+    "name": "mainnet-00266-9166fa52.erae",
+    "size": 17744460
+  },
+  {
+    "name": "mainnet-00267-980806ce.erae",
+    "size": 14319243
+  },
+  {
+    "name": "mainnet-00268-75550dcd.erae",
+    "size": 15748682
+  },
+  {
+    "name": "mainnet-00269-12becdb6.erae",
+    "size": 15266139
+  },
+  {
+    "name": "mainnet-00270-5e248f54.erae",
+    "size": 15220369
+  },
+  {
+    "name": "mainnet-00271-1f25d132.erae",
+    "size": 19526121
+  },
+  {
+    "name": "mainnet-00272-21c8560d.erae",
+    "size": 13684675
+  },
+  {
+    "name": "mainnet-00273-6e63114d.erae",
+    "size": 13779503
+  },
+  {
+    "name": "mainnet-00274-237d1c93.erae",
+    "size": 15016911
+  },
+  {
+    "name": "mainnet-00275-29d717ae.erae",
+    "size": 15712479
+  },
+  {
+    "name": "mainnet-00276-caf8d64b.erae",
+    "size": 17381572
+  },
+  {
+    "name": "mainnet-00277-031cdb81.erae",
+    "size": 17806916
+  },
+  {
+    "name": "mainnet-00278-59e51a17.erae",
+    "size": 12564470
+  },
+  {
+    "name": "mainnet-00279-b1d3c04a.erae",
+    "size": 14297529
+  },
+  {
+    "name": "mainnet-00280-7e3bdeed.erae",
+    "size": 15796661
+  },
+  {
+    "name": "mainnet-00281-56235734.erae",
+    "size": 16161380
+  },
+  {
+    "name": "mainnet-00282-9caba4b6.erae",
+    "size": 12111365
+  },
+  {
+    "name": "mainnet-00283-83a93412.erae",
+    "size": 13732465
+  },
+  {
+    "name": "mainnet-00284-0d4b6f7f.erae",
+    "size": 14435431
+  },
+  {
+    "name": "mainnet-00285-c70c3d0e.erae",
+    "size": 14656808
+  },
+  {
+    "name": "mainnet-00286-d3fadfd5.erae",
+    "size": 13673322
+  },
+  {
+    "name": "mainnet-00287-3fbf27c2.erae",
+    "size": 13863920
+  },
+  {
+    "name": "mainnet-00288-ffa5e635.erae",
+    "size": 16741762
+  },
+  {
+    "name": "mainnet-00289-672bb2e8.erae",
+    "size": 15702536
+  },
+  {
+    "name": "mainnet-00290-4e3f69ac.erae",
+    "size": 17926652
+  },
+  {
+    "name": "mainnet-00291-36a16384.erae",
+    "size": 16801122
+  },
+  {
+    "name": "mainnet-00292-d1d0be49.erae",
+    "size": 16221590
+  },
+  {
+    "name": "mainnet-00293-6c3fd372.erae",
+    "size": 14813311
+  },
+  {
+    "name": "mainnet-00294-cc7e564d.erae",
+    "size": 18389185
+  },
+  {
+    "name": "mainnet-00295-e2798329.erae",
+    "size": 13715114
+  },
+  {
+    "name": "mainnet-00296-add2d6a9.erae",
+    "size": 11156797
+  },
+  {
+    "name": "mainnet-00297-df8c9f85.erae",
+    "size": 12468695
+  },
+  {
+    "name": "mainnet-00298-a640e7e8.erae",
+    "size": 11408078
+  },
+  {
+    "name": "mainnet-00299-e0d038b3.erae",
+    "size": 12509671
+  },
+  {
+    "name": "mainnet-00300-64167edb.erae",
+    "size": 15149361
+  },
+  {
+    "name": "mainnet-00301-f3175c8b.erae",
+    "size": 13404582
+  },
+  {
+    "name": "mainnet-00302-2c67ac51.erae",
+    "size": 16717019
+  },
+  {
+    "name": "mainnet-00303-bc3dd6fe.erae",
+    "size": 12099260
+  },
+  {
+    "name": "mainnet-00304-40ed2047.erae",
+    "size": 13783602
+  },
+  {
+    "name": "mainnet-00305-9489eab2.erae",
+    "size": 16042612
+  },
+  {
+    "name": "mainnet-00306-a106ace2.erae",
+    "size": 14506952
+  },
+  {
+    "name": "mainnet-00307-302e0565.erae",
+    "size": 14324799
+  },
+  {
+    "name": "mainnet-00308-f3e2e3d5.erae",
+    "size": 13782902
+  },
+  {
+    "name": "mainnet-00309-f3c58f65.erae",
+    "size": 13458176
+  },
+  {
+    "name": "mainnet-00310-32b7619d.erae",
+    "size": 14614641
+  },
+  {
+    "name": "mainnet-00311-1921c18c.erae",
+    "size": 14322994
+  },
+  {
+    "name": "mainnet-00312-fd4e426e.erae",
+    "size": 13700264
+  },
+  {
+    "name": "mainnet-00313-b139c1ff.erae",
+    "size": 11534227
+  },
+  {
+    "name": "mainnet-00314-c5d9a34f.erae",
+    "size": 12558113
+  },
+  {
+    "name": "mainnet-00315-2b77b9b3.erae",
+    "size": 13072243
+  },
+  {
+    "name": "mainnet-00316-e5102cb6.erae",
+    "size": 13768289
+  },
+  {
+    "name": "mainnet-00317-761553f1.erae",
+    "size": 13440998
+  },
+  {
+    "name": "mainnet-00318-54b6106f.erae",
+    "size": 13767709
+  },
+  {
+    "name": "mainnet-00319-148fca8e.erae",
+    "size": 13382979
+  },
+  {
+    "name": "mainnet-00320-bb03b6db.erae",
+    "size": 14587289
+  },
+  {
+    "name": "mainnet-00321-c9ff7fde.erae",
+    "size": 14207730
+  },
+  {
+    "name": "mainnet-00322-d52723fe.erae",
+    "size": 13994710
+  },
+  {
+    "name": "mainnet-00323-4ccf60c2.erae",
+    "size": 13625988
+  },
+  {
+    "name": "mainnet-00324-eb547288.erae",
+    "size": 13184407
+  },
+  {
+    "name": "mainnet-00325-f8bb8c9d.erae",
+    "size": 13757418
+  },
+  {
+    "name": "mainnet-00326-63d56097.erae",
+    "size": 16754045
+  },
+  {
+    "name": "mainnet-00327-0144df26.erae",
+    "size": 14087196
+  },
+  {
+    "name": "mainnet-00328-b3e90f82.erae",
+    "size": 15034428
+  },
+  {
+    "name": "mainnet-00329-5c05922f.erae",
+    "size": 14073014
+  },
+  {
+    "name": "mainnet-00330-90a5c846.erae",
+    "size": 15837331
+  },
+  {
+    "name": "mainnet-00331-d62b5516.erae",
+    "size": 16970350
+  },
+  {
+    "name": "mainnet-00332-05d6c661.erae",
+    "size": 13938179
+  },
+  {
+    "name": "mainnet-00333-fd0acd1c.erae",
+    "size": 13670504
+  },
+  {
+    "name": "mainnet-00334-89e48334.erae",
+    "size": 12961613
+  },
+  {
+    "name": "mainnet-00335-ca74c16f.erae",
+    "size": 13557073
+  },
+  {
+    "name": "mainnet-00336-4b689de3.erae",
+    "size": 15146982
+  },
+  {
+    "name": "mainnet-00337-67e986d5.erae",
+    "size": 13859514
+  },
+  {
+    "name": "mainnet-00338-695b877a.erae",
+    "size": 13852520
+  },
+  {
+    "name": "mainnet-00339-762a5ee6.erae",
+    "size": 13314083
+  },
+  {
+    "name": "mainnet-00340-64f00bae.erae",
+    "size": 13777148
+  },
+  {
+    "name": "mainnet-00341-e448d451.erae",
+    "size": 14005921
+  },
+  {
+    "name": "mainnet-00342-5ceef6f8.erae",
+    "size": 15378504
+  },
+  {
+    "name": "mainnet-00343-3ec5ed6b.erae",
+    "size": 15370058
+  },
+  {
+    "name": "mainnet-00344-21140bbd.erae",
+    "size": 13575831
+  },
+  {
+    "name": "mainnet-00345-fd542d42.erae",
+    "size": 12768442
+  },
+  {
+    "name": "mainnet-00346-50487faa.erae",
+    "size": 14508382
+  },
+  {
+    "name": "mainnet-00347-ffce5437.erae",
+    "size": 15432767
+  },
+  {
+    "name": "mainnet-00348-f23b4695.erae",
+    "size": 17263083
+  },
+  {
+    "name": "mainnet-00349-d2d4af88.erae",
+    "size": 13685515
+  },
+  {
+    "name": "mainnet-00350-f1605fbf.erae",
+    "size": 12611597
+  },
+  {
+    "name": "mainnet-00351-cb535a18.erae",
+    "size": 12775777
+  },
+  {
+    "name": "mainnet-00352-52138a73.erae",
+    "size": 14449249
+  },
+  {
+    "name": "mainnet-00353-e49f14ab.erae",
+    "size": 14860796
+  },
+  {
+    "name": "mainnet-00354-7413123e.erae",
+    "size": 15010057
+  },
+  {
+    "name": "mainnet-00355-575a3803.erae",
+    "size": 13566759
+  },
+  {
+    "name": "mainnet-00356-6bd0bc95.erae",
+    "size": 13242094
+  },
+  {
+    "name": "mainnet-00357-6cb64125.erae",
+    "size": 15551593
+  },
+  {
+    "name": "mainnet-00358-98692335.erae",
+    "size": 16160421
+  },
+  {
+    "name": "mainnet-00359-76d4cdfd.erae",
+    "size": 15111630
+  },
+  {
+    "name": "mainnet-00360-cc167522.erae",
+    "size": 14814549
+  },
+  {
+    "name": "mainnet-00361-648be787.erae",
+    "size": 14892347
+  },
+  {
+    "name": "mainnet-00362-b00f1769.erae",
+    "size": 15462735
+  },
+  {
+    "name": "mainnet-00363-1e4bee10.erae",
+    "size": 15368385
+  },
+  {
+    "name": "mainnet-00364-07fb288d.erae",
+    "size": 16428977
+  },
+  {
+    "name": "mainnet-00365-6a382d92.erae",
+    "size": 14293829
+  },
+  {
+    "name": "mainnet-00366-a139a346.erae",
+    "size": 13606470
+  },
+  {
+    "name": "mainnet-00367-1ad54a62.erae",
+    "size": 15768958
+  },
+  {
+    "name": "mainnet-00368-4ab38bab.erae",
+    "size": 15310912
+  },
+  {
+    "name": "mainnet-00369-87703e08.erae",
+    "size": 14966085
+  },
+  {
+    "name": "mainnet-00370-4782e5cc.erae",
+    "size": 15312363
+  },
+  {
+    "name": "mainnet-00371-6c24925f.erae",
+    "size": 15504820
+  },
+  {
+    "name": "mainnet-00372-6b6b2c1e.erae",
+    "size": 16813256
+  },
+  {
+    "name": "mainnet-00373-0d0a7272.erae",
+    "size": 16063661
+  },
+  {
+    "name": "mainnet-00374-89a9d09d.erae",
+    "size": 16193992
+  },
+  {
+    "name": "mainnet-00375-052cfab2.erae",
+    "size": 16226318
+  },
+  {
+    "name": "mainnet-00376-b9cac6ba.erae",
+    "size": 14304340
+  },
+  {
+    "name": "mainnet-00377-0312847e.erae",
+    "size": 15641200
+  },
+  {
+    "name": "mainnet-00378-afda7a51.erae",
+    "size": 15061776
+  },
+  {
+    "name": "mainnet-00379-b47f8ab6.erae",
+    "size": 15030618
+  },
+  {
+    "name": "mainnet-00380-92f0dc0f.erae",
+    "size": 14952435
+  },
+  {
+    "name": "mainnet-00381-6d558790.erae",
+    "size": 15623772
+  },
+  {
+    "name": "mainnet-00382-aba45a8a.erae",
+    "size": 15733893
+  },
+  {
+    "name": "mainnet-00383-6c9011f0.erae",
+    "size": 17402722
+  },
+  {
+    "name": "mainnet-00384-3bbdb984.erae",
+    "size": 15911084
+  },
+  {
+    "name": "mainnet-00385-ffbc279c.erae",
+    "size": 16987149
+  },
+  {
+    "name": "mainnet-00386-f5d28f70.erae",
+    "size": 15207561
+  },
+  {
+    "name": "mainnet-00387-368a2191.erae",
+    "size": 17631814
+  },
+  {
+    "name": "mainnet-00388-eb9c80de.erae",
+    "size": 18468123
+  },
+  {
+    "name": "mainnet-00389-1f680408.erae",
+    "size": 17211628
+  },
+  {
+    "name": "mainnet-00390-ec3d7a45.erae",
+    "size": 15881631
+  },
+  {
+    "name": "mainnet-00391-7faab949.erae",
+    "size": 16705105
+  },
+  {
+    "name": "mainnet-00392-ac5115fd.erae",
+    "size": 16285243
+  },
+  {
+    "name": "mainnet-00393-0a0fd6fd.erae",
+    "size": 17806768
+  },
+  {
+    "name": "mainnet-00394-6fdcde3f.erae",
+    "size": 17351261
+  },
+  {
+    "name": "mainnet-00395-8862666f.erae",
+    "size": 16347971
+  },
+  {
+    "name": "mainnet-00396-97fa2f52.erae",
+    "size": 17171404
+  },
+  {
+    "name": "mainnet-00397-7c5530eb.erae",
+    "size": 17285633
+  },
+  {
+    "name": "mainnet-00398-35538c1f.erae",
+    "size": 19047187
+  },
+  {
+    "name": "mainnet-00399-9fb24105.erae",
+    "size": 19195759
+  },
+  {
+    "name": "mainnet-00400-da61c690.erae",
+    "size": 20675539
+  },
+  {
+    "name": "mainnet-00401-cbb2a004.erae",
+    "size": 18575271
+  },
+  {
+    "name": "mainnet-00402-f23cdd5a.erae",
+    "size": 17723619
+  },
+  {
+    "name": "mainnet-00403-081b8a15.erae",
+    "size": 19205623
+  },
+  {
+    "name": "mainnet-00404-2b1b4d91.erae",
+    "size": 17309416
+  },
+  {
+    "name": "mainnet-00405-b7ea39d8.erae",
+    "size": 20218431
+  },
+  {
+    "name": "mainnet-00406-2d75b874.erae",
+    "size": 19907191
+  },
+  {
+    "name": "mainnet-00407-7c2b83ee.erae",
+    "size": 20333707
+  },
+  {
+    "name": "mainnet-00408-6e11e6e1.erae",
+    "size": 26102799
+  },
+  {
+    "name": "mainnet-00409-0098a663.erae",
+    "size": 23715661
+  },
+  {
+    "name": "mainnet-00410-6f744d7b.erae",
+    "size": 30651247
+  },
+  {
+    "name": "mainnet-00411-8cc62fcb.erae",
+    "size": 26867315
+  },
+  {
+    "name": "mainnet-00412-3a4f8a95.erae",
+    "size": 25104976
+  },
+  {
+    "name": "mainnet-00413-f80611a4.erae",
+    "size": 24390375
+  },
+  {
+    "name": "mainnet-00414-1112338c.erae",
+    "size": 23816907
+  },
+  {
+    "name": "mainnet-00415-2d1b11c5.erae",
+    "size": 24070322
+  },
+  {
+    "name": "mainnet-00416-5d6293c9.erae",
+    "size": 25310962
+  },
+  {
+    "name": "mainnet-00417-680738fd.erae",
+    "size": 24013532
+  },
+  {
+    "name": "mainnet-00418-0efa81a0.erae",
+    "size": 27326868
+  },
+  {
+    "name": "mainnet-00419-3867d312.erae",
+    "size": 25548232
+  },
+  {
+    "name": "mainnet-00420-cf5d01a0.erae",
+    "size": 28884271
+  },
+  {
+    "name": "mainnet-00421-206dc57f.erae",
+    "size": 28004822
+  },
+  {
+    "name": "mainnet-00422-688d3902.erae",
+    "size": 25437451
+  },
+  {
+    "name": "mainnet-00423-539b765e.erae",
+    "size": 29267666
+  },
+  {
+    "name": "mainnet-00424-4d8e89df.erae",
+    "size": 25233120
+  },
+  {
+    "name": "mainnet-00425-e2aa2e27.erae",
+    "size": 27542801
+  },
+  {
+    "name": "mainnet-00426-c9c61a0d.erae",
+    "size": 25764705
+  },
+  {
+    "name": "mainnet-00427-327fc3b2.erae",
+    "size": 22519430
+  },
+  {
+    "name": "mainnet-00428-1667d26d.erae",
+    "size": 23497983
+  },
+  {
+    "name": "mainnet-00429-f7921fb9.erae",
+    "size": 24385682
+  },
+  {
+    "name": "mainnet-00430-610174a4.erae",
+    "size": 25443736
+  },
+  {
+    "name": "mainnet-00431-63a6cb9c.erae",
+    "size": 25445310
+  },
+  {
+    "name": "mainnet-00432-6f802fa4.erae",
+    "size": 22522961
+  },
+  {
+    "name": "mainnet-00433-29c17231.erae",
+    "size": 24451166
+  },
+  {
+    "name": "mainnet-00434-c98fb453.erae",
+    "size": 26348922
+  },
+  {
+    "name": "mainnet-00435-590536c0.erae",
+    "size": 27872537
+  },
+  {
+    "name": "mainnet-00436-e95e9aee.erae",
+    "size": 25647055
+  },
+  {
+    "name": "mainnet-00437-d35bb015.erae",
+    "size": 24497205
+  },
+  {
+    "name": "mainnet-00438-21ec9faf.erae",
+    "size": 25630170
+  },
+  {
+    "name": "mainnet-00439-b92a628f.erae",
+    "size": 29866779
+  },
+  {
+    "name": "mainnet-00440-84e83804.erae",
+    "size": 30526894
+  },
+  {
+    "name": "mainnet-00441-4766f210.erae",
+    "size": 31012232
+  },
+  {
+    "name": "mainnet-00442-c680ba96.erae",
+    "size": 30388225
+  },
+  {
+    "name": "mainnet-00443-c791ac46.erae",
+    "size": 34815986
+  },
+  {
+    "name": "mainnet-00444-6f32929e.erae",
+    "size": 32770933
+  },
+  {
+    "name": "mainnet-00445-23c41c41.erae",
+    "size": 34998458
+  },
+  {
+    "name": "mainnet-00446-3e259f33.erae",
+    "size": 31481773
+  },
+  {
+    "name": "mainnet-00447-a6d84d16.erae",
+    "size": 33084508
+  },
+  {
+    "name": "mainnet-00448-05b804e8.erae",
+    "size": 35851786
+  },
+  {
+    "name": "mainnet-00449-5cf69a02.erae",
+    "size": 34705867
+  },
+  {
+    "name": "mainnet-00450-23fe764c.erae",
+    "size": 36749747
+  },
+  {
+    "name": "mainnet-00451-4a8615be.erae",
+    "size": 34186441
+  },
+  {
+    "name": "mainnet-00452-d5ff9a10.erae",
+    "size": 38074890
+  },
+  {
+    "name": "mainnet-00453-075282f6.erae",
+    "size": 40715711
+  },
+  {
+    "name": "mainnet-00454-c88c41de.erae",
+    "size": 46818637
+  },
+  {
+    "name": "mainnet-00455-f7fdaecc.erae",
+    "size": 49830626
+  },
+  {
+    "name": "mainnet-00456-add7ae2a.erae",
+    "size": 44915851
+  },
+  {
+    "name": "mainnet-00457-c3be453e.erae",
+    "size": 54775128
+  },
+  {
+    "name": "mainnet-00458-83f628bb.erae",
+    "size": 60204334
+  },
+  {
+    "name": "mainnet-00459-78b1832d.erae",
+    "size": 60573725
+  },
+  {
+    "name": "mainnet-00460-854d75ae.erae",
+    "size": 52949713
+  },
+  {
+    "name": "mainnet-00461-53d1a2eb.erae",
+    "size": 50289928
+  },
+  {
+    "name": "mainnet-00462-ec8ed8bf.erae",
+    "size": 54840448
+  },
+  {
+    "name": "mainnet-00463-3b8039b9.erae",
+    "size": 65227498
+  },
+  {
+    "name": "mainnet-00464-eafb93da.erae",
+    "size": 66622363
+  },
+  {
+    "name": "mainnet-00465-9923be5d.erae",
+    "size": 61462934
+  },
+  {
+    "name": "mainnet-00466-e77a4d0d.erae",
+    "size": 62577805
+  },
+  {
+    "name": "mainnet-00467-f5eaf704.erae",
+    "size": 66710475
+  },
+  {
+    "name": "mainnet-00468-b07e5adf.erae",
+    "size": 66101126
+  },
+  {
+    "name": "mainnet-00469-33b50552.erae",
+    "size": 67678667
+  },
+  {
+    "name": "mainnet-00470-ad5961dc.erae",
+    "size": 74424684
+  },
+  {
+    "name": "mainnet-00471-6bc68c66.erae",
+    "size": 88902382
+  },
+  {
+    "name": "mainnet-00472-df9a8015.erae",
+    "size": 80968300
+  },
+  {
+    "name": "mainnet-00473-584c6adf.erae",
+    "size": 80544645
+  },
+  {
+    "name": "mainnet-00474-e5b94d75.erae",
+    "size": 75375645
+  },
+  {
+    "name": "mainnet-00475-a4328375.erae",
+    "size": 81582132
+  },
+  {
+    "name": "mainnet-00476-bf2804db.erae",
+    "size": 87261805
+  },
+  {
+    "name": "mainnet-00477-8716b19b.erae",
+    "size": 86919821
+  },
+  {
+    "name": "mainnet-00478-b2916711.erae",
+    "size": 89297468
+  },
+  {
+    "name": "mainnet-00479-8752d21f.erae",
+    "size": 81207526
+  },
+  {
+    "name": "mainnet-00480-57f101a3.erae",
+    "size": 94190610
+  },
+  {
+    "name": "mainnet-00481-619e6ac8.erae",
+    "size": 94495266
+  },
+  {
+    "name": "mainnet-00482-11685786.erae",
+    "size": 85481703
+  },
+  {
+    "name": "mainnet-00483-f5bc751d.erae",
+    "size": 82425691
+  },
+  {
+    "name": "mainnet-00484-66c29ceb.erae",
+    "size": 99499780
+  },
+  {
+    "name": "mainnet-00485-1aa77e02.erae",
+    "size": 91856821
+  },
+  {
+    "name": "mainnet-00486-4dc5cc00.erae",
+    "size": 94308835
+  },
+  {
+    "name": "mainnet-00487-1bc8ac42.erae",
+    "size": 84787636
+  },
+  {
+    "name": "mainnet-00488-6e0170a7.erae",
+    "size": 96603420
+  },
+  {
+    "name": "mainnet-00489-64921e6d.erae",
+    "size": 108085385
+  },
+  {
+    "name": "mainnet-00490-049ea141.erae",
+    "size": 98113512
+  },
+  {
+    "name": "mainnet-00491-c4c2ca50.erae",
+    "size": 88625670
+  },
+  {
+    "name": "mainnet-00492-627cc80f.erae",
+    "size": 95228741
+  },
+  {
+    "name": "mainnet-00493-063dd58c.erae",
+    "size": 101760088
+  },
+  {
+    "name": "mainnet-00494-7624b432.erae",
+    "size": 88474428
+  },
+  {
+    "name": "mainnet-00495-79b89010.erae",
+    "size": 84688436
+  },
+  {
+    "name": "mainnet-00496-68d34d89.erae",
+    "size": 96107759
+  },
+  {
+    "name": "mainnet-00497-9a09b37b.erae",
+    "size": 87165450
+  },
+  {
+    "name": "mainnet-00498-cccd34e6.erae",
+    "size": 87423397
+  },
+  {
+    "name": "mainnet-00499-e0bfae95.erae",
+    "size": 75400101
+  },
+  {
+    "name": "mainnet-00500-365ebdb8.erae",
+    "size": 91967975
+  },
+  {
+    "name": "mainnet-00501-b99f6c4b.erae",
+    "size": 99524174
+  },
+  {
+    "name": "mainnet-00502-24eb744a.erae",
+    "size": 106274242
+  },
+  {
+    "name": "mainnet-00503-c85a734f.erae",
+    "size": 111000458
+  },
+  {
+    "name": "mainnet-00504-3e6ae99e.erae",
+    "size": 124761763
+  },
+  {
+    "name": "mainnet-00505-f3d76eaa.erae",
+    "size": 135499950
+  },
+  {
+    "name": "mainnet-00506-54213714.erae",
+    "size": 136022256
+  },
+  {
+    "name": "mainnet-00507-8d129cf8.erae",
+    "size": 157102948
+  },
+  {
+    "name": "mainnet-00508-066ba7e6.erae",
+    "size": 171124626
+  },
+  {
+    "name": "mainnet-00509-bf3de274.erae",
+    "size": 162713194
+  },
+  {
+    "name": "mainnet-00510-f586f971.erae",
+    "size": 139230237
+  },
+  {
+    "name": "mainnet-00511-45e3f079.erae",
+    "size": 145086403
+  },
+  {
+    "name": "mainnet-00512-cc6cedd0.erae",
+    "size": 146270546
+  },
+  {
+    "name": "mainnet-00513-7f08431d.erae",
+    "size": 148243924
+  },
+  {
+    "name": "mainnet-00514-c47e8a33.erae",
+    "size": 178869837
+  },
+  {
+    "name": "mainnet-00515-eb8b81df.erae",
+    "size": 181126300
+  },
+  {
+    "name": "mainnet-00516-8d578689.erae",
+    "size": 157661194
+  },
+  {
+    "name": "mainnet-00517-ba69dee2.erae",
+    "size": 199255275
+  },
+  {
+    "name": "mainnet-00518-c2939cef.erae",
+    "size": 216678335
+  },
+  {
+    "name": "mainnet-00519-64100587.erae",
+    "size": 175468654
+  },
+  {
+    "name": "mainnet-00520-bfaa0f6f.erae",
+    "size": 173216376
+  },
+  {
+    "name": "mainnet-00521-337851a7.erae",
+    "size": 177629913
+  },
+  {
+    "name": "mainnet-00522-197ff634.erae",
+    "size": 176040360
+  },
+  {
+    "name": "mainnet-00523-03ca1d1d.erae",
+    "size": 167012794
+  },
+  {
+    "name": "mainnet-00524-241c9382.erae",
+    "size": 161985948
+  },
+  {
+    "name": "mainnet-00525-d743dd5a.erae",
+    "size": 162011485
+  },
+  {
+    "name": "mainnet-00526-731fdc0f.erae",
+    "size": 187344063
+  },
+  {
+    "name": "mainnet-00527-e1c739bf.erae",
+    "size": 196645489
+  },
+  {
+    "name": "mainnet-00528-44df81d7.erae",
+    "size": 189009426
+  },
+  {
+    "name": "mainnet-00529-b6f90ce1.erae",
+    "size": 189375825
+  },
+  {
+    "name": "mainnet-00530-4e341963.erae",
+    "size": 187979388
+  },
+  {
+    "name": "mainnet-00531-746cdc23.erae",
+    "size": 198845579
+  },
+  {
+    "name": "mainnet-00532-f0b8df97.erae",
+    "size": 208714346
+  },
+  {
+    "name": "mainnet-00533-c97b4498.erae",
+    "size": 152988664
+  },
+  {
+    "name": "mainnet-00534-9f9b408c.erae",
+    "size": 114387153
+  },
+  {
+    "name": "mainnet-00535-98bcc3e8.erae",
+    "size": 106325275
+  },
+  {
+    "name": "mainnet-00536-da96bf41.erae",
+    "size": 114461865
+  },
+  {
+    "name": "mainnet-00537-31b2b95b.erae",
+    "size": 93401892
+  },
+  {
+    "name": "mainnet-00538-809e65ca.erae",
+    "size": 98997524
+  },
+  {
+    "name": "mainnet-00539-9958d636.erae",
+    "size": 112477826
+  },
+  {
+    "name": "mainnet-00540-876c8f15.erae",
+    "size": 114531673
+  },
+  {
+    "name": "mainnet-00541-cd655a3f.erae",
+    "size": 120025151
+  },
+  {
+    "name": "mainnet-00542-e06244e3.erae",
+    "size": 118319048
+  },
+  {
+    "name": "mainnet-00543-27597f9f.erae",
+    "size": 123739009
+  },
+  {
+    "name": "mainnet-00544-d21eb2bc.erae",
+    "size": 132535550
+  },
+  {
+    "name": "mainnet-00545-cb7c87c7.erae",
+    "size": 130701265
+  },
+  {
+    "name": "mainnet-00546-92a53ff1.erae",
+    "size": 129106466
+  },
+  {
+    "name": "mainnet-00547-1b0baed8.erae",
+    "size": 117526470
+  },
+  {
+    "name": "mainnet-00548-da3d7869.erae",
+    "size": 96365505
+  },
+  {
+    "name": "mainnet-00549-4a346471.erae",
+    "size": 108827674
+  },
+  {
+    "name": "mainnet-00550-913c1e9a.erae",
+    "size": 111347083
+  },
+  {
+    "name": "mainnet-00551-596067e9.erae",
+    "size": 117460314
+  },
+  {
+    "name": "mainnet-00552-dfe14ad6.erae",
+    "size": 107282926
+  },
+  {
+    "name": "mainnet-00553-e275d0aa.erae",
+    "size": 109435554
+  },
+  {
+    "name": "mainnet-00554-ca0a3957.erae",
+    "size": 113824383
+  },
+  {
+    "name": "mainnet-00555-83853a61.erae",
+    "size": 121070784
+  },
+  {
+    "name": "mainnet-00556-bf4deab2.erae",
+    "size": 125980571
+  },
+  {
+    "name": "mainnet-00557-d511257e.erae",
+    "size": 126066136
+  },
+  {
+    "name": "mainnet-00558-7df395e7.erae",
+    "size": 117423032
+  },
+  {
+    "name": "mainnet-00559-28d5e978.erae",
+    "size": 119208855
+  },
+  {
+    "name": "mainnet-00560-35c4672f.erae",
+    "size": 135883992
+  },
+  {
+    "name": "mainnet-00561-28dbaf0f.erae",
+    "size": 127789311
+  },
+  {
+    "name": "mainnet-00562-e4f16964.erae",
+    "size": 127143737
+  },
+  {
+    "name": "mainnet-00563-0a212a48.erae",
+    "size": 134738570
+  },
+  {
+    "name": "mainnet-00564-2c8f5745.erae",
+    "size": 126460591
+  },
+  {
+    "name": "mainnet-00565-d61e3d10.erae",
+    "size": 199431526
+  },
+  {
+    "name": "mainnet-00566-9f54929c.erae",
+    "size": 151100900
+  },
+  {
+    "name": "mainnet-00567-aeb32c77.erae",
+    "size": 149764615
+  },
+  {
+    "name": "mainnet-00568-59a12ef0.erae",
+    "size": 147824935
+  },
+  {
+    "name": "mainnet-00569-999d2adb.erae",
+    "size": 150516162
+  },
+  {
+    "name": "mainnet-00570-be52c767.erae",
+    "size": 162905211
+  },
+  {
+    "name": "mainnet-00571-b590c799.erae",
+    "size": 166768276
+  },
+  {
+    "name": "mainnet-00572-b17b9547.erae",
+    "size": 150872792
+  },
+  {
+    "name": "mainnet-00573-219c88d3.erae",
+    "size": 167906138
+  },
+  {
+    "name": "mainnet-00574-02a22535.erae",
+    "size": 165344394
+  },
+  {
+    "name": "mainnet-00575-c870d4b2.erae",
+    "size": 188609816
+  },
+  {
+    "name": "mainnet-00576-64ea7380.erae",
+    "size": 209300847
+  },
+  {
+    "name": "mainnet-00577-5860e45b.erae",
+    "size": 214886481
+  },
+  {
+    "name": "mainnet-00578-2d964890.erae",
+    "size": 202873121
+  },
+  {
+    "name": "mainnet-00579-fcc889c0.erae",
+    "size": 205132327
+  },
+  {
+    "name": "mainnet-00580-064fbda7.erae",
+    "size": 232470673
+  },
+  {
+    "name": "mainnet-00581-42176c69.erae",
+    "size": 229352908
+  },
+  {
+    "name": "mainnet-00582-fa3b455d.erae",
+    "size": 236020665
+  },
+  {
+    "name": "mainnet-00583-3ca5d1db.erae",
+    "size": 216097273
+  },
+  {
+    "name": "mainnet-00584-89f54c71.erae",
+    "size": 167900968
+  },
+  {
+    "name": "mainnet-00585-c55042cb.erae",
+    "size": 168848215
+  },
+  {
+    "name": "mainnet-00586-09d4883d.erae",
+    "size": 205281536
+  },
+  {
+    "name": "mainnet-00587-ed1e6403.erae",
+    "size": 213742724
+  },
+  {
+    "name": "mainnet-00588-f8ca6319.erae",
+    "size": 242446286
+  },
+  {
+    "name": "mainnet-00589-a27ac525.erae",
+    "size": 203828957
+  },
+  {
+    "name": "mainnet-00590-8532403b.erae",
+    "size": 210400564
+  },
+  {
+    "name": "mainnet-00591-be23dca7.erae",
+    "size": 262551294
+  },
+  {
+    "name": "mainnet-00592-8d0d8275.erae",
+    "size": 274873232
+  },
+  {
+    "name": "mainnet-00593-2f4b6f4c.erae",
+    "size": 267869979
+  },
+  {
+    "name": "mainnet-00594-07d24284.erae",
+    "size": 257374205
+  },
+  {
+    "name": "mainnet-00595-3dfb8734.erae",
+    "size": 271939955
+  },
+  {
+    "name": "mainnet-00596-4cbbdf5a.erae",
+    "size": 256476037
+  },
+  {
+    "name": "mainnet-00597-fc350d40.erae",
+    "size": 251299292
+  },
+  {
+    "name": "mainnet-00598-aa8724cd.erae",
+    "size": 246286514
+  },
+  {
+    "name": "mainnet-00599-017988b7.erae",
+    "size": 253635036
+  },
+  {
+    "name": "mainnet-00600-49dc8d1d.erae",
+    "size": 264354495
+  },
+  {
+    "name": "mainnet-00601-dcf9f8c0.erae",
+    "size": 263591590
+  },
+  {
+    "name": "mainnet-00602-96d6f840.erae",
+    "size": 231582975
+  },
+  {
+    "name": "mainnet-00603-1e2e67f2.erae",
+    "size": 215538774
+  },
+  {
+    "name": "mainnet-00604-24981cb6.erae",
+    "size": 209714303
+  },
+  {
+    "name": "mainnet-00605-8a1d4d07.erae",
+    "size": 206209319
+  },
+  {
+    "name": "mainnet-00606-9fcea93a.erae",
+    "size": 198202532
+  },
+  {
+    "name": "mainnet-00607-052647e9.erae",
+    "size": 204886874
+  },
+  {
+    "name": "mainnet-00608-45e55104.erae",
+    "size": 194526337
+  },
+  {
+    "name": "mainnet-00609-c0ff57f8.erae",
+    "size": 201750989
+  },
+  {
+    "name": "mainnet-00610-76a20735.erae",
+    "size": 204740325
+  },
+  {
+    "name": "mainnet-00611-2d64a929.erae",
+    "size": 216884612
+  },
+  {
+    "name": "mainnet-00612-fee725c6.erae",
+    "size": 208769784
+  },
+  {
+    "name": "mainnet-00613-779bf93e.erae",
+    "size": 185301666
+  },
+  {
+    "name": "mainnet-00614-32aaa206.erae",
+    "size": 191591980
+  },
+  {
+    "name": "mainnet-00615-04c2114a.erae",
+    "size": 197729034
+  },
+  {
+    "name": "mainnet-00616-18f7dfac.erae",
+    "size": 179351491
+  },
+  {
+    "name": "mainnet-00617-a7a13973.erae",
+    "size": 175628177
+  },
+  {
+    "name": "mainnet-00618-5d121bca.erae",
+    "size": 181285174
+  },
+  {
+    "name": "mainnet-00619-d9d7fa74.erae",
+    "size": 185712782
+  },
+  {
+    "name": "mainnet-00620-0814ab83.erae",
+    "size": 168413674
+  },
+  {
+    "name": "mainnet-00621-c83d3a6a.erae",
+    "size": 180035279
+  },
+  {
+    "name": "mainnet-00622-1ad9b53e.erae",
+    "size": 170583024
+  },
+  {
+    "name": "mainnet-00623-122be131.erae",
+    "size": 179007221
+  },
+  {
+    "name": "mainnet-00624-750f93cc.erae",
+    "size": 177773973
+  },
+  {
+    "name": "mainnet-00625-8b363659.erae",
+    "size": 201466623
+  },
+  {
+    "name": "mainnet-00626-64c36fa6.erae",
+    "size": 193643238
+  },
+  {
+    "name": "mainnet-00627-28762850.erae",
+    "size": 175414184
+  },
+  {
+    "name": "mainnet-00628-a38fae25.erae",
+    "size": 177290889
+  },
+  {
+    "name": "mainnet-00629-3897b910.erae",
+    "size": 179975997
+  },
+  {
+    "name": "mainnet-00630-a0c8433b.erae",
+    "size": 171598754
+  },
+  {
+    "name": "mainnet-00631-1963c080.erae",
+    "size": 181688188
+  },
+  {
+    "name": "mainnet-00632-a0fbd113.erae",
+    "size": 184286651
+  },
+  {
+    "name": "mainnet-00633-308de421.erae",
+    "size": 168682529
+  },
+  {
+    "name": "mainnet-00634-ad8d6d3a.erae",
+    "size": 182255224
+  },
+  {
+    "name": "mainnet-00635-0a87097d.erae",
+    "size": 174189653
+  },
+  {
+    "name": "mainnet-00636-48585da8.erae",
+    "size": 187344489
+  },
+  {
+    "name": "mainnet-00637-7d10bee8.erae",
+    "size": 174320833
+  },
+  {
+    "name": "mainnet-00638-ccc4fa91.erae",
+    "size": 150647525
+  },
+  {
+    "name": "mainnet-00639-d7a1c0a4.erae",
+    "size": 169830022
+  },
+  {
+    "name": "mainnet-00640-6175b619.erae",
+    "size": 171817471
+  },
+  {
+    "name": "mainnet-00641-9a7fe401.erae",
+    "size": 174194627
+  },
+  {
+    "name": "mainnet-00642-c577502e.erae",
+    "size": 165462931
+  },
+  {
+    "name": "mainnet-00643-88fbc716.erae",
+    "size": 149866684
+  },
+  {
+    "name": "mainnet-00644-91882349.erae",
+    "size": 171684272
+  },
+  {
+    "name": "mainnet-00645-4f6ad27f.erae",
+    "size": 164822185
+  },
+  {
+    "name": "mainnet-00646-a70b21d4.erae",
+    "size": 166167923
+  },
+  {
+    "name": "mainnet-00647-75b0c4ba.erae",
+    "size": 154428909
+  },
+  {
+    "name": "mainnet-00648-47955f1e.erae",
+    "size": 142774100
+  },
+  {
+    "name": "mainnet-00649-03e3d1a5.erae",
+    "size": 134588423
+  },
+  {
+    "name": "mainnet-00650-9744bec5.erae",
+    "size": 155089841
+  },
+  {
+    "name": "mainnet-00651-e4551244.erae",
+    "size": 138014127
+  },
+  {
+    "name": "mainnet-00652-7a29f10a.erae",
+    "size": 157944389
+  },
+  {
+    "name": "mainnet-00653-cbffce08.erae",
+    "size": 146129658
+  },
+  {
+    "name": "mainnet-00654-73f01bd1.erae",
+    "size": 137229410
+  },
+  {
+    "name": "mainnet-00655-23ef67ff.erae",
+    "size": 159253106
+  },
+  {
+    "name": "mainnet-00656-677c9a85.erae",
+    "size": 155850635
+  },
+  {
+    "name": "mainnet-00657-1a582bd5.erae",
+    "size": 168432597
+  },
+  {
+    "name": "mainnet-00658-890b65fe.erae",
+    "size": 145433471
+  },
+  {
+    "name": "mainnet-00659-d36247ed.erae",
+    "size": 143916746
+  },
+  {
+    "name": "mainnet-00660-52f5e1ce.erae",
+    "size": 157864094
+  },
+  {
+    "name": "mainnet-00661-b148fe94.erae",
+    "size": 163628637
+  },
+  {
+    "name": "mainnet-00662-cf07d247.erae",
+    "size": 175567262
+  },
+  {
+    "name": "mainnet-00663-21028acf.erae",
+    "size": 177199984
+  },
+  {
+    "name": "mainnet-00664-09acb90f.erae",
+    "size": 157731400
+  },
+  {
+    "name": "mainnet-00665-85c07314.erae",
+    "size": 178154394
+  },
+  {
+    "name": "mainnet-00666-31aff2e5.erae",
+    "size": 190807750
+  },
+  {
+    "name": "mainnet-00667-84364e03.erae",
+    "size": 201646225
+  },
+  {
+    "name": "mainnet-00668-0a1b6872.erae",
+    "size": 208369353
+  },
+  {
+    "name": "mainnet-00669-41a86778.erae",
+    "size": 180397910
+  },
+  {
+    "name": "mainnet-00670-25c4bdb9.erae",
+    "size": 203001169
+  },
+  {
+    "name": "mainnet-00671-86eed4db.erae",
+    "size": 210742774
+  },
+  {
+    "name": "mainnet-00672-4ac8cac1.erae",
+    "size": 201883942
+  },
+  {
+    "name": "mainnet-00673-f176aeb1.erae",
+    "size": 203827557
+  },
+  {
+    "name": "mainnet-00674-dc53a2f6.erae",
+    "size": 195888266
+  },
+  {
+    "name": "mainnet-00675-96f8ded5.erae",
+    "size": 211095830
+  },
+  {
+    "name": "mainnet-00676-661748e7.erae",
+    "size": 208415729
+  },
+  {
+    "name": "mainnet-00677-f8f64bc7.erae",
+    "size": 219851177
+  },
+  {
+    "name": "mainnet-00678-5d01c16f.erae",
+    "size": 219984148
+  },
+  {
+    "name": "mainnet-00679-3611128b.erae",
+    "size": 191030509
+  },
+  {
+    "name": "mainnet-00680-75640e03.erae",
+    "size": 206030658
+  },
+  {
+    "name": "mainnet-00681-5f5c0b1a.erae",
+    "size": 206667873
+  },
+  {
+    "name": "mainnet-00682-0e9fa303.erae",
+    "size": 219788618
+  },
+  {
+    "name": "mainnet-00683-3bb2c28b.erae",
+    "size": 203101127
+  },
+  {
+    "name": "mainnet-00684-a979cd8a.erae",
+    "size": 202691343
+  },
+  {
+    "name": "mainnet-00685-0ffa8c2b.erae",
+    "size": 211863626
+  },
+  {
+    "name": "mainnet-00686-e65742e1.erae",
+    "size": 205558181
+  },
+  {
+    "name": "mainnet-00687-9aec4df4.erae",
+    "size": 206869567
+  },
+  {
+    "name": "mainnet-00688-8d1e343a.erae",
+    "size": 200251786
+  },
+  {
+    "name": "mainnet-00689-d55f0949.erae",
+    "size": 207054249
+  },
+  {
+    "name": "mainnet-00690-098d6a6e.erae",
+    "size": 205624900
+  },
+  {
+    "name": "mainnet-00691-2552ff0b.erae",
+    "size": 214429408
+  },
+  {
+    "name": "mainnet-00692-8957495e.erae",
+    "size": 208318570
+  },
+  {
+    "name": "mainnet-00693-f605b255.erae",
+    "size": 197363157
+  },
+  {
+    "name": "mainnet-00694-d7c36fc0.erae",
+    "size": 206867888
+  },
+  {
+    "name": "mainnet-00695-97127c7e.erae",
+    "size": 211427424
+  },
+  {
+    "name": "mainnet-00696-37fe4986.erae",
+    "size": 215727308
+  },
+  {
+    "name": "mainnet-00697-ea7dfcf6.erae",
+    "size": 204281449
+  },
+  {
+    "name": "mainnet-00698-66b0fcbd.erae",
+    "size": 211616098
+  },
+  {
+    "name": "mainnet-00699-a3ef48cd.erae",
+    "size": 205703162
+  },
+  {
+    "name": "mainnet-00700-1f5a3ab9.erae",
+    "size": 212083348
+  },
+  {
+    "name": "mainnet-00701-34aecd9a.erae",
+    "size": 196968496
+  },
+  {
+    "name": "mainnet-00702-940cce5f.erae",
+    "size": 203050536
+  },
+  {
+    "name": "mainnet-00703-a53c810b.erae",
+    "size": 199845416
+  },
+  {
+    "name": "mainnet-00704-a17a6174.erae",
+    "size": 204071260
+  },
+  {
+    "name": "mainnet-00705-04d6733d.erae",
+    "size": 210444097
+  },
+  {
+    "name": "mainnet-00706-5e91ba4b.erae",
+    "size": 197737219
+  },
+  {
+    "name": "mainnet-00707-ff134b5a.erae",
+    "size": 218423915
+  },
+  {
+    "name": "mainnet-00708-73a4ac22.erae",
+    "size": 186123590
+  },
+  {
+    "name": "mainnet-00709-ed3fa7a5.erae",
+    "size": 189511394
+  },
+  {
+    "name": "mainnet-00710-ecfb8f0f.erae",
+    "size": 208645237
+  },
+  {
+    "name": "mainnet-00711-3c56e108.erae",
+    "size": 194607422
+  },
+  {
+    "name": "mainnet-00712-d69cf01a.erae",
+    "size": 194969114
+  },
+  {
+    "name": "mainnet-00713-848c3b1d.erae",
+    "size": 168123166
+  },
+  {
+    "name": "mainnet-00714-eafadb55.erae",
+    "size": 200114394
+  },
+  {
+    "name": "mainnet-00715-6f738c46.erae",
+    "size": 201677151
+  },
+  {
+    "name": "mainnet-00716-d2557409.erae",
+    "size": 200386109
+  },
+  {
+    "name": "mainnet-00717-1946ba44.erae",
+    "size": 188672916
+  },
+  {
+    "name": "mainnet-00718-b7206c5b.erae",
+    "size": 179283341
+  },
+  {
+    "name": "mainnet-00719-ae778e45.erae",
+    "size": 172421253
+  },
+  {
+    "name": "mainnet-00720-d790d851.erae",
+    "size": 172227999
+  },
+  {
+    "name": "mainnet-00721-7510e4f1.erae",
+    "size": 173501473
+  },
+  {
+    "name": "mainnet-00722-bad87c04.erae",
+    "size": 175290073
+  },
+  {
+    "name": "mainnet-00723-2f52825a.erae",
+    "size": 179674295
+  },
+  {
+    "name": "mainnet-00724-128ec100.erae",
+    "size": 197063173
+  },
+  {
+    "name": "mainnet-00725-889ecd51.erae",
+    "size": 189122132
+  },
+  {
+    "name": "mainnet-00726-70a3e8ea.erae",
+    "size": 181236168
+  },
+  {
+    "name": "mainnet-00727-c63aa08f.erae",
+    "size": 177740358
+  },
+  {
+    "name": "mainnet-00728-57dac4d3.erae",
+    "size": 165565423
+  },
+  {
+    "name": "mainnet-00729-cb0121c1.erae",
+    "size": 201504798
+  },
+  {
+    "name": "mainnet-00730-ae4f891a.erae",
+    "size": 192050801
+  },
+  {
+    "name": "mainnet-00731-f62f0179.erae",
+    "size": 190012814
+  },
+  {
+    "name": "mainnet-00732-fc23fa9a.erae",
+    "size": 171155747
+  },
+  {
+    "name": "mainnet-00733-fb8e0929.erae",
+    "size": 174685865
+  },
+  {
+    "name": "mainnet-00734-d20ad0ad.erae",
+    "size": 200360918
+  },
+  {
+    "name": "mainnet-00735-04f5183d.erae",
+    "size": 198714962
+  },
+  {
+    "name": "mainnet-00736-68d6c4a5.erae",
+    "size": 190751092
+  },
+  {
+    "name": "mainnet-00737-ca2aa00a.erae",
+    "size": 185637381
+  },
+  {
+    "name": "mainnet-00738-09b0cb7e.erae",
+    "size": 172510136
+  },
+  {
+    "name": "mainnet-00739-f4b930e7.erae",
+    "size": 197371988
+  },
+  {
+    "name": "mainnet-00740-bd2158bc.erae",
+    "size": 201318326
+  },
+  {
+    "name": "mainnet-00741-2777198f.erae",
+    "size": 202610227
+  },
+  {
+    "name": "mainnet-00742-b964c494.erae",
+    "size": 187264993
+  },
+  {
+    "name": "mainnet-00743-9737bfb3.erae",
+    "size": 182492918
+  },
+  {
+    "name": "mainnet-00744-804bc9fa.erae",
+    "size": 190335300
+  },
+  {
+    "name": "mainnet-00745-0c347e3a.erae",
+    "size": 158942840
+  },
+  {
+    "name": "mainnet-00746-ca094c1e.erae",
+    "size": 146335786
+  },
+  {
+    "name": "mainnet-00747-e6d5c022.erae",
+    "size": 170518142
+  },
+  {
+    "name": "mainnet-00748-9c866f3c.erae",
+    "size": 172557985
+  },
+  {
+    "name": "mainnet-00749-e42887cf.erae",
+    "size": 184668422
+  },
+  {
+    "name": "mainnet-00750-4136d331.erae",
+    "size": 182681587
+  },
+  {
+    "name": "mainnet-00751-e6baa034.erae",
+    "size": 178449823
+  },
+  {
+    "name": "mainnet-00752-5703c2ed.erae",
+    "size": 182170139
+  },
+  {
+    "name": "mainnet-00753-6f1d45d1.erae",
+    "size": 179730537
+  },
+  {
+    "name": "mainnet-00754-c3b3e7b6.erae",
+    "size": 188587172
+  },
+  {
+    "name": "mainnet-00755-07ed9850.erae",
+    "size": 198838535
+  },
+  {
+    "name": "mainnet-00756-b7d3783d.erae",
+    "size": 189617003
+  },
+  {
+    "name": "mainnet-00757-ebe2139e.erae",
+    "size": 183075975
+  },
+  {
+    "name": "mainnet-00758-bc5e30d3.erae",
+    "size": 190728307
+  },
+  {
+    "name": "mainnet-00759-d9ea6643.erae",
+    "size": 195055837
+  },
+  {
+    "name": "mainnet-00760-6a7435b1.erae",
+    "size": 204196246
+  },
+  {
+    "name": "mainnet-00761-96c5b69a.erae",
+    "size": 189643657
+  },
+  {
+    "name": "mainnet-00762-5072b822.erae",
+    "size": 175371433
+  },
+  {
+    "name": "mainnet-00763-dfa23bfc.erae",
+    "size": 185976014
+  },
+  {
+    "name": "mainnet-00764-a201390b.erae",
+    "size": 186623345
+  },
+  {
+    "name": "mainnet-00765-d0c96131.erae",
+    "size": 183400602
+  },
+  {
+    "name": "mainnet-00766-a44b3195.erae",
+    "size": 185076996
+  },
+  {
+    "name": "mainnet-00767-ceae895e.erae",
+    "size": 221675700
+  },
+  {
+    "name": "mainnet-00768-1907dc72.erae",
+    "size": 195521643
+  },
+  {
+    "name": "mainnet-00769-992e238b.erae",
+    "size": 180662834
+  },
+  {
+    "name": "mainnet-00770-dca46e39.erae",
+    "size": 178189884
+  },
+  {
+    "name": "mainnet-00771-404b5803.erae",
+    "size": 197210788
+  },
+  {
+    "name": "mainnet-00772-43f7681b.erae",
+    "size": 194319604
+  },
+  {
+    "name": "mainnet-00773-82318e5b.erae",
+    "size": 191209920
+  },
+  {
+    "name": "mainnet-00774-610d3df5.erae",
+    "size": 190489042
+  },
+  {
+    "name": "mainnet-00775-c2d57429.erae",
+    "size": 210160567
+  },
+  {
+    "name": "mainnet-00776-5e965e80.erae",
+    "size": 164948481
+  },
+  {
+    "name": "mainnet-00777-5d9a059d.erae",
+    "size": 211686859
+  },
+  {
+    "name": "mainnet-00778-d5bbd04a.erae",
+    "size": 193312043
+  },
+  {
+    "name": "mainnet-00779-0415519b.erae",
+    "size": 204913778
+  },
+  {
+    "name": "mainnet-00780-e4c55872.erae",
+    "size": 213035949
+  },
+  {
+    "name": "mainnet-00781-4408c263.erae",
+    "size": 223168865
+  },
+  {
+    "name": "mainnet-00782-9d4b169d.erae",
+    "size": 229184196
+  },
+  {
+    "name": "mainnet-00783-1cdd2a84.erae",
+    "size": 181943871
+  },
+  {
+    "name": "mainnet-00784-124faa87.erae",
+    "size": 166126416
+  },
+  {
+    "name": "mainnet-00785-0f040929.erae",
+    "size": 185765590
+  },
+  {
+    "name": "mainnet-00786-8fddf45f.erae",
+    "size": 164673234
+  },
+  {
+    "name": "mainnet-00787-bb8fa005.erae",
+    "size": 159885301
+  },
+  {
+    "name": "mainnet-00788-6d02af24.erae",
+    "size": 161236320
+  },
+  {
+    "name": "mainnet-00789-763ad297.erae",
+    "size": 141889896
+  },
+  {
+    "name": "mainnet-00790-43ec1983.erae",
+    "size": 136154510
+  },
+  {
+    "name": "mainnet-00791-d0208ec0.erae",
+    "size": 152029742
+  },
+  {
+    "name": "mainnet-00792-7135fb86.erae",
+    "size": 144949152
+  },
+  {
+    "name": "mainnet-00793-2b55f231.erae",
+    "size": 162958359
+  },
+  {
+    "name": "mainnet-00794-68b0f6ee.erae",
+    "size": 142340558
+  },
+  {
+    "name": "mainnet-00795-4b08dcd4.erae",
+    "size": 145891516
+  },
+  {
+    "name": "mainnet-00796-f1bee48b.erae",
+    "size": 142875282
+  },
+  {
+    "name": "mainnet-00797-6971161b.erae",
+    "size": 153194959
+  },
+  {
+    "name": "mainnet-00798-ed5cda06.erae",
+    "size": 156297169
+  },
+  {
+    "name": "mainnet-00799-86dbfe57.erae",
+    "size": 138410151
+  },
+  {
+    "name": "mainnet-00800-201d9bd9.erae",
+    "size": 146300927
+  },
+  {
+    "name": "mainnet-00801-f357c28f.erae",
+    "size": 153068956
+  },
+  {
+    "name": "mainnet-00802-3e4986fe.erae",
+    "size": 142422731
+  },
+  {
+    "name": "mainnet-00803-e98826c2.erae",
+    "size": 156503463
+  },
+  {
+    "name": "mainnet-00804-b1510272.erae",
+    "size": 141555880
+  },
+  {
+    "name": "mainnet-00805-6604a918.erae",
+    "size": 133873525
+  },
+  {
+    "name": "mainnet-00806-966ee78c.erae",
+    "size": 165246634
+  },
+  {
+    "name": "mainnet-00807-fa1450bb.erae",
+    "size": 157317377
+  },
+  {
+    "name": "mainnet-00808-ec745884.erae",
+    "size": 150880988
+  },
+  {
+    "name": "mainnet-00809-0847fb81.erae",
+    "size": 145437001
+  },
+  {
+    "name": "mainnet-00810-3a6e4c6a.erae",
+    "size": 136668418
+  },
+  {
+    "name": "mainnet-00811-b743cf2e.erae",
+    "size": 145839112
+  },
+  {
+    "name": "mainnet-00812-27b6605c.erae",
+    "size": 160809893
+  },
+  {
+    "name": "mainnet-00813-8c1475a4.erae",
+    "size": 151184614
+  },
+  {
+    "name": "mainnet-00814-c1c0a0de.erae",
+    "size": 141187881
+  },
+  {
+    "name": "mainnet-00815-c9e05fc6.erae",
+    "size": 141158527
+  },
+  {
+    "name": "mainnet-00816-513ddcc4.erae",
+    "size": 154223695
+  },
+  {
+    "name": "mainnet-00817-36c8c08b.erae",
+    "size": 146033686
+  },
+  {
+    "name": "mainnet-00818-be1226b0.erae",
+    "size": 156264859
+  },
+  {
+    "name": "mainnet-00819-42f6b025.erae",
+    "size": 142871331
+  },
+  {
+    "name": "mainnet-00820-ab5c79e5.erae",
+    "size": 133627625
+  },
+  {
+    "name": "mainnet-00821-fc913f25.erae",
+    "size": 139331564
+  },
+  {
+    "name": "mainnet-00822-23ce89f4.erae",
+    "size": 164827093
+  },
+  {
+    "name": "mainnet-00823-fb90b31c.erae",
+    "size": 154978844
+  },
+  {
+    "name": "mainnet-00824-830e2f97.erae",
+    "size": 153853771
+  },
+  {
+    "name": "mainnet-00825-423e3a68.erae",
+    "size": 131081604
+  },
+  {
+    "name": "mainnet-00826-fe98bc15.erae",
+    "size": 142081163
+  },
+  {
+    "name": "mainnet-00827-9fa677c7.erae",
+    "size": 156092018
+  },
+  {
+    "name": "mainnet-00828-7009e71f.erae",
+    "size": 157479475
+  },
+  {
+    "name": "mainnet-00829-280fc224.erae",
+    "size": 155273749
+  },
+  {
+    "name": "mainnet-00830-6b5ee58e.erae",
+    "size": 152302378
+  },
+  {
+    "name": "mainnet-00831-1e34814b.erae",
+    "size": 128144595
+  },
+  {
+    "name": "mainnet-00832-9217f484.erae",
+    "size": 153273382
+  },
+  {
+    "name": "mainnet-00833-f66a3de0.erae",
+    "size": 156707671
+  },
+  {
+    "name": "mainnet-00834-40f4fc07.erae",
+    "size": 157104608
+  },
+  {
+    "name": "mainnet-00835-5e9f7696.erae",
+    "size": 152368002
+  },
+  {
+    "name": "mainnet-00836-ca49ab54.erae",
+    "size": 141484729
+  },
+  {
+    "name": "mainnet-00837-278afd0c.erae",
+    "size": 152656790
+  },
+  {
+    "name": "mainnet-00838-dcc53bb0.erae",
+    "size": 151942854
+  },
+  {
+    "name": "mainnet-00839-70baa48f.erae",
+    "size": 144686770
+  },
+  {
+    "name": "mainnet-00840-d81f6e1b.erae",
+    "size": 149867492
+  },
+  {
+    "name": "mainnet-00841-d38e9c8c.erae",
+    "size": 142061906
+  },
+  {
+    "name": "mainnet-00842-17c23660.erae",
+    "size": 152034422
+  },
+  {
+    "name": "mainnet-00843-c412e4bb.erae",
+    "size": 160524431
+  },
+  {
+    "name": "mainnet-00844-1ff37aa8.erae",
+    "size": 168488485
+  },
+  {
+    "name": "mainnet-00845-4d168acc.erae",
+    "size": 157855781
+  },
+  {
+    "name": "mainnet-00846-74cffa5c.erae",
+    "size": 150795178
+  },
+  {
+    "name": "mainnet-00847-dcaa1f9c.erae",
+    "size": 156878450
+  },
+  {
+    "name": "mainnet-00848-1d84460c.erae",
+    "size": 144308137
+  },
+  {
+    "name": "mainnet-00849-6b064ba3.erae",
+    "size": 163141974
+  },
+  {
+    "name": "mainnet-00850-11d31d0f.erae",
+    "size": 148880240
+  },
+  {
+    "name": "mainnet-00851-33e15598.erae",
+    "size": 144091215
+  },
+  {
+    "name": "mainnet-00852-2b5d36a4.erae",
+    "size": 145858413
+  },
+  {
+    "name": "mainnet-00853-a6812f13.erae",
+    "size": 125085732
+  },
+  {
+    "name": "mainnet-00854-beb42d41.erae",
+    "size": 171155716
+  },
+  {
+    "name": "mainnet-00855-f6ad948e.erae",
+    "size": 155826827
+  },
+  {
+    "name": "mainnet-00856-ce8bbc22.erae",
+    "size": 150168754
+  },
+  {
+    "name": "mainnet-00857-bcf3406f.erae",
+    "size": 150731445
+  },
+  {
+    "name": "mainnet-00858-5da31996.erae",
+    "size": 161867694
+  },
+  {
+    "name": "mainnet-00859-b47c101d.erae",
+    "size": 155866232
+  },
+  {
+    "name": "mainnet-00860-e8fdeb10.erae",
+    "size": 152883561
+  },
+  {
+    "name": "mainnet-00861-9973d74e.erae",
+    "size": 138271806
+  },
+  {
+    "name": "mainnet-00862-3d90fece.erae",
+    "size": 155924675
+  },
+  {
+    "name": "mainnet-00863-df9c7a70.erae",
+    "size": 151201524
+  },
+  {
+    "name": "mainnet-00864-4663c550.erae",
+    "size": 149578754
+  },
+  {
+    "name": "mainnet-00865-a0b26a4a.erae",
+    "size": 156936114
+  },
+  {
+    "name": "mainnet-00866-6f4358a3.erae",
+    "size": 155996400
+  },
+  {
+    "name": "mainnet-00867-ae3e551c.erae",
+    "size": 189133165
+  },
+  {
+    "name": "mainnet-00868-4d1f03b0.erae",
+    "size": 174063311
+  },
+  {
+    "name": "mainnet-00869-f2adc483.erae",
+    "size": 155669362
+  },
+  {
+    "name": "mainnet-00870-dd88c4bc.erae",
+    "size": 160305653
+  },
+  {
+    "name": "mainnet-00871-bbda54d3.erae",
+    "size": 178124738
+  },
+  {
+    "name": "mainnet-00872-d86cea74.erae",
+    "size": 181003951
+  },
+  {
+    "name": "mainnet-00873-b9436b49.erae",
+    "size": 178066351
+  },
+  {
+    "name": "mainnet-00874-9e31d9a6.erae",
+    "size": 147240929
+  },
+  {
+    "name": "mainnet-00875-4ab54570.erae",
+    "size": 142017457
+  },
+  {
+    "name": "mainnet-00876-29bf60c8.erae",
+    "size": 144251184
+  },
+  {
+    "name": "mainnet-00877-8e241ef7.erae",
+    "size": 142787633
+  },
+  {
+    "name": "mainnet-00878-f432ef34.erae",
+    "size": 148040921
+  },
+  {
+    "name": "mainnet-00879-8287624e.erae",
+    "size": 162107449
+  },
+  {
+    "name": "mainnet-00880-2cacc334.erae",
+    "size": 182402452
+  },
+  {
+    "name": "mainnet-00881-eedcf212.erae",
+    "size": 189507758
+  },
+  {
+    "name": "mainnet-00882-dfcd4b99.erae",
+    "size": 177731712
+  },
+  {
+    "name": "mainnet-00883-ccdf667d.erae",
+    "size": 201568764
+  },
+  {
+    "name": "mainnet-00884-294650d7.erae",
+    "size": 202100161
+  },
+  {
+    "name": "mainnet-00885-c9b5f143.erae",
+    "size": 196990306
+  },
+  {
+    "name": "mainnet-00886-7bc4c8f1.erae",
+    "size": 201676233
+  },
+  {
+    "name": "mainnet-00887-3eaf5e6a.erae",
+    "size": 209089700
+  },
+  {
+    "name": "mainnet-00888-3fb0ca9a.erae",
+    "size": 192599023
+  },
+  {
+    "name": "mainnet-00889-136d8649.erae",
+    "size": 150176283
+  },
+  {
+    "name": "mainnet-00890-fe1d63b3.erae",
+    "size": 133188706
+  },
+  {
+    "name": "mainnet-00891-68907dc0.erae",
+    "size": 159145370
+  },
+  {
+    "name": "mainnet-00892-3afdc77e.erae",
+    "size": 160389789
+  },
+  {
+    "name": "mainnet-00893-afd5644e.erae",
+    "size": 152322940
+  },
+  {
+    "name": "mainnet-00894-a1b17fa6.erae",
+    "size": 149669541
+  },
+  {
+    "name": "mainnet-00895-b0964206.erae",
+    "size": 144565950
+  },
+  {
+    "name": "mainnet-00896-7c62cb83.erae",
+    "size": 139186629
+  },
+  {
+    "name": "mainnet-00897-955b0f5f.erae",
+    "size": 146274651
+  },
+  {
+    "name": "mainnet-00898-2ac4f6fc.erae",
+    "size": 151461155
+  },
+  {
+    "name": "mainnet-00899-82d9e4b7.erae",
+    "size": 154660756
+  },
+  {
+    "name": "mainnet-00900-1fac2ca4.erae",
+    "size": 146090200
+  },
+  {
+    "name": "mainnet-00901-4e6be3e7.erae",
+    "size": 129860995
+  },
+  {
+    "name": "mainnet-00902-abf62069.erae",
+    "size": 156154171
+  },
+  {
+    "name": "mainnet-00903-a0baca39.erae",
+    "size": 173259017
+  },
+  {
+    "name": "mainnet-00904-cf03e75a.erae",
+    "size": 168752324
+  },
+  {
+    "name": "mainnet-00905-6d5ce48d.erae",
+    "size": 158444890
+  },
+  {
+    "name": "mainnet-00906-05fba316.erae",
+    "size": 144282294
+  },
+  {
+    "name": "mainnet-00907-00d15b5a.erae",
+    "size": 157286253
+  },
+  {
+    "name": "mainnet-00908-3f97eba5.erae",
+    "size": 164543484
+  },
+  {
+    "name": "mainnet-00909-6e1dc9bf.erae",
+    "size": 163682416
+  },
+  {
+    "name": "mainnet-00910-408ec17d.erae",
+    "size": 168759198
+  },
+  {
+    "name": "mainnet-00911-a2e0b25d.erae",
+    "size": 171285592
+  },
+  {
+    "name": "mainnet-00912-8ebe39e1.erae",
+    "size": 161202589
+  },
+  {
+    "name": "mainnet-00913-7747b116.erae",
+    "size": 174214411
+  },
+  {
+    "name": "mainnet-00914-dba32097.erae",
+    "size": 196056433
+  },
+  {
+    "name": "mainnet-00915-a262c4f6.erae",
+    "size": 175827702
+  },
+  {
+    "name": "mainnet-00916-0fbc4a2a.erae",
+    "size": 156375074
+  },
+  {
+    "name": "mainnet-00917-e62f7cf9.erae",
+    "size": 144176000
+  },
+  {
+    "name": "mainnet-00918-8b275459.erae",
+    "size": 166785847
+  },
+  {
+    "name": "mainnet-00919-c64c08c4.erae",
+    "size": 160457675
+  },
+  {
+    "name": "mainnet-00920-e9ccd801.erae",
+    "size": 172920667
+  },
+  {
+    "name": "mainnet-00921-3cdb12ad.erae",
+    "size": 184110913
+  },
+  {
+    "name": "mainnet-00922-fb5c16b4.erae",
+    "size": 157412626
+  },
+  {
+    "name": "mainnet-00923-d798990c.erae",
+    "size": 137679405
+  },
+  {
+    "name": "mainnet-00924-4f9c949b.erae",
+    "size": 164615933
+  },
+  {
+    "name": "mainnet-00925-551220ab.erae",
+    "size": 176665592
+  },
+  {
+    "name": "mainnet-00926-415ecebe.erae",
+    "size": 173148864
+  },
+  {
+    "name": "mainnet-00927-c1fd8821.erae",
+    "size": 167856459
+  },
+  {
+    "name": "mainnet-00928-5a68c760.erae",
+    "size": 167660322
+  },
+  {
+    "name": "mainnet-00929-f4bd2370.erae",
+    "size": 169504485
+  },
+  {
+    "name": "mainnet-00930-7abf8323.erae",
+    "size": 179077325
+  },
+  {
+    "name": "mainnet-00931-73245160.erae",
+    "size": 168000129
+  },
+  {
+    "name": "mainnet-00932-03a5dc09.erae",
+    "size": 176542157
+  },
+  {
+    "name": "mainnet-00933-f0cba349.erae",
+    "size": 146770410
+  },
+  {
+    "name": "mainnet-00934-2fec8be1.erae",
+    "size": 141438032
+  },
+  {
+    "name": "mainnet-00935-a7150ff9.erae",
+    "size": 166997566
+  },
+  {
+    "name": "mainnet-00936-e46e4079.erae",
+    "size": 179044702
+  },
+  {
+    "name": "mainnet-00937-90db96fa.erae",
+    "size": 164323986
+  },
+  {
+    "name": "mainnet-00938-bfab2a82.erae",
+    "size": 170227721
+  },
+  {
+    "name": "mainnet-00939-e6d22862.erae",
+    "size": 161107727
+  },
+  {
+    "name": "mainnet-00940-9e32b2f4.erae",
+    "size": 177265482
+  },
+  {
+    "name": "mainnet-00941-ac881631.erae",
+    "size": 176258425
+  },
+  {
+    "name": "mainnet-00942-65aa0b12.erae",
+    "size": 184462462
+  },
+  {
+    "name": "mainnet-00943-bdc491e2.erae",
+    "size": 194056842
+  },
+  {
+    "name": "mainnet-00944-56d8df86.erae",
+    "size": 188362530
+  },
+  {
+    "name": "mainnet-00945-d25ca1e5.erae",
+    "size": 174986291
+  },
+  {
+    "name": "mainnet-00946-79323ef6.erae",
+    "size": 199957674
+  },
+  {
+    "name": "mainnet-00947-42cc43fe.erae",
+    "size": 204962314
+  },
+  {
+    "name": "mainnet-00948-7492466e.erae",
+    "size": 211967734
+  },
+  {
+    "name": "mainnet-00949-e032b616.erae",
+    "size": 195848172
+  },
+  {
+    "name": "mainnet-00950-0052c55c.erae",
+    "size": 189195253
+  },
+  {
+    "name": "mainnet-00951-373ba812.erae",
+    "size": 202406964
+  },
+  {
+    "name": "mainnet-00952-f5129975.erae",
+    "size": 198187040
+  },
+  {
+    "name": "mainnet-00953-93cd498b.erae",
+    "size": 220513872
+  },
+  {
+    "name": "mainnet-00954-e5e15c77.erae",
+    "size": 214358774
+  },
+  {
+    "name": "mainnet-00955-759a521f.erae",
+    "size": 197374420
+  },
+  {
+    "name": "mainnet-00956-b4beb890.erae",
+    "size": 188301655
+  },
+  {
+    "name": "mainnet-00957-76386f19.erae",
+    "size": 224940934
+  },
+  {
+    "name": "mainnet-00958-856c9920.erae",
+    "size": 206956502
+  },
+  {
+    "name": "mainnet-00959-f0512691.erae",
+    "size": 204395979
+  },
+  {
+    "name": "mainnet-00960-98f8050e.erae",
+    "size": 204024679
+  },
+  {
+    "name": "mainnet-00961-13288f31.erae",
+    "size": 211441619
+  },
+  {
+    "name": "mainnet-00962-a257b866.erae",
+    "size": 203586836
+  },
+  {
+    "name": "mainnet-00963-f72f9cdb.erae",
+    "size": 205148140
+  },
+  {
+    "name": "mainnet-00964-f312fa2b.erae",
+    "size": 195435438
+  },
+  {
+    "name": "mainnet-00965-16e60825.erae",
+    "size": 196458456
+  },
+  {
+    "name": "mainnet-00966-0b03cf04.erae",
+    "size": 208893079
+  },
+  {
+    "name": "mainnet-00967-3acfa5f2.erae",
+    "size": 173276689
+  },
+  {
+    "name": "mainnet-00968-2acc23dd.erae",
+    "size": 244649049
+  },
+  {
+    "name": "mainnet-00969-b7d2ee0a.erae",
+    "size": 203957562
+  },
+  {
+    "name": "mainnet-00970-30bc07eb.erae",
+    "size": 178467803
+  },
+  {
+    "name": "mainnet-00971-16576044.erae",
+    "size": 213949768
+  },
+  {
+    "name": "mainnet-00972-f55c8663.erae",
+    "size": 204346339
+  },
+  {
+    "name": "mainnet-00973-01ae7f8c.erae",
+    "size": 212082637
+  },
+  {
+    "name": "mainnet-00974-d54c3761.erae",
+    "size": 205627936
+  },
+  {
+    "name": "mainnet-00975-9d31948f.erae",
+    "size": 231095358
+  },
+  {
+    "name": "mainnet-00976-09948f92.erae",
+    "size": 204877081
+  },
+  {
+    "name": "mainnet-00977-30ef19b8.erae",
+    "size": 175467984
+  },
+  {
+    "name": "mainnet-00978-3a636ec4.erae",
+    "size": 196610561
+  },
+  {
+    "name": "mainnet-00979-387ff902.erae",
+    "size": 216890497
+  },
+  {
+    "name": "mainnet-00980-637c8eb5.erae",
+    "size": 201964503
+  },
+  {
+    "name": "mainnet-00981-60126dfd.erae",
+    "size": 203380383
+  },
+  {
+    "name": "mainnet-00982-12b2a200.erae",
+    "size": 227519778
+  },
+  {
+    "name": "mainnet-00983-836f51c5.erae",
+    "size": 172972551
+  },
+  {
+    "name": "mainnet-00984-5e58eb1a.erae",
+    "size": 212366738
+  },
+  {
+    "name": "mainnet-00985-6db8a6d6.erae",
+    "size": 220043553
+  },
+  {
+    "name": "mainnet-00986-d0825694.erae",
+    "size": 194001090
+  },
+  {
+    "name": "mainnet-00987-b86fbe8a.erae",
+    "size": 196713971
+  },
+  {
+    "name": "mainnet-00988-41671415.erae",
+    "size": 187242602
+  },
+  {
+    "name": "mainnet-00989-714d21a7.erae",
+    "size": 189436708
+  },
+  {
+    "name": "mainnet-00990-a0f3a107.erae",
+    "size": 204303890
+  },
+  {
+    "name": "mainnet-00991-8bf91e9f.erae",
+    "size": 178256443
+  },
+  {
+    "name": "mainnet-00992-9d88a0ab.erae",
+    "size": 224354736
+  },
+  {
+    "name": "mainnet-00993-bf79b5df.erae",
+    "size": 170162802
+  },
+  {
+    "name": "mainnet-00994-b8232c62.erae",
+    "size": 154470572
+  },
+  {
+    "name": "mainnet-00995-89a33907.erae",
+    "size": 216489066
+  },
+  {
+    "name": "mainnet-00996-721fd7c9.erae",
+    "size": 255401542
+  },
+  {
+    "name": "mainnet-00997-9ee5cb5c.erae",
+    "size": 200746191
+  },
+  {
+    "name": "mainnet-00998-b84a7ca9.erae",
+    "size": 186678689
+  },
+  {
+    "name": "mainnet-00999-0d656b0c.erae",
+    "size": 151711639
+  },
+  {
+    "name": "mainnet-01000-6b5390b8.erae",
+    "size": 151042855
+  },
+  {
+    "name": "mainnet-01001-9169aac2.erae",
+    "size": 167240188
+  },
+  {
+    "name": "mainnet-01002-a112fa91.erae",
+    "size": 195835042
+  },
+  {
+    "name": "mainnet-01003-02526c10.erae",
+    "size": 224084912
+  },
+  {
+    "name": "mainnet-01004-3bd311b5.erae",
+    "size": 166186778
+  },
+  {
+    "name": "mainnet-01005-b36af400.erae",
+    "size": 150367101
+  },
+  {
+    "name": "mainnet-01006-1a57dc5b.erae",
+    "size": 168306354
+  },
+  {
+    "name": "mainnet-01007-6d353f86.erae",
+    "size": 180583857
+  },
+  {
+    "name": "mainnet-01008-7ed3518e.erae",
+    "size": 194738781
+  },
+  {
+    "name": "mainnet-01009-750ca8c7.erae",
+    "size": 202263062
+  },
+  {
+    "name": "mainnet-01010-b3301d4a.erae",
+    "size": 187324774
+  },
+  {
+    "name": "mainnet-01011-ae7e747c.erae",
+    "size": 169121389
+  },
+  {
+    "name": "mainnet-01012-9588db2d.erae",
+    "size": 187342346
+  },
+  {
+    "name": "mainnet-01013-9765aec4.erae",
+    "size": 180120506
+  },
+  {
+    "name": "mainnet-01014-81cb85b0.erae",
+    "size": 185568705
+  },
+  {
+    "name": "mainnet-01015-f35fabd0.erae",
+    "size": 172790855
+  },
+  {
+    "name": "mainnet-01016-6b4d1ba0.erae",
+    "size": 149344446
+  },
+  {
+    "name": "mainnet-01017-e678607f.erae",
+    "size": 162037768
+  },
+  {
+    "name": "mainnet-01018-f73b294d.erae",
+    "size": 182859918
+  },
+  {
+    "name": "mainnet-01019-74b0ff1e.erae",
+    "size": 185868507
+  },
+  {
+    "name": "mainnet-01020-cc423ab6.erae",
+    "size": 171111157
+  },
+  {
+    "name": "mainnet-01021-20ce541e.erae",
+    "size": 162432605
+  },
+  {
+    "name": "mainnet-01022-6b728419.erae",
+    "size": 174792461
+  },
+  {
+    "name": "mainnet-01023-bd3b4607.erae",
+    "size": 182780470
+  },
+  {
+    "name": "mainnet-01024-f6f05807.erae",
+    "size": 171593664
+  },
+  {
+    "name": "mainnet-01025-d781bd64.erae",
+    "size": 185998670
+  },
+  {
+    "name": "mainnet-01026-bbfc9f6d.erae",
+    "size": 182214709
+  },
+  {
+    "name": "mainnet-01027-93eb4af0.erae",
+    "size": 164523904
+  },
+  {
+    "name": "mainnet-01028-94d04d06.erae",
+    "size": 174904528
+  },
+  {
+    "name": "mainnet-01029-e444f5c6.erae",
+    "size": 187951521
+  },
+  {
+    "name": "mainnet-01030-2a3c75e1.erae",
+    "size": 189357265
+  },
+  {
+    "name": "mainnet-01031-44aa09d6.erae",
+    "size": 167125856
+  },
+  {
+    "name": "mainnet-01032-668dddaf.erae",
+    "size": 165762877
+  },
+  {
+    "name": "mainnet-01033-6f544a62.erae",
+    "size": 181806471
+  },
+  {
+    "name": "mainnet-01034-22e2295a.erae",
+    "size": 185231878
+  },
+  {
+    "name": "mainnet-01035-cccfc9ad.erae",
+    "size": 161811998
+  },
+  {
+    "name": "mainnet-01036-d958217d.erae",
+    "size": 184592690
+  },
+  {
+    "name": "mainnet-01037-82476215.erae",
+    "size": 184165174
+  },
+  {
+    "name": "mainnet-01038-df23a7cc.erae",
+    "size": 156515511
+  },
+  {
+    "name": "mainnet-01039-d12b76e5.erae",
+    "size": 165612252
+  },
+  {
+    "name": "mainnet-01040-ae792637.erae",
+    "size": 176153331
+  },
+  {
+    "name": "mainnet-01041-61dbf17f.erae",
+    "size": 171877184
+  },
+  {
+    "name": "mainnet-01042-0682af16.erae",
+    "size": 143983187
+  },
+  {
+    "name": "mainnet-01043-613fc3c6.erae",
+    "size": 152076201
+  },
+  {
+    "name": "mainnet-01044-61c15743.erae",
+    "size": 173131761
+  },
+  {
+    "name": "mainnet-01045-a28227eb.erae",
+    "size": 161345194
+  },
+  {
+    "name": "mainnet-01046-fa620a0a.erae",
+    "size": 159015119
+  },
+  {
+    "name": "mainnet-01047-24363f46.erae",
+    "size": 181456374
+  },
+  {
+    "name": "mainnet-01048-7c00a03c.erae",
+    "size": 154191565
+  },
+  {
+    "name": "mainnet-01049-001273c2.erae",
+    "size": 138319417
+  },
+  {
+    "name": "mainnet-01050-0ce373f3.erae",
+    "size": 155230833
+  },
+  {
+    "name": "mainnet-01051-67eb3454.erae",
+    "size": 180273556
+  },
+  {
+    "name": "mainnet-01052-4d805723.erae",
+    "size": 166603446
+  },
+  {
+    "name": "mainnet-01053-239d48dd.erae",
+    "size": 142999568
+  },
+  {
+    "name": "mainnet-01054-d3871ebc.erae",
+    "size": 154511669
+  },
+  {
+    "name": "mainnet-01055-d1555fa0.erae",
+    "size": 157016506
+  },
+  {
+    "name": "mainnet-01056-01809281.erae",
+    "size": 169997302
+  },
+  {
+    "name": "mainnet-01057-ee0b8665.erae",
+    "size": 168713627
+  },
+  {
+    "name": "mainnet-01058-91d55bfd.erae",
+    "size": 177021454
+  },
+  {
+    "name": "mainnet-01059-39e8626c.erae",
+    "size": 161456663
+  },
+  {
+    "name": "mainnet-01060-7748276b.erae",
+    "size": 146212118
+  },
+  {
+    "name": "mainnet-01061-295a14a7.erae",
+    "size": 178546296
+  },
+  {
+    "name": "mainnet-01062-e017f86a.erae",
+    "size": 193041479
+  },
+  {
+    "name": "mainnet-01063-d4c87c6e.erae",
+    "size": 185445059
+  },
+  {
+    "name": "mainnet-01064-0b63c211.erae",
+    "size": 172941880
+  },
+  {
+    "name": "mainnet-01065-3a81a033.erae",
+    "size": 161336059
+  },
+  {
+    "name": "mainnet-01066-3110a073.erae",
+    "size": 168794747
+  },
+  {
+    "name": "mainnet-01067-bab9ab5d.erae",
+    "size": 170188787
+  },
+  {
+    "name": "mainnet-01068-6bd06950.erae",
+    "size": 184215336
+  },
+  {
+    "name": "mainnet-01069-389e2e24.erae",
+    "size": 191881526
+  },
+  {
+    "name": "mainnet-01070-8eb3124d.erae",
+    "size": 169173703
+  },
+  {
+    "name": "mainnet-01071-e5f5bcb7.erae",
+    "size": 158722257
+  },
+  {
+    "name": "mainnet-01072-678271f8.erae",
+    "size": 184932172
+  },
+  {
+    "name": "mainnet-01073-9c042f65.erae",
+    "size": 193683167
+  },
+  {
+    "name": "mainnet-01074-34231712.erae",
+    "size": 183279119
+  },
+  {
+    "name": "mainnet-01075-d095d9ab.erae",
+    "size": 204235174
+  },
+  {
+    "name": "mainnet-01076-4896752d.erae",
+    "size": 175841671
+  },
+  {
+    "name": "mainnet-01077-6a2320f1.erae",
+    "size": 179054448
+  },
+  {
+    "name": "mainnet-01078-47ab0d7e.erae",
+    "size": 192647242
+  },
+  {
+    "name": "mainnet-01079-b6c38a7c.erae",
+    "size": 198994798
+  },
+  {
+    "name": "mainnet-01080-d8456805.erae",
+    "size": 178614922
+  },
+  {
+    "name": "mainnet-01081-6c2d91cf.erae",
+    "size": 170372068
+  },
+  {
+    "name": "mainnet-01082-01cbc052.erae",
+    "size": 187211797
+  },
+  {
+    "name": "mainnet-01083-b67c33d8.erae",
+    "size": 185470860
+  },
+  {
+    "name": "mainnet-01084-ff793461.erae",
+    "size": 188001816
+  },
+  {
+    "name": "mainnet-01085-0ac504c0.erae",
+    "size": 209977507
+  },
+  {
+    "name": "mainnet-01086-e2a1cdb7.erae",
+    "size": 180664045
+  },
+  {
+    "name": "mainnet-01087-37e75588.erae",
+    "size": 182569721
+  },
+  {
+    "name": "mainnet-01088-c278ed24.erae",
+    "size": 207867937
+  },
+  {
+    "name": "mainnet-01089-edc18889.erae",
+    "size": 188749266
+  },
+  {
+    "name": "mainnet-01090-56e387ea.erae",
+    "size": 203872794
+  },
+  {
+    "name": "mainnet-01091-6eedf814.erae",
+    "size": 196730813
+  },
+  {
+    "name": "mainnet-01092-9188cacd.erae",
+    "size": 221107290
+  },
+  {
+    "name": "mainnet-01093-5217bbc3.erae",
+    "size": 218069092
+  },
+  {
+    "name": "mainnet-01094-77f896d6.erae",
+    "size": 197293634
+  },
+  {
+    "name": "mainnet-01095-47120ca5.erae",
+    "size": 202401559
+  },
+  {
+    "name": "mainnet-01096-b27430d8.erae",
+    "size": 218875663
+  },
+  {
+    "name": "mainnet-01097-cf4c77e5.erae",
+    "size": 170778628
+  },
+  {
+    "name": "mainnet-01098-acb413cf.erae",
+    "size": 216370682
+  },
+  {
+    "name": "mainnet-01099-69443252.erae",
+    "size": 212074855
+  },
+  {
+    "name": "mainnet-01100-c38a74ff.erae",
+    "size": 212147097
+  },
+  {
+    "name": "mainnet-01101-1824b7bf.erae",
+    "size": 202047137
+  },
+  {
+    "name": "mainnet-01102-310b3f79.erae",
+    "size": 189042929
+  },
+  {
+    "name": "mainnet-01103-03159234.erae",
+    "size": 207639170
+  },
+  {
+    "name": "mainnet-01104-43bf966b.erae",
+    "size": 213870656
+  },
+  {
+    "name": "mainnet-01105-b18c9e89.erae",
+    "size": 208779837
+  },
+  {
+    "name": "mainnet-01106-1416f1b5.erae",
+    "size": 155753777
+  },
+  {
+    "name": "mainnet-01107-6c5c771e.erae",
+    "size": 174923977
+  },
+  {
+    "name": "mainnet-01108-8ba378ed.erae",
+    "size": 199706809
+  },
+  {
+    "name": "mainnet-01109-ede8a1ca.erae",
+    "size": 193401018
+  },
+  {
+    "name": "mainnet-01110-c00f554b.erae",
+    "size": 200425869
+  },
+  {
+    "name": "mainnet-01111-08f3d484.erae",
+    "size": 184091268
+  },
+  {
+    "name": "mainnet-01112-238cea85.erae",
+    "size": 201421088
+  },
+  {
+    "name": "mainnet-01113-db6abb40.erae",
+    "size": 228319130
+  },
+  {
+    "name": "mainnet-01114-eadb9cdb.erae",
+    "size": 212829052
+  },
+  {
+    "name": "mainnet-01115-b9bcf111.erae",
+    "size": 207670316
+  },
+  {
+    "name": "mainnet-01116-77eaa676.erae",
+    "size": 200170749
+  },
+  {
+    "name": "mainnet-01117-530fb245.erae",
+    "size": 198557002
+  },
+  {
+    "name": "mainnet-01118-323b2125.erae",
+    "size": 204608672
+  },
+  {
+    "name": "mainnet-01119-dbfa75e3.erae",
+    "size": 190801626
+  },
+  {
+    "name": "mainnet-01120-0aa9ea60.erae",
+    "size": 164737014
+  },
+  {
+    "name": "mainnet-01121-edf81636.erae",
+    "size": 202798810
+  },
+  {
+    "name": "mainnet-01122-630f41de.erae",
+    "size": 169974809
+  },
+  {
+    "name": "mainnet-01123-4344e7a6.erae",
+    "size": 163478654
+  },
+  {
+    "name": "mainnet-01124-0427814b.erae",
+    "size": 150380069
+  },
+  {
+    "name": "mainnet-01125-7d7b367e.erae",
+    "size": 146186420
+  },
+  {
+    "name": "mainnet-01126-6b33e3b4.erae",
+    "size": 172757435
+  },
+  {
+    "name": "mainnet-01127-aa2e8715.erae",
+    "size": 183529044
+  },
+  {
+    "name": "mainnet-01128-e359f8c1.erae",
+    "size": 163834190
+  },
+  {
+    "name": "mainnet-01129-24f81c27.erae",
+    "size": 156744000
+  },
+  {
+    "name": "mainnet-01130-3c50c704.erae",
+    "size": 150730983
+  },
+  {
+    "name": "mainnet-01131-042566e5.erae",
+    "size": 283507477
+  },
+  {
+    "name": "mainnet-01132-ae3530c7.erae",
+    "size": 177160005
+  },
+  {
+    "name": "mainnet-01133-0f93d074.erae",
+    "size": 182522490
+  },
+  {
+    "name": "mainnet-01134-b74e0306.erae",
+    "size": 185381258
+  },
+  {
+    "name": "mainnet-01135-7da9639e.erae",
+    "size": 175870699
+  },
+  {
+    "name": "mainnet-01136-ef3175b8.erae",
+    "size": 163391145
+  },
+  {
+    "name": "mainnet-01137-905ce5f6.erae",
+    "size": 158032689
+  },
+  {
+    "name": "mainnet-01138-442ea2c5.erae",
+    "size": 151996925
+  },
+  {
+    "name": "mainnet-01139-7eecb71a.erae",
+    "size": 145149986
+  },
+  {
+    "name": "mainnet-01140-8e2050ae.erae",
+    "size": 149386454
+  },
+  {
+    "name": "mainnet-01141-49ee5c32.erae",
+    "size": 128778309
+  },
+  {
+    "name": "mainnet-01142-547dfca0.erae",
+    "size": 133754176
+  },
+  {
+    "name": "mainnet-01143-49ca6103.erae",
+    "size": 155668315
+  },
+  {
+    "name": "mainnet-01144-bbc7ff27.erae",
+    "size": 152576166
+  },
+  {
+    "name": "mainnet-01145-25128b10.erae",
+    "size": 167643594
+  },
+  {
+    "name": "mainnet-01146-195a4a93.erae",
+    "size": 169757617
+  },
+  {
+    "name": "mainnet-01147-9db137cf.erae",
+    "size": 154114325
+  },
+  {
+    "name": "mainnet-01148-db5932e5.erae",
+    "size": 165831368
+  },
+  {
+    "name": "mainnet-01149-8eb2e3ca.erae",
+    "size": 173687029
+  },
+  {
+    "name": "mainnet-01150-a039f317.erae",
+    "size": 190402280
+  },
+  {
+    "name": "mainnet-01151-97c5cb5a.erae",
+    "size": 193427301
+  },
+  {
+    "name": "mainnet-01152-aecf07cb.erae",
+    "size": 176665756
+  },
+  {
+    "name": "mainnet-01153-470228de.erae",
+    "size": 172868885
+  },
+  {
+    "name": "mainnet-01154-7b451286.erae",
+    "size": 187404959
+  },
+  {
+    "name": "mainnet-01155-9301d474.erae",
+    "size": 208022265
+  },
+  {
+    "name": "mainnet-01156-c0aeb280.erae",
+    "size": 207876842
+  },
+  {
+    "name": "mainnet-01157-da0184e7.erae",
+    "size": 206144756
+  },
+  {
+    "name": "mainnet-01158-1d6f1911.erae",
+    "size": 187082373
+  },
+  {
+    "name": "mainnet-01159-5a95eed1.erae",
+    "size": 195396839
+  },
+  {
+    "name": "mainnet-01160-108084e3.erae",
+    "size": 188141148
+  },
+  {
+    "name": "mainnet-01161-3ae37cf6.erae",
+    "size": 193382188
+  },
+  {
+    "name": "mainnet-01162-d26195ac.erae",
+    "size": 192143018
+  },
+  {
+    "name": "mainnet-01163-4f199314.erae",
+    "size": 168435550
+  },
+  {
+    "name": "mainnet-01164-224bd227.erae",
+    "size": 161793240
+  },
+  {
+    "name": "mainnet-01165-ef00b468.erae",
+    "size": 188963644
+  },
+  {
+    "name": "mainnet-01166-a11333e5.erae",
+    "size": 198398648
+  },
+  {
+    "name": "mainnet-01167-e9c7f2c5.erae",
+    "size": 194914686
+  },
+  {
+    "name": "mainnet-01168-1f9ad6b4.erae",
+    "size": 182907870
+  },
+  {
+    "name": "mainnet-01169-1288ca5a.erae",
+    "size": 171852325
+  },
+  {
+    "name": "mainnet-01170-fffece77.erae",
+    "size": 180012431
+  },
+  {
+    "name": "mainnet-01171-56a3c2dc.erae",
+    "size": 175785850
+  },
+  {
+    "name": "mainnet-01172-66a71eaf.erae",
+    "size": 178885291
+  },
+  {
+    "name": "mainnet-01173-b166b3c0.erae",
+    "size": 193715128
+  },
+  {
+    "name": "mainnet-01174-27ac2f0f.erae",
+    "size": 175063230
+  },
+  {
+    "name": "mainnet-01175-fdd0cf36.erae",
+    "size": 173761831
+  },
+  {
+    "name": "mainnet-01176-3deb03ce.erae",
+    "size": 214008060
+  },
+  {
+    "name": "mainnet-01177-c5ea20de.erae",
+    "size": 198438629
+  },
+  {
+    "name": "mainnet-01178-8cac5190.erae",
+    "size": 209637307
+  },
+  {
+    "name": "mainnet-01179-b04f70b0.erae",
+    "size": 224112113
+  },
+  {
+    "name": "mainnet-01180-ba2658b3.erae",
+    "size": 188446971
+  },
+  {
+    "name": "mainnet-01181-a4ca3a8f.erae",
+    "size": 196470699
+  },
+  {
+    "name": "mainnet-01182-4981d1eb.erae",
+    "size": 205634178
+  },
+  {
+    "name": "mainnet-01183-244e41f2.erae",
+    "size": 192517618
+  },
+  {
+    "name": "mainnet-01184-42c66956.erae",
+    "size": 224960063
+  },
+  {
+    "name": "mainnet-01185-ebba8c58.erae",
+    "size": 224598701
+  },
+  {
+    "name": "mainnet-01186-5bcc5a63.erae",
+    "size": 195422493
+  },
+  {
+    "name": "mainnet-01187-d3ce49ee.erae",
+    "size": 202313049
+  },
+  {
+    "name": "mainnet-01188-54056d9d.erae",
+    "size": 215752245
+  },
+  {
+    "name": "mainnet-01189-7a64b37a.erae",
+    "size": 199330704
+  },
+  {
+    "name": "mainnet-01190-8b0c31c6.erae",
+    "size": 182359542
+  },
+  {
+    "name": "mainnet-01191-452c35e1.erae",
+    "size": 176280646
+  },
+  {
+    "name": "mainnet-01192-da3e99bc.erae",
+    "size": 174080624
+  },
+  {
+    "name": "mainnet-01193-eec8cdcb.erae",
+    "size": 198141510
+  },
+  {
+    "name": "mainnet-01194-d2057dca.erae",
+    "size": 180870619
+  },
+  {
+    "name": "mainnet-01195-f76ddc4a.erae",
+    "size": 197326352
+  },
+  {
+    "name": "mainnet-01196-b1c2703c.erae",
+    "size": 188063068
+  },
+  {
+    "name": "mainnet-01197-1894b15a.erae",
+    "size": 170187237
+  },
+  {
+    "name": "mainnet-01198-5b37dd53.erae",
+    "size": 197040582
+  },
+  {
+    "name": "mainnet-01199-dc96f524.erae",
+    "size": 208723455
+  },
+  {
+    "name": "mainnet-01200-625fca2d.erae",
+    "size": 206995901
+  },
+  {
+    "name": "mainnet-01201-30d85914.erae",
+    "size": 192116846
+  },
+  {
+    "name": "mainnet-01202-64e8f9a8.erae",
+    "size": 201682469
+  },
+  {
+    "name": "mainnet-01203-022d252f.erae",
+    "size": 202386871
+  },
+  {
+    "name": "mainnet-01204-74b0ec6c.erae",
+    "size": 203321011
+  },
+  {
+    "name": "mainnet-01205-b48ce3dd.erae",
+    "size": 205528771
+  },
+  {
+    "name": "mainnet-01206-3de702e6.erae",
+    "size": 212813515
+  },
+  {
+    "name": "mainnet-01207-2d896e26.erae",
+    "size": 206798270
+  },
+  {
+    "name": "mainnet-01208-3613cbcf.erae",
+    "size": 204345236
+  },
+  {
+    "name": "mainnet-01209-e8965670.erae",
+    "size": 205437383
+  },
+  {
+    "name": "mainnet-01210-4578bc97.erae",
+    "size": 213292641
+  },
+  {
+    "name": "mainnet-01211-1f74a5cd.erae",
+    "size": 214236418
+  },
+  {
+    "name": "mainnet-01212-ea69fd90.erae",
+    "size": 217756121
+  },
+  {
+    "name": "mainnet-01213-0cfc0d9e.erae",
+    "size": 202321136
+  },
+  {
+    "name": "mainnet-01214-91442309.erae",
+    "size": 210034524
+  },
+  {
+    "name": "mainnet-01215-3b705b34.erae",
+    "size": 221646684
+  },
+  {
+    "name": "mainnet-01216-d2bf2522.erae",
+    "size": 221512968
+  },
+  {
+    "name": "mainnet-01217-91bd2e38.erae",
+    "size": 225848757
+  },
+  {
+    "name": "mainnet-01218-95ea38a2.erae",
+    "size": 212467034
+  },
+  {
+    "name": "mainnet-01219-6dc7f601.erae",
+    "size": 204673047
+  },
+  {
+    "name": "mainnet-01220-81b5cfb8.erae",
+    "size": 212453278
+  },
+  {
+    "name": "mainnet-01221-0b9046e9.erae",
+    "size": 209856603
+  },
+  {
+    "name": "mainnet-01222-99ec0cc2.erae",
+    "size": 275083698
+  },
+  {
+    "name": "mainnet-01223-ebff6145.erae",
+    "size": 234564808
+  },
+  {
+    "name": "mainnet-01224-4f0b2d64.erae",
+    "size": 221141893
+  },
+  {
+    "name": "mainnet-01225-7a432845.erae",
+    "size": 222371464
+  },
+  {
+    "name": "mainnet-01226-2a34fcff.erae",
+    "size": 225086535
+  },
+  {
+    "name": "mainnet-01227-3e42232b.erae",
+    "size": 215478509
+  },
+  {
+    "name": "mainnet-01228-e31699aa.erae",
+    "size": 209157484
+  },
+  {
+    "name": "mainnet-01229-442d93b0.erae",
+    "size": 230633887
+  },
+  {
+    "name": "mainnet-01230-c44ed0d6.erae",
+    "size": 212489812
+  },
+  {
+    "name": "mainnet-01231-2e828b32.erae",
+    "size": 219328618
+  },
+  {
+    "name": "mainnet-01232-f91726e2.erae",
+    "size": 219406263
+  },
+  {
+    "name": "mainnet-01233-579ac158.erae",
+    "size": 222731061
+  },
+  {
+    "name": "mainnet-01234-80bcad5f.erae",
+    "size": 229694311
+  },
+  {
+    "name": "mainnet-01235-c313df6a.erae",
+    "size": 217830571
+  },
+  {
+    "name": "mainnet-01236-e1f5c6f2.erae",
+    "size": 217430301
+  },
+  {
+    "name": "mainnet-01237-25948a52.erae",
+    "size": 231242350
+  },
+  {
+    "name": "mainnet-01238-52db4389.erae",
+    "size": 219898895
+  },
+  {
+    "name": "mainnet-01239-a4bc6132.erae",
+    "size": 226425864
+  },
+  {
+    "name": "mainnet-01240-22bf2abd.erae",
+    "size": 236150656
+  },
+  {
+    "name": "mainnet-01241-cd831cb6.erae",
+    "size": 224464100
+  },
+  {
+    "name": "mainnet-01242-b0cc8528.erae",
+    "size": 240044951
+  },
+  {
+    "name": "mainnet-01243-9ad36047.erae",
+    "size": 237546761
+  },
+  {
+    "name": "mainnet-01244-7c6246ee.erae",
+    "size": 234394776
+  },
+  {
+    "name": "mainnet-01245-8850049b.erae",
+    "size": 229086481
+  },
+  {
+    "name": "mainnet-01246-3ec26126.erae",
+    "size": 220957718
+  },
+  {
+    "name": "mainnet-01247-2631b8aa.erae",
+    "size": 234630717
+  },
+  {
+    "name": "mainnet-01248-cff633a5.erae",
+    "size": 236737161
+  },
+  {
+    "name": "mainnet-01249-37d70c17.erae",
+    "size": 232301870
+  },
+  {
+    "name": "mainnet-01250-55dca9f4.erae",
+    "size": 228936793
+  },
+  {
+    "name": "mainnet-01251-1a3de4de.erae",
+    "size": 225053086
+  },
+  {
+    "name": "mainnet-01252-29a0758e.erae",
+    "size": 210226906
+  },
+  {
+    "name": "mainnet-01253-e375e3f9.erae",
+    "size": 221909238
+  },
+  {
+    "name": "mainnet-01254-113838cd.erae",
+    "size": 227568847
+  },
+  {
+    "name": "mainnet-01255-708bc1f6.erae",
+    "size": 231251155
+  },
+  {
+    "name": "mainnet-01256-6ab642a0.erae",
+    "size": 239466062
+  },
+  {
+    "name": "mainnet-01257-2e76c8dc.erae",
+    "size": 243403375
+  },
+  {
+    "name": "mainnet-01258-e0f0b40b.erae",
+    "size": 255593931
+  },
+  {
+    "name": "mainnet-01259-b01e9767.erae",
+    "size": 279766294
+  },
+  {
+    "name": "mainnet-01260-313bc794.erae",
+    "size": 275710500
+  },
+  {
+    "name": "mainnet-01261-8eb2d5cf.erae",
+    "size": 264333402
+  },
+  {
+    "name": "mainnet-01262-ab159589.erae",
+    "size": 264837587
+  },
+  {
+    "name": "mainnet-01263-595ffd28.erae",
+    "size": 261985303
+  },
+  {
+    "name": "mainnet-01264-8daca416.erae",
+    "size": 258798472
+  },
+  {
+    "name": "mainnet-01265-e46210d8.erae",
+    "size": 259112247
+  },
+  {
+    "name": "mainnet-01266-c47414b1.erae",
+    "size": 273437416
+  },
+  {
+    "name": "mainnet-01267-d8f7a1e8.erae",
+    "size": 273209831
+  },
+  {
+    "name": "mainnet-01268-70cfa5a2.erae",
+    "size": 251332842
+  },
+  {
+    "name": "mainnet-01269-c8b9da9e.erae",
+    "size": 240749928
+  },
+  {
+    "name": "mainnet-01270-84117437.erae",
+    "size": 277621459
+  },
+  {
+    "name": "mainnet-01271-e0514e73.erae",
+    "size": 273612788
+  },
+  {
+    "name": "mainnet-01272-9b7cac65.erae",
+    "size": 275754278
+  },
+  {
+    "name": "mainnet-01273-f1a1c4b7.erae",
+    "size": 266428362
+  },
+  {
+    "name": "mainnet-01274-2cc2b13b.erae",
+    "size": 259655775
+  },
+  {
+    "name": "mainnet-01275-f707f697.erae",
+    "size": 279400146
+  },
+  {
+    "name": "mainnet-01276-b2ff9b34.erae",
+    "size": 279162683
+  },
+  {
+    "name": "mainnet-01277-291372ea.erae",
+    "size": 283588517
+  },
+  {
+    "name": "mainnet-01278-87cde713.erae",
+    "size": 279880924
+  },
+  {
+    "name": "mainnet-01279-adf1765a.erae",
+    "size": 276735219
+  },
+  {
+    "name": "mainnet-01280-5278d9ba.erae",
+    "size": 282420312
+  },
+  {
+    "name": "mainnet-01281-db4ef908.erae",
+    "size": 293520769
+  },
+  {
+    "name": "mainnet-01282-80f0ef8a.erae",
+    "size": 293890459
+  },
+  {
+    "name": "mainnet-01283-89ca854e.erae",
+    "size": 288534158
+  },
+  {
+    "name": "mainnet-01284-ccd31cdd.erae",
+    "size": 292923378
+  },
+  {
+    "name": "mainnet-01285-b935d046.erae",
+    "size": 303008783
+  },
+  {
+    "name": "mainnet-01286-1dc02855.erae",
+    "size": 307693568
+  },
+  {
+    "name": "mainnet-01287-84be4846.erae",
+    "size": 305251074
+  },
+  {
+    "name": "mainnet-01288-bc3576fc.erae",
+    "size": 299734115
+  },
+  {
+    "name": "mainnet-01289-9a31c09e.erae",
+    "size": 309967460
+  },
+  {
+    "name": "mainnet-01290-6de93e74.erae",
+    "size": 305247073
+  },
+  {
+    "name": "mainnet-01291-a1f83ba0.erae",
+    "size": 291604383
+  },
+  {
+    "name": "mainnet-01292-2d6f4728.erae",
+    "size": 308020962
+  },
+  {
+    "name": "mainnet-01293-f48f42ed.erae",
+    "size": 304489707
+  },
+  {
+    "name": "mainnet-01294-8b7aabab.erae",
+    "size": 300677410
+  },
+  {
+    "name": "mainnet-01295-2cab24d8.erae",
+    "size": 308986937
+  },
+  {
+    "name": "mainnet-01296-0c5a9fc3.erae",
+    "size": 308247639
+  },
+  {
+    "name": "mainnet-01297-bab000ee.erae",
+    "size": 322975518
+  },
+  {
+    "name": "mainnet-01298-a6ae5ab8.erae",
+    "size": 318098502
+  },
+  {
+    "name": "mainnet-01299-48e3edbb.erae",
+    "size": 309043646
+  },
+  {
+    "name": "mainnet-01300-40ef44e3.erae",
+    "size": 311163215
+  },
+  {
+    "name": "mainnet-01301-4bd0be51.erae",
+    "size": 301685329
+  },
+  {
+    "name": "mainnet-01302-daef9679.erae",
+    "size": 290253829
+  },
+  {
+    "name": "mainnet-01303-85f8e0e6.erae",
+    "size": 314757336
+  },
+  {
+    "name": "mainnet-01304-410674a7.erae",
+    "size": 316636826
+  },
+  {
+    "name": "mainnet-01305-d69f391b.erae",
+    "size": 310199058
+  },
+  {
+    "name": "mainnet-01306-13c3ff40.erae",
+    "size": 319430084
+  },
+  {
+    "name": "mainnet-01307-bdec9f70.erae",
+    "size": 297784052
+  },
+  {
+    "name": "mainnet-01308-d1886bce.erae",
+    "size": 304150950
+  },
+  {
+    "name": "mainnet-01309-1c550b38.erae",
+    "size": 309980175
+  },
+  {
+    "name": "mainnet-01310-8bf14ca2.erae",
+    "size": 299375264
+  },
+  {
+    "name": "mainnet-01311-8874a13a.erae",
+    "size": 301294663
+  },
+  {
+    "name": "mainnet-01312-5aa437a9.erae",
+    "size": 305043970
+  },
+  {
+    "name": "mainnet-01313-9803e52c.erae",
+    "size": 313156941
+  },
+  {
+    "name": "mainnet-01314-3b5717ba.erae",
+    "size": 322243941
+  },
+  {
+    "name": "mainnet-01315-e665fcb6.erae",
+    "size": 329141387
+  },
+  {
+    "name": "mainnet-01316-58f98642.erae",
+    "size": 324304155
+  },
+  {
+    "name": "mainnet-01317-b9b261d1.erae",
+    "size": 316382884
+  },
+  {
+    "name": "mainnet-01318-68d02286.erae",
+    "size": 293907027
+  },
+  {
+    "name": "mainnet-01319-96bb6d28.erae",
+    "size": 295730813
+  },
+  {
+    "name": "mainnet-01320-b9593627.erae",
+    "size": 294899782
+  },
+  {
+    "name": "mainnet-01321-c02d993a.erae",
+    "size": 296069873
+  },
+  {
+    "name": "mainnet-01322-b28b5c27.erae",
+    "size": 309959592
+  },
+  {
+    "name": "mainnet-01323-076f7acf.erae",
+    "size": 303947631
+  },
+  {
+    "name": "mainnet-01324-ba1ffb48.erae",
+    "size": 303650057
+  },
+  {
+    "name": "mainnet-01325-50c11360.erae",
+    "size": 310291973
+  },
+  {
+    "name": "mainnet-01326-20ffce85.erae",
+    "size": 313823490
+  },
+  {
+    "name": "mainnet-01327-72072f19.erae",
+    "size": 354819824
+  },
+  {
+    "name": "mainnet-01328-d41a8f13.erae",
+    "size": 391486311
+  },
+  {
+    "name": "mainnet-01329-474d5def.erae",
+    "size": 329534105
+  },
+  {
+    "name": "mainnet-01330-c08829fd.erae",
+    "size": 313335034
+  },
+  {
+    "name": "mainnet-01331-085dd9d3.erae",
+    "size": 323531211
+  },
+  {
+    "name": "mainnet-01332-9af02dbd.erae",
+    "size": 322521973
+  },
+  {
+    "name": "mainnet-01333-ef41a0f7.erae",
+    "size": 309110428
+  },
+  {
+    "name": "mainnet-01334-28a6e85e.erae",
+    "size": 302703800
+  },
+  {
+    "name": "mainnet-01335-b80784cb.erae",
+    "size": 301837748
+  },
+  {
+    "name": "mainnet-01336-2d596fe0.erae",
+    "size": 302103253
+  },
+  {
+    "name": "mainnet-01337-213f4ef5.erae",
+    "size": 311971563
+  },
+  {
+    "name": "mainnet-01338-b76180ca.erae",
+    "size": 314084495
+  },
+  {
+    "name": "mainnet-01339-cc0de83c.erae",
+    "size": 306133228
+  },
+  {
+    "name": "mainnet-01340-e29c7184.erae",
+    "size": 290706845
+  },
+  {
+    "name": "mainnet-01341-9757dc64.erae",
+    "size": 295983520
+  },
+  {
+    "name": "mainnet-01342-248b04d6.erae",
+    "size": 316467340
+  },
+  {
+    "name": "mainnet-01343-f779e456.erae",
+    "size": 317461198
+  },
+  {
+    "name": "mainnet-01344-24c4ab50.erae",
+    "size": 299828789
+  },
+  {
+    "name": "mainnet-01345-841fed33.erae",
+    "size": 305543395
+  },
+  {
+    "name": "mainnet-01346-0793134d.erae",
+    "size": 292816898
+  },
+  {
+    "name": "mainnet-01347-d42b7890.erae",
+    "size": 302680662
+  },
+  {
+    "name": "mainnet-01348-efc3dbba.erae",
+    "size": 308204457
+  },
+  {
+    "name": "mainnet-01349-7cfd4050.erae",
+    "size": 309048863
+  },
+  {
+    "name": "mainnet-01350-c9e62828.erae",
+    "size": 320556596
+  },
+  {
+    "name": "mainnet-01351-8be23865.erae",
+    "size": 294639167
+  },
+  {
+    "name": "mainnet-01352-e732a74b.erae",
+    "size": 284438748
+  },
+  {
+    "name": "mainnet-01353-e7681806.erae",
+    "size": 315813224
+  },
+  {
+    "name": "mainnet-01354-9820f04e.erae",
+    "size": 321355658
+  },
+  {
+    "name": "mainnet-01355-d394db84.erae",
+    "size": 324236435
+  },
+  {
+    "name": "mainnet-01356-2b5b7b82.erae",
+    "size": 305470486
+  },
+  {
+    "name": "mainnet-01357-1e1780ae.erae",
+    "size": 286097529
+  },
+  {
+    "name": "mainnet-01358-fd1f78c5.erae",
+    "size": 299948161
+  },
+  {
+    "name": "mainnet-01359-8423d0e6.erae",
+    "size": 310282112
+  },
+  {
+    "name": "mainnet-01360-9589aa7a.erae",
+    "size": 315979520
+  },
+  {
+    "name": "mainnet-01361-d3eb129d.erae",
+    "size": 318810302
+  },
+  {
+    "name": "mainnet-01362-4cae0aa0.erae",
+    "size": 313102012
+  },
+  {
+    "name": "mainnet-01363-f9b5d785.erae",
+    "size": 302687147
+  },
+  {
+    "name": "mainnet-01364-93f0457c.erae",
+    "size": 319119142
+  },
+  {
+    "name": "mainnet-01365-83514cc8.erae",
+    "size": 315771751
+  },
+  {
+    "name": "mainnet-01366-5ec3b899.erae",
+    "size": 315491045
+  },
+  {
+    "name": "mainnet-01367-fa634aec.erae",
+    "size": 317706388
+  },
+  {
+    "name": "mainnet-01368-b8a2477a.erae",
+    "size": 307793233
+  },
+  {
+    "name": "mainnet-01369-37f46346.erae",
+    "size": 304367215
+  },
+  {
+    "name": "mainnet-01370-33652482.erae",
+    "size": 323363021
+  },
+  {
+    "name": "mainnet-01371-7c86c8d6.erae",
+    "size": 300582699
+  },
+  {
+    "name": "mainnet-01372-91f6f043.erae",
+    "size": 307017310
+  },
+  {
+    "name": "mainnet-01373-4cbc57c4.erae",
+    "size": 313302409
+  },
+  {
+    "name": "mainnet-01374-ce93a6db.erae",
+    "size": 297531622
+  },
+  {
+    "name": "mainnet-01375-9a1cbaf3.erae",
+    "size": 306891380
+  },
+  {
+    "name": "mainnet-01376-02b50a23.erae",
+    "size": 324711339
+  },
+  {
+    "name": "mainnet-01377-c40f0b73.erae",
+    "size": 310616394
+  },
+  {
+    "name": "mainnet-01378-1780e017.erae",
+    "size": 324359470
+  },
+  {
+    "name": "mainnet-01379-ef2068fe.erae",
+    "size": 319798188
+  },
+  {
+    "name": "mainnet-01380-a355e0a2.erae",
+    "size": 321568720
+  },
+  {
+    "name": "mainnet-01381-dd5f203f.erae",
+    "size": 345864996
+  },
+  {
+    "name": "mainnet-01382-d13903d4.erae",
+    "size": 329618979
+  },
+  {
+    "name": "mainnet-01383-5453bab8.erae",
+    "size": 319678378
+  },
+  {
+    "name": "mainnet-01384-2922be9e.erae",
+    "size": 297790139
+  },
+  {
+    "name": "mainnet-01385-9d5a5601.erae",
+    "size": 276164716
+  },
+  {
+    "name": "mainnet-01386-1945bc7e.erae",
+    "size": 313447480
+  },
+  {
+    "name": "mainnet-01387-98a279ba.erae",
+    "size": 320999793
+  },
+  {
+    "name": "mainnet-01388-b95a7a69.erae",
+    "size": 316094501
+  },
+  {
+    "name": "mainnet-01389-cecf96f3.erae",
+    "size": 333615424
+  },
+  {
+    "name": "mainnet-01390-315a71a4.erae",
+    "size": 308049680
+  },
+  {
+    "name": "mainnet-01391-62ab80c7.erae",
+    "size": 305011069
+  },
+  {
+    "name": "mainnet-01392-3090200c.erae",
+    "size": 328160678
+  },
+  {
+    "name": "mainnet-01393-1b216a19.erae",
+    "size": 331474591
+  },
+  {
+    "name": "mainnet-01394-68a9244b.erae",
+    "size": 318212617
+  },
+  {
+    "name": "mainnet-01395-8e44a1ae.erae",
+    "size": 323367623
+  },
+  {
+    "name": "mainnet-01396-57e434e8.erae",
+    "size": 300708828
+  },
+  {
+    "name": "mainnet-01397-caa23e60.erae",
+    "size": 327362502
+  },
+  {
+    "name": "mainnet-01398-775c3e29.erae",
+    "size": 325280490
+  },
+  {
+    "name": "mainnet-01399-5bbc83f3.erae",
+    "size": 337575299
+  },
+  {
+    "name": "mainnet-01400-3a647a57.erae",
+    "size": 338053322
+  },
+  {
+    "name": "mainnet-01401-71c00c7d.erae",
+    "size": 327689824
+  },
+  {
+    "name": "mainnet-01402-f0b86311.erae",
+    "size": 313407530
+  },
+  {
+    "name": "mainnet-01403-1e690039.erae",
+    "size": 331851138
+  },
+  {
+    "name": "mainnet-01404-12045ec7.erae",
+    "size": 355936837
+  },
+  {
+    "name": "mainnet-01405-6126700c.erae",
+    "size": 355038735
+  },
+  {
+    "name": "mainnet-01406-b255b961.erae",
+    "size": 343356528
+  },
+  {
+    "name": "mainnet-01407-a57c6e9c.erae",
+    "size": 334899387
+  },
+  {
+    "name": "mainnet-01408-dfae885b.erae",
+    "size": 344530183
+  },
+  {
+    "name": "mainnet-01409-83727bee.erae",
+    "size": 345272431
+  },
+  {
+    "name": "mainnet-01410-af1a4061.erae",
+    "size": 333158067
+  },
+  {
+    "name": "mainnet-01411-4bf92eae.erae",
+    "size": 328129131
+  },
+  {
+    "name": "mainnet-01412-bf10718d.erae",
+    "size": 324023238
+  },
+  {
+    "name": "mainnet-01413-c077670d.erae",
+    "size": 339745794
+  },
+  {
+    "name": "mainnet-01414-28e36db0.erae",
+    "size": 335086992
+  },
+  {
+    "name": "mainnet-01415-7c37d5a7.erae",
+    "size": 342420969
+  },
+  {
+    "name": "mainnet-01416-263fdfb0.erae",
+    "size": 348905598
+  },
+  {
+    "name": "mainnet-01417-6526cfe0.erae",
+    "size": 342741001
+  },
+  {
+    "name": "mainnet-01418-c6a6b6ca.erae",
+    "size": 334920065
+  },
+  {
+    "name": "mainnet-01419-aec2b2b5.erae",
+    "size": 335308131
+  },
+  {
+    "name": "mainnet-01420-c5a1c750.erae",
+    "size": 334025801
+  },
+  {
+    "name": "mainnet-01421-bbddcce2.erae",
+    "size": 319507437
+  },
+  {
+    "name": "mainnet-01422-30ac883a.erae",
+    "size": 333014599
+  },
+  {
+    "name": "mainnet-01423-50b03246.erae",
+    "size": 330320223
+  },
+  {
+    "name": "mainnet-01424-a7ec0b2b.erae",
+    "size": 330705221
+  },
+  {
+    "name": "mainnet-01425-09462a81.erae",
+    "size": 338839177
+  },
+  {
+    "name": "mainnet-01426-d21f9bdd.erae",
+    "size": 343988218
+  },
+  {
+    "name": "mainnet-01427-ae6650b5.erae",
+    "size": 336517953
+  },
+  {
+    "name": "mainnet-01428-c5f7e7d5.erae",
+    "size": 330628319
+  },
+  {
+    "name": "mainnet-01429-2bababd1.erae",
+    "size": 323538288
+  },
+  {
+    "name": "mainnet-01430-8d2d718a.erae",
+    "size": 328786195
+  },
+  {
+    "name": "mainnet-01431-b8b63b67.erae",
+    "size": 339402068
+  },
+  {
+    "name": "mainnet-01432-22201323.erae",
+    "size": 334853245
+  },
+  {
+    "name": "mainnet-01433-08e383be.erae",
+    "size": 343080031
+  },
+  {
+    "name": "mainnet-01434-24ab808a.erae",
+    "size": 347368600
+  },
+  {
+    "name": "mainnet-01435-c30f5c5f.erae",
+    "size": 341940933
+  },
+  {
+    "name": "mainnet-01436-e00d60ba.erae",
+    "size": 346719872
+  },
+  {
+    "name": "mainnet-01437-3463b6b5.erae",
+    "size": 349968682
+  },
+  {
+    "name": "mainnet-01438-1d0f49ca.erae",
+    "size": 350365125
+  },
+  {
+    "name": "mainnet-01439-d70d06f8.erae",
+    "size": 348418809
+  },
+  {
+    "name": "mainnet-01440-b91f298b.erae",
+    "size": 340391051
+  },
+  {
+    "name": "mainnet-01441-4b3a39e5.erae",
+    "size": 331823882
+  },
+  {
+    "name": "mainnet-01442-ade7465f.erae",
+    "size": 344435621
+  },
+  {
+    "name": "mainnet-01443-515810d1.erae",
+    "size": 346613553
+  },
+  {
+    "name": "mainnet-01444-817d3acf.erae",
+    "size": 344464651
+  },
+  {
+    "name": "mainnet-01445-ff83c680.erae",
+    "size": 354119027
+  },
+  {
+    "name": "mainnet-01446-da5b4dec.erae",
+    "size": 347878046
+  },
+  {
+    "name": "mainnet-01447-effd3a6c.erae",
+    "size": 340349482
+  },
+  {
+    "name": "mainnet-01448-28bef738.erae",
+    "size": 342921940
+  },
+  {
+    "name": "mainnet-01449-db09cb44.erae",
+    "size": 346278405
+  },
+  {
+    "name": "mainnet-01450-3156af61.erae",
+    "size": 355582458
+  },
+  {
+    "name": "mainnet-01451-ef5284f9.erae",
+    "size": 353594144
+  },
+  {
+    "name": "mainnet-01452-ee117d55.erae",
+    "size": 342356610
+  },
+  {
+    "name": "mainnet-01453-d761f056.erae",
+    "size": 348974839
+  },
+  {
+    "name": "mainnet-01454-844a1768.erae",
+    "size": 346034066
+  },
+  {
+    "name": "mainnet-01455-86672855.erae",
+    "size": 338594161
+  },
+  {
+    "name": "mainnet-01456-05ccda4c.erae",
+    "size": 336902098
+  },
+  {
+    "name": "mainnet-01457-49c7db15.erae",
+    "size": 335352988
+  },
+  {
+    "name": "mainnet-01458-9cb40690.erae",
+    "size": 335037938
+  },
+  {
+    "name": "mainnet-01459-3fd20ff2.erae",
+    "size": 338861542
+  },
+  {
+    "name": "mainnet-01460-571ddd19.erae",
+    "size": 345162951
+  },
+  {
+    "name": "mainnet-01461-b27aa1e9.erae",
+    "size": 346258659
+  },
+  {
+    "name": "mainnet-01462-226b78ad.erae",
+    "size": 336275551
+  },
+  {
+    "name": "mainnet-01463-8f7bf08c.erae",
+    "size": 339929093
+  },
+  {
+    "name": "mainnet-01464-064ab035.erae",
+    "size": 341098939
+  },
+  {
+    "name": "mainnet-01465-cce51263.erae",
+    "size": 354232986
+  },
+  {
+    "name": "mainnet-01466-af4f1714.erae",
+    "size": 350157550
+  },
+  {
+    "name": "mainnet-01467-734f7d6f.erae",
+    "size": 356962387
+  },
+  {
+    "name": "mainnet-01468-46697856.erae",
+    "size": 350575966
+  },
+  {
+    "name": "mainnet-01469-dad33525.erae",
+    "size": 353958958
+  },
+  {
+    "name": "mainnet-01470-3f224bf4.erae",
+    "size": 357117443
+  },
+  {
+    "name": "mainnet-01471-16cd8faf.erae",
+    "size": 346166728
+  },
+  {
+    "name": "mainnet-01472-f20e8ccb.erae",
+    "size": 348544211
+  },
+  {
+    "name": "mainnet-01473-8d1c1c40.erae",
+    "size": 350454645
+  },
+  {
+    "name": "mainnet-01474-5bc19676.erae",
+    "size": 338318462
+  },
+  {
+    "name": "mainnet-01475-7a1d4641.erae",
+    "size": 352233544
+  },
+  {
+    "name": "mainnet-01476-5050e9f9.erae",
+    "size": 353954845
+  },
+  {
+    "name": "mainnet-01477-e5a9be36.erae",
+    "size": 357849442
+  },
+  {
+    "name": "mainnet-01478-ca2af0e3.erae",
+    "size": 348856235
+  },
+  {
+    "name": "mainnet-01479-246ebcd7.erae",
+    "size": 339250745
+  },
+  {
+    "name": "mainnet-01480-7f01ce05.erae",
+    "size": 336805338
+  },
+  {
+    "name": "mainnet-01481-1f358668.erae",
+    "size": 357256603
+  },
+  {
+    "name": "mainnet-01482-af72748b.erae",
+    "size": 361774645
+  },
+  {
+    "name": "mainnet-01483-1c5e3aa7.erae",
+    "size": 365256788
+  },
+  {
+    "name": "mainnet-01484-74cb15f2.erae",
+    "size": 361516403
+  },
+  {
+    "name": "mainnet-01485-f0f5b04b.erae",
+    "size": 345438608
+  },
+  {
+    "name": "mainnet-01486-d0ee080d.erae",
+    "size": 349621124
+  },
+  {
+    "name": "mainnet-01487-50fd3cec.erae",
+    "size": 362561831
+  },
+  {
+    "name": "mainnet-01488-285dbb59.erae",
+    "size": 357371845
+  },
+  {
+    "name": "mainnet-01489-a8babebc.erae",
+    "size": 358186573
+  },
+  {
+    "name": "mainnet-01490-8d709ea3.erae",
+    "size": 357988485
+  },
+  {
+    "name": "mainnet-01491-c00783ff.erae",
+    "size": 340127491
+  },
+  {
+    "name": "mainnet-01492-9af1889c.erae",
+    "size": 359445754
+  },
+  {
+    "name": "mainnet-01493-6fc284a2.erae",
+    "size": 372404225
+  },
+  {
+    "name": "mainnet-01494-b9da1123.erae",
+    "size": 353990794
+  },
+  {
+    "name": "mainnet-01495-d6707d12.erae",
+    "size": 366901420
+  },
+  {
+    "name": "mainnet-01496-ab7faf2b.erae",
+    "size": 378737402
+  },
+  {
+    "name": "mainnet-01497-d581183d.erae",
+    "size": 373718496
+  },
+  {
+    "name": "mainnet-01498-b3c77a89.erae",
+    "size": 380996898
+  },
+  {
+    "name": "mainnet-01499-5b07320f.erae",
+    "size": 413311617
+  },
+  {
+    "name": "mainnet-01500-8f81d882.erae",
+    "size": 441433122
+  },
+  {
+    "name": "mainnet-01501-45f699a9.erae",
+    "size": 398080346
+  },
+  {
+    "name": "mainnet-01502-d9b53f85.erae",
+    "size": 381111794
+  },
+  {
+    "name": "mainnet-01503-9918d10b.erae",
+    "size": 407187881
+  },
+  {
+    "name": "mainnet-01504-20c808c7.erae",
+    "size": 415283172
+  },
+  {
+    "name": "mainnet-01505-68f671ba.erae",
+    "size": 427652795
+  },
+  {
+    "name": "mainnet-01506-b395d002.erae",
+    "size": 414583561
+  },
+  {
+    "name": "mainnet-01507-a7fc5637.erae",
+    "size": 403822873
+  },
+  {
+    "name": "mainnet-01508-541b40a2.erae",
+    "size": 417399564
+  },
+  {
+    "name": "mainnet-01509-0c47583a.erae",
+    "size": 429177129
+  },
+  {
+    "name": "mainnet-01510-84a37bf4.erae",
+    "size": 420979631
+  },
+  {
+    "name": "mainnet-01511-01dc059b.erae",
+    "size": 424281081
+  },
+  {
+    "name": "mainnet-01512-262b88be.erae",
+    "size": 427490592
+  },
+  {
+    "name": "mainnet-01513-88e44722.erae",
+    "size": 435507780
+  },
+  {
+    "name": "mainnet-01514-878434a3.erae",
+    "size": 429378687
+  },
+  {
+    "name": "mainnet-01515-ea986ffb.erae",
+    "size": 425242366
+  },
+  {
+    "name": "mainnet-01516-cff608ff.erae",
+    "size": 427289551
+  },
+  {
+    "name": "mainnet-01517-e6596cb4.erae",
+    "size": 411505027
+  },
+  {
+    "name": "mainnet-01518-45be43b6.erae",
+    "size": 407928321
+  },
+  {
+    "name": "mainnet-01519-92f80a7b.erae",
+    "size": 416855016
+  },
+  {
+    "name": "mainnet-01520-1fb228d2.erae",
+    "size": 417026155
+  },
+  {
+    "name": "mainnet-01521-5f5b5ab8.erae",
+    "size": 439475863
+  },
+  {
+    "name": "mainnet-01522-4f0cb9a9.erae",
+    "size": 422921880
+  },
+  {
+    "name": "mainnet-01523-cfab90f6.erae",
+    "size": 412167700
+  },
+  {
+    "name": "mainnet-01524-bb128d29.erae",
+    "size": 391940336
+  },
+  {
+    "name": "mainnet-01525-ab7590c3.erae",
+    "size": 406718350
+  },
+  {
+    "name": "mainnet-01526-359b0581.erae",
+    "size": 409046483
+  },
+  {
+    "name": "mainnet-01527-7a612982.erae",
+    "size": 396909009
+  },
+  {
+    "name": "mainnet-01528-96aad7bc.erae",
+    "size": 403187441
+  },
+  {
+    "name": "mainnet-01529-a4d0dff2.erae",
+    "size": 385194783
+  },
+  {
+    "name": "mainnet-01530-81b25b29.erae",
+    "size": 376600470
+  },
+  {
+    "name": "mainnet-01531-d54a7352.erae",
+    "size": 387794604
+  },
+  {
+    "name": "mainnet-01532-5c464982.erae",
+    "size": 382092836
+  },
+  {
+    "name": "mainnet-01533-ec72b2b6.erae",
+    "size": 398222704
+  },
+  {
+    "name": "mainnet-01534-4802c7a1.erae",
+    "size": 374905712
+  },
+  {
+    "name": "mainnet-01535-f6d298bc.erae",
+    "size": 344920959
+  },
+  {
+    "name": "mainnet-01536-5ff7773b.erae",
+    "size": 377031557
+  },
+  {
+    "name": "mainnet-01537-dc35cc9b.erae",
+    "size": 384157665
+  },
+  {
+    "name": "mainnet-01538-7692a0eb.erae",
+    "size": 384220118
+  },
+  {
+    "name": "mainnet-01539-b583a0ea.erae",
+    "size": 377723723
+  },
+  {
+    "name": "mainnet-01540-e3f03d7d.erae",
+    "size": 361284231
+  },
+  {
+    "name": "mainnet-01541-3a69a76c.erae",
+    "size": 357810135
+  },
+  {
+    "name": "mainnet-01542-46c68ebd.erae",
+    "size": 382523938
+  },
+  {
+    "name": "mainnet-01543-927df556.erae",
+    "size": 389661871
+  },
+  {
+    "name": "mainnet-01544-e100bacf.erae",
+    "size": 384798474
+  },
+  {
+    "name": "mainnet-01545-224faca2.erae",
+    "size": 372247607
+  },
+  {
+    "name": "mainnet-01546-aba72bd6.erae",
+    "size": 351193399
+  },
+  {
+    "name": "mainnet-01547-18385373.erae",
+    "size": 388359396
+  },
+  {
+    "name": "mainnet-01548-84615154.erae",
+    "size": 407372838
+  },
+  {
+    "name": "mainnet-01549-b12d9bab.erae",
+    "size": 383616701
+  },
+  {
+    "name": "mainnet-01550-fd018b26.erae",
+    "size": 382882470
+  },
+  {
+    "name": "mainnet-01551-2ecb8523.erae",
+    "size": 359017969
+  },
+  {
+    "name": "mainnet-01552-f0367676.erae",
+    "size": 372880698
+  },
+  {
+    "name": "mainnet-01553-a1c3bf59.erae",
+    "size": 401262988
+  },
+  {
+    "name": "mainnet-01554-36e9851d.erae",
+    "size": 380598804
+  },
+  {
+    "name": "mainnet-01555-07fee1ec.erae",
+    "size": 382608046
+  },
+  {
+    "name": "mainnet-01556-090bd4c2.erae",
+    "size": 368482547
+  },
+  {
+    "name": "mainnet-01557-63cb861d.erae",
+    "size": 362666192
+  },
+  {
+    "name": "mainnet-01558-088d355e.erae",
+    "size": 365164327
+  },
+  {
+    "name": "mainnet-01559-8f96e510.erae",
+    "size": 395876302
+  },
+  {
+    "name": "mainnet-01560-1d1bd171.erae",
+    "size": 389676157
+  },
+  {
+    "name": "mainnet-01561-0144934c.erae",
+    "size": 378681881
+  },
+  {
+    "name": "mainnet-01562-6f507e3e.erae",
+    "size": 366612754
+  },
+  {
+    "name": "mainnet-01563-705979f5.erae",
+    "size": 365070281
+  },
+  {
+    "name": "mainnet-01564-3d8a87ed.erae",
+    "size": 377510588
+  },
+  {
+    "name": "mainnet-01565-556d2417.erae",
+    "size": 386829177
+  },
+  {
+    "name": "mainnet-01566-48e142af.erae",
+    "size": 400660080
+  },
+  {
+    "name": "mainnet-01567-92bc3c3b.erae",
+    "size": 379598763
+  },
+  {
+    "name": "mainnet-01568-68500d9f.erae",
+    "size": 379258901
+  },
+  {
+    "name": "mainnet-01569-bcdaecc3.erae",
+    "size": 389513888
+  },
+  {
+    "name": "mainnet-01570-beba9de7.erae",
+    "size": 392558924
+  },
+  {
+    "name": "mainnet-01571-2324f846.erae",
+    "size": 396438214
+  },
+  {
+    "name": "mainnet-01572-9ff80e98.erae",
+    "size": 386590856
+  },
+  {
+    "name": "mainnet-01573-e7bea710.erae",
+    "size": 391018828
+  },
+  {
+    "name": "mainnet-01574-5ec7a4d0.erae",
+    "size": 398291715
+  },
+  {
+    "name": "mainnet-01575-303e8240.erae",
+    "size": 406490107
+  },
+  {
+    "name": "mainnet-01576-ef8a6b19.erae",
+    "size": 401152675
+  },
+  {
+    "name": "mainnet-01577-2cd649bf.erae",
+    "size": 403662518
+  },
+  {
+    "name": "mainnet-01578-f9200a7c.erae",
+    "size": 389416647
+  },
+  {
+    "name": "mainnet-01579-9174b51a.erae",
+    "size": 399170038
+  },
+  {
+    "name": "mainnet-01580-b43757c8.erae",
+    "size": 398329153
+  },
+  {
+    "name": "mainnet-01581-6064fbc8.erae",
+    "size": 398101232
+  },
+  {
+    "name": "mainnet-01582-38d4d248.erae",
+    "size": 397492482
+  },
+  {
+    "name": "mainnet-01583-bfca95b8.erae",
+    "size": 403555897
+  },
+  {
+    "name": "mainnet-01584-3b583e58.erae",
+    "size": 401337746
+  },
+  {
+    "name": "mainnet-01585-bc7b18d1.erae",
+    "size": 405774397
+  },
+  {
+    "name": "mainnet-01586-06a57f40.erae",
+    "size": 403332805
+  },
+  {
+    "name": "mainnet-01587-cb145da3.erae",
+    "size": 413304059
+  },
+  {
+    "name": "mainnet-01588-6d12fdb7.erae",
+    "size": 408535566
+  },
+  {
+    "name": "mainnet-01589-aa5c4178.erae",
+    "size": 401067628
+  },
+  {
+    "name": "mainnet-01590-0bd9d85a.erae",
+    "size": 381696944
+  },
+  {
+    "name": "mainnet-01591-96076dd5.erae",
+    "size": 418981200
+  },
+  {
+    "name": "mainnet-01592-a64ea871.erae",
+    "size": 415526568
+  },
+  {
+    "name": "mainnet-01593-e1bd7824.erae",
+    "size": 412974485
+  },
+  {
+    "name": "mainnet-01594-f0b0fdda.erae",
+    "size": 415256571
+  },
+  {
+    "name": "mainnet-01595-b3029169.erae",
+    "size": 411488545
+  },
+  {
+    "name": "mainnet-01596-63abf3f3.erae",
+    "size": 429695933
+  },
+  {
+    "name": "mainnet-01597-f8fcc2cd.erae",
+    "size": 425123935
+  },
+  {
+    "name": "mainnet-01598-9961df65.erae",
+    "size": 415421106
+  },
+  {
+    "name": "mainnet-01599-c65cda84.erae",
+    "size": 414247156
+  },
+  {
+    "name": "mainnet-01600-bef5c4b2.erae",
+    "size": 389110247
+  },
+  {
+    "name": "mainnet-01601-9efa4f8b.erae",
+    "size": 393939789
+  },
+  {
+    "name": "mainnet-01602-39c991bb.erae",
+    "size": 411962588
+  },
+  {
+    "name": "mainnet-01603-b84921b5.erae",
+    "size": 418732931
+  },
+  {
+    "name": "mainnet-01604-a17bfd03.erae",
+    "size": 396116924
+  },
+  {
+    "name": "mainnet-01605-514e2182.erae",
+    "size": 374384788
+  },
+  {
+    "name": "mainnet-01606-d9b492e7.erae",
+    "size": 370453881
+  },
+  {
+    "name": "mainnet-01607-71c2f381.erae",
+    "size": 379161433
+  },
+  {
+    "name": "mainnet-01608-98c103d3.erae",
+    "size": 416145205
+  },
+  {
+    "name": "mainnet-01609-0f8347e1.erae",
+    "size": 395639409
+  },
+  {
+    "name": "mainnet-01610-2a0f5993.erae",
+    "size": 411799043
+  },
+  {
+    "name": "mainnet-01611-d083a9f9.erae",
+    "size": 435133663
+  },
+  {
+    "name": "mainnet-01612-d41d4628.erae",
+    "size": 445183662
+  },
+  {
+    "name": "mainnet-01613-68e49ea6.erae",
+    "size": 427668571
+  },
+  {
+    "name": "mainnet-01614-2eb77698.erae",
+    "size": 435147308
+  },
+  {
+    "name": "mainnet-01615-464bcba7.erae",
+    "size": 445082787
+  },
+  {
+    "name": "mainnet-01616-f43abaf8.erae",
+    "size": 421218028
+  },
+  {
+    "name": "mainnet-01617-886b1941.erae",
+    "size": 411937672
+  },
+  {
+    "name": "mainnet-01618-1e172129.erae",
+    "size": 433212686
+  },
+  {
+    "name": "mainnet-01619-9a97f717.erae",
+    "size": 423234620
+  },
+  {
+    "name": "mainnet-01620-06132df4.erae",
+    "size": 433672163
+  },
+  {
+    "name": "mainnet-01621-b4d1b0b5.erae",
+    "size": 437504485
+  },
+  {
+    "name": "mainnet-01622-3dec6bd3.erae",
+    "size": 431142181
+  },
+  {
+    "name": "mainnet-01623-11060dc0.erae",
+    "size": 410772825
+  },
+  {
+    "name": "mainnet-01624-50bb6939.erae",
+    "size": 417719806
+  },
+  {
+    "name": "mainnet-01625-e5cbe490.erae",
+    "size": 421777050
+  },
+  {
+    "name": "mainnet-01626-d4c36f9e.erae",
+    "size": 417153436
+  },
+  {
+    "name": "mainnet-01627-a9a2b8a4.erae",
+    "size": 406638526
+  },
+  {
+    "name": "mainnet-01628-6997da10.erae",
+    "size": 415912211
+  },
+  {
+    "name": "mainnet-01629-a6143b45.erae",
+    "size": 422319066
+  },
+  {
+    "name": "mainnet-01630-30e27364.erae",
+    "size": 422869493
+  },
+  {
+    "name": "mainnet-01631-1a72c2e4.erae",
+    "size": 435728222
+  },
+  {
+    "name": "mainnet-01632-ef7beba4.erae",
+    "size": 438071958
+  },
+  {
+    "name": "mainnet-01633-23496081.erae",
+    "size": 416322914
+  },
+  {
+    "name": "mainnet-01634-7e091e05.erae",
+    "size": 409267997
+  },
+  {
+    "name": "mainnet-01635-2fbaef0f.erae",
+    "size": 414171252
+  },
+  {
+    "name": "mainnet-01636-99899853.erae",
+    "size": 423648438
+  },
+  {
+    "name": "mainnet-01637-0cd24f7f.erae",
+    "size": 421755736
+  },
+  {
+    "name": "mainnet-01638-e2f0b095.erae",
+    "size": 425496823
+  },
+  {
+    "name": "mainnet-01639-d50d888e.erae",
+    "size": 395325016
+  },
+  {
+    "name": "mainnet-01640-181524bd.erae",
+    "size": 418036489
+  },
+  {
+    "name": "mainnet-01641-b7c4b57d.erae",
+    "size": 412308562
+  },
+  {
+    "name": "mainnet-01642-660c0633.erae",
+    "size": 426563984
+  },
+  {
+    "name": "mainnet-01643-586a6894.erae",
+    "size": 426675990
+  },
+  {
+    "name": "mainnet-01644-a5d6bfe9.erae",
+    "size": 421937696
+  },
+  {
+    "name": "mainnet-01645-f245c6d5.erae",
+    "size": 421345296
+  },
+  {
+    "name": "mainnet-01646-bc62ab85.erae",
+    "size": 430344460
+  },
+  {
+    "name": "mainnet-01647-1093e262.erae",
+    "size": 441650796
+  },
+  {
+    "name": "mainnet-01648-9c68fbb6.erae",
+    "size": 446214564
+  },
+  {
+    "name": "mainnet-01649-2a498d36.erae",
+    "size": 438377625
+  },
+  {
+    "name": "mainnet-01650-e3c8cc00.erae",
+    "size": 428815800
+  },
+  {
+    "name": "mainnet-01651-c0976efd.erae",
+    "size": 427589548
+  },
+  {
+    "name": "mainnet-01652-1bbf4677.erae",
+    "size": 437131708
+  },
+  {
+    "name": "mainnet-01653-6503a81e.erae",
+    "size": 441415515
+  },
+  {
+    "name": "mainnet-01654-8af896ea.erae",
+    "size": 428536079
+  },
+  {
+    "name": "mainnet-01655-8aa8e64c.erae",
+    "size": 411552329
+  },
+  {
+    "name": "mainnet-01656-452459e1.erae",
+    "size": 418032075
+  },
+  {
+    "name": "mainnet-01657-3d445055.erae",
+    "size": 446434622
+  },
+  {
+    "name": "mainnet-01658-18ca26c9.erae",
+    "size": 454507455
+  },
+  {
+    "name": "mainnet-01659-e28debd7.erae",
+    "size": 435294999
+  },
+  {
+    "name": "mainnet-01660-89570096.erae",
+    "size": 421388993
+  },
+  {
+    "name": "mainnet-01661-4ddc5454.erae",
+    "size": 418558322
+  },
+  {
+    "name": "mainnet-01662-66e0baf0.erae",
+    "size": 423365745
+  },
+  {
+    "name": "mainnet-01663-cc1a55ee.erae",
+    "size": 439869285
+  },
+  {
+    "name": "mainnet-01664-ec446b59.erae",
+    "size": 437499272
+  },
+  {
+    "name": "mainnet-01665-b09d48b8.erae",
+    "size": 429176028
+  },
+  {
+    "name": "mainnet-01666-9628a9fd.erae",
+    "size": 415037829
+  },
+  {
+    "name": "mainnet-01667-9b7c8443.erae",
+    "size": 426724649
+  },
+  {
+    "name": "mainnet-01668-19c5a1b7.erae",
+    "size": 426127864
+  },
+  {
+    "name": "mainnet-01669-aa605615.erae",
+    "size": 444280910
+  },
+  {
+    "name": "mainnet-01670-ef3c9eb6.erae",
+    "size": 443574368
+  },
+  {
+    "name": "mainnet-01671-35ef480e.erae",
+    "size": 438426293
+  },
+  {
+    "name": "mainnet-01672-beee6aec.erae",
+    "size": 411504437
+  },
+  {
+    "name": "mainnet-01673-b5643dcb.erae",
+    "size": 428375201
+  },
+  {
+    "name": "mainnet-01674-cf5dc62a.erae",
+    "size": 418383490
+  },
+  {
+    "name": "mainnet-01675-f5cf63fb.erae",
+    "size": 428967071
+  },
+  {
+    "name": "mainnet-01676-d5d035cd.erae",
+    "size": 421442363
+  },
+  {
+    "name": "mainnet-01677-a8198670.erae",
+    "size": 431745902
+  },
+  {
+    "name": "mainnet-01678-96ab309a.erae",
+    "size": 431609458
+  },
+  {
+    "name": "mainnet-01679-4ab2318f.erae",
+    "size": 414003122
+  },
+  {
+    "name": "mainnet-01680-84487470.erae",
+    "size": 426332698
+  },
+  {
+    "name": "mainnet-01681-1acedb4e.erae",
+    "size": 420777358
+  },
+  {
+    "name": "mainnet-01682-197d352c.erae",
+    "size": 399993009
+  },
+  {
+    "name": "mainnet-01683-a60c5496.erae",
+    "size": 397842224
+  },
+  {
+    "name": "mainnet-01684-8cc35863.erae",
+    "size": 415229240
+  },
+  {
+    "name": "mainnet-01685-43acba23.erae",
+    "size": 421306314
+  },
+  {
+    "name": "mainnet-01686-1b714521.erae",
+    "size": 399783797
+  },
+  {
+    "name": "mainnet-01687-56023863.erae",
+    "size": 417050621
+  },
+  {
+    "name": "mainnet-01688-b37138cc.erae",
+    "size": 400398577
+  },
+  {
+    "name": "mainnet-01689-aceba1c3.erae",
+    "size": 403379690
+  },
+  {
+    "name": "mainnet-01690-325a67bb.erae",
+    "size": 403808026
+  },
+  {
+    "name": "mainnet-01691-efe88758.erae",
+    "size": 416731636
+  },
+  {
+    "name": "mainnet-01692-0914087d.erae",
+    "size": 426377626
+  },
+  {
+    "name": "mainnet-01693-f1f70e91.erae",
+    "size": 430890493
+  },
+  {
+    "name": "mainnet-01694-d4b03cdc.erae",
+    "size": 417225297
+  },
+  {
+    "name": "mainnet-01695-9f0410f3.erae",
+    "size": 428743290
+  },
+  {
+    "name": "mainnet-01696-9651419e.erae",
+    "size": 455162056
+  },
+  {
+    "name": "mainnet-01697-b6738ee2.erae",
+    "size": 434101149
+  },
+  {
+    "name": "mainnet-01698-75b50790.erae",
+    "size": 421140784
+  },
+  {
+    "name": "mainnet-01699-ed055de6.erae",
+    "size": 416844771
+  },
+  {
+    "name": "mainnet-01700-8fcd5dd3.erae",
+    "size": 427597602
+  },
+  {
+    "name": "mainnet-01701-e1571300.erae",
+    "size": 418836126
+  },
+  {
+    "name": "mainnet-01702-f0655728.erae",
+    "size": 442155164
+  },
+  {
+    "name": "mainnet-01703-531711a5.erae",
+    "size": 428214663
+  },
+  {
+    "name": "mainnet-01704-f7de244e.erae",
+    "size": 427209461
+  },
+  {
+    "name": "mainnet-01705-51b769b1.erae",
+    "size": 409954870
+  },
+  {
+    "name": "mainnet-01706-77c33969.erae",
+    "size": 477156686
+  },
+  {
+    "name": "mainnet-01707-54b92acd.erae",
+    "size": 454625184
+  },
+  {
+    "name": "mainnet-01708-796ab140.erae",
+    "size": 436280722
+  },
+  {
+    "name": "mainnet-01709-6f4982f0.erae",
+    "size": 449325767
+  },
+  {
+    "name": "mainnet-01710-3dea1095.erae",
+    "size": 425524620
+  },
+  {
+    "name": "mainnet-01711-8330b618.erae",
+    "size": 434383391
+  },
+  {
+    "name": "mainnet-01712-6c113f2b.erae",
+    "size": 437991864
+  },
+  {
+    "name": "mainnet-01713-07621da0.erae",
+    "size": 435184259
+  },
+  {
+    "name": "mainnet-01714-52ff763f.erae",
+    "size": 433220529
+  },
+  {
+    "name": "mainnet-01715-55de40d4.erae",
+    "size": 463803855
+  },
+  {
+    "name": "mainnet-01716-9f27f11a.erae",
+    "size": 415164001
+  },
+  {
+    "name": "mainnet-01717-f30d2933.erae",
+    "size": 441906002
+  },
+  {
+    "name": "mainnet-01718-6add0080.erae",
+    "size": 430501139
+  },
+  {
+    "name": "mainnet-01719-5348214c.erae",
+    "size": 442401931
+  },
+  {
+    "name": "mainnet-01720-1b08a8b5.erae",
+    "size": 417562585
+  },
+  {
+    "name": "mainnet-01721-e702b29b.erae",
+    "size": 410233540
+  },
+  {
+    "name": "mainnet-01722-83c26eb2.erae",
+    "size": 418117949
+  },
+  {
+    "name": "mainnet-01723-2140a7d2.erae",
+    "size": 423079292
+  },
+  {
+    "name": "mainnet-01724-7f917729.erae",
+    "size": 421118074
+  },
+  {
+    "name": "mainnet-01725-613b0c40.erae",
+    "size": 415702037
+  },
+  {
+    "name": "mainnet-01726-15856926.erae",
+    "size": 430628407
+  },
+  {
+    "name": "mainnet-01727-65c49a5c.erae",
+    "size": 416228270
+  },
+  {
+    "name": "mainnet-01728-6df3b5db.erae",
+    "size": 433733306
+  },
+  {
+    "name": "mainnet-01729-a974e0d4.erae",
+    "size": 430474134
+  },
+  {
+    "name": "mainnet-01730-89753de8.erae",
+    "size": 442579539
+  },
+  {
+    "name": "mainnet-01731-c503e7bf.erae",
+    "size": 435415523
+  },
+  {
+    "name": "mainnet-01732-4c640b87.erae",
+    "size": 406887463
+  },
+  {
+    "name": "mainnet-01733-6333a042.erae",
+    "size": 422182459
+  },
+  {
+    "name": "mainnet-01734-730b2604.erae",
+    "size": 441811409
+  },
+  {
+    "name": "mainnet-01735-37973f64.erae",
+    "size": 440199110
+  },
+  {
+    "name": "mainnet-01736-7515786b.erae",
+    "size": 442512242
+  },
+  {
+    "name": "mainnet-01737-552f6230.erae",
+    "size": 441003270
+  },
+  {
+    "name": "mainnet-01738-7de93a03.erae",
+    "size": 467666255
+  },
+  {
+    "name": "mainnet-01739-eb4787c1.erae",
+    "size": 460517787
+  },
+  {
+    "name": "mainnet-01740-b2e4b8b8.erae",
+    "size": 437635174
+  },
+  {
+    "name": "mainnet-01741-fd32dd5e.erae",
+    "size": 458052578
+  },
+  {
+    "name": "mainnet-01742-d1a4ad38.erae",
+    "size": 444672245
+  },
+  {
+    "name": "mainnet-01743-bb7fa9d0.erae",
+    "size": 427049960
+  },
+  {
+    "name": "mainnet-01744-aaed9381.erae",
+    "size": 423639139
+  },
+  {
+    "name": "mainnet-01745-fe1c5234.erae",
+    "size": 443316475
+  },
+  {
+    "name": "mainnet-01746-e5844dfb.erae",
+    "size": 457694254
+  },
+  {
+    "name": "mainnet-01747-35605eb4.erae",
+    "size": 427728946
+  },
+  {
+    "name": "mainnet-01748-ef0998a5.erae",
+    "size": 420930777
+  },
+  {
+    "name": "mainnet-01749-6575931b.erae",
+    "size": 403944966
+  },
+  {
+    "name": "mainnet-01750-ab69cbc2.erae",
+    "size": 433052452
+  },
+  {
+    "name": "mainnet-01751-7dcc1408.erae",
+    "size": 442733458
+  },
+  {
+    "name": "mainnet-01752-d092e1db.erae",
+    "size": 439735630
+  },
+  {
+    "name": "mainnet-01753-9a7c03a5.erae",
+    "size": 434796707
+  },
+  {
+    "name": "mainnet-01754-70654ae8.erae",
+    "size": 421052001
+  },
+  {
+    "name": "mainnet-01755-a8d93677.erae",
+    "size": 439336883
+  },
+  {
+    "name": "mainnet-01756-2d3b8c7b.erae",
+    "size": 461229384
+  },
+  {
+    "name": "mainnet-01757-0a8630ed.erae",
+    "size": 452603612
+  },
+  {
+    "name": "mainnet-01758-5f65ced0.erae",
+    "size": 434469537
+  },
+  {
+    "name": "mainnet-01759-3ef74ce8.erae",
+    "size": 426095300
+  },
+  {
+    "name": "mainnet-01760-e999c6fa.erae",
+    "size": 429237628
+  },
+  {
+    "name": "mainnet-01761-5d98af0e.erae",
+    "size": 439008155
+  },
+  {
+    "name": "mainnet-01762-7e5be732.erae",
+    "size": 448671968
+  },
+  {
+    "name": "mainnet-01763-02d54e95.erae",
+    "size": 447597323
+  },
+  {
+    "name": "mainnet-01764-7a08b2af.erae",
+    "size": 441960251
+  },
+  {
+    "name": "mainnet-01765-6e6c90b2.erae",
+    "size": 416021732
+  },
+  {
+    "name": "mainnet-01766-b9d03474.erae",
+    "size": 446664238
+  },
+  {
+    "name": "mainnet-01767-65c60579.erae",
+    "size": 461263196
+  },
+  {
+    "name": "mainnet-01768-b4546496.erae",
+    "size": 458356932
+  },
+  {
+    "name": "mainnet-01769-806ac19f.erae",
+    "size": 458320843
+  },
+  {
+    "name": "mainnet-01770-6930bb7b.erae",
+    "size": 461710915
+  },
+  {
+    "name": "mainnet-01771-39f85d77.erae",
+    "size": 436463288
+  },
+  {
+    "name": "mainnet-01772-465576fa.erae",
+    "size": 433977568
+  },
+  {
+    "name": "mainnet-01773-8ee5dc55.erae",
+    "size": 440323054
+  },
+  {
+    "name": "mainnet-01774-b120471c.erae",
+    "size": 464878448
+  },
+  {
+    "name": "mainnet-01775-2c9a8e1d.erae",
+    "size": 457131329
+  },
+  {
+    "name": "mainnet-01776-c5223eb9.erae",
+    "size": 426462987
+  },
+  {
+    "name": "mainnet-01777-81e515e4.erae",
+    "size": 438948795
+  },
+  {
+    "name": "mainnet-01778-c8c5fc47.erae",
+    "size": 442878365
+  },
+  {
+    "name": "mainnet-01779-5e3d64f3.erae",
+    "size": 431801723
+  },
+  {
+    "name": "mainnet-01780-1935131e.erae",
+    "size": 433639991
+  },
+  {
+    "name": "mainnet-01781-721aa801.erae",
+    "size": 422415729
+  },
+  {
+    "name": "mainnet-01782-b82d4162.erae",
+    "size": 420746242
+  },
+  {
+    "name": "mainnet-01783-03adb66f.erae",
+    "size": 448658825
+  },
+  {
+    "name": "mainnet-01784-3ff2e2e5.erae",
+    "size": 466828601
+  },
+  {
+    "name": "mainnet-01785-bd8535d0.erae",
+    "size": 454857737
+  },
+  {
+    "name": "mainnet-01786-c847ea90.erae",
+    "size": 451158446
+  },
+  {
+    "name": "mainnet-01787-028295ba.erae",
+    "size": 437812248
+  },
+  {
+    "name": "mainnet-01788-fa959250.erae",
+    "size": 472209595
+  },
+  {
+    "name": "mainnet-01789-97018222.erae",
+    "size": 451585963
+  },
+  {
+    "name": "mainnet-01790-c6b66ebf.erae",
+    "size": 466810485
+  },
+  {
+    "name": "mainnet-01791-63ded748.erae",
+    "size": 466743046
+  },
+  {
+    "name": "mainnet-01792-97265de5.erae",
+    "size": 456449549
+  },
+  {
+    "name": "mainnet-01793-db6c1b0e.erae",
+    "size": 438956540
+  },
+  {
+    "name": "mainnet-01794-7febd580.erae",
+    "size": 438061589
+  },
+  {
+    "name": "mainnet-01795-08e9c485.erae",
+    "size": 456805451
+  },
+  {
+    "name": "mainnet-01796-91dc8bd1.erae",
+    "size": 470881094
+  },
+  {
+    "name": "mainnet-01797-96ebbe37.erae",
+    "size": 463205264
+  },
+  {
+    "name": "mainnet-01798-9a7e76a6.erae",
+    "size": 463298814
+  },
+  {
+    "name": "mainnet-01799-601cdc24.erae",
+    "size": 490406623
+  },
+  {
+    "name": "mainnet-01800-ef354397.erae",
+    "size": 525804113
+  },
+  {
+    "name": "mainnet-01801-08c5c53d.erae",
+    "size": 550730652
+  },
+  {
+    "name": "mainnet-01802-156fd4dc.erae",
+    "size": 517259067
+  },
+  {
+    "name": "mainnet-01803-9c8ad7be.erae",
+    "size": 467983727
+  },
+  {
+    "name": "mainnet-01804-270b4fc6.erae",
+    "size": 468569757
+  },
+  {
+    "name": "mainnet-01805-3e73128e.erae",
+    "size": 474176147
+  },
+  {
+    "name": "mainnet-01806-7f8e27c4.erae",
+    "size": 464660522
+  },
+  {
+    "name": "mainnet-01807-e47f84b9.erae",
+    "size": 462775671
+  },
+  {
+    "name": "mainnet-01808-0b0c046f.erae",
+    "size": 460287078
+  },
+  {
+    "name": "mainnet-01809-441d73f1.erae",
+    "size": 453611353
+  },
+  {
+    "name": "mainnet-01810-1f4832e6.erae",
+    "size": 469648655
+  },
+  {
+    "name": "mainnet-01811-3175d312.erae",
+    "size": 462682794
+  },
+  {
+    "name": "mainnet-01812-671fb1ff.erae",
+    "size": 471239324
+  },
+  {
+    "name": "mainnet-01813-7268775c.erae",
+    "size": 462425707
+  },
+  {
+    "name": "mainnet-01814-5a87a38f.erae",
+    "size": 461733329
+  },
+  {
+    "name": "mainnet-01815-90c4b814.erae",
+    "size": 458113551
+  },
+  {
+    "name": "mainnet-01816-be2707be.erae",
+    "size": 608286108
+  },
+  {
+    "name": "mainnet-01817-775e2668.erae",
+    "size": 547185462
+  },
+  {
+    "name": "mainnet-01818-db128c9b.erae",
+    "size": 484272872
+  },
+  {
+    "name": "mainnet-01819-7bdc50aa.erae",
+    "size": 466769389
+  },
+  {
+    "name": "mainnet-01820-14b1b0b1.erae",
+    "size": 471817479
+  },
+  {
+    "name": "mainnet-01821-b302023a.erae",
+    "size": 486901847
+  },
+  {
+    "name": "mainnet-01822-fc67f0d8.erae",
+    "size": 465129184
+  },
+  {
+    "name": "mainnet-01823-03247b82.erae",
+    "size": 456237562
+  },
+  {
+    "name": "mainnet-01824-3bad8918.erae",
+    "size": 483416163
+  },
+  {
+    "name": "mainnet-01825-082881a2.erae",
+    "size": 522023783
+  },
+  {
+    "name": "mainnet-01826-ce4880ff.erae",
+    "size": 524738740
+  },
+  {
+    "name": "mainnet-01827-59d918cc.erae",
+    "size": 519483564
+  },
+  {
+    "name": "mainnet-01828-a6055229.erae",
+    "size": 472221628
+  },
+  {
+    "name": "mainnet-01829-7335a998.erae",
+    "size": 492988360
+  },
+  {
+    "name": "mainnet-01830-691faca7.erae",
+    "size": 480483389
+  },
+  {
+    "name": "mainnet-01831-19dc2b84.erae",
+    "size": 514446143
+  },
+  {
+    "name": "mainnet-01832-ca882564.erae",
+    "size": 517136761
+  },
+  {
+    "name": "mainnet-01833-8e4bb88d.erae",
+    "size": 528335614
+  },
+  {
+    "name": "mainnet-01834-8ed4dcec.erae",
+    "size": 528298661
+  },
+  {
+    "name": "mainnet-01835-91f92a43.erae",
+    "size": 531397041
+  },
+  {
+    "name": "mainnet-01836-301c84d3.erae",
+    "size": 545777046
+  },
+  {
+    "name": "mainnet-01837-d123ff5e.erae",
+    "size": 502324806
+  },
+  {
+    "name": "mainnet-01838-6161634f.erae",
+    "size": 451108389
+  },
+  {
+    "name": "mainnet-01839-66bfa5f6.erae",
+    "size": 442301948
+  },
+  {
+    "name": "mainnet-01840-414ae4fa.erae",
+    "size": 458543844
+  },
+  {
+    "name": "mainnet-01841-106b3d4f.erae",
+    "size": 457961853
+  },
+  {
+    "name": "mainnet-01842-15e0322e.erae",
+    "size": 461049928
+  },
+  {
+    "name": "mainnet-01843-7afa6d80.erae",
+    "size": 453825756
+  },
+  {
+    "name": "mainnet-01844-5cffce62.erae",
+    "size": 441364646
+  },
+  {
+    "name": "mainnet-01845-2483be35.erae",
+    "size": 444222835
+  },
+  {
+    "name": "mainnet-01846-abbb1c50.erae",
+    "size": 447185346
+  },
+  {
+    "name": "mainnet-01847-d2a4700a.erae",
+    "size": 467168140
+  },
+  {
+    "name": "mainnet-01848-0f6a2094.erae",
+    "size": 466859661
+  },
+  {
+    "name": "mainnet-01849-bbbc0ef6.erae",
+    "size": 482297639
+  },
+  {
+    "name": "mainnet-01850-0a718456.erae",
+    "size": 464619178
+  },
+  {
+    "name": "mainnet-01851-f8d67cec.erae",
+    "size": 493269850
+  },
+  {
+    "name": "mainnet-01852-b18c3f31.erae",
+    "size": 479216977
+  },
+  {
+    "name": "mainnet-01853-fd6ecae0.erae",
+    "size": 492624036
+  },
+  {
+    "name": "mainnet-01854-d280502a.erae",
+    "size": 475679561
+  },
+  {
+    "name": "mainnet-01855-e8eb421b.erae",
+    "size": 474294862
+  },
+  {
+    "name": "mainnet-01856-6bbf7572.erae",
+    "size": 480197958
+  },
+  {
+    "name": "mainnet-01857-f1323e3b.erae",
+    "size": 499639990
+  },
+  {
+    "name": "mainnet-01858-667d6b4e.erae",
+    "size": 485024719
+  },
+  {
+    "name": "mainnet-01859-c365fc7b.erae",
+    "size": 514722572
+  },
+  {
+    "name": "mainnet-01860-92cdce2a.erae",
+    "size": 502225530
+  },
+  {
+    "name": "mainnet-01861-1ba4052a.erae",
+    "size": 485545381
+  },
+  {
+    "name": "mainnet-01862-93e74248.erae",
+    "size": 486353531
+  },
+  {
+    "name": "mainnet-01863-814eac4d.erae",
+    "size": 497409106
+  },
+  {
+    "name": "mainnet-01864-b8b43333.erae",
+    "size": 509346557
+  },
+  {
+    "name": "mainnet-01865-dd228508.erae",
+    "size": 493572838
+  },
+  {
+    "name": "mainnet-01866-259a037d.erae",
+    "size": 472867518
+  },
+  {
+    "name": "mainnet-01867-227bba69.erae",
+    "size": 476453466
+  },
+  {
+    "name": "mainnet-01868-37dd1343.erae",
+    "size": 477712297
+  },
+  {
+    "name": "mainnet-01869-984b733c.erae",
+    "size": 497090663
+  },
+  {
+    "name": "mainnet-01870-8d03675e.erae",
+    "size": 479767918
+  },
+  {
+    "name": "mainnet-01871-4629af1d.erae",
+    "size": 467426319
+  },
+  {
+    "name": "mainnet-01872-f5feeef6.erae",
+    "size": 474651999
+  },
+  {
+    "name": "mainnet-01873-c4e70a15.erae",
+    "size": 482473788
+  },
+  {
+    "name": "mainnet-01874-fd2a3c2f.erae",
+    "size": 480931159
+  },
+  {
+    "name": "mainnet-01875-982957a9.erae",
+    "size": 476779344
+  },
+  {
+    "name": "mainnet-01876-eb015af5.erae",
+    "size": 494993311
+  },
+  {
+    "name": "mainnet-01877-1eea5ffc.erae",
+    "size": 478717181
+  },
+  {
+    "name": "mainnet-01878-5b8b33a4.erae",
+    "size": 469237023
+  },
+  {
+    "name": "mainnet-01879-6e1488f5.erae",
+    "size": 475229181
+  },
+  {
+    "name": "mainnet-01880-15e05a2a.erae",
+    "size": 479926859
+  },
+  {
+    "name": "mainnet-01881-ea4626dc.erae",
+    "size": 486985085
+  },
+  {
+    "name": "mainnet-01882-07b08574.erae",
+    "size": 479722215
+  },
+  {
+    "name": "mainnet-01883-19bcf762.erae",
+    "size": 482298694
+  },
+  {
+    "name": "mainnet-01884-bad60fd1.erae",
+    "size": 511364246
+  },
+  {
+    "name": "mainnet-01885-71c63cd6.erae",
+    "size": 495496623
+  },
+  {
+    "name": "mainnet-01886-15fef6e0.erae",
+    "size": 485804246
+  },
+  {
+    "name": "mainnet-01887-a03d6354.erae",
+    "size": 466159382
+  },
+  {
+    "name": "mainnet-01888-1e2bcc3c.erae",
+    "size": 448584675
+  },
+  {
+    "name": "mainnet-01889-c21a9ed9.erae",
+    "size": 492449279
+  },
+  {
+    "name": "mainnet-01890-109d247c.erae",
+    "size": 502413484
+  },
+  {
+    "name": "mainnet-01891-5e365d21.erae",
+    "size": 490240486
+  },
+  {
+    "name": "mainnet-01892-762f5924.erae",
+    "size": 480390946
+  },
+  {
+    "name": "mainnet-01893-62df83e3.erae",
+    "size": 466849834
+  },
+  {
+    "name": "mainnet-01894-525da7e3.erae",
+    "size": 483928695
+  },
+  {
+    "name": "mainnet-01895-4373f22f.erae",
+    "size": 498433938
+  },
+  {
+    "name": "mainnet-01896-19b741b9.erae",
+    "size": 486614268
+  },
+  {
+    "name": "mainnet-01897-e49dd4c0.erae",
+    "size": 477531992
+  },
+  {
+    "name": "mainnet-01898-5803b13c.erae",
+    "size": 444109984
+  },
+  {
+    "name": "mainnet-01899-055071df.erae",
+    "size": 460929963
+  },
+  {
+    "name": "mainnet-01900-34196a7e.erae",
+    "size": 485141977
+  },
+  {
+    "name": "mainnet-01901-90d51cb0.erae",
+    "size": 532982128
+  },
+  {
+    "name": "mainnet-01902-13bff279.erae",
+    "size": 534079597
+  },
+  {
+    "name": "mainnet-01903-4ff9cfc3.erae",
+    "size": 522429223
+  },
+  {
+    "name": "mainnet-01904-a596da19.erae",
+    "size": 489537554
+  },
+  {
+    "name": "mainnet-01905-f3e658be.erae",
+    "size": 463042013
+  },
+  {
+    "name": "mainnet-01906-3af15234.erae",
+    "size": 505483660
+  },
+  {
+    "name": "mainnet-01907-18927213.erae",
+    "size": 491157889
+  },
+  {
+    "name": "mainnet-01908-b3ef8103.erae",
+    "size": 504802203
+  },
+  {
+    "name": "mainnet-01909-133b076d.erae",
+    "size": 503435770
+  },
+  {
+    "name": "mainnet-01910-fde06115.erae",
+    "size": 492467548
+  },
+  {
+    "name": "mainnet-01911-9ed65266.erae",
+    "size": 491368393
+  },
+  {
+    "name": "mainnet-01912-282b299f.erae",
+    "size": 470302949
+  },
+  {
+    "name": "mainnet-01913-63916250.erae",
+    "size": 488728230
+  },
+  {
+    "name": "mainnet-01914-2f273c0e.erae",
+    "size": 513031064
+  },
+  {
+    "name": "mainnet-01915-1cfb2ecf.erae",
+    "size": 498675823
+  },
+  {
+    "name": "mainnet-01916-ad4c39a6.erae",
+    "size": 489305152
+  },
+  {
+    "name": "mainnet-01917-3ed021fe.erae",
+    "size": 362205678
+  },
+  {
+    "name": "mainnet-01918-18a0adff.erae",
+    "size": 353003234
+  },
+  {
+    "name": "mainnet-01919-4813fa7b.erae",
+    "size": 411969096
+  },
+  {
+    "name": "mainnet-01920-472f6728.erae",
+    "size": 413412495
+  },
+  {
+    "name": "mainnet-01921-4f7f3e61.erae",
+    "size": 470952870
+  },
+  {
+    "name": "mainnet-01922-8dd920a6.erae",
+    "size": 418657185
+  },
+  {
+    "name": "mainnet-01923-2eb5ccb0.erae",
+    "size": 413807947
+  },
+  {
+    "name": "mainnet-01924-0a6c0e21.erae",
+    "size": 453610775
+  },
+  {
+    "name": "mainnet-01925-19ab3c3e.erae",
+    "size": 468402904
+  },
+  {
+    "name": "mainnet-01926-96917c07.erae",
+    "size": 479203416
+  },
+  {
+    "name": "mainnet-01927-7313aa96.erae",
+    "size": 491702815
+  },
+  {
+    "name": "mainnet-01928-809ab3ba.erae",
+    "size": 454915529
+  },
+  {
+    "name": "mainnet-01929-c22c5d6d.erae",
+    "size": 436724053
+  },
+  {
+    "name": "mainnet-01930-aba02f93.erae",
+    "size": 487742892
+  },
+  {
+    "name": "mainnet-01931-d41f832a.erae",
+    "size": 503218200
+  },
+  {
+    "name": "mainnet-01932-fe0e732d.erae",
+    "size": 545217658
+  },
+  {
+    "name": "mainnet-01933-d375eeb8.erae",
+    "size": 543131289
+  },
+  {
+    "name": "mainnet-01934-59dfc3cd.erae",
+    "size": 509236541
+  },
+  {
+    "name": "mainnet-01935-07c0189f.erae",
+    "size": 513979097
+  },
+  {
+    "name": "mainnet-01936-6827ff75.erae",
+    "size": 523248910
+  },
+  {
+    "name": "mainnet-01937-e7a897c0.erae",
+    "size": 528970848
+  },
+  {
+    "name": "mainnet-01938-e2d454a6.erae",
+    "size": 516281215
+  },
+  {
+    "name": "mainnet-01939-5e65d25e.erae",
+    "size": 501168188
+  },
+  {
+    "name": "mainnet-01940-8d9a7bdc.erae",
+    "size": 519705852
+  },
+  {
+    "name": "mainnet-01941-a4197bc9.erae",
+    "size": 487558896
+  },
+  {
+    "name": "mainnet-01942-1b874da3.erae",
+    "size": 529592366
+  },
+  {
+    "name": "mainnet-01943-30cabf5c.erae",
+    "size": 569809649
+  },
+  {
+    "name": "mainnet-01944-062d5741.erae",
+    "size": 650987889
+  },
+  {
+    "name": "mainnet-01945-b5d80d4d.erae",
+    "size": 622364737
+  },
+  {
+    "name": "mainnet-01946-eda73321.erae",
+    "size": 575768128
+  },
+  {
+    "name": "mainnet-01947-252d4b03.erae",
+    "size": 499870440
+  },
+  {
+    "name": "mainnet-01948-0b618a5e.erae",
+    "size": 523897067
+  },
+  {
+    "name": "mainnet-01949-94479c0b.erae",
+    "size": 538693071
+  },
+  {
+    "name": "mainnet-01950-4024ea28.erae",
+    "size": 506447860
+  },
+  {
+    "name": "mainnet-01951-f7e94049.erae",
+    "size": 520871743
+  },
+  {
+    "name": "mainnet-01952-7b9081ae.erae",
+    "size": 497191144
+  },
+  {
+    "name": "mainnet-01953-8ed975a1.erae",
+    "size": 489557989
+  },
+  {
+    "name": "mainnet-01954-9eb354c5.erae",
+    "size": 518382721
+  },
+  {
+    "name": "mainnet-01955-13295608.erae",
+    "size": 537561638
+  },
+  {
+    "name": "mainnet-01956-a3feaf03.erae",
+    "size": 543743714
+  },
+  {
+    "name": "mainnet-01957-9b2a2749.erae",
+    "size": 534741485
+  },
+  {
+    "name": "mainnet-01958-440df436.erae",
+    "size": 494328849
+  },
+  {
+    "name": "mainnet-01959-5fe90cea.erae",
+    "size": 490710884
+  },
+  {
+    "name": "mainnet-01960-5648562d.erae",
+    "size": 461576849
+  },
+  {
+    "name": "mainnet-01961-ba1d2515.erae",
+    "size": 503096430
+  },
+  {
+    "name": "mainnet-01962-1a80c4bb.erae",
+    "size": 521407835
+  },
+  {
+    "name": "mainnet-01963-96c7bdb2.erae",
+    "size": 529574855
+  },
+  {
+    "name": "mainnet-01964-66bf8c79.erae",
+    "size": 509103510
+  },
+  {
+    "name": "mainnet-01965-eb2a1632.erae",
+    "size": 498940871
+  },
+  {
+    "name": "mainnet-01966-c041f92e.erae",
+    "size": 483220939
+  },
+  {
+    "name": "mainnet-01967-a6e235d4.erae",
+    "size": 501495168
+  },
+  {
+    "name": "mainnet-01968-926cc715.erae",
+    "size": 507169624
+  },
+  {
+    "name": "mainnet-01969-e2af05fc.erae",
+    "size": 492510766
+  },
+  {
+    "name": "mainnet-01970-9dc3f5b8.erae",
+    "size": 519488383
+  },
+  {
+    "name": "mainnet-01971-eaec8f31.erae",
+    "size": 524292071
+  },
+  {
+    "name": "mainnet-01972-f32dd1e7.erae",
+    "size": 486617872
+  },
+  {
+    "name": "mainnet-01973-fb0f8039.erae",
+    "size": 527145767
+  },
+  {
+    "name": "mainnet-01974-157ab7ab.erae",
+    "size": 561171618
+  },
+  {
+    "name": "mainnet-01975-44640c81.erae",
+    "size": 559625706
+  },
+  {
+    "name": "mainnet-01976-03684773.erae",
+    "size": 553557143
+  },
+  {
+    "name": "mainnet-01977-5c297bd5.erae",
+    "size": 576905871
+  },
+  {
+    "name": "mainnet-01978-5105cc6d.erae",
+    "size": 515781286
+  },
+  {
+    "name": "mainnet-01979-f9802df2.erae",
+    "size": 492633885
+  },
+  {
+    "name": "mainnet-01980-2398f8ea.erae",
+    "size": 559303620
+  },
+  {
+    "name": "mainnet-01981-f7e423f6.erae",
+    "size": 563292948
+  },
+  {
+    "name": "mainnet-01982-d95280e9.erae",
+    "size": 542330499
+  },
+  {
+    "name": "mainnet-01983-8fce0970.erae",
+    "size": 519629529
+  },
+  {
+    "name": "mainnet-01984-af42c754.erae",
+    "size": 484041291
+  },
+  {
+    "name": "mainnet-01985-0988a1ae.erae",
+    "size": 508925502
+  },
+  {
+    "name": "mainnet-01986-87548e57.erae",
+    "size": 518842272
+  },
+  {
+    "name": "mainnet-01987-bf30ce97.erae",
+    "size": 537588038
+  },
+  {
+    "name": "mainnet-01988-ea923ec0.erae",
+    "size": 523274429
+  },
+  {
+    "name": "mainnet-01989-9b8d866b.erae",
+    "size": 525741559
+  },
+  {
+    "name": "mainnet-01990-5103f4da.erae",
+    "size": 468620307
+  },
+  {
+    "name": "mainnet-01991-08548406.erae",
+    "size": 435515856
+  },
+  {
+    "name": "mainnet-01992-87e746e7.erae",
+    "size": 509122941
+  },
+  {
+    "name": "mainnet-01993-d142c483.erae",
+    "size": 553290165
+  },
+  {
+    "name": "mainnet-01994-bfcf9511.erae",
+    "size": 552995115
+  },
+  {
+    "name": "mainnet-01995-cf6690c4.erae",
+    "size": 558852154
+  },
+  {
+    "name": "mainnet-01996-651e805a.erae",
+    "size": 533681862
+  },
+  {
+    "name": "mainnet-01997-46b8615e.erae",
+    "size": 559118499
+  },
+  {
+    "name": "mainnet-01998-b0206bec.erae",
+    "size": 601499727
+  },
+  {
+    "name": "mainnet-01999-d83c5d6b.erae",
+    "size": 592242565
+  },
+  {
+    "name": "mainnet-02000-06dadd70.erae",
+    "size": 628582821
+  },
+  {
+    "name": "mainnet-02001-9bc0ce13.erae",
+    "size": 609765527
+  },
+  {
+    "name": "mainnet-02002-fc952cf8.erae",
+    "size": 640807154
+  },
+  {
+    "name": "mainnet-02003-1e144d00.erae",
+    "size": 592631374
+  },
+  {
+    "name": "mainnet-02004-6d2ee8c2.erae",
+    "size": 606382948
+  },
+  {
+    "name": "mainnet-02005-8f197fc6.erae",
+    "size": 555295542
+  },
+  {
+    "name": "mainnet-02006-e8dd90c2.erae",
+    "size": 511702948
+  },
+  {
+    "name": "mainnet-02007-364fce4d.erae",
+    "size": 480562171
+  },
+  {
+    "name": "mainnet-02008-cc8afb3a.erae",
+    "size": 514693647
+  },
+  {
+    "name": "mainnet-02009-12df69f7.erae",
+    "size": 455816560
+  },
+  {
+    "name": "mainnet-02010-c8547e10.erae",
+    "size": 479542127
+  },
+  {
+    "name": "mainnet-02011-58f025f5.erae",
+    "size": 499788902
+  },
+  {
+    "name": "mainnet-02012-ea68f11b.erae",
+    "size": 529471808
+  },
+  {
+    "name": "mainnet-02013-93bad730.erae",
+    "size": 518731483
+  },
+  {
+    "name": "mainnet-02014-2f6aec2d.erae",
+    "size": 510535462
+  },
+  {
+    "name": "mainnet-02015-9f3f58bf.erae",
+    "size": 481518049
+  },
+  {
+    "name": "mainnet-02016-424284ff.erae",
+    "size": 529202647
+  },
+  {
+    "name": "mainnet-02017-c5ae7079.erae",
+    "size": 511826622
+  },
+  {
+    "name": "mainnet-02018-d862a4ff.erae",
+    "size": 540387946
+  },
+  {
+    "name": "mainnet-02019-0c1ade00.erae",
+    "size": 545664381
+  },
+  {
+    "name": "mainnet-02020-0a87d406.erae",
+    "size": 535268399
+  },
+  {
+    "name": "mainnet-02021-1bc23291.erae",
+    "size": 530874864
+  },
+  {
+    "name": "mainnet-02022-06d7b0b3.erae",
+    "size": 541120689
+  },
+  {
+    "name": "mainnet-02023-24d4b79e.erae",
+    "size": 564230369
+  },
+  {
+    "name": "mainnet-02024-aa0b336b.erae",
+    "size": 573317567
+  },
+  {
+    "name": "mainnet-02025-207966f9.erae",
+    "size": 599709771
+  },
+  {
+    "name": "mainnet-02026-8d0fa517.erae",
+    "size": 547651869
+  },
+  {
+    "name": "mainnet-02027-3d1a139a.erae",
+    "size": 499018598
+  },
+  {
+    "name": "mainnet-02028-927ebdae.erae",
+    "size": 562570822
+  },
+  {
+    "name": "mainnet-02029-5023e620.erae",
+    "size": 559917287
+  },
+  {
+    "name": "mainnet-02030-59171dc5.erae",
+    "size": 600931684
+  },
+  {
+    "name": "mainnet-02031-98383a87.erae",
+    "size": 606780001
+  },
+  {
+    "name": "mainnet-02032-c52c2a85.erae",
+    "size": 613573736
+  },
+  {
+    "name": "mainnet-02033-e4383422.erae",
+    "size": 590097768
+  },
+  {
+    "name": "mainnet-02034-eb0240a9.erae",
+    "size": 632380763
+  },
+  {
+    "name": "mainnet-02035-95dbc4af.erae",
+    "size": 653514352
+  },
+  {
+    "name": "mainnet-02036-e5d86f87.erae",
+    "size": 671544480
+  },
+  {
+    "name": "mainnet-02037-8bc09756.erae",
+    "size": 666308235
+  },
+  {
+    "name": "mainnet-02038-21e12590.erae",
+    "size": 661692167
+  },
+  {
+    "name": "mainnet-02039-f3d43bc0.erae",
+    "size": 575216963
+  },
+  {
+    "name": "mainnet-02040-a2f86fc5.erae",
+    "size": 594655072
+  },
+  {
+    "name": "mainnet-02041-e068972b.erae",
+    "size": 621051317
+  },
+  {
+    "name": "mainnet-02042-3bd67477.erae",
+    "size": 606316587
+  },
+  {
+    "name": "mainnet-02043-a14af82b.erae",
+    "size": 598957122
+  },
+  {
+    "name": "mainnet-02044-672646ed.erae",
+    "size": 591602467
+  },
+  {
+    "name": "mainnet-02045-196d675c.erae",
+    "size": 561745321
+  },
+  {
+    "name": "mainnet-02046-c11e3728.erae",
+    "size": 551474726
+  },
+  {
+    "name": "mainnet-02047-f34c3c11.erae",
+    "size": 582877324
+  },
+  {
+    "name": "mainnet-02048-9ddffa88.erae",
+    "size": 595351235
+  },
+  {
+    "name": "mainnet-02049-517375e3.erae",
+    "size": 618043764
+  },
+  {
+    "name": "mainnet-02050-9e3ce259.erae",
+    "size": 634029102
+  },
+  {
+    "name": "mainnet-02051-341a646e.erae",
+    "size": 570140284
+  },
+  {
+    "name": "mainnet-02052-6ec0b513.erae",
+    "size": 580365044
+  },
+  {
+    "name": "mainnet-02053-29663943.erae",
+    "size": 627656695
+  },
+  {
+    "name": "mainnet-02054-3bf4fff7.erae",
+    "size": 655976262
+  },
+  {
+    "name": "mainnet-02055-65d5de47.erae",
+    "size": 657202228
+  },
+  {
+    "name": "mainnet-02056-a2d2912a.erae",
+    "size": 661871354
+  },
+  {
+    "name": "mainnet-02057-9f495998.erae",
+    "size": 651239185
+  },
+  {
+    "name": "mainnet-02058-fb9615f2.erae",
+    "size": 650355688
+  },
+  {
+    "name": "mainnet-02059-0141da6d.erae",
+    "size": 705753984
+  },
+  {
+    "name": "mainnet-02060-474c0b98.erae",
+    "size": 723146920
+  },
+  {
+    "name": "mainnet-02061-f0114ec5.erae",
+    "size": 870177938
+  },
+  {
+    "name": "mainnet-02062-bba359d9.erae",
+    "size": 864971600
+  },
+  {
+    "name": "mainnet-02063-6280a1ff.erae",
+    "size": 726831725
+  },
+  {
+    "name": "mainnet-02064-255fa68e.erae",
+    "size": 717296168
+  },
+  {
+    "name": "mainnet-02065-741836bc.erae",
+    "size": 772817027
+  },
+  {
+    "name": "mainnet-02066-da83beab.erae",
+    "size": 755796225
+  },
+  {
+    "name": "mainnet-02067-07a9a835.erae",
+    "size": 774053788
+  },
+  {
+    "name": "mainnet-02068-f012a0f9.erae",
+    "size": 747959686
+  },
+  {
+    "name": "mainnet-02069-bd7ca232.erae",
+    "size": 688934510
+  },
+  {
+    "name": "mainnet-02070-3fa733ce.erae",
+    "size": 683498587
+  },
+  {
+    "name": "mainnet-02071-6f8b7045.erae",
+    "size": 762466556
+  },
+  {
+    "name": "mainnet-02072-5ace84db.erae",
+    "size": 803875947
+  },
+  {
+    "name": "mainnet-02073-6e5a1fa7.erae",
+    "size": 801451818
+  },
+  {
+    "name": "mainnet-02074-43425468.erae",
+    "size": 755567429
+  },
+  {
+    "name": "mainnet-02075-79810f97.erae",
+    "size": 735498662
+  },
+  {
+    "name": "mainnet-02076-432800e5.erae",
+    "size": 756832685
+  },
+  {
+    "name": "mainnet-02077-b31e7205.erae",
+    "size": 776481854
+  },
+  {
+    "name": "mainnet-02078-e2058649.erae",
+    "size": 788999028
+  },
+  {
+    "name": "mainnet-02079-b64a7811.erae",
+    "size": 821132238
+  },
+  {
+    "name": "mainnet-02080-8a0c1b0b.erae",
+    "size": 803649652
+  },
+  {
+    "name": "mainnet-02081-27c4262f.erae",
+    "size": 754559881
+  },
+  {
+    "name": "mainnet-02082-d7e9df90.erae",
+    "size": 696633609
+  },
+  {
+    "name": "mainnet-02083-62f757b9.erae",
+    "size": 835026206
+  },
+  {
+    "name": "mainnet-02084-95412796.erae",
+    "size": 778725993
+  },
+  {
+    "name": "mainnet-02085-eee8e499.erae",
+    "size": 771545073
+  },
+  {
+    "name": "mainnet-02086-40405e4c.erae",
+    "size": 744139637
+  },
+  {
+    "name": "mainnet-02087-60875806.erae",
+    "size": 693330302
+  },
+  {
+    "name": "mainnet-02088-1e58e967.erae",
+    "size": 672325342
+  },
+  {
+    "name": "mainnet-02089-eac0b507.erae",
+    "size": 708593431
+  },
+  {
+    "name": "mainnet-02090-3f251d66.erae",
+    "size": 698366204
+  },
+  {
+    "name": "mainnet-02091-66f446bb.erae",
+    "size": 761446270
+  },
+  {
+    "name": "mainnet-02092-ac52b8de.erae",
+    "size": 699898454
+  },
+  {
+    "name": "mainnet-02093-5c6c300c.erae",
+    "size": 626229671
+  },
+  {
+    "name": "mainnet-02094-8f40ed74.erae",
+    "size": 683738909
+  },
+  {
+    "name": "mainnet-02095-12f1040a.erae",
+    "size": 648985589
+  },
+  {
+    "name": "mainnet-02096-bcf2790a.erae",
+    "size": 684121533
+  },
+  {
+    "name": "mainnet-02097-e6b1af58.erae",
+    "size": 697153769
+  },
+  {
+    "name": "mainnet-02098-f8bc5d1a.erae",
+    "size": 633513171
+  },
+  {
+    "name": "mainnet-02099-424c802c.erae",
+    "size": 659867454
+  },
+  {
+    "name": "mainnet-02100-dcd6fc94.erae",
+    "size": 601108698
+  },
+  {
+    "name": "mainnet-02101-f3f0cc26.erae",
+    "size": 629634839
+  },
+  {
+    "name": "mainnet-02102-5ba104fd.erae",
+    "size": 684594690
+  },
+  {
+    "name": "mainnet-02103-2e7d500e.erae",
+    "size": 706240970
+  },
+  {
+    "name": "mainnet-02104-bb4aa2d7.erae",
+    "size": 742082284
+  },
+  {
+    "name": "mainnet-02105-7d511583.erae",
+    "size": 737173085
+  },
+  {
+    "name": "mainnet-02106-4f5a2f5c.erae",
+    "size": 703091835
+  },
+  {
+    "name": "mainnet-02107-4ba2e24a.erae",
+    "size": 723412544
+  },
+  {
+    "name": "mainnet-02108-75069467.erae",
+    "size": 799555966
+  },
+  {
+    "name": "mainnet-02109-4200170d.erae",
+    "size": 782812034
+  },
+  {
+    "name": "mainnet-02110-c2620460.erae",
+    "size": 727500391
+  },
+  {
+    "name": "mainnet-02111-17fc9c10.erae",
+    "size": 726603822
+  },
+  {
+    "name": "mainnet-02112-92d74444.erae",
+    "size": 713454502
+  },
+  {
+    "name": "mainnet-02113-24a0f3d2.erae",
+    "size": 714583549
+  },
+  {
+    "name": "mainnet-02114-3b4fb239.erae",
+    "size": 718035463
+  },
+  {
+    "name": "mainnet-02115-0372b62f.erae",
+    "size": 805489525
+  },
+  {
+    "name": "mainnet-02116-34dd6a37.erae",
+    "size": 848868932
+  },
+  {
+    "name": "mainnet-02117-71e71e4f.erae",
+    "size": 800310912
+  },
+  {
+    "name": "mainnet-02118-b72b192f.erae",
+    "size": 821864026
+  },
+  {
+    "name": "mainnet-02119-919a35c2.erae",
+    "size": 765317161
+  },
+  {
+    "name": "mainnet-02120-c4ec5641.erae",
+    "size": 788026030
+  },
+  {
+    "name": "mainnet-02121-0e29e456.erae",
+    "size": 793836448
+  },
+  {
+    "name": "mainnet-02122-44f86280.erae",
+    "size": 743782273
+  },
+  {
+    "name": "mainnet-02123-1c6e972d.erae",
+    "size": 783039418
+  },
+  {
+    "name": "mainnet-02124-9b1502dd.erae",
+    "size": 786877606
+  },
+  {
+    "name": "mainnet-02125-08bceb55.erae",
+    "size": 818877544
+  },
+  {
+    "name": "mainnet-02126-d6541d77.erae",
+    "size": 770127308
+  },
+  {
+    "name": "mainnet-02127-6835b35a.erae",
+    "size": 745438110
+  },
+  {
+    "name": "mainnet-02128-683b1ab1.erae",
+    "size": 743687447
+  },
+  {
+    "name": "mainnet-02129-9e4181c2.erae",
+    "size": 821943111
+  },
+  {
+    "name": "mainnet-02130-9dd6a732.erae",
+    "size": 788050833
+  },
+  {
+    "name": "mainnet-02131-f1e474f0.erae",
+    "size": 829588451
+  },
+  {
+    "name": "mainnet-02132-106537df.erae",
+    "size": 803427537
+  },
+  {
+    "name": "mainnet-02133-e470fc61.erae",
+    "size": 809992629
+  },
+  {
+    "name": "mainnet-02134-fae52d89.erae",
+    "size": 800505457
+  },
+  {
+    "name": "mainnet-02135-907129a7.erae",
+    "size": 803063399
+  },
+  {
+    "name": "mainnet-02136-edb10732.erae",
+    "size": 749474312
+  },
+  {
+    "name": "mainnet-02137-13442167.erae",
+    "size": 734766709
+  },
+  {
+    "name": "mainnet-02138-0a353f11.erae",
+    "size": 796512317
+  },
+  {
+    "name": "mainnet-02139-023660e8.erae",
+    "size": 830033223
+  },
+  {
+    "name": "mainnet-02140-993f8d7e.erae",
+    "size": 788085456
+  },
+  {
+    "name": "mainnet-02141-32cba786.erae",
+    "size": 766316160
+  },
+  {
+    "name": "mainnet-02142-4d4a1a37.erae",
+    "size": 751518961
+  },
+  {
+    "name": "mainnet-02143-e32259e7.erae",
+    "size": 803156854
+  },
+  {
+    "name": "mainnet-02144-5ca3fc45.erae",
+    "size": 884483637
+  },
+  {
+    "name": "mainnet-02145-fdfe39f0.erae",
+    "size": 843549401
+  },
+  {
+    "name": "mainnet-02146-2d235b03.erae",
+    "size": 803799819
+  },
+  {
+    "name": "mainnet-02147-42153343.erae",
+    "size": 821937532
+  },
+  {
+    "name": "mainnet-02148-9efeb98b.erae",
+    "size": 750039496
+  },
+  {
+    "name": "mainnet-02149-4da24de3.erae",
+    "size": 834785338
+  },
+  {
+    "name": "mainnet-02150-292f809e.erae",
+    "size": 838730579
+  },
+  {
+    "name": "mainnet-02151-18b48084.erae",
+    "size": 577266097
+  },
+  {
+    "name": "mainnet-02152-3073b8e1.erae",
+    "size": 630396407
+  },
+  {
+    "name": "mainnet-02153-03102003.erae",
+    "size": 775200679
+  },
+  {
+    "name": "mainnet-02154-76081a3c.erae",
+    "size": 782169662
+  },
+  {
+    "name": "mainnet-02155-7904b466.erae",
+    "size": 816839739
+  },
+  {
+    "name": "mainnet-02156-56a0ca5e.erae",
+    "size": 855709595
+  },
+  {
+    "name": "mainnet-02157-67907f27.erae",
+    "size": 856355446
+  },
+  {
+    "name": "mainnet-02158-a636d01c.erae",
+    "size": 837295872
+  },
+  {
+    "name": "mainnet-02159-9a59522e.erae",
+    "size": 868741833
+  },
+  {
+    "name": "mainnet-02160-2075d097.erae",
+    "size": 832911051
+  },
+  {
+    "name": "mainnet-02161-05aafb78.erae",
+    "size": 806140641
+  },
+  {
+    "name": "mainnet-02162-482daa24.erae",
+    "size": 864336124
+  },
+  {
+    "name": "mainnet-02163-97d0013d.erae",
+    "size": 874289779
+  },
+  {
+    "name": "mainnet-02164-58a40017.erae",
+    "size": 876705171
+  },
+  {
+    "name": "mainnet-02165-5919fe74.erae",
+    "size": 782435502
+  },
+  {
+    "name": "mainnet-02166-070b7115.erae",
+    "size": 823114494
+  },
+  {
+    "name": "mainnet-02167-2cdbaaf7.erae",
+    "size": 822663348
+  },
+  {
+    "name": "mainnet-02168-2bce242c.erae",
+    "size": 879990295
+  },
+  {
+    "name": "mainnet-02169-6066cfb6.erae",
+    "size": 927107862
+  },
+  {
+    "name": "mainnet-02170-0098b10a.erae",
+    "size": 934038835
+  },
+  {
+    "name": "mainnet-02171-732f37ae.erae",
+    "size": 915898985
+  },
+  {
+    "name": "mainnet-02172-e3b2d052.erae",
+    "size": 869919383
+  },
+  {
+    "name": "mainnet-02173-09f754d2.erae",
+    "size": 952451563
+  },
+  {
+    "name": "mainnet-02174-b70af11c.erae",
+    "size": 962338300
+  },
+  {
+    "name": "mainnet-02175-a1d67ba1.erae",
+    "size": 887688120
+  },
+  {
+    "name": "mainnet-02176-17aeee31.erae",
+    "size": 899274770
+  },
+  {
+    "name": "mainnet-02177-b2fba185.erae",
+    "size": 1016180660
+  },
+  {
+    "name": "mainnet-02178-a5aca338.erae",
+    "size": 927911838
+  },
+  {
+    "name": "mainnet-02179-ea532cae.erae",
+    "size": 878390607
+  },
+  {
+    "name": "mainnet-02180-c8d7e6b5.erae",
+    "size": 975138873
+  },
+  {
+    "name": "mainnet-02181-0f9799d4.erae",
+    "size": 1005316165
+  },
+  {
+    "name": "mainnet-02182-87871bfd.erae",
+    "size": 973816501
+  },
+  {
+    "name": "mainnet-02183-483be915.erae",
+    "size": 983559030
+  },
+  {
+    "name": "mainnet-02184-dd5b5d37.erae",
+    "size": 905582413
+  },
+  {
+    "name": "mainnet-02185-ae5a9494.erae",
+    "size": 891276727
+  },
+  {
+    "name": "mainnet-02186-a81df879.erae",
+    "size": 975619020
+  },
+  {
+    "name": "mainnet-02187-45a4327a.erae",
+    "size": 1081600065
+  },
+  {
+    "name": "mainnet-02188-1ebe00d0.erae",
+    "size": 956483200
+  },
+  {
+    "name": "mainnet-02189-a33dae8d.erae",
+    "size": 964777856
+  },
+  {
+    "name": "mainnet-02190-8bb45570.erae",
+    "size": 944864716
+  },
+  {
+    "name": "mainnet-02191-80b8369b.erae",
+    "size": 959518703
+  },
+  {
+    "name": "mainnet-02192-e8597827.erae",
+    "size": 962419171
+  },
+  {
+    "name": "mainnet-02193-b172f77e.erae",
+    "size": 912216144
+  },
+  {
+    "name": "mainnet-02194-249d07c3.erae",
+    "size": 957913609
+  },
+  {
+    "name": "mainnet-02195-14f9930c.erae",
+    "size": 942521947
+  },
+  {
+    "name": "mainnet-02196-37f557f9.erae",
+    "size": 981909318
+  },
+  {
+    "name": "mainnet-02197-65d5430f.erae",
+    "size": 913875459
+  },
+  {
+    "name": "mainnet-02198-0f1a31a9.erae",
+    "size": 955326588
+  },
+  {
+    "name": "mainnet-02199-3ef7d6fc.erae",
+    "size": 931594823
+  },
+  {
+    "name": "mainnet-02200-e49c46ac.erae",
+    "size": 942444456
+  },
+  {
+    "name": "mainnet-02201-d9b9b72a.erae",
+    "size": 975996357
+  },
+  {
+    "name": "mainnet-02202-ef5206c4.erae",
+    "size": 906090293
+  },
+  {
+    "name": "mainnet-02203-18a8b8d8.erae",
+    "size": 906521436
+  },
+  {
+    "name": "mainnet-02204-b4843e01.erae",
+    "size": 937946236
+  },
+  {
+    "name": "mainnet-02205-15958ec5.erae",
+    "size": 917187504
+  },
+  {
+    "name": "mainnet-02206-d7de2fb4.erae",
+    "size": 975863073
+  },
+  {
+    "name": "mainnet-02207-2200d0e1.erae",
+    "size": 914748614
+  },
+  {
+    "name": "mainnet-02208-7a00cde5.erae",
+    "size": 940506864
+  },
+  {
+    "name": "mainnet-02209-72f5ec34.erae",
+    "size": 969515343
+  },
+  {
+    "name": "mainnet-02210-7142ee91.erae",
+    "size": 1048013573
+  },
+  {
+    "name": "mainnet-02211-1054383e.erae",
+    "size": 1037649224
+  },
+  {
+    "name": "mainnet-02212-402b6d64.erae",
+    "size": 1007173878
+  },
+  {
+    "name": "mainnet-02213-c20e4656.erae",
+    "size": 1085930570
+  },
+  {
+    "name": "mainnet-02214-c7ddee64.erae",
+    "size": 1030988230
+  },
+  {
+    "name": "mainnet-02215-7ca8c61e.erae",
+    "size": 1023848557
+  },
+  {
+    "name": "mainnet-02216-cfaf1fa7.erae",
+    "size": 1022888320
+  },
+  {
+    "name": "mainnet-02217-c4b4185d.erae",
+    "size": 1062570781
+  },
+  {
+    "name": "mainnet-02218-7c13dbd1.erae",
+    "size": 1037387453
+  },
+  {
+    "name": "mainnet-02219-9fcf794f.erae",
+    "size": 1018496523
+  },
+  {
+    "name": "mainnet-02220-95910be4.erae",
+    "size": 1000506627
+  },
+  {
+    "name": "mainnet-02221-c78a91c1.erae",
+    "size": 947264110
+  },
+  {
+    "name": "mainnet-02222-45101978.erae",
+    "size": 962020272
+  },
+  {
+    "name": "mainnet-02223-70261b5a.erae",
+    "size": 1056549233
+  },
+  {
+    "name": "mainnet-02224-c5314b48.erae",
+    "size": 1042333727
+  },
+  {
+    "name": "mainnet-02225-42e2b441.erae",
+    "size": 1091457293
+  },
+  {
+    "name": "mainnet-02226-263786a1.erae",
+    "size": 1033719831
+  },
+  {
+    "name": "mainnet-02227-e921ae4f.erae",
+    "size": 1058201466
+  },
+  {
+    "name": "mainnet-02228-d9bbca41.erae",
+    "size": 1020769043
+  },
+  {
+    "name": "mainnet-02229-8fcea3ec.erae",
+    "size": 994546669
+  },
+  {
+    "name": "mainnet-02230-5d074429.erae",
+    "size": 983276021
+  },
+  {
+    "name": "mainnet-02231-a5b8a1ac.erae",
+    "size": 1037386253
+  },
+  {
+    "name": "mainnet-02232-e3f820f2.erae",
+    "size": 991287228
+  },
+  {
+    "name": "mainnet-02233-503bf847.erae",
+    "size": 1000302255
+  },
+  {
+    "name": "mainnet-02234-27929d1c.erae",
+    "size": 971399424
+  },
+  {
+    "name": "mainnet-02235-b9aa5950.erae",
+    "size": 1016780881
+  },
+  {
+    "name": "mainnet-02236-6b0b7893.erae",
+    "size": 1042408516
+  },
+  {
+    "name": "mainnet-02237-69e01d5c.erae",
+    "size": 1034106370
+  },
+  {
+    "name": "mainnet-02238-051e3358.erae",
+    "size": 922382191
+  },
+  {
+    "name": "mainnet-02239-88ef8973.erae",
+    "size": 910198032
+  },
+  {
+    "name": "mainnet-02240-2e472dfa.erae",
+    "size": 873627998
+  },
+  {
+    "name": "mainnet-02241-f5ad7e69.erae",
+    "size": 931469947
+  },
+  {
+    "name": "mainnet-02242-fbd26b34.erae",
+    "size": 942882980
+  },
+  {
+    "name": "mainnet-02243-7962f322.erae",
+    "size": 945938968
+  },
+  {
+    "name": "mainnet-02244-74547827.erae",
+    "size": 948753885
+  },
+  {
+    "name": "mainnet-02245-fc67a355.erae",
+    "size": 904875481
+  },
+  {
+    "name": "mainnet-02246-b3c6d0e3.erae",
+    "size": 989314153
+  },
+  {
+    "name": "mainnet-02247-5d966b32.erae",
+    "size": 996240266
+  },
+  {
+    "name": "mainnet-02248-73f0a625.erae",
+    "size": 924444467
+  },
+  {
+    "name": "mainnet-02249-0f93fe8e.erae",
+    "size": 918270351
+  },
+  {
+    "name": "mainnet-02250-7cc3ac65.erae",
+    "size": 941500256
+  },
+  {
+    "name": "mainnet-02251-49835bdc.erae",
+    "size": 982694094
+  },
+  {
+    "name": "mainnet-02252-28f5ceb7.erae",
+    "size": 975566144
+  },
+  {
+    "name": "mainnet-02253-86d14311.erae",
+    "size": 958392183
+  },
+  {
+    "name": "mainnet-02254-f60a85cb.erae",
+    "size": 900870155
+  },
+  {
+    "name": "mainnet-02255-e6f64a3d.erae",
+    "size": 943949591
+  },
+  {
+    "name": "mainnet-02256-fc9c19a1.erae",
+    "size": 946952519
+  },
+  {
+    "name": "mainnet-02257-d4038020.erae",
+    "size": 999630633
+  },
+  {
+    "name": "mainnet-02258-f63f5e1e.erae",
+    "size": 1089907489
+  },
+  {
+    "name": "mainnet-02259-d76dd9eb.erae",
+    "size": 1078905853
+  },
+  {
+    "name": "mainnet-02260-bd4dca58.erae",
+    "size": 992936456
+  },
+  {
+    "name": "mainnet-02261-7c836afa.erae",
+    "size": 1036820237
+  },
+  {
+    "name": "mainnet-02262-5eb8681c.erae",
+    "size": 1009656236
+  },
+  {
+    "name": "mainnet-02263-418b2a55.erae",
+    "size": 875081707
+  },
+  {
+    "name": "mainnet-02264-81548a51.erae",
+    "size": 996319119
+  },
+  {
+    "name": "mainnet-02265-86a002fc.erae",
+    "size": 929823175
+  },
+  {
+    "name": "mainnet-02266-13db07c0.erae",
+    "size": 913023075
+  },
+  {
+    "name": "mainnet-02267-d441c6eb.erae",
+    "size": 952422987
+  },
+  {
+    "name": "mainnet-02268-ca74754c.erae",
+    "size": 958642365
+  },
+  {
+    "name": "mainnet-02269-3132c52e.erae",
+    "size": 1022254314
+  },
+  {
+    "name": "mainnet-02270-cb1d2cd3.erae",
+    "size": 1079824784
+  },
+  {
+    "name": "mainnet-02271-10d6ed58.erae",
+    "size": 1074622375
+  },
+  {
+    "name": "mainnet-02272-809bca18.erae",
+    "size": 1020679354
+  },
+  {
+    "name": "mainnet-02273-bb8a5c05.erae",
+    "size": 1013579136
+  },
+  {
+    "name": "mainnet-02274-7e292407.erae",
+    "size": 957854896
+  },
+  {
+    "name": "mainnet-02275-566d6829.erae",
+    "size": 1030410558
+  },
+  {
+    "name": "mainnet-02276-33b986c8.erae",
+    "size": 1239033801
+  },
+  {
+    "name": "mainnet-02277-53fc51f8.erae",
+    "size": 1125329853
+  },
+  {
+    "name": "mainnet-02278-28c2e9e2.erae",
+    "size": 976115681
+  },
+  {
+    "name": "mainnet-02279-aebed88c.erae",
+    "size": 925468486
+  },
+  {
+    "name": "mainnet-02280-988d527c.erae",
+    "size": 911103949
+  },
+  {
+    "name": "mainnet-02281-71b5c8ba.erae",
+    "size": 848010374
+  },
+  {
+    "name": "mainnet-02282-a035f54d.erae",
+    "size": 910336684
+  },
+  {
+    "name": "mainnet-02283-5025d438.erae",
+    "size": 953880819
+  },
+  {
+    "name": "mainnet-02284-abe1832b.erae",
+    "size": 988331815
+  },
+  {
+    "name": "mainnet-02285-2d9190f7.erae",
+    "size": 1046287455
+  },
+  {
+    "name": "mainnet-02286-7abb4512.erae",
+    "size": 986503123
+  },
+  {
+    "name": "mainnet-02287-dcd5f241.erae",
+    "size": 982173082
+  },
+  {
+    "name": "mainnet-02288-6f1056c1.erae",
+    "size": 1078359552
+  },
+  {
+    "name": "mainnet-02289-264a13a4.erae",
+    "size": 1022926666
+  },
+  {
+    "name": "mainnet-02290-6fcc67b0.erae",
+    "size": 1078594231
+  },
+  {
+    "name": "mainnet-02291-8355224a.erae",
+    "size": 1149959378
+  },
+  {
+    "name": "mainnet-02292-ad96b031.erae",
+    "size": 1083203906
+  },
+  {
+    "name": "mainnet-02293-c87405f1.erae",
+    "size": 1079717234
+  },
+  {
+    "name": "mainnet-02294-1b64ea75.erae",
+    "size": 1510110610
+  },
+  {
+    "name": "mainnet-02295-e959767d.erae",
+    "size": 1078209711
+  },
+  {
+    "name": "mainnet-02296-66c32b0f.erae",
+    "size": 1156096743
+  },
+  {
+    "name": "mainnet-02297-6e0a994d.erae",
+    "size": 1100357221
+  },
+  {
+    "name": "mainnet-02298-63eaae93.erae",
+    "size": 1069659693
+  },
+  {
+    "name": "mainnet-02299-6e6ca2d2.erae",
+    "size": 1061321848
+  },
+  {
+    "name": "mainnet-02300-6bd4252a.erae",
+    "size": 1131830195
+  },
+  {
+    "name": "mainnet-02301-0a03ee7b.erae",
+    "size": 1035557048
+  },
+  {
+    "name": "mainnet-02302-66e5e49a.erae",
+    "size": 982820343
+  },
+  {
+    "name": "mainnet-02303-91ff369b.erae",
+    "size": 1139350762
+  },
+  {
+    "name": "mainnet-02304-3700bcf2.erae",
+    "size": 1152141023
+  },
+  {
+    "name": "mainnet-02305-1dfb3d46.erae",
+    "size": 1043865082
+  },
+  {
+    "name": "mainnet-02306-4c67ad97.erae",
+    "size": 1090674370
+  },
+  {
+    "name": "mainnet-02307-9b88dbf9.erae",
+    "size": 1121237988
+  },
+  {
+    "name": "mainnet-02308-412f5d5e.erae",
+    "size": 1180893166
+  },
+  {
+    "name": "mainnet-02309-84181c81.erae",
+    "size": 1211135351
+  },
+  {
+    "name": "mainnet-02310-b9a71165.erae",
+    "size": 1102871665
+  },
+  {
+    "name": "mainnet-02311-16e9ad1d.erae",
+    "size": 1137267766
+  },
+  {
+    "name": "mainnet-02312-e26e8e86.erae",
+    "size": 1157268475
+  },
+  {
+    "name": "mainnet-02313-f28e9959.erae",
+    "size": 1209450701
+  },
+  {
+    "name": "mainnet-02314-c926ed55.erae",
+    "size": 1131969687
+  },
+  {
+    "name": "mainnet-02315-586a39d8.erae",
+    "size": 1106421157
+  },
+  {
+    "name": "mainnet-02316-c2670f48.erae",
+    "size": 1034909437
+  },
+  {
+    "name": "mainnet-02317-418d54a4.erae",
+    "size": 1078282214
+  },
+  {
+    "name": "mainnet-02318-9b7f2a4c.erae",
+    "size": 1117626693
+  },
+  {
+    "name": "mainnet-02319-92d7d598.erae",
+    "size": 1020563636
+  },
+  {
+    "name": "mainnet-02320-d8acb971.erae",
+    "size": 1101246385
+  },
+  {
+    "name": "mainnet-02321-bed782ec.erae",
+    "size": 1036173300
+  },
+  {
+    "name": "mainnet-02322-42d6f694.erae",
+    "size": 957259933
+  },
+  {
+    "name": "mainnet-02323-2ac583ed.erae",
+    "size": 902402112
+  },
+  {
+    "name": "mainnet-02324-2dedc2ae.erae",
+    "size": 1043816237
+  },
+  {
+    "name": "mainnet-02325-40cab436.erae",
+    "size": 1050643675
+  },
+  {
+    "name": "mainnet-02326-92e45545.erae",
+    "size": 1066391605
+  },
+  {
+    "name": "mainnet-02327-08893145.erae",
+    "size": 1086445963
+  },
+  {
+    "name": "mainnet-02328-9f131946.erae",
+    "size": 1092064855
+  },
+  {
+    "name": "mainnet-02329-d02c8b63.erae",
+    "size": 1032857928
+  },
+  {
+    "name": "mainnet-02330-520c2dfb.erae",
+    "size": 1038462804
+  },
+  {
+    "name": "mainnet-02331-19553270.erae",
+    "size": 1050246055
+  },
+  {
+    "name": "mainnet-02332-7e962050.erae",
+    "size": 1135265871
+  },
+  {
+    "name": "mainnet-02333-da54221b.erae",
+    "size": 1109046863
+  },
+  {
+    "name": "mainnet-02334-046088bc.erae",
+    "size": 1146076101
+  },
+  {
+    "name": "mainnet-02335-5efebe8c.erae",
+    "size": 1031735088
+  },
+  {
+    "name": "mainnet-02336-82013989.erae",
+    "size": 990363629
+  },
+  {
+    "name": "mainnet-02337-2a158e34.erae",
+    "size": 1029649193
+  },
+  {
+    "name": "mainnet-02338-75acb7de.erae",
+    "size": 1082300740
+  },
+  {
+    "name": "mainnet-02339-1bd52d1b.erae",
+    "size": 1108276756
+  },
+  {
+    "name": "mainnet-02340-8c1c4e46.erae",
+    "size": 1009095284
+  },
+  {
+    "name": "mainnet-02341-7f54dd99.erae",
+    "size": 907701638
+  },
+  {
+    "name": "mainnet-02342-3c4b586f.erae",
+    "size": 806624061
+  },
+  {
+    "name": "mainnet-02343-2b9b2bd6.erae",
+    "size": 890282234
+  },
+  {
+    "name": "mainnet-02344-aa57f702.erae",
+    "size": 974445062
+  },
+  {
+    "name": "mainnet-02345-afac15bb.erae",
+    "size": 1138565347
+  },
+  {
+    "name": "mainnet-02346-4491214e.erae",
+    "size": 1232826745
+  },
+  {
+    "name": "mainnet-02347-748071a5.erae",
+    "size": 1148840173
+  },
+  {
+    "name": "mainnet-02348-695bd63d.erae",
+    "size": 1074261765
+  },
+  {
+    "name": "mainnet-02349-51b8d32c.erae",
+    "size": 1148214138
+  },
+  {
+    "name": "mainnet-02350-0bd84c1d.erae",
+    "size": 1170986753
+  },
+  {
+    "name": "mainnet-02351-16bf7ba4.erae",
+    "size": 1131064117
+  },
+  {
+    "name": "mainnet-02352-4e754846.erae",
+    "size": 1361475714
+  },
+  {
+    "name": "mainnet-02353-2d2be2d0.erae",
+    "size": 1253554824
+  },
+  {
+    "name": "mainnet-02354-71dd646f.erae",
+    "size": 1153120667
+  },
+  {
+    "name": "mainnet-02355-ff4ba0a3.erae",
+    "size": 1288540290
+  },
+  {
+    "name": "mainnet-02356-85bf0f50.erae",
+    "size": 1295778344
+  },
+  {
+    "name": "mainnet-02357-f6909941.erae",
+    "size": 1229917052
+  },
+  {
+    "name": "mainnet-02358-394d342a.erae",
+    "size": 1272320874
+  },
+  {
+    "name": "mainnet-02359-83a6d85f.erae",
+    "size": 1270130840
+  },
+  {
+    "name": "mainnet-02360-b3565ebc.erae",
+    "size": 1299995106
+  },
+  {
+    "name": "mainnet-02361-cea1ffb2.erae",
+    "size": 1205053942
+  },
+  {
+    "name": "mainnet-02362-12d87170.erae",
+    "size": 1192088974
+  },
+  {
+    "name": "mainnet-02363-d5dfe58a.erae",
+    "size": 1031058101
+  },
+  {
+    "name": "mainnet-02364-439ee557.erae",
+    "size": 1128355296
+  },
+  {
+    "name": "mainnet-02365-e64e7793.erae",
+    "size": 1062088743
+  },
+  {
+    "name": "mainnet-02366-8f183a11.erae",
+    "size": 1029734808
+  },
+  {
+    "name": "mainnet-02367-6bc1ea9b.erae",
+    "size": 1079738382
+  },
+  {
+    "name": "mainnet-02368-8efeb9be.erae",
+    "size": 1017396444
+  },
+  {
+    "name": "mainnet-02369-dba5a870.erae",
+    "size": 996445185
+  },
+  {
+    "name": "mainnet-02370-dcd050cf.erae",
+    "size": 1047280294
+  },
+  {
+    "name": "mainnet-02371-f4c742e6.erae",
+    "size": 967091886
+  },
+  {
+    "name": "mainnet-02372-f6f06f62.erae",
+    "size": 739462019
+  },
+  {
+    "name": "mainnet-02373-fe2859b5.erae",
+    "size": 719343804
+  },
+  {
+    "name": "mainnet-02374-30217d21.erae",
+    "size": 762179660
+  },
+  {
+    "name": "mainnet-02375-c371bc89.erae",
+    "size": 745754452
+  },
+  {
+    "name": "mainnet-02376-80333263.erae",
+    "size": 741717433
+  },
+  {
+    "name": "mainnet-02377-f26bef54.erae",
+    "size": 732805115
+  },
+  {
+    "name": "mainnet-02378-72d27db0.erae",
+    "size": 768795065
+  },
+  {
+    "name": "mainnet-02379-9a1b6123.erae",
+    "size": 767790294
+  },
+  {
+    "name": "mainnet-02380-85641868.erae",
+    "size": 798454061
+  },
+  {
+    "name": "mainnet-02381-04cca457.erae",
+    "size": 756197582
+  },
+  {
+    "name": "mainnet-02382-46c94133.erae",
+    "size": 673166800
+  },
+  {
+    "name": "mainnet-02383-83033e1d.erae",
+    "size": 656512971
+  },
+  {
+    "name": "mainnet-02384-69f57e4d.erae",
+    "size": 683411251
+  },
+  {
+    "name": "mainnet-02385-be9a22cd.erae",
+    "size": 676881108
+  },
+  {
+    "name": "mainnet-02386-6e10573e.erae",
+    "size": 663237491
+  },
+  {
+    "name": "mainnet-02387-8a26ea04.erae",
+    "size": 626959231
+  },
+  {
+    "name": "mainnet-02388-502c5a91.erae",
+    "size": 637882783
+  },
+  {
+    "name": "mainnet-02389-a8b94460.erae",
+    "size": 618027153
+  },
+  {
+    "name": "mainnet-02390-c18e93e5.erae",
+    "size": 613841138
+  },
+  {
+    "name": "mainnet-02391-4c831129.erae",
+    "size": 626196608
+  },
+  {
+    "name": "mainnet-02392-556c3c25.erae",
+    "size": 652032749
+  },
+  {
+    "name": "mainnet-02393-250af625.erae",
+    "size": 643799929
+  },
+  {
+    "name": "mainnet-02394-957acc23.erae",
+    "size": 619112266
+  },
+  {
+    "name": "mainnet-02395-8018d672.erae",
+    "size": 652218962
+  },
+  {
+    "name": "mainnet-02396-e324029e.erae",
+    "size": 650178363
+  },
+  {
+    "name": "mainnet-02397-d0e46d51.erae",
+    "size": 626385147
+  },
+  {
+    "name": "mainnet-02398-29caaeae.erae",
+    "size": 632271015
+  },
+  {
+    "name": "mainnet-02399-333276bd.erae",
+    "size": 644783182
+  },
+  {
+    "name": "mainnet-02400-56ad5d1a.erae",
+    "size": 630956823
+  },
+  {
+    "name": "mainnet-02401-fd87d6eb.erae",
+    "size": 604692736
+  },
+  {
+    "name": "mainnet-02402-d27d694e.erae",
+    "size": 609995660
+  },
+  {
+    "name": "mainnet-02403-cbca92c4.erae",
+    "size": 613771918
+  },
+  {
+    "name": "mainnet-02404-c066d363.erae",
+    "size": 596478265
+  },
+  {
+    "name": "mainnet-02405-6451de5a.erae",
+    "size": 614598074
+  },
+  {
+    "name": "mainnet-02406-8fb82bed.erae",
+    "size": 602354402
+  },
+  {
+    "name": "mainnet-02407-eff3d0e7.erae",
+    "size": 599800439
+  },
+  {
+    "name": "mainnet-02408-e25c0285.erae",
+    "size": 619425892
+  },
+  {
+    "name": "mainnet-02409-c5c3c0a1.erae",
+    "size": 609250468
+  },
+  {
+    "name": "mainnet-02410-18d3c8b2.erae",
+    "size": 578610195
+  },
+  {
+    "name": "mainnet-02411-2b1dd3b9.erae",
+    "size": 575536026
+  },
+  {
+    "name": "mainnet-02412-4d8e3945.erae",
+    "size": 543742374
+  },
+  {
+    "name": "mainnet-02413-9bad7a68.erae",
+    "size": 611638648
+  },
+  {
+    "name": "mainnet-02414-a6cdcede.erae",
+    "size": 639338781
+  },
+  {
+    "name": "mainnet-02415-959f43ea.erae",
+    "size": 585668689
+  },
+  {
+    "name": "mainnet-02416-fa3b1b4b.erae",
+    "size": 602019754
+  },
+  {
+    "name": "mainnet-02417-fec8f0fc.erae",
+    "size": 572933028
+  },
+  {
+    "name": "mainnet-02418-3fd55c12.erae",
+    "size": 599347865
+  },
+  {
+    "name": "mainnet-02419-2b6fd29b.erae",
+    "size": 627879805
+  },
+  {
+    "name": "mainnet-02420-e756b5ea.erae",
+    "size": 592092161
+  },
+  {
+    "name": "mainnet-02421-49134409.erae",
+    "size": 621678774
+  },
+  {
+    "name": "mainnet-02422-90607089.erae",
+    "size": 620629054
+  },
+  {
+    "name": "mainnet-02423-9ec19f93.erae",
+    "size": 540061416
+  },
+  {
+    "name": "mainnet-02424-187c114c.erae",
+    "size": 581408394
+  },
+  {
+    "name": "mainnet-02425-742f6f3d.erae",
+    "size": 620741302
+  },
+  {
+    "name": "mainnet-02426-5bdff4fc.erae",
+    "size": 613252167
+  },
+  {
+    "name": "mainnet-02427-f2339609.erae",
+    "size": 584877658
+  },
+  {
+    "name": "mainnet-02428-36e23215.erae",
+    "size": 593673110
+  },
+  {
+    "name": "mainnet-02429-2ad20c7d.erae",
+    "size": 575526991
+  },
+  {
+    "name": "mainnet-02430-06427328.erae",
+    "size": 572652457
+  },
+  {
+    "name": "mainnet-02431-a9731e8f.erae",
+    "size": 589671756
+  },
+  {
+    "name": "mainnet-02432-6879b968.erae",
+    "size": 576498030
+  },
+  {
+    "name": "mainnet-02433-8c84570c.erae",
+    "size": 589418604
+  },
+  {
+    "name": "mainnet-02434-1e5d96b7.erae",
+    "size": 577789002
+  },
+  {
+    "name": "mainnet-02435-75329e6b.erae",
+    "size": 557410545
+  },
+  {
+    "name": "mainnet-02436-68d5afa8.erae",
+    "size": 552083945
+  },
+  {
+    "name": "mainnet-02437-4b9c398d.erae",
+    "size": 435474922
+  },
+  {
+    "name": "mainnet-02438-809ae891.erae",
+    "size": 466393928
+  },
+  {
+    "name": "mainnet-02439-30c90562.erae",
+    "size": 470576077
+  },
+  {
+    "name": "mainnet-02440-40265799.erae",
+    "size": 479498910
+  },
+  {
+    "name": "mainnet-02441-a76a4fa0.erae",
+    "size": 477882771
+  },
+  {
+    "name": "mainnet-02442-f8f9f2a4.erae",
+    "size": 460297405
+  },
+  {
+    "name": "mainnet-02443-9a8bdf3f.erae",
+    "size": 476985250
+  },
+  {
+    "name": "mainnet-02444-0f212dbd.erae",
+    "size": 460979226
+  },
+  {
+    "name": "mainnet-02445-82fe1b49.erae",
+    "size": 458542093
+  },
+  {
+    "name": "mainnet-02446-a6de8d8c.erae",
+    "size": 494838470
+  },
+  {
+    "name": "mainnet-02447-61c03345.erae",
+    "size": 490462326
+  },
+  {
+    "name": "mainnet-02448-2ac540f1.erae",
+    "size": 470440374
+  },
+  {
+    "name": "mainnet-02449-4f32e4a6.erae",
+    "size": 471443307
+  },
+  {
+    "name": "mainnet-02450-d667b7f3.erae",
+    "size": 491827180
+  },
+  {
+    "name": "mainnet-02451-e0412be8.erae",
+    "size": 509189803
+  },
+  {
+    "name": "mainnet-02452-c3ef5f67.erae",
+    "size": 520611137
+  },
+  {
+    "name": "mainnet-02453-b7a0021d.erae",
+    "size": 485754086
+  },
+  {
+    "name": "mainnet-02454-394d1a2b.erae",
+    "size": 485427667
+  },
+  {
+    "name": "mainnet-02455-30e210b8.erae",
+    "size": 483949138
+  },
+  {
+    "name": "mainnet-02456-8e357791.erae",
+    "size": 505389145
+  },
+  {
+    "name": "mainnet-02457-ba610558.erae",
+    "size": 569759851
+  },
+  {
+    "name": "mainnet-02458-5c91496c.erae",
+    "size": 483997399
+  },
+  {
+    "name": "mainnet-02459-cb878a83.erae",
+    "size": 467836722
+  },
+  {
+    "name": "mainnet-02460-cc7ef47b.erae",
+    "size": 501596668
+  },
+  {
+    "name": "mainnet-02461-0bd14752.erae",
+    "size": 487509358
+  },
+  {
+    "name": "mainnet-02462-f602fcb6.erae",
+    "size": 483575644
+  },
+  {
+    "name": "mainnet-02463-eb13c6b0.erae",
+    "size": 491964616
+  },
+  {
+    "name": "mainnet-02464-bc6f72e2.erae",
+    "size": 483308911
+  },
+  {
+    "name": "mainnet-02465-b4925062.erae",
+    "size": 492075475
+  },
+  {
+    "name": "mainnet-02466-d7f7d8d2.erae",
+    "size": 457157367
+  },
+  {
+    "name": "mainnet-02467-01174163.erae",
+    "size": 465252124
+  },
+  {
+    "name": "mainnet-02468-7eac3439.erae",
+    "size": 470902671
+  },
+  {
+    "name": "mainnet-02469-42b7c2e3.erae",
+    "size": 473286313
+  },
+  {
+    "name": "mainnet-02470-76e86601.erae",
+    "size": 493043473
+  },
+  {
+    "name": "mainnet-02471-28f97e3f.erae",
+    "size": 479348357
+  },
+  {
+    "name": "mainnet-02472-a66e18f8.erae",
+    "size": 447961688
+  },
+  {
+    "name": "mainnet-02473-f1c2d287.erae",
+    "size": 480119809
+  },
+  {
+    "name": "mainnet-02474-54e3a26d.erae",
+    "size": 456932336
+  },
+  {
+    "name": "mainnet-02475-8e161d25.erae",
+    "size": 464783833
+  },
+  {
+    "name": "mainnet-02476-53827e77.erae",
+    "size": 461024685
+  },
+  {
+    "name": "mainnet-02477-05df84e0.erae",
+    "size": 449515463
+  },
+  {
+    "name": "mainnet-02478-a590577c.erae",
+    "size": 454308107
+  },
+  {
+    "name": "mainnet-02479-97ec5c9b.erae",
+    "size": 477048558
+  },
+  {
+    "name": "mainnet-02480-2ec68927.erae",
+    "size": 472020777
+  },
+  {
+    "name": "mainnet-02481-3fd5a401.erae",
+    "size": 476283890
+  },
+  {
+    "name": "mainnet-02482-502dd9d7.erae",
+    "size": 467002546
+  },
+  {
+    "name": "mainnet-02483-68562b35.erae",
+    "size": 465834409
+  },
+  {
+    "name": "mainnet-02484-a29977f9.erae",
+    "size": 456521853
+  },
+  {
+    "name": "mainnet-02485-0cee2a5a.erae",
+    "size": 461597041
+  },
+  {
+    "name": "mainnet-02486-f35595fc.erae",
+    "size": 477670792
+  },
+  {
+    "name": "mainnet-02487-12bb2a92.erae",
+    "size": 471824210
+  },
+  {
+    "name": "mainnet-02488-cab10523.erae",
+    "size": 474909124
+  },
+  {
+    "name": "mainnet-02489-7da695cc.erae",
+    "size": 452318716
+  },
+  {
+    "name": "mainnet-02490-b151eedc.erae",
+    "size": 440500811
+  },
+  {
+    "name": "mainnet-02491-3c5f802d.erae",
+    "size": 465916975
+  },
+  {
+    "name": "mainnet-02492-bfebfbd4.erae",
+    "size": 474590196
+  },
+  {
+    "name": "mainnet-02493-b801caf8.erae",
+    "size": 474061121
+  },
+  {
+    "name": "mainnet-02494-ee48c2a7.erae",
+    "size": 469263909
+  },
+  {
+    "name": "mainnet-02495-388db4b1.erae",
+    "size": 471126807
+  },
+  {
+    "name": "mainnet-02496-028aa85f.erae",
+    "size": 444208807
+  },
+  {
+    "name": "mainnet-02497-11630a07.erae",
+    "size": 478452640
+  },
+  {
+    "name": "mainnet-02498-f581524a.erae",
+    "size": 487472322
+  },
+  {
+    "name": "mainnet-02499-43838cb0.erae",
+    "size": 474811399
+  },
+  {
+    "name": "mainnet-02500-73f28496.erae",
+    "size": 459335785
+  },
+  {
+    "name": "mainnet-02501-a9d215cf.erae",
+    "size": 451187433
+  },
+  {
+    "name": "mainnet-02502-8ed60239.erae",
+    "size": 423300796
+  },
+  {
+    "name": "mainnet-02503-e2140c60.erae",
+    "size": 444003347
+  },
+  {
+    "name": "mainnet-02504-fd05c67e.erae",
+    "size": 462119081
+  },
+  {
+    "name": "mainnet-02505-56742f29.erae",
+    "size": 466297456
+  },
+  {
+    "name": "mainnet-02506-c194052c.erae",
+    "size": 470461777
+  },
+  {
+    "name": "mainnet-02507-2502625b.erae",
+    "size": 477706909
+  },
+  {
+    "name": "mainnet-02508-79e540a4.erae",
+    "size": 427329708
+  },
+  {
+    "name": "mainnet-02509-cc85d002.erae",
+    "size": 514441127
+  },
+  {
+    "name": "mainnet-02510-d26ea10b.erae",
+    "size": 507812073
+  },
+  {
+    "name": "mainnet-02511-c7a7e024.erae",
+    "size": 467235067
+  },
+  {
+    "name": "mainnet-02512-a8c9b44c.erae",
+    "size": 480531778
+  },
+  {
+    "name": "mainnet-02513-8b105490.erae",
+    "size": 500367825
+  },
+  {
+    "name": "mainnet-02514-f52a160b.erae",
+    "size": 456148482
+  },
+  {
+    "name": "mainnet-02515-9b2a8859.erae",
+    "size": 469084856
+  },
+  {
+    "name": "mainnet-02516-44a56bc9.erae",
+    "size": 480472617
+  },
+  {
+    "name": "mainnet-02517-b4532395.erae",
+    "size": 478561534
+  },
+  {
+    "name": "mainnet-02518-765d5ab1.erae",
+    "size": 471390212
+  },
+  {
+    "name": "mainnet-02519-926fcfb0.erae",
+    "size": 467484842
+  },
+  {
+    "name": "mainnet-02520-6690af11.erae",
+    "size": 461722578
+  },
+  {
+    "name": "mainnet-02521-a5e2e755.erae",
+    "size": 412732388
+  },
+  {
+    "name": "mainnet-02522-18847e78.erae",
+    "size": 422819856
+  },
+  {
+    "name": "mainnet-02523-39fc4c45.erae",
+    "size": 460219728
+  },
+  {
+    "name": "mainnet-02524-cab2accb.erae",
+    "size": 436470706
+  },
+  {
+    "name": "mainnet-02525-ad2b32ea.erae",
+    "size": 450928027
+  },
+  {
+    "name": "mainnet-02526-4ace7fd6.erae",
+    "size": 459717846
+  },
+  {
+    "name": "mainnet-02527-9e8015b2.erae",
+    "size": 444886549
+  },
+  {
+    "name": "mainnet-02528-ea6d7f26.erae",
+    "size": 450069945
+  },
+  {
+    "name": "mainnet-02529-e251826e.erae",
+    "size": 455925037
+  },
+  {
+    "name": "mainnet-02530-07fb188b.erae",
+    "size": 462712183
+  },
+  {
+    "name": "mainnet-02531-f2696a34.erae",
+    "size": 464480744
+  },
+  {
+    "name": "mainnet-02532-a4c8878b.erae",
+    "size": 476311453
+  },
+  {
+    "name": "mainnet-02533-7fe638fe.erae",
+    "size": 443865093
+  },
+  {
+    "name": "mainnet-02534-b040ff36.erae",
+    "size": 475821264
+  },
+  {
+    "name": "mainnet-02535-539a6e16.erae",
+    "size": 486881259
+  },
+  {
+    "name": "mainnet-02536-d820dd41.erae",
+    "size": 457808485
+  },
+  {
+    "name": "mainnet-02537-0e99bd04.erae",
+    "size": 457290782
+  },
+  {
+    "name": "mainnet-02538-dc13b963.erae",
+    "size": 444977816
+  },
+  {
+    "name": "mainnet-02539-0d2af953.erae",
+    "size": 451552244
+  },
+  {
+    "name": "mainnet-02540-7f2f1cc4.erae",
+    "size": 443618799
+  },
+  {
+    "name": "mainnet-02541-2ec4e876.erae",
+    "size": 440079655
+  },
+  {
+    "name": "mainnet-02542-714a1454.erae",
+    "size": 446616009
+  },
+  {
+    "name": "mainnet-02543-328ffafb.erae",
+    "size": 461016573
+  },
+  {
+    "name": "mainnet-02544-6b2f8688.erae",
+    "size": 478760340
+  },
+  {
+    "name": "mainnet-02545-159d6ef9.erae",
+    "size": 501678147
+  },
+  {
+    "name": "mainnet-02546-a99e0826.erae",
+    "size": 477336363
+  },
+  {
+    "name": "mainnet-02547-b16db3c8.erae",
+    "size": 485384033
+  },
+  {
+    "name": "mainnet-02548-a659ad4f.erae",
+    "size": 498637353
+  },
+  {
+    "name": "mainnet-02549-40f9fc19.erae",
+    "size": 524053892
+  },
+  {
+    "name": "mainnet-02550-a7c28bda.erae",
+    "size": 509505393
+  },
+  {
+    "name": "mainnet-02551-f89102d9.erae",
+    "size": 464102436
+  },
+  {
+    "name": "mainnet-02552-3295f963.erae",
+    "size": 461443738
+  },
+  {
+    "name": "mainnet-02553-c0eebf3c.erae",
+    "size": 458595909
+  },
+  {
+    "name": "mainnet-02554-d88aca02.erae",
+    "size": 452633344
+  },
+  {
+    "name": "mainnet-02555-6dccf6df.erae",
+    "size": 462754393
+  },
+  {
+    "name": "mainnet-02556-f16d98f6.erae",
+    "size": 453882367
+  },
+  {
+    "name": "mainnet-02557-ab9da2ba.erae",
+    "size": 475131783
+  },
+  {
+    "name": "mainnet-02558-d7582831.erae",
+    "size": 461278224
+  },
+  {
+    "name": "mainnet-02559-634981a4.erae",
+    "size": 478766223
+  },
+  {
+    "name": "mainnet-02560-a7ebac9c.erae",
+    "size": 478475447
+  },
+  {
+    "name": "mainnet-02561-dc403d69.erae",
+    "size": 469764101
+  },
+  {
+    "name": "mainnet-02562-f18f1dad.erae",
+    "size": 458501849
+  },
+  {
+    "name": "mainnet-02563-b8eeed0b.erae",
+    "size": 482130400
+  },
+  {
+    "name": "mainnet-02564-1a5f9380.erae",
+    "size": 483385802
+  },
+  {
+    "name": "mainnet-02565-ebdf761d.erae",
+    "size": 497277069
+  },
+  {
+    "name": "mainnet-02566-5ff039d2.erae",
+    "size": 473396626
+  },
+  {
+    "name": "mainnet-02567-114f96a2.erae",
+    "size": 455093707
+  },
+  {
+    "name": "mainnet-02568-0731d23d.erae",
+    "size": 480128136
+  },
+  {
+    "name": "mainnet-02569-f0725518.erae",
+    "size": 462931109
+  },
+  {
+    "name": "mainnet-02570-098f5859.erae",
+    "size": 414666512
+  },
+  {
+    "name": "mainnet-02571-87eb10cb.erae",
+    "size": 438265894
+  },
+  {
+    "name": "mainnet-02572-bf069610.erae",
+    "size": 462900847
+  },
+  {
+    "name": "mainnet-02573-da81c883.erae",
+    "size": 445148066
+  },
+  {
+    "name": "mainnet-02574-8e50adf5.erae",
+    "size": 448483611
+  },
+  {
+    "name": "mainnet-02575-cbafb38a.erae",
+    "size": 453457919
+  },
+  {
+    "name": "mainnet-02576-799def81.erae",
+    "size": 468871619
+  },
+  {
+    "name": "mainnet-02577-dac9ce11.erae",
+    "size": 522545244
+  },
+  {
+    "name": "mainnet-02578-27d720c4.erae",
+    "size": 473999755
+  },
+  {
+    "name": "mainnet-02579-ae477e9a.erae",
+    "size": 484967468
+  },
+  {
+    "name": "mainnet-02580-1a246716.erae",
+    "size": 486278861
+  },
+  {
+    "name": "mainnet-02581-e1db4363.erae",
+    "size": 484900815
+  },
+  {
+    "name": "mainnet-02582-363d7e55.erae",
+    "size": 486243417
+  },
+  {
+    "name": "mainnet-02583-3f4824fa.erae",
+    "size": 485120817
+  },
+  {
+    "name": "mainnet-02584-3a6ac59d.erae",
+    "size": 487511112
+  },
+  {
+    "name": "mainnet-02585-10bd4f57.erae",
+    "size": 480909187
+  },
+  {
+    "name": "mainnet-02586-b096b70d.erae",
+    "size": 478484505
+  },
+  {
+    "name": "mainnet-02587-7235dce6.erae",
+    "size": 483353448
+  },
+  {
+    "name": "mainnet-02588-968286ac.erae",
+    "size": 486809449
+  },
+  {
+    "name": "mainnet-02589-d085dda6.erae",
+    "size": 501970694
+  },
+  {
+    "name": "mainnet-02590-28164234.erae",
+    "size": 492664725
+  },
+  {
+    "name": "mainnet-02591-928c41ad.erae",
+    "size": 487821147
+  },
+  {
+    "name": "mainnet-02592-f410f401.erae",
+    "size": 486501517
+  },
+  {
+    "name": "mainnet-02593-3aa67758.erae",
+    "size": 500230571
+  },
+  {
+    "name": "mainnet-02594-2c5e73a6.erae",
+    "size": 492508315
+  },
+  {
+    "name": "mainnet-02595-263066b2.erae",
+    "size": 498977717
+  },
+  {
+    "name": "mainnet-02596-da6d8a07.erae",
+    "size": 497007429
+  },
+  {
+    "name": "mainnet-02597-61de5b89.erae",
+    "size": 496352973
+  },
+  {
+    "name": "mainnet-02598-a906f181.erae",
+    "size": 505832533
+  },
+  {
+    "name": "mainnet-02599-01e7a40e.erae",
+    "size": 499299061
+  },
+  {
+    "name": "mainnet-02600-423019aa.erae",
+    "size": 493573061
+  },
+  {
+    "name": "mainnet-02601-b52a6e59.erae",
+    "size": 505909646
+  },
+  {
+    "name": "mainnet-02602-e8cb00b6.erae",
+    "size": 503350783
+  },
+  {
+    "name": "mainnet-02603-9a43d541.erae",
+    "size": 503203382
+  },
+  {
+    "name": "mainnet-02604-f1e63464.erae",
+    "size": 501525356
+  },
+  {
+    "name": "mainnet-02605-0f102e49.erae",
+    "size": 502681266
+  },
+  {
+    "name": "mainnet-02606-fac4c205.erae",
+    "size": 519471703
+  },
+  {
+    "name": "mainnet-02607-fdab8d9c.erae",
+    "size": 520245864
+  },
+  {
+    "name": "mainnet-02608-421a01ea.erae",
+    "size": 513987163
+  },
+  {
+    "name": "mainnet-02609-8901e78f.erae",
+    "size": 503679804
+  },
+  {
+    "name": "mainnet-02610-f3537a7c.erae",
+    "size": 509880222
+  },
+  {
+    "name": "mainnet-02611-3abc49c0.erae",
+    "size": 491164185
+  },
+  {
+    "name": "mainnet-02612-3611babd.erae",
+    "size": 529459089
+  },
+  {
+    "name": "mainnet-02613-5885fe60.erae",
+    "size": 510167920
+  },
+  {
+    "name": "mainnet-02614-4a069493.erae",
+    "size": 516428677
+  },
+  {
+    "name": "mainnet-02615-f18bc285.erae",
+    "size": 538212817
+  },
+  {
+    "name": "mainnet-02616-6db7c7a3.erae",
+    "size": 509622728
+  },
+  {
+    "name": "mainnet-02617-a3bd935f.erae",
+    "size": 514906422
+  },
+  {
+    "name": "mainnet-02618-816f4065.erae",
+    "size": 499070784
+  },
+  {
+    "name": "mainnet-02619-5d0b12b7.erae",
+    "size": 498770048
+  },
+  {
+    "name": "mainnet-02620-564c6a1f.erae",
+    "size": 497095225
+  },
+  {
+    "name": "mainnet-02621-335138e7.erae",
+    "size": 490947681
+  },
+  {
+    "name": "mainnet-02622-da3475ae.erae",
+    "size": 482731189
+  },
+  {
+    "name": "mainnet-02623-67244f90.erae",
+    "size": 507239943
+  },
+  {
+    "name": "mainnet-02624-31a8b96b.erae",
+    "size": 498882512
+  },
+  {
+    "name": "mainnet-02625-c80c839d.erae",
+    "size": 500312696
+  },
+  {
+    "name": "mainnet-02626-bc5d6045.erae",
+    "size": 528011431
+  },
+  {
+    "name": "mainnet-02627-e4b46ced.erae",
+    "size": 503245309
+  },
+  {
+    "name": "mainnet-02628-823101ce.erae",
+    "size": 412087634
+  },
+  {
+    "name": "mainnet-02629-107d547e.erae",
+    "size": 492261305
+  },
+  {
+    "name": "mainnet-02630-3b6d68c2.erae",
+    "size": 480535189
+  },
+  {
+    "name": "mainnet-02631-74aed27b.erae",
+    "size": 483612816
+  },
+  {
+    "name": "mainnet-02632-205a92f9.erae",
+    "size": 492887658
+  },
+  {
+    "name": "mainnet-02633-27810753.erae",
+    "size": 499384141
+  },
+  {
+    "name": "mainnet-02634-efd83c80.erae",
+    "size": 514625650
+  },
+  {
+    "name": "mainnet-02635-eecfa5f4.erae",
+    "size": 490232358
+  },
+  {
+    "name": "mainnet-02636-39396dc5.erae",
+    "size": 498210785
+  },
+  {
+    "name": "mainnet-02637-36012d4d.erae",
+    "size": 482198261
+  },
+  {
+    "name": "mainnet-02638-0ec91858.erae",
+    "size": 502665535
+  },
+  {
+    "name": "mainnet-02639-7beae1a8.erae",
+    "size": 489134310
+  },
+  {
+    "name": "mainnet-02640-a92a6475.erae",
+    "size": 508407315
+  },
+  {
+    "name": "mainnet-02641-d3946e54.erae",
+    "size": 549103275
+  },
+  {
+    "name": "mainnet-02642-cc12a939.erae",
+    "size": 507398861
+  },
+  {
+    "name": "mainnet-02643-91e3fe38.erae",
+    "size": 506770449
+  },
+  {
+    "name": "mainnet-02644-7121f2ee.erae",
+    "size": 500351710
+  },
+  {
+    "name": "mainnet-02645-609bfa82.erae",
+    "size": 495640891
+  },
+  {
+    "name": "mainnet-02646-73667f43.erae",
+    "size": 506987229
+  },
+  {
+    "name": "mainnet-02647-5eaa3c53.erae",
+    "size": 514549245
+  },
+  {
+    "name": "mainnet-02648-615be141.erae",
+    "size": 532804103
+  },
+  {
+    "name": "mainnet-02649-5583c797.erae",
+    "size": 511925067
+  },
+  {
+    "name": "mainnet-02650-b1ab366f.erae",
+    "size": 514375393
+  },
+  {
+    "name": "mainnet-02651-60e333ba.erae",
+    "size": 549978051
+  },
+  {
+    "name": "mainnet-02652-37d48208.erae",
+    "size": 503471590
+  },
+  {
+    "name": "mainnet-02653-478f0404.erae",
+    "size": 493391166
+  },
+  {
+    "name": "mainnet-02654-eeb5e24b.erae",
+    "size": 492031063
+  },
+  {
+    "name": "mainnet-02655-dd2f22dc.erae",
+    "size": 483872080
+  },
+  {
+    "name": "mainnet-02656-8501a880.erae",
+    "size": 509876293
+  },
+  {
+    "name": "mainnet-02657-daf1b638.erae",
+    "size": 558775130
+  },
+  {
+    "name": "mainnet-02658-4f18bdaa.erae",
+    "size": 586591028
+  },
+  {
+    "name": "mainnet-02659-292c29e0.erae",
+    "size": 549687122
+  },
+  {
+    "name": "mainnet-02660-a5b6a152.erae",
+    "size": 550459952
+  },
+  {
+    "name": "mainnet-02661-0cb3281a.erae",
+    "size": 482552163
+  },
+  {
+    "name": "mainnet-02662-59e3360f.erae",
+    "size": 526221501
+  },
+  {
+    "name": "mainnet-02663-f63c8615.erae",
+    "size": 601403993
+  },
+  {
+    "name": "mainnet-02664-1409524b.erae",
+    "size": 560559915
+  },
+  {
+    "name": "mainnet-02665-2f51fac1.erae",
+    "size": 571525598
+  },
+  {
+    "name": "mainnet-02666-ea0d76e3.erae",
+    "size": 575909632
+  },
+  {
+    "name": "mainnet-02667-44a6a6f5.erae",
+    "size": 481611331
+  },
+  {
+    "name": "mainnet-02668-a70d5679.erae",
+    "size": 495605953
+  },
+  {
+    "name": "mainnet-02669-1cc20f32.erae",
+    "size": 563444697
+  },
+  {
+    "name": "mainnet-02670-1dec9578.erae",
+    "size": 553002530
+  },
+  {
+    "name": "mainnet-02671-20b565bd.erae",
+    "size": 549394191
+  },
+  {
+    "name": "mainnet-02672-30564e56.erae",
+    "size": 589250689
+  },
+  {
+    "name": "mainnet-02673-9d567a93.erae",
+    "size": 522316773
+  },
+  {
+    "name": "mainnet-02674-9562d5f5.erae",
+    "size": 542942254
+  },
+  {
+    "name": "mainnet-02675-5c899062.erae",
+    "size": 586711003
+  },
+  {
+    "name": "mainnet-02676-c633ab13.erae",
+    "size": 597183461
+  },
+  {
+    "name": "mainnet-02677-9dc848ed.erae",
+    "size": 659094344
+  },
+  {
+    "name": "mainnet-02678-9337dc7a.erae",
+    "size": 691898346
+  },
+  {
+    "name": "mainnet-02679-83da2183.erae",
+    "size": 854689734
+  },
+  {
+    "name": "mainnet-02680-83aa70d8.erae",
+    "size": 555967796
+  },
+  {
+    "name": "mainnet-02681-c56ab4aa.erae",
+    "size": 647257044
+  },
+  {
+    "name": "mainnet-02682-b625f11b.erae",
+    "size": 631634898
+  },
+  {
+    "name": "mainnet-02683-66c65ff7.erae",
+    "size": 576489391
+  },
+  {
+    "name": "mainnet-02684-77054c2f.erae",
+    "size": 674180367
+  },
+  {
+    "name": "mainnet-02685-2d1fcbdd.erae",
+    "size": 586435371
+  },
+  {
+    "name": "mainnet-02686-4de959d2.erae",
+    "size": 617760746
+  },
+  {
+    "name": "mainnet-02687-f22a42f6.erae",
+    "size": 780112503
+  },
+  {
+    "name": "mainnet-02688-34b183e5.erae",
+    "size": 739948577
+  },
+  {
+    "name": "mainnet-02689-dc7ad9e9.erae",
+    "size": 607939060
+  },
+  {
+    "name": "mainnet-02690-ad8b27db.erae",
+    "size": 631899187
+  },
+  {
+    "name": "mainnet-02691-96f4f66c.erae",
+    "size": 525135476
+  },
+  {
+    "name": "mainnet-02692-8c51046a.erae",
+    "size": 512883922
+  },
+  {
+    "name": "mainnet-02693-bd018b3e.erae",
+    "size": 643371344
+  },
+  {
+    "name": "mainnet-02694-ade27851.erae",
+    "size": 596596215
+  },
+  {
+    "name": "mainnet-02695-35d6b872.erae",
+    "size": 614231082
+  },
+  {
+    "name": "mainnet-02696-fe56da0f.erae",
+    "size": 620583765
+  },
+  {
+    "name": "mainnet-02697-74e047fe.erae",
+    "size": 495009395
+  },
+  {
+    "name": "mainnet-02698-d7372f60.erae",
+    "size": 498692909
+  },
+  {
+    "name": "mainnet-02699-6625ed4f.erae",
+    "size": 691147941
+  },
+  {
+    "name": "mainnet-02700-04e8d7af.erae",
+    "size": 793922901
+  },
+  {
+    "name": "mainnet-02701-b4695b63.erae",
+    "size": 682920801
+  },
+  {
+    "name": "mainnet-02702-2e00531f.erae",
+    "size": 716732152
+  },
+  {
+    "name": "mainnet-02703-c849cf00.erae",
+    "size": 722596873
+  },
+  {
+    "name": "mainnet-02704-62d891fc.erae",
+    "size": 720949289
+  },
+  {
+    "name": "mainnet-02705-c6561081.erae",
+    "size": 717454502
+  },
+  {
+    "name": "mainnet-02706-1dc51cf3.erae",
+    "size": 772626211
+  },
+  {
+    "name": "mainnet-02707-5f8616b5.erae",
+    "size": 772081020
+  },
+  {
+    "name": "mainnet-02708-223215a3.erae",
+    "size": 653616988
+  },
+  {
+    "name": "mainnet-02709-c1f37ac6.erae",
+    "size": 504715822
+  },
+  {
+    "name": "mainnet-02710-8195f34b.erae",
+    "size": 417385337
+  },
+  {
+    "name": "mainnet-02711-016a6ebf.erae",
+    "size": 563760456
+  },
+  {
+    "name": "mainnet-02712-572887b6.erae",
+    "size": 580896555
+  },
+  {
+    "name": "mainnet-02713-5957ec6b.erae",
+    "size": 593864221
+  },
+  {
+    "name": "mainnet-02714-234bd17d.erae",
+    "size": 594622332
+  },
+  {
+    "name": "mainnet-02715-6b0d66e7.erae",
+    "size": 538998693
+  },
+  {
+    "name": "mainnet-02716-6a0ef6b1.erae",
+    "size": 494252676
+  },
+  {
+    "name": "mainnet-02717-e9bc9a8c.erae",
+    "size": 480154493
+  },
+  {
+    "name": "mainnet-02718-0855ad0c.erae",
+    "size": 538389224
+  },
+  {
+    "name": "mainnet-02719-e978730a.erae",
+    "size": 583197446
+  },
+  {
+    "name": "mainnet-02720-62855dbd.erae",
+    "size": 725337401
+  },
+  {
+    "name": "mainnet-02721-e05b3b31.erae",
+    "size": 647250615
+  },
+  {
+    "name": "mainnet-02722-644dd15f.erae",
+    "size": 448479291
+  },
+  {
+    "name": "mainnet-02723-81d95f06.erae",
+    "size": 446306662
+  },
+  {
+    "name": "mainnet-02724-ad350a2d.erae",
+    "size": 523258605
+  },
+  {
+    "name": "mainnet-02725-ae0cc9d1.erae",
+    "size": 773004719
+  },
+  {
+    "name": "mainnet-02726-be18e371.erae",
+    "size": 785804659
+  },
+  {
+    "name": "mainnet-02727-7418ca56.erae",
+    "size": 664018581
+  },
+  {
+    "name": "mainnet-02728-9de10c61.erae",
+    "size": 750723796
+  },
+  {
+    "name": "mainnet-02729-9b7a833f.erae",
+    "size": 541475930
+  },
+  {
+    "name": "mainnet-02730-9dd32472.erae",
+    "size": 601837429
+  },
+  {
+    "name": "mainnet-02731-47295af0.erae",
+    "size": 574583317
+  },
+  {
+    "name": "mainnet-02732-d7f736aa.erae",
+    "size": 608464380
+  },
+  {
+    "name": "mainnet-02733-cfb7134a.erae",
+    "size": 614596236
+  },
+  {
+    "name": "mainnet-02734-eebd43c1.erae",
+    "size": 478348330
+  },
+  {
+    "name": "mainnet-02735-1fabfc4f.erae",
+    "size": 472902968
+  },
+  {
+    "name": "mainnet-02736-2b53348f.erae",
+    "size": 521131313
+  },
+  {
+    "name": "mainnet-02737-0c5bb767.erae",
+    "size": 540489233
+  },
+  {
+    "name": "mainnet-02738-ecf8dd50.erae",
+    "size": 531818412
+  },
+  {
+    "name": "mainnet-02739-8b9a88be.erae",
+    "size": 609022206
+  },
+  {
+    "name": "mainnet-02740-4eea020d.erae",
+    "size": 573018352
+  },
+  {
+    "name": "mainnet-02741-cd023161.erae",
+    "size": 560854658
+  },
+  {
+    "name": "mainnet-02742-2e800514.erae",
+    "size": 571538470
+  },
+  {
+    "name": "mainnet-02743-3d201bd8.erae",
+    "size": 596531707
+  },
+  {
+    "name": "mainnet-02744-8cc82f90.erae",
+    "size": 575500288
+  },
+  {
+    "name": "mainnet-02745-89fd2cdb.erae",
+    "size": 573951952
+  },
+  {
+    "name": "mainnet-02746-43a0e87e.erae",
+    "size": 556946760
+  },
+  {
+    "name": "mainnet-02747-e274acfc.erae",
+    "size": 514593890
+  },
+  {
+    "name": "mainnet-02748-30580435.erae",
+    "size": 568123369
+  },
+  {
+    "name": "mainnet-02749-b65bac20.erae",
+    "size": 576026075
+  },
+  {
+    "name": "mainnet-02750-3926b780.erae",
+    "size": 567469008
+  },
+  {
+    "name": "mainnet-02751-5bcac33e.erae",
+    "size": 572056453
+  },
+  {
+    "name": "mainnet-02752-4100d924.erae",
+    "size": 563495845
+  },
+  {
+    "name": "mainnet-02753-4c70642f.erae",
+    "size": 538690131
+  },
+  {
+    "name": "mainnet-02754-7098969d.erae",
+    "size": 571194301
+  },
+  {
+    "name": "mainnet-02755-3afcc2eb.erae",
+    "size": 572012935
+  },
+  {
+    "name": "mainnet-02756-34232521.erae",
+    "size": 584831217
+  },
+  {
+    "name": "mainnet-02757-71a60273.erae",
+    "size": 572311374
+  },
+  {
+    "name": "mainnet-02758-51ac3d38.erae",
+    "size": 591126648
+  },
+  {
+    "name": "mainnet-02759-ae0891e5.erae",
+    "size": 572224126
+  },
+  {
+    "name": "mainnet-02760-09a8459b.erae",
+    "size": 569089582
+  },
+  {
+    "name": "mainnet-02761-874ecb84.erae",
+    "size": 569505025
+  },
+  {
+    "name": "mainnet-02762-6beab669.erae",
+    "size": 562982218
+  },
+  {
+    "name": "mainnet-02763-1e2bccab.erae",
+    "size": 573817938
+  },
+  {
+    "name": "mainnet-02764-cd503e75.erae",
+    "size": 560748363
+  },
+  {
+    "name": "mainnet-02765-4b0c8247.erae",
+    "size": 548036077
+  },
+  {
+    "name": "mainnet-02766-09203332.erae",
+    "size": 565125432
+  },
+  {
+    "name": "mainnet-02767-32cd01d9.erae",
+    "size": 588004653
+  },
+  {
+    "name": "mainnet-02768-4191bd37.erae",
+    "size": 578057569
+  },
+  {
+    "name": "mainnet-02769-8c964f77.erae",
+    "size": 579119823
+  },
+  {
+    "name": "mainnet-02770-58fb5353.erae",
+    "size": 587184693
+  },
+  {
+    "name": "mainnet-02771-1ee5b285.erae",
+    "size": 515395417
+  },
+  {
+    "name": "mainnet-02772-97226691.erae",
+    "size": 549569749
+  },
+  {
+    "name": "mainnet-02773-7a961d24.erae",
+    "size": 599056987
+  },
+  {
+    "name": "mainnet-02774-54efb30c.erae",
+    "size": 592125302
+  },
+  {
+    "name": "mainnet-02775-005d2b43.erae",
+    "size": 575285441
+  },
+  {
+    "name": "mainnet-02776-5a313fd7.erae",
+    "size": 572114930
+  },
+  {
+    "name": "mainnet-02777-1eb3b827.erae",
+    "size": 551305777
+  },
+  {
+    "name": "mainnet-02778-9c1cae8c.erae",
+    "size": 559667953
+  },
+  {
+    "name": "mainnet-02779-f2dd77d3.erae",
+    "size": 592478763
+  },
+  {
+    "name": "mainnet-02780-e95b5ec8.erae",
+    "size": 651209374
+  },
+  {
+    "name": "mainnet-02781-99ad070f.erae",
+    "size": 640062905
+  },
+  {
+    "name": "mainnet-02782-0bd0e7bd.erae",
+    "size": 606626351
+  },
+  {
+    "name": "mainnet-02783-3b922023.erae",
+    "size": 529225707
+  },
+  {
+    "name": "mainnet-02784-9067451d.erae",
+    "size": 536284065
+  },
+  {
+    "name": "mainnet-02785-2f033826.erae",
+    "size": 607097527
+  },
+  {
+    "name": "mainnet-02786-d932840c.erae",
+    "size": 613308465
+  },
+  {
+    "name": "mainnet-02787-20894001.erae",
+    "size": 603492393
+  },
+  {
+    "name": "mainnet-02788-9bfb9013.erae",
+    "size": 605526823
+  },
+  {
+    "name": "mainnet-02789-6fcfec43.erae",
+    "size": 542577882
+  },
+  {
+    "name": "mainnet-02790-40944181.erae",
+    "size": 522113607
+  },
+  {
+    "name": "mainnet-02791-a98b9098.erae",
+    "size": 589399127
+  },
+  {
+    "name": "mainnet-02792-f40701ee.erae",
+    "size": 607785545
+  },
+  {
+    "name": "mainnet-02793-a7b33d3a.erae",
+    "size": 606325419
+  },
+  {
+    "name": "mainnet-02794-c93143f4.erae",
+    "size": 616143802
+  },
+  {
+    "name": "mainnet-02795-c4961d93.erae",
+    "size": 609065706
+  },
+  {
+    "name": "mainnet-02796-a99b263d.erae",
+    "size": 573607960
+  },
+  {
+    "name": "mainnet-02797-05a36602.erae",
+    "size": 600337891
+  },
+  {
+    "name": "mainnet-02798-23fbf057.erae",
+    "size": 606623726
+  },
+  {
+    "name": "mainnet-02799-eae5f7d9.erae",
+    "size": 598025062
+  },
+  {
+    "name": "mainnet-02800-33c7ce2d.erae",
+    "size": 599979797
+  },
+  {
+    "name": "mainnet-02801-240722d8.erae",
+    "size": 612225812
+  },
+  {
+    "name": "mainnet-02802-1fa06f11.erae",
+    "size": 604111598
+  },
+  {
+    "name": "mainnet-02803-2bb63469.erae",
+    "size": 676288429
+  },
+  {
+    "name": "mainnet-02804-57f91a54.erae",
+    "size": 725545713
+  },
+  {
+    "name": "mainnet-02805-9078ed45.erae",
+    "size": 733141984
+  },
+  {
+    "name": "mainnet-02806-baddfa86.erae",
+    "size": 739402311
+  },
+  {
+    "name": "mainnet-02807-97e6d877.erae",
+    "size": 683574182
+  },
+  {
+    "name": "mainnet-02808-d970d9b5.erae",
+    "size": 660521766
+  },
+  {
+    "name": "mainnet-02809-700b7bc7.erae",
+    "size": 737001471
+  },
+  {
+    "name": "mainnet-02810-4bb011de.erae",
+    "size": 718345244
+  },
+  {
+    "name": "mainnet-02811-1280ebe9.erae",
+    "size": 651768640
+  },
+  {
+    "name": "mainnet-02812-e0d6ec3e.erae",
+    "size": 681960167
+  },
+  {
+    "name": "mainnet-02813-2046d44a.erae",
+    "size": 723544785
+  },
+  {
+    "name": "mainnet-02814-a10f6f05.erae",
+    "size": 655084010
+  },
+  {
+    "name": "mainnet-02815-4e1122fe.erae",
+    "size": 666003709
+  },
+  {
+    "name": "mainnet-02816-e8259738.erae",
+    "size": 729104800
+  },
+  {
+    "name": "mainnet-02817-2d19b486.erae",
+    "size": 753947911
+  },
+  {
+    "name": "mainnet-02818-5c31df7d.erae",
+    "size": 736157642
+  },
+  {
+    "name": "mainnet-02819-89fa53bf.erae",
+    "size": 746984367
+  },
+  {
+    "name": "mainnet-02820-8f69ae8e.erae",
+    "size": 740335632
+  },
+  {
+    "name": "mainnet-02821-aa11288c.erae",
+    "size": 729397473
+  },
+  {
+    "name": "mainnet-02822-6446f4c1.erae",
+    "size": 734453610
+  },
+  {
+    "name": "mainnet-02823-56585091.erae",
+    "size": 757867087
+  },
+  {
+    "name": "mainnet-02824-14766fd2.erae",
+    "size": 752929632
+  },
+  {
+    "name": "mainnet-02825-f5ce34eb.erae",
+    "size": 752975009
+  },
+  {
+    "name": "mainnet-02826-3a38f0a2.erae",
+    "size": 671075078
+  },
+  {
+    "name": "mainnet-02827-35e7f5eb.erae",
+    "size": 703674067
+  },
+  {
+    "name": "mainnet-02828-07b24aaa.erae",
+    "size": 749768562
+  },
+  {
+    "name": "mainnet-02829-1d8f69e5.erae",
+    "size": 753440504
+  },
+  {
+    "name": "mainnet-02830-00b89ba4.erae",
+    "size": 735685875
+  },
+  {
+    "name": "mainnet-02831-b77b65ee.erae",
+    "size": 725615127
+  },
+  {
+    "name": "mainnet-02832-e2273b7d.erae",
+    "size": 744314751
+  },
+  {
+    "name": "mainnet-02833-6d2c9f98.erae",
+    "size": 735487781
+  },
+  {
+    "name": "mainnet-02834-1ddefb3a.erae",
+    "size": 872590708
+  },
+  {
+    "name": "mainnet-02835-e440a4b8.erae",
+    "size": 953737900
+  },
+  {
+    "name": "mainnet-02836-3cb5ae6e.erae",
+    "size": 1051057012
+  },
+  {
+    "name": "mainnet-02837-5d22894c.erae",
+    "size": 777103667
+  },
+  {
+    "name": "mainnet-02838-a1303064.erae",
+    "size": 708539498
+  },
+  {
+    "name": "mainnet-02839-46bab4b3.erae",
+    "size": 697598072
+  },
+  {
+    "name": "mainnet-02840-abd2003e.erae",
+    "size": 894268418
+  },
+  {
+    "name": "mainnet-02841-8c92f145.erae",
+    "size": 823562212
+  },
+  {
+    "name": "mainnet-02842-3df46757.erae",
+    "size": 938948920
+  },
+  {
+    "name": "mainnet-02843-f4f7d029.erae",
+    "size": 946787065
+  },
+  {
+    "name": "mainnet-02844-947d99e5.erae",
+    "size": 938164619
+  },
+  {
+    "name": "mainnet-02845-1162b184.erae",
+    "size": 788434552
+  },
+  {
+    "name": "mainnet-02846-8b3a917c.erae",
+    "size": 901928625
+  },
+  {
+    "name": "mainnet-02847-0cc3a59e.erae",
+    "size": 849774720
+  },
+  {
+    "name": "mainnet-02848-a8a55ebc.erae",
+    "size": 825386524
+  },
+  {
+    "name": "mainnet-02849-a8318fe5.erae",
+    "size": 841487291
+  },
+  {
+    "name": "mainnet-02850-e1857d3e.erae",
+    "size": 821811541
+  },
+  {
+    "name": "mainnet-02851-b1d6a737.erae",
+    "size": 733981279
+  },
+  {
+    "name": "mainnet-02852-b503e1af.erae",
+    "size": 788798557
+  },
+  {
+    "name": "mainnet-02853-f412da92.erae",
+    "size": 756580448
+  },
+  {
+    "name": "mainnet-02854-be98d50d.erae",
+    "size": 762728201
+  },
+  {
+    "name": "mainnet-02855-cd42ebb1.erae",
+    "size": 762253216
+  },
+  {
+    "name": "mainnet-02856-6dcb97e7.erae",
+    "size": 755084020
+  },
+  {
+    "name": "mainnet-02857-ad7df00c.erae",
+    "size": 746562577
+  },
+  {
+    "name": "mainnet-02858-9eaf20a2.erae",
+    "size": 736109539
+  },
+  {
+    "name": "mainnet-02859-4019e53b.erae",
+    "size": 798544734
+  },
+  {
+    "name": "mainnet-02860-e9e66e16.erae",
+    "size": 789430660
+  },
+  {
+    "name": "mainnet-02861-3b023d9e.erae",
+    "size": 788533241
+  },
+  {
+    "name": "mainnet-02862-90d855c0.erae",
+    "size": 792166844
+  },
+  {
+    "name": "mainnet-02863-3c1c19f0.erae",
+    "size": 778493128
+  },
+  {
+    "name": "mainnet-02864-702376d9.erae",
+    "size": 756705331
+  },
+  {
+    "name": "mainnet-02865-38c039d5.erae",
+    "size": 776388323
+  },
+  {
+    "name": "mainnet-02866-0bce6f4e.erae",
+    "size": 794030935
+  },
+  {
+    "name": "mainnet-02867-82f98b6e.erae",
+    "size": 780265461
+  },
+  {
+    "name": "mainnet-02868-cbff4af4.erae",
+    "size": 741296523
+  },
+  {
+    "name": "mainnet-02869-e6edcbb4.erae",
+    "size": 660070198
+  },
+  {
+    "name": "mainnet-02870-20098aef.erae",
+    "size": 713132795
+  },
+  {
+    "name": "mainnet-02871-45d5d4ea.erae",
+    "size": 784329389
+  },
+  {
+    "name": "mainnet-02872-697134e3.erae",
+    "size": 762516828
+  },
+  {
+    "name": "mainnet-02873-0de86b44.erae",
+    "size": 759806222
+  },
+  {
+    "name": "mainnet-02874-e779bea3.erae",
+    "size": 755090081
+  },
+  {
+    "name": "mainnet-02875-48492798.erae",
+    "size": 773201096
+  },
+  {
+    "name": "mainnet-02876-e6888886.erae",
+    "size": 732537810
+  },
+  {
+    "name": "mainnet-02877-41037a81.erae",
+    "size": 751715214
+  },
+  {
+    "name": "mainnet-02878-d6376c0d.erae",
+    "size": 733038395
+  },
+  {
+    "name": "mainnet-02879-3fc1c51d.erae",
+    "size": 753482387
+  },
+  {
+    "name": "mainnet-02880-116f24b7.erae",
+    "size": 749379281
+  },
+  {
+    "name": "mainnet-02881-3f763800.erae",
+    "size": 683899326
+  },
+  {
+    "name": "mainnet-02882-bdb950d0.erae",
+    "size": 659411036
+  },
+  {
+    "name": "mainnet-02883-750b66be.erae",
+    "size": 660073725
+  },
+  {
+    "name": "mainnet-02884-4a5958b4.erae",
+    "size": 707610683
+  },
+  {
+    "name": "mainnet-02885-d9de8e05.erae",
+    "size": 686868193
+  },
+  {
+    "name": "mainnet-02886-217e868c.erae",
+    "size": 675511517
+  },
+  {
+    "name": "mainnet-02887-c9b5ca6c.erae",
+    "size": 584570468
+  },
+  {
+    "name": "mainnet-02888-bfd224be.erae",
+    "size": 664409361
+  },
+  {
+    "name": "mainnet-02889-fbcf6d1b.erae",
+    "size": 710436406
+  },
+  {
+    "name": "mainnet-02890-fa997f47.erae",
+    "size": 708052391
+  },
+  {
+    "name": "mainnet-02891-7d1d0a91.erae",
+    "size": 751758531
+  },
+  {
+    "name": "mainnet-02892-57463b12.erae",
+    "size": 766439758
+  },
+  {
+    "name": "mainnet-02893-a6910b99.erae",
+    "size": 641172608
+  },
+  {
+    "name": "mainnet-02894-eb95836d.erae",
+    "size": 676941018
+  },
+  {
+    "name": "mainnet-02895-f2ac0186.erae",
+    "size": 768409963
+  },
+  {
+    "name": "mainnet-02896-829a93a8.erae",
+    "size": 739362344
+  },
+  {
+    "name": "mainnet-02897-ced423b4.erae",
+    "size": 721145499
+  },
+  {
+    "name": "mainnet-02898-b8d43c11.erae",
+    "size": 705028189
+  },
+  {
+    "name": "mainnet-02899-e1f6971a.erae",
+    "size": 747144553
+  },
+  {
+    "name": "mainnet-02900-efe70af7.erae",
+    "size": 685088610
+  },
+  {
+    "name": "mainnet-02901-41418d74.erae",
+    "size": 730951784
+  },
+  {
+    "name": "mainnet-02902-625a46fe.erae",
+    "size": 723601329
+  },
+  {
+    "name": "mainnet-02903-456e78a4.erae",
+    "size": 722242022
+  },
+  {
+    "name": "mainnet-02904-bdf25b26.erae",
+    "size": 753171600
+  },
+  {
+    "name": "mainnet-02905-c4f391a4.erae",
+    "size": 705581231
+  },
+  {
+    "name": "mainnet-02906-1499d942.erae",
+    "size": 660066586
+  },
+  {
+    "name": "mainnet-02907-be2dc277.erae",
+    "size": 742243096
+  },
+  {
+    "name": "mainnet-02908-4acddd95.erae",
+    "size": 734815484
+  },
+  {
+    "name": "mainnet-02909-413fb390.erae",
+    "size": 753368464
+  },
+  {
+    "name": "mainnet-02910-9d02280e.erae",
+    "size": 743115088
+  },
+  {
+    "name": "mainnet-02911-0e77fa43.erae",
+    "size": 730259000
+  },
+  {
+    "name": "mainnet-02912-28803d00.erae",
+    "size": 661582768
+  },
+  {
+    "name": "mainnet-02913-aa30fece.erae",
+    "size": 721077763
+  },
+  {
+    "name": "mainnet-02914-1d9c1a94.erae",
+    "size": 747790357
+  },
+  {
+    "name": "mainnet-02915-8bf65d9a.erae",
+    "size": 832452617
+  },
+  {
+    "name": "mainnet-02916-be1c8731.erae",
+    "size": 859618041
+  },
+  {
+    "name": "mainnet-02917-40ce362f.erae",
+    "size": 812337943
+  },
+  {
+    "name": "mainnet-02918-70a84e30.erae",
+    "size": 701547794
+  },
+  {
+    "name": "mainnet-02919-12f71a88.erae",
+    "size": 922380380
+  },
+  {
+    "name": "mainnet-02920-cc2a8fd9.erae",
+    "size": 878395054
+  },
+  {
+    "name": "mainnet-02921-9db0d63c.erae",
+    "size": 881086356
+  },
+  {
+    "name": "mainnet-02922-a550f5af.erae",
+    "size": 896726653
+  },
+  {
+    "name": "mainnet-02923-aa39262d.erae",
+    "size": 827365826
+  },
+  {
+    "name": "mainnet-02924-fdab85e6.erae",
+    "size": 725374137
+  },
+  {
+    "name": "mainnet-02925-26b551dc.erae",
+    "size": 714359605
+  },
+  {
+    "name": "mainnet-02926-bec55bc6.erae",
+    "size": 750183907
+  },
+  {
+    "name": "mainnet-02927-4268cf71.erae",
+    "size": 785121194
+  },
+  {
+    "name": "mainnet-02928-c6795273.erae",
+    "size": 804272554
+  },
+  {
+    "name": "mainnet-02929-a581aabf.erae",
+    "size": 769179198
+  },
+  {
+    "name": "mainnet-02930-cd1d91c8.erae",
+    "size": 692369162
+  },
+  {
+    "name": "mainnet-02931-29cd027f.erae",
+    "size": 745727225
+  },
+  {
+    "name": "mainnet-02932-81b226a5.erae",
+    "size": 876914381
+  },
+  {
+    "name": "mainnet-02933-e1ce860f.erae",
+    "size": 827748943
+  },
+  {
+    "name": "mainnet-02934-d1f70fa6.erae",
+    "size": 838526871
+  },
+  {
+    "name": "mainnet-02935-6ca893c6.erae",
+    "size": 808637277
+  },
+  {
+    "name": "mainnet-02936-81241ac6.erae",
+    "size": 709565141
+  },
+  {
+    "name": "mainnet-02937-e1af94e4.erae",
+    "size": 777658858
+  },
+  {
+    "name": "mainnet-02938-4a70e0cb.erae",
+    "size": 844075270
+  },
+  {
+    "name": "mainnet-02939-4f40af7f.erae",
+    "size": 871569792
+  },
+  {
+    "name": "mainnet-02940-10520b21.erae",
+    "size": 846327731
+  },
+  {
+    "name": "mainnet-02941-e7f15a78.erae",
+    "size": 875768426
+  },
+  {
+    "name": "mainnet-02942-f865a44b.erae",
+    "size": 803054371
+  },
+  {
+    "name": "mainnet-02943-bc5f885e.erae",
+    "size": 828685913
+  },
+  {
+    "name": "mainnet-02944-de1ad382.erae",
+    "size": 933827337
+  },
+  {
+    "name": "mainnet-02945-70325e1e.erae",
+    "size": 913819176
+  },
+  {
+    "name": "mainnet-02946-e2541d21.erae",
+    "size": 901554394
+  },
+  {
+    "name": "mainnet-02947-91722ea0.erae",
+    "size": 924296941
+  },
+  {
+    "name": "mainnet-02948-0add0984.erae",
+    "size": 957152740
+  },
+  {
+    "name": "mainnet-02949-6d6bc7a1.erae",
+    "size": 882791903
+  },
+  {
+    "name": "mainnet-02950-ac4f91fa.erae",
+    "size": 971480615
+  },
+  {
+    "name": "mainnet-02951-ac1d1459.erae",
+    "size": 956283268
+  },
+  {
+    "name": "mainnet-02952-a44f1049.erae",
+    "size": 944222705
+  },
+  {
+    "name": "mainnet-02953-6527baf2.erae",
+    "size": 864051716
+  },
+  {
+    "name": "mainnet-02954-4d8f7bb5.erae",
+    "size": 789630391
+  },
+  {
+    "name": "mainnet-02955-bf6a6b86.erae",
+    "size": 763995476
+  },
+  {
+    "name": "mainnet-02956-ac56a62e.erae",
+    "size": 851927701
+  },
+  {
+    "name": "mainnet-02957-1cbb8951.erae",
+    "size": 932366902
+  },
+  {
+    "name": "mainnet-02958-aba5b5ca.erae",
+    "size": 960273751
+  },
+  {
+    "name": "mainnet-02959-bf7cc9bf.erae",
+    "size": 962387530
+  },
+  {
+    "name": "mainnet-02960-7c0068ea.erae",
+    "size": 897003946
+  },
+  {
+    "name": "mainnet-02961-4a68b3ac.erae",
+    "size": 761912792
+  },
+  {
+    "name": "mainnet-02962-9b6effc2.erae",
+    "size": 932478548
+  },
+  {
+    "name": "mainnet-02963-8cb9235e.erae",
+    "size": 963858484
+  },
+  {
+    "name": "mainnet-02964-97070707.erae",
+    "size": 947115199
+  },
+  {
+    "name": "mainnet-02965-f661d3e7.erae",
+    "size": 945446623
+  },
+  {
+    "name": "mainnet-02966-c17b7789.erae",
+    "size": 908031042
+  },
+  {
+    "name": "mainnet-02967-6df58ccb.erae",
+    "size": 885182491
+  },
+  {
+    "name": "mainnet-02968-d6f787b1.erae",
+    "size": 1001758662
+  },
+  {
+    "name": "mainnet-02969-ec3a64fa.erae",
+    "size": 1006644830
+  },
+  {
+    "name": "mainnet-02970-42353af2.erae",
+    "size": 1000293677
+  },
+  {
+    "name": "mainnet-02971-3cfcc40a.erae",
+    "size": 991445535
+  },
+  {
+    "name": "mainnet-02972-d0d0769f.erae",
+    "size": 926509852
+  },
+  {
+    "name": "mainnet-02973-97b2bb37.erae",
+    "size": 953606849
+  },
+  {
+    "name": "mainnet-02974-cb5c1162.erae",
+    "size": 978737192
+  },
+  {
+    "name": "mainnet-02975-99e434e1.erae",
+    "size": 1003809934
+  },
+  {
+    "name": "mainnet-02976-21d6f3ce.erae",
+    "size": 1033773737
+  },
+  {
+    "name": "mainnet-02977-ef5aed7a.erae",
+    "size": 987093770
+  },
+  {
+    "name": "mainnet-02978-46d0e7a6.erae",
+    "size": 1025656729
+  },
+  {
+    "name": "mainnet-02979-3ac16e09.erae",
+    "size": 1020020089
+  },
+  {
+    "name": "mainnet-02980-a392d3d4.erae",
+    "size": 1009870771
+  },
+  {
+    "name": "mainnet-02981-6cab3348.erae",
+    "size": 1046100173
+  },
+  {
+    "name": "mainnet-02982-006c44b6.erae",
+    "size": 984215805
+  },
+  {
+    "name": "mainnet-02983-6d538e6f.erae",
+    "size": 962138258
+  },
+  {
+    "name": "mainnet-02984-04f29b50.erae",
+    "size": 952470390
+  },
+  {
+    "name": "mainnet-02985-73faae83.erae",
+    "size": 914979198
+  },
+  {
+    "name": "mainnet-02986-c41d0ede.erae",
+    "size": 870698130
+  },
+  {
+    "name": "mainnet-02987-548d092a.erae",
+    "size": 894402012
+  },
+  {
+    "name": "mainnet-02988-9bf8564b.erae",
+    "size": 875389777
+  },
+  {
+    "name": "mainnet-02989-68ff533b.erae",
+    "size": 904806614
+  },
+  {
+    "name": "mainnet-02990-5d6604e5.erae",
+    "size": 899987389
+  },
+  {
+    "name": "mainnet-02991-e6730a3a.erae",
+    "size": 762019308
+  },
+  {
+    "name": "mainnet-02992-d3f7961d.erae",
+    "size": 819854280
+  },
+  {
+    "name": "urls.txt",
+    "size": 206517
+  }
+];
+
+        // Format file size
+        function formatSize(bytes) {
+            if (bytes < 1024) return bytes + ' B';
+            else if (bytes < 1048576) return (bytes / 1024).toFixed(1) + ' KB';
+            else if (bytes < 1073741824) return (bytes / 1048576).toFixed(1) + ' MB';
+            else return (bytes / 1073741824).toFixed(2) + ' GB';
+        }
+
+        // Populate file list
+        function populateFiles() {
+            const fileList = document.getElementById('fileList');
+            const fileCount = document.getElementById('fileCount');
+            let totalSize = 0;
+
+            files.forEach(file => {
+                const li = document.createElement('li');
+                li.className = 'file-item';
+
+                li.innerHTML = `
+                    <a href="./${file.name}" class="file-link">${file.name}</a>
+                    <span class="file-size">${formatSize(file.size)}</span>
+                `;
+
+                fileList.appendChild(li);
+                totalSize += file.size;
+            });
+
+            // Update file count
+            fileCount.textContent = `${files.length} files`;
+
+            // Update stats
+            const stats = document.getElementById('stats');
+            stats.innerHTML = `Total: ${files.length} files &bull; ${formatSize(totalSize)}`;
+        }
+
+        // Initialize
+        populateFiles();
+    </script>
+</body>
+</html>
diff --git a/crates/era-downloader/tests/res/ere/files/mainnet-00000-a6860fef.erae b/crates/era-downloader/tests/res/ere/files/mainnet-00000-a6860fef.erae
new file mode 100644
index 00000000000..4bcfe98e640
--- /dev/null
+++ b/crates/era-downloader/tests/res/ere/files/mainnet-00000-a6860fef.erae
@@ -0,0 +1 @@
+d
diff --git a/crates/era-downloader/tests/res/ere/files/mainnet-00001-05c64fc4.erae b/crates/era-downloader/tests/res/ere/files/mainnet-00001-05c64fc4.erae
new file mode 100644
index 00000000000..d905d9da82c
--- /dev/null
+++ b/crates/era-downloader/tests/res/ere/files/mainnet-00001-05c64fc4.erae
@@ -0,0 +1 @@
+e
diff --git a/crates/era-utils/Cargo.toml b/crates/era-utils/Cargo.toml
index 3363545faa0..f9e63bfa90a 100644
--- a/crates/era-utils/Cargo.toml
+++ b/crates/era-utils/Cargo.toml
@@ -38,6 +38,7 @@ tracing.workspace = true
 reth-provider.workspace = true
 reth-provider.features = ["test-utils"]
 reth-db-common.workspace = true
+reth-ethereum-primitives.workspace = true
 
 # async
 tokio-util.workspace = true
diff --git a/crates/era-utils/src/history.rs b/crates/era-utils/src/history.rs
index 625ebb6846d..d54d91dc8cc 100644
--- a/crates/era-utils/src/history.rs
+++ b/crates/era-utils/src/history.rs
@@ -11,10 +11,7 @@ use reth_db_api::{
 use reth_era::{
     common::{decode::DecodeCompressedRlp, file_ops::StreamReader},
     e2s::error::E2sError,
-    era1::{
-        file::{BlockTupleIterator, Era1Reader},
-        types::execution::BlockTuple,
-    },
+    era1::{file::Era1Reader, types::execution::BlockTuple},
 };
 use reth_era_downloader::EraMeta;
 use reth_etl::Collector;
@@ -31,26 +28,54 @@ use reth_storage_api::{
     errors::ProviderResult, DBProvider, DatabaseProviderFactory, NodePrimitivesProvider,
     StageCheckpointWriter,
 };
-use std::{
-    collections::Bound,
-    error::Error,
-    fmt::{Display, Formatter},
-    io::{Read, Seek},
-    iter::Map,
-    ops::RangeBounds,
-    sync::mpsc,
-};
+use std::{collections::Bound, error::Error, ops::RangeBounds, sync::mpsc};
 use tracing::info;
 
-/// Imports blocks from `downloader` using `provider`.
+/// Reads execution `(header, body)` pairs out of an ERA file.
+///
+/// Per-format seam of the import pipeline.
+pub trait EraBlockReader<BH, BB> {
+    /// Opens the ERA file at `meta` and iterates its execution blocks.
+    fn blocks<M: EraMeta + ?Sized>(
+        meta: &M,
+    ) -> eyre::Result<impl Iterator<Item = eyre::Result<(BH, BB)>>>;
+}
+
+/// [`EraBlockReader`] for `.era1` files.
+#[derive(Debug)]
+pub struct Era1;
+
+impl<BH, BB> EraBlockReader<BH, BB> for Era1
+where
+    BH: FullBlockHeader + Value,
+    BB: FullBlockBody<OmmerHeader = BH>,
+{
+    fn blocks<M: EraMeta + ?Sized>(
+        meta: &M,
+    ) -> eyre::Result<impl Iterator<Item = eyre::Result<(BH, BB)>>> {
+        let reader: Era1Reader<std::fs::File> = open(meta)?;
+        Ok(reader.iter().map(decode::<BH, BB, E2sError>))
+    }
+}
+
+/// Opens the ERA file at `meta` with the format's [`StreamReader`].
+pub fn open<Reader>(meta: &(impl EraMeta + ?Sized)) -> eyre::Result<Reader>
+where
+    Reader: StreamReader<std::fs::File>,
+{
+    Ok(Reader::new(fs::open(meta.path())?))
+}
+
+/// Imports blocks from `downloader`, decoding each file with the [`EraBlockReader`] `S`.
 ///
 /// Returns current block height.
-pub fn import<Downloader, Era, PF, B, BB, BH>(
+pub fn import<S, Downloader, Era, PF, B, BB, BH>(
     mut downloader: Downloader,
     provider_factory: &PF,
     hash_collector: &mut Collector<BlockHash, BlockNumber>,
 ) -> eyre::Result<BlockNumber>
 where
+    S: EraBlockReader<BH, BB>,
     B: Block<Header = BH, Body = BB>,
     BH: FullBlockHeader + Value,
     BB: FullBlockBody<
@@ -88,7 +113,7 @@ where
         let from = height;
         let provider = provider_factory.database_provider_rw()?;
 
-        height = process(
+        height = process::<S, _, _, _, _>(
             &meta?,
             &mut static_file_provider.latest_writer(StaticFileSegment::Headers)?,
             &provider,
@@ -140,98 +165,37 @@ where
     Ok(())
 }
 
-/// Extracts block headers and bodies from `meta` and appends them using `writer` and `provider`.
-///
-/// Collects hash to height using `hash_collector`.
-///
-/// Skips all blocks below the [`start_bound`] of `block_numbers` and stops when reaching past the
-/// [`end_bound`] or the end of the file.
-///
-/// Returns last block height.
-///
-/// [`start_bound`]: RangeBounds::start_bound
-/// [`end_bound`]: RangeBounds::end_bound
-pub fn process<Era, P, B, BB, BH>(
-    meta: &Era,
+/// Reads `meta` with the [`EraBlockReader`] `S`, appends its blocks within `block_numbers`, and
+/// marks `meta` processed if the file was fully consumed. Returns last block height.
+pub fn process<S, P, B, BB, BH>(
+    meta: &(impl EraMeta + ?Sized),
     writer: &mut StaticFileProviderRWRefMut<'_, <P as NodePrimitivesProvider>::Primitives>,
     provider: &P,
     hash_collector: &mut Collector<BlockHash, BlockNumber>,
     block_numbers: impl RangeBounds<BlockNumber>,
 ) -> eyre::Result<BlockNumber>
 where
+    S: EraBlockReader<BH, BB>,
     B: Block<Header = BH, Body = BB>,
     BH: FullBlockHeader + Value,
     BB: FullBlockBody<
         Transaction = <<P as NodePrimitivesProvider>::Primitives as NodePrimitives>::SignedTx,
         OmmerHeader = BH,
     >,
-    Era: EraMeta + ?Sized,
     P: DBProvider<Tx: DbTxMut> + NodePrimitivesProvider + BlockWriter<Block = B>,
     <P as NodePrimitivesProvider>::Primitives: NodePrimitives<BlockHeader = BH, BlockBody = BB>,
 {
-    let reader = open(meta)?;
-    let iter = reader.iter().map(decode as fn(_) -> _);
-    let iter = ProcessIter { iter, era: meta };
+    let iter = S::blocks(meta)?
+        .map(Some)
+        .chain(std::iter::once_with(|| match meta.mark_as_processed() {
+            Ok(()) => None,
+            Err(error) => Some(Err(error)),
+        }))
+        .flatten();
 
     process_iter(iter, writer, provider, hash_collector, block_numbers)
 }
 
-type ProcessInnerIter<R, BH, BB> =
-    Map<BlockTupleIterator<R>, fn(Result<BlockTuple, E2sError>) -> eyre::Result<(BH, BB)>>;
-
-/// An iterator that wraps era file extraction. After the final item [`EraMeta::mark_as_processed`]
-/// is called to ensure proper cleanup.
-#[derive(Debug)]
-pub struct ProcessIter<'a, Era: ?Sized, R: Read, BH, BB>
-where
-    BH: FullBlockHeader + Value,
-    BB: FullBlockBody<OmmerHeader = BH>,
-{
-    iter: ProcessInnerIter<R, BH, BB>,
-    era: &'a Era,
-}
-
-impl<'a, Era: EraMeta + ?Sized, R: Read, BH, BB> Display for ProcessIter<'a, Era, R, BH, BB>
-where
-    BH: FullBlockHeader + Value,
-    BB: FullBlockBody<OmmerHeader = BH>,
-{
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        Display::fmt(&self.era.path().to_string_lossy(), f)
-    }
-}
-
-impl<'a, Era, R, BH, BB> Iterator for ProcessIter<'a, Era, R, BH, BB>
-where
-    R: Read + Seek,
-    Era: EraMeta + ?Sized,
-    BH: FullBlockHeader + Value,
-    BB: FullBlockBody<OmmerHeader = BH>,
-{
-    type Item = eyre::Result<(BH, BB)>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.iter.next() {
-            Some(item) => Some(item),
-            None => match self.era.mark_as_processed() {
-                Ok(..) => None,
-                Err(e) => Some(Err(e)),
-            },
-        }
-    }
-}
-
-/// Opens the era file described by `meta`.
-pub fn open<Era>(meta: &Era) -> eyre::Result<Era1Reader<std::fs::File>>
-where
-    Era: EraMeta + ?Sized,
-{
-    let file = fs::open(meta.path())?;
-    let reader = Era1Reader::new(file);
-
-    Ok(reader)
-}
-
 /// Extracts a pair of [`FullBlockHeader`] and [`FullBlockBody`] from [`BlockTuple`].
 pub fn decode<BH, BB, E>(block: Result<BlockTuple, E>) -> eyre::Result<(BH, BB)>
 where
@@ -314,19 +278,12 @@ where
 }
 
 /// Dumps the contents of `hash_collector` into [`tables::HeaderNumbers`].
-pub fn build_index<P, B, BB, BH>(
+pub fn build_index<P>(
     provider: &P,
     hash_collector: &mut Collector<BlockHash, BlockNumber>,
 ) -> eyre::Result<()>
 where
-    B: Block<Header = BH, Body = BB>,
-    BH: FullBlockHeader + Value,
-    BB: FullBlockBody<
-        Transaction = <<P as NodePrimitivesProvider>::Primitives as NodePrimitives>::SignedTx,
-        OmmerHeader = BH,
-    >,
-    P: DBProvider<Tx: DbTxMut> + NodePrimitivesProvider + BlockWriter<Block = B>,
-    <P as NodePrimitivesProvider>::Primitives: NodePrimitives<BlockHeader = BH, BlockBody = BB>,
+    P: DBProvider<Tx: DbTxMut>,
 {
     let total_headers = hash_collector.len();
     info!(target: "era::history::import", total = total_headers, "Writing headers hash index");
@@ -394,3 +351,70 @@ where
 
     Ok(total_difficulty)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy_consensus::Header;
+    use reth_db_common::init::init_genesis;
+    use reth_ethereum_primitives::{Block, BlockBody};
+    use reth_provider::{
+        test_utils::create_test_provider_factory, DatabaseProviderFactory,
+        StaticFileProviderFactory, StaticFileSegment, StaticFileWriter,
+    };
+    use std::{cell::Cell, path::Path};
+    use tempfile::tempdir;
+
+    struct TestEra;
+
+    impl EraBlockReader<Header, BlockBody> for TestEra {
+        fn blocks<M: EraMeta + ?Sized>(
+            _meta: &M,
+        ) -> eyre::Result<impl Iterator<Item = eyre::Result<(Header, BlockBody)>>> {
+            Ok([1, 2]
+                .into_iter()
+                .map(|number| Ok((Header { number, ..Default::default() }, BlockBody::default()))))
+        }
+    }
+
+    #[derive(Debug)]
+    struct TestMeta {
+        marked: Cell<bool>,
+    }
+
+    impl EraMeta for TestMeta {
+        fn mark_as_processed(&self) -> eyre::Result<()> {
+            self.marked.set(true);
+            Ok(())
+        }
+
+        fn path(&self) -> &Path {
+            Path::new("test.era1")
+        }
+    }
+
+    #[test]
+    fn process_does_not_mark_partially_consumed_file_processed() {
+        let pf = create_test_provider_factory();
+        init_genesis(&pf).unwrap();
+
+        let static_file_provider = pf.static_file_provider();
+        let mut writer = static_file_provider.latest_writer(StaticFileSegment::Headers).unwrap();
+        let provider = pf.database_provider_rw().unwrap();
+        let folder = tempdir().unwrap();
+        let mut hash_collector = Collector::new(4096, Some(folder.path().to_owned()));
+        let meta = TestMeta { marked: Cell::new(false) };
+
+        let height = process::<TestEra, _, Block, _, _>(
+            &meta,
+            &mut writer,
+            &provider,
+            &mut hash_collector,
+            0..=1,
+        )
+        .unwrap();
+
+        assert_eq!(height, 1);
+        assert!(!meta.marked.get());
+    }
+}
diff --git a/crates/era-utils/src/lib.rs b/crates/era-utils/src/lib.rs
index 13a5ceefe92..59a28aca0ad 100644
--- a/crates/era-utils/src/lib.rs
+++ b/crates/era-utils/src/lib.rs
@@ -1,19 +1,14 @@
-//! Utilities to store history from downloaded ERA files with storage-api
-//!  and export it to recreate era1 files.
+//! Moves block history between ERA files ([`reth_era`]) and node storage ([`reth_storage_api`]).
 //!
-//! The import is downloaded using [`reth_era_downloader`] and parsed using [`reth_era`].
+//! Each ERA format plugs into a shared pipeline through a per-format seam ([`EraBlockReader`]).
 
 mod history;
 
-/// Export block history data from the database to recreate era1 files.
 mod export;
 
-/// Export history from storage-api between 2 blocks
-/// with parameters defined in [`ExportConfig`].
 pub use export::{export, ExportConfig};
 
-/// Imports history from ERA files.
 pub use history::{
     build_index, calculate_td_by_number, decode, import, open, process, process_iter,
-    save_stage_checkpoints, ProcessIter,
+    save_stage_checkpoints, Era1, EraBlockReader,
 };
diff --git a/crates/era-utils/tests/it/history.rs b/crates/era-utils/tests/it/history.rs
index 2075722398f..69ec0dcffc0 100644
--- a/crates/era-utils/tests/it/history.rs
+++ b/crates/era-utils/tests/it/history.rs
@@ -3,7 +3,7 @@ use reqwest::{Client, Url};
 use reth_db_common::init::init_genesis;
 use reth_era::era1::types::execution::MAX_BLOCKS_PER_ERA1;
 use reth_era_downloader::{EraClient, EraStream, EraStreamConfig};
-use reth_era_utils::{export, import, ExportConfig};
+use reth_era_utils::{export, import, Era1, ExportConfig};
 use reth_etl::Collector;
 use reth_fs_util as fs;
 use reth_provider::{test_utils::create_test_provider_factory, BlockNumReader, BlockReader};
@@ -38,7 +38,8 @@ async fn test_history_imports_from_fresh_state_successfully() {
     let mut hash_collector = Collector::new(4096, folder);
 
     let expected_block_number = 8191;
-    let actual_block_number = import(stream, &pf, &mut hash_collector).unwrap();
+    let actual_block_number =
+        import::<Era1, _, _, _, _, _, _>(stream, &pf, &mut hash_collector).unwrap();
 
     assert_eq!(actual_block_number, expected_block_number);
 }
@@ -67,7 +68,8 @@ async fn test_roundtrip_export_after_import() {
     let mut hash_collector = Collector::new(4096, folder);
 
     // Import blocks from one era1 file into database
-    let last_imported_block_height = import(stream, &pf, &mut hash_collector).unwrap();
+    let last_imported_block_height =
+        import::<Era1, _, _, _, _, _, _>(stream, &pf, &mut hash_collector).unwrap();
 
     assert_eq!(last_imported_block_height, 8191);
     let provider_ref = pf.provider_rw().unwrap().0;
diff --git a/crates/era/Cargo.toml b/crates/era/Cargo.toml
index 396a0a0f8b7..c3a5dd848ec 100644
--- a/crates/era/Cargo.toml
+++ b/crates/era/Cargo.toml
@@ -16,7 +16,7 @@ thiserror.workspace = true
 alloy-consensus.workspace = true
 alloy-eips.workspace = true
 alloy-primitives.workspace = true
-alloy-rlp.workspace = true
+alloy-rlp = { workspace = true, features = ["derive"] }
 
 # compression and decompression
 snap.workspace = true
diff --git a/crates/era/src/common/compression.rs b/crates/era/src/common/compression.rs
new file mode 100644
index 00000000000..30086c47155
--- /dev/null
+++ b/crates/era/src/common/compression.rs
@@ -0,0 +1,76 @@
+//! Snappy-framed compression helpers and a generic Snappy + RLP codec.
+//!
+//! These utilities are format-agnostic and shared across the e2store-based file formats.
+
+use crate::e2s::error::E2sError;
+use alloy_rlp::{Decodable, Encodable};
+use snap::{read::FrameDecoder, write::FrameEncoder};
+use std::{
+    io::{Read, Write},
+    marker::PhantomData,
+};
+
+/// Compress raw bytes with Snappy framed encoding.
+pub fn snappy_compress(data: &[u8]) -> Result<Vec<u8>, E2sError> {
+    let mut compressed = Vec::new();
+    {
+        let mut encoder = FrameEncoder::new(&mut compressed);
+        Write::write_all(&mut encoder, data)
+            .map_err(|e| E2sError::SnappyCompression(format!("Failed to compress: {e}")))?;
+        encoder
+            .flush()
+            .map_err(|e| E2sError::SnappyCompression(format!("Failed to flush encoder: {e}")))?;
+    }
+    Ok(compressed)
+}
+
+/// Decompress Snappy framed-encoded bytes.
+pub fn snappy_decompress(data: &[u8]) -> Result<Vec<u8>, E2sError> {
+    let mut decoder = FrameDecoder::new(data);
+    let mut decompressed = Vec::new();
+    Read::read_to_end(&mut decoder, &mut decompressed)
+        .map_err(|e| E2sError::SnappyDecompression(format!("Failed to decompress: {e}")))?;
+    Ok(decompressed)
+}
+
+/// Generic codec for Snappy-framed-compressed RLP data.
+#[derive(Debug, Clone, Default)]
+pub struct SnappyRlpCodec<T> {
+    _phantom: PhantomData<T>,
+}
+
+impl<T> SnappyRlpCodec<T> {
+    /// Create a new codec for the given type.
+    pub const fn new() -> Self {
+        Self { _phantom: PhantomData }
+    }
+}
+
+impl<T: Decodable> SnappyRlpCodec<T> {
+    /// Decode compressed data into the target type.
+    ///
+    /// A record holds exactly one RLP value, so any bytes left after it are treated as corruption
+    /// and rejected rather than silently ignored.
+    pub fn decode(&self, compressed_data: &[u8]) -> Result<T, E2sError> {
+        let decompressed = snappy_decompress(compressed_data)?;
+        let mut slice = decompressed.as_slice();
+        let value = T::decode(&mut slice)
+            .map_err(|e| E2sError::Rlp(format!("Failed to decode RLP data: {e}")))?;
+        if !slice.is_empty() {
+            return Err(E2sError::Rlp(format!(
+                "Trailing bytes after RLP value: {} byte(s) remain",
+                slice.len()
+            )));
+        }
+        Ok(value)
+    }
+}
+
+impl<T: Encodable> SnappyRlpCodec<T> {
+    /// Encode data into compressed format.
+    pub fn encode(&self, data: &T) -> Result<Vec<u8>, E2sError> {
+        let mut rlp_data = Vec::new();
+        data.encode(&mut rlp_data);
+        snappy_compress(&rlp_data)
+    }
+}
diff --git a/crates/era/src/common/file_ops.rs b/crates/era/src/common/file_ops.rs
index 3938f9ebe89..081ace4b6a5 100644
--- a/crates/era/src/common/file_ops.rs
+++ b/crates/era/src/common/file_ops.rs
@@ -114,6 +114,8 @@ pub trait FileReader: StreamReader<File> {
     }
 }
 
+impl<T: StreamReader<File>> FileReader for T {}
+
 /// [`StreamWriter`] for writing era-format files
 pub trait StreamWriter<W: Write>: Sized {
     /// The file type this writer handles
@@ -172,26 +174,50 @@ pub enum EraFileType {
     /// Execution layer ERA1 file, `.era1`
     /// Contains execution blocks pre-merge
     Era1,
+    /// Execution layer ERE file, `.ere`
+    /// Contains execution blocks for both pre-merge and post-merge
+    Ere,
 }
 
 impl EraFileType {
-    /// Get the file extension for this type, dot included
+    /// All file types. No extension is a suffix of another, so `from_filename`'s suffix match is
+    /// order-independent.
+    const ALL: [Self; 3] = [Self::Era, Self::Era1, Self::Ere];
+
+    /// Get the canonical file extension for this type, dot included.
+    ///
+    /// Used when writing files. For recognizing downloaded files, which may use an alternate
+    /// extension, see [`extensions`](Self::extensions).
     pub const fn extension(&self) -> &'static str {
         match self {
             Self::Era => ".era",
             Self::Era1 => ".era1",
+            Self::Ere => ".ere",
+        }
+    }
+
+    /// All file extensions this type may be published with, dot included, ordered longest-first.
+    ///
+    /// `ere` files are served as either `.erae` (current ethPandaOps naming) or `.ere`. The
+    /// longest-first order matters for substring scans so `.ere` never matches inside `.erae`.
+    pub const fn extensions(&self) -> &'static [&'static str] {
+        match self {
+            Self::Era => &[".era"],
+            Self::Era1 => &[".era1"],
+            Self::Ere => &[".erae", ".ere"],
         }
     }
 
+    /// Whether files of this type are published with a `checksums.txt` for verification.
+    ///
+    /// Execution-layer files (`era1`, `ere`) ship checksums; consensus-layer `era` files do not.
+    pub const fn has_checksums(&self) -> bool {
+        matches!(self, Self::Era1 | Self::Ere)
+    }
+
     /// Detect file type from a filename
     pub fn from_filename(filename: &str) -> Option<Self> {
-        if filename.ends_with(".era") {
-            Some(Self::Era)
-        } else if filename.ends_with(".era1") {
-            Some(Self::Era1)
-        } else {
-            None
-        }
+        Self::ALL.into_iter().find(|ty| ty.extensions().iter().any(|ext| filename.ends_with(ext)))
     }
 
     /// Generate era file name.
@@ -210,26 +236,24 @@ impl EraFileType {
         era_count: u64,
     ) -> String {
         let hash = format_hash(hash);
-
-        if include_era_count {
-            format!(
-                "{}-{:05}-{:05}-{}{}",
-                network_name,
-                era_number,
-                era_count,
-                hash,
-                self.extension()
-            )
-        } else {
-            format!("{}-{:05}-{}{}", network_name, era_number, hash, self.extension())
-        }
+        // Custom exports insert an `-<era-count>` segment between the era number and the hash.
+        let era_count = if include_era_count { format!("-{era_count:05}") } else { String::new() };
+        format!("{network_name}-{era_number:05}{era_count}-{hash}{}", self.extension())
     }
 
-    /// Detect file type from URL
-    /// By default, it assumes `Era` type
+    /// Detect file type from a URL, defaulting to `Era`.
+    ///
+    /// Resolves by file extension when the URL names a file; otherwise falls back to the `era1`
+    /// host/path substring.
     pub fn from_url(url: &str) -> Self {
+        let file_url = url.split(['?', '#']).next().unwrap_or(url);
+        if let Some(ty) = Self::from_filename(file_url) {
+            return ty;
+        }
         if url.contains("era1") {
             Self::Era1
+        } else if url.contains("erae") {
+            Self::Ere
         } else {
             Self::Era
         }
@@ -243,3 +267,71 @@ pub fn format_hash(hash: Option<[u8; 4]>) -> String {
         None => "00000000".to_string(),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_from_url_detection() {
+        // A URL that names a file resolves by its extension, regardless of the rest of the path.
+        assert_eq!(
+            EraFileType::from_url("https://host/mainnet-00000-abcd1234.ere"),
+            EraFileType::Ere
+        );
+        assert_eq!(
+            EraFileType::from_url("https://host/mainnet-00000-abcd1234.era1"),
+            EraFileType::Era1
+        );
+        assert_eq!(
+            EraFileType::from_url("https://host/mainnet-00000-abcd1234.era"),
+            EraFileType::Era
+        );
+
+        // An ERE file under a path/mirror containing `era1` still resolves by its `.ere` extension.
+        assert_eq!(
+            EraFileType::from_url("https://host/era1/mainnet-00000-abcd1234.ere"),
+            EraFileType::Ere
+        );
+
+        // Directory/index endpoints have no file extension and fall back to the host/path
+        // substring.
+        assert_eq!(EraFileType::from_url("https://mainnet.era1.nimbus.team/"), EraFileType::Era1);
+        assert_eq!(EraFileType::from_url("https://era.ithaca.xyz/"), EraFileType::Era);
+        assert_eq!(
+            EraFileType::from_url("https://data.ethpandaops.io/erae/mainnet/"),
+            EraFileType::Ere
+        );
+    }
+
+    #[test]
+    fn test_from_filename_detection() {
+        assert_eq!(
+            EraFileType::from_filename("mainnet-00000-abcd1234.era"),
+            Some(EraFileType::Era)
+        );
+        assert_eq!(
+            EraFileType::from_filename("mainnet-00000-abcd1234.era1"),
+            Some(EraFileType::Era1)
+        );
+        assert_eq!(
+            EraFileType::from_filename("mainnet-00000-abcd1234.ere"),
+            Some(EraFileType::Ere)
+        );
+        // The alternate `.erae` extension also resolves to `Ere`.
+        assert_eq!(
+            EraFileType::from_filename("mainnet-00000-abcd1234.erae"),
+            Some(EraFileType::Ere)
+        );
+        // Profile postfixes don't change extension detection.
+        assert_eq!(
+            EraFileType::from_filename("mainnet-00000-abcd1234-noproofs.ere"),
+            Some(EraFileType::Ere)
+        );
+        assert_eq!(
+            EraFileType::from_filename("mainnet-00000-abcd1234-noproofs.erae"),
+            Some(EraFileType::Ere)
+        );
+        assert_eq!(EraFileType::from_filename("mainnet-00000-abcd1234.txt"), None);
+    }
+}
diff --git a/crates/era/src/common/mod.rs b/crates/era/src/common/mod.rs
index 3ad45dfdd8a..95a0ec6a3cb 100644
--- a/crates/era/src/common/mod.rs
+++ b/crates/era/src/common/mod.rs
@@ -1,4 +1,13 @@
 //! Common utilities and shared functionality.
 
+pub mod compression;
 pub mod decode;
 pub mod file_ops;
+
+/// Maximum number of entries per e2store era file.
+///
+/// One value for every era format: `.era` files store one beacon block per slot, and
+/// `.ere`/`.era1` files cap their block count at the same number so the header-record accumulator
+/// (`List[HeaderRecord, 8192]`) stays within its SSZ size limit. Numerically this is the beacon
+/// chain `SLOTS_PER_HISTORICAL_ROOT`.
+pub const MAX_ENTRIES_PER_ERA: u64 = 8192;
diff --git a/crates/era/src/e2s/types.rs b/crates/era/src/e2s/types.rs
index dd0e9485da2..0c45acfa52b 100644
--- a/crates/era/src/e2s/types.rs
+++ b/crates/era/src/e2s/types.rs
@@ -136,6 +136,19 @@ impl Entry {
     pub fn is_slot_index(&self) -> bool {
         self.entry_type == SLOT_INDEX
     }
+
+    /// Ensure this entry carries the `expected` type id.
+    ///
+    /// `name` is the human-readable record name used in the error message.
+    pub fn ensure_type(&self, expected: [u8; 2], name: &str) -> Result<(), E2sError> {
+        if self.entry_type != expected {
+            return Err(E2sError::Ssz(format!(
+                "Invalid entry type for {name}: expected {:02x}{:02x}, got {:02x}{:02x}",
+                expected[0], expected[1], self.entry_type[0], self.entry_type[1]
+            )));
+        }
+        Ok(())
+    }
 }
 
 /// Serialize and deserialize index entries with format:
@@ -173,14 +186,7 @@ pub trait IndexEntry: Sized {
 
     /// Create from an [`Entry`]
     fn from_entry(entry: &Entry) -> Result<Self, E2sError> {
-        let expected_type = Self::entry_type();
-
-        if entry.entry_type != expected_type {
-            return Err(E2sError::Ssz(format!(
-                "Invalid entry type: expected {:02x}{:02x}, got {:02x}{:02x}",
-                expected_type[0], expected_type[1], entry.entry_type[0], entry.entry_type[1]
-            )));
-        }
+        entry.ensure_type(Self::entry_type(), "index")?;
 
         if entry.data.len() < 16 {
             return Err(E2sError::Ssz(
diff --git a/crates/era/src/era/file.rs b/crates/era/src/era/file.rs
index 1c1a20543fa..150252133d0 100644
--- a/crates/era/src/era/file.rs
+++ b/crates/era/src/era/file.rs
@@ -6,7 +6,7 @@
 //! See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/era.md>.
 
 use crate::{
-    common::file_ops::{EraFileFormat, FileReader, StreamReader, StreamWriter},
+    common::file_ops::{EraFileFormat, StreamReader, StreamWriter},
     e2s::{
         error::E2sError,
         file::{E2StoreReader, E2StoreWriter},
@@ -20,10 +20,7 @@ use crate::{
         group::{EraGroup, EraId, SlotIndex},
     },
 };
-use std::{
-    fs::File,
-    io::{Read, Seek, Write},
-};
+use std::io::{Read, Seek, Write};
 
 /// Era file interface
 #[derive(Debug)]
@@ -195,8 +192,6 @@ impl<R: Read + Seek> EraReader<R> {
     }
 }
 
-impl FileReader for EraReader<File> {}
-
 /// Writer for Era files that builds on top of [`E2StoreWriter`]
 #[derive(Debug)]
 pub struct EraWriter<W: Write> {
diff --git a/crates/era/src/era/types/group.rs b/crates/era/src/era/types/group.rs
index 2536c0394c2..2d2b96d6933 100644
--- a/crates/era/src/era/types/group.rs
+++ b/crates/era/src/era/types/group.rs
@@ -8,8 +8,10 @@ use crate::{
     era::types::consensus::{CompressedBeaconState, CompressedSignedBeaconBlock},
 };
 
-/// Number of slots per historical root in ERA files
-pub const SLOTS_PER_HISTORICAL_ROOT: u64 = 8192;
+/// Number of slots per historical root in ERA files.
+///
+/// Equals [`crate::common::MAX_ENTRIES_PER_ERA`].
+pub const SLOTS_PER_HISTORICAL_ROOT: u64 = crate::common::MAX_ENTRIES_PER_ERA;
 
 /// Era file content group
 ///
diff --git a/crates/era/src/era1/file.rs b/crates/era/src/era1/file.rs
index 3f230e8ea66..e3b29d3f149 100644
--- a/crates/era/src/era1/file.rs
+++ b/crates/era/src/era1/file.rs
@@ -6,7 +6,7 @@
 //! See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/era1.md>.
 
 use crate::{
-    common::file_ops::{EraFileFormat, FileReader, StreamReader, StreamWriter},
+    common::file_ops::{EraFileFormat, StreamReader, StreamWriter},
     e2s::{
         error::E2sError,
         file::{E2StoreReader, E2StoreWriter},
@@ -24,7 +24,6 @@ use crate::{
 use alloy_primitives::BlockNumber;
 use std::{
     collections::VecDeque,
-    fs::File,
     io::{Read, Seek, Write},
 };
 
@@ -256,8 +255,6 @@ impl<R: Read + Seek> Era1Reader<R> {
     }
 }
 
-impl FileReader for Era1Reader<File> {}
-
 /// Writer for Era1 files that builds on top of [`E2StoreWriter`]
 #[derive(Debug)]
 pub struct Era1Writer<W: Write> {
@@ -406,7 +403,7 @@ impl<W: Write> Era1Writer<W> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::common::file_ops::FileWriter;
+    use crate::common::file_ops::{FileReader, FileWriter};
     use alloy_primitives::{B256, U256};
     use std::io::Cursor;
     use tempfile::tempdir;
diff --git a/crates/era/src/ere/file.rs b/crates/era/src/ere/file.rs
new file mode 100644
index 00000000000..41d4e8da9e4
--- /dev/null
+++ b/crates/era/src/ere/file.rs
@@ -0,0 +1,760 @@
+//! Represents a complete `ere` (era execution) file.
+//!
+//! The structure of an `ere` file follows the specification:
+//! `Version | CompressedHeader+ | CompressedBody+ | CompressedSlimReceipts* | Proof* |
+//! TotalDifficulty* | other-entries* | Accumulator? | DynamicBlockIndex`
+//!
+//! See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md>.
+
+use crate::{
+    common::file_ops::{EraFileFormat, StreamReader, StreamWriter},
+    e2s::{
+        error::E2sError,
+        file::{E2StoreReader, E2StoreWriter},
+        types::{Entry, Version},
+    },
+    ere::types::{
+        execution::{
+            Accumulator, BlockTuple, CompressedBody, CompressedHeader, CompressedSlimReceipts,
+            Proof, TotalDifficulty, ACCUMULATOR, COMPRESSED_BODY, COMPRESSED_HEADER,
+            COMPRESSED_SLIM_RECEIPTS, MAX_BLOCKS_PER_ERE, PROOF, TOTAL_DIFFICULTY,
+        },
+        group::{DynamicBlockIndex, EreGroup, EreId, DYNAMIC_BLOCK_INDEX},
+    },
+};
+use std::{
+    collections::VecDeque,
+    io::{Read, Seek, Write},
+};
+
+/// `ere` file interface
+#[derive(Debug)]
+pub struct EreFile {
+    /// Version record, must be the first record in the file
+    pub version: Version,
+
+    /// Main content group of the `ere` file
+    pub group: EreGroup,
+
+    /// File identifier
+    pub id: EreId,
+}
+
+impl EraFileFormat for EreFile {
+    type EraGroup = EreGroup;
+    type Id = EreId;
+
+    /// Create a new [`EreFile`]
+    fn new(group: EreGroup, id: EreId) -> Self {
+        Self { version: Version, group, id }
+    }
+
+    fn version(&self) -> &Version {
+        &self.version
+    }
+
+    fn group(&self) -> &Self::EraGroup {
+        &self.group
+    }
+
+    fn id(&self) -> &Self::Id {
+        &self.id
+    }
+}
+
+/// Reader for `ere` files that builds on top of [`E2StoreReader`]
+#[derive(Debug)]
+pub struct EreReader<R: Read> {
+    reader: E2StoreReader<R>,
+}
+
+/// An iterator over the [`BlockTuple`]s in an `ere` file.
+///
+/// Records are grouped by type rather than per block, so a complete tuple spans the entire stream.
+/// Iteration is therefore eager: the full set of blocks is materialized up front and yielded from
+/// that buffer, rather than decoded incrementally per item.
+#[derive(Debug)]
+pub struct EreBlockTupleIterator<R: Read> {
+    reader: E2StoreReader<R>,
+    blocks: VecDeque<BlockTuple>,
+    accumulator: Option<Accumulator>,
+    index: Option<DynamicBlockIndex>,
+    other_entries: Vec<Entry>,
+    loaded: bool,
+}
+
+impl<R: Read> EreBlockTupleIterator<R> {
+    const fn new(reader: E2StoreReader<R>) -> Self {
+        Self {
+            reader,
+            blocks: VecDeque::new(),
+            accumulator: None,
+            index: None,
+            other_entries: Vec::new(),
+            loaded: false,
+        }
+    }
+}
+
+impl<R: Read + Seek> EreBlockTupleIterator<R> {
+    /// Drain every remaining entry, bucketing it by record type, then assemble the block tuples.
+    fn load(&mut self) -> Result<(), E2sError> {
+        if self.loaded {
+            return Ok(());
+        }
+        // Set before reading so a mid-stream error is surfaced exactly once.
+        self.loaded = true;
+
+        let mut headers = Vec::new();
+        let mut bodies = Vec::new();
+        let mut receipts = Vec::new();
+        let mut proofs = Vec::new();
+        let mut difficulties = Vec::new();
+
+        while let Some(entry) = self.reader.read_next_entry()? {
+            match entry.entry_type {
+                COMPRESSED_HEADER => headers.push(CompressedHeader::from_entry(&entry)?),
+                COMPRESSED_BODY => bodies.push(CompressedBody::from_entry(&entry)?),
+                COMPRESSED_SLIM_RECEIPTS => {
+                    receipts.push(CompressedSlimReceipts::from_entry(&entry)?)
+                }
+                PROOF => proofs.push(Proof::from_entry(&entry)?),
+                TOTAL_DIFFICULTY => difficulties.push(TotalDifficulty::from_entry(&entry)?),
+                ACCUMULATOR => {
+                    if self.accumulator.is_some() {
+                        return Err(E2sError::Ssz("Multiple accumulator entries found".to_string()));
+                    }
+                    self.accumulator = Some(Accumulator::from_entry(&entry)?);
+                }
+                DYNAMIC_BLOCK_INDEX => {
+                    if self.index.is_some() {
+                        return Err(E2sError::Ssz("Multiple block index entries found".to_string()));
+                    }
+                    self.index = Some(DynamicBlockIndex::from_entry(&entry)?);
+                }
+                _ => self.other_entries.push(entry),
+            }
+        }
+
+        self.blocks = assemble_blocks(headers, bodies, receipts, proofs, difficulties)?;
+        Ok(())
+    }
+}
+
+impl<R: Read + Seek> Iterator for EreBlockTupleIterator<R> {
+    type Item = Result<BlockTuple, E2sError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if !self.loaded &&
+            let Err(err) = self.load()
+        {
+            return Some(Err(err));
+        }
+        self.blocks.pop_front().map(Ok)
+    }
+}
+
+impl<R: Read + Seek> StreamReader<R> for EreReader<R> {
+    type File = EreFile;
+    type Iterator = EreBlockTupleIterator<R>;
+
+    /// Create a new [`EreReader`]
+    fn new(reader: R) -> Self {
+        Self { reader: E2StoreReader::new(reader) }
+    }
+
+    /// Returns an iterator over the [`BlockTuple`]s streamed from `reader`.
+    ///
+    /// Assumes the reader is positioned past the version record; a fresh reader at offset 0 will
+    /// bucket the leading version entry as an unrecognized `other` entry.
+    fn iter(self) -> EreBlockTupleIterator<R> {
+        EreBlockTupleIterator::new(self.reader)
+    }
+
+    fn read(self, network_name: String) -> Result<Self::File, E2sError> {
+        self.read_and_assemble(network_name)
+    }
+}
+
+impl<R: Read + Seek> EreReader<R> {
+    /// Reads and parses an `ere` file from the underlying reader, assembling all components into a
+    /// complete [`EreFile`] with an [`EreId`] that includes the provided network name.
+    pub fn read_and_assemble(mut self, network_name: String) -> Result<EreFile, E2sError> {
+        // Validate the version entry before draining the rest of the stream.
+        match self.reader.read_version()? {
+            Some(entry) if entry.is_version() => {}
+            Some(_) => return Err(E2sError::Ssz("First entry is not a Version entry".to_string())),
+            None => return Err(E2sError::Ssz("Empty ere file".to_string())),
+        }
+
+        let mut iter = self.iter();
+        let blocks = (&mut iter).collect::<Result<Vec<_>, _>>()?;
+
+        let EreBlockTupleIterator { accumulator, index, other_entries, .. } = iter;
+
+        let index =
+            index.ok_or_else(|| E2sError::Ssz("ere file missing block index entry".to_string()))?;
+
+        validate_blocks_and_index(&blocks, &index)?;
+
+        let id = EreId::new(network_name, index.starting_number(), index.block_count() as u32);
+
+        let mut group = EreGroup::new(blocks, accumulator, index);
+        for entry in other_entries {
+            group.add_entry(entry);
+        }
+
+        Ok(EreFile::new(group, id))
+    }
+}
+
+/// Writer for `ere` files that builds on top of [`E2StoreWriter`]
+#[derive(Debug)]
+pub struct EreWriter<W: Write> {
+    writer: E2StoreWriter<W>,
+}
+
+impl<W: Write> StreamWriter<W> for EreWriter<W> {
+    type File = EreFile;
+
+    /// Create a new [`EreWriter`]
+    fn new(writer: W) -> Self {
+        Self { writer: E2StoreWriter::new(writer) }
+    }
+
+    /// Write the version entry
+    fn write_version(&mut self) -> Result<(), E2sError> {
+        self.writer.write_version()
+    }
+
+    /// Write a complete [`EreFile`] to the underlying writer.
+    ///
+    /// Records are emitted in the spec's sectioned order: all headers, all bodies, then each
+    /// optional section (receipts, proofs, total-difficulty), followed by any other entries, the
+    /// optional accumulator, and finally the mandatory block index.
+    fn write_file(&mut self, file: &EreFile) -> Result<(), E2sError> {
+        self.write_version()?;
+
+        let blocks = &file.group.blocks;
+
+        // Reject input the reader could not load back: too many blocks, non-uniform optional
+        // components (which would write a partial section), or an index disagreeing with the
+        // blocks.
+        validate_blocks_and_index(blocks, &file.group.index)?;
+
+        for block in blocks {
+            self.writer.write_entry(&block.header.to_entry())?;
+        }
+        for block in blocks {
+            self.writer.write_entry(&block.body.to_entry())?;
+        }
+        for block in blocks {
+            if let Some(receipts) = &block.receipts {
+                self.writer.write_entry(&receipts.to_entry())?;
+            }
+        }
+        for block in blocks {
+            if let Some(proof) = &block.proof {
+                self.writer.write_entry(&proof.to_entry())?;
+            }
+        }
+        for block in blocks {
+            if let Some(total_difficulty) = &block.total_difficulty {
+                self.writer.write_entry(&total_difficulty.to_entry())?;
+            }
+        }
+
+        for entry in &file.group.other_entries {
+            self.writer.write_entry(entry)?;
+        }
+
+        if let Some(accumulator) = &file.group.accumulator {
+            self.writer.write_entry(&accumulator.to_entry())?;
+        }
+
+        self.writer.write_entry(&file.group.index.to_entry())?;
+
+        self.writer.flush()?;
+        Ok(())
+    }
+
+    /// Flush any buffered data to the underlying writer
+    fn flush(&mut self) -> Result<(), E2sError> {
+        self.writer.flush()
+    }
+}
+
+/// Enforce the `ere` layout invariants tying `blocks` to `index`:
+/// - `blocks.len() <= MAX_BLOCKS_PER_ERE` — the per-file block ceiling;
+/// - `index.block_count() == blocks.len()` — the index spans exactly the serialized blocks;
+/// - every optional component (receipts, total-difficulty, proof) is set on all blocks or none, so
+///   each per-type section has length `0` or `blocks.len()`;
+/// - `index.component_count() == BlockTuple::component_count()` — the offset stride matches the
+///   number of records per block.
+///
+/// Violations are serializable but not decodable (the sectioned reader cannot realign a partial
+/// section), so they are rejected on both the write and read paths.
+fn validate_blocks_and_index(
+    blocks: &[BlockTuple],
+    index: &DynamicBlockIndex,
+) -> Result<(), E2sError> {
+    if blocks.len() > MAX_BLOCKS_PER_ERE {
+        return Err(E2sError::Ssz(format!(
+            "ere file cannot contain more than {MAX_BLOCKS_PER_ERE} blocks, got {}",
+            blocks.len()
+        )));
+    }
+
+    if index.block_count() != blocks.len() {
+        return Err(E2sError::Ssz(format!(
+            "ere index covers {} blocks but the file has {}",
+            index.block_count(),
+            blocks.len()
+        )));
+    }
+
+    let Some(first) = blocks.first() else { return Ok(()) };
+    let (has_receipts, has_difficulty, has_proof) =
+        (first.receipts.is_some(), first.total_difficulty.is_some(), first.proof.is_some());
+
+    for block in blocks {
+        if block.receipts.is_some() != has_receipts ||
+            block.total_difficulty.is_some() != has_difficulty ||
+            block.proof.is_some() != has_proof
+        {
+            return Err(E2sError::Ssz(
+                "ere blocks must share the same optional components (each component present for \
+                 all blocks or none)"
+                    .to_string(),
+            ));
+        }
+    }
+
+    if index.component_count() != first.component_count() {
+        return Err(E2sError::Ssz(format!(
+            "ere index component-count {} does not match block component-count {}",
+            index.component_count(),
+            first.component_count()
+        )));
+    }
+
+    Ok(())
+}
+
+/// Zip the per-type sections of an `ere` file back into [`BlockTuple`]s.
+///
+/// Headers and bodies are mandatory and must be equinumerous. Each optional section must be either
+/// empty (absent for the whole file) or carry exactly one entry per block, mirroring the single,
+/// uniform `component-count` the spec stores in the [`DynamicBlockIndex`].
+fn assemble_blocks(
+    headers: Vec<CompressedHeader>,
+    bodies: Vec<CompressedBody>,
+    receipts: Vec<CompressedSlimReceipts>,
+    proofs: Vec<Proof>,
+    difficulties: Vec<TotalDifficulty>,
+) -> Result<VecDeque<BlockTuple>, E2sError> {
+    let block_count = headers.len();
+    if bodies.len() != block_count {
+        return Err(E2sError::Ssz(format!(
+            "Mismatched header/body counts: headers={block_count}, bodies={}",
+            bodies.len()
+        )));
+    }
+
+    let mut receipts = optional_section(receipts, block_count)?;
+    let mut difficulties = optional_section(difficulties, block_count)?;
+    let mut proofs = optional_section(proofs, block_count)?;
+
+    let mut blocks = VecDeque::with_capacity(block_count);
+    for (header, body) in headers.into_iter().zip(bodies) {
+        let mut block = BlockTuple::new(header, body);
+        if let Some(receipts) = receipts.next().flatten() {
+            block = block.with_receipts(receipts);
+        }
+        if let Some(difficulty) = difficulties.next().flatten() {
+            block = block.with_total_difficulty(difficulty);
+        }
+        if let Some(proof) = proofs.next().flatten() {
+            block = block.with_proof(proof);
+        }
+        blocks.push_back(block);
+    }
+
+    Ok(blocks)
+}
+
+/// Expand an optional component column into one `Option<T>` per block.
+///
+/// The `component-count` is file-uniform, so a component is encoded for every block or for none: an
+/// empty column maps to `block_count` `None`s and a full column to its wrapped values. Any other
+/// length breaks the column/block alignment and is rejected.
+fn optional_section<T>(
+    section: Vec<T>,
+    block_count: usize,
+) -> Result<impl Iterator<Item = Option<T>>, E2sError> {
+    let slots: Vec<Option<T>> = match section.len() {
+        0 => (0..block_count).map(|_| None).collect(),
+        n if n == block_count => section.into_iter().map(Some).collect(),
+        n => {
+            return Err(E2sError::Ssz(format!(
+                "ere optional section length must be 0 or {block_count}, got {n}"
+            )))
+        }
+    };
+    Ok(slots.into_iter())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy_primitives::{B256, U256};
+    use std::io::Cursor;
+
+    /// Build a test block tuple. Optional components are attached based on the flags so tests can
+    /// exercise the full 2-5 component-count range.
+    fn create_test_block(
+        number: u64,
+        data_size: usize,
+        with_receipts: bool,
+        with_difficulty: bool,
+        with_proof: bool,
+    ) -> BlockTuple {
+        let header = CompressedHeader::new(vec![(number % 256) as u8; data_size]);
+        let body = CompressedBody::new(vec![((number + 1) % 256) as u8; data_size * 2]);
+
+        let mut block = BlockTuple::new(header, body);
+        if with_receipts {
+            block = block.with_receipts(CompressedSlimReceipts::new(vec![
+                ((number + 2) % 256)
+                    as u8;
+                data_size
+            ]));
+        }
+        if with_difficulty {
+            block = block.with_total_difficulty(TotalDifficulty::new(U256::from(number * 1000)));
+        }
+        if with_proof {
+            block = block.with_proof(Proof::new(vec![((number + 3) % 256) as u8; data_size]));
+        }
+        block
+    }
+
+    /// Build a test [`EreFile`]. The block index records the component-count derived from the first
+    /// block, mirroring the uniform layout the spec mandates.
+    fn create_test_ere_file(
+        start_block: u64,
+        block_count: usize,
+        network: &str,
+        with_receipts: bool,
+        with_difficulty: bool,
+        with_proof: bool,
+        with_accumulator: bool,
+    ) -> EreFile {
+        let mut blocks = Vec::with_capacity(block_count);
+        for i in 0..block_count {
+            blocks.push(create_test_block(
+                start_block + i as u64,
+                32,
+                with_receipts,
+                with_difficulty,
+                with_proof,
+            ));
+        }
+
+        let component_count = blocks.first().map_or(2, BlockTuple::component_count);
+        // Offsets are placeholders here; the index is stored and read back verbatim, so the values
+        // are not interpreted when assembling blocks.
+        let offsets = (0..(block_count as u64 * component_count) as i64).collect();
+        let index = DynamicBlockIndex::new(start_block, component_count, offsets);
+
+        let accumulator = with_accumulator.then(|| Accumulator::new(B256::from([0xAA; 32])));
+        let group = EreGroup::new(blocks, accumulator, index);
+        let id = EreId::new(network, start_block, block_count as u32);
+
+        EreFile::new(group, id)
+    }
+
+    /// Assert two block tuples carry identical compressed payloads and optional components.
+    fn assert_block_eq(actual: &BlockTuple, expected: &BlockTuple) {
+        assert_eq!(actual.header.data, expected.header.data);
+        assert_eq!(actual.body.data, expected.body.data);
+        assert_eq!(
+            actual.receipts.as_ref().map(|r| &r.data),
+            expected.receipts.as_ref().map(|r| &r.data)
+        );
+        assert_eq!(
+            actual.total_difficulty.as_ref().map(|d| d.value),
+            expected.total_difficulty.as_ref().map(|d| d.value)
+        );
+        assert_eq!(
+            actual.proof.as_ref().map(|p| &p.data),
+            expected.proof.as_ref().map(|p| &p.data)
+        );
+    }
+
+    /// Write `original` to an in-memory buffer and read it back.
+    fn write_then_read(original: &EreFile, network: &str) -> EreFile {
+        let mut buffer = Vec::new();
+        EreWriter::new(&mut buffer).write_file(original).expect("write");
+        EreReader::new(Cursor::new(&buffer)).read(network.to_string()).expect("read")
+    }
+
+    #[test]
+    fn test_ere_write_read_all_components() {
+        // Pre-merge file: every optional component present (component-count 5) plus accumulator.
+        let original = create_test_ere_file(1000, 4, "testnet", true, true, true, true);
+        let read = write_then_read(&original, "testnet");
+
+        assert_eq!(read.id.network_name, "testnet");
+        assert_eq!(read.id.start_block, 1000);
+        assert_eq!(read.id.block_count, 4);
+        assert_eq!(read.group.blocks.len(), 4);
+        assert_eq!(read.group.index, original.group.index);
+        assert_eq!(read.group.accumulator, original.group.accumulator);
+
+        for (read_block, original_block) in read.group.blocks.iter().zip(&original.group.blocks) {
+            assert_eq!(read_block.component_count(), 5);
+            assert_block_eq(read_block, original_block);
+        }
+    }
+
+    #[test]
+    fn test_ere_write_read_header_body_only() {
+        // Post-merge subset file: only header + body (component-count 2), no accumulator.
+        let original = create_test_ere_file(2000, 3, "mainnet", false, false, false, false);
+        let read = write_then_read(&original, "mainnet");
+
+        assert_eq!(read.group.blocks.len(), 3);
+        assert!(read.group.accumulator.is_none());
+        assert_eq!(read.group.index, original.group.index);
+
+        for (read_block, original_block) in read.group.blocks.iter().zip(&original.group.blocks) {
+            assert_eq!(read_block.component_count(), 2);
+            assert!(read_block.receipts.is_none());
+            assert!(read_block.total_difficulty.is_none());
+            assert!(read_block.proof.is_none());
+            assert_block_eq(read_block, original_block);
+        }
+    }
+
+    #[test]
+    fn test_ere_write_read_partial_components() {
+        // `noproofs` profile: receipts and difficulty present, proofs absent (component-count 4).
+        let original = create_test_ere_file(0, 2, "sepolia", true, true, false, true);
+        let read = write_then_read(&original, "sepolia");
+
+        for block in &read.group.blocks {
+            assert_eq!(block.component_count(), 4);
+            assert!(block.receipts.is_some());
+            assert!(block.total_difficulty.is_some());
+            assert!(block.proof.is_none());
+        }
+    }
+
+    #[test]
+    fn test_ere_write_read_preserves_other_entries() {
+        let mut original = create_test_ere_file(1000, 1, "testnet", true, true, true, true);
+        original.group.add_entry(Entry::new([0x42, 0x42], vec![1, 2, 3, 4]));
+
+        let read = write_then_read(&original, "testnet");
+
+        assert_eq!(read.group.other_entries.len(), 1);
+        assert_eq!(read.group.other_entries[0].entry_type, [0x42, 0x42]);
+        assert_eq!(read.group.other_entries[0].data, vec![1, 2, 3, 4]);
+    }
+
+    #[test]
+    fn test_ere_read_rejects_missing_index() {
+        // A file with blocks but no DynamicBlockIndex must be rejected.
+        let mut buffer = Vec::new();
+        {
+            let mut writer = E2StoreWriter::new(&mut buffer);
+            writer.write_version().unwrap();
+            let block = create_test_block(1, 8, false, false, false);
+            writer.write_entry(&block.header.to_entry()).unwrap();
+            writer.write_entry(&block.body.to_entry()).unwrap();
+            writer.flush().unwrap();
+        }
+
+        let err = EreReader::new(Cursor::new(&buffer)).read("testnet".to_string());
+        assert!(err.is_err());
+    }
+
+    #[test]
+    fn test_ere_read_rejects_partial_optional_section() {
+        // Two blocks but only one receipts entry: the optional section is neither empty nor 1-per
+        // block, so assembly must fail.
+        let mut buffer = Vec::new();
+        {
+            let mut writer = E2StoreWriter::new(&mut buffer);
+            writer.write_version().unwrap();
+            let b0 = create_test_block(0, 8, false, false, false);
+            let b1 = create_test_block(1, 8, false, false, false);
+            writer.write_entry(&b0.header.to_entry()).unwrap();
+            writer.write_entry(&b1.header.to_entry()).unwrap();
+            writer.write_entry(&b0.body.to_entry()).unwrap();
+            writer.write_entry(&b1.body.to_entry()).unwrap();
+            // Only one receipts entry for two blocks.
+            writer.write_entry(&CompressedSlimReceipts::new(vec![0xCC; 8]).to_entry()).unwrap();
+            writer.write_entry(&DynamicBlockIndex::new(0, 2, vec![0, 1, 2, 3]).to_entry()).unwrap();
+            writer.flush().unwrap();
+        }
+
+        let err = EreReader::new(Cursor::new(&buffer)).read("testnet".to_string());
+        assert!(err.is_err());
+    }
+
+    #[test]
+    fn test_ere_write_read_empty() {
+        // No blocks: the header/body sections are empty and the index covers zero blocks.
+        let original = create_test_ere_file(0, 0, "testnet", false, false, false, false);
+        let read = write_then_read(&original, "testnet");
+
+        assert_eq!(read.group.blocks.len(), 0);
+        assert_eq!(read.id.block_count, 0);
+        assert_eq!(read.group.index, original.group.index);
+    }
+
+    #[test]
+    fn test_ere_read_rejects_empty_input() {
+        // No version record at all.
+        let err = EreReader::new(Cursor::new(Vec::new())).read("testnet".to_string());
+        assert!(err.is_err());
+    }
+
+    #[test]
+    fn test_ere_read_rejects_non_version_first_entry() {
+        // The first record must be the version; a stray entry up front is rejected.
+        let mut buffer = Vec::new();
+        Entry::new([0x99, 0x99], vec![1, 2, 3]).write(&mut buffer).unwrap();
+
+        let err = EreReader::new(Cursor::new(&buffer)).read("testnet".to_string());
+        assert!(err.is_err());
+    }
+
+    #[test]
+    fn test_ere_read_rejects_header_body_mismatch() {
+        // Two headers but one body: the mandatory sections must be equinumerous.
+        let mut buffer = Vec::new();
+        {
+            let mut writer = E2StoreWriter::new(&mut buffer);
+            writer.write_version().unwrap();
+            let b0 = create_test_block(0, 8, false, false, false);
+            let b1 = create_test_block(1, 8, false, false, false);
+            writer.write_entry(&b0.header.to_entry()).unwrap();
+            writer.write_entry(&b1.header.to_entry()).unwrap();
+            writer.write_entry(&b0.body.to_entry()).unwrap();
+            writer.write_entry(&DynamicBlockIndex::new(0, 2, vec![0, 1, 2, 3]).to_entry()).unwrap();
+            writer.flush().unwrap();
+        }
+
+        let err = EreReader::new(Cursor::new(&buffer)).read("testnet".to_string());
+        assert!(err.is_err());
+    }
+
+    #[test]
+    fn test_ere_read_rejects_duplicate_index() {
+        // A second DynamicBlockIndex record must be rejected.
+        let mut buffer = Vec::new();
+        {
+            let mut writer = E2StoreWriter::new(&mut buffer);
+            writer.write_version().unwrap();
+            writer.write_entry(&DynamicBlockIndex::new(0, 2, Vec::new()).to_entry()).unwrap();
+            writer.write_entry(&DynamicBlockIndex::new(0, 2, Vec::new()).to_entry()).unwrap();
+            writer.flush().unwrap();
+        }
+
+        let err = EreReader::new(Cursor::new(&buffer)).read("testnet".to_string());
+        assert!(err.is_err());
+    }
+
+    #[test]
+    fn test_ere_write_rejects_non_uniform_components() {
+        // Block 0 carries receipts, block 1 does not: the sectioned layout would write a partial
+        // receipts section the reader cannot reassemble, so the writer must reject it up front.
+        let blocks = vec![
+            create_test_block(0, 8, true, false, false),
+            create_test_block(1, 8, false, false, false),
+        ];
+        let index = DynamicBlockIndex::new(0, 3, vec![0, 1, 2, 3, 4, 5]);
+        let file = EreFile::new(EreGroup::new(blocks, None, index), EreId::new("testnet", 0, 2));
+
+        let err = EreWriter::new(&mut Vec::new()).write_file(&file);
+        assert!(err.is_err());
+    }
+
+    #[test]
+    fn test_ere_write_rejects_too_many_blocks() {
+        // One block over the per-file ceiling must be rejected before any record is written.
+        let file =
+            create_test_ere_file(0, MAX_BLOCKS_PER_ERE + 1, "testnet", false, false, false, false);
+
+        let err = EreWriter::new(&mut Vec::new()).write_file(&file);
+        assert!(err.is_err());
+    }
+
+    #[test]
+    fn test_ere_write_rejects_index_block_count_mismatch() {
+        // Two blocks but an index that covers only one.
+        let mut file = create_test_ere_file(0, 2, "testnet", false, false, false, false);
+        file.group.index = DynamicBlockIndex::new(0, 2, vec![0, 1]);
+
+        let err = EreWriter::new(&mut Vec::new()).write_file(&file);
+        assert!(err.is_err());
+    }
+
+    #[test]
+    fn test_ere_read_rejects_index_block_count_mismatch() {
+        // Two header/body blocks written, but the index declares only one block.
+        let mut buffer = Vec::new();
+        {
+            let mut writer = E2StoreWriter::new(&mut buffer);
+            writer.write_version().unwrap();
+            let b0 = create_test_block(0, 8, false, false, false);
+            let b1 = create_test_block(1, 8, false, false, false);
+            writer.write_entry(&b0.header.to_entry()).unwrap();
+            writer.write_entry(&b1.header.to_entry()).unwrap();
+            writer.write_entry(&b0.body.to_entry()).unwrap();
+            writer.write_entry(&b1.body.to_entry()).unwrap();
+            writer.write_entry(&DynamicBlockIndex::new(0, 2, vec![0, 1]).to_entry()).unwrap();
+            writer.flush().unwrap();
+        }
+
+        let err = EreReader::new(Cursor::new(&buffer)).read("testnet".to_string());
+        assert!(err.is_err());
+    }
+
+    #[test]
+    fn test_ere_write_version_then_write_file_writes_single_version() {
+        // `write_version` followed by `write_file` must not emit two version records; the dedup
+        // lives in `E2StoreWriter`, so no redundant flag is needed on `EreWriter`.
+        let original = create_test_ere_file(0, 1, "testnet", false, false, false, false);
+
+        let mut buffer = Vec::new();
+        {
+            let mut writer = EreWriter::new(&mut buffer);
+            writer.write_version().unwrap();
+            writer.write_file(&original).unwrap();
+        }
+
+        let entries = E2StoreReader::new(Cursor::new(&buffer)).entries().unwrap();
+        assert_eq!(entries.iter().filter(|entry| entry.is_version()).count(), 1);
+    }
+
+    #[test]
+    fn test_ere_read_rejects_duplicate_accumulator() {
+        // A second Accumulator record must be rejected.
+        let mut buffer = Vec::new();
+        {
+            let mut writer = E2StoreWriter::new(&mut buffer);
+            writer.write_version().unwrap();
+            writer.write_entry(&Accumulator::new(B256::from([0x11; 32])).to_entry()).unwrap();
+            writer.write_entry(&Accumulator::new(B256::from([0x22; 32])).to_entry()).unwrap();
+            writer.write_entry(&DynamicBlockIndex::new(0, 2, Vec::new()).to_entry()).unwrap();
+            writer.flush().unwrap();
+        }
+
+        let err = EreReader::new(Cursor::new(&buffer)).read("testnet".to_string());
+        assert!(err.is_err());
+    }
+}
diff --git a/crates/era/src/ere/mod.rs b/crates/era/src/ere/mod.rs
new file mode 100644
index 00000000000..2337ef29572
--- /dev/null
+++ b/crates/era/src/ere/mod.rs
@@ -0,0 +1,6 @@
+//! Core `ere` (era execution) primitives.
+//!
+//! See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md>
+
+pub mod file;
+pub mod types;
diff --git a/crates/era/src/ere/types/execution.rs b/crates/era/src/ere/types/execution.rs
new file mode 100644
index 00000000000..8fb11fdff7e
--- /dev/null
+++ b/crates/era/src/ere/types/execution.rs
@@ -0,0 +1,964 @@
+//! Execution layer specific types for `.ere` files
+//!
+//! Contains implementations for compressed execution layer data structures:
+//! - [`CompressedHeader`] - Block header
+//! - [`CompressedBody`] - Block body
+//! - [`CompressedSlimReceipts`] - Block receipts
+//! - [`TotalDifficulty`] - Block total difficulty
+//!
+//! These types use Snappy compression to match the specification.
+//!
+//! See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md>
+
+use crate::{
+    common::{
+        compression::{snappy_compress, snappy_decompress, SnappyRlpCodec},
+        decode::DecodeCompressedRlp,
+    },
+    e2s::{error::E2sError, types::Entry},
+};
+use alloy_consensus::{Block, BlockBody, Eip658Value, Header, TxType};
+use alloy_primitives::{Log, B256, U256};
+use alloy_rlp::{Decodable, Encodable, RlpDecodable, RlpEncodable};
+use sha2::{Digest, Sha256};
+
+// ERE-specific constants
+/// `CompressedHeader` record type
+pub const COMPRESSED_HEADER: [u8; 2] = [0x03, 0x00];
+
+/// `CompressedBody` record type
+pub const COMPRESSED_BODY: [u8; 2] = [0x04, 0x00];
+
+/// `CompressedSlimReceipts` record type (0x0a00)
+/// Slim receipts exclude bloom filters to optimize storage.
+pub const COMPRESSED_SLIM_RECEIPTS: [u8; 2] = [0x0a, 0x00];
+
+/// `Proof` record type (0x0b00)
+/// Format: `snappyFramed(rlp([proof-type, ssz(proof-object)]))`
+pub const PROOF: [u8; 2] = [0x0b, 0x00];
+
+/// `TotalDifficulty` record type
+pub const TOTAL_DIFFICULTY: [u8; 2] = [0x06, 0x00];
+
+/// `Accumulator` record type
+pub const ACCUMULATOR: [u8; 2] = [0x07, 0x00];
+
+/// Maximum number of blocks in an `ERE` file, limited by accumulator size.
+pub const MAX_BLOCKS_PER_ERE: usize = crate::common::MAX_ENTRIES_PER_ERA as usize;
+
+/// Compressed block header using `snappyFramed(rlp(header))`
+#[derive(Debug, Clone)]
+pub struct CompressedHeader {
+    /// The compressed data
+    pub data: Vec<u8>,
+}
+
+impl CompressedHeader {
+    /// Create a new [`CompressedHeader`] from compressed data
+    pub const fn new(data: Vec<u8>) -> Self {
+        Self { data }
+    }
+
+    /// Create from RLP-encoded header by compressing it with Snappy framed encoding
+    pub fn from_rlp(rlp_data: &[u8]) -> Result<Self, E2sError> {
+        Ok(Self { data: snappy_compress(rlp_data)? })
+    }
+
+    /// Decompress to get the original RLP-encoded header
+    pub fn decompress(&self) -> Result<Vec<u8>, E2sError> {
+        snappy_decompress(&self.data)
+    }
+
+    /// Convert to an [`Entry`]
+    pub fn to_entry(&self) -> Entry {
+        Entry::new(COMPRESSED_HEADER, self.data.clone())
+    }
+
+    /// Create from an [`Entry`]
+    pub fn from_entry(entry: &Entry) -> Result<Self, E2sError> {
+        entry.ensure_type(COMPRESSED_HEADER, "CompressedHeader")?;
+        Ok(Self { data: entry.data.clone() })
+    }
+
+    /// Decode this compressed header into an `alloy_consensus::Header`
+    pub fn decode_header(&self) -> Result<Header, E2sError> {
+        self.decode()
+    }
+
+    /// Create a [`CompressedHeader`] from a header
+    pub fn from_header<H: Encodable>(header: &H) -> Result<Self, E2sError> {
+        let encoder = SnappyRlpCodec::new();
+        let compressed = encoder.encode(header)?;
+        Ok(Self::new(compressed))
+    }
+}
+
+impl DecodeCompressedRlp for CompressedHeader {
+    fn decode<T: Decodable>(&self) -> Result<T, E2sError> {
+        let decoder = SnappyRlpCodec::<T>::new();
+        decoder.decode(&self.data)
+    }
+}
+
+/// Compressed block body using `snappyFramed(rlp(body))`
+#[derive(Debug, Clone)]
+pub struct CompressedBody {
+    /// The compressed data
+    pub data: Vec<u8>,
+}
+
+impl CompressedBody {
+    /// Create a new [`CompressedBody`] from compressed data
+    pub const fn new(data: Vec<u8>) -> Self {
+        Self { data }
+    }
+
+    /// Create from RLP-encoded body by compressing it with Snappy framed encoding
+    pub fn from_rlp(rlp_data: &[u8]) -> Result<Self, E2sError> {
+        Ok(Self { data: snappy_compress(rlp_data)? })
+    }
+
+    /// Decompress to get the original RLP-encoded body
+    pub fn decompress(&self) -> Result<Vec<u8>, E2sError> {
+        snappy_decompress(&self.data)
+    }
+
+    /// Convert to an [`Entry`]
+    pub fn to_entry(&self) -> Entry {
+        Entry::new(COMPRESSED_BODY, self.data.clone())
+    }
+
+    /// Create from an [`Entry`]
+    pub fn from_entry(entry: &Entry) -> Result<Self, E2sError> {
+        entry.ensure_type(COMPRESSED_BODY, "CompressedBody")?;
+        Ok(Self { data: entry.data.clone() })
+    }
+
+    /// Decode this [`CompressedBody`] into an `alloy_consensus::BlockBody`
+    pub fn decode_body<T: Decodable, H: Decodable>(&self) -> Result<BlockBody<T, H>, E2sError> {
+        let decompressed = self.decompress()?;
+        Self::decode_body_from_decompressed(&decompressed)
+    }
+
+    /// Decode decompressed body data into an `alloy_consensus::BlockBody`
+    pub fn decode_body_from_decompressed<T: Decodable, H: Decodable>(
+        data: &[u8],
+    ) -> Result<BlockBody<T, H>, E2sError> {
+        alloy_rlp::decode_exact::<BlockBody<T, H>>(data)
+            .map_err(|e| E2sError::Rlp(format!("Failed to decode RLP data: {e}")))
+    }
+
+    /// Create a [`CompressedBody`] from a block body (e.g.  `alloy_consensus::BlockBody`)
+    pub fn from_body<B: Encodable>(body: &B) -> Result<Self, E2sError> {
+        let encoder = SnappyRlpCodec::new();
+        let compressed = encoder.encode(body)?;
+        Ok(Self::new(compressed))
+    }
+}
+
+impl DecodeCompressedRlp for CompressedBody {
+    fn decode<T: Decodable>(&self) -> Result<T, E2sError> {
+        let decoder = SnappyRlpCodec::<T>::new();
+        decoder.decode(&self.data)
+    }
+}
+
+/// Compressed slim receipts using `snappyFramed(rlp(...))`.
+///
+/// Slim receipts exclude bloom filters to optimize storage.
+/// Format: `snappyFramed(rlp([tx-type, post-state-or-status, cumulative-gas, logs]))`
+#[derive(Debug, Clone)]
+pub struct CompressedSlimReceipts {
+    /// The compressed data
+    pub data: Vec<u8>,
+}
+
+impl CompressedSlimReceipts {
+    /// Create a new [`CompressedSlimReceipts`] from compressed data
+    pub const fn new(data: Vec<u8>) -> Self {
+        Self { data }
+    }
+
+    /// Create from RLP-encoded slim receipts by compressing with Snappy framed encoding
+    pub fn from_rlp(rlp_data: &[u8]) -> Result<Self, E2sError> {
+        Ok(Self { data: snappy_compress(rlp_data)? })
+    }
+
+    /// Decompress to get the original RLP-encoded slim receipts
+    pub fn decompress(&self) -> Result<Vec<u8>, E2sError> {
+        snappy_decompress(&self.data)
+    }
+
+    /// Convert to an [`Entry`]
+    pub fn to_entry(&self) -> Entry {
+        Entry::new(COMPRESSED_SLIM_RECEIPTS, self.data.clone())
+    }
+
+    /// Create from an [`Entry`]
+    pub fn from_entry(entry: &Entry) -> Result<Self, E2sError> {
+        entry.ensure_type(COMPRESSED_SLIM_RECEIPTS, "CompressedSlimReceipts")?;
+        Ok(Self { data: entry.data.clone() })
+    }
+
+    /// Decode this [`CompressedSlimReceipts`] into the given type
+    pub fn decode<T: Decodable>(&self) -> Result<T, E2sError> {
+        let decoder = SnappyRlpCodec::<T>::new();
+        decoder.decode(&self.data)
+    }
+
+    /// Create [`CompressedSlimReceipts`] from an encodable type
+    pub fn from_encodable<T: Encodable>(data: &T) -> Result<Self, E2sError> {
+        let encoder = SnappyRlpCodec::<T>::new();
+        let compressed = encoder.encode(data)?;
+        Ok(Self::new(compressed))
+    }
+
+    /// Encode and compress a list of slim receipts
+    pub fn from_encodable_list<T: Encodable>(receipts: &[T]) -> Result<Self, E2sError> {
+        let mut rlp_data = Vec::new();
+        alloy_rlp::encode_list(receipts, &mut rlp_data);
+        Self::from_rlp(&rlp_data)
+    }
+
+    /// Compress a block's slim receipts.
+    ///
+    /// [`SlimReceipt`] is the canonical slim receipt: its RLP encoding is the 4-element list
+    /// `[tx-type, post-state-or-status, cumulative-gas, logs]`, with no bloom filter.
+    pub fn from_receipts(receipts: &[SlimReceipt]) -> Result<Self, E2sError> {
+        Self::from_encodable_list(receipts)
+    }
+
+    /// Decompress and decode this entry into a block's slim receipts.
+    pub fn decode_receipts(&self) -> Result<Vec<SlimReceipt>, E2sError> {
+        self.decode()
+    }
+}
+
+impl DecodeCompressedRlp for CompressedSlimReceipts {
+    fn decode<T: Decodable>(&self) -> Result<T, E2sError> {
+        let decoder = SnappyRlpCodec::<T>::new();
+        decoder.decode(&self.data)
+    }
+}
+
+/// A slim execution receipt as stored in an `ERE` file.
+///
+/// Per the spec, the slim form is the 4-element RLP list
+/// `[tx-type, post-state-or-status, cumulative-gas, logs]` with **no bloom filter** (the bloom is
+/// recomputable from the logs). This is a thin wrapper over alloy's field types: [`Eip658Value`]
+/// captures both the pre-Byzantium 32-byte post-state root and the post-Byzantium boolean status,
+/// so a single type decodes receipts across every fork.
+#[derive(Debug, Clone, PartialEq, Eq, RlpEncodable, RlpDecodable)]
+pub struct SlimReceipt {
+    /// Transaction type (EIP-2718).
+    pub tx_type: TxType,
+    /// Post-state root (pre-Byzantium) or success status (post-Byzantium).
+    pub status: Eip658Value,
+    /// Cumulative gas used in the block up to and including this transaction.
+    pub cumulative_gas_used: u64,
+    /// Logs emitted by the transaction.
+    pub logs: Vec<Log>,
+}
+
+/// Proof type discriminant used inside the Proof entry's RLP envelope.
+///
+/// Maps to specific Portal Network proof objects.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum ProofType {
+    /// Pre-merge proof against the historical hashes accumulator
+    BlockProofHistoricalHashesAccumulator = 0,
+    /// Post-merge proof against historical roots
+    BlockProofHistoricalRoots = 1,
+    /// Capella-era proof against historical summaries
+    BlockProofHistoricalSummariesCapella = 2,
+    /// Deneb-era proof against historical summaries
+    BlockProofHistoricalSummariesDeneb = 3,
+}
+
+impl ProofType {
+    /// Convert from a raw byte value
+    pub const fn from_byte(value: u8) -> Option<Self> {
+        match value {
+            0 => Some(Self::BlockProofHistoricalHashesAccumulator),
+            1 => Some(Self::BlockProofHistoricalRoots),
+            2 => Some(Self::BlockProofHistoricalSummariesCapella),
+            3 => Some(Self::BlockProofHistoricalSummariesDeneb),
+            _ => None,
+        }
+    }
+
+    /// Convert to a raw byte value
+    pub const fn as_byte(self) -> u8 {
+        self as u8
+    }
+}
+
+/// A proof entry attesting to block validity against a trusted consensus layer header.
+///
+/// Format: `snappyFramed(rlp([proof-type, ssz(proof-object)]))`
+///
+/// Multiple proof types can coexist in the same file at fork boundaries.
+#[derive(Debug, Clone)]
+pub struct Proof {
+    /// The compressed data containing `rlp([proof-type, ssz(proof-object)])`
+    pub data: Vec<u8>,
+}
+
+impl Proof {
+    /// Create a new [`Proof`] from already-compressed data
+    pub const fn new(data: Vec<u8>) -> Self {
+        Self { data }
+    }
+
+    /// Encode a [`Proof`] from a proof type and raw SSZ-encoded proof object.
+    pub fn encode(proof_type: ProofType, ssz_proof: &[u8]) -> Result<Self, E2sError> {
+        // Build the list payload first so the RLP list header gets the exact length,
+        // regardless of how each item encodes.
+        let mut payload = Vec::new();
+        proof_type.as_byte().encode(&mut payload);
+        ssz_proof.encode(&mut payload);
+
+        let mut rlp_data = Vec::new();
+        alloy_rlp::Header { list: true, payload_length: payload.len() }.encode(&mut rlp_data);
+        rlp_data.extend_from_slice(&payload);
+
+        Ok(Self { data: snappy_compress(&rlp_data)? })
+    }
+
+    /// Decode the proof, returning `(proof_type, raw_ssz_proof_bytes)`.
+    pub fn decode(&self) -> Result<(ProofType, Vec<u8>), E2sError> {
+        let decompressed = snappy_decompress(&self.data)?;
+
+        let mut buf = decompressed.as_slice();
+        let header = alloy_rlp::Header::decode(&mut buf)
+            .map_err(|e| E2sError::Rlp(format!("Failed to decode proof RLP header: {e}")))?;
+        if !header.list {
+            return Err(E2sError::Rlp("Expected RLP list for Proof entry".to_string()));
+        }
+
+        // A proof is exactly the two-item list `[proof-type, ssz(proof-object)]`. Pin decoding to
+        // the list's own payload so nothing outside it slips through: bytes after the list end, or
+        // a third item inside it, both fail instead of being silently dropped.
+        if buf.len() != header.payload_length {
+            return Err(E2sError::Rlp(format!(
+                "Trailing bytes after Proof list: {} byte(s) beyond the list payload",
+                buf.len().saturating_sub(header.payload_length)
+            )));
+        }
+        let mut payload = &buf[..header.payload_length];
+
+        let proof_type_byte = u8::decode(&mut payload)
+            .map_err(|e| E2sError::Rlp(format!("Failed to decode proof type: {e}")))?;
+        let proof_type = ProofType::from_byte(proof_type_byte)
+            .ok_or_else(|| E2sError::Rlp(format!("Unknown proof type: {proof_type_byte}")))?;
+
+        let ssz_bytes = alloy_primitives::Bytes::decode(&mut payload)
+            .map_err(|e| E2sError::Rlp(format!("Failed to decode proof SSZ bytes: {e}")))?;
+
+        if !payload.is_empty() {
+            return Err(E2sError::Rlp("Unexpected extra items in Proof list".to_string()));
+        }
+
+        Ok((proof_type, ssz_bytes.to_vec()))
+    }
+
+    /// Convert to an [`Entry`]
+    pub fn to_entry(&self) -> Entry {
+        Entry::new(PROOF, self.data.clone())
+    }
+
+    /// Create from an [`Entry`]
+    pub fn from_entry(entry: &Entry) -> Result<Self, E2sError> {
+        entry.ensure_type(PROOF, "Proof")?;
+        Ok(Self { data: entry.data.clone() })
+    }
+}
+
+/// Total difficulty for a block
+#[derive(Debug, Clone)]
+pub struct TotalDifficulty {
+    /// The total difficulty as U256
+    pub value: U256,
+}
+
+impl TotalDifficulty {
+    /// Create a new [`TotalDifficulty`] from a U256 value
+    pub const fn new(value: U256) -> Self {
+        Self { value }
+    }
+
+    /// Convert to an [`Entry`]
+    pub fn to_entry(&self) -> Entry {
+        // ere spec: `total-difficulty = { type: 0x0600, data: SSZ uint256 }` (little-endian)
+        let data = self.value.to_le_bytes::<32>().to_vec();
+        Entry::new(TOTAL_DIFFICULTY, data)
+    }
+
+    /// Create from an [`Entry`]
+    pub fn from_entry(entry: &Entry) -> Result<Self, E2sError> {
+        entry.ensure_type(TOTAL_DIFFICULTY, "TotalDifficulty")?;
+
+        if entry.data.len() != 32 {
+            return Err(E2sError::Ssz(format!(
+                "Invalid data length for TotalDifficulty: expected 32, got {}",
+                entry.data.len()
+            )));
+        }
+
+        // ere spec: `total-difficulty = { type: 0x0600, data: SSZ uint256 }` (little-endian)
+        let value = U256::from_le_slice(&entry.data);
+
+        Ok(Self { value })
+    }
+}
+
+/// Accumulator is computed by constructing an SSZ list of header-records
+/// and calculating the `hash_tree_root`
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Accumulator {
+    /// The accumulator root hash
+    pub root: B256,
+}
+
+impl Accumulator {
+    /// Create a new [`Accumulator`] from a root hash
+    pub const fn new(root: B256) -> Self {
+        Self { root }
+    }
+
+    /// Convert to an [`Entry`]
+    pub fn to_entry(&self) -> Entry {
+        Entry::new(ACCUMULATOR, self.root.to_vec())
+    }
+
+    /// Create from an [`Entry`]
+    pub fn from_entry(entry: &Entry) -> Result<Self, E2sError> {
+        entry.ensure_type(ACCUMULATOR, "Accumulator")?;
+
+        if entry.data.len() != 32 {
+            return Err(E2sError::Ssz(format!(
+                "Invalid data length for Accumulator: expected 32, got {}",
+                entry.data.len()
+            )));
+        }
+
+        let mut root = [0u8; 32];
+        root.copy_from_slice(&entry.data);
+
+        Ok(Self { root: B256::from(root) })
+    }
+
+    /// Compute the accumulator from a list of header records.
+    ///
+    /// Implements `hash_tree_root(List[HeaderRecord, 8192])` per the spec:
+    /// - Each leaf is `sha256(block_hash || total_difficulty_le_bytes32)`
+    /// - Leaves are padded to `MAX_BLOCKS_PER_ERE` (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_ERE`].
+    pub fn from_header_records(records: &[HeaderRecord]) -> Result<Self, E2sError> {
+        let capacity = MAX_BLOCKS_PER_ERE;
+
+        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))) })
+    }
+}
+
+/// The minimal per-block commitment used to build the accumulator.
+///
+/// This is **not** a block header: it is the 64-byte leaf
+/// `{ block-hash: Bytes32, total-difficulty: Uint256 }` that
+/// [`Accumulator::from_header_records`] merkleizes as `hash_tree_root(List[HeaderRecord, 8192])`.
+/// The full header is stored separately as [`CompressedHeader`].
+///
+/// Only meaningful pre-merge, since `total-difficulty` stops advancing after the merge.
+#[derive(Debug, Clone)]
+pub struct HeaderRecord {
+    /// The canonical block hash, i.e. `keccak256(rlp(header))` — the hash *of* the full block
+    /// header, which serves as this leaf's identity in the accumulator.
+    pub block_hash: B256,
+    /// The **cumulative** total difficulty through this block (the running sum of every block's
+    /// difficulty up to and including it), not the header's own per-block `difficulty` field.
+    pub total_difficulty: U256,
+}
+
+/// A single block's components in an `ERE` file.
+///
+/// Only the header and body are mandatory; receipts, total difficulty, and the proof are optional,
+/// so subset profiles or post-merge blocks can omit them.
+/// [`component_count`](Self::component_count) reports how many are present, matching the file's
+/// `DynamicBlockIndex` `component-count`.
+///
+/// See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md#specification>
+#[derive(Debug, Clone)]
+pub struct BlockTuple {
+    /// Compressed block header
+    pub header: CompressedHeader,
+
+    /// Compressed block body
+    pub body: CompressedBody,
+
+    /// Compressed slim receipts, omitted by the `noreceipts` profile
+    pub receipts: Option<CompressedSlimReceipts>,
+
+    /// Total difficulty, absent once it stops advancing after the merge
+    pub total_difficulty: Option<TotalDifficulty>,
+
+    /// Proof of block validity, omitted by the `noproofs` profile
+    pub proof: Option<Proof>,
+}
+
+impl BlockTuple {
+    /// Create a new [`BlockTuple`] with only the mandatory header and body.
+    ///
+    /// Attach the optional components with [`with_receipts`](Self::with_receipts),
+    /// [`with_total_difficulty`](Self::with_total_difficulty), and
+    /// [`with_proof`](Self::with_proof).
+    pub const fn new(header: CompressedHeader, body: CompressedBody) -> Self {
+        Self { header, body, receipts: None, total_difficulty: None, proof: None }
+    }
+
+    /// Attach compressed slim receipts.
+    pub fn with_receipts(mut self, receipts: CompressedSlimReceipts) -> Self {
+        self.receipts = Some(receipts);
+        self
+    }
+
+    /// Attach the total difficulty.
+    pub const fn with_total_difficulty(mut self, total_difficulty: TotalDifficulty) -> Self {
+        self.total_difficulty = Some(total_difficulty);
+        self
+    }
+
+    /// Attach a validity proof.
+    pub fn with_proof(mut self, proof: Proof) -> Self {
+        self.proof = Some(proof);
+        self
+    }
+
+    /// Number of index components this block contributes: the mandatory header and body plus each
+    /// optional component present. Always in the range 2-5, matching the file's `component-count`.
+    pub const fn component_count(&self) -> u64 {
+        2 + self.receipts.is_some() as u64 +
+            self.total_difficulty.is_some() as u64 +
+            self.proof.is_some() as u64
+    }
+
+    /// Convert to an `alloy_consensus::Block`
+    pub fn to_alloy_block<T: Decodable>(&self) -> Result<Block<T>, E2sError> {
+        let header: Header = self.header.decode()?;
+        let body: BlockBody<T> = self.body.decode()?;
+
+        Ok(Block::new(header, body))
+    }
+
+    /// Create from an `alloy_consensus::Block`, attaching the given receipts and total difficulty.
+    pub fn from_alloy_block<T: Encodable, R: Encodable>(
+        block: &Block<T>,
+        receipts: &R,
+        total_difficulty: U256,
+    ) -> Result<Self, E2sError> {
+        let header = CompressedHeader::from_header(&block.header)?;
+        let body = CompressedBody::from_body(&block.body)?;
+
+        let compressed_receipts = CompressedSlimReceipts::from_encodable(receipts)?;
+
+        let difficulty = TotalDifficulty::new(total_difficulty);
+
+        Ok(Self::new(header, body)
+            .with_receipts(compressed_receipts)
+            .with_total_difficulty(difficulty))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{create_header, create_test_receipt, create_test_receipts};
+    use alloy_eips::eip4895::Withdrawals;
+    use alloy_primitives::{Bytes, U256};
+    use reth_ethereum_primitives::{Receipt, TxType};
+
+    #[test]
+    fn test_header_conversion_roundtrip() {
+        let header = create_header();
+
+        let compressed_header = CompressedHeader::from_header(&header).unwrap();
+
+        let decoded_header = compressed_header.decode_header().unwrap();
+
+        assert_eq!(header.number, decoded_header.number);
+        assert_eq!(header.difficulty, decoded_header.difficulty);
+        assert_eq!(header.timestamp, decoded_header.timestamp);
+        assert_eq!(header.gas_used, decoded_header.gas_used);
+        assert_eq!(header.parent_hash, decoded_header.parent_hash);
+        assert_eq!(header.base_fee_per_gas, decoded_header.base_fee_per_gas);
+    }
+
+    #[test]
+    fn test_block_body_conversion() {
+        let block_body: BlockBody<Bytes> =
+            BlockBody { transactions: vec![], ommers: vec![], withdrawals: None };
+
+        let compressed_body = CompressedBody::from_body(&block_body).unwrap();
+
+        let decoded_body: BlockBody<Bytes> = compressed_body.decode_body().unwrap();
+
+        assert_eq!(decoded_body.transactions.len(), 0);
+        assert_eq!(decoded_body.ommers.len(), 0);
+        assert_eq!(decoded_body.withdrawals, None);
+    }
+
+    #[test]
+    fn test_total_difficulty_roundtrip() {
+        let value = U256::from(123456789u64);
+
+        let total_difficulty = TotalDifficulty::new(value);
+
+        let entry = total_difficulty.to_entry();
+
+        assert_eq!(entry.entry_type, TOTAL_DIFFICULTY);
+
+        let recovered = TotalDifficulty::from_entry(&entry).unwrap();
+
+        assert_eq!(recovered.value, value);
+    }
+
+    #[test]
+    fn test_total_difficulty_ssz_le_encoding() {
+        // Verify that total-difficulty is encoded as SSZ uint256 (little-endian).
+        // See https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md
+        let value = U256::from(1u64);
+        let td = TotalDifficulty::new(value);
+        let entry = td.to_entry();
+
+        // Little-endian: least significant byte first [1, 0, 0, ..., 0]
+        assert_eq!(entry.data[0], 1, "First byte must be 1 (little-endian)");
+        assert_eq!(entry.data[31], 0, "Last byte must be 0 (little-endian)");
+    }
+
+    #[test]
+    fn test_compression_roundtrip() {
+        let rlp_data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+        // Test header compression/decompression
+        let compressed_header = CompressedHeader::from_rlp(&rlp_data).unwrap();
+        let decompressed = compressed_header.decompress().unwrap();
+        assert_eq!(decompressed, rlp_data);
+
+        // Test body compression/decompression
+        let compressed_body = CompressedBody::from_rlp(&rlp_data).unwrap();
+        let decompressed = compressed_body.decompress().unwrap();
+        assert_eq!(decompressed, rlp_data);
+
+        // Test receipts compression/decompression
+        let compressed_receipts = CompressedSlimReceipts::from_rlp(&rlp_data).unwrap();
+        let decompressed = compressed_receipts.decompress().unwrap();
+        assert_eq!(decompressed, rlp_data);
+    }
+
+    #[test]
+    fn test_block_tuple_with_data() {
+        // Create block with transactions and withdrawals
+        let header = create_header();
+
+        let transactions = vec![Bytes::from(vec![1, 2, 3, 4]), Bytes::from(vec![5, 6, 7, 8])];
+
+        let withdrawals = Some(Withdrawals(vec![]));
+
+        let block_body = BlockBody { transactions, ommers: vec![], withdrawals };
+
+        let block = Block::new(header, block_body);
+
+        let receipts: Vec<u8> = Vec::new();
+
+        let block_tuple =
+            BlockTuple::from_alloy_block(&block, &receipts, U256::from(123456u64)).unwrap();
+
+        // Convert back to Block
+        let decoded_block: Block<Bytes> = block_tuple.to_alloy_block().unwrap();
+
+        // Verify block components
+        assert_eq!(decoded_block.header.number, 100);
+        assert_eq!(decoded_block.body.transactions.len(), 2);
+        assert_eq!(decoded_block.body.transactions[0], Bytes::from(vec![1, 2, 3, 4]));
+        assert_eq!(decoded_block.body.transactions[1], Bytes::from(vec![5, 6, 7, 8]));
+        assert!(decoded_block.body.withdrawals.is_some());
+    }
+
+    #[test]
+    fn test_block_tuple_component_count() {
+        let base = BlockTuple::new(CompressedHeader::new(vec![1]), CompressedBody::new(vec![2]));
+        // Mandatory header + body only.
+        assert_eq!(base.component_count(), 2);
+
+        // Each optional component bumps the count, up to the 5-component maximum.
+        assert_eq!(
+            base.clone().with_receipts(CompressedSlimReceipts::new(vec![3])).component_count(),
+            3
+        );
+        let full = base
+            .with_receipts(CompressedSlimReceipts::new(vec![3]))
+            .with_total_difficulty(TotalDifficulty::new(U256::from(1u64)))
+            .with_proof(Proof::new(vec![4]));
+        assert_eq!(full.component_count(), 5);
+        assert!(full.receipts.is_some() && full.total_difficulty.is_some() && full.proof.is_some());
+    }
+
+    #[test]
+    fn test_single_receipt_compression_roundtrip() {
+        let test_receipt = create_test_receipt(TxType::Eip1559, true, 21000, 2);
+
+        // Compress the receipt
+        let compressed_receipts = CompressedSlimReceipts::from_encodable(&test_receipt)
+            .expect("Failed to compress receipt");
+
+        // Verify compression
+        assert!(!compressed_receipts.data.is_empty());
+
+        // Decode the compressed receipt back
+        let decoded_receipt: Receipt =
+            compressed_receipts.decode().expect("Failed to decode compressed receipt");
+
+        // Verify that the decoded receipt matches the original
+        assert_eq!(decoded_receipt.tx_type, test_receipt.tx_type);
+        assert_eq!(decoded_receipt.success, test_receipt.success);
+        assert_eq!(decoded_receipt.cumulative_gas_used, test_receipt.cumulative_gas_used);
+        assert_eq!(decoded_receipt.logs.len(), test_receipt.logs.len());
+
+        // Verify each log
+        for (original_log, decoded_log) in test_receipt.logs.iter().zip(decoded_receipt.logs.iter())
+        {
+            assert_eq!(decoded_log.address, original_log.address);
+            assert_eq!(decoded_log.data.topics(), original_log.data.topics());
+        }
+    }
+
+    #[test]
+    fn test_slim_receipt_matches_spec_rlp() {
+        // Spec: CompressedSlimReceipts.data = snappyFramed(rlp([tx-type, status, cumulative-gas,
+        // logs])), with no bloom filter. Prove the inner RLP of `EthereumReceipt` is exactly that
+        // 4-element list, byte for byte.
+        let receipt = create_test_receipt(TxType::Eip1559, true, 21000, 2);
+
+        let compressed = CompressedSlimReceipts::from_encodable(&receipt).unwrap();
+        let actual_rlp = compressed.decompress().unwrap();
+
+        // Hand-build rlp([tx-type, status, cumulative-gas, logs]) in spec field order.
+        let mut fields = Vec::new();
+        (receipt.tx_type as u8).encode(&mut fields);
+        receipt.success.encode(&mut fields);
+        receipt.cumulative_gas_used.encode(&mut fields);
+        receipt.logs.encode(&mut fields);
+        let mut expected = Vec::new();
+        alloy_rlp::Header { list: true, payload_length: fields.len() }.encode(&mut expected);
+        expected.extend_from_slice(&fields);
+
+        assert_eq!(
+            actual_rlp, expected,
+            "slim receipt RLP must be the 4-element list [tx-type, status, cumulative-gas, logs]"
+        );
+    }
+
+    #[test]
+    fn test_slim_receipts_typed_helpers() {
+        // Cover both status variants: post-Byzantium boolean status and a pre-Byzantium 32-byte
+        // post-state root, proving a single `SlimReceipt` type round-trips across forks.
+        let receipts = vec![
+            SlimReceipt {
+                tx_type: TxType::Eip1559,
+                status: Eip658Value::Eip658(true),
+                cumulative_gas_used: 21000,
+                logs: vec![],
+            },
+            SlimReceipt {
+                tx_type: TxType::Legacy,
+                status: Eip658Value::PostState(B256::repeat_byte(0xab)),
+                cumulative_gas_used: 42000,
+                logs: vec![],
+            },
+        ];
+
+        let compressed = CompressedSlimReceipts::from_receipts(&receipts).unwrap();
+        let decoded = compressed.decode_receipts().unwrap();
+
+        assert_eq!(decoded, receipts);
+    }
+
+    #[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_ERE + 1
+        ];
+        assert!(Accumulator::from_header_records(&records).is_err());
+    }
+
+    #[test]
+    fn test_proof_type_byte_roundtrip() {
+        for ty in [
+            ProofType::BlockProofHistoricalHashesAccumulator,
+            ProofType::BlockProofHistoricalRoots,
+            ProofType::BlockProofHistoricalSummariesCapella,
+            ProofType::BlockProofHistoricalSummariesDeneb,
+        ] {
+            assert_eq!(ProofType::from_byte(ty.as_byte()), Some(ty));
+        }
+        assert_eq!(ProofType::from_byte(4), None);
+    }
+
+    #[test]
+    fn test_proof_roundtrip() {
+        let ssz_proof = vec![0xab; 64];
+        let proof = Proof::encode(ProofType::BlockProofHistoricalRoots, &ssz_proof).unwrap();
+
+        // Roundtrip through an Entry
+        let entry = proof.to_entry();
+        assert_eq!(entry.entry_type, PROOF);
+        let recovered = Proof::from_entry(&entry).unwrap();
+
+        let (proof_type, ssz_bytes) = recovered.decode().unwrap();
+        assert_eq!(proof_type, ProofType::BlockProofHistoricalRoots);
+        assert_eq!(ssz_bytes, ssz_proof);
+    }
+
+    #[test]
+    fn test_from_entry_rejects_wrong_type() {
+        let entry = Entry::new(COMPRESSED_BODY, vec![1, 2, 3]);
+        assert!(CompressedHeader::from_entry(&entry).is_err());
+    }
+
+    #[test]
+    fn test_decode_rejects_trailing_bytes() {
+        // A record is exactly `snappyFramed(rlp(...))`; an extra byte after the RLP value
+        // must be rejected, not silently ignored.
+        let mut rlp = Vec::new();
+        7u64.encode(&mut rlp);
+        rlp.push(0xff);
+        let compressed = CompressedHeader::from_rlp(&rlp).unwrap();
+        assert!(compressed.decode::<u64>().is_err());
+    }
+
+    #[test]
+    fn test_proof_decode_rejects_trailing_bytes() {
+        let valid = Proof::encode(ProofType::BlockProofHistoricalRoots, &[1, 2, 3]).unwrap();
+        let mut raw = snappy_decompress(&valid.data).unwrap();
+        raw.push(0xff); // byte beyond the RLP list
+        let tampered = Proof::new(snappy_compress(&raw).unwrap());
+        assert!(tampered.decode().is_err());
+    }
+
+    #[test]
+    fn test_proof_decode_rejects_extra_list_item() {
+        // Build rlp([proof-type, ssz, extra]) — a third item must be rejected.
+        let mut payload = Vec::new();
+        0u8.encode(&mut payload);
+        alloy_primitives::Bytes::from(vec![1, 2, 3]).encode(&mut payload);
+        99u8.encode(&mut payload);
+        let mut rlp = Vec::new();
+        alloy_rlp::Header { list: true, payload_length: payload.len() }.encode(&mut rlp);
+        rlp.extend_from_slice(&payload);
+        let proof = Proof::new(snappy_compress(&rlp).unwrap());
+        assert!(proof.decode().is_err());
+    }
+
+    #[test]
+    fn test_receipt_list_compression() {
+        let receipts = create_test_receipts();
+
+        // Compress the list of receipts
+        let compressed_receipts = CompressedSlimReceipts::from_encodable_list(&receipts)
+            .expect("Failed to compress receipt list");
+
+        // Decode the compressed receipts back. ERE always stores slim receipts (no bloom), so the
+        // bare `Receipt` (`alloy_consensus::EthereumReceipt`) is the canonical decode target.
+        let decoded_receipts: Vec<Receipt> =
+            compressed_receipts.decode().expect("Failed to decode compressed receipt list");
+
+        // Verify that the decoded receipts match the original
+        assert_eq!(decoded_receipts.len(), receipts.len());
+
+        for (original, decoded) in receipts.iter().zip(decoded_receipts.iter()) {
+            assert_eq!(decoded.tx_type, original.tx_type);
+            assert_eq!(decoded.success, original.success);
+            assert_eq!(decoded.cumulative_gas_used, original.cumulative_gas_used);
+            assert_eq!(decoded.logs.len(), original.logs.len());
+
+            for (original_log, decoded_log) in original.logs.iter().zip(decoded.logs.iter()) {
+                assert_eq!(decoded_log.address, original_log.address);
+                assert_eq!(decoded_log.data.topics(), original_log.data.topics());
+            }
+        }
+    }
+}
diff --git a/crates/era/src/ere/types/group.rs b/crates/era/src/ere/types/group.rs
new file mode 100644
index 00000000000..333447b7a9f
--- /dev/null
+++ b/crates/era/src/ere/types/group.rs
@@ -0,0 +1,627 @@
+//! `ere` (era execution) file content group.
+//!
+//! See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md#specification>
+
+use crate::{
+    common::file_ops::{EraFileId, EraFileType},
+    e2s::{error::E2sError, types::Entry},
+    ere::types::execution::{Accumulator, BlockTuple, MAX_BLOCKS_PER_ERE},
+};
+use alloy_primitives::BlockNumber;
+
+/// `DynamicBlockIndex` record: ['g', '2']
+pub const DYNAMIC_BLOCK_INDEX: [u8; 2] = [0x67, 0x32];
+
+/// Minimum number of index components stored per block (header + body).
+pub const MIN_COMPONENTS_PER_BLOCK: u64 = 2;
+
+/// Maximum number of index components stored per block
+/// (header + body + receipts + difficulty + proof).
+pub const MAX_COMPONENTS_PER_BLOCK: u64 = 5;
+
+/// File content in an `ere` file.
+///
+/// Format:
+/// `CompressedHeader+ | CompressedBody+ | CompressedSlimReceipts* | Proof* | TotalDifficulty* |
+/// other-entries* | Accumulator? | DynamicBlockIndex`
+///
+/// See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md#specification>
+#[derive(Debug)]
+pub struct EreGroup {
+    /// Blocks in this `ere` group
+    pub blocks: Vec<BlockTuple>,
+
+    /// Other entries that don't fit into the standard per-block categories
+    pub other_entries: Vec<Entry>,
+
+    /// Accumulator over the block header records.
+    ///
+    /// Optional: it is only present for files that contain pre-merge blocks, since
+    /// `total-difficulty` stops advancing after the merge.
+    pub accumulator: Option<Accumulator>,
+
+    /// Dynamic block index, required
+    pub index: DynamicBlockIndex,
+}
+
+impl EreGroup {
+    /// Create a new [`EreGroup`]
+    pub const fn new(
+        blocks: Vec<BlockTuple>,
+        accumulator: Option<Accumulator>,
+        index: DynamicBlockIndex,
+    ) -> Self {
+        Self { blocks, accumulator, index, other_entries: Vec::new() }
+    }
+
+    /// Add another entry to this group
+    pub fn add_entry(&mut self, entry: Entry) {
+        self.other_entries.push(entry);
+    }
+}
+
+/// `ere` block index with a dynamic per-block component count.
+///
+/// Unlike `era1`'s single-offset-per-block index, an `ere` block can carry a variable number of
+/// components, so the index stores `component_count` offsets for every block.
+///
+/// Format: `starting-number | indexes | indexes | ... | component-count | count`
+///
+/// where each `indexes` group holds the offsets for one block:
+/// `header-index | body-index | receipts-index? | difficulty-index? | proof-index?`
+///
+/// `component-count` is 2-5 depending on which optional components are present. Offsets are `i64`
+/// (they point backward to earlier entries); their little-endian bytes match the spec's `uint64`.
+///
+/// See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md#specification>
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DynamicBlockIndex {
+    /// Starting block number
+    starting_number: BlockNumber,
+
+    /// Number of index components per block (2-5)
+    component_count: u64,
+
+    /// Flattened, block-major offsets: `[h0, b0, (r0)?, (d0)?, (p0)?, h1, b1, ...]`.
+    /// Length is `count * component_count`.
+    offsets: Vec<i64>,
+}
+
+impl DynamicBlockIndex {
+    /// Create a new [`DynamicBlockIndex`].
+    ///
+    /// `offsets` must be block-major with exactly `component_count` entries per block; the encoded
+    /// block count is derived as `offsets.len() / component_count`.
+    pub const fn new(
+        starting_number: BlockNumber,
+        component_count: u64,
+        offsets: Vec<i64>,
+    ) -> Self {
+        Self { starting_number, component_count, offsets }
+    }
+
+    /// Get the starting block number
+    pub const fn starting_number(&self) -> u64 {
+        self.starting_number
+    }
+
+    /// Get the number of index components stored per block
+    pub const fn component_count(&self) -> u64 {
+        self.component_count
+    }
+
+    /// Get the number of blocks covered by this index
+    pub const fn block_count(&self) -> usize {
+        if self.component_count == 0 {
+            return 0;
+        }
+        self.offsets.len() / self.component_count as usize
+    }
+
+    /// Get all offsets in block-major order
+    pub fn offsets(&self) -> &[i64] {
+        &self.offsets
+    }
+
+    /// Get the `component_count` offsets for a specific block number.
+    ///
+    /// Returns a slice ordered as
+    /// `[header, body, (receipts)?, (difficulty)?, (proof)?]`, or `None` when the block is outside
+    /// the range covered by this index.
+    pub fn offsets_for_block(&self, block_number: BlockNumber) -> Option<&[i64]> {
+        if block_number < self.starting_number || self.component_count == 0 {
+            return None;
+        }
+        let index = (block_number - self.starting_number) as usize;
+        let cc = self.component_count as usize;
+        let start = index.checked_mul(cc)?;
+        let end = start.checked_add(cc)?;
+        self.offsets.get(start..end)
+    }
+
+    /// Convert to an [`Entry`] for storage in an e2store file.
+    ///
+    /// Format: `starting-number | offsets... | component-count | count`
+    pub fn to_entry(&self) -> Entry {
+        let block_count = self.block_count();
+        let mut data = Vec::with_capacity(8 + self.offsets.len() * 8 + 16);
+
+        data.extend_from_slice(&self.starting_number.to_le_bytes());
+        data.extend(self.offsets.iter().flat_map(|offset| offset.to_le_bytes()));
+        data.extend_from_slice(&self.component_count.to_le_bytes());
+        data.extend_from_slice(&(block_count as u64).to_le_bytes());
+
+        Entry::new(DYNAMIC_BLOCK_INDEX, data)
+    }
+
+    /// Create from an [`Entry`]
+    pub fn from_entry(entry: &Entry) -> Result<Self, E2sError> {
+        entry.ensure_type(DYNAMIC_BLOCK_INDEX, "DynamicBlockIndex")?;
+
+        // Need at least: starting-number(8) + component-count(8) + count(8) = 24 bytes
+        if entry.data.len() < 24 {
+            return Err(E2sError::Ssz(
+                "DynamicBlockIndex too short: need at least 24 bytes for starting-number, \
+                 component-count and count"
+                    .to_string(),
+            ));
+        }
+
+        let data = &entry.data;
+        let len = data.len();
+
+        // Count is the last 8 bytes, component-count the 8 before it.
+        let count = u64::from_le_bytes(
+            data[len - 8..]
+                .try_into()
+                .map_err(|_| E2sError::Ssz("Failed to read count bytes".to_string()))?,
+        ) as usize;
+
+        let component_count = u64::from_le_bytes(
+            data[len - 16..len - 8]
+                .try_into()
+                .map_err(|_| E2sError::Ssz("Failed to read component-count bytes".to_string()))?,
+        );
+
+        if !(MIN_COMPONENTS_PER_BLOCK..=MAX_COMPONENTS_PER_BLOCK).contains(&component_count) {
+            return Err(E2sError::Ssz(format!(
+                "Invalid component-count for DynamicBlockIndex: expected 2-5, got {component_count}"
+            )));
+        }
+
+        // Derive the offset count from the actual entry length, not the untrusted `count`, so a
+        // crafted `count` can't overflow `* 8` and drive a huge `Vec::with_capacity`.
+        let offsets_bytes = len - 24; // len >= 24 checked above
+        if !offsets_bytes.is_multiple_of(8) {
+            return Err(E2sError::Ssz(
+                "DynamicBlockIndex offset section is not 8-byte aligned".to_string(),
+            ));
+        }
+        let total_offsets = offsets_bytes / 8;
+
+        // The declared `count` and `component-count` must match the stored offsets exactly.
+        if count.checked_mul(component_count as usize) != Some(total_offsets) {
+            return Err(E2sError::Ssz(format!(
+                "DynamicBlockIndex length mismatch: count {count} * component-count \
+                 {component_count} does not equal the {total_offsets} stored offsets"
+            )));
+        }
+
+        let starting_number = u64::from_le_bytes(
+            data[0..8]
+                .try_into()
+                .map_err(|_| E2sError::Ssz("Failed to read starting_number bytes".to_string()))?,
+        );
+
+        let mut offsets = Vec::with_capacity(total_offsets);
+        for chunk in data[8..8 + offsets_bytes].chunks_exact(8) {
+            let offset = i64::from_le_bytes(
+                chunk.try_into().map_err(|_| E2sError::Ssz("Failed to read offset".to_string()))?,
+            );
+            offsets.push(offset);
+        }
+
+        Ok(Self { starting_number, component_count, offsets })
+    }
+}
+
+/// `ere` file identifier
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EreId {
+    /// Network configuration name
+    pub network_name: String,
+
+    /// First block number in file
+    pub start_block: BlockNumber,
+
+    /// Number of blocks in the file
+    pub block_count: u32,
+
+    /// Optional hash identifier for this file.
+    /// First 4 bytes of the hash of the last block in the file.
+    pub hash: Option<[u8; 4]>,
+
+    /// Whether to include era count in filename.
+    /// It is used for custom exports when we don't use the max number of items per file.
+    pub include_era_count: bool,
+
+    /// Subset profiles applied to this file.
+    ///
+    /// Kept sorted and deduplicated by the builders so the filename postfix renders in the
+    /// spec-mandated alphabetical order. Empty means the default, fully verifiable profile.
+    pub profiles: Vec<EreProfile>,
+}
+
+impl EreId {
+    /// Create a new [`EreId`]
+    pub fn new(
+        network_name: impl Into<String>,
+        start_block: BlockNumber,
+        block_count: u32,
+    ) -> Self {
+        Self {
+            network_name: network_name.into(),
+            start_block,
+            block_count,
+            hash: None,
+            include_era_count: false,
+            profiles: Vec::new(),
+        }
+    }
+
+    /// Add a hash identifier to [`EreId`]
+    pub const fn with_hash(mut self, hash: [u8; 4]) -> Self {
+        self.hash = Some(hash);
+        self
+    }
+
+    /// Include era count in filename, for custom block-per-file exports
+    pub const fn with_era_count(mut self) -> Self {
+        self.include_era_count = true;
+        self
+    }
+
+    /// Add a subset [`EreProfile`] to this file, keeping profiles sorted and deduplicated.
+    pub fn with_profile(mut self, profile: EreProfile) -> Self {
+        self.profiles.push(profile);
+        self.normalize_profiles();
+        self
+    }
+
+    /// Add several subset profiles to this file, keeping profiles sorted and deduplicated.
+    pub fn with_profiles(mut self, profiles: impl IntoIterator<Item = EreProfile>) -> Self {
+        self.profiles.extend(profiles);
+        self.normalize_profiles();
+        self
+    }
+
+    /// Sort and deduplicate profiles so the filename postfix is deterministic and alphabetical.
+    fn normalize_profiles(&mut self) {
+        self.profiles.sort_unstable();
+        self.profiles.dedup();
+    }
+}
+
+impl EraFileId for EreId {
+    const FILE_TYPE: EraFileType = EraFileType::Ere;
+
+    const ITEMS_PER_ERA: u64 = MAX_BLOCKS_PER_ERE as u64;
+
+    fn network_name(&self) -> &str {
+        &self.network_name
+    }
+
+    fn start_number(&self) -> u64 {
+        self.start_block
+    }
+
+    fn count(&self) -> u32 {
+        self.block_count
+    }
+
+    fn hash(&self) -> Option<[u8; 4]> {
+        self.hash
+    }
+
+    fn include_era_count(&self) -> bool {
+        self.include_era_count
+    }
+
+    /// Render the filename, appending any subset-profile postfixes before the extension.
+    ///
+    /// Default profile: `<network>-<era-number>-<short-block-hash>.ere`.
+    /// With profiles: `<network>-<era-number>-<short-block-hash>-<profile>...-.ere`, in
+    /// alphabetical profile order, e.g. `mainnet-00000-4bb7de2e-noproofs-noreceipts.ere`.
+    ///
+    /// See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md#file-name>
+    fn to_file_name(&self) -> String {
+        let base = Self::FILE_TYPE.format_filename(
+            self.network_name(),
+            self.era_number(),
+            self.hash(),
+            self.include_era_count(),
+            self.era_count(),
+        );
+
+        if self.profiles.is_empty() {
+            return base;
+        }
+
+        // Insert the `-<profile>` postfixes before the extension. `profiles` is already sorted
+        // and deduplicated, so the order matches the spec's alphabetical requirement.
+        let extension = Self::FILE_TYPE.extension();
+        let stem = base.strip_suffix(extension).unwrap_or(base.as_str());
+        let mut name = String::with_capacity(base.len() + self.profiles.len() * 12);
+        name.push_str(stem);
+        for profile in &self.profiles {
+            name.push('-');
+            name.push_str(profile.as_str());
+        }
+        name.push_str(extension);
+        name
+    }
+}
+
+/// A subset profile for an `ere` file, distinguishing non-default contents from the fully
+/// verifiable default profile.
+///
+/// Variants are ordered so that [`EreId::to_file_name`] renders their postfixes alphabetically,
+/// as required by the spec.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum EreProfile {
+    /// Omits `Proof` entries (`noproofs`).
+    NoProofs,
+    /// Omits `CompressedSlimReceipts` entries (`noreceipts`).
+    NoReceipts,
+}
+
+impl EreProfile {
+    /// The lower-case ASCII filename postfix for this profile.
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::NoProofs => "noproofs",
+            Self::NoReceipts => "noreceipts",
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ere::types::execution::{
+        CompressedBody, CompressedHeader, CompressedSlimReceipts, TotalDifficulty,
+    };
+    use alloy_primitives::{B256, U256};
+
+    /// Build an `ere` block tuple from uncompressed sample bytes; the index/group tests only care
+    /// about the tuple's presence, not its decoded contents.
+    fn sample_block(data_size: usize) -> BlockTuple {
+        BlockTuple::new(
+            CompressedHeader::new(vec![0xAA; data_size]),
+            CompressedBody::new(vec![0xBB; data_size * 2]),
+        )
+        .with_receipts(CompressedSlimReceipts::new(vec![0xCC; data_size]))
+        .with_total_difficulty(TotalDifficulty::new(U256::from(data_size)))
+    }
+
+    #[test]
+    fn test_dynamic_block_index_roundtrip() {
+        let starting_number = 1000;
+        let component_count = 4;
+        // 2 blocks, 4 components each = 8 offsets
+        let offsets = vec![100, 200, 300, 400, 500, 600, 700, 800];
+
+        let block_index = DynamicBlockIndex::new(starting_number, component_count, offsets.clone());
+
+        let entry = block_index.to_entry();
+        assert_eq!(entry.entry_type, DYNAMIC_BLOCK_INDEX);
+
+        let recovered = DynamicBlockIndex::from_entry(&entry).unwrap();
+        assert_eq!(recovered, block_index);
+        assert_eq!(recovered.starting_number(), starting_number);
+        assert_eq!(recovered.component_count(), component_count);
+        assert_eq!(recovered.offsets(), offsets);
+        assert_eq!(recovered.block_count(), 2);
+    }
+
+    #[test]
+    fn test_dynamic_block_index_negative_offsets_roundtrip() {
+        // Offsets point backward from the index to earlier entries, so they are negative in real
+        // files. Cover the full component-count range (2 and 5) to exercise the `i64` LE encoding.
+        for (component_count, offsets) in [
+            (2u64, vec![-2048, -1024, -512, -256]),
+            (5u64, vec![-50, -40, -30, -20, -10, -9, -8, -7, -6, -5]),
+        ] {
+            let index = DynamicBlockIndex::new(1000, component_count, offsets);
+            let recovered = DynamicBlockIndex::from_entry(&index.to_entry()).unwrap();
+            assert_eq!(recovered, index);
+        }
+    }
+
+    #[test]
+    fn test_dynamic_block_index_offset_lookup() {
+        let starting_number = 1000;
+        let component_count = 3;
+        // 3 blocks, 3 components each = 9 offsets
+        let offsets = vec![10, 20, 30, 40, 50, 60, 70, 80, 90];
+
+        let block_index = DynamicBlockIndex::new(starting_number, component_count, offsets);
+
+        // Block 1000: [10, 20, 30]
+        assert_eq!(block_index.offsets_for_block(1000), Some(&[10, 20, 30][..]));
+
+        // Block 1002: [70, 80, 90]
+        assert_eq!(block_index.offsets_for_block(1002), Some(&[70, 80, 90][..]));
+
+        // Out of range below and above
+        assert_eq!(block_index.offsets_for_block(999), None);
+        assert_eq!(block_index.offsets_for_block(1003), None);
+    }
+
+    #[test]
+    fn test_dynamic_block_index_rejects_bad_component_count() {
+        // component-count must be in 2..=5; forge an entry with component-count = 1.
+        let mut data = Vec::new();
+        data.extend_from_slice(&1000u64.to_le_bytes()); // starting-number
+        data.extend_from_slice(&42i64.to_le_bytes()); // single offset
+        data.extend_from_slice(&1u64.to_le_bytes()); // component-count = 1 (invalid)
+        data.extend_from_slice(&1u64.to_le_bytes()); // count
+        let entry = Entry::new(DYNAMIC_BLOCK_INDEX, data);
+
+        assert!(DynamicBlockIndex::from_entry(&entry).is_err());
+    }
+
+    #[test]
+    fn test_dynamic_block_index_rejects_overflowing_count() {
+        // 24-byte entry declaring a count whose offset length overflows usize; must be rejected,
+        // not allocated.
+        let mut data = Vec::new();
+        data.extend_from_slice(&1000u64.to_le_bytes()); // starting-number
+        data.extend_from_slice(&2u64.to_le_bytes()); // component-count = 2
+        data.extend_from_slice(&(1u64 << 60).to_le_bytes()); // count = 2^60
+        let entry = Entry::new(DYNAMIC_BLOCK_INDEX, data);
+
+        assert!(DynamicBlockIndex::from_entry(&entry).is_err());
+    }
+
+    #[test]
+    fn test_dynamic_block_index_rejects_wrong_length() {
+        // Encode a valid index, then drop a trailing byte so the declared count no longer matches.
+        let block_index = DynamicBlockIndex::new(1000, 2, vec![100, 200, 300, 400]);
+        let mut entry = block_index.to_entry();
+        entry.data.pop();
+
+        assert!(DynamicBlockIndex::from_entry(&entry).is_err());
+    }
+
+    #[test]
+    fn test_dynamic_block_index_rejects_wrong_type() {
+        let entry = Entry::new([0x66, 0x32], vec![0u8; 24]);
+        assert!(DynamicBlockIndex::from_entry(&entry).is_err());
+    }
+
+    #[test]
+    fn test_ere_group_basic_construction() {
+        let blocks = vec![sample_block(10), sample_block(15), sample_block(20)];
+
+        let accumulator = Accumulator::new(B256::from([0xDD; 32]));
+        let block_index = DynamicBlockIndex::new(1000, 2, vec![100, 200, 300, 400, 500, 600]);
+
+        let group = EreGroup::new(blocks, Some(accumulator.clone()), block_index);
+
+        assert_eq!(group.blocks.len(), 3);
+        assert_eq!(group.other_entries.len(), 0);
+        assert_eq!(group.accumulator.unwrap().root, accumulator.root);
+        assert_eq!(group.index.starting_number(), 1000);
+        assert_eq!(group.index.offsets(), vec![100, 200, 300, 400, 500, 600]);
+    }
+
+    #[test]
+    fn test_ere_group_without_accumulator() {
+        // Post-merge files carry no accumulator.
+        let blocks = vec![sample_block(10)];
+        let block_index = DynamicBlockIndex::new(1000, 2, vec![100, 200]);
+
+        let group = EreGroup::new(blocks, None, block_index);
+
+        assert!(group.accumulator.is_none());
+        assert_eq!(group.blocks.len(), 1);
+    }
+
+    #[test]
+    fn test_ere_group_add_entries() {
+        let blocks = vec![sample_block(10)];
+        let accumulator = Accumulator::new(B256::from([0xDD; 32]));
+        let block_index = DynamicBlockIndex::new(1000, 2, vec![100, 200]);
+
+        let mut group = EreGroup::new(blocks, Some(accumulator), block_index);
+        assert_eq!(group.other_entries.len(), 0);
+
+        group.add_entry(Entry::new([0x01, 0x01], vec![1, 2, 3, 4]));
+        group.add_entry(Entry::new([0x02, 0x02], vec![5, 6, 7, 8]));
+
+        assert_eq!(group.other_entries.len(), 2);
+        assert_eq!(group.other_entries[0].entry_type, [0x01, 0x01]);
+        assert_eq!(group.other_entries[1].data, vec![5, 6, 7, 8]);
+    }
+
+    #[test]
+    fn test_ere_group_with_mismatched_index() {
+        // The group is a plain container; it does not validate that block count matches the index.
+        let blocks = vec![sample_block(10), sample_block(15)];
+        let index = DynamicBlockIndex::new(2000, 2, vec![100, 200, 300, 400, 500, 600]); // 3 blocks
+        let group = EreGroup::new(blocks, None, index);
+        assert_eq!(group.blocks.len(), 2);
+        assert_eq!(group.index.starting_number(), 2000);
+    }
+
+    #[test_case::test_case(
+        EreId::new("mainnet", 0, 8192).with_hash([0x5e, 0xc1, 0xff, 0xb8]),
+        "mainnet-00000-5ec1ffb8.ere";
+        "Mainnet era 0"
+    )]
+    #[test_case::test_case(
+        EreId::new("mainnet", 8192, 8192).with_hash([0x5e, 0xcb, 0x9b, 0xf9]),
+        "mainnet-00001-5ecb9bf9.ere";
+        "Mainnet era 1"
+    )]
+    #[test_case::test_case(
+        EreId::new("sepolia", 0, 8192).with_hash([0x90, 0x91, 0x84, 0x72]),
+        "sepolia-00000-90918472.ere";
+        "Sepolia era 0"
+    )]
+    #[test_case::test_case(
+        EreId::new("mainnet", 1000, 100),
+        "mainnet-00000-00000000.ere";
+        "ID without hash"
+    )]
+    fn test_ere_id_file_naming(id: EreId, expected_file_name: &str) {
+        assert_eq!(id.to_file_name(), expected_file_name);
+    }
+
+    // File naming with era-count, for custom exports
+    #[test_case::test_case(
+        EreId::new("mainnet", 0, 8192).with_hash([0x5e, 0xc1, 0xff, 0xb8]).with_era_count(),
+        "mainnet-00000-00001-5ec1ffb8.ere";
+        "Mainnet era 0 with count"
+    )]
+    #[test_case::test_case(
+        EreId::new("mainnet", 8000, 500).with_hash([0xab, 0xcd, 0xef, 0x12]).with_era_count(),
+        "mainnet-00000-00002-abcdef12.ere";
+        "Spanning two eras with count"
+    )]
+    fn test_ere_id_file_naming_with_era_count(id: EreId, expected_file_name: &str) {
+        assert_eq!(id.to_file_name(), expected_file_name);
+    }
+
+    // File naming with subset-profile postfixes, in alphabetical order.
+    #[test_case::test_case(
+        EreId::new("mainnet", 0, 8192).with_hash([0x4b, 0xb7, 0xde, 0x2e]),
+        "mainnet-00000-4bb7de2e.ere";
+        "Default profile, no postfix"
+    )]
+    #[test_case::test_case(
+        EreId::new("mainnet", 0, 8192).with_hash([0x4b, 0xb7, 0xde, 0x2e]).with_profile(EreProfile::NoProofs),
+        "mainnet-00000-4bb7de2e-noproofs.ere";
+        "noproofs profile"
+    )]
+    #[test_case::test_case(
+        EreId::new("mainnet", 0, 8192).with_hash([0x4b, 0xb7, 0xde, 0x2e]).with_profile(EreProfile::NoReceipts),
+        "mainnet-00000-4bb7de2e-noreceipts.ere";
+        "noreceipts profile"
+    )]
+    #[test_case::test_case(
+        EreId::new("mainnet", 0, 8192).with_hash([0x4b, 0xb7, 0xde, 0x2e]).with_profiles([EreProfile::NoProofs, EreProfile::NoReceipts]),
+        "mainnet-00000-4bb7de2e-noproofs-noreceipts.ere";
+        "Combined profiles"
+    )]
+    #[test_case::test_case(
+        // Insertion order reversed and duplicated; output must still be alphabetical and deduped.
+        EreId::new("mainnet", 0, 8192).with_hash([0x4b, 0xb7, 0xde, 0x2e]).with_profile(EreProfile::NoReceipts).with_profile(EreProfile::NoProofs).with_profile(EreProfile::NoReceipts),
+        "mainnet-00000-4bb7de2e-noproofs-noreceipts.ere";
+        "Profiles normalized to alphabetical order"
+    )]
+    fn test_ere_id_file_naming_with_profiles(id: EreId, expected_file_name: &str) {
+        assert_eq!(id.to_file_name(), expected_file_name);
+    }
+}
diff --git a/crates/era/src/ere/types/mod.rs b/crates/era/src/ere/types/mod.rs
new file mode 100644
index 00000000000..c61a22d390a
--- /dev/null
+++ b/crates/era/src/ere/types/mod.rs
@@ -0,0 +1,6 @@
+//! `ere` (era execution) types
+//!
+//! See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md>
+
+pub mod execution;
+pub mod group;
diff --git a/crates/era/src/lib.rs b/crates/era/src/lib.rs
index 2e4b755d76f..5aa46211b29 100644
--- a/crates/era/src/lib.rs
+++ b/crates/era/src/lib.rs
@@ -16,6 +16,7 @@ pub mod common;
 pub mod e2s;
 pub mod era;
 pub mod era1;
+pub mod ere;
 
 #[cfg(test)]
 pub(crate) mod test_utils;
diff --git a/crates/era/tests/it/ere/mod.rs b/crates/era/tests/it/ere/mod.rs
new file mode 100644
index 00000000000..e108117e793
--- /dev/null
+++ b/crates/era/tests/it/ere/mod.rs
@@ -0,0 +1 @@
+mod roundtrip;
diff --git a/crates/era/tests/it/ere/roundtrip.rs b/crates/era/tests/it/ere/roundtrip.rs
new file mode 100644
index 00000000000..b3267867413
--- /dev/null
+++ b/crates/era/tests/it/ere/roundtrip.rs
@@ -0,0 +1,221 @@
+//! Roundtrip tests for `.erae` files.
+//!
+//! These tests download mainnet `.erae` files spread across history (and the merge) from
+//! <https://data.ethpandaops.io/erae/mainnet/> and, for a sample of blocks, verify the full
+//! lifecycle: read → write the file back and read it again (file roundtrip), then for each
+//! component decompress → decode → re-encode → re-compress and confirm nothing is lost.
+
+use alloy_consensus::{BlockBody, Header};
+use reth_era::{
+    common::file_ops::{EraFileFormat, StreamReader, StreamWriter},
+    ere::{
+        file::{EreFile, EreReader, EreWriter},
+        types::{
+            execution::{
+                BlockTuple, CompressedBody, CompressedHeader, CompressedSlimReceipts, Proof,
+                TotalDifficulty,
+            },
+            group::{DynamicBlockIndex, EreGroup, EreId},
+        },
+    },
+};
+use reth_ethereum_primitives::TransactionSigned;
+use std::io::Cursor;
+
+use crate::{EraTestDownloader, MAINNET};
+
+async fn test_ere_file_roundtrip(
+    downloader: &EraTestDownloader,
+    filename: &str,
+    network: &str,
+) -> eyre::Result<()> {
+    println!("\nTesting roundtrip for file: {filename}");
+
+    let original_file = downloader.open_ere_file(filename, network).await?;
+
+    // Write the whole file to a buffer and read it back.
+    let mut buffer = Vec::new();
+    {
+        let mut writer = EreWriter::new(&mut buffer);
+        writer.write_file(&original_file)?;
+    }
+    let roundtrip_file = EreReader::new(Cursor::new(&buffer)).read(network.to_string())?;
+
+    assert_eq!(
+        original_file.id.network_name, roundtrip_file.id.network_name,
+        "Network name should match after roundtrip"
+    );
+    assert_eq!(
+        original_file.id.start_block, roundtrip_file.id.start_block,
+        "Start block should match after roundtrip"
+    );
+    assert_eq!(
+        original_file.group.blocks.len(),
+        roundtrip_file.group.blocks.len(),
+        "Block count should match after roundtrip"
+    );
+    assert_eq!(
+        original_file.group.accumulator, roundtrip_file.group.accumulator,
+        "Accumulator should match after roundtrip"
+    );
+    assert_eq!(
+        original_file.group.index, roundtrip_file.group.index,
+        "Block index should match after roundtrip"
+    );
+
+    // Test the first, middle and last block.
+    let blocks_len = original_file.group.blocks.len();
+    let test_block_indices = [0, blocks_len / 2, blocks_len - 1];
+
+    for &i in &test_block_indices {
+        let original = &original_file.group.blocks[i];
+        let roundtrip = &roundtrip_file.group.blocks[i];
+        let block_number = original_file.group.index.starting_number() + i as u64;
+
+        println!("Testing roundtrip for block {block_number}");
+
+        // --- File roundtrip: compressed bytes / values must be identical ---
+        let original_header_data = original.header.decompress()?;
+        let original_body_data = original.body.decompress()?;
+        assert_eq!(
+            original_header_data,
+            roundtrip.header.decompress()?,
+            "Block {block_number} header data should be identical after roundtrip"
+        );
+        assert_eq!(
+            original_body_data,
+            roundtrip.body.decompress()?,
+            "Block {block_number} body data should be identical after roundtrip"
+        );
+        assert_eq!(
+            original.receipts.as_ref().map(|r| r.decompress()).transpose()?,
+            roundtrip.receipts.as_ref().map(|r| r.decompress()).transpose()?,
+            "Block {block_number} receipts should be identical after roundtrip"
+        );
+        assert_eq!(
+            original.total_difficulty.as_ref().map(|d| d.value),
+            roundtrip.total_difficulty.as_ref().map(|d| d.value),
+            "Block {block_number} total difficulty should be identical after roundtrip"
+        );
+        assert_eq!(
+            original.proof.as_ref().map(|p| &p.data),
+            roundtrip.proof.as_ref().map(|p| &p.data),
+            "Block {block_number} proof should be identical after roundtrip"
+        );
+
+        // --- Decode every component ---
+        let original_header = original.header.decode_header()?;
+        assert_eq!(
+            original_header.number,
+            roundtrip.header.decode_header()?.number,
+            "Block number should match after roundtrip decoding"
+        );
+
+        let original_body = decode_body(&original_body_data)?;
+        assert_eq!(
+            original_body.transactions.len(),
+            decode_body(&roundtrip.body.decompress()?)?.transactions.len(),
+            "Transaction count should match after roundtrip"
+        );
+
+        let original_receipts =
+            original.receipts.as_ref().map(|r| r.decode_receipts()).transpose()?;
+        let original_proof = original.proof.as_ref().map(|p| p.decode()).transpose()?;
+
+        // --- Re-encode / re-compress each component and confirm it survives ---
+        println!("Testing full re-encoding/re-compression cycle for block {block_number}");
+
+        let recompressed_header = CompressedHeader::from_header(&original_header)?;
+        assert_eq!(
+            recompressed_header.decompress()?,
+            original_header_data,
+            "Re-compressed header should match original after full cycle"
+        );
+
+        let recompressed_body = CompressedBody::from_body(&original_body)?;
+        assert_eq!(
+            decode_body(&recompressed_body.decompress()?)?.transactions.len(),
+            original_body.transactions.len(),
+            "Transaction count should match after re-compression"
+        );
+
+        let mut recompressed_block = BlockTuple::new(recompressed_header, recompressed_body);
+
+        if let Some(receipts) = &original_receipts {
+            let recompressed = CompressedSlimReceipts::from_receipts(receipts)?;
+            assert_eq!(
+                &recompressed.decode_receipts()?,
+                receipts,
+                "Block {block_number} receipts should survive re-encode"
+            );
+            recompressed_block = recompressed_block.with_receipts(recompressed);
+        }
+        if let Some(total_difficulty) = &original.total_difficulty {
+            recompressed_block = recompressed_block
+                .with_total_difficulty(TotalDifficulty::new(total_difficulty.value));
+        }
+        if let Some((proof_type, ssz_proof)) = &original_proof {
+            let recompressed = Proof::encode(*proof_type, ssz_proof)?;
+            assert_eq!(
+                recompressed.decode()?,
+                (*proof_type, ssz_proof.clone()),
+                "Block {block_number} proof should survive re-encode"
+            );
+            recompressed_block = recompressed_block.with_proof(recompressed);
+        }
+
+        // Write the single recompressed block to a new file and read it back.
+        let component_count = recompressed_block.component_count();
+        let index = DynamicBlockIndex::new(
+            block_number,
+            component_count,
+            vec![0; component_count as usize],
+        );
+        let new_group =
+            EreGroup::new(vec![recompressed_block], original_file.group.accumulator.clone(), index);
+        let new_file = EreFile::new(new_group, EreId::new(network, block_number, 1));
+
+        let mut recompressed_buffer = Vec::new();
+        {
+            let mut writer = EreWriter::new(&mut recompressed_buffer);
+            writer.write_file(&new_file)?;
+        }
+        let recompressed_file =
+            EreReader::new(Cursor::new(&recompressed_buffer)).read(network.to_string())?;
+        let recompressed_first = &recompressed_file.group.blocks[0];
+
+        assert_eq!(
+            recompressed_first.header.decode_header()?.number,
+            original_header.number,
+            "Block number should match after complete re-encoding cycle"
+        );
+        assert_eq!(
+            recompressed_first.header.decompress()?,
+            original_header_data,
+            "Header data should match after complete re-encoding cycle"
+        );
+
+        println!("Block {block_number} full cycle verified successfully 🫡");
+    }
+
+    println!("File {filename} roundtrip successful");
+    Ok(())
+}
+
+/// Decode a decompressed body into a typed [`BlockBody`].
+fn decode_body(data: &[u8]) -> eyre::Result<BlockBody<TransactionSigned>> {
+    Ok(CompressedBody::decode_body_from_decompressed::<TransactionSigned, Header>(data)?)
+}
+
+#[test_case::test_case("mainnet-00000-a6860fef.erae"; "ere_roundtrip_mainnet_0_premerge")]
+#[test_case::test_case("mainnet-00500-365ebdb8.erae"; "ere_roundtrip_mainnet_500_premerge")]
+#[test_case::test_case("mainnet-01500-8f81d882.erae"; "ere_roundtrip_mainnet_1500_premerge")]
+#[test_case::test_case("mainnet-01900-34196a7e.erae"; "ere_roundtrip_mainnet_1900_postmerge")]
+#[test_case::test_case("mainnet-02500-73f28496.erae"; "ere_roundtrip_mainnet_2500_postmerge")]
+#[test_case::test_case("mainnet-02992-d3f7961d.erae"; "ere_roundtrip_mainnet_2992_postmerge")]
+#[tokio::test(flavor = "multi_thread")]
+#[ignore = "download intensive"]
+async fn test_roundtrip_compression_encoding_mainnet(filename: &str) -> eyre::Result<()> {
+    let downloader = EraTestDownloader::new().await?;
+    test_ere_file_roundtrip(&downloader, filename, MAINNET).await
+}
diff --git a/crates/era/tests/it/main.rs b/crates/era/tests/it/main.rs
index 3954ef860b7..264075b6c67 100644
--- a/crates/era/tests/it/main.rs
+++ b/crates/era/tests/it/main.rs
@@ -12,6 +12,7 @@ use reth_era::{
     e2s::error::E2sError,
     era::file::{EraFile, EraReader},
     era1::file::{Era1File, Era1Reader},
+    ere::file::{EreFile, EreReader},
 };
 use reth_era_downloader::EraClient;
 use std::{
@@ -26,6 +27,7 @@ use tempfile::TempDir;
 
 mod era;
 mod era1;
+mod ere;
 
 const fn main() {}
 
@@ -102,6 +104,23 @@ const ERA_MAINNET_FILES_NAMES: [&str; 8] = [
     "mainnet-01592-d4dc8b98.era",
 ];
 
+/// Default mainnet url for downloading mainnet `.erae` files
+const ERE_MAINNET_URL: &str = "https://data.ethpandaops.io/erae/mainnet/";
+
+/// Succinct list of mainnet `.erae` files
+/// from <https://data.ethpandaops.io/erae/mainnet/>.
+///
+/// Spread across history and the merge (era ~1896) so both compositions are covered: pre-merge
+/// files carry total-difficulty and an accumulator, post-merge files carry neither.
+const ERE_MAINNET_FILES_NAMES: [&str; 6] = [
+    "mainnet-00000-a6860fef.erae",
+    "mainnet-00500-365ebdb8.erae",
+    "mainnet-01500-8f81d882.erae",
+    "mainnet-01900-34196a7e.erae",
+    "mainnet-02500-73f28496.erae",
+    "mainnet-02992-d3f7961d.erae",
+];
+
 /// Utility for downloading `.era` and `.era1` files for tests
 /// in a temporary directory and caching them in memory
 #[derive(Debug)]
@@ -195,6 +214,7 @@ impl EraTestDownloader {
         match (network, file_type) {
             (MAINNET, EraFileType::Era1) => Ok((ERA1_MAINNET_URL, &ERA1_MAINNET_FILES_NAMES[..])),
             (MAINNET, EraFileType::Era) => Ok((ERA_MAINNET_URL, &ERA_MAINNET_FILES_NAMES[..])),
+            (MAINNET, EraFileType::Ere) => Ok((ERE_MAINNET_URL, &ERE_MAINNET_FILES_NAMES[..])),
             (SEPOLIA, EraFileType::Era1) => Ok((ERA1_SEPOLIA_URL, &ERA1_SEPOLIA_FILES_NAMES[..])),
             (HOODI, EraFileType::Era) => Ok((ERA_HOODI_URL, &ERA_HOODI_FILES_NAMES[..])),
             _ => Err(eyre!(
@@ -216,4 +236,10 @@ impl EraTestDownloader {
         let path = self.download_file(filename, network).await?;
         EraReader::open(&path, network).map_err(|e| eyre!("Failed to open Era1 file: {e}"))
     }
+
+    /// Open `.erae` file, downloading it if necessary
+    async fn open_ere_file(&self, filename: &str, network: &str) -> Result<EreFile> {
+        let path = self.download_file(filename, network).await?;
+        EreReader::open(&path, network).map_err(|e| eyre!("Failed to open ere file: {e}"))
+    }
 }
diff --git a/crates/errors/src/error.rs b/crates/errors/src/error.rs
index 676a9c015d9..7ecda605651 100644
--- a/crates/errors/src/error.rs
+++ b/crates/errors/src/error.rs
@@ -61,9 +61,9 @@ mod size_asserts {
         };
     }
 
-    static_assert_size!(RethError, 56);
+    static_assert_size!(RethError, 64);
     static_assert_size!(BlockExecutionError, 56);
     static_assert_size!(ConsensusError, 48);
     static_assert_size!(DatabaseError, 32);
-    static_assert_size!(ProviderError, 48);
+    static_assert_size!(ProviderError, 56);
 }
diff --git a/crates/ethereum/cli/src/app.rs b/crates/ethereum/cli/src/app.rs
index 5858689d1e9..eb1466ab785 100644
--- a/crates/ethereum/cli/src/app.rs
+++ b/crates/ethereum/cli/src/app.rs
@@ -18,7 +18,7 @@ use reth_node_ethereum::{consensus::EthBeaconConsensus, EthEvmConfig, EthereumNo
 use reth_node_metrics::recorder::install_prometheus_recorder;
 use reth_rpc_server_types::RpcModuleValidator;
 use reth_tasks::RayonConfig;
-use reth_tracing::{FileWorkerGuard, Layers};
+use reth_tracing::{Layers, TracingGuards};
 use std::{fmt, sync::Arc};
 
 /// A wrapper around a parsed CLI that handles command execution.
@@ -32,7 +32,7 @@ pub struct CliApp<
     cli: Cli<Spec, Ext, Rpc, SubCmd>,
     runner: Option<CliRunner>,
     layers: Option<Layers>,
-    guard: Option<FileWorkerGuard>,
+    guard: Option<TracingGuards>,
 }
 
 impl<C, Ext, Rpc, SubCmd> CliApp<C, Ext, Rpc, SubCmd>
@@ -141,7 +141,7 @@ where
     /// See [`Cli::init_tracing`] for more information.
     pub fn init_tracing(&mut self, runner: &CliRunner) -> Result<()> {
         if let Some(layers) = self.layers.take() {
-            self.guard = self.cli.init_tracing(runner, layers)?;
+            self.guard = Some(self.cli.init_tracing(runner, layers)?);
         }
 
         Ok(())
diff --git a/crates/ethereum/cli/src/interface.rs b/crates/ethereum/cli/src/interface.rs
index d647c76e0a4..8d059ea58ae 100644
--- a/crates/ethereum/cli/src/interface.rs
+++ b/crates/ethereum/cli/src/interface.rs
@@ -22,7 +22,7 @@ use reth_node_core::{
     version::version_metadata,
 };
 use reth_rpc_server_types::{DefaultRpcModuleValidator, RethRpcModule, RpcModuleValidator};
-use reth_tracing::{FileWorkerGuard, Layers};
+use reth_tracing::{Layers, TracingGuards};
 use std::{ffi::OsString, fmt, future::Future, marker::PhantomData, sync::Arc};
 use tracing::{info, warn};
 
@@ -210,8 +210,7 @@ impl<
 
     /// Initializes tracing with the configured options.
     ///
-    /// If file logging is enabled, this function returns a guard that must be kept alive to ensure
-    /// that all logs are flushed to disk.
+    /// Returns tracing guards that must be kept alive to ensure outputs are flushed to disk.
     ///
     /// If an OTLP endpoint is specified, it will export traces and logs to the configured
     /// collector.
@@ -219,13 +218,13 @@ impl<
         &mut self,
         runner: &CliRunner,
         mut layers: Layers,
-    ) -> eyre::Result<Option<FileWorkerGuard>> {
+    ) -> eyre::Result<TracingGuards> {
         let otlp_status = runner.block_on(self.traces.init_otlp_tracing(&mut layers))?;
         let otlp_logs_status = runner.block_on(self.traces.init_otlp_logs(&mut layers))?;
 
         // Enable reload support if debug RPC namespace is available
         let enable_reload = self.command.debug_namespace_enabled();
-        let file_guard = self.logs.init_tracing_with_layers(layers, enable_reload)?;
+        let guards = self.logs.init_tracing_with_layers(layers, enable_reload)?;
         info!(target: "reth::cli", "Initialized tracing, debug log directory: {}", self.logs.log_file_directory);
 
         match otlp_status {
@@ -248,7 +247,7 @@ impl<
             OtlpLogsStatus::Disabled => {}
         }
 
-        Ok(file_guard)
+        Ok(guards)
     }
 }
 
diff --git a/crates/ethereum/consensus/src/lib.rs b/crates/ethereum/consensus/src/lib.rs
index f1113898c0d..8bc2c6badb1 100644
--- a/crates/ethereum/consensus/src/lib.rs
+++ b/crates/ethereum/consensus/src/lib.rs
@@ -14,6 +14,7 @@ extern crate alloc;
 use alloc::{fmt::Debug, sync::Arc};
 use alloy_consensus::{constants::MAXIMUM_EXTRA_DATA_SIZE, EMPTY_OMMER_ROOT_HASH};
 use alloy_eips::eip7840::BlobParams;
+use alloy_primitives::B256;
 use reth_chainspec::{EthChainSpec, EthereumHardforks};
 use reth_consensus::{
     Consensus, ConsensusError, FullConsensus, HeaderValidator, ReceiptRootBloom, TransactionRoot,
@@ -49,6 +50,8 @@ pub struct EthBeaconConsensus<ChainSpec> {
     skip_blob_gas_used_check: bool,
     /// When true, skips the requests hash check in post-execution validation.
     skip_requests_hash_check: bool,
+    /// When true, allows BAL hashes before Amsterdam activation.
+    allow_bal_hashes: bool,
 }
 
 impl<ChainSpec: EthChainSpec + EthereumHardforks> EthBeaconConsensus<ChainSpec> {
@@ -60,6 +63,7 @@ impl<ChainSpec: EthChainSpec + EthereumHardforks> EthBeaconConsensus<ChainSpec>
             skip_gas_limit_ramp_check: false,
             skip_blob_gas_used_check: false,
             skip_requests_hash_check: false,
+            allow_bal_hashes: false,
         }
     }
 
@@ -92,6 +96,12 @@ impl<ChainSpec: EthChainSpec + EthereumHardforks> EthBeaconConsensus<ChainSpec>
         self
     }
 
+    /// Allows BAL hashes before Amsterdam activation.
+    pub const fn with_allow_bal_hashes(mut self, allow: bool) -> Self {
+        self.allow_bal_hashes = allow;
+        self
+    }
+
     /// Returns the chain spec associated with this consensus engine.
     pub const fn chain_spec(&self) -> &Arc<ChainSpec> {
         &self.chain_spec
@@ -108,9 +118,16 @@ where
         block: &RecoveredBlock<N::Block>,
         result: &BlockExecutionResult<N::Receipt>,
         receipt_root_bloom: Option<ReceiptRootBloom>,
+        block_access_list_hash: Option<B256>,
     ) -> Result<(), ConsensusError> {
-        let res =
-            validate_block_post_execution(block, &self.chain_spec, result, receipt_root_bloom);
+        let res = validation::validate_block_post_execution_with_bal_hashes(
+            block,
+            &self.chain_spec,
+            result,
+            receipt_root_bloom,
+            block_access_list_hash,
+            self.allow_bal_hashes,
+        );
 
         if self.skip_requests_hash_check &&
             let Err(ConsensusError::BodyRequestsHashDiff(_)) = &res
@@ -228,6 +245,22 @@ where
             return Err(ConsensusError::RequestsHashUnexpected)
         }
 
+        if self.chain_spec.is_amsterdam_active_at_timestamp(header.timestamp()) {
+            if header.block_access_list_hash().is_none() {
+                return Err(ConsensusError::BlockAccessListHashMissing)
+            }
+            if header.slot_number().is_none() {
+                return Err(ConsensusError::SlotNumberMissing)
+            }
+        } else {
+            if header.block_access_list_hash().is_some() && !self.allow_bal_hashes {
+                return Err(ConsensusError::BlockAccessListHashUnexpected)
+            }
+            if header.slot_number().is_some() {
+                return Err(ConsensusError::SlotNumberUnexpected)
+            }
+        }
+
         Ok(())
     }
 
@@ -263,9 +296,11 @@ where
 mod tests {
     use super::*;
     use alloy_consensus::Header;
+    use alloy_eips::eip7685::EMPTY_REQUESTS_HASH;
     use alloy_primitives::B256;
     use reth_chainspec::{ChainSpec, ChainSpecBuilder};
     use reth_consensus_common::validation::validate_against_parent_gas_limit;
+    use reth_ethereum_primitives::{Block as EthBlock, EthPrimitives, Receipt};
     use reth_primitives_traits::{
         constants::{GAS_LIMIT_BOUND_DIVISOR, MINIMUM_GAS_LIMIT},
         proofs,
@@ -276,6 +311,24 @@ mod tests {
         SealedHeader::new(header, B256::ZERO)
     }
 
+    fn valid_prague_header() -> reth_primitives_traits::Header {
+        reth_primitives_traits::Header {
+            base_fee_per_gas: Some(1337),
+            withdrawals_root: Some(proofs::calculate_withdrawals_root(&[])),
+            blob_gas_used: Some(0),
+            excess_blob_gas: Some(0),
+            parent_beacon_block_root: Some(B256::ZERO),
+            requests_hash: Some(EMPTY_REQUESTS_HASH),
+            ..Default::default()
+        }
+    }
+
+    fn prague_recovered_block_with_bal_hash(hash: B256) -> RecoveredBlock<EthBlock> {
+        let mut header = valid_prague_header();
+        header.block_access_list_hash = Some(hash);
+        RecoveredBlock::new_unhashed(EthBlock { header, body: Default::default() }, Vec::new())
+    }
+
     #[test]
     fn test_valid_gas_limit_increase() {
         let parent = header_with_gas_limit(GAS_LIMIT_BOUND_DIVISOR * 10);
@@ -358,4 +411,135 @@ mod tests {
             .validate_header(&SealedHeader::seal_slow(header,))
             .is_ok());
     }
+
+    #[test]
+    fn prague_header_rejects_block_access_list_hash_before_amsterdam() {
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().prague_activated().build());
+        let mut header = valid_prague_header();
+        header.block_access_list_hash = Some(B256::ZERO);
+
+        assert!(matches!(
+            EthBeaconConsensus::new(chain_spec)
+                .validate_header(&SealedHeader::seal_slow(header,))
+                .unwrap_err(),
+            ConsensusError::BlockAccessListHashUnexpected
+        ));
+    }
+
+    #[test]
+    fn prague_header_allows_block_access_list_hash_before_amsterdam() {
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().prague_activated().build());
+        let mut header = valid_prague_header();
+        header.block_access_list_hash = Some(B256::ZERO);
+
+        assert!(EthBeaconConsensus::new(chain_spec)
+            .with_allow_bal_hashes(true)
+            .validate_header(&SealedHeader::seal_slow(header,))
+            .is_ok());
+    }
+
+    #[test]
+    fn prague_header_rejects_slot_number_before_amsterdam() {
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().prague_activated().build());
+        let mut header = valid_prague_header();
+        header.slot_number = Some(0);
+
+        assert!(matches!(
+            EthBeaconConsensus::new(chain_spec)
+                .validate_header(&SealedHeader::seal_slow(header,))
+                .unwrap_err(),
+            ConsensusError::SlotNumberUnexpected
+        ));
+    }
+
+    #[test]
+    fn prague_header_rejects_slot_number_with_allowed_bal_hashes_before_amsterdam() {
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().prague_activated().build());
+        let mut header = valid_prague_header();
+        header.block_access_list_hash = Some(B256::ZERO);
+        header.slot_number = Some(0);
+
+        assert!(matches!(
+            EthBeaconConsensus::new(chain_spec)
+                .with_allow_bal_hashes(true)
+                .validate_header(&SealedHeader::seal_slow(header,))
+                .unwrap_err(),
+            ConsensusError::SlotNumberUnexpected
+        ));
+    }
+
+    #[test]
+    fn prague_post_execution_allows_block_access_list_hash_before_amsterdam() {
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().prague_activated().build());
+        let expected_hash = B256::repeat_byte(0x42);
+        let block = prague_recovered_block_with_bal_hash(expected_hash);
+        let result = BlockExecutionResult::<Receipt>::default();
+        let consensus = EthBeaconConsensus::new(chain_spec).with_allow_bal_hashes(true);
+
+        assert!(FullConsensus::<EthPrimitives>::validate_block_post_execution(
+            &consensus,
+            &block,
+            &result,
+            None,
+            Some(expected_hash),
+        )
+        .is_ok());
+
+        assert!(FullConsensus::<EthPrimitives>::validate_block_post_execution(
+            &consensus, &block, &result, None, None,
+        )
+        .is_ok());
+
+        assert!(matches!(
+            FullConsensus::<EthPrimitives>::validate_block_post_execution(
+                &consensus,
+                &block,
+                &result,
+                None,
+                Some(B256::repeat_byte(0x24)),
+            )
+            .unwrap_err(),
+            ConsensusError::BlockAccessListHashMismatch(_)
+        ));
+    }
+
+    #[test]
+    fn amsterdam_header_requires_block_access_list_hash() {
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().amsterdam_activated().build());
+        let mut header = valid_prague_header();
+        header.slot_number = Some(0);
+
+        assert!(matches!(
+            EthBeaconConsensus::new(chain_spec)
+                .validate_header(&SealedHeader::seal_slow(header,))
+                .unwrap_err(),
+            ConsensusError::BlockAccessListHashMissing
+        ));
+    }
+
+    #[test]
+    fn amsterdam_header_requires_slot_number() {
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().amsterdam_activated().build());
+        let mut header = valid_prague_header();
+        header.block_access_list_hash = Some(B256::ZERO);
+
+        assert!(matches!(
+            EthBeaconConsensus::new(chain_spec)
+                .validate_header(&SealedHeader::seal_slow(header,))
+                .unwrap_err(),
+            ConsensusError::SlotNumberMissing
+        ));
+    }
+
+    #[test]
+    fn amsterdam_header_accepts_block_access_list_hash_and_slot_number() {
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().amsterdam_activated().build());
+        let mut header = valid_prague_header();
+        header.block_access_list_hash = Some(B256::ZERO);
+        header.slot_number = Some(0);
+
+        assert!(EthBeaconConsensus::new(chain_spec)
+            .validate_header(&SealedHeader::seal_slow(header,))
+            .is_ok());
+    }
 }
diff --git a/crates/ethereum/consensus/src/validation.rs b/crates/ethereum/consensus/src/validation.rs
index 56ba60c5860..5acb8a02e29 100644
--- a/crates/ethereum/consensus/src/validation.rs
+++ b/crates/ethereum/consensus/src/validation.rs
@@ -13,6 +13,7 @@ use reth_primitives_traits::{
 ///
 /// - Compares the receipts root in the block header to the block body
 /// - Compares the gas used in the block header to the actual gas usage after execution
+/// - Compares the computed Block Access List Hash to the value in the header if Amsterdam is active
 ///
 /// If `receipt_root_bloom` is provided, the pre-computed receipt root and logs bloom are used
 /// instead of computing them from the receipts.
@@ -21,6 +22,31 @@ pub fn validate_block_post_execution<B, R, ChainSpec>(
     chain_spec: &ChainSpec,
     result: &BlockExecutionResult<R>,
     receipt_root_bloom: Option<(B256, Bloom)>,
+    block_access_list_hash: Option<B256>,
+) -> Result<(), ConsensusError>
+where
+    B: Block,
+    R: Receipt,
+    ChainSpec: EthereumHardforks,
+{
+    validate_block_post_execution_with_bal_hashes(
+        block,
+        chain_spec,
+        result,
+        receipt_root_bloom,
+        block_access_list_hash,
+        false,
+    )
+}
+
+/// Validate a block with regard to execution results, optionally allowing pre-Amsterdam BAL hashes.
+pub(crate) fn validate_block_post_execution_with_bal_hashes<B, R, ChainSpec>(
+    block: &RecoveredBlock<B>,
+    chain_spec: &ChainSpec,
+    result: &BlockExecutionResult<R>,
+    receipt_root_bloom: Option<(B256, Bloom)>,
+    block_access_list_hash: Option<B256>,
+    allow_bal_hashes: bool,
 ) -> Result<(), ConsensusError>
 where
     B: Block,
@@ -79,6 +105,23 @@ where
         }
     }
 
+    // Validate that the header block access list hash matches the calculated block access list hash
+    let is_allowed_pre_amsterdam_bal_hash = allow_bal_hashes &&
+        !chain_spec.is_amsterdam_active_at_timestamp(block.header().timestamp()) &&
+        block.header().block_access_list_hash().is_some();
+
+    if (chain_spec.is_amsterdam_active_at_timestamp(block.header().timestamp()) ||
+        is_allowed_pre_amsterdam_bal_hash) &&
+        let Some(block_access_list_hash) = block_access_list_hash
+    {
+        let block_bal_hash = block.header().block_access_list_hash().unwrap_or_default();
+        if block_access_list_hash != block_bal_hash {
+            return Err(ConsensusError::BlockAccessListHashMismatch(
+                GotExpected::new(block_access_list_hash, block_bal_hash).into(),
+            ))
+        }
+    }
+
     Ok(())
 }
 
diff --git a/crates/ethereum/engine-primitives/src/lib.rs b/crates/ethereum/engine-primitives/src/lib.rs
index 962f6241f4e..798b9ec71d7 100644
--- a/crates/ethereum/engine-primitives/src/lib.rs
+++ b/crates/ethereum/engine-primitives/src/lib.rs
@@ -12,6 +12,7 @@
 extern crate alloc;
 
 mod payload;
+use alloy_primitives::Bytes;
 pub use payload::{BlobSidecars, EthBuiltPayload};
 
 mod error;
@@ -34,14 +35,15 @@ pub struct EthEngineTypes<T: PayloadTypes = EthPayloadTypes> {
     _marker: core::marker::PhantomData<T>,
 }
 
-impl<
-        T: PayloadTypes<
-            ExecutionData = ExecutionData,
-            BuiltPayload: BuiltPayload<
-                Primitives: NodePrimitives<Block = reth_ethereum_primitives::Block>,
-            >,
+impl<T> PayloadTypes for EthEngineTypes<T>
+where
+    T: PayloadTypes<
+        ExecutionData = ExecutionData,
+        BuiltPayload: BuiltPayload<
+            Primitives: NodePrimitives<Block = reth_ethereum_primitives::Block>,
         >,
-    > PayloadTypes for EthEngineTypes<T>
+    >,
+    ExecutionData: From<T::BuiltPayload>,
 {
     type ExecutionData = T::ExecutionData;
     type BuiltPayload = T::BuiltPayload;
@@ -51,14 +53,16 @@ impl<
         block: SealedBlock<
             <<Self::BuiltPayload as BuiltPayload>::Primitives as NodePrimitives>::Block,
         >,
+        bal: Option<Bytes>,
     ) -> Self::ExecutionData {
-        T::block_to_payload(block)
+        T::block_to_payload(block, bal)
     }
 }
 
 impl<T> EngineTypes for EthEngineTypes<T>
 where
     T: PayloadTypes<ExecutionData = ExecutionData>,
+    ExecutionData: From<T::BuiltPayload>,
     T::BuiltPayload: BuiltPayload<Primitives: NodePrimitives<Block = reth_ethereum_primitives::Block>>
         + TryInto<ExecutionPayloadV1>
         + TryInto<ExecutionPayloadEnvelopeV2>
@@ -89,9 +93,13 @@ impl PayloadTypes for EthPayloadTypes {
         block: SealedBlock<
             <<Self::BuiltPayload as BuiltPayload>::Primitives as NodePrimitives>::Block,
         >,
+        bal: Option<Bytes>,
     ) -> Self::ExecutionData {
-        let (payload, sidecar) =
-            ExecutionPayload::from_block_unchecked(block.hash(), &block.into_block());
+        let (payload, sidecar) = ExecutionPayload::from_block_unchecked_with_extras(
+            block.hash(),
+            &block.into_block(),
+            bal,
+        );
         ExecutionData { payload, sidecar }
     }
 }
diff --git a/crates/ethereum/engine-primitives/src/payload.rs b/crates/ethereum/engine-primitives/src/payload.rs
index 0318b095ef9..602dcc9f355 100644
--- a/crates/ethereum/engine-primitives/src/payload.rs
+++ b/crates/ethereum/engine-primitives/src/payload.rs
@@ -8,13 +8,15 @@ use alloy_eips::{
 };
 use alloy_primitives::{Bytes, U256};
 use alloy_rpc_types_engine::{
-    BlobsBundleV1, BlobsBundleV2, ExecutionPayloadEnvelopeV2, ExecutionPayloadEnvelopeV3,
-    ExecutionPayloadEnvelopeV4, ExecutionPayloadEnvelopeV5, ExecutionPayloadEnvelopeV6,
-    ExecutionPayloadFieldV2, ExecutionPayloadV1, ExecutionPayloadV3, ExecutionPayloadV4,
+    BlobsBundleV1, BlobsBundleV2, CancunPayloadFields, ExecutionData, ExecutionPayload,
+    ExecutionPayloadEnvelopeV2, ExecutionPayloadEnvelopeV3, ExecutionPayloadEnvelopeV4,
+    ExecutionPayloadEnvelopeV5, ExecutionPayloadEnvelopeV6, ExecutionPayloadFieldV2,
+    ExecutionPayloadSidecar, ExecutionPayloadV1, ExecutionPayloadV3, ExecutionPayloadV4,
+    PraguePayloadFields,
 };
 use reth_ethereum_primitives::EthPrimitives;
 use reth_payload_primitives::BuiltPayload;
-use reth_primitives_traits::{NodePrimitives, SealedBlock};
+use reth_primitives_traits::{NodePrimitives, RecoveredBlock, SealedBlock};
 
 use crate::BuiltPayloadConversionError;
 
@@ -28,7 +30,7 @@ use crate::BuiltPayloadConversionError;
 #[derive(Debug, Clone)]
 pub struct EthBuiltPayload<N: NodePrimitives = EthPrimitives> {
     /// The built block
-    pub(crate) block: Arc<SealedBlock<N::Block>>,
+    pub(crate) block: Arc<RecoveredBlock<N::Block>>,
     /// The fees of the block
     pub(crate) fees: U256,
     /// The blobs, proofs, and commitments in the block. If the block is pre-cancun, this will be
@@ -47,7 +49,7 @@ impl<N: NodePrimitives> EthBuiltPayload<N> {
     ///
     /// Caution: This does not set any [`BlobSidecars`].
     pub const fn new(
-        block: Arc<SealedBlock<N::Block>>,
+        block: Arc<RecoveredBlock<N::Block>>,
         fees: U256,
         requests: Option<Requests>,
         block_access_list: Option<Bytes>,
@@ -57,9 +59,24 @@ impl<N: NodePrimitives> EthBuiltPayload<N> {
 
     /// Returns the built block(sealed)
     pub fn block(&self) -> &SealedBlock<N::Block> {
+        self.block.sealed_block()
+    }
+
+    /// Returns the built block with recovered senders.
+    pub fn recovered_block(&self) -> &RecoveredBlock<N::Block> {
+        &self.block
+    }
+
+    /// Returns the built block with shared ownership.
+    pub const fn block_arc(&self) -> &Arc<RecoveredBlock<N::Block>> {
         &self.block
     }
 
+    /// Consumes the payload and returns the built block with shared ownership.
+    pub fn into_block_arc(self) -> Arc<RecoveredBlock<N::Block>> {
+        self.block
+    }
+
     /// Fees of the block
     pub const fn fees(&self) -> U256 {
         self.fees
@@ -189,19 +206,56 @@ impl EthBuiltPayload {
             execution_requests: requests.unwrap_or_default(),
         })
     }
+
+    /// Converts built payload into [`ExecutionData`].
+    pub fn into_execution_data(self) -> ExecutionData {
+        let Self { block, requests, block_access_list, .. } = self;
+        let block_hash = block.hash();
+        let block = Arc::unwrap_or_clone(block).into_block();
+
+        let (payload, sidecar) = ExecutionPayload::from_block_unchecked_with_extras(
+            block_hash,
+            &block,
+            block_access_list,
+        );
+
+        let sidecar = if let Some(requests) = requests {
+            block.header.parent_beacon_block_root.map_or(sidecar, |parent_beacon_block_root| {
+                ExecutionPayloadSidecar::v4(
+                    CancunPayloadFields {
+                        parent_beacon_block_root,
+                        versioned_hashes: block
+                            .body
+                            .blob_versioned_hashes_iter()
+                            .copied()
+                            .collect(),
+                    },
+                    PraguePayloadFields::new(requests),
+                )
+            })
+        } else {
+            sidecar
+        };
+
+        ExecutionData::new(payload, sidecar)
+    }
 }
 
 impl<N: NodePrimitives> BuiltPayload for EthBuiltPayload<N> {
     type Primitives = N;
 
     fn block(&self) -> &SealedBlock<N::Block> {
-        &self.block
+        self.block.sealed_block()
     }
 
     fn fees(&self) -> U256 {
         self.fees
     }
 
+    fn block_access_list(&self) -> Option<&Bytes> {
+        self.block_access_list.as_ref()
+    }
+
     fn requests(&self) -> Option<Requests> {
         self.requests.clone()
     }
@@ -264,6 +318,19 @@ impl TryFrom<EthBuiltPayload> for ExecutionPayloadEnvelopeV6 {
     }
 }
 
+impl From<EthBuiltPayload> for ExecutionData {
+    fn from(value: EthBuiltPayload) -> Self {
+        value.into_execution_data()
+    }
+}
+
+#[cfg(feature = "std")]
+impl From<EthBuiltPayload> for reth_engine_primitives::BigBlockData<ExecutionData> {
+    fn from(_value: EthBuiltPayload) -> Self {
+        unreachable!("payload building is not supported for big blocks");
+    }
+}
+
 /// An enum representing blob transaction sidecars belonging to [`EthBuiltPayload`].
 #[derive(Clone, Default, Debug)]
 pub enum BlobSidecars {
@@ -350,3 +417,62 @@ impl From<alloc::vec::IntoIter<BlobTransactionSidecarEip7594>> for BlobSidecars
         value.collect::<Vec<_>>().into()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy_primitives::B256;
+    use reth_primitives_traits::{Block as _, RecoveredBlock};
+
+    #[test]
+    fn into_execution_data_preserves_requests() {
+        let requests = Requests::from_requests([Bytes::from_static(&[1, 2])]);
+        let parent_beacon_block_root = B256::with_last_byte(1);
+
+        let mut block = reth_ethereum_primitives::Block::default();
+        block.header.parent_beacon_block_root = Some(parent_beacon_block_root);
+        block.header.requests_hash = Some(requests.requests_hash());
+
+        let payload = EthBuiltPayload::new(
+            Arc::new(RecoveredBlock::new_sealed(block.seal_slow(), vec![])),
+            U256::ZERO,
+            Some(requests.clone()),
+            None,
+        );
+
+        let execution_data: ExecutionData = payload.into();
+
+        assert_eq!(
+            execution_data.sidecar.parent_beacon_block_root(),
+            Some(parent_beacon_block_root)
+        );
+        assert_eq!(execution_data.sidecar.requests(), Some(&requests));
+    }
+
+    #[test]
+    fn into_execution_data_preserves_block_access_list() {
+        let block_access_list = Bytes::from_static(&[0xc0]);
+
+        let mut block = reth_ethereum_primitives::Block::default();
+        block.header.parent_beacon_block_root = Some(B256::ZERO);
+        block.header.block_access_list_hash = Some(B256::ZERO);
+
+        let payload = EthBuiltPayload::new(
+            Arc::new(RecoveredBlock::new_sealed(block.seal_slow(), vec![])),
+            U256::ZERO,
+            None,
+            Some(block_access_list.clone()),
+        );
+
+        let execution_data: ExecutionData = payload.into();
+
+        assert_eq!(execution_data.payload.block_access_list(), Some(&block_access_list));
+    }
+
+    #[test]
+    fn execution_data_has_infallible_try_from_impl() {
+        fn assert_try_from<T: TryFrom<EthBuiltPayload, Error = core::convert::Infallible>>() {}
+
+        assert_try_from::<ExecutionData>();
+    }
+}
diff --git a/crates/ethereum/evm/src/build.rs b/crates/ethereum/evm/src/build.rs
index 4de9e8361ed..263cf4e0b35 100644
--- a/crates/ethereum/evm/src/build.rs
+++ b/crates/ethereum/evm/src/build.rs
@@ -5,10 +5,11 @@ use alloy_consensus::{
 };
 use alloy_eips::{eip4895::Withdrawals, merge::BEACON_NONCE};
 use alloy_evm::{block::BlockExecutorFactory, eth::EthBlockExecutionCtx};
+use alloy_primitives::{Bloom, B256};
 use reth_chainspec::{EthChainSpec, EthereumHardforks};
 use reth_evm::execute::{BlockAssembler, BlockAssemblerInput, BlockExecutionError};
 use reth_execution_types::BlockExecutionResult;
-use reth_primitives_traits::{logs_bloom, Receipt, SignedTransaction};
+use reth_primitives_traits::{logs_bloom as calculate_logs_bloom, Receipt, SignedTransaction};
 use revm::context::Block as _;
 
 /// Block builder for Ethereum.
@@ -25,21 +26,23 @@ impl<ChainSpec> EthBlockAssembler<ChainSpec> {
     }
 }
 
-impl<F, ChainSpec> BlockAssembler<F> for EthBlockAssembler<ChainSpec>
-where
-    F: for<'a> BlockExecutorFactory<
-        ExecutionCtx<'a> = EthBlockExecutionCtx<'a>,
-        Transaction: SignedTransaction,
-        Receipt: Receipt,
-    >,
-    ChainSpec: EthChainSpec + EthereumHardforks,
-{
-    type Block = Block<F::Transaction>;
-
-    fn assemble_block(
+impl<ChainSpec: EthChainSpec + EthereumHardforks> EthBlockAssembler<ChainSpec> {
+    /// Assembles a block. Accepts optional precomputed transaction root, receipt root, and logs
+    /// bloom.
+    pub fn assemble_block<F>(
         &self,
         input: BlockAssemblerInput<'_, '_, F>,
-    ) -> Result<Self::Block, BlockExecutionError> {
+        transactions_root: Option<B256>,
+        receipts_root: Option<B256>,
+        logs_bloom: Option<Bloom>,
+    ) -> Result<Block<F::Transaction>, BlockExecutionError>
+    where
+        F: for<'a> BlockExecutorFactory<
+            ExecutionCtx<'a> = EthBlockExecutionCtx<'a>,
+            Transaction: SignedTransaction,
+            Receipt: Receipt,
+        >,
+    {
         let BlockAssemblerInput {
             evm_env,
             execution_ctx: ctx,
@@ -47,16 +50,19 @@ where
             transactions,
             output: BlockExecutionResult { receipts, requests, gas_used, blob_gas_used },
             state_root,
+            block_access_list_hash,
             ..
         } = input;
 
         let timestamp = evm_env.block_env.timestamp().saturating_to();
 
-        let transactions_root = proofs::calculate_transaction_root(&transactions);
-        let receipts_root = calculate_receipt_root(
-            &receipts.iter().map(|r| r.with_bloom_ref()).collect::<Vec<_>>(),
-        );
-        let logs_bloom = logs_bloom(receipts.iter().flat_map(|r| r.logs()));
+        let transactions_root =
+            transactions_root.unwrap_or_else(|| proofs::calculate_transaction_root(&transactions));
+        let receipts_root = receipts_root.unwrap_or_else(|| {
+            calculate_receipt_root(&receipts.iter().map(|r| r.with_bloom_ref()).collect::<Vec<_>>())
+        });
+        let logs_bloom = logs_bloom
+            .unwrap_or_else(|| calculate_logs_bloom(receipts.iter().flat_map(|r| r.logs())));
 
         let withdrawals = self
             .chain_spec
@@ -69,6 +75,11 @@ where
             .chain_spec
             .is_prague_active_at_timestamp(timestamp)
             .then(|| requests.requests_hash());
+        let block_number = evm_env.block_env.number().saturating_to();
+        let base_fee_per_gas = self
+            .chain_spec
+            .is_london_active_at_block(block_number)
+            .then(|| evm_env.block_env.basefee());
 
         let mut excess_blob_gas = None;
         let mut block_blob_gas_used = None;
@@ -102,8 +113,8 @@ where
             timestamp,
             mix_hash: evm_env.block_env.prevrandao().unwrap_or_default(),
             nonce: BEACON_NONCE.into(),
-            base_fee_per_gas: Some(evm_env.block_env.basefee()),
-            number: evm_env.block_env.number().saturating_to(),
+            base_fee_per_gas,
+            number: block_number,
             gas_limit: evm_env.block_env.gas_limit(),
             difficulty: evm_env.block_env.difficulty(),
             gas_used: *gas_used,
@@ -112,8 +123,8 @@ where
             blob_gas_used: block_blob_gas_used,
             excess_blob_gas,
             requests_hash,
-            block_access_list_hash: None,
-            slot_number: None,
+            block_access_list_hash,
+            slot_number: ctx.slot_number,
         };
 
         Ok(Block {
@@ -122,3 +133,22 @@ where
         })
     }
 }
+
+impl<F, ChainSpec> BlockAssembler<F> for EthBlockAssembler<ChainSpec>
+where
+    F: for<'a> BlockExecutorFactory<
+        ExecutionCtx<'a> = EthBlockExecutionCtx<'a>,
+        Transaction: SignedTransaction,
+        Receipt: Receipt,
+    >,
+    ChainSpec: EthChainSpec + EthereumHardforks,
+{
+    type Block = Block<F::Transaction>;
+
+    fn assemble_block(
+        &self,
+        input: BlockAssemblerInput<'_, '_, F>,
+    ) -> Result<Self::Block, BlockExecutionError> {
+        self.assemble_block(input, None, None, None)
+    }
+}
diff --git a/crates/ethereum/evm/src/lib.rs b/crates/ethereum/evm/src/lib.rs
index db337b2b362..efc025726c1 100644
--- a/crates/ethereum/evm/src/lib.rs
+++ b/crates/ethereum/evm/src/lib.rs
@@ -416,14 +416,14 @@ mod tests {
         let db = CacheDB::<EmptyDBTyped<ProviderError>>::default();
 
         let evm_env = EvmEnv {
-            cfg_env: CfgEnv::new().with_spec_and_mainnet_gas_params(SpecId::CONSTANTINOPLE),
+            cfg_env: CfgEnv::new().with_spec_and_mainnet_gas_params(SpecId::PETERSBURG),
             ..Default::default()
         };
 
         let evm = evm_config.evm_with_env(db, evm_env);
 
         // Check that the spec ID is setup properly
-        assert_eq!(evm.cfg.spec, SpecId::CONSTANTINOPLE);
+        assert_eq!(evm.cfg.spec, SpecId::PETERSBURG);
     }
 
     #[test]
@@ -483,7 +483,7 @@ mod tests {
         let db = CacheDB::<EmptyDBTyped<ProviderError>>::default();
 
         let evm_env = EvmEnv {
-            cfg_env: CfgEnv::new().with_spec_and_mainnet_gas_params(SpecId::CONSTANTINOPLE),
+            cfg_env: CfgEnv::new().with_spec_and_mainnet_gas_params(SpecId::PETERSBURG),
             ..Default::default()
         };
 
diff --git a/crates/ethereum/evm/tests/execute.rs b/crates/ethereum/evm/tests/execute.rs
index c7d0a083376..e7db3d4271b 100644
--- a/crates/ethereum/evm/tests/execute.rs
+++ b/crates/ethereum/evm/tests/execute.rs
@@ -811,7 +811,7 @@ fn test_balance_increment_not_duplicated() {
     let tx_clone = tx.clone();
 
     let _output = executor
-        .execute_with_state_hook(block, move |_, state: &EvmState| {
+        .execute_with_state_hook(block, move |state: &EvmState| {
             if let Some(account) = state.get(&withdrawal_recipient) {
                 let _ = tx_clone.send(account.info.balance);
             }
diff --git a/crates/ethereum/node/Cargo.toml b/crates/ethereum/node/Cargo.toml
index 3a52f188a90..d29cfafff8c 100644
--- a/crates/ethereum/node/Cargo.toml
+++ b/crates/ethereum/node/Cargo.toml
@@ -12,7 +12,7 @@ workspace = true
 
 [dependencies]
 # reth
-reth-ethereum-engine-primitives.workspace = true
+reth-ethereum-engine-primitives = { workspace = true, features = ["std"] }
 reth-ethereum-payload-builder.workspace = true
 reth-ethereum-consensus.workspace = true
 reth-ethereum-primitives.workspace = true
@@ -31,6 +31,7 @@ reth-rpc-eth-api.workspace = true
 reth-rpc-builder.workspace = true
 reth-rpc-server-types.workspace = true
 reth-node-api.workspace = true
+reth-node-core.workspace = true
 reth-chainspec.workspace = true
 reth-revm = { workspace = true, features = ["std"] }
 reth-rpc-eth-types.workspace = true
@@ -38,13 +39,16 @@ reth-engine-local.workspace = true
 reth-engine-primitives = { workspace = true, features = ["std"] }
 reth-payload-primitives.workspace = true
 # ethereum
+alloy-consensus.workspace = true
 alloy-eips.workspace = true
+alloy-primitives.workspace = true
+jsonrpsee.workspace = true
 alloy-network.workspace = true
 alloy-rpc-types-eth.workspace = true
-alloy-rpc-types-engine.workspace = true
+alloy-rpc-types-engine = { workspace = true, features = ["ssz"] }
 
 # async
-tokio.workspace = true
+tokio = { workspace = true, features = ["sync"] }
 
 # revm with required ethereum features
 # Note: this must be kept to ensure all features are properly enabled/forwarded
@@ -52,6 +56,11 @@ revm = { workspace = true, features = ["secp256k1", "blst", "c-kzg", "memory_lim
 
 # misc
 eyre.workspace = true
+ethereum_ssz.workspace = true
+http-body-util.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+tower.workspace = true
 
 [dev-dependencies]
 reth-db.workspace = true
@@ -71,15 +80,17 @@ alloy-signer.workspace = true
 alloy-sol-types.workspace = true
 alloy-contract.workspace = true
 alloy-rpc-types-beacon = { workspace = true, features = ["ssz"] }
-alloy-consensus.workspace = true
 
 futures.workspace = true
 tokio.workspace = true
 serde_json.workspace = true
 rand.workspace = true
 serde.workspace = true
+enr = { workspace = true, features = ["rust-secp256k1"] }
 alloy-rpc-types-trace.workspace = true
 similar-asserts.workspace = true
+reqwest.workspace = true
+reth-rpc-layer.workspace = true
 
 [features]
 default = []
diff --git a/crates/ethereum/node/src/engine_ssz_proxy.rs b/crates/ethereum/node/src/engine_ssz_proxy.rs
new file mode 100644
index 00000000000..44984d296a1
--- /dev/null
+++ b/crates/ethereum/node/src/engine_ssz_proxy.rs
@@ -0,0 +1,751 @@
+//! HTTP SSZ transport proxy for the authenticated Engine API server.
+//!
+//! Implements the [EIP-8178] SSZ Engine API routes under `/engine/v2`.
+//!
+//! [EIP-8178]: https://eips.ethereum.org/EIPS/eip-8178
+
+use alloy_consensus::{Transaction, TxEnvelope};
+use alloy_eips::{
+    eip2718::Decodable2718,
+    eip7685::{Requests, RequestsOrHash},
+};
+use alloy_primitives::{Bytes, B128, B256};
+use alloy_rpc_types_engine::{
+    CancunPayloadFields, ClientVersionV1, ExecutionData, ExecutionPayload, ExecutionPayloadSidecar,
+    ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3, ExecutionPayloadV4,
+    ForkchoiceState, PayloadAttributes, PraguePayloadFields,
+};
+use http_body_util::BodyExt;
+use jsonrpsee::server::{HttpBody, HttpRequest, HttpResponse};
+use reth_chainspec::EthereumHardforks;
+use reth_engine_primitives::ConsensusEngineHandle;
+use reth_ethereum_engine_primitives::EthEngineTypes;
+use reth_node_core::version::{version_metadata, CLIENT_CODE};
+use reth_payload_primitives::EngineObjectValidationError;
+use reth_transaction_pool::BlobStore;
+use ssz::Decode;
+use std::{
+    future::Future,
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+    time::SystemTime,
+};
+use tokio::sync::RwLock;
+use tower::{BoxError, Layer, Service};
+
+const OCTET_STREAM: &str = "application/octet-stream";
+const APPLICATION_JSON: &str = "application/json";
+const TEXT_PLAIN: &str = "text/plain";
+const CONTENT_TYPE: &str = "content-type";
+
+const STATUS_OK: u16 = 200;
+const STATUS_BAD_REQUEST: u16 = 400;
+const STATUS_NOT_FOUND: u16 = 404;
+const STATUS_METHOD_NOT_ALLOWED: u16 = 405;
+const STATUS_PAYLOAD_TOO_LARGE: u16 = 413;
+const STATUS_INTERNAL_SERVER_ERROR: u16 = 500;
+const STATUS_SERVICE_UNAVAILABLE: u16 = 503;
+
+const MAX_BLOB_LIMIT: usize = 128;
+const MAX_PAYLOAD_BYTES: u64 = 64 * 1024 * 1024;
+
+/// Shared handle used by [`EngineSszProxyLayer`].
+pub struct EngineSszProxyHandle<ChainSpec> {
+    engine: Arc<RwLock<Option<ConsensusEngineHandle<EthEngineTypes>>>>,
+    blob_store: Arc<RwLock<Option<Arc<dyn BlobStore>>>>,
+    client_version: Arc<RwLock<Option<ClientVersionV1>>>,
+    chain_spec: Arc<ChainSpec>,
+}
+
+impl<C> Clone for EngineSszProxyHandle<C> {
+    fn clone(&self) -> Self {
+        Self {
+            engine: self.engine.clone(),
+            blob_store: self.blob_store.clone(),
+            client_version: self.client_version.clone(),
+            chain_spec: self.chain_spec.clone(),
+        }
+    }
+}
+
+impl<C> std::fmt::Debug for EngineSszProxyHandle<C> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("EngineSszProxyHandle").finish_non_exhaustive()
+    }
+}
+
+impl<ChainSpec> EngineSszProxyHandle<ChainSpec> {
+    fn new(chain_spec: Arc<ChainSpec>) -> Self {
+        Self {
+            engine: Default::default(),
+            blob_store: Default::default(),
+            client_version: Arc::new(RwLock::new(Some(default_client_version()))),
+            chain_spec,
+        }
+    }
+
+    /// Sets the consensus engine handle used by the proxy.
+    pub async fn set_engine(&self, engine: ConsensusEngineHandle<EthEngineTypes>) {
+        *self.engine.write().await = Some(engine);
+    }
+
+    async fn engine(&self) -> Option<ConsensusEngineHandle<EthEngineTypes>> {
+        self.engine.read().await.clone()
+    }
+
+    /// Sets the blob store used by the proxy for handling blob requests.
+    pub async fn set_blob_store(&self, blob_store: impl BlobStore) {
+        *self.blob_store.write().await = Some(Arc::new(blob_store));
+    }
+
+    async fn blob_store(&self) -> Option<Arc<dyn BlobStore>> {
+        self.blob_store.read().await.clone()
+    }
+
+    /// Sets the client version returned by the identity endpoint.
+    pub async fn set_client_version(&self, client_version: ClientVersionV1) {
+        *self.client_version.write().await = Some(client_version);
+    }
+
+    async fn client_version(&self) -> Option<ClientVersionV1> {
+        self.client_version.read().await.clone()
+    }
+
+    fn chain_spec(&self) -> Arc<ChainSpec> {
+        self.chain_spec.clone()
+    }
+}
+
+/// A tower layer that intercepts SSZ Engine API routes under `/engine/v2`.
+#[derive(Clone, Debug)]
+pub struct EngineSszProxyLayer<ChainSpec> {
+    handle: EngineSszProxyHandle<ChainSpec>,
+}
+
+impl<ChainSpec> EngineSszProxyLayer<ChainSpec> {
+    /// Creates a new proxy layer and a handle for setting the engine after node launch.
+    pub fn new(chain_spec: Arc<ChainSpec>) -> (Self, EngineSszProxyHandle<ChainSpec>) {
+        let handle = EngineSszProxyHandle::new(chain_spec);
+        (Self { handle: handle.clone() }, handle)
+    }
+}
+
+impl<S, ChainSpec> Layer<S> for EngineSszProxyLayer<ChainSpec> {
+    type Service = EngineSszProxyService<S, ChainSpec>;
+
+    fn layer(&self, inner: S) -> Self::Service {
+        EngineSszProxyService { inner, handle: self.handle.clone() }
+    }
+}
+
+/// The service produced by [`EngineSszProxyLayer`].
+#[derive(Clone, Debug)]
+pub struct EngineSszProxyService<S, ChainSpec> {
+    inner: S,
+    handle: EngineSszProxyHandle<ChainSpec>,
+}
+
+impl<S, ChainSpec> Service<HttpRequest> for EngineSszProxyService<S, ChainSpec>
+where
+    S: Service<HttpRequest, Response = HttpResponse, Error = BoxError> + Send + Clone,
+    S::Future: Send + 'static,
+    ChainSpec: EthereumHardforks + Send + Sync + 'static,
+{
+    type Response = HttpResponse;
+    type Error = BoxError;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx)
+    }
+
+    fn call(&mut self, request: HttpRequest) -> Self::Future {
+        if !request.uri().path().starts_with("/engine/") {
+            let fut = self.inner.call(request);
+            return Box::pin(fut)
+        }
+
+        let handle = self.handle.clone();
+        Box::pin(async move { Ok(handle_engine_ssz_request(handle, request).await) })
+    }
+}
+
+async fn handle_engine_ssz_request<ChainSpec>(
+    handle: EngineSszProxyHandle<ChainSpec>,
+    request: HttpRequest,
+) -> HttpResponse
+where
+    ChainSpec: EthereumHardforks + Send + Sync + 'static,
+{
+    let method = request.method().as_str().to_owned();
+    let path = request.uri().path().to_owned();
+    let Some(endpoint) = parse_engine_path(&path) else {
+        return text_response(STATUS_NOT_FOUND, "unknown engine ssz endpoint")
+    };
+
+    match endpoint {
+        EngineSszEndpoint::Capabilities => {
+            if method != "GET" {
+                return text_response(STATUS_METHOD_NOT_ALLOWED, "method not allowed")
+            }
+            handle_capabilities()
+        }
+        EngineSszEndpoint::Identity => {
+            if method != "GET" {
+                return text_response(STATUS_METHOD_NOT_ALLOWED, "method not allowed")
+            }
+            handle_identity(handle.client_version().await)
+        }
+        EngineSszEndpoint::Payloads(fork) => {
+            if method != "POST" {
+                return text_response(STATUS_METHOD_NOT_ALLOWED, "method not allowed")
+            }
+            let Ok(body) = request.into_body().collect().await.map(|body| body.to_bytes()) else {
+                return text_response(STATUS_BAD_REQUEST, "failed to read request body")
+            };
+            let Some(engine) = handle.engine().await else {
+                return text_response(STATUS_SERVICE_UNAVAILABLE, "engine handle unavailable")
+            };
+            handle_new_payload(engine, fork.payloads_version(), &body).await
+        }
+        EngineSszEndpoint::Forkchoice(fork) => {
+            if method != "POST" {
+                return text_response(STATUS_METHOD_NOT_ALLOWED, "method not allowed")
+            }
+            let Ok(body) = request.into_body().collect().await.map(|body| body.to_bytes()) else {
+                return text_response(STATUS_BAD_REQUEST, "failed to read request body")
+            };
+            let Some(engine) = handle.engine().await else {
+                return text_response(STATUS_SERVICE_UNAVAILABLE, "engine handle unavailable")
+            };
+            handle_forkchoice_updated(engine, fork.forkchoice_version(), &body).await
+        }
+        EngineSszEndpoint::Blobs(version) => {
+            if method != "POST" {
+                return text_response(STATUS_METHOD_NOT_ALLOWED, "method not allowed")
+            }
+            let Ok(body) = request.into_body().collect().await.map(|body| body.to_bytes()) else {
+                return text_response(STATUS_BAD_REQUEST, "failed to read request body")
+            };
+            handle_get_blobs(handle, version, &body).await
+        }
+    }
+}
+
+fn parse_engine_path(path: &str) -> Option<EngineSszEndpoint> {
+    let mut segments = path.trim_start_matches('/').split('/');
+    match (segments.next(), segments.next(), segments.next(), segments.next(), segments.next()) {
+        (Some("engine"), Some("v2"), Some("capabilities"), None, None) => {
+            Some(EngineSszEndpoint::Capabilities)
+        }
+        (Some("engine"), Some("v2"), Some("identity"), None, None) => {
+            Some(EngineSszEndpoint::Identity)
+        }
+        (Some("engine"), Some("v2"), Some(fork), Some("payloads"), None) => {
+            Some(EngineSszEndpoint::Payloads(fork.parse().ok()?))
+        }
+        (Some("engine"), Some("v2"), Some(fork), Some("forkchoice"), None) => {
+            Some(EngineSszEndpoint::Forkchoice(fork.parse().ok()?))
+        }
+        (Some("engine"), Some("v2"), Some("blobs"), version, None) => {
+            Some(EngineSszEndpoint::Blobs(parse_method_version(version?)?))
+        }
+        _ => None,
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum EngineSszEndpoint {
+    Capabilities,
+    Identity,
+    Payloads(EngineSszFork),
+    Forkchoice(EngineSszFork),
+    Blobs(u8),
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum EngineSszFork {
+    Paris,
+    Shanghai,
+    Cancun,
+    Prague,
+    Osaka,
+    Amsterdam,
+}
+
+impl EngineSszFork {
+    const fn payloads_version(self) -> u8 {
+        match self {
+            Self::Paris => 1,
+            Self::Shanghai => 2,
+            Self::Cancun => 3,
+            Self::Prague | Self::Osaka => 4,
+            Self::Amsterdam => 5,
+        }
+    }
+
+    const fn forkchoice_version(self) -> u8 {
+        match self {
+            Self::Paris => 1,
+            Self::Shanghai => 2,
+            Self::Cancun | Self::Prague | Self::Osaka => 3,
+            Self::Amsterdam => 4,
+        }
+    }
+}
+
+impl std::str::FromStr for EngineSszFork {
+    type Err = ();
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        match value {
+            "paris" => Ok(Self::Paris),
+            "shanghai" => Ok(Self::Shanghai),
+            "cancun" => Ok(Self::Cancun),
+            "prague" => Ok(Self::Prague),
+            "osaka" => Ok(Self::Osaka),
+            "amsterdam" => Ok(Self::Amsterdam),
+            _ => Err(()),
+        }
+    }
+}
+
+fn parse_method_version(version: &str) -> Option<u8> {
+    version.strip_prefix('v')?.parse().ok().filter(|version| (1..=4).contains(version))
+}
+
+fn default_client_version() -> ClientVersionV1 {
+    ClientVersionV1 {
+        code: CLIENT_CODE,
+        name: version_metadata().name_client.to_string(),
+        version: version_metadata().cargo_pkg_version.to_string(),
+        commit: version_metadata().vergen_git_sha.to_string(),
+    }
+}
+
+fn handle_capabilities() -> HttpResponse {
+    json_response(serde_json::json!({
+        "supported_forks": ["paris", "shanghai", "cancun", "prague", "osaka", "amsterdam"],
+        "fork_scoped_endpoints": ["payloads", "forkchoice", "bodies"],
+        "independently_versioned": {
+            "blobs": ["v1", "v2", "v3", "v4"],
+        },
+        "unscoped_endpoints": ["capabilities", "identity"],
+        "limits": {
+            "bodies.max_count": 128,
+            "blobs.max_versioned_hashes": MAX_BLOB_LIMIT,
+            "payload.max_bytes": MAX_PAYLOAD_BYTES,
+        },
+    }))
+}
+
+fn handle_identity(client_version: Option<ClientVersionV1>) -> HttpResponse {
+    json_response(client_version.into_iter().collect::<Vec<_>>())
+}
+
+async fn handle_new_payload(
+    engine: ConsensusEngineHandle<EthEngineTypes>,
+    version: u8,
+    body: &[u8],
+) -> HttpResponse {
+    let payload = match decode_new_payload_request(version, body) {
+        Ok(payload) => payload,
+        Err(err) => return text_response(STATUS_BAD_REQUEST, err),
+    };
+
+    match engine.new_payload(payload).await {
+        Ok(status) => ssz_response(status),
+        Err(err) => text_response(STATUS_INTERNAL_SERVER_ERROR, err.to_string()),
+    }
+}
+
+async fn handle_forkchoice_updated(
+    engine: ConsensusEngineHandle<EthEngineTypes>,
+    version: u8,
+    body: &[u8],
+) -> HttpResponse {
+    let (state, attrs) = match decode_forkchoice_request(version, body) {
+        Ok(request) => request,
+        Err(err) => return text_response(STATUS_BAD_REQUEST, err),
+    };
+
+    match engine.fork_choice_updated(state, attrs).await {
+        Ok(updated) => ssz_response(updated),
+        Err(err) => text_response(STATUS_INTERNAL_SERVER_ERROR, err.to_string()),
+    }
+}
+
+/// Handles SSZ `engine_getBlobsV*` requests with the node's blob store.
+async fn handle_get_blobs<ChainSpec>(
+    handler: EngineSszProxyHandle<ChainSpec>,
+    version: u8,
+    body: &[u8],
+) -> HttpResponse
+where
+    ChainSpec: EthereumHardforks + Send + Sync + 'static,
+{
+    let Some(blob_store) = handler.blob_store().await else {
+        return text_response(STATUS_SERVICE_UNAVAILABLE, "blob store unavailable")
+    };
+
+    let chain_spec = handler.chain_spec();
+    let current_timestamp =
+        SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap_or_default().as_secs();
+    let unsupported_fork = || {
+        text_response(STATUS_BAD_REQUEST, EngineObjectValidationError::UnsupportedFork.to_string())
+    };
+
+    match version {
+        1 => {
+            let hashes = match decode_blob_hashes_request(body) {
+                Ok(hashes) => hashes,
+                Err(err) => return text_response(STATUS_BAD_REQUEST, err),
+            };
+            if chain_spec.is_osaka_active_at_timestamp(current_timestamp) {
+                return unsupported_fork()
+            }
+            if hashes.len() > MAX_BLOB_LIMIT {
+                return text_response(
+                    STATUS_PAYLOAD_TOO_LARGE,
+                    format!("blob request too large: {}", hashes.len()),
+                )
+            }
+            match blob_store.get_by_versioned_hashes_v1(&hashes) {
+                Ok(response) => ssz_response(response),
+                Err(err) => text_response(STATUS_INTERNAL_SERVER_ERROR, err.to_string()),
+            }
+        }
+        2 => {
+            let hashes = match decode_blob_hashes_request(body) {
+                Ok(hashes) => hashes,
+                Err(err) => return text_response(STATUS_BAD_REQUEST, err),
+            };
+            if !chain_spec.is_osaka_active_at_timestamp(current_timestamp) {
+                return unsupported_fork()
+            }
+            if hashes.len() > MAX_BLOB_LIMIT {
+                return text_response(
+                    STATUS_PAYLOAD_TOO_LARGE,
+                    format!("blob request too large: {}", hashes.len()),
+                )
+            }
+            match blob_store.get_by_versioned_hashes_v2(&hashes) {
+                Ok(Some(response)) => ssz_response(response),
+                Ok(None) => no_content_response(),
+                Err(err) => text_response(STATUS_INTERNAL_SERVER_ERROR, err.to_string()),
+            }
+        }
+        3 => {
+            let hashes = match decode_blob_hashes_request(body) {
+                Ok(hashes) => hashes,
+                Err(err) => return text_response(STATUS_BAD_REQUEST, err),
+            };
+            if !chain_spec.is_osaka_active_at_timestamp(current_timestamp) {
+                return unsupported_fork()
+            }
+            if hashes.len() > MAX_BLOB_LIMIT {
+                return text_response(
+                    STATUS_PAYLOAD_TOO_LARGE,
+                    format!("blob request too large: {}", hashes.len()),
+                )
+            }
+            match blob_store.get_by_versioned_hashes_v3(&hashes) {
+                Ok(response) => ssz_response(response),
+                Err(err) => text_response(STATUS_INTERNAL_SERVER_ERROR, err.to_string()),
+            }
+        }
+        4 => {
+            let (hashes, indices_bitarray) = match decode_blob_cells_request(body) {
+                Ok(request) => request,
+                Err(err) => return text_response(STATUS_BAD_REQUEST, err),
+            };
+            if !chain_spec.is_amsterdam_active_at_timestamp(current_timestamp) {
+                return unsupported_fork()
+            }
+            if hashes.len() > MAX_BLOB_LIMIT {
+                return text_response(
+                    STATUS_PAYLOAD_TOO_LARGE,
+                    format!("blob request too large: {}", hashes.len()),
+                )
+            }
+            match blob_store.get_by_versioned_hashes_v4(&hashes, indices_bitarray) {
+                Ok(response) => ssz_response(response),
+                Err(err) => text_response(STATUS_INTERNAL_SERVER_ERROR, err.to_string()),
+            }
+        }
+        _ => text_response(STATUS_NOT_FOUND, "unsupported blobs endpoint version"),
+    }
+}
+
+/// Decodes the common getBlobs request container with only versioned hashes.
+fn decode_blob_hashes_request(body: &[u8]) -> Result<Vec<B256>, &'static str> {
+    Vec::<B256>::from_ssz_bytes(body).map_err(|_| "invalid ssz")
+}
+
+/// Decodes the Amsterdam getBlobs request container with hashes and a cell index mask.
+fn decode_blob_cells_request(body: &[u8]) -> Result<(Vec<B256>, B128), &'static str> {
+    <(Vec<B256>, B128) as ssz::Decode>::from_ssz_bytes(body).map_err(|_| "invalid ssz")
+}
+
+fn decode_new_payload_request(version: u8, body: &[u8]) -> Result<ExecutionData, &'static str> {
+    match version {
+        1 => {
+            let execution_payload =
+                decode_one::<ExecutionPayloadV1>(body).map_err(|_| "invalid ssz")?;
+            Ok(ExecutionData::new(execution_payload.into(), ExecutionPayloadSidecar::none()))
+        }
+        2 => {
+            let execution_payload =
+                decode_one::<ExecutionPayloadV2>(body).map_err(|_| "invalid ssz")?;
+            Ok(ExecutionData::new(execution_payload.into(), ExecutionPayloadSidecar::none()))
+        }
+        3 => {
+            let (execution_payload, parent_beacon_block_root) =
+                <(ExecutionPayloadV3, B256)>::from_ssz_bytes(body).map_err(|_| "invalid ssz")?;
+            let versioned_hashes = calculate_versioned_hashes(
+                &execution_payload.payload_inner.payload_inner.transactions,
+            )?;
+            let sidecar = ExecutionPayloadSidecar::v3(CancunPayloadFields {
+                parent_beacon_block_root,
+                versioned_hashes,
+            });
+            Ok(ExecutionData::new(execution_payload.into(), sidecar))
+        }
+        4 => {
+            let (execution_payload, parent_beacon_block_root, execution_requests) =
+                <(ExecutionPayloadV3, B256, Vec<Bytes>)>::from_ssz_bytes(body)
+                    .map_err(|_| "invalid ssz")?;
+            let versioned_hashes = calculate_versioned_hashes(
+                &execution_payload.payload_inner.payload_inner.transactions,
+            )?;
+            let sidecar = ExecutionPayloadSidecar::v4(
+                CancunPayloadFields { parent_beacon_block_root, versioned_hashes },
+                PraguePayloadFields::new(RequestsOrHash::Requests(Requests::new(
+                    execution_requests,
+                ))),
+            );
+            Ok(ExecutionData::new(execution_payload.into(), sidecar))
+        }
+        5 => {
+            let (execution_payload, parent_beacon_block_root, execution_requests) =
+                <(ExecutionPayloadV4, B256, Vec<Bytes>)>::from_ssz_bytes(body)
+                    .map_err(|_| "invalid ssz")?;
+            let versioned_hashes = calculate_versioned_hashes(
+                &execution_payload.payload_inner.payload_inner.payload_inner.transactions,
+            )?;
+            let sidecar = ExecutionPayloadSidecar::v4(
+                CancunPayloadFields { parent_beacon_block_root, versioned_hashes },
+                PraguePayloadFields::new(RequestsOrHash::Requests(Requests::new(
+                    execution_requests,
+                ))),
+            );
+            Ok(ExecutionData::new(ExecutionPayload::V4(execution_payload), sidecar))
+        }
+        _ => Err("unsupported payload endpoint version"),
+    }
+}
+
+fn calculate_versioned_hashes(transactions: &[Bytes]) -> Result<Vec<B256>, &'static str> {
+    let mut versioned_hashes = Vec::new();
+    for transaction in transactions {
+        let transaction =
+            TxEnvelope::decode_2718_exact(transaction.as_ref()).map_err(|_| "invalid tx")?;
+        if let Some(hashes) = transaction.blob_versioned_hashes() {
+            versioned_hashes.extend_from_slice(hashes);
+        }
+    }
+
+    Ok(versioned_hashes)
+}
+
+fn decode_forkchoice_request(
+    version: u8,
+    body: &[u8],
+) -> Result<(ForkchoiceState, Option<PayloadAttributes>), &'static str> {
+    match version {
+        1..=3 => {
+            let (forkchoice_state, payload_attributes) =
+                <(ForkchoiceState, Vec<PayloadAttributes>)>::from_ssz_bytes(body)
+                    .map_err(|_| "invalid ssz")?;
+            Ok((forkchoice_state, payload_attrs(version, payload_attributes)?))
+        }
+        4 => {
+            let (forkchoice_state, payload_attributes, custody_columns) =
+                <(ForkchoiceState, Vec<PayloadAttributes>, Vec<B128>)>::from_ssz_bytes(body)
+                    .map_err(|_| "invalid ssz")?;
+            custody_columns_opt(custody_columns)?;
+            Ok((forkchoice_state, payload_attrs(version, payload_attributes)?))
+        }
+        _ => Err("unsupported forkchoice endpoint version"),
+    }
+}
+
+fn decode_one<T: ssz::Decode>(body: &[u8]) -> Result<T, ssz::DecodeError> {
+    let mut builder = ssz::SszDecoderBuilder::new(body);
+    builder.register_type::<T>()?;
+    let mut decoder = builder.build()?;
+    decoder.decode_next()
+}
+
+fn payload_attrs(
+    version: u8,
+    attrs: Vec<PayloadAttributes>,
+) -> Result<Option<PayloadAttributes>, &'static str> {
+    if attrs.len() > 1 {
+        return Err("payload_attributes must contain at most one value")
+    }
+
+    attrs.into_iter().next().map(|attrs| validate_payload_attrs_version(version, attrs)).transpose()
+}
+
+fn custody_columns_opt(custody_columns: Vec<B128>) -> Result<Option<B128>, &'static str> {
+    if custody_columns.len() > 1 {
+        return Err("invalid params")
+    }
+
+    Ok(custody_columns.into_iter().next())
+}
+
+fn validate_payload_attrs_version(
+    version: u8,
+    attrs: PayloadAttributes,
+) -> Result<PayloadAttributes, &'static str> {
+    let matches_version = match version {
+        1 => {
+            attrs.withdrawals.is_none() &&
+                attrs.parent_beacon_block_root.is_none() &&
+                attrs.slot_number.is_none()
+        }
+        2 => {
+            attrs.withdrawals.is_some() &&
+                attrs.parent_beacon_block_root.is_none() &&
+                attrs.slot_number.is_none()
+        }
+        3 => {
+            attrs.withdrawals.is_some() &&
+                attrs.parent_beacon_block_root.is_some() &&
+                attrs.slot_number.is_none()
+        }
+        4 => {
+            attrs.withdrawals.is_some() &&
+                attrs.parent_beacon_block_root.is_some() &&
+                attrs.slot_number.is_some()
+        }
+        _ => false,
+    };
+
+    if matches_version {
+        Ok(attrs)
+    } else {
+        Err("payload_attributes version does not match endpoint")
+    }
+}
+
+fn ssz_response<T: ssz::Encode>(value: T) -> HttpResponse {
+    HttpResponse::builder()
+        .status(STATUS_OK)
+        .header(CONTENT_TYPE, OCTET_STREAM)
+        .body(HttpBody::from(value.as_ssz_bytes()))
+        .expect("valid response")
+}
+
+fn json_response<T: serde::Serialize>(value: T) -> HttpResponse {
+    let Ok(body) = serde_json::to_string(&value) else {
+        return text_response(STATUS_INTERNAL_SERVER_ERROR, "failed to encode json")
+    };
+
+    HttpResponse::builder()
+        .status(STATUS_OK)
+        .header(CONTENT_TYPE, APPLICATION_JSON)
+        .body(HttpBody::from(body))
+        .expect("valid response")
+}
+
+fn no_content_response() -> HttpResponse {
+    HttpResponse::builder().status(204).body(HttpBody::empty()).expect("valid response")
+}
+
+fn text_response(status: u16, body: impl Into<String>) -> HttpResponse {
+    HttpResponse::builder()
+        .status(status)
+        .header(CONTENT_TYPE, TEXT_PLAIN)
+        .body(HttpBody::from(body.into()))
+        .expect("valid response")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ssz::Encode;
+
+    #[test]
+    fn parses_capabilities_endpoint() {
+        let endpoint = parse_engine_path("/engine/v2/capabilities").unwrap();
+        assert_eq!(endpoint, EngineSszEndpoint::Capabilities);
+    }
+
+    #[test]
+    fn parses_identity_endpoint() {
+        let endpoint = parse_engine_path("/engine/v2/identity").unwrap();
+        assert_eq!(endpoint, EngineSszEndpoint::Identity);
+    }
+
+    #[test]
+    fn parses_fork_scoped_payload_endpoint() {
+        let endpoint = parse_engine_path("/engine/v2/prague/payloads").unwrap();
+        assert_eq!(endpoint, EngineSszEndpoint::Payloads(EngineSszFork::Prague));
+    }
+
+    #[test]
+    fn parses_fork_scoped_forkchoice_endpoint() {
+        let endpoint = parse_engine_path("/engine/v2/amsterdam/forkchoice").unwrap();
+        assert_eq!(endpoint, EngineSszEndpoint::Forkchoice(EngineSszFork::Amsterdam));
+    }
+
+    #[test]
+    fn rejects_legacy_version_scoped_endpoint() {
+        assert!(parse_engine_path("/engine/v4/payloads").is_none());
+    }
+
+    #[test]
+    fn decodes_top_level_blob_hashes_request() {
+        let hashes = vec![B256::ZERO, B256::with_last_byte(1)];
+        let decoded = decode_blob_hashes_request(&hashes.as_ssz_bytes()).unwrap();
+        assert_eq!(decoded, hashes);
+    }
+
+    #[test]
+    fn decodes_forkchoice_v4_with_custody_columns() {
+        let forkchoice_state = ForkchoiceState {
+            head_block_hash: B256::ZERO,
+            safe_block_hash: B256::ZERO,
+            finalized_block_hash: B256::ZERO,
+        };
+        let encoded =
+            (forkchoice_state, Vec::<PayloadAttributes>::new(), vec![B128::with_last_byte(1)])
+                .as_ssz_bytes();
+
+        let (decoded_state, decoded_attrs) = decode_forkchoice_request(4, &encoded).unwrap();
+        assert_eq!(decoded_state, forkchoice_state);
+        assert!(decoded_attrs.is_none());
+    }
+
+    #[test]
+    fn rejects_forkchoice_v4_with_multiple_custody_columns() {
+        let forkchoice_state = ForkchoiceState {
+            head_block_hash: B256::ZERO,
+            safe_block_hash: B256::ZERO,
+            finalized_block_hash: B256::ZERO,
+        };
+        let encoded = (
+            forkchoice_state,
+            Vec::<PayloadAttributes>::new(),
+            vec![B128::ZERO, B128::with_last_byte(1)],
+        )
+            .as_ssz_bytes();
+
+        let err = decode_forkchoice_request(4, &encoded).unwrap_err();
+        assert_eq!(err, "invalid params");
+    }
+}
diff --git a/crates/ethereum/node/src/lib.rs b/crates/ethereum/node/src/lib.rs
index 60d2c8ee2a7..1b4f5252a45 100644
--- a/crates/ethereum/node/src/lib.rs
+++ b/crates/ethereum/node/src/lib.rs
@@ -14,7 +14,7 @@
 use reth_revm as _;
 use revm as _;
 
-pub use reth_ethereum_engine_primitives::EthEngineTypes;
+pub use reth_ethereum_engine_primitives::{EthEngineTypes, EthPayloadTypes};
 
 pub mod evm;
 pub use evm::EthEvmConfig;
@@ -30,3 +30,5 @@ pub mod payload;
 
 pub mod engine;
 pub use engine::EthereumEngineValidator;
+
+pub mod engine_ssz_proxy;
diff --git a/crates/ethereum/node/src/node.rs b/crates/ethereum/node/src/node.rs
index eca9d36fbdc..0bf530280fc 100644
--- a/crates/ethereum/node/src/node.rs
+++ b/crates/ethereum/node/src/node.rs
@@ -31,7 +31,7 @@ use reth_node_builder::{
         PayloadValidatorBuilder, RethAuthHttpMiddleware, RethRpcAddOns, RethRpcMiddleware,
         RpcAddOns, RpcHandle, Stack,
     },
-    BuilderContext, DebugNode, Node, NodeAdapter,
+    BuilderContext, DebugNode, Node, NodeAdapter, PayloadBuilderConfig,
 };
 use reth_payload_primitives::PayloadTypes;
 use reth_provider::{providers::ProviderFactoryBuilder, EthStorage};
@@ -301,7 +301,7 @@ impl<N, EthB, PVB, EB, EVB, RpcMiddleware, AuthHttpMiddleware> NodeAddOns<N>
 where
     N: FullNodeComponents<
         Types: NodeTypes<
-            ChainSpec: Hardforks + EthereumHardforks,
+            ChainSpec: EthChainSpec + Hardforks + EthereumHardforks,
             Primitives = EthPrimitives,
             Payload: EngineTypes<ExecutionData = ExecutionData>,
         >,
@@ -336,6 +336,7 @@ where
 
         let testing_skip_invalid_transactions = ctx.config.rpc.testing_skip_invalid_transactions;
         let testing_gas_limit_override = ctx.config.rpc.testing_gas_limit;
+        let testing_desired_gas_limit = ctx.config.builder.gas_limit_for(ctx.config.chain.chain());
 
         self.inner
             .launch_add_ons_with(ctx, move |container| {
@@ -353,6 +354,7 @@ where
                 let mut testing_api = TestingApi::new(
                     container.registry.eth_api().clone(),
                     container.registry.evm_config().clone(),
+                    testing_desired_gas_limit,
                 );
                 if testing_skip_invalid_transactions {
                     testing_api = testing_api.with_skip_invalid_transactions();
diff --git a/crates/ethereum/node/tests/e2e/dev.rs b/crates/ethereum/node/tests/e2e/dev.rs
index 72590adc225..a91020b63d6 100644
--- a/crates/ethereum/node/tests/e2e/dev.rs
+++ b/crates/ethereum/node/tests/e2e/dev.rs
@@ -1,4 +1,3 @@
-use alloy_eips::eip2718::Encodable2718;
 use alloy_genesis::Genesis;
 use alloy_primitives::{b256, hex, Address};
 use futures::StreamExt;
@@ -7,6 +6,7 @@ use reth_node_api::{BlockBody, FullNodeComponents};
 use reth_node_builder::{rpc::RethRpcAddOns, FullNode, NodeBuilder, NodeConfig, NodeHandle};
 use reth_node_core::args::DevArgs;
 use reth_node_ethereum::{node::EthereumAddOns, EthereumNode};
+use reth_primitives_traits::transaction::TxHashRef;
 use reth_provider::{providers::BlockchainProvider, CanonStateSubscriptions};
 use reth_rpc_eth_api::{helpers::EthTransactions, EthApiServer};
 use reth_tasks::Runtime;
@@ -99,7 +99,7 @@ where
     let head = notifications.next().await.unwrap();
 
     let tx = &head.tip().body().transactions()[0];
-    assert_eq!(tx.trie_hash(), hash);
+    assert_eq!(*tx.tx_hash(), hash);
     println!("mined transaction: {hash}");
 }
 
diff --git a/crates/ethereum/node/tests/e2e/eth.rs b/crates/ethereum/node/tests/e2e/eth.rs
index 197b5f89c1b..5d0f604f638 100644
--- a/crates/ethereum/node/tests/e2e/eth.rs
+++ b/crates/ethereum/node/tests/e2e/eth.rs
@@ -1,8 +1,11 @@
 use crate::utils::{advance_with_random_transactions, eth_payload_attributes};
-use alloy_eips::eip7685::RequestsOrHash;
+use alloy_eips::{eip4844::BlobAndProofV1, eip7685::RequestsOrHash};
 use alloy_genesis::Genesis;
 use alloy_primitives::{Address, B256};
-use alloy_rpc_types_engine::{PayloadAttributes, PayloadStatusEnum};
+use alloy_rpc_types_engine::{
+    ClientVersionV1, ForkchoiceState, ForkchoiceUpdated, PayloadAttributes, PayloadStatus,
+    PayloadStatusEnum,
+};
 use jsonrpsee_core::client::ClientT;
 use reth_chainspec::{ChainSpecBuilder, EthChainSpec, MAINNET};
 use reth_e2e_test_utils::{
@@ -10,13 +13,25 @@ use reth_e2e_test_utils::{
 };
 use reth_node_api::TreeConfig;
 use reth_node_builder::{NodeBuilder, NodeHandle};
-use reth_node_core::{args::RpcServerArgs, node_config::NodeConfig};
-use reth_node_ethereum::EthereumNode;
+use reth_node_core::{
+    args::RpcServerArgs,
+    node_config::NodeConfig,
+    version::{version_metadata, CLIENT_CODE},
+};
+use reth_node_ethereum::{engine_ssz_proxy::EngineSszProxyLayer, EthereumAddOns, EthereumNode};
 use reth_provider::BlockNumReader;
 use reth_rpc_api::TestingBuildBlockRequestV1;
+use reth_rpc_layer::secret_to_bearer_header;
 use reth_tasks::Runtime;
+use ssz::{Decode, Encode};
 use std::sync::Arc;
 
+const ENGINE_PRAGUE_PAYLOADS_ROUTE: &str = "/engine/v2/prague/payloads";
+const ENGINE_PRAGUE_FORKCHOICE_ROUTE: &str = "/engine/v2/prague/forkchoice";
+const ENGINE_V1_BLOBS_ROUTE: &str = "/engine/v2/blobs/v1";
+const ENGINE_CAPABILITIES_ROUTE: &str = "/engine/v2/capabilities";
+const ENGINE_IDENTITY_ROUTE: &str = "/engine/v2/identity";
+
 #[tokio::test]
 async fn can_run_eth_node() -> eyre::Result<()> {
     reth_tracing::init_test_tracing();
@@ -256,6 +271,189 @@ async fn test_testing_build_block_v1_osaka() -> eyre::Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn test_engine_ssz_proxy_can_mine_block() -> 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)
+            .prague_activated()
+            .build(),
+    );
+    let genesis_hash = chain_spec.genesis_hash();
+    let node_config =
+        NodeConfig::test().with_chain(chain_spec.clone()).with_unused_ports().with_rpc(
+            RpcServerArgs::default()
+                .with_unused_ports()
+                .with_http()
+                .with_http_api(reth_rpc_server_types::RpcModuleSelection::All),
+        );
+
+    let (ssz_layer, ssz_handle) = EngineSszProxyLayer::new(chain_spec.clone());
+    let NodeHandle { node, node_exit_future: _ } = NodeBuilder::new(node_config)
+        .testing_node(runtime)
+        .with_types::<EthereumNode>()
+        .with_components(EthereumNode::components())
+        .with_add_ons(EthereumAddOns::default().with_auth_http_middleware(ssz_layer))
+        .launch()
+        .await?;
+
+    ssz_handle.set_engine(node.add_ons_handle.beacon_engine_handle.clone()).await;
+    ssz_handle.set_blob_store(node.pool.blob_store().clone()).await;
+    let node = NodeTestContext::new(node, eth_payload_attributes).await?;
+
+    let wallets = Wallet::new(2).wallet_gen();
+    let raw_tx = TransactionTestContext::transfer_tx_bytes(1, wallets[0].clone()).await;
+
+    let payload_attributes = PayloadAttributes {
+        timestamp: chain_spec.genesis().timestamp + 1,
+        prev_randao: B256::ZERO,
+        suggested_fee_recipient: Address::ZERO,
+        withdrawals: Some(vec![]),
+        parent_beacon_block_root: Some(B256::ZERO),
+        slot_number: None,
+    };
+
+    let envelope = node
+        .testing_build_block_v1(TestingBuildBlockRequestV1 {
+            parent_block_hash: genesis_hash,
+            payload_attributes,
+            transactions: vec![raw_tx],
+            extra_data: None,
+        })
+        .await?;
+
+    let payload = envelope.execution_payload;
+    let block_hash = payload.payload_inner.payload_inner.block_hash;
+    let client = reqwest::Client::new();
+    let auth_server = node.auth_server_handle();
+    let auth_url = auth_server.http_url();
+    let auth_header = secret_to_bearer_header(auth_server.jwt_secret());
+
+    let capabilities_response = client
+        .get(format!("{auth_url}{ENGINE_CAPABILITIES_ROUTE}"))
+        .header(reqwest::header::AUTHORIZATION, auth_header.to_str()?)
+        .header(reqwest::header::ACCEPT, "application/json")
+        .send()
+        .await?;
+    assert_eq!(capabilities_response.status(), reqwest::StatusCode::OK);
+    assert_eq!(
+        capabilities_response
+            .headers()
+            .get(reqwest::header::CONTENT_TYPE)
+            .and_then(|value| value.to_str().ok()),
+        Some("application/json")
+    );
+
+    let capabilities: serde_json::Value = capabilities_response.json().await?;
+    assert_eq!(
+        capabilities,
+        serde_json::json!({
+            "supported_forks": ["paris", "shanghai", "cancun", "prague", "osaka", "amsterdam"],
+            "fork_scoped_endpoints": ["payloads", "forkchoice", "bodies"],
+            "independently_versioned": {
+                "blobs": ["v1", "v2", "v3", "v4"],
+            },
+            "unscoped_endpoints": ["capabilities", "identity"],
+            "limits": {
+                "bodies.max_count": 128,
+                "blobs.max_versioned_hashes": 128,
+                "payload.max_bytes": 67108864,
+            },
+        })
+    );
+
+    let identity_response = client
+        .get(format!("{auth_url}{ENGINE_IDENTITY_ROUTE}"))
+        .header(reqwest::header::AUTHORIZATION, auth_header.to_str()?)
+        .header(reqwest::header::ACCEPT, "application/json")
+        .send()
+        .await?;
+    assert_eq!(identity_response.status(), reqwest::StatusCode::OK);
+    assert_eq!(
+        identity_response
+            .headers()
+            .get(reqwest::header::CONTENT_TYPE)
+            .and_then(|value| value.to_str().ok()),
+        Some("application/json")
+    );
+
+    let identity: Vec<ClientVersionV1> = identity_response.json().await?;
+    assert_eq!(
+        identity,
+        vec![ClientVersionV1 {
+            code: CLIENT_CODE,
+            name: version_metadata().name_client.to_string(),
+            version: version_metadata().cargo_pkg_version.to_string(),
+            commit: version_metadata().vergen_git_sha.to_string(),
+        }]
+    );
+
+    let new_payload_response = client
+        .post(format!("{auth_url}{ENGINE_PRAGUE_PAYLOADS_ROUTE}"))
+        .header(reqwest::header::AUTHORIZATION, auth_header.to_str()?)
+        .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
+        .header(reqwest::header::ACCEPT, "application/octet-stream")
+        .body((payload, B256::ZERO, envelope.execution_requests.take()).as_ssz_bytes())
+        .send()
+        .await?;
+    assert_eq!(new_payload_response.status(), reqwest::StatusCode::OK);
+
+    let status = PayloadStatus::from_ssz_bytes(&new_payload_response.bytes().await?).unwrap();
+    assert_eq!(status.status, PayloadStatusEnum::Valid);
+
+    let fcu_response = client
+        .post(format!("{auth_url}{ENGINE_PRAGUE_FORKCHOICE_ROUTE}"))
+        .header(reqwest::header::AUTHORIZATION, auth_header.to_str()?)
+        .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
+        .header(reqwest::header::ACCEPT, "application/octet-stream")
+        .body(
+            (
+                ForkchoiceState {
+                    head_block_hash: block_hash,
+                    safe_block_hash: genesis_hash,
+                    finalized_block_hash: genesis_hash,
+                },
+                Vec::<PayloadAttributes>::new(),
+            )
+                .as_ssz_bytes(),
+        )
+        .send()
+        .await?;
+    assert_eq!(fcu_response.status(), reqwest::StatusCode::OK);
+
+    let blob_tx = TransactionTestContext::tx_with_blobs_bytes(1, wallets[1].clone()).await?;
+    let blob_tx_hash = node.rpc.inject_tx(blob_tx).await?;
+    let envelope = node.rpc.envelope_by_hash(blob_tx_hash).await?;
+    let versioned_hashes = TransactionTestContext::validate_sidecar(envelope);
+
+    let blobs_response = client
+        .post(format!("{auth_url}{ENGINE_V1_BLOBS_ROUTE}"))
+        .header(reqwest::header::AUTHORIZATION, auth_header.to_str()?)
+        .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
+        .header(reqwest::header::ACCEPT, "application/octet-stream")
+        .body(versioned_hashes.as_ssz_bytes())
+        .send()
+        .await?;
+    assert_eq!(blobs_response.status(), reqwest::StatusCode::OK);
+
+    let blobs =
+        Vec::<Option<BlobAndProofV1>>::from_ssz_bytes(&blobs_response.bytes().await?).unwrap();
+    assert_eq!(blobs.len(), versioned_hashes.len());
+    assert!(blobs.iter().all(Option::is_some));
+
+    let fcu = ForkchoiceUpdated::from_ssz_bytes(&fcu_response.bytes().await?).unwrap();
+    assert_eq!(fcu.payload_status.status, PayloadStatusEnum::Valid);
+
+    node.wait_block(1, block_hash, false).await?;
+
+    Ok(())
+}
+
 /// Tests that the sparse trie pipeline can be shared with the payload builder.
 ///
 /// Enables both `share_execution_cache_with_payload_builder` and
diff --git a/crates/ethereum/node/tests/e2e/p2p.rs b/crates/ethereum/node/tests/e2e/p2p.rs
index 90193b2c4e8..229db7fd508 100644
--- a/crates/ethereum/node/tests/e2e/p2p.rs
+++ b/crates/ethereum/node/tests/e2e/p2p.rs
@@ -10,9 +10,86 @@ use reth_e2e_test_utils::{
     setup, setup_engine, setup_engine_with_connection, transaction::TransactionTestContext,
     wallet::Wallet,
 };
+use reth_network::{NetworkInfo, PeersInfo};
+use reth_node_builder::{NodeBuilder, NodeHandle};
+use reth_node_core::{args::NetworkArgs, node_config::NodeConfig};
 use reth_node_ethereum::EthereumNode;
 use reth_rpc_api::EthApiServer;
-use std::{sync::Arc, time::Duration};
+use reth_tasks::Runtime;
+use std::{net::UdpSocket, sync::Arc, time::Duration};
+
+#[tokio::test]
+async fn can_launch_with_net_if_and_shared_discovery_port() -> eyre::Result<()> {
+    reth_tracing::init_test_tracing();
+
+    let runtime = Runtime::test();
+    let chain_spec = Arc::new(
+        ChainSpecBuilder::default()
+            .chain(MAINNET.chain)
+            .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap())
+            .cancun_activated()
+            .build(),
+    );
+
+    let discovery_port = unused_udp_port();
+    let mut network = NetworkArgs::default().with_unused_p2p_port();
+    network.bootnodes = Some(Vec::new());
+    network.net_if = Some(loopback_net_if().to_string());
+    network.discovery.disable_dns_discovery = true;
+    network.discovery.disable_nat = true;
+    network.discovery.port = discovery_port;
+    network.discovery.discv5_port = None;
+    network.discovery.discv5_port_ipv6 = None;
+
+    let node_config = NodeConfig::test().with_chain(chain_spec).with_network(network);
+    let NodeHandle { node, node_exit_future: _ } = NodeBuilder::new(node_config)
+        .testing_node(runtime)
+        .node(EthereumNode::default())
+        .launch()
+        .await?;
+
+    assert!(node.network.discv4().is_some());
+    assert!(node.network.discv5().is_some());
+    assert!(node.network.local_addr().ip().is_loopback());
+
+    let local_node_record = node.network.local_node_record();
+    let discv5_port = node.network.discv5().expect("discv5 should be enabled").local_port();
+    assert!(local_node_record.address.is_loopback());
+    assert_eq!(local_node_record.udp_port, discovery_port);
+    assert_eq!(discv5_port, discovery_port);
+
+    Ok(())
+}
+
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+const fn loopback_net_if() -> &'static str {
+    "lo0"
+}
+
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd"
+)))]
+const fn loopback_net_if() -> &'static str {
+    "lo"
+}
+
+fn unused_udp_port() -> u16 {
+    UdpSocket::bind((std::net::Ipv4Addr::LOCALHOST, 0))
+        .expect("failed to bind temporary UDP socket")
+        .local_addr()
+        .expect("failed to read temporary UDP socket address")
+        .port()
+}
 
 #[tokio::test]
 async fn can_sync() -> eyre::Result<()> {
diff --git a/crates/ethereum/node/tests/e2e/rpc.rs b/crates/ethereum/node/tests/e2e/rpc.rs
index 89f4300daf1..3b6aedfe893 100644
--- a/crates/ethereum/node/tests/e2e/rpc.rs
+++ b/crates/ethereum/node/tests/e2e/rpc.rs
@@ -1,11 +1,12 @@
-use crate::utils::eth_payload_attributes;
+use crate::utils::{eth_payload_attributes, eth_payload_attributes_amsterdam};
 use alloy_eips::{eip2718::Encodable2718, eip7910::EthConfig};
 use alloy_genesis::Genesis;
-use alloy_primitives::{Address, B256, U256};
+use alloy_primitives::{Address, Bytes, B256, U256};
 use alloy_provider::{network::EthereumWallet, Provider, ProviderBuilder, SendableTx};
 use alloy_rpc_types_beacon::relay::{
     BidTrace, BuilderBlockValidationRequestV3, BuilderBlockValidationRequestV4,
-    SignedBidSubmissionV3, SignedBidSubmissionV4,
+    BuilderBlockValidationRequestV6, SignedBidSubmissionV3, SignedBidSubmissionV4,
+    SignedBidSubmissionV6,
 };
 use alloy_rpc_types_engine::{BlobsBundleV1, ExecutionPayloadV3};
 use alloy_rpc_types_eth::TransactionRequest;
@@ -23,6 +24,7 @@ use reth_payload_primitives::BuiltPayload;
 use reth_rpc_api::servers::AdminApiServer;
 use reth_tasks::Runtime;
 use std::{
+    net::{IpAddr, Ipv4Addr},
     sync::Arc,
     time::{SystemTime, UNIX_EPOCH},
 };
@@ -295,6 +297,92 @@ async fn test_flashbots_validate_v4() -> eyre::Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn test_flashbots_validate_v6() -> eyre::Result<()> {
+    reth_tracing::init_test_tracing();
+
+    let chain_spec = Arc::new(
+        ChainSpecBuilder::default()
+            .chain(MAINNET.chain)
+            .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap())
+            .amsterdam_activated()
+            .build(),
+    );
+
+    let (mut nodes, wallet) = setup_engine::<EthereumNode>(
+        1,
+        chain_spec.clone(),
+        false,
+        Default::default(),
+        eth_payload_attributes_amsterdam,
+    )
+    .await?;
+    let mut node = nodes.pop().unwrap();
+    let provider = ProviderBuilder::new()
+        .wallet(EthereumWallet::new(wallet.wallet_gen().swap_remove(0)))
+        .connect_http(node.rpc_url());
+
+    for nonce in 0..3 {
+        let _ = provider
+            .send_transaction(TransactionRequest::default().to(Address::ZERO).nonce(nonce))
+            .await?;
+    }
+
+    let payload = node.new_payload().await?;
+    assert!(payload.block_access_list().is_some());
+    assert!(payload.block().body().transactions().count() >= 3);
+
+    let envelope = payload.clone().try_into_v6()?;
+    let mut request = BuilderBlockValidationRequestV6 {
+        request: SignedBidSubmissionV6 {
+            message: BidTrace {
+                parent_hash: payload.block().parent_hash,
+                block_hash: payload.block().hash(),
+                gas_used: payload.block().gas_used,
+                gas_limit: payload.block().gas_limit,
+                ..Default::default()
+            },
+            execution_payload: envelope.execution_payload,
+            blobs_bundle: envelope.blobs_bundle,
+            execution_requests: envelope.execution_requests.try_into().unwrap(),
+            signature: Default::default(),
+        },
+        parent_beacon_block_root: payload.block().parent_beacon_block_root.unwrap(),
+        registered_gas_limit: payload.block().gas_limit,
+    };
+
+    provider
+        .raw_request::<_, ()>("flashbots_validateBuilderSubmissionV6".into(), (&request,))
+        .await
+        .expect("request should validate");
+
+    request.registered_gas_limit -= 1;
+    assert!(provider
+        .raw_request::<_, ()>("flashbots_validateBuilderSubmissionV6".into(), (&request,))
+        .await
+        .is_err());
+    request.registered_gas_limit += 1;
+
+    let mut invalid_bal_request = request.clone();
+    invalid_bal_request.request.execution_payload.block_access_list = Bytes::from_static(&[0xc0]);
+    assert!(provider
+        .raw_request::<_, ()>(
+            "flashbots_validateBuilderSubmissionV6".into(),
+            (&invalid_bal_request,)
+        )
+        .await
+        .is_err());
+
+    request.request.execution_payload.payload_inner.payload_inner.payload_inner.state_root =
+        B256::ZERO;
+    assert!(provider
+        .raw_request::<_, ()>("flashbots_validateBuilderSubmissionV6".into(), (&request,))
+        .await
+        .is_err());
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_eth_config() -> eyre::Result<()> {
     reth_tracing::init_test_tracing();
@@ -419,3 +507,49 @@ async fn test_admin_node_info_uses_discv5_port_when_discv4_is_disabled() -> eyre
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_admin_node_info_discv5_enr_uses_nat_extip_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;
+    let external_ip = Ipv4Addr::new(203, 0, 113, 7);
+    network = network.with_nat_resolver(NatResolver::ExternalIp(IpAddr::V4(external_ip)));
+
+    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 = node.network.discv5().expect("discv5 should be enabled");
+    let discv5_port = discv5.local_port();
+    let info = node.add_ons_handle.admin_api().node_info().await.unwrap();
+    let admin_enr: enr::Enr<enr::secp256k1::SecretKey> =
+        info.enr.parse().map_err(|err| eyre::eyre!("failed to parse admin ENR: {err}"))?;
+
+    assert_eq!(discv5.local_enr().ip4(), Some(external_ip));
+    assert_eq!(discv5.local_enr().udp4(), Some(discv5_port));
+    assert_eq!(admin_enr.ip4(), Some(external_ip));
+    assert_eq!(admin_enr.udp4(), Some(discv5_port));
+    assert_eq!(info.ip, IpAddr::V4(external_ip));
+    assert_eq!(info.ports.discovery, discv5_port);
+
+    Ok(())
+}
diff --git a/crates/ethereum/node/tests/e2e/simulate.rs b/crates/ethereum/node/tests/e2e/simulate.rs
index 32405511f08..cd9d2b1de23 100644
--- a/crates/ethereum/node/tests/e2e/simulate.rs
+++ b/crates/ethereum/node/tests/e2e/simulate.rs
@@ -1,16 +1,202 @@
 use crate::utils::eth_payload_attributes;
-use alloy_primitives::{Address, U256};
+use alloy_primitives::{bytes, Address, U256};
 use alloy_provider::{network::EthereumWallet, Provider, ProviderBuilder};
 use alloy_rpc_types_eth::{
     simulate::{SimBlock, SimulatePayload, SimulatedBlock},
-    state::StateOverridesBuilder,
-    BlockOverrides, TransactionRequest,
+    state::{AccountOverride, StateOverride, StateOverridesBuilder},
+    BlockOverrides, TransactionRequest, TransactionTrait as _,
 };
 use reth_chainspec::{ChainSpecBuilder, MAINNET};
 use reth_e2e_test_utils::setup_engine;
 use reth_node_ethereum::EthereumNode;
 use std::sync::Arc;
 
+#[tokio::test]
+async fn test_simulate_v1_explicit_gas_uses_remaining_block_gas() -> eyre::Result<()> {
+    reth_tracing::init_test_tracing();
+
+    let chain_spec = Arc::new(
+        ChainSpecBuilder::default()
+            .chain(MAINNET.chain)
+            .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap())
+            .cancun_activated()
+            .build(),
+    );
+
+    let (mut nodes, wallet) = setup_engine::<EthereumNode>(
+        1,
+        chain_spec,
+        false,
+        Default::default(),
+        eth_payload_attributes,
+    )
+    .await?;
+    let node = nodes.pop().unwrap();
+    let provider = ProviderBuilder::new()
+        .wallet(EthereumWallet::new(wallet.wallet_gen().swap_remove(0)))
+        .connect_http(node.rpc_url());
+
+    let tx = TransactionRequest::default().to(Address::ZERO).gas_limit(3_000_000);
+    let sim_block = SimBlock::default().call(tx.clone()).call(tx);
+    let payload = SimulatePayload::default().extend(sim_block);
+
+    let result: Vec<SimulatedBlock> =
+        provider.raw_request("eth_simulateV1".into(), (&payload, "latest")).await?;
+
+    assert_eq!(result.len(), 1);
+    assert_eq!(result[0].calls.len(), 2);
+    assert!(result[0].calls.iter().all(|call| call.status));
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_simulate_v1_no_fields_call_defaults_to_remaining_block_gas() -> eyre::Result<()> {
+    reth_tracing::init_test_tracing();
+
+    let chain_spec = Arc::new(
+        ChainSpecBuilder::default()
+            .chain(MAINNET.chain)
+            .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap())
+            .cancun_activated()
+            .build(),
+    );
+
+    let (mut nodes, wallet) = setup_engine::<EthereumNode>(
+        1,
+        chain_spec,
+        false,
+        Default::default(),
+        eth_payload_attributes,
+    )
+    .await?;
+    let node = nodes.pop().unwrap();
+    let provider = ProviderBuilder::new()
+        .wallet(EthereumWallet::new(wallet.wallet_gen().swap_remove(0)))
+        .connect_http(node.rpc_url());
+
+    let first_tx_gas_limit = 21_000;
+    let sim_block = SimBlock::default()
+        .call(TransactionRequest::default().to(Address::ZERO).gas_limit(first_tx_gas_limit))
+        .call(TransactionRequest::default());
+    let payload = SimulatePayload::default().with_full_transactions().extend(sim_block);
+
+    let result: Vec<SimulatedBlock> =
+        provider.raw_request("eth_simulateV1".into(), (&payload, "latest")).await?;
+
+    assert_eq!(result.len(), 1);
+    assert_eq!(result[0].calls.len(), 2);
+    assert!(result[0].calls.iter().all(|call| call.status));
+
+    let block = &result[0].inner;
+    let txs = block.transactions.as_transactions().expect("expected full transactions");
+    assert_eq!(txs.len(), 2);
+    assert_eq!(txs[0].gas_limit(), first_tx_gas_limit);
+
+    let expected_remaining_gas = block.header.inner.gas_limit - result[0].calls[0].gas_used;
+    assert_eq!(txs[1].gas_limit(), expected_remaining_gas);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_simulate_v1_blockhash_reads_prior_simulated_block() -> eyre::Result<()> {
+    reth_tracing::init_test_tracing();
+
+    let chain_spec = Arc::new(
+        ChainSpecBuilder::default()
+            .chain(MAINNET.chain)
+            .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap())
+            .cancun_activated()
+            .build(),
+    );
+
+    let (mut nodes, wallet) = setup_engine::<EthereumNode>(
+        1,
+        chain_spec,
+        false,
+        Default::default(),
+        eth_payload_attributes,
+    )
+    .await?;
+    let node = nodes.pop().unwrap();
+    let provider = ProviderBuilder::new()
+        .wallet(EthereumWallet::new(wallet.wallet_gen().swap_remove(0)))
+        .connect_http(node.rpc_url());
+
+    let contract = Address::with_last_byte(0x42);
+    let mut state_overrides = StateOverride::default();
+    state_overrides.insert(
+        contract,
+        AccountOverride::default().with_code(bytes!("0x6004354303405f5260205ff3")),
+    );
+    let input =
+        bytes!("0xee82ac5e000000000000000000000000000000000000000000000000000000000000000f").into();
+
+    let payload = SimulatePayload::default().extend(SimBlock::default()).extend(
+        SimBlock::default()
+            .with_block_overrides(BlockOverrides {
+                number: Some(U256::from(16)),
+                ..Default::default()
+            })
+            .with_state_overrides(state_overrides)
+            .call(TransactionRequest::default().to(contract).input(input)),
+    );
+
+    let result: Vec<SimulatedBlock> =
+        provider.raw_request("eth_simulateV1".into(), (&payload, "latest")).await?;
+
+    assert_eq!(result.len(), 16);
+    assert_eq!(result[15].calls.len(), 1);
+    assert!(result[15].calls[0].status);
+    assert_eq!(result[15].calls[0].return_data.as_ref(), result[0].inner.header.hash.as_slice());
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_simulate_v1_explicit_gas_over_remaining_block_gas_errors() -> eyre::Result<()> {
+    reth_tracing::init_test_tracing();
+
+    let chain_spec = Arc::new(
+        ChainSpecBuilder::default()
+            .chain(MAINNET.chain)
+            .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap())
+            .cancun_activated()
+            .build(),
+    );
+
+    let (mut nodes, wallet) = setup_engine::<EthereumNode>(
+        1,
+        chain_spec,
+        false,
+        Default::default(),
+        eth_payload_attributes,
+    )
+    .await?;
+    let node = nodes.pop().unwrap();
+    let provider = ProviderBuilder::new()
+        .wallet(EthereumWallet::new(wallet.wallet_gen().swap_remove(0)))
+        .connect_http(node.rpc_url());
+
+    let sim_block = SimBlock::default()
+        .with_block_overrides(BlockOverrides { gas_limit: Some(50_000), ..Default::default() })
+        .call(TransactionRequest::default().to(Address::ZERO))
+        .call(TransactionRequest::default().to(Address::ZERO).gas_limit(30_000));
+    let payload = SimulatePayload::default().extend(sim_block);
+
+    let err = provider
+        .raw_request::<_, Vec<SimulatedBlock>>("eth_simulateV1".into(), (&payload, "latest"))
+        .await
+        .unwrap_err();
+    let err = err.as_error_resp().expect("expected JSON-RPC error response");
+
+    assert_eq!(err.code, -38015);
+    assert_eq!(err.message, "Block gas limit exceeded by the block's transactions");
+
+    Ok(())
+}
+
 /// Tests that `eth_simulateV1` handles a transaction with `maxFeePerBlobGas` set but no
 /// `blob_versioned_hashes` or sidecar. The transaction should be treated as EIP-1559, not
 /// EIP-4844.
@@ -73,8 +259,10 @@ async fn test_simulate_v1_with_max_fee_per_blob_gas_only() -> eyre::Result<()> {
 
     assert_eq!(result.len(), 1, "expected exactly 1 simulated block");
     assert_eq!(result[0].calls.len(), 1, "expected exactly 1 call result");
-    assert!(result[0].calls[0].status, "expected call to succeed");
-    assert!(result[0].calls[0].error.is_none(), "expected no error");
+    let call = &result[0].calls[0];
+    assert!(call.status, "expected call to succeed");
+    assert!(call.error.is_none(), "expected no error");
+    assert_eq!(call.max_used_gas, Some(call.gas_used), "expected maxUsedGas in call result");
 
     Ok(())
 }
diff --git a/crates/ethereum/node/tests/e2e/utils.rs b/crates/ethereum/node/tests/e2e/utils.rs
index 6f413468dc6..8d249162bae 100644
--- a/crates/ethereum/node/tests/e2e/utils.rs
+++ b/crates/ethereum/node/tests/e2e/utils.rs
@@ -41,6 +41,23 @@ pub(crate) const fn eth_payload_attributes_shanghai(timestamp: u64) -> PayloadAt
     }
 }
 
+/// Helper function to create Amsterdam payload attributes.
+///
+/// Amsterdam payloads include block access lists, and the payload builder expects a
+/// `slot_number` in the attributes once Amsterdam is active. Tests use the timestamp as a
+/// deterministic dummy slot because the exact beacon slot is irrelevant for these local e2e
+/// payloads.
+pub(crate) const fn eth_payload_attributes_amsterdam(timestamp: u64) -> PayloadAttributes {
+    PayloadAttributes {
+        timestamp,
+        prev_randao: B256::ZERO,
+        suggested_fee_recipient: Address::ZERO,
+        withdrawals: Some(vec![]),
+        parent_beacon_block_root: Some(B256::ZERO),
+        slot_number: Some(timestamp),
+    }
+}
+
 /// Advances node by producing blocks with random transactions.
 pub(crate) async fn advance_with_random_transactions<Provider>(
     node: &mut NodeHelperType<EthereumNode, Provider>,
diff --git a/crates/ethereum/payload/src/config.rs b/crates/ethereum/payload/src/config.rs
index 6e429b61f0f..0af9d9f19c9 100644
--- a/crates/ethereum/payload/src/config.rs
+++ b/crates/ethereum/payload/src/config.rs
@@ -1,6 +1,6 @@
+pub use alloy_eips::eip1559::calculate_block_gas_limit;
 use alloy_eips::eip1559::ETHEREUM_BLOCK_GAS_LIMIT_30M;
 use alloy_primitives::Bytes;
-use reth_primitives_traits::constants::GAS_LIMIT_BOUND_DIVISOR;
 
 /// Settings for the Ethereum builder.
 #[derive(PartialEq, Eq, Clone, Debug)]
@@ -65,15 +65,46 @@ impl EthereumBuilderConfig {
     /// Returns the gas limit for the next block based
     /// on parent and desired gas limits.
     pub fn gas_limit(&self, parent_gas_limit: u64) -> u64 {
-        calculate_block_gas_limit(parent_gas_limit, self.desired_gas_limit)
+        self.gas_limit_with_target(parent_gas_limit, None)
+    }
+
+    /// Returns the gas limit for the next block based on the parent gas limit and an optional
+    /// target from payload attributes.
+    pub fn gas_limit_with_target(
+        &self,
+        parent_gas_limit: u64,
+        target_gas_limit: Option<u64>,
+    ) -> u64 {
+        calculate_block_gas_limit(
+            parent_gas_limit,
+            target_gas_limit.unwrap_or(self.desired_gas_limit),
+        )
     }
 }
 
-/// Calculate the gas limit for the next block based on parent and desired gas limits.
-/// Ref: <https://github.com/ethereum/go-ethereum/blob/88cbfab332c96edfbe99d161d9df6a40721bd786/core/block_validator.go#L166>
-pub fn calculate_block_gas_limit(parent_gas_limit: u64, desired_gas_limit: u64) -> u64 {
-    let delta = (parent_gas_limit / GAS_LIMIT_BOUND_DIVISOR).saturating_sub(1);
-    let min_gas_limit = parent_gas_limit - delta;
-    let max_gas_limit = parent_gas_limit + delta;
-    desired_gas_limit.clamp(min_gas_limit, max_gas_limit)
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn gas_limit_uses_payload_target_when_present() {
+        let parent_gas_limit = 30_000_000;
+        let target_gas_limit = parent_gas_limit - 100;
+        let config = EthereumBuilderConfig::new().with_gas_limit(parent_gas_limit + 100);
+
+        assert_eq!(
+            config.gas_limit_with_target(parent_gas_limit, Some(target_gas_limit)),
+            target_gas_limit
+        );
+    }
+
+    #[test]
+    fn gas_limit_falls_back_to_configured_target() {
+        let parent_gas_limit = 30_000_000;
+        let desired_gas_limit = parent_gas_limit + 100;
+        let config = EthereumBuilderConfig::new().with_gas_limit(desired_gas_limit);
+
+        assert_eq!(config.gas_limit_with_target(parent_gas_limit, None), desired_gas_limit);
+        assert_eq!(config.gas_limit(parent_gas_limit), desired_gas_limit);
+    }
 }
diff --git a/crates/ethereum/payload/src/lib.rs b/crates/ethereum/payload/src/lib.rs
index 2d6c2e2d022..34428e71b2b 100644
--- a/crates/ethereum/payload/src/lib.rs
+++ b/crates/ethereum/payload/src/lib.rs
@@ -9,7 +9,7 @@
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
 use alloy_consensus::Transaction;
-use alloy_primitives::U256;
+use alloy_primitives::{Bytes, U256};
 use alloy_rlp::Encodable;
 use alloy_rpc_types_engine::PayloadAttributes as EthPayloadAttributes;
 use reth_basic_payload_builder::{
@@ -22,7 +22,7 @@ use reth_errors::{BlockExecutionError, BlockValidationError, ConsensusError};
 use reth_ethereum_primitives::{EthPrimitives, TransactionSigned};
 use reth_evm::{
     block::TxResult,
-    execute::{BlockBuilder, BlockBuilderOutcome, BlockExecutor},
+    execute::{BlockBuilder, BlockBuilderOutcome},
     ConfigureEvm, Evm, NextBlockEnvAttributes,
 };
 use reth_evm_ethereum::EthEvmConfig;
@@ -131,7 +131,7 @@ where
             self.pool.clone(),
             self.builder_config.clone(),
             args,
-            |attributes| self.pool.best_transactions_with_attributes(attributes),
+            |_| -> BestTransactionsIter<Pool> { Box::new(std::iter::empty()) },
         )?
         .into_payload()
         .ok_or_else(|| PayloadBuilderError::MissingPayload)
@@ -166,7 +166,7 @@ where
         cancel,
         best_payload,
     } = args;
-    let PayloadConfig { parent_header, attributes, payload_id } = config;
+    let PayloadConfig { parent_header, attributes, payload_id, .. } = config;
 
     let mut state_provider = client.state_by_block_hash(parent_header.hash())?;
     if let Some(execution_cache) = execution_cache {
@@ -175,7 +175,7 @@ where
             execution_cache.cache().clone(),
             // It's ok to recreate the cache every time, because it's cheap to do so for a vanilla
             // Ethereum builder every 12s.
-            CachedStateMetrics::zeroed(CachedStateMetricsSource::Builder),
+            Some(CachedStateMetrics::zeroed(CachedStateMetricsSource::Builder)),
         ));
     }
     let state = StateProviderDatabase::new(state_provider.as_ref());
@@ -195,7 +195,8 @@ where
                 timestamp: attributes.timestamp(),
                 suggested_fee_recipient: attributes.suggested_fee_recipient,
                 prev_randao: attributes.prev_randao,
-                gas_limit: builder_config.gas_limit(parent_header.gas_limit),
+                gas_limit: builder_config
+                    .gas_limit_with_target(parent_header.gas_limit, attributes.target_gas_limit()),
                 parent_beacon_block_root: attributes.parent_beacon_block_root(),
                 withdrawals: attributes.withdrawals.clone().map(Into::into),
                 extra_data: builder_config.extra_data,
@@ -221,7 +222,7 @@ where
     // If we have a sparse trie handle, wire a state hook that streams per-tx state diffs
     // to the background trie pipeline for incremental state root computation.
     if let Some(ref handle) = trie_handle {
-        builder.executor_mut().set_state_hook(Some(Box::new(handle.state_hook())));
+        builder.evm_mut().db_mut().set_state_hook(Some(Box::new(handle.state_hook())));
     }
 
     builder.apply_pre_execution_changes().map_err(|err| {
@@ -278,7 +279,7 @@ where
             // continue
             best_txs.mark_invalid(
                 &pool_tx,
-                &InvalidPoolTransactionError::ExceedsGasLimit(
+                InvalidPoolTransactionError::ExceedsGasLimit(
                     transaction_gas_limit,
                     block_available_gas,
                 ),
@@ -302,7 +303,7 @@ where
         if is_osaka && estimated_block_size_with_tx > MAX_RLP_BLOCK_SIZE {
             best_txs.mark_invalid(
                 &pool_tx,
-                &InvalidPoolTransactionError::OversizedData {
+                InvalidPoolTransactionError::OversizedData {
                     size: estimated_block_size_with_tx,
                     limit: MAX_RLP_BLOCK_SIZE,
                 },
@@ -324,7 +325,7 @@ where
                 trace!(target: "payload_builder", tx=?tx.hash(), ?block_blob_count, "skipping blob transaction because it would exceed the max blob count per block");
                 best_txs.mark_invalid(
                     &pool_tx,
-                    &InvalidPoolTransactionError::Eip4844(
+                    InvalidPoolTransactionError::Eip4844(
                         Eip4844PoolTransactionError::TooManyEip4844Blobs {
                             have: block_blob_count + tx_blob_count,
                             permitted: max_blob_count,
@@ -357,7 +358,7 @@ where
             blob_tx_sidecar = match blob_sidecar_result {
                 Ok(sidecar) => Some(sidecar),
                 Err(error) => {
-                    best_txs.mark_invalid(&pool_tx, &InvalidPoolTransactionError::Eip4844(error));
+                    best_txs.mark_invalid(&pool_tx, InvalidPoolTransactionError::Eip4844(error));
                     continue
                 }
             };
@@ -383,7 +384,7 @@ where
                     trace!(target: "payload_builder", %error, ?tx_hash, "skipping invalid transaction and its descendants");
                     best_txs.mark_invalid(
                         &pool_tx,
-                        &InvalidPoolTransactionError::Consensus(
+                        InvalidPoolTransactionError::Consensus(
                             InvalidTransactionError::TxTypeNotSupported,
                         ),
                     );
@@ -401,7 +402,7 @@ where
                 trace!(target: "payload_builder", %transaction_gas_limit, %block_available_gas, ?tx_hash, "skipping transaction exceeding block gas limit");
                 best_txs.mark_invalid(
                     &pool_tx,
-                    &InvalidPoolTransactionError::ExceedsGasLimit(
+                    InvalidPoolTransactionError::ExceedsGasLimit(
                         transaction_gas_limit,
                         block_available_gas,
                     ),
@@ -446,11 +447,13 @@ where
         return Ok(BuildOutcome::Aborted { fees: total_fees, cached_reads })
     }
 
-    let BlockBuilderOutcome { execution_result, block, .. } = if let Some(mut handle) = trie_handle
+    let BlockBuilderOutcome { execution_result, block, block_access_list, .. } = if let Some(
+        mut handle,
+    ) = trie_handle
     {
         // Drop the state hook, which drops the StateHookSender and triggers
         // FinishedStateUpdates via its Drop impl, signaling the trie task to finalize.
-        builder.executor_mut().set_state_hook(None);
+        builder.evm_mut().db_mut().set_state_hook(None);
 
         // The sparse trie has been computing incrementally alongside tx execution.
         // This recv() waits for the final root hash — most work is already done.
@@ -476,17 +479,18 @@ where
         .is_prague_active_at_timestamp(attributes.timestamp)
         .then_some(execution_result.requests);
 
-    let sealed_block = Arc::new(block.into_sealed_block());
-    debug!(target: "payload_builder", id=%payload_id, sealed_block_header = ?sealed_block.sealed_header(), "sealed built block");
+    debug!(target: "payload_builder", id=%payload_id, sealed_block_header = ?block.sealed_header(), "sealed built block");
 
-    if is_osaka && sealed_block.rlp_length() > MAX_RLP_BLOCK_SIZE {
+    if is_osaka && block.rlp_length() > MAX_RLP_BLOCK_SIZE {
         return Err(PayloadBuilderError::other(ConsensusError::BlockTooLarge {
-            rlp_length: sealed_block.rlp_length(),
+            rlp_length: block.rlp_length(),
             max_rlp_length: MAX_RLP_BLOCK_SIZE,
         }));
     }
 
-    let payload = EthBuiltPayload::new(sealed_block, total_fees, requests, None)
+    let block_access_list: Option<Bytes> =
+        block_access_list.map(|block_access_list| alloy_rlp::encode(&block_access_list).into());
+    let payload = EthBuiltPayload::new(Arc::new(block), total_fees, requests, block_access_list)
         // add blob sidecars from the executed txs
         .with_sidecars(blob_sidecars);
 
diff --git a/crates/ethereum/primitives/Cargo.toml b/crates/ethereum/primitives/Cargo.toml
index f9f2ab6f240..bdd8a2c2f15 100644
--- a/crates/ethereum/primitives/Cargo.toml
+++ b/crates/ethereum/primitives/Cargo.toml
@@ -47,6 +47,7 @@ std = [
     "alloy-consensus/std",
     "alloy-primitives/std",
     "reth-primitives-traits/std",
+    "reth-primitives-traits/quanta",
     "serde?/std",
     "alloy-eips/std",
     "alloy-rpc-types-eth?/std",
diff --git a/crates/evm/evm/Cargo.toml b/crates/evm/evm/Cargo.toml
index 727042d552e..ab367006f8e 100644
--- a/crates/evm/evm/Cargo.toml
+++ b/crates/evm/evm/Cargo.toml
@@ -24,6 +24,7 @@ revm.workspace = true
 
 # alloy
 alloy-primitives.workspace = true
+alloy-eip7928.workspace = true
 alloy-eips.workspace = true
 alloy-evm.workspace = true
 alloy-consensus.workspace = true
@@ -55,6 +56,7 @@ std = [
     "reth-storage-api/std",
     "reth-trie-common/std",
     "reth-ethereum-primitives/std",
+    "alloy-eip7928/std",
 ]
 metrics = ["std", "dep:metrics", "dep:reth-metrics"]
 test-utils = [
diff --git a/crates/evm/evm/src/either.rs b/crates/evm/evm/src/either.rs
index 904ce7ebbd6..1c989ec98bc 100644
--- a/crates/evm/evm/src/either.rs
+++ b/crates/evm/evm/src/either.rs
@@ -79,4 +79,11 @@ where
             Self::Right(b) => b.size_hint(),
         }
     }
+
+    fn take_bal(&mut self) -> Option<alloy_eip7928::BlockAccessList> {
+        match self {
+            Self::Left(a) => a.take_bal(),
+            Self::Right(b) => b.take_bal(),
+        }
+    }
 }
diff --git a/crates/evm/evm/src/execute.rs b/crates/evm/evm/src/execute.rs
index fe0e9b15602..6d4bcc1451c 100644
--- a/crates/evm/evm/src/execute.rs
+++ b/crates/evm/evm/src/execute.rs
@@ -3,6 +3,7 @@
 use crate::{ConfigureEvm, Database, OnStateHook, TxEnvFor};
 use alloc::{boxed::Box, sync::Arc, vec::Vec};
 use alloy_consensus::{BlockHeader, Header};
+use alloy_eip7928::{compute_block_access_list_hash, BlockAccessList};
 use alloy_eips::eip2718::WithEncoded;
 pub use alloy_evm::block::{BlockExecutor, BlockExecutorFactory, GasOutput};
 use alloy_evm::{
@@ -21,7 +22,10 @@ use reth_primitives_traits::{
 use reth_storage_api::StateProvider;
 pub use reth_storage_errors::provider::ProviderError;
 use reth_trie_common::{updates::TrieUpdates, HashedPostState};
-use revm::database::{states::bundle_state::BundleRetention, BundleState, State};
+use revm::{
+    database::{states::bundle_state::BundleRetention, BundleState, State},
+    state::bal::Bal,
+};
 
 /// A type that knows how to execute a block. It is assumed to operate on a
 /// [`crate::Evm`] internally and use [`State`] as database.
@@ -157,6 +161,9 @@ pub trait Executor<DB: Database>: Sized {
     ///
     /// This is used to optimize DB commits depending on the size of the state.
     fn size_hint(&self) -> usize;
+
+    /// Takes built [`BlockAccessList`] from executor.
+    fn take_bal(&mut self) -> Option<BlockAccessList>;
 }
 
 /// Input for block building. Consumed by [`BlockAssembler`].
@@ -174,6 +181,7 @@ pub trait Executor<DB: Database>: Sized {
 /// - `bundle_state`: Accumulated state changes from all transactions
 /// - `state_provider`: Access to the current state for additional lookups
 /// - `state_root`: The calculated state root after all changes
+/// - `block_access_list_hash`: Block access list hash (EIP-7928, Amsterdam)
 ///
 /// # Usage
 ///
@@ -190,6 +198,7 @@ pub trait Executor<DB: Database>: Sized {
 ///     bundle_state: &state_changes,
 ///     state_provider: &state,
 ///     state_root: calculated_root,
+///     block_access_list_hash: Some(calculated_bal_hash),
 /// };
 ///
 /// let block = assembler.assemble_block(input)?;
@@ -217,6 +226,8 @@ pub struct BlockAssemblerInput<'a, 'b, F: BlockExecutorFactory, H = Header> {
     pub state_provider: &'b dyn StateProvider,
     /// State root for this block.
     pub state_root: B256,
+    /// Block access list hash (EIP-7928, Amsterdam).
+    pub block_access_list_hash: Option<B256>,
 }
 
 impl<'a, 'b, F: BlockExecutorFactory, H> BlockAssemblerInput<'a, 'b, F, H> {
@@ -234,6 +245,7 @@ impl<'a, 'b, F: BlockExecutorFactory, H> BlockAssemblerInput<'a, 'b, F, H> {
         bundle_state: &'a BundleState,
         state_provider: &'b dyn StateProvider,
         state_root: B256,
+        block_access_list_hash: Option<B256>,
     ) -> Self {
         Self {
             evm_env,
@@ -244,6 +256,7 @@ impl<'a, 'b, F: BlockExecutorFactory, H> BlockAssemblerInput<'a, 'b, F, H> {
             bundle_state,
             state_provider,
             state_root,
+            block_access_list_hash,
         }
     }
 }
@@ -313,6 +326,8 @@ pub struct BlockBuilderOutcome<N: NodePrimitives> {
     pub trie_updates: TrieUpdates,
     /// The built block.
     pub block: RecoveredBlock<N::Block>,
+    /// Block access list built during execution (EIP-7928, Amsterdam).
+    pub block_access_list: Option<BlockAccessList>,
 }
 
 /// A type that knows how to execute and build a block.
@@ -433,6 +448,14 @@ impl<Executor: BlockExecutor> ExecutorTx<Executor> for Recovered<Executor::Trans
     }
 }
 
+impl<Executor: BlockExecutor> ExecutorTx<Executor>
+    for (<Executor::Evm as Evm>::Tx, Recovered<Executor::Transaction>)
+{
+    fn into_parts(self) -> (<Executor::Evm as Evm>::Tx, Recovered<Executor::Transaction>) {
+        self
+    }
+}
+
 impl<Executor> ExecutorTx<Executor>
     for WithTxEnv<<Executor::Evm as Evm>::Tx, Recovered<Executor::Transaction>>
 where
@@ -465,7 +488,10 @@ where
     type Executor = Executor;
 
     fn apply_pre_execution_changes(&mut self) -> Result<(), BlockExecutionError> {
-        self.executor.apply_pre_execution_changes()
+        self.executor.apply_pre_execution_changes()?;
+        self.executor.evm_mut().db_mut().bump_bal_index();
+
+        Ok(())
     }
 
     fn execute_transaction_with_commit_condition(
@@ -478,6 +504,7 @@ where
             self.executor.execute_transaction_with_commit_condition((tx_env, &tx), f)?
         {
             self.transactions.push(tx);
+            self.executor.evm_mut().db_mut().bump_bal_index();
             Ok(Some(gas_used))
         } else {
             Ok(None)
@@ -495,6 +522,10 @@ where
         // merge all transitions into bundle state
         db.merge_transitions(BundleRetention::Reverts);
 
+        let block_access_list = db.take_built_alloy_bal();
+        let block_access_list_hash =
+            block_access_list.as_ref().map(|bal| compute_block_access_list_hash(bal.as_slice()));
+
         let hashed_state = state.hashed_post_state(&db.bundle_state);
         let (state_root, trie_updates) = match state_root_precomputed {
             Some(precomputed) => precomputed,
@@ -515,11 +546,18 @@ where
             bundle_state: &db.bundle_state,
             state_provider: &state,
             state_root,
+            block_access_list_hash,
         })?;
 
         let block = RecoveredBlock::new_unhashed(block, senders);
 
-        Ok(BlockBuilderOutcome { execution_result: result, hashed_state, trie_updates, block })
+        Ok(BlockBuilderOutcome {
+            execution_result: result,
+            hashed_state,
+            trie_updates,
+            block,
+            block_access_list,
+        })
     }
 
     fn executor_mut(&mut self) -> &mut Self::Executor {
@@ -566,11 +604,33 @@ where
         block: &RecoveredBlock<<Self::Primitives as NodePrimitives>::Block>,
     ) -> Result<BlockExecutionResult<<Self::Primitives as NodePrimitives>::Receipt>, Self::Error>
     {
-        let result = self
+        let mut executor = self
             .strategy_factory
             .executor_for_block(&mut self.db, block)
-            .map_err(BlockExecutionError::other)?
-            .execute_block(block.transactions_recovered())?;
+            .map_err(BlockExecutionError::other)?;
+
+        let has_bal = block.header().block_access_list_hash().is_some();
+
+        if has_bal {
+            executor.evm_mut().db_mut().bal_state.bal_builder = Some(Bal::new());
+        } else {
+            executor.evm_mut().db_mut().bal_state.bal_builder = None;
+        }
+
+        executor.apply_pre_execution_changes()?;
+
+        if has_bal {
+            executor.evm_mut().db_mut().bump_bal_index();
+        }
+
+        for tx in block.transactions_recovered() {
+            executor.execute_transaction(tx)?;
+            if has_bal {
+                executor.evm_mut().db_mut().bump_bal_index();
+            }
+        }
+
+        let result = executor.apply_post_execution_changes()?;
 
         self.db.merge_transitions(BundleRetention::Reverts);
 
@@ -585,16 +645,19 @@ where
     where
         H: OnStateHook + 'static,
     {
-        let result = self
+        let mut executor = self
             .strategy_factory
             .executor_for_block(&mut self.db, block)
-            .map_err(BlockExecutionError::other)?
-            .with_state_hook(Some(Box::new(state_hook)))
-            .execute_block(block.transactions_recovered())?;
+            .map_err(BlockExecutionError::other)?;
+
+        executor.evm_mut().db_mut().set_state_hook(Some(Box::new(state_hook)));
+
+        let result = executor.execute_block(block.transactions_recovered());
 
+        self.db.set_state_hook(None);
         self.db.merge_transitions(BundleRetention::Reverts);
 
-        Ok(result)
+        result
     }
 
     fn into_state(self) -> State<DB> {
@@ -604,6 +667,10 @@ where
     fn size_hint(&self) -> usize {
         self.db.bundle_state.size_hint()
     }
+
+    fn take_bal(&mut self) -> Option<BlockAccessList> {
+        self.db.take_built_alloy_bal()
+    }
 }
 
 /// A helper trait marking a 'static type that can be converted into an [`ExecutableTxParts`] for
@@ -618,7 +685,10 @@ impl<T, Evm: ConfigureEvm> ExecutableTxFor<Evm> for T where
 {
 }
 
-/// A container for a transaction and a transaction environment.
+/// A transaction stored together with its `TxEnv`.
+///
+/// See also [`ExecutableTxParts`] for types that can be split into a transaction environment and
+/// recovered transaction.
 #[derive(Debug)]
 pub struct WithTxEnv<TxEnv, T> {
     /// The transaction environment for EVM.
@@ -627,6 +697,18 @@ pub struct WithTxEnv<TxEnv, T> {
     pub tx: Arc<T>,
 }
 
+impl<TxEnv, T> WithTxEnv<TxEnv, T> {
+    /// Creates a transaction/environment pair from a type that can be split with
+    /// [`ExecutableTxParts::into_parts`].
+    pub fn new<Tx, InnerTx>(tx: Tx) -> Self
+    where
+        Tx: ExecutableTxParts<TxEnv, InnerTx, Recovered = T>,
+    {
+        let (tx_env, tx) = tx.into_parts();
+        Self { tx_env, tx: Arc::new(tx) }
+    }
+}
+
 impl<TxEnv: Clone, T> Clone for WithTxEnv<TxEnv, T> {
     fn clone(&self) -> Self {
         Self { tx_env: self.tx_env.clone(), tx: self.tx.clone() }
@@ -654,16 +736,9 @@ impl<TxEnv, T: RecoveredTx<Tx>, Tx> ExecutableTxParts<TxEnv, Tx> for WithTxEnv<T
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::Address;
-    use alloy_consensus::constants::KECCAK_EMPTY;
-    use alloy_evm::block::state_changes::balance_increment_state;
-    use alloy_primitives::{address, map::HashMap, U256};
     use core::marker::PhantomData;
     use reth_ethereum_primitives::EthPrimitives;
-    use revm::{
-        database::{CacheDB, EmptyDB},
-        state::AccountInfo,
-    };
+    use revm::database::{CacheDB, EmptyDB};
 
     #[derive(Clone, Debug, Default)]
     struct TestExecutorProvider;
@@ -709,6 +784,10 @@ mod tests {
         fn size_hint(&self) -> usize {
             0
         }
+
+        fn take_bal(&mut self) -> Option<BlockAccessList> {
+            None
+        }
     }
 
     #[test]
@@ -718,101 +797,4 @@ mod tests {
         let executor = provider.executor(db);
         let _ = executor.execute(&Default::default());
     }
-
-    fn setup_state_with_account(
-        addr: Address,
-        balance: u128,
-        nonce: u64,
-    ) -> State<CacheDB<EmptyDB>> {
-        let db = CacheDB::<EmptyDB>::default();
-        let mut state = State::builder().with_database(db).with_bundle_update().build();
-
-        let account_info = AccountInfo {
-            balance: U256::from(balance),
-            nonce,
-            code_hash: KECCAK_EMPTY,
-            code: None,
-            account_id: None,
-        };
-        state.insert_account(addr, account_info);
-        state
-    }
-
-    #[test]
-    fn test_balance_increment_state_zero() {
-        let addr = address!("0x1000000000000000000000000000000000000000");
-        let mut state = setup_state_with_account(addr, 100, 1);
-
-        let mut increments = HashMap::default();
-        increments.insert(addr, 0);
-
-        let result = balance_increment_state(&increments, &mut state).unwrap();
-        assert!(result.is_empty(), "Zero increments should be ignored");
-    }
-
-    #[test]
-    fn test_balance_increment_state_empty_increments_map() {
-        let mut state = State::builder()
-            .with_database(CacheDB::<EmptyDB>::default())
-            .with_bundle_update()
-            .build();
-
-        let increments = HashMap::default();
-        let result = balance_increment_state(&increments, &mut state).unwrap();
-        assert!(result.is_empty(), "Empty increments map should return empty state");
-    }
-
-    #[test]
-    fn test_balance_increment_state_multiple_valid_increments() {
-        let addr1 = address!("0x1000000000000000000000000000000000000000");
-        let addr2 = address!("0x2000000000000000000000000000000000000000");
-
-        let mut state = setup_state_with_account(addr1, 100, 1);
-
-        let account2 = AccountInfo {
-            balance: U256::from(200),
-            nonce: 1,
-            code_hash: KECCAK_EMPTY,
-            code: None,
-            account_id: None,
-        };
-        state.insert_account(addr2, account2);
-
-        let mut increments = HashMap::default();
-        increments.insert(addr1, 50);
-        increments.insert(addr2, 100);
-
-        let result = balance_increment_state(&increments, &mut state).unwrap();
-
-        assert_eq!(result.len(), 2);
-        assert_eq!(result.get(&addr1).unwrap().info.balance, U256::from(100));
-        assert_eq!(result.get(&addr2).unwrap().info.balance, U256::from(200));
-    }
-
-    #[test]
-    fn test_balance_increment_state_mixed_zero_and_nonzero_increments() {
-        let addr1 = address!("0x1000000000000000000000000000000000000000");
-        let addr2 = address!("0x2000000000000000000000000000000000000000");
-
-        let mut state = setup_state_with_account(addr1, 100, 1);
-
-        let account2 = AccountInfo {
-            balance: U256::from(200),
-            nonce: 1,
-            code_hash: KECCAK_EMPTY,
-            code: None,
-            account_id: None,
-        };
-        state.insert_account(addr2, account2);
-
-        let mut increments = HashMap::default();
-        increments.insert(addr1, 0);
-        increments.insert(addr2, 100);
-
-        let result = balance_increment_state(&increments, &mut state).unwrap();
-
-        assert_eq!(result.len(), 1, "Only non-zero increments should be included");
-        assert!(!result.contains_key(&addr1), "Zero increment account should not be included");
-        assert_eq!(result.get(&addr2).unwrap().info.balance, U256::from(200));
-    }
 }
diff --git a/crates/evm/evm/src/lib.rs b/crates/evm/evm/src/lib.rs
index 02c33b33059..e9df93bad70 100644
--- 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};
@@ -317,6 +320,19 @@ pub trait ConfigureEvm: Clone + Debug + Send + Sync + Unpin {
         self.block_executor_factory().create_executor(evm, ctx)
     }
 
+    /// Creates a strategy with a DB state borrow that can be shorter than the execution context.
+    fn create_executor_with_state<'a, 'db, DB, I>(
+        &'a self,
+        evm: EvmFor<Self, &'db mut State<DB>, I>,
+        ctx: <Self::BlockExecutorFactory as BlockExecutorFactory>::ExecutionCtx<'a>,
+    ) -> BlockExecutorFor<'a, Self::BlockExecutorFactory, &'db mut State<DB>, I>
+    where
+        DB: Database,
+        I: InspectorFor<Self, &'db mut State<DB>>,
+    {
+        self.block_executor_factory().create_executor(evm, ctx)
+    }
+
     /// Creates a strategy for execution of a given block.
     fn executor_for_block<'a, DB: Database>(
         &'a self,
diff --git a/crates/evm/execution-types/src/chain.rs b/crates/evm/execution-types/src/chain.rs
index ec6b8b6eb54..bb561010812 100644
--- a/crates/evm/execution-types/src/chain.rs
+++ b/crates/evm/execution-types/src/chain.rs
@@ -2,9 +2,12 @@
 
 use crate::ExecutionOutcome;
 use alloc::{borrow::Cow, collections::BTreeMap, vec::Vec};
-use alloy_consensus::{transaction::Recovered, BlockHeader, TxReceipt};
-use alloy_eips::{eip1898::ForkBlock, eip2718::Encodable2718, BlockNumHash};
-use alloy_primitives::{Address, BlockHash, BlockNumber, Log, TxHash};
+use alloy_consensus::{
+    transaction::{Recovered, TxHashRef},
+    BlockHeader, TxReceipt,
+};
+use alloy_eips::{eip1898::ForkBlock, BlockNumHash};
+use alloy_primitives::{map::HashSet, Address, BlockHash, BlockNumber, Log, TxHash};
 use core::{fmt, ops::RangeInclusive};
 use reth_primitives_traits::{
     transaction::signed::SignedTransaction, Block, BlockBody, IndexedTx, NodePrimitives,
@@ -207,6 +210,11 @@ impl<N: NodePrimitives> Chain<N> {
         self.blocks_iter().flat_map(|block| block.body().transactions())
     }
 
+    /// Returns an iterator over all transaction hashes in the chain.
+    pub fn transaction_hashes(&self) -> impl Iterator<Item = &TxHash> + '_ {
+        self.transactions_iter().map(|tx| tx.tx_hash())
+    }
+
     /// Returns an iterator over all [`Recovered`] transaction references in the chain.
     pub fn transactions_recovered_iter(
         &self,
@@ -291,10 +299,7 @@ impl<N: NodePrimitives> Chain<N> {
     /// Get all receipts with attachment.
     ///
     /// Attachment includes block number, block hash, transaction hash and transaction index.
-    pub fn receipts_with_attachment(&self) -> Vec<BlockReceipts<N::Receipt>>
-    where
-        N::SignedTx: Encodable2718,
-    {
+    pub fn receipts_with_attachment(&self) -> Vec<BlockReceipts<N::Receipt>> {
         let mut receipt_attach = Vec::with_capacity(self.blocks().len());
 
         self.blocks_and_receipts().for_each(|(block, receipts)| {
@@ -305,7 +310,7 @@ impl<N: NodePrimitives> Chain<N> {
                 .transactions()
                 .iter()
                 .zip(receipts)
-                .map(|(tx, receipt)| (tx.trie_hash(), receipt.clone()))
+                .map(|(tx, receipt)| (*tx.tx_hash(), receipt.clone()))
                 .collect();
 
             receipt_attach.push(BlockReceipts {
@@ -445,7 +450,27 @@ impl<B: Block<Body: BlockBody<Transaction: SignedTransaction>>> ChainBlocks<'_,
     pub fn transaction_hashes(&self) -> impl Iterator<Item = TxHash> + '_ {
         self.blocks
             .values()
-            .flat_map(|block| block.body().transactions_iter().map(|tx| tx.trie_hash()))
+            .flat_map(|block| block.body().transactions_iter().map(|tx| *tx.tx_hash()))
+    }
+
+    /// Returns all transaction hashes in a pre-allocated vector.
+    #[inline]
+    pub fn transaction_hashes_vec(&self) -> Vec<TxHash> {
+        let capacity = self.blocks.values().map(|block| block.body().transactions().len()).sum();
+
+        let mut hashes = Vec::with_capacity(capacity);
+        hashes.extend(self.transaction_hashes());
+        hashes
+    }
+
+    /// Returns all transaction hashes in a pre-allocated set.
+    #[inline]
+    pub fn transaction_hashes_set(&self) -> HashSet<TxHash> {
+        let capacity = self.blocks.values().map(|block| block.body().transactions().len()).sum();
+
+        let mut hashes = HashSet::with_capacity_and_hasher(capacity, Default::default());
+        hashes.extend(self.transaction_hashes());
+        hashes
     }
 }
 
diff --git a/crates/firehose-tests/tests/cases/nop_transfer/block.2099.binpb b/crates/firehose-tests/tests/cases/nop_transfer/block.2099.binpb
index 5cb95f0957a..0e4759b3054 100644
Binary files a/crates/firehose-tests/tests/cases/nop_transfer/block.2099.binpb and b/crates/firehose-tests/tests/cases/nop_transfer/block.2099.binpb differ
diff --git a/crates/firehose-tests/tests/cases/storage_sstore_oog/block.2713.binpb b/crates/firehose-tests/tests/cases/storage_sstore_oog/block.2713.binpb
index a2251ea9ad7..7eaaba510d0 100644
Binary files a/crates/firehose-tests/tests/cases/storage_sstore_oog/block.2713.binpb and b/crates/firehose-tests/tests/cases/storage_sstore_oog/block.2713.binpb differ
diff --git a/crates/firehose/Cargo.toml b/crates/firehose/Cargo.toml
index 339e8dd83e7..133572bab18 100644
--- a/crates/firehose/Cargo.toml
+++ b/crates/firehose/Cargo.toml
@@ -28,6 +28,7 @@ reth-tracing.workspace = true
 
 # alloy
 alloy-consensus.workspace = true
+alloy-eip7928.workspace = true
 alloy-eips.workspace = true
 alloy-evm.workspace = true
 alloy-genesis.workspace = true
diff --git a/crates/firehose/src/executor.rs b/crates/firehose/src/executor.rs
index f142b140cb6..0707c697c7b 100644
--- a/crates/firehose/src/executor.rs
+++ b/crates/firehose/src/executor.rs
@@ -43,7 +43,7 @@ use reth_evm::{
     execute::{BlockExecutionError, Executor},
     ConfigureEvm, Evm as _, OnStateHook,
 };
-use reth_execution_types::BlockExecutionResult;
+use reth_execution_types::{BlockExecutionOutput, BlockExecutionResult};
 use reth_node_api::NodePrimitives;
 use reth_primitives_traits::{Block as BlockTrait, BlockBody, BlockTy, RecoveredBlock, TxTy};
 use reth_revm::{
@@ -401,10 +401,6 @@ where
         Ok((evm, exec_result))
     }
 
-    fn set_state_hook(&mut self, hook: Option<Box<dyn OnStateHook>>) {
-        self.inner.set_state_hook(hook);
-    }
-
     fn evm_mut(&mut self) -> &mut Self::Evm {
         self.inner.evm_mut()
     }
@@ -630,6 +626,28 @@ where
         }
     }
 
+    /// Overrides the trait default so that `execute()` — the single-block convenience method used
+    /// by the pipeline and any other call site that doesn't know about Firehose — automatically
+    /// routes through [`Self::execute_and_trace_one`] when the global tracer is active.
+    ///
+    /// Without this override, the provided `execute()` calls `execute_one()` unconditionally,
+    /// which skips inspector attachment and produces no `FIRE BLOCK` output for historical blocks.
+    fn execute(
+        mut self,
+        block: &RecoveredBlock<<Self::Primitives as NodePrimitives>::Block>,
+    ) -> Result<
+        BlockExecutionOutput<<Self::Primitives as NodePrimitives>::Receipt>,
+        Self::Error,
+    > {
+        let result = if crate::is_tracer_initialized() {
+            self.execute_and_trace_one(block)?
+        } else {
+            self.execute_one(block)?
+        };
+        let mut state = self.into_state();
+        Ok(BlockExecutionOutput { state: state.take_bundle(), result })
+    }
+
     fn execute_one_with_state_hook<S>(
         &mut self,
         block: &RecoveredBlock<<Self::Primitives as NodePrimitives>::Block>,
@@ -638,12 +656,16 @@ where
     where
         S: OnStateHook + 'static,
     {
-        let result = self
+        let mut executor = self
             .strategy_factory
             .executor_for_block(&mut self.db, block)
-            .map_err(BlockExecutionError::other)?
-            .with_state_hook(Some(Box::new(state_hook)))
-            .execute_block(block.transactions_recovered())?;
+            .map_err(BlockExecutionError::other)?;
+        // State hooks moved from the executor to the revm State (alloy-evm #366); set on the db.
+        executor
+            .evm_mut()
+            .db_mut()
+            .set_state_hook(Some(Box::new(state_hook) as Box<dyn OnStateHook + 'static>));
+        let result = executor.execute_block(block.transactions_recovered())?;
         self.db.merge_transitions(BundleRetention::Reverts);
         Ok(result)
     }
@@ -661,6 +683,10 @@ where
     fn size_hint(&self) -> usize {
         self.db.bundle_state.size_hint()
     }
+
+    fn take_bal(&mut self) -> Option<Vec<alloy_eip7928::account_changes::AccountChanges>> {
+        None
+    }
 }
 
 /// Runs a single block through a [`FirehoseWrappedExecutor`] using the existing tracer guard for
diff --git a/crates/firehose/src/inspector.rs b/crates/firehose/src/inspector.rs
index a797fe0394d..474c0ef888e 100644
--- a/crates/firehose/src/inspector.rs
+++ b/crates/firehose/src/inspector.rs
@@ -427,7 +427,7 @@ impl<'a> FirehoseInspector<'a> {
 
         self.tracer.on_balance_change(
             caller,
-            account.original_info.balance,
+            account.original_info().balance,
             account.info.balance,
             reason,
         );
@@ -439,7 +439,7 @@ impl<'a> FirehoseInspector<'a> {
         // and `process_eip7702_auth_list` (called below) emits those bumps
         // separately. Letting the live nonce through here would double-count.
         if let Some((old, new)) =
-            deduct_caller_nonce_emission(account.original_info.nonce, account.info.nonce)
+            deduct_caller_nonce_emission(account.original_info().nonce, account.info.nonce)
         {
             self.tracer.on_nonce_change(caller, old, new);
         }
@@ -640,8 +640,8 @@ impl<'a> FirehoseInspector<'a> {
                 let (mut nonce, code_hash, code_loaded) = if let Some(acc) =
                     context.journal().evm_state().get(&authority)
                 {
-                    let code = acc.original_info.code.as_ref().map(|b| b.original_bytes().to_vec());
-                    (acc.original_info.nonce, acc.original_info.code_hash, code)
+                    let code = acc.original_info().code.as_ref().map(|b| b.original_bytes().to_vec());
+                    (acc.original_info().nonce, acc.original_info().code_hash, code)
                 } else {
                     (0, KECCAK_EMPTY, Some(Vec::new()))
                 };
@@ -1159,7 +1159,9 @@ where
         // in-block delegation set by any prior transaction.
         {
             if let Some(account) = context.journal().evm_state().get(&to) {
-                if let Some(eip7702) = account.info.code.as_ref().and_then(|code| code.eip7702_address()) {
+                if let Some(eip7702) =
+                    account.info.code.as_ref().and_then(|code| code.eip7702_address())
+                {
                     self.tracer.set_current_call_address_delegates_to(eip7702);
                 }
             }
diff --git a/crates/net/discv4/src/config.rs b/crates/net/discv4/src/config.rs
index f9002a8fde9..c2b30d3daf1 100644
--- a/crates/net/discv4/src/config.rs
+++ b/crates/net/discv4/src/config.rs
@@ -49,6 +49,13 @@ pub struct Discv4Config {
     pub enable_lookup: bool,
     /// Whether to enforce EIP-868 extension.
     pub enable_eip868: bool,
+    /// Whether to only respond with nodes that have a known EIP-868 ENR record (fork ID) in
+    /// `Neighbours` responses.
+    ///
+    /// When enabled, the node will filter out entries that have not yet been confirmed to support
+    /// EIP-868 (i.e., have no `fork_id`) when responding to `FindNode` requests. This helps
+    /// callers discover only peers that advertise their fork ID.
+    pub enforce_eip868_neighbours: bool,
     /// Whether to respect expiration timestamps in messages.
     pub enforce_expiration_timestamps: bool,
     /// Additional pairs to include in The [`Enr`](enr::Enr) if EIP-868 extension is enabled <https://eips.ethereum.org/EIPS/eip-868>
@@ -123,6 +130,7 @@ impl Default for Discv4Config {
             enable_dht_random_walk: true,
             enable_lookup: true,
             enable_eip868: true,
+            enforce_eip868_neighbours: false,
             enforce_expiration_timestamps: true,
             additional_eip868_rlp_pairs: Default::default(),
             external_ip_resolver: Some(Default::default()),
@@ -218,6 +226,16 @@ impl Discv4ConfigBuilder {
         self
     }
 
+    /// Whether to only include nodes with a known EIP-868 ENR record (fork ID) in `Neighbours`
+    /// responses.
+    pub const fn enforce_eip868_neighbours(
+        &mut self,
+        enforce_eip868_neighbours: bool,
+    ) -> &mut Self {
+        self.config.enforce_eip868_neighbours = enforce_eip868_neighbours;
+        self
+    }
+
     /// Whether to enforce expiration timestamps in messages.
     pub const fn enforce_expiration_timestamps(
         &mut self,
diff --git a/crates/net/discv4/src/lib.rs b/crates/net/discv4/src/lib.rs
index 0d9f0bc5315..3ef421ea628 100644
--- a/crates/net/discv4/src/lib.rs
+++ b/crates/net/discv4/src/lib.rs
@@ -1603,9 +1603,23 @@ impl Discv4Service {
         let key = kad_key(target);
         let expire = self.send_neighbours_expiration();
 
-        // get the MAX_NODES_PER_BUCKET closest nodes to the target
-        let closest_nodes =
-            self.kbuckets.closest_values(&key).take(MAX_NODES_PER_BUCKET).collect::<Vec<_>>();
+        let enforce_eip868 = self.config.enable_eip868 && self.config.enforce_eip868_neighbours;
+
+        // get the MAX_NODES_PER_BUCKET closest nodes to the target, optionally filtering out
+        // entries that have no EIP-868 fork ID
+        let closest_nodes = self
+            .kbuckets
+            .closest_values(&key)
+            .filter(|entry| !enforce_eip868 || entry.value.fork_id.is_some())
+            .take(MAX_NODES_PER_BUCKET)
+            .collect::<Vec<_>>();
+
+        if closest_nodes.is_empty() {
+            // always respond so the requester does not treat this as a timeout
+            let msg = Message::Neighbours(Neighbours { nodes: Vec::new(), expire });
+            self.send_packet(msg, to);
+            return;
+        }
 
         for nodes in closest_nodes.chunks(SAFE_MAX_DATAGRAM_NEIGHBOUR_RECORDS) {
             let nodes = nodes.iter().map(|node| node.value.record).collect::<Vec<NodeRecord>>();
diff --git a/crates/net/discv5/src/config.rs b/crates/net/discv5/src/config.rs
index 1e07986ea6b..16e94cf79a3 100644
--- a/crates/net/discv5/src/config.rs
+++ b/crates/net/discv5/src/config.rs
@@ -72,6 +72,12 @@ pub struct ConfigBuilder {
     /// NOTE: IP address of `RLPx` socket overwrites IP address of same IP version in
     /// [`discv5::ListenConfig`].
     tcp_socket: SocketAddr,
+    /// IP address to advertise in the local ENR instead of the listen socket address.
+    ///
+    /// This is separate from [`discv5::ListenConfig`] because the listen address describes where
+    /// discv5 binds its UDP socket. Nodes commonly bind to an unspecified address like `0.0.0.0`
+    /// while advertising an externally reachable address from NAT configuration.
+    advertised_ip: Option<IpAddr>,
     /// List of `(key, rlp-encoded-value)` tuples that should be advertised in local node record
     /// (in addition to tcp port, udp port and fork).
     other_enr_kv_pairs: Vec<(&'static [u8], Bytes)>,
@@ -95,6 +101,7 @@ impl ConfigBuilder {
             bootstrap_nodes,
             fork,
             tcp_socket,
+            advertised_ip,
             other_enr_kv_pairs,
             lookup_interval,
             bootstrap_lookup_interval,
@@ -107,6 +114,7 @@ impl ConfigBuilder {
             bootstrap_nodes,
             fork: fork.map(|(key, fork_id)| (key, fork_id.fork_id)),
             tcp_socket,
+            advertised_ip,
             other_enr_kv_pairs,
             lookup_interval: Some(lookup_interval),
             bootstrap_lookup_interval: Some(bootstrap_lookup_interval),
@@ -177,6 +185,13 @@ impl ConfigBuilder {
         self
     }
 
+    /// Sets the IP address to advertise in the local [`Enr`](discv5::enr::Enr), without changing
+    /// the discv5 listen socket.
+    pub const fn advertised_ip(mut self, ip: IpAddr) -> Self {
+        self.advertised_ip = Some(ip);
+        self
+    }
+
     /// Adds an additional kv-pair to include in the local [`Enr`](discv5::enr::Enr). Takes the key
     /// to use for the kv-pair and the rlp encoded value.
     pub fn add_enr_kv_pair(mut self, key: &'static [u8], value: Bytes) -> Self {
@@ -221,6 +236,7 @@ impl ConfigBuilder {
             bootstrap_nodes,
             fork,
             tcp_socket,
+            advertised_ip,
             other_enr_kv_pairs,
             lookup_interval,
             bootstrap_lookup_interval,
@@ -234,6 +250,12 @@ impl ConfigBuilder {
 
         discv5_config.listen_config =
             amend_listen_config_wrt_rlpx(&discv5_config.listen_config, tcp_socket.ip());
+        if advertised_ip.is_some() {
+            // The upstream discv5 service can update local ENR IP fields from peer-observed
+            // socket addresses. When the operator configured a NAT address, that address is
+            // intentional advertisement state and must not be replaced by peer observations.
+            discv5_config.enr_update = false;
+        }
 
         let fork = fork.map(|(key, fork_id)| (key, fork_id.into()));
 
@@ -251,6 +273,7 @@ impl ConfigBuilder {
             bootstrap_nodes,
             fork,
             tcp_socket,
+            advertised_ip,
             other_enr_kv_pairs,
             lookup_interval,
             bootstrap_lookup_interval,
@@ -276,6 +299,8 @@ pub struct Config {
     /// NOTE: IP address of `RLPx` socket overwrites IP address of same IP version in
     /// [`discv5::ListenConfig`].
     pub(super) tcp_socket: SocketAddr,
+    /// IP address to advertise in the local ENR instead of the listen socket address.
+    pub(super) advertised_ip: Option<IpAddr>,
     /// Additional kv-pairs (besides tcp port, udp port and fork) that should be advertised to
     /// peers by including in local node record.
     pub(super) other_enr_kv_pairs: Vec<(&'static [u8], Bytes)>,
@@ -300,6 +325,7 @@ impl Config {
             bootstrap_nodes: HashSet::default(),
             fork: None,
             tcp_socket: rlpx_tcp_socket,
+            advertised_ip: None,
             other_enr_kv_pairs: Vec::new(),
             lookup_interval: None,
             bootstrap_lookup_interval: None,
diff --git a/crates/net/discv5/src/lib.rs b/crates/net/discv5/src/lib.rs
index 5472e3c161a..7a77d8f6788 100644
--- a/crates/net/discv5/src/lib.rs
+++ b/crates/net/discv5/src/lib.rs
@@ -471,20 +471,26 @@ pub fn build_local_enr(
 ) -> (Enr<SecretKey>, NodeRecord, Option<&'static [u8]>, IpMode) {
     let mut builder = discv5::enr::Enr::builder();
 
-    let Config { discv5_config, fork, tcp_socket, other_enr_kv_pairs, .. } = config;
+    let Config { discv5_config, fork, tcp_socket, advertised_ip, 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);
 
+        // Prefer an explicit advertised IP for ENR IP fields. Listen sockets still supply UDP
+        // ports and determine which address-family fields are emitted.
         if let Some(addr) = v4 {
-            if *addr.ip() != Ipv4Addr::UNSPECIFIED {
+            if let Some(IpAddr::V4(ip)) = advertised_ip {
+                builder.ip4(*ip);
+            } else if *addr.ip() != Ipv4Addr::UNSPECIFIED {
                 builder.ip4(*addr.ip());
             }
             builder.udp4(addr.port());
         }
         if let Some(addr) = v6 {
-            if *addr.ip() != Ipv6Addr::UNSPECIFIED {
+            if let Some(IpAddr::V6(ip)) = advertised_ip {
+                builder.ip6(*ip);
+            } else if *addr.ip() != Ipv6Addr::UNSPECIFIED {
                 builder.ip6(*addr.ip());
             }
             builder.udp6(addr.port());
diff --git a/crates/net/dns/src/error.rs b/crates/net/dns/src/error.rs
index 6246e1c4176..60aa3d3322b 100644
--- a/crates/net/dns/src/error.rs
+++ b/crates/net/dns/src/error.rs
@@ -54,6 +54,10 @@ pub(crate) enum LookupError {
     #[error("request timed out")]
     /// Indicates a timeout occurred during the request.
     RequestTimedOut,
+    /// Entry hash mismatch error.
+    #[error("entry content does not match hash {0}")]
+    /// Indicates that resolved TXT content does not match the requested hash label.
+    HashMismatch(String),
     /// Entry not found error.
     #[error("entry not found")]
     /// Indicates the requested entry was not found.
diff --git a/crates/net/dns/src/lib.rs b/crates/net/dns/src/lib.rs
index 0fd5d9590fc..31b147ed321 100644
--- a/crates/net/dns/src/lib.rs
+++ b/crates/net/dns/src/lib.rs
@@ -409,13 +409,19 @@ mod tests {
     use super::*;
     use crate::tree::TreeRootEntry;
     use alloy_chains::Chain;
+    use alloy_primitives::keccak256;
     use alloy_rlp::{Decodable, Encodable};
+    use data_encoding::BASE32_NOPAD;
     use enr::EnrKey;
     use reth_chainspec::MAINNET;
     use reth_ethereum_forks::{EthereumHardfork, ForkHash};
     use secp256k1::rand::thread_rng;
     use std::{future::poll_fn, net::Ipv4Addr};
 
+    fn entry_hash(entry_txt: &str) -> String {
+        BASE32_NOPAD.encode(&keccak256(entry_txt.as_bytes()).as_slice()[..16])
+    }
+
     #[test]
     fn test_convert_enr_node_record() {
         // rig
@@ -503,11 +509,9 @@ mod tests {
         let resolver = MapResolver::default();
         let s = "enrtree-root:v1 e=QFT4PBCRX4XQCV3VUYJ6BTCEPU l=JGUFMSAGI7KZYB3P7IZW4S5Y3A seq=3 sig=3FmXuVwpa8Y7OstZTx9PIb1mt8FrW7VpDOFv4AaGCsZ2EIHmhraWhe4NxYhQDlw5MjeFXYMbJjsPeKlHzmJREQE";
         let mut root: TreeRootEntry = s.parse().unwrap();
-        root.sign(&secret_key).unwrap();
 
         let link =
             LinkEntry { domain: "nodes.example.org".to_string(), pubkey: secret_key.public() };
-        resolver.insert(link.domain.clone(), root.to_string());
 
         let mut builder = Enr::builder();
         let fork_id = MAINNET.hardfork_fork_id(EthereumHardfork::Frontier).unwrap();
@@ -517,8 +521,13 @@ mod tests {
             .tcp4(30303)
             .add_value(b"eth", &EnrForkIdEntry::from(fork_id));
         let enr = builder.build(&secret_key).unwrap();
+        let enr_txt = enr.to_base64();
 
-        resolver.insert(format!("{}.{}", root.enr_root.clone(), link.domain), enr.to_base64());
+        root.enr_root = entry_hash(&enr_txt);
+        root.sign(&secret_key).unwrap();
+
+        resolver.insert(link.domain.clone(), root.to_string());
+        resolver.insert(format!("{}.{}", root.enr_root.clone(), link.domain), enr_txt);
 
         let mut service = DnsDiscoveryService::new(Arc::new(resolver), Default::default());
 
@@ -582,12 +591,13 @@ mod tests {
 
         let mut new_root = root.clone();
         new_root.sequence_number = new_root.sequence_number.saturating_add(1);
-        new_root.enr_root = "NEW_ENR_ROOT".to_string();
-        new_root.sign(&secret_key).unwrap();
-        resolver.insert(link.domain.clone(), new_root.to_string());
 
         let enr = Enr::empty(&secret_key).unwrap();
-        resolver.insert(format!("{}.{}", new_root.enr_root.clone(), link.domain), enr.to_base64());
+        let enr_txt = enr.to_base64();
+        new_root.enr_root = entry_hash(&enr_txt);
+        new_root.sign(&secret_key).unwrap();
+        resolver.insert(link.domain.clone(), new_root.to_string());
+        resolver.insert(format!("{}.{}", new_root.enr_root.clone(), link.domain), enr_txt);
 
         let event = poll_fn(|cx| service.poll(cx)).await;
 
@@ -604,6 +614,46 @@ mod tests {
         .await;
     }
 
+    #[tokio::test]
+    async fn test_hash_mismatch_is_not_cached_and_does_not_poison_same_hash() {
+        let secret_key = SecretKey::new(&mut thread_rng());
+        let resolver = MapResolver::default();
+
+        let invalid_entry = "enrtree-branch:AAAAAAAAAAAAAAAAAAAA".to_string();
+        let valid_entry = "enrtree-branch:YNEGZIWHOM7TOOSUATAPTM".to_string();
+
+        let hash = entry_hash(&valid_entry);
+
+        let bad_link =
+            LinkEntry { domain: "bad.example.org".to_string(), pubkey: secret_key.public() };
+        let good_link =
+            LinkEntry { domain: "good.example.org".to_string(), pubkey: secret_key.public() };
+
+        resolver.insert(format!("{}.{}", hash, bad_link.domain), invalid_entry);
+        resolver.insert(format!("{}.{}", hash, good_link.domain), valid_entry.clone());
+
+        let mut service = DnsDiscoveryService::new(Arc::new(resolver), Default::default());
+
+        service.resolve_entry(bad_link, hash.clone(), ResolveKind::Enr);
+        poll_fn(|cx| {
+            let _ = service.poll(cx);
+            Poll::Ready(())
+        })
+        .await;
+
+        assert!(service.dns_record_cache.get(&hash).is_none());
+
+        service.resolve_entry(good_link, hash.clone(), ResolveKind::Enr);
+        poll_fn(|cx| {
+            let _ = service.poll(cx);
+            Poll::Ready(())
+        })
+        .await;
+
+        let cached = service.dns_record_cache.get(&hash).cloned();
+        assert_eq!(cached.map(|entry| entry.to_string()), Some(valid_entry));
+    }
+
     #[tokio::test]
     #[ignore]
     async fn test_dns_resolver() {
diff --git a/crates/net/dns/src/query.rs b/crates/net/dns/src/query.rs
index f64551f42f1..81f27a2fdc3 100644
--- a/crates/net/dns/src/query.rs
+++ b/crates/net/dns/src/query.rs
@@ -6,6 +6,8 @@ use crate::{
     sync::ResolveKind,
     tree::{DnsEntry, LinkEntry, TreeRootEntry},
 };
+use alloy_primitives::keccak256;
+use data_encoding::BASE32_NOPAD;
 use enr::EnrKeyUnambiguous;
 use reth_tokio_util::ratelimit::{Rate, RateLimit};
 use std::{
@@ -18,6 +20,11 @@ use std::{
     time::Duration,
 };
 
+/// Minimum number of bytes an abbreviated EIP-1459 content hash may contain.
+const MIN_HASH_BYTES: usize = 12;
+/// Maximum number of bytes an abbreviated EIP-1459 content hash may contain.
+const MAX_HASH_BYTES: usize = 32;
+
 /// The `QueryPool` provides an aggregate state machine for driving queries to completion.
 pub(crate) struct QueryPool<R: Resolver, K: EnrKeyUnambiguous> {
     /// The [Resolver] that's used to lookup queries.
@@ -165,7 +172,10 @@ async fn resolve_entry<K: EnrKeyUnambiguous, R: Resolver>(
     let mut resp = ResolveEntryResult { entry: None, link, hash, kind };
     match lookup_with_timeout::<R>(&resolver, &fqn, timeout).await {
         Ok(Some(entry)) => {
-            resp.entry = Some(entry.parse::<DnsEntry<K>>().map_err(|err| err.into()))
+            resp.entry = Some(match verify_entry_hash(&resp.hash, &entry) {
+                Ok(()) => entry.parse::<DnsEntry<K>>().map_err(Into::into),
+                Err(err) => Err(err),
+            })
         }
         Err(err) => resp.entry = Some(Err(err)),
         Ok(None) => {}
@@ -173,6 +183,28 @@ async fn resolve_entry<K: EnrKeyUnambiguous, R: Resolver>(
     resp
 }
 
+/// Verifies that `entry_txt` belongs under the queried
+/// [EIP-1459](https://eips.ethereum.org/EIPS/eip-1459) hash label.
+///
+/// Entries resolved through `<hash>.<domain>` are stored below the base32 encoding of an
+/// abbreviated `keccak256` digest of their TXT content. The protocol accepts any prefix length in
+/// the valid hash range.
+fn verify_entry_hash(hash: &str, entry_txt: &str) -> LookupResult<()> {
+    let expected =
+        BASE32_NOPAD.decode(hash.as_bytes()).map_err(|_| LookupError::HashMismatch(hash.into()))?;
+    let actual = keccak256(entry_txt.as_bytes());
+
+    if !(MIN_HASH_BYTES..=MAX_HASH_BYTES).contains(&expected.len()) {
+        return Err(LookupError::HashMismatch(hash.into()))
+    }
+
+    if actual.as_slice().starts_with(&expected) {
+        Ok(())
+    } else {
+        Err(LookupError::HashMismatch(hash.into()))
+    }
+}
+
 /// Retrieves the root entry the link points to and returns the verified entry
 ///
 /// Returns an error if the record could be retrieved but is not a root entry or failed to be
@@ -216,6 +248,10 @@ mod tests {
     use crate::{resolver::TimeoutResolver, DnsDiscoveryConfig, MapResolver};
     use std::future::poll_fn;
 
+    fn entry_hash(entry_txt: &str) -> String {
+        BASE32_NOPAD.encode(&keccak256(entry_txt.as_bytes()).as_slice()[..16])
+    }
+
     #[tokio::test]
     async fn test_rate_limit() {
         let resolver = Arc::new(MapResolver::default());
@@ -274,4 +310,43 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn verify_entry_hash_accepts_eip_1459_vectors() {
+        let entries = [
+            (
+                "C7HRFPF3BLGF3YR4DY5KX3SMBE",
+                "enrtree://AM5FCQLWIZX2QFPNJAP7VUERCCRNGRHWZG3YYHIUV7BVDQ5FDPRT2@morenodes.example.org",
+            ),
+            (
+                "JWXYDBPXYWG6FX3GMDIBFA6CJ4",
+                "enrtree-branch:2XS2367YHAXJFGLZHVAWLQD4ZY,H4FHT4B454P6UXFD7JCYQ5PWDY,MHTDO6TMUBRIA2XWG5LUDACK24",
+            ),
+            (
+                "2XS2367YHAXJFGLZHVAWLQD4ZY",
+                "enr:-HW4QOFzoVLaFJnNhbgMoDXPnOvcdVuj7pDpqRvh6BRDO68aVi5ZcjB3vzQRZH2IcLBGHzo8uUN3snqmgTiE56CH3AMBgmlkgnY0iXNlY3AyNTZrMaECC2_24YYkYHEgdzxlSNKQEnHhuNAbNlMlWJxrJxbAFvA",
+            ),
+        ];
+
+        for (hash, entry) in entries {
+            verify_entry_hash(hash, entry).unwrap();
+        }
+    }
+
+    #[test]
+    fn verify_entry_hash_rejects_mismatched_or_invalid_hashes() {
+        let entry = "enrtree-branch:YNEGZIWHOM7TOOSUATAPTM";
+        let hash = entry_hash(entry);
+        verify_entry_hash(&hash, entry).unwrap();
+
+        assert!(matches!(
+            verify_entry_hash(&hash, "enrtree-branch:AAAAAAAAAAAAAAAAAAAA"),
+            Err(LookupError::HashMismatch(_))
+        ));
+        assert!(matches!(
+            verify_entry_hash("NOT_BASE32!", entry),
+            Err(LookupError::HashMismatch(_))
+        ));
+        assert!(matches!(verify_entry_hash("AAAA", entry), Err(LookupError::HashMismatch(_))));
+    }
 }
diff --git a/crates/net/dns/src/resolver.rs b/crates/net/dns/src/resolver.rs
index 434f34c75aa..7b966184bd6 100644
--- a/crates/net/dns/src/resolver.rs
+++ b/crates/net/dns/src/resolver.rs
@@ -1,8 +1,8 @@
 //! Perform DNS lookups
 
 use dashmap::DashMap;
-use hickory_resolver::name_server::ConnectionProvider;
-pub use hickory_resolver::{ResolveError, TokioResolver};
+pub use hickory_resolver::{net::NetError, TokioResolver};
+use hickory_resolver::{proto::rr::RData, ConnectionProvider};
 use std::future::Future;
 use tracing::trace;
 
@@ -23,8 +23,11 @@ impl<P: ConnectionProvider> Resolver for hickory_resolver::Resolver<P> {
                 None
             }
             Ok(lookup) => {
-                let txt = lookup.into_iter().next()?;
-                let entry = txt.iter().next()?;
+                let txt = lookup.answers().iter().find_map(|r| match &r.data {
+                    RData::TXT(txt) => Some(txt),
+                    _ => None,
+                })?;
+                let entry = txt.txt_data.first()?;
                 String::from_utf8(entry.to_vec()).ok()
             }
         }
@@ -59,8 +62,8 @@ impl DnsResolver {
     /// Constructs a new Tokio based Resolver with the system configuration.
     ///
     /// This will use `/etc/resolv.conf` on Unix OSes and the registry on Windows.
-    pub fn from_system_conf() -> Result<Self, ResolveError> {
-        TokioResolver::builder_tokio().map(|builder| Self::new(builder.build()))
+    pub fn from_system_conf() -> Result<Self, NetError> {
+        TokioResolver::builder_tokio()?.build().map(Self::new)
     }
 }
 
diff --git a/crates/net/downloaders/src/file_client.rs b/crates/net/downloaders/src/file_client.rs
index 6149e2c6fe5..0cb4b0df43e 100644
--- a/crates/net/downloaders/src/file_client.rs
+++ b/crates/net/downloaders/src/file_client.rs
@@ -126,7 +126,7 @@ impl<B: FullBlock> FileClient<B> {
         let mut reader = vec![];
         file.read_to_end(&mut reader).await?;
 
-        Ok(FileClientBuilder { consensus, parent_header: None }
+        Ok(FileClientBuilder { consensus, parent_header: None, skip_invalid_blocks: false }
             .build(&reader[..], file_len)
             .await?
             .file_client)
@@ -216,6 +216,7 @@ impl<B: FullBlock> FileClient<B> {
 struct FileClientBuilder<B: Block> {
     pub consensus: Arc<dyn Consensus<B>>,
     pub parent_header: Option<SealedHeader<B::Header>>,
+    pub skip_invalid_blocks: bool,
 }
 
 impl<B: FullBlock<Header: reth_primitives_traits::BlockHeader>> FromReader
@@ -272,16 +273,34 @@ impl<B: FullBlock<Header: reth_primitives_traits::BlockHeader>> FromReader
 
                 let block = SealedBlock::seal_slow(block);
 
-                // Validate standalone header
-                self.consensus.validate_header(block.sealed_header())?;
-                if let Some(parent) = &parent_header {
-                    self.consensus.validate_header_against_parent(block.sealed_header(), parent)?;
+                // Run consensus pre-checks. An invalid block here (e.g. mid-file in a
+                // BlockchainTest sequence that intentionally interleaves invalid block proposals
+                // with the valid chain) is not a hard failure: skip the block and keep decoding
+                // so the pipeline can still apply the valid prefix.
+                let validation =
+                    self.consensus.validate_header(block.sealed_header()).and_then(|_| {
+                        if let Some(parent) = &parent_header {
+                            self.consensus
+                                .validate_header_against_parent(block.sealed_header(), parent)?;
+                        }
+                        self.consensus.validate_block_pre_execution(&block)
+                    });
+                if let Err(err) = validation {
+                    if !self.skip_invalid_blocks {
+                        return Err(err.into())
+                    }
+                    warn!(target: "downloaders::file",
+                        block_number = block.number(),
+                        block_hash = %block.hash(),
+                        %err,
+                        "skipping invalid block while decoding file"
+                    );
+                    continue
+                }
+                if parent_header.is_some() {
                     parent_header = Some(block.sealed_header().clone());
                 }
 
-                // Validate block against header
-                self.consensus.validate_block_pre_execution(&block)?;
-
                 // add to the internal maps
                 let block_hash = block.hash();
                 let block_number = block.number();
@@ -578,12 +597,22 @@ impl ChunkedFileReader {
         &mut self,
         consensus: Arc<dyn Consensus<B>>,
         parent_header: Option<SealedHeader<B::Header>>,
+    ) -> Result<Option<FileClient<B>>, FileClientError> {
+        self.next_chunk_with_invalid_block_handling(consensus, parent_header, false).await
+    }
+
+    /// Read next chunk from file, optionally skipping blocks that fail consensus pre-checks.
+    pub async fn next_chunk_with_invalid_block_handling<B: FullBlock>(
+        &mut self,
+        consensus: Arc<dyn Consensus<B>>,
+        parent_header: Option<SealedHeader<B::Header>>,
+        skip_invalid_blocks: bool,
     ) -> Result<Option<FileClient<B>>, FileClientError> {
         let Some(chunk_len) = self.read_next_chunk().await? else { return Ok(None) };
 
         // make new file client from chunk
         let DecodedFileChunk { file_client, remaining_bytes, .. } =
-            FileClientBuilder { consensus, parent_header }
+            FileClientBuilder { consensus, parent_header, skip_invalid_blocks }
                 .build(&self.chunk[..], chunk_len)
                 .await?;
 
@@ -668,7 +697,7 @@ mod tests {
     use async_compression::tokio::write::GzipEncoder;
     use futures_util::stream::StreamExt;
     use rand::Rng;
-    use reth_consensus::{noop::NoopConsensus, test_utils::TestConsensus};
+    use reth_consensus::{noop::NoopConsensus, test_utils::TestConsensus, ConsensusError};
     use reth_ethereum_primitives::Block;
     use reth_network_p2p::{
         bodies::downloader::BodyDownloader,
@@ -797,6 +826,37 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn strict_chunk_decode_fails_on_invalid_block() {
+        let (file, _, _) = generate_bodies_file(0..=2).await;
+        let chunk_byte_len = file.metadata().await.unwrap().len();
+        let mut reader = ChunkedFileReader::from_file(file, chunk_byte_len, false).await.unwrap();
+        let consensus = Arc::new(TestConsensus::default());
+        consensus.set_fail_validation(true);
+
+        let err = reader.next_chunk::<Block>(consensus, None).await.unwrap_err();
+
+        assert_matches!(err, FileClientError::Consensus(ConsensusError::BaseFeeMissing));
+    }
+
+    #[tokio::test]
+    async fn lenient_chunk_decode_skips_invalid_blocks() {
+        let (file, _, _) = generate_bodies_file(0..=2).await;
+        let chunk_byte_len = file.metadata().await.unwrap().len();
+        let mut reader = ChunkedFileReader::from_file(file, chunk_byte_len, false).await.unwrap();
+        let consensus = Arc::new(TestConsensus::default());
+        consensus.set_fail_validation(true);
+
+        let client = reader
+            .next_chunk_with_invalid_block_handling::<Block>(consensus, None, true)
+            .await
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(client.headers_len(), 0);
+        assert!(client.tip().is_none());
+    }
+
     #[tokio::test]
     async fn test_chunk_download_headers_from_file() {
         reth_tracing::init_test_tracing();
diff --git a/crates/net/eth-wire-types/src/block_access_lists.rs b/crates/net/eth-wire-types/src/block_access_lists.rs
index 4f58f9b2542..a6c97fe20ec 100644
--- a/crates/net/eth-wire-types/src/block_access_lists.rs
+++ b/crates/net/eth-wire-types/src/block_access_lists.rs
@@ -2,7 +2,10 @@
 
 use alloc::vec::Vec;
 use alloy_primitives::{Bytes, B256};
-use alloy_rlp::{BufMut, Decodable, Encodable, Header, RlpDecodableWrapper, RlpEncodableWrapper};
+use alloy_rlp::{
+    BufMut, Decodable, Encodable, Header, RlpDecodableWrapper, RlpEncodableWrapper,
+    EMPTY_STRING_CODE,
+};
 use reth_codecs_derive::add_arbitrary_tests;
 
 /// A request for block access lists from the given block hashes.
@@ -15,30 +18,35 @@ pub struct GetBlockAccessLists(
     pub Vec<B256>,
 );
 
-/// Response for [`GetBlockAccessLists`] containing one BAL per requested block hash.
+/// Response for [`GetBlockAccessLists`] containing one BAL entry per requested block hash.
 ///
-/// The inner `Bytes` values store raw BAL RLP payloads and are encoded as nested RLP items, not
-/// as RLP byte strings.
+/// Present `Bytes` values store raw BAL RLP payloads and are encoded as nested RLP items, not as
+/// RLP byte strings.
 #[derive(Clone, Debug, PartialEq, Eq, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[add_arbitrary_tests(rlp)]
 pub struct BlockAccessLists(
     /// The requested block access lists as raw RLP blobs. Per EIP-8159, unavailable entries are
-    /// represented by an RLP-encoded empty list (`0xc0`).
-    pub Vec<Bytes>,
+    /// represented by `None` and encoded as the RLP empty string (`0x80`).
+    pub Vec<Option<Bytes>>,
 );
 
 impl Encodable for BlockAccessLists {
     fn encode(&self, out: &mut dyn BufMut) {
-        let payload_length = self.0.iter().map(|bytes| bytes.len()).sum();
+        let payload_length =
+            self.0.iter().map(|entry| entry.as_ref().map_or(1, |bytes| bytes.len())).sum();
         Header { list: true, payload_length }.encode(out);
-        for bal in &self.0 {
-            out.put_slice(bal);
+        for entry in &self.0 {
+            match entry {
+                Some(bal) => out.put_slice(bal),
+                None => out.put_u8(EMPTY_STRING_CODE),
+            }
         }
     }
 
     fn length(&self) -> usize {
-        let payload_length = self.0.iter().map(|bytes| bytes.len()).sum();
+        let payload_length =
+            self.0.iter().map(|entry| entry.as_ref().map_or(1, |bytes| bytes.len())).sum();
         Header { list: true, payload_length }.length_with_payload()
     }
 }
@@ -49,6 +57,9 @@ impl Decodable for BlockAccessLists {
         if !header.list {
             return Err(alloy_rlp::Error::UnexpectedString)
         }
+        if buf.len() < header.payload_length {
+            return Err(alloy_rlp::Error::InputTooShort)
+        }
 
         let (mut payload, rest) = buf.split_at(header.payload_length);
         *buf = rest;
@@ -57,12 +68,19 @@ impl Decodable for BlockAccessLists {
         while !payload.is_empty() {
             let item_start = payload;
             let item_header = Header::decode(&mut payload)?;
-            if !item_header.list {
+            let header_length = item_start.len() - payload.len();
+            let item_length = header_length + item_header.payload_length;
+            if item_length > item_start.len() {
+                return Err(alloy_rlp::Error::InputTooShort)
+            }
+            if item_header.list {
+                bals.push(Some(Bytes::copy_from_slice(&item_start[..item_length])));
+            } else if item_start[..item_length] == [EMPTY_STRING_CODE] {
+                bals.push(None);
+            } else {
                 return Err(alloy_rlp::Error::UnexpectedString)
             }
 
-            let item_length = item_header.length_with_payload();
-            bals.push(Bytes::copy_from_slice(&item_start[..item_length]));
             payload = &payload[item_header.payload_length..];
         }
 
@@ -73,12 +91,13 @@ impl Decodable for BlockAccessLists {
 #[cfg(any(test, feature = "arbitrary"))]
 impl<'a> arbitrary::Arbitrary<'a> for BlockAccessLists {
     fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
-        let entries = Vec::<Vec<alloy_eip7928::AccountChanges>>::arbitrary(u)?
+        let entries = Vec::<Option<Vec<alloy_eip7928::AccountChanges>>>::arbitrary(u)?
             .into_iter()
             .map(|entry| {
+                let entry = entry?;
                 let mut out = Vec::new();
                 alloy_rlp::encode_list(&entry, &mut out);
-                Bytes::from(out)
+                Some(Bytes::from(out))
             })
             .collect();
         Ok(Self(entries))
@@ -89,10 +108,11 @@ impl<'a> arbitrary::Arbitrary<'a> for BlockAccessLists {
 mod tests {
     use super::*;
     use alloy_eip7928::{
-        AccountChanges, BalanceChange, CodeChange, NonceChange, SlotChanges, StorageChange,
+        AccountChanges, BalanceChange, BlockAccessIndex, CodeChange, NonceChange, SlotChanges,
+        StorageChange,
     };
     use alloy_primitives::{Address, U256};
-    use alloy_rlp::EMPTY_LIST_CODE;
+    use alloy_rlp::{EMPTY_LIST_CODE, EMPTY_STRING_CODE};
 
     fn elaborate_account_changes(seed: u8) -> Vec<AccountChanges> {
         vec![
@@ -101,8 +121,14 @@ mod tests {
                 storage_changes: vec![SlotChanges::new(
                     U256::from_be_bytes([seed.wrapping_add(1); 32]),
                     vec![
-                        StorageChange::new(1, U256::from_be_bytes([seed.wrapping_add(2); 32])),
-                        StorageChange::new(2, U256::from_be_bytes([seed.wrapping_add(3); 32])),
+                        StorageChange::new(
+                            BlockAccessIndex::new(1),
+                            U256::from_be_bytes([seed.wrapping_add(2); 32]),
+                        ),
+                        StorageChange::new(
+                            BlockAccessIndex::new(2),
+                            U256::from_be_bytes([seed.wrapping_add(3); 32]),
+                        ),
                     ],
                 )],
                 storage_reads: vec![
@@ -110,15 +136,15 @@ mod tests {
                     U256::from_be_bytes([seed.wrapping_add(5); 32]),
                 ],
                 balance_changes: vec![
-                    BalanceChange::new(1, U256::from(1_000 + seed as u64)),
-                    BalanceChange::new(2, U256::from(2_000 + seed as u64)),
+                    BalanceChange::new(BlockAccessIndex::new(1), U256::from(1_000 + seed as u64)),
+                    BalanceChange::new(BlockAccessIndex::new(2), U256::from(2_000 + seed as u64)),
                 ],
                 nonce_changes: vec![
-                    NonceChange::new(1, seed as u64),
-                    NonceChange::new(2, seed as u64 + 1),
+                    NonceChange::new(BlockAccessIndex::new(1), seed as u64),
+                    NonceChange::new(BlockAccessIndex::new(2), seed as u64 + 1),
                 ],
                 code_changes: vec![CodeChange::new(
-                    1,
+                    BlockAccessIndex::new(1),
                     Bytes::from(vec![0x60, seed, 0x61, seed.wrapping_add(1), 0x56]),
                 )],
             },
@@ -126,9 +152,15 @@ mod tests {
                 address: Address::from([seed.wrapping_add(9); 20]),
                 storage_changes: Vec::new(),
                 storage_reads: vec![U256::from_be_bytes([seed.wrapping_add(10); 32])],
-                balance_changes: vec![BalanceChange::new(3, U256::from(3_000 + seed as u64))],
-                nonce_changes: vec![NonceChange::new(3, seed as u64 + 2)],
-                code_changes: vec![CodeChange::new(2, Bytes::from(vec![0x5f, 0x5f, 0xf3]))],
+                balance_changes: vec![BalanceChange::new(
+                    BlockAccessIndex::new(3),
+                    U256::from(3_000 + seed as u64),
+                )],
+                nonce_changes: vec![NonceChange::new(BlockAccessIndex::new(3), seed as u64 + 2)],
+                code_changes: vec![CodeChange::new(
+                    BlockAccessIndex::new(2),
+                    Bytes::from(vec![0x5f, 0x5f, 0xf3]),
+                )],
             },
         ]
     }
@@ -140,19 +172,26 @@ mod tests {
         Bytes::from(out)
     }
 
+    #[test]
+    fn unavailable_bal_entry_encodes_as_empty_string() {
+        let encoded = alloy_rlp::encode(BlockAccessLists(vec![None]));
+        assert_eq!(encoded, vec![0xc1, EMPTY_STRING_CODE]);
+    }
+
     #[test]
     fn empty_bal_entry_encodes_as_empty_list() {
         let encoded =
-            alloy_rlp::encode(BlockAccessLists(vec![Bytes::from_static(&[EMPTY_LIST_CODE])]));
+            alloy_rlp::encode(BlockAccessLists(vec![Some(Bytes::from_static(&[EMPTY_LIST_CODE]))]));
         assert_eq!(encoded, vec![0xc1, EMPTY_LIST_CODE]);
     }
 
     #[test]
     fn block_access_lists_roundtrip_preserves_raw_bal_items() {
         let original = BlockAccessLists(vec![
-            Bytes::from_static(&[EMPTY_LIST_CODE]),
-            Bytes::from_static(&[0xc1, EMPTY_LIST_CODE]),
-            Bytes::from_static(&[0xc2, EMPTY_LIST_CODE, EMPTY_LIST_CODE]),
+            None,
+            Some(Bytes::from_static(&[EMPTY_LIST_CODE])),
+            Some(Bytes::from_static(&[0xc1, EMPTY_LIST_CODE])),
+            Some(Bytes::from_static(&[0xc2, EMPTY_LIST_CODE, EMPTY_LIST_CODE])),
         ]);
 
         let encoded = alloy_rlp::encode(&original);
@@ -176,6 +215,19 @@ mod tests {
         assert!(matches!(err, alloy_rlp::Error::UnexpectedString));
     }
 
+    #[test]
+    fn rejects_non_empty_string_bal_entries() {
+        let err = alloy_rlp::decode_exact::<BlockAccessLists>(&[0xc2, 0x81, 0x80]).unwrap_err();
+        assert!(matches!(err, alloy_rlp::Error::UnexpectedString));
+    }
+
+    #[test]
+    fn rejects_truncated_response_payload() {
+        let err =
+            alloy_rlp::decode_exact::<BlockAccessLists>(&[0xc2, EMPTY_LIST_CODE]).unwrap_err();
+        assert!(matches!(err, alloy_rlp::Error::InputTooShort));
+    }
+
     #[test]
     fn elaborate_bal_entry_roundtrips_into_account_changes() {
         let expected = elaborate_account_changes(0x11);
@@ -188,9 +240,10 @@ mod tests {
     #[test]
     fn elaborate_block_access_lists_roundtrip_preserves_complex_bal_contents() {
         let original = BlockAccessLists(vec![
-            elaborate_bal_entry(0x11),
-            Bytes::from_static(&[EMPTY_LIST_CODE]),
-            elaborate_bal_entry(0x77),
+            Some(elaborate_bal_entry(0x11)),
+            None,
+            Some(Bytes::from_static(&[EMPTY_LIST_CODE])),
+            Some(elaborate_bal_entry(0x77)),
         ]);
 
         let encoded = alloy_rlp::encode(&original);
@@ -198,12 +251,16 @@ mod tests {
 
         assert_eq!(decoded, original);
         assert_eq!(
-            alloy_rlp::decode_exact::<Vec<AccountChanges>>(&decoded.0[0]).unwrap(),
+            alloy_rlp::decode_exact::<Vec<AccountChanges>>(decoded.0[0].as_ref().unwrap()).unwrap(),
             elaborate_account_changes(0x11)
         );
-        assert_eq!(alloy_rlp::decode_exact::<Vec<AccountChanges>>(&decoded.0[1]).unwrap(), vec![]);
+        assert!(decoded.0[1].is_none());
+        assert_eq!(
+            alloy_rlp::decode_exact::<Vec<AccountChanges>>(decoded.0[2].as_ref().unwrap()).unwrap(),
+            vec![]
+        );
         assert_eq!(
-            alloy_rlp::decode_exact::<Vec<AccountChanges>>(&decoded.0[2]).unwrap(),
+            alloy_rlp::decode_exact::<Vec<AccountChanges>>(decoded.0[3].as_ref().unwrap()).unwrap(),
             elaborate_account_changes(0x77)
         );
     }
@@ -212,7 +269,8 @@ mod tests {
     fn elaborate_block_access_lists_embed_raw_bal_payloads_without_reencoding() {
         let first = elaborate_bal_entry(0x21);
         let second = elaborate_bal_entry(0x42);
-        let encoded = alloy_rlp::encode(BlockAccessLists(vec![first.clone(), second.clone()]));
+        let encoded =
+            alloy_rlp::encode(BlockAccessLists(vec![Some(first.clone()), Some(second.clone())]));
 
         let header = alloy_rlp::Header::decode(&mut &encoded[..]).unwrap();
         let payload = &encoded[header.length()..];
diff --git a/crates/net/eth-wire-types/src/broadcast.rs b/crates/net/eth-wire-types/src/broadcast.rs
index aa939a152cd..1ae9f211045 100644
--- a/crates/net/eth-wire-types/src/broadcast.rs
+++ b/crates/net/eth-wire-types/src/broadcast.rs
@@ -3,8 +3,8 @@
 use crate::{EthMessage, EthVersion, NetworkPrimitives};
 use alloc::{sync::Arc, vec::Vec};
 use alloy_primitives::{
-    map::{HashMap, HashSet},
-    Bytes, TxHash, B256, U128,
+    map::{B256Map, B256Set},
+    Bytes, TxHash, B128, B256, U128,
 };
 use alloy_rlp::{
     Decodable, Encodable, Header, RlpDecodable, RlpDecodableWrapper, RlpEncodable,
@@ -211,10 +211,17 @@ pub struct SharedTransactions<T = TransactionSigned>(
 pub enum NewPooledTransactionHashes {
     /// A list of transaction hashes valid for [66-68)
     Eth66(NewPooledTransactionHashes66),
-    /// A list of transaction hashes valid from [68..]
+    /// A list of transaction hashes valid for [68-72)
     ///
     /// Note: it is assumed that the payload is valid (all vectors have the same length)
     Eth68(NewPooledTransactionHashes68),
+    /// A list of transaction hashes valid from [72..]
+    ///
+    /// This extends the eth/68 announcement payload with the `cell_mask` field introduced by
+    /// [EIP-8070](https://eips.ethereum.org/EIPS/eip-8070).
+    ///
+    /// Note: it is assumed that the payload is valid (all vectors have the same length)
+    Eth72(NewPooledTransactionHashes72),
 }
 
 // === impl NewPooledTransactionHashes ===
@@ -225,6 +232,7 @@ impl NewPooledTransactionHashes {
         match self {
             Self::Eth66(_) => EthVersion::Eth66,
             Self::Eth68(_) => EthVersion::Eth68,
+            Self::Eth72(_) => EthVersion::Eth72,
         }
     }
 
@@ -240,6 +248,9 @@ impl NewPooledTransactionHashes {
                     EthVersion::Eth68 | EthVersion::Eth69 | EthVersion::Eth70 | EthVersion::Eth71
                 )
             }
+            Self::Eth72(_) => {
+                matches!(version, EthVersion::Eth72)
+            }
         }
     }
 
@@ -248,6 +259,7 @@ impl NewPooledTransactionHashes {
         match self {
             Self::Eth66(msg) => msg.iter(),
             Self::Eth68(msg) => msg.hashes.iter(),
+            Self::Eth72(msg) => msg.hashes.iter(),
         }
     }
 
@@ -256,6 +268,7 @@ impl NewPooledTransactionHashes {
         match self {
             Self::Eth66(msg) => &msg.0,
             Self::Eth68(msg) => &msg.hashes,
+            Self::Eth72(msg) => &msg.hashes,
         }
     }
 
@@ -264,6 +277,7 @@ impl NewPooledTransactionHashes {
         match self {
             Self::Eth66(msg) => &mut msg.0,
             Self::Eth68(msg) => &mut msg.hashes,
+            Self::Eth72(msg) => &mut msg.hashes,
         }
     }
 
@@ -272,6 +286,7 @@ impl NewPooledTransactionHashes {
         match self {
             Self::Eth66(msg) => msg.0,
             Self::Eth68(msg) => msg.hashes,
+            Self::Eth72(msg) => msg.hashes,
         }
     }
 
@@ -280,6 +295,7 @@ impl NewPooledTransactionHashes {
         match self {
             Self::Eth66(msg) => msg.into_iter(),
             Self::Eth68(msg) => msg.hashes.into_iter(),
+            Self::Eth72(msg) => msg.hashes.into_iter(),
         }
     }
 
@@ -293,6 +309,11 @@ impl NewPooledTransactionHashes {
                 msg.sizes.truncate(len);
                 msg.hashes.truncate(len);
             }
+            Self::Eth72(msg) => {
+                msg.types.truncate(len);
+                msg.sizes.truncate(len);
+                msg.hashes.truncate(len);
+            }
         }
     }
 
@@ -301,6 +322,7 @@ impl NewPooledTransactionHashes {
         match self {
             Self::Eth66(msg) => msg.0.is_empty(),
             Self::Eth68(msg) => msg.hashes.is_empty(),
+            Self::Eth72(msg) => msg.hashes.is_empty(),
         }
     }
 
@@ -309,13 +331,30 @@ impl NewPooledTransactionHashes {
         match self {
             Self::Eth66(msg) => msg.0.len(),
             Self::Eth68(msg) => msg.hashes.len(),
+            Self::Eth72(msg) => msg.hashes.len(),
+        }
+    }
+
+    /// Returns an immutable reference to the inner type if this is an eth68 announcement.
+    pub const fn as_eth72(&self) -> Option<&NewPooledTransactionHashes72> {
+        match self {
+            Self::Eth66(_) | Self::Eth68(_) => None,
+            Self::Eth72(msg) => Some(msg),
+        }
+    }
+
+    /// Returns a mutable reference to the inner type if this is an eth68 announcement.
+    pub const fn as_eth72_mut(&mut self) -> Option<&mut NewPooledTransactionHashes72> {
+        match self {
+            Self::Eth66(_) | Self::Eth68(_) => None,
+            Self::Eth72(msg) => Some(msg),
         }
     }
 
     /// Returns an immutable reference to the inner type if this is an eth68 announcement.
     pub const fn as_eth68(&self) -> Option<&NewPooledTransactionHashes68> {
         match self {
-            Self::Eth66(_) => None,
+            Self::Eth66(_) | Self::Eth72(_) => None,
             Self::Eth68(msg) => Some(msg),
         }
     }
@@ -323,7 +362,7 @@ impl NewPooledTransactionHashes {
     /// Returns a mutable reference to the inner type if this is an eth68 announcement.
     pub const fn as_eth68_mut(&mut self) -> Option<&mut NewPooledTransactionHashes68> {
         match self {
-            Self::Eth66(_) => None,
+            Self::Eth66(_) | Self::Eth72(_) => None,
             Self::Eth68(msg) => Some(msg),
         }
     }
@@ -332,14 +371,14 @@ impl NewPooledTransactionHashes {
     pub const fn as_eth66_mut(&mut self) -> Option<&mut NewPooledTransactionHashes66> {
         match self {
             Self::Eth66(msg) => Some(msg),
-            Self::Eth68(_) => None,
+            Self::Eth68(_) | Self::Eth72(_) => None,
         }
     }
 
     /// Returns the inner type if this is an eth68 announcement.
     pub fn take_eth68(&mut self) -> Option<NewPooledTransactionHashes68> {
         match self {
-            Self::Eth66(_) => None,
+            Self::Eth66(_) | Self::Eth72(_) => None,
             Self::Eth68(msg) => Some(mem::take(msg)),
         }
     }
@@ -348,7 +387,7 @@ impl NewPooledTransactionHashes {
     pub fn take_eth66(&mut self) -> Option<NewPooledTransactionHashes66> {
         match self {
             Self::Eth66(msg) => Some(mem::take(msg)),
-            Self::Eth68(_) => None,
+            Self::Eth68(_) | Self::Eth72(_) => None,
         }
     }
 }
@@ -358,6 +397,7 @@ impl<N: NetworkPrimitives> From<NewPooledTransactionHashes> for EthMessage<N> {
         match value {
             NewPooledTransactionHashes::Eth66(msg) => Self::NewPooledTransactionHashes66(msg),
             NewPooledTransactionHashes::Eth68(msg) => Self::NewPooledTransactionHashes68(msg),
+            NewPooledTransactionHashes::Eth72(msg) => Self::NewPooledTransactionHashes72(msg),
         }
     }
 }
@@ -374,6 +414,12 @@ impl From<NewPooledTransactionHashes68> for NewPooledTransactionHashes {
     }
 }
 
+impl From<NewPooledTransactionHashes72> for NewPooledTransactionHashes {
+    fn from(hashes: NewPooledTransactionHashes72) -> Self {
+        Self::Eth72(hashes)
+    }
+}
+
 /// This informs peers of transaction hashes for transactions that have appeared on the network,
 /// but have not been included in a block.
 #[derive(
@@ -580,6 +626,184 @@ impl Decodable for NewPooledTransactionHashes68 {
     }
 }
 
+/// Same as [`NewPooledTransactionHashes68`] but adds the eth/72 `cell_mask` field from
+/// [EIP-8070](https://eips.ethereum.org/EIPS/eip-8070).
+#[derive(Clone, Debug, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct NewPooledTransactionHashes72 {
+    /// Transaction types for new transactions that have appeared on the network.
+    ///
+    /// ## Note on RLP encoding and decoding
+    ///
+    /// In the [eth/72 spec](https://eips.ethereum.org/EIPS/eip-8070#specification) this is defined
+    /// the following way:
+    ///  * `[types: B, [size_0: P, size_1: P, ...], [hash_0: B_32, hash_1: B_32, ...], cell_mask:
+    ///    B_16]`
+    pub types: Vec<u8>,
+    /// Transaction sizes for new transactions that have appeared on the network.
+    pub sizes: Vec<usize>,
+    /// Transaction hashes for new transactions that have appeared on the network.
+    pub hashes: Vec<B256>,
+    /// Cell availability mask for type 3 (blob) transactions announced by this message.
+    ///
+    /// Per [EIP-8070](https://eips.ethereum.org/EIPS/eip-8070), this is a `B_16`
+    /// bitarray over `CELLS_PER_EXT_BLOB`; bit `i` is set when the announcer has column
+    /// `i` available for every type 3 transaction in the message. `None` encodes as RLP
+    /// `nil` and must be used when no type 3 transactions are announced.
+    pub cell_mask: Option<B128>,
+}
+
+#[cfg(feature = "arbitrary")]
+impl proptest::prelude::Arbitrary for NewPooledTransactionHashes72 {
+    type Parameters = ();
+    fn arbitrary_with(_args: ()) -> Self::Strategy {
+        use proptest::{collection::vec, prelude::*};
+        // Generate a single random length for all vectors
+        let vec_length = any::<usize>().prop_map(|x| x % 100 + 1); // Lengths between 1 and 100
+
+        vec_length
+            .prop_flat_map(|len| {
+                // Use the generated length to create vectors of TxType, usize, and B256
+                let types_vec = vec(
+                    proptest_arbitrary_interop::arb::<reth_ethereum_primitives::TxType>()
+                        .prop_map(|ty| ty as u8),
+                    len..=len,
+                );
+
+                // Map the usize values to the range 0..131072(0x20000)
+                let sizes_vec = vec(proptest::num::usize::ANY.prop_map(|x| x % 131072), len..=len);
+                let hashes_vec = vec(any::<B256>(), len..=len);
+                let cell_mask = any::<Option<B128>>();
+
+                (types_vec, sizes_vec, hashes_vec, cell_mask)
+            })
+            .prop_map(|(types, sizes, hashes, cell_mask)| Self { types, sizes, hashes, cell_mask })
+            .boxed()
+    }
+
+    type Strategy = proptest::prelude::BoxedStrategy<Self>;
+}
+
+impl NewPooledTransactionHashes72 {
+    /// Returns an iterator over tx hashes zipped with corresponding metadata.
+    pub fn metadata_iter(&self) -> impl Iterator<Item = (&B256, (u8, usize))> {
+        self.hashes.iter().zip(self.types.iter().copied().zip(self.sizes.iter().copied()))
+    }
+
+    /// Appends a transaction
+    pub fn push<T: SignedTransaction>(&mut self, tx: &T) {
+        self.hashes.push(*tx.tx_hash());
+        self.sizes.push(tx.encode_2718_len());
+        self.types.push(tx.ty());
+    }
+
+    /// Appends the provided transactions
+    pub fn extend<'a, T: SignedTransaction>(&mut self, txs: impl IntoIterator<Item = &'a T>) {
+        for tx in txs {
+            self.push(tx);
+        }
+    }
+
+    /// Shrinks the capacity of the message vectors as much as possible.
+    pub fn shrink_to_fit(&mut self) {
+        self.hashes.shrink_to_fit();
+        self.sizes.shrink_to_fit();
+        self.types.shrink_to_fit()
+    }
+
+    /// Consumes and appends a transaction
+    pub fn with_transaction<T: SignedTransaction>(mut self, tx: &T) -> Self {
+        self.push(tx);
+        self
+    }
+
+    /// Consumes and appends the provided transactions
+    pub fn with_transactions<'a, T: SignedTransaction>(
+        mut self,
+        txs: impl IntoIterator<Item = &'a T>,
+    ) -> Self {
+        self.extend(txs);
+        self
+    }
+
+    fn payload_length(&self) -> usize {
+        self.types.as_slice().length() +
+            self.sizes.length() +
+            self.hashes.length() +
+            self.cell_mask.as_ref().map_or(1, Encodable::length)
+    }
+}
+
+impl Encodable for NewPooledTransactionHashes72 {
+    fn encode(&self, out: &mut dyn bytes::BufMut) {
+        Header { list: true, payload_length: self.payload_length() }.encode(out);
+        self.types.as_slice().encode(out);
+        self.sizes.encode(out);
+        self.hashes.encode(out);
+        if let Some(cell_mask) = &self.cell_mask {
+            cell_mask.encode(out);
+        } else {
+            out.put_u8(alloy_rlp::EMPTY_STRING_CODE);
+        }
+    }
+
+    fn length(&self) -> usize {
+        Header { list: true, payload_length: self.payload_length() }.length_with_payload()
+    }
+}
+
+impl Decodable for NewPooledTransactionHashes72 {
+    fn decode(buf: &mut &[u8]) -> alloy_rlp::Result<Self> {
+        let Header { list, payload_length } = Header::decode(buf)?;
+        if !list {
+            return Err(alloy_rlp::Error::UnexpectedString)
+        }
+        if buf.len() < payload_length {
+            return Err(alloy_rlp::Error::InputTooShort)
+        }
+
+        let (mut payload, rest) = buf.split_at(payload_length);
+        let types = Bytes::decode(&mut payload)?;
+        let sizes = Vec::<usize>::decode(&mut payload)?;
+        let hashes = Vec::<B256>::decode(&mut payload)?;
+        let Some(first_byte) = payload.first().copied() else {
+            return Err(alloy_rlp::Error::InputTooShort)
+        };
+        let cell_mask = if first_byte == alloy_rlp::EMPTY_STRING_CODE {
+            payload = &payload[1..];
+            None
+        } else {
+            Some(B128::decode(&mut payload)?)
+        };
+
+        if !payload.is_empty() {
+            return Err(alloy_rlp::Error::ListLengthMismatch {
+                expected: payload_length,
+                got: payload_length - payload.len(),
+            })
+        }
+
+        let msg = Self { types: types.into(), sizes, hashes, cell_mask };
+
+        if msg.hashes.len() != msg.types.len() {
+            return Err(alloy_rlp::Error::ListLengthMismatch {
+                expected: msg.hashes.len(),
+                got: msg.types.len(),
+            })
+        }
+        if msg.hashes.len() != msg.sizes.len() {
+            return Err(alloy_rlp::Error::ListLengthMismatch {
+                expected: msg.hashes.len(),
+                got: msg.sizes.len(),
+            })
+        }
+
+        *buf = rest;
+
+        Ok(msg)
+    }
+}
+
 /// Validation pass that checks for unique transaction hashes.
 pub trait DedupPayload {
     /// Value type in [`PartiallyValidData`] map.
@@ -613,10 +837,37 @@ impl DedupPayload for NewPooledTransactionHashes {
         match self {
             Self::Eth66(msg) => msg.dedup(),
             Self::Eth68(msg) => msg.dedup(),
+            Self::Eth72(msg) => msg.dedup(),
         }
     }
 }
 
+impl DedupPayload for NewPooledTransactionHashes72 {
+    type Value = Eth68TxMetadata;
+
+    fn is_empty(&self) -> bool {
+        self.hashes.is_empty()
+    }
+
+    fn len(&self) -> usize {
+        self.hashes.len()
+    }
+
+    fn dedup(self) -> PartiallyValidData<Self::Value> {
+        let Self { hashes, mut sizes, mut types, .. } = self;
+
+        let mut deduped_data = B256Map::with_capacity_and_hasher(hashes.len(), Default::default());
+
+        for hash in hashes.into_iter().rev() {
+            if let (Some(ty), Some(size)) = (types.pop(), sizes.pop()) {
+                deduped_data.insert(hash, Some((ty, size)));
+            }
+        }
+
+        PartiallyValidData::from_raw_data_eth72(deduped_data)
+    }
+}
+
 impl DedupPayload for NewPooledTransactionHashes68 {
     type Value = Eth68TxMetadata;
 
@@ -631,7 +882,7 @@ impl DedupPayload for NewPooledTransactionHashes68 {
     fn dedup(self) -> PartiallyValidData<Self::Value> {
         let Self { hashes, mut sizes, mut types } = self;
 
-        let mut deduped_data = HashMap::with_capacity_and_hasher(hashes.len(), Default::default());
+        let mut deduped_data = B256Map::with_capacity_and_hasher(hashes.len(), Default::default());
 
         for hash in hashes.into_iter().rev() {
             if let (Some(ty), Some(size)) = (types.pop(), sizes.pop()) {
@@ -657,7 +908,7 @@ impl DedupPayload for NewPooledTransactionHashes66 {
     fn dedup(self) -> PartiallyValidData<Self::Value> {
         let Self(hashes) = self;
 
-        let mut deduped_data = HashMap::with_capacity_and_hasher(hashes.len(), Default::default());
+        let mut deduped_data = B256Map::with_capacity_and_hasher(hashes.len(), Default::default());
 
         let noop_value: Eth68TxMetadata = None;
 
@@ -728,7 +979,7 @@ pub struct PartiallyValidData<V> {
     #[deref]
     #[deref_mut]
     #[into_iterator]
-    data: HashMap<TxHash, V>,
+    data: B256Map<V>,
     version: Option<EthVersion>,
 }
 
@@ -736,40 +987,51 @@ handle_mempool_data_map_impl!(PartiallyValidData<V>, <V>);
 
 impl<V> PartiallyValidData<V> {
     /// Wraps raw data.
-    pub const fn from_raw_data(data: HashMap<TxHash, V>, version: Option<EthVersion>) -> Self {
+    pub const fn from_raw_data(data: B256Map<V>, version: Option<EthVersion>) -> Self {
         Self { data, version }
     }
 
+    /// Wraps raw data with version [`EthVersion::Eth72`].
+    pub const fn from_raw_data_eth72(data: B256Map<V>) -> Self {
+        Self::from_raw_data(data, Some(EthVersion::Eth72))
+    }
+
     /// Wraps raw data with version [`EthVersion::Eth68`].
-    pub const fn from_raw_data_eth68(data: HashMap<TxHash, V>) -> Self {
+    pub const fn from_raw_data_eth68(data: B256Map<V>) -> Self {
         Self::from_raw_data(data, Some(EthVersion::Eth68))
     }
 
     /// Wraps raw data with version [`EthVersion::Eth66`].
-    pub const fn from_raw_data_eth66(data: HashMap<TxHash, V>) -> Self {
+    pub const fn from_raw_data_eth66(data: B256Map<V>) -> Self {
         Self::from_raw_data(data, Some(EthVersion::Eth66))
     }
 
+    /// Returns a new [`PartiallyValidData`] with empty data from an [`Eth72`](EthVersion::Eth72)
+    /// announcement.
+    pub fn empty_eth72() -> Self {
+        Self::from_raw_data_eth72(B256Map::default())
+    }
+
     /// Returns a new [`PartiallyValidData`] with empty data from an [`Eth68`](EthVersion::Eth68)
     /// announcement.
     pub fn empty_eth68() -> Self {
-        Self::from_raw_data_eth68(HashMap::default())
+        Self::from_raw_data_eth68(B256Map::default())
     }
 
     /// Returns a new [`PartiallyValidData`] with empty data from an [`Eth66`](EthVersion::Eth66)
     /// announcement.
     pub fn empty_eth66() -> Self {
-        Self::from_raw_data_eth66(HashMap::default())
+        Self::from_raw_data_eth66(B256Map::default())
     }
 
     /// Returns the version of the message this data was received in if different versions of the
-    /// message exists, either [`Eth66`](EthVersion::Eth66) or [`Eth68`](EthVersion::Eth68).
+    /// message exist.
     pub const fn msg_version(&self) -> Option<EthVersion> {
         self.version
     }
 
     /// Destructs returning the validated data.
-    pub fn into_data(self) -> HashMap<TxHash, V> {
+    pub fn into_data(self) -> B256Map<V> {
         self.data
     }
 }
@@ -781,7 +1043,7 @@ pub struct ValidAnnouncementData {
     #[deref]
     #[deref_mut]
     #[into_iterator]
-    data: HashMap<TxHash, Eth68TxMetadata>,
+    data: B256Map<Eth68TxMetadata>,
     version: EthVersion,
 }
 
@@ -791,7 +1053,7 @@ impl ValidAnnouncementData {
     /// Destructs returning only the valid hashes and the announcement message version. Caution! If
     /// this is [`Eth68`](EthVersion::Eth68) announcement data, this drops the metadata.
     pub fn into_request_hashes(self) -> (RequestTxHashes, EthVersion) {
-        let hashes = self.data.into_keys().collect::<HashSet<_>>();
+        let hashes = self.data.into_keys().collect::<B256Set>();
 
         (RequestTxHashes::new(hashes), self.version)
     }
@@ -808,7 +1070,7 @@ impl ValidAnnouncementData {
     }
 
     /// Destructs returning the validated data.
-    pub fn into_data(self) -> HashMap<TxHash, Eth68TxMetadata> {
+    pub fn into_data(self) -> B256Map<Eth68TxMetadata> {
         self.data
     }
 }
@@ -825,21 +1087,21 @@ pub struct RequestTxHashes {
     #[deref]
     #[deref_mut]
     #[into_iterator(owned, ref)]
-    hashes: HashSet<TxHash>,
+    hashes: B256Set,
 }
 
 impl RequestTxHashes {
     /// Returns a new [`RequestTxHashes`] with given capacity for hashes. Caution! Make sure to
-    /// call [`HashSet::shrink_to_fit`] on [`RequestTxHashes`] when full, especially where it will
+    /// call `shrink_to_fit` on [`RequestTxHashes`] when full, especially where it will
     /// be stored in its entirety like in the future waiting for a
     /// [`GetPooledTransactions`](crate::GetPooledTransactions) request to resolve.
     pub fn with_capacity(capacity: usize) -> Self {
-        Self::new(HashSet::with_capacity_and_hasher(capacity, Default::default()))
+        Self::new(B256Set::with_capacity_and_hasher(capacity, Default::default()))
     }
 
     /// Returns a new empty instance.
     fn empty() -> Self {
-        Self::new(HashSet::default())
+        Self::new(B256Set::default())
     }
 
     /// Retains the given number of elements, returning an iterator over the rest.
@@ -894,6 +1156,12 @@ impl InMemorySize for NewPooledTransactionHashes {
                     msg.sizes.len() * core::mem::size_of::<usize>() +
                     msg.hashes.len() * core::mem::size_of::<B256>()
             }
+            Self::Eth72(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>() +
+                    core::mem::size_of::<B128>()
+            }
         }
     }
 }
@@ -1073,6 +1341,43 @@ mod tests {
         }
     }
 
+    #[test]
+    fn eth_72_tx_hash_roundtrip() {
+        let vectors = vec![
+            (
+                NewPooledTransactionHashes72 {
+                    types: vec![],
+                    sizes: vec![],
+                    hashes: vec![],
+                    cell_mask: None,
+                },
+                &hex!("c480c0c080")[..],
+            ),
+            (
+                NewPooledTransactionHashes72 {
+                    types: vec![],
+                    sizes: vec![],
+                    hashes: vec![],
+                    cell_mask: Some(B128::repeat_byte(0x11)),
+                },
+                &hex!("d480c0c09011111111111111111111111111111111")[..],
+            ),
+        ];
+
+        for vector in vectors {
+            test_encoding_vector(vector);
+        }
+    }
+
+    #[test]
+    fn eth_72_rejects_missing_cell_mask() {
+        let encoded_eth68_payload = hex!("c380c0c0");
+
+        let result = NewPooledTransactionHashes72::decode(&mut encoded_eth68_payload.as_ref());
+
+        assert!(matches!(result, Err(alloy_rlp::Error::InputTooShort)));
+    }
+
     #[test]
     fn request_hashes_retain_count_keep_subset() {
         let mut hashes = RequestTxHashes::new(
@@ -1084,7 +1389,7 @@ mod tests {
                 b256!("0x0000000000000000000000000000000000000000000000000000000000000005"),
             ]
             .into_iter()
-            .collect::<HashSet<_>>(),
+            .collect::<B256Set>(),
         );
 
         let rest = hashes.retain_count(3);
@@ -1104,7 +1409,7 @@ mod tests {
                 b256!("0x0000000000000000000000000000000000000000000000000000000000000005"),
             ]
             .into_iter()
-            .collect::<HashSet<_>>(),
+            .collect::<B256Set>(),
         );
 
         let _ = hashes.retain_count(6);
@@ -1123,7 +1428,7 @@ mod tests {
                 b256!("0x0000000000000000000000000000000000000000000000000000000000000005"),
             ]
             .into_iter()
-            .collect::<HashSet<_>>(),
+            .collect::<B256Set>(),
         );
 
         let rest = hashes.retain_count(0);
diff --git a/crates/net/eth-wire-types/src/capability.rs b/crates/net/eth-wire-types/src/capability.rs
index 69c64038e74..4a94f4e3533 100644
--- a/crates/net/eth-wire-types/src/capability.rs
+++ b/crates/net/eth-wire-types/src/capability.rs
@@ -120,6 +120,11 @@ impl Capability {
         Self::eth(EthVersion::Eth71)
     }
 
+    /// Returns the [`EthVersion::Eth72`] capability.
+    pub const fn eth_72() -> Self {
+        Self::eth(EthVersion::Eth72)
+    }
+
     /// Returns the `snap/1` capability.
     pub const fn snap_1() -> Self {
         Self::snap(SnapVersion::V1)
@@ -166,6 +171,12 @@ impl Capability {
         self.name == "eth" && self.version == 71
     }
 
+    /// Whether this is eth v72.
+    #[inline]
+    pub fn is_eth_v72(&self) -> bool {
+        self.name == "eth" && self.version == 72
+    }
+
     /// Whether this is any eth version.
     #[inline]
     pub fn is_eth(&self) -> bool {
@@ -174,7 +185,8 @@ impl Capability {
             self.is_eth_v68() ||
             self.is_eth_v69() ||
             self.is_eth_v70() ||
-            self.is_eth_v71()
+            self.is_eth_v71() ||
+            self.is_eth_v72()
     }
 }
 
@@ -211,6 +223,7 @@ pub struct Capabilities {
     eth_69: bool,
     eth_70: bool,
     eth_71: bool,
+    eth_72: bool,
 }
 
 impl Capabilities {
@@ -223,6 +236,7 @@ impl Capabilities {
             eth_69: value.iter().any(Capability::is_eth_v69),
             eth_70: value.iter().any(Capability::is_eth_v70),
             eth_71: value.iter().any(Capability::is_eth_v71),
+            eth_72: value.iter().any(Capability::is_eth_v72),
             inner: value,
         }
     }
@@ -244,15 +258,24 @@ impl Capabilities {
                     self.eth_68 ||
                     self.eth_69 ||
                     self.eth_70 ||
-                    self.eth_71
+                    self.eth_71 ||
+                    self.eth_72
             }
             EthVersion::Eth67 => {
-                self.eth_67 || self.eth_68 || self.eth_69 || self.eth_70 || self.eth_71
+                self.eth_67 ||
+                    self.eth_68 ||
+                    self.eth_69 ||
+                    self.eth_70 ||
+                    self.eth_71 ||
+                    self.eth_72
+            }
+            EthVersion::Eth68 => {
+                self.eth_68 || self.eth_69 || self.eth_70 || self.eth_71 || self.eth_72
             }
-            EthVersion::Eth68 => self.eth_68 || self.eth_69 || self.eth_70 || self.eth_71,
-            EthVersion::Eth69 => self.eth_69 || self.eth_70 || self.eth_71,
-            EthVersion::Eth70 => self.eth_70 || self.eth_71,
-            EthVersion::Eth71 => self.eth_71,
+            EthVersion::Eth69 => self.eth_69 || self.eth_70 || self.eth_71 || self.eth_72,
+            EthVersion::Eth70 => self.eth_70 || self.eth_71 || self.eth_72,
+            EthVersion::Eth71 => self.eth_71 || self.eth_72,
+            EthVersion::Eth72 => self.eth_72,
         }
     }
 
@@ -271,7 +294,13 @@ impl Capabilities {
     /// Whether the peer supports `eth` sub-protocol.
     #[inline]
     pub const fn supports_eth(&self) -> bool {
-        self.eth_71 || self.eth_70 || self.eth_69 || self.eth_68 || self.eth_67 || self.eth_66
+        self.eth_72 ||
+            self.eth_71 ||
+            self.eth_70 ||
+            self.eth_69 ||
+            self.eth_68 ||
+            self.eth_67 ||
+            self.eth_66
     }
 
     /// Whether this peer supports eth v66 protocol.
@@ -334,6 +363,7 @@ impl Decodable for Capabilities {
             eth_69: inner.iter().any(Capability::is_eth_v69),
             eth_70: inner.iter().any(Capability::is_eth_v70),
             eth_71: inner.iter().any(Capability::is_eth_v71),
+            eth_72: inner.iter().any(Capability::is_eth_v72),
             inner,
         })
     }
diff --git a/crates/net/eth-wire-types/src/message.rs b/crates/net/eth-wire-types/src/message.rs
index c07dcc8c408..c6eb68f970b 100644
--- a/crates/net/eth-wire-types/src/message.rs
+++ b/crates/net/eth-wire-types/src/message.rs
@@ -13,8 +13,9 @@ use super::{
     PooledTransactions, Receipts, Status, StatusEth69, Transactions,
 };
 use crate::{
-    status::StatusMessage, BlockRangeUpdate, EthNetworkPrimitives, EthVersion, NetworkPrimitives,
-    RawCapabilityMessage, Receipts69, Receipts70, SharedTransactions,
+    status::StatusMessage, BlockRangeUpdate, Cells, EthNetworkPrimitives, EthVersion, GetCells,
+    NetworkPrimitives, NewPooledTransactionHashes72, RawCapabilityMessage, Receipts69, Receipts70,
+    SharedTransactions,
 };
 use alloc::{boxed::Box, string::String, sync::Arc};
 use alloy_primitives::{
@@ -129,7 +130,11 @@ impl<N: NetworkPrimitives> ProtocolMessage<N> {
                 Transactions::decode_with_memory_budget(buf, tx_memory_budget)?,
             ),
             EthMessageID::NewPooledTransactionHashes => {
-                if version >= EthVersion::Eth68 {
+                if version >= EthVersion::Eth72 {
+                    EthMessage::NewPooledTransactionHashes72(NewPooledTransactionHashes72::decode(
+                        buf,
+                    )?)
+                } else if version >= EthVersion::Eth68 {
                     EthMessage::NewPooledTransactionHashes68(NewPooledTransactionHashes68::decode(
                         buf,
                     )?)
@@ -206,6 +211,18 @@ impl<N: NetworkPrimitives> ProtocolMessage<N> {
                 }
                 EthMessage::BlockAccessLists(RequestPair::decode(buf)?)
             }
+            EthMessageID::Cells => {
+                if version < EthVersion::Eth72 {
+                    return Err(MessageError::Invalid(version, EthMessageID::Cells))
+                }
+                EthMessage::Cells(RequestPair::decode(buf)?)
+            }
+            EthMessageID::GetCells => {
+                if version < EthVersion::Eth72 {
+                    return Err(MessageError::Invalid(version, EthMessageID::GetCells))
+                }
+                EthMessage::GetCells(RequestPair::decode(buf)?)
+            }
             EthMessageID::Other(_) => {
                 let raw_payload = Bytes::copy_from_slice(buf);
                 buf.advance(raw_payload.len());
@@ -313,6 +330,9 @@ pub enum EthMessage<N: NetworkPrimitives = EthNetworkPrimitives> {
     NewPooledTransactionHashes66(NewPooledTransactionHashes66),
     /// Represents a `NewPooledTransactionHashes` message for eth/68 version.
     NewPooledTransactionHashes68(NewPooledTransactionHashes68),
+    /// Represents a `NewPooledTransactionHashes` message for eth/72 version.
+    NewPooledTransactionHashes72(NewPooledTransactionHashes72),
+
     // The following messages are request-response message pairs
     /// Represents a `GetBlockHeaders` request-response pair.
     GetBlockHeaders(RequestPair<GetBlockHeaders>),
@@ -376,6 +396,10 @@ pub enum EthMessage<N: NetworkPrimitives = EthNetworkPrimitives> {
     Receipts70(RequestPair<Receipts70<N::Receipt>>),
     /// Represents a `BlockAccessLists` request-response pair for eth/71.
     BlockAccessLists(RequestPair<BlockAccessLists>),
+    /// Represents a `Cells` request-response pair for eth/72.
+    Cells(RequestPair<Cells>),
+    /// Represents a `GetCells` request-response pair for eth/72.
+    GetCells(RequestPair<GetCells>),
     /// Represents a `BlockRangeUpdate` message broadcast to the network.
     #[cfg_attr(
         feature = "serde",
@@ -394,9 +418,9 @@ impl<N: NetworkPrimitives> EthMessage<N> {
             Self::NewBlockHashes(_) => EthMessageID::NewBlockHashes,
             Self::NewBlock(_) => EthMessageID::NewBlock,
             Self::Transactions(_) => EthMessageID::Transactions,
-            Self::NewPooledTransactionHashes66(_) | Self::NewPooledTransactionHashes68(_) => {
-                EthMessageID::NewPooledTransactionHashes
-            }
+            Self::NewPooledTransactionHashes66(_) |
+            Self::NewPooledTransactionHashes68(_) |
+            Self::NewPooledTransactionHashes72(_) => EthMessageID::NewPooledTransactionHashes,
             Self::GetBlockHeaders(_) => EthMessageID::GetBlockHeaders,
             Self::BlockHeaders(_) => EthMessageID::BlockHeaders,
             Self::GetBlockBodies(_) => EthMessageID::GetBlockBodies,
@@ -410,6 +434,8 @@ impl<N: NetworkPrimitives> EthMessage<N> {
             Self::BlockRangeUpdate(_) => EthMessageID::BlockRangeUpdate,
             Self::GetBlockAccessLists(_) => EthMessageID::GetBlockAccessLists,
             Self::BlockAccessLists(_) => EthMessageID::BlockAccessLists,
+            Self::Cells(_) => EthMessageID::Cells,
+            Self::GetCells(_) => EthMessageID::GetCells,
             Self::Other(msg) => EthMessageID::Other(msg.id as u8),
         }
     }
@@ -423,6 +449,7 @@ impl<N: NetworkPrimitives> EthMessage<N> {
                 Self::GetReceipts(_) |
                 Self::GetReceipts70(_) |
                 Self::GetBlockAccessLists(_) |
+                Self::GetCells(_) |
                 Self::GetPooledTransactions(_) |
                 Self::GetNodeData(_)
         )
@@ -439,7 +466,8 @@ impl<N: NetworkPrimitives> EthMessage<N> {
                 Self::BlockAccessLists(_) |
                 Self::BlockHeaders(_) |
                 Self::BlockBodies(_) |
-                Self::NodeData(_)
+                Self::NodeData(_) |
+                Self::Cells(_)
         )
     }
 
@@ -481,6 +509,7 @@ impl<N: NetworkPrimitives> Encodable for EthMessage<N> {
             Self::Transactions(transactions) => transactions.encode(out),
             Self::NewPooledTransactionHashes66(hashes) => hashes.encode(out),
             Self::NewPooledTransactionHashes68(hashes) => hashes.encode(out),
+            Self::NewPooledTransactionHashes72(hashes) => hashes.encode(out),
             Self::GetBlockHeaders(request) => request.encode(out),
             Self::BlockHeaders(headers) => headers.encode(out),
             Self::GetBlockBodies(request) => request.encode(out),
@@ -492,11 +521,13 @@ impl<N: NetworkPrimitives> Encodable for EthMessage<N> {
             Self::GetReceipts(request) => request.encode(out),
             Self::GetReceipts70(request) => request.encode(out),
             Self::GetBlockAccessLists(request) => request.encode(out),
+            Self::GetCells(request) => request.encode(out),
             Self::Receipts(receipts) => receipts.encode(out),
             Self::Receipts69(receipt69) => receipt69.encode(out),
             Self::Receipts70(receipt70) => receipt70.encode(out),
             Self::BlockAccessLists(block_access_lists) => block_access_lists.encode(out),
             Self::BlockRangeUpdate(block_range_update) => block_range_update.encode(out),
+            Self::Cells(cells) => cells.encode(out),
             Self::Other(unknown) => out.put_slice(&unknown.payload),
         }
     }
@@ -508,6 +539,7 @@ impl<N: NetworkPrimitives> Encodable for EthMessage<N> {
             Self::Transactions(transactions) => transactions.length(),
             Self::NewPooledTransactionHashes66(hashes) => hashes.length(),
             Self::NewPooledTransactionHashes68(hashes) => hashes.length(),
+            Self::NewPooledTransactionHashes72(hashes) => hashes.length(),
             Self::GetBlockHeaders(request) => request.length(),
             Self::BlockHeaders(headers) => headers.length(),
             Self::GetBlockBodies(request) => request.length(),
@@ -519,11 +551,13 @@ impl<N: NetworkPrimitives> Encodable for EthMessage<N> {
             Self::GetReceipts(request) => request.length(),
             Self::GetReceipts70(request) => request.length(),
             Self::GetBlockAccessLists(request) => request.length(),
+            Self::GetCells(request) => request.length(),
             Self::Receipts(receipts) => receipts.length(),
             Self::Receipts69(receipt69) => receipt69.length(),
             Self::Receipts70(receipt70) => receipt70.length(),
             Self::BlockAccessLists(block_access_lists) => block_access_lists.length(),
             Self::BlockRangeUpdate(block_range_update) => block_range_update.length(),
+            Self::Cells(cells) => cells.length(),
             Self::Other(unknown) => unknown.length(),
         }
     }
@@ -619,6 +653,15 @@ pub enum EthMessageID {
     ///
     /// Introduced in Eth71
     BlockAccessLists = 0x13,
+
+    /// Requests cells.
+    ///
+    /// Introduced in Eth72
+    GetCells = 0x14,
+    /// Represents Cells
+    ///
+    /// Introduced in Eth72
+    Cells = 0x15,
     /// Represents unknown message types.
     Other(u8),
 }
@@ -645,13 +688,17 @@ impl EthMessageID {
             Self::BlockRangeUpdate => 0x11,
             Self::GetBlockAccessLists => 0x12,
             Self::BlockAccessLists => 0x13,
+            Self::GetCells => 0x14,
+            Self::Cells => 0x15,
             Self::Other(value) => *value, // Return the stored `u8`
         }
     }
 
     /// Returns the max value for the given version.
     pub const fn max(version: EthVersion) -> u8 {
-        if version.is_eth71() {
+        if version.is_eth72() {
+            Self::Cells.to_u8()
+        } else if version.is_eth71() {
             Self::BlockAccessLists.to_u8()
         } else if version.is_eth69_or_newer() {
             Self::BlockRangeUpdate.to_u8()
@@ -700,6 +747,8 @@ impl Decodable for EthMessageID {
             0x11 => Self::BlockRangeUpdate,
             0x12 => Self::GetBlockAccessLists,
             0x13 => Self::BlockAccessLists,
+            0x14 => Self::GetCells,
+            0x15 => Self::Cells,
             unknown => Self::Other(*unknown),
         };
         buf.advance(1);
@@ -730,6 +779,8 @@ impl TryFrom<usize> for EthMessageID {
             0x11 => Ok(Self::BlockRangeUpdate),
             0x12 => Ok(Self::GetBlockAccessLists),
             0x13 => Ok(Self::BlockAccessLists),
+            0x14 => Ok(Self::GetCells),
+            0x15 => Ok(Self::Cells),
             _ => Err("Invalid message ID"),
         }
     }
diff --git a/crates/net/eth-wire-types/src/snap.rs b/crates/net/eth-wire-types/src/snap.rs
index 5db75a08bbb..74115c233a1 100644
--- a/crates/net/eth-wire-types/src/snap.rs
+++ b/crates/net/eth-wire-types/src/snap.rs
@@ -511,8 +511,8 @@ mod tests {
         test_roundtrip(SnapProtocolMessage::BlockAccessLists(BlockAccessListsMessage {
             request_id: 42,
             block_access_lists: BlockAccessLists(vec![
-                Bytes::from_static(&[alloy_rlp::EMPTY_LIST_CODE]),
-                Bytes::from_static(&[0xc1, alloy_rlp::EMPTY_LIST_CODE]),
+                Some(Bytes::from_static(&[alloy_rlp::EMPTY_LIST_CODE])),
+                Some(Bytes::from_static(&[0xc1, alloy_rlp::EMPTY_LIST_CODE])),
             ]),
         }));
     }
diff --git a/crates/net/eth-wire-types/src/transactions.rs b/crates/net/eth-wire-types/src/transactions.rs
index 730a1bbf8d5..ebfe4f4e4ad 100644
--- a/crates/net/eth-wire-types/src/transactions.rs
+++ b/crates/net/eth-wire-types/src/transactions.rs
@@ -2,10 +2,10 @@
 
 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_consensus::transaction::{PooledTransaction, TxHashRef};
+use alloy_eips::eip7594::Cell;
+use alloy_primitives::{B128, B256};
+use alloy_rlp::{Decodable, RlpDecodable, RlpDecodableWrapper, RlpEncodable, RlpEncodableWrapper};
 use derive_more::{Constructor, Deref, IntoIterator};
 use reth_codecs_derive::add_arbitrary_tests;
 use reth_primitives_traits::InMemorySize;
@@ -82,10 +82,10 @@ impl<T: Decodable + InMemorySize> PooledTransactions<T> {
     }
 }
 
-impl<T: Encodable2718> PooledTransactions<T> {
+impl<T: TxHashRef> PooledTransactions<T> {
     /// Returns an iterator over the transaction hashes in this response.
     pub fn hashes(&self) -> impl Iterator<Item = B256> + '_ {
-        self.iter().map(|tx| tx.trie_hash())
+        self.iter().map(|tx| *tx.tx_hash())
     }
 }
 
@@ -112,6 +112,39 @@ impl<T> Default for PooledTransactions<T> {
     }
 }
 
+/// A list of transaction hashes and the cell indices requested for each transaction.
+///
+/// See [EIP-8070]: Sparse Blobpool
+///
+/// [EIP-8070]: https://eips.ethereum.org/EIPS/eip-8070
+#[derive(Clone, Debug, PartialEq, Eq, RlpEncodable, RlpDecodable, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct GetCells {
+    /// Transaction hashes to request cells for.
+    pub hashes: Vec<B256>,
+    /// Requested cell indices, encoded with the same syntax as the `cell_mask` in
+    /// `NewPooledTransactionHashes`.
+    pub cell_mask: B128,
+}
+
+impl InMemorySize for GetCells {
+    fn size(&self) -> usize {
+        self.hashes.len() * core::mem::size_of::<B256>() + core::mem::size_of::<B128>()
+    }
+}
+
+/// The response to [`GetCells`], containing requested cells for each transaction hash.
+#[derive(Clone, Debug, PartialEq, Eq, RlpEncodable, RlpDecodable, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Cells {
+    /// Transaction hashes corresponding to the returned cell lists.
+    pub hashes: Vec<B256>,
+    /// Requested cells for each transaction hash.
+    pub cells: Vec<Vec<Cell>>,
+    /// Cell indices included in each cell list.
+    pub cell_mask: B128,
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{message::RequestPair, GetPooledTransactions, PooledTransactions};
diff --git a/crates/net/eth-wire-types/src/version.rs b/crates/net/eth-wire-types/src/version.rs
index d9921c44b9c..b5eecfa0081 100644
--- a/crates/net/eth-wire-types/src/version.rs
+++ b/crates/net/eth-wire-types/src/version.rs
@@ -31,6 +31,8 @@ pub enum EthVersion {
     Eth70 = 70,
     /// The `eth` protocol version 71.
     Eth71 = 71,
+    /// The `eth` protocol version 72.
+    Eth72 = 72,
 }
 
 impl EthVersion {
@@ -55,6 +57,11 @@ impl EthVersion {
         matches!(self, Self::Eth68)
     }
 
+    /// Returns true if the version carries eth/68 transaction announcement metadata.
+    pub const fn has_eth68_metadata(&self) -> bool {
+        matches!(self, Self::Eth68 | Self::Eth69 | Self::Eth70 | Self::Eth71 | Self::Eth72)
+    }
+
     /// Returns true if the version is eth/69
     pub const fn is_eth69(&self) -> bool {
         matches!(self, Self::Eth69)
@@ -70,9 +77,14 @@ impl EthVersion {
         matches!(self, Self::Eth71)
     }
 
+    /// Returns true if the version is eth/72
+    pub const fn is_eth72(&self) -> bool {
+        matches!(self, Self::Eth72)
+    }
+
     /// Returns true if the version is eth/69 or newer.
     pub const fn is_eth69_or_newer(&self) -> bool {
-        matches!(self, Self::Eth69 | Self::Eth70 | Self::Eth71)
+        matches!(self, Self::Eth69 | Self::Eth70 | Self::Eth71 | Self::Eth72)
     }
 }
 
@@ -117,6 +129,7 @@ impl TryFrom<&str> for EthVersion {
             "69" => Ok(Self::Eth69),
             "70" => Ok(Self::Eth70),
             "71" => Ok(Self::Eth71),
+            "72" => Ok(Self::Eth72),
             _ => Err(ParseVersionError(s.to_string())),
         }
     }
@@ -143,6 +156,7 @@ impl TryFrom<u8> for EthVersion {
             69 => Ok(Self::Eth69),
             70 => Ok(Self::Eth70),
             71 => Ok(Self::Eth71),
+            72 => Ok(Self::Eth72),
             _ => Err(ParseVersionError(u.to_string())),
         }
     }
@@ -174,6 +188,7 @@ impl From<EthVersion> for &'static str {
             EthVersion::Eth69 => "69",
             EthVersion::Eth70 => "70",
             EthVersion::Eth71 => "71",
+            EthVersion::Eth72 => "72",
         }
     }
 }
@@ -232,6 +247,7 @@ mod tests {
         assert_eq!(EthVersion::Eth69, EthVersion::try_from("69").unwrap());
         assert_eq!(EthVersion::Eth70, EthVersion::try_from("70").unwrap());
         assert_eq!(EthVersion::Eth71, EthVersion::try_from("71").unwrap());
+        assert_eq!(EthVersion::Eth72, EthVersion::try_from("72").unwrap());
     }
 
     #[test]
@@ -242,6 +258,18 @@ mod tests {
         assert_eq!(EthVersion::Eth69, "69".parse().unwrap());
         assert_eq!(EthVersion::Eth70, "70".parse().unwrap());
         assert_eq!(EthVersion::Eth71, "71".parse().unwrap());
+        assert_eq!(EthVersion::Eth72, "72".parse().unwrap());
+    }
+
+    #[test]
+    fn test_has_eth68_metadata() {
+        assert!(!EthVersion::Eth66.has_eth68_metadata());
+        assert!(!EthVersion::Eth67.has_eth68_metadata());
+        assert!(EthVersion::Eth68.has_eth68_metadata());
+        assert!(EthVersion::Eth69.has_eth68_metadata());
+        assert!(EthVersion::Eth70.has_eth68_metadata());
+        assert!(EthVersion::Eth71.has_eth68_metadata());
+        assert!(EthVersion::Eth72.has_eth68_metadata());
     }
 
     #[test]
@@ -253,6 +281,7 @@ mod tests {
             EthVersion::Eth69,
             EthVersion::Eth70,
             EthVersion::Eth71,
+            EthVersion::Eth72,
         ];
 
         for version in versions {
@@ -272,6 +301,7 @@ mod tests {
             (69_u8, Ok(EthVersion::Eth69)),
             (70_u8, Ok(EthVersion::Eth70)),
             (71_u8, Ok(EthVersion::Eth71)),
+            (72_u8, Ok(EthVersion::Eth72)),
             (65_u8, Err(RlpError::Custom("invalid eth version"))),
         ];
 
diff --git a/crates/net/eth-wire/src/capability.rs b/crates/net/eth-wire/src/capability.rs
index 9691acb4399..475e85e6158 100644
--- a/crates/net/eth-wire/src/capability.rs
+++ b/crates/net/eth-wire/src/capability.rs
@@ -188,6 +188,34 @@ impl SharedCapabilities {
         self.0.iter().find(|c| c.version() == cap.version as u8 && c.name() == cap.name)
     }
 
+    /// Converts a capability-local message ID into the relative `RLPx` message ID used by
+    /// [`P2PStream`](crate::P2PStream).
+    ///
+    /// `P2PStream` strips the reserved p2p message ID range before yielding subprotocol messages,
+    /// so the returned ID is relative to the first shared capability, not the absolute wire ID.
+    #[inline]
+    pub fn relative_message_id(&self, cap: &Capability, message_id: u8) -> Option<u8> {
+        let shared = self.find(cap)?;
+        if message_id >= shared.num_messages() {
+            return None
+        }
+
+        shared.relative_message_id_offset().checked_add(message_id)
+    }
+
+    /// Converts a relative `RLPx` message ID back into the message ID local to `cap`.
+    ///
+    /// Returns `None` if `cap` is not shared, if the relative ID belongs to a different
+    /// capability, or if it is outside the capability's negotiated message range.
+    #[inline]
+    pub fn capability_message_id(&self, cap: &Capability, relative_message_id: u8) -> Option<u8> {
+        let shared = self.find(cap)?;
+        let start = shared.relative_message_id_offset();
+        let end = start.checked_add(shared.num_messages())?;
+
+        (start..end).contains(&relative_message_id).then(|| relative_message_id - start)
+    }
+
     /// Returns the matching shared capability for the given capability offset.
     ///
     /// `offset` is the multiplexed message id offset of the capability relative to the reserved
@@ -362,7 +390,7 @@ impl UnsupportedCapabilityError {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{Capabilities, Capability};
+    use crate::{Capabilities, Capability, SnapVersion};
     use alloy_primitives::bytes::Bytes;
     use alloy_rlp::{Decodable, Encodable};
     use reth_eth_wire_types::RawCapabilityMessage;
@@ -530,6 +558,40 @@ mod tests {
         assert_eq!(shared_eth.name(), "eth");
     }
 
+    #[test]
+    fn relative_message_id_accounts_for_intermediate_capabilities() {
+        let intermediate_cap = Capability::new_static("foo", 1);
+        let intermediate = Protocol::new(intermediate_cap.clone(), 3);
+        let snap = Capability::snap(SnapVersion::V1);
+        let eth = Capability::eth(EthVersion::Eth69);
+        let local_capabilities =
+            vec![EthVersion::Eth69.into(), intermediate, Protocol::snap(SnapVersion::V1)];
+        let peer_capabilities = vec![eth, intermediate_cap, snap.clone()];
+
+        let shared = SharedCapabilities::try_new(local_capabilities, peer_capabilities).unwrap();
+        let snap_id = shared.relative_message_id(&snap, 2).unwrap();
+
+        assert_eq!(snap_id, EthMessageID::message_count(EthVersion::Eth69) + 3 + 2);
+        assert_eq!(shared.capability_message_id(&snap, snap_id), Some(2));
+    }
+
+    #[test]
+    fn capability_message_id_rejects_other_capability_range() {
+        let intermediate_cap = Capability::new_static("foo", 1);
+        let intermediate = Protocol::new(intermediate_cap.clone(), 3);
+        let snap = Capability::snap(SnapVersion::V1);
+        let local_capabilities =
+            vec![EthVersion::Eth69.into(), intermediate, Protocol::snap(SnapVersion::V1)];
+        let peer_capabilities =
+            vec![Capability::eth(EthVersion::Eth69), intermediate_cap.clone(), snap.clone()];
+
+        let shared = SharedCapabilities::try_new(local_capabilities, peer_capabilities).unwrap();
+        let intermediate_id = shared.relative_message_id(&intermediate_cap, 1).unwrap();
+
+        assert_eq!(shared.capability_message_id(&snap, intermediate_id), None);
+        assert_eq!(shared.relative_message_id(&snap, SnapVersion::V1.message_count()), None);
+    }
+
     #[test]
     fn test_raw_capability_rlp() {
         let msg = RawCapabilityMessage { id: 1, payload: Bytes::from(vec![0x01, 0x02, 0x03]) };
diff --git a/crates/net/eth-wire/src/eth_snap_stream.rs b/crates/net/eth-wire/src/eth_snap_stream.rs
index 986d3dd8c5d..49a35b04497 100644
--- a/crates/net/eth-wire/src/eth_snap_stream.rs
+++ b/crates/net/eth-wire/src/eth_snap_stream.rs
@@ -575,9 +575,9 @@ mod tests {
         let inner = EthSnapStreamInner::<EthNetworkPrimitives>::new(EthVersion::Eth67);
         let snap2_msg = SnapProtocolMessage::BlockAccessLists(BlockAccessListsMessage {
             request_id: 1,
-            block_access_lists: BlockAccessLists(vec![alloy_primitives::Bytes::from_static(&[
-                alloy_rlp::EMPTY_LIST_CODE,
-            ])]),
+            block_access_lists: BlockAccessLists(vec![Some(alloy_primitives::Bytes::from_static(
+                &[alloy_rlp::EMPTY_LIST_CODE],
+            ))]),
         });
 
         let encoded = EthSnapStreamInner::<EthNetworkPrimitives>::new_with_snap_version(
diff --git a/crates/net/eth-wire/src/multiplex.rs b/crates/net/eth-wire/src/multiplex.rs
index 18252924743..50e7983d7e2 100644
--- a/crates/net/eth-wire/src/multiplex.rs
+++ b/crates/net/eth-wire/src/multiplex.rs
@@ -103,6 +103,7 @@ impl<St> RlpxProtocolMultiplexer<St> {
                 st,
                 shared_cap,
             },
+            next_outbound: 0,
         })
     }
 
@@ -197,15 +198,19 @@ impl<St> RlpxProtocolMultiplexer<St> {
                 }
                 res = &mut f => {
                     let (st, extra) = res?;
-                    return Ok((RlpxSatelliteStream {
+                    return Ok((
+                        RlpxSatelliteStream {
                             inner: self.inner,
                             primary: PrimaryProtocol {
                                 to_primary,
                                 from_primary: UnboundedReceiverStream::new(from_primary),
                                 st,
                                 shared_cap,
-                            }
-                    }, extra))
+                            },
+                            next_outbound: 0,
+                        },
+                        extra,
+                    ))
                 }
             }
         }
@@ -249,9 +254,9 @@ struct MultiplexInner<St> {
     /// The raw p2p stream
     conn: P2PStream<St>,
     /// All the subprotocols that are multiplexed on top of the raw p2p stream
-    protocols: Vec<ProtocolStream>,
+    protocols: VecDeque<ProtocolStream>,
     /// Buffer for outgoing messages on the wire.
-    out_buffer: VecDeque<Bytes>,
+    out_buffer: OutBuffer,
 }
 
 impl<St> MultiplexInner<St> {
@@ -285,7 +290,7 @@ impl<St> MultiplexInner<St> {
         let proto_conn = ProtocolConnection { from_wire: UnboundedReceiverStream::new(rx) };
         let st = f(proto_conn);
         let st = ProtocolStream { shared_cap, to_satellite, satellite_st: Box::pin(st) };
-        self.protocols.push(st);
+        self.protocols.push_back(st);
         Ok(())
     }
 }
@@ -468,6 +473,8 @@ impl Stream for ProtocolConnection {
 pub struct RlpxSatelliteStream<St, Primary> {
     inner: MultiplexInner<St>,
     primary: PrimaryProtocol<Primary>,
+    /// Round-robin cursor for the next outbound producer to poll.
+    next_outbound: usize,
 }
 
 impl<St, Primary> RlpxSatelliteStream<St, Primary> {
@@ -516,6 +523,59 @@ impl<St, Primary> RlpxSatelliteStream<St, Primary> {
     pub fn into_inner(self) -> P2PStream<St> {
         self.inner.conn
     }
+
+    /// Polls primary and satellite outbound producers round-robin until the `OutBuffer` is full or
+    /// every producer is pending.
+    ///
+    /// The cursor advances after each producer poll, so a ready producer cannot drain repeatedly
+    /// before later producers get a turn.
+    fn poll_outbound_producers(&mut self, cx: &mut Context<'_>) -> Result<ProducerPoll, io::Error> {
+        let producers = self.inner.protocols.len() + 1;
+        let mut pending = 0;
+
+        while pending < producers {
+            if self.inner.out_buffer.is_full() {
+                return Ok(ProducerPoll::Full)
+            }
+
+            if self.next_outbound >= producers {
+                self.next_outbound = 0;
+            }
+
+            let producer = self.next_outbound;
+            self.next_outbound = (self.next_outbound + 1) % producers;
+
+            let msg = if producer == 0 {
+                match self.primary.from_primary.poll_next_unpin(cx) {
+                    Poll::Ready(Some(msg)) => msg,
+                    Poll::Ready(None) => return Ok(ProducerPoll::Closed),
+                    Poll::Pending => {
+                        pending += 1;
+                        continue
+                    }
+                }
+            } else {
+                let proto = self
+                    .inner
+                    .protocols
+                    .get_mut(producer - 1)
+                    .expect("outbound producer index checked against protocol count");
+                match proto.poll_next_unpin(cx) {
+                    Poll::Ready(Some(msg)) => msg?,
+                    Poll::Ready(None) => return Ok(ProducerPoll::Closed),
+                    Poll::Pending => {
+                        pending += 1;
+                        continue
+                    }
+                }
+            };
+
+            pending = 0;
+            self.inner.out_buffer.push_back(msg);
+        }
+
+        Ok(ProducerPoll::Pending)
+    }
 }
 
 impl<St, Primary, PrimaryErr> Stream for RlpxSatelliteStream<St, Primary>
@@ -562,38 +622,10 @@ where
                 }
             }
 
-            // advance primary out
-            loop {
-                match this.primary.from_primary.poll_next_unpin(cx) {
-                    Poll::Ready(Some(msg)) => {
-                        this.inner.out_buffer.push_back(msg);
-                    }
-                    Poll::Ready(None) => {
-                        // primary closed
-                        return Poll::Ready(None)
-                    }
-                    Poll::Pending => break,
-                }
-            }
-
-            // advance all satellites
-            for idx in (0..this.inner.protocols.len()).rev() {
-                let mut proto = this.inner.protocols.swap_remove(idx);
-                loop {
-                    match proto.poll_next_unpin(cx) {
-                        Poll::Ready(Some(Err(err))) => {
-                            return Poll::Ready(Some(Err(P2PStreamError::Io(err).into())))
-                        }
-                        Poll::Ready(Some(Ok(msg))) => {
-                            this.inner.out_buffer.push_back(msg);
-                        }
-                        Poll::Ready(None) => return Poll::Ready(None),
-                        Poll::Pending => {
-                            this.inner.protocols.push(proto);
-                            break
-                        }
-                    }
-                }
+            match this.poll_outbound_producers(cx) {
+                Ok(ProducerPoll::Pending | ProducerPoll::Full) => {}
+                Ok(ProducerPoll::Closed) => return Poll::Ready(None),
+                Err(err) => return Poll::Ready(Some(Err(P2PStreamError::Io(err).into()))),
             }
 
             let mut delegated = false;
@@ -737,11 +769,11 @@ impl fmt::Debug for ProtocolStream {
 
 /// Helper to poll multiple protocol streams in a `tokio::select`! branch
 struct ProtocolsPoller<'a> {
-    protocols: &'a mut Vec<ProtocolStream>,
+    protocols: &'a mut VecDeque<ProtocolStream>,
 }
 
 impl<'a> ProtocolsPoller<'a> {
-    const fn new(protocols: &'a mut Vec<ProtocolStream>) -> Self {
+    const fn new(protocols: &'a mut VecDeque<ProtocolStream>) -> Self {
         Self { protocols }
     }
 }
@@ -750,22 +782,22 @@ impl<'a> Future for ProtocolsPoller<'a> {
     type Output = Result<Bytes, P2PStreamError>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        // Process protocols in reverse order, like the existing pattern
-        for idx in (0..self.protocols.len()).rev() {
-            let mut proto = self.protocols.swap_remove(idx);
+        let protocols = self.protocols.len();
+        for _ in 0..protocols {
+            let mut proto = self.protocols.pop_front().expect("protocol count checked");
             match proto.poll_next_unpin(cx) {
                 Poll::Ready(Some(Err(err))) => {
-                    self.protocols.push(proto);
+                    self.protocols.push_back(proto);
                     return Poll::Ready(Err(P2PStreamError::from(err)))
                 }
                 Poll::Ready(Some(Ok(msg))) => {
                     // Got a message, put protocol back and return the message
-                    self.protocols.push(proto);
+                    self.protocols.push_back(proto);
                     return Poll::Ready(Ok(msg));
                 }
                 _ => {
                     // push it back because we still want to complete the handshake first
-                    self.protocols.push(proto);
+                    self.protocols.push_back(proto);
                 }
             }
         }
@@ -775,22 +807,211 @@ impl<'a> Future for ProtocolsPoller<'a> {
     }
 }
 
+/// Soft cap for per-connection outbound `RLPx` messages waiting in the multiplexer.
+///
+/// The cap is soft because the next message size is only known after polling a protocol stream.
+/// The buffer may exceed this by at most one message before producer polling is paused.
+///
+/// The lower [`P2PStream`] sink admits two outbound messages and rejects uncompressed payloads
+/// above 16 MiB, so 32 MiB mirrors the largest payload volume the lower p2p layer is already
+/// prepared to buffer.
+const MAX_MUX_OUT_BUFFER_BYTES: usize = 32 * 1024 * 1024;
+
+#[derive(Debug)]
+struct OutBuffer {
+    messages: VecDeque<Bytes>,
+    bytes: usize,
+    max_bytes: usize,
+}
+
+impl Default for OutBuffer {
+    fn default() -> Self {
+        Self { messages: Default::default(), bytes: 0, max_bytes: MAX_MUX_OUT_BUFFER_BYTES }
+    }
+}
+
+impl OutBuffer {
+    fn push_back(&mut self, msg: Bytes) {
+        self.bytes += msg.len();
+        self.messages.push_back(msg);
+    }
+
+    fn pop_front(&mut self) -> Option<Bytes> {
+        let msg = self.messages.pop_front()?;
+        self.bytes -= msg.len();
+        Some(msg)
+    }
+
+    fn is_empty(&self) -> bool {
+        self.messages.is_empty()
+    }
+
+    const fn is_full(&self) -> bool {
+        self.bytes >= self.max_bytes
+    }
+}
+
+/// Result of polling outbound producers into the mux buffer.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum ProducerPoll {
+    /// All outbound producers are pending.
+    Pending,
+    /// The mux buffer reached its soft cap.
+    Full,
+    /// An outbound producer closed.
+    Closed,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::{
         handshake::EthHandshake,
         message::MAX_MESSAGE_SIZE,
+        protocol::Protocol,
         test_utils::{
             connect_passthrough, eth_handshake, eth_hello,
             proto::{test_hello, TestProtoMessage},
         },
         UnauthedEthStream, UnauthedP2PStream,
     };
+    use futures::{stream, task::noop_waker_ref};
     use reth_eth_wire_types::EthNetworkPrimitives;
+    use std::task::Poll;
     use tokio::{net::TcpListener, sync::oneshot};
     use tokio_util::codec::Decoder;
 
+    #[derive(Debug)]
+    struct PendingPrimary {
+        _proxy: ProtocolProxy,
+    }
+
+    impl Stream for PendingPrimary {
+        type Item = Result<(), P2PStreamError>;
+
+        fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+            Poll::Pending
+        }
+    }
+
+    #[derive(Debug)]
+    struct StalledTransport;
+
+    impl Stream for StalledTransport {
+        type Item = io::Result<BytesMut>;
+
+        fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+            Poll::Pending
+        }
+    }
+
+    impl Sink<Bytes> for StalledTransport {
+        type Error = io::Error;
+
+        fn poll_ready(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Result<(), Self::Error>> {
+            Poll::Pending
+        }
+
+        fn start_send(self: Pin<&mut Self>, _item: Bytes) -> Result<(), Self::Error> {
+            Ok(())
+        }
+
+        fn poll_flush(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Result<(), Self::Error>> {
+            Poll::Pending
+        }
+
+        fn poll_close(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Result<(), Self::Error>> {
+            Poll::Pending
+        }
+    }
+
+    #[tokio::test]
+    async fn satellite_mux_stops_polling_protocols_when_out_buffer_is_full() {
+        let (hello, _) = test_hello();
+        let shared_capabilities =
+            SharedCapabilities::try_new(hello.protocols.clone(), hello.message().capabilities)
+                .unwrap();
+        let conn = P2PStream::new(StalledTransport, shared_capabilities);
+        let eth = conn.shared_capabilities().eth().unwrap().clone();
+
+        let mut st = RlpxProtocolMultiplexer::new(conn)
+            .into_satellite_stream(eth.capability().as_ref(), |proxy| PendingPrimary {
+                _proxy: proxy,
+            })
+            .unwrap();
+        const MESSAGE_COUNT: usize = 4096;
+        const MESSAGE_BYTES: usize = 1024;
+        st.inner.out_buffer.max_bytes = 4 * MESSAGE_BYTES + 1;
+        st.install_protocol(&TestProtoMessage::capability(), |_conn| {
+            stream::iter((0..MESSAGE_COUNT).map(|_| {
+                let mut msg = BytesMut::zeroed(MESSAGE_BYTES);
+                msg[0] = TestProtoMessage::ping().message_type as u8;
+                msg
+            }))
+        })
+        .unwrap();
+
+        let mut cx = Context::from_waker(noop_waker_ref());
+        assert!(Pin::new(&mut st).poll_next(&mut cx).is_pending());
+
+        assert!(st.inner.out_buffer.bytes > st.inner.out_buffer.max_bytes);
+        assert!(st.inner.out_buffer.bytes <= st.inner.out_buffer.max_bytes + MESSAGE_BYTES);
+        assert!(st.inner.out_buffer.messages.len() < MESSAGE_COUNT);
+    }
+
+    #[tokio::test]
+    async fn satellite_mux_round_robins_ready_protocols_when_out_buffer_fills() {
+        let (mut hello, _) = eth_hello();
+        let cap_a = Capability::new_static("aaa", 1);
+        let cap_b = Capability::new_static("bbb", 1);
+        hello.protocols.push(Protocol::new(cap_a.clone(), 1));
+        hello.protocols.push(Protocol::new(cap_b.clone(), 1));
+
+        let shared_capabilities =
+            SharedCapabilities::try_new(hello.protocols.clone(), hello.message().capabilities)
+                .unwrap();
+        let conn = P2PStream::new(StalledTransport, shared_capabilities);
+        let eth = conn.shared_capabilities().eth().unwrap().clone();
+        let cap_a_offset =
+            conn.shared_capabilities().find(&cap_a).unwrap().relative_message_id_offset();
+        let cap_b_offset =
+            conn.shared_capabilities().find(&cap_b).unwrap().relative_message_id_offset();
+
+        let mut st = RlpxProtocolMultiplexer::new(conn)
+            .into_satellite_stream(eth.capability().as_ref(), |proxy| PendingPrimary {
+                _proxy: proxy,
+            })
+            .unwrap();
+        st.inner.out_buffer.max_bytes = 5;
+        st.install_protocol(&cap_a, |_conn| {
+            stream::iter((0..16).map(|_| BytesMut::from(&[0, b'a'][..])))
+        })
+        .unwrap();
+        st.install_protocol(&cap_b, |_conn| {
+            stream::iter((0..16).map(|_| BytesMut::from(&[0, b'b'][..])))
+        })
+        .unwrap();
+
+        let mut cx = Context::from_waker(noop_waker_ref());
+        assert!(Pin::new(&mut st).poll_next(&mut cx).is_pending());
+
+        let message_ids =
+            st.inner.out_buffer.messages.iter().take(2).map(|msg| msg[0]).collect::<Vec<_>>();
+        assert_eq!(message_ids.len(), 2);
+        assert_ne!(message_ids[0], message_ids[1]);
+        assert!(message_ids.contains(&cap_a_offset));
+        assert!(message_ids.contains(&cap_b_offset));
+    }
+
     #[tokio::test]
     async fn eth_satellite() {
         reth_tracing::init_test_tracing();
diff --git a/crates/net/network-api/src/custody.rs b/crates/net/network-api/src/custody.rs
new file mode 100644
index 00000000000..fe2f47e7766
--- /dev/null
+++ b/crates/net/network-api/src/custody.rs
@@ -0,0 +1,65 @@
+//! Shared blob cell custody state.
+
+use alloy_primitives::B128;
+use std::sync::{
+    atomic::{AtomicU64, AtomicU8, Ordering},
+    Arc,
+};
+
+/// Shared blob cell custody bitmap for [EIP-8070] sparse blobpool sampling.
+///
+/// This stores the latest `custodyColumns` value received from
+/// `engine_forkchoiceUpdatedV4`, so network components can align blob cell sampling with the
+/// consensus client's custody set. The value is a lightweight hint for sampling decisions, not a
+/// consensus-critical guard.
+///
+/// [EIP-8070]: https://eips.ethereum.org/EIPS/eip-8070
+#[derive(Debug, Clone, Default)]
+pub struct CellCustody {
+    inner: Arc<CellCustodyInner>,
+}
+
+impl CellCustody {
+    /// Returns the currently configured blob cell custody bitmap.
+    ///
+    /// Reads are intentionally cheap and eventually consistent. Concurrent custom-to-custom
+    /// updates may briefly expose an in-flight bitmap, which is acceptable because custody is only
+    /// used to steer future sampling requests.
+    pub fn get(&self) -> B128 {
+        match self.inner.state.load(Ordering::Relaxed) {
+            CELL_CUSTODY_NONE => B128::from(0u128),
+            CELL_CUSTODY_FULL => B128::from(u128::MAX),
+            _ => {
+                let high = self.inner.high.load(Ordering::Relaxed) as u128;
+                let low = self.inner.low.load(Ordering::Relaxed) as u128;
+
+                B128::from((high << 64) | low)
+            }
+        }
+    }
+
+    /// Updates the blob cell custody bitmap.
+    pub fn set(&self, custody_columns: B128) {
+        let custody_columns = u128::from(custody_columns);
+        match custody_columns {
+            0 => self.inner.state.store(CELL_CUSTODY_NONE, Ordering::Relaxed),
+            u128::MAX => self.inner.state.store(CELL_CUSTODY_FULL, Ordering::Relaxed),
+            _ => {
+                self.inner.high.store((custody_columns >> 64) as u64, Ordering::Relaxed);
+                self.inner.low.store(custody_columns as u64, Ordering::Relaxed);
+                self.inner.state.store(CELL_CUSTODY_CUSTOM, Ordering::Relaxed);
+            }
+        }
+    }
+}
+
+const CELL_CUSTODY_NONE: u8 = 0;
+const CELL_CUSTODY_FULL: u8 = 1;
+const CELL_CUSTODY_CUSTOM: u8 = 2;
+
+#[derive(Debug, Default)]
+struct CellCustodyInner {
+    state: AtomicU8,
+    high: AtomicU64,
+    low: AtomicU64,
+}
diff --git a/crates/net/network-api/src/events.rs b/crates/net/network-api/src/events.rs
index 5ec061f204d..69074f57f25 100644
--- a/crates/net/network-api/src/events.rs
+++ b/crates/net/network-api/src/events.rs
@@ -1,9 +1,9 @@
 //! API related to listening for network events.
 
 use reth_eth_wire_types::{
-    message::RequestPair, BlockAccessLists, BlockBodies, BlockHeaders, Capabilities,
+    message::RequestPair, BlockAccessLists, BlockBodies, BlockHeaders, Capabilities, Cells,
     DisconnectReason, EthMessage, EthNetworkPrimitives, EthVersion, GetBlockAccessLists,
-    GetBlockBodies, GetBlockHeaders, GetNodeData, GetPooledTransactions, GetReceipts,
+    GetBlockBodies, GetBlockHeaders, GetCells, GetNodeData, GetPooledTransactions, GetReceipts,
     GetReceipts70, NetworkPrimitives, NodeData, PooledTransactions, Receipts, Receipts69,
     Receipts70, UnifiedStatus,
 };
@@ -262,6 +262,15 @@ pub enum PeerRequest<N: NetworkPrimitives = EthNetworkPrimitives> {
         /// The channel to send the response for block access lists.
         response: oneshot::Sender<RequestResult<BlockAccessLists>>,
     },
+    /// Requests cells from the peer.
+    ///
+    /// The response should be sent through the channel.
+    GetCells {
+        /// The request for cells.
+        request: GetCells,
+        /// The channel to send the response for cells.
+        response: oneshot::Sender<RequestResult<Cells>>,
+    },
 }
 
 // === impl PeerRequest ===
@@ -283,6 +292,7 @@ impl<N: NetworkPrimitives> PeerRequest<N> {
             Self::GetReceipts69 { response, .. } => response.send(Err(err)).ok(),
             Self::GetReceipts70 { response, .. } => response.send(Err(err)).ok(),
             Self::GetBlockAccessLists { response, .. } => response.send(Err(err)).ok(),
+            Self::GetCells { response, .. } => response.send(Err(err)).ok(),
         };
     }
 
@@ -291,6 +301,7 @@ impl<N: NetworkPrimitives> PeerRequest<N> {
     pub fn is_supported_by_eth_version(&self, version: EthVersion) -> bool {
         match self {
             Self::GetBlockAccessLists { .. } => version >= EthVersion::Eth71,
+            Self::GetCells { .. } => version >= EthVersion::Eth72,
             _ => true,
         }
     }
@@ -325,6 +336,9 @@ impl<N: NetworkPrimitives> PeerRequest<N> {
                     message: request.clone(),
                 })
             }
+            Self::GetCells { request, .. } => {
+                EthMessage::GetCells(RequestPair { request_id, message: request.clone() })
+            }
         }
     }
 
@@ -389,4 +403,14 @@ mod tests {
         assert!(!req.is_supported_by_eth_version(EthVersion::Eth70));
         assert!(req.is_supported_by_eth_version(EthVersion::Eth71));
     }
+
+    #[test]
+    fn test_get_cells_version_support() {
+        let (tx, _rx) = oneshot::channel();
+        let req: PeerRequest<EthNetworkPrimitives> =
+            PeerRequest::GetCells { request: GetCells::default(), response: tx };
+
+        assert!(!req.is_supported_by_eth_version(EthVersion::Eth71));
+        assert!(req.is_supported_by_eth_version(EthVersion::Eth72));
+    }
 }
diff --git a/crates/net/network-api/src/lib.rs b/crates/net/network-api/src/lib.rs
index 95030ad4ded..16773b998f1 100644
--- a/crates/net/network-api/src/lib.rs
+++ b/crates/net/network-api/src/lib.rs
@@ -13,6 +13,8 @@
 )]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
+/// Shared blob cell custody state.
+pub mod custody;
 pub mod downloaders;
 /// Network Error
 pub mod error;
@@ -27,6 +29,7 @@ pub use alloy_rpc_types_admin::EthProtocolInfo;
 pub use reth_network_p2p::{BlockClient, HeadersClient};
 pub use reth_network_types::{PeerKind, Reputation, ReputationChangeKind};
 
+pub use custody::CellCustody;
 pub use downloaders::BlockDownloaderProvider;
 pub use error::NetworkError;
 pub use events::{
@@ -86,6 +89,14 @@ pub trait NetworkInfo: Send + Sync {
     /// Returns the chain id
     fn chain_id(&self) -> u64;
 
+    /// Returns shared blob cell custody state for [EIP-8070] sparse blobpool sampling.
+    ///
+    /// This is updated from non-null `custodyColumns` values received through
+    /// `engine_forkchoiceUpdatedV4` and should be treated as a lightweight sampling hint.
+    ///
+    /// [EIP-8070]: https://eips.ethereum.org/EIPS/eip-8070
+    fn cell_custody(&self) -> &CellCustody;
+
     /// Returns `true` if the network is undergoing sync.
     fn is_syncing(&self) -> bool;
 
@@ -140,6 +151,13 @@ pub trait Peers: PeersInfo {
         self.add_peer_kind(peer, Some(PeerKind::Trusted), tcp_addr, Some(udp_addr));
     }
 
+    /// Registers a trusted peer that may use a hostname instead of an IP address.
+    ///
+    /// Resolution is performed asynchronously by the periodic DNS resolver; the peer is
+    /// added to the peer set on first successful resolution and re-resolved periodically
+    /// so address changes are picked up automatically.
+    fn add_trusted_peer_node(&self, _peer: reth_network_peers::TrustedPeer) {}
+
     /// Adds a peer to the known peer set, with the given kind.
     ///
     /// If the peer already exists, then this will update its tracked info.
diff --git a/crates/net/network-api/src/noop.rs b/crates/net/network-api/src/noop.rs
index f0b7de9bd9f..b8ffe9bdd8d 100644
--- a/crates/net/network-api/src/noop.rs
+++ b/crates/net/network-api/src/noop.rs
@@ -9,7 +9,7 @@ use std::net::{IpAddr, SocketAddr};
 use crate::{
     events::{NetworkPeersEvents, PeerEventStream},
     test_utils::{PeersHandle, PeersHandleProvider},
-    BlockDownloaderProvider, DiscoveryEvent, NetworkError, NetworkEvent,
+    BlockDownloaderProvider, CellCustody, DiscoveryEvent, NetworkError, NetworkEvent,
     NetworkEventListenerProvider, NetworkInfo, NetworkStatus, PeerId, PeerInfo, PeerRequest, Peers,
     PeersInfo,
 };
@@ -33,6 +33,7 @@ use tokio_stream::wrappers::UnboundedReceiverStream;
 pub struct NoopNetwork<Net = EthNetworkPrimitives> {
     chain_id: u64,
     peers_handle: PeersHandle,
+    cell_custody: CellCustody,
     _marker: PhantomData<Net>,
 }
 
@@ -44,6 +45,7 @@ impl<Net> NoopNetwork<Net> {
         Self {
             chain_id: 1, // mainnet
             peers_handle: PeersHandle::new(tx),
+            cell_custody: CellCustody::default(),
             _marker: PhantomData,
         }
     }
@@ -89,6 +91,10 @@ where
         self.chain_id
     }
 
+    fn cell_custody(&self) -> &CellCustody {
+        &self.cell_custody
+    }
+
     fn is_syncing(&self) -> bool {
         false
     }
diff --git a/crates/net/network-types/src/peers/config.rs b/crates/net/network-types/src/peers/config.rs
index ecea24a3289..a766674952f 100644
--- a/crates/net/network-types/src/peers/config.rs
+++ b/crates/net/network-types/src/peers/config.rs
@@ -112,6 +112,15 @@ impl Default for ConnectionsConfig {
     }
 }
 
+/// Default mean interval for the jittered peer rotation timer.
+///
+/// The actual fire interval is uniformly random in `[mean * 3/5, mean * 7/5]`. With the default
+/// of 5 minutes that gives a `[3 min, 7 min]` range, matching geth's peer dropper.
+pub const DEFAULT_PEER_ROTATION_INTERVAL: Duration = Duration::from_mins(5);
+
+/// Minimum connection uptime before a peer is eligible for rotation eviction.
+pub const PEER_ROTATION_MIN_UPTIME: Duration = Duration::from_mins(10);
+
 /// Config type for initiating a `PeersManager` instance.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -174,6 +183,10 @@ pub struct PeersConfig {
     ///
     /// This filters out peers from other networks that pollute the discovery table.
     pub enforce_enr_fork_id: bool,
+    /// How often to rotate a random non-protected peer (inbound or outbound) to open a slot for
+    /// new nodes. Set to `None` to disable rotation.
+    #[cfg_attr(feature = "serde", serde(default, with = "humantime_serde"))]
+    pub peer_rotation_interval: Option<Duration>,
 }
 
 impl Default for PeersConfig {
@@ -195,6 +208,7 @@ impl Default for PeersConfig {
             incoming_ip_throttle_duration: INBOUND_IP_THROTTLE_DURATION,
             ip_filter: IpFilter::default(),
             enforce_enr_fork_id: false,
+            peer_rotation_interval: Some(DEFAULT_PEER_ROTATION_INTERVAL),
         }
     }
 }
@@ -344,6 +358,13 @@ impl PeersConfig {
         self
     }
 
+    /// Configures the interval at which a random outbound peer is rotated.
+    /// Pass `None` to disable rotation.
+    pub const fn with_peer_rotation_interval(mut self, interval: Option<Duration>) -> Self {
+        self.peer_rotation_interval = interval;
+        self
+    }
+
     /// Returns settings for testing
     #[cfg(any(test, feature = "test-utils"))]
     pub fn test() -> Self {
@@ -351,6 +372,7 @@ impl PeersConfig {
             refill_slots_interval: Duration::from_millis(100),
             backoff_durations: PeerBackoffDurations::test(),
             ban_duration: Duration::from_millis(200),
+            peer_rotation_interval: None,
             ..Default::default()
         }
     }
diff --git a/crates/net/network-types/src/peers/mod.rs b/crates/net/network-types/src/peers/mod.rs
index 7dfc3867414..a86841068b7 100644
--- a/crates/net/network-types/src/peers/mod.rs
+++ b/crates/net/network-types/src/peers/mod.rs
@@ -9,6 +9,7 @@ pub use reputation::{Reputation, ReputationChange, ReputationChangeKind, Reputat
 
 use alloy_eip2124::ForkId;
 use reth_network_peers::{NodeRecord, PeerId};
+use std::time::{Duration, Instant};
 use tracing::trace;
 
 use crate::{
@@ -25,6 +26,8 @@ pub struct Peer {
     pub reputation: i32,
     /// The state of the connection, if any.
     pub state: PeerConnectionState,
+    /// When the current session was established.
+    pub connected_at: Option<Instant>,
     /// The [`ForkId`] that the peer announced via discovery.
     pub fork_id: Option<Box<ForkId>>,
     /// Whether the entry should be removed after an existing session was terminated.
@@ -56,11 +59,28 @@ impl Peer {
         self.reputation
     }
 
+    /// Marks this peer as connected.
+    pub fn mark_connected(&mut self) {
+        self.connected_at = Some(Instant::now());
+    }
+
+    /// Clears the current connection timestamp.
+    pub const fn mark_disconnected(&mut self) {
+        self.connected_at = None;
+    }
+
+    /// Returns `true` if the current connection has been active for at least `min_uptime`.
+    pub fn connected_for_at_least(&self, now: Instant, min_uptime: Duration) -> bool {
+        self.connected_at
+            .is_some_and(|connected_at| now.saturating_duration_since(connected_at) >= min_uptime)
+    }
+
     /// Returns a new peer for given [`PeerAddr`] and [`PeerConnectionState`].
     pub fn with_state(addr: PeerAddr, state: PeerConnectionState) -> Self {
         Self {
             addr,
             state,
+            connected_at: None,
             reputation: DEFAULT_REPUTATION,
             fork_id: None,
             remove_after_disconnect: false,
diff --git a/crates/net/network/src/builder.rs b/crates/net/network/src/builder.rs
index 425f290f50f..82309393a24 100644
--- a/crates/net/network/src/builder.rs
+++ b/crates/net/network/src/builder.rs
@@ -16,7 +16,7 @@ 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 reth_transaction_pool::{BlobStore, TransactionPool};
 use tokio::sync::mpsc;
 
 /// We set the max channel capacity of the `EthRequestHandler` to 256
@@ -78,6 +78,21 @@ impl<Tx, Eth, N: NetworkPrimitives> NetworkBuilder<Tx, Eth, N> {
         NetworkBuilder { network, request_handler, transactions }
     }
 
+    /// Creates a new [`EthRequestHandler`] with access to a blob store and wires it to the network.
+    pub fn request_handler_with_blob_store<Client>(
+        self,
+        client: Client,
+        blob_store: Box<dyn BlobStore>,
+    ) -> NetworkBuilder<Tx, EthRequestHandler<Client, N>, N>
+    where
+        Client: BalProvider,
+    {
+        let NetworkBuilder { network, transactions, request_handler } =
+            self.request_handler(client);
+        let request_handler = request_handler.with_blob_store(blob_store);
+        NetworkBuilder { network, request_handler, transactions }
+    }
+
     /// Creates a new [`TransactionsManager`] and wires it to the network.
     pub fn transactions<Pool: TransactionPool>(
         self,
diff --git a/crates/net/network/src/cache.rs b/crates/net/network/src/cache.rs
index 2c1ea15792c..3ad96686d64 100644
--- a/crates/net/network/src/cache.rs
+++ b/crates/net/network/src/cache.rs
@@ -11,17 +11,27 @@ use std::{fmt, hash::Hash};
 ///
 /// If the length exceeds the set capacity, the oldest element will be removed
 /// In the limit, for each element inserted the oldest existing element will be removed.
-pub struct LruCache<T: Hash + Eq + fmt::Debug> {
+pub struct LruCache<T: Hash + Eq + fmt::Debug, S = DefaultHashBuilder>
+where
+    S: BuildHasher,
+{
     limit: u32,
-    inner: LruMap<T, ()>,
+    inner: LruMap<T, (), ByLength, S>,
 }
 
 impl<T: Hash + Eq + fmt::Debug> LruCache<T> {
     /// Creates a new [`LruCache`] using the given limit
     pub fn new(limit: u32) -> Self {
+        Self::with_hasher(limit, Default::default())
+    }
+}
+
+impl<T: Hash + Eq + fmt::Debug, S: BuildHasher> LruCache<T, S> {
+    /// Creates a new [`LruCache`] using the given limit and hash builder.
+    pub const fn with_hasher(limit: u32, hash_builder: S) -> Self {
         // limit of lru map is one element more, so can give eviction feedback, which isn't
         // supported by LruMap
-        Self { inner: LruMap::new(limit + 1), limit }
+        Self { inner: LruMap::with_hasher(limit + 1, hash_builder), limit }
     }
 
     /// Insert an element into the set.
@@ -105,9 +115,10 @@ impl<T: Hash + Eq + fmt::Debug> LruCache<T> {
     }
 }
 
-impl<T> Extend<T> for LruCache<T>
+impl<T, S> Extend<T> for LruCache<T, S>
 where
     T: Eq + Hash + fmt::Debug,
+    S: BuildHasher,
 {
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         for item in iter {
@@ -116,9 +127,10 @@ where
     }
 }
 
-impl<T> fmt::Debug for LruCache<T>
+impl<T, S> fmt::Debug for LruCache<T, S>
 where
     T: fmt::Debug + Hash + Eq,
+    S: BuildHasher,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut debug_struct = f.debug_struct("LruCache");
@@ -173,7 +185,18 @@ where
 {
     /// Returns a new cache with default limiter and hash builder.
     pub fn new(max_length: u32) -> Self {
-        Self(schnellru::LruMap::with_hasher(ByLength::new(max_length), Default::default()))
+        Self::with_hasher(max_length, Default::default())
+    }
+}
+
+impl<K, V, S> LruMap<K, V, ByLength, S>
+where
+    K: Hash + PartialEq,
+    S: BuildHasher,
+{
+    /// Returns a new cache with default limiter and the given hash builder.
+    pub const fn with_hasher(max_length: u32, hash_builder: S) -> Self {
+        Self(schnellru::LruMap::with_hasher(ByLength::new(max_length), hash_builder))
     }
 }
 
diff --git a/crates/net/network/src/config.rs b/crates/net/network/src/config.rs
index 8c13a21445a..8a51029f2fe 100644
--- a/crates/net/network/src/config.rs
+++ b/crates/net/network/src/config.rs
@@ -657,17 +657,25 @@ impl<N: NetworkPrimitives> NetworkConfigBuilder<N> {
             total_difficulty: chain_spec.genesis().difficulty,
         });
 
+        let listener_addr = listener_addr.unwrap_or(DEFAULT_DISCOVERY_ADDRESS);
+        // Static NAT addresses (`extip`/`extaddr`) tell peers which IP to dial, but that IP may
+        // not exist on a local interface. Keep binding to `listener_addr` and use the NAT IP only
+        // as the ENR address.
+        let advertised_ip = nat.clone().and_then(|nat| nat.as_external_ip(listener_addr.port()));
+
         discovery_v5_builder = discovery_v5_builder.map(|mut builder| {
             if let Some(network_stack_id) = NetworkStackId::id(&chain_spec) {
                 let fork_id = chain_spec.fork_id(&head);
                 builder = builder.fork(network_stack_id, fork_id)
             }
 
+            if let Some(ip) = advertised_ip {
+                builder = builder.advertised_ip(ip);
+            }
+
             builder
         });
 
-        let listener_addr = listener_addr.unwrap_or(DEFAULT_DISCOVERY_ADDRESS);
-
         let mut hello_message =
             hello_message.unwrap_or_else(|| HelloMessage::builder(peer_id).build());
         hello_message.port = listener_addr.port();
diff --git a/crates/net/network/src/error.rs b/crates/net/network/src/error.rs
index b6509a0db0c..fee5326b047 100644
--- a/crates/net/network/src/error.rs
+++ b/crates/net/network/src/error.rs
@@ -1,7 +1,7 @@
 //! Possible errors when interacting with the network.
 
 use crate::session::PendingSessionHandshakeError;
-use reth_dns_discovery::resolver::ResolveError;
+use reth_dns_discovery::resolver::NetError;
 use reth_ecies::ECIESErrorImpl;
 use reth_eth_wire::{
     errors::{EthHandshakeError, EthStreamError, P2PHandshakeError, P2PStreamError},
@@ -62,7 +62,7 @@ pub enum NetworkError {
     ///
     /// See also [`DnsResolver`](reth_dns_discovery::DnsResolver::from_system_conf)
     #[error("failed to configure DNS resolver: {0}")]
-    DnsResolver(#[from] ResolveError),
+    DnsResolver(#[from] NetError),
 }
 
 impl NetworkError {
diff --git a/crates/net/network/src/eth_requests.rs b/crates/net/network/src/eth_requests.rs
index a954c321d3e..3282285d3e5 100644
--- a/crates/net/network/src/eth_requests.rs
+++ b/crates/net/network/src/eth_requests.rs
@@ -6,19 +6,19 @@ use crate::{
 };
 use alloy_consensus::{BlockHeader, ReceiptWithBloom};
 use alloy_eips::BlockHashOrNumber;
-use alloy_primitives::Bytes;
 use alloy_rlp::Encodable;
 use futures::StreamExt;
 use reth_eth_wire::{
-    BlockAccessLists, BlockBodies, BlockHeaders, EthNetworkPrimitives, GetBlockAccessLists,
-    GetBlockBodies, GetBlockHeaders, GetNodeData, GetReceipts, GetReceipts70, HeadersDirection,
-    NetworkPrimitives, NodeData, Receipts, Receipts69, Receipts70,
+    BlockAccessLists, BlockBodies, BlockHeaders, Cells, EthNetworkPrimitives, GetBlockAccessLists,
+    GetBlockBodies, GetBlockHeaders, GetCells, GetNodeData, GetReceipts, GetReceipts70,
+    HeadersDirection, NetworkPrimitives, NodeData, Receipts, Receipts69, Receipts70,
 };
 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_transaction_pool::{blobstore::NoopBlobStore, BlobStore};
 use std::{
     future::Future,
     pin::Pin,
@@ -51,6 +51,11 @@ pub const MAX_BODIES_SERVE: usize = 1024;
 /// Used to limit lookups.
 pub const MAX_BLOCK_ACCESS_LISTS_SERVE: usize = 1024;
 
+/// Maximum number of cell lookups to serve.
+///
+/// Used to limit lookups.
+pub const MAX_CELLS_SERVE: usize = 1024;
+
 /// Maximum size of replies to data retrievals: 2MB
 pub const SOFT_RESPONSE_LIMIT: usize = 2 * 1024 * 1024;
 
@@ -62,6 +67,8 @@ pub const SOFT_RESPONSE_LIMIT: usize = 2 * 1024 * 1024;
 pub struct EthRequestHandler<C, N: NetworkPrimitives = EthNetworkPrimitives> {
     /// The client type that can interact with the chain.
     client: C,
+    /// Blob store used for serving blob cell requests.
+    blob_store: Box<dyn BlobStore>,
     /// Used for reporting peers.
     // TODO use to report spammers
     #[expect(dead_code)]
@@ -78,11 +85,18 @@ impl<C, N: NetworkPrimitives> EthRequestHandler<C, N> {
     pub fn new(client: C, peers: PeersHandle, incoming: Receiver<IncomingEthRequest<N>>) -> Self {
         Self {
             client,
+            blob_store: Box::<NoopBlobStore>::default(),
             peers,
             incoming_requests: ReceiverStream::new(incoming),
             metrics: Default::default(),
         }
     }
+
+    /// Set blob store for the request handler
+    pub fn with_blob_store(mut self, blob_store: Box<dyn BlobStore>) -> Self {
+        self.blob_store = blob_store;
+        self
+    }
 }
 
 impl<C, N> EthRequestHandler<C, N>
@@ -314,6 +328,32 @@ where
 
         receipts
     }
+
+    fn on_cells_request(
+        &self,
+        _peer_id: PeerId,
+        request: GetCells,
+        response: oneshot::Sender<RequestResult<Cells>>,
+    ) {
+        let mut cells_response = Cells { cell_mask: request.cell_mask, ..Default::default() };
+
+        for hash in request.hashes.into_iter().take(MAX_CELLS_SERVE) {
+            let Some(cells) =
+                self.blob_store.get_cells(hash, request.cell_mask).unwrap_or_default()
+            else {
+                continue;
+            };
+
+            cells_response.hashes.push(hash);
+            cells_response.cells.push(cells);
+
+            if cells_response.length() > SOFT_RESPONSE_LIMIT {
+                break
+            }
+        }
+
+        let _ = response.send(Ok(cells_response));
+    }
 }
 
 impl<C, N> EthRequestHandler<C, N>
@@ -331,34 +371,16 @@ where
         mut request: GetBlockAccessLists,
         response: oneshot::Sender<RequestResult<BlockAccessLists>>,
     ) {
+        self.metrics.eth_block_access_lists_requests_received_total.increment(1);
         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 access_lists =
+            self.client.bal_store().get_by_hashes_with_limit(&request.0, limit).unwrap_or_default();
         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!`.
@@ -405,6 +427,9 @@ where
                     IncomingEthRequest::GetBlockAccessLists { peer_id, request, response } => {
                         this.on_block_access_lists_request(peer_id, request, response)
                     }
+                    IncomingEthRequest::GetCells { peer_id, request, response } => {
+                        this.on_cells_request(peer_id, request, response)
+                    }
                 }
             },
         );
@@ -501,4 +526,165 @@ pub enum IncomingEthRequest<N: NetworkPrimitives = EthNetworkPrimitives> {
         /// The channel sender for the response containing block access lists.
         response: oneshot::Sender<RequestResult<BlockAccessLists>>,
     },
+    /// Request Cells from the peer.
+    ///
+    /// The response should be sent through the channel.
+    GetCells {
+        /// The ID of the peer to request cells from.
+        peer_id: PeerId,
+        /// The requested block hashes.
+        request: GetCells,
+        /// The channel sender for the response containing cells.
+        response: oneshot::Sender<RequestResult<Cells>>,
+    },
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy_eips::{
+        eip4844::{BlobAndProofV1, BlobAndProofV2, BlobCellsAndProofsV1},
+        eip7594::{BlobTransactionSidecarVariant, Cell},
+    };
+    use alloy_primitives::{TxHash, B128, B256};
+    use reth_network_api::test_utils::PeersHandle;
+    use reth_storage_api::noop::NoopProvider;
+    use reth_transaction_pool::blobstore::{BlobStoreCleanupStat, BlobStoreError};
+    use std::sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    };
+    use tokio::sync::mpsc;
+
+    #[derive(Debug, Default)]
+    struct CountingBlobStore {
+        get_cells_calls: Arc<AtomicUsize>,
+    }
+
+    impl BlobStore for CountingBlobStore {
+        fn insert(
+            &self,
+            _tx: B256,
+            _data: BlobTransactionSidecarVariant,
+        ) -> Result<(), BlobStoreError> {
+            Ok(())
+        }
+
+        fn insert_all(
+            &self,
+            _txs: Vec<(B256, BlobTransactionSidecarVariant)>,
+        ) -> Result<(), BlobStoreError> {
+            Ok(())
+        }
+
+        fn delete(&self, _tx: B256) -> Result<(), BlobStoreError> {
+            Ok(())
+        }
+
+        fn delete_all(&self, _txs: Vec<B256>) -> Result<(), BlobStoreError> {
+            Ok(())
+        }
+
+        fn cleanup(&self) -> BlobStoreCleanupStat {
+            BlobStoreCleanupStat::default()
+        }
+
+        fn get(
+            &self,
+            _tx: B256,
+        ) -> Result<Option<Arc<BlobTransactionSidecarVariant>>, BlobStoreError> {
+            Ok(None)
+        }
+
+        fn contains(&self, _tx: B256) -> Result<bool, BlobStoreError> {
+            Ok(false)
+        }
+
+        fn get_all(
+            &self,
+            _txs: Vec<B256>,
+        ) -> Result<Vec<(B256, Arc<BlobTransactionSidecarVariant>)>, BlobStoreError> {
+            Ok(vec![])
+        }
+
+        fn get_exact(
+            &self,
+            txs: Vec<B256>,
+        ) -> Result<Vec<Arc<BlobTransactionSidecarVariant>>, BlobStoreError> {
+            if txs.is_empty() {
+                return Ok(vec![])
+            }
+
+            Err(BlobStoreError::MissingSidecar(txs[0]))
+        }
+
+        fn get_by_versioned_hashes_v1(
+            &self,
+            versioned_hashes: &[B256],
+        ) -> Result<Vec<Option<BlobAndProofV1>>, BlobStoreError> {
+            Ok(vec![None; versioned_hashes.len()])
+        }
+
+        fn get_by_versioned_hashes_v2(
+            &self,
+            _versioned_hashes: &[B256],
+        ) -> Result<Option<Vec<BlobAndProofV2>>, BlobStoreError> {
+            Ok(None)
+        }
+
+        fn get_by_versioned_hashes_v3(
+            &self,
+            versioned_hashes: &[B256],
+        ) -> Result<Vec<Option<BlobAndProofV2>>, BlobStoreError> {
+            Ok(vec![None; versioned_hashes.len()])
+        }
+
+        fn get_by_versioned_hashes_v4(
+            &self,
+            versioned_hashes: &[B256],
+            _indices_bitarray: B128,
+        ) -> Result<Vec<Option<BlobCellsAndProofsV1>>, BlobStoreError> {
+            Ok(vec![None; versioned_hashes.len()])
+        }
+
+        fn get_cells(
+            &self,
+            _tx_hash: TxHash,
+            _indices_bitarray: B128,
+        ) -> Result<Option<Vec<Cell>>, BlobStoreError> {
+            self.get_cells_calls.fetch_add(1, Ordering::Relaxed);
+            Ok(None)
+        }
+
+        fn data_size_hint(&self) -> Option<usize> {
+            Some(0)
+        }
+
+        fn blobs_len(&self) -> usize {
+            0
+        }
+    }
+
+    #[tokio::test]
+    async fn get_cells_request_limits_blob_store_lookups() {
+        let (peers_tx, _) = mpsc::unbounded_channel();
+        let (_incoming_tx, incoming_rx) = mpsc::channel(1);
+        let get_cells_calls = Arc::new(AtomicUsize::new(0));
+        let blob_store = CountingBlobStore { get_cells_calls: Arc::clone(&get_cells_calls) };
+        let handler = EthRequestHandler::<NoopProvider>::new(
+            NoopProvider::default(),
+            PeersHandle::new(peers_tx),
+            incoming_rx,
+        )
+        .with_blob_store(Box::new(blob_store));
+        let (response, rx) = oneshot::channel();
+        let request =
+            GetCells { hashes: vec![B256::ZERO; MAX_CELLS_SERVE + 1], cell_mask: B128::default() };
+
+        handler.on_cells_request(PeerId::default(), request, response);
+
+        let cells = rx.await.unwrap().unwrap();
+        assert!(cells.hashes.is_empty());
+        assert_eq!(get_cells_calls.load(Ordering::Relaxed), MAX_CELLS_SERVE);
+    }
 }
diff --git a/crates/net/network/src/fetch/client.rs b/crates/net/network/src/fetch/client.rs
index bd00dd9a49b..9fcc0f6067f 100644
--- a/crates/net/network/src/fetch/client.rs
+++ b/crates/net/network/src/fetch/client.rs
@@ -130,19 +130,6 @@ impl<N: NetworkPrimitives> BlockAccessListsClient for FetchClient<N> {
     type Output =
         std::pin::Pin<Box<dyn Future<Output = PeerRequestResult<BlockAccessLists>> + Send + Sync>>;
 
-    /// Sends a `GetBlockAccessLists` request to an available peer.
-    fn get_block_access_lists_with_priority(
-        &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>,
diff --git a/crates/net/network/src/manager.rs b/crates/net/network/src/manager.rs
index 4a37707516c..1afce957ac5 100644
--- a/crates/net/network/src/manager.rs
+++ b/crates/net/network/src/manager.rs
@@ -573,6 +573,8 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
                     response,
                 })
             }
+            PeerRequest::GetCells { request, response } => self
+                .delegate_eth_request(IncomingEthRequest::GetCells { peer_id, request, response }),
             PeerRequest::GetPooledTransactions { request, response } => {
                 self.notify_tx_manager(NetworkTransactionEvent::GetPooledTransactions {
                     peer_id,
@@ -712,6 +714,11 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
             NetworkHandleMessage::AddTrustedPeerId(peer_id) => {
                 self.swarm.state_mut().add_trusted_peer_id(peer_id);
             }
+            NetworkHandleMessage::AddTrustedPeerNode(trusted_peer) => {
+                if !self.swarm.is_shutting_down() {
+                    self.swarm.state_mut().add_trusted_peer_node(trusted_peer);
+                }
+            }
             NetworkHandleMessage::AddPeerAddress(peer, kind, addr) => {
                 // only add peer if we are not shutting down
                 if !self.swarm.is_shutting_down() {
diff --git a/crates/net/network/src/message.rs b/crates/net/network/src/message.rs
index 6f69fca975b..684b558e4b1 100644
--- a/crates/net/network/src/message.rs
+++ b/crates/net/network/src/message.rs
@@ -8,7 +8,7 @@ use alloy_consensus::{BlockHeader, ReceiptWithBloom};
 use alloy_primitives::{Bytes, B256};
 use futures::FutureExt;
 use reth_eth_wire::{
-    message::RequestPair, BlockBodies, BlockHeaders, BlockRangeUpdate, EthMessage,
+    message::RequestPair, BlockBodies, BlockHeaders, BlockRangeUpdate, Cells, EthMessage,
     EthNetworkPrimitives, GetBlockAccessLists, GetBlockBodies, GetBlockHeaders, GetReceipts,
     NetworkPrimitives, NewBlock, NewBlockHashes, NewBlockPayload, NewPooledTransactionHashes,
     NodeData, PooledTransactions, Receipts, SharedTransactions, Transactions,
@@ -177,6 +177,12 @@ pub enum PeerResponse<N: NetworkPrimitives = EthNetworkPrimitives> {
         /// The receiver channel for the response to a block access lists request.
         response: oneshot::Receiver<RequestResult<BlockAccessLists>>,
     },
+    ///
+    /// Represents a response to a request for cells.
+    Cells {
+        /// The receiver channel for the response to a cells request.
+        response: oneshot::Receiver<RequestResult<Cells>>,
+    },
 }
 
 // === impl PeerResponse ===
@@ -220,6 +226,10 @@ impl<N: NetworkPrimitives> PeerResponse<N> {
                 Ok(res) => PeerResponseResult::BlockAccessLists(res),
                 Err(err) => PeerResponseResult::BlockAccessLists(Err(err.into())),
             },
+            Self::Cells { response } => match ready!(response.poll_unpin(cx)) {
+                Ok(res) => PeerResponseResult::Cells(res),
+                Err(err) => PeerResponseResult::Cells(Err(err.into())),
+            },
         };
         Poll::Ready(res)
     }
@@ -244,6 +254,8 @@ pub enum PeerResponseResult<N: NetworkPrimitives = EthNetworkPrimitives> {
     Receipts70(RequestResult<Receipts70<N::Receipt>>),
     /// Represents a result containing block access lists or an error.
     BlockAccessLists(RequestResult<BlockAccessLists>),
+    /// Represents a result containing cells or an error.
+    Cells(RequestResult<Cells>),
 }
 
 // === impl PeerResponseResult ===
@@ -295,6 +307,13 @@ impl<N: NetworkPrimitives> PeerResponseResult<N> {
                 }
                 Err(err) => Err(err),
             },
+            Self::Cells(resp) => match resp {
+                Ok(res) => {
+                    let request = RequestPair { request_id: id, message: res };
+                    Ok(EthMessage::Cells(request))
+                }
+                Err(err) => Err(err),
+            },
         }
     }
 
@@ -309,6 +328,7 @@ impl<N: NetworkPrimitives> PeerResponseResult<N> {
             Self::Receipts69(res) => res.as_ref().err(),
             Self::Receipts70(res) => res.as_ref().err(),
             Self::BlockAccessLists(res) => res.as_ref().err(),
+            Self::Cells(res) => res.as_ref().err(),
         }
     }
 
diff --git a/crates/net/network/src/metrics.rs b/crates/net/network/src/metrics.rs
index b8c66346e7d..39ebfe89cc7 100644
--- a/crates/net/network/src/metrics.rs
+++ b/crates/net/network/src/metrics.rs
@@ -557,6 +557,9 @@ pub struct EthRequestHandlerMetrics {
     /// Number of `GetNodeData` requests received
     pub(crate) eth_node_data_requests_received_total: Counter,
 
+    /// Number of `GetBlockAccessLists` requests received
+    pub(crate) eth_block_access_lists_requests_received_total: Counter,
+
     /// Duration in seconds of call to poll
     /// [`EthRequestHandler`](crate::eth_requests::EthRequestHandler).
     pub(crate) acc_duration_poll_eth_req_handler: Gauge,
diff --git a/crates/net/network/src/network.rs b/crates/net/network/src/network.rs
index e188ebd8369..a02ad9a6361 100644
--- a/crates/net/network/src/network.rs
+++ b/crates/net/network/src/network.rs
@@ -16,12 +16,12 @@ use reth_ethereum_forks::Head;
 use reth_network_api::{
     events::{NetworkPeersEvents, PeerEvent, PeerEventStream},
     test_utils::{PeersHandle, PeersHandleProvider},
-    BlockDownloaderProvider, DiscoveryEvent, NetworkError, NetworkEvent,
+    BlockDownloaderProvider, CellCustody, DiscoveryEvent, NetworkError, NetworkEvent,
     NetworkEventListenerProvider, NetworkInfo, NetworkStatus, PeerInfo, PeerRequest, Peers,
     PeersInfo,
 };
 use reth_network_p2p::sync::{NetworkSyncUpdater, SyncState, SyncStateProvider};
-use reth_network_peers::{NodeRecord, PeerId};
+use reth_network_peers::{NodeRecord, PeerId, TrustedPeer};
 use reth_network_types::{PeerAddr, PeerKind, Reputation, ReputationChangeKind};
 use reth_tokio_util::{EventSender, EventStream};
 use secp256k1::SecretKey;
@@ -78,6 +78,7 @@ impl<N: NetworkPrimitives> NetworkHandle<N> {
             is_syncing: Arc::new(AtomicBool::new(false)),
             initial_sync_done: Arc::new(AtomicBool::new(false)),
             chain_id,
+            cell_custody: CellCustody::default(),
             tx_gossip_disabled,
             discv4,
             discv5,
@@ -320,6 +321,10 @@ impl<N: NetworkPrimitives> Peers for NetworkHandle<N> {
         self.send_message(NetworkHandleMessage::AddTrustedPeerId(peer));
     }
 
+    fn add_trusted_peer_node(&self, peer: TrustedPeer) {
+        self.send_message(NetworkHandleMessage::AddTrustedPeerNode(peer));
+    }
+
     /// Sends a message to the [`NetworkManager`](crate::NetworkManager) to add a peer to the known
     /// set, with the given kind.
     fn add_peer_kind(
@@ -427,6 +432,10 @@ impl<N: NetworkPrimitives> NetworkInfo for NetworkHandle<N> {
         self.inner.chain_id.load(Ordering::Relaxed)
     }
 
+    fn cell_custody(&self) -> &CellCustody {
+        &self.inner.cell_custody
+    }
+
     fn is_syncing(&self) -> bool {
         SyncStateProvider::is_syncing(self)
     }
@@ -502,6 +511,8 @@ struct NetworkInner<N: NetworkPrimitives = EthNetworkPrimitives> {
     initial_sync_done: Arc<AtomicBool>,
     /// The chain id
     chain_id: Arc<AtomicU64>,
+    /// Shared blob cell custody bitmap.
+    cell_custody: CellCustody,
     /// Whether to disable transaction gossip
     tx_gossip_disabled: bool,
     /// The instance of the discv4 service
@@ -525,6 +536,8 @@ pub trait NetworkProtocols: Send + Sync {
 pub(crate) enum NetworkHandleMessage<N: NetworkPrimitives = EthNetworkPrimitives> {
     /// Marks a peer as trusted.
     AddTrustedPeerId(PeerId),
+    /// Adds a trusted peer that may use a hostname, registering it for periodic DNS re-resolution.
+    AddTrustedPeerNode(TrustedPeer),
     /// Adds an address for a peer, including its ID, kind, and socket address.
     AddPeerAddress(PeerId, Option<PeerKind>, PeerAddr),
     /// Removes a peer from the peerset corresponding to the given kind.
diff --git a/crates/net/network/src/peers.rs b/crates/net/network/src/peers.rs
index c2e371f8039..aecdb16b944 100644
--- a/crates/net/network/src/peers.rs
+++ b/crates/net/network/src/peers.rs
@@ -8,15 +8,16 @@ use crate::{
 };
 use futures::StreamExt;
 
+use rand::Rng;
 use reth_eth_wire::{errors::EthStreamError, DisconnectReason};
 use reth_ethereum_forks::ForkId;
 use reth_net_banlist::BanList;
 use reth_network_api::test_utils::{PeerCommand, PeersHandle};
-use reth_network_peers::{NodeRecord, PeerId};
+use reth_network_peers::{NodeRecord, PeerId, TrustedPeer};
 use reth_network_types::{
     is_connection_failed_reputation,
     peers::{
-        config::PeerBackoffDurations,
+        config::{PeerBackoffDurations, PEER_ROTATION_MIN_UPTIME},
         reputation::{DEFAULT_REPUTATION, MAX_TRUSTED_PEER_REPUTATION_CHANGE},
     },
     ConnectionsConfig, Peer, PeerAddr, PeerConnectionState, PeerKind, PeersConfig,
@@ -27,13 +28,14 @@ use std::{
     fmt::Display,
     io::{self},
     net::{IpAddr, SocketAddr},
+    pin::Pin,
     task::{Context, Poll},
     time::Duration,
 };
 use thiserror::Error;
 use tokio::{
     sync::mpsc,
-    time::{Instant, Interval},
+    time::{Instant, Interval, Sleep},
 };
 use tokio_stream::wrappers::UnboundedReceiverStream;
 use tracing::{trace, warn};
@@ -95,6 +97,11 @@ pub struct PeersManager {
     /// If true, discovered peers without a confirmed ENR fork ID will not be added until their
     /// fork ID is verified via EIP-868.
     enforce_enr_fork_id: bool,
+    /// One-shot sleep that fires when it's time to rotate a peer; reset with jitter after each
+    /// fire. `None` when rotation is disabled.
+    peer_rotation_sleep: Option<Pin<Box<Sleep>>>,
+    /// Mean duration for computing jittered rotation intervals. `None` when rotation is disabled.
+    peer_rotation_mean: Option<Duration>,
 }
 
 impl PeersManager {
@@ -116,6 +123,7 @@ impl PeersManager {
             incoming_ip_throttle_duration,
             ip_filter,
             enforce_enr_fork_id,
+            peer_rotation_interval,
         } = config;
         let (manager_tx, handle_rx) = mpsc::unbounded_channel();
         let now = Instant::now();
@@ -193,6 +201,9 @@ impl PeersManager {
             incoming_ip_throttle_duration,
             ip_filter,
             enforce_enr_fork_id,
+            peer_rotation_sleep: peer_rotation_interval
+                .map(|mean| Box::pin(tokio::time::sleep(jitter_rotation_interval(mean)))),
+            peer_rotation_mean: peer_rotation_interval,
         }
     }
 
@@ -424,6 +435,7 @@ impl PeersManager {
                 }
 
                 peer.state = PeerConnectionState::In;
+                peer.mark_connected();
 
                 is_trusted = is_trusted || peer.is_trusted();
             }
@@ -431,6 +443,7 @@ impl PeersManager {
                 // peer is missing in the table, we add it but mark it as to be removed after
                 // disconnect, because we only know the outgoing port
                 let mut peer = Peer::with_state(PeerAddr::from_tcp(addr), PeerConnectionState::In);
+                peer.mark_connected();
                 peer.remove_after_disconnect = true;
                 entry.insert(peer);
                 self.queued_actions.push_back(PeerAction::PeerAdded(peer_id));
@@ -580,6 +593,7 @@ impl PeersManager {
         if let Some(peer) = self.peers.get_mut(peer_id) {
             self.connection_info.decr_state(peer.state);
             peer.state = PeerConnectionState::Idle;
+            peer.mark_disconnected();
         }
     }
 
@@ -612,6 +626,7 @@ impl PeersManager {
                     // session to that peer
                     peer.severe_backoff_counter = 0;
                     peer.state = PeerConnectionState::Idle;
+                    peer.mark_disconnected();
 
                     // but we're backing off slightly to avoid dialing the peer again right away, to
                     // give the remote time to also properly register the closed session and clean
@@ -638,6 +653,7 @@ impl PeersManager {
             self.connection_info.decr_state(peer.state);
             self.connection_info.inc_out();
             peer.state = PeerConnectionState::Out;
+            peer.mark_connected();
         }
     }
 
@@ -698,7 +714,9 @@ impl PeersManager {
                 self.connection_info.decr_state(entry.get().state);
                 // only remove if the peer is not trusted
                 if entry.get().is_trusted() {
-                    entry.get_mut().state = PeerConnectionState::Idle;
+                    let peer = entry.get_mut();
+                    peer.state = PeerConnectionState::Idle;
+                    peer.mark_disconnected();
                 } else {
                     entry.remove();
                     self.queued_actions.push_back(PeerAction::PeerRemoved(*peer_id));
@@ -753,6 +771,7 @@ impl PeersManager {
 
                 self.connection_info.decr_state(peer.state);
                 peer.state = PeerConnectionState::Idle;
+                peer.mark_disconnected();
 
                 if peer.severe_backoff_counter > self.max_backoff_count &&
                     !peer.is_trusted() &&
@@ -819,6 +838,15 @@ impl PeersManager {
         self.add_peer_kind(peer_id, Some(PeerKind::Trusted), addr, None)
     }
 
+    /// Adds a trusted peer that may use a hostname instead of an IP address.
+    pub(crate) fn add_trusted_peer_node(&mut self, trusted: TrustedPeer) {
+        let peer_id = trusted.id;
+        self.trusted_peer_ids.insert(peer_id);
+        self.trusted_peers_resolver.remove(peer_id);
+        self.trusted_peers_resolver.trusted_peers.push(trusted);
+        self.trusted_peers_resolver.interval.reset_immediately();
+    }
+
     /// Called for a newly discovered peer.
     ///
     /// If the peer already exists, then the address, kind and `fork_id` will be updated.
@@ -969,7 +997,12 @@ impl PeersManager {
 
     /// Removes the tracked node from the trusted set.
     pub(crate) fn remove_peer_from_trusted_set(&mut self, peer_id: PeerId) {
-        let Entry::Occupied(mut entry) = self.peers.entry(peer_id) else { return };
+        self.trusted_peers_resolver.remove(peer_id);
+
+        let Entry::Occupied(mut entry) = self.peers.entry(peer_id) else {
+            self.trusted_peer_ids.remove(&peer_id);
+            return
+        };
         if !entry.get().is_trusted() {
             return
         }
@@ -1027,6 +1060,53 @@ impl PeersManager {
         Some((*best_peer.0, best_peer.1))
     }
 
+    /// Disconnects one eligible peer (inbound or outbound) to open a slot for new nodes,
+    /// mirroring Geth's peer dropper logic:
+    /// <https://github.com/ethereum/go-ethereum/blob/c5c75977ab55e4d7ea6147cc0e221b588e5e3754/eth/dropper.go#L106-L138>
+    ///
+    /// A peer is eligible when its pool (inbound or outbound) is at capacity, the peer is not
+    /// trusted or static, and it has been connected for at least [`PEER_ROTATION_MIN_UPTIME`].
+    fn try_rotate_peer(&mut self) {
+        let outbound_at_capacity = self.connection_info.is_outbound_at_capacity();
+        let inbound_at_capacity = self.connection_info.is_inbound_at_capacity();
+
+        if !outbound_at_capacity && !inbound_at_capacity {
+            return
+        }
+
+        let now = std::time::Instant::now();
+
+        let candidates = self
+            .peers
+            .iter()
+            .filter_map(|(peer_id, peer)| {
+                let eligible = match peer.state {
+                    PeerConnectionState::Out => outbound_at_capacity,
+                    PeerConnectionState::In => inbound_at_capacity,
+                    _ => false,
+                };
+                (eligible &&
+                    !peer.is_trusted() &&
+                    !peer.is_static() &&
+                    !self.trusted_peer_ids.contains(peer_id) &&
+                    peer.connected_for_at_least(now, PEER_ROTATION_MIN_UPTIME))
+                .then_some(*peer_id)
+            })
+            .collect::<Vec<_>>();
+
+        if candidates.is_empty() {
+            return
+        }
+        let peer_id = candidates[rand::rng().random_range(0..candidates.len())];
+
+        trace!(target: "net::peers", ?peer_id, "rotating peer to open slot for new nodes");
+
+        self.queued_actions.push_back(PeerAction::Disconnect {
+            peer_id,
+            reason: Some(DisconnectReason::UselessPeer),
+        });
+    }
+
     /// If there's capacity for new outbound connections, this will queue new
     /// [`PeerAction::Connect`] actions.
     ///
@@ -1061,17 +1141,25 @@ impl PeersManager {
     }
 
     fn on_resolved_peer(&mut self, peer_id: PeerId, new_record: NodeRecord) {
-        if let Some(peer) = self.peers.get_mut(&peer_id) {
-            let new_addr = PeerAddr::new_with_ports(
-                new_record.address,
-                new_record.tcp_port,
-                Some(new_record.udp_port),
-            );
+        if !self.trusted_peer_ids.contains(&peer_id) {
+            trace!(target: "net::peers", ?peer_id, "Ignoring resolved trusted peer after removal");
+            return
+        }
 
+        let new_addr = PeerAddr::new_with_ports(
+            new_record.address,
+            new_record.tcp_port,
+            Some(new_record.udp_port),
+        );
+
+        if let Some(peer) = self.peers.get_mut(&peer_id) {
             if peer.addr != new_addr {
                 peer.addr = new_addr;
                 trace!(target: "net::peers", ?peer_id, addr=?peer.addr, "Updated resolved trusted peer address");
             }
+        } else {
+            trace!(target: "net::peers", ?peer_id, ?new_addr, "Adding trusted peer after first successful resolution");
+            self.add_peer_kind(peer_id, Some(PeerKind::Trusted), new_addr, None);
         }
     }
 
@@ -1151,6 +1239,22 @@ impl PeersManager {
                 self.on_resolved_peer(peer_id, new_record);
             }
 
+            // Poll the jittered rotation timer and rotate one eligible peer when ready.
+            let rotation_ready = self
+                .peer_rotation_sleep
+                .as_mut()
+                .is_some_and(|sleep| sleep.as_mut().poll(cx).is_ready());
+            if rotation_ready {
+                self.try_rotate_peer();
+                if let Some((mean, sleep)) =
+                    self.peer_rotation_mean.zip(self.peer_rotation_sleep.as_mut())
+                {
+                    sleep
+                        .as_mut()
+                        .reset(tokio::time::Instant::now() + jitter_rotation_interval(mean));
+                }
+            }
+
             if self.queued_actions.is_empty() {
                 return Poll::Pending
             }
@@ -1193,6 +1297,16 @@ impl ConnectionInfo {
             self.num_outbound < self.config.max_outbound
     }
 
+    /// Returns `true` if all active outbound slots are occupied (ignoring pending dials).
+    const fn is_outbound_at_capacity(&self) -> bool {
+        self.num_outbound >= self.config.max_outbound
+    }
+
+    /// Returns `true` if all active inbound slots are occupied.
+    const fn is_inbound_at_capacity(&self) -> bool {
+        self.num_inbound >= self.config.max_inbound
+    }
+
     ///  Returns `true` if there's still capacity to accept a new incoming connection.
     const fn has_in_capacity(&self) -> bool {
         self.num_inbound < self.config.max_inbound
@@ -1337,6 +1451,16 @@ impl BackoffReason {
     }
 }
 
+/// Returns a random duration uniformly distributed in `[mean * 3/5, mean * 7/5]`.
+///
+/// With the default 5-minute mean this gives `[3 min, 7 min]`, matching Geth's peer dropper:
+/// <https://github.com/ethereum/go-ethereum/blob/c5c75977ab55e4d7ea6147cc0e221b588e5e3754/eth/dropper.go#L32-L36>
+fn jitter_rotation_interval(mean: Duration) -> Duration {
+    let min_nanos = (mean * 3 / 5).as_nanos() as u64;
+    let max_nanos = (mean * 7 / 5).as_nanos() as u64;
+    Duration::from_nanos(rand::rng().random_range(min_nanos..=max_nanos))
+}
+
 #[cfg(test)]
 mod tests {
     use alloy_primitives::B512;
@@ -1347,7 +1471,7 @@ mod tests {
     use reth_ethereum_forks::{ForkHash, ForkId};
     use reth_net_banlist::BanList;
     use reth_network_api::Direction;
-    use reth_network_peers::{PeerId, TrustedPeer};
+    use reth_network_peers::{NodeRecord, PeerId, TrustedPeer};
     use reth_network_types::{
         peers::reputation::DEFAULT_REPUTATION, BackoffKind, Peer, ReputationChangeKind,
     };
@@ -1390,6 +1514,14 @@ mod tests {
         };
     }
 
+    fn set_connected_at(
+        peers: &mut PeersManager,
+        peer_id: PeerId,
+        connected_at: std::time::Instant,
+    ) {
+        peers.peers.get_mut(&peer_id).expect("peer exists").connected_at = Some(connected_at);
+    }
+
     #[tokio::test]
     async fn test_insert() {
         let peer = PeerId::random();
@@ -3308,4 +3440,299 @@ mod tests {
         let (best_id, _) = peers.best_unconnected().unwrap();
         assert_eq!(best_id, with_fork, "fork_id should break tie when reputation is equal");
     }
+
+    #[tokio::test]
+    async fn test_add_trusted_peer_node_resolves_absent_peer() {
+        let peer_id = PeerId::random();
+        let trusted = TrustedPeer {
+            host: url::Host::Domain("example.invalid".to_string()),
+            tcp_port: 30303,
+            udp_port: 30303,
+            id: peer_id,
+        };
+
+        let mut manager = PeersManager::default();
+        manager.add_trusted_peer_node(trusted);
+
+        assert!(manager.trusted_peer_ids.contains(&peer_id));
+        assert_eq!(manager.trusted_peers_resolver.trusted_peers.len(), 1);
+        assert!(!manager.peers.contains_key(&peer_id));
+
+        let resolved = NodeRecord {
+            address: "10.0.0.1".parse::<IpAddr>().unwrap(),
+            tcp_port: 30303,
+            udp_port: 30303,
+            id: peer_id,
+        };
+        manager.on_resolved_peer(peer_id, resolved);
+
+        let peer = manager.peers.get(&peer_id).expect("peer should be added after resolution");
+        assert!(peer.kind.is_trusted());
+        assert_eq!(peer.addr.tcp().ip(), "10.0.0.1".parse::<IpAddr>().unwrap());
+    }
+
+    #[tokio::test]
+    async fn test_removed_trusted_peer_ignores_late_resolution() {
+        let peer_id = PeerId::random();
+        let trusted = TrustedPeer {
+            host: url::Host::Domain("example.invalid".to_string()),
+            tcp_port: 30303,
+            udp_port: 30303,
+            id: peer_id,
+        };
+
+        let mut manager = PeersManager::default();
+        manager.add_trusted_peer_node(trusted);
+        manager.remove_peer_from_trusted_set(peer_id);
+
+        let resolved = NodeRecord {
+            address: "10.0.0.1".parse::<IpAddr>().unwrap(),
+            tcp_port: 30303,
+            udp_port: 30303,
+            id: peer_id,
+        };
+        manager.on_resolved_peer(peer_id, resolved);
+
+        assert!(!manager.peers.contains_key(&peer_id));
+        assert!(!manager.trusted_peer_ids.contains(&peer_id));
+    }
+
+    #[tokio::test]
+    async fn test_rotation_disconnects_eligible_peer() {
+        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 1, 2)), 8008);
+        let peer = PeerId::random();
+        let mut peers = PeersManager::new(
+            PeersConfig::test()
+                .with_max_outbound(1)
+                .with_peer_rotation_interval(Some(Duration::from_millis(50))),
+        );
+
+        peers.add_peer(peer, PeerAddr::from_tcp(addr), None);
+        match event!(peers) {
+            PeerAction::PeerAdded(_) => {}
+            _ => unreachable!(),
+        }
+        match event!(peers) {
+            PeerAction::Connect { .. } => {}
+            _ => unreachable!(),
+        }
+        peers.on_active_outgoing_established(peer);
+
+        set_connected_at(
+            &mut peers,
+            peer,
+            std::time::Instant::now() - Duration::from_secs(11 * 60),
+        );
+
+        tokio::time::sleep(Duration::from_millis(100)).await;
+
+        match event!(peers) {
+            PeerAction::Disconnect { peer_id, reason } => {
+                assert_eq!(peer_id, peer);
+                assert_eq!(reason, Some(DisconnectReason::UselessPeer));
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    #[tokio::test]
+    async fn test_rotation_then_remove_uses_active_session_removal() {
+        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 1, 7)), 8008);
+        let peer = PeerId::random();
+        let mut peers = PeersManager::new(
+            PeersConfig::test()
+                .with_max_outbound(1)
+                .with_peer_rotation_interval(Some(Duration::from_millis(50))),
+        );
+
+        peers.add_peer(peer, PeerAddr::from_tcp(addr), None);
+        match event!(peers) {
+            PeerAction::PeerAdded(_) => {}
+            _ => unreachable!(),
+        }
+        match event!(peers) {
+            PeerAction::Connect { .. } => {}
+            _ => unreachable!(),
+        }
+        peers.on_active_outgoing_established(peer);
+        set_connected_at(
+            &mut peers,
+            peer,
+            std::time::Instant::now() - Duration::from_secs(11 * 60),
+        );
+
+        tokio::time::sleep(Duration::from_millis(100)).await;
+
+        match event!(peers) {
+            PeerAction::Disconnect { peer_id, reason } => {
+                assert_eq!(peer_id, peer);
+                assert_eq!(reason, Some(DisconnectReason::UselessPeer));
+            }
+            _ => unreachable!(),
+        }
+        assert_eq!(peers.peers.get(&peer).unwrap().state, PeerConnectionState::Out);
+        assert_eq!(peers.connection_info.num_outbound, 1);
+
+        peers.remove_peer(peer);
+        match event!(peers) {
+            PeerAction::PeerRemoved(peer_id) => assert_eq!(peer_id, peer),
+            _ => unreachable!(),
+        }
+        match event!(peers) {
+            PeerAction::Disconnect { peer_id, reason } => {
+                assert_eq!(peer_id, peer);
+                assert_eq!(reason, Some(DisconnectReason::DisconnectRequested));
+            }
+            _ => unreachable!(),
+        }
+
+        let p = peers.peers.get(&peer).unwrap();
+        assert_eq!(p.state, PeerConnectionState::DisconnectingOut);
+        assert!(p.remove_after_disconnect);
+        assert_eq!(peers.connection_info.num_outbound, 1);
+
+        peers.on_active_session_gracefully_closed(peer);
+        assert_eq!(peers.connection_info.num_outbound, 0);
+        assert!(!peers.peers.contains_key(&peer));
+    }
+
+    #[tokio::test]
+    async fn test_rotation_skips_trusted_peers() {
+        let _addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 1, 3)), 8008);
+        let peer = PeerId::random();
+        let trusted = TrustedPeer {
+            host: Host::Ipv4(Ipv4Addr::new(127, 0, 1, 3)),
+            tcp_port: 8008,
+            udp_port: 8008,
+            id: peer,
+        };
+        let mut peers = PeersManager::new(
+            PeersConfig::test()
+                .with_max_outbound(1)
+                .with_trusted_nodes(vec![trusted])
+                .with_peer_rotation_interval(Some(Duration::from_millis(50))),
+        );
+
+        match event!(peers) {
+            PeerAction::Connect { .. } => {}
+            _ => unreachable!(),
+        }
+        peers.on_active_outgoing_established(peer);
+        set_connected_at(
+            &mut peers,
+            peer,
+            std::time::Instant::now() - Duration::from_secs(11 * 60),
+        );
+
+        tokio::time::sleep(Duration::from_millis(100)).await;
+
+        poll_fn(|cx| {
+            assert!(peers.poll(cx).is_pending(), "trusted peer must not be rotated");
+            Poll::Ready(())
+        })
+        .await;
+    }
+
+    #[tokio::test]
+    async fn test_rotation_skips_recently_connected_peers() {
+        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 1, 4)), 8008);
+        let peer = PeerId::random();
+        let mut peers = PeersManager::new(
+            PeersConfig::test()
+                .with_max_outbound(1)
+                .with_peer_rotation_interval(Some(Duration::from_millis(50))),
+        );
+
+        peers.add_peer(peer, PeerAddr::from_tcp(addr), None);
+        match event!(peers) {
+            PeerAction::PeerAdded(_) => {}
+            _ => unreachable!(),
+        }
+        match event!(peers) {
+            PeerAction::Connect { .. } => {}
+            _ => unreachable!(),
+        }
+        peers.on_active_outgoing_established(peer);
+
+        tokio::time::sleep(Duration::from_millis(100)).await;
+
+        poll_fn(|cx| {
+            assert!(peers.poll(cx).is_pending(), "recently connected peer must not be rotated");
+            Poll::Ready(())
+        })
+        .await;
+    }
+
+    #[tokio::test]
+    async fn test_rotation_skips_when_slots_available() {
+        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 1, 5)), 8008);
+        let peer = PeerId::random();
+        let mut peers = PeersManager::new(
+            PeersConfig::test()
+                .with_max_outbound(2)
+                .with_peer_rotation_interval(Some(Duration::from_millis(50))),
+        );
+
+        peers.add_peer(peer, PeerAddr::from_tcp(addr), None);
+        match event!(peers) {
+            PeerAction::PeerAdded(_) => {}
+            _ => unreachable!(),
+        }
+        match event!(peers) {
+            PeerAction::Connect { .. } => {}
+            _ => unreachable!(),
+        }
+        peers.on_active_outgoing_established(peer);
+        set_connected_at(
+            &mut peers,
+            peer,
+            std::time::Instant::now() - Duration::from_secs(11 * 60),
+        );
+
+        tokio::time::sleep(Duration::from_millis(100)).await;
+
+        poll_fn(|cx| {
+            assert!(
+                peers.poll(cx).is_pending(),
+                "rotation must not fire when outbound slots are available"
+            );
+            Poll::Ready(())
+        })
+        .await;
+    }
+
+    #[tokio::test]
+    async fn test_rotation_disconnects_inbound_peer() {
+        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 1, 6)), 8008);
+        let peer = PeerId::random();
+        let mut peers = PeersManager::new(
+            PeersConfig::test()
+                .with_max_inbound(1)
+                .with_peer_rotation_interval(Some(Duration::from_millis(50))),
+        );
+
+        assert!(peers.on_incoming_pending_session(addr.ip()).is_ok());
+        peers.on_incoming_session_established(peer, addr);
+
+        match event!(peers) {
+            PeerAction::PeerAdded(_) => {}
+            _ => unreachable!(),
+        }
+
+        set_connected_at(
+            &mut peers,
+            peer,
+            std::time::Instant::now() - Duration::from_secs(11 * 60),
+        );
+
+        tokio::time::sleep(Duration::from_millis(100)).await;
+
+        match event!(peers) {
+            PeerAction::Disconnect { peer_id, reason } => {
+                assert_eq!(peer_id, peer);
+                assert_eq!(reason, Some(DisconnectReason::UselessPeer));
+            }
+            _ => unreachable!(),
+        }
+    }
 }
diff --git a/crates/net/network/src/session/active.rs b/crates/net/network/src/session/active.rs
index e5765dcbcf3..fd2168f35b5 100644
--- a/crates/net/network/src/session/active.rs
+++ b/crates/net/network/src/session/active.rs
@@ -294,6 +294,9 @@ impl<N: NetworkPrimitives> ActiveSession<N> {
             EthMessage::NewPooledTransactionHashes68(msg) => {
                 self.try_emit_broadcast(PeerMessage::PooledTransactions(msg.into())).into()
             }
+            EthMessage::NewPooledTransactionHashes72(msg) => {
+                self.try_emit_broadcast(PeerMessage::PooledTransactions(msg.into())).into()
+            }
             EthMessage::GetBlockHeaders(req) => {
                 on_request!(req, BlockHeaders, GetBlockHeaders)
             }
@@ -343,6 +346,9 @@ impl<N: NetworkPrimitives> ActiveSession<N> {
             EthMessage::BlockAccessLists(resp) => {
                 on_response!(resp, GetBlockAccessLists)
             }
+            EthMessage::Cells(resp) => {
+                on_response!(resp, GetCells)
+            }
             EthMessage::BlockRangeUpdate(msg) => {
                 // Validate that earliest <= latest according to the spec
                 if msg.earliest > msg.latest {
@@ -371,6 +377,9 @@ impl<N: NetworkPrimitives> ActiveSession<N> {
 
                 OnIncomingMessageOutcome::Ok
             }
+            EthMessage::GetCells(resp) => {
+                on_request!(resp, Cells, GetCells)
+            }
             EthMessage::Other(bytes) => self.try_emit_broadcast(PeerMessage::Other(bytes)).into(),
         }
     }
@@ -983,6 +992,7 @@ impl<N: NetworkPrimitives> OutgoingMessage<N> {
                 EthMessage::NewBlockHashes(h) => h.len(),
                 EthMessage::NewPooledTransactionHashes66(h) => h.len(),
                 EthMessage::NewPooledTransactionHashes68(h) => h.hashes.len(),
+                EthMessage::NewPooledTransactionHashes72(h) => h.hashes.len(),
                 _ => 0,
             },
             Self::Broadcast(msg) => match msg {
@@ -1017,6 +1027,15 @@ impl<N: NetworkPrimitives> OutgoingMessage<N> {
                 existing.types.extend(inc.types);
                 None
             }
+            (
+                EthMessage::NewPooledTransactionHashes72(existing),
+                NewPooledTransactionHashes::Eth72(inc),
+            ) => {
+                existing.hashes.extend(inc.hashes);
+                existing.sizes.extend(inc.sizes);
+                existing.types.extend(inc.types);
+                None
+            }
             (_, incoming) => Some(incoming),
         }
     }
@@ -1079,7 +1098,7 @@ impl<N: NetworkPrimitives> QueuedOutgoingMessages<N> {
     }
 
     /// Pushes a pooled transaction hash announcement, merging into the last queued message if
-    /// it is the same variant (eth66 or eth68).
+    /// it is the same variant (eth66, eth68, or eth72).
     pub(crate) fn push_pooled_hashes(&mut self, msg: NewPooledTransactionHashes) {
         let msg = if let Some(last) = self.messages.back_mut() {
             match last.try_merge_hashes(msg) {
@@ -1120,7 +1139,9 @@ mod tests {
         GetBlockBodies, HelloMessageWithProtocols, P2PStream, StatusBuilder, UnauthedEthStream,
         UnauthedP2PStream, UnifiedStatus,
     };
-    use reth_eth_wire_types::{message::MAX_MESSAGE_SIZE, EthMessageID, RawCapabilityMessage};
+    use reth_eth_wire_types::{
+        message::MAX_MESSAGE_SIZE, EthMessageID, NewPooledTransactionHashes72, RawCapabilityMessage,
+    };
     use reth_ethereum_forks::EthereumHardfork;
     use reth_network_peers::pk2id;
     use reth_network_types::session::config::PROTOCOL_BREACH_REQUEST_TIMEOUT;
@@ -1460,6 +1481,22 @@ mod tests {
         }
     }
 
+    #[test]
+    fn eth72_pooled_hashes_count_broadcast_items() {
+        let hashes =
+            vec![alloy_primitives::B256::repeat_byte(1), alloy_primitives::B256::repeat_byte(2)];
+        let msg: OutgoingMessage<EthNetworkPrimitives> =
+            EthMessage::NewPooledTransactionHashes72(NewPooledTransactionHashes72 {
+                types: vec![0; hashes.len()],
+                sizes: vec![1; hashes.len()],
+                hashes,
+                cell_mask: None,
+            })
+            .into();
+
+        assert_eq!(2, msg.broadcast_item_count());
+    }
+
     #[test]
     fn test_reject_bal_request_for_eth70() {
         let (tx, _rx) = oneshot::channel();
diff --git a/crates/net/network/src/session/handle.rs b/crates/net/network/src/session/handle.rs
index 75d4669abd3..92a22bac633 100644
--- a/crates/net/network/src/session/handle.rs
+++ b/crates/net/network/src/session/handle.rs
@@ -74,6 +74,11 @@ pub struct ActiveSessionHandle<N: NetworkPrimitives> {
     pub(crate) remote_addr: SocketAddr,
     /// The local address of the connection.
     pub(crate) local_addr: Option<SocketAddr>,
+    /// The TCP listening port the peer announced in its `Hello` message, if non-zero.
+    ///
+    /// This is effectively deprecated, but we still keep it around if a peer announced it as it's
+    /// likely still more useful than the ephemeral source port.
+    pub(crate) peer_listen_port: Option<u16>,
     /// The Status message the peer sent for the `eth` handshake
     pub(crate) status: Arc<UnifiedStatus>,
 }
@@ -141,10 +146,24 @@ impl<N: NetworkPrimitives> ActiveSessionHandle<N> {
 
     /// Extracts the [`PeerInfo`] from the session handle.
     pub(crate) fn peer_info(&self, record: &NodeRecord, kind: PeerKind) -> PeerInfo {
+        // For inbound connections, the `record` was built from the TCP socket address, which
+        // carries the peer's OS-assigned ephemeral source port (not dialable). If the peer
+        // announced a non-zero listening port in its `Hello` message, prefer that combined with
+        // the connection IP so the resulting enode is actually dialable.
+        let enode = match (self.direction, self.peer_listen_port) {
+            (Direction::Incoming, Some(port)) => NodeRecord::new_with_ports(
+                self.remote_addr.ip(),
+                port,
+                Some(record.udp_port),
+                record.id,
+            )
+            .to_string(),
+            _ => record.to_string(),
+        };
         PeerInfo {
             remote_id: self.remote_id,
             direction: self.direction,
-            enode: record.to_string(),
+            enode,
             enr: None,
             remote_addr: self.remote_addr,
             local_addr: self.local_addr,
@@ -288,6 +307,10 @@ pub enum PendingSessionEvent<N: NetworkPrimitives> {
         direction: Direction,
         /// The remote node's user agent, usually containing the client name and version
         client_id: String,
+        /// The TCP listening port the peer announced in its `Hello` message, if non-zero.
+        ///
+        /// See `ActiveSessionHandle::peer_listen_port` for context.
+        peer_listen_port: Option<u16>,
     },
     /// Handshake unsuccessful, session was disconnected.
     Disconnected {
diff --git a/crates/net/network/src/session/mod.rs b/crates/net/network/src/session/mod.rs
index 2322d07567d..170dc012fdc 100644
--- a/crates/net/network/src/session/mod.rs
+++ b/crates/net/network/src/session/mod.rs
@@ -505,6 +505,7 @@ impl<N: NetworkPrimitives> SessionManager<N> {
                 status,
                 direction,
                 client_id,
+                peer_listen_port,
             } => {
                 // move from pending to established.
                 self.remove_pending_session(&session_id);
@@ -618,6 +619,7 @@ impl<N: NetworkPrimitives> SessionManager<N> {
                     client_version: Arc::clone(&client_version),
                     remote_addr,
                     local_addr,
+                    peer_listen_port,
                 };
 
                 self.active_sessions.insert(peer_id, handle);
@@ -1206,6 +1208,9 @@ async fn authenticate_stream<N: NetworkPrimitives>(
         (multiplex_stream.into(), their_status)
     };
 
+    // `port` field is effectively deprecated, so we treat 0 value as a missing port.
+    let peer_listen_port = (their_hello.port != 0).then_some(their_hello.port);
+
     PendingSessionEvent::Established {
         session_id,
         remote_addr,
@@ -1216,5 +1221,6 @@ async fn authenticate_stream<N: NetworkPrimitives>(
         conn,
         direction,
         client_id: their_hello.client_version,
+        peer_listen_port,
     }
 }
diff --git a/crates/net/network/src/state.rs b/crates/net/network/src/state.rs
index e6d300b39ff..2cc0acce6f2 100644
--- a/crates/net/network/src/state.rs
+++ b/crates/net/network/src/state.rs
@@ -307,6 +307,11 @@ impl<N: NetworkPrimitives> NetworkState<N> {
         self.peers_manager.add_trusted_peer_id(peer_id)
     }
 
+    /// Adds a trusted peer that may use a hostname, with periodic DNS re-resolution.
+    pub(crate) fn add_trusted_peer_node(&mut self, trusted: reth_network_peers::TrustedPeer) {
+        self.peers_manager.add_trusted_peer_node(trusted)
+    }
+
     /// Adds a peer and its address with the given kind to the peerset.
     pub(crate) fn add_peer_kind(
         &mut self,
diff --git a/crates/net/network/src/test_utils/transactions.rs b/crates/net/network/src/test_utils/transactions.rs
index 49b4030d1de..bb51cd3c56a 100644
--- a/crates/net/network/src/test_utils/transactions.rs
+++ b/crates/net/network/src/test_utils/transactions.rs
@@ -63,7 +63,7 @@ pub fn buffer_hash_to_tx_fetcher(
     match tx_fetcher.hashes_fetch_inflight_and_pending_fetch.get_or_insert(hash, || {
         TxFetchMetadata::new(
             retries,
-            LruCache::new(DEFAULT_MAX_COUNT_FALLBACK_PEERS as u32),
+            LruCache::with_hasher(DEFAULT_MAX_COUNT_FALLBACK_PEERS as u32, Default::default()),
             tx_encoded_length,
         )
     }) {
diff --git a/crates/net/network/src/transactions/fetcher.rs b/crates/net/network/src/transactions/fetcher.rs
index 3310c3eef16..f3dda344ae4 100644
--- a/crates/net/network/src/transactions/fetcher.rs
+++ b/crates/net/network/src/transactions/fetcher.rs
@@ -36,7 +36,7 @@ use crate::{
     metrics::TransactionFetcherMetrics,
 };
 use alloy_consensus::transaction::PooledTransaction;
-use alloy_primitives::TxHash;
+use alloy_primitives::{map::FbBuildHasher, TxHash};
 use derive_more::{Constructor, Deref};
 use futures::{stream::FuturesUnordered, Future, FutureExt, Stream, StreamExt};
 use pin_project::pin_project;
@@ -67,7 +67,7 @@ use tracing::trace;
 #[pin_project]
 pub struct TransactionFetcher<N: NetworkPrimitives = EthNetworkPrimitives> {
     /// All peers with to which a [`GetPooledTransactions`] request is inflight.
-    pub active_peers: LruMap<PeerId, u8, ByLength>,
+    pub active_peers: LruMap<PeerId, u8, ByLength, FbBuildHasher<64>>,
     /// All currently active [`GetPooledTransactions`] requests.
     ///
     /// The set of hashes encompassed by these requests are a subset of all hashes in the fetcher.
@@ -79,9 +79,10 @@ pub struct TransactionFetcher<N: NetworkPrimitives = EthNetworkPrimitives> {
     ///
     /// This is a subset of all hashes in the fetcher, and is disjoint from the set of hashes for
     /// which a [`GetPooledTransactions`] request is inflight.
-    pub hashes_pending_fetch: LruCache<TxHash>,
+    pub hashes_pending_fetch: LruCache<TxHash, FbBuildHasher<32>>,
     /// Tracks all hashes in the transaction fetcher.
-    pub hashes_fetch_inflight_and_pending_fetch: LruMap<TxHash, TxFetchMetadata, ByLength>,
+    pub hashes_fetch_inflight_and_pending_fetch:
+        LruMap<TxHash, TxFetchMetadata, ByLength, FbBuildHasher<32>>,
     /// Info on capacity of the transaction fetcher.
     pub info: TransactionFetcherInfo,
     #[doc(hidden)]
@@ -133,10 +134,14 @@ impl<N: NetworkPrimitives> TransactionFetcher<N> {
         metrics.capacity_inflight_requests.increment(max_inflight_requests as u64);
 
         Self {
-            active_peers: LruMap::new(max_inflight_requests),
-            hashes_pending_fetch: LruCache::new(max_capacity_cache_txns_pending_fetch),
-            hashes_fetch_inflight_and_pending_fetch: LruMap::new(
+            active_peers: LruMap::with_hasher(max_inflight_requests, Default::default()),
+            hashes_pending_fetch: LruCache::with_hasher(
+                max_capacity_cache_txns_pending_fetch,
+                Default::default(),
+            ),
+            hashes_fetch_inflight_and_pending_fetch: LruMap::with_hasher(
                 max_inflight_requests + max_capacity_cache_txns_pending_fetch,
+                Default::default(),
             ),
             info,
             metrics,
@@ -238,7 +243,7 @@ impl<N: NetworkPrimitives> TransactionFetcher<N> {
         hashes_to_request: &mut RequestTxHashes,
         hashes_from_announcement: ValidAnnouncementData,
     ) -> RequestTxHashes {
-        if hashes_from_announcement.msg_version().is_eth68() {
+        if hashes_from_announcement.msg_version().has_eth68_metadata() {
             return self.pack_request_eth68(hashes_to_request, hashes_from_announcement)
         }
         self.pack_request_eth66(hashes_to_request, hashes_from_announcement)
@@ -283,11 +288,12 @@ impl<N: NetworkPrimitives> TransactionFetcher<N> {
                 unreachable!("this method is called upon reception of an eth68 announcement")
             };
 
-            let next_acc_size = acc_size_response + size;
+            let next_acc_size = acc_size_response.checked_add(size).filter(|next_acc_size| {
+                *next_acc_size <=
+                    self.info.soft_limit_byte_size_pooled_transactions_response_on_pack_request
+            });
 
-            if next_acc_size <=
-                self.info.soft_limit_byte_size_pooled_transactions_response_on_pack_request
-            {
+            if let Some(next_acc_size) = next_acc_size {
                 // only update accumulated size of tx response if tx will fit in without exceeding
                 // soft limit
                 acc_size_response = next_acc_size;
@@ -550,9 +556,18 @@ impl<N: NetworkPrimitives> TransactionFetcher<N> {
 
             previously_unseen_hashes_count += 1;
 
-            if self.hashes_fetch_inflight_and_pending_fetch.get_or_insert(*hash, ||
-                TxFetchMetadata{retries: 0, fallback_peers: LruCache::new(DEFAULT_MAX_COUNT_FALLBACK_PEERS as u32), tx_encoded_length: None}
-            ).is_none() {
+            if self
+                .hashes_fetch_inflight_and_pending_fetch
+                .get_or_insert(*hash, || TxFetchMetadata {
+                    retries: 0,
+                    fallback_peers: LruCache::with_hasher(
+                        DEFAULT_MAX_COUNT_FALLBACK_PEERS as u32,
+                        Default::default(),
+                    ),
+                    tx_encoded_length: None,
+                })
+                .is_none()
+            {
 
                 trace!(target: "net::tx",
                     peer_id=format!("{peer_id:#}"),
@@ -685,7 +700,7 @@ impl<N: NetworkPrimitives> TransactionFetcher<N> {
     pub fn fill_request_from_hashes_pending_fetch(
         &mut self,
         hashes_to_request: &mut RequestTxHashes,
-        seen_hashes: &LruCache<TxHash>,
+        seen_hashes: &LruCache<TxHash, FbBuildHasher<32>>,
         mut budget_fill_request: Option<usize>, // check max `budget` lru pending hashes
     ) {
         let Some(hash) = hashes_to_request.iter().next() else { return };
@@ -721,7 +736,7 @@ impl<N: NetworkPrimitives> TransactionFetcher<N> {
                 .and_then(|entry| entry.tx_encoded_len())
                 .unwrap_or(AVERAGE_BYTE_SIZE_TX_ENCODED);
 
-            acc_size_response += size;
+            acc_size_response = acc_size_response.saturating_add(size);
 
             // 4. Check if acc size or hashes count is at limit, if so stop looping.
             // if expected response is full enough or the number of hashes in the request is
@@ -991,11 +1006,18 @@ impl<N: NetworkPrimitives> Stream for TransactionFetcher<N> {
 impl<T: NetworkPrimitives> Default for TransactionFetcher<T> {
     fn default() -> Self {
         Self {
-            active_peers: LruMap::new(DEFAULT_MAX_COUNT_CONCURRENT_REQUESTS),
+            active_peers: LruMap::with_hasher(
+                DEFAULT_MAX_COUNT_CONCURRENT_REQUESTS,
+                Default::default(),
+            ),
             inflight_requests: Default::default(),
-            hashes_pending_fetch: LruCache::new(DEFAULT_MAX_CAPACITY_CACHE_PENDING_FETCH),
-            hashes_fetch_inflight_and_pending_fetch: LruMap::new(
+            hashes_pending_fetch: LruCache::with_hasher(
+                DEFAULT_MAX_CAPACITY_CACHE_PENDING_FETCH,
+                Default::default(),
+            ),
+            hashes_fetch_inflight_and_pending_fetch: LruMap::with_hasher(
                 DEFAULT_MAX_CAPACITY_CACHE_INFLIGHT_AND_PENDING_FETCH,
+                Default::default(),
             ),
             info: TransactionFetcherInfo::default(),
             metrics: Default::default(),
@@ -1009,7 +1031,7 @@ pub struct TxFetchMetadata {
     /// The number of times a request attempt has been made for the hash.
     retries: u8,
     /// Peers that have announced the hash, but to which a request attempt has not yet been made.
-    fallback_peers: LruCache<PeerId>,
+    fallback_peers: LruCache<PeerId, FbBuildHasher<64>>,
     /// Size metadata of the transaction if it has been seen in an eth68 announcement.
     // todo: store all seen sizes as a `(size, peer_id)` tuple to catch peers that respond with
     // another size tx than they announced. alt enter in request (won't catch peers announcing
@@ -1019,7 +1041,7 @@ pub struct TxFetchMetadata {
 
 impl TxFetchMetadata {
     /// Returns a mutable reference to the fallback peers cache for this transaction hash.
-    pub const fn fallback_peers_mut(&mut self) -> &mut LruCache<PeerId> {
+    pub const fn fallback_peers_mut(&mut self) -> &mut LruCache<PeerId, FbBuildHasher<64>> {
         &mut self.fallback_peers
     }
 
@@ -1287,12 +1309,16 @@ struct TxFetcherSearchDurations {
 mod test {
     use super::*;
     use crate::test_utils::transactions::{buffer_hash_to_tx_fetcher, new_mock_session};
-    use alloy_primitives::{hex, B256};
+    use alloy_primitives::{
+        hex,
+        map::{B256Map, B256Set, HashMap},
+        B256,
+    };
     use alloy_rlp::Decodable;
     use derive_more::IntoIterator;
     use reth_eth_wire_types::EthVersion;
     use reth_ethereum_primitives::TransactionSigned;
-    use std::{collections::HashSet, str::FromStr};
+    use std::str::FromStr;
 
     #[derive(IntoIterator)]
     struct TestValidAnnouncementData(Vec<(TxHash, Option<(u8, usize)>)>);
@@ -1341,10 +1367,10 @@ mod test {
         ];
 
         let expected_request_hashes =
-            [eth68_hashes[0], eth68_hashes[2]].into_iter().collect::<HashSet<_>>();
+            [eth68_hashes[0], eth68_hashes[2]].into_iter().collect::<B256Set>();
 
         let expected_surplus_hashes =
-            [eth68_hashes[1], eth68_hashes[3], eth68_hashes[4]].into_iter().collect::<HashSet<_>>();
+            [eth68_hashes[1], eth68_hashes[3], eth68_hashes[4]].into_iter().collect::<B256Set>();
 
         let mut eth68_hashes_to_request = RequestTxHashes::with_capacity(3);
 
@@ -1361,13 +1387,76 @@ mod test {
         let surplus_eth68_hashes =
             tx_fetcher.pack_request_eth68(&mut eth68_hashes_to_request, valid_announcement_data);
 
-        let eth68_hashes_to_request = eth68_hashes_to_request.into_iter().collect::<HashSet<_>>();
-        let surplus_eth68_hashes = surplus_eth68_hashes.into_iter().collect::<HashSet<_>>();
+        let eth68_hashes_to_request = eth68_hashes_to_request.into_iter().collect::<B256Set>();
+        let surplus_eth68_hashes = surplus_eth68_hashes.into_iter().collect::<B256Set>();
 
         assert_eq!(expected_request_hashes, eth68_hashes_to_request);
         assert_eq!(expected_surplus_hashes, surplus_eth68_hashes);
     }
 
+    #[test]
+    fn pack_eth68_request_does_not_overflow_announced_size() {
+        reth_tracing::init_test_tracing();
+
+        let tx_fetcher = &mut TransactionFetcher::<EthNetworkPrimitives>::default();
+
+        let eth68_hashes =
+            [B256::from_slice(&[1; 32]), B256::from_slice(&[2; 32]), B256::from_slice(&[3; 32])];
+        let eth68_sizes = [
+            DEFAULT_SOFT_LIMIT_BYTE_SIZE_POOLED_TRANSACTIONS_RESP_ON_PACK_GET_POOLED_TRANSACTIONS_REQ - MEDIAN_BYTE_SIZE_SMALL_LEGACY_TX_ENCODED - 1,
+            usize::MAX,
+            2,
+        ];
+
+        let expected_request_hashes =
+            [eth68_hashes[0], eth68_hashes[2]].into_iter().collect::<B256Set>();
+        let expected_surplus_hashes = std::iter::once(eth68_hashes[1]).collect::<B256Set>();
+
+        let mut eth68_hashes_to_request = RequestTxHashes::with_capacity(3);
+        let valid_announcement_data = TestValidAnnouncementData(
+            eth68_hashes
+                .into_iter()
+                .zip(eth68_sizes)
+                .map(|(hash, size)| (hash, Some((0u8, size))))
+                .collect::<Vec<_>>(),
+        );
+
+        let surplus_eth68_hashes =
+            tx_fetcher.pack_request_eth68(&mut eth68_hashes_to_request, valid_announcement_data);
+
+        let eth68_hashes_to_request = eth68_hashes_to_request.into_iter().collect::<B256Set>();
+        let surplus_eth68_hashes = surplus_eth68_hashes.into_iter().collect::<B256Set>();
+
+        assert_eq!(expected_request_hashes, eth68_hashes_to_request);
+        assert_eq!(expected_surplus_hashes, surplus_eth68_hashes);
+    }
+
+    #[test]
+    fn pack_eth72_request_uses_metadata_size_limit() {
+        reth_tracing::init_test_tracing();
+
+        let tx_fetcher = &mut TransactionFetcher::<EthNetworkPrimitives>::default();
+
+        let hashes =
+            [B256::from_slice(&[1; 32]), B256::from_slice(&[2; 32]), B256::from_slice(&[3; 32])];
+        let announced_size =
+            DEFAULT_SOFT_LIMIT_BYTE_SIZE_POOLED_TRANSACTIONS_RESP_ON_PACK_GET_POOLED_TRANSACTIONS_REQ;
+        let announcement_data = hashes
+            .into_iter()
+            .map(|hash| (hash, Some((0u8, announced_size))))
+            .collect::<B256Map<_>>();
+        let valid_announcement_data = ValidAnnouncementData::from_partially_valid_data(
+            PartiallyValidData::from_raw_data_eth72(announcement_data),
+        );
+
+        let mut hashes_to_request = RequestTxHashes::with_capacity(3);
+        let surplus_hashes =
+            tx_fetcher.pack_request(&mut hashes_to_request, valid_announcement_data);
+
+        assert_eq!(1, hashes_to_request.len());
+        assert_eq!(2, surplus_hashes.len());
+    }
+
     #[tokio::test]
     async fn test_on_fetch_pending_hashes() {
         reth_tracing::init_test_tracing();
@@ -1448,8 +1537,8 @@ mod test {
         let GetPooledTransactions(requested_hashes) = request;
 
         assert_eq!(
-            requested_hashes.into_iter().collect::<HashSet<_>>(),
-            seen_hashes.into_iter().collect::<HashSet<_>>()
+            requested_hashes.into_iter().collect::<B256Set>(),
+            seen_hashes.into_iter().collect::<B256Set>()
         )
     }
 
diff --git a/crates/net/network/src/transactions/mod.rs b/crates/net/network/src/transactions/mod.rs
index 3920cc3056e..85edcc82598 100644
--- a/crates/net/network/src/transactions/mod.rs
+++ b/crates/net/network/src/transactions/mod.rs
@@ -37,14 +37,17 @@ use crate::{
     transactions::config::{StrictEthAnnouncementFilter, TransactionPropagationKind},
     NetworkHandle, TxTypesCounter,
 };
-use alloy_primitives::{TxHash, B256};
+use alloy_primitives::{
+    map::{B256Map, B256Set, FbBuildHasher},
+    TxHash, B256,
+};
 use constants::SOFT_LIMIT_COUNT_HASHES_IN_NEW_POOLED_TRANSACTIONS_BROADCAST_MESSAGE;
 use futures::{stream::FuturesUnordered, Future, StreamExt};
 use reth_eth_wire::{
     DedupPayload, EthNetworkPrimitives, EthVersion, GetPooledTransactions, HandleMempoolData,
     HandleVersionedMempoolData, NetworkPrimitives, NewPooledTransactionHashes,
-    NewPooledTransactionHashes66, NewPooledTransactionHashes68, PooledTransactions,
-    RequestTxHashes, Transactions, ValidAnnouncementData,
+    NewPooledTransactionHashes66, NewPooledTransactionHashes68, NewPooledTransactionHashes72,
+    PooledTransactions, RequestTxHashes, Transactions, ValidAnnouncementData,
 };
 use reth_ethereum_primitives::{TransactionSigned, TxType};
 use reth_metrics::common::mpsc::MemoryBoundedReceiver;
@@ -184,7 +187,7 @@ impl<N: NetworkPrimitives> TransactionsHandle<N> {
     pub async fn get_transaction_hashes(
         &self,
         peers: Vec<PeerId>,
-    ) -> Result<HashMap<PeerId, HashSet<TxHash>>, RecvError> {
+    ) -> Result<HashMap<PeerId, B256Set>, RecvError> {
         if peers.is_empty() {
             return Ok(Default::default())
         }
@@ -194,10 +197,7 @@ impl<N: NetworkPrimitives> TransactionsHandle<N> {
     }
 
     /// Request the transaction hashes known by a specific peer.
-    pub async fn get_peer_transaction_hashes(
-        &self,
-        peer: PeerId,
-    ) -> Result<HashSet<TxHash>, RecvError> {
+    pub async fn get_peer_transaction_hashes(&self, peer: PeerId) -> Result<B256Set, RecvError> {
         let res = self.get_transaction_hashes(vec![peer]).await?;
         Ok(res.into_values().next().unwrap_or_default())
     }
@@ -293,7 +293,7 @@ pub struct TransactionsManager<Pool, N: NetworkPrimitives = EthNetworkPrimitives
     ///
     /// This way we can track incoming transactions and prevent multiple pool imports for the same
     /// transaction
-    transactions_by_peers: HashMap<TxHash, HashSet<PeerId>>,
+    transactions_by_peers: B256Map<HashSet<PeerId>>,
     /// Transactions that are currently imported into the `Pool`.
     ///
     /// The import process includes:
@@ -309,7 +309,7 @@ pub struct TransactionsManager<Pool, N: NetworkPrimitives = EthNetworkPrimitives
     /// Stats on pending pool imports that help the node self-monitor.
     pending_pool_imports_info: PendingPoolImportsInfo,
     /// Bad imports.
-    bad_imports: LruCache<TxHash>,
+    bad_imports: LruCache<TxHash, FbBuildHasher<32>>,
     /// All the connected peers.
     peers: HashMap<PeerId, PeerMetadata<N>>,
     /// Send half for the command channel.
@@ -402,7 +402,7 @@ impl<Pool: TransactionPool, N: NetworkPrimitives> TransactionsManager<Pool, N> {
             transactions_by_peers: Default::default(),
             pool_imports: Default::default(),
             pending_pool_imports_info,
-            bad_imports: LruCache::new(DEFAULT_MAX_COUNT_BAD_IMPORTS),
+            bad_imports: LruCache::with_hasher(DEFAULT_MAX_COUNT_BAD_IMPORTS, Default::default()),
             peers: Default::default(),
             command_tx,
             command_rx: UnboundedReceiverStream::new(command_rx),
@@ -673,21 +673,21 @@ impl<Pool: TransactionPool, N: NetworkPrimitives> TransactionsManager<Pool, N> {
         let mut should_report_peer = false;
         let mut tx_types_counter = TxTypesCounter::default();
 
-        let is_eth68_message = partially_valid_msg
+        let has_eth68_metadata = partially_valid_msg
             .msg_version()
             .expect("partially valid announcement should have a version")
-            .is_eth68();
+            .has_eth68_metadata();
 
         partially_valid_msg.retain(|tx_hash, metadata_ref_mut| {
             let (ty_byte, size_val) = match *metadata_ref_mut {
                 Some((ty, size)) => {
-                    if !is_eth68_message {
+                    if !has_eth68_metadata {
                         should_report_peer = true;
                     }
                     (ty, size)
                 }
                 None => {
-                    if is_eth68_message {
+                    if has_eth68_metadata {
                         should_report_peer = true;
                         return false;
                     }
@@ -695,7 +695,7 @@ impl<Pool: TransactionPool, N: NetworkPrimitives> TransactionsManager<Pool, N> {
                 }
             };
 
-            if is_eth68_message && let Some((actual_ty_byte, _)) = *metadata_ref_mut {
+            if has_eth68_metadata && let Some((actual_ty_byte, _)) = *metadata_ref_mut {
                 match TxType::try_from(actual_ty_byte) {
                     Ok(parsed_tx_type) => tx_types_counter.increase_by_tx_type(parsed_tx_type),
                     Err(_) => tx_types_counter.increase_other(),
@@ -719,7 +719,7 @@ impl<Pool: TransactionPool, N: NetworkPrimitives> TransactionsManager<Pool, N> {
             }
         });
 
-        if is_eth68_message {
+        if has_eth68_metadata {
             self.announced_tx_types_metrics.update_eth68_announcement_metrics(tx_types_counter);
         }
 
@@ -1192,7 +1192,7 @@ where
                     let hashes = self
                         .peers
                         .get(&peer_id)
-                        .map(|peer| peer.seen_transactions.iter().copied().collect::<HashSet<_>>())
+                        .map(|peer| peer.seen_transactions.iter().copied().collect::<B256Set>())
                         .unwrap_or_default();
                     res.insert(peer_id, hashes);
                 }
@@ -1916,6 +1916,7 @@ impl<T: SignedTransaction> FullTransactionsBuilder<T> {
 enum PooledTransactionsHashesBuilder {
     Eth66(NewPooledTransactionHashes66),
     Eth68(NewPooledTransactionHashes68),
+    Eth72(NewPooledTransactionHashes72),
 }
 
 // === impl PooledTransactionsHashesBuilder ===
@@ -1930,6 +1931,11 @@ impl PooledTransactionsHashesBuilder {
                 msg.sizes.push(pooled_tx.encoded_length());
                 msg.types.push(pooled_tx.transaction.ty());
             }
+            Self::Eth72(msg) => {
+                msg.hashes.push(*pooled_tx.hash());
+                msg.sizes.push(pooled_tx.encoded_length());
+                msg.types.push(pooled_tx.transaction.ty());
+            }
         }
     }
 
@@ -1938,6 +1944,7 @@ impl PooledTransactionsHashesBuilder {
         match self {
             Self::Eth66(hashes) => hashes.is_empty(),
             Self::Eth68(hashes) => hashes.is_empty(),
+            Self::Eth72(hashes) => hashes.is_empty(),
         }
     }
 
@@ -1946,6 +1953,7 @@ impl PooledTransactionsHashesBuilder {
         match self {
             Self::Eth66(hashes) => hashes.len(),
             Self::Eth68(hashes) => hashes.len(),
+            Self::Eth72(hashes) => hashes.len(),
         }
     }
 
@@ -1967,6 +1975,11 @@ impl PooledTransactionsHashesBuilder {
                 msg.sizes.push(tx.size);
                 msg.types.push(tx.transaction.ty());
             }
+            Self::Eth72(msg) => {
+                msg.hashes.push(*tx.tx_hash());
+                msg.sizes.push(tx.size);
+                msg.types.push(tx.transaction.ty());
+            }
         }
     }
 
@@ -1977,6 +1990,7 @@ impl PooledTransactionsHashesBuilder {
             EthVersion::Eth68 | EthVersion::Eth69 | EthVersion::Eth70 | EthVersion::Eth71 => {
                 Self::Eth68(Default::default())
             }
+            EthVersion::Eth72 => Self::Eth72(Default::default()),
         }
     }
 
@@ -1990,6 +2004,10 @@ impl PooledTransactionsHashesBuilder {
                 msg.shrink_to_fit();
                 msg.into()
             }
+            Self::Eth72(mut msg) => {
+                msg.shrink_to_fit();
+                msg.into()
+            }
         }
     }
 }
@@ -2017,7 +2035,7 @@ pub struct PeerMetadata<N: NetworkPrimitives = EthNetworkPrimitives> {
     /// Optimistically keeps track of transactions that we know the peer has seen. Optimistic, in
     /// the sense that transactions are preemptively marked as seen by peer when they are sent to
     /// the peer.
-    seen_transactions: LruCache<TxHash>,
+    seen_transactions: LruCache<TxHash, FbBuildHasher<32>>,
     /// A communication channel directly to the peer's session task.
     request_tx: PeerRequestSender<PeerRequest<N>>,
     /// negotiated version of the session.
@@ -2038,7 +2056,10 @@ impl<N: NetworkPrimitives> PeerMetadata<N> {
         peer_kind: PeerKind,
     ) -> Self {
         Self {
-            seen_transactions: LruCache::new(max_transactions_seen_by_peer),
+            seen_transactions: LruCache::with_hasher(
+                max_transactions_seen_by_peer,
+                Default::default(),
+            ),
             request_tx,
             version,
             client_version,
@@ -2052,7 +2073,7 @@ impl<N: NetworkPrimitives> PeerMetadata<N> {
     }
 
     /// Returns a mutable reference to the seen transactions LRU cache.
-    pub const fn seen_transactions_mut(&mut self) -> &mut LruCache<TxHash> {
+    pub const fn seen_transactions_mut(&mut self) -> &mut LruCache<TxHash, FbBuildHasher<32>> {
         &mut self.seen_transactions
     }
 
@@ -2088,10 +2109,7 @@ enum TransactionsCommand<N: NetworkPrimitives = EthNetworkPrimitives> {
     /// Propagate a collection of broadcastable transactions in full to all peers.
     BroadcastTransactions(Vec<PropagateTransaction<N::BroadcastedTransaction>>),
     /// Request transaction hashes known by specific peers from the [`TransactionsManager`].
-    GetTransactionHashes {
-        peers: Vec<PeerId>,
-        tx: oneshot::Sender<HashMap<PeerId, HashSet<TxHash>>>,
-    },
+    GetTransactionHashes { peers: Vec<PeerId>, tx: oneshot::Sender<HashMap<PeerId, B256Set>> },
     /// Requests a clone of the sender channel to the peer.
     GetPeerSender {
         peer_id: PeerId,
@@ -2893,9 +2911,9 @@ mod tests {
         let PeerRequest::GetPooledTransactions { request, response } = req else { unreachable!() };
         let GetPooledTransactions(hashes) = request;
 
-        let hashes = hashes.into_iter().collect::<HashSet<_>>();
+        let hashes = hashes.into_iter().collect::<B256Set>();
 
-        assert_eq!(hashes, seen_hashes.into_iter().collect::<HashSet<_>>());
+        assert_eq!(hashes, seen_hashes.into_iter().collect::<B256Set>());
 
         // fail request to peer_1
         response
@@ -3173,7 +3191,7 @@ mod tests {
         })
         .await;
 
-        let mut requested_hashes_in_getpooled = HashSet::new();
+        let mut requested_hashes_in_getpooled = B256Set::default();
         let mut unexpected_request_received = false;
 
         match tokio::time::timeout(std::time::Duration::from_millis(200), mock_session_rx.recv())
diff --git a/crates/net/network/src/trusted_peers_resolver.rs b/crates/net/network/src/trusted_peers_resolver.rs
index 29940f415ec..c0be5d78cd8 100644
--- a/crates/net/network/src/trusted_peers_resolver.rs
+++ b/crates/net/network/src/trusted_peers_resolver.rs
@@ -33,6 +33,11 @@ impl TrustedPeersResolver {
         self.interval = interval;
     }
 
+    /// Remove a trusted peer from the resolver.
+    pub fn remove(&mut self, peer_id: PeerId) {
+        self.trusted_peers.retain(|trusted| trusted.id != peer_id);
+    }
+
     /// Poll the resolver.
     /// When the interval ticks, new resolution futures for each trusted peer are spawned.
     /// If a future completes successfully, it returns the resolved (`PeerId`, `NodeRecord`).
diff --git a/crates/net/network/tests/it/requests.rs b/crates/net/network/tests/it/requests.rs
index ce5d57cfe4b..2b9323f70cb 100644
--- a/crates/net/network/tests/it/requests.rs
+++ b/crates/net/network/tests/it/requests.rs
@@ -2,7 +2,8 @@
 //! Tests for eth related requests
 
 use alloy_consensus::Header;
-use alloy_primitives::{Bytes, B256};
+use alloy_eips::NumHash;
+use alloy_primitives::{keccak256, BlockHash, BlockNumber, Bytes, Sealed, B256};
 use rand::Rng;
 use reth_eth_wire::{BlockAccessLists, EthVersion, GetBlockAccessLists, HeadersDirection};
 use reth_ethereum_primitives::Block;
@@ -16,9 +17,12 @@ use reth_network_p2p::{
     bodies::client::BodiesClient,
     error::RequestError,
     headers::client::{HeadersClient, HeadersRequest},
-    BalRequirement, BlockAccessListsClient,
+    BlockAccessListsClient,
+};
+use reth_provider::{
+    test_utils::MockEthProvider, BalNotificationStream, BalStore, BalStoreHandle, InMemoryBalStore,
+    ProviderError, ProviderResult, SealedBal,
 };
-use reth_provider::{test_utils::MockEthProvider, BalStoreHandle, InMemoryBalStore};
 use reth_transaction_pool::test_utils::{TestPool, TransactionGenerator};
 use std::sync::Arc;
 use tokio::sync::oneshot;
@@ -544,14 +548,11 @@ async fn test_eth71_get_block_access_lists() {
     let bal0 = Bytes::from_static(&[0xc1, 0x01]);
     let bal2 = Bytes::from_static(&[0xc1, 0x02]);
 
-    bal_store.insert(hash0, 1, bal0.clone()).unwrap();
-    bal_store.insert(hash2, 3, bal2.clone()).unwrap();
+    bal_store.insert(NumHash::new(1, hash0), sealed_bal(bal0.clone())).unwrap();
+    bal_store.insert(NumHash::new(3, hash2), sealed_bal(bal2.clone())).unwrap();
 
     let response = request_block_access_lists(&net, vec![hash0, hash1, hash2]).await;
-    assert_eq!(
-        response,
-        BlockAccessLists(vec![bal0, Bytes::from_static(&[alloy_rlp::EMPTY_LIST_CODE]), bal2,])
-    );
+    assert_eq!(response, BlockAccessLists(vec![Some(bal0), None, Some(bal2)]));
 }
 
 // Ensures BAL responses stop at the soft response limit while keeping the item that crosses it.
@@ -568,13 +569,13 @@ async fn test_eth71_get_block_access_lists_respects_response_soft_limit() {
     let bal2 = raw_bal_with_len(2);
     assert!(bal0.len() + bal1.len() > SOFT_RESPONSE_LIMIT);
 
-    bal_store.insert(hash0, 1, bal0.clone()).unwrap();
-    bal_store.insert(hash1, 2, bal1.clone()).unwrap();
-    bal_store.insert(hash2, 3, bal2).unwrap();
+    bal_store.insert(NumHash::new(1, hash0), sealed_bal(bal0.clone())).unwrap();
+    bal_store.insert(NumHash::new(2, hash1), sealed_bal(bal1.clone())).unwrap();
+    bal_store.insert(NumHash::new(3, hash2), sealed_bal(bal2)).unwrap();
 
     let response = request_block_access_lists(&net, vec![hash0, hash1, hash2]).await;
 
-    assert_eq!(response, BlockAccessLists(vec![bal0, bal1]));
+    assert_eq!(response, BlockAccessLists(vec![Some(bal0), Some(bal1)]));
 }
 
 // Ensures a single BAL larger than the soft limit is still returned.
@@ -588,12 +589,12 @@ async fn test_eth71_get_block_access_lists_returns_single_oversized_bal() {
     let bal0 = raw_bal_with_len(SOFT_RESPONSE_LIMIT + 1);
     let bal1 = raw_bal_with_len(2);
 
-    bal_store.insert(hash0, 1, bal0.clone()).unwrap();
-    bal_store.insert(hash1, 2, bal1).unwrap();
+    bal_store.insert(NumHash::new(1, hash0), sealed_bal(bal0.clone())).unwrap();
+    bal_store.insert(NumHash::new(2, hash1), sealed_bal(bal1)).unwrap();
 
     let response = request_block_access_lists(&net, vec![hash0, hash1]).await;
 
-    assert_eq!(response, BlockAccessLists(vec![bal0]));
+    assert_eq!(response, BlockAccessLists(vec![Some(bal0)]));
 }
 
 // Ensures an empty BAL request roundtrips to an empty response.
@@ -620,7 +621,7 @@ async fn test_eth71_get_block_access_lists_caps_count() {
     // Insert one BAL so the store isn't entirely empty (not strictly needed,
     // but keeps the test path closer to real usage).
     let bal = Bytes::from_static(&[0xc1, 0x01]);
-    bal_store.insert(hashes[0], 1, bal).unwrap();
+    bal_store.insert(NumHash::new(1, hashes[0]), sealed_bal(bal)).unwrap();
 
     let response = request_block_access_lists(&net, hashes).await;
 
@@ -637,28 +638,38 @@ async fn test_eth71_fetch_client_get_block_access_lists() {
     let hash1 = B256::random();
     let bal0 = Bytes::from_static(&[0xc1, 0x01]);
 
-    bal_store.insert(hash0, 1, bal0.clone()).unwrap();
+    bal_store.insert(NumHash::new(1, hash0), sealed_bal(bal0.clone())).unwrap();
 
     let fetch = net.peers()[0].network().fetch_client().await.unwrap();
     let response = fetch.get_block_access_lists(vec![hash0, hash1]).await.unwrap().into_data();
 
-    assert_eq!(
-        response,
-        BlockAccessLists(vec![bal0, Bytes::from_static(&[alloy_rlp::EMPTY_LIST_CODE])])
-    );
+    assert_eq!(response, BlockAccessLists(vec![Some(bal0), None]));
 }
 
-// Ensures fetch client BAL requests are rejected when no eth/71 peer is available.
+// Ensures store errors produce a valid empty BAL response instead of synthesizing unavailable
+// entries.
 #[tokio::test(flavor = "multi_thread")]
-async fn test_eth70_fetch_client_rejects_optional_block_access_lists_request() {
+async fn test_eth71_get_block_access_lists_returns_empty_on_store_error() {
+    reth_tracing::init_test_tracing();
+    let (net, _) = spawn_bal_testnet_with_store(
+        [EthVersion::Eth71, EthVersion::Eth71],
+        BalStoreHandle::new(FailingLookupBalStore),
+    )
+    .await;
+
+    let response = request_block_access_lists(&net, vec![B256::random(), B256::random()]).await;
+
+    assert_eq!(response, BlockAccessLists(Vec::new()));
+}
+
+// Ensures default fetch client BAL requests are rejected when no eth/71 peer is available.
+#[tokio::test(flavor = "multi_thread")]
+async fn test_eth70_fetch_client_rejects_default_block_access_lists_request() {
     reth_tracing::init_test_tracing();
     let (net, _) = spawn_bal_testnet([EthVersion::Eth70, EthVersion::Eth70]).await;
 
     let fetch = net.peers()[0].network().fetch_client().await.unwrap();
-    let err = fetch
-        .get_block_access_lists_with_requirement(vec![B256::random()], BalRequirement::Optional)
-        .await
-        .unwrap_err();
+    let err = fetch.get_block_access_lists(vec![B256::random()]).await.unwrap_err();
 
     assert_eq!(err, RequestError::UnsupportedCapability);
 }
@@ -670,9 +681,16 @@ async fn spawn_eth71_bal_testnet() -> (BalTestnetHandle, BalStoreHandle) {
 // Spawns a BAL testnet with one peer per requested eth protocol version.
 async fn spawn_bal_testnet(
     versions: impl IntoIterator<Item = EthVersion>,
+) -> (BalTestnetHandle, BalStoreHandle) {
+    spawn_bal_testnet_with_store(versions, BalStoreHandle::new(InMemoryBalStore::default())).await
+}
+
+// Spawns a BAL testnet with one peer per requested eth protocol version and the given BAL store.
+async fn spawn_bal_testnet_with_store(
+    versions: impl IntoIterator<Item = EthVersion>,
+    bal_store: BalStoreHandle,
 ) -> (BalTestnetHandle, BalStoreHandle) {
     let mut mock_provider = MockEthProvider::default();
-    let bal_store = BalStoreHandle::new(InMemoryBalStore::default());
     mock_provider.bal_store = bal_store.clone();
     let mock_provider = Arc::new(mock_provider);
 
@@ -691,6 +709,27 @@ async fn spawn_bal_testnet(
     (net, bal_store)
 }
 
+#[derive(Debug)]
+struct FailingLookupBalStore;
+
+impl BalStore for FailingLookupBalStore {
+    fn insert(&self, _num_hash: NumHash, _bal: SealedBal) -> ProviderResult<()> {
+        Ok(())
+    }
+
+    fn prune(&self, _tip: BlockNumber) -> ProviderResult<usize> {
+        Ok(0)
+    }
+
+    fn get_by_hashes(&self, _block_hashes: &[BlockHash]) -> ProviderResult<Vec<Option<Bytes>>> {
+        Err(ProviderError::other(std::io::Error::other("BAL lookup failed")))
+    }
+
+    fn bal_stream(&self) -> BalNotificationStream {
+        BalStoreHandle::noop().bal_stream()
+    }
+}
+
 // Sends a GetBlockAccessLists request from peer 0 to peer 1.
 async fn request_block_access_lists(net: &BalTestnetHandle, hashes: Vec<B256>) -> BlockAccessLists {
     let requester = &net.peers()[0];
@@ -727,3 +766,7 @@ fn raw_bal_with_len(len: usize) -> Bytes {
     out.resize(len, alloy_rlp::EMPTY_LIST_CODE);
     Bytes::from(out)
 }
+
+fn sealed_bal(bal: Bytes) -> SealedBal {
+    Sealed::new_unchecked(bal.clone(), keccak256(&bal))
+}
diff --git a/crates/net/p2p/src/block_access_lists/client.rs b/crates/net/p2p/src/block_access_lists/client.rs
index cc9301d91bc..c1aa8adf2bc 100644
--- a/crates/net/p2p/src/block_access_lists/client.rs
+++ b/crates/net/p2p/src/block_access_lists/client.rs
@@ -9,9 +9,9 @@ use reth_eth_wire_types::BlockAccessLists;
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub enum BalRequirement {
     /// Keep waiting until an eth/71-capable peer is available.
-    #[default]
     Mandatory,
     /// Return early if no connected peer can serve BALs.
+    #[default]
     Optional,
 }
 
@@ -26,7 +26,7 @@ pub trait BlockAccessListsClient: DownloadClient {
         self.get_block_access_lists_with_priority_and_requirement(
             hashes,
             Priority::Normal,
-            BalRequirement::Mandatory,
+            BalRequirement::default(),
         )
     }
 
@@ -52,7 +52,7 @@ pub trait BlockAccessListsClient: DownloadClient {
         self.get_block_access_lists_with_priority_and_requirement(
             hashes,
             priority,
-            BalRequirement::Mandatory,
+            BalRequirement::default(),
         )
     }
 
diff --git a/crates/net/p2p/src/full_block.rs b/crates/net/p2p/src/full_block.rs
index 45bedcbd39c..3150cbdf068 100644
--- a/crates/net/p2p/src/full_block.rs
+++ b/crates/net/p2p/src/full_block.rs
@@ -1,6 +1,6 @@
 use super::headers::client::HeadersRequest;
 use crate::{
-    block_access_lists::client::BlockAccessListsClient,
+    block_access_lists::client::{BalRequirement, BlockAccessListsClient},
     bodies::client::{BodiesClient, SingleBodyRequest},
     download::DownloadClient,
     error::PeerRequestResult,
@@ -9,7 +9,7 @@ use crate::{
     BlockClient,
 };
 use alloy_consensus::BlockHeader;
-use alloy_primitives::{Sealable, B256};
+use alloy_primitives::{keccak256, Bytes, Sealable, Sealed, B256};
 use core::marker::PhantomData;
 use futures::FutureExt;
 use reth_consensus::Consensus;
@@ -17,7 +17,7 @@ use reth_eth_wire_types::{
     BlockAccessLists, EthNetworkPrimitives, HeadersDirection, NetworkPrimitives,
 };
 use reth_network_peers::{PeerId, WithPeerId};
-use reth_primitives_traits::{SealedBlock, SealedHeader};
+use reth_primitives_traits::{Block, SealedBlock, SealedHeader};
 use std::{
     cmp::Reverse,
     collections::{HashMap, VecDeque},
@@ -28,7 +28,65 @@ use std::{
     sync::Arc,
     task::{ready, Context, Poll},
 };
-use tracing::debug;
+use tracing::{debug, trace};
+
+/// A sealed block with associated data.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SealedBlockWith<B: Block, T = Option<Sealed<Bytes>>> {
+    block: SealedBlock<B>,
+    data: T,
+}
+
+/// Raw block access-list RLP bytes sealed by `header.block_access_list_hash`.
+pub type SealedBlockAccessList = Sealed<Bytes>;
+
+/// A sealed block with optional validated block access-list data.
+pub type SealedBlockWithAccessList<B> = SealedBlockWith<B, Option<SealedBlockAccessList>>;
+
+impl<B: Block, T> SealedBlockWith<B, T> {
+    /// Creates a sealed block with associated data.
+    pub const fn new(block: SealedBlock<B>, data: T) -> Self {
+        Self { block, data }
+    }
+
+    /// Returns the sealed block.
+    pub const fn block(&self) -> &SealedBlock<B> {
+        &self.block
+    }
+
+    /// Returns the associated data.
+    pub const fn data(&self) -> &T {
+        &self.data
+    }
+
+    /// Consumes the wrapper and returns its parts.
+    pub fn into_parts(self) -> (SealedBlock<B>, T) {
+        (self.block, self.data)
+    }
+}
+
+impl<B: Block> SealedBlockWithAccessList<B> {
+    /// Creates a full block response without block access-list data.
+    pub const fn from_block(block: SealedBlock<B>) -> Self {
+        Self::new(block, None)
+    }
+
+    /// Returns the optional raw block access-list data, sealed by its hash.
+    pub const fn access_list(&self) -> Option<&SealedBlockAccessList> {
+        self.data.as_ref()
+    }
+
+    /// Returns the optional raw block access-list data, sealed by its hash.
+    pub const fn access_lists(&self) -> Option<&SealedBlockAccessList> {
+        self.data.as_ref()
+    }
+}
+
+impl<B: Block> From<SealedBlock<B>> for SealedBlockWith<B> {
+    fn from(block: SealedBlock<B>) -> Self {
+        Self::new(block, None)
+    }
+}
 
 /// A Client that can fetch full blocks from the network.
 #[derive(Debug, Clone)]
@@ -72,7 +130,7 @@ where
 
     /// Returns a future that fetches [`SealedBlock`]s for the given hash and count.
     ///
-    /// Note: this future is cancel safe
+    /// Note: this future is cancel safe.
     ///
     /// Caution: This does no validation of body (transactions) responses but guarantees that
     /// the starting [`SealedHeader`] matches the requested hash, and that the number of headers and
@@ -101,31 +159,12 @@ where
     }
 }
 
-impl<Client> FetchFullBlockFuture<Client>
-where
-    Client: BlockClient,
-{
-    fn new(client: Client, consensus: Arc<dyn Consensus<Client::Block>>, hash: B256) -> Self {
-        Self {
-            hash,
-            consensus,
-            request: FullBlockRequest {
-                header: Some(client.get_header(hash.into())),
-                body: Some(client.get_block_body(hash)),
-            },
-            client,
-            header: None,
-            body: None,
-        }
-    }
-}
-
 impl<Client> FullBlockClient<Client>
 where
     Client: BlockClient + BlockAccessListsClient,
 {
-    /// Returns a future that fetches the [`SealedBlock`] and its [`BlockAccessLists`] for the
-    /// given hash.
+    /// Returns a future that fetches the [`SealedBlock`] and optionally its block access list
+    /// for the given hash.
     ///
     /// Note: this future is cancel safe
     ///
@@ -134,12 +173,68 @@ where
     pub fn get_full_block_with_access_lists(
         &self,
         hash: B256,
-    ) -> FetchFullBlockWithAccessListsFuture<Client> {
+    ) -> FetchFullBlockWithBalFuture<Client> {
+        self.get_full_block_with_access_lists_with_requirement(hash, BalRequirement::default())
+    }
+
+    /// Returns a future that fetches the [`SealedBlock`] and optionally its block access list
+    /// for the given hash using the requested BAL availability policy.
+    ///
+    /// Note: this future is cancel safe
+    ///
+    /// Caution: This does no validation of body (transactions) response but guarantees that the
+    /// [`SealedHeader`] matches the requested hash.
+    pub fn get_full_block_with_access_lists_with_requirement(
+        &self,
+        hash: B256,
+        requirement: BalRequirement,
+    ) -> FetchFullBlockWithBalFuture<Client> {
         let client = self.client.clone();
-        FetchFullBlockWithAccessListsFuture {
+        FetchFullBlockWithBalFuture {
             block: FetchFullBlockFuture::new(client.clone(), self.consensus.clone(), hash),
             block_result: None,
-            bal_request_state: BalRequestState::Pending(client.get_block_access_lists(vec![hash])),
+            bal_request_state: BalRequestState::Pending(
+                client.get_block_access_lists_with_requirement(vec![hash], requirement),
+            ),
+        }
+    }
+
+    /// Returns a future that fetches [`SealedBlock`]s and optionally their block access lists for
+    /// the given hash and count.
+    ///
+    /// The block range is always the primary result. Access lists are requested after the block
+    /// range is downloaded. Each block contains access-list data when the optional BAL response
+    /// included the corresponding entry.
+    pub fn get_full_block_range_with_optional_access_lists(
+        &self,
+        hash: B256,
+        count: u64,
+    ) -> FetchFullBlockRangeWithBalFuture<Client> {
+        self.get_full_block_range_with_optional_access_lists_with_requirement(
+            hash,
+            count,
+            BalRequirement::default(),
+        )
+    }
+
+    /// Returns a future that fetches [`SealedBlock`]s and optionally their block access lists for
+    /// the given hash and count using the requested BAL availability policy.
+    ///
+    /// The block range is always the primary result. Access lists are requested after the block
+    /// range is downloaded. Each block contains access-list data when the optional BAL response
+    /// included the corresponding entry.
+    pub fn get_full_block_range_with_optional_access_lists_with_requirement(
+        &self,
+        hash: B256,
+        count: u64,
+        requirement: BalRequirement,
+    ) -> FetchFullBlockRangeWithBalFuture<Client> {
+        let client = self.client.clone();
+        FetchFullBlockRangeWithBalFuture {
+            blocks: self.get_full_block_range(hash, count),
+            client,
+            block_result: None,
+            access_lists: OptionalBlockAccessListsState::WaitingForBlocks { requirement },
         }
     }
 }
@@ -165,6 +260,20 @@ impl<Client> FetchFullBlockFuture<Client>
 where
     Client: BlockClient,
 {
+    fn new(client: Client, consensus: Arc<dyn Consensus<Client::Block>>, hash: B256) -> Self {
+        Self {
+            hash,
+            consensus,
+            request: FullBlockRequest {
+                header: Some(client.get_header(hash.into())),
+                body: Some(client.get_block_body(hash)),
+            },
+            client,
+            header: None,
+            body: None,
+        }
+    }
+
     /// Returns the hash of the block being requested.
     pub const fn hash(&self) -> &B256 {
         &self.hash
@@ -286,12 +395,12 @@ where
     }
 }
 
-/// A future that downloads a full block and its block access lists from the network.
+/// A future that downloads a full block and optionally its block access lists from the network.
 ///
 /// This composes the existing full block downloader with a block access list request so the
-/// header/body logic stays centralized.
+/// header/body logic stays centralized. Missing access lists do not block returning the full block.
 #[must_use = "futures do nothing unless polled"]
-pub struct FetchFullBlockWithAccessListsFuture<Client>
+pub struct FetchFullBlockWithBalFuture<Client>
 where
     Client: BlockClient + BlockAccessListsClient,
 {
@@ -300,7 +409,7 @@ where
     bal_request_state: BalRequestState<<Client as BlockAccessListsClient>::Output>,
 }
 
-impl<Client> FetchFullBlockWithAccessListsFuture<Client>
+impl<Client> FetchFullBlockWithBalFuture<Client>
 where
     Client: BlockClient<Header: BlockHeader> + BlockAccessListsClient,
 {
@@ -310,7 +419,7 @@ where
     }
 }
 
-impl<Client> FetchFullBlockWithAccessListsFuture<Client>
+impl<Client> FetchFullBlockWithBalFuture<Client>
 where
     Client: BlockClient<Header: BlockHeader + Sealable> + BlockAccessListsClient + 'static,
 {
@@ -319,77 +428,80 @@ where
         self.block_result.as_ref().map(|block| block.number()).or_else(|| self.block.block_number())
     }
 
-    fn send_bal_request(&mut self) {
-        let hash = *self.block.hash();
-        self.bal_request_state =
-            BalRequestState::Pending(self.block.client.get_block_access_lists(vec![hash]));
-    }
-
-    // This retries BAL failures inline instead of surfacing them to the outer future, so
-    // `FetchFullBlockWithAccessListsFuture` only makes progress once the BAL request either
-    // becomes pending again or resolves with a single access-list entry.
-    fn poll_bal_request(&mut self, cx: &mut Context<'_>) {
-        loop {
-            let poll = match &mut self.bal_request_state {
-                BalRequestState::Pending(fut) => fut.poll_unpin(cx),
-                BalRequestState::Ready(_) => return,
-            };
-
-            match poll {
-                Poll::Pending => return,
-                Poll::Ready(res) => match res {
-                    Ok(bal) => {
-                        let (peer, access_lists) = bal.split();
-                        if access_lists.0.len() == 1 {
-                            self.bal_request_state = BalRequestState::Ready(access_lists);
-                            return;
-                        }
-
+    /// Polls the optional BAL request once and records its final best-effort result.
+    ///
+    /// Exactly one returned BAL entry is preserved. Empty responses, malformed responses, and
+    /// request errors resolve to `None` instead of being retried, so a BAL failure cannot block
+    /// returning the downloaded block.
+    fn poll_bal_request(&mut self, cx: &mut Context<'_>) -> Poll<()> {
+        let res = match &mut self.bal_request_state {
+            BalRequestState::Pending(fut) => ready!(fut.poll_unpin(cx)),
+            BalRequestState::Ready(_) => return Poll::Ready(()),
+        };
+
+        match res {
+            Ok(bal) => {
+                let (peer, access_lists) = bal.split();
+                match access_lists.0.len() {
+                    0 => self.bal_request_state = BalRequestState::Ready(None),
+                    1 => {
+                        let access_list = access_lists.0.into_iter().next().expect("len checked");
+                        self.bal_request_state =
+                            BalRequestState::Ready(Some(WithPeerId::new(peer, access_list)));
+                    }
+                    received => {
                         debug!(
                             target: "downloaders",
                             hash = ?self.block.hash(),
                             expected = 1,
-                            received = access_lists.0.len(),
+                            received,
                             "Received wrong access list response",
                         );
                         self.block.client.report_bad_message(peer);
-                        self.send_bal_request();
-                    }
-                    Err(err) => {
-                        debug!(
-                            target: "downloaders",
-                            %err,
-                            hash = ?self.block.hash(),
-                            "Access list download failed",
-                        );
-                        self.send_bal_request();
+                        self.bal_request_state = BalRequestState::Ready(None);
                     }
-                },
+                }
+            }
+            Err(err) => {
+                debug!(
+                    target: "downloaders",
+                    %err,
+                    hash = ?self.block.hash(),
+                    "Access list download failed",
+                );
+                self.bal_request_state = BalRequestState::Ready(None);
             }
         }
-    }
 
-    fn take_block_and_access_lists(
-        &mut self,
-    ) -> Option<(SealedBlock<Client::Block>, BlockAccessLists)> {
-        if self.block_result.is_some() && self.bal_request_state.is_ready() {
-            let block = self.block_result.take().expect("block result should exist");
-            let access_lists = match &mut self.bal_request_state {
-                BalRequestState::Ready(access_lists) => std::mem::take(access_lists),
-                BalRequestState::Pending(_) => unreachable!("access lists should be ready"),
-            };
-            return Some((block, access_lists))
-        }
+        Poll::Ready(())
+    }
 
-        None
+    /// Returns the block once the block download and optional BAL lookup have both completed.
+    ///
+    /// The BAL lookup must be ready even when it resolved to `None`, which prevents a fast block
+    /// response from racing a still-pending BAL response and incorrectly dropping available BAL
+    /// data.
+    fn take_block_and_access_lists(&mut self) -> Option<SealedBlockWithAccessList<Client::Block>> {
+        let BalRequestState::Ready(access_list) = &mut self.bal_request_state else { return None };
+        let block = self.block_result.take()?;
+        let access_list = access_list.take().and_then(|access_list| {
+            match seal_block_access_list_for_block(&block, access_list) {
+                Ok(access_list) => access_list,
+                Err(peer) => {
+                    self.block.client.report_bad_message(peer);
+                    None
+                }
+            }
+        });
+        Some(SealedBlockWith::new(block, access_list))
     }
 }
 
-impl<Client> Future for FetchFullBlockWithAccessListsFuture<Client>
+impl<Client> Future for FetchFullBlockWithBalFuture<Client>
 where
     Client: BlockClient<Header: BlockHeader + Sealable> + BlockAccessListsClient + 'static,
 {
-    type Output = (SealedBlock<Client::Block>, BlockAccessLists);
+    type Output = SealedBlockWithAccessList<Client::Block>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
@@ -400,7 +512,7 @@ where
             this.block_result = Some(block);
         }
 
-        this.poll_bal_request(cx);
+        ready!(this.poll_bal_request(cx));
 
         if let Some(res) = this.take_block_and_access_lists() {
             return Poll::Ready(res)
@@ -410,12 +522,12 @@ where
     }
 }
 
-impl<Client> Debug for FetchFullBlockWithAccessListsFuture<Client>
+impl<Client> Debug for FetchFullBlockWithBalFuture<Client>
 where
     Client: BlockClient<Header: BlockHeader> + BlockAccessListsClient,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("FetchFullBlockWithAccessListsFuture")
+        f.debug_struct("FetchFullBlockWithBalFuture")
             .field("hash", &self.block.hash())
             .field("block_ready", &self.block_result.is_some())
             .field("bal_request_ready", &self.bal_request_state.is_ready())
@@ -426,7 +538,7 @@ where
 /// Tracks the BAL request and its completed result.
 enum BalRequestState<Req> {
     Pending(Req),
-    Ready(BlockAccessLists),
+    Ready(Option<WithPeerId<Option<Bytes>>>),
 }
 
 impl<Req> BalRequestState<Req> {
@@ -435,6 +547,128 @@ impl<Req> BalRequestState<Req> {
     }
 }
 
+/// A future that downloads a range of full blocks and optionally their block access lists from the
+/// network.
+///
+/// This composes the existing full block range downloader with a follow-up optional block
+/// access-list request, so callers that only need blocks can keep using
+/// [`FetchFullBlockRangeFuture`].
+#[must_use = "futures do nothing unless polled"]
+#[expect(missing_debug_implementations)]
+pub struct FetchFullBlockRangeWithBalFuture<Client>
+where
+    Client: BlockClient + BlockAccessListsClient,
+{
+    blocks: FetchFullBlockRangeFuture<Client>,
+    client: Client,
+    block_result: Option<Vec<SealedBlock<Client::Block>>>,
+    access_lists: OptionalBlockAccessListsState<<Client as BlockAccessListsClient>::Output>,
+}
+
+impl<Client> FetchFullBlockRangeWithBalFuture<Client>
+where
+    Client: BlockClient<Header: Debug + BlockHeader + Sealable + Clone + Hash + Eq>
+        + BlockAccessListsClient,
+{
+    fn start_access_lists_request_if_possible(&mut self) {
+        let requirement = match &self.access_lists {
+            OptionalBlockAccessListsState::WaitingForBlocks { requirement } => *requirement,
+            OptionalBlockAccessListsState::Pending(_) | OptionalBlockAccessListsState::Ready(_) => {
+                return
+            }
+        };
+
+        // BALs are requested by block hash, so wait until the block range is fully assembled.
+        let Some(blocks) = self.block_result.as_ref() else { return };
+        let hashes = blocks.iter().map(|block| block.hash()).collect::<Vec<_>>();
+        self.access_lists = OptionalBlockAccessListsState::Pending(
+            self.client.get_block_access_lists_with_requirement(hashes, requirement),
+        );
+    }
+
+    /// Starts and polls the optional BAL request once, if it is ready to make progress.
+    fn poll_access_lists(&mut self, cx: &mut Context<'_>) {
+        self.start_access_lists_request_if_possible();
+
+        let poll = match &mut self.access_lists {
+            OptionalBlockAccessListsState::Pending(fut) => fut.poll_unpin(cx),
+            OptionalBlockAccessListsState::WaitingForBlocks { .. } |
+            OptionalBlockAccessListsState::Ready(_) => return,
+        };
+
+        match poll {
+            Poll::Pending => {}
+            Poll::Ready(Ok(access_lists)) => {
+                self.access_lists = OptionalBlockAccessListsState::Ready(Some(access_lists));
+            }
+            Poll::Ready(Err(err)) => {
+                debug!(
+                    target: "downloaders",
+                    %err,
+                    start_hash = ?self.blocks.start_hash(),
+                    "Access list range download failed",
+                );
+
+                // Optional BAL lookup is best-effort: missing eth/71 support or request failures
+                // should not block returning the downloaded block range.
+                self.access_lists = OptionalBlockAccessListsState::Ready(None);
+            }
+        }
+    }
+
+    /// Returns the block range once blocks and the optional BAL lookup are both complete.
+    fn take_response(&mut self) -> Option<Vec<SealedBlockWithAccessList<Client::Block>>> {
+        let OptionalBlockAccessListsState::Ready(access_lists) = &mut self.access_lists else {
+            return None
+        };
+
+        let blocks = self.block_result.take()?;
+
+        Some(seal_blocks_with_access_lists(&self.client, blocks, access_lists.take()))
+    }
+}
+
+impl<Client> Future for FetchFullBlockRangeWithBalFuture<Client>
+where
+    Client: BlockClient<Header: Debug + BlockHeader + Sealable + Clone + Hash + Eq>
+        + BlockAccessListsClient
+        + 'static,
+{
+    type Output = Vec<SealedBlockWithAccessList<Client::Block>>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+
+        // Complete the normal block range first, then issue a separate BAL hash-list request.
+        if this.block_result.is_none() &&
+            let Poll::Ready(blocks) = this.blocks.poll_unpin(cx)
+        {
+            this.block_result = Some(blocks);
+        }
+
+        this.poll_access_lists(cx);
+
+        if let Some(response) = this.take_response() {
+            return Poll::Ready(response)
+        }
+
+        Poll::Pending
+    }
+}
+
+/// Tracks an optional BAL range request and its completed result.
+enum OptionalBlockAccessListsState<Req> {
+    /// The block hashes needed for `GetBlockAccessLists` are not known yet.
+    WaitingForBlocks {
+        /// The BAL availability policy for the eventual request.
+        requirement: BalRequirement,
+    },
+    /// A `GetBlockAccessLists` request is in flight.
+    Pending(Req),
+    /// `None` means the block range is available but optional BAL data is not.
+    Ready(Option<WithPeerId<BlockAccessLists>>),
+}
+
 impl<Client> Debug for FetchFullBlockFuture<Client>
 where
     Client: BlockClient<Header: Debug, Body: Debug>,
@@ -534,11 +768,6 @@ impl<Client> FetchFullBlockRangeFuture<Client>
 where
     Client: BlockClient<Header: Debug + BlockHeader + Sealable + Clone + Hash + Eq>,
 {
-    /// Returns the block hashes for the given range, if they are available.
-    pub fn range_block_hashes(&self) -> Option<Vec<B256>> {
-        self.headers.as_ref().map(|h| h.iter().map(|h| h.hash()).collect())
-    }
-
     /// Returns whether or not the bodies map is fully populated with requested headers and bodies.
     fn is_bodies_complete(&self) -> bool {
         self.bodies.len() == self.count as usize
@@ -930,26 +1159,132 @@ impl<Net> Default for NoopFullBlockClient<Net> {
     }
 }
 
+/// Validates one raw block access-list entry against the block's access-list hash.
+///
+/// Returns `Ok(Some(_))` for a matching entry, `Ok(None)` when the block has no access-list hash
+/// or the peer returned an unavailable entry, and `Err(peer)` for a hash mismatch that should be
+/// reported as a bad message.
+fn seal_block_access_list_for_block<B: Block>(
+    block: &SealedBlock<B>,
+    access_list: WithPeerId<Option<Bytes>>,
+) -> Result<Option<Sealed<Bytes>>, PeerId> {
+    let Some(expected) = block.header().block_access_list_hash() else { return Ok(None) };
+
+    let (peer, access_list) = access_list.split();
+    let Some(access_list) = access_list else { return Ok(None) };
+    let computed = keccak256(access_list.as_ref());
+    if computed == expected {
+        return Ok(Some(Sealed::new_unchecked(access_list, expected)))
+    }
+
+    debug!(
+        target: "downloaders",
+        block_hash = ?block.hash(),
+        ?computed,
+        ?expected,
+        "Received block access list with wrong hash",
+    );
+    Err(peer)
+}
+
+/// Wraps a block range with validated block access-list entries.
+///
+/// Short responses are treated as a valid prefix and the remaining blocks receive `None`.
+/// Responses longer than the requested block range return the full block range without access-list
+/// data. Non-empty hash mismatches stop accepting access-list data after reporting the peer, so any
+/// already validated prefix is preserved.
+fn seal_blocks_with_access_lists<Client>(
+    client: &Client,
+    blocks: Vec<SealedBlock<Client::Block>>,
+    access_lists: Option<WithPeerId<BlockAccessLists>>,
+) -> Vec<SealedBlockWithAccessList<Client::Block>>
+where
+    Client: BlockClient,
+{
+    let Some(access_lists) = access_lists else {
+        return blocks.into_iter().map(SealedBlockWith::from_block).collect()
+    };
+
+    let (peer, access_lists) = access_lists.split();
+    let expected = blocks.len();
+    let received = access_lists.0.len();
+
+    if received > expected {
+        trace!(
+            target: "downloaders",
+            expected,
+            received,
+            "Ignoring overlong access list range response",
+        );
+        return blocks.into_iter().map(SealedBlockWith::from_block).collect()
+    }
+
+    let mut access_lists = access_lists.0.into_iter();
+    let mut blocks = blocks.into_iter();
+    let mut response = Vec::with_capacity(expected);
+
+    for block in blocks.by_ref() {
+        let Some(access_list) = access_lists.next() else {
+            // Short BAL responses are valid; the current block and all remaining blocks are
+            // returned without access-list data below.
+            response.push(SealedBlockWith::from_block(block));
+            break
+        };
+
+        match seal_block_access_list_for_block(&block, WithPeerId::new(peer, access_list)) {
+            Ok(access_list) => response.push(SealedBlockWith::new(block, access_list)),
+            Err(peer) => {
+                // A hash mismatch means this BAL entry is not for the current block. Stop matching
+                // later positional entries and return the rest of the range without BAL data.
+                client.report_bad_message(peer);
+                response.push(SealedBlockWith::from_block(block));
+                break
+            }
+        }
+    }
+
+    response.extend(blocks.map(SealedBlockWith::from_block));
+    response
+}
+
 #[cfg(test)]
 mod tests {
     use reth_ethereum_primitives::BlockBody;
 
     use super::*;
     use crate::{error::RequestError, test_utils::TestFullBlockClient};
-    use alloy_primitives::Bytes;
+    use alloy_consensus::Header;
+    use alloy_primitives::{keccak256, map::B256Map, Bytes};
     use parking_lot::Mutex;
     use std::{
-        collections::HashMap,
         ops::Range,
         sync::{
             atomic::{AtomicBool, AtomicUsize, Ordering},
             Arc,
         },
     };
-    use tokio::time::{timeout, Duration};
 
-    // RLP encoding for an empty list.
     const EMPTY_LIST_CODE: u8 = 0xc0;
+    use tokio::time::{timeout, Duration};
+
+    fn sealed_access_list(access_list: Bytes) -> Sealed<Bytes> {
+        let hash = keccak256(access_list.as_ref());
+        Sealed::new_unchecked(access_list, hash)
+    }
+
+    fn sealed_header_with_access_list_hash(access_list: &Bytes) -> SealedHeader {
+        let header = Header {
+            block_access_list_hash: Some(keccak256(access_list.as_ref())),
+            ..Default::default()
+        };
+        SealedHeader::seal_slow(header)
+    }
+
+    fn range_access_lists<B: Block>(
+        blocks: &[SealedBlockWithAccessList<B>],
+    ) -> Vec<Option<Sealed<Bytes>>> {
+        blocks.iter().map(|block| block.access_list().cloned()).collect()
+    }
 
     #[tokio::test]
     async fn download_single_full_block() {
@@ -979,47 +1314,189 @@ mod tests {
     #[tokio::test]
     async fn download_single_full_block_with_access_lists() {
         let client = FullBlockWithAccessListsClient::default();
-        let header: SealedHeader = SealedHeader::default();
         let body = BlockBody::default();
         let access_list = Bytes::from_static(&[EMPTY_LIST_CODE]);
+        let header = sealed_header_with_access_list_hash(&access_list);
         client.insert(header.clone(), body.clone(), access_list.clone());
 
         let request_count = Arc::clone(&client.access_list_requests);
         let client = FullBlockClient::test_client(client);
 
-        let (received_block, received_access_lists) =
-            client.get_full_block_with_access_lists(header.hash()).await;
+        let received = client.get_full_block_with_access_lists(header.hash()).await;
+        let expected_access_list = sealed_access_list(access_list);
 
-        assert_eq!(received_block, SealedBlock::from_sealed_parts(header, body));
-        assert_eq!(received_access_lists, BlockAccessLists(vec![access_list]));
+        assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
+        assert_eq!(received.access_list(), Some(&expected_access_list));
         assert_eq!(request_count.load(Ordering::SeqCst), 1);
     }
 
     #[tokio::test]
-    async fn download_single_full_block_with_access_lists_retries_after_invalid_response() {
+    async fn download_single_full_block_with_access_lists_uses_requested_requirement() {
         let client = FullBlockWithAccessListsClient::default();
-        client.empty_first_response.store(true, Ordering::SeqCst);
+        let body = BlockBody::default();
+        let access_list = Bytes::from_static(&[EMPTY_LIST_CODE]);
+        let header = sealed_header_with_access_list_hash(&access_list);
+        client.insert(header.clone(), body.clone(), access_list.clone());
+
+        let requirement = Arc::clone(&client.last_access_list_requirement);
+        let client = FullBlockClient::test_client(client);
+
+        let received = client
+            .get_full_block_with_access_lists_with_requirement(
+                header.hash(),
+                BalRequirement::Mandatory,
+            )
+            .await;
+
+        let expected_access_list = sealed_access_list(access_list);
+        assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
+        assert_eq!(received.access_list(), Some(&expected_access_list));
+        assert_eq!(*requirement.lock(), Some(BalRequirement::Mandatory));
+    }
+
+    #[tokio::test]
+    async fn download_single_full_block_with_access_lists_waits_for_pending_access_lists() {
+        let client = FullBlockWithAccessListsClient::default();
+        client.set_access_list_pending_polls(1);
 
-        let header: SealedHeader = SealedHeader::default();
         let body = BlockBody::default();
         let access_list = Bytes::from_static(&[EMPTY_LIST_CODE]);
+        let header = sealed_header_with_access_list_hash(&access_list);
         client.insert(header.clone(), body.clone(), access_list.clone());
 
         let request_count = Arc::clone(&client.access_list_requests);
+        let client = FullBlockClient::test_client(client);
+
+        let received =
+            timeout(Duration::from_secs(1), client.get_full_block_with_access_lists(header.hash()))
+                .await
+                .expect("access list request should complete");
+
+        let expected_access_list = sealed_access_list(access_list);
+        assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
+        assert_eq!(received.access_list(), Some(&expected_access_list));
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn download_single_full_block_with_access_lists_rejects_wrong_hash() {
+        let client = FullBlockWithAccessListsClient::default();
+        let body = BlockBody::default();
+        let expected_access_list = Bytes::from_static(&[EMPTY_LIST_CODE]);
+        let wrong_access_list = Bytes::from_static(&[0xc1, 0x01]);
+        let header = sealed_header_with_access_list_hash(&expected_access_list);
+        client.insert(header.clone(), body.clone(), wrong_access_list);
+
         let bad_messages = Arc::clone(&client.bad_messages);
         let client = FullBlockClient::test_client(client);
 
-        let (received_block, received_access_lists) =
+        let received =
             timeout(Duration::from_secs(1), client.get_full_block_with_access_lists(header.hash()))
                 .await
-                .expect("access list request retry should complete");
+                .expect("block request should complete without access lists");
 
-        assert_eq!(received_block, SealedBlock::from_sealed_parts(header, body));
-        assert_eq!(received_access_lists, BlockAccessLists(vec![access_list]));
-        assert_eq!(request_count.load(Ordering::SeqCst), 2);
+        assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
+        assert!(received.access_list().is_none());
         assert_eq!(bad_messages.load(Ordering::SeqCst), 1);
     }
 
+    #[tokio::test]
+    async fn download_single_full_block_with_access_lists_treats_none_as_unavailable() {
+        let client = FullBlockWithAccessListsClient::default();
+        let body = BlockBody::default();
+        let expected_access_list = Bytes::from_static(&[0xc1, 0x01]);
+        let header = sealed_header_with_access_list_hash(&expected_access_list);
+        client.inner.insert(header.clone(), body.clone());
+
+        let bad_messages = Arc::clone(&client.bad_messages);
+        let client = FullBlockClient::test_client(client);
+
+        let received =
+            timeout(Duration::from_secs(1), client.get_full_block_with_access_lists(header.hash()))
+                .await
+                .expect("block request should complete without access lists");
+
+        assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
+        assert!(received.access_list().is_none());
+        assert_eq!(bad_messages.load(Ordering::SeqCst), 0);
+    }
+
+    #[tokio::test]
+    async fn download_single_full_block_with_access_lists_rejects_wrong_empty_list() {
+        let client = FullBlockWithAccessListsClient::default();
+        let body = BlockBody::default();
+        let expected_access_list = Bytes::from_static(&[0xc1, 0x01]);
+        let wrong_empty_access_list = Bytes::from_static(&[EMPTY_LIST_CODE]);
+        let header = sealed_header_with_access_list_hash(&expected_access_list);
+        client.insert(header.clone(), body.clone(), wrong_empty_access_list);
+
+        let bad_messages = Arc::clone(&client.bad_messages);
+        let client = FullBlockClient::test_client(client);
+
+        let received =
+            timeout(Duration::from_secs(1), client.get_full_block_with_access_lists(header.hash()))
+                .await
+                .expect("block request should complete without access lists");
+
+        assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
+        assert!(received.access_list().is_none());
+        assert_eq!(bad_messages.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn download_single_full_block_with_access_lists_returns_none_after_empty_response() {
+        let client = FullBlockWithAccessListsClient::default();
+        client.empty_first_response.store(true, Ordering::SeqCst);
+
+        let body = BlockBody::default();
+        let access_list = Bytes::from_static(&[EMPTY_LIST_CODE]);
+        let header = sealed_header_with_access_list_hash(&access_list);
+        client.insert(header.clone(), body.clone(), access_list.clone());
+
+        let request_count = Arc::clone(&client.access_list_requests);
+        let bad_messages = Arc::clone(&client.bad_messages);
+        let client = FullBlockClient::test_client(client);
+
+        let received =
+            timeout(Duration::from_secs(1), client.get_full_block_with_access_lists(header.hash()))
+                .await
+                .expect("block request should complete without access lists");
+
+        assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
+        assert!(received.access_list().is_none());
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+        assert_eq!(bad_messages.load(Ordering::SeqCst), 0);
+    }
+
+    #[tokio::test]
+    async fn download_single_full_block_with_access_lists_returns_block_when_unavailable() {
+        let client = FullBlockWithAccessListsClient::default();
+        client.set_access_lists_unsupported(true);
+
+        let body = BlockBody::default();
+        let access_list = Bytes::from_static(&[EMPTY_LIST_CODE]);
+        let header = sealed_header_with_access_list_hash(&access_list);
+        client.insert(header.clone(), body.clone(), access_list);
+
+        let request_count = Arc::clone(&client.access_list_requests);
+        let requirement = Arc::clone(&client.last_access_list_requirement);
+        let client = FullBlockClient::test_client(client);
+
+        let received =
+            timeout(Duration::from_secs(1), client.get_full_block_with_access_lists(header.hash()))
+                .await
+                .expect("block request should complete without access lists");
+
+        assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
+        assert!(received.access_list().is_none());
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+        assert_eq!(
+            *requirement.lock(),
+            Some(BalRequirement::Optional),
+            "single block BAL lookup should be best-effort"
+        );
+    }
+
     /// Inserts headers and returns the last header and block body.
     fn insert_headers_into_client(
         client: &TestFullBlockClient,
@@ -1044,8 +1521,13 @@ mod tests {
     #[derive(Clone, Debug)]
     struct FullBlockWithAccessListsClient {
         inner: TestFullBlockClient,
-        access_lists: Arc<Mutex<HashMap<B256, Bytes>>>,
+        access_lists: Arc<Mutex<B256Map<Bytes>>>,
         access_list_requests: Arc<AtomicUsize>,
+        access_list_soft_limit: Arc<AtomicUsize>,
+        access_list_pending_polls: Arc<AtomicUsize>,
+        extra_access_list_entries: Arc<AtomicUsize>,
+        unsupported_access_lists: Arc<AtomicBool>,
+        last_access_list_requirement: Arc<Mutex<Option<BalRequirement>>>,
         bad_messages: Arc<AtomicUsize>,
         empty_first_response: Arc<AtomicBool>,
     }
@@ -1054,8 +1536,13 @@ mod tests {
         fn default() -> Self {
             Self {
                 inner: TestFullBlockClient::default(),
-                access_lists: Arc::new(Mutex::new(HashMap::default())),
+                access_lists: Arc::new(Mutex::new(B256Map::default())),
                 access_list_requests: Arc::new(AtomicUsize::new(0)),
+                access_list_soft_limit: Arc::new(AtomicUsize::new(usize::MAX)),
+                access_list_pending_polls: Arc::new(AtomicUsize::new(0)),
+                extra_access_list_entries: Arc::new(AtomicUsize::new(0)),
+                unsupported_access_lists: Arc::new(AtomicBool::new(false)),
+                last_access_list_requirement: Arc::new(Mutex::new(None)),
                 bad_messages: Arc::new(AtomicUsize::new(0)),
                 empty_first_response: Arc::new(AtomicBool::new(false)),
             }
@@ -1067,6 +1554,44 @@ mod tests {
             self.inner.insert(header.clone(), body);
             self.access_lists.lock().insert(header.hash(), access_list);
         }
+
+        fn set_access_list_soft_limit(&self, limit: usize) {
+            self.access_list_soft_limit.store(limit, Ordering::SeqCst);
+        }
+
+        fn set_access_list_pending_polls(&self, polls: usize) {
+            self.access_list_pending_polls.store(polls, Ordering::SeqCst);
+        }
+
+        fn set_extra_access_list_entries(&self, count: usize) {
+            self.extra_access_list_entries.store(count, Ordering::SeqCst);
+        }
+
+        fn set_access_lists_unsupported(&self, unsupported: bool) {
+            self.unsupported_access_lists.store(unsupported, Ordering::SeqCst);
+        }
+    }
+
+    /// Inserts headers with block access lists and returns the last header and block body.
+    fn insert_headers_with_access_lists_into_client(
+        client: &FullBlockWithAccessListsClient,
+        range: Range<usize>,
+    ) -> (SealedHeader, BlockBody) {
+        let mut sealed_header: SealedHeader = SealedHeader::default();
+        let body = BlockBody::default();
+        for block_idx in range {
+            let (mut header, hash) = sealed_header.split();
+            header.parent_hash = hash;
+            header.number += 1;
+            let access_list = Bytes::from(vec![0xc1, block_idx as u8]);
+            header.block_access_list_hash = Some(keccak256(access_list.as_ref()));
+
+            sealed_header = SealedHeader::seal_slow(header);
+
+            client.insert(sealed_header.clone(), body.clone(), access_list);
+        }
+
+        (sealed_header, body)
     }
 
     impl DownloadClient for FullBlockWithAccessListsClient {
@@ -1107,39 +1632,71 @@ mod tests {
         }
     }
 
+    struct MaybePendingAccessLists {
+        response: Option<PeerRequestResult<BlockAccessLists>>,
+        pending_polls: usize,
+    }
+
+    impl MaybePendingAccessLists {
+        const fn new(response: PeerRequestResult<BlockAccessLists>, pending_polls: usize) -> Self {
+            Self { response: Some(response), pending_polls }
+        }
+    }
+
+    impl std::future::Future for MaybePendingAccessLists {
+        type Output = PeerRequestResult<BlockAccessLists>;
+
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            if self.pending_polls > 0 {
+                self.pending_polls -= 1;
+                cx.waker().wake_by_ref();
+                return Poll::Pending
+            }
+
+            Poll::Ready(self.response.take().expect("future polled after completion"))
+        }
+    }
+
     impl BlockAccessListsClient for FullBlockWithAccessListsClient {
-        type Output = futures::future::Ready<PeerRequestResult<BlockAccessLists>>;
+        type Output = MaybePendingAccessLists;
 
         fn get_block_access_lists_with_priority_and_requirement(
             &self,
             hashes: Vec<B256>,
             _priority: Priority,
-            _requirement: crate::block_access_lists::client::BalRequirement,
+            requirement: BalRequirement,
         ) -> Self::Output {
             self.access_list_requests.fetch_add(1, Ordering::SeqCst);
+            *self.last_access_list_requirement.lock() = Some(requirement);
+            let pending_polls = self.access_list_pending_polls.swap(0, Ordering::SeqCst);
+
+            if self.unsupported_access_lists.load(Ordering::SeqCst) {
+                return MaybePendingAccessLists::new(
+                    Err(RequestError::UnsupportedCapability),
+                    pending_polls,
+                )
+            }
 
             if self.empty_first_response.swap(false, Ordering::SeqCst) {
-                return futures::future::ready(Ok(WithPeerId::new(
-                    PeerId::random(),
-                    BlockAccessLists(Vec::new()),
-                )))
+                return MaybePendingAccessLists::new(
+                    Ok(WithPeerId::new(PeerId::random(), BlockAccessLists(Vec::new()))),
+                    pending_polls,
+                )
             }
 
-            let access_lists = hashes
+            let mut access_lists: Vec<_> = hashes
                 .into_iter()
-                .map(|hash| {
-                    self.access_lists
-                        .lock()
-                        .get(&hash)
-                        .cloned()
-                        .unwrap_or_else(|| Bytes::from_static(&[EMPTY_LIST_CODE]))
-                })
+                .take(self.access_list_soft_limit.load(Ordering::SeqCst))
+                .map(|hash| self.access_lists.lock().get(&hash).cloned())
                 .collect();
+            for _ in 0..self.extra_access_list_entries.load(Ordering::SeqCst) {
+                access_lists.push(None);
+            }
 
-            futures::future::ready(Ok(WithPeerId::new(
-                PeerId::random(),
-                BlockAccessLists(access_lists),
-            )))
+            MaybePendingAccessLists::new(
+                Ok(WithPeerId::new(PeerId::random(), BlockAccessLists(access_lists))),
+                pending_polls,
+            )
         }
     }
 
@@ -1262,6 +1819,260 @@ mod tests {
         assert_eq!(body_requests.load(Ordering::SeqCst), 3);
     }
 
+    #[tokio::test]
+    async fn download_full_block_range_with_access_lists() {
+        let client = FullBlockWithAccessListsClient::default();
+        let (header, _) = insert_headers_with_access_lists_into_client(&client, 0..3);
+
+        let access_lists = Arc::clone(&client.access_lists);
+        let request_count = Arc::clone(&client.access_list_requests);
+        let requirement = Arc::clone(&client.last_access_list_requirement);
+        let client = FullBlockClient::test_client(client);
+
+        let response = timeout(
+            Duration::from_secs(1),
+            client.get_full_block_range_with_optional_access_lists(header.hash(), 3),
+        )
+        .await
+        .expect("range request should complete");
+
+        let blocks = response;
+        assert_eq!(blocks.len(), 3);
+        let expected = {
+            let access_lists = access_lists.lock();
+            blocks
+                .iter()
+                .map(|block| {
+                    let access_list = access_lists
+                        .get(&block.block().hash())
+                        .cloned()
+                        .expect("access list exists");
+                    Some(sealed_access_list(access_list))
+                })
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(range_access_lists(&blocks), expected);
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+        assert_eq!(*requirement.lock(), Some(BalRequirement::Optional));
+    }
+
+    #[tokio::test]
+    async fn download_full_block_range_with_access_lists_returns_none_for_empty_response() {
+        let client = FullBlockWithAccessListsClient::default();
+        client.empty_first_response.store(true, Ordering::SeqCst);
+        let (header, _) = insert_headers_with_access_lists_into_client(&client, 0..3);
+
+        let request_count = Arc::clone(&client.access_list_requests);
+        let client = FullBlockClient::test_client(client);
+
+        let response = timeout(
+            Duration::from_secs(1),
+            client.get_full_block_range_with_optional_access_lists(header.hash(), 3),
+        )
+        .await
+        .expect("range request should complete without access lists");
+
+        let blocks = response;
+        assert_eq!(blocks.len(), 3);
+        assert_eq!(range_access_lists(&blocks), vec![None; blocks.len()]);
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn download_full_block_range_with_access_lists_uses_requested_requirement() {
+        let client = FullBlockWithAccessListsClient::default();
+        let (header, _) = insert_headers_with_access_lists_into_client(&client, 0..3);
+
+        let requirement = Arc::clone(&client.last_access_list_requirement);
+        let client = FullBlockClient::test_client(client);
+
+        let blocks = timeout(
+            Duration::from_secs(1),
+            client.get_full_block_range_with_optional_access_lists_with_requirement(
+                header.hash(),
+                3,
+                BalRequirement::Mandatory,
+            ),
+        )
+        .await
+        .expect("range request should complete");
+
+        assert_eq!(blocks.len(), 3);
+        assert_eq!(*requirement.lock(), Some(BalRequirement::Mandatory));
+    }
+
+    #[tokio::test]
+    async fn download_full_block_range_with_access_lists_preserves_short_response() {
+        let client = FullBlockWithAccessListsClient::default();
+        client.set_access_list_soft_limit(2);
+        let (header, _) = insert_headers_with_access_lists_into_client(&client, 0..5);
+
+        let access_lists = Arc::clone(&client.access_lists);
+        let request_count = Arc::clone(&client.access_list_requests);
+        let client = FullBlockClient::test_client(client);
+
+        let blocks = timeout(
+            Duration::from_secs(1),
+            client.get_full_block_range_with_optional_access_lists(header.hash(), 5),
+        )
+        .await
+        .expect("range request should complete without access lists");
+
+        assert_eq!(blocks.len(), 5);
+        let expected = {
+            let access_lists = access_lists.lock();
+            blocks
+                .iter()
+                .enumerate()
+                .map(|(idx, block)| {
+                    if idx >= 2 {
+                        return None
+                    }
+
+                    let access_list = access_lists
+                        .get(&block.block().hash())
+                        .cloned()
+                        .expect("access list exists");
+                    Some(sealed_access_list(access_list))
+                })
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(range_access_lists(&blocks), expected);
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn download_full_block_range_with_access_lists_preserves_unavailable_entries() {
+        let client = FullBlockWithAccessListsClient::default();
+        let (header, _) = insert_headers_with_access_lists_into_client(&client, 0..3);
+        client.access_lists.lock().remove(&header.hash());
+
+        let access_lists = Arc::clone(&client.access_lists);
+        let bad_messages = Arc::clone(&client.bad_messages);
+        let client = FullBlockClient::test_client(client);
+
+        let blocks = timeout(
+            Duration::from_secs(1),
+            client.get_full_block_range_with_optional_access_lists(header.hash(), 3),
+        )
+        .await
+        .expect("range request should complete");
+
+        assert_eq!(blocks.len(), 3);
+        let expected = {
+            let access_lists = access_lists.lock();
+            blocks
+                .iter()
+                .map(|block| {
+                    if block.block().hash() == header.hash() {
+                        return None
+                    }
+
+                    let access_list = access_lists
+                        .get(&block.block().hash())
+                        .cloned()
+                        .expect("access list exists");
+                    Some(sealed_access_list(access_list))
+                })
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(range_access_lists(&blocks), expected);
+        assert_eq!(bad_messages.load(Ordering::SeqCst), 0);
+    }
+
+    #[tokio::test]
+    async fn download_full_block_range_with_access_lists_returns_none_when_unavailable() {
+        let client = FullBlockWithAccessListsClient::default();
+        client.set_access_lists_unsupported(true);
+        let (header, _) = insert_headers_with_access_lists_into_client(&client, 0..3);
+
+        let request_count = Arc::clone(&client.access_list_requests);
+        let client = FullBlockClient::test_client(client);
+
+        let blocks = timeout(
+            Duration::from_secs(1),
+            client.get_full_block_range_with_optional_access_lists(header.hash(), 3),
+        )
+        .await
+        .expect("range request should complete without access lists");
+
+        assert_eq!(blocks.len(), 3);
+        assert_eq!(range_access_lists(&blocks), vec![None; blocks.len()]);
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn download_full_block_range_with_access_lists_ignores_long_response() {
+        let client = FullBlockWithAccessListsClient::default();
+        client.set_extra_access_list_entries(1);
+        let (header, _) = insert_headers_with_access_lists_into_client(&client, 0..3);
+
+        let request_count = Arc::clone(&client.access_list_requests);
+        let bad_messages = Arc::clone(&client.bad_messages);
+        let client = FullBlockClient::test_client(client);
+
+        let blocks = timeout(
+            Duration::from_secs(1),
+            client.get_full_block_range_with_optional_access_lists(header.hash(), 3),
+        )
+        .await
+        .expect("range request should complete without access lists");
+
+        assert_eq!(blocks.len(), 3);
+        assert_eq!(range_access_lists(&blocks), vec![None; blocks.len()]);
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+        assert_eq!(bad_messages.load(Ordering::SeqCst), 0);
+    }
+
+    #[tokio::test]
+    async fn download_full_block_range_with_access_lists_rejects_wrong_hash() {
+        let client = FullBlockWithAccessListsClient::default();
+        let (header, _) = insert_headers_with_access_lists_into_client(&client, 0..3);
+        client.access_lists.lock().insert(header.hash(), Bytes::from_static(&[0xc1, 0x7f]));
+
+        let bad_messages = Arc::clone(&client.bad_messages);
+        let client = FullBlockClient::test_client(client);
+
+        let blocks = timeout(
+            Duration::from_secs(1),
+            client.get_full_block_range_with_optional_access_lists(header.hash(), 3),
+        )
+        .await
+        .expect("range request should complete without access lists");
+
+        assert_eq!(blocks.len(), 3);
+        assert_eq!(range_access_lists(&blocks), vec![None; blocks.len()]);
+        assert_eq!(bad_messages.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn download_full_block_range_with_access_lists_preserves_valid_prefix_until_wrong_hash() {
+        let client = FullBlockWithAccessListsClient::default();
+        let (header, _) = insert_headers_with_access_lists_into_client(&client, 0..3);
+        let first_access_list =
+            client.access_lists.lock().get(&header.hash()).cloned().expect("access list exists");
+        let second_hash = header.parent_hash;
+        client.access_lists.lock().insert(second_hash, Bytes::from_static(&[0xc1, 0x7f]));
+
+        let bad_messages = Arc::clone(&client.bad_messages);
+        let client = FullBlockClient::test_client(client);
+
+        let blocks = timeout(
+            Duration::from_secs(1),
+            client.get_full_block_range_with_optional_access_lists(header.hash(), 3),
+        )
+        .await
+        .expect("range request should complete without unvalidated access lists");
+
+        assert_eq!(blocks.len(), 3);
+        assert_eq!(blocks[1].block().hash(), second_hash);
+        assert_eq!(
+            range_access_lists(&blocks),
+            vec![Some(sealed_access_list(first_access_list)), None, None]
+        );
+        assert_eq!(bad_messages.load(Ordering::SeqCst), 1);
+    }
+
     #[tokio::test]
     async fn download_full_block_range_with_invalid_header() {
         let client = TestFullBlockClient::default();
diff --git a/crates/net/p2p/src/lib.rs b/crates/net/p2p/src/lib.rs
index 4457fdd9f9d..6a08740e117 100644
--- a/crates/net/p2p/src/lib.rs
+++ b/crates/net/p2p/src/lib.rs
@@ -58,6 +58,7 @@ pub use block_access_lists::client::{BalRequirement, BlockAccessListsClient};
 pub use bodies::client::BodiesClient;
 pub use headers::client::HeadersClient;
 pub use receipts::client::ReceiptsClient;
+pub use reth_eth_wire_types::BlockAccessLists;
 use reth_primitives_traits::Block;
 
 /// Helper trait that unifies network behaviour needed for fetching entire blocks.
diff --git a/crates/net/peers/Cargo.toml b/crates/net/peers/Cargo.toml
index 63bdb344f05..5e4259fb62b 100644
--- a/crates/net/peers/Cargo.toml
+++ b/crates/net/peers/Cargo.toml
@@ -46,5 +46,9 @@ std = [
     "url/std",
     "serde_json/std",
 ]
-secp256k1 = ["dep:secp256k1", "enr/secp256k1"]
+secp256k1 = [
+    "dep:secp256k1",
+    "enr/secp256k1",
+    "alloy-primitives/secp256k1",
+]
 net = ["std", "dep:tokio", "tokio?/net"]
diff --git a/crates/net/peers/src/lib.rs b/crates/net/peers/src/lib.rs
index 9b6ee1f0280..e7a656cb94c 100644
--- a/crates/net/peers/src/lib.rs
+++ b/crates/net/peers/src/lib.rs
@@ -18,9 +18,9 @@
 //! signed, versioned record that includes the information from a [`NodeRecord`] along with
 //! additional metadata. This is the data structure returned from discovery v5 queries.
 //!
-//! When we need to deserialize an identifier that could be any of these three types ([`PeerId`],
-//! [`NodeRecord`], and [`Enr`]), we use the [`AnyNode`] type, which is an enum over the three
-//! types. [`AnyNode`] is used in reth's `admin_addTrustedPeer` RPC method.
+//! When we need to deserialize an identifier that could be a [`PeerId`], [`NodeRecord`], [`Enr`],
+//! or [`TrustedPeer`], we use the [`AnyNode`] type. [`AnyNode`] is used in reth's
+//! `admin_addTrustedPeer` RPC method.
 //!
 //! The __final__ type is the [`TrustedPeer`] type, which is similar to a [`NodeRecord`] but may
 //! include a domain name instead of a direct IP address. It includes a `resolve` method, which can
@@ -34,8 +34,8 @@
 //! - [`NodeRecord`]: A more complete representation of a peer, including IP address and ports.
 //! - [`Enr`]: An Ethereum Node Record, which is a signed, versioned record that includes additional
 //!   metadata. Useful when interacting with discovery v5, or when custom metadata is required.
-//! - [`AnyNode`]: An enum over [`PeerId`], [`NodeRecord`], and [`Enr`], useful in deserialization
-//!   when the type of the node record is not known.
+//! - [`AnyNode`]: An enum over [`PeerId`], [`NodeRecord`], [`Enr`], and [`TrustedPeer`], useful in
+//!   deserialization when the type of the node record is not known.
 //! - [`TrustedPeer`]: A [`NodeRecord`] with an optional domain name, which can be resolved to a
 //!   [`NodeRecord`]. Useful for adding trusted peers at startup, whose IP address may not be
 //!   static.
@@ -121,24 +121,46 @@ pub enum AnyNode {
     Enr(Enr<secp256k1::SecretKey>),
     /// An incomplete "enode" with only a peer id
     PeerId(PeerId),
+    /// An "enode:" peer whose host may be a domain name instead of an IP address
+    TrustedPeer(TrustedPeer),
 }
 
 impl AnyNode {
     /// Returns the peer id of the node.
+    #[cfg(not(feature = "secp256k1"))]
+    pub const fn peer_id(&self) -> PeerId {
+        match self {
+            Self::NodeRecord(record) => record.id,
+            Self::PeerId(peer_id) => *peer_id,
+            Self::TrustedPeer(peer) => peer.id,
+        }
+    }
+
+    /// Returns the peer id of the node.
+    #[cfg(feature = "secp256k1")]
     pub fn peer_id(&self) -> PeerId {
         match self {
             Self::NodeRecord(record) => record.id,
-            #[cfg(feature = "secp256k1")]
             Self::Enr(enr) => pk2id(&enr.public_key()),
             Self::PeerId(peer_id) => *peer_id,
+            Self::TrustedPeer(peer) => peer.id,
+        }
+    }
+
+    /// Returns the full node record if available.
+    #[cfg(not(feature = "secp256k1"))]
+    pub const fn node_record(&self) -> Option<NodeRecord> {
+        match self {
+            Self::NodeRecord(record) => Some(*record),
+            Self::PeerId(_) | Self::TrustedPeer(_) => None,
         }
     }
 
     /// Returns the full node record if available.
+    #[cfg(feature = "secp256k1")]
     pub fn node_record(&self) -> Option<NodeRecord> {
         match self {
             Self::NodeRecord(record) => Some(*record),
-            #[cfg(feature = "secp256k1")]
             Self::Enr(enr) => {
                 let node_record = NodeRecord {
                     address: enr
@@ -152,6 +174,14 @@ impl AnyNode {
                 .into_ipv4_mapped();
                 Some(node_record)
             }
+            Self::PeerId(_) | Self::TrustedPeer(_) => None,
+        }
+    }
+
+    /// Returns the [`TrustedPeer`] if this is a `TrustedPeer` variant.
+    pub const fn trusted_peer(&self) -> Option<&TrustedPeer> {
+        match self {
+            Self::TrustedPeer(peer) => Some(peer),
             _ => None,
         }
     }
@@ -178,7 +208,11 @@ impl FromStr for AnyNode {
             if let Ok(record) = NodeRecord::from_str(s) {
                 return Ok(Self::NodeRecord(record))
             }
-            // incomplete enode
+            // NodeRecord parsing rejects domain hosts, but trusted peers may use DNS names.
+            if let Ok(trusted) = TrustedPeer::from_str(s) {
+                return Ok(Self::TrustedPeer(trusted))
+            }
+            // incomplete enode with only a peer id
             if let Ok(peer_id) = PeerId::from_str(rem) {
                 return Ok(Self::PeerId(peer_id))
             }
@@ -201,6 +235,7 @@ impl core::fmt::Display for AnyNode {
             Self::PeerId(peer_id) => {
                 write!(f, "enode://{}", alloy_primitives::hex::encode(peer_id.as_slice()))
             }
+            Self::TrustedPeer(peer) => write!(f, "{peer}"),
         }
     }
 }
@@ -324,6 +359,20 @@ mod tests {
         assert_eq!(node.to_string(), url);
     }
 
+    #[test]
+    fn test_trusted_peer_parse_hostname() {
+        let url = "enode://6f8a80d14311c39f35f516fa664deaaaa13e85b2f7493f37f6144d86991ec012937307647bd3b9a82abe2974e1407241d54947bbb39763a4cac9f77166ad92a0@my-node.example.com:30303";
+        let node: AnyNode = url.parse().unwrap();
+        assert!(matches!(node, AnyNode::TrustedPeer(_)));
+        assert_eq!(
+            node.peer_id(),
+            "6f8a80d14311c39f35f516fa664deaaaa13e85b2f7493f37f6144d86991ec012937307647bd3b9a82abe2974e1407241d54947bbb39763a4cac9f77166ad92a0".parse::<PeerId>().unwrap()
+        );
+        assert!(node.node_record().is_none());
+        assert!(node.trusted_peer().is_some());
+        assert_eq!(node.to_string(), url);
+    }
+
     #[test]
     #[cfg(feature = "secp256k1")]
     fn pk2id2pk() {
diff --git a/crates/node/builder/Cargo.toml b/crates/node/builder/Cargo.toml
index 0717b3e10b1..6428ce6f3f3 100644
--- a/crates/node/builder/Cargo.toml
+++ b/crates/node/builder/Cargo.toml
@@ -51,7 +51,7 @@ reth-stages.workspace = true
 reth-static-file.workspace = true
 reth-tasks = { workspace = true, features = ["rayon"] }
 reth-tokio-util.workspace = true
-reth-tracing.workspace = true
+reth-tracing = { workspace = true, features = ["std"] }
 reth-transaction-pool.workspace = true
 reth-trie-db = { workspace = true, features = ["metrics"] }
 reth-basic-payload-builder.workspace = true
diff --git a/crates/node/builder/src/builder/mod.rs b/crates/node/builder/src/builder/mod.rs
index b0dd0e7f822..e9a611b56fb 100644
--- a/crates/node/builder/src/builder/mod.rs
+++ b/crates/node/builder/src/builder/mod.rs
@@ -914,8 +914,13 @@ impl<Node: FullNodeTypes> BuilderContext<Node> {
         AnnPolicy: AnnouncementFilteringPolicy<N>,
     {
         let (handle, network, txpool, eth) = builder
-            .transactions_with_policies(pool, tx_config, propagation_policy, announcement_policy)
-            .request_handler(self.provider().clone())
+            .transactions_with_policies(
+                pool.clone(),
+                tx_config,
+                propagation_policy,
+                announcement_policy,
+            )
+            .request_handler_with_blob_store(self.provider().clone(), pool.blob_store())
             .split_with_handle();
 
         self.executor.spawn_critical_blocking_task("p2p txpool", txpool);
diff --git a/crates/node/builder/src/components/payload.rs b/crates/node/builder/src/components/payload.rs
index 5afe08ee5e9..562253b03ef 100644
--- a/crates/node/builder/src/components/payload.rs
+++ b/crates/node/builder/src/components/payload.rs
@@ -65,13 +65,33 @@ pub trait PayloadBuilderBuilder<Node: FullNodeTypes, Pool: TransactionPool, EvmC
 }
 
 /// Basic payload service builder that spawns a [`BasicPayloadJobGenerator`]
-#[derive(Debug, Default, Clone)]
-pub struct BasicPayloadServiceBuilder<PB>(PB);
+#[derive(Debug, Clone)]
+pub struct BasicPayloadServiceBuilder<PB> {
+    /// Builds the payload builder used by generated payload jobs.
+    payload_builder_builder: PB,
+    /// Whether to pre-cache changed state from canonical state notifications.
+    pre_cache_state: bool,
+}
 
 impl<PB> BasicPayloadServiceBuilder<PB> {
     /// Create a new [`BasicPayloadServiceBuilder`].
     pub const fn new(payload_builder_builder: PB) -> Self {
-        Self(payload_builder_builder)
+        Self { payload_builder_builder, pre_cache_state: true }
+    }
+
+    /// Sets whether to pre-cache changed state from canonical state notifications.
+    pub const fn with_pre_cache_state(mut self, pre_cache_state: bool) -> Self {
+        self.pre_cache_state = pre_cache_state;
+        self
+    }
+}
+
+impl<PB> Default for BasicPayloadServiceBuilder<PB>
+where
+    PB: Default,
+{
+    fn default() -> Self {
+        Self::new(PB::default())
     }
 }
 
@@ -89,14 +109,17 @@ where
         pool: Pool,
         evm_config: EvmConfig,
     ) -> eyre::Result<PayloadBuilderHandle<<Node::Types as NodeTypes>::Payload>> {
-        let payload_builder = self.0.build_payload_builder(ctx, pool, evm_config).await?;
+        let Self { payload_builder_builder, pre_cache_state } = self;
+        let payload_builder =
+            payload_builder_builder.build_payload_builder(ctx, pool, evm_config).await?;
 
         let conf = ctx.config().builder.clone();
 
         let payload_job_config = BasicPayloadJobGeneratorConfig::default()
             .interval(conf.interval)
             .deadline(conf.deadline)
-            .max_payload_tasks(conf.max_payload_tasks);
+            .max_payload_tasks(conf.max_payload_tasks)
+            .pre_cache_state(pre_cache_state);
 
         let payload_generator = BasicPayloadJobGenerator::with_builder(
             ctx.provider().clone(),
@@ -105,9 +128,16 @@ where
             payload_builder,
         );
         let (payload_service, payload_service_handle) =
-            PayloadBuilderService::new(payload_generator, ctx.provider().canonical_state_stream());
-
-        ctx.task_executor().spawn_critical_task("payload builder service", payload_service);
+            PayloadBuilderService::<_, _, <Node::Types as NodeTypes>::Payload>::new(
+                payload_generator,
+                ctx.provider().canonical_state_stream(),
+            );
+
+        ctx.task_executor().spawn_critical_os_thread(
+            "payload-service",
+            "payload builder service",
+            payload_service,
+        );
 
         Ok(payload_service_handle)
     }
@@ -133,22 +163,26 @@ where
     ) -> eyre::Result<PayloadBuilderHandle<<Node::Types as NodeTypes>::Payload>> {
         let (tx, mut rx) = mpsc::unbounded_channel();
 
-        ctx.task_executor().spawn_critical_task("payload builder", async move {
-            #[expect(clippy::collection_is_never_read)]
-            let mut subscriptions = Vec::new();
-
-            while let Some(message) = rx.recv().await {
-                match message {
-                    PayloadServiceCommand::Subscribe(tx) => {
-                        let (events_tx, events_rx) = broadcast::channel(100);
-                        // Retain senders to make sure that channels are not getting closed
-                        subscriptions.push(events_tx);
-                        let _ = tx.send(events_rx);
+        ctx.task_executor().spawn_critical_os_thread(
+            "payload-service",
+            "payload builder service",
+            async move {
+                #[expect(clippy::collection_is_never_read)]
+                let mut subscriptions = Vec::new();
+
+                while let Some(message) = rx.recv().await {
+                    match message {
+                        PayloadServiceCommand::Subscribe(tx) => {
+                            let (events_tx, events_rx) = broadcast::channel(100);
+                            // Retain senders to make sure that channels are not getting closed
+                            subscriptions.push(events_tx);
+                            let _ = tx.send(events_rx);
+                        }
+                        message => warn!(?message, "Noop payload service received a message"),
                     }
-                    message => warn!(?message, "Noop payload service received a message"),
                 }
-            }
-        });
+            },
+        );
 
         Ok(PayloadBuilderHandle::new(tx))
     }
diff --git a/crates/node/builder/src/components/pool.rs b/crates/node/builder/src/components/pool.rs
index eb9568f5fff..8d1afcdb59c 100644
--- a/crates/node/builder/src/components/pool.rs
+++ b/crates/node/builder/src/components/pool.rs
@@ -50,11 +50,11 @@ where
 /// Convenience type to override cli or default pool configuration during build.
 #[derive(Debug, Clone, Default)]
 pub struct PoolBuilderConfigOverrides {
-    /// Max number of transaction in the pending sub-pool
+    /// Max number of transactions in the pending sub-pool
     pub pending_limit: Option<SubPoolLimit>,
-    /// Max number of transaction in the basefee sub-pool
+    /// Max number of transactions in the basefee sub-pool
     pub basefee_limit: Option<SubPoolLimit>,
-    /// Max number of transaction in the queued sub-pool
+    /// Max number of transactions in the queued sub-pool
     pub queued_limit: Option<SubPoolLimit>,
     /// Max number of transactions in the blob sub-pool
     pub blob_limit: Option<SubPoolLimit>,
@@ -136,8 +136,8 @@ where
     V::Transaction:
         PoolTransaction<Consensus = TxTy<Node::Types>> + reth_transaction_pool::EthPoolTransaction,
 {
-    /// Consume the ype and build the [`reth_transaction_pool::Pool`] with the given config and blob
-    /// store.
+    /// Consume the type and build the [`reth_transaction_pool::Pool`] with the given config and
+    /// blob store.
     pub fn build<BS>(
         self,
         blob_store: BS,
@@ -173,7 +173,7 @@ where
         >,
     >
     where
-        BS: BlobStore,
+        BS: BlobStore + Clone,
     {
         self.build_with_ordering_and_spawn_maintenance_task(
             CoinbaseTipOrdering::default(),
@@ -191,7 +191,7 @@ where
         pool_config: PoolConfig,
     ) -> eyre::Result<reth_transaction_pool::Pool<TransactionValidationTaskExecutor<V>, O, BS>>
     where
-        BS: BlobStore,
+        BS: BlobStore + Clone,
         O: TransactionOrdering<Transaction = V::Transaction>,
     {
         let TxPoolBuilder { ctx, validator, .. } = self;
diff --git a/crates/node/builder/src/launch/common.rs b/crates/node/builder/src/launch/common.rs
index 94272368775..dca47987689 100644
--- a/crates/node/builder/src/launch/common.rs
+++ b/crates/node/builder/src/launch/common.rs
@@ -42,7 +42,9 @@ use reth_chainspec::{Chain, EthChainSpec, EthereumHardforks};
 use reth_config::{config::EtlConfig, PruneConfig};
 use reth_consensus::noop::NoopConsensus;
 use reth_db_api::{database::Database, database_metrics::DatabaseMetrics};
-use reth_db_common::init::{init_genesis_with_settings, InitStorageError};
+use reth_db_common::init::{
+    init_genesis_with_settings, init_genesis_with_settings_and_validate, InitStorageError,
+};
 use reth_downloaders::{bodies::noop::NoopBodiesDownloader, headers::noop::NoopHeaderDownloader};
 use reth_engine_local::MiningMode;
 use reth_evm::{noop::NoopEvmConfig, ConfigureEvm};
@@ -51,7 +53,7 @@ use reth_fs_util as fs;
 use reth_network_p2p::headers::client::HeadersClient;
 use reth_node_api::{FullNodeTypes, NodeTypes, NodeTypesWithDB, NodeTypesWithDBAdapter};
 use reth_node_core::{
-    args::DefaultEraHost,
+    args::{DefaultEraHost, PruneConfigKind},
     dirs::{ChainPath, DataDirPath},
     node_config::NodeConfig,
     primitives::BlockHeader,
@@ -62,20 +64,21 @@ use reth_node_metrics::{
     hooks::Hooks,
     recorder::install_prometheus_recorder,
     server::{MetricServer, MetricServerConfig},
+    storage::StorageSettingsInfo,
     version::VersionInfo,
 };
 use reth_provider::{
     providers::{NodeTypesForProvider, ProviderNodeTypes, RocksDBProvider, StaticFileProvider},
-    BlockHashReader, BlockNumReader, ProviderError, ProviderFactory, ProviderResult,
-    RocksDBProviderFactory, StageCheckpointReader, StaticFileProviderBuilder,
-    StaticFileProviderFactory,
+    BalConfig, BalStoreHandle, BlockHashReader, BlockNumReader, InMemoryBalStore, ProviderError,
+    ProviderFactory, ProviderResult, RocksDBProviderFactory, StageCheckpointReader,
+    StaticFileProviderBuilder, StaticFileProviderFactory, StorageSettingsCache,
 };
 use reth_prune::{PruneModes, PrunerBuilder};
 use reth_rpc_builder::config::RethRpcServerConfig;
 use reth_rpc_layer::JwtSecret;
 use reth_stages::{
     sets::DefaultStages, stages::EraImportSource, MetricEvent, PipelineBuilder, PipelineTarget,
-    StageId,
+    StageId, StageSet,
 };
 use reth_static_file::StaticFileProducer;
 use reth_tasks::TaskExecutor;
@@ -474,6 +477,7 @@ where
         &self,
         changeset_cache: ChangesetCache,
         rocksdb_provider: Option<RocksDBProvider>,
+        disabled_stages: &[StageId],
     ) -> eyre::Result<ProviderFactory<N>>
     where
         N: ProviderNodeTypes<DB = DB, ChainSpec = ChainSpec>,
@@ -503,6 +507,14 @@ where
         };
 
         let prune_config = self.prune_config();
+        let balstore_cache_size = self
+            .node_config()
+            .db
+            .balstore_cache_size
+            .unwrap_or(BalConfig::DEFAULT_IN_MEMORY_RETENTION_DISTANCE);
+        let bal_store = BalStoreHandle::new(InMemoryBalStore::new(
+            BalConfig::with_in_memory_retention_distance(balstore_cache_size),
+        ));
         let factory = ProviderFactory::new(
             self.right().clone(),
             self.chain_spec(),
@@ -512,7 +524,8 @@ where
         )?
         .with_prune_modes(prune_config.segments)
         .with_minimum_pruning_distance(prune_config.minimum_pruning_distance)
-        .with_changeset_cache(changeset_cache);
+        .with_changeset_cache(changeset_cache)
+        .with_bal_store(bal_store);
 
         // Check consistency between the database and static files, returning
         // the unwind targets for each storage layer if inconsistencies are
@@ -545,17 +558,21 @@ where
 
             // Builds an unwind-only pipeline
             let pipeline = PipelineBuilder::default()
-                .add_stages(DefaultStages::new(
-                    factory.clone(),
-                    tip_rx,
-                    Arc::new(NoopConsensus::default()),
-                    NoopHeaderDownloader::default(),
-                    NoopBodiesDownloader::default(),
-                    NoopEvmConfig::<Evm>::default(),
-                    self.toml_config().stages.clone(),
-                    self.prune_modes(),
-                    None,
-                ))
+                .add_stages(
+                    DefaultStages::new(
+                        factory.clone(),
+                        tip_rx,
+                        Arc::new(NoopConsensus::default()),
+                        NoopHeaderDownloader::default(),
+                        NoopBodiesDownloader::default(),
+                        NoopEvmConfig::<Evm>::default(),
+                        self.toml_config().stages.clone(),
+                        self.prune_modes(),
+                        None,
+                    )
+                    .builder()
+                    .disable_all(disabled_stages),
+                )
                 .build(
                     factory.clone(),
                     StaticFileProducer::new(factory.clone(), self.prune_modes()),
@@ -582,13 +599,15 @@ where
         self,
         changeset_cache: ChangesetCache,
         rocksdb_provider: Option<RocksDBProvider>,
+        disabled_stages: &[StageId],
     ) -> eyre::Result<LaunchContextWith<Attached<WithConfigs<ChainSpec>, ProviderFactory<N>>>>
     where
         N: ProviderNodeTypes<DB = DB, ChainSpec = ChainSpec>,
         Evm: ConfigureEvm<Primitives = N::Primitives> + 'static,
     {
-        let factory =
-            self.create_provider_factory::<N, Evm>(changeset_cache, rocksdb_provider).await?;
+        let factory = self
+            .create_provider_factory::<N, Evm>(changeset_cache, rocksdb_provider, disabled_stages)
+            .await?;
         let ctx = LaunchContextWith {
             inner: self.inner,
             attachment: self.attachment.map_right(|_| factory),
@@ -620,18 +639,36 @@ where
     /// This launches the prometheus endpoint.
     ///
     /// Convenience function to [`Self::start_prometheus_endpoint`]
-    pub async fn with_prometheus_server(self) -> eyre::Result<Self> {
+    pub async fn with_prometheus_server(self) -> eyre::Result<Self>
+    where
+        T::ChainSpec: EthereumHardforks,
+    {
         self.start_prometheus_endpoint().await?;
         Ok(self)
     }
 
     /// Starts the prometheus endpoint.
-    pub async fn start_prometheus_endpoint(&self) -> eyre::Result<()> {
+    pub async fn start_prometheus_endpoint(&self) -> eyre::Result<()>
+    where
+        T::ChainSpec: EthereumHardforks,
+    {
         // ensure recorder runs upkeep periodically
         install_prometheus_recorder().spawn_upkeep();
 
         let listen_addr = self.node_config().metrics.prometheus;
         if let Some(addr) = listen_addr {
+            let prune_config = self.prune_config();
+            let pruning_mode =
+                PruneConfigKind::from_config(&prune_config, self.chain_spec().as_ref()).as_str();
+            // On existing databases, stored settings are authoritative and already cached by the
+            // provider factory. Fresh databases do not have storage metadata until genesis is
+            // initialized, so report the configured setting during this pre-genesis startup window.
+            let storage_settings =
+                if self.provider_factory().get_stage_checkpoint(StageId::Headers)?.is_some() {
+                    self.provider_factory().cached_storage_settings()
+                } else {
+                    self.node_config().storage_settings()
+                };
             let config = MetricServerConfig::new(
                 addr,
                 VersionInfo {
@@ -647,6 +684,12 @@ where
                 metrics_hooks(self.provider_factory()),
                 self.data_dir().pprof_dumps(),
             )
+            .with_storage_settings_info(StorageSettingsInfo {
+                storage_v2: storage_settings.storage_v2,
+                pruning_mode,
+                prune_config: serde_json::to_string(&prune_config)
+                    .expect("serializing PruneConfig should not fail"),
+            })
             .with_push_gateway(
                 self.node_config().metrics.push_gateway_url.clone(),
                 self.node_config().metrics.push_gateway_interval,
@@ -660,7 +703,11 @@ where
 
     /// Convenience function to [`Self::init_genesis`]
     pub fn with_genesis(self) -> Result<Self, InitStorageError> {
-        init_genesis_with_settings(self.provider_factory(), self.node_config().storage_settings())?;
+        init_genesis_with_settings_and_validate(
+            self.provider_factory(),
+            self.node_config().storage_settings(),
+            !self.node_config().debug.skip_genesis_validation,
+        )?;
         Ok(self)
     }
 
@@ -897,11 +944,14 @@ where
     /// This returns the configured `debug.tip` if set, otherwise it will check if backfill was
     /// previously interrupted and returns the block hash of the last checkpoint, see also
     /// [`Self::check_pipeline_consistency`]
-    pub fn initial_backfill_target(&self) -> ProviderResult<Option<B256>> {
+    pub fn initial_backfill_target(
+        &self,
+        disabled_stages: &[StageId],
+    ) -> ProviderResult<Option<B256>> {
         let mut initial_target = self.node_config().debug.tip;
 
         if initial_target.is_none() {
-            initial_target = self.check_pipeline_consistency()?;
+            initial_target = self.check_pipeline_consistency(disabled_stages)?;
         }
 
         Ok(initial_target)
@@ -949,11 +999,15 @@ where
     /// # Returns
     ///
     /// A target block hash if the pipeline is inconsistent, otherwise `None`.
-    pub fn check_pipeline_consistency(&self) -> ProviderResult<Option<B256>> {
+    pub fn check_pipeline_consistency(
+        &self,
+        disabled_stages: &[StageId],
+    ) -> ProviderResult<Option<B256>> {
         // We skip the era stage if it's not enabled
         let era_enabled = self.era_import_source().is_some();
-        let mut all_stages =
-            StageId::ALL.into_iter().filter(|id| era_enabled || id != &StageId::Era);
+        let mut all_stages = StageId::ALL
+            .into_iter()
+            .filter(|id| (era_enabled || id != &StageId::Era) && !disabled_stages.contains(id));
 
         // Get the expected first stage based on config.
         let first_stage = all_stages.next().expect("there must be at least one stage");
diff --git a/crates/node/builder/src/launch/debug.rs b/crates/node/builder/src/launch/debug.rs
index 3a5644d83ae..0f870f51ac9 100644
--- a/crates/node/builder/src/launch/debug.rs
+++ b/crates/node/builder/src/launch/debug.rs
@@ -5,13 +5,14 @@ use alloy_provider::network::AnyNetwork;
 use jsonrpsee::core::{DeserializeOwned, Serialize};
 use reth_chainspec::EthChainSpec;
 use reth_consensus_debug_client::{
-    BlockProvider, DebugConsensusClient, EtherscanBlockProvider, RpcBlockProvider,
+    DebugConsensusClient, EtherscanBlockProvider, PayloadProvider, RpcBlockProvider,
 };
 use reth_engine_local::{LocalMiner, MiningMode};
 use reth_node_api::{
-    BlockTy, FullNodeComponents, FullNodeTypes, HeaderTy, PayloadAttrTy, PayloadAttributesBuilder,
-    PayloadTypes,
+    BlockTy, FullNodeComponents, FullNodeTypes, HeaderTy, NodeTypes, PayloadAttrTy,
+    PayloadAttributesBuilder, PayloadTypes,
 };
+use reth_primitives_traits::SealedBlock;
 use std::{
     future::{Future, IntoFuture},
     pin::Pin,
@@ -19,11 +20,14 @@ use std::{
 };
 use tracing::info;
 
+/// Helper adapter type for accessing [`PayloadTypes::ExecutionData`] on [`NodeTypes`].
+pub(crate) type PayloadDataTy<N> = <<N as NodeTypes>::Payload as PayloadTypes>::ExecutionData;
+
 /// [`Node`] extension with support for debugging utilities.
 ///
 /// This trait provides additional necessary conversion from RPC block type to the node's
-/// primitive block type, e.g. `alloy_rpc_types_eth::Block` to the node's internal block
-/// representation.
+/// execution payload data type, e.g. `alloy_rpc_types_eth::Block` to the node's Engine API
+/// payload representation.
 ///
 /// This is used in conjunction with the [`DebugNodeLauncher`] to enable debugging features such as:
 ///
@@ -38,7 +42,7 @@ use tracing::info;
 ///
 /// To implement this trait, you need to:
 /// 1. Define the RPC block type (typically `alloy_rpc_types_eth::Block`)
-/// 2. Implement the conversion from RPC format to your primitive block type
+/// 2. Implement the conversion from RPC format to your execution payload data type
 ///
 /// # Example
 ///
@@ -46,15 +50,17 @@ use tracing::info;
 /// impl<N: FullNodeComponents<Types = Self>> DebugNode<N> for MyNode {
 ///     type RpcBlock = alloy_rpc_types_eth::Block;
 ///
-///     fn rpc_to_primitive_block(rpc_block: Self::RpcBlock) -> BlockTy<Self> {
-///         // Convert from RPC format to primitive format by converting the transactions
-///         rpc_block.into_consensus().convert_transactions()
+///     fn rpc_to_execution_data(
+///         rpc_block: Self::RpcBlock,
+///         extras: PayloadExtras,
+///     ) -> PayloadDataTy<Self> {
+///         // Convert from RPC format to the Engine API payload data expected by the node.
 ///     }
 /// }
 /// ```
 pub trait DebugNode<N: FullNodeComponents>: Node<N> {
-    /// RPC block type. Used by [`DebugConsensusClient`] to fetch blocks and submit them to the
-    /// engine. This is intended to match the block format returned by the external RPC endpoint.
+    /// RPC block type. This is intended to match the block format returned by the external RPC
+    /// endpoint.
     type RpcBlock: Serialize + DeserializeOwned + 'static;
 
     /// Converts an RPC block to a primitive block.
@@ -116,7 +122,7 @@ impl<L> DebugNodeLauncher<L> {
 /// bounds.
 pub type DefaultDebugBlockProvider<N> = EtherscanBlockProvider<
     <<N as FullNodeTypes>::Types as DebugNode<N>>::RpcBlock,
-    BlockTy<<N as FullNodeTypes>::Types>,
+    PayloadDataTy<<N as FullNodeTypes>::Types>,
 >;
 
 /// Future for the [`DebugNodeLauncher`].
@@ -140,7 +146,7 @@ where
     N: FullNodeComponents<Types: DebugNode<N>>,
     AddOns: RethRpcAddOns<N>,
     L: LaunchNode<Target, Node = NodeHandle<N, AddOns>>,
-    B: BlockProvider<Block = BlockTy<N::Types>> + Clone,
+    B: PayloadProvider<ExecutionData = PayloadDataTy<N::Types>> + Clone,
 {
     /// Sets a custom payload attributes builder for local mining in dev mode.
     pub fn with_payload_attributes_builder(
@@ -181,7 +187,7 @@ where
         self
     }
 
-    /// Sets a custom block provider for the debug consensus client.
+    /// Sets a custom payload provider for the debug consensus client.
     ///
     /// When set, this provider will be used instead of creating an `EtherscanBlockProvider`
     /// or `RpcBlockProvider` from CLI arguments.
@@ -190,7 +196,7 @@ where
         provider: B2,
     ) -> DebugNodeLauncherFuture<L, Target, N, B2>
     where
-        B2: BlockProvider<Block = BlockTy<N::Types>> + Clone,
+        B2: PayloadProvider<ExecutionData = PayloadDataTy<N::Types>> + Clone,
     {
         DebugNodeLauncherFuture {
             inner: self.inner,
@@ -234,12 +240,16 @@ where
             info!(target: "reth::cli", "Using RPC consensus client: {}", url);
 
             let block_provider =
-                RpcBlockProvider::<AnyNetwork, _>::new(url.as_str(), |block_response| {
+                RpcBlockProvider::<AnyNetwork, _>::new(url.as_str(), |block_response, extras| {
                     let json = serde_json::to_value(block_response)
                         .expect("Block serialization cannot fail");
                     let rpc_block =
                         serde_json::from_value(json).expect("Block deserialization cannot fail");
-                    N::Types::rpc_to_primitive_block(rpc_block)
+                    let primitive_block = N::Types::rpc_to_primitive_block(rpc_block);
+                    <N::Types as NodeTypes>::Payload::block_to_payload(
+                        SealedBlock::new_unhashed(primitive_block),
+                        extras.bal,
+                    )
                 })
                 .await?;
 
@@ -270,7 +280,13 @@ where
                     )
                 })?,
                 chain.id(),
-                N::Types::rpc_to_primitive_block,
+                |rpc_block| {
+                    let primitive_block = N::Types::rpc_to_primitive_block(rpc_block);
+                    <N::Types as NodeTypes>::Payload::block_to_payload(
+                        SealedBlock::new_unhashed(primitive_block),
+                        None,
+                    )
+                },
             );
             let rpc_consensus_client = DebugConsensusClient::new(
                 handle.node.add_ons_handle.beacon_engine_handle.clone(),
@@ -339,7 +355,7 @@ where
     N: FullNodeComponents<Types: DebugNode<N>>,
     AddOns: RethRpcAddOns<N> + 'static,
     L: LaunchNode<Target, Node = NodeHandle<N, AddOns>> + 'static,
-    B: BlockProvider<Block = BlockTy<N::Types>> + Clone + 'static,
+    B: PayloadProvider<ExecutionData = PayloadDataTy<N::Types>> + Clone + 'static,
 {
     type Output = eyre::Result<NodeHandle<N, AddOns>>;
     type IntoFuture = Pin<Box<dyn Future<Output = eyre::Result<NodeHandle<N, AddOns>>> + Send>>;
@@ -355,7 +371,7 @@ where
     N: FullNodeComponents<Types: DebugNode<N>>,
     AddOns: RethRpcAddOns<N> + 'static,
     L: LaunchNode<Target, Node = NodeHandle<N, AddOns>> + 'static,
-    DefaultDebugBlockProvider<N>: BlockProvider<Block = BlockTy<N::Types>> + Clone,
+    DefaultDebugBlockProvider<N>: PayloadProvider<ExecutionData = PayloadDataTy<N::Types>> + Clone,
 {
     type Node = NodeHandle<N, AddOns>;
     type Future = DebugNodeLauncherFuture<L, Target, N>;
diff --git a/crates/node/builder/src/launch/engine.rs b/crates/node/builder/src/launch/engine.rs
index 0b568564930..81e3fb5f00c 100644
--- a/crates/node/builder/src/launch/engine.rs
+++ b/crates/node/builder/src/launch/engine.rs
@@ -5,12 +5,14 @@ use crate::{
     hooks::NodeHooks,
     rpc::{EngineShutdown, EngineValidatorAddOn, EngineValidatorBuilder, RethRpcAddOns, RpcHandle},
     setup::build_networked_pipeline,
-    AddOns, AddOnsContext, FullNode, LaunchContext, LaunchNode, NodeAdapter,
+    AddOns, AddOnsContext, FullNode, LaunchContext, LaunchNode, Node, NodeAdapter,
     NodeBuilderWithComponents, NodeComponents, NodeComponentsBuilder, NodeHandle, NodeTypesAdapter,
+    RethFullAdapter,
 };
 use alloy_consensus::BlockHeader;
 use futures::{stream::FusedStream, stream_select, FutureExt, StreamExt};
 use reth_chainspec::{EthChainSpec, EthereumHardforks};
+use reth_db::{database_metrics::DatabaseMetrics, Database};
 use reth_engine_tree::{
     chain::{ChainEvent, FromOrchestrator},
     engine::{EngineApiKind, EngineApiRequest, EngineRequestHandler},
@@ -25,6 +27,7 @@ use reth_node_api::{
     BuiltPayload, ConsensusEngineHandle, FullNodeTypes, NodeTypes, NodeTypesWithDBAdapter,
 };
 use reth_node_core::{
+    args::PruneConfigKind,
     dirs::{ChainPath, DataDirPath},
     exit::NodeExitFuture,
     primitives::Head,
@@ -63,16 +66,17 @@ impl EngineNodeLauncher {
         Self { ctx: LaunchContext::new(task_executor, data_dir), engine_tree_config }
     }
 
-    async fn launch_node<T, CB, AO>(
+    async fn launch_node<N, DB, T, CB, AO>(
         self,
         target: NodeBuilderWithComponents<T, CB, AO>,
     ) -> eyre::Result<NodeHandle<NodeAdapter<T, CB::Components>, AO>>
     where
+        N: Node<RethFullAdapter<DB, N>> + NodeTypesForProvider,
+        DB: Database + DatabaseMetrics + Clone + Unpin + 'static,
         T: FullNodeTypes<
-            Types: NodeTypesForProvider,
-            Provider = BlockchainProvider<
-                NodeTypesWithDBAdapter<<T as FullNodeTypes>::Types, <T as FullNodeTypes>::DB>,
-            >,
+            Types = N,
+            Provider = BlockchainProvider<NodeTypesWithDBAdapter<N, DB>>,
+            DB = DB,
         >,
         CB: NodeComponentsBuilder<T>,
         AO: RethRpcAddOns<NodeAdapter<T, CB::Components>>
@@ -90,6 +94,7 @@ impl EngineNodeLauncher {
 
         // Create changeset cache that will be shared across the engine
         let changeset_cache = ChangesetCache::new();
+        let disabled_stages = N::disabled_stages();
 
         // setup the launch context
         let ctx = ctx
@@ -103,7 +108,12 @@ impl EngineNodeLauncher {
             // ensure certain settings take effect
             .with_adjusted_configs()
             // Create the provider factory with changeset cache
-            .with_provider_factory::<_, <CB::Components as NodeComponents<T>>::Evm>(changeset_cache.clone(), rocksdb_provider).await?
+            .with_provider_factory::<_, <CB::Components as NodeComponents<T>>::Evm>(
+                changeset_cache.clone(),
+                rocksdb_provider,
+                disabled_stages,
+            )
+            .await?
             .inspect(|_| {
                 info!(target: "reth::cli", "Database opened");
             })
@@ -115,7 +125,9 @@ impl EngineNodeLauncher {
             .inspect(|this: &LaunchContextWith<Attached<WithConfigs<<T::Types as NodeTypes>::ChainSpec>, _>>| {
                 info!(target: "reth::cli", "\n{}", this.chain_spec().display_hardforks());
                 let settings = this.provider_factory().cached_storage_settings();
-                info!(target: "reth::cli", ?settings, "Loaded storage settings");
+                let pruning_mode =
+                    PruneConfigKind::from_config(&this.prune_config(), this.chain_spec().as_ref()).as_str();
+                info!(target: "reth::cli", ?settings, ?pruning_mode, "Loaded storage settings");
             })
             .with_metrics_task()
             // passing FullNodeTypes as type parameter here so that we can build
@@ -159,6 +171,7 @@ impl EngineNodeLauncher {
             ctx.components().evm_config().clone(),
             maybe_exex_manager_handle.clone().unwrap_or_else(ExExManagerHandle::empty),
             ctx.era_import_source(),
+            disabled_stages,
         )?;
 
         // The new engine writes directly to static files. This ensures that they're up to the tip.
@@ -279,7 +292,7 @@ impl EngineNodeLauncher {
         let (engine_shutdown, shutdown_rx) = EngineShutdown::new();
 
         // Run consensus engine to completion
-        let initial_target = ctx.initial_backfill_target()?;
+        let initial_target = ctx.initial_backfill_target(disabled_stages)?;
         let mut built_payloads = ctx
             .components()
             .payload_builder_handle()
@@ -363,7 +376,7 @@ impl EngineNodeLauncher {
                     payload = built_payloads.select_next_some(), if !built_payloads.is_terminated() => {
                         if let Some(executed_block) = payload.executed_block() {
                             debug!(target: "reth::cli", block=?executed_block.recovered_block.num_hash(),  "inserting built payload");
-                            orchestrator.handler_mut().handler_mut().on_event(EngineApiRequest::InsertExecutedBlock(executed_block.into_executed_payload()).into());
+                            orchestrator.handler_mut().handler_mut().on_event(EngineApiRequest::InsertExecutedBlock(executed_block).into());
                         }
                     }
                     shutdown_req = &mut shutdown_rx => {
@@ -427,14 +440,15 @@ impl EngineNodeLauncher {
     }
 }
 
-impl<T, CB, AO> LaunchNode<NodeBuilderWithComponents<T, CB, AO>> for EngineNodeLauncher
+impl<N, DB, T, CB, AO> LaunchNode<NodeBuilderWithComponents<T, CB, AO>> for EngineNodeLauncher
 where
     T: FullNodeTypes<
-        Types: NodeTypesForProvider,
-        Provider = BlockchainProvider<
-            NodeTypesWithDBAdapter<<T as FullNodeTypes>::Types, <T as FullNodeTypes>::DB>,
-        >,
+        Types = N,
+        DB = DB,
+        Provider = BlockchainProvider<NodeTypesWithDBAdapter<N, DB>>,
     >,
+    N: Node<RethFullAdapter<DB, N>> + NodeTypesForProvider,
+    DB: Database + DatabaseMetrics + Clone + Unpin + 'static,
     CB: NodeComponentsBuilder<T> + 'static,
     AO: RethRpcAddOns<NodeAdapter<T, CB::Components>>
         + EngineValidatorAddOn<NodeAdapter<T, CB::Components>>
diff --git a/crates/node/builder/src/node.rs b/crates/node/builder/src/node.rs
index 8019e8ab1c3..4c3d62137f4 100644
--- a/crates/node/builder/src/node.rs
+++ b/crates/node/builder/src/node.rs
@@ -44,6 +44,11 @@ pub trait Node<N: FullNodeTypes>: NodeTypes + Clone {
 
     /// Returns the node add-ons.
     fn add_ons(&self) -> Self::AddOns;
+
+    /// Returns the stages that should be disabled for this node.
+    fn disabled_stages() -> &'static [reth_stages::StageId] {
+        &[]
+    }
 }
 
 /// A [`Node`] type builder
diff --git a/crates/node/builder/src/rpc.rs b/crates/node/builder/src/rpc.rs
index 4f23d00e799..519dfa1bf80 100644
--- a/crates/node/builder/src/rpc.rs
+++ b/crates/node/builder/src/rpc.rs
@@ -1305,6 +1305,7 @@ impl<'a, N: FullNodeComponents<Types: NodeTypes<ChainSpec: Hardforks + EthereumH
             .task_spawner(self.components.task_executor().clone())
             .gas_cap(self.config.rpc_gas_cap.into())
             .max_simulate_blocks(self.config.rpc_max_simulate_blocks)
+            .compute_state_root_for_eth_simulate(self.config.compute_state_root_for_eth_simulate)
             .eth_proof_window(self.config.eth_proof_window)
             .fee_history_cache_config(self.config.fee_history_cache)
             .proof_permits(self.config.proof_permits)
diff --git a/crates/node/builder/src/setup.rs b/crates/node/builder/src/setup.rs
index 25cc5f27bee..969a0df4e05 100644
--- a/crates/node/builder/src/setup.rs
+++ b/crates/node/builder/src/setup.rs
@@ -20,7 +20,7 @@ use reth_provider::{providers::ProviderNodeTypes, ProviderFactory};
 use reth_stages::{
     prelude::DefaultStages,
     stages::{EraImportSource, ExecutionStage},
-    Pipeline, StageSet,
+    Pipeline, StageId, StageSet,
 };
 use reth_static_file::StaticFileProducer;
 use reth_tasks::TaskExecutor;
@@ -42,6 +42,7 @@ pub fn build_networked_pipeline<N, Client, Evm>(
     evm_config: Evm,
     exex_manager_handle: ExExManagerHandle<N::Primitives>,
     era_import_source: Option<EraImportSource>,
+    disabled_stages: &[StageId],
 ) -> eyre::Result<Pipeline<N>>
 where
     N: ProviderNodeTypes,
@@ -70,6 +71,7 @@ where
         evm_config,
         exex_manager_handle,
         era_import_source,
+        disabled_stages,
     )?;
 
     Ok(pipeline)
@@ -90,6 +92,7 @@ pub fn build_pipeline<N, H, B, Evm>(
     evm_config: Evm,
     exex_manager_handle: ExExManagerHandle<N::Primitives>,
     era_import_source: Option<EraImportSource>,
+    disabled_stages: &[StageId],
 ) -> eyre::Result<Pipeline<N>>
 where
     N: ProviderNodeTypes,
@@ -127,7 +130,8 @@ where
                 stage_config.execution.into(),
                 stage_config.execution_external_clean_threshold(),
                 exex_manager_handle,
-            )),
+            ))
+            .disable_all(disabled_stages),
         )
         .build(provider_factory, static_file_producer);
 
diff --git a/crates/node/core/Cargo.toml b/crates/node/core/Cargo.toml
index cdb8c67d60d..7443e6a3fb8 100644
--- a/crates/node/core/Cargo.toml
+++ b/crates/node/core/Cargo.toml
@@ -26,7 +26,7 @@ reth-rpc-server-types.workspace = true
 reth-rpc-convert.workspace = true
 reth-transaction-pool.workspace = true
 reth-tasks.workspace = true
-reth-tracing.workspace = true
+reth-tracing = { workspace = true, features = ["std"] }
 reth-config = { workspace = true, features = ["serde"] }
 reth-discv4.workspace = true
 reth-discv5.workspace = true
diff --git a/crates/node/core/src/args/benchmark_args.rs b/crates/node/core/src/args/benchmark_args.rs
deleted file mode 100644
index 983b74cc870..00000000000
--- a/crates/node/core/src/args/benchmark_args.rs
+++ /dev/null
@@ -1,324 +0,0 @@
-//! clap [Args](clap::Args) for benchmark configuration
-
-use clap::Args;
-use std::{path::PathBuf, str::FromStr};
-
-/// Parameters for benchmark configuration
-#[derive(Debug, Args, PartialEq, Eq, Default, Clone)]
-#[command(next_help_heading = "Benchmark")]
-pub struct BenchmarkArgs {
-    /// Run the benchmark from a specific block.
-    #[arg(long, verbatim_doc_comment)]
-    pub from: Option<u64>,
-
-    /// Run the benchmark to a specific block.
-    #[arg(long, verbatim_doc_comment)]
-    pub to: Option<u64>,
-
-    /// Number of blocks to advance from the current head block.
-    /// When specified, automatically sets --from to current head + 1 and --to to current head +
-    /// advance. Cannot be used together with explicit --from and --to arguments.
-    #[arg(long, conflicts_with_all = &["from", "to"], verbatim_doc_comment)]
-    pub advance: Option<u64>,
-
-    /// Path to a JWT secret to use for the authenticated engine-API RPC server.
-    ///
-    /// This will perform JWT authentication for all requests to the given engine RPC url.
-    ///
-    /// If no path is provided, a secret will be generated and stored in the datadir under
-    /// `<DIR>/<CHAIN_ID>/jwt.hex`. For mainnet this would be `~/.local/share/reth/mainnet/jwt.hex`
-    /// by default.
-    #[arg(
-        long = "jwt-secret",
-        alias = "jwtsecret",
-        value_name = "PATH",
-        global = true,
-        required = false
-    )]
-    pub auth_jwtsecret: Option<PathBuf>,
-
-    /// The RPC url to use for sending engine requests.
-    #[arg(
-        long,
-        value_name = "ENGINE_RPC_URL",
-        verbatim_doc_comment,
-        default_value = "http://localhost:8551"
-    )]
-    pub engine_rpc_url: String,
-
-    /// The RPC url to use for non-authenticated node RPC requests.
-    #[arg(
-        long,
-        value_name = "LOCAL_RPC_URL",
-        verbatim_doc_comment,
-        default_value = "http://localhost:8545"
-    )]
-    pub local_rpc_url: String,
-
-    /// The `WebSocket` RPC URL to use for persistence subscriptions.
-    ///
-    /// If not provided, will attempt to derive from engine-rpc-url by:
-    /// - Converting http/https to ws/wss
-    /// - Using port 8546 (standard RPC `WebSocket` port)
-    ///
-    /// Example: `ws://localhost:8546`
-    #[arg(long, value_name = "WS_RPC_URL", verbatim_doc_comment)]
-    pub ws_rpc_url: Option<String>,
-
-    /// The path to the output directory for granular benchmark results.
-    #[arg(long, short, value_name = "BENCHMARK_OUTPUT", verbatim_doc_comment)]
-    pub output: Option<PathBuf>,
-
-    /// Optional Prometheus metrics endpoint to scrape after each block.
-    ///
-    /// When provided, reth-bench will fetch metrics from this URL after each
-    /// `newPayload` / `forkchoiceUpdated` call, recording per-block execution
-    /// and state root durations. Results are written to `metrics.csv` in the
-    /// output directory.
-    ///
-    /// Example: `http://127.0.0.1:9001/metrics`
-    #[arg(long = "metrics-url", value_name = "URL", verbatim_doc_comment)]
-    pub metrics_url: Option<String>,
-
-    /// Number of retries for fetching blocks from `--rpc-url` after a failure.
-    ///
-    /// Use `0` to fail immediately, or `forever` to never stop retrying.
-    #[arg(
-        long = "rpc-block-fetch-retries",
-        value_name = "RETRIES",
-        default_value = "10",
-        value_parser = parse_rpc_block_fetch_retries,
-        verbatim_doc_comment
-    )]
-    pub rpc_block_fetch_retries: RpcBlockFetchRetries,
-
-    /// Use `reth_newPayload` endpoint instead of `engine_newPayload*`.
-    ///
-    /// The `reth_newPayload` endpoint is a reth-specific extension that takes `ExecutionData`
-    /// directly, waits for persistence and cache updates to complete before processing,
-    /// and returns server-side timing breakdowns (latency, persistence wait, cache wait).
-    ///
-    /// Cannot be used with `--wait-for-persistence` because `reth_newPayload` already
-    /// waits for persistence by default.
-    #[arg(long, default_value = "false", verbatim_doc_comment)]
-    pub reth_new_payload: bool,
-
-    /// Control when `reth_newPayload` waits for in-flight persistence.
-    ///
-    /// Accepts `always` (wait on every block), `never` (default), or a number N
-    /// to wait every N blocks and skip the rest.
-    ///
-    /// Requires `--reth-new-payload`.
-    #[arg(
-        long = "wait-for-persistence",
-        value_name = "MODE",
-        num_args = 0..=1,
-        default_missing_value = "always",
-        value_parser = clap::value_parser!(WaitForPersistence),
-        requires = "reth_new_payload",
-        verbatim_doc_comment
-    )]
-    pub wait_for_persistence: Option<WaitForPersistence>,
-
-    /// Skip waiting for execution cache and sparse trie locks before processing.
-    ///
-    /// Only works with `--reth-new-payload`. When set, passes `wait_for_caches: false`
-    /// to the `reth_newPayload` endpoint.
-    #[arg(long, default_value = "false", verbatim_doc_comment, requires = "reth_new_payload")]
-    pub no_wait_for_caches: bool,
-
-    /// Fetch and replay RLP-encoded blocks. Implies `reth_new_payload`.
-    #[arg(long, default_value = "false", verbatim_doc_comment)]
-    pub rlp_blocks: bool,
-}
-
-/// Retry strategy for fetching blocks from the benchmark RPC provider.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum RpcBlockFetchRetries {
-    /// Retry up to `u32` times after the first failed attempt.
-    Finite(u32),
-    /// Retry forever.
-    Forever,
-}
-
-impl RpcBlockFetchRetries {
-    /// Returns the maximum number of retries for the `RetryBackoffLayer`.
-    pub const fn as_max_retries(self) -> u32 {
-        match self {
-            Self::Finite(n) => n,
-            Self::Forever => u32::MAX,
-        }
-    }
-}
-
-impl Default for RpcBlockFetchRetries {
-    fn default() -> Self {
-        Self::Finite(10)
-    }
-}
-
-impl FromStr for RpcBlockFetchRetries {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.trim();
-        if s.eq_ignore_ascii_case("forever") ||
-            s.eq_ignore_ascii_case("infinite") ||
-            s.eq_ignore_ascii_case("inf")
-        {
-            return Ok(Self::Forever)
-        }
-
-        let retries = s
-            .parse::<u32>()
-            .map_err(|_| format!("invalid retry value {s:?}, expected a number or 'forever'"))?;
-        Ok(Self::Finite(retries))
-    }
-}
-
-fn parse_rpc_block_fetch_retries(value: &str) -> Result<RpcBlockFetchRetries, String> {
-    value.parse()
-}
-
-/// Controls when `reth_newPayload` waits for in-flight persistence to complete.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum WaitForPersistence {
-    /// Wait for persistence on every block (default `reth_newPayload` behavior).
-    #[default]
-    Always,
-    /// Never wait for persistence.
-    Never,
-    /// Wait for persistence every N blocks, skip for the rest.
-    EveryN(u64),
-}
-
-impl WaitForPersistence {
-    /// Returns the `wait_for_persistence` RPC parameter value for a given block number.
-    ///
-    /// - `None` → use the server default (true)
-    /// - `Some(false)` → skip waiting
-    /// - `Some(true)` → explicitly wait
-    pub const fn rpc_value(self, block_number: u64) -> Option<bool> {
-        match self {
-            Self::Always => None,
-            Self::Never => Some(false),
-            Self::EveryN(n) => {
-                if block_number.is_multiple_of(n) {
-                    Some(true)
-                } else {
-                    Some(false)
-                }
-            }
-        }
-    }
-}
-
-impl FromStr for WaitForPersistence {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.trim();
-        if s.eq_ignore_ascii_case("always") {
-            return Ok(Self::Always)
-        }
-        if s.eq_ignore_ascii_case("never") {
-            return Ok(Self::Never)
-        }
-        let n = s.parse::<u64>().map_err(|_| {
-            format!("invalid value {s:?}, expected 'always', 'never', or a block interval number")
-        })?;
-        if n == 0 {
-            return Err("block interval must be > 0, use 'never' to disable".to_string())
-        }
-        Ok(Self::EveryN(n))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use clap::Parser;
-
-    /// A helper type to parse Args more easily
-    #[derive(Parser)]
-    struct CommandParser<T: Args> {
-        #[command(flatten)]
-        args: T,
-    }
-
-    #[test]
-    fn test_parse_benchmark_args() {
-        let default_args = BenchmarkArgs {
-            engine_rpc_url: "http://localhost:8551".to_string(),
-            local_rpc_url: "http://localhost:8545".to_string(),
-            ..Default::default()
-        };
-        let args = CommandParser::<BenchmarkArgs>::parse_from(["reth-bench"]).args;
-        assert_eq!(args, default_args);
-    }
-
-    #[test]
-    fn test_parse_rpc_block_fetch_retries_forever() {
-        let args = CommandParser::<BenchmarkArgs>::parse_from([
-            "reth-bench",
-            "--rpc-block-fetch-retries",
-            "forever",
-        ])
-        .args;
-        assert_eq!(args.rpc_block_fetch_retries, RpcBlockFetchRetries::Forever);
-    }
-
-    #[test]
-    fn test_parse_rpc_block_fetch_retries_number() {
-        let args = CommandParser::<BenchmarkArgs>::parse_from([
-            "reth-bench",
-            "--rpc-block-fetch-retries",
-            "7",
-        ])
-        .args;
-        assert_eq!(args.rpc_block_fetch_retries, RpcBlockFetchRetries::Finite(7));
-    }
-
-    #[test]
-    fn test_parse_wait_for_persistence() {
-        let args = CommandParser::<BenchmarkArgs>::parse_from([
-            "reth-bench",
-            "--reth-new-payload",
-            "--wait-for-persistence",
-            "always",
-        ])
-        .args;
-        assert_eq!(args.wait_for_persistence, Some(WaitForPersistence::Always));
-
-        let args = CommandParser::<BenchmarkArgs>::parse_from([
-            "reth-bench",
-            "--reth-new-payload",
-            "--wait-for-persistence",
-            "never",
-        ])
-        .args;
-        assert_eq!(args.wait_for_persistence, Some(WaitForPersistence::Never));
-
-        let args = CommandParser::<BenchmarkArgs>::parse_from([
-            "reth-bench",
-            "--reth-new-payload",
-            "--wait-for-persistence",
-            "10",
-        ])
-        .args;
-        assert_eq!(args.wait_for_persistence, Some(WaitForPersistence::EveryN(10)));
-
-        // bare --wait-for-persistence (no value) defaults to Always
-        let args = CommandParser::<BenchmarkArgs>::parse_from([
-            "reth-bench",
-            "--reth-new-payload",
-            "--wait-for-persistence",
-        ])
-        .args;
-        assert_eq!(args.wait_for_persistence, Some(WaitForPersistence::Always));
-
-        // default is None
-        let args = CommandParser::<BenchmarkArgs>::parse_from(["reth-bench"]).args;
-        assert_eq!(args.wait_for_persistence, None);
-    }
-}
diff --git a/crates/node/core/src/args/database.rs b/crates/node/core/src/args/database.rs
index 81a6aeea6da..abe7d17cd9a 100644
--- a/crates/node/core/src/args/database.rs
+++ b/crates/node/core/src/args/database.rs
@@ -67,6 +67,12 @@ pub struct DatabaseArgs {
     /// performance for history lookups.
     #[arg(long = "db.rocksdb-block-cache-size", value_parser = parse_byte_size)]
     pub rocksdb_block_cache_size: Option<usize>,
+    /// Number of recent blocks to keep in the in-memory BAL store cache.
+    #[arg(long = "db.balstore-cache-size")]
+    pub balstore_cache_size: Option<u64>,
+    /// Disable built-in database metrics.
+    #[arg(long = "db.disable-metrics")]
+    pub disable_metrics: bool,
 }
 
 impl DatabaseArgs {
@@ -97,6 +103,11 @@ impl DatabaseArgs {
             .with_max_readers(self.max_readers)
             .with_sync_mode(self.sync_mode)
     }
+
+    /// Returns whether built-in database metrics are enabled.
+    pub const fn metrics_enabled(&self) -> bool {
+        !self.disable_metrics
+    }
 }
 
 /// clap value parser for [`LogLevel`].
@@ -230,6 +241,16 @@ mod tests {
         assert_eq!(args, default_args);
     }
 
+    #[test]
+    fn test_command_parser_disable_metrics() {
+        let args = CommandParser::<DatabaseArgs>::parse_from(["reth"]).args;
+        assert!(args.metrics_enabled());
+
+        let args = CommandParser::<DatabaseArgs>::parse_from(["reth", "--db.disable-metrics"]).args;
+        assert!(args.disable_metrics);
+        assert!(!args.metrics_enabled());
+    }
+
     #[test]
     fn test_command_parser_with_valid_max_size() {
         let cmd = CommandParser::<DatabaseArgs>::try_parse_from([
@@ -442,4 +463,15 @@ mod tests {
             CommandParser::<DatabaseArgs>::try_parse_from(["reth", "--db.sync-mode", "ultra-fast"]);
         assert!(result.is_err());
     }
+
+    #[test]
+    fn test_command_parser_with_valid_balstore_cache_size() {
+        let cmd = CommandParser::<DatabaseArgs>::try_parse_from([
+            "reth",
+            "--db.balstore-cache-size",
+            "1234",
+        ])
+        .unwrap();
+        assert_eq!(cmd.args.balstore_cache_size, Some(1234));
+    }
 }
diff --git a/crates/node/core/src/args/debug.rs b/crates/node/core/src/args/debug.rs
index dce3aa784e6..037f08c31ab 100644
--- a/crates/node/core/src/args/debug.rs
+++ b/crates/node/core/src/args/debug.rs
@@ -58,6 +58,15 @@ pub struct DebugArgs {
     #[arg(long = "debug.skip-new-payload", help_heading = "Debug")]
     pub skip_new_payload: Option<usize>,
 
+    /// If set, bypasses genesis hash validation during init.
+    /// Intended for tools that direct-write the database (e.g. snapshot
+    /// importers, state-actor) and want reth to trust the DB-resident
+    /// genesis state instead of recomputing it from the chainspec's alloc.
+    /// When the bypass fires, a structured `tracing::warn!` is emitted so
+    /// the divergence stays observable in operator logs.
+    #[arg(long = "debug.skip-genesis-validation", help_heading = "Debug")]
+    pub skip_genesis_validation: bool,
+
     /// If provided, the chain will be reorged at specified frequency.
     #[arg(long = "debug.reorg-frequency", help_heading = "Debug")]
     pub reorg_frequency: Option<usize>,
@@ -120,6 +129,7 @@ impl Default for DebugArgs {
             rpc_consensus_url: None,
             skip_fcu: None,
             skip_new_payload: None,
+            skip_genesis_validation: false,
             reorg_frequency: None,
             reorg_depth: None,
             engine_api_store: None,
diff --git a/crates/node/core/src/args/engine.rs b/crates/node/core/src/args/engine.rs
index 5dedc68747b..a2f1b06b474 100644
--- a/crates/node/core/src/args/engine.rs
+++ b/crates/node/core/src/args/engine.rs
@@ -1,6 +1,9 @@
 //! clap [Args](clap::Args) for engine purposes
 
-use clap::{builder::Resettable, Args};
+use clap::{
+    builder::{RangedU64ValueParser, Resettable},
+    Args,
+};
 use eyre::ensure;
 use reth_cli_util::{parse_duration_from_secs_or_ms, parsers::format_duration_as_secs_or_ms};
 use reth_engine_primitives::{
@@ -285,16 +288,22 @@ impl Default for DefaultEngineValues {
             sparse_trie_max_hot_accounts: DEFAULT_SPARSE_TRIE_MAX_HOT_ACCOUNTS,
             slow_block_threshold: None,
             disable_sparse_trie_cache_pruning: false,
-            state_root_task_timeout: Some("1s".to_string()),
+            state_root_task_timeout: Some("4s".to_string()),
             share_execution_cache_with_payload_builder: false,
             share_sparse_trie_with_payload_builder: false,
             suppress_persistence_during_build: false,
-            bal_parallel_execution_disabled: true,
+            bal_parallel_execution_disabled: false,
             bal_parallel_state_root_disabled: false,
         }
     }
 }
 
+fn default_persistence_backpressure_threshold(persistence_threshold: u64) -> u64 {
+    DefaultEngineValues::get_global()
+        .persistence_backpressure_threshold
+        .max(persistence_threshold.saturating_mul(2))
+}
+
 /// Parameters for configuring the engine driver.
 #[derive(Debug, Clone, Args, PartialEq, Eq)]
 #[command(next_help_heading = "Engine")]
@@ -310,9 +319,12 @@ pub struct EngineArgs {
 
     /// Configure the maximum canonical-minus-persisted gap before engine API processing stalls.
     ///
+    /// If omitted, this defaults to the larger of the default backpressure threshold and twice
+    /// `--engine.persistence-threshold`.
+    ///
     /// This value must be greater than `--engine.persistence-threshold`.
-    #[arg(long = "engine.persistence-backpressure-threshold", default_value_t = DefaultEngineValues::get_global().persistence_backpressure_threshold)]
-    pub persistence_backpressure_threshold: u64,
+    #[arg(long = "engine.persistence-backpressure-threshold")]
+    pub persistence_backpressure_threshold: Option<u64>,
 
     /// Configure the target number of blocks to keep in memory.
     #[arg(long = "engine.memory-block-buffer-target", default_value_t = DefaultEngineValues::get_global().memory_block_buffer_target)]
@@ -374,7 +386,7 @@ pub struct EngineArgs {
     pub accept_execution_requests_hash: bool,
 
     /// Multiproof task chunk size for proof targets.
-    #[arg(long = "engine.multiproof-chunk-size", default_value_t = DefaultEngineValues::get_global().multiproof_chunk_size)]
+    #[arg(long = "engine.multiproof-chunk-size", default_value_t = DefaultEngineValues::get_global().multiproof_chunk_size, value_parser = RangedU64ValueParser::<usize>::new().range(1..))]
     pub multiproof_chunk_size: usize,
 
     /// Configure the number of reserved CPU cores for non-reth processes
@@ -459,14 +471,14 @@ pub struct EngineArgs {
     /// If the state root task takes longer than this, a sequential computation starts in
     /// parallel and whichever finishes first is used.
     ///
-    /// --engine.state-root-task-timeout 1s
+    /// --engine.state-root-task-timeout 4s
     /// --engine.state-root-task-timeout 400ms
     ///
     /// Set to 0s to disable.
     #[arg(
         long = "engine.state-root-task-timeout",
         value_parser = humantime::parse_duration,
-        default_value = DefaultEngineValues::get_global().state_root_task_timeout.as_deref().unwrap_or("1s"),
+        default_value = DefaultEngineValues::get_global().state_root_task_timeout.as_deref().unwrap_or("4s"),
     )]
     pub state_root_task_timeout: Option<Duration>,
 
@@ -511,13 +523,12 @@ pub struct EngineArgs {
     )]
     pub suppress_persistence_during_build: bool,
 
-    /// Disable BAL (Block Access List, EIP-7928) based parallel execution. Defaults to disabled,
-    /// falling back to transaction-based prewarming even when a BAL is available.
+    /// Disable BAL (Block Access List, EIP-7928) based parallel execution.
     #[arg(long = "engine.disable-bal-parallel-execution", default_value_t = DefaultEngineValues::get_global().bal_parallel_execution_disabled)]
     pub bal_parallel_execution_disabled: bool,
 
-    /// Disable BAL-driven parallel state root computation. When set, the BAL hashed post state
-    /// is not sent to the multiproof task for early parallel state root computation.
+    /// Disable BAL-driven parallel state root computation. This is only valid together with
+    /// `--engine.disable-bal-parallel-execution`.
     #[arg(long = "engine.disable-bal-parallel-state-root", default_value_t = DefaultEngineValues::get_global().bal_parallel_state_root_disabled)]
     pub bal_parallel_state_root_disabled: bool,
 
@@ -545,7 +556,7 @@ impl Default for EngineArgs {
     fn default() -> Self {
         let DefaultEngineValues {
             persistence_threshold,
-            persistence_backpressure_threshold,
+            persistence_backpressure_threshold: _,
             memory_block_buffer_target,
             invalid_header_hit_eviction_threshold,
             legacy_state_root_task_enabled,
@@ -578,7 +589,7 @@ impl Default for EngineArgs {
         } = DefaultEngineValues::get_global().clone();
         Self {
             persistence_threshold,
-            persistence_backpressure_threshold,
+            persistence_backpressure_threshold: None,
             memory_block_buffer_target,
             invalid_header_hit_eviction_threshold,
             legacy_state_root_task_enabled,
@@ -622,22 +633,34 @@ impl Default for EngineArgs {
 }
 
 impl EngineArgs {
+    /// Returns the effective persistence backpressure threshold.
+    pub fn persistence_backpressure_threshold(&self) -> u64 {
+        self.persistence_backpressure_threshold.unwrap_or_else(|| {
+            default_persistence_backpressure_threshold(self.persistence_threshold)
+        })
+    }
+
     /// Validates cross-field engine arguments.
     pub fn validate(&self) -> eyre::Result<()> {
+        let persistence_backpressure_threshold = self.persistence_backpressure_threshold();
         ensure!(
-            self.persistence_backpressure_threshold > self.persistence_threshold,
+            persistence_backpressure_threshold > self.persistence_threshold,
             "--engine.persistence-backpressure-threshold ({}) must be greater than --engine.persistence-threshold ({})",
-            self.persistence_backpressure_threshold,
+            persistence_backpressure_threshold,
             self.persistence_threshold
         );
+        ensure!(
+            self.bal_parallel_execution_disabled || !self.bal_parallel_state_root_disabled,
+            "--engine.disable-bal-parallel-state-root requires --engine.disable-bal-parallel-execution because BAL parallel execution depends on BAL prewarm state-root updates"
+        );
         Ok(())
     }
 
     /// Creates a [`TreeConfig`] from the engine arguments.
     pub fn tree_config(&self) -> TreeConfig {
         let config = TreeConfig::default()
+            .with_persistence_backpressure_threshold(self.persistence_backpressure_threshold())
             .with_persistence_threshold(self.persistence_threshold)
-            .with_persistence_backpressure_threshold(self.persistence_backpressure_threshold)
             .with_memory_block_buffer_target(self.memory_block_buffer_target)
             .with_invalid_header_hit_eviction_threshold(self.invalid_header_hit_eviction_threshold)
             .with_legacy_state_root(self.legacy_state_root_task_enabled)
@@ -693,6 +716,60 @@ mod tests {
         let default_args = EngineArgs::default();
         let args = CommandParser::<EngineArgs>::parse_from(["reth"]).args;
         assert_eq!(args, default_args);
+        assert_eq!(
+            args.persistence_backpressure_threshold(),
+            DefaultEngineValues::get_global().persistence_backpressure_threshold
+        );
+    }
+
+    #[test]
+    fn default_backpressure_threshold_uses_parsed_persistence_args() {
+        let args = CommandParser::<EngineArgs>::parse_from([
+            "reth",
+            "--engine.persistence-threshold",
+            "100",
+            "--engine.memory-block-buffer-target",
+            "50",
+        ])
+        .args;
+
+        assert_eq!(args.persistence_backpressure_threshold(), 200);
+
+        let tree_config = args.tree_config();
+        assert_eq!(tree_config.persistence_threshold(), 100);
+        assert_eq!(tree_config.memory_block_buffer_target(), 50);
+        assert_eq!(tree_config.persistence_backpressure_threshold(), 200);
+    }
+
+    #[test]
+    fn default_backpressure_threshold_uses_global_default_when_larger() {
+        let args = CommandParser::<EngineArgs>::parse_from([
+            "reth",
+            "--engine.persistence-threshold",
+            "4",
+        ])
+        .args;
+
+        assert_eq!(
+            args.persistence_backpressure_threshold(),
+            DefaultEngineValues::get_global().persistence_backpressure_threshold
+        );
+    }
+
+    #[test]
+    fn explicit_backpressure_threshold_overrides_calculated_default() {
+        let args = CommandParser::<EngineArgs>::parse_from([
+            "reth",
+            "--engine.persistence-threshold",
+            "100",
+            "--engine.memory-block-buffer-target",
+            "50",
+            "--engine.persistence-backpressure-threshold",
+            "101",
+        ])
+        .args;
+
+        assert_eq!(args.persistence_backpressure_threshold(), 101);
     }
 
     #[test]
@@ -700,7 +777,7 @@ mod tests {
     fn engine_args() {
         let args = EngineArgs {
             persistence_threshold: 100,
-            persistence_backpressure_threshold: 101,
+            persistence_backpressure_threshold: Some(101),
             memory_block_buffer_target: 50,
             invalid_header_hit_eviction_threshold: 7,
             legacy_state_root_task_enabled: true,
@@ -792,7 +869,7 @@ mod tests {
     fn validate_rejects_invalid_backpressure_threshold() {
         let args = EngineArgs {
             persistence_threshold: 4,
-            persistence_backpressure_threshold: 4,
+            persistence_backpressure_threshold: Some(4),
             ..EngineArgs::default()
         };
 
@@ -801,6 +878,30 @@ mod tests {
         assert!(err.contains("engine.persistence-threshold"));
     }
 
+    #[test]
+    fn parse_rejects_zero_multiproof_chunk_size() {
+        let result = CommandParser::<EngineArgs>::try_parse_from([
+            "reth",
+            "--engine.multiproof-chunk-size",
+            "0",
+        ]);
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn validate_rejects_bal_parallel_execution_without_bal_parallel_state_root() {
+        let args = EngineArgs {
+            bal_parallel_execution_disabled: false,
+            bal_parallel_state_root_disabled: true,
+            ..EngineArgs::default()
+        };
+
+        let err = args.validate().unwrap_err().to_string();
+        assert!(err.contains("engine.disable-bal-parallel-state-root"));
+        assert!(err.contains("engine.disable-bal-parallel-execution"));
+    }
+
     #[test]
     fn test_parse_slow_block_threshold() {
         // Test default value (None - disabled)
diff --git a/crates/node/core/src/args/log.rs b/crates/node/core/src/args/log.rs
index 40162d50cb0..931a6407571 100644
--- a/crates/node/core/src/args/log.rs
+++ b/crates/node/core/src/args/log.rs
@@ -3,10 +3,10 @@
 use crate::dirs::{LogsDir, PlatformPath};
 use clap::{ArgAction, Args, ValueEnum};
 use reth_tracing::{
-    tracing_subscriber::filter::Directive, FileInfo, FileWorkerGuard, LayerInfo, Layers, LogFormat,
-    RethTracer, Tracer,
+    tracing_subscriber::filter::Directive, FileInfo, LayerInfo, Layers, LogFormat, RethTracer,
+    Tracer, TracingGuards,
 };
-use std::{fmt, fmt::Display, sync::OnceLock};
+use std::{fmt, fmt::Display, path::PathBuf, sync::OnceLock};
 use tracing::{level_filters::LevelFilter, Level};
 
 /// Constant to convert megabytes to bytes
@@ -83,6 +83,30 @@ pub struct LogArgs {
     )]
     pub samply_filter: String,
 
+    /// Emit traces to a Chrome trace JSON file. Only useful when profiling.
+    #[arg(long = "log.tracing-chrome", global = true, hide = true, default_value_t = DefaultLogArgs::get_global().tracing_chrome)]
+    pub tracing_chrome: bool,
+
+    /// The path to write Chrome trace JSON to.
+    #[arg(
+        long = "log.tracing-chrome.file",
+        value_name = "PATH",
+        global = true,
+        default_value = "trace.json",
+        hide = true
+    )]
+    pub tracing_chrome_file: PathBuf,
+
+    /// The filter to use for traces emitted to Chrome trace JSON.
+    #[arg(
+        long = "log.tracing-chrome.filter",
+        value_name = "FILTER",
+        global = true,
+        default_value_t = DefaultLogArgs::get_global().tracing_chrome_filter.clone(),
+        hide = true
+    )]
+    pub tracing_chrome_filter: String,
+
     /// Emit traces to tracy. Only useful when profiling.
     #[arg(long = "log.tracy", global = true, hide = true, default_value_t = DefaultLogArgs::get_global().tracy)]
     pub tracy: bool,
@@ -157,26 +181,26 @@ impl LogArgs {
 
     /// Initializes tracing with the configured options from cli args.
     ///
-    /// Returns the file worker guard if a file worker was configured.
-    pub fn init_tracing(&self) -> eyre::Result<Option<FileWorkerGuard>> {
+    /// Returns guards for tracing layers that need to stay alive.
+    pub fn init_tracing(&self) -> eyre::Result<TracingGuards> {
         self.init_tracing_with_layers(Layers::new(), false)
     }
 
     /// Initializes tracing with the configured options from cli args.
     ///
     /// When `enable_reload` is true, a global log handle is installed that allows changing
-    /// log levels at runtime via RPC methods like `debug_verbosity` and `debug_vmodule`.
+    /// log levels at runtime.
     ///
     /// # Arguments
     /// * `layers` - Pre-configured layers to include
     /// * `enable_reload` - If true, enables runtime log level changes
     ///
-    /// Returns the file worker guard if a file worker was configured.
+    /// Returns guards for tracing layers that need to stay alive.
     pub fn init_tracing_with_layers(
         &self,
         layers: Layers,
         enable_reload: bool,
-    ) -> eyre::Result<Option<FileWorkerGuard>> {
+    ) -> eyre::Result<TracingGuards> {
         let mut tracer = RethTracer::new();
 
         let stdout = self.layer_info(self.log_stdout_format, self.log_stdout_filter.clone(), true);
@@ -197,6 +221,12 @@ impl LogArgs {
             tracer = tracer.with_samply(config);
         }
 
+        if self.tracing_chrome {
+            let config =
+                self.layer_info(LogFormat::Terminal, self.tracing_chrome_filter.clone(), false);
+            tracer = tracer.with_chrome(config, self.tracing_chrome_file.clone());
+        }
+
         if self.tracy {
             #[cfg(feature = "tracy")]
             {
@@ -228,6 +258,8 @@ pub struct DefaultLogArgs {
     journald_filter: String,
     samply: bool,
     samply_filter: String,
+    tracing_chrome: bool,
+    tracing_chrome_filter: String,
     tracy: bool,
     tracy_filter: String,
     color: ColorMode,
@@ -304,6 +336,18 @@ impl DefaultLogArgs {
         self
     }
 
+    /// Set whether Chrome trace JSON tracing is enabled by default.
+    pub const fn with_tracing_chrome(mut self, v: bool) -> Self {
+        self.tracing_chrome = v;
+        self
+    }
+
+    /// Set the default Chrome trace JSON filter.
+    pub fn with_tracing_chrome_filter(mut self, v: String) -> Self {
+        self.tracing_chrome_filter = v;
+        self
+    }
+
     /// Set whether tracy tracing is enabled by default.
     pub const fn with_tracy(mut self, v: bool) -> Self {
         self.tracy = v;
@@ -336,6 +380,8 @@ impl Default for DefaultLogArgs {
             journald_filter: "error".to_string(),
             samply: false,
             samply_filter: PROFILER_TRACING_FILTER.to_string(),
+            tracing_chrome: false,
+            tracing_chrome_filter: PROFILER_TRACING_FILTER.to_string(),
             tracy: false,
             tracy_filter: PROFILER_TRACING_FILTER.to_string(),
             color: ColorMode::Always,
diff --git a/crates/node/core/src/args/mod.rs b/crates/node/core/src/args/mod.rs
index 3703d4144f0..68a0c9f8f8b 100644
--- a/crates/node/core/src/args/mod.rs
+++ b/crates/node/core/src/args/mod.rs
@@ -2,7 +2,7 @@
 
 /// NetworkArg struct for configuring the network
 mod network;
-pub use network::{DefaultNetworkArgs, DiscoveryArgs, NetworkArgs};
+pub use network::{DefaultDiscoveryArgs, DefaultNetworkArgs, DiscoveryArgs, NetworkArgs};
 
 /// RpcServerArg struct for configuring the RPC
 mod rpc_server;
@@ -26,7 +26,7 @@ pub use log::{ColorMode, DefaultLogArgs, LogArgs, Verbosity};
 
 /// `TraceArgs` for tracing and spans support
 mod trace;
-pub use trace::{OtlpInitStatus, OtlpLogsStatus, TraceArgs};
+pub use trace::{DefaultTraceValues, OtlpInitStatus, OtlpLogsStatus, TraceArgs};
 
 /// `MetricArgs` to configure metrics.
 mod metric;
@@ -54,16 +54,12 @@ pub use dev::DevArgs;
 
 /// PruneArgs for configuring the pruning and full node
 mod pruning;
-pub use pruning::{DefaultPruningValues, PruningArgs};
+pub use pruning::{DefaultPruningValues, PruneConfigKind, PruningArgs};
 
 /// DatadirArgs for configuring data storage paths
 mod datadir_args;
 pub use datadir_args::DatadirArgs;
 
-/// BenchmarkArgs struct for configuring the benchmark to run
-mod benchmark_args;
-pub use benchmark_args::{BenchmarkArgs, RpcBlockFetchRetries, WaitForPersistence};
-
 /// EngineArgs for configuring the engine
 mod engine;
 pub use engine::{DefaultEngineValues, EngineArgs};
diff --git a/crates/node/core/src/args/network.rs b/crates/node/core/src/args/network.rs
index 614bcf30259..d25921ed30b 100644
--- a/crates/node/core/src/args/network.rs
+++ b/crates/node/core/src/args/network.rs
@@ -11,7 +11,10 @@ use std::{
 };
 
 use crate::version::version_metadata;
-use clap::Args;
+use clap::{
+    builder::{OsStr, Resettable},
+    Args,
+};
 use reth_chainspec::EthChainSpec;
 use reth_cli_util::{get_secret_key, load_secret_key::SecretKeyError};
 use reth_config::Config;
@@ -372,6 +375,8 @@ pub struct NetworkArgs {
     /// Name of network interface used to communicate with peers.
     ///
     /// If flag is set, but no value is passed, the default interface for docker `eth0` is tried.
+    /// If `--discovery.addr` is left at its default, discv4 will also bind to the resolved
+    /// interface address.
     #[arg(long = "net-if.experimental", conflicts_with = "addr", value_name = "IF_NAME")]
     pub net_if: Option<String>,
 
@@ -438,7 +443,13 @@ pub struct NetworkArgs {
 }
 
 impl NetworkArgs {
-    /// Returns the resolved IP address.
+    /// Returns the IP address used for the `RLPx` TCP listener.
+    ///
+    /// If `--net-if.experimental` is set, this resolves the interface name to a concrete local IP
+    /// address. That concrete address is also passed to discv5 as the default address to advertise
+    /// in the local ENR.
+    ///
+    /// If no interface is configured, this returns the configured `--addr` value.
     pub fn resolved_addr(&self) -> IpAddr {
         if let Some(ref if_name) = self.net_if {
             let if_name = if if_name.is_empty() { DEFAULT_NET_IF_NAME } else { if_name };
@@ -459,6 +470,21 @@ impl NetworkArgs {
         self.addr
     }
 
+    /// Returns the IP address used for the discovery v4 UDP bind socket.
+    ///
+    /// By default this is `--discovery.addr`. When `--net-if.experimental` is set and
+    /// `--discovery.addr` is still the wildcard default, discovery v4 follows the resolved `RLPx`
+    /// listener address. That keeps discv4 and discv5 on the same concrete UDP address when they
+    /// share a port; otherwise discv4 would bind wildcard while discv5 binds the resolved
+    /// interface address, which prevents socket sharing.
+    fn resolved_discovery_addr(&self, listener_addr: IpAddr) -> IpAddr {
+        if self.net_if.is_some() && self.discovery.addr == DEFAULT_DISCOVERY_ADDR {
+            return listener_addr;
+        }
+
+        self.discovery.addr
+    }
+
     /// Returns the resolved bootnodes if any are provided.
     pub fn resolved_bootnodes(&self) -> Option<Vec<NodeRecord>> {
         self.bootnodes.clone().map(|bootnodes| {
@@ -529,7 +555,13 @@ impl NetworkArgs {
         default_peers_file: PathBuf,
         executor: Runtime,
     ) -> NetworkConfigBuilder<N> {
-        let addr = self.resolved_addr();
+        // `listener_addr` is the concrete RLPx TCP bind address. With `--net-if.experimental`,
+        // this is the resolved interface IP and is also used as discv5's default address.
+        let listener_addr = self.resolved_addr();
+        // Discovery v4 has its own CLI bind address. If left at the wildcard default while
+        // `--net-if.experimental` is active, make it follow the listener address so discv4 and
+        // discv5 can share the same UDP socket.
+        let discovery_addr = self.resolved_discovery_addr(listener_addr);
         let chain_bootnodes = self
             .resolved_bootnodes()
             .unwrap_or_else(|| chain_spec.bootnodes().unwrap_or_else(mainnet_nodes));
@@ -566,18 +598,11 @@ impl NetworkArgs {
             })
             // apply discovery settings
             .apply(|builder| {
-                let rlpx_socket = (addr, self.port).into();
+                let rlpx_socket = (listener_addr, self.port).into();
                 self.discovery.apply_to_builder(builder, rlpx_socket, chain_bootnodes)
             })
-            .listener_addr(SocketAddr::new(
-                addr, // set discovery port based on instance number
-                self.port,
-            ))
-            .discovery_addr(SocketAddr::new(
-                self.discovery.addr,
-                // set discovery port based on instance number
-                self.discovery.port,
-            ))
+            .listener_addr(SocketAddr::new(listener_addr, self.port))
+            .discovery_addr(SocketAddr::new(discovery_addr, self.discovery.port))
             .disable_tx_gossip(self.disable_tx_gossip)
             .required_block_hashes(self.required_block_hashes.clone())
             .eth_max_message_size_opt(self.eth_max_message_size.map(NonZeroUsize::get))
@@ -727,19 +752,172 @@ impl Default for NetworkArgs {
     }
 }
 
+/// Global static discovery defaults
+static DISCOVERY_DEFAULTS: OnceLock<DefaultDiscoveryArgs> = OnceLock::new();
+
+/// Default values for discovery CLI arguments that can be customized.
+#[derive(Debug, Clone, Copy)]
+pub struct DefaultDiscoveryArgs {
+    /// Default for `--disable-discovery`.
+    pub disable_discovery: bool,
+    /// Default for `--disable-dns-discovery`.
+    pub disable_dns_discovery: bool,
+    /// Default for `--disable-discv4-discovery`.
+    pub disable_discv4_discovery: bool,
+    /// Default for `--disable-discv5-discovery`.
+    pub disable_discv5_discovery: bool,
+    /// Default for `--disable-nat`.
+    pub disable_nat: bool,
+    /// Default UDP address for devp2p discovery v4.
+    pub addr: IpAddr,
+    /// Default UDP port for devp2p discovery v4.
+    pub port: u16,
+    /// Default UDP IPv4 address for devp2p discovery v5.
+    pub discv5_addr: Option<Ipv4Addr>,
+    /// Default UDP IPv6 address for devp2p discovery v5.
+    pub discv5_addr_ipv6: Option<Ipv6Addr>,
+    /// Default UDP IPv4 port for devp2p discovery v5.
+    pub discv5_port: Option<u16>,
+    /// Default UDP IPv6 port for devp2p discovery v5.
+    pub discv5_port_ipv6: Option<u16>,
+    /// Default discv5 periodic lookup interval (seconds).
+    pub discv5_lookup_interval: u64,
+    /// Default discv5 bootstrap lookup interval (seconds).
+    pub discv5_bootstrap_lookup_interval: u64,
+    /// Default discv5 bootstrap lookup countdown.
+    pub discv5_bootstrap_lookup_countdown: u64,
+}
+
+impl DefaultDiscoveryArgs {
+    /// Initialize the global discovery defaults with this configuration.
+    pub fn try_init(self) -> Result<(), Self> {
+        DISCOVERY_DEFAULTS.set(self)
+    }
+
+    /// Get a reference to the global discovery defaults.
+    pub fn get_global() -> &'static Self {
+        DISCOVERY_DEFAULTS.get_or_init(Self::default)
+    }
+
+    /// Set the default for `--disable-discovery`.
+    pub const fn with_disable_discovery(mut self, disable: bool) -> Self {
+        self.disable_discovery = disable;
+        self
+    }
+
+    /// Set the default for `--disable-dns-discovery`.
+    pub const fn with_disable_dns_discovery(mut self, disable: bool) -> Self {
+        self.disable_dns_discovery = disable;
+        self
+    }
+
+    /// Set the default for `--disable-discv4-discovery`.
+    pub const fn with_disable_discv4_discovery(mut self, disable: bool) -> Self {
+        self.disable_discv4_discovery = disable;
+        self
+    }
+
+    /// Set the default for `--disable-discv5-discovery`.
+    pub const fn with_disable_discv5_discovery(mut self, disable: bool) -> Self {
+        self.disable_discv5_discovery = disable;
+        self
+    }
+
+    /// Set the default for `--disable-nat`.
+    pub const fn with_disable_nat(mut self, disable: bool) -> Self {
+        self.disable_nat = disable;
+        self
+    }
+
+    /// Set the default discovery v4 address.
+    pub const fn with_addr(mut self, addr: IpAddr) -> Self {
+        self.addr = addr;
+        self
+    }
+
+    /// Set the default discovery v4 port.
+    pub const fn with_port(mut self, port: u16) -> Self {
+        self.port = port;
+        self
+    }
+
+    /// Set the default discovery v5 IPv4 address.
+    pub fn with_discv5_addr(mut self, addr: impl Into<Option<Ipv4Addr>>) -> Self {
+        self.discv5_addr = addr.into();
+        self
+    }
+
+    /// Set the default discovery v5 IPv6 address.
+    pub fn with_discv5_addr_ipv6(mut self, addr: impl Into<Option<Ipv6Addr>>) -> Self {
+        self.discv5_addr_ipv6 = addr.into();
+        self
+    }
+
+    /// Set the default discovery V5 port.
+    pub fn with_discv5_port(mut self, port: impl Into<Option<u16>>) -> Self {
+        self.discv5_port = port.into();
+        self
+    }
+
+    /// Set the default discovery v5 IPv6 port.
+    pub fn with_discv5_port_ipv6(mut self, port: impl Into<Option<u16>>) -> Self {
+        self.discv5_port_ipv6 = port.into();
+        self
+    }
+
+    /// Set the default discv5 periodic lookup interval (seconds).
+    pub const fn with_discv5_lookup_interval(mut self, interval: u64) -> Self {
+        self.discv5_lookup_interval = interval;
+        self
+    }
+
+    /// Set the default discv5 bootstrap lookup interval (seconds).
+    pub const fn with_discv5_bootstrap_lookup_interval(mut self, interval: u64) -> Self {
+        self.discv5_bootstrap_lookup_interval = interval;
+        self
+    }
+
+    /// Set the default discv5 bootstrap lookup countdown.
+    pub const fn with_discv5_bootstrap_lookup_countdown(mut self, countdown: u64) -> Self {
+        self.discv5_bootstrap_lookup_countdown = countdown;
+        self
+    }
+}
+
+impl Default for DefaultDiscoveryArgs {
+    fn default() -> Self {
+        Self {
+            disable_discovery: false,
+            disable_dns_discovery: false,
+            disable_discv4_discovery: false,
+            disable_discv5_discovery: false,
+            disable_nat: false,
+            addr: DEFAULT_DISCOVERY_ADDR,
+            port: DEFAULT_DISCOVERY_PORT,
+            discv5_addr: None,
+            discv5_addr_ipv6: None,
+            discv5_port: Some(DEFAULT_DISCOVERY_V5_PORT),
+            discv5_port_ipv6: Some(DEFAULT_DISCOVERY_V5_PORT),
+            discv5_lookup_interval: DEFAULT_SECONDS_LOOKUP_INTERVAL,
+            discv5_bootstrap_lookup_interval: DEFAULT_SECONDS_BOOTSTRAP_LOOKUP_INTERVAL,
+            discv5_bootstrap_lookup_countdown: DEFAULT_COUNT_BOOTSTRAP_LOOKUPS,
+        }
+    }
+}
+
 /// Arguments to setup discovery
 #[derive(Debug, Clone, Args, PartialEq, Eq)]
 pub struct DiscoveryArgs {
     /// Disable the discovery service.
-    #[arg(short, long, default_value_if("dev", "true", "true"))]
+    #[arg(short, long, default_value_if("dev", "true", "true"), default_value_t = DefaultDiscoveryArgs::get_global().disable_discovery)]
     pub disable_discovery: bool,
 
     /// Disable the DNS discovery.
-    #[arg(long, conflicts_with = "disable_discovery")]
+    #[arg(long, conflicts_with = "disable_discovery", default_value_t = DefaultDiscoveryArgs::get_global().disable_dns_discovery)]
     pub disable_dns_discovery: bool,
 
     /// Disable Discv4 discovery.
-    #[arg(long, conflicts_with = "disable_discovery")]
+    #[arg(long, conflicts_with = "disable_discovery", default_value_t = DefaultDiscoveryArgs::get_global().disable_discv4_discovery)]
     pub disable_discv4_discovery: bool,
 
     /// Enable Discv5 discovery.
@@ -750,57 +928,60 @@ pub struct DiscoveryArgs {
     pub enable_discv5_discovery: bool,
 
     /// Disable Discv5 discovery.
-    #[arg(long, conflicts_with = "disable_discovery")]
+    #[arg(long, conflicts_with = "disable_discovery", default_value_t = DefaultDiscoveryArgs::get_global().disable_discv5_discovery)]
     pub disable_discv5_discovery: bool,
 
     /// Disable Nat discovery.
-    #[arg(long, conflicts_with = "disable_discovery")]
+    #[arg(long, conflicts_with = "disable_discovery", default_value_t = DefaultDiscoveryArgs::get_global().disable_nat)]
     pub disable_nat: bool,
 
     /// The UDP address to use for devp2p peer discovery version 4.
-    #[arg(id = "discovery.addr", long = "discovery.addr", value_name = "DISCOVERY_ADDR", default_value_t = DEFAULT_DISCOVERY_ADDR)]
+    ///
+    /// If unset and `--net-if.experimental` is used, discv4 binds to the resolved interface
+    /// address.
+    #[arg(id = "discovery.addr", long = "discovery.addr", value_name = "DISCOVERY_ADDR", default_value_t = DefaultDiscoveryArgs::get_global().addr)]
     pub addr: IpAddr,
 
     /// The UDP port to use for devp2p peer discovery version 4.
-    #[arg(id = "discovery.port", long = "discovery.port", value_name = "DISCOVERY_PORT", default_value_t = DEFAULT_DISCOVERY_PORT)]
+    #[arg(id = "discovery.port", long = "discovery.port", value_name = "DISCOVERY_PORT", default_value_t = DefaultDiscoveryArgs::get_global().port)]
     pub port: u16,
 
     /// The UDP IPv4 address to use for devp2p peer discovery version 5. Overwritten by `RLPx`
     /// address, if it's also IPv4.
-    #[arg(id = "discovery.v5.addr", long = "discovery.v5.addr", value_name = "DISCOVERY_V5_ADDR", default_value = None)]
+    #[arg(id = "discovery.v5.addr", long = "discovery.v5.addr", value_name = "DISCOVERY_V5_ADDR", default_value = Resettable::from(DefaultDiscoveryArgs::get_global().discv5_addr.map(|a| OsStr::from(a.to_string()))))]
     pub discv5_addr: Option<Ipv4Addr>,
 
     /// The UDP IPv6 address to use for devp2p peer discovery version 5. Overwritten by `RLPx`
     /// address, if it's also IPv6.
-    #[arg(id = "discovery.v5.addr.ipv6", long = "discovery.v5.addr.ipv6", value_name = "DISCOVERY_V5_ADDR_IPV6", default_value = None)]
+    #[arg(id = "discovery.v5.addr.ipv6", long = "discovery.v5.addr.ipv6", value_name = "DISCOVERY_V5_ADDR_IPV6", default_value = Resettable::from(DefaultDiscoveryArgs::get_global().discv5_addr_ipv6.map(|a| OsStr::from(a.to_string()))))]
     pub discv5_addr_ipv6: Option<Ipv6Addr>,
 
     /// The UDP IPv4 port to use for devp2p peer discovery version 5. Not used unless `--addr` is
     /// IPv4, or `--discovery.v5.addr` is set.
-    #[arg(id = "discovery.v5.port", long = "discovery.v5.port", value_name = "DISCOVERY_V5_PORT",
-    default_value_t = DEFAULT_DISCOVERY_V5_PORT)]
-    pub discv5_port: u16,
+    #[arg(id = "discovery.v5.port", long = "discovery.v5.port", value_name = "DISCOVERY_V5_PORT", default_value = Resettable::from(DefaultDiscoveryArgs::get_global().discv5_port.map(|p| OsStr::from(p.to_string()))))]
+    pub discv5_port: Option<u16>,
 
     /// The UDP IPv6 port to use for devp2p peer discovery version 5. Not used unless `--addr` is
     /// IPv6, or `--discovery.addr.ipv6` is set.
-    #[arg(id = "discovery.v5.port.ipv6", long = "discovery.v5.port.ipv6", value_name = "DISCOVERY_V5_PORT_IPV6",
-    default_value_t = DEFAULT_DISCOVERY_V5_PORT)]
-    pub discv5_port_ipv6: u16,
+    ///
+    /// If not provided, discovery V5 defaults to same port as discovery V4 (--discovery.port).
+    #[arg(id = "discovery.v5.port.ipv6", long = "discovery.v5.port.ipv6", value_name = "DISCOVERY_V5_PORT_IPV6", default_value = Resettable::from(DefaultDiscoveryArgs::get_global().discv5_port_ipv6.map(|p| OsStr::from(p.to_string()))))]
+    pub discv5_port_ipv6: Option<u16>,
 
     /// The interval in seconds at which to carry out periodic lookup queries, for the whole
     /// run of the program.
-    #[arg(id = "discovery.v5.lookup-interval", long = "discovery.v5.lookup-interval", value_name = "DISCOVERY_V5_LOOKUP_INTERVAL", default_value_t = DEFAULT_SECONDS_LOOKUP_INTERVAL)]
+    #[arg(id = "discovery.v5.lookup-interval", long = "discovery.v5.lookup-interval", value_name = "DISCOVERY_V5_LOOKUP_INTERVAL", default_value_t = DefaultDiscoveryArgs::get_global().discv5_lookup_interval)]
     pub discv5_lookup_interval: u64,
 
     /// The interval in seconds at which to carry out boost lookup queries, for a fixed number of
     /// times, at bootstrap.
     #[arg(id = "discovery.v5.bootstrap.lookup-interval", long = "discovery.v5.bootstrap.lookup-interval", value_name = "DISCOVERY_V5_BOOTSTRAP_LOOKUP_INTERVAL",
-        default_value_t = DEFAULT_SECONDS_BOOTSTRAP_LOOKUP_INTERVAL)]
+        default_value_t = DefaultDiscoveryArgs::get_global().discv5_bootstrap_lookup_interval)]
     pub discv5_bootstrap_lookup_interval: u64,
 
     /// The number of times to carry out boost lookup queries at bootstrap.
     #[arg(id = "discovery.v5.bootstrap.lookup-countdown", long = "discovery.v5.bootstrap.lookup-countdown", value_name = "DISCOVERY_V5_BOOTSTRAP_LOOKUP_COUNTDOWN",
-        default_value_t = DEFAULT_COUNT_BOOTSTRAP_LOOKUPS)]
+        default_value_t = DefaultDiscoveryArgs::get_global().discv5_bootstrap_lookup_countdown)]
     pub discv5_bootstrap_lookup_countdown: u64,
 }
 
@@ -850,6 +1031,7 @@ impl DiscoveryArgs {
             discv5_lookup_interval,
             discv5_bootstrap_lookup_interval,
             discv5_bootstrap_lookup_countdown,
+            port,
             ..
         } = self;
 
@@ -867,8 +1049,9 @@ impl DiscoveryArgs {
 
         let mut discv5_config_builder =
             reth_discv5::discv5::ConfigBuilder::new(ListenConfig::from_two_sockets(
-                discv5_addr_ipv4.map(|addr| SocketAddrV4::new(addr, *discv5_port)),
-                discv5_addr_ipv6.map(|addr| SocketAddrV6::new(addr, *discv5_port_ipv6, 0, 0)),
+                discv5_addr_ipv4.map(|addr| SocketAddrV4::new(addr, discv5_port.unwrap_or(*port))),
+                discv5_addr_ipv6
+                    .map(|addr| SocketAddrV6::new(addr, discv5_port_ipv6.unwrap_or(*port), 0, 0)),
             ));
 
         if has_discv5_addr_args || self.disable_nat {
@@ -898,14 +1081,14 @@ impl DiscoveryArgs {
     /// discovery binds to the sockets.
     pub const fn with_unused_discovery_port(mut self) -> Self {
         self.port = 0;
-        self.discv5_port = 0;
-        self.discv5_port_ipv6 = 0;
+        self.discv5_port = Some(0);
+        self.discv5_port_ipv6 = Some(0);
         self
     }
 
     /// Set the discovery V5 port
-    pub const fn with_discv5_port(mut self, port: u16) -> Self {
-        self.discv5_port = port;
+    pub fn with_discv5_port(mut self, port: impl Into<Option<u16>>) -> Self {
+        self.discv5_port = port.into();
         self
     }
 
@@ -917,29 +1100,45 @@ impl DiscoveryArgs {
     pub fn adjust_instance_ports(&mut self, instance: u16) {
         debug_assert_ne!(instance, 0, "instance must be non-zero");
         self.port += instance - 1;
-        self.discv5_port += instance - 1;
-        self.discv5_port_ipv6 += instance - 1;
+        self.discv5_port = self.discv5_port.map(|port| port + instance - 1);
+        self.discv5_port_ipv6 = self.discv5_port_ipv6.map(|port| port + instance - 1);
     }
 }
 
 impl Default for DiscoveryArgs {
     fn default() -> Self {
+        let DefaultDiscoveryArgs {
+            disable_discovery,
+            disable_dns_discovery,
+            disable_discv4_discovery,
+            disable_discv5_discovery,
+            disable_nat,
+            addr,
+            port,
+            discv5_addr,
+            discv5_addr_ipv6,
+            discv5_port,
+            discv5_port_ipv6,
+            discv5_lookup_interval,
+            discv5_bootstrap_lookup_interval,
+            discv5_bootstrap_lookup_countdown,
+        } = *DefaultDiscoveryArgs::get_global();
         Self {
-            disable_discovery: false,
-            disable_dns_discovery: false,
-            disable_discv4_discovery: false,
+            disable_discovery,
+            disable_dns_discovery,
+            disable_discv4_discovery,
             enable_discv5_discovery: false,
-            disable_discv5_discovery: false,
-            disable_nat: false,
-            addr: DEFAULT_DISCOVERY_ADDR,
-            port: DEFAULT_DISCOVERY_PORT,
-            discv5_addr: None,
-            discv5_addr_ipv6: None,
-            discv5_port: DEFAULT_DISCOVERY_V5_PORT,
-            discv5_port_ipv6: DEFAULT_DISCOVERY_V5_PORT,
-            discv5_lookup_interval: DEFAULT_SECONDS_LOOKUP_INTERVAL,
-            discv5_bootstrap_lookup_interval: DEFAULT_SECONDS_BOOTSTRAP_LOOKUP_INTERVAL,
-            discv5_bootstrap_lookup_countdown: DEFAULT_COUNT_BOOTSTRAP_LOOKUPS,
+            disable_discv5_discovery,
+            disable_nat,
+            addr,
+            port,
+            discv5_addr,
+            discv5_addr_ipv6,
+            discv5_port,
+            discv5_port_ipv6,
+            discv5_lookup_interval,
+            discv5_bootstrap_lookup_interval,
+            discv5_bootstrap_lookup_countdown,
         }
     }
 }
@@ -1146,6 +1345,39 @@ mod tests {
         assert_eq!(args, default_args);
     }
 
+    #[test]
+    fn net_if_uses_resolved_addr_for_default_discovery_addr() {
+        let args =
+            CommandParser::<NetworkArgs>::parse_from(["reth", "--net-if.experimental", "en0"]).args;
+        let listener_addr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1));
+
+        assert_eq!(args.resolved_discovery_addr(listener_addr), listener_addr);
+    }
+
+    #[test]
+    fn net_if_preserves_custom_discovery_addr() {
+        let custom_discovery_addr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 2));
+        let args = CommandParser::<NetworkArgs>::parse_from([
+            "reth",
+            "--net-if.experimental",
+            "en0",
+            "--discovery.addr",
+            "192.0.2.2",
+        ])
+        .args;
+        let listener_addr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1));
+
+        assert_eq!(args.resolved_discovery_addr(listener_addr), custom_discovery_addr);
+    }
+
+    #[test]
+    fn default_discovery_addr_is_preserved_without_net_if() {
+        let args = CommandParser::<NetworkArgs>::parse_from(["reth"]).args;
+        let listener_addr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1));
+
+        assert_eq!(args.resolved_discovery_addr(listener_addr), DEFAULT_DISCOVERY_ADDR);
+    }
+
     #[test]
     fn parse_eth_max_message_size() {
         let args = CommandParser::<NetworkArgs>::parse_from([
diff --git a/crates/node/core/src/args/pruning.rs b/crates/node/core/src/args/pruning.rs
index 5e70add6e2a..557d9b3d4a2 100644
--- a/crates/node/core/src/args/pruning.rs
+++ b/crates/node/core/src/args/pruning.rs
@@ -91,6 +91,54 @@ impl Default for DefaultPruningValues {
     }
 }
 
+/// High-level pruning configuration profile.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PruneConfigKind {
+    /// Archive node with default pruning configuration.
+    Archive,
+    /// Full node pruning preset.
+    Full,
+    /// Minimal storage pruning preset.
+    Minimal,
+    /// Custom pruning configuration.
+    Custom,
+}
+
+impl PruneConfigKind {
+    /// Returns the string representation of the pruning profile.
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Archive => "archive",
+            Self::Full => "full",
+            Self::Minimal => "minimal",
+            Self::Custom => "custom",
+        }
+    }
+
+    /// Classifies an effective pruning configuration.
+    pub fn from_config<ChainSpec>(config: &PruneConfig, chain_spec: &ChainSpec) -> Self
+    where
+        ChainSpec: EthereumHardforks,
+    {
+        if config.is_default() {
+            return Self::Archive
+        }
+
+        let full_config = PruningArgs { full: true, ..Default::default() }.prune_config(chain_spec);
+        if full_config.as_ref() == Some(config) {
+            return Self::Full
+        }
+
+        let minimal_config =
+            PruningArgs { minimal: true, ..Default::default() }.prune_config(chain_spec);
+        if minimal_config.as_ref() == Some(config) {
+            return Self::Minimal
+        }
+
+        Self::Custom
+    }
+}
+
 /// Parameters for pruning and full node
 #[derive(Debug, Clone, Args, PartialEq, Eq, Default)]
 #[command(next_help_heading = "Pruning")]
@@ -409,6 +457,7 @@ mod tests {
     use super::*;
     use alloy_primitives::address;
     use clap::Parser;
+    use reth_chainspec::MAINNET;
 
     /// A helper type to parse Args more easily
     #[derive(Parser)]
@@ -433,6 +482,34 @@ mod tests {
         assert_eq!(args.receipts_log_filter, Some(config));
     }
 
+    #[test]
+    fn pruning_config_kind_classifies_presets() {
+        let chain_spec = MAINNET.as_ref();
+
+        assert_eq!(
+            PruneConfigKind::from_config(&PruneConfig::default(), chain_spec),
+            PruneConfigKind::Archive
+        );
+
+        let full_config =
+            PruningArgs { full: true, ..Default::default() }.prune_config(chain_spec).unwrap();
+        assert_eq!(PruneConfigKind::from_config(&full_config, chain_spec), PruneConfigKind::Full);
+
+        let minimal_config =
+            PruningArgs { minimal: true, ..Default::default() }.prune_config(chain_spec).unwrap();
+        assert_eq!(
+            PruneConfigKind::from_config(&minimal_config, chain_spec),
+            PruneConfigKind::Minimal
+        );
+
+        let mut custom_config = full_config;
+        custom_config.block_interval += 1;
+        assert_eq!(
+            PruneConfigKind::from_config(&custom_config, chain_spec),
+            PruneConfigKind::Custom
+        );
+    }
+
     #[test]
     fn parse_receiptslogfilter() {
         let default_args = PruningArgs::default();
diff --git a/crates/node/core/src/args/rpc_server.rs b/crates/node/core/src/args/rpc_server.rs
index cdd4c681129..5a55aeb1c4b 100644
--- a/crates/node/core/src/args/rpc_server.rs
+++ b/crates/node/core/src/args/rpc_server.rs
@@ -71,6 +71,7 @@ pub struct DefaultRpcServerArgs {
     auth_ipc_path: String,
     disable_auth_server: bool,
     rpc_jwtsecret: Option<JwtSecret>,
+    rpc_disable_metrics: bool,
     rpc_max_request_size: MaxU32,
     rpc_max_response_size: MaxU32,
     rpc_max_subscriptions_per_connection: MaxU32,
@@ -84,6 +85,7 @@ pub struct DefaultRpcServerArgs {
     rpc_evm_memory_limit: u64,
     rpc_tx_fee_cap: u128,
     rpc_max_simulate_blocks: u64,
+    rpc_compute_state_root_for_eth_simulate: bool,
     rpc_eth_proof_window: u64,
     rpc_proof_permits: usize,
     rpc_pending_block: PendingBlockKind,
@@ -231,6 +233,12 @@ impl DefaultRpcServerArgs {
         self
     }
 
+    /// Set whether to disable RPC request metrics by default
+    pub const fn with_rpc_disable_metrics(mut self, v: bool) -> Self {
+        self.rpc_disable_metrics = v;
+        self
+    }
+
     /// Set the default max request size
     pub const fn with_rpc_max_request_size(mut self, v: MaxU32) -> Self {
         self.rpc_max_request_size = v;
@@ -309,6 +317,12 @@ impl DefaultRpcServerArgs {
         self
     }
 
+    /// Set whether to compute state roots for `eth_simulateV1` responses by default.
+    pub const fn with_rpc_compute_state_root_for_eth_simulate(mut self, v: bool) -> Self {
+        self.rpc_compute_state_root_for_eth_simulate = v;
+        self
+    }
+
     /// Set the default eth proof window
     pub const fn with_rpc_eth_proof_window(mut self, v: u64) -> Self {
         self.rpc_eth_proof_window = v;
@@ -382,6 +396,7 @@ impl Default for DefaultRpcServerArgs {
             auth_ipc_path: constants::DEFAULT_ENGINE_API_IPC_ENDPOINT.to_string(),
             disable_auth_server: false,
             rpc_jwtsecret: None,
+            rpc_disable_metrics: false,
             rpc_max_request_size: RPC_DEFAULT_MAX_REQUEST_SIZE_MB.into(),
             rpc_max_response_size: RPC_DEFAULT_MAX_RESPONSE_SIZE_MB.into(),
             rpc_max_subscriptions_per_connection: RPC_DEFAULT_MAX_SUBS_PER_CONN.into(),
@@ -395,6 +410,7 @@ impl Default for DefaultRpcServerArgs {
             rpc_evm_memory_limit: (1 << 32) - 1,
             rpc_tx_fee_cap: constants::DEFAULT_TX_FEE_CAP_WEI,
             rpc_max_simulate_blocks: constants::DEFAULT_MAX_SIMULATE_BLOCKS,
+            rpc_compute_state_root_for_eth_simulate: false,
             rpc_eth_proof_window: constants::DEFAULT_ETH_PROOF_WINDOW,
             rpc_proof_permits: constants::DEFAULT_PROOF_PERMITS,
             rpc_pending_block: PendingBlockKind::Full,
@@ -511,6 +527,10 @@ pub struct RpcServerArgs {
     #[arg(long = "rpc.jwtsecret", value_name = "HEX", global = true, required = false, default_value = Resettable::from(DefaultRpcServerArgs::get_global().rpc_jwtsecret.as_ref().map(|v| format!("{:?}", v).into())))]
     pub rpc_jwtsecret: Option<JwtSecret>,
 
+    /// Disable built-in RPC request metrics.
+    #[arg(long = "rpc.disable-metrics", default_value_t = DefaultRpcServerArgs::get_global().rpc_disable_metrics)]
+    pub rpc_disable_metrics: bool,
+
     /// Set the maximum RPC request payload size for both HTTP and WS in megabytes.
     #[arg(long = "rpc.max-request-size", alias = "rpc-max-request-size", default_value_t = DefaultRpcServerArgs::get_global().rpc_max_request_size)]
     pub rpc_max_request_size: MaxU32,
@@ -594,6 +614,14 @@ pub struct RpcServerArgs {
     )]
     pub rpc_max_simulate_blocks: u64,
 
+    /// Compute state roots for `eth_simulateV1` responses.
+    #[arg(
+        long = "rpc.compute-state-root-for-eth-simulate",
+        env = "RETH_RPC_COMPUTE_STATE_ROOT_FOR_ETH_SIMULATE",
+        default_value_t = DefaultRpcServerArgs::get_global().rpc_compute_state_root_for_eth_simulate
+    )]
+    pub rpc_compute_state_root_for_eth_simulate: bool,
+
     /// The maximum proof window for historical proof generation.
     /// This value allows for generating historical proofs up to
     /// configured number of blocks from current tip (up to `tip - window`).
@@ -650,8 +678,8 @@ pub struct RpcServerArgs {
 
     /// Override the gas limit used by `testing_buildBlockV1`.
     ///
-    /// When set, `testing_buildBlockV1` will use this value instead of inheriting
-    /// the parent block's gas limit. Accepts short notation: K for thousand, M for
+    /// When set, `testing_buildBlockV1` will use this exact value instead of moving toward the
+    /// payload builder's configured gas limit. Accepts short notation: K for thousand, M for
     /// million, G for billion (e.g., 1G = 1 billion).
     #[arg(long = "testing.gas-limit", value_name = "GAS_LIMIT", hide = true)]
     pub testing_gas_limit: Option<u64>,
@@ -828,6 +856,7 @@ impl Default for RpcServerArgs {
             auth_ipc_path,
             disable_auth_server,
             rpc_jwtsecret,
+            rpc_disable_metrics,
             rpc_max_request_size,
             rpc_max_response_size,
             rpc_max_subscriptions_per_connection,
@@ -841,6 +870,7 @@ impl Default for RpcServerArgs {
             rpc_evm_memory_limit,
             rpc_tx_fee_cap,
             rpc_max_simulate_blocks,
+            rpc_compute_state_root_for_eth_simulate,
             rpc_eth_proof_window,
             rpc_proof_permits,
             rpc_pending_block,
@@ -872,6 +902,7 @@ impl Default for RpcServerArgs {
             auth_ipc_path,
             disable_auth_server,
             rpc_jwtsecret,
+            rpc_disable_metrics,
             rpc_max_request_size,
             rpc_max_response_size,
             rpc_max_subscriptions_per_connection,
@@ -885,6 +916,7 @@ impl Default for RpcServerArgs {
             rpc_evm_memory_limit,
             rpc_tx_fee_cap,
             rpc_max_simulate_blocks,
+            rpc_compute_state_root_for_eth_simulate,
             rpc_eth_proof_window,
             rpc_proof_permits,
             rpc_pending_block,
@@ -981,6 +1013,16 @@ mod tests {
         assert_eq!(args, default_args);
     }
 
+    #[test]
+    fn test_rpc_disable_metrics_arg() {
+        let args = CommandParser::<RpcServerArgs>::parse_from(["reth"]).args;
+        assert!(!args.rpc_disable_metrics);
+
+        let args =
+            CommandParser::<RpcServerArgs>::parse_from(["reth", "--rpc.disable-metrics"]).args;
+        assert!(args.rpc_disable_metrics);
+    }
+
     #[test]
     fn test_rpc_tx_fee_cap_parse_integer() {
         let args = CommandParser::<RpcServerArgs>::parse_from(["reth", "--rpc.txfeecap", "2"]).args;
@@ -1038,6 +1080,7 @@ mod tests {
                 )
                 .unwrap(),
             ),
+            rpc_disable_metrics: false,
             rpc_max_request_size: 15u32.into(),
             rpc_max_response_size: 160u32.into(),
             rpc_max_subscriptions_per_connection: 1024u32.into(),
@@ -1051,6 +1094,7 @@ mod tests {
             rpc_evm_memory_limit: 256,
             rpc_tx_fee_cap: 2_000_000_000_000_000_000u128,
             rpc_max_simulate_blocks: 256,
+            rpc_compute_state_root_for_eth_simulate: false,
             rpc_eth_proof_window: 100_000,
             rpc_proof_permits: 16,
             rpc_pending_block: PendingBlockKind::Full,
@@ -1060,6 +1104,7 @@ mod tests {
                 max_blocks: 5000,
                 max_receipts: 2000,
                 max_headers: 1000,
+                max_bals: 1000,
                 max_concurrent_db_requests: 512,
                 max_cached_tx_hashes: 30_000,
             },
@@ -1150,6 +1195,8 @@ mod tests {
             "2000",
             "--rpc-cache.max-headers",
             "1000",
+            "--rpc-cache.max-bals",
+            "1000",
             "--rpc-cache.max-concurrent-db-requests",
             "512",
             "--gpo.blocks",
diff --git a/crates/node/core/src/args/rpc_state_cache.rs b/crates/node/core/src/args/rpc_state_cache.rs
index 054fe78e5e4..7c3062e5baf 100644
--- a/crates/node/core/src/args/rpc_state_cache.rs
+++ b/crates/node/core/src/args/rpc_state_cache.rs
@@ -1,7 +1,7 @@
 use clap::Args;
 use reth_rpc_server_types::constants::cache::{
-    DEFAULT_BLOCK_CACHE_MAX_LEN, DEFAULT_CONCURRENT_DB_REQUESTS, DEFAULT_HEADER_CACHE_MAX_LEN,
-    DEFAULT_MAX_CACHED_TX_HASHES, DEFAULT_RECEIPT_CACHE_MAX_LEN,
+    DEFAULT_BAL_CACHE_MAX_LEN, DEFAULT_BLOCK_CACHE_MAX_LEN, DEFAULT_CONCURRENT_DB_REQUESTS,
+    DEFAULT_HEADER_CACHE_MAX_LEN, DEFAULT_MAX_CACHED_TX_HASHES, DEFAULT_RECEIPT_CACHE_MAX_LEN,
 };
 
 /// Parameters to configure RPC state cache.
@@ -30,6 +30,13 @@ pub struct RpcStateCacheArgs {
     )]
     pub max_headers: u32,
 
+    /// Max number of revm block access lists in cache.
+    #[arg(
+        long = "rpc-cache.max-bals",
+        default_value_t = DEFAULT_BAL_CACHE_MAX_LEN,
+    )]
+    pub max_bals: u32,
+
     /// Max number of concurrent database requests.
     #[arg(
         long = "rpc-cache.max-concurrent-db-requests",
@@ -51,6 +58,7 @@ impl RpcStateCacheArgs {
         self.max_blocks = 0;
         self.max_receipts = 0;
         self.max_headers = 0;
+        self.max_bals = 0;
     }
 }
 
@@ -60,6 +68,7 @@ impl Default for RpcStateCacheArgs {
             max_blocks: DEFAULT_BLOCK_CACHE_MAX_LEN,
             max_receipts: DEFAULT_RECEIPT_CACHE_MAX_LEN,
             max_headers: DEFAULT_HEADER_CACHE_MAX_LEN,
+            max_bals: DEFAULT_BAL_CACHE_MAX_LEN,
             max_concurrent_db_requests: DEFAULT_CONCURRENT_DB_REQUESTS,
             max_cached_tx_hashes: DEFAULT_MAX_CACHED_TX_HASHES,
         }
diff --git a/crates/node/core/src/args/trace.rs b/crates/node/core/src/args/trace.rs
index 58371940359..ae6caf1aad6 100644
--- a/crates/node/core/src/args/trace.rs
+++ b/crates/node/core/src/args/trace.rs
@@ -4,8 +4,52 @@ use clap::Parser;
 use eyre::WrapErr;
 use reth_tracing::{tracing_subscriber::EnvFilter, Layers};
 use reth_tracing_otlp::OtlpProtocol;
+use std::sync::OnceLock;
 use url::Url;
 
+static TRACE_DEFAULTS: OnceLock<DefaultTraceValues> = OnceLock::new();
+
+/// Overridable defaults for OTLP trace configuration.
+///
+/// Downstream binaries that embed reth can call
+/// `DefaultTraceValues::default().with_service_name("myapp").try_init()` before CLI parsing to
+/// change the defaults that clap will use.
+#[derive(Debug, Clone)]
+pub struct DefaultTraceValues {
+    service_name: String,
+    service_version: Option<String>,
+}
+
+impl Default for DefaultTraceValues {
+    fn default() -> Self {
+        Self { service_name: "reth".to_string(), service_version: None }
+    }
+}
+
+impl DefaultTraceValues {
+    /// Initialize the global trace defaults with this configuration.
+    pub fn try_init(self) -> Result<(), Self> {
+        TRACE_DEFAULTS.set(self)
+    }
+
+    /// Get a reference to the global trace defaults.
+    pub fn get_global() -> &'static Self {
+        TRACE_DEFAULTS.get_or_init(Self::default)
+    }
+
+    /// Set the default service name.
+    pub fn with_service_name(mut self, name: impl Into<String>) -> Self {
+        self.service_name = name.into();
+        self
+    }
+
+    /// Set the default service version.
+    pub fn with_service_version(mut self, version: impl Into<String>) -> Self {
+        self.service_version = Some(version.into());
+        self
+    }
+}
+
 /// CLI arguments for configuring `Opentelemetry` trace and logs export.
 #[derive(Debug, Clone, Parser)]
 pub struct TraceArgs {
@@ -109,12 +153,26 @@ pub struct TraceArgs {
         env = "OTEL_SERVICE_NAME",
         global = true,
         value_name = "NAME",
-        default_value = "reth",
+        default_value = DefaultTraceValues::get_global().service_name.as_str(),
         hide = true,
         help_heading = "Tracing"
     )]
     pub service_name: String,
 
+    /// Service version to use for OTLP tracing export.
+    ///
+    /// Overrides the default version reported in the `service.version` OTLP resource attribute.
+    /// Falls back to the crate's `CARGO_PKG_VERSION` if not specified.
+    #[arg(
+        long = "tracing-otlp.service-version",
+        env = "OTEL_SERVICE_VERSION",
+        global = true,
+        value_name = "VERSION",
+        hide = true,
+        help_heading = "Tracing"
+    )]
+    pub service_version: Option<String>,
+
     /// Trace sampling ratio to control the percentage of traces to export.
     ///
     /// Valid range: 0.0 to 1.0
@@ -135,6 +193,7 @@ pub struct TraceArgs {
 
 impl Default for TraceArgs {
     fn default() -> Self {
+        let defaults = DefaultTraceValues::get_global();
         Self {
             otlp: None,
             logs_otlp: None,
@@ -142,7 +201,8 @@ impl Default for TraceArgs {
             otlp_filter: EnvFilter::from_default_env(),
             logs_otlp_filter: EnvFilter::try_new("info").expect("valid filter"),
             sample_ratio: None,
-            service_name: "reth".to_string(),
+            service_name: defaults.service_name.clone(),
+            service_version: defaults.service_version.clone(),
         }
     }
 }
@@ -168,12 +228,15 @@ impl TraceArgs {
             #[cfg(feature = "otlp")]
             {
                 {
-                    let config = reth_tracing_otlp::OtlpConfig::new(
+                    let mut config = reth_tracing_otlp::OtlpConfig::new(
                         self.service_name.clone(),
                         endpoint.clone(),
                         self.protocol,
                         self.sample_ratio,
                     )?;
+                    if let Some(version) = &self.service_version {
+                        config = config.with_service_version(version.clone());
+                    }
 
                     _layers.with_span_layer(config.clone(), self.otlp_filter.clone())?;
 
@@ -201,11 +264,14 @@ impl TraceArgs {
 
             #[cfg(feature = "otlp-logs")]
             {
-                let config = reth_tracing_otlp::OtlpLogsConfig::new(
+                let mut config = reth_tracing_otlp::OtlpLogsConfig::new(
                     self.service_name.clone(),
                     endpoint.clone(),
                     self.protocol,
                 )?;
+                if let Some(version) = &self.service_version {
+                    config = config.with_service_version(version.clone());
+                }
 
                 _layers.with_log_layer(config.clone(), self.logs_otlp_filter.clone())?;
 
diff --git a/crates/node/core/src/args/txpool.rs b/crates/node/core/src/args/txpool.rs
index 2428fcd6b4b..0dc2ad027f6 100644
--- a/crates/node/core/src/args/txpool.rs
+++ b/crates/node/core/src/args/txpool.rs
@@ -290,28 +290,28 @@ impl Default for DefaultTxPoolValues {
 #[derive(Debug, Clone, Args, PartialEq, Eq)]
 #[command(next_help_heading = "TxPool")]
 pub struct TxPoolArgs {
-    /// Max number of transaction in the pending sub-pool.
+    /// Max number of transactions in the pending sub-pool.
     #[arg(long = "txpool.pending-max-count", alias = "txpool.pending_max_count", default_value_t = DefaultTxPoolValues::get_global().pending_max_count)]
     pub pending_max_count: usize,
     /// Max size of the pending sub-pool in megabytes.
     #[arg(long = "txpool.pending-max-size", alias = "txpool.pending_max_size", default_value_t = DefaultTxPoolValues::get_global().pending_max_size)]
     pub pending_max_size: usize,
 
-    /// Max number of transaction in the basefee sub-pool
+    /// Max number of transactions in the basefee sub-pool
     #[arg(long = "txpool.basefee-max-count", alias = "txpool.basefee_max_count", default_value_t = DefaultTxPoolValues::get_global().basefee_max_count)]
     pub basefee_max_count: usize,
     /// Max size of the basefee sub-pool in megabytes.
     #[arg(long = "txpool.basefee-max-size", alias = "txpool.basefee_max_size", default_value_t = DefaultTxPoolValues::get_global().basefee_max_size)]
     pub basefee_max_size: usize,
 
-    /// Max number of transaction in the queued sub-pool
+    /// Max number of transactions in the queued sub-pool
     #[arg(long = "txpool.queued-max-count", alias = "txpool.queued_max_count", default_value_t = DefaultTxPoolValues::get_global().queued_max_count)]
     pub queued_max_count: usize,
     /// Max size of the queued sub-pool in megabytes.
     #[arg(long = "txpool.queued-max-size", alias = "txpool.queued_max_size", default_value_t = DefaultTxPoolValues::get_global().queued_max_size)]
     pub queued_max_size: usize,
 
-    /// Max number of transaction in the blobpool
+    /// Max number of transactions in the blobpool
     #[arg(long = "txpool.blobpool-max-count", alias = "txpool.blobpool_max_count", default_value_t = DefaultTxPoolValues::get_global().blobpool_max_count)]
     pub blobpool_max_count: usize,
     /// Max size of the blobpool in megabytes.
diff --git a/crates/node/events/src/node.rs b/crates/node/events/src/node.rs
index 79648246b4a..7223026273f 100644
--- a/crates/node/events/src/node.rs
+++ b/crates/node/events/src/node.rs
@@ -268,8 +268,8 @@ impl NodeState {
                 let block = executed.sealed_block();
                 info!(number=block.number(), hash=?block.hash(), ?elapsed, "Block added to fork chain");
             }
-            ConsensusEngineEvent::InvalidBlock(block) => {
-                warn!(number=block.number(), hash=?block.hash(), "Encountered invalid block");
+            ConsensusEngineEvent::InvalidBlock { block, error } => {
+                warn!(number=block.number(), hash=?block.hash(), %error, "Encountered invalid block");
             }
             ConsensusEngineEvent::BlockReceived(num_hash) => {
                 info!(number=num_hash.number, hash=?num_hash.hash, "Received new payload from consensus engine");
diff --git a/crates/node/metrics/src/lib.rs b/crates/node/metrics/src/lib.rs
index 08cc77168ed..0baede0fdab 100644
--- a/crates/node/metrics/src/lib.rs
+++ b/crates/node/metrics/src/lib.rs
@@ -14,6 +14,7 @@ pub mod process;
 pub mod recorder;
 /// The metric server serving the metrics.
 pub mod server;
+pub mod storage;
 pub mod version;
 
 pub use metrics_exporter_prometheus::*;
diff --git a/crates/node/metrics/src/server.rs b/crates/node/metrics/src/server.rs
index 36f2200cbef..be1da314ad5 100644
--- a/crates/node/metrics/src/server.rs
+++ b/crates/node/metrics/src/server.rs
@@ -3,6 +3,7 @@ use crate::{
     hooks::{Hook, Hooks},
     process::register_process_metrics,
     recorder::install_prometheus_recorder,
+    storage::StorageSettingsInfo,
     version::VersionInfo,
 };
 use bytes::Bytes;
@@ -22,6 +23,7 @@ pub struct MetricServerConfig {
     listen_addr: SocketAddr,
     version_info: VersionInfo,
     chain_spec_info: ChainSpecInfo,
+    storage_settings_info: Option<StorageSettingsInfo>,
     task_executor: TaskExecutor,
     hooks: Hooks,
     push_gateway_url: Option<String>,
@@ -45,12 +47,19 @@ impl MetricServerConfig {
             task_executor,
             version_info,
             chain_spec_info,
+            storage_settings_info: None,
             push_gateway_url: None,
             push_gateway_interval: Duration::from_secs(5),
             pprof_dump_dir,
         }
     }
 
+    /// Set the storage settings information to expose over prometheus.
+    pub fn with_storage_settings_info(mut self, info: StorageSettingsInfo) -> Self {
+        self.storage_settings_info = Some(info);
+        self
+    }
+
     /// Set the gateway URL and interval for pushing metrics
     pub fn with_push_gateway(mut self, url: Option<String>, interval: Duration) -> Self {
         self.push_gateway_url = url;
@@ -79,6 +88,7 @@ impl MetricServer {
             task_executor,
             version_info,
             chain_spec_info,
+            storage_settings_info,
             push_gateway_url,
             push_gateway_interval,
             pprof_dump_dir,
@@ -114,6 +124,9 @@ impl MetricServer {
 
         version_info.register_version_metrics();
         chain_spec_info.register_chain_spec_metrics();
+        if let Some(storage_settings_info) = storage_settings_info {
+            storage_settings_info.register_storage_settings_metrics();
+        }
         register_process_metrics();
 
         Ok(())
@@ -462,6 +475,11 @@ mod tests {
         install_prometheus_recorder();
 
         let chain_spec_info = ChainSpecInfo { name: "test".to_string() };
+        let storage_settings_info = StorageSettingsInfo {
+            storage_v2: true,
+            pruning_mode: "archive",
+            prune_config: r#"{"block_interval":5}"#.to_string(),
+        };
         let version_info = VersionInfo {
             version: "test",
             build_timestamp: "test",
@@ -483,7 +501,8 @@ mod tests {
             runtime.clone(),
             hooks,
             std::env::temp_dir(),
-        );
+        )
+        .with_storage_settings_info(storage_settings_info);
 
         MetricServer::new(config).serve().await.unwrap();
 
@@ -497,6 +516,10 @@ mod tests {
         assert!(body.contains("reth_process_cpu_seconds_total"));
         assert!(body.contains("reth_process_start_time_seconds"));
         assert!(body.contains("process_cli_args"), "expected process_cli_args metric in output");
+        assert!(body.contains("reth_storage_settings"), "expected storage settings metric");
+        assert!(body.contains("storage_v2=\"true\""), "expected storage v2 label");
+        assert!(body.contains("pruning_mode=\"archive\""), "expected pruning mode label");
+        assert!(body.contains("prune_config="), "expected prune config label");
 
         // Make sure the runtime is dropped after the test runs.
         drop(runtime);
diff --git a/crates/node/metrics/src/storage.rs b/crates/node/metrics/src/storage.rs
new file mode 100644
index 00000000000..cd22e692288
--- /dev/null
+++ b/crates/node/metrics/src/storage.rs
@@ -0,0 +1,29 @@
+//! This exposes reth's storage settings over prometheus.
+
+use metrics::gauge;
+
+/// Contains storage settings information for the application.
+#[derive(Debug, Clone)]
+pub struct StorageSettingsInfo {
+    /// Whether this node uses v2 storage layout.
+    pub storage_v2: bool,
+    /// The high-level pruning mode.
+    pub pruning_mode: &'static str,
+    /// The effective pruning configuration as JSON.
+    pub prune_config: String,
+}
+
+impl StorageSettingsInfo {
+    /// This exposes reth's storage settings over prometheus.
+    pub fn register_storage_settings_metrics(&self) {
+        let storage_v2 = if self.storage_v2 { "true" } else { "false" };
+        let labels: [(&str, String); 3] = [
+            ("storage_v2", storage_v2.to_string()),
+            ("pruning_mode", self.pruning_mode.to_string()),
+            ("prune_config", self.prune_config.clone()),
+        ];
+
+        let gauge = gauge!("storage_settings", &labels);
+        gauge.set(1);
+    }
+}
diff --git a/crates/payload/basic/src/lib.rs b/crates/payload/basic/src/lib.rs
index 86a710837e3..5e95081d736 100644
--- a/crates/payload/basic/src/lib.rs
+++ b/crates/payload/basic/src/lib.rs
@@ -47,6 +47,8 @@ mod stack;
 pub use better_payload_emitter::BetterPayloadEmitter;
 pub use stack::PayloadBuilderStack;
 
+const PAYLOAD_BUILDER_THREAD_NAME: &str = "payload-builder";
+
 /// Helper to access [`NodePrimitives::BlockHeader`] from [`PayloadBuilder::BuiltPayload`].
 pub type HeaderForPayload<P> = <<P as BuiltPayload>::Primitives as NodePrimitives>::BlockHeader;
 
@@ -67,6 +69,8 @@ pub struct BasicPayloadJobGenerator<Client, Builder> {
     builder: Builder,
     /// Stored `cached_reads` for new payload jobs.
     pre_cached: Option<PrecachedState>,
+    /// Stored parent block information for new payload jobs.
+    pre_cached_parent_block_info: Option<PrecachedParentBlockInfo>,
 }
 
 // === impl BasicPayloadJobGenerator ===
@@ -87,6 +91,7 @@ impl<Client, Builder> BasicPayloadJobGenerator<Client, Builder> {
             config,
             builder,
             pre_cached: None,
+            pre_cached_parent_block_info: None,
         }
     }
 
@@ -123,8 +128,20 @@ impl<Client, Builder> BasicPayloadJobGenerator<Client, Builder> {
     /// Returns the pre-cached reads for the given parent header if it matches the cached state's
     /// block.
     fn maybe_pre_cached(&self, parent: B256) -> Option<CachedReads> {
+        if !self.config.pre_cache_state {
+            return None
+        }
+
         self.pre_cached.as_ref().filter(|pc| pc.block == parent).map(|pc| pc.cached.clone())
     }
+
+    /// Returns the cached parent block information if it matches the requested parent.
+    fn maybe_parent_block_info(&self, parent: B256) -> Option<PayloadParentBlockInfo> {
+        self.pre_cached_parent_block_info
+            .as_ref()
+            .filter(|info| info.block == parent)
+            .map(|info| info.parent_block_info)
+    }
 }
 
 // === impl BasicPayloadJobGenerator ===
@@ -161,9 +178,12 @@ where
                 .ok_or_else(|| PayloadBuilderError::MissingParentHeader(input.parent_hash))?
         };
 
-        let cached_reads = self.maybe_pre_cached(parent_header.hash());
+        let parent_hash = parent_header.hash();
+        let cached_reads = self.maybe_pre_cached(parent_hash);
+        let parent_block_info = self.maybe_parent_block_info(parent_hash);
 
-        let config = PayloadConfig::new(Arc::new(parent_header), input.attributes, id);
+        let config = PayloadConfig::new(Arc::new(parent_header), input.attributes, id)
+            .with_parent_block_info(parent_block_info);
 
         let until = self.job_deadline(config.attributes.timestamp());
         let deadline = Box::pin(tokio::time::sleep_until(until));
@@ -191,6 +211,11 @@ where
     }
 
     fn on_new_state<N: NodePrimitives>(&mut self, new_state: CanonStateNotification<N>) {
+        if !self.config.pre_cache_state {
+            self.pre_cached = None;
+            return
+        }
+
         let mut cached = CachedReads::default();
 
         // extract the state from the notification and put it into the cache
@@ -206,7 +231,14 @@ where
             }
         }
 
-        self.pre_cached = Some(PrecachedState { block: committed.tip().hash(), cached });
+        let tip = committed.tip();
+        let block = tip.hash();
+        let parent_block_info =
+            PayloadParentBlockInfo { transaction_count: tip.transaction_count() };
+
+        self.pre_cached = Some(PrecachedState { block, cached });
+        self.pre_cached_parent_block_info =
+            Some(PrecachedParentBlockInfo { block, parent_block_info });
     }
 }
 
@@ -221,6 +253,15 @@ pub struct PrecachedState {
     pub cached: CachedReads,
 }
 
+/// Pre-filled parent block information for a specific block.
+#[derive(Debug, Clone, Copy)]
+struct PrecachedParentBlockInfo {
+    /// The block for which the parent block information is cached.
+    block: B256,
+    /// Cached parent block information.
+    parent_block_info: PayloadParentBlockInfo,
+}
+
 /// Restricts how many generator tasks can be executed at once.
 #[derive(Debug, Clone)]
 pub struct PayloadTaskGuard(Arc<Semaphore>);
@@ -240,6 +281,11 @@ impl PayloadTaskGuard {
     pub fn new(max_payload_tasks: usize) -> Self {
         Self(Arc::new(Semaphore::new(max_payload_tasks)))
     }
+
+    /// Acquires an owned permit for a payload build task.
+    async fn acquire_owned(&self) -> tokio::sync::OwnedSemaphorePermit {
+        self.0.clone().acquire_owned().await.expect("payload task semaphore closed")
+    }
 }
 
 /// Settings for the [`BasicPayloadJobGenerator`].
@@ -253,6 +299,8 @@ pub struct BasicPayloadJobGeneratorConfig {
     deadline: Duration,
     /// Maximum number of tasks to spawn for building a payload.
     max_payload_tasks: usize,
+    /// Whether to pre-cache changed state from canonical state notifications.
+    pre_cache_state: bool,
 }
 
 // === impl BasicPayloadJobGeneratorConfig ===
@@ -280,6 +328,15 @@ impl BasicPayloadJobGeneratorConfig {
         self.max_payload_tasks = max_payload_tasks;
         self
     }
+
+    /// Sets whether to pre-cache changed state from canonical state notifications.
+    ///
+    /// This keeps the parent block's state changes in memory so payload jobs building on top of it
+    /// can reuse those reads.
+    pub const fn pre_cache_state(mut self, pre_cache_state: bool) -> Self {
+        self.pre_cache_state = pre_cache_state;
+        self
+    }
 }
 
 impl Default for BasicPayloadJobGeneratorConfig {
@@ -289,6 +346,7 @@ impl Default for BasicPayloadJobGeneratorConfig {
             // 12s slot time
             deadline: SLOT_DURATION,
             max_payload_tasks: 3,
+            pre_cache_state: true,
         }
     }
 }
@@ -359,19 +417,23 @@ where
         let execution_cache = self.execution_cache.clone();
         let trie_handle = self.trie_handle.take();
         let builder = self.builder.clone();
-        self.executor.spawn_blocking_task(async move {
+        let executor = self.executor.clone();
+        self.executor.spawn_task(async move {
             // acquire the permit for executing the task
-            let _permit = guard.acquire().await;
-            let args = BuildArguments {
-                cached_reads,
-                execution_cache,
-                trie_handle,
-                config: payload_config,
-                cancel,
-                best_payload,
-            };
-            let result = builder.try_build(args);
-            let _ = tx.send(result);
+            let permit = guard.acquire_owned().await;
+            executor.spawn_blocking_named_or_tokio(PAYLOAD_BUILDER_THREAD_NAME, move || {
+                let _permit = permit;
+                let args = BuildArguments {
+                    cached_reads,
+                    execution_cache,
+                    trie_handle,
+                    config: payload_config,
+                    cancel,
+                    best_payload,
+                };
+                let result = builder.try_build(args);
+                let _ = tx.send(result);
+            });
         });
 
         self.pending_block = Some(PendingPayload { _cancel, payload: rx });
@@ -519,10 +581,13 @@ where
                     let (tx, rx) = oneshot::channel();
                     let config = self.config.clone();
                     let builder = self.builder.clone();
-                    self.executor.spawn_blocking_task(async move {
-                        let res = builder.build_empty_payload(config);
-                        let _ = tx.send(res);
-                    });
+                    self.executor.spawn_blocking_named_or_tokio(
+                        PAYLOAD_BUILDER_THREAD_NAME,
+                        move || {
+                            let res = builder.build_empty_payload(config);
+                            let _ = tx.send(res);
+                        },
+                    );
 
                     empty_payload = Some(rx);
                 }
@@ -530,9 +595,12 @@ where
                     debug!(target: "payload_builder", id=%self.config.payload_id(), "racing fallback payload");
                     // race the in progress job with this job
                     let (tx, rx) = oneshot::channel();
-                    self.executor.spawn_blocking_task(async move {
-                        let _ = tx.send(job());
-                    });
+                    self.executor.spawn_blocking_named_or_tokio(
+                        PAYLOAD_BUILDER_THREAD_NAME,
+                        move || {
+                            let _ = tx.send(job());
+                        },
+                    );
                     empty_payload = Some(rx);
                 }
             };
@@ -686,12 +754,21 @@ impl<P> Future for PendingPayload<P> {
 pub struct PayloadConfig<Attributes, Header = alloy_consensus::Header> {
     /// The parent header.
     pub parent_header: Arc<SealedHeader<Header>>,
+    /// Additional parent block information, if available.
+    pub parent_block_info: Option<PayloadParentBlockInfo>,
     /// Requested attributes for the payload.
     pub attributes: Attributes,
     /// The payload id.
     pub payload_id: PayloadId,
 }
 
+/// Additional information about the parent block.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct PayloadParentBlockInfo {
+    /// Number of transactions in the parent block.
+    pub transaction_count: usize,
+}
+
 impl<Attributes, Header> PayloadConfig<Attributes, Header>
 where
     Attributes: PayloadAttributes,
@@ -702,7 +779,16 @@ where
         attributes: Attributes,
         payload_id: PayloadId,
     ) -> Self {
-        Self { parent_header, attributes, payload_id }
+        Self { parent_header, parent_block_info: None, attributes, payload_id }
+    }
+
+    /// Attaches cached parent block information.
+    pub const fn with_parent_block_info(
+        mut self,
+        parent_block_info: Option<PayloadParentBlockInfo>,
+    ) -> Self {
+        self.parent_block_info = parent_block_info;
+        self
     }
 
     /// Returns the payload id.
diff --git a/crates/payload/basic/src/stack.rs b/crates/payload/basic/src/stack.rs
index f953f16be23..faf61450e11 100644
--- a/crates/payload/basic/src/stack.rs
+++ b/crates/payload/basic/src/stack.rs
@@ -3,7 +3,7 @@ use crate::{
     PayloadConfig,
 };
 
-use alloy_primitives::{B256, U256};
+use alloy_primitives::{Bytes, B256, U256};
 use reth_payload_builder::PayloadId;
 use reth_payload_primitives::{BuiltPayload, PayloadAttributes};
 use reth_primitives_traits::{NodePrimitives, SealedBlock};
@@ -135,6 +135,13 @@ where
         }
     }
 
+    fn block_access_list(&self) -> Option<&Bytes> {
+        match self {
+            Self::Left(l) => l.block_access_list(),
+            Self::Right(r) => r.block_access_list(),
+        }
+    }
+
     fn requests(&self) -> Option<Requests> {
         match self {
             Self::Left(l) => l.requests(),
@@ -168,7 +175,7 @@ where
             cancel,
             best_payload,
         } = args;
-        let PayloadConfig { parent_header, attributes, payload_id } = config;
+        let PayloadConfig { parent_header, parent_block_info, attributes, payload_id } = config;
 
         match attributes {
             Either::Left(left_attr) => {
@@ -176,7 +183,12 @@ where
                     cached_reads,
                     execution_cache,
                     trie_handle,
-                    config: PayloadConfig { parent_header, attributes: left_attr, payload_id },
+                    config: PayloadConfig {
+                        parent_header,
+                        parent_block_info,
+                        attributes: left_attr,
+                        payload_id,
+                    },
                     cancel,
                     best_payload: best_payload.and_then(|payload| {
                         if let Either::Left(p) = payload {
@@ -193,7 +205,12 @@ where
                     cached_reads,
                     execution_cache,
                     trie_handle,
-                    config: PayloadConfig { parent_header, attributes: right_attr, payload_id },
+                    config: PayloadConfig {
+                        parent_header,
+                        parent_block_info,
+                        attributes: right_attr,
+                        payload_id,
+                    },
                     cancel,
                     best_payload: best_payload.and_then(|payload| {
                         if let Either::Right(p) = payload {
@@ -213,14 +230,32 @@ where
         config: PayloadConfig<Self::Attributes, HeaderForPayload<Self::BuiltPayload>>,
     ) -> Result<Self::BuiltPayload, PayloadBuilderError> {
         match config {
-            PayloadConfig { parent_header, attributes: Either::Left(left_attr), payload_id } => {
-                let left_config =
-                    PayloadConfig { parent_header, attributes: left_attr, payload_id };
+            PayloadConfig {
+                parent_header,
+                parent_block_info,
+                attributes: Either::Left(left_attr),
+                payload_id,
+            } => {
+                let left_config = PayloadConfig {
+                    parent_header,
+                    parent_block_info,
+                    attributes: left_attr,
+                    payload_id,
+                };
                 self.left.build_empty_payload(left_config).map(Either::Left)
             }
-            PayloadConfig { parent_header, attributes: Either::Right(right_attr), payload_id } => {
-                let right_config =
-                    PayloadConfig { parent_header, attributes: right_attr, payload_id };
+            PayloadConfig {
+                parent_header,
+                parent_block_info,
+                attributes: Either::Right(right_attr),
+                payload_id,
+            } => {
+                let right_config = PayloadConfig {
+                    parent_header,
+                    parent_block_info,
+                    attributes: right_attr,
+                    payload_id,
+                };
                 self.right.build_empty_payload(right_config).map(Either::Right)
             }
         }
diff --git a/crates/payload/builder-primitives/Cargo.toml b/crates/payload/builder-primitives/Cargo.toml
index 70ff2d58833..4d16ce9c002 100644
--- a/crates/payload/builder-primitives/Cargo.toml
+++ b/crates/payload/builder-primitives/Cargo.toml
@@ -18,7 +18,7 @@ reth-payload-primitives.workspace = true
 # async
 pin-project.workspace = true
 tokio = { workspace = true, features = ["sync"] }
-tokio-stream.workspace = true
+tokio-stream = { workspace = true, features = ["sync"] }
 
 # misc
 tracing.workspace = true
diff --git a/crates/payload/builder/src/lib.rs b/crates/payload/builder/src/lib.rs
index 4cd2b1fccbb..7b1e4e27846 100644
--- a/crates/payload/builder/src/lib.rs
+++ b/crates/payload/builder/src/lib.rs
@@ -33,7 +33,7 @@
 //! use reth_payload_builder::PayloadId;
 //! use alloy_primitives::U256;
 //! use reth_payload_builder::{EthBuiltPayload, PayloadBuilderError, KeepPayloadJobAlive, PayloadJob, PayloadJobGenerator, PayloadKind};
-//! use reth_primitives_traits::SealedBlock;
+//! use reth_primitives_traits::{RecoveredBlock, SealedBlock};
 //! use alloy_rpc_types::engine::PayloadAttributes;
 //! use reth_payload_builder::BuildNewPayload;
 //!
@@ -72,7 +72,8 @@
 //!         },
 //!         ..Default::default()
 //!     };
-//!     let payload = EthBuiltPayload::new(Arc::new(SealedBlock::seal_slow(block)), U256::ZERO, None, None);
+//!     let block = RecoveredBlock::new_sealed(SealedBlock::seal_slow(block), vec![]);
+//!     let payload = EthBuiltPayload::new(Arc::new(block), U256::ZERO, None, None);
 //!     Ok(payload)
 //! }
 //!
diff --git a/crates/payload/builder/src/service.rs b/crates/payload/builder/src/service.rs
index 8805651f345..086c31f8b3e 100644
--- a/crates/payload/builder/src/service.rs
+++ b/crates/payload/builder/src/service.rs
@@ -32,6 +32,8 @@ use tokio_stream::wrappers::UnboundedReceiverStream;
 use tracing::{debug, debug_span, info, trace, warn, Span};
 
 type PayloadFuture<P> = Pin<Box<dyn Future<Output = Result<P, PayloadBuilderError>> + Send>>;
+type PayloadJobEntry<Job> = (Job, PayloadId, Span);
+type ResolvePayloadResult<P, Job> = (Option<PayloadFuture<P>>, Option<PayloadJobEntry<Job>>);
 
 /// A communication channel to the [`PayloadBuilderService`] that can retrieve payloads.
 ///
@@ -307,13 +309,15 @@ where
         res
     }
 
-    /// Returns the best payload for the given identifier that has been built so far and terminates
-    /// the job if requested.
+    /// Returns the best payload for the given identifier that has been built so far.
+    ///
+    /// If the job should be terminated, this removes it from active polling and returns it so the
+    /// caller can drop it after the response is sent.
     fn resolve(
         &mut self,
         id: PayloadId,
         kind: PayloadKind,
-    ) -> Option<PayloadFuture<T::BuiltPayload>> {
+    ) -> ResolvePayloadResult<T::BuiltPayload, Gen::Job> {
         let start = Instant::now();
         debug!(target: "payload_builder", %id, "resolving payload job");
 
@@ -321,17 +325,17 @@ where
             *cached == id
         {
             self.metrics.resolve_duration_seconds.record(start.elapsed());
-            return Some(Box::pin(core::future::ready(Ok(payload.clone()))));
+            return (Some(Box::pin(core::future::ready(Ok(payload.clone())))), None);
         }
 
-        let job = self.payload_jobs.iter().position(|(_, job_id, _)| *job_id == id)?;
+        let Some(job) = self.payload_jobs.iter().position(|(_, job_id, _)| *job_id == id) else {
+            return (None, None)
+        };
         let (fut, keep_alive) = self.payload_jobs[job].0.resolve_kind(kind);
         let payload_timestamp = self.payload_jobs[job].0.payload_timestamp();
 
-        if keep_alive == KeepPayloadJobAlive::No {
-            let (_, id, _) = self.payload_jobs.swap_remove(job);
-            debug!(target: "payload_builder", %id, "terminated resolved job");
-        }
+        let resolved_job =
+            (keep_alive == KeepPayloadJobAlive::No).then(|| self.payload_jobs.swap_remove(job));
 
         // Since the fees will not be known until the payload future is resolved / awaited, we wrap
         // the future in a new future that will update the metrics.
@@ -357,7 +361,7 @@ where
             res.map(|p| p.into())
         };
 
-        Some(Box::pin(fut))
+        (Some(Box::pin(fut)), resolved_job)
     }
 
     /// Returns the payload timestamp for the given payload.
@@ -491,7 +495,12 @@ where
                         let _ = tx.send(timestamp);
                     }
                     PayloadServiceCommand::Resolve(id, strategy, tx) => {
-                        let _ = tx.send(this.resolve(id, strategy));
+                        let (payload_fut, resolved_job) = this.resolve(id, strategy);
+                        let _ = tx.send(payload_fut);
+
+                        if let Some((_job, id, _job_span)) = resolved_job {
+                            debug!(target: "payload_builder", %id, "terminated resolved job");
+                        }
                     }
                     PayloadServiceCommand::Subscribe(tx) => {
                         let new_rx = this.payload_events.subscribe();
diff --git a/crates/payload/builder/src/test_utils.rs b/crates/payload/builder/src/test_utils.rs
index 0829eea133a..eb48312752c 100644
--- a/crates/payload/builder/src/test_utils.rs
+++ b/crates/payload/builder/src/test_utils.rs
@@ -12,7 +12,7 @@ use reth_chain_state::CanonStateNotification;
 use reth_ethereum_engine_primitives::EthPayloadAttributes;
 use reth_payload_builder_primitives::PayloadBuilderError;
 use reth_payload_primitives::{PayloadKind, PayloadTypes};
-use reth_primitives_traits::Block as _;
+use reth_primitives_traits::{Block as _, RecoveredBlock};
 use std::{
     future::Future,
     pin::Pin,
@@ -86,7 +86,7 @@ impl PayloadJob for TestPayloadJob {
 
     fn best_payload(&self) -> Result<EthBuiltPayload, PayloadBuilderError> {
         Ok(EthBuiltPayload::new(
-            Arc::new(Block::<_>::default().seal_slow()),
+            Arc::new(RecoveredBlock::new_sealed(Block::<_>::default().seal_slow(), vec![])),
             U256::ZERO,
             Some(Default::default()),
             None,
diff --git a/crates/payload/primitives/Cargo.toml b/crates/payload/primitives/Cargo.toml
index 4cacba280cc..e47b5afad98 100644
--- a/crates/payload/primitives/Cargo.toml
+++ b/crates/payload/primitives/Cargo.toml
@@ -16,7 +16,6 @@ workspace = true
 reth-primitives-traits.workspace = true
 reth-chainspec.workspace = true
 reth-errors.workspace = true
-reth-chain-state.workspace = true
 reth-execution-types.workspace = true
 reth-trie-common.workspace = true
 
diff --git a/crates/payload/primitives/src/lib.rs b/crates/payload/primitives/src/lib.rs
index 4123f4ea168..946284961b2 100644
--- a/crates/payload/primitives/src/lib.rs
+++ b/crates/payload/primitives/src/lib.rs
@@ -38,7 +38,7 @@ pub trait PayloadTypes: Send + Sync + Unpin + core::fmt::Debug + Clone + 'static
     ///
     /// This type represents the canonical format for block data that includes
     /// all necessary information for execution and validation.
-    type ExecutionData: ExecutionPayload;
+    type ExecutionData: ExecutionPayload + From<Self::BuiltPayload>;
     /// The type representing a successfully built payload/block.
     type BuiltPayload: BuiltPayload + Clone + Unpin;
 
@@ -53,6 +53,7 @@ pub trait PayloadTypes: Send + Sync + Unpin + core::fmt::Debug + Clone + 'static
         block: SealedBlock<
             <<Self::BuiltPayload as BuiltPayload>::Primitives as NodePrimitives>::Block,
         >,
+        bal: Option<Bytes>,
     ) -> Self::ExecutionData;
 }
 
diff --git a/crates/payload/primitives/src/payload.rs b/crates/payload/primitives/src/payload.rs
index 20468d08879..294b789565d 100644
--- a/crates/payload/primitives/src/payload.rs
+++ b/crates/payload/primitives/src/payload.rs
@@ -189,6 +189,14 @@ where
             Self::PayloadAttributes(attributes) => attributes.slot_number(),
         }
     }
+
+    /// Returns `target_gas_limit` from payload attributes.
+    pub fn target_gas_limit(&self) -> Option<u64> {
+        match self {
+            Self::ExecutionPayload(_) => None,
+            Self::PayloadAttributes(attributes) => attributes.target_gas_limit(),
+        }
+    }
 }
 
 impl<'a, Payload, AttributesType> From<&'a AttributesType>
diff --git a/crates/payload/primitives/src/traits.rs b/crates/payload/primitives/src/traits.rs
index c031b604f53..9b9ca191048 100644
--- a/crates/payload/primitives/src/traits.rs
+++ b/crates/payload/primitives/src/traits.rs
@@ -3,18 +3,14 @@
 use crate::PayloadBuilderError;
 use alloc::{boxed::Box, sync::Arc, vec::Vec};
 use alloy_eips::{eip4895::Withdrawal, eip7685::Requests};
-use alloy_primitives::{B256, U256};
+use alloy_primitives::{Bytes, B256, U256};
 use alloy_rlp::Encodable;
 use alloy_rpc_types_engine::{PayloadAttributes as EthPayloadAttributes, PayloadId};
 use core::fmt;
 use either::Either;
-use reth_chain_state::ComputedTrieData;
 use reth_execution_types::BlockExecutionOutput;
 use reth_primitives_traits::{NodePrimitives, RecoveredBlock, SealedBlock, SealedHeader};
-use reth_trie_common::{
-    updates::{TrieUpdates, TrieUpdatesSorted},
-    HashedPostState, HashedPostStateSorted,
-};
+use reth_trie_common::{updates::TrieUpdates, HashedPostState};
 
 /// Represents an executed block for payload building purposes.
 ///
@@ -26,44 +22,10 @@ pub struct BuiltPayloadExecutedBlock<N: NodePrimitives> {
     pub recovered_block: Arc<RecoveredBlock<N::Block>>,
     /// Block's execution outcome.
     pub execution_output: Arc<BlockExecutionOutput<N::Receipt>>,
-    /// Block's hashed state.
-    ///
-    /// Supports both unsorted and sorted variants so payload builders can avoid cloning in order
-    /// to convert from one to the other when it's not necessary.
-    pub hashed_state: Either<Arc<HashedPostState>, Arc<HashedPostStateSorted>>,
-    /// Trie updates that result from calculating the state root for the block.
-    ///
-    /// Supports both unsorted and sorted variants so payload builders can avoid cloning in order
-    /// to convert from one to the other when it's not necessary.
-    pub trie_updates: Either<Arc<TrieUpdates>, Arc<TrieUpdatesSorted>>,
-}
-
-impl<N: NodePrimitives> BuiltPayloadExecutedBlock<N> {
-    /// Converts this into an [`reth_chain_state::ExecutedBlock`].
-    ///
-    /// Ensures hashed state and trie updates are in their sorted representations
-    /// as required by `reth_chain_state::ExecutedBlock`.
-    pub fn into_executed_payload(self) -> reth_chain_state::ExecutedBlock<N> {
-        let hashed_state = match self.hashed_state {
-            // Convert unsorted to sorted
-            Either::Left(unsorted) => Arc::new(Arc::unwrap_or_clone(unsorted).into_sorted()),
-            // Already sorted
-            Either::Right(sorted) => sorted,
-        };
-
-        let trie_updates = match self.trie_updates {
-            // Convert unsorted to sorted
-            Either::Left(unsorted) => Arc::new(Arc::unwrap_or_clone(unsorted).into_sorted()),
-            // Already sorted
-            Either::Right(sorted) => sorted,
-        };
-
-        reth_chain_state::ExecutedBlock::new(
-            self.recovered_block,
-            self.execution_output,
-            ComputedTrieData::without_trie_input(hashed_state, trie_updates),
-        )
-    }
+    /// Block's hashed state (unsorted).
+    pub hashed_state: Arc<HashedPostState>,
+    /// Trie updates that result from calculating the state root for the block (unsorted).
+    pub trie_updates: Arc<TrieUpdates>,
 }
 
 /// Represents a successfully built execution payload (block).
@@ -81,6 +43,13 @@ pub trait BuiltPayload: Send + Sync + fmt::Debug {
     /// Returns the total fees collected from all transactions in this block.
     fn fees(&self) -> U256;
 
+    /// Returns the EIP-7928 block access list included in this payload.
+    ///
+    /// Returns `None` for payloads that do not carry a block access list.
+    fn block_access_list(&self) -> Option<&Bytes> {
+        None
+    }
+
     /// Returns the complete execution result including state updates.
     ///
     /// Returns `None` if execution data is not available or not tracked.
@@ -122,6 +91,14 @@ pub trait PayloadAttributes:
     ///
     /// `Some` for post-Amsterdam blocks, `None` for earlier blocks.
     fn slot_number(&self) -> Option<u64>;
+
+    /// Returns the target gas limit for the new payload.
+    ///
+    /// `Some` for payload attributes that specify the desired gas limit, `None` if the builder
+    /// should use its configured target.
+    fn target_gas_limit(&self) -> Option<u64> {
+        None
+    }
 }
 
 impl PayloadAttributes for EthPayloadAttributes {
@@ -144,6 +121,10 @@ impl PayloadAttributes for EthPayloadAttributes {
     fn slot_number(&self) -> Option<u64> {
         self.slot_number
     }
+
+    fn target_gas_limit(&self) -> Option<u64> {
+        None
+    }
 }
 
 /// Factory trait for creating payload attributes.
diff --git a/crates/prune/prune/Cargo.toml b/crates/prune/prune/Cargo.toml
index d86a35eaf14..09d867f5c6a 100644
--- a/crates/prune/prune/Cargo.toml
+++ b/crates/prune/prune/Cargo.toml
@@ -27,7 +27,6 @@ reth-static-file-types.workspace = true
 
 # ethereum
 alloy-consensus.workspace = true
-alloy-eips.workspace = true
 
 # metrics
 reth-metrics.workspace = true
diff --git a/crates/prune/prune/src/builder.rs b/crates/prune/prune/src/builder.rs
index 33c8706de8c..d30f053939d 100644
--- a/crates/prune/prune/src/builder.rs
+++ b/crates/prune/prune/src/builder.rs
@@ -1,5 +1,4 @@
 use crate::{segments::SegmentSet, Pruner};
-use alloy_eips::eip2718::Encodable2718;
 use reth_config::PruneConfig;
 use reth_db_api::{table::Value, transaction::DbTxMut};
 use reth_exex_types::FinishedExExHeight;
@@ -86,7 +85,7 @@ impl PrunerBuilder {
         PF: DatabaseProviderFactory<
                 ProviderRW: PruneCheckpointWriter
                                 + PruneCheckpointReader
-                                + BlockReader<Transaction: Encodable2718>
+                                + BlockReader
                                 + ChainStateBlockReader
                                 + StorageSettingsCache
                                 + StageCheckpointReader
@@ -126,7 +125,7 @@ impl PrunerBuilder {
         Provider: StaticFileProviderFactory<
                 Primitives: NodePrimitives<SignedTx: Value, Receipt: Value, BlockHeader: Value>,
             > + DBProvider<Tx: DbTxMut>
-            + BlockReader<Transaction: Encodable2718>
+            + BlockReader
             + ChainStateBlockReader
             + PruneCheckpointWriter
             + PruneCheckpointReader
diff --git a/crates/prune/prune/src/segments/set.rs b/crates/prune/prune/src/segments/set.rs
index 1722d015b51..d4541393b66 100644
--- a/crates/prune/prune/src/segments/set.rs
+++ b/crates/prune/prune/src/segments/set.rs
@@ -2,7 +2,6 @@ use crate::segments::{
     user::ReceiptsByLogs, AccountHistory, Bodies, Segment, SenderRecovery, StorageHistory,
     TransactionLookup, UserReceipts,
 };
-use alloy_eips::eip2718::Encodable2718;
 use reth_db_api::{table::Value, transaction::DbTxMut};
 use reth_primitives_traits::NodePrimitives;
 use reth_provider::{
@@ -52,7 +51,7 @@ where
         > + DBProvider<Tx: DbTxMut>
         + PruneCheckpointWriter
         + PruneCheckpointReader
-        + BlockReader<Transaction: Encodable2718>
+        + BlockReader
         + ChainStateBlockReader
         + StorageSettingsCache
         + ChangeSetReader
diff --git a/crates/prune/prune/src/segments/user/transaction_lookup.rs b/crates/prune/prune/src/segments/user/transaction_lookup.rs
index 41d9ffae352..8ff58834744 100644
--- a/crates/prune/prune/src/segments/user/transaction_lookup.rs
+++ b/crates/prune/prune/src/segments/user/transaction_lookup.rs
@@ -3,9 +3,10 @@ use crate::{
     segments::{PruneInput, Segment, SegmentOutput},
     PrunerError,
 };
-use alloy_eips::eip2718::Encodable2718;
+use alloy_consensus::transaction::TxHashRef;
 use rayon::prelude::*;
 use reth_db_api::{tables, transaction::DbTxMut};
+use reth_primitives_traits::SignedTransaction;
 use reth_provider::{
     BlockReader, DBProvider, PruneCheckpointReader, RocksDBProviderFactory,
     StaticFileProviderFactory,
@@ -31,7 +32,7 @@ impl TransactionLookup {
 impl<Provider> Segment<Provider> for TransactionLookup
 where
     Provider: DBProvider<Tx: DbTxMut>
-        + BlockReader<Transaction: Encodable2718>
+        + BlockReader<Transaction: SignedTransaction>
         + PruneCheckpointReader
         + StaticFileProviderFactory
         + StorageSettingsCache
@@ -131,11 +132,11 @@ where
                 .unwrap();
         let tx_range_end = *tx_range.end();
 
-        // Retrieve transactions in the range and calculate their hashes in parallel
+        // Retrieve transactions in the range and collect their hashes in parallel.
         let mut hashes = provider
             .transactions_by_tx_range(tx_range.clone())?
             .into_par_iter()
-            .map(|transaction| transaction.trie_hash())
+            .map(|transaction| *transaction.tx_hash())
             .collect::<Vec<_>>();
 
         // Sort hashes to enable efficient cursor traversal through the TransactionHashNumbers
@@ -204,7 +205,7 @@ impl TransactionLookup {
     ) -> Result<SegmentOutput, PrunerError>
     where
         Provider: DBProvider
-            + BlockReader<Transaction: Encodable2718>
+            + BlockReader<Transaction: SignedTransaction>
             + StaticFileProviderFactory
             + RocksDBProviderFactory,
     {
@@ -235,11 +236,11 @@ impl TransactionLookup {
             .map_or(end, |limited| limited.min(end));
         let tx_range = start..=tx_range_end;
 
-        // Retrieve transactions in the range and calculate their hashes in parallel
+        // Retrieve transactions in the range and collect their hashes in parallel.
         let hashes: Vec<_> = provider
             .transactions_by_tx_range(tx_range.clone())?
             .into_par_iter()
-            .map(|transaction| transaction.trie_hash())
+            .map(|transaction| *transaction.tx_hash())
             .collect();
 
         // Number of transactions retrieved from the database should match the tx range count
diff --git a/crates/revm/src/cached.rs b/crates/revm/src/cached.rs
index b5fd4d5dcc5..8b87aa10ba2 100644
--- a/crates/revm/src/cached.rs
+++ b/crates/revm/src/cached.rs
@@ -41,6 +41,14 @@ pub struct CachedReads {
 // === impl CachedReads ===
 
 impl CachedReads {
+    /// Creates a new [`CachedReads`] with capacity for account entries.
+    pub fn with_account_capacity(capacity: usize) -> Self {
+        Self {
+            accounts: AddressMap::with_capacity_and_hasher(capacity, Default::default()),
+            ..Default::default()
+        }
+    }
+
     /// Gets a [`DatabaseRef`] that will cache reads from the given database.
     pub const fn as_db<DB>(&mut self, db: DB) -> CachedReadsDBRef<'_, DB> {
         self.as_db_mut(db).into_db()
diff --git a/crates/rpc/ipc/src/server/mod.rs b/crates/rpc/ipc/src/server/mod.rs
index d160647675f..b0d09b89b42 100644
--- a/crates/rpc/ipc/src/server/mod.rs
+++ b/crates/rpc/ipc/src/server/mod.rs
@@ -9,7 +9,10 @@ use interprocess::local_socket::{
     GenericFilePath, ListenerOptions, ToFsName,
 };
 use jsonrpsee::{
-    core::{middleware::layer::RpcLoggerLayer, JsonRawValue, TEN_MB_SIZE_BYTES},
+    core::{
+        middleware::layer::{Either as RpcEither, RpcLoggerLayer},
+        JsonRawValue, TEN_MB_SIZE_BYTES,
+    },
     server::{
         middleware::rpc::RpcServiceT, stop_channel, ConnectionGuard, ConnectionPermit, IdProvider,
         RandomIntegerIdProvider, ServerHandle, StopHandle,
@@ -316,11 +319,11 @@ impl<L> RpcServiceBuilder<L> {
     pub fn option_layer<T>(
         self,
         layer: Option<T>,
-    ) -> RpcServiceBuilder<Stack<Either<T, Identity>, L>> {
+    ) -> RpcServiceBuilder<Stack<RpcEither<T, Identity>, L>> {
         let layer = if let Some(layer) = layer {
-            Either::Left(layer)
+            RpcEither::Left(layer)
         } else {
-            Either::Right(Identity::new())
+            RpcEither::Right(Identity::new())
         };
         self.layer(layer)
     }
diff --git a/crates/rpc/rpc-api/src/debug.rs b/crates/rpc/rpc-api/src/debug.rs
index a9d8b32009a..d4a2995804e 100644
--- a/crates/rpc/rpc-api/src/debug.rs
+++ b/crates/rpc/rpc-api/src/debug.rs
@@ -3,7 +3,7 @@ use alloy_genesis::ChainConfig;
 use alloy_json_rpc::RpcObject;
 use alloy_primitives::{Address, Bytes, B256, U64};
 use alloy_rpc_types_debug::ExecutionWitness;
-use alloy_rpc_types_eth::{Bundle, StateContext};
+use alloy_rpc_types_eth::{Account, AccountInfo, Bundle, Index, StateContext};
 use alloy_rpc_types_trace::geth::{
     BlockTraceResult, GethDebugTracingCallOptions, GethDebugTracingOptions, GethTrace, TraceResult,
 };
@@ -162,11 +162,25 @@ pub trait DebugApi<TxReq: RpcObject> {
         mode: Option<ExecutionWitnessMode>,
     ) -> RpcResult<ExecutionWitness>;
 
-    /// Sets the logging backtrace location. When a backtrace location is set and a log message is
-    /// emitted at that location, the stack of the goroutine executing the log statement will
-    /// be printed to stderr.
-    #[method(name = "backtraceAt")]
-    async fn debug_backtrace_at(&self, location: &str) -> RpcResult<()>;
+    /// Returns account information, including the storage root, at the state after executing the
+    /// transaction with the given index in the block.
+    #[method(name = "accountAt")]
+    async fn debug_account_at(
+        &self,
+        block_id: BlockId,
+        tx_index: Index,
+        address: Address,
+    ) -> RpcResult<Option<Account>>;
+
+    /// Returns account information at the state after executing the transaction with the given
+    /// index in the block.
+    #[method(name = "accountInfoAt")]
+    async fn debug_account_info_at(
+        &self,
+        block_id: BlockId,
+        tx_index: Index,
+        address: Address,
+    ) -> RpcResult<Option<AccountInfo>>;
 
     /// Enumerates all accounts at a given block with paging capability. `maxResults` are returned
     /// in the page and the items have keys that come after the `start` key (hashed address).
@@ -184,12 +198,6 @@ pub trait DebugApi<TxReq: RpcObject> {
         incompletes: bool,
     ) -> RpcResult<()>;
 
-    /// Turns on block profiling for the given duration and writes profile data to disk. It uses a
-    /// profile rate of 1 for most accurate information. If a different rate is desired, set the
-    /// rate and write the profile manually using `debug_writeBlockProfile`.
-    #[method(name = "blockProfile")]
-    async fn debug_block_profile(&self, file: String, seconds: u64) -> RpcResult<()>;
-
     /// Flattens the entire key-value database into a single level, removing all unused slots and
     /// merging all keys.
     #[method(name = "chaindbCompact")]
@@ -212,10 +220,6 @@ pub trait DebugApi<TxReq: RpcObject> {
         block_id: Option<BlockId>,
     ) -> RpcResult<Option<Bytes>>;
 
-    /// Turns on CPU profiling for the given duration and writes profile data to disk.
-    #[method(name = "cpuProfile")]
-    async fn debug_cpu_profile(&self, file: String, seconds: u64) -> RpcResult<()>;
-
     /// Retrieves an ancient binary blob from the freezer. The freezer is a collection of
     /// append-only immutable files. The first argument `kind` specifies which table to look up data
     /// from. The list of all table kinds are as follows:
@@ -239,10 +243,6 @@ pub trait DebugApi<TxReq: RpcObject> {
     #[method(name = "freeOSMemory")]
     async fn debug_free_os_memory(&self) -> RpcResult<()>;
 
-    /// Forces a temporary client freeze, normally when the server is overloaded.
-    #[method(name = "freezeClient")]
-    async fn debug_freeze_client(&self, node: String) -> RpcResult<()>;
-
     /// Returns garbage collection statistics.
     #[method(name = "gcStats")]
     async fn debug_gc_stats(&self) -> RpcResult<()>;
@@ -278,10 +278,6 @@ pub trait DebugApi<TxReq: RpcObject> {
         end_number: u64,
     ) -> RpcResult<()>;
 
-    /// Turns on Go runtime tracing for the given duration and writes trace data to disk.
-    #[method(name = "goTrace")]
-    async fn debug_go_trace(&self, file: String, seconds: u64) -> RpcResult<()>;
-
     /// Executes a block (bad- or canon- or side-), and returns a list of intermediate roots: the
     /// stateroot after each transaction.
     #[method(name = "intermediateRoots")]
@@ -295,12 +291,6 @@ pub trait DebugApi<TxReq: RpcObject> {
     #[method(name = "memStats")]
     async fn debug_mem_stats(&self) -> RpcResult<()>;
 
-    /// Turns on mutex profiling for `nsec` seconds and writes profile data to file. It uses a
-    /// profile rate of 1 for most accurate information. If a different rate is desired, set the
-    /// rate and write the profile manually.
-    #[method(name = "mutexProfile")]
-    async fn debug_mutex_profile(&self, file: String, nsec: u64) -> RpcResult<()>;
-
     /// Returns the preimage for a sha3 hash, if known.
     #[method(name = "preimage")]
     async fn debug_preimage(&self, hash: B256) -> RpcResult<()>;
@@ -313,12 +303,6 @@ pub trait DebugApi<TxReq: RpcObject> {
     #[method(name = "seedHash")]
     async fn debug_seed_hash(&self, number: u64) -> RpcResult<B256>;
 
-    /// Sets the rate (in samples/sec) of goroutine block profile data collection. A non-zero rate
-    /// enables block profiling, setting it to zero stops the profile. Collected profile data can be
-    /// written using `debug_writeBlockProfile`.
-    #[method(name = "setBlockProfileRate")]
-    async fn debug_set_block_profile_rate(&self, rate: u64) -> RpcResult<()>;
-
     /// Sets the garbage collection target percentage. A negative value disables garbage collection.
     #[method(name = "setGCPercent")]
     async fn debug_set_gc_percent(&self, v: i32) -> RpcResult<()>;
@@ -328,20 +312,12 @@ pub trait DebugApi<TxReq: RpcObject> {
     #[method(name = "setHead")]
     async fn debug_set_head(&self, number: U64) -> RpcResult<()>;
 
-    /// Sets the rate of mutex profiling.
-    #[method(name = "setMutexProfileFraction")]
-    async fn debug_set_mutex_profile_fraction(&self, rate: i32) -> RpcResult<()>;
-
     /// Configures how often in-memory state tries are persisted to disk. The interval needs to be
     /// in a format parsable by a time.Duration. Note that the interval is not wall-clock time.
     /// Rather it is accumulated block processing time after which the state should be flushed.
     #[method(name = "setTrieFlushInterval")]
     async fn debug_set_trie_flush_interval(&self, interval: String) -> RpcResult<()>;
 
-    /// Returns a printed representation of the stacks of all goroutines.
-    #[method(name = "stacks")]
-    async fn debug_stacks(&self) -> RpcResult<()>;
-
     /// Used to obtain info about a block.
     #[method(name = "standardTraceBadBlockToFile")]
     async fn debug_standard_trace_bad_block_to_file(
@@ -359,14 +335,6 @@ pub trait DebugApi<TxReq: RpcObject> {
         opts: Option<GethDebugTracingCallOptions>,
     ) -> RpcResult<()>;
 
-    /// Turns on CPU profiling indefinitely, writing to the given file.
-    #[method(name = "startCPUProfile")]
-    async fn debug_start_cpu_profile(&self, file: String) -> RpcResult<()>;
-
-    /// Starts writing a Go runtime trace to the given file.
-    #[method(name = "startGoTrace")]
-    async fn debug_start_go_trace(&self, file: String) -> RpcResult<()>;
-
     /// Returns the state root of the `HashedPostState` on top of the state for the given block with
     /// trie updates.
     #[method(name = "stateRootWithUpdates")]
@@ -376,14 +344,6 @@ pub trait DebugApi<TxReq: RpcObject> {
         block_id: Option<BlockId>,
     ) -> RpcResult<(B256, TrieUpdates)>;
 
-    /// Stops an ongoing CPU profile.
-    #[method(name = "stopCPUProfile")]
-    async fn debug_stop_cpu_profile(&self) -> RpcResult<()>;
-
-    /// Stops writing the Go runtime trace.
-    #[method(name = "stopGoTrace")]
-    async fn debug_stop_go_trace(&self) -> RpcResult<()>;
-
     /// Returns the storage at the given block height and transaction index. The result can be
     /// paged by providing a `maxResult` to cap the number of storage slots returned as well as
     /// specifying the offset via `keyStart` (hash of storage key).
@@ -406,48 +366,4 @@ pub trait DebugApi<TxReq: RpcObject> {
         block_hash: B256,
         opts: Option<GethDebugTracingCallOptions>,
     ) -> RpcResult<Vec<TraceResult>>;
-
-    /// Sets the logging verbosity ceiling. Log messages with level up to and including the given
-    /// level will be printed.
-    #[method(name = "verbosity")]
-    async fn debug_verbosity(&self, level: usize) -> RpcResult<()>;
-
-    /// Sets the logging verbosity pattern.
-    #[method(name = "vmodule")]
-    async fn debug_vmodule(&self, pattern: String) -> RpcResult<()>;
-
-    /// Writes a goroutine blocking profile to the given file.
-    #[method(name = "writeBlockProfile")]
-    async fn debug_write_block_profile(&self, file: String) -> RpcResult<()>;
-
-    /// Writes an allocation profile to the given file.
-    #[method(name = "writeMemProfile")]
-    async fn debug_write_mem_profile(&self, file: String) -> RpcResult<()>;
-
-    /// Writes a goroutine blocking profile to the given file.
-    #[method(name = "writeMutexProfile")]
-    async fn debug_write_mutex_profile(&self, file: String) -> RpcResult<()>;
-}
-
-/// An extension to the `debug_` namespace that provides additional methods for retrieving
-/// witnesses.
-///
-/// This is separate from the regular `debug_` api, because this depends on the network specific
-/// params. For optimism this will expect the optimism specific payload attributes
-#[cfg_attr(not(feature = "client"), rpc(server, namespace = "debug"))]
-#[cfg_attr(feature = "client", rpc(server, client, namespace = "debug"))]
-pub trait DebugExecutionWitnessApi<Attributes> {
-    /// The `debug_executePayload` method allows for re-execution of a group of transactions with
-    /// the purpose of generating an execution witness. The witness comprises of a map of all
-    /// hashed trie nodes to their preimages that were required during the execution of the block,
-    /// including during state root recomputation.
-    ///
-    /// The first argument is the parent block hash. The second argument is the payload
-    /// attributes for the new block.
-    #[method(name = "executePayload")]
-    async fn execute_payload(
-        &self,
-        parent_block_hash: B256,
-        attributes: Attributes,
-    ) -> RpcResult<ExecutionWitness>;
 }
diff --git a/crates/rpc/rpc-api/src/engine.rs b/crates/rpc/rpc-api/src/engine.rs
index b34a7934f9c..b19bd53475d 100644
--- a/crates/rpc/rpc-api/src/engine.rs
+++ b/crates/rpc/rpc-api/src/engine.rs
@@ -133,12 +133,22 @@ pub trait EngineApi<Engine: EngineTypes> {
     /// `slotNumber` field in the `payloadAttributes`, if payload attributes
     /// are provided.
     ///
+    /// `custody_columns` maps to the third positional JSON-RPC parameter, `custodyColumns`,
+    /// the custody-column bitmask used for [EIP-8070] sparse blobpool signaling. It is
+    /// `DATA|null` and must be 16 bytes when set. When calling `engine_forkchoiceUpdatedV4`
+    /// with custody columns but without payload attributes, the second parameter must still
+    /// be supplied as `null`, for example:
+    /// `[forkchoiceState, null, custodyColumns]`.
+    ///
+    /// [EIP-8070]: https://eips.ethereum.org/EIPS/eip-8070
+    ///
     /// See also <https://github.com/ethereum/execution-apis/blob/main/src/engine/amsterdam.md#engine_forkchoiceupdatedv4>
     #[method(name = "forkchoiceUpdatedV4")]
     async fn fork_choice_updated_v4(
         &self,
         fork_choice_state: ForkchoiceState,
         payload_attributes: Option<Engine::PayloadAttributes>,
+        custody_columns: Option<B128>,
     ) -> RpcResult<ForkchoiceUpdated>;
 
     /// See also <https://github.com/ethereum/execution-apis/blob/6709c2a795b707202e93c4f2867fa0bf2640a84f/src/engine/paris.md#engine_getpayloadv1>
@@ -419,6 +429,10 @@ pub trait EngineEthApi<TxReq: RpcObject, B: RpcObject, R: RpcObject> {
         number: BlockNumberOrTag,
     ) -> RpcResult<Option<Value>>;
 
+    /// Returns the EIP-7928 block access list for a block by block id.
+    #[method(name = "getBlockAccessList")]
+    async fn block_access_list(&self, block_id: BlockId) -> RpcResult<Option<Value>>;
+
     /// Returns the EIP-7928 block access list bytes for a block by number.
     #[method(name = "getBlockAccessListRaw")]
     async fn block_access_list_raw(&self, block: BlockId) -> RpcResult<Option<Bytes>>;
diff --git a/crates/rpc/rpc-api/src/lib.rs b/crates/rpc/rpc-api/src/lib.rs
index 43dfc065e28..5a0c36be70b 100644
--- a/crates/rpc/rpc-api/src/lib.rs
+++ b/crates/rpc/rpc-api/src/lib.rs
@@ -41,8 +41,10 @@ pub use servers::*;
 pub mod servers {
     pub use crate::{
         admin::AdminApiServer,
-        debug::{DebugApiServer, DebugExecutionWitnessApiServer},
+        anvil::AnvilApiServer,
+        debug::DebugApiServer,
         engine::{EngineApiServer, EngineEthApiServer, IntoEngineApiRpcModule},
+        hardhat::HardhatApiServer,
         mev::{MevFullApiServer, MevSimApiServer},
         miner::MinerApiServer,
         net::NetApiServer,
@@ -72,7 +74,7 @@ pub mod clients {
     pub use crate::{
         admin::AdminApiClient,
         anvil::AnvilApiClient,
-        debug::{DebugApiClient, DebugExecutionWitnessApiClient},
+        debug::DebugApiClient,
         engine::{EngineApiClient, EngineEthApiClient},
         hardhat::HardhatApiClient,
         mev::{MevFullApiClient, MevSimApiClient},
diff --git a/crates/rpc/rpc-api/src/reth_engine.rs b/crates/rpc/rpc-api/src/reth_engine.rs
index b67f140c6a2..b8f52a2f8fb 100644
--- a/crates/rpc/rpc-api/src/reth_engine.rs
+++ b/crates/rpc/rpc-api/src/reth_engine.rs
@@ -3,7 +3,7 @@
 use alloy_primitives::Bytes;
 use alloy_rpc_types_engine::{ForkchoiceState, ForkchoiceUpdated, PayloadStatus};
 use jsonrpsee::{core::RpcResult, proc_macros::rpc};
-use serde::{Deserialize, Serialize};
+use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
 
 /// Reth-specific payload status that includes server-measured execution latency.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -30,14 +30,67 @@ pub struct RethPayloadStatus {
 }
 
 /// Input for `reth_newPayload` that accepts either `ExecutionData` directly or an RLP-encoded
-/// block.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(untagged)]
+/// block with optional side data.
+#[derive(Debug, Clone)]
 pub enum RethNewPayloadInput<ExecutionData> {
     /// Standard execution data (payload + sidecar).
     ExecutionData(ExecutionData),
-    /// An RLP-encoded block.
-    BlockRlp(Bytes),
+    /// An RLP-encoded block and optional encoded block access list.
+    BlockRlp {
+        /// RLP-encoded block bytes.
+        block: Bytes,
+        /// RLP-encoded block access list bytes.
+        bal: Option<Bytes>,
+    },
+}
+
+impl<ExecutionData> Serialize for RethNewPayloadInput<ExecutionData>
+where
+    ExecutionData: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            Self::ExecutionData(data) => data.serialize(serializer),
+            Self::BlockRlp { block, bal: None } => block.serialize(serializer),
+            Self::BlockRlp { block, bal: Some(bal) } => {
+                let mut state = serializer.serialize_struct("BlockRlp", 2)?;
+                state.serialize_field("block", block)?;
+                state.serialize_field("bal", bal)?;
+                state.end()
+            }
+        }
+    }
+}
+
+impl<'de, ExecutionData> Deserialize<'de> for RethNewPayloadInput<ExecutionData>
+where
+    ExecutionData: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        #[serde(untagged)]
+        enum RethNewPayloadInputSerde<ExecutionData> {
+            ExecutionData(ExecutionData),
+            BlockRlp {
+                block: Bytes,
+                #[serde(default)]
+                bal: Option<Bytes>,
+            },
+            LegacyBlockRlp(Bytes),
+        }
+
+        Ok(match RethNewPayloadInputSerde::deserialize(deserializer)? {
+            RethNewPayloadInputSerde::ExecutionData(data) => Self::ExecutionData(data),
+            RethNewPayloadInputSerde::BlockRlp { block, bal } => Self::BlockRlp { block, bal },
+            RethNewPayloadInputSerde::LegacyBlockRlp(block) => Self::BlockRlp { block, bal: None },
+        })
+    }
 }
 
 /// Reth-specific engine API extensions.
@@ -75,3 +128,76 @@ pub trait RethEngineApi<ExecutionData> {
         forkchoice_state: ForkchoiceState,
     ) -> RpcResult<ForkchoiceUpdated>;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::RethNewPayloadInput;
+    use alloy_primitives::Bytes;
+    use serde::{Deserialize, Serialize};
+    use serde_json::json;
+
+    #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+    struct TestExecutionData {
+        payload: Bytes,
+        sidecar: Bytes,
+    }
+
+    #[test]
+    fn block_rlp_serializes_named_fields() {
+        let input = RethNewPayloadInput::<TestExecutionData>::BlockRlp {
+            block: Bytes::from_static(&[1]),
+            bal: Some(Bytes::from_static(&[2])),
+        };
+
+        assert_eq!(serde_json::to_string(&input).unwrap(), r#"{"block":"0x01","bal":"0x02"}"#);
+        assert_eq!(serde_json::to_value(input).unwrap(), json!({ "block": "0x01", "bal": "0x02" }));
+    }
+
+    #[test]
+    fn block_rlp_without_bal_serializes_legacy_bytes_roundtrip() {
+        let input = RethNewPayloadInput::<TestExecutionData>::BlockRlp {
+            block: Bytes::from_static(&[1]),
+            bal: None,
+        };
+
+        let serialized = serde_json::to_string(&input).unwrap();
+        assert_eq!(serialized, r#""0x01""#);
+
+        let input =
+            serde_json::from_str::<RethNewPayloadInput<TestExecutionData>>(&serialized).unwrap();
+
+        let RethNewPayloadInput::BlockRlp { block, bal } = input else {
+            panic!("expected block rlp input")
+        };
+
+        assert_eq!(block, Bytes::from_static(&[1]));
+        assert_eq!(bal, None);
+    }
+
+    #[test]
+    fn block_rlp_deserializes_without_bal() {
+        let input =
+            serde_json::from_str::<RethNewPayloadInput<TestExecutionData>>(r#"{"block":"0x01"}"#)
+                .unwrap();
+
+        let RethNewPayloadInput::BlockRlp { block, bal } = input else {
+            panic!("expected block rlp input")
+        };
+
+        assert_eq!(block, Bytes::from_static(&[1]));
+        assert_eq!(bal, None);
+    }
+
+    #[test]
+    fn block_rlp_deserializes_legacy_bytes() {
+        let input = serde_json::from_value::<RethNewPayloadInput<TestExecutionData>>(json!("0x01"))
+            .unwrap();
+
+        let RethNewPayloadInput::BlockRlp { block, bal } = input else {
+            panic!("expected block rlp input")
+        };
+
+        assert_eq!(block, Bytes::from_static(&[1]));
+        assert_eq!(bal, None);
+    }
+}
diff --git a/crates/rpc/rpc-api/src/validation.rs b/crates/rpc/rpc-api/src/validation.rs
index 9ff47b5eaf2..dc374f7561b 100644
--- a/crates/rpc/rpc-api/src/validation.rs
+++ b/crates/rpc/rpc-api/src/validation.rs
@@ -3,7 +3,7 @@
 use alloy_rpc_types_beacon::relay::{
     BuilderBlockValidationRequest, BuilderBlockValidationRequestV2,
     BuilderBlockValidationRequestV3, BuilderBlockValidationRequestV4,
-    BuilderBlockValidationRequestV5,
+    BuilderBlockValidationRequestV5, BuilderBlockValidationRequestV6,
 };
 use jsonrpsee::proc_macros::rpc;
 
@@ -45,4 +45,11 @@ pub trait BlockSubmissionValidationApi {
         &self,
         request: BuilderBlockValidationRequestV5,
     ) -> jsonrpsee::core::RpcResult<()>;
+
+    /// A Request to validate a block submission.
+    #[method(name = "validateBuilderSubmissionV6")]
+    async fn validate_builder_submission_v6(
+        &self,
+        request: BuilderBlockValidationRequestV6,
+    ) -> jsonrpsee::core::RpcResult<()>;
 }
diff --git a/crates/rpc/rpc-builder/src/auth.rs b/crates/rpc/rpc-builder/src/auth.rs
index 8a4b83158dd..f4a71187114 100644
--- a/crates/rpc/rpc-builder/src/auth.rs
+++ b/crates/rpc/rpc-builder/src/auth.rs
@@ -455,6 +455,11 @@ impl AuthServerHandle {
         self.local_addr
     }
 
+    /// Returns the JWT secret used by the auth server.
+    pub const fn jwt_secret(&self) -> &JwtSecret {
+        &self.secret
+    }
+
     /// Tell the server to stop without waiting for the server to stop.
     pub fn stop(self) -> Result<(), AlreadyStoppedError> {
         if let Some(handle) = self.handle {
diff --git a/crates/rpc/rpc-builder/src/config.rs b/crates/rpc/rpc-builder/src/config.rs
index d89866c955f..6518ba6deac 100644
--- a/crates/rpc/rpc-builder/src/config.rs
+++ b/crates/rpc/rpc-builder/src/config.rs
@@ -57,6 +57,9 @@ pub trait RethRpcServerConfig {
     /// Creates the [`RpcServerConfig`] from cli args.
     fn rpc_server_config(&self) -> RpcServerConfig;
 
+    /// Returns whether built-in RPC request metrics are enabled.
+    fn rpc_metrics_enabled(&self) -> bool;
+
     /// Creates the [`AuthServerConfig`] from cli args.
     fn auth_server_config(&self, jwt_secret: JwtSecret) -> Result<AuthServerConfig, RpcError>;
 
@@ -101,6 +104,7 @@ impl RethRpcServerConfig for RpcServerArgs {
             .eth_proof_window(self.rpc_eth_proof_window)
             .rpc_gas_cap(self.rpc_gas_cap)
             .rpc_max_simulate_blocks(self.rpc_max_simulate_blocks)
+            .compute_state_root_for_eth_simulate(self.rpc_compute_state_root_for_eth_simulate)
             .state_cache(self.state_cache_config())
             .gpo_config(self.gas_price_oracle_config())
             .proof_permits(self.rpc_proof_permits)
@@ -122,6 +126,7 @@ impl RethRpcServerConfig for RpcServerArgs {
             max_blocks: self.rpc_state_cache.max_blocks,
             max_receipts: self.rpc_state_cache.max_receipts,
             max_headers: self.rpc_state_cache.max_headers,
+            max_bals: self.rpc_state_cache.max_bals,
             max_concurrent_db_requests: self.rpc_state_cache.max_concurrent_db_requests,
             max_cached_tx_hashes: self.rpc_state_cache.max_cached_tx_hashes,
         }
@@ -184,7 +189,9 @@ impl RethRpcServerConfig for RpcServerArgs {
     }
 
     fn rpc_server_config(&self) -> RpcServerConfig {
-        let mut config = RpcServerConfig::default().with_jwt_secret(self.rpc_secret_key());
+        let mut config = RpcServerConfig::default()
+            .with_jwt_secret(self.rpc_secret_key())
+            .with_rpc_metrics_enabled(self.rpc_metrics_enabled());
 
         if self.http_api.is_some() && !self.http {
             warn!(
@@ -226,6 +233,10 @@ impl RethRpcServerConfig for RpcServerArgs {
         config
     }
 
+    fn rpc_metrics_enabled(&self) -> bool {
+        !self.rpc_disable_metrics
+    }
+
     fn auth_server_config(&self, jwt_secret: JwtSecret) -> Result<AuthServerConfig, RpcError> {
         let address = SocketAddr::new(self.auth_addr, self.auth_port);
 
@@ -369,6 +380,15 @@ mod tests {
             SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8888))
         );
         assert_eq!(config.ipc_endpoint().unwrap(), constants::DEFAULT_IPC_ENDPOINT);
+        assert!(config.rpc_metrics_enabled());
+    }
+
+    #[test]
+    fn test_rpc_server_config_disable_metrics() {
+        let args =
+            CommandParser::<RpcServerArgs>::parse_from(["reth", "--rpc.disable-metrics"]).args;
+        let config = args.rpc_server_config();
+        assert!(!config.rpc_metrics_enabled());
     }
 
     #[test]
diff --git a/crates/rpc/rpc-builder/src/lib.rs b/crates/rpc/rpc-builder/src/lib.rs
index cee1daf4596..c3dd3392168 100644
--- a/crates/rpc/rpc-builder/src/lib.rs
+++ b/crates/rpc/rpc-builder/src/lib.rs
@@ -1104,6 +1104,8 @@ pub struct RpcServerConfig<RpcMiddleware = Identity> {
     ipc_endpoint: Option<String>,
     /// JWT secret for authentication
     jwt_secret: Option<JwtSecret>,
+    /// Whether RPC request metrics are enabled.
+    rpc_metrics_enabled: bool,
     /// Configurable RPC middleware
     rpc_middleware: RpcMiddleware,
 }
@@ -1124,6 +1126,7 @@ impl Default for RpcServerConfig<Identity> {
             ipc_server_config: None,
             ipc_endpoint: None,
             jwt_secret: None,
+            rpc_metrics_enabled: true,
             rpc_middleware: Default::default(),
         }
     }
@@ -1188,10 +1191,17 @@ impl<RpcMiddleware> RpcServerConfig<RpcMiddleware> {
             ipc_server_config: self.ipc_server_config,
             ipc_endpoint: self.ipc_endpoint,
             jwt_secret: self.jwt_secret,
+            rpc_metrics_enabled: self.rpc_metrics_enabled,
             rpc_middleware,
         }
     }
 
+    /// Configures whether the built-in RPC request metrics layer is enabled.
+    pub const fn with_rpc_metrics_enabled(mut self, enabled: bool) -> Self {
+        self.rpc_metrics_enabled = enabled;
+        self
+    }
+
     /// Configure the cors domains for http _and_ ws
     pub fn with_cors(self, cors_domain: Option<String>) -> Self {
         self.with_http_cors(cors_domain.clone()).with_ws_cors(cors_domain)
@@ -1308,6 +1318,11 @@ impl<RpcMiddleware> RpcServerConfig<RpcMiddleware> {
         self.ipc_endpoint.clone()
     }
 
+    /// Returns whether the built-in RPC request metrics layer is enabled.
+    pub const fn rpc_metrics_enabled(&self) -> bool {
+        self.rpc_metrics_enabled
+    }
+
     /// Creates the [`CorsLayer`] if any
     fn maybe_cors_layer(cors: Option<String>) -> Result<Option<CorsLayer>, CorsDomainError> {
         cors.as_deref().map(cors::create_cors_layer).transpose()
@@ -1351,13 +1366,19 @@ impl<RpcMiddleware> RpcServerConfig<RpcMiddleware> {
             constants::DEFAULT_WS_RPC_PORT,
         )));
 
-        let metrics = modules.ipc.as_ref().map(RpcRequestMetrics::ipc).unwrap_or_default();
+        let rpc_metrics_enabled = self.rpc_metrics_enabled;
         let ipc_path =
             self.ipc_endpoint.clone().unwrap_or_else(|| constants::DEFAULT_IPC_ENDPOINT.into());
 
         if let Some(builder) = self.ipc_server_config {
             let ipc = builder
-                .set_rpc_middleware(IpcRpcServiceBuilder::new().layer(metrics))
+                .set_rpc_middleware(
+                    IpcRpcServiceBuilder::new().option_layer(
+                        rpc_metrics_enabled
+                            .then(|| modules.ipc.as_ref().map(RpcRequestMetrics::ipc))
+                            .flatten(),
+                    ),
+                )
                 .build(ipc_path);
             ipc_handle = Some(ipc.start(modules.ipc.clone().expect("ipc server error")).await?);
         }
@@ -1397,13 +1418,16 @@ impl<RpcMiddleware> RpcServerConfig<RpcMiddleware> {
                     )
                     .set_rpc_middleware(
                         RpcServiceBuilder::default()
-                            .layer(
-                                modules
-                                    .http
-                                    .as_ref()
-                                    .or(modules.ws.as_ref())
-                                    .map(RpcRequestMetrics::same_port)
-                                    .unwrap_or_default(),
+                            .option_layer(
+                                rpc_metrics_enabled
+                                    .then(|| {
+                                        modules
+                                            .http
+                                            .as_ref()
+                                            .or(modules.ws.as_ref())
+                                            .map(RpcRequestMetrics::same_port)
+                                    })
+                                    .flatten(),
                             )
                             .layer(self.rpc_middleware.clone()),
                     )
@@ -1448,7 +1472,11 @@ impl<RpcMiddleware> RpcServerConfig<RpcMiddleware> {
                 )
                 .set_rpc_middleware(
                     RpcServiceBuilder::default()
-                        .layer(modules.ws.as_ref().map(RpcRequestMetrics::ws).unwrap_or_default())
+                        .option_layer(
+                            rpc_metrics_enabled
+                                .then(|| modules.ws.as_ref().map(RpcRequestMetrics::ws))
+                                .flatten(),
+                        )
                         .layer(self.rpc_middleware.clone()),
                 )
                 .build(ws_socket_addr)
@@ -1474,8 +1502,10 @@ impl<RpcMiddleware> RpcServerConfig<RpcMiddleware> {
                 )
                 .set_rpc_middleware(
                     RpcServiceBuilder::default()
-                        .layer(
-                            modules.http.as_ref().map(RpcRequestMetrics::http).unwrap_or_default(),
+                        .option_layer(
+                            rpc_metrics_enabled
+                                .then(|| modules.http.as_ref().map(RpcRequestMetrics::http))
+                                .flatten(),
                         )
                         .layer(self.rpc_middleware.clone()),
                 )
diff --git a/crates/rpc/rpc-builder/tests/it/http.rs b/crates/rpc/rpc-builder/tests/it/http.rs
index 120721a82f6..9270b46717d 100644
--- a/crates/rpc/rpc-builder/tests/it/http.rs
+++ b/crates/rpc/rpc-builder/tests/it/http.rs
@@ -319,6 +319,7 @@ where
         call_request.clone(),
         Some(block_number.into()),
         None,
+        None,
     )
     .await
     .unwrap_err();
@@ -446,6 +447,22 @@ where
     DebugApiClient::<TransactionRequest>::raw_transaction(client, B256::default()).await.unwrap();
     DebugApiClient::<TransactionRequest>::raw_receipts(client, block_id).await.unwrap_err();
     DebugApiClient::<TransactionRequest>::bad_blocks(client).await.unwrap();
+    DebugApiClient::<TransactionRequest>::debug_account_at(
+        client,
+        block_id,
+        Index::default(),
+        Address::default(),
+    )
+    .await
+    .unwrap_err();
+    DebugApiClient::<TransactionRequest>::debug_account_info_at(
+        client,
+        block_id,
+        Index::default(),
+        Address::default(),
+    )
+    .await
+    .unwrap_err();
 }
 
 async fn test_basic_net_calls<C>(client: &C)
diff --git a/crates/rpc/rpc-engine-api/src/capabilities.rs b/crates/rpc/rpc-engine-api/src/capabilities.rs
index 0f0987b09f3..6ac1c3b9c87 100644
--- a/crates/rpc/rpc-engine-api/src/capabilities.rs
+++ b/crates/rpc/rpc-engine-api/src/capabilities.rs
@@ -10,6 +10,10 @@ use tracing::warn;
 const CRITICAL_METHOD_PREFIXES: &[&str] =
     &["engine_forkchoiceUpdated", "engine_getPayload", "engine_newPayload"];
 
+/// Engine API methods for upcoming hardforks that should not warn while they are still unstable.
+const UNSTABLE_METHODS: &[&str] =
+    &["engine_forkchoiceUpdatedV4", "engine_getPayloadV6", "engine_newPayloadV5"];
+
 /// All Engine API capabilities supported by Reth (Ethereum mainnet).
 ///
 /// See <https://github.com/ethereum/execution-apis/tree/main/src/engine> for updates.
@@ -97,11 +101,19 @@ impl EngineCapabilities {
     pub fn log_capability_mismatches(&self, cl_capabilities: &[String]) {
         let mismatches = self.get_capability_mismatches(cl_capabilities);
 
-        let critical_missing_in_el: Vec<_> =
-            mismatches.missing_in_el.iter().filter(|m| is_critical_method(m)).cloned().collect();
+        let critical_missing_in_el: Vec<_> = mismatches
+            .missing_in_el
+            .iter()
+            .filter(|m| should_warn_for_method(m))
+            .cloned()
+            .collect();
 
-        let critical_missing_in_cl: Vec<_> =
-            mismatches.missing_in_cl.iter().filter(|m| is_critical_method(m)).cloned().collect();
+        let critical_missing_in_cl: Vec<_> = mismatches
+            .missing_in_cl
+            .iter()
+            .filter(|m| should_warn_for_method(m))
+            .cloned()
+            .collect();
 
         if !critical_missing_in_el.is_empty() {
             warn!(
@@ -131,6 +143,16 @@ fn is_critical_method(method: &str) -> bool {
     })
 }
 
+/// Returns `true` if the method should warn on a capability mismatch.
+fn should_warn_for_method(method: &str) -> bool {
+    is_critical_method(method) && !is_unstable_method(method)
+}
+
+/// Returns `true` if the method belongs to an upcoming, unstable Engine API fork.
+fn is_unstable_method(method: &str) -> bool {
+    UNSTABLE_METHODS.contains(&method)
+}
+
 impl Default for EngineCapabilities {
     fn default() -> Self {
         Self::new(CAPABILITIES.iter().copied())
@@ -212,10 +234,13 @@ mod tests {
     fn test_is_critical_method() {
         assert!(is_critical_method("engine_forkchoiceUpdatedV1"));
         assert!(is_critical_method("engine_forkchoiceUpdatedV3"));
+        assert!(is_critical_method("engine_forkchoiceUpdatedV4"));
         assert!(is_critical_method("engine_getPayloadV1"));
         assert!(is_critical_method("engine_getPayloadV4"));
+        assert!(is_critical_method("engine_getPayloadV6"));
         assert!(is_critical_method("engine_newPayloadV1"));
         assert!(is_critical_method("engine_newPayloadV4"));
+        assert!(is_critical_method("engine_newPayloadV5"));
 
         assert!(!is_critical_method("engine_getBlobsV1"));
         assert!(!is_critical_method("engine_getBlobsV3"));
@@ -224,4 +249,17 @@ mod tests {
         assert!(!is_critical_method("engine_getPayloadBodiesByRangeV1"));
         assert!(!is_critical_method("engine_getClientVersionV1"));
     }
+
+    #[test]
+    fn test_unstable_methods_do_not_warn() {
+        assert!(!should_warn_for_method("engine_forkchoiceUpdatedV4"));
+        assert!(!should_warn_for_method("engine_getPayloadV6"));
+        assert!(!should_warn_for_method("engine_newPayloadV5"));
+
+        assert!(should_warn_for_method("engine_forkchoiceUpdatedV3"));
+        assert!(should_warn_for_method("engine_getPayloadV5"));
+        assert!(should_warn_for_method("engine_newPayloadV4"));
+
+        assert!(!should_warn_for_method("engine_getBlobsV4"));
+    }
 }
diff --git a/crates/rpc/rpc-engine-api/src/engine_api.rs b/crates/rpc/rpc-engine-api/src/engine_api.rs
index e376c509a00..6dd6105d29f 100644
--- a/crates/rpc/rpc-engine-api/src/engine_api.rs
+++ b/crates/rpc/rpc-engine-api/src/engine_api.rs
@@ -7,7 +7,7 @@ use alloy_eips::{
     eip4895::Withdrawals,
     eip7685::RequestsOrHash,
 };
-use alloy_primitives::{BlockHash, BlockNumber, B128, B256, U64};
+use alloy_primitives::{BlockHash, BlockNumber, Bytes, Sealable, B128, B256, U64};
 use alloy_rpc_types_engine::{
     CancunPayloadFields, ClientVersionV1, ExecutionData, ExecutionPayloadBodiesV1,
     ExecutionPayloadBodiesV2, ExecutionPayloadBodyV1, ExecutionPayloadBodyV2,
@@ -19,7 +19,7 @@ use async_trait::async_trait;
 use jsonrpsee_core::{server::RpcModule, RpcResult};
 use reth_chainspec::EthereumHardforks;
 use reth_engine_primitives::{ConsensusEngineHandle, EngineApiValidator, EngineTypes};
-use reth_network_api::NetworkInfo;
+use reth_network_api::{CellCustody, NetworkInfo};
 use reth_payload_builder::PayloadStore;
 use reth_payload_primitives::{
     validate_payload_timestamp, EngineApiMessageVersion, MessageValidationKind,
@@ -27,7 +27,7 @@ use reth_payload_primitives::{
 };
 use reth_primitives_traits::{Block, BlockBody};
 use reth_rpc_api::{EngineApiServer, IntoEngineApiRpcModule};
-use reth_storage_api::{BlockReader, HeaderProvider, StateProviderFactory};
+use reth_storage_api::{BalProvider, BlockReader, HeaderProvider, StateProviderFactory};
 use reth_tasks::Runtime;
 use reth_transaction_pool::TransactionPool;
 use std::{
@@ -77,7 +77,7 @@ impl<Provider, PayloadT: PayloadTypes, Pool, Validator, ChainSpec>
 impl<Provider, PayloadT, Pool, Validator, ChainSpec>
     EngineApi<Provider, PayloadT, Pool, Validator, ChainSpec>
 where
-    Provider: HeaderProvider + BlockReader + StateProviderFactory + 'static,
+    Provider: HeaderProvider + BlockReader + StateProviderFactory + BalProvider + 'static,
     PayloadT: PayloadTypes,
     Pool: TransactionPool + 'static,
     Validator: EngineApiValidator<PayloadT>,
@@ -98,6 +98,7 @@ where
         accept_execution_requests_hash: bool,
         network: impl NetworkInfo + 'static,
     ) -> Self {
+        let cell_custody = network.cell_custody().clone();
         let is_syncing = Arc::new(move || network.is_syncing());
         let inner = Arc::new(EngineApiInner {
             provider,
@@ -111,6 +112,7 @@ where
             tx_pool,
             validator,
             accept_execution_requests_hash,
+            cell_custody,
             is_syncing,
         });
         Self { inner }
@@ -294,7 +296,7 @@ where
 impl<Provider, EngineT, Pool, Validator, ChainSpec>
     EngineApi<Provider, EngineT, Pool, Validator, ChainSpec>
 where
-    Provider: HeaderProvider + BlockReader + StateProviderFactory + 'static,
+    Provider: HeaderProvider + BlockReader + StateProviderFactory + BalProvider + 'static,
     EngineT: EngineTypes,
     Pool: TransactionPool + 'static,
     Validator: EngineApiValidator<EngineT>,
@@ -385,7 +387,11 @@ where
         &self,
         state: ForkchoiceState,
         payload_attrs: Option<EngineT::PayloadAttributes>,
+        custody_columns: Option<B128>,
     ) -> EngineApiResult<ForkchoiceUpdated> {
+        if let Some(custody_columns) = custody_columns {
+            self.inner.cell_custody.set(custody_columns);
+        }
         self.validate_and_execute_forkchoice(EngineApiMessageVersion::V4, state, payload_attrs)
             .await
     }
@@ -395,9 +401,10 @@ where
         &self,
         state: ForkchoiceState,
         payload_attrs: Option<EngineT::PayloadAttributes>,
+        custody_columns: Option<B128>,
     ) -> EngineApiResult<ForkchoiceUpdated> {
         let start = Instant::now();
-        let res = Self::fork_choice_updated_v4(self, state, payload_attrs).await;
+        let res = Self::fork_choice_updated_v4(self, state, payload_attrs, custody_columns).await;
         self.inner.metrics.latency.fork_choice_updated_v4.record(start.elapsed());
         res
     }
@@ -701,12 +708,40 @@ where
         start: BlockNumber,
         count: u64,
     ) -> EngineApiResult<ExecutionPayloadBodiesV2> {
-        self.get_payload_bodies_by_range_with(start, count, |block| ExecutionPayloadBodyV2 {
-            transactions: block.body().encoded_2718_transactions(),
-            withdrawals: block.body().withdrawals().cloned().map(Withdrawals::into_inner),
-            block_access_list: None,
-        })
-        .await
+        let mut payload_bodies = self
+            .get_payload_bodies_by_range_with(start, count, |block| {
+                let block_hash = block.header().hash_slow();
+                (
+                    block_hash,
+                    ExecutionPayloadBodyV2 {
+                        transactions: block.body().encoded_2718_transactions(),
+                        withdrawals: block
+                            .body()
+                            .withdrawals()
+                            .cloned()
+                            .map(Withdrawals::into_inner),
+                        block_access_list: None,
+                    },
+                )
+            })
+            .await?;
+
+        let block_hashes = payload_bodies
+            .iter()
+            .filter_map(|payload_body| payload_body.as_ref().map(|(block_hash, _)| *block_hash))
+            .collect::<Vec<_>>();
+        let block_access_lists = self.get_block_access_lists_by_hashes(block_hashes).await?;
+
+        for (payload_body, block_access_list) in
+            payload_bodies.iter_mut().filter_map(Option::as_mut).zip(block_access_lists)
+        {
+            payload_body.1.block_access_list = block_access_list;
+        }
+
+        Ok(payload_bodies
+            .into_iter()
+            .map(|payload_body| payload_body.map(|(_, payload_body)| payload_body))
+            .collect())
     }
 
     /// Metrics version of `get_payload_bodies_by_range_v2`
@@ -759,6 +794,30 @@ where
         rx.await.map_err(|err| EngineApiError::Internal(Box::new(err)))?
     }
 
+    async fn get_block_access_lists_by_hashes(
+        &self,
+        hashes: Vec<BlockHash>,
+    ) -> EngineApiResult<Vec<Option<Bytes>>> {
+        let len = hashes.len() as u64;
+        if len > MAX_PAYLOAD_BODIES_LIMIT {
+            return Err(EngineApiError::PayloadRequestTooLarge { len });
+        }
+
+        let (tx, rx) = oneshot::channel();
+        let bal_store = self.inner.provider.bal_store().clone();
+
+        self.inner.task_spawner.spawn_blocking_task(async move {
+            tx.send(
+                bal_store
+                    .get_by_hashes(&hashes)
+                    .map_err(|err| EngineApiError::Internal(Box::new(err))),
+            )
+            .ok();
+        });
+
+        rx.await.map_err(|err| EngineApiError::Internal(Box::new(err)))?
+    }
+
     /// Called to retrieve execution payload bodies by hashes.
     pub async fn get_payload_bodies_by_hash_v1(
         &self,
@@ -789,12 +848,23 @@ where
         &self,
         hashes: Vec<BlockHash>,
     ) -> EngineApiResult<ExecutionPayloadBodiesV2> {
-        self.get_payload_bodies_by_hash_with(hashes, |block| ExecutionPayloadBodyV2 {
-            transactions: block.body().encoded_2718_transactions(),
-            withdrawals: block.body().withdrawals().cloned().map(Withdrawals::into_inner),
-            block_access_list: None,
-        })
-        .await
+        let payload_bodies =
+            self.get_payload_bodies_by_hash_with(hashes.clone(), |block| ExecutionPayloadBodyV2 {
+                transactions: block.body().encoded_2718_transactions(),
+                withdrawals: block.body().withdrawals().cloned().map(Withdrawals::into_inner),
+                block_access_list: None,
+            });
+        let block_access_lists = self.get_block_access_lists_by_hashes(hashes);
+        let (mut payload_bodies, block_access_lists) =
+            tokio::try_join!(payload_bodies, block_access_lists)?;
+
+        for (payload_body, block_access_list) in payload_bodies.iter_mut().zip(block_access_lists) {
+            if let Some(payload_body) = payload_body {
+                payload_body.block_access_list = block_access_list;
+            }
+        }
+
+        Ok(payload_bodies)
     }
 
     /// Metrics version of `get_payload_bodies_by_hash_v2`
@@ -1067,7 +1137,7 @@ where
 impl<Provider, EngineT, Pool, Validator, ChainSpec> EngineApiServer<EngineT>
     for EngineApi<Provider, EngineT, Pool, Validator, ChainSpec>
 where
-    Provider: HeaderProvider + BlockReader + StateProviderFactory + 'static,
+    Provider: HeaderProvider + BlockReader + StateProviderFactory + BalProvider + 'static,
     EngineT: EngineTypes<ExecutionData = ExecutionData>,
     Pool: TransactionPool + 'static,
     Validator: EngineApiValidator<EngineT>,
@@ -1214,9 +1284,12 @@ where
         &self,
         fork_choice_state: ForkchoiceState,
         payload_attributes: Option<EngineT::PayloadAttributes>,
+        custody_columns: Option<B128>,
     ) -> RpcResult<ForkchoiceUpdated> {
         trace!(target: "rpc::engine", "Serving engine_forkchoiceUpdatedV4");
-        Ok(self.fork_choice_updated_v4_metered(fork_choice_state, payload_attributes).await?)
+        Ok(self
+            .fork_choice_updated_v4_metered(fork_choice_state, payload_attributes, custody_columns)
+            .await?)
     }
 
     /// Handler for `engine_getPayloadV1`
@@ -1308,7 +1381,7 @@ where
 
     /// Handler for `engine_getPayloadV6`
     ///
-    /// Post Amsterdam payload handler. Currently returns unsupported fork error.
+    /// Post-Amsterdam payload handler that includes Block Access Lists (BAL).
     ///
     /// See also <https://github.com/ethereum/execution-apis/blob/main/src/engine/amsterdam.md#engine_getpayloadv6>
     async fn get_payload_v6(
@@ -1491,6 +1564,8 @@ struct EngineApiInner<Provider, PayloadT: PayloadTypes, Pool, Validator, ChainSp
     /// Engine validator.
     validator: Validator,
     accept_execution_requests_hash: bool,
+    /// Shared blob cell custody bitmap.
+    cell_custody: CellCustody,
     /// Returns `true` if the node is currently syncing.
     is_syncing: Arc<dyn Fn() -> bool + Send + Sync>,
 }
@@ -1498,8 +1573,8 @@ struct EngineApiInner<Provider, PayloadT: PayloadTypes, Pool, Validator, ChainSp
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy_eips::eip7685::Requests;
-    use alloy_primitives::{Address, Bytes, B256};
+    use alloy_eips::{eip7685::Requests, NumHash};
+    use alloy_primitives::{keccak256, Address, Bytes, Sealed, B256};
     use alloy_rpc_types_engine::{
         ClientCode, ClientVersionV1, ExecutionPayloadV2, PayloadAttributes, PayloadStatusEnum,
     };
@@ -1513,7 +1588,7 @@ mod tests {
     };
     use reth_node_ethereum::EthereumEngineValidator;
     use reth_payload_builder::test_utils::spawn_test_payload_service;
-    use reth_provider::test_utils::MockEthProvider;
+    use reth_provider::{test_utils::MockEthProvider, BalStoreHandle, InMemoryBalStore};
     use reth_tasks::Runtime;
     use reth_transaction_pool::noop::NoopTransactionPool;
     use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};
@@ -1570,6 +1645,114 @@ mod tests {
         assert_eq!(res.unwrap(), vec![client]);
     }
 
+    #[tokio::test]
+    async fn get_payload_bodies_by_hash_v2_returns_block_access_list_from_store() {
+        let bal_store = BalStoreHandle::new(InMemoryBalStore::default());
+        let mut provider = MockEthProvider::default();
+        provider.bal_store = bal_store.clone();
+        let provider = Arc::new(provider);
+
+        let client = ClientVersionV1 {
+            code: ClientCode::RH,
+            name: "Reth".to_string(),
+            version: "v0.2.0-beta.5".to_string(),
+            commit: "defa64b2".to_string(),
+        };
+        let chain_spec: Arc<ChainSpec> = MAINNET.clone();
+        let payload_store = spawn_test_payload_service::<EthEngineTypes>();
+        let (to_engine, _engine_rx) = unbounded_channel();
+        let api = EngineApi::new(
+            provider.clone(),
+            chain_spec.clone(),
+            ConsensusEngineHandle::new(to_engine),
+            payload_store.into(),
+            NoopTransactionPool::default(),
+            Runtime::test(),
+            client,
+            EngineCapabilities::default(),
+            EthereumEngineValidator::new(chain_spec),
+            false,
+            NoopNetwork::default(),
+        );
+
+        let mut block = Block::default();
+        block.header.number = 1;
+        let block_hash = block.header.hash_slow();
+        provider.add_block(block_hash, block);
+
+        let mut block_without_bal = Block::default();
+        block_without_bal.header.number = 2;
+        let block_without_bal_hash = block_without_bal.header.hash_slow();
+        provider.add_block(block_without_bal_hash, block_without_bal);
+
+        let raw_bal = Bytes::from_static(&[alloy_rlp::EMPTY_LIST_CODE]);
+        let sealed_bal = Sealed::new_unchecked(raw_bal.clone(), keccak256(&raw_bal));
+        bal_store.insert(NumHash::new(1, block_hash), sealed_bal).unwrap();
+
+        let missing_hash = B256::with_last_byte(3);
+        let response = api
+            .get_payload_bodies_by_hash_v2(vec![block_hash, block_without_bal_hash, missing_hash])
+            .await
+            .unwrap();
+
+        assert_eq!(response.len(), 3);
+        assert_eq!(response[0].as_ref().unwrap().block_access_list, Some(raw_bal));
+        assert_eq!(response[1].as_ref().unwrap().block_access_list, None);
+        assert!(response[2].is_none());
+    }
+
+    #[tokio::test]
+    async fn get_payload_bodies_by_range_v2_returns_block_access_lists_from_store() {
+        let bal_store = BalStoreHandle::new(InMemoryBalStore::default());
+        let mut provider = MockEthProvider::default();
+        provider.bal_store = bal_store.clone();
+        let provider = Arc::new(provider);
+
+        let client = ClientVersionV1 {
+            code: ClientCode::RH,
+            name: "Reth".to_string(),
+            version: "v0.2.0-beta.5".to_string(),
+            commit: "defa64b2".to_string(),
+        };
+        let chain_spec: Arc<ChainSpec> = MAINNET.clone();
+        let payload_store = spawn_test_payload_service::<EthEngineTypes>();
+        let (to_engine, _engine_rx) = unbounded_channel();
+        let api = EngineApi::new(
+            provider.clone(),
+            chain_spec.clone(),
+            ConsensusEngineHandle::new(to_engine),
+            payload_store.into(),
+            NoopTransactionPool::default(),
+            Runtime::test(),
+            client,
+            EngineCapabilities::default(),
+            EthereumEngineValidator::new(chain_spec),
+            false,
+            NoopNetwork::default(),
+        );
+
+        let mut block = Block::default();
+        block.header.number = 1;
+        let block_hash = block.header.hash_slow();
+        provider.add_block(block_hash, block);
+
+        let mut block_without_bal = Block::default();
+        block_without_bal.header.number = 3;
+        let block_without_bal_hash = block_without_bal.header.hash_slow();
+        provider.add_block(block_without_bal_hash, block_without_bal);
+
+        let raw_bal = Bytes::from_static(&[alloy_rlp::EMPTY_LIST_CODE]);
+        let sealed_bal = Sealed::new_unchecked(raw_bal.clone(), keccak256(&raw_bal));
+        bal_store.insert(NumHash::new(1, block_hash), sealed_bal).unwrap();
+
+        let response = api.get_payload_bodies_by_range_v2(1, 3).await.unwrap();
+
+        assert_eq!(response.len(), 3);
+        assert_eq!(response[0].as_ref().unwrap().block_access_list, Some(raw_bal));
+        assert!(response[1].is_none());
+        assert_eq!(response[2].as_ref().unwrap().block_access_list, None);
+    }
+
     struct EngineApiTestHandle {
         #[allow(dead_code)]
         chain_spec: Arc<ChainSpec>,
@@ -1680,6 +1863,11 @@ mod tests {
             1
         }
 
+        fn cell_custody(&self) -> &CellCustody {
+            static CELL_CUSTODY: std::sync::OnceLock<CellCustody> = std::sync::OnceLock::new();
+            CELL_CUSTODY.get_or_init(CellCustody::default)
+        }
+
         fn is_syncing(&self) -> bool {
             self.syncing
         }
@@ -1751,6 +1939,151 @@ mod tests {
         assert_matches!(res, Ok(None));
     }
 
+    #[tokio::test]
+    async fn fcu_v4_updates_shared_cell_custody_before_forkchoice_result() {
+        let chain_spec: Arc<ChainSpec> =
+            Arc::new(ChainSpecBuilder::mainnet().amsterdam_activated().build());
+        let provider = Arc::new(MockEthProvider::default());
+        let payload_store = spawn_test_payload_service::<EthEngineTypes>();
+        let (to_engine, mut engine_rx) = unbounded_channel();
+        let network = NoopNetwork::default();
+        let cell_custody = network.cell_custody().clone();
+
+        let api = EngineApi::new(
+            provider,
+            chain_spec.clone(),
+            ConsensusEngineHandle::new(to_engine),
+            payload_store.into(),
+            NoopTransactionPool::default(),
+            Runtime::test(),
+            ClientVersionV1 {
+                code: ClientCode::RH,
+                name: "Reth".to_string(),
+                version: "v0.0.0-test".to_string(),
+                commit: "test".to_string(),
+            },
+            EngineCapabilities::default(),
+            EthereumEngineValidator::new(chain_spec),
+            false,
+            network,
+        );
+
+        let state = ForkchoiceState {
+            head_block_hash: B256::from([0x33; 32]),
+            safe_block_hash: B256::ZERO,
+            finalized_block_hash: B256::ZERO,
+        };
+        let custody_columns = B128::from(0b1010u128);
+
+        let api_task = tokio::spawn(async move {
+            api.fork_choice_updated_v4(state, None, Some(custody_columns)).await
+        });
+
+        let request = tokio::time::timeout(std::time::Duration::from_secs(1), engine_rx.recv())
+            .await
+            .expect("timed out waiting for forkchoiceUpdated request")
+            .expect("expected forkchoiceUpdated request");
+        let response_tx = match request {
+            BeaconEngineMessage::ForkchoiceUpdated { payload_attrs, tx, .. } => {
+                assert!(payload_attrs.is_none());
+                tx
+            }
+            other => panic!("unexpected engine message: {other:?}"),
+        };
+        assert_eq!(cell_custody.get(), custody_columns);
+
+        response_tx
+            .send(Ok(OnForkChoiceUpdated::valid(PayloadStatus::from_status(
+                PayloadStatusEnum::Valid,
+            ))))
+            .expect("send valid response");
+
+        api_task
+            .await
+            .expect("api task should not panic")
+            .expect("forkchoiceUpdatedV4 should succeed");
+        assert_eq!(cell_custody.get(), custody_columns);
+    }
+
+    #[tokio::test]
+    async fn fcu_v4_updates_shared_cell_custody_when_payload_attrs_invalid() {
+        let chain_spec: Arc<ChainSpec> =
+            Arc::new(ChainSpecBuilder::mainnet().amsterdam_activated().build());
+        let provider = Arc::new(MockEthProvider::default());
+        let payload_store = spawn_test_payload_service::<EthEngineTypes>();
+        let (to_engine, mut engine_rx) = unbounded_channel();
+        let network = NoopNetwork::default();
+        let cell_custody = network.cell_custody().clone();
+
+        let api = EngineApi::new(
+            provider,
+            chain_spec.clone(),
+            ConsensusEngineHandle::new(to_engine),
+            payload_store.into(),
+            NoopTransactionPool::default(),
+            Runtime::test(),
+            ClientVersionV1 {
+                code: ClientCode::RH,
+                name: "Reth".to_string(),
+                version: "v0.0.0-test".to_string(),
+                commit: "test".to_string(),
+            },
+            EngineCapabilities::default(),
+            EthereumEngineValidator::new(chain_spec),
+            false,
+            network,
+        );
+
+        let state = ForkchoiceState {
+            head_block_hash: B256::from([0x44; 32]),
+            safe_block_hash: B256::ZERO,
+            finalized_block_hash: B256::ZERO,
+        };
+        let payload_attributes = PayloadAttributes {
+            timestamp: 1,
+            prev_randao: B256::ZERO,
+            suggested_fee_recipient: Address::ZERO,
+            withdrawals: Some(vec![]),
+            parent_beacon_block_root: None,
+            slot_number: None,
+        };
+        let custody_columns = B128::from(0b1010u128);
+
+        let api_task = tokio::spawn(async move {
+            api.fork_choice_updated_v4(state, Some(payload_attributes), Some(custody_columns)).await
+        });
+
+        let request = tokio::time::timeout(std::time::Duration::from_secs(1), engine_rx.recv())
+            .await
+            .expect("timed out waiting for forkchoiceUpdated request")
+            .expect("expected forkchoiceUpdated request");
+        let response_tx = match request {
+            BeaconEngineMessage::ForkchoiceUpdated { payload_attrs, tx, .. } => {
+                assert!(
+                    payload_attrs.is_none(),
+                    "when attrs are invalid, API should first evaluate forkchoice without attrs"
+                );
+                tx
+            }
+            other => panic!("unexpected engine message: {other:?}"),
+        };
+        assert_eq!(cell_custody.get(), custody_columns);
+
+        response_tx
+            .send(Ok(OnForkChoiceUpdated::valid(PayloadStatus::from_status(
+                PayloadStatusEnum::Valid,
+            ))))
+            .expect("send valid response");
+
+        let response = api_task.await.expect("api task should not panic");
+        assert_matches!(
+            response,
+            Err(EngineApiError::EngineObjectValidationError(
+                reth_payload_primitives::EngineObjectValidationError::PayloadAttributes(_)
+            ))
+        );
+    }
+
     #[tokio::test]
     async fn fcu_v3_syncing_precedes_invalid_payload_attributes_validation() {
         let (mut handle, api) = setup_engine_api();
diff --git a/crates/rpc/rpc-engine-api/src/error.rs b/crates/rpc/rpc-engine-api/src/error.rs
index c521cd14c56..f6070b0515a 100644
--- a/crates/rpc/rpc-engine-api/src/error.rs
+++ b/crates/rpc/rpc-engine-api/src/error.rs
@@ -195,6 +195,15 @@ impl From<EngineApiError> for jsonrpsee_types::error::ErrorObject<'static> {
                             None::<()>,
                         )
                     }
+                    // Map future alloy forkchoice errors as internal until handled.
+                    #[allow(unreachable_patterns, clippy::needless_return)]
+                    _ => {
+                        return jsonrpsee_types::error::ErrorObject::owned(
+                            INTERNAL_ERROR_CODE,
+                            SERVER_ERROR_MSG,
+                            Some(ErrorData::new(error)),
+                        );
+                    }
                 },
                 BeaconForkChoiceUpdateError::EngineUnavailable |
                 BeaconForkChoiceUpdateError::Internal(_) => {
diff --git a/crates/rpc/rpc-engine-api/src/reth_engine_api.rs b/crates/rpc/rpc-engine-api/src/reth_engine_api.rs
index 7230552a399..35b66e48c24 100644
--- a/crates/rpc/rpc-engine-api/src/reth_engine_api.rs
+++ b/crates/rpc/rpc-engine-api/src/reth_engine_api.rs
@@ -40,10 +40,10 @@ impl<Payload: PayloadTypes> RethEngineApiServer<Payload::ExecutionData> for Reth
 
         let payload = match input {
             RethNewPayloadInput::ExecutionData(data) => data,
-            RethNewPayloadInput::BlockRlp(rlp) => {
-                let block = Decodable::decode(&mut rlp.as_ref())
+            RethNewPayloadInput::BlockRlp { block: block_rlp, bal } => {
+                let block = Decodable::decode(&mut block_rlp.as_ref())
                     .map_err(|err| EngineApiError::Internal(Box::new(err)))?;
-                Payload::block_to_payload(SealedBlock::new_unhashed(block))
+                Payload::block_to_payload(SealedBlock::new_unhashed(block), bal)
             }
         };
 
diff --git a/crates/rpc/rpc-eth-api/Cargo.toml b/crates/rpc/rpc-eth-api/Cargo.toml
index 04786c7aeb6..f3b12654670 100644
--- a/crates/rpc/rpc-eth-api/Cargo.toml
+++ b/crates/rpc/rpc-eth-api/Cargo.toml
@@ -30,6 +30,7 @@ reth-rpc-server-types.workspace = true
 reth-network-api.workspace = true
 reth-node-api.workspace = true
 reth-trie-common = { workspace = true, features = ["eip1186"] }
+reth-prune-types.workspace = true
 
 # ethereum
 alloy-evm = { workspace = true, features = ["overrides", "call-util"] }
diff --git a/crates/rpc/rpc-eth-api/src/core.rs b/crates/rpc/rpc-eth-api/src/core.rs
index e7fde53e5a4..03e63ea5d7e 100644
--- a/crates/rpc/rpc-eth-api/src/core.rs
+++ b/crates/rpc/rpc-eth-api/src/core.rs
@@ -5,7 +5,6 @@ use crate::{
     RpcBlock, RpcHeader, RpcReceipt, RpcTransaction,
 };
 use alloy_dyn_abi::TypedData;
-use alloy_eip7928::BlockAccessList;
 use alloy_eips::{eip2930::AccessListResult, BlockId, BlockNumberOrTag};
 use alloy_json_rpc::RpcObject;
 use alloy_primitives::{Address, Bytes, B256, B64, U256, U64};
@@ -19,7 +18,7 @@ use alloy_serde::JsonStorageKey;
 use jsonrpsee::{core::RpcResult, proc_macros::rpc};
 use reth_primitives_traits::TxTy;
 use reth_rpc_convert::RpcTxReq;
-use reth_rpc_eth_types::{EthApiError, FillTransaction};
+use reth_rpc_eth_types::{EthApiError, EthCapabilities, FillTransaction};
 use reth_rpc_server_types::{result::internal_rpc_err, ToRpcResult};
 use serde_json::Value;
 use std::collections::HashMap;
@@ -89,6 +88,13 @@ pub trait EthApi<
     #[method(name = "chainId")]
     async fn chain_id(&self) -> RpcResult<Option<U64>>;
 
+    /// Returns effective routing capabilities for this node.
+    ///
+    /// See the `eth_capabilities` execution API proposal:
+    /// <https://github.com/ethereum/execution-apis/pull/755>.
+    #[method(name = "capabilities")]
+    fn capabilities(&self) -> RpcResult<EthCapabilities>;
+
     /// Returns information about a block by hash.
     #[method(name = "getBlockByHash")]
     async fn block_by_hash(&self, hash: B256, full: bool) -> RpcResult<Option<B>>;
@@ -187,6 +193,10 @@ pub trait EthApi<
         nonce: U64,
     ) -> RpcResult<Option<T>>;
 
+    /// Returns all transactions in the local pending pool.
+    #[method(name = "pendingTransactions")]
+    fn pending_transactions(&self) -> RpcResult<Vec<T>>;
+
     /// Returns the receipt of a transaction by transaction hash.
     #[method(name = "getTransactionReceipt")]
     async fn transaction_receipt(&self, hash: B256) -> RpcResult<Option<R>>;
@@ -295,6 +305,7 @@ pub trait EthApi<
         request: TxReq,
         block_number: Option<BlockId>,
         state_override: Option<StateOverride>,
+        block_overrides: Option<Box<BlockOverrides>>,
     ) -> RpcResult<U256>;
 
     /// Returns the current price per gas in wei.
@@ -313,6 +324,10 @@ pub trait EthApi<
     #[method(name = "maxPriorityFeePerGas")]
     async fn max_priority_fee_per_gas(&self) -> RpcResult<U256>;
 
+    /// Returns the base fee for the next block, or `null` before London activation.
+    #[method(name = "baseFee")]
+    async fn base_fee(&self) -> RpcResult<Option<U256>>;
+
     /// Introduced in EIP-4844, returns the current blob base fee in wei.
     #[method(name = "blobBaseFee")]
     async fn blob_base_fee(&self) -> RpcResult<U256>;
@@ -417,6 +432,10 @@ pub trait EthApi<
         number: BlockNumberOrTag,
     ) -> RpcResult<Option<Value>>;
 
+    /// Returns the EIP-7928 block access list for a given block id.
+    #[method(name = "getBlockAccessList")]
+    async fn block_access_list(&self, block_id: BlockId) -> RpcResult<Option<Value>>;
+
     /// Returns the EIP-7928 block access list bytes for a block by number.
     #[method(name = "getBlockAccessListRaw")]
     async fn block_access_list_raw(&self, block: BlockId) -> RpcResult<Option<Bytes>>;
@@ -473,6 +492,12 @@ where
         Ok(Some(EthApiSpec::chain_id(self)))
     }
 
+    /// Handler for: `eth_capabilities`
+    fn capabilities(&self) -> RpcResult<EthCapabilities> {
+        trace!(target: "rpc::eth", "Serving eth_capabilities");
+        EthApiSpec::capabilities(self).to_rpc_result()
+    }
+
     /// Handler for: `eth_getBlockByHash`
     async fn block_by_hash(
         &self,
@@ -640,6 +665,12 @@ where
             .await?)
     }
 
+    /// Handler for: `eth_pendingTransactions`
+    fn pending_transactions(&self) -> RpcResult<Vec<RpcTransaction<T::NetworkTypes>>> {
+        trace!(target: "rpc::eth", "Serving eth_pendingTransactions");
+        Ok(EthTransactions::pending_transactions(self)?)
+    }
+
     /// Handler for: `eth_getTransactionReceipt`
     async fn transaction_receipt(
         &self,
@@ -773,13 +804,14 @@ where
         request: RpcTxReq<T::NetworkTypes>,
         block_number: Option<BlockId>,
         state_override: Option<StateOverride>,
+        block_overrides: Option<Box<BlockOverrides>>,
     ) -> RpcResult<U256> {
         trace!(target: "rpc::eth", ?request, ?block_number, "Serving eth_estimateGas");
         Ok(EthCall::estimate_gas_at(
             self,
             request,
             block_number.unwrap_or_default(),
-            state_override,
+            EvmOverrides::new(state_override, block_overrides),
         )
         .await?)
     }
@@ -812,6 +844,12 @@ where
         Ok(EthFees::blob_base_fee(self).await?)
     }
 
+    /// Handler for: `eth_baseFee`
+    async fn base_fee(&self) -> RpcResult<Option<U256>> {
+        trace!(target: "rpc::eth", "Serving eth_baseFee");
+        Ok(EthFees::base_fee(self).await?)
+    }
+
     // FeeHistory is calculated based on lazy evaluation of fees for historical blocks, and further
     // caching of it in the LRU cache.
     // When new RPC call is executed, the cache gets locked, we check it for the historical fees
@@ -928,6 +966,7 @@ where
 
         Ok(Some(json))
     }
+
     /// Handler for: `eth_getBlockAccessListByBlockNumber`
     async fn block_access_list_by_block_number(
         &self,
@@ -941,11 +980,22 @@ where
 
         Ok(Some(json))
     }
+
+    /// Handler for: `eth_getBlockAccessList`
+    async fn block_access_list(&self, block_id: BlockId) -> RpcResult<Option<Value>> {
+        trace!(target: "rpc::eth", ?block_id, "Serving eth_getBlockAccessList");
+
+        let bal = self.get_block_access_list(block_id).await?;
+        let json = serde_json::to_value(&bal)
+            .map_err(|e| EthApiError::Internal(reth_errors::RethError::msg(e.to_string())))?;
+
+        Ok(Some(json))
+    }
+
     /// Handler for: `eth_getBlockAccessListRaw`
     async fn block_access_list_raw(&self, block: BlockId) -> RpcResult<Option<Bytes>> {
         trace!(target: "rpc::eth", ?block, "Serving eth_getBlockAccessListRaw");
 
-        let bal = self.get_block_access_list(block).await?;
-        Ok(bal.map(|b: BlockAccessList| alloy_rlp::encode(b).into()))
+        Ok(self.get_raw_block_access_list(block).await?)
     }
 }
diff --git a/crates/rpc/rpc-eth-api/src/helpers/bal.rs b/crates/rpc/rpc-eth-api/src/helpers/bal.rs
index 608140afe17..7fa5cecfd8e 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/bal.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/bal.rs
@@ -1,6 +1,7 @@
 //! Helpers for `eth_blockAccessList` RPC method.
 use alloy_consensus::BlockHeader;
-use alloy_eips::eip7928::BlockAccessList;
+use alloy_eip7928::BlockAccessList;
+use alloy_primitives::Bytes;
 use alloy_rpc_types_eth::BlockId;
 use reth_errors::RethError;
 use reth_evm::{block::BlockExecutor, ConfigureEvm, Evm};
@@ -12,11 +13,11 @@ use reth_storage_api::StateProviderFactory;
 
 use crate::{
     helpers::{Call, LoadBlock, Trace},
-    RpcNodeCore,
+    RpcNodeCore, RpcNodeCoreExt,
 };
 
 /// Helper trait for `eth_blockAccessList` RPC method.
-pub trait GetBlockAccessList: Trace + Call + LoadBlock {
+pub trait GetBlockAccessList: Trace + Call + LoadBlock + RpcNodeCoreExt {
     /// Retrieves the block access list for a block identified by its hash.
     fn get_block_access_list(
         &self,
@@ -28,6 +29,12 @@ pub trait GetBlockAccessList: Trace + Call + LoadBlock {
                 .await?
                 .ok_or_else(|| EthApiError::HeaderNotFound(block_id))?;
 
+            if let Some(cached_bal) =
+                self.cache().get_bal(block.hash()).await.map_err(Self::Error::from_eth_err)?
+            {
+                return Ok(Some(cached_bal.as_bal().clone().into_alloy_bal()))
+            }
+
             self.spawn_blocking_io(move |eth_api| {
                 let state = eth_api
                     .provider()
@@ -64,4 +71,25 @@ pub trait GetBlockAccessList: Trace + Call + LoadBlock {
             .await
         }
     }
+
+    /// Retrieves the raw RLP-encoded block access list for a block.
+    fn get_raw_block_access_list(
+        &self,
+        block_id: BlockId,
+    ) -> impl Future<Output = Result<Option<Bytes>, Self::Error>> + Send {
+        async move {
+            let block = self
+                .recovered_block(block_id)
+                .await?
+                .ok_or_else(|| EthApiError::HeaderNotFound(block_id))?;
+
+            if let Some(cached_bal) =
+                self.cache().get_bal(block.hash()).await.map_err(Self::Error::from_eth_err)?
+            {
+                return Ok(Some(cached_bal.as_raw().clone()))
+            }
+
+            Ok(self.get_block_access_list(block_id).await?.map(|bal| alloy_rlp::encode(bal).into()))
+        }
+    }
 }
diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs
index e417943fea8..07ca27cdf82 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/call.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/call.rs
@@ -18,6 +18,7 @@ use alloy_rpc_types_eth::{
     BlockId, Bundle, EthCallResponse, StateContext, TransactionInfo,
 };
 use futures::Future;
+use reth_chainspec::{ChainSpecProvider, EthChainSpec, EthereumHardforks};
 use reth_errors::{ProviderError, RethError};
 use reth_evm::{
     block::BlockExecutor, env::BlockEnvironment, execute::BlockBuilder, ConfigureEvm, Evm,
@@ -44,6 +45,7 @@ use revm::{
     Database, DatabaseCommit,
 };
 use revm_inspectors::{access_list::AccessListInspector, transfer::TransferInspector};
+use std::collections::BTreeMap;
 use tracing::{trace, warn};
 
 /// Result type for `eth_simulateV1` RPC method.
@@ -57,9 +59,9 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
         &self,
         request: RpcTxReq<<Self::RpcConvert as RpcConvert>::Network>,
         at: BlockId,
-        state_override: Option<StateOverride>,
+        overrides: EvmOverrides,
     ) -> impl Future<Output = Result<U256, Self::Error>> + Send {
-        EstimateCall::estimate_gas_at(self, request, at, state_override)
+        EstimateCall::estimate_gas_at(self, request, at, overrides)
     }
 
     /// `eth_simulateV1` executes an arbitrary number of transactions on top of the requested state.
@@ -89,45 +91,47 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                 return Err(EthApiError::InvalidParams(String::from("calls are empty.")).into())
             }
 
+            let _permit = self.acquire_owned_blocking_io().await;
+
             let base_block =
                 self.recovered_block(block).await?.ok_or(EthApiError::HeaderNotFound(block))?;
-            let mut parent = base_block.sealed_header().clone();
+            let parent = base_block.sealed_header().clone();
+            let max_simulate_blocks = self.max_simulate_blocks();
+
+            self.spawn_with_state_at_block(block, move |this, db| {
+                let state_provider = db.database.0 .0;
+                let mut db = State::builder()
+                    .with_database(StateProviderDatabase::new(&state_provider))
+                    .with_bundle_update()
+                    .build();
+                let mut parent = parent;
+
+                let chain_id = this.provider().chain_spec().chain_id();
+
+                // Validate block ordering and fill gaps with empty blocks so every entry has an
+                // explicit `number` and `time` override and the chain is contiguous (see the
+                // execution-apis spec note: "If the block number is increased more than 1 compared
+                // to the previous block, new empty blocks are generated in between.").
+                let block_state_calls = simulate::sanitize_chain(
+                    block_state_calls,
+                    &parent,
+                    chain_id,
+                    max_simulate_blocks,
+                )?;
 
-            self.spawn_with_state_at_block(block, move |this, mut db| {
                 let mut blocks: Vec<SimulatedBlock<RpcBlock<Self::NetworkTypes>>> =
                     Vec::with_capacity(block_state_calls.len());
 
-                // Track previous block number and timestamp for validation
-                let mut prev_block_number = parent.number();
-                let mut prev_timestamp = parent.timestamp();
+                let call_gas_limit = this.call_gas_limit();
+                let mut remaining_call_gas_limit = (call_gas_limit > 0).then_some(call_gas_limit);
 
                 for block in block_state_calls {
-                    // Validate block number ordering if overridden
-                    if let Some(number) = block.block_overrides.as_ref().and_then(|o| o.number) {
-                        let number: u64 = number.try_into().unwrap_or(u64::MAX);
-                        if number <= prev_block_number {
-                            return Err(EthApiError::other(EthSimulateError::BlockNumberInvalid {
-                                got: number,
-                                parent: prev_block_number,
-                            })
-                            .into());
-                        }
-                    }
-                    // Validate timestamp ordering if overridden
-                    if let Some(time) = block
-                        .block_overrides
-                        .as_ref()
-                        .and_then(|o| o.time)
-                        .filter(|&t| t <= prev_timestamp)
-                    {
-                        return Err(EthApiError::other(EthSimulateError::BlockTimestampInvalid {
-                            got: time,
-                            parent: prev_timestamp,
-                        })
-                        .into());
-                    }
+                    let SimBlock { block_overrides, state_overrides, calls } = block;
 
-                    let attributes = this.next_env_attributes(&parent)?;
+                    let attributes = this
+                        .pending_env_builder()
+                        .pending_env_attributes(&parent, block_overrides.as_ref())
+                        .map_err(Self::Error::from_eth_err)?;
 
                     let mut evm_env = this
                         .evm_config()
@@ -146,12 +150,17 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                         evm_env.block_env.inner_mut().basefee = 0;
                     }
 
-                    let SimBlock { block_overrides, state_overrides, calls } = block;
-
                     // Set prevrandao to zero for simulated blocks by default,
                     // matching spec behavior where MixDigest is zero-initialized.
                     // If user provides an override, it will be applied by apply_block_overrides.
                     evm_env.block_env.inner_mut().prevrandao = Some(B256::ZERO);
+                    if !this
+                        .provider()
+                        .chain_spec()
+                        .is_paris_active_at_block(evm_env.block_env.number().saturating_to())
+                    {
+                        evm_env.block_env.inner_mut().difficulty = parent.difficulty();
+                    }
 
                     if let Some(block_overrides) = block_overrides {
                         // ensure we don't allow uncapped gas limit per block
@@ -172,39 +181,8 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                             .map_err(Self::Error::from_eth_err)?;
                     }
 
-                    let block_gas_limit = evm_env.block_env.gas_limit();
                     let chain_id = evm_env.cfg_env.chain_id;
 
-                    let default_gas_limit = {
-                        let total_specified_gas =
-                            calls.iter().filter_map(|tx| tx.as_ref().gas_limit()).sum::<u64>();
-                        let txs_without_gas_limit =
-                            calls.iter().filter(|tx| tx.as_ref().gas_limit().is_none()).count();
-
-                        if total_specified_gas > block_gas_limit {
-                            return Err(EthApiError::Other(Box::new(
-                                EthSimulateError::BlockGasLimitExceeded,
-                            ))
-                            .into())
-                        }
-
-                        if txs_without_gas_limit > 0 {
-                            // Per spec: "gasLimit: blockGasLimit - soFarUsedGasInBlock"
-                            // Divide remaining gas equally among transactions without gas
-                            let gas_per_tx = (block_gas_limit - total_specified_gas) /
-                                txs_without_gas_limit as u64;
-                            // Cap to RPC gas limit, matching spec behavior
-                            let call_gas_limit = this.call_gas_limit();
-                            if call_gas_limit > 0 {
-                                gas_per_tx.min(call_gas_limit)
-                            } else {
-                                gas_per_tx
-                            }
-                        } else {
-                            0
-                        }
-                    };
-
                     let ctx = this
                         .evm_config()
                         .context_for_next_block(&parent, attributes)
@@ -236,9 +214,11 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
 
                         simulate::execute_transactions(
                             builder,
+                            &state_provider,
                             calls,
-                            default_gas_limit,
+                            &mut remaining_call_gas_limit,
                             chain_id,
+                            this.compute_state_root_for_eth_simulate(),
                             this.converter(),
                         )
                         .map_err(map_err)?
@@ -256,19 +236,22 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
 
                         simulate::execute_transactions(
                             builder,
+                            &state_provider,
                             calls,
-                            default_gas_limit,
+                            &mut remaining_call_gas_limit,
                             chain_id,
+                            this.compute_state_root_for_eth_simulate(),
                             this.converter(),
                         )
                         .map_err(map_err)?
                     };
 
-                    parent = result.block.clone_sealed_header();
-
-                    // Update tracking for next iteration's validation
-                    prev_block_number = parent.number();
-                    prev_timestamp = parent.timestamp();
+                    let simulated_header = result.block.clone_sealed_header();
+                    db.override_block_hashes(BTreeMap::from([(
+                        simulated_header.number(),
+                        simulated_header.hash(),
+                    )]));
+                    parent = simulated_header;
 
                     let block = simulate::build_simulated_block::<Self::Error, _>(
                         result.block,
@@ -316,6 +299,8 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                 return Err(EthApiError::InvalidParams(String::from("bundles are empty.")).into());
             }
 
+            let _permit = self.acquire_owned_blocking_io().await;
+
             let StateContext { transaction_index, block_number } =
                 state_context.unwrap_or_default();
             let transaction_index = transaction_index.unwrap_or_default();
@@ -554,6 +539,9 @@ pub trait Call:
     /// Returns the maximum number of blocks accepted for `eth_simulateV1`.
     fn max_simulate_blocks(&self) -> u64;
 
+    /// Returns whether `eth_simulateV1` should compute state roots.
+    fn compute_state_root_for_eth_simulate(&self) -> bool;
+
     /// Returns the maximum memory the EVM can allocate per RPC request.
     fn evm_memory_limit(&self) -> u64;
 
diff --git a/crates/rpc/rpc-eth-api/src/helpers/estimate.rs b/crates/rpc/rpc-eth-api/src/helpers/estimate.rs
index 44c573728b4..fccd6572961 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/estimate.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/estimate.rs
@@ -2,14 +2,17 @@
 
 use super::{Call, LoadPendingBlock};
 use crate::{AsEthApiError, FromEthApiError, IntoEthApiError};
-use alloy_evm::overrides::apply_state_overrides;
+use alloy_evm::overrides::{apply_block_overrides, apply_state_overrides};
 use alloy_network::TransactionBuilder;
 use alloy_primitives::{TxKind, U256};
-use alloy_rpc_types_eth::{state::StateOverride, BlockId};
+use alloy_rpc_types_eth::{state::EvmOverrides, BlockId};
 use futures::Future;
 use reth_chainspec::MIN_TRANSACTION_GAS;
 use reth_errors::ProviderError;
-use reth_evm::{ConfigureEvm, Database, Evm, EvmEnvFor, EvmFor, TransactionEnvMut, TxEnvFor};
+use reth_evm::{
+    env::BlockEnvironment, ConfigureEvm, Database, Evm, EvmEnvFor, EvmFor, TransactionEnvMut,
+    TxEnvFor,
+};
 use reth_revm::{
     database::{EvmStateProvider, StateProviderDatabase},
     db::{bal::EvmDatabaseError, State},
@@ -49,7 +52,7 @@ pub trait EstimateCall: Call {
         mut evm_env: EvmEnvFor<Self::Evm>,
         mut request: RpcTxReq<<Self::RpcConvert as RpcConvert>::Network>,
         state: S,
-        state_override: Option<StateOverride>,
+        overrides: EvmOverrides,
     ) -> Result<U256, Self::Error>
     where
         S: EvmStateProvider,
@@ -73,6 +76,23 @@ pub trait EstimateCall: Call {
         // Keep a copy of gas related request values
         let tx_request_gas_limit = request.as_ref().gas_limit();
         let tx_request_gas_price = request.as_ref().gas_price();
+
+        // Configure the evm env
+        let mut db = State::builder().with_database(StateProviderDatabase::new(state)).build();
+
+        // Apply any block overrides before deriving block-derived limits and the tx env so
+        // overrides for `gasLimit`, `baseFee` and `blobBaseFee` are visible to estimation.
+        // Mirrors geth's behavior, see:
+        // <https://github.com/ethereum/go-ethereum/pull/30695>
+        if let Some(block_overrides) = overrides.block {
+            apply_block_overrides(*block_overrides, &mut db, evm_env.block_env.inner_mut());
+        }
+
+        // Apply any state overrides if specified.
+        if let Some(state_override) = overrides.state {
+            apply_state_overrides(state_override, &mut db).map_err(Self::Error::from_eth_err)?;
+        }
+
         // the gas limit of the corresponding block
         let max_gas_limit = evm_env
             .cfg_env
@@ -96,14 +116,6 @@ pub trait EstimateCall: Call {
             })
             .unwrap_or(max_gas_limit);
 
-        // Configure the evm env
-        let mut db = State::builder().with_database(StateProviderDatabase::new(state)).build();
-
-        // Apply any state overrides if specified.
-        if let Some(state_override) = state_override {
-            apply_state_overrides(state_override, &mut db).map_err(Self::Error::from_eth_err)?;
-        }
-
         let mut tx_env = self.create_txn_env(&evm_env, request, &mut db)?;
 
         // Check if this is a basic transfer (no input data to account with no code)
@@ -298,7 +310,7 @@ pub trait EstimateCall: Call {
         &self,
         request: RpcTxReq<<Self::RpcConvert as RpcConvert>::Network>,
         at: BlockId,
-        state_override: Option<StateOverride>,
+        overrides: EvmOverrides,
     ) -> impl Future<Output = Result<U256, Self::Error>> + Send
     where
         Self: LoadPendingBlock,
@@ -308,7 +320,7 @@ pub trait EstimateCall: Call {
 
             self.spawn_blocking_io_fut(async move |this| {
                 let state = this.state_at_block_id(at).await?;
-                EstimateCall::estimate_gas_with(&this, evm_env, request, state, state_override)
+                EstimateCall::estimate_gas_with(&this, evm_env, request, state, overrides)
             })
             .await
         }
diff --git a/crates/rpc/rpc-eth-api/src/helpers/fee.rs b/crates/rpc/rpc-eth-api/src/helpers/fee.rs
index acb2fd9419f..7046064704e 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/fee.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/fee.rs
@@ -43,6 +43,14 @@ pub trait EthFees:
         LoadFee::blob_base_fee(self)
     }
 
+    /// Returns the base fee for the next block, or `None` before London activation.
+    fn base_fee(&self) -> impl Future<Output = Result<Option<U256>, Self::Error>> + Send
+    where
+        Self: LoadBlock,
+    {
+        LoadFee::base_fee(self)
+    }
+
     /// Returns a suggestion for the priority fee (the tip)
     fn suggested_priority_fee(&self) -> impl Future<Output = Result<U256, Self::Error>> + Send
     where
@@ -400,6 +408,22 @@ where
         }
     }
 
+    /// Returns the base fee for the next block, or `None` before London activation.
+    fn base_fee(&self) -> impl Future<Output = Result<Option<U256>, Self::Error>> + Send {
+        async move {
+            let header = self
+                .provider()
+                .latest_header()
+                .map_err(Self::Error::from_eth_err)?
+                .ok_or(EthApiError::HeaderNotFound(BlockNumberOrTag::Latest.into()))?;
+            Ok(self
+                .provider()
+                .chain_spec()
+                .next_block_base_fee(&header, header.timestamp())
+                .map(U256::from))
+        }
+    }
+
     /// Returns a suggestion for the priority fee (the tip)
     fn suggested_priority_fee(&self) -> impl Future<Output = Result<U256, Self::Error>> + Send
     where
diff --git a/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs b/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
index 6a0e6995ca7..85c4d8e63ac 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
@@ -6,7 +6,7 @@ use crate::{EthApiTypes, FromEthApiError, FromEvmError, RpcNodeCore};
 use alloy_consensus::{BlockHeader, Transaction};
 use alloy_eips::eip7840::BlobParams;
 use alloy_primitives::{B256, U256};
-use alloy_rpc_types_eth::BlockNumberOrTag;
+use alloy_rpc_types_eth::{BlockNumberOrTag, BlockOverrides};
 use futures::Future;
 use reth_chain_state::{BlockState, ComputedTrieData, ExecutedBlock};
 use reth_chainspec::{ChainSpecProvider, EthChainSpec, EthereumHardforks};
@@ -103,7 +103,7 @@ pub trait LoadPendingBlock:
         &self,
         parent: &SealedHeader<ProviderHeader<Self::Provider>>,
     ) -> Result<<Self::Evm as ConfigureEvm>::NextBlockEnvCtx, Self::Error> {
-        Ok(self.pending_env_builder().pending_env_attributes(parent)?)
+        Ok(self.pending_env_builder().pending_env_attributes(parent, None)?)
     }
 
     /// Returns a [`StateProviderBox`] on a mem-pool built pending block overlaying latest.
@@ -321,7 +321,7 @@ pub trait LoadPendingBlock:
                     // the iterator before we can continue
                     best_txs.mark_invalid(
                         &pool_tx,
-                        &InvalidPoolTransactionError::ExceedsGasLimit(
+                        InvalidPoolTransactionError::ExceedsGasLimit(
                             transaction_gas_limit,
                             block_available_gas,
                         ),
@@ -335,7 +335,7 @@ pub trait LoadPendingBlock:
                     // transactions from the iteratorbefore we can continue
                     best_txs.mark_invalid(
                         &pool_tx,
-                        &InvalidPoolTransactionError::Consensus(
+                        InvalidPoolTransactionError::Consensus(
                             InvalidTransactionError::TxTypeNotSupported,
                         ),
                     );
@@ -357,7 +357,7 @@ pub trait LoadPendingBlock:
                     // for regular transactions above.
                     best_txs.mark_invalid(
                         &pool_tx,
-                        &InvalidPoolTransactionError::ExceedsGasLimit(
+                        InvalidPoolTransactionError::ExceedsGasLimit(
                             tx_blob_gas,
                             blob_params.max_blob_gas_per_block(),
                         ),
@@ -382,7 +382,7 @@ pub trait LoadPendingBlock:
                                 // descendants
                                 best_txs.mark_invalid(
                                     &pool_tx,
-                                    &InvalidPoolTransactionError::Consensus(
+                                    InvalidPoolTransactionError::Consensus(
                                         InvalidTransactionError::TxTypeNotSupported,
                                     ),
                                 );
@@ -397,7 +397,7 @@ pub trait LoadPendingBlock:
                         )) => {
                             best_txs.mark_invalid(
                                 &pool_tx,
-                                &InvalidPoolTransactionError::ExceedsGasLimit(
+                                InvalidPoolTransactionError::ExceedsGasLimit(
                                     transaction_gas_limit,
                                     block_available_gas,
                                 ),
@@ -435,7 +435,7 @@ pub trait LoadPendingBlock:
         Ok(ExecutedBlock::new(
             block.into(),
             Arc::new(execution_outcome),
-            ComputedTrieData::without_trie_input(
+            ComputedTrieData::new(
                 Arc::new(hashed_state.into_sorted()),
                 Arc::new(trie_updates.into_sorted()),
             ),
@@ -445,10 +445,15 @@ pub trait LoadPendingBlock:
 
 /// A type that knows how to build a [`ConfigureEvm::NextBlockEnvCtx`] for a pending block.
 pub trait PendingEnvBuilder<Evm: ConfigureEvm>: Send + Sync + Unpin + 'static {
-    /// Builds a [`ConfigureEvm::NextBlockEnvCtx`] for pending block.
+    /// Builds a [`ConfigureEvm::NextBlockEnvCtx`] for a pending block.
+    ///
+    /// `block_overrides` can be used for values that need to be part of the next block context
+    /// before the EVM environment is constructed. Other block overrides are applied directly to the
+    /// EVM environment after construction.
     fn pending_env_attributes(
         &self,
         parent: &SealedHeader<HeaderTy<Evm::Primitives>>,
+        block_overrides: Option<&BlockOverrides>,
     ) -> Result<Evm::NextBlockEnvCtx, EthApiError>;
 }
 
@@ -458,8 +463,15 @@ pub trait PendingEnvBuilder<Evm: ConfigureEvm>: Send + Sync + Unpin + 'static {
 /// This assumes that next environment building doesn't require any additional context, for more
 /// complex implementations one should implement [`PendingEnvBuilder`] on their custom type.
 pub trait BuildPendingEnv<Header> {
-    /// Builds a [`ConfigureEvm::NextBlockEnvCtx`] for pending block.
-    fn build_pending_env(parent: &SealedHeader<Header>) -> Self;
+    /// Builds a [`ConfigureEvm::NextBlockEnvCtx`] for a pending block.
+    ///
+    /// `block_overrides` can be used for values that need to be part of the next block context
+    /// before the EVM environment is constructed. Other block overrides are applied directly to the
+    /// EVM environment after construction.
+    fn build_pending_env(
+        parent: &SealedHeader<Header>,
+        block_overrides: Option<&BlockOverrides>,
+    ) -> Self;
 }
 
 impl<Evm> PendingEnvBuilder<Evm> for ()
@@ -469,23 +481,35 @@ where
     fn pending_env_attributes(
         &self,
         parent: &SealedHeader<HeaderTy<Evm::Primitives>>,
+        block_overrides: Option<&BlockOverrides>,
     ) -> Result<Evm::NextBlockEnvCtx, EthApiError> {
-        Ok(Evm::NextBlockEnvCtx::build_pending_env(parent))
+        Ok(Evm::NextBlockEnvCtx::build_pending_env(parent, block_overrides))
     }
 }
 
 impl<H: BlockHeader> BuildPendingEnv<H> for NextBlockEnvAttributes {
-    fn build_pending_env(parent: &SealedHeader<H>) -> Self {
-        Self {
+    fn build_pending_env(
+        parent: &SealedHeader<H>,
+        block_overrides: Option<&BlockOverrides>,
+    ) -> Self {
+        let mut attributes = Self {
             timestamp: parent.timestamp().saturating_add(12),
             suggested_fee_recipient: parent.beneficiary(),
             prev_randao: B256::random(),
             gas_limit: parent.gas_limit(),
-            parent_beacon_block_root: parent.parent_beacon_block_root(),
+            parent_beacon_block_root: parent.parent_beacon_block_root().map(|_| B256::ZERO),
             withdrawals: parent.withdrawals_root().map(|_| Default::default()),
             extra_data: parent.extra_data().clone(),
             slot_number: parent.slot_number().map(|slot| slot.saturating_add(1)),
+        };
+
+        if attributes.parent_beacon_block_root.is_some() &&
+            let Some(beacon_root) = block_overrides.and_then(|overrides| overrides.beacon_root)
+        {
+            attributes.parent_beacon_block_root = Some(beacon_root);
         }
+
+        attributes
     }
 }
 
@@ -497,23 +521,48 @@ mod tests {
     use reth_primitives_traits::SealedHeader;
 
     #[test]
-    fn pending_env_keeps_parent_beacon_root() {
+    fn pending_env_defaults_parent_beacon_root() {
         let mut header = Header::default();
         let beacon_root = B256::repeat_byte(0x42);
         header.parent_beacon_block_root = Some(beacon_root);
         let sealed = SealedHeader::new(header, B256::ZERO);
 
-        let attrs = NextBlockEnvAttributes::build_pending_env(&sealed);
+        let attrs = NextBlockEnvAttributes::build_pending_env(&sealed, None);
+
+        assert_eq!(attrs.parent_beacon_block_root, Some(B256::ZERO));
+    }
+
+    #[test]
+    fn pending_env_applies_parent_beacon_root_override() {
+        let header = Header { parent_beacon_block_root: Some(B256::ZERO), ..Default::default() };
+        let sealed = SealedHeader::new(header, B256::ZERO);
+        let beacon_root = B256::repeat_byte(0x42);
+        let block_overrides =
+            BlockOverrides { beacon_root: Some(beacon_root), ..Default::default() };
+
+        let attrs = NextBlockEnvAttributes::build_pending_env(&sealed, Some(&block_overrides));
 
         assert_eq!(attrs.parent_beacon_block_root, Some(beacon_root));
     }
 
+    #[test]
+    fn pending_env_ignores_parent_beacon_root_override_before_fork() {
+        let sealed = SealedHeader::new(Header::default(), B256::ZERO);
+        let beacon_root = B256::repeat_byte(0x42);
+        let block_overrides =
+            BlockOverrides { beacon_root: Some(beacon_root), ..Default::default() };
+
+        let attrs = NextBlockEnvAttributes::build_pending_env(&sealed, Some(&block_overrides));
+
+        assert_eq!(attrs.parent_beacon_block_root, None);
+    }
+
     #[test]
     fn pending_env_increments_parent_slot_number() {
         let header = Header { slot_number: Some(7), ..Default::default() };
         let sealed = SealedHeader::new(header, B256::ZERO);
 
-        let attrs = NextBlockEnvAttributes::build_pending_env(&sealed);
+        let attrs = NextBlockEnvAttributes::build_pending_env(&sealed, None);
 
         assert_eq!(attrs.slot_number, Some(8));
     }
diff --git a/crates/rpc/rpc-eth-api/src/helpers/spec.rs b/crates/rpc/rpc-eth-api/src/helpers/spec.rs
index 39c9f67cc69..197cfd803d4 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/spec.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/spec.rs
@@ -6,10 +6,17 @@ use futures::Future;
 use reth_chainspec::ChainInfo;
 use reth_errors::{RethError, RethResult};
 use reth_network_api::NetworkInfo;
+use reth_prune_types::{PruneMode, PruneSegment};
 use reth_rpc_convert::RpcTxReq;
-use reth_storage_api::{BlockNumReader, StageCheckpointReader, TransactionsProvider};
+use reth_rpc_eth_types::{EthCapabilities, EthCapabilitiesHead, EthCapabilitiesResource};
+use reth_storage_api::{
+    BlockNumReader, PruneCheckpointReader, StageCheckpointReader, TransactionsProvider,
+};
 
-use crate::{helpers::EthSigner, EthApiTypes, RpcNodeCore};
+use crate::{
+    helpers::{EthSigner, EthState},
+    EthApiTypes, RpcNodeCore,
+};
 
 /// `Eth` API trait.
 ///
@@ -37,6 +44,52 @@ pub trait EthApiSpec: RpcNodeCore + EthApiTypes {
         Ok(self.provider().chain_info()?)
     }
 
+    /// Returns effective routing capabilities for this node.
+    ///
+    /// The response follows the `eth_capabilities` execution API proposal:
+    /// <https://github.com/ethereum/execution-apis/pull/755>.
+    fn capabilities(&self) -> RethResult<EthCapabilities>
+    where
+        Self: EthState,
+    {
+        let chain_info = self.chain_info()?;
+        let provider = self.provider();
+
+        let state = effective_resource(
+            provider,
+            &[PruneSegment::AccountHistory, PruneSegment::StorageHistory],
+        )?;
+        let tx =
+            effective_resource(provider, &[PruneSegment::TransactionLookup, PruneSegment::Bodies])?;
+        let logs =
+            effective_resource(provider, &[PruneSegment::Receipts, PruneSegment::ContractLogs])?;
+        let receipts = effective_resource(
+            provider,
+            &[PruneSegment::Receipts, PruneSegment::TransactionLookup, PruneSegment::Bodies],
+        )?;
+        let blocks = effective_resource(provider, &[PruneSegment::Bodies])?;
+
+        let proof_window = self.max_proof_window();
+        let proof_oldest = chain_info
+            .best_number
+            .saturating_sub(proof_window)
+            .max(state.oldest_block.map(|number| number.to::<u64>()).unwrap_or_default());
+        let state_proofs = EthCapabilitiesResource::window(proof_oldest, proof_window);
+
+        Ok(EthCapabilities {
+            head: EthCapabilitiesHead {
+                number: chain_info.best_number,
+                hash: chain_info.best_hash,
+            },
+            state,
+            tx,
+            logs,
+            receipts,
+            blocks,
+            state_proofs,
+        })
+    }
+
     /// Returns `true` if the network is undergoing sync.
     fn is_syncing(&self) -> bool {
         self.network().is_syncing()
@@ -72,8 +125,134 @@ pub trait EthApiSpec: RpcNodeCore + EthApiTypes {
     }
 }
 
+/// Derives the effective block availability for a capability resource from the prune checkpoints of
+/// all storage segments needed to serve it.
+///
+/// A resource is only available where every required segment is available, so the oldest available
+/// block is the maximum pruned checkpoint across the segments. If any segment is configured with a
+/// distance-based prune mode, or with full pruning that still keeps the segment minimum, expose the
+/// smallest retention window because that is the tightest limit callers can rely on. If full
+/// pruning leaves no reliable window for any required segment, the resource is disabled.
+///
+/// See also: <https://github.com/ethereum/execution-apis/pull/755>
+fn effective_resource(
+    provider: &impl PruneCheckpointReader,
+    segments: &[PruneSegment],
+) -> RethResult<EthCapabilitiesResource> {
+    let mut oldest_block = 0;
+    let mut retention_blocks = None::<u64>;
+    let mut disabled = false;
+
+    for segment in segments {
+        let Some(checkpoint) = provider.get_prune_checkpoint(*segment)? else {
+            continue;
+        };
+
+        if let Some(block_number) = checkpoint.block_number {
+            oldest_block = oldest_block.max(block_number.saturating_add(1));
+        }
+
+        match checkpoint.prune_mode {
+            PruneMode::Distance(distance) => {
+                retention_blocks =
+                    Some(retention_blocks.map_or(distance, |current| current.min(distance)));
+            }
+            PruneMode::Full => {
+                let min_blocks = segment.min_blocks();
+                if min_blocks == 0 {
+                    disabled = true;
+                } else {
+                    retention_blocks = Some(
+                        retention_blocks.map_or(min_blocks, |current| current.min(min_blocks)),
+                    );
+                }
+            }
+            PruneMode::Before(_) => {}
+        }
+    }
+
+    Ok(if disabled {
+        EthCapabilitiesResource::disabled()
+    } else if let Some(retention_blocks) = retention_blocks {
+        EthCapabilitiesResource::window(oldest_block, retention_blocks)
+    } else {
+        EthCapabilitiesResource::available_from(oldest_block)
+    })
+}
+
 /// A handle to [`EthSigner`]s with its generics set from [`TransactionsProvider`] and
 /// [`reth_rpc_convert::RpcTypes`].
 pub type SignersForRpc<Provider, Rpc> = parking_lot::RwLock<
     Vec<Box<dyn EthSigner<<Provider as TransactionsProvider>::Transaction, RpcTxReq<Rpc>>>>,
 >;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use reth_prune_types::PruneCheckpoint;
+    use reth_storage_api::errors::provider::ProviderResult;
+    use std::collections::HashMap;
+
+    #[derive(Default)]
+    struct TestPruneCheckpointReader {
+        checkpoints: HashMap<PruneSegment, PruneCheckpoint>,
+    }
+
+    impl TestPruneCheckpointReader {
+        fn with_checkpoint(segment: PruneSegment, checkpoint: PruneCheckpoint) -> Self {
+            Self { checkpoints: HashMap::from([(segment, checkpoint)]) }
+        }
+    }
+
+    impl PruneCheckpointReader for TestPruneCheckpointReader {
+        fn get_prune_checkpoint(
+            &self,
+            segment: PruneSegment,
+        ) -> ProviderResult<Option<PruneCheckpoint>> {
+            Ok(self.checkpoints.get(&segment).copied())
+        }
+
+        fn get_prune_checkpoints(&self) -> ProviderResult<Vec<(PruneSegment, PruneCheckpoint)>> {
+            Ok(self
+                .checkpoints
+                .iter()
+                .map(|(segment, checkpoint)| (*segment, *checkpoint))
+                .collect())
+        }
+    }
+
+    #[test]
+    fn full_prune_segment_without_retention_disables_resource() {
+        let provider = TestPruneCheckpointReader::with_checkpoint(
+            PruneSegment::TransactionLookup,
+            PruneCheckpoint {
+                block_number: Some(10),
+                tx_number: None,
+                prune_mode: PruneMode::Full,
+            },
+        );
+
+        let resource = effective_resource(&provider, &[PruneSegment::TransactionLookup]).unwrap();
+
+        assert_eq!(resource, EthCapabilitiesResource::disabled());
+    }
+
+    #[test]
+    fn full_prune_segment_with_minimum_retention_uses_window() {
+        let provider = TestPruneCheckpointReader::with_checkpoint(
+            PruneSegment::Bodies,
+            PruneCheckpoint {
+                block_number: Some(10),
+                tx_number: None,
+                prune_mode: PruneMode::Full,
+            },
+        );
+
+        let resource = effective_resource(&provider, &[PruneSegment::Bodies]).unwrap();
+
+        assert_eq!(
+            resource,
+            EthCapabilitiesResource::window(11, PruneSegment::Bodies.min_blocks())
+        );
+    }
+}
diff --git a/crates/rpc/rpc-eth-api/src/helpers/state.rs b/crates/rpc/rpc-eth-api/src/helpers/state.rs
index 322e070458c..9eb4e9e7bbc 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/state.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/state.rs
@@ -1,7 +1,7 @@
 //! Loads a pending block from database. Helper trait for `eth_` block, transaction, call and trace
 //! RPC methods.
 
-use super::{EthApiSpec, LoadPendingBlock, SpawnBlocking};
+use super::{EthApiSpec, LoadBlock, LoadPendingBlock, SpawnBlocking};
 use crate::{EthApiTypes, FromEthApiError, RpcNodeCore, RpcNodeCoreExt};
 use alloy_consensus::constants::KECCAK_EMPTY;
 use alloy_eips::BlockId;
@@ -11,7 +11,7 @@ use alloy_serde::JsonStorageKey;
 use futures::Future;
 use reth_errors::RethError;
 use reth_evm::{ConfigureEvm, EvmEnvFor};
-use reth_primitives_traits::SealedHeaderFor;
+use reth_primitives_traits::{BlockTy, RecoveredBlock, SealedHeaderFor};
 use reth_rpc_convert::{RpcConvert, RpcTxReq};
 use reth_rpc_eth_types::{
     error::{FromEvmError, IntoEthApiError},
@@ -22,7 +22,7 @@ use reth_storage_api::{
     BlockIdReader, BlockReaderIdExt, StateProvider, StateProviderBox, StateProviderFactory,
 };
 use reth_transaction_pool::TransactionPool;
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
 
 /// Helper methods for `eth_` methods relating to state (accounts).
 pub trait EthState: LoadState + SpawnBlocking {
@@ -353,6 +353,46 @@ pub trait LoadState:
         }
     }
 
+    /// Returns the recovered block, revm evm env, and state block id for the requested [`BlockId`].
+    ///
+    /// For pending blocks, this preserves the state id returned by [`Self::evm_env_at`], which can
+    /// be the pending tag for an actual pending block or the latest block hash when the pending env
+    /// is derived from latest.
+    #[expect(clippy::type_complexity)]
+    fn evm_env_and_recovered_block_at(
+        &self,
+        at: BlockId,
+    ) -> impl Future<
+        Output = Result<
+            (Arc<RecoveredBlock<BlockTy<Self::Primitives>>>, EvmEnvFor<Self::Evm>, BlockId),
+            Self::Error,
+        >,
+    > + Send
+    where
+        Self: SpawnBlocking + LoadBlock,
+    {
+        async move {
+            if at.is_pending() {
+                let (evm_env, block_id) = self.evm_env_at(at).await?;
+                let block = self
+                    .recovered_block(block_id)
+                    .await?
+                    .ok_or_else(|| EthApiError::HeaderNotFound(at))?;
+
+                Ok((block, evm_env, block_id))
+            } else {
+                let block = self
+                    .recovered_block(at)
+                    .await?
+                    .ok_or_else(|| EthApiError::HeaderNotFound(at))?;
+                let evm_env = self.evm_env_for_header(block.sealed_block().sealed_header())?;
+                let block_id = block.hash().into();
+
+                Ok((block, evm_env, block_id))
+            }
+        }
+    }
+
     /// Returns the next available nonce without gaps for the given address
     /// Next available nonce is either the on chain nonce of the account or the highest consecutive
     /// nonce in the pool + 1
diff --git a/crates/rpc/rpc-eth-api/src/helpers/transaction.rs b/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
index 77f5e4699c8..1905a33701a 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
@@ -15,7 +15,7 @@ use alloy_dyn_abi::TypedData;
 use alloy_eips::{eip2718::Encodable2718, BlockId};
 use alloy_network::{TransactionBuilder, TransactionBuilder4844};
 use alloy_primitives::{Address, Bytes, TxHash, B256, U256};
-use alloy_rpc_types_eth::TransactionInfo;
+use alloy_rpc_types_eth::{state::EvmOverrides, TransactionInfo};
 use futures::{Future, StreamExt};
 use reth_chain_state::CanonStateSubscriptions;
 use reth_primitives_traits::{
@@ -157,6 +157,16 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
         LoadTransaction::transaction_by_hash(self, hash)
     }
 
+    /// Returns all transactions from the local pending pool.
+    fn pending_transactions(&self) -> Result<Vec<RpcTransaction<Self::NetworkTypes>>, Self::Error> {
+        self.pool()
+            .pending_transactions()
+            .into_iter()
+            .map(|tx| self.converter().fill_pending(tx.transaction.clone_into_consensus()))
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(Self::Error::from)
+    }
+
     /// Get all transactions in the block with the given hash.
     ///
     /// Returns `None` if block does not exist.
@@ -470,8 +480,9 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
             let chain_id = self.chain_id();
             request.as_mut().set_chain_id(chain_id.to());
 
-            let estimated_gas =
-                self.estimate_gas_at(request.clone(), BlockId::pending(), None).await?;
+            let estimated_gas = self
+                .estimate_gas_at(request.clone(), BlockId::pending(), EvmOverrides::default())
+                .await?;
             let gas_limit = estimated_gas;
             request.as_mut().set_gas_limit(gas_limit.to());
 
@@ -533,8 +544,9 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
             }
 
             if request.as_ref().gas_limit().is_none() {
-                let estimated_gas =
-                    self.estimate_gas_at(request.clone(), BlockId::pending(), None).await?;
+                let estimated_gas = self
+                    .estimate_gas_at(request.clone(), BlockId::pending(), EvmOverrides::default())
+                    .await?;
                 request.as_mut().set_gas_limit(estimated_gas.to());
             }
 
diff --git a/crates/rpc/rpc-eth-api/src/node.rs b/crates/rpc/rpc-eth-api/src/node.rs
index bde95b9c572..1c26cba7998 100644
--- a/crates/rpc/rpc-eth-api/src/node.rs
+++ b/crates/rpc/rpc-eth-api/src/node.rs
@@ -8,7 +8,8 @@ use reth_node_api::{FullNodeComponents, NodePrimitives, PrimitivesTy};
 use reth_primitives_traits::{BlockTy, HeaderTy, ReceiptTy, TxTy};
 use reth_rpc_eth_types::EthStateCache;
 use reth_storage_api::{
-    BlockReader, BlockReaderIdExt, StageCheckpointReader, StateProviderFactory,
+    BalProvider, BlockReader, BlockReaderIdExt, PruneCheckpointReader, StageCheckpointReader,
+    StateProviderFactory,
 };
 use reth_transaction_pool::{PoolTransaction, TransactionPool};
 
@@ -37,6 +38,8 @@ pub trait RpcNodeCore: Clone + Send + Sync + Unpin + 'static {
         > + StateProviderFactory
         + CanonStateSubscriptions<Primitives = Self::Primitives>
         + StageCheckpointReader
+        + PruneCheckpointReader
+        + BalProvider
         + Send
         + Sync
         + Clone
@@ -130,6 +133,8 @@ where
         > + StateProviderFactory
         + CanonStateSubscriptions<Primitives = Evm::Primitives>
         + StageCheckpointReader
+        + PruneCheckpointReader
+        + BalProvider
         + Send
         + Sync
         + Unpin
diff --git a/crates/rpc/rpc-eth-types/Cargo.toml b/crates/rpc/rpc-eth-types/Cargo.toml
index 1ef87874dbd..3785c89b2bc 100644
--- a/crates/rpc/rpc-eth-types/Cargo.toml
+++ b/crates/rpc/rpc-eth-types/Cargo.toml
@@ -29,6 +29,8 @@ reth-transaction-pool.workspace = true
 reth-trie.workspace = true
 
 # ethereum
+alloy-chains.workspace = true
+alloy-eip7928.workspace = true
 alloy-eips.workspace = true
 alloy-evm = { workspace = true, features = ["overrides", "call-util"] }
 alloy-primitives.workspace = true
@@ -38,6 +40,7 @@ alloy-transport.workspace = true
 alloy-rpc-client = { workspace = true, features = ["reqwest"] }
 alloy-rpc-types-eth.workspace = true
 alloy-network.workspace = true
+alloy-serde.workspace = true
 revm.workspace = true
 revm-inspectors.workspace = true
 
@@ -65,6 +68,8 @@ tracing.workspace = true
 itertools.workspace = true
 
 [dev-dependencies]
+reth-db-models.workspace = true
+reth-storage-api = { workspace = true, features = ["std"] }
 serde_json.workspace = true
 
 [features]
diff --git a/crates/rpc/rpc-eth-types/src/builder/config.rs b/crates/rpc/rpc-eth-types/src/builder/config.rs
index 7be7c37d841..edc808bc499 100644
--- a/crates/rpc/rpc-eth-types/src/builder/config.rs
+++ b/crates/rpc/rpc-eth-types/src/builder/config.rs
@@ -90,6 +90,8 @@ pub struct EthConfig {
     pub rpc_gas_cap: u64,
     /// Max number of blocks for `eth_simulateV1`.
     pub rpc_max_simulate_blocks: u64,
+    /// Whether to compute state roots for `eth_simulateV1` responses.
+    pub compute_state_root_for_eth_simulate: bool,
     ///
     /// Sets TTL for stale filters
     pub stale_filter_ttl: Duration,
@@ -137,6 +139,7 @@ impl Default for EthConfig {
             max_logs_per_response: DEFAULT_MAX_LOGS_PER_RESPONSE,
             rpc_gas_cap: RPC_DEFAULT_GAS_CAP.into(),
             rpc_max_simulate_blocks: DEFAULT_MAX_SIMULATE_BLOCKS,
+            compute_state_root_for_eth_simulate: false,
             stale_filter_ttl: DEFAULT_STALE_FILTER_TTL,
             fee_history_cache: FeeHistoryCacheConfig::default(),
             proof_permits: DEFAULT_PROOF_PERMITS,
@@ -205,6 +208,12 @@ impl EthConfig {
         self
     }
 
+    /// Configures whether to compute state roots for `eth_simulateV1` responses.
+    pub const fn compute_state_root_for_eth_simulate(mut self, enabled: bool) -> Self {
+        self.compute_state_root_for_eth_simulate = enabled;
+        self
+    }
+
     /// Configures the maximum proof window for historical proof generation.
     pub const fn eth_proof_window(mut self, window: u64) -> Self {
         self.eth_proof_window = window;
diff --git a/crates/rpc/rpc-eth-types/src/cache/config.rs b/crates/rpc/rpc-eth-types/src/cache/config.rs
index 1f908e57aa9..108f51c248e 100644
--- a/crates/rpc/rpc-eth-types/src/cache/config.rs
+++ b/crates/rpc/rpc-eth-types/src/cache/config.rs
@@ -3,8 +3,8 @@
 use serde::{Deserialize, Serialize};
 
 use reth_rpc_server_types::constants::cache::{
-    DEFAULT_BLOCK_CACHE_MAX_LEN, DEFAULT_CONCURRENT_DB_REQUESTS, DEFAULT_HEADER_CACHE_MAX_LEN,
-    DEFAULT_MAX_CACHED_TX_HASHES, DEFAULT_RECEIPT_CACHE_MAX_LEN,
+    DEFAULT_BAL_CACHE_MAX_LEN, DEFAULT_BLOCK_CACHE_MAX_LEN, DEFAULT_CONCURRENT_DB_REQUESTS,
+    DEFAULT_HEADER_CACHE_MAX_LEN, DEFAULT_MAX_CACHED_TX_HASHES, DEFAULT_RECEIPT_CACHE_MAX_LEN,
 };
 
 /// Settings for the [`EthStateCache`](super::EthStateCache).
@@ -23,6 +23,10 @@ pub struct EthStateCacheConfig {
     ///
     /// Default is 1000.
     pub max_headers: u32,
+    /// Max number of revm BALs in cache.
+    ///
+    /// Default is 1000.
+    pub max_bals: u32,
     /// Max number of concurrent database requests.
     ///
     /// Default is 512.
@@ -37,6 +41,7 @@ impl Default for EthStateCacheConfig {
             max_blocks: DEFAULT_BLOCK_CACHE_MAX_LEN,
             max_receipts: DEFAULT_RECEIPT_CACHE_MAX_LEN,
             max_headers: DEFAULT_HEADER_CACHE_MAX_LEN,
+            max_bals: DEFAULT_BAL_CACHE_MAX_LEN,
             max_concurrent_db_requests: DEFAULT_CONCURRENT_DB_REQUESTS,
             max_cached_tx_hashes: DEFAULT_MAX_CACHED_TX_HASHES,
         }
diff --git a/crates/rpc/rpc-eth-types/src/cache/mod.rs b/crates/rpc/rpc-eth-types/src/cache/mod.rs
index c4b487b15df..4ef466e5310 100644
--- a/crates/rpc/rpc-eth-types/src/cache/mod.rs
+++ b/crates/rpc/rpc-eth-types/src/cache/mod.rs
@@ -3,14 +3,23 @@
 use super::{EthStateCacheConfig, MultiConsumerLruCache};
 use crate::block::CachedTransaction;
 use alloy_consensus::{transaction::TxHashRef, BlockHeader};
+use alloy_eip7928::bal::DecodedBal;
 use alloy_eips::BlockHashOrNumber;
-use alloy_primitives::{TxHash, B256};
+use alloy_primitives::{Address, TxHash, B256};
 use futures::{stream::FuturesOrdered, Stream, StreamExt};
 use reth_chain_state::CanonStateNotification;
 use reth_errors::{ProviderError, ProviderResult};
 use reth_execution_types::Chain;
-use reth_primitives_traits::{Block, BlockBody, NodePrimitives, RecoveredBlock};
-use reth_storage_api::{BlockReader, TransactionVariant};
+use reth_primitives_traits::{Block, BlockBody, InMemorySize, NodePrimitives, RecoveredBlock};
+use reth_revm::{
+    bytecode::Bytecode,
+    primitives::{StorageKey, StorageValue},
+    state::bal::{
+        AccountBal as RevmAccountBal, AccountInfoBal as RevmAccountInfoBal, Bal as RevmBal,
+        BalWrites as RevmBalWrites, StorageBal as RevmStorageBal,
+    },
+};
+use reth_storage_api::{BalProvider, BlockReader, TransactionVariant};
 use reth_tasks::Runtime;
 use schnellru::{ByLength, Limiter, LruMap};
 use std::{
@@ -51,6 +60,9 @@ type CachedParentBlocksResponseSender<B> = oneshot::Sender<Vec<Arc<RecoveredBloc
 /// The type that can send the response for a transaction hash lookup
 type TransactionHashResponseSender<B, R> = oneshot::Sender<Option<CachedTransaction<B, R>>>;
 
+/// The type that can send the response to a requested revm BAL.
+type BalResponseSender = oneshot::Sender<ProviderResult<Option<CachedRevmBal>>>;
+
 type BlockLruCache<B, L> =
     MultiConsumerLruCache<B256, Arc<RecoveredBlock<B>>, L, BlockWithSendersResponseSender<B>>;
 
@@ -59,6 +71,8 @@ type ReceiptsLruCache<R, L> =
 
 type HeaderLruCache<H, L> = MultiConsumerLruCache<B256, H, L, HeaderResponseSender<H>>;
 
+type BalLruCache<L> = MultiConsumerLruCache<B256, CachedRevmBal, L, BalResponseSender>;
+
 /// Provides async access to cached eth data
 ///
 /// This is the frontend for the async caching service which manages cached data on a different
@@ -79,15 +93,19 @@ impl<N: NodePrimitives> EthStateCache<N> {
     fn create<Provider>(
         provider: Provider,
         action_task_spawner: Runtime,
-        max_blocks: u32,
-        max_receipts: u32,
-        max_headers: u32,
-        max_concurrent_db_operations: usize,
-        max_cached_tx_hashes: u32,
+        config: EthStateCacheConfig,
     ) -> (Self, EthStateCacheService<Provider, Runtime>)
     where
-        Provider: BlockReader<Block = N::Block, Receipt = N::Receipt>,
+        Provider: BlockReader<Block = N::Block, Receipt = N::Receipt> + BalProvider,
     {
+        let EthStateCacheConfig {
+            max_blocks,
+            max_receipts,
+            max_headers,
+            max_bals,
+            max_concurrent_db_requests,
+            max_cached_tx_hashes,
+        } = config;
         let (to_service, rx) = unbounded_channel();
 
         let service = EthStateCacheService {
@@ -95,10 +113,11 @@ impl<N: NodePrimitives> EthStateCache<N> {
             full_block_cache: BlockLruCache::new(max_blocks, "blocks"),
             receipts_cache: ReceiptsLruCache::new(max_receipts, "receipts"),
             headers_cache: HeaderLruCache::new(max_headers, "headers"),
+            bal_cache: BalLruCache::new(max_bals, "bals"),
             action_tx: to_service.clone(),
             action_rx: UnboundedReceiverStream::new(rx),
             action_task_spawner,
-            rate_limiter: Arc::new(Semaphore::new(max_concurrent_db_operations)),
+            rate_limiter: Arc::new(Semaphore::new(max_concurrent_db_requests)),
             tx_hash_index: LruMap::new(ByLength::new(max_cached_tx_hashes)),
         };
         let cache = Self { to_service };
@@ -115,24 +134,13 @@ impl<N: NodePrimitives> EthStateCache<N> {
         executor: Runtime,
     ) -> Self
     where
-        Provider: BlockReader<Block = N::Block, Receipt = N::Receipt> + Clone + Unpin + 'static,
+        Provider: BlockReader<Block = N::Block, Receipt = N::Receipt>
+            + BalProvider
+            + Clone
+            + Unpin
+            + 'static,
     {
-        let EthStateCacheConfig {
-            max_blocks,
-            max_receipts,
-            max_headers,
-            max_concurrent_db_requests,
-            max_cached_tx_hashes,
-        } = config;
-        let (this, service) = Self::create(
-            provider,
-            executor.clone(),
-            max_blocks,
-            max_receipts,
-            max_headers,
-            max_concurrent_db_requests,
-            max_cached_tx_hashes,
-        );
+        let (this, service) = Self::create(provider, executor.clone(), config);
         executor.spawn_critical_task("eth state cache", service);
         this
     }
@@ -265,6 +273,20 @@ impl<N: NodePrimitives> EthStateCache<N> {
         let _ = self.to_service.send(CacheAction::GetTransactionByHash { tx_hash, response_tx });
         rx.await.ok()?
     }
+
+    /// Requests the revm BAL for the block hash.
+    ///
+    /// Returns `None` if the BAL does not exist.
+    pub async fn get_bal(
+        &self,
+        block_hash: B256,
+    ) -> ProviderResult<Option<Arc<DecodedBal<RevmBal>>>> {
+        let (response_tx, rx) = oneshot::channel();
+        let _ = self.to_service.send(CacheAction::GetBal { block_hash, response_tx });
+        rx.await
+            .map_err(|_| CacheServiceUnavailable)?
+            .map(|maybe_bal| maybe_bal.map(|cached| cached.0))
+    }
 }
 /// Thrown when the cache service task dropped.
 #[derive(Debug, thiserror::Error)]
@@ -300,11 +322,13 @@ pub(crate) struct EthStateCacheService<
     LimitBlocks = ByLength,
     LimitReceipts = ByLength,
     LimitHeaders = ByLength,
+    LimitBals = ByLength,
 > where
-    Provider: BlockReader,
+    Provider: BlockReader + BalProvider,
     LimitBlocks: Limiter<B256, Arc<RecoveredBlock<Provider::Block>>>,
     LimitReceipts: Limiter<B256, Arc<Vec<Provider::Receipt>>>,
     LimitHeaders: Limiter<B256, Provider::Header>,
+    LimitBals: Limiter<B256, CachedRevmBal>,
 {
     /// The type used to lookup data from disk
     provider: Provider,
@@ -317,6 +341,8 @@ pub(crate) struct EthStateCacheService<
     /// Headers are cached because they are required to populate the environment for execution
     /// (evm).
     headers_cache: HeaderLruCache<Provider::Header, LimitHeaders>,
+    /// The LRU cache for revm BALs grouped by the block hash.
+    bal_cache: BalLruCache<LimitBals>,
     /// Sender half of the action channel.
     action_tx: UnboundedSender<CacheAction<Provider::Block, Provider::Receipt>>,
     /// Receiver half of the action channel.
@@ -333,7 +359,7 @@ pub(crate) struct EthStateCacheService<
 
 impl<Provider> EthStateCacheService<Provider, Runtime>
 where
-    Provider: BlockReader + Clone + Unpin + 'static,
+    Provider: BlockReader + BalProvider + Clone + Unpin + 'static,
 {
     /// Indexes all transactions in a block by transaction hash.
     fn index_block_transactions(&mut self, block: &RecoveredBlock<Provider::Block>) {
@@ -386,6 +412,18 @@ where
         }
     }
 
+    fn on_new_bal(&mut self, block_hash: B256, res: ProviderResult<Option<CachedRevmBal>>) {
+        if let Some(queued) = self.bal_cache.remove(&block_hash) {
+            for tx in queued {
+                let _ = tx.send(res.clone());
+            }
+        }
+
+        if let Ok(Some(bal)) = res {
+            self.bal_cache.insert(block_hash, bal);
+        }
+    }
+
     fn on_reorg_block(
         &mut self,
         block_hash: B256,
@@ -422,24 +460,34 @@ where
         }
     }
 
+    fn on_reorg_bal(&mut self, block_hash: B256, res: ProviderResult<Option<CachedRevmBal>>) {
+        if let Some(queued) = self.bal_cache.remove(&block_hash) {
+            for tx in queued {
+                let _ = tx.send(res.clone());
+            }
+        }
+    }
+
     /// Shrinks the queues but leaves some space for the next requests
     fn shrink_queues(&mut self) {
         let min_capacity = 2;
         self.full_block_cache.shrink_to(min_capacity);
         self.receipts_cache.shrink_to(min_capacity);
         self.headers_cache.shrink_to(min_capacity);
+        self.bal_cache.shrink_to(min_capacity);
     }
 
     fn update_cached_metrics(&self) {
         self.full_block_cache.update_cached_metrics();
         self.receipts_cache.update_cached_metrics();
         self.headers_cache.update_cached_metrics();
+        self.bal_cache.update_cached_metrics();
     }
 }
 
 impl<Provider> Future for EthStateCacheService<Provider, Runtime>
 where
-    Provider: BlockReader + Clone + Unpin + 'static,
+    Provider: BlockReader + BalProvider + Clone + Unpin + 'static,
 {
     type Output = ();
 
@@ -554,9 +602,34 @@ where
                                 });
                             }
                         }
+                        CacheAction::GetBal { block_hash, response_tx } => {
+                            if let Some(bal) = this.bal_cache.get(&block_hash).cloned() {
+                                let _ = response_tx.send(Ok(Some(bal)));
+                                continue
+                            }
+
+                            if this.bal_cache.queue(block_hash, response_tx) {
+                                let provider = this.provider.clone();
+                                let action_tx = this.action_tx.clone();
+                                let rate_limiter = this.rate_limiter.clone();
+                                let mut action_sender =
+                                    ActionSender::new(CacheKind::Bal, block_hash, action_tx);
+                                this.action_task_spawner.spawn_blocking_task(async move {
+                                    let _permit = rate_limiter.acquire().await;
+                                    let res = provider
+                                        .bal_store()
+                                        .revm_bal_by_hash(block_hash)
+                                        .map(|maybe_bal| maybe_bal.map(CachedRevmBal::new));
+                                    action_sender.send_bal(res);
+                                });
+                            }
+                        }
                         CacheAction::ReceiptsResult { block_hash, res } => {
                             this.on_new_receipts(block_hash, res);
                         }
+                        CacheAction::BalResult { block_hash, res } => {
+                            this.on_new_bal(block_hash, res);
+                        }
                         CacheAction::BlockWithSendersResult { block_hash, res } => match res {
                             Ok(Some(block_with_senders)) => {
                                 this.on_new_block(block_hash, Ok(Some(block_with_senders)));
@@ -604,6 +677,7 @@ where
                                 this.remove_block_transactions(&block);
                                 this.on_reorg_block(block_hash, Ok(Some(block)));
                                 this.on_reorg_header(block_hash, Ok(header));
+                                this.on_reorg_bal(block_hash, Ok(None));
                             }
 
                             for block_receipts in chain_change.receipts {
@@ -668,6 +742,10 @@ enum CacheAction<B: Block, R> {
         block_hash: B256,
         response_tx: ReceiptsResponseSender<R>,
     },
+    GetBal {
+        block_hash: B256,
+        response_tx: BalResponseSender,
+    },
     GetCachedBlock {
         block_hash: B256,
         response_tx: CachedBlockResponseSender<B>,
@@ -688,6 +766,10 @@ enum CacheAction<B: Block, R> {
         block_hash: B256,
         res: Box<ProviderResult<B::Header>>,
     },
+    BalResult {
+        block_hash: B256,
+        res: ProviderResult<Option<CachedRevmBal>>,
+    },
     CacheNewCanonicalChain {
         chain_change: ChainChange<B, R>,
     },
@@ -740,6 +822,7 @@ enum CacheKind {
     Block,
     Receipt,
     Header,
+    Bal,
 }
 
 /// Drop aware sender struct that ensures a response is always emitted even if the db task panics
@@ -782,6 +865,12 @@ impl<R: Send + Sync, B: Block> ActionSender<B, R> {
             });
         }
     }
+
+    fn send_bal(&mut self, bal: Result<Option<CachedRevmBal>, ProviderError>) {
+        if let Some(tx) = self.tx.take() {
+            let _ = tx.send(CacheAction::BalResult { block_hash: self.blockhash, res: bal });
+        }
+    }
 }
 impl<R: Send + Sync, B: Block> Drop for ActionSender<B, R> {
     fn drop(&mut self) {
@@ -799,6 +888,10 @@ impl<R: Send + Sync, B: Block> Drop for ActionSender<B, R> {
                     block_hash: self.blockhash,
                     res: Box::new(Err(CacheServiceUnavailable.into())),
                 },
+                CacheKind::Bal => CacheAction::BalResult {
+                    block_hash: self.blockhash,
+                    res: Err(CacheServiceUnavailable.into()),
+                },
             };
             let _ = tx.send(msg);
         }
@@ -830,30 +923,107 @@ pub async fn cache_new_blocks_task<St, N: NodePrimitives>(
     }
 }
 
+/// Cached decoded revm BAL.
+#[derive(Clone, Debug)]
+pub(crate) struct CachedRevmBal(Arc<DecodedBal<RevmBal>>);
+
+impl CachedRevmBal {
+    /// Creates a cached revm BAL from an owned decoded BAL.
+    #[inline]
+    fn new(bal: DecodedBal<RevmBal>) -> Self {
+        Self(Arc::new(bal))
+    }
+}
+
+impl InMemorySize for CachedRevmBal {
+    fn size(&self) -> usize {
+        core::mem::size_of::<Self>() + decoded_revm_bal_size(&self.0)
+    }
+}
+
+fn decoded_revm_bal_size(bal: &DecodedBal<RevmBal>) -> usize {
+    core::mem::size_of::<DecodedBal<RevmBal>>() + bal.as_raw().len() + revm_bal_size(bal.as_bal())
+}
+
+fn revm_bal_size(bal: &RevmBal) -> usize {
+    core::mem::size_of::<RevmBal>() +
+        bal.accounts.capacity() * core::mem::size_of::<(Address, RevmAccountBal)>() +
+        bal.accounts.values().map(revm_account_bal_heap_size).sum::<usize>()
+}
+
+fn revm_account_bal_heap_size(account: &RevmAccountBal) -> usize {
+    revm_account_info_bal_heap_size(&account.account_info) +
+        revm_storage_bal_heap_size(&account.storage)
+}
+
+fn revm_account_info_bal_heap_size(account_info: &RevmAccountInfoBal) -> usize {
+    revm_bal_writes_heap_size(&account_info.nonce, |_| 0) +
+        revm_bal_writes_heap_size(&account_info.balance, |_| 0) +
+        revm_bal_writes_heap_size(&account_info.code, revm_code_write_heap_size)
+}
+
+fn revm_storage_bal_heap_size(storage: &RevmStorageBal) -> usize {
+    storage.storage.len() * core::mem::size_of::<(StorageKey, RevmBalWrites<StorageValue>)>() +
+        storage
+            .storage
+            .values()
+            .map(|writes| revm_bal_writes_heap_size(writes, |_| 0))
+            .sum::<usize>()
+}
+
+fn revm_bal_writes_heap_size<T, F>(writes: &RevmBalWrites<T>, mut item_heap_size: F) -> usize
+where
+    T: PartialEq + Clone,
+    F: FnMut(&T) -> usize,
+{
+    writes.writes.capacity() * core::mem::size_of::<(u64, T)>() +
+        writes.writes.iter().map(|(_, item)| item_heap_size(item)).sum::<usize>()
+}
+
+fn revm_code_write_heap_size((_, bytecode): &(B256, Bytecode)) -> usize {
+    bytecode.bytes_ref().len()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy_consensus::Header;
-    use alloy_primitives::{Address, Signature};
+    use alloy_consensus::{transaction::TransactionMeta, Header};
+    use alloy_eip7928::BlockAccessIndex;
+    use alloy_eips::{BlockHashOrNumber, NumHash};
+    use alloy_primitives::{Address, BlockHash, BlockNumber, Bytes, Signature, TxHash, TxNumber};
+    use core::ops::{RangeBounds, RangeInclusive};
+    use reth_db_models::StoredBlockBodyIndices;
     use reth_ethereum_primitives::{
-        Block, BlockBody, EthPrimitives, Transaction, TransactionSigned,
+        Block, BlockBody, EthPrimitives, Receipt, Transaction, TransactionSigned,
     };
-    use reth_primitives_traits::RecoveredBlock;
-    use reth_storage_api::noop::NoopProvider;
+    use reth_primitives_traits::{RecoveredBlock, SealedHeader};
+    use reth_storage_api::{
+        noop::NoopProvider, BalProvider, BalStore, BalStoreHandle, BlockBodyIndicesProvider,
+        BlockHashReader, BlockNumReader, BlockReader, BlockSource, HeaderProvider, ReceiptProvider,
+        TransactionVariant, TransactionsProvider,
+    };
+    use std::sync::atomic::{AtomicUsize, Ordering};
 
     fn test_service() -> EthStateCacheService<NoopProvider, Runtime> {
         let (_cache, service) = EthStateCache::<EthPrimitives>::create(
             NoopProvider::default(),
             Runtime::test(),
-            4,
-            4,
-            4,
-            1,
-            16,
+            EthStateCacheConfig {
+                max_blocks: 4,
+                max_receipts: 4,
+                max_headers: 4,
+                max_bals: 4,
+                max_concurrent_db_requests: 1,
+                max_cached_tx_hashes: 16,
+            },
         );
         service
     }
 
+    fn test_decoded_revm_bal() -> DecodedBal<RevmBal> {
+        DecodedBal::new(RevmBal::default(), Bytes::from_static(&[0xc0]))
+    }
+
     fn test_block() -> RecoveredBlock<Block> {
         RecoveredBlock::new_unhashed(
             Block {
@@ -914,4 +1084,404 @@ mod tests {
 
         assert!(service.tx_hash_index.get(&tx_hash).is_none());
     }
+
+    #[test]
+    fn reorg_evicts_cached_bal() {
+        let mut service = test_service();
+        let block_hash = B256::repeat_byte(0x44);
+
+        assert!(service.bal_cache.insert(block_hash, CachedRevmBal::new(test_decoded_revm_bal())));
+        assert!(service.bal_cache.get(&block_hash).is_some());
+
+        service.on_reorg_bal(block_hash, Ok(None));
+
+        assert!(service.bal_cache.get(&block_hash).is_none());
+    }
+
+    #[test]
+    fn reorg_forwards_bal_to_queued_requests() {
+        let mut service = test_service();
+        let block_hash = B256::repeat_byte(0x55);
+        let (response_tx, mut response_rx) = oneshot::channel();
+        let bal = CachedRevmBal::new(test_decoded_revm_bal());
+
+        assert!(service.bal_cache.queue(block_hash, response_tx));
+
+        service.on_reorg_bal(block_hash, Ok(Some(bal)));
+
+        let bal = response_rx.try_recv().expect("queued BAL response").expect("BAL result");
+
+        assert!(bal.is_some());
+    }
+
+    #[test]
+    fn cached_revm_bal_size_accounts_for_nested_allocations() {
+        let mut account = RevmAccountBal::default();
+        account.account_info.nonce.writes.push((BlockAccessIndex::new(1), 1));
+        account
+            .account_info
+            .balance
+            .writes
+            .push((BlockAccessIndex::new(2), StorageValue::from(1u64)));
+        account.account_info.code.writes.push((
+            BlockAccessIndex::new(3),
+            (B256::repeat_byte(0xaa), Bytecode::new_raw(Bytes::from_static(&[0x60, 0x00]))),
+        ));
+        account.storage.storage.insert(
+            StorageKey::from(1u64),
+            RevmBalWrites::new(vec![(BlockAccessIndex::new(4), StorageValue::from(2u64))]),
+        );
+
+        let mut bal = RevmBal::default();
+        bal.accounts.insert(Address::ZERO, account);
+
+        let raw = Bytes::from_static(&[0xc0, 0x01, 0x02]);
+        let previous_estimate = core::mem::size_of::<CachedRevmBal>() +
+            core::mem::size_of::<DecodedBal<RevmBal>>() +
+            raw.len() +
+            core::mem::size_of::<RevmBal>();
+        assert!(CachedRevmBal::new(DecodedBal::new(bal, raw)).size() > previous_estimate);
+    }
+
+    #[tokio::test]
+    async fn get_bal_uses_cached_revm_bal() {
+        let fetches = Arc::new(AtomicUsize::default());
+        let provider = TestBalProvider::new(fetches.clone());
+        let cache = EthStateCache::<EthPrimitives>::spawn_with(
+            provider,
+            EthStateCacheConfig {
+                max_blocks: 0,
+                max_receipts: 0,
+                max_headers: 0,
+                max_bals: 4,
+                max_concurrent_db_requests: 1,
+                max_cached_tx_hashes: 0,
+            },
+            Runtime::test(),
+        );
+        let block_hash = B256::repeat_byte(0x66);
+
+        assert!(cache.get_bal(block_hash).await.unwrap().is_some());
+        assert!(cache.get_bal(block_hash).await.unwrap().is_some());
+
+        assert_eq!(fetches.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn concurrent_get_bal_requests_share_fetch() {
+        let fetches = Arc::new(AtomicUsize::default());
+        let provider = TestBalProvider::new(fetches.clone());
+        let cache = EthStateCache::<EthPrimitives>::spawn_with(
+            provider,
+            EthStateCacheConfig {
+                max_blocks: 0,
+                max_receipts: 0,
+                max_headers: 0,
+                max_bals: 4,
+                max_concurrent_db_requests: 1,
+                max_cached_tx_hashes: 0,
+            },
+            Runtime::test(),
+        );
+        let block_hash = B256::repeat_byte(0x77);
+
+        let (first, second) = tokio::join!(cache.get_bal(block_hash), cache.get_bal(block_hash));
+
+        assert!(first.unwrap().is_some());
+        assert!(second.unwrap().is_some());
+        assert_eq!(fetches.load(Ordering::SeqCst), 1);
+    }
+
+    #[derive(Clone, Debug, Default)]
+    struct TestBalProvider {
+        bal_store: BalStoreHandle,
+    }
+
+    impl TestBalProvider {
+        fn new(fetches: Arc<AtomicUsize>) -> Self {
+            Self { bal_store: BalStoreHandle::new(TestBalStore { fetches }) }
+        }
+    }
+
+    impl BalProvider for TestBalProvider {
+        fn bal_store(&self) -> &BalStoreHandle {
+            &self.bal_store
+        }
+    }
+
+    #[derive(Debug)]
+    struct TestBalStore {
+        fetches: Arc<AtomicUsize>,
+    }
+
+    impl BalStore for TestBalStore {
+        fn insert(
+            &self,
+            _num_hash: NumHash,
+            _bal: reth_storage_api::SealedBal,
+        ) -> ProviderResult<()> {
+            Ok(())
+        }
+
+        fn prune(&self, _tip: BlockNumber) -> ProviderResult<usize> {
+            Ok(0)
+        }
+
+        fn get_by_hashes(&self, block_hashes: &[BlockHash]) -> ProviderResult<Vec<Option<Bytes>>> {
+            Ok(block_hashes.iter().map(|_| None).collect())
+        }
+
+        fn revm_bal_by_hash(
+            &self,
+            _block_hash: BlockHash,
+        ) -> ProviderResult<Option<DecodedBal<RevmBal>>> {
+            self.fetches.fetch_add(1, Ordering::SeqCst);
+            Ok(Some(test_decoded_revm_bal()))
+        }
+
+        fn bal_stream(&self) -> reth_storage_api::BalNotificationStream {
+            reth_storage_api::NoopBalStore.bal_stream()
+        }
+    }
+
+    impl BlockHashReader for TestBalProvider {
+        fn block_hash(&self, _number: BlockNumber) -> ProviderResult<Option<B256>> {
+            Ok(None)
+        }
+
+        fn canonical_hashes_range(
+            &self,
+            _start: BlockNumber,
+            _end: BlockNumber,
+        ) -> ProviderResult<Vec<B256>> {
+            Ok(Vec::new())
+        }
+    }
+
+    impl BlockNumReader for TestBalProvider {
+        fn chain_info(&self) -> ProviderResult<reth_chainspec::ChainInfo> {
+            Ok(reth_chainspec::ChainInfo::default())
+        }
+
+        fn best_block_number(&self) -> ProviderResult<BlockNumber> {
+            Ok(0)
+        }
+
+        fn last_block_number(&self) -> ProviderResult<BlockNumber> {
+            Ok(0)
+        }
+
+        fn block_number(&self, _hash: B256) -> ProviderResult<Option<BlockNumber>> {
+            Ok(None)
+        }
+    }
+
+    impl HeaderProvider for TestBalProvider {
+        type Header = Header;
+
+        fn header(&self, _block_hash: BlockHash) -> ProviderResult<Option<Self::Header>> {
+            Ok(None)
+        }
+
+        fn header_by_number(&self, _num: u64) -> ProviderResult<Option<Self::Header>> {
+            Ok(None)
+        }
+
+        fn headers_range(
+            &self,
+            _range: impl RangeBounds<BlockNumber>,
+        ) -> ProviderResult<Vec<Self::Header>> {
+            Ok(Vec::new())
+        }
+
+        fn sealed_header(
+            &self,
+            _number: BlockNumber,
+        ) -> ProviderResult<Option<SealedHeader<Self::Header>>> {
+            Ok(None)
+        }
+
+        fn sealed_headers_while(
+            &self,
+            _range: impl RangeBounds<BlockNumber>,
+            _predicate: impl FnMut(&SealedHeader<Self::Header>) -> bool,
+        ) -> ProviderResult<Vec<SealedHeader<Self::Header>>> {
+            Ok(Vec::new())
+        }
+    }
+
+    impl BlockBodyIndicesProvider for TestBalProvider {
+        fn block_body_indices(&self, _num: u64) -> ProviderResult<Option<StoredBlockBodyIndices>> {
+            Ok(None)
+        }
+
+        fn block_body_indices_range(
+            &self,
+            _range: RangeInclusive<BlockNumber>,
+        ) -> ProviderResult<Vec<StoredBlockBodyIndices>> {
+            Ok(Vec::new())
+        }
+    }
+
+    impl TransactionsProvider for TestBalProvider {
+        type Transaction = TransactionSigned;
+
+        fn transaction_id(&self, _tx_hash: TxHash) -> ProviderResult<Option<TxNumber>> {
+            Ok(None)
+        }
+
+        fn transaction_by_id(&self, _id: TxNumber) -> ProviderResult<Option<Self::Transaction>> {
+            Ok(None)
+        }
+
+        fn transaction_by_id_unhashed(
+            &self,
+            _id: TxNumber,
+        ) -> ProviderResult<Option<Self::Transaction>> {
+            Ok(None)
+        }
+
+        fn transaction_by_hash(&self, _hash: TxHash) -> ProviderResult<Option<Self::Transaction>> {
+            Ok(None)
+        }
+
+        fn transaction_by_hash_with_meta(
+            &self,
+            _hash: TxHash,
+        ) -> ProviderResult<Option<(Self::Transaction, TransactionMeta)>> {
+            Ok(None)
+        }
+
+        fn transactions_by_block(
+            &self,
+            _block: BlockHashOrNumber,
+        ) -> ProviderResult<Option<Vec<Self::Transaction>>> {
+            Ok(None)
+        }
+
+        fn transactions_by_block_range(
+            &self,
+            _range: impl RangeBounds<BlockNumber>,
+        ) -> ProviderResult<Vec<Vec<Self::Transaction>>> {
+            Ok(Vec::new())
+        }
+
+        fn transactions_by_tx_range(
+            &self,
+            _range: impl RangeBounds<TxNumber>,
+        ) -> ProviderResult<Vec<Self::Transaction>> {
+            Ok(Vec::new())
+        }
+
+        fn senders_by_tx_range(
+            &self,
+            _range: impl RangeBounds<TxNumber>,
+        ) -> ProviderResult<Vec<Address>> {
+            Ok(Vec::new())
+        }
+
+        fn transaction_sender(&self, _id: TxNumber) -> ProviderResult<Option<Address>> {
+            Ok(None)
+        }
+    }
+
+    impl ReceiptProvider for TestBalProvider {
+        type Receipt = Receipt;
+
+        fn receipt(&self, _id: TxNumber) -> ProviderResult<Option<Self::Receipt>> {
+            Ok(None)
+        }
+
+        fn receipt_by_hash(&self, _hash: TxHash) -> ProviderResult<Option<Self::Receipt>> {
+            Ok(None)
+        }
+
+        fn receipts_by_block(
+            &self,
+            _block: BlockHashOrNumber,
+        ) -> ProviderResult<Option<Vec<Self::Receipt>>> {
+            Ok(None)
+        }
+
+        fn receipts_by_tx_range(
+            &self,
+            _range: impl RangeBounds<TxNumber>,
+        ) -> ProviderResult<Vec<Self::Receipt>> {
+            Ok(Vec::new())
+        }
+
+        fn receipts_by_block_range(
+            &self,
+            _block_range: RangeInclusive<BlockNumber>,
+        ) -> ProviderResult<Vec<Vec<Self::Receipt>>> {
+            Ok(Vec::new())
+        }
+    }
+
+    impl BlockReader for TestBalProvider {
+        type Block = Block;
+
+        fn find_block_by_hash(
+            &self,
+            _hash: B256,
+            _source: BlockSource,
+        ) -> ProviderResult<Option<Self::Block>> {
+            Ok(None)
+        }
+
+        fn block(&self, _id: BlockHashOrNumber) -> ProviderResult<Option<Self::Block>> {
+            Ok(None)
+        }
+
+        fn pending_block(&self) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
+            Ok(None)
+        }
+
+        fn pending_block_and_receipts(
+            &self,
+        ) -> ProviderResult<Option<(RecoveredBlock<Self::Block>, Vec<Self::Receipt>)>> {
+            Ok(None)
+        }
+
+        fn recovered_block(
+            &self,
+            _id: BlockHashOrNumber,
+            _transaction_kind: TransactionVariant,
+        ) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
+            Ok(None)
+        }
+
+        fn sealed_block_with_senders(
+            &self,
+            _id: BlockHashOrNumber,
+            _transaction_kind: TransactionVariant,
+        ) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
+            Ok(None)
+        }
+
+        fn block_range(
+            &self,
+            _range: RangeInclusive<BlockNumber>,
+        ) -> ProviderResult<Vec<Self::Block>> {
+            Ok(Vec::new())
+        }
+
+        fn block_with_senders_range(
+            &self,
+            _range: RangeInclusive<BlockNumber>,
+        ) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
+            Ok(Vec::new())
+        }
+
+        fn recovered_block_range(
+            &self,
+            _range: RangeInclusive<BlockNumber>,
+        ) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
+            Ok(Vec::new())
+        }
+
+        fn block_by_transaction_id(&self, _id: TxNumber) -> ProviderResult<Option<BlockNumber>> {
+            Ok(None)
+        }
+    }
 }
diff --git a/crates/rpc/rpc-eth-types/src/capabilities.rs b/crates/rpc/rpc-eth-types/src/capabilities.rs
new file mode 100644
index 00000000000..bd3cc7a11b2
--- /dev/null
+++ b/crates/rpc/rpc-eth-types/src/capabilities.rs
@@ -0,0 +1,153 @@
+//! Types for `eth_capabilities`.
+
+use alloy_primitives::{B256, U64};
+use serde::{Deserialize, Serialize};
+
+/// Effective routing capabilities for the `eth` namespace.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EthCapabilities {
+    /// Current chain head.
+    pub head: EthCapabilitiesHead,
+    /// Account and storage state availability.
+    pub state: EthCapabilitiesResource,
+    /// Transaction lookup availability.
+    pub tx: EthCapabilitiesResource,
+    /// Log query availability.
+    pub logs: EthCapabilitiesResource,
+    /// Receipt availability.
+    pub receipts: EthCapabilitiesResource,
+    /// Block header and body availability.
+    pub blocks: EthCapabilitiesResource,
+    /// State proof availability.
+    #[serde(rename = "stateproofs")]
+    pub state_proofs: EthCapabilitiesResource,
+}
+
+/// Current head block.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EthCapabilitiesHead {
+    /// Head block number.
+    #[serde(with = "alloy_serde::quantity")]
+    pub number: u64,
+    /// Head block hash.
+    pub hash: B256,
+}
+
+/// Effective capability for one resource.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EthCapabilitiesResource {
+    /// Whether this resource is unavailable.
+    pub disabled: bool,
+    /// Oldest block expected to be served correctly.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub oldest_block: Option<U64>,
+    /// Deletion strategy, if the resource is pruned by a sliding window.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub delete_strategy: Option<EthCapabilitiesDeleteStrategy>,
+}
+
+impl EthCapabilitiesResource {
+    /// Creates an enabled resource available from the given oldest block.
+    pub fn available_from(oldest_block: u64) -> Self {
+        Self { disabled: false, oldest_block: Some(U64::from(oldest_block)), delete_strategy: None }
+    }
+
+    /// Creates an enabled resource with a sliding window deletion strategy.
+    pub fn window(oldest_block: u64, retention_blocks: u64) -> Self {
+        Self {
+            disabled: false,
+            oldest_block: Some(U64::from(oldest_block)),
+            delete_strategy: Some(EthCapabilitiesDeleteStrategy {
+                strategy_type: EthCapabilitiesDeleteStrategyKind::Window,
+                retention_blocks,
+            }),
+        }
+    }
+
+    /// Creates a disabled resource.
+    pub const fn disabled() -> Self {
+        Self { disabled: true, oldest_block: None, delete_strategy: None }
+    }
+}
+
+/// Deletion strategy for a resource.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EthCapabilitiesDeleteStrategy {
+    /// Strategy type.
+    #[serde(rename = "type")]
+    pub strategy_type: EthCapabilitiesDeleteStrategyKind,
+    /// Number of blocks retained by the sliding window.
+    pub retention_blocks: u64,
+}
+
+/// Deletion strategy kind.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum EthCapabilitiesDeleteStrategyKind {
+    /// Sliding window deletion.
+    #[serde(rename = "window")]
+    Window,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy_primitives::B256;
+    use serde_json::json;
+
+    #[test]
+    fn serializes_capabilities_schema_shape() {
+        let capabilities = EthCapabilities {
+            head: EthCapabilitiesHead { number: 1, hash: B256::ZERO },
+            state: EthCapabilitiesResource::window(10, 90),
+            tx: EthCapabilitiesResource::available_from(0),
+            logs: EthCapabilitiesResource::available_from(0),
+            receipts: EthCapabilitiesResource::available_from(0),
+            blocks: EthCapabilitiesResource::available_from(0),
+            state_proofs: EthCapabilitiesResource::disabled(),
+        };
+
+        let value = serde_json::to_value(capabilities).unwrap();
+
+        assert_eq!(
+            value,
+            json!({
+                "head": {
+                    "number": "0x1",
+                    "hash": B256::ZERO,
+                },
+                "state": {
+                    "disabled": false,
+                    "oldestBlock": "0xa",
+                    "deleteStrategy": {
+                        "type": "window",
+                        "retentionBlocks": 90,
+                    },
+                },
+                "tx": {
+                    "disabled": false,
+                    "oldestBlock": "0x0",
+                },
+                "logs": {
+                    "disabled": false,
+                    "oldestBlock": "0x0",
+                },
+                "receipts": {
+                    "disabled": false,
+                    "oldestBlock": "0x0",
+                },
+                "blocks": {
+                    "disabled": false,
+                    "oldestBlock": "0x0",
+                },
+                "stateproofs": {
+                    "disabled": true,
+                },
+            })
+        );
+    }
+}
diff --git a/crates/rpc/rpc-eth-types/src/lib.rs b/crates/rpc/rpc-eth-types/src/lib.rs
index ef234e33aad..fec783da17a 100644
--- a/crates/rpc/rpc-eth-types/src/lib.rs
+++ b/crates/rpc/rpc-eth-types/src/lib.rs
@@ -14,6 +14,7 @@ use url as _;
 pub mod block;
 pub mod builder;
 pub mod cache;
+pub mod capabilities;
 pub mod error;
 pub mod fee_history;
 pub mod gas_oracle;
@@ -33,6 +34,7 @@ pub use cache::{
     config::EthStateCacheConfig, db::StateCacheDb, multi_consumer::MultiConsumerLruCache,
     EthStateCache,
 };
+pub use capabilities::{EthCapabilities, EthCapabilitiesHead, EthCapabilitiesResource};
 pub use error::{EthApiError, EthResult, RevertError, RpcInvalidTransactionError, SignError};
 pub use fee_history::{FeeHistoryCache, FeeHistoryCacheConfig, FeeHistoryEntry};
 pub use gas_oracle::{
diff --git a/crates/rpc/rpc-eth-types/src/logs_utils.rs b/crates/rpc/rpc-eth-types/src/logs_utils.rs
index 3abf4aea759..8d9100c4944 100644
--- a/crates/rpc/rpc-eth-types/src/logs_utils.rs
+++ b/crates/rpc/rpc-eth-types/src/logs_utils.rs
@@ -2,8 +2,8 @@
 //!
 //! Log parsing for building filter.
 
-use alloy_consensus::TxReceipt;
-use alloy_eips::{eip2718::Encodable2718, BlockNumHash};
+use alloy_consensus::{transaction::TxHashRef, TxReceipt};
+use alloy_eips::BlockNumHash;
 use alloy_primitives::TxHash;
 use alloy_rpc_types_eth::{Filter, Log};
 use reth_chainspec::ChainInfo;
@@ -102,7 +102,7 @@ where
                 if transaction_hash.is_none() {
                     transaction_hash = match &provider_or_block {
                         ProviderOrBlock::Block(block) => {
-                            block.body().transactions().get(receipt_idx).map(|t| t.trie_hash())
+                            block.body().transactions().get(receipt_idx).map(|t| *t.tx_hash())
                         }
                         ProviderOrBlock::Provider(provider) => {
                             let first_tx_num = match loaded_first_tx_num {
@@ -126,7 +126,7 @@ where
                                     ProviderError::TransactionNotFound(transaction_id.into())
                                 })?;
 
-                            Some(transaction.trie_hash())
+                            Some(*transaction.tx_hash())
                         }
                     };
                 }
diff --git a/crates/rpc/rpc-eth-types/src/simulate.rs b/crates/rpc/rpc-eth-types/src/simulate.rs
index 7946459cfe3..a484e979035 100644
--- a/crates/rpc/rpc-eth-types/src/simulate.rs
+++ b/crates/rpc/rpc-eth-types/src/simulate.rs
@@ -4,24 +4,27 @@ use crate::{
     error::{api::FromEthApiError, FromEvmError, ToRpcError},
     EthApiError,
 };
+use alloy_chains::Chain;
 use alloy_consensus::{transaction::TxHashRef, BlockHeader, Transaction as _};
 use alloy_eips::eip2718::WithEncoded;
 use alloy_evm::{block::TxResult, precompiles::PrecompilesMap};
 use alloy_network::{NetworkTransactionBuilder, TransactionBuilder};
 use alloy_rpc_types_eth::{
-    simulate::{SimCallResult, SimulateError, SimulatedBlock},
+    simulate::{SimBlock, SimCallResult, SimulateError, SimulatedBlock},
     state::StateOverride,
-    BlockTransactionsKind,
+    BlockOverrides, BlockTransactionsKind,
 };
 use jsonrpsee_types::ErrorObject;
 use reth_evm::{
     execute::{BlockBuilder, BlockBuilderOutcome, BlockExecutor},
     Evm, HaltReasonFor,
 };
-use reth_primitives_traits::{BlockBody as _, BlockTy, NodePrimitives, Recovered, RecoveredBlock};
+use reth_primitives_traits::{
+    BlockBody as _, BlockTy, NodePrimitives, Recovered, RecoveredBlock, SealedHeader,
+};
 use reth_rpc_convert::{RpcBlock, RpcConvert, RpcTxReq};
 use reth_rpc_server_types::result::rpc_err;
-use reth_storage_api::noop::NoopProvider;
+use reth_storage_api::{noop::NoopProvider, StateProvider};
 use revm::{
     context::Block,
     context_interface::result::ExecutionResult,
@@ -29,6 +32,10 @@ use revm::{
     Database,
 };
 
+/// Fallback seconds added between simulated block timestamps when neither the user nor the chain
+/// hint provides a value.
+const SIMULATE_FALLBACK_TIMESTAMP_INCREMENT: u64 = 12;
+
 /// Error code for execution reverted in `eth_simulateV1`.
 ///
 /// Consistent with `eth_call` revert error code.
@@ -103,6 +110,9 @@ pub enum EthSimulateError {
     /// Attempted to move a non-precompile address.
     #[error("account {0} is not a precompile")]
     NotAPrecompile(Address),
+    /// Attempted to move a precompile to its own address.
+    #[error("cannot move precompile {0} to itself")]
+    MovePrecompileToSelf(Address),
 }
 
 impl EthSimulateError {
@@ -120,6 +130,7 @@ impl EthSimulateError {
             Self::SenderNotEOA => -38024,
             Self::MaxInitCodeSizeExceeded => -38025,
             Self::TooManyBlocks | Self::GasLimitReached => -38026,
+            Self::MovePrecompileToSelf(_) => -38022,
             Self::NotAPrecompile(_) => -32000,
         }
     }
@@ -131,6 +142,107 @@ impl ToRpcError for EthSimulateError {
     }
 }
 
+/// Sanitizes and gap-fills the chain of [`SimBlock`]s for `eth_simulateV1`.
+///
+/// Walks the provided block-state calls in order and:
+/// - validates that each block number and timestamp strictly increases relative to the parent and
+///   prior simulated block;
+/// - inserts empty filler blocks for every gap in block numbers, so a request like `[block at
+///   number N + k]` over a parent at `N` expands to `k - 1` empty blocks followed by the requested
+///   one (per the execution-apis spec: "If the block number is increased more than `1` compared to
+///   the previous block, new empty blocks are generated in between.");
+/// - assigns default block numbers (`prev_number + 1`) and timestamps (`prev_timestamp + chain
+///   block time`) when missing, so every returned entry has explicit `number` and `time` overrides.
+///   The block time defaults to [`Chain::average_blocktime_hint`] for the chain id, falling back to
+///   `SIMULATE_FALLBACK_TIMESTAMP_INCREMENT` when no hint is registered. Sub-second chain hints are
+///   rounded up because block timestamps are second-granular;
+/// - enforces the global `max_simulate_blocks` cap on the total number of blocks (including
+///   generated fillers).
+pub fn sanitize_chain<TxReq, H>(
+    blocks: Vec<SimBlock<TxReq>>,
+    parent: &SealedHeader<H>,
+    chain_id: u64,
+    max_simulate_blocks: u64,
+) -> Result<Vec<SimBlock<TxReq>>, EthApiError>
+where
+    H: BlockHeader,
+{
+    let timestamp_increment = Chain::from(chain_id)
+        .average_blocktime_hint()
+        .map(|d| d.as_secs().saturating_add(u64::from(d.subsec_nanos() > 0)))
+        .filter(|&s| s > 0)
+        .unwrap_or(SIMULATE_FALLBACK_TIMESTAMP_INCREMENT);
+
+    let mut out = Vec::with_capacity(blocks.len());
+    let base_number = parent.number();
+    let mut prev_number = base_number;
+    let mut prev_timestamp = parent.timestamp();
+
+    for mut block in blocks {
+        let overrides = block.block_overrides.get_or_insert_with(BlockOverrides::default);
+
+        // Default block number to prev + 1 if not specified.
+        let target_number = if let Some(n) = overrides.number {
+            u64::try_from(n).unwrap_or(u64::MAX)
+        } else {
+            let n = prev_number.saturating_add(1);
+            overrides.number = Some(U256::from(n));
+            n
+        };
+
+        if target_number <= prev_number {
+            return Err(EthApiError::other(EthSimulateError::BlockNumberInvalid {
+                got: target_number,
+                parent: prev_number,
+            }));
+        }
+
+        if target_number.saturating_sub(base_number) > max_simulate_blocks {
+            return Err(EthApiError::other(EthSimulateError::TooManyBlocks));
+        }
+
+        // Insert empty filler blocks for any gap between prev_number and target_number.
+        let gap = target_number - prev_number;
+        if gap > 1 {
+            for i in 1..gap {
+                let filler_number = prev_number + i;
+                let filler_time = prev_timestamp + timestamp_increment;
+                out.push(SimBlock {
+                    block_overrides: Some(BlockOverrides {
+                        number: Some(U256::from(filler_number)),
+                        time: Some(filler_time),
+                        ..Default::default()
+                    }),
+                    state_overrides: None,
+                    calls: Vec::new(),
+                });
+                prev_timestamp = filler_time;
+            }
+        }
+
+        prev_number = target_number;
+        // Default timestamp to prev + increment if not specified, otherwise validate ordering.
+        let block_time = if let Some(t) = overrides.time {
+            if t <= prev_timestamp {
+                return Err(EthApiError::other(EthSimulateError::BlockTimestampInvalid {
+                    got: t,
+                    parent: prev_timestamp,
+                }));
+            }
+            t
+        } else {
+            let t = prev_timestamp + timestamp_increment;
+            overrides.time = Some(t);
+            t
+        };
+        prev_timestamp = block_time;
+
+        out.push(block);
+    }
+
+    Ok(out)
+}
+
 /// Applies precompile move overrides from state overrides to the EVM's precompiles map.
 ///
 /// This function processes `movePrecompileToAddress` entries from the state overrides and
@@ -147,6 +259,15 @@ pub fn apply_precompile_overrides(
         })
         .collect();
 
+    for (source, dest) in &moves {
+        if source == dest {
+            if precompiles.get(source).is_none() {
+                return Err(EthSimulateError::NotAPrecompile(*source))
+            }
+            return Err(EthSimulateError::MovePrecompileToSelf(*source))
+        }
+    }
+
     precompiles.move_precompiles(moves).map_err(
         |alloy_evm::precompiles::MovePrecompileError::NotAPrecompile(addr)| {
             EthSimulateError::NotAPrecompile(addr)
@@ -161,13 +282,20 @@ pub fn apply_precompile_overrides(
 ///
 /// Returns all executed transactions and the result of the execution.
 ///
+/// For each call without an explicit `gas` field, the remaining block gas is used as the default.
+/// The RPC gas cap is tracked as a request-wide remaining budget and caps each call before
+/// execution. This matches the spec rule `"gasLimit: blockGasLimit - soFarUsedGasInBlock"` and
+/// geth's per-call `sanitizeCall` behavior.
+///
 /// [`TransactionRequest`]: alloy_rpc_types_eth::TransactionRequest
 #[expect(clippy::type_complexity)]
 pub fn execute_transactions<S, T>(
     mut builder: S,
+    state_provider: impl StateProvider,
     calls: Vec<RpcTxReq<T::Network>>,
-    default_gas_limit: u64,
+    remaining_call_gas_limit: &mut Option<u64>,
     chain_id: u64,
+    compute_state_root: bool,
     converter: &T,
 ) -> Result<
     (
@@ -183,7 +311,48 @@ where
     builder.apply_pre_execution_changes()?;
 
     let mut results = Vec::with_capacity(calls.len());
-    for call in calls {
+    let mut cumulative_tx_gas_used: u64 = 0;
+    let mut block_regular_gas_used: u64 = 0;
+    let mut block_state_gas_used: u64 = 0;
+    let block_gas_limit = builder.evm().block().gas_limit();
+    let is_amsterdam = builder.evm().cfg_env().enable_amsterdam_eip8037;
+    let tx_gas_limit_cap = builder.evm().cfg_env().tx_gas_limit_cap.unwrap_or(u64::MAX);
+    for mut call in calls {
+        let block_gas_remaining = if is_amsterdam {
+            block_gas_limit
+                .saturating_sub(block_regular_gas_used)
+                .min(block_gas_limit.saturating_sub(block_state_gas_used))
+        } else {
+            block_gas_limit.saturating_sub(cumulative_tx_gas_used)
+        };
+        let mut default_gas_limit = block_gas_remaining;
+
+        if let Some(gas_limit) = call.as_ref().gas_limit() {
+            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 = gas_limit.min(tx_gas_limit_cap);
+
+                regular_tx_gas_limit > regular_available_gas || gas_limit > state_available_gas
+            } else {
+                gas_limit > block_gas_remaining
+            };
+
+            if exceeds_gas_limit {
+                return Err(EthApiError::other(EthSimulateError::BlockGasLimitExceeded))
+            }
+        }
+
+        if let Some(remaining_call_gas_limit) = *remaining_call_gas_limit {
+            if let Some(gas_limit) = call.as_ref().gas_limit() {
+                if gas_limit > remaining_call_gas_limit {
+                    call.as_mut().set_gas_limit(remaining_call_gas_limit);
+                }
+            } else {
+                default_gas_limit = default_gas_limit.min(remaining_call_gas_limit);
+            }
+        }
+
         // Resolve transaction, populate missing fields and enforce calls
         // correctness.
         let tx = resolve_transaction(
@@ -198,13 +367,30 @@ where
         // The effect for a layer-2 execution client is that it does not charge L1 cost.
         let tx = WithEncoded::new(Default::default(), tx);
 
-        builder.execute_transaction_with_result_closure(tx, |result| {
+        let mut tx_regular_gas_used = 0;
+        let gas_output = builder.execute_transaction_with_result_closure(tx, |result| {
+            tx_regular_gas_used = result.result().result.gas().block_regular_gas_used();
             results.push(result.result().result.clone())
         })?;
+
+        let gas_used = gas_output.tx_gas_used();
+        if let Some(remaining_call_gas_limit) = remaining_call_gas_limit.as_mut() {
+            if gas_used > *remaining_call_gas_limit {
+                return Err(EthApiError::other(EthSimulateError::GasLimitReached))
+            }
+            *remaining_call_gas_limit -= gas_used;
+        }
+
+        cumulative_tx_gas_used = cumulative_tx_gas_used.saturating_add(gas_used);
+        block_regular_gas_used = block_regular_gas_used.saturating_add(tx_regular_gas_used);
+        block_state_gas_used = block_state_gas_used.saturating_add(gas_output.state_gas_used());
     }
 
-    // Pass noop provider to skip state root calculations.
-    let result = builder.finish(NoopProvider::default(), None)?;
+    let result = if compute_state_root {
+        builder.finish(state_provider, None)?
+    } else {
+        builder.finish(NoopProvider::default(), None)?
+    };
 
     Ok((result, results))
 }
@@ -256,22 +442,21 @@ where
         tx.as_mut().set_kind(TxKind::Create);
     }
 
-    // if we can't build the _entire_ transaction yet, we need to check the fee values
+    // if we can't build the _entire_ transaction yet, fill the fee fields.
+    //
+    // Per the eth_simulateV1 spec, unspecified fee fields default to 0 (not the block base fee),
+    // matching geth's `CallDefaults` behavior. This lets simulation behave like a free-gas
+    // `eth_call` when validation is off, and surfaces "max fee per gas less than block base fee"
+    // errors when validation is on with a real base fee.
+    let _ = block_base_fee_per_gas;
     if tx.as_ref().output_tx_type_checked().is_none() {
         if tx_type.is_legacy() || tx_type.is_eip2930() {
             if tx.as_ref().gas_price().is_none() {
-                tx.as_mut().set_gas_price(block_base_fee_per_gas as u128);
+                tx.as_mut().set_gas_price(0);
             }
         } else {
-            // set dynamic 1559 fees
             if tx.as_ref().max_fee_per_gas().is_none() {
-                let mut max_fee_per_gas = block_base_fee_per_gas as u128;
-                if let Some(prio_fee) = tx.as_ref().max_priority_fee_per_gas() {
-                    // if a prio fee is provided we need to select the max fee accordingly
-                    // because the base fee must be higher than the prio fee.
-                    max_fee_per_gas = prio_fee.max(max_fee_per_gas);
-                }
-                tx.as_mut().set_max_fee_per_gas(max_fee_per_gas);
+                tx.as_mut().set_max_fee_per_gas(0);
             }
             if tx.as_ref().max_priority_fee_per_gas().is_none() {
                 tx.as_mut().set_max_priority_fee_per_gas(0);
@@ -315,30 +500,31 @@ where
                         ..SimulateError::invalid_params()
                     }),
                     gas_used: gas.tx_gas_used(),
+                    max_used_gas: Some(gas.total_gas_spent().max(gas.floor_gas())),
                     logs: Vec::new(),
                     status: false,
-                    ..Default::default()
                 }
             }
             ExecutionResult::Revert { output, gas, .. } => {
                 let error = Err::from_revert(output.clone());
                 SimCallResult {
-                    return_data: output,
+                    return_data: Bytes::new(),
                     error: Some(SimulateError {
                         message: error.to_string(),
                         code: SIMULATE_REVERT_CODE,
-                        ..SimulateError::invalid_params()
+                        data: Some(output),
                     }),
                     gas_used: gas.tx_gas_used(),
+                    max_used_gas: Some(gas.total_gas_spent().max(gas.floor_gas())),
                     status: false,
                     logs: Vec::new(),
-                    ..Default::default()
                 }
             }
             ExecutionResult::Success { output, gas, logs, .. } => SimCallResult {
                 return_data: output.into_data(),
                 error: None,
                 gas_used: gas.tx_gas_used(),
+                max_used_gas: Some(gas.total_gas_spent().max(gas.floor_gas())),
                 logs: logs
                     .into_iter()
                     .map(|log| {
@@ -356,7 +542,6 @@ where
                     })
                     .collect(),
                 status: true,
-                ..Default::default()
             },
         };
 
@@ -370,3 +555,177 @@ where
     )?;
     Ok(SimulatedBlock { inner: block, calls })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{apply_precompile_overrides, sanitize_chain, EthSimulateError};
+    use crate::EthApiError;
+    use alloy_chains::Chain;
+    use alloy_consensus::Header;
+    use alloy_evm::precompiles::PrecompilesMap;
+    use alloy_primitives::{address, U256};
+    use alloy_rpc_types_eth::{
+        simulate::SimBlock,
+        state::{AccountOverride, StateOverride},
+        BlockOverrides, TransactionRequest,
+    };
+    use reth_primitives_traits::SealedHeader;
+    use revm::precompile::Precompiles;
+
+    fn parent_at(number: u64, timestamp: u64) -> SealedHeader<Header> {
+        SealedHeader::seal_slow(Header { number, timestamp, ..Default::default() })
+    }
+
+    fn block_with_number(number: u64) -> SimBlock<TransactionRequest> {
+        SimBlock {
+            block_overrides: Some(BlockOverrides {
+                number: Some(U256::from(number)),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn precompile_self_move_requires_existing_precompile() {
+        let address = address!("c100000000000000000000000000000000000000");
+        let mut state_overrides = StateOverride::default();
+        state_overrides.insert(
+            address,
+            AccountOverride { move_precompile_to: Some(address), ..Default::default() },
+        );
+        let mut precompiles = PrecompilesMap::from_static(Precompiles::prague());
+
+        let err = apply_precompile_overrides(&state_overrides, &mut precompiles).unwrap_err();
+
+        assert!(matches!(err, EthSimulateError::NotAPrecompile(addr) if addr == address));
+    }
+
+    #[test]
+    fn precompile_self_move_errors_for_existing_precompile() {
+        let address = address!("0000000000000000000000000000000000000001");
+        let mut state_overrides = StateOverride::default();
+        state_overrides.insert(
+            address,
+            AccountOverride { move_precompile_to: Some(address), ..Default::default() },
+        );
+        let mut precompiles = PrecompilesMap::from_static(Precompiles::prague());
+
+        let err = apply_precompile_overrides(&state_overrides, &mut precompiles).unwrap_err();
+
+        assert!(matches!(err, EthSimulateError::MovePrecompileToSelf(addr) if addr == address));
+    }
+
+    #[test]
+    fn moved_precompile_is_callable() {
+        let source = address!("0000000000000000000000000000000000000001");
+        let dest = address!("0000000000000000000000000000000000123456");
+        let mut state_overrides = StateOverride::default();
+        state_overrides.insert(
+            source,
+            AccountOverride { move_precompile_to: Some(dest), ..Default::default() },
+        );
+        let mut precompiles = PrecompilesMap::from_static(Precompiles::prague());
+
+        apply_precompile_overrides(&state_overrides, &mut precompiles).unwrap();
+
+        assert!(precompiles.get(&source).is_none());
+        assert!(precompiles.get(&dest).is_some());
+    }
+
+    #[test]
+    fn sanitize_chain_fills_gaps_with_empty_blocks() {
+        // parent at block 5; user requests one block at 8 — sanitize should insert fillers at 6
+        // and 7 before the requested block.
+        let parent = parent_at(5, 100);
+        let blocks = vec![block_with_number(8)];
+
+        let out = sanitize_chain(blocks, &parent, Chain::mainnet().id(), 256).unwrap();
+        assert_eq!(out.len(), 3);
+
+        let numbers: Vec<u64> = out
+            .iter()
+            .map(|b| b.block_overrides.as_ref().unwrap().number.unwrap().try_into().unwrap())
+            .collect();
+        assert_eq!(numbers, vec![6, 7, 8]);
+
+        assert!(out[0].calls.is_empty());
+        assert!(out[1].calls.is_empty());
+
+        // Mainnet hint is 12s, so timestamps should auto-increment from 100 by 12.
+        let times: Vec<u64> =
+            out.iter().map(|b| b.block_overrides.as_ref().unwrap().time.unwrap()).collect();
+        assert_eq!(times, vec![112, 124, 136]);
+    }
+
+    #[test]
+    fn sanitize_chain_defaults_missing_number_and_time() {
+        let parent = parent_at(10, 1000);
+        let blocks: Vec<SimBlock<TransactionRequest>> =
+            vec![SimBlock::default(), SimBlock::default()];
+
+        let out = sanitize_chain(blocks, &parent, Chain::mainnet().id(), 256).unwrap();
+        assert_eq!(out.len(), 2);
+
+        let overrides = out[0].block_overrides.as_ref().unwrap();
+        assert_eq!(overrides.number.unwrap(), U256::from(11));
+        assert_eq!(overrides.time, Some(1012));
+
+        let overrides = out[1].block_overrides.as_ref().unwrap();
+        assert_eq!(overrides.number.unwrap(), U256::from(12));
+        assert_eq!(overrides.time, Some(1024));
+    }
+
+    #[test]
+    fn sanitize_chain_uses_chain_blocktime_hint() {
+        // Optimism has a 2s blocktime hint; filler/auto timestamps should reflect that.
+        let parent = parent_at(0, 0);
+        let blocks = vec![block_with_number(3)];
+
+        let out = sanitize_chain(blocks, &parent, Chain::optimism_mainnet().id(), 256).unwrap();
+        let times: Vec<u64> =
+            out.iter().map(|b| b.block_overrides.as_ref().unwrap().time.unwrap()).collect();
+        assert_eq!(times, vec![2, 4, 6]);
+    }
+
+    #[test]
+    fn sanitize_chain_rounds_subsecond_blocktime_hint_up() {
+        // Arbitrum has a 260ms blocktime hint. Simulated timestamps are second-granular, so this
+        // rounds up to a 1s increment instead of falling back to the default.
+        let parent = parent_at(0, 0);
+        let blocks = vec![block_with_number(3)];
+
+        let out = sanitize_chain(blocks, &parent, Chain::arbitrum_mainnet().id(), 256).unwrap();
+        let times: Vec<u64> =
+            out.iter().map(|b| b.block_overrides.as_ref().unwrap().time.unwrap()).collect();
+        assert_eq!(times, vec![1, 2, 3]);
+    }
+
+    #[test]
+    fn sanitize_chain_falls_back_when_chain_has_no_hint() {
+        // An unknown chain id has no blocktime hint — fall back to the 12s default.
+        let parent = parent_at(0, 0);
+        let blocks = vec![block_with_number(2)];
+
+        let out = sanitize_chain(blocks, &parent, Chain::from_id(123_456_789).id(), 256).unwrap();
+        let times: Vec<u64> =
+            out.iter().map(|b| b.block_overrides.as_ref().unwrap().time.unwrap()).collect();
+        assert_eq!(times, vec![12, 24]);
+    }
+
+    #[test]
+    fn sanitize_chain_rejects_non_increasing_number() {
+        let parent = parent_at(10, 100);
+        let err = sanitize_chain(vec![block_with_number(10)], &parent, Chain::mainnet().id(), 256)
+            .unwrap_err();
+        assert!(matches!(err, EthApiError::Other(_)));
+    }
+
+    #[test]
+    fn sanitize_chain_enforces_max_blocks() {
+        let parent = parent_at(0, 0);
+        let err = sanitize_chain(vec![block_with_number(257)], &parent, Chain::mainnet().id(), 256)
+            .unwrap_err();
+        assert!(matches!(err, EthApiError::Other(_)));
+    }
+}
diff --git a/crates/rpc/rpc-eth-types/src/transaction.rs b/crates/rpc/rpc-eth-types/src/transaction.rs
index f9e9ae6b92b..4b7720050c9 100644
--- a/crates/rpc/rpc-eth-types/src/transaction.rs
+++ b/crates/rpc/rpc-eth-types/src/transaction.rs
@@ -2,6 +2,7 @@
 //!
 //! Transaction wrapper that labels transaction with its origin.
 
+use alloy_consensus::transaction::TxHashRef;
 use alloy_primitives::B256;
 use alloy_rpc_types_eth::TransactionInfo;
 use reth_ethereum_primitives::TransactionSigned;
@@ -59,7 +60,7 @@ impl<T: SignedTransaction> TransactionSource<T> {
                 base_fee,
             } => {
                 let tx_info = TransactionInfo {
-                    hash: Some(transaction.trie_hash()),
+                    hash: Some(*transaction.tx_hash()),
                     index: Some(index),
                     block_hash: Some(block_hash),
                     block_number: Some(block_number),
@@ -76,7 +77,7 @@ impl<T: SignedTransaction> TransactionSource<T> {
     pub fn split(self) -> (Recovered<T>, TransactionInfo) {
         match self {
             Self::Pool(tx) => {
-                let hash = tx.trie_hash();
+                let hash = *tx.tx_hash();
                 (tx, TransactionInfo { hash: Some(hash), ..Default::default() })
             }
             Self::Block {
@@ -87,7 +88,7 @@ impl<T: SignedTransaction> TransactionSource<T> {
                 block_timestamp,
                 base_fee,
             } => {
-                let hash = transaction.trie_hash();
+                let hash = *transaction.tx_hash();
                 (
                     transaction,
                     TransactionInfo {
diff --git a/crates/rpc/rpc-server-types/src/constants.rs b/crates/rpc/rpc-server-types/src/constants.rs
index 9f1e0f8167e..fe82c064bd0 100644
--- a/crates/rpc/rpc-server-types/src/constants.rs
+++ b/crates/rpc/rpc-server-types/src/constants.rs
@@ -123,6 +123,9 @@ pub mod cache {
     /// Default cache size for the header cache: 1000 headers.
     pub const DEFAULT_HEADER_CACHE_MAX_LEN: u32 = 1000;
 
+    /// Default cache size for the revm BAL cache: 1000 block access lists.
+    pub const DEFAULT_BAL_CACHE_MAX_LEN: u32 = 1000;
+
     /// Default number of concurrent database requests.
     pub const DEFAULT_CONCURRENT_DB_REQUESTS: usize = 512;
 
diff --git a/crates/rpc/rpc/Cargo.toml b/crates/rpc/rpc/Cargo.toml
index 27d9fb8e5dd..25310f36990 100644
--- a/crates/rpc/rpc/Cargo.toml
+++ b/crates/rpc/rpc/Cargo.toml
@@ -28,7 +28,6 @@ reth-network-api.workspace = true
 reth-rpc-engine-api.workspace = true
 reth-revm = { workspace = true, features = ["witness"] }
 reth-tasks = { workspace = true, features = ["rayon"] }
-reth-tracing.workspace = true
 reth-rpc-convert.workspace = true
 revm-inspectors.workspace = true
 reth-network-peers = { workspace = true, features = ["secp256k1"] }
diff --git a/crates/rpc/rpc/src/admin.rs b/crates/rpc/rpc/src/admin.rs
index 441053ab86d..871842bdc74 100644
--- a/crates/rpc/rpc/src/admin.rs
+++ b/crates/rpc/rpc/src/admin.rs
@@ -56,10 +56,18 @@ where
 
     /// Handler for `admin_addTrustedPeer`
     fn add_trusted_peer(&self, record: AnyNode) -> RpcResult<bool> {
-        if let Some(record) = record.node_record() {
-            self.network.add_trusted_peer_with_udp(record.id, record.tcp_addr(), record.udp_addr())
+        if let Some(trusted) = record.trusted_peer().cloned() {
+            self.network.add_trusted_peer_node(trusted);
+        } else {
+            if let Some(record) = record.node_record() {
+                self.network.add_trusted_peer_with_udp(
+                    record.id,
+                    record.tcp_addr(),
+                    record.udp_addr(),
+                )
+            }
+            self.network.add_trusted_peer_id(record.peer_id());
         }
-        self.network.add_trusted_peer_id(record.peer_id());
         Ok(true)
     }
 
diff --git a/crates/rpc/rpc/src/debug.rs b/crates/rpc/rpc/src/debug.rs
index 86e1fe8b42c..fc616fad038 100644
--- a/crates/rpc/rpc/src/debug.rs
+++ b/crates/rpc/rpc/src/debug.rs
@@ -1,4 +1,4 @@
-use alloy_consensus::{transaction::TxHashRef, BlockHeader};
+use alloy_consensus::{constants::KECCAK_EMPTY, transaction::TxHashRef, BlockHeader};
 use alloy_eips::{eip2718::Encodable2718, BlockId, BlockNumberOrTag};
 use alloy_evm::{env::BlockEnvironment, Evm};
 use alloy_genesis::ChainConfig;
@@ -6,7 +6,9 @@ use alloy_primitives::{hex::decode, uint, Address, Bytes, B256, U64};
 use alloy_rlp::{Decodable, Encodable};
 use alloy_rpc_types::BlockTransactionsKind;
 use alloy_rpc_types_debug::ExecutionWitness;
-use alloy_rpc_types_eth::{state::EvmOverrides, BlockError, Bundle, StateContext};
+use alloy_rpc_types_eth::{
+    state::EvmOverrides, Account, AccountInfo, BlockError, Bundle, Index, StateContext,
+};
 use alloy_rpc_types_trace::geth::{
     BlockTraceResult, GethDebugTracingCallOptions, GethDebugTracingOptions, GethTrace, TraceResult,
 };
@@ -17,7 +19,7 @@ use parking_lot::RwLock;
 use reth_chainspec::{ChainSpecProvider, EthChainSpec, EthereumHardforks};
 use reth_engine_primitives::ConsensusEngineEvent;
 use reth_errors::RethError;
-use reth_evm::{execute::Executor, ConfigureEvm, EvmEnvFor};
+use reth_evm::{block::BlockExecutor, execute::Executor, ConfigureEvm, EvmEnvFor};
 use reth_primitives_traits::{
     Block as BlockTrait, BlockBody, BlockTy, ReceiptWithBloom, RecoveredBlock,
 };
@@ -28,15 +30,18 @@ use reth_rpc_eth_api::{
     helpers::{EthTransactions, TraceExt},
     FromEthApiError, FromEvmError, RpcConvert, RpcNodeCore,
 };
-use reth_rpc_eth_types::EthApiError;
+use reth_rpc_eth_types::{EthApiError, StateCacheDb};
 use reth_rpc_server_types::{result::internal_rpc_err, ToRpcResult};
 use reth_storage_api::{
     BlockIdReader, BlockReaderIdExt, HashedPostStateProvider, HeaderProvider, ProviderBlock,
-    ReceiptProviderIdExt, StateProviderFactory, StateRootProvider, TransactionVariant,
+    ReceiptProviderIdExt, StateProviderFactory, StateRootProvider, StorageRootProvider,
+    TransactionVariant,
 };
 use reth_tasks::{pool::BlockingTaskGuard, Runtime};
-use reth_trie_common::{updates::TrieUpdates, ExecutionWitnessMode, HashedPostState};
-use revm::{database::states::bundle_state::BundleRetention, DatabaseCommit};
+use reth_trie_common::{
+    updates::TrieUpdates, ExecutionWitnessMode, HashedPostState, HashedStorage,
+};
+use revm::{database::states::bundle_state::BundleRetention, Database, DatabaseCommit};
 use revm_inspectors::tracing::{DebugInspector, TransactionContext};
 use serde::{Deserialize, Serialize};
 use std::{collections::VecDeque, sync::Arc};
@@ -71,10 +76,10 @@ where
         // Spawn a task caching bad blocks
         executor.spawn_task(async move {
             while let Some(event) = stream.next().await {
-                if let ConsensusEngineEvent::InvalidBlock(block) = event &&
+                if let ConsensusEngineEvent::InvalidBlock { block, error } = event &&
                     let Ok(recovered) = RecoveredBlock::try_recover_sealed(*block)
                 {
-                    bad_block_store.insert(recovered);
+                    bad_block_store.insert(recovered, error);
                 }
             }
         });
@@ -553,6 +558,118 @@ where
             .await
     }
 
+    /// Returns account information, including the storage root, after replaying the block through
+    /// the transaction at the given index.
+    pub async fn debug_account_at(
+        &self,
+        block_id: BlockId,
+        tx_index: Index,
+        address: Address,
+    ) -> Result<Option<Account>, Eth::Error> {
+        self.replay_block_until(block_id, tx_index, move |db| Self::account(db, address))
+            .await
+            .map(Option::flatten)
+    }
+
+    /// Returns account information after replaying the block through the transaction at the given
+    /// index.
+    pub async fn debug_account_info_at(
+        &self,
+        block_id: BlockId,
+        tx_index: Index,
+        address: Address,
+    ) -> Result<Option<AccountInfo>, Eth::Error> {
+        self.replay_block_until(block_id, tx_index, move |db| Self::account_info(db, address)).await
+    }
+
+    /// Replays a block through the transaction at the given index and calls `f` with the resulting
+    /// state.
+    async fn replay_block_until<F, R>(
+        &self,
+        block_id: BlockId,
+        tx_index: Index,
+        f: F,
+    ) -> Result<Option<R>, Eth::Error>
+    where
+        F: FnOnce(&mut StateCacheDb) -> Result<R, Eth::Error> + Send + 'static,
+        R: Send + 'static,
+    {
+        let block = self
+            .eth_api()
+            .recovered_block(block_id)
+            .await?
+            .ok_or(EthApiError::HeaderNotFound(block_id))?;
+        let tx_index = usize::from(tx_index);
+        let transaction_count = block.transaction_count();
+        if tx_index >= transaction_count {
+            return Err(EthApiError::InvalidParams(format!(
+                "tx_index {tx_index} out of bounds for block with {transaction_count} transactions"
+            ))
+            .into())
+        }
+
+        self.eth_api()
+            .spawn_with_state_at_block(block.parent_hash(), move |eth_api, mut db| {
+                let mut executor = eth_api
+                    .evm_config()
+                    .executor_for_block(&mut db, block.sealed_block())
+                    .map_err(RethError::other)
+                    .map_err(Eth::Error::from_eth_err)?;
+                executor.apply_pre_execution_changes().map_err(Eth::Error::from_eth_err)?;
+
+                for tx in block.transactions_recovered().take(tx_index + 1) {
+                    executor.execute_transaction(tx).map_err(Eth::Error::from_eth_err)?;
+                }
+                drop(executor);
+
+                f(&mut db)
+            })
+            .await
+            .map(Some)
+    }
+
+    /// Retrieves the account's balance, nonce, code hash, and storage root from the given state.
+    fn account(db: &mut StateCacheDb, address: Address) -> Result<Option<Account>, Eth::Error> {
+        let account = db.basic(address).map_err(Eth::Error::from_eth_err)?;
+        let Some(account) = account else { return Ok(None) };
+
+        let balance = account.balance;
+        let nonce = account.nonce;
+        let code_hash = account.code_hash;
+        let hashed_storage = db
+            .cache
+            .accounts
+            .get(&address)
+            .and_then(|account| {
+                account.account.as_ref().map(|plain_account| {
+                    HashedStorage::from_plain_storage(account.status, plain_account.storage.iter())
+                })
+            })
+            .unwrap_or_default();
+        let storage_root =
+            db.database.storage_root(address, hashed_storage).map_err(Eth::Error::from_eth_err)?;
+
+        Ok(Some(Account { balance, nonce, code_hash, storage_root }))
+    }
+
+    /// Retrieves the account's balance, nonce, and code from the given state.
+    fn account_info<DB>(db: &mut DB, address: Address) -> Result<AccountInfo, Eth::Error>
+    where
+        DB: Database,
+        EthApiError: From<DB::Error>,
+    {
+        let account = db.basic(address).map_err(Eth::Error::from_eth_err)?.unwrap_or_default();
+        let code = if account.code_hash == KECCAK_EMPTY {
+            Default::default()
+        } else if let Some(code) = account.code {
+            code.original_bytes()
+        } else {
+            db.code_by_hash(account.code_hash).map_err(Eth::Error::from_eth_err)?.original_bytes()
+        };
+
+        Ok(AccountInfo { balance: account.balance, nonce: account.nonce, code })
+    }
+
     /// Returns the code associated with a given hash at the specified block ID. If no code is
     /// found, it returns None. If no block ID is provided, it defaults to the latest block.
     pub async fn debug_code_by_hash(
@@ -697,21 +814,23 @@ where
 
     /// Handler for `debug_getBadBlocks`
     async fn bad_blocks(&self) -> RpcResult<Vec<serde_json::Value>> {
-        let blocks = self.inner.bad_block_store.all();
-        let mut bad_blocks = Vec::with_capacity(blocks.len());
+        let entries = self.inner.bad_block_store.all();
+        let mut bad_blocks = Vec::with_capacity(entries.len());
 
         #[derive(Serialize, Deserialize)]
         struct BadBlockSerde<T> {
             block: T,
             hash: B256,
             rlp: Bytes,
+            reason: String,
         }
 
-        for block in blocks {
-            let rlp = alloy_rlp::encode(block.sealed_block()).into();
-            let hash = block.hash();
+        for entry in entries {
+            let rlp = alloy_rlp::encode(entry.block.sealed_block()).into();
+            let hash = entry.block.hash();
 
-            let block = block
+            let block = entry
+                .block
                 .clone_into_rpc_block(
                     BlockTransactionsKind::Full,
                     |tx, tx_info| self.eth_api().converter().fill(tx, tx_info),
@@ -719,8 +838,9 @@ where
                 )
                 .map_err(|err| Eth::Error::from(err).into())?;
 
-            let bad_block = serde_json::to_value(BadBlockSerde { block, hash, rlp })
-                .map_err(|err| EthApiError::other(internal_rpc_err(err.to_string())))?;
+            let bad_block =
+                serde_json::to_value(BadBlockSerde { block, hash, rlp, reason: entry.reason })
+                    .map_err(|err| EthApiError::other(internal_rpc_err(err.to_string())))?;
 
             bad_blocks.push(bad_block);
         }
@@ -828,8 +948,26 @@ where
         Self::debug_execution_witness_by_block_hash(self, hash, mode).await.map_err(Into::into)
     }
 
-    async fn debug_backtrace_at(&self, _location: &str) -> RpcResult<()> {
-        Ok(())
+    /// Handler for `debug_accountAt`
+    async fn debug_account_at(
+        &self,
+        block_id: BlockId,
+        tx_index: Index,
+        address: Address,
+    ) -> RpcResult<Option<Account>> {
+        let _permit = self.acquire_trace_permit().await;
+        Self::debug_account_at(self, block_id, tx_index, address).await.map_err(Into::into)
+    }
+
+    /// Handler for `debug_accountInfoAt`
+    async fn debug_account_info_at(
+        &self,
+        block_id: BlockId,
+        tx_index: Index,
+        address: Address,
+    ) -> RpcResult<Option<AccountInfo>> {
+        let _permit = self.acquire_trace_permit().await;
+        Self::debug_account_info_at(self, block_id, tx_index, address).await.map_err(Into::into)
     }
 
     async fn debug_account_range(
@@ -844,10 +982,6 @@ where
         Ok(())
     }
 
-    async fn debug_block_profile(&self, _file: String, _seconds: u64) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_chaindb_compact(&self) -> RpcResult<()> {
         Ok(())
     }
@@ -868,10 +1002,6 @@ where
         Self::debug_code_by_hash(self, hash, block_id).await.map_err(Into::into)
     }
 
-    async fn debug_cpu_profile(&self, _file: String, _seconds: u64) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_db_ancient(&self, _kind: String, _number: u64) -> RpcResult<()> {
         Ok(())
     }
@@ -922,10 +1052,6 @@ where
         Ok(())
     }
 
-    async fn debug_freeze_client(&self, _node: String) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_gc_stats(&self) -> RpcResult<()> {
         Ok(())
     }
@@ -954,10 +1080,6 @@ where
         Ok(())
     }
 
-    async fn debug_go_trace(&self, _file: String, _seconds: u64) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_intermediate_roots(
         &self,
         block_hash: B256,
@@ -971,10 +1093,6 @@ where
         Ok(())
     }
 
-    async fn debug_mutex_profile(&self, _file: String, _nsec: u64) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_preimage(&self, _hash: B256) -> RpcResult<()> {
         Ok(())
     }
@@ -987,10 +1105,6 @@ where
         Ok(Default::default())
     }
 
-    async fn debug_set_block_profile_rate(&self, _rate: u64) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_set_gc_percent(&self, _v: i32) -> RpcResult<()> {
         Ok(())
     }
@@ -999,18 +1113,10 @@ where
         Ok(())
     }
 
-    async fn debug_set_mutex_profile_fraction(&self, _rate: i32) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_set_trie_flush_interval(&self, _interval: String) -> RpcResult<()> {
         Ok(())
     }
 
-    async fn debug_stacks(&self) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_standard_trace_bad_block_to_file(
         &self,
         _block: BlockNumberOrTag,
@@ -1027,14 +1133,6 @@ where
         Ok(())
     }
 
-    async fn debug_start_cpu_profile(&self, _file: String) -> RpcResult<()> {
-        Ok(())
-    }
-
-    async fn debug_start_go_trace(&self, _file: String) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_state_root_with_updates(
         &self,
         hashed_state: HashedPostState,
@@ -1043,14 +1141,6 @@ where
         Self::debug_state_root_with_updates(self, hashed_state, block_id).await.map_err(Into::into)
     }
 
-    async fn debug_stop_cpu_profile(&self) -> RpcResult<()> {
-        Ok(())
-    }
-
-    async fn debug_stop_go_trace(&self) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_storage_range_at(
         &self,
         _block_hash: B256,
@@ -1068,7 +1158,7 @@ where
         opts: Option<GethDebugTracingCallOptions>,
     ) -> RpcResult<Vec<TraceResult>> {
         let _permit = self.acquire_trace_permit().await;
-        let block = self
+        let entry = self
             .inner
             .bad_block_store
             .get(block_hash)
@@ -1077,32 +1167,12 @@ where
         let evm_env = self
             .eth_api()
             .evm_config()
-            .evm_env(block.header())
+            .evm_env(entry.block.header())
             .map_err(RethError::other)
             .to_rpc_result()?;
 
         let opts = opts.map(|o| o.tracing_options).unwrap_or_default();
-        self.trace_block(block, evm_env, opts).await.map_err(Into::into)
-    }
-
-    async fn debug_verbosity(&self, level: usize) -> RpcResult<()> {
-        reth_tracing::set_log_verbosity(level).map_err(internal_rpc_err)
-    }
-
-    async fn debug_vmodule(&self, pattern: String) -> RpcResult<()> {
-        reth_tracing::set_log_vmodule(&pattern).map_err(internal_rpc_err)
-    }
-
-    async fn debug_write_block_profile(&self, _file: String) -> RpcResult<()> {
-        Ok(())
-    }
-
-    async fn debug_write_mem_profile(&self, _file: String) -> RpcResult<()> {
-        Ok(())
-    }
-
-    async fn debug_write_mutex_profile(&self, _file: String) -> RpcResult<()> {
-        Ok(())
+        self.trace_block(entry.block.clone(), evm_env, opts).await.map_err(Into::into)
     }
 }
 
@@ -1130,43 +1200,50 @@ struct DebugApiInner<Eth: RpcNodeCore> {
 /// A bounded, deduplicating store of recently observed bad blocks.
 #[derive(Clone, Debug)]
 struct BadBlockStore<B: BlockTrait> {
-    inner: Arc<RwLock<VecDeque<Arc<RecoveredBlock<B>>>>>,
+    inner: Arc<RwLock<VecDeque<BadBlockEntry<B>>>>,
     limit: usize,
 }
 
+/// A cached bad block paired with the reason it was rejected.
+#[derive(Clone, Debug)]
+struct BadBlockEntry<B: BlockTrait> {
+    block: Arc<RecoveredBlock<B>>,
+    reason: String,
+}
+
 impl<B: BlockTrait> BadBlockStore<B> {
     /// Creates a new store with the given capacity.
     fn new(limit: usize) -> Self {
         Self { inner: Arc::new(RwLock::new(VecDeque::with_capacity(limit))), limit }
     }
 
-    /// Inserts a recovered block, keeping only the most recent `limit` entries and deduplicating
-    /// by block hash.
-    fn insert(&self, block: RecoveredBlock<B>) {
+    /// Inserts a recovered block with its rejection reason, keeping only the most recent `limit`
+    /// entries and deduplicating by block hash.
+    fn insert(&self, block: RecoveredBlock<B>, reason: String) {
         let hash = block.hash();
         let mut guard = self.inner.write();
 
         // skip if we already recorded this bad block , and keep original ordering
-        if guard.iter().any(|b| b.hash() == hash) {
+        if guard.iter().any(|entry| entry.block.hash() == hash) {
             return;
         }
-        guard.push_back(Arc::new(block));
+        guard.push_back(BadBlockEntry { block: Arc::new(block), reason });
 
         while guard.len() > self.limit {
             guard.pop_front();
         }
     }
 
-    /// Returns all cached bad blocks ordered from newest to oldest.
-    fn all(&self) -> Vec<Arc<RecoveredBlock<B>>> {
+    /// Returns all cached bad block entries ordered from newest to oldest.
+    fn all(&self) -> Vec<BadBlockEntry<B>> {
         let guard = self.inner.read();
         guard.iter().rev().cloned().collect()
     }
 
-    /// Returns the bad block with the given hash, if cached.
-    fn get(&self, hash: B256) -> Option<Arc<RecoveredBlock<B>>> {
+    /// Returns the bad block entry with the given hash, if cached.
+    fn get(&self, hash: B256) -> Option<BadBlockEntry<B>> {
         let guard = self.inner.read();
-        guard.iter().find(|b| b.hash() == hash).cloned()
+        guard.iter().find(|entry| entry.block.hash() == hash).cloned()
     }
 }
 
diff --git a/crates/rpc/rpc/src/engine.rs b/crates/rpc/rpc/src/engine.rs
index 0e7a5d16aa8..e1d64911a8b 100644
--- a/crates/rpc/rpc/src/engine.rs
+++ b/crates/rpc/rpc/src/engine.rs
@@ -160,6 +160,11 @@ where
         self.eth.block_access_list_by_block_number(block_number).instrument(engine_span!()).await
     }
 
+    /// Handler for `eth_getBlockAccessList`
+    async fn block_access_list(&self, block_id: BlockId) -> Result<Option<Value>> {
+        self.eth.block_access_list(block_id).instrument(engine_span!()).await
+    }
+
     /// Handler for `getBlockAccessListRaw`
     async fn block_access_list_raw(&self, block: BlockId) -> Result<Option<Bytes>> {
         self.eth.block_access_list_raw(block).instrument(engine_span!()).await
diff --git a/crates/rpc/rpc/src/eth/builder.rs b/crates/rpc/rpc/src/eth/builder.rs
index aaa9805274e..8cb0d665953 100644
--- a/crates/rpc/rpc/src/eth/builder.rs
+++ b/crates/rpc/rpc/src/eth/builder.rs
@@ -31,6 +31,7 @@ pub struct EthApiBuilder<N: RpcNodeCore, Rpc, NextEnv = ()> {
     rpc_converter: Rpc,
     gas_cap: GasCap,
     max_simulate_blocks: u64,
+    compute_state_root_for_eth_simulate: bool,
     eth_proof_window: u64,
     fee_history_cache_config: FeeHistoryCacheConfig,
     proof_permits: usize,
@@ -84,6 +85,7 @@ impl<N: RpcNodeCore, Rpc, NextEnv> EthApiBuilder<N, Rpc, NextEnv> {
             rpc_converter,
             gas_cap,
             max_simulate_blocks,
+            compute_state_root_for_eth_simulate,
             eth_proof_window,
             fee_history_cache_config,
             proof_permits,
@@ -107,6 +109,7 @@ impl<N: RpcNodeCore, Rpc, NextEnv> EthApiBuilder<N, Rpc, NextEnv> {
             rpc_converter: f(rpc_converter),
             gas_cap,
             max_simulate_blocks,
+            compute_state_root_for_eth_simulate,
             eth_proof_window,
             fee_history_cache_config,
             proof_permits,
@@ -143,6 +146,7 @@ where
             gas_oracle: None,
             gas_cap: GasCap::default(),
             max_simulate_blocks: DEFAULT_MAX_SIMULATE_BLOCKS,
+            compute_state_root_for_eth_simulate: false,
             eth_proof_window: DEFAULT_ETH_PROOF_WINDOW,
             blocking_task_pool: None,
             fee_history_cache_config: FeeHistoryCacheConfig::default(),
@@ -182,6 +186,7 @@ where
             rpc_converter: _,
             gas_cap,
             max_simulate_blocks,
+            compute_state_root_for_eth_simulate,
             eth_proof_window,
             fee_history_cache_config,
             proof_permits,
@@ -205,6 +210,7 @@ where
             rpc_converter,
             gas_cap,
             max_simulate_blocks,
+            compute_state_root_for_eth_simulate,
             eth_proof_window,
             fee_history_cache_config,
             proof_permits,
@@ -235,6 +241,7 @@ where
             rpc_converter,
             gas_cap,
             max_simulate_blocks,
+            compute_state_root_for_eth_simulate,
             eth_proof_window,
             fee_history_cache_config,
             proof_permits,
@@ -258,6 +265,7 @@ where
             rpc_converter,
             gas_cap,
             max_simulate_blocks,
+            compute_state_root_for_eth_simulate,
             eth_proof_window,
             fee_history_cache_config,
             proof_permits,
@@ -319,6 +327,12 @@ where
         self
     }
 
+    /// Sets whether to compute state roots for `eth_simulateV1`.
+    pub const fn compute_state_root_for_eth_simulate(mut self, enabled: bool) -> Self {
+        self.compute_state_root_for_eth_simulate = enabled;
+        self
+    }
+
     /// Sets the maximum number of blocks into the past for generating state proofs.
     pub const fn eth_proof_window(mut self, eth_proof_window: u64) -> Self {
         self.eth_proof_window = eth_proof_window;
@@ -380,6 +394,11 @@ where
         self.max_simulate_blocks
     }
 
+    /// Returns whether state roots are computed for `eth_simulateV1`.
+    pub const fn get_compute_state_root_for_eth_simulate(&self) -> bool {
+        self.compute_state_root_for_eth_simulate
+    }
+
     /// Returns the ETH proof window.
     pub const fn get_eth_proof_window(&self) -> u64 {
         self.eth_proof_window
@@ -498,6 +517,7 @@ where
             gas_oracle,
             gas_cap,
             max_simulate_blocks,
+            compute_state_root_for_eth_simulate,
             eth_proof_window,
             blocking_task_pool,
             fee_history_cache_config,
@@ -543,6 +563,7 @@ where
             gas_oracle,
             gas_cap,
             max_simulate_blocks,
+            compute_state_root_for_eth_simulate,
             eth_proof_window,
             blocking_task_pool.unwrap_or_else(|| {
                 BlockingTaskPool::builder()
diff --git a/crates/rpc/rpc/src/eth/core.rs b/crates/rpc/rpc/src/eth/core.rs
index d6bc1884481..7b28e2787aa 100644
--- a/crates/rpc/rpc/src/eth/core.rs
+++ b/crates/rpc/rpc/src/eth/core.rs
@@ -236,6 +236,8 @@ pub struct EthApiInner<N: RpcNodeCore, Rpc: RpcConvert> {
     gas_cap: u64,
     /// Maximum number of blocks for `eth_simulateV1`.
     max_simulate_blocks: u64,
+    /// Whether to compute state roots for `eth_simulateV1`.
+    compute_state_root_for_eth_simulate: bool,
     /// The maximum number of blocks into the past for generating state proofs.
     eth_proof_window: u64,
     /// The block number at which the node started
@@ -300,6 +302,7 @@ where
         gas_oracle: GasPriceOracle<N::Provider>,
         gas_cap: impl Into<GasCap>,
         max_simulate_blocks: u64,
+        compute_state_root_for_eth_simulate: bool,
         eth_proof_window: u64,
         blocking_task_pool: BlockingTaskPool,
         fee_history_cache: FeeHistoryCache<ProviderHeader<N::Provider>>,
@@ -341,6 +344,7 @@ where
             gas_oracle,
             gas_cap: gas_cap.into().into(),
             max_simulate_blocks,
+            compute_state_root_for_eth_simulate,
             eth_proof_window,
             starting_block,
             task_spawner,
@@ -437,6 +441,12 @@ where
         self.max_simulate_blocks
     }
 
+    /// Returns whether state roots are computed for `eth_simulateV1`.
+    #[inline]
+    pub const fn compute_state_root_for_eth_simulate(&self) -> bool {
+        self.compute_state_root_for_eth_simulate
+    }
+
     /// Returns a handle to the gas oracle.
     #[inline]
     pub const fn gas_oracle(&self) -> &GasPriceOracle<N::Provider> {
@@ -576,10 +586,10 @@ mod tests {
     use reth_network_api::noop::NoopNetwork;
     use reth_provider::{
         test_utils::{MockEthProvider, NoopProvider},
-        StageCheckpointReader,
+        PruneCheckpointReader, StageCheckpointReader,
     };
     use reth_rpc_eth_api::{node::RpcNodeCoreAdapter, EthApiServer};
-    use reth_storage_api::{BlockReader, BlockReaderIdExt, StateProviderFactory};
+    use reth_storage_api::{BalProvider, BlockReader, BlockReaderIdExt, StateProviderFactory};
     use reth_testing_utils::generators;
     use reth_transaction_pool::test_utils::{testing_pool, TestPool};
 
@@ -599,6 +609,8 @@ mod tests {
             + StateProviderFactory
             + CanonStateSubscriptions<Primitives = reth_ethereum_primitives::EthPrimitives>
             + StageCheckpointReader
+            + PruneCheckpointReader
+            + BalProvider
             + Unpin
             + Clone
             + 'static,
diff --git a/crates/rpc/rpc/src/eth/helpers/call.rs b/crates/rpc/rpc/src/eth/helpers/call.rs
index ad9f020bd0c..4caf6be3200 100644
--- a/crates/rpc/rpc/src/eth/helpers/call.rs
+++ b/crates/rpc/rpc/src/eth/helpers/call.rs
@@ -32,6 +32,11 @@ where
         self.inner.max_simulate_blocks()
     }
 
+    #[inline]
+    fn compute_state_root_for_eth_simulate(&self) -> bool {
+        self.inner.compute_state_root_for_eth_simulate()
+    }
+
     #[inline]
     fn evm_memory_limit(&self) -> u64 {
         self.inner.evm_memory_limit()
diff --git a/crates/rpc/rpc/src/eth/helpers/sync_listener.rs b/crates/rpc/rpc/src/eth/helpers/sync_listener.rs
index d9069f45963..16e643d726a 100644
--- a/crates/rpc/rpc/src/eth/helpers/sync_listener.rs
+++ b/crates/rpc/rpc/src/eth/helpers/sync_listener.rs
@@ -60,7 +60,7 @@ mod tests {
     use super::*;
     use alloy_rpc_types_admin::EthProtocolInfo;
     use futures::stream;
-    use reth_network_api::{NetworkError, NetworkStatus};
+    use reth_network_api::{CellCustody, NetworkError, NetworkStatus};
     use std::{
         net::{IpAddr, SocketAddr},
         sync::{
@@ -99,6 +99,11 @@ mod tests {
             1
         }
 
+        fn cell_custody(&self) -> &CellCustody {
+            static CELL_CUSTODY: std::sync::OnceLock<CellCustody> = std::sync::OnceLock::new();
+            CELL_CUSTODY.get_or_init(CellCustody::default)
+        }
+
         fn is_syncing(&self) -> bool {
             self.syncing.load(Ordering::SeqCst)
         }
diff --git a/crates/rpc/rpc/src/eth/sim_bundle.rs b/crates/rpc/rpc/src/eth/sim_bundle.rs
index c70360d76c3..fb4ef5814ca 100644
--- a/crates/rpc/rpc/src/eth/sim_bundle.rs
+++ b/crates/rpc/rpc/src/eth/sim_bundle.rs
@@ -290,9 +290,8 @@ where
         let flattened_bundle = self.parse_and_flatten_bundle(&request)?;
 
         let block_id = parent_block.unwrap_or(BlockId::Number(BlockNumberOrTag::Latest));
-        let (mut evm_env, current_block_id) = self.eth_api().evm_env_at(block_id).await?;
-        let current_block = self.eth_api().recovered_block(current_block_id).await?;
-        let current_block = current_block.ok_or(EthApiError::HeaderNotFound(block_id))?;
+        let (current_block, mut evm_env, current_block_id) =
+            self.eth_api().evm_env_and_recovered_block_at(block_id).await?;
 
         let eth_api = self.inner.eth_api.clone();
 
diff --git a/crates/rpc/rpc/src/testing.rs b/crates/rpc/rpc/src/testing.rs
index e7d2e45826c..c40e3247bef 100644
--- a/crates/rpc/rpc/src/testing.rs
+++ b/crates/rpc/rpc/src/testing.rs
@@ -15,7 +15,7 @@
 //! on public-facing RPC endpoints without proper authentication.
 
 use alloy_consensus::{Header, Transaction};
-use alloy_eips::eip2718::Decodable2718;
+use alloy_eips::{eip1559::calculate_block_gas_limit, eip2718::Decodable2718};
 use alloy_evm::{Evm, RecoveredTx};
 use alloy_primitives::{map::HashSet, Address, U256};
 use alloy_rlp::Encodable;
@@ -37,6 +37,7 @@ use reth_rpc_api::{TestingApiServer, TestingBuildBlockRequestV1};
 use reth_rpc_eth_api::{helpers::Call, FromEthApiError};
 use reth_rpc_eth_types::EthApiError;
 use reth_storage_api::{BlockReader, HeaderProvider};
+use reth_transaction_pool::{BestTransactionsAttributes, PoolTransaction, TransactionPool};
 use revm::context::Block;
 use revm_primitives::map::DefaultHashBuilder;
 use std::sync::Arc;
@@ -47,16 +48,24 @@ use tracing::debug;
 pub struct TestingApi<Eth, Evm> {
     eth_api: Eth,
     evm_config: Evm,
+    /// Desired gas limit to move toward while respecting the consensus gas limit bounds.
+    desired_gas_limit: u64,
     /// If true, skip invalid transactions instead of failing.
     skip_invalid_transactions: bool,
-    /// If set, override the parent block's gas limit in `testing_buildBlockV1`.
+    /// If set, override the block gas limit in `testing_buildBlockV1`.
     gas_limit_override: Option<u64>,
 }
 
 impl<Eth, Evm> TestingApi<Eth, Evm> {
     /// Create a new testing API handler.
-    pub const fn new(eth_api: Eth, evm_config: Evm) -> Self {
-        Self { eth_api, evm_config, skip_invalid_transactions: false, gas_limit_override: None }
+    pub const fn new(eth_api: Eth, evm_config: Evm, desired_gas_limit: u64) -> Self {
+        Self {
+            eth_api,
+            evm_config,
+            desired_gas_limit,
+            skip_invalid_transactions: false,
+            gas_limit_override: None,
+        }
     }
 
     /// Enable skipping invalid transactions instead of failing.
@@ -67,8 +76,7 @@ impl<Eth, Evm> TestingApi<Eth, Evm> {
         self
     }
 
-    /// Override the gas limit used by `testing_buildBlockV1` instead of inheriting from the
-    /// parent block.
+    /// Override the gas limit used by `testing_buildBlockV1`.
     pub const fn with_gas_limit_override(mut self, gas_limit: u64) -> Self {
         self.gas_limit_override = Some(gas_limit);
         self
@@ -79,6 +87,7 @@ impl<Eth, Evm> TestingApi<Eth, Evm>
 where
     Eth: Call<
         Provider: BlockReader<Header = Header> + ChainSpecProvider<ChainSpec: EthereumHardforks>,
+        Pool: TransactionPool<Transaction: PoolTransaction<Consensus = TxTy<Evm::Primitives>>>,
     >,
     Evm: ConfigureEvm<NextBlockEnvCtx = NextBlockEnvAttributes, Primitives = EthPrimitives>
         + 'static,
@@ -89,6 +98,7 @@ where
     ) -> Result<ExecutionPayloadEnvelopeV5, Eth::Error> {
         let evm_config = self.evm_config.clone();
         let skip_invalid_transactions = self.skip_invalid_transactions;
+        let desired_gas_limit = self.desired_gas_limit;
         let gas_limit_override = self.gas_limit_override;
         self.eth_api
             .spawn_with_state_at_block(request.parent_block_hash, move |eth_api, state| {
@@ -115,7 +125,9 @@ where
                     timestamp: request.payload_attributes.timestamp,
                     suggested_fee_recipient: request.payload_attributes.suggested_fee_recipient,
                     prev_randao: request.payload_attributes.prev_randao,
-                    gas_limit: gas_limit_override.unwrap_or_else(|| parent.gas_limit()),
+                    gas_limit: gas_limit_override.unwrap_or_else(|| {
+                        calculate_block_gas_limit(parent.gas_limit(), desired_gas_limit)
+                    }),
                     parent_beacon_block_root: request.payload_attributes.parent_beacon_block_root,
                     withdrawals: withdrawals.map(Into::into),
                     extra_data: request.extra_data.unwrap_or_default(),
@@ -134,16 +146,35 @@ where
                 let mut invalid_senders: HashSet<Address, DefaultHashBuilder> = HashSet::default();
                 let mut block_transactions_rlp_length = 0usize;
 
-                // Decode and recover all transactions in parallel
-                let recovered_txs = try_recover_signers(&request.transactions, |tx| {
-                    TxTy::<Evm::Primitives>::decode_2718_exact(tx.as_ref())
-                        .map_err(RecoveryError::from_source)
-                })
-                .or(Err(EthApiError::InvalidTransactionSignature))?;
+                // If no transactions are provided in the request, use transactions from the pool.
+                let use_pool_transactions = request.transactions.is_empty();
+                let recovered_txs = if use_pool_transactions {
+                    let mut best_txs = eth_api.pool().best_transactions_with_attributes(
+                        BestTransactionsAttributes::new(
+                            base_fee,
+                            builder
+                                .evm_mut()
+                                .block()
+                                .blob_gasprice()
+                                .map(|gasprice| gasprice as u64),
+                        ),
+                    );
+                    best_txs.no_updates();
+                    best_txs.map(|tx| tx.to_consensus()).collect()
+                } else {
+                    // Decode and recover all transactions in parallel
+                    try_recover_signers(&request.transactions, |tx| {
+                        TxTy::<Evm::Primitives>::decode_2718_exact(tx.as_ref())
+                            .map_err(RecoveryError::from_source)
+                    })
+                    .or(Err(EthApiError::InvalidTransactionSignature))?
+                };
+                let allow_skip_invalid_transactions =
+                    skip_invalid_transactions || use_pool_transactions;
 
                 for (idx, tx) in recovered_txs.into_iter().enumerate() {
                     let signer = tx.signer();
-                    if skip_invalid_transactions && invalid_senders.contains(&signer) {
+                    if allow_skip_invalid_transactions && invalid_senders.contains(&signer) {
                         continue;
                     }
 
@@ -156,7 +187,7 @@ where
                             withdrawals_rlp_length +
                             1024;
                         if estimated_block_size > MAX_RLP_BLOCK_SIZE {
-                            if skip_invalid_transactions {
+                            if allow_skip_invalid_transactions {
                                 debug!(
                                     target: "rpc::testing",
                                     tx_idx = idx,
@@ -181,7 +212,7 @@ where
                     let gas_used = match builder.execute_transaction(tx) {
                         Ok(gas_used) => gas_used.tx_gas_used(),
                         Err(err) => {
-                            if skip_invalid_transactions {
+                            if allow_skip_invalid_transactions {
                                 debug!(
                                     target: "rpc::testing",
                                     tx_idx = idx,
@@ -209,11 +240,9 @@ where
                 let outcome = builder.finish(&state, None).map_err(Eth::Error::from_eth_err)?;
 
                 let has_requests = outcome.block.requests_hash().is_some();
-                let sealed_block = Arc::new(outcome.block.into_sealed_block());
-
                 let requests = has_requests.then_some(outcome.execution_result.requests);
 
-                EthBuiltPayload::new(sealed_block, total_fees, requests, None)
+                EthBuiltPayload::new(Arc::new(outcome.block), total_fees, requests, None)
                     .try_into_v5()
                     .map_err(RethError::other)
                     .map_err(Eth::Error::from_eth_err)
@@ -227,6 +256,7 @@ impl<Eth, Evm> TestingApiServer for TestingApi<Eth, Evm>
 where
     Eth: Call<
         Provider: BlockReader<Header = Header> + ChainSpecProvider<ChainSpec: EthereumHardforks>,
+        Pool: TransactionPool<Transaction: PoolTransaction<Consensus = TxTy<Evm::Primitives>>>,
     >,
     Evm: ConfigureEvm<NextBlockEnvCtx = NextBlockEnvAttributes, Primitives = EthPrimitives>
         + 'static,
diff --git a/crates/rpc/rpc/src/trace.rs b/crates/rpc/rpc/src/trace.rs
index f1dd998f495..71f0f084a0c 100644
--- a/crates/rpc/rpc/src/trace.rs
+++ b/crates/rpc/rpc/src/trace.rs
@@ -360,6 +360,13 @@ where
             return Err(EthApiError::HeaderNotFound(end.into()).into());
         }
 
+        // Check if the requested range overlaps with pruned history (EIP-4444)
+        let earliest_block =
+            self.provider().earliest_block_number().map_err(Eth::Error::from_eth_err)?;
+        if start < earliest_block {
+            return Err(EthApiError::PrunedHistoryUnavailable.into());
+        }
+
         if start > end {
             return Err(EthApiError::InvalidParams(
                 "invalid parameters: fromBlock cannot be greater than toBlock".to_string(),
diff --git a/crates/rpc/rpc/src/validation.rs b/crates/rpc/rpc/src/validation.rs
index e1b3171d628..428317591b4 100644
--- a/crates/rpc/rpc/src/validation.rs
+++ b/crates/rpc/rpc/src/validation.rs
@@ -1,12 +1,12 @@
 use alloy_consensus::{
     BlobTransactionValidationError, BlockHeader, EnvKzgSettings, Transaction, TxReceipt,
 };
-use alloy_eips::{eip4844::kzg_to_versioned_hash, eip7685::RequestsOrHash};
+use alloy_eips::{eip7685::RequestsOrHash, eip7928::bal::DecodedBal};
 use alloy_primitives::map::AddressSet;
 use alloy_rpc_types_beacon::relay::{
     BidTrace, BuilderBlockValidationRequest, BuilderBlockValidationRequestV2,
     BuilderBlockValidationRequestV3, BuilderBlockValidationRequestV4,
-    BuilderBlockValidationRequestV5,
+    BuilderBlockValidationRequestV5, BuilderBlockValidationRequestV6,
 };
 use alloy_rpc_types_engine::{
     BlobsBundleV1, BlobsBundleV2, CancunPayloadFields, ExecutionData, ExecutionPayload,
@@ -127,6 +127,7 @@ where
         block: RecoveredBlock<<E::Primitives as NodePrimitives>::Block>,
         message: BidTrace,
         registered_gas_limit: u64,
+        _decoded_bal: Option<DecodedBal>,
     ) -> Result<(), ValidationApiError> {
         self.validate_message_against_header(block.sealed_header(), &message)?;
 
@@ -202,7 +203,7 @@ where
         // update the cached reads
         self.update_cached_reads(parent_header_hash, request_cache).await;
 
-        self.consensus.validate_block_post_execution(&block, &output, None)?;
+        self.consensus.validate_block_post_execution(&block, &output, None, None)?;
 
         self.ensure_payment(&block, &output, &message)?;
 
@@ -347,42 +348,26 @@ where
     /// Validates the given [`BlobsBundleV1`] and returns versioned hashes for blobs.
     pub fn validate_blobs_bundle(
         &self,
-        mut blobs_bundle: BlobsBundleV1,
+        blobs_bundle: BlobsBundleV1,
     ) -> Result<Vec<B256>, ValidationApiError> {
-        if blobs_bundle.commitments.len() != blobs_bundle.proofs.len() ||
-            blobs_bundle.commitments.len() != blobs_bundle.blobs.len()
-        {
-            return Err(ValidationApiError::InvalidBlobsBundle)
-        }
-
-        let versioned_hashes = blobs_bundle
-            .commitments
-            .iter()
-            .map(|c| kzg_to_versioned_hash(c.as_slice()))
-            .collect::<Vec<_>>();
-
-        let sidecar = blobs_bundle.pop_sidecar(blobs_bundle.blobs.len());
+        let versioned_hashes = blobs_bundle.versioned_hashes();
+        let sidecar =
+            blobs_bundle.try_into_sidecar().map_err(|_| ValidationApiError::InvalidBlobsBundle)?;
 
         sidecar.validate(&versioned_hashes, EnvKzgSettings::default().get())?;
-
         Ok(versioned_hashes)
     }
-    /// Validates the given [`BlobsBundleV1`] and returns versioned hashes for blobs.
+
+    /// Validates the given [`BlobsBundleV2`] and returns versioned hashes for blobs.
     pub fn validate_blobs_bundle_v2(
         &self,
         blobs_bundle: BlobsBundleV2,
     ) -> Result<Vec<B256>, ValidationApiError> {
-        let versioned_hashes = blobs_bundle
-            .commitments
-            .iter()
-            .map(|c| kzg_to_versioned_hash(c.as_slice()))
-            .collect::<Vec<_>>();
-
-        blobs_bundle
-            .try_into_sidecar()
-            .map_err(|_| ValidationApiError::InvalidBlobsBundle)?
-            .validate(&versioned_hashes, EnvKzgSettings::default().get())?;
+        let versioned_hashes = blobs_bundle.versioned_hashes();
+        let sidecar =
+            blobs_bundle.try_into_sidecar().map_err(|_| ValidationApiError::InvalidBlobsBundle)?;
 
+        sidecar.validate(&versioned_hashes, EnvKzgSettings::default().get())?;
         Ok(versioned_hashes)
     }
 
@@ -403,6 +388,7 @@ where
             block,
             request.request.message,
             request.registered_gas_limit,
+            None,
         )
         .await
     }
@@ -431,6 +417,7 @@ where
             block,
             request.request.message,
             request.registered_gas_limit,
+            None,
         )
         .await
     }
@@ -471,6 +458,51 @@ where
             block,
             request.request.message,
             request.registered_gas_limit,
+            None,
+        )
+        .await
+    }
+
+    /// Core logic for validating the builder submission v6
+    async fn validate_builder_submission_v6(
+        &self,
+        request: BuilderBlockValidationRequestV6,
+    ) -> Result<(), ValidationApiError> {
+        let decoded_bal =
+            DecodedBal::from_rlp_bytes(request.request.execution_payload.block_access_list.clone())
+                .map_err(ValidationApiError::InvalidBlockAccessList)?;
+
+        let block = self.payload_validator.ensure_well_formed_payload(ExecutionData {
+            payload: ExecutionPayload::V4(request.request.execution_payload),
+            sidecar: ExecutionPayloadSidecar::v4(
+                CancunPayloadFields {
+                    parent_beacon_block_root: request.parent_beacon_block_root,
+                    versioned_hashes: self
+                        .validate_blobs_bundle_v2(request.request.blobs_bundle)?,
+                },
+                PraguePayloadFields {
+                    requests: RequestsOrHash::Requests(
+                        request.request.execution_requests.to_requests(),
+                    ),
+                },
+            ),
+        })?;
+
+        let chain_spec = self.provider.chain_spec();
+        if chain_spec.is_osaka_active_at_timestamp(block.timestamp()) &&
+            block.rlp_length() > MAX_RLP_BLOCK_SIZE
+        {
+            return Err(ValidationApiError::Consensus(ConsensusError::BlockTooLarge {
+                rlp_length: block.rlp_length(),
+                max_rlp_length: MAX_RLP_BLOCK_SIZE,
+            }));
+        }
+
+        self.validate_message_against_block(
+            block,
+            request.request.message,
+            request.registered_gas_limit,
+            Some(decoded_bal),
         )
         .await
     }
@@ -556,6 +588,24 @@ where
 
         rx.await.map_err(|_| internal_rpc_err("Internal blocking task error"))?
     }
+
+    /// Validates a block submitted to the relay
+    async fn validate_builder_submission_v6(
+        &self,
+        request: BuilderBlockValidationRequestV6,
+    ) -> RpcResult<()> {
+        let this = self.clone();
+        let (tx, rx) = oneshot::channel();
+
+        self.task_spawner.spawn_blocking_task(async move {
+            let result = Self::validate_builder_submission_v6(&this, request)
+                .await
+                .map_err(ErrorObject::from);
+            let _ = tx.send(result);
+        });
+
+        rx.await.map_err(|_| internal_rpc_err("Internal blocking task error"))?
+    }
 }
 
 pub struct ValidationApiInner<Provider, E: ConfigureEvm, T: PayloadTypes> {
@@ -646,6 +696,8 @@ pub enum ValidationApiError {
     ProposerPayment,
     #[error("invalid blobs bundle")]
     InvalidBlobsBundle,
+    #[error("invalid block access list: {_0}")]
+    InvalidBlockAccessList(alloy_rlp::Error),
     #[error("block accesses blacklisted address: {_0}")]
     Blacklist(Address),
     #[error(transparent)]
@@ -670,6 +722,7 @@ impl From<ValidationApiError> for ErrorObject<'static> {
             ValidationApiError::Blacklist(_) |
             ValidationApiError::ProposerPayment |
             ValidationApiError::InvalidBlobsBundle |
+            ValidationApiError::InvalidBlockAccessList(_) |
             ValidationApiError::Blob(_) => invalid_params_rpc_err(error.to_string()),
 
             ValidationApiError::MissingLatestBlock |
diff --git a/crates/stages/stages/Cargo.toml b/crates/stages/stages/Cargo.toml
index 970afb5b8ca..46eba3e0786 100644
--- a/crates/stages/stages/Cargo.toml
+++ b/crates/stages/stages/Cargo.toml
@@ -45,7 +45,6 @@ reth-trie-db = { workspace = true, features = ["metrics"] }
 
 reth-testing-utils = { workspace = true, optional = true }
 
-alloy-eips.workspace = true
 alloy-primitives.workspace = true
 alloy-consensus.workspace = true
 alloy-rlp.workspace = true
@@ -86,6 +85,7 @@ reth-provider = { workspace = true, features = ["test-utils"] }
 reth-network-peers.workspace = true
 
 alloy-genesis.workspace = true
+alloy-eips.workspace = true
 alloy-primitives = { workspace = true, features = ["getrandom", "rand"] }
 reth-db-common.workspace = true
 reth-tracing.workspace = true
diff --git a/crates/stages/stages/src/stages/execution/mod.rs b/crates/stages/stages/src/stages/execution/mod.rs
index 2aeb0d7afc3..642b7ad773d 100644
--- a/crates/stages/stages/src/stages/execution/mod.rs
+++ b/crates/stages/stages/src/stages/execution/mod.rs
@@ -357,7 +357,9 @@ where
                 })
             })?;
 
-            if let Err(err) = self.consensus.validate_block_post_execution(&block, &result, None) {
+            if let Err(err) =
+                self.consensus.validate_block_post_execution(&block, &result, None, None)
+            {
                 return Err(StageError::Block {
                     block: Box::new(block.block_with_parent()),
                     error: BlockErrorKind::Validation(err),
diff --git a/crates/stages/stages/src/stages/merkle.rs b/crates/stages/stages/src/stages/merkle.rs
index 3271eeaa219..bb1e44b6668 100644
--- a/crates/stages/stages/src/stages/merkle.rs
+++ b/crates/stages/stages/src/stages/merkle.rs
@@ -312,7 +312,7 @@ where
             debug!(target: "sync::stages::merkle::exec", current = ?current_block_number, target = ?to_block, "Updating trie in chunks");
             let mut final_root = None;
             for start_block in range.step_by(incremental_threshold as usize) {
-                let chunk_to = std::cmp::min(start_block + incremental_threshold, to_block);
+                let chunk_to = std::cmp::min(start_block + incremental_threshold - 1, to_block);
                 let chunk_range = start_block..=chunk_to;
                 debug!(
                     target: "sync::stages::merkle::exec",
diff --git a/crates/stages/stages/src/stages/tx_lookup.rs b/crates/stages/stages/src/stages/tx_lookup.rs
index 6940403976d..9eae2084e3d 100644
--- a/crates/stages/stages/src/stages/tx_lookup.rs
+++ b/crates/stages/stages/src/stages/tx_lookup.rs
@@ -1,4 +1,4 @@
-use alloy_eips::eip2718::Encodable2718;
+use alloy_consensus::transaction::TxHashRef;
 use alloy_primitives::{TxHash, TxNumber};
 use num_traits::Zero;
 use reth_config::config::{EtlConfig, TransactionLookupConfig};
@@ -237,7 +237,7 @@ where
                 for transaction in
                     static_file_provider.transactions_by_tx_range(body.tx_num_range())?
                 {
-                    writer.delete_transaction_hash_number(transaction.trie_hash())?;
+                    writer.delete_transaction_hash_number(*transaction.tx_hash())?;
                 }
             }
 
diff --git a/crates/storage/db-common/src/init.rs b/crates/storage/db-common/src/init.rs
index f42eca05925..32924a67a1e 100644
--- a/crates/storage/db-common/src/init.rs
+++ b/crates/storage/db-common/src/init.rs
@@ -67,7 +67,10 @@ const SOFT_LIMIT_COUNT_FLUSHED_UPDATES: usize = 1_000_000;
 /// Max number of storage "units" (1 per account + 1 per storage slot) before committing
 /// the current MDBX transaction and opening a new one. This bounds dirty page accumulation
 /// and prevents OOM on large state imports.
-const STORAGE_COMMIT_THRESHOLD: usize = 500_000;
+const STORAGE_COMMIT_THRESHOLD: usize = 100_000;
+
+/// Max number of trie updates retained before init-state state root computation commits progress.
+const STATE_ROOT_COMMIT_THRESHOLD: u64 = 25_000;
 
 /// Storage initialization error type.
 #[derive(Debug, thiserror::Error, Clone)]
@@ -138,6 +141,39 @@ pub fn init_genesis_with_settings<PF>(
     factory: &PF,
     genesis_storage_settings: StorageSettings,
 ) -> Result<B256, InitStorageError>
+where
+    PF: DatabaseProviderFactory
+        + StaticFileProviderFactory<Primitives: NodePrimitives<BlockHeader: Compact>>
+        + ChainSpecProvider
+        + StageCheckpointReader
+        + BlockNumReader
+        + MetadataProvider
+        + StorageSettingsCache,
+    PF::ProviderRW: StaticFileProviderFactory<Primitives = PF::Primitives>
+        + StageCheckpointWriter
+        + HistoryWriter
+        + HeaderProvider
+        + HashingWriter
+        + StateWriter
+        + TrieWriter
+        + MetadataWriter
+        + ChainSpecProvider
+        + StorageSettingsCache
+        + RocksDBProviderFactory
+        + NodePrimitivesProvider
+        + AsRef<PF::ProviderRW>,
+    PF::ChainSpec: EthChainSpec<Header = <PF::Primitives as NodePrimitives>::BlockHeader>,
+{
+    init_genesis_with_settings_and_validate(factory, genesis_storage_settings, true)
+}
+
+/// Write the genesis block if it has not already been written with [`StorageSettings`],
+/// optionally validating the DB-resident genesis hash against the chainspec hash.
+pub fn init_genesis_with_settings_and_validate<PF>(
+    factory: &PF,
+    genesis_storage_settings: StorageSettings,
+    validate_genesis_hash: bool,
+) -> Result<B256, InitStorageError>
 where
     PF: DatabaseProviderFactory
         + StaticFileProviderFactory<Primitives: NodePrimitives<BlockHeader: Compact>>
@@ -196,6 +232,15 @@ where
                 return Ok(hash)
             }
 
+            if !validate_genesis_hash {
+                warn!(
+                    target: "reth::storage",
+                    chainspec_hash = %hash,
+                    storage_hash = %block_hash,
+                    "Genesis hash mismatch with chainspec; trusting DB per --debug.skip-genesis-validation"
+                );
+                return Ok(block_hash)
+            }
             return Err(InitStorageError::GenesisHashMismatch {
                 chainspec_hash: hash,
                 storage_hash: block_hash,
@@ -603,22 +648,22 @@ fn parse_state_root(reader: &mut impl BufRead) -> eyre::Result<B256> {
 
 /// Parses accounts and pushes them to a [`Collector`].
 fn parse_accounts(
-    mut reader: impl BufRead,
+    reader: impl BufRead,
     etl_config: EtlConfig,
 ) -> Result<Collector<Address, GenesisAccount>, eyre::Error> {
-    let mut line = String::new();
     let mut collector = Collector::new(etl_config.file_size, etl_config.dir);
+    let mut parsed_accounts = 0usize;
 
-    loop {
-        let n = reader.read_line(&mut line)?;
-        if n == 0 {
-            break
-        }
-
-        let GenesisAccountWithAddress { genesis_account, address } = serde_json::from_str(&line)?;
+    let stream =
+        serde_json::Deserializer::from_reader(reader).into_iter::<GenesisAccountWithAddress>();
+    for account in stream {
+        let GenesisAccountWithAddress { genesis_account, address } = account?;
         collector.insert(address, genesis_account)?;
 
-        line.clear();
+        parsed_accounts += 1;
+        if parsed_accounts.is_multiple_of(100_000) {
+            info!(target: "reth::cli", parsed_accounts, "Parsed accounts");
+        }
     }
 
     Ok(collector)
@@ -645,7 +690,16 @@ fn dump_state<PF>(
 ) -> Result<(), eyre::Error>
 where
     PF: DatabaseProviderFactory<ProviderRW: DBProvider<Tx: DbTxMut>>,
+    PF::ProviderRW: StaticFileProviderFactory
+        + StorageSettingsCache
+        + RocksDBProviderFactory
+        + NodePrimitivesProvider,
 {
+    let storage_settings = provider_factory.database_provider_rw()?.cached_storage_settings();
+    if storage_settings.storage_v2 {
+        return dump_state_v2(collector, provider_factory, block)
+    }
+
     let accounts_len = collector.len();
     let mut total_accounts: usize = 0;
     let mut storage_units: usize = 0;
@@ -677,6 +731,7 @@ where
                 "Committed chunk"
             );
             storage_units = 0;
+            seen_bytecodes = B256Set::default();
         }
 
         write_account_to_db(
@@ -704,6 +759,212 @@ where
     Ok(())
 }
 
+fn dump_state_v2<PF>(
+    mut collector: Collector<Address, GenesisAccount>,
+    provider_factory: &PF,
+    block: u64,
+) -> Result<(), eyre::Error>
+where
+    PF: DatabaseProviderFactory<
+        ProviderRW: StaticFileProviderFactory
+                        + DBProvider<Tx: DbTxMut>
+                        + StorageSettingsCache
+                        + RocksDBProviderFactory
+                        + NodePrimitivesProvider,
+    >,
+{
+    let accounts_len = collector.len();
+    let mut total_accounts: usize = 0;
+    let mut storage_units: usize = 0;
+
+    // pre-allocate the history list once — every entry uses the same single-block bitmap
+    let history_list = IntegerList::new([block])?;
+
+    // track seen bytecode hashes to avoid re-hashing and re-writing duplicates
+    let mut seen_bytecodes: B256Set = B256Set::default();
+
+    let mut provider_rw = provider_factory.database_provider_rw()?;
+    let static_file_provider = provider_rw.static_file_provider();
+    let rocksdb_provider = provider_rw.rocksdb_provider();
+    let mut history_batch = rocksdb_provider.batch_with_auto_commit();
+    if snapshot_state_tables_empty(provider_rw.tx_ref())? {
+        reset_pre_snapshot_changeset_segment(
+            &static_file_provider,
+            StaticFileSegment::AccountChangeSets,
+            block,
+        )?;
+        reset_pre_snapshot_changeset_segment(
+            &static_file_provider,
+            StaticFileSegment::StorageChangeSets,
+            block,
+        )?;
+    }
+
+    {
+        let mut account_changeset_writer =
+            static_file_provider.get_writer(block, StaticFileSegment::AccountChangeSets)?;
+        let mut storage_changeset_writer =
+            static_file_provider.get_writer(block, StaticFileSegment::StorageChangeSets)?;
+        prepare_account_changeset_writer(&mut account_changeset_writer, block)?;
+        prepare_storage_changeset_writer(&mut storage_changeset_writer, block)?;
+
+        for entry in collector.iter()? {
+            let (address_raw, account_raw) = entry?;
+            let (address, _) = Address::from_compact(address_raw.as_slice(), address_raw.len());
+            let (account, _) =
+                GenesisAccount::from_compact(account_raw.as_slice(), account_raw.len());
+
+            let account_storage_len = account.storage.as_ref().map_or(0, |s| s.len());
+            let account_units = 1 + account_storage_len;
+
+            // commit before this account would push us over the threshold
+            if storage_units > 0 && storage_units + account_units > STORAGE_COMMIT_THRESHOLD {
+                history_batch.commit()?;
+                commit_mdbx_only(provider_rw)?;
+                provider_rw = provider_factory.database_provider_rw()?;
+                history_batch = rocksdb_provider.batch_with_auto_commit();
+                info!(target: "reth::cli",
+                    total_accounts,
+                    accounts_len,
+                    storage_units,
+                    "Committed chunk"
+                );
+                storage_units = 0;
+                seen_bytecodes = B256Set::default();
+            }
+
+            write_account_to_db_v2(
+                provider_rw.tx_ref(),
+                (&mut account_changeset_writer, &mut storage_changeset_writer),
+                &mut history_batch,
+                &address,
+                &account,
+                &history_list,
+                &mut seen_bytecodes,
+            )?;
+
+            total_accounts += 1;
+            storage_units += account_units;
+
+            if total_accounts.is_multiple_of(100_000) {
+                info!(target: "reth::cli", total_accounts, accounts_len, "Writing accounts...");
+            }
+        }
+    }
+
+    history_batch.commit()?;
+    commit_mdbx_only(provider_rw)?;
+    static_file_provider.finalize()?;
+
+    info!(target: "reth::cli", total_accounts, "All accounts written to database");
+
+    Ok(())
+}
+
+fn prepare_account_changeset_writer<N: NodePrimitives>(
+    writer: &mut reth_provider::providers::StaticFileProviderRWRefMut<'_, N>,
+    block: u64,
+) -> ProviderResult<()> {
+    let next_block = writer.next_block_number();
+    if next_block < block {
+        info!(
+            target: "reth::cli",
+            from_block = next_block,
+            to_block = block - 1,
+            "Padding empty account changesets before state import"
+        );
+        for empty_block in next_block..block {
+            writer.append_account_changeset(Vec::new(), empty_block)?;
+            if empty_block > next_block && empty_block.is_multiple_of(1_000_000) {
+                info!(
+                    target: "reth::cli",
+                    padded_to_block = empty_block,
+                    "Padded empty account changesets"
+                );
+            }
+        }
+    }
+
+    writer.begin_account_changeset(block)
+}
+
+fn prepare_storage_changeset_writer<N: NodePrimitives>(
+    writer: &mut reth_provider::providers::StaticFileProviderRWRefMut<'_, N>,
+    block: u64,
+) -> ProviderResult<()> {
+    let next_block = writer.next_block_number();
+    if next_block < block {
+        info!(
+            target: "reth::cli",
+            from_block = next_block,
+            to_block = block - 1,
+            "Padding empty storage changesets before state import"
+        );
+        for empty_block in next_block..block {
+            writer.append_storage_changeset(Vec::new(), empty_block)?;
+            if empty_block > next_block && empty_block.is_multiple_of(1_000_000) {
+                info!(
+                    target: "reth::cli",
+                    padded_to_block = empty_block,
+                    "Padded empty storage changesets"
+                );
+            }
+        }
+    }
+
+    writer.begin_storage_changeset(block)
+}
+
+fn snapshot_state_tables_empty<TX: reth_db_api::transaction::DbTx>(
+    tx: &TX,
+) -> ProviderResult<bool> {
+    Ok(tx.entries::<tables::PlainAccountState>()? == 0 &&
+        tx.entries::<tables::PlainStorageState>()? == 0 &&
+        tx.entries::<tables::HashedAccounts>()? == 0 &&
+        tx.entries::<tables::HashedStorages>()? == 0 &&
+        tx.entries::<tables::AccountChangeSets>()? == 0 &&
+        tx.entries::<tables::StorageChangeSets>()? == 0 &&
+        tx.entries::<tables::Bytecodes>()? == 0)
+}
+
+fn reset_pre_snapshot_changeset_segment<N: NodePrimitives>(
+    static_file_provider: &reth_provider::providers::StaticFileProvider<N>,
+    segment: StaticFileSegment,
+    block: u64,
+) -> ProviderResult<()> {
+    if block == 0 {
+        return Ok(())
+    }
+
+    let Some(highest_block) = static_file_provider.get_highest_static_file_block(segment) else {
+        return Ok(())
+    };
+
+    if highest_block >= block {
+        return Ok(())
+    }
+
+    let file_start = static_file_provider.find_fixed_range(segment, block).start();
+    info!(
+        target: "reth::cli",
+        ?segment,
+        highest_block,
+        import_block = block,
+        file_start,
+        "Resetting pre-snapshot changeset static files before state import"
+    );
+    static_file_provider.delete_segment(segment)?;
+
+    Ok(())
+}
+
+fn commit_mdbx_only<Provider>(provider: Provider) -> ProviderResult<()>
+where
+    Provider: DBProvider<Tx: DbTxMut>,
+{
+    reth_db_api::transaction::DbTx::commit(provider.into_tx()).map_err(ProviderError::from)
+}
+
 /// Writes a single account and all its storage to every required DB table directly,
 /// without building intermediary structures.
 ///
@@ -759,11 +1020,7 @@ fn write_account_to_db<TX: DbTxMut>(
         let mut plain_storage_cursor = tx.cursor_dup_write::<tables::PlainStorageState>()?;
         let mut storage_cs_cursor = tx.cursor_dup_write::<tables::StorageChangeSets>()?;
 
-        // sort storage slots by key so we can use append_dup for plain/changeset tables
-        let mut sorted_slots: Vec<_> = storage.iter().collect();
-        sorted_slots.sort_unstable_by_key(|(k, _)| *k);
-
-        for &(&key, &value) in &sorted_slots {
+        for (&key, &value) in storage {
             let value_u256 = U256::from_be_bytes(value.0);
 
             // plain storage — sorted by (address, key), use append_dup
@@ -791,6 +1048,78 @@ fn write_account_to_db<TX: DbTxMut>(
     Ok(())
 }
 
+/// Writes a single account to the v2 storage destinations.
+///
+/// Storage v2 uses hashed state as the canonical state, static-file change sets, and `RocksDB`
+/// history indices. The ETL collector yields accounts sorted by address and genesis storage is a
+/// `BTreeMap`, so the streaming static-file writes preserve the required order.
+fn write_account_to_db_v2<TX, N>(
+    tx: &TX,
+    changeset_writers: (
+        &mut reth_provider::providers::StaticFileProviderRWRefMut<'_, N>,
+        &mut reth_provider::providers::StaticFileProviderRWRefMut<'_, N>,
+    ),
+    history_batch: &mut reth_provider::providers::RocksDBBatch<'_>,
+    address: &Address,
+    genesis_account: &GenesisAccount,
+    history_list: &IntegerList,
+    seen_bytecodes: &mut B256Set,
+) -> Result<(), eyre::Error>
+where
+    TX: DbTxMut,
+    N: NodePrimitives,
+{
+    let bytecode_hash = if let Some(code) = &genesis_account.code {
+        let bytecode = Bytecode::new_raw_checked(code.clone())
+            .map_err(|e| eyre::eyre!("Invalid bytecode for {address}: {e}"))?;
+        let hash = bytecode.hash_slow();
+        if seen_bytecodes.insert(hash) {
+            tx.put::<tables::Bytecodes>(hash, bytecode)?;
+        }
+        Some(hash)
+    } else {
+        None
+    };
+
+    let account = Account {
+        nonce: genesis_account.nonce.unwrap_or_default(),
+        balance: genesis_account.balance,
+        bytecode_hash,
+    };
+
+    let hashed_address = keccak256(address);
+    let (account_changeset_writer, storage_changeset_writer) = changeset_writers;
+
+    tx.put::<tables::HashedAccounts>(hashed_address, account)?;
+    account_changeset_writer
+        .append_account_changeset_entry(AccountBeforeTx { address: *address, info: None })?;
+    history_batch
+        .put::<tables::AccountsHistory>(ShardedKey::new(*address, u64::MAX), history_list)?;
+
+    if let Some(storage) = &genesis_account.storage {
+        let mut hashed_storage_cursor = tx.cursor_dup_write::<tables::HashedStorages>()?;
+
+        for (&key, &value) in storage {
+            let value_u256 = U256::from_be_bytes(value.0);
+
+            let hashed_key = keccak256(key);
+            hashed_storage_cursor
+                .upsert(hashed_address, &StorageEntry { key: hashed_key, value: value_u256 })?;
+
+            storage_changeset_writer.append_storage_changeset_entry(
+                reth_db_api::models::StorageBeforeTx { address: *address, key, value: U256::ZERO },
+            )?;
+
+            history_batch.put::<tables::StoragesHistory>(
+                StorageShardedKey::new(*address, key, u64::MAX),
+                history_list,
+            )?;
+        }
+    }
+
+    Ok(())
+}
+
 /// Computes the state root (from scratch) based on the accounts and storages present in the
 /// database.
 fn compute_state_root<Provider>(
@@ -899,8 +1228,9 @@ where
         let provider_rw = provider_factory.database_provider_rw().map_err(provider_db_err)?;
         let tx = provider_rw.tx_ref();
 
-        let state_root =
-            DbStateRoot::<_, A>::from_tx(tx).with_intermediate_state(intermediate_state.take());
+        let state_root = DbStateRoot::<_, A>::from_tx(tx)
+            .with_intermediate_state(intermediate_state.take())
+            .with_threshold(STATE_ROOT_COMMIT_THRESHOLD);
 
         match state_root.root_with_progress()? {
             StateRootProgress::Progress(state, _, updates) => {
@@ -989,6 +1319,193 @@ mod tests {
         Ok(tx.cursor_read::<T>()?.walk_range(..)?.collect::<Result<Vec<_>, _>>()?)
     }
 
+    #[test]
+    fn parse_accounts_streams_jsonl_accounts() {
+        let input = br#"{"address":"0x0000000000000000000000000000000000000002","balance":"0x2"}
+{"address":"0x0000000000000000000000000000000000000001","balance":"0x1"}
+"#;
+
+        let mut collector =
+            parse_accounts(&input[..], EtlConfig::new(None, 128)).expect("parse succeeds");
+
+        let accounts = collector
+            .iter()
+            .unwrap()
+            .map(|entry| {
+                let (address_raw, account_raw) = entry.unwrap();
+                let (address, _) = Address::from_compact(address_raw.as_slice(), address_raw.len());
+                let (account, _) =
+                    GenesisAccount::from_compact(account_raw.as_slice(), account_raw.len());
+                (address, account.balance)
+            })
+            .collect::<Vec<_>>();
+
+        assert_eq!(
+            accounts,
+            vec![
+                (Address::with_last_byte(1), U256::from(1)),
+                (Address::with_last_byte(2), U256::from(2))
+            ]
+        );
+    }
+
+    #[test]
+    fn dump_state_uses_storage_v2_destinations() {
+        let storage_key = B256::with_last_byte(3);
+        let input = br#"{"address":"0x0000000000000000000000000000000000000001","balance":"0x1"}
+{"address":"0x0000000000000000000000000000000000000002","balance":"0x0","storage":{"0x0000000000000000000000000000000000000000000000000000000000000003":"0x0000000000000000000000000000000000000000000000000000000000000004"}}
+"#;
+
+        let collector = parse_accounts(&input[..], EtlConfig::new(None, 128)).unwrap();
+        let factory = create_test_provider_factory_with_chain_spec(MAINNET.clone());
+        factory.set_storage_settings_cache(StorageSettings::v2());
+        let block = 10;
+
+        dump_state(collector, &factory, block).unwrap();
+
+        let provider = factory.provider().unwrap();
+        let tx = provider.tx_ref();
+        assert_eq!(tx.entries::<tables::PlainAccountState>().unwrap(), 0);
+        assert_eq!(tx.entries::<tables::PlainStorageState>().unwrap(), 0);
+        assert_eq!(tx.entries::<tables::AccountChangeSets>().unwrap(), 0);
+        assert_eq!(tx.entries::<tables::StorageChangeSets>().unwrap(), 0);
+        assert_eq!(tx.entries::<tables::HashedAccounts>().unwrap(), 2);
+        assert_eq!(tx.entries::<tables::HashedStorages>().unwrap(), 1);
+
+        let address_with_balance = Address::with_last_byte(1);
+        let address_with_storage = Address::with_last_byte(2);
+        assert_eq!(
+            reth_provider::ChangeSetReader::account_block_changeset(&provider, block).unwrap(),
+            vec![
+                AccountBeforeTx { address: address_with_balance, info: None },
+                AccountBeforeTx { address: address_with_storage, info: None }
+            ]
+        );
+        assert_eq!(
+            reth_provider::StorageChangeSetReader::storage_changeset(&provider, block).unwrap(),
+            vec![(
+                BlockNumberAddress((block, address_with_storage)),
+                StorageEntry { key: storage_key, value: U256::ZERO }
+            )]
+        );
+
+        let rocksdb = factory.rocksdb_provider();
+        let accounts = rocksdb
+            .iter::<tables::AccountsHistory>()
+            .unwrap()
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
+        let storages = rocksdb
+            .iter::<tables::StoragesHistory>()
+            .unwrap()
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
+
+        assert_eq!(
+            accounts,
+            vec![
+                (
+                    ShardedKey::new(address_with_balance, u64::MAX),
+                    IntegerList::new([block]).unwrap()
+                ),
+                (
+                    ShardedKey::new(address_with_storage, u64::MAX),
+                    IntegerList::new([block]).unwrap()
+                )
+            ]
+        );
+        assert_eq!(
+            storages,
+            vec![(
+                StorageShardedKey::new(address_with_storage, storage_key, u64::MAX),
+                IntegerList::new([block]).unwrap()
+            )]
+        );
+    }
+
+    #[test]
+    fn dump_state_v2_resets_presnapshot_changeset_static_files() {
+        let storage_key = B256::with_last_byte(3);
+        let input = br#"{"address":"0x0000000000000000000000000000000000000002","balance":"0x0","storage":{"0x0000000000000000000000000000000000000000000000000000000000000003":"0x0000000000000000000000000000000000000000000000000000000000000004"}}
+"#;
+
+        let collector = parse_accounts(&input[..], EtlConfig::new(None, 128)).unwrap();
+        let factory = create_test_provider_factory_with_chain_spec(MAINNET.clone());
+        factory.set_storage_settings_cache(StorageSettings::v2());
+        let static_files = factory.static_file_provider();
+
+        {
+            let mut writer =
+                static_files.get_writer(0, StaticFileSegment::AccountChangeSets).unwrap();
+            writer.append_account_changeset(Vec::new(), 0).unwrap();
+        }
+        {
+            let mut writer =
+                static_files.get_writer(0, StaticFileSegment::StorageChangeSets).unwrap();
+            writer.append_storage_changeset(Vec::new(), 0).unwrap();
+        }
+        static_files.commit().unwrap();
+
+        let block = 500_010;
+        dump_state(collector, &factory, block).unwrap();
+        static_files.initialize_index().unwrap();
+
+        let provider = factory.provider().unwrap();
+        let address = Address::with_last_byte(2);
+        assert!(reth_provider::ChangeSetReader::account_block_changeset(&provider, 5)
+            .unwrap()
+            .is_empty());
+        assert!(reth_provider::StorageChangeSetReader::storage_changeset(&provider, 5)
+            .unwrap()
+            .is_empty());
+
+        let account_file_start =
+            static_files.find_fixed_range(StaticFileSegment::AccountChangeSets, block).start();
+        let storage_file_start =
+            static_files.find_fixed_range(StaticFileSegment::StorageChangeSets, block).start();
+        assert_eq!(account_file_start, 500_000);
+        assert_eq!(storage_file_start, 500_000);
+        assert!(reth_provider::ChangeSetReader::account_block_changeset(
+            &provider,
+            account_file_start
+        )
+        .unwrap()
+        .is_empty());
+        assert!(reth_provider::StorageChangeSetReader::storage_changeset(
+            &provider,
+            storage_file_start
+        )
+        .unwrap()
+        .is_empty());
+
+        assert_eq!(
+            reth_provider::ChangeSetReader::account_block_changeset(&provider, block).unwrap(),
+            vec![AccountBeforeTx { address, info: None }]
+        );
+        assert_eq!(
+            reth_provider::StorageChangeSetReader::storage_changeset(&provider, block).unwrap(),
+            vec![(
+                BlockNumberAddress((block, address)),
+                StorageEntry { key: storage_key, value: U256::ZERO }
+            )]
+        );
+
+        let account_offsets = static_files
+            .get_segment_provider_for_block(StaticFileSegment::AccountChangeSets, block, None)
+            .unwrap()
+            .read_changeset_offsets()
+            .unwrap()
+            .unwrap();
+        let storage_offsets = static_files
+            .get_segment_provider_for_block(StaticFileSegment::StorageChangeSets, block, None)
+            .unwrap()
+            .read_changeset_offsets()
+            .unwrap()
+            .unwrap();
+        assert_eq!(account_offsets.len() as u64, block - account_file_start + 1);
+        assert_eq!(storage_offsets.len() as u64, block - storage_file_start + 1);
+    }
+
     #[test]
     fn success_init_genesis_mainnet() {
         let genesis_hash =
@@ -1044,6 +1561,33 @@ mod tests {
         ))
     }
 
+    #[test]
+    fn skip_genesis_hash_validation_accepts_mismatched_db() {
+        let factory = create_test_provider_factory_with_chain_spec(SEPOLIA.clone());
+        let static_file_provider = factory.static_file_provider();
+        let rocksdb_provider = factory.rocksdb_provider();
+        init_genesis(&factory).unwrap();
+
+        let result = init_genesis_with_settings_and_validate(
+            &ProviderFactory::<MockNodeTypesWithDB>::new(
+                factory.into_db(),
+                MAINNET.clone(),
+                static_file_provider,
+                rocksdb_provider,
+                reth_tasks::Runtime::test(),
+            )
+            .unwrap(),
+            StorageSettings::base(),
+            false,
+        );
+
+        let returned = result.expect("skip_genesis_validation should suppress mismatch error");
+        assert_eq!(
+            returned, SEPOLIA_GENESIS_HASH,
+            "bypass returns the DB-resident hash, not the chainspec hash",
+        );
+    }
+
     #[test]
     fn init_genesis_history() {
         let address_with_balance = Address::with_last_byte(1);
diff --git a/crates/storage/db/src/implementation/mdbx/mod.rs b/crates/storage/db/src/implementation/mdbx/mod.rs
index d9c63b3bd68..b10ad2ff6be 100644
--- a/crates/storage/db/src/implementation/mdbx/mod.rs
+++ b/crates/storage/db/src/implementation/mdbx/mod.rs
@@ -549,6 +549,15 @@ impl DatabaseEnv {
         self
     }
 
+    /// Enables metrics on the database if requested.
+    pub fn with_metrics_if(self, enabled: bool) -> Self {
+        if enabled {
+            self.with_metrics()
+        } else {
+            self
+        }
+    }
+
     /// Creates all the tables defined in [`Tables`], if necessary.
     ///
     /// This keeps tracks of the created table handles and stores them for better efficiency.
diff --git a/crates/storage/db/src/static_file/cursor.rs b/crates/storage/db/src/static_file/cursor.rs
index 7721acc1a81..fc29892b37b 100644
--- a/crates/storage/db/src/static_file/cursor.rs
+++ b/crates/storage/db/src/static_file/cursor.rs
@@ -48,7 +48,7 @@ impl<'a> StaticFileCursor<'a> {
                 None => Ok(None),
             },
         }
-        .map_or(None, |v| v);
+        .unwrap_or(None);
 
         Ok(row)
     }
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/build.rs b/crates/storage/libmdbx-rs/mdbx-sys/build.rs
index c265d02e233..1bd764b87d2 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/build.rs
+++ b/crates/storage/libmdbx-rs/mdbx-sys/build.rs
@@ -20,7 +20,13 @@ fn main() {
     }
 
     let flags = format!("{:?}", cc.get_compiler().cflags_env());
-    cc.define("MDBX_BUILD_FLAGS", flags.as_str()).define("MDBX_TXN_CHECKOWNER", "0");
+    cc.define("MDBX_BUILD_FLAGS", flags.as_str())
+        .define("MDBX_TXN_CHECKOWNER", "0")
+        // Disable posix_fallocate() usage. On filesystems that do not support fallocate (e.g. ZFS),
+        // glibc's posix_fallocate() emulates it by writing zeros, which can spuriously fail with
+        // ENOSPC even when sufficient disk space is available. The fallback path uses ftruncate()
+        // which works correctly on all filesystems.
+        .define("MDBX_USE_FALLOCATE", "0");
 
     // Enable debugging on debug builds
     #[cfg(debug_assertions)]
@@ -97,6 +103,7 @@ fn generate_bindings(mdbx: &Path, out_file: &Path) {
     let bindings = bindgen::Builder::default()
         .header(mdbx.join("mdbx.h").to_string_lossy())
         .allowlist_var("^(MDBX|mdbx)_.*")
+        .blocklist_item("MDBX_NOTLS")
         .allowlist_type("^(MDBX|mdbx)_.*")
         .allowlist_function("^(MDBX|mdbx)_.*")
         .size_t_is_usize(true)
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/CMakeLists.txt b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/CMakeLists.txt
index 7d0e3f434cf..9f0a7457555 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/CMakeLists.txt
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/CMakeLists.txt
@@ -1,10 +1,12 @@
-# Copyright (c) 2020-2025 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> ###############################################
+# Copyright (c) 2020-2026 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> ###############################################
 # SPDX-License-Identifier: Apache-2.0
 #
-# Donations are welcome to ETH `0xD104d8f8B2dC312aaD74899F83EBf3EEBDC1EA3A`. Всё будет хорошо!
+# Donations are welcome to ETH `0xD104d8f8B2dC312aaD74899F83EBf3EEBDC1EA3A`,
+# BTC `bc1qzvl9uegf2ea6cwlytnanrscyv8snwsvrc0xfsu`, SOL `FTCTgbHajoLVZGr8aEFWMzx3NDMyS5wXJgfeMTmJznRi`.
+# Всё будет хорошо!
 
-# libmdbx = { Revised and extended descendant of Symas LMDB. } Please see README.md at
-# https://gitflic.ru/project/erthink/libmdbx
+# libmdbx = { Revised and extended descendant of Symas LMDB. }
+# Please see README.md at https://sourcecraft.dev/dqdkfa/libmdbx
 #
 # Libmdbx is superior to LMDB in terms of features and reliability, not inferior in performance. libmdbx works on Linux,
 # FreeBSD, MacOS X and other systems compliant with POSIX.1-2008, but also support Windows as a complementary platform.
@@ -12,10 +14,8 @@
 # The next version is under active non-public development and will be released as MithrilDB and libmithrildb for
 # libraries & packages. Admittedly mythical Mithril is resembling silver but being stronger and lighter than steel.
 # Therefore MithrilDB is rightly relevant name.
-#
-# MithrilDB will be radically different from libmdbx by the new database format and API based on C++17, as well as the
-# Apache 2.0 License. The goal of this revolution is to provide a clearer and robust API, add more features and new
-# valuable properties of database.
+# MithrilDB will be radically different from libmdbx by the new database format and API based on C++20.
+# The goal of this revolution is to provide a clearer and robust API, add more features and new valuable properties.
 
 if(CMAKE_VERSION VERSION_LESS 3.8.2)
   cmake_minimum_required(VERSION 3.0.2)
@@ -53,122 +53,12 @@ endif()
 
 cmake_policy(SET CMP0054 NEW)
 
-if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/COPYRIGHT"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/NOTICE"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/README.md"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/mdbx.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/mdbx.h++"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/alloy.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/api-cold.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/api-copy.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/api-cursor.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/api-dbi.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/api-env.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/api-extra.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/api-key-transform.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/api-misc.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/api-opts.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/api-range-estimate.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/api-txn-data.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/api-txn.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/atomics-ops.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/atomics-types.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/audit.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/chk.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/cogs.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/cogs.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/coherency.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/cursor.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/cursor.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/dbi.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/dbi.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/debug_begin.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/debug_end.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/dpl.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/dpl.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/dxb.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/env.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/essentials.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/gc-get.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/gc-put.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/gc.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/global.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/internals.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/layout-dxb.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/layout-lck.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/lck-posix.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/lck-windows.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/lck.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/lck.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/logging_and_debug.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/logging_and_debug.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/man1/mdbx_chk.1"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/man1/mdbx_copy.1"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/man1/mdbx_drop.1"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/man1/mdbx_dump.1"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/man1/mdbx_load.1"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/man1/mdbx_stat.1"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/mdbx.c++"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/meta.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/meta.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/mvcc-readers.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/node.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/node.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/ntdll.def"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/options.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/osal.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/osal.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/page-get.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/page-iov.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/page-iov.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/page-ops.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/page-ops.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/tree-search.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/pnl.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/pnl.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/preface.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/proto.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/refund.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/sort.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/spill.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/spill.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/table.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/tls.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/tls.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/tools/chk.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/tools/copy.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/tools/drop.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/tools/dump.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/tools/load.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/tools/stat.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/tools/wingetopt.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/tools/wingetopt.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/tree-ops.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/txl.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/txl.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/txn.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/unaligned.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/utils.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/utils.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/version.c.in"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/walk.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/walk.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/windows-import.c"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/windows-import.h"
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
-  set(MDBX_AMALGAMATED_SOURCE FALSE)
-  find_program(GIT git)
-  if(NOT GIT)
-    message(SEND_ERROR "Git command-line tool not found")
-  endif()
-  set(MDBX_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
-elseif(
-  EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/VERSION.json"
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/VERSION.json"
+  AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/COPYRIGHT"
   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE"
   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/NOTICE"
+  AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/README.md"
+  AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/GNUmakefile"
   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/mdbx.c"
   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/mdbx.c++"
   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/mdbx.h"
@@ -186,8 +76,9 @@ elseif(
 else()
   message(
     FATAL_ERROR
-      "\nThe set of libmdbx source code files is incomplete!  "
-      "Instead just follow the https://libmdbx.dqdkfa.ru/usage.html  " "PLEASE, AVOID USING ANY OTHER TECHNIQUES.")
+      "\nThe set of libmdbx source code files is incomplete!"
+      "  Instead just follow the https://libmdbx.dqdkfa.ru/usage.html"
+      "  PLEASE, AVOID USING ANY OTHER TECHNIQUES.")
 endif()
 
 # Provide version
@@ -206,9 +97,6 @@ endif()
 if(DEFINED PROJECT_NAME AND NOT MDBX_FORCE_BUILD_AS_MAIN_PROJECT)
   set(SUBPROJECT ON)
   set(NOT_SUBPROJECT OFF)
-  if(NOT MDBX_AMALGAMATED_SOURCE AND NOT DEFINED BUILD_TESTING)
-    set(BUILD_TESTING OFF)
-  endif()
   enable_language(C)
 else()
   set(SUBPROJECT OFF)
@@ -228,25 +116,18 @@ else()
   endif()
 
   project(libmdbx C)
-  if(NOT MDBX_AMALGAMATED_SOURCE AND NOT DEFINED BUILD_TESTING)
-    set(BUILD_TESTING ON)
-  endif()
 endif()
 
-if(NOT MDBX_AMALGAMATED_SOURCE)
+if(NOT ((DEFINED BUILD_TESTING AND NOT BUILD_TESTING) OR (DEFINED MDBX_ENABLE_TESTS AND NOT MDBX_ENABLE_TESTS)))
   include(CTest)
-  option(MDBX_ENABLE_TESTS "Build libmdbx tests." ${BUILD_TESTING})
-elseif(DEFINED MDBX_ENABLE_TESTS AND MDBX_ENABLE_TESTS)
-  message(WARNING "MDBX_ENABLE_TESTS=${MDBX_ENABLE_TESTS}: But amalgamated source code don't includes tests.")
-  set(MDBX_ENABLE_TESTS OFF)
+  option(MDBX_ENABLE_TESTS "Build MDBX tests" ${BUILD_TESTING})
 endif()
 
 # Try to find a C++ compiler unless sure that this is unnecessary.
 if(NOT CMAKE_CXX_COMPILER_LOADED)
   include(CheckLanguage)
-  if(NOT DEFINED MDBX_BUILD_CXX
-     OR MDBX_BUILD_CXX
-     OR (NOT MDBX_AMALGAMATED_SOURCE AND (NOT DEFINED MDBX_ENABLE_TESTS OR MDBX_ENABLE_TESTS)))
+  if(NOT (DEFINED MDBX_BUILD_CXX AND NOT MDBX_BUILD_CXX)
+     OR NOT (DEFINED MDBX_ENABLE_TESTS AND NOT MDBX_ENABLE_TESTS))
     check_language(CXX)
     if(CMAKE_CXX_COMPILER)
       enable_language(CXX)
@@ -443,68 +324,6 @@ else()
     set(LTO_ENABLED FALSE)
   endif()
 
-  if(NOT MDBX_AMALGAMATED_SOURCE)
-    find_program(VALGRIND valgrind)
-    if(VALGRIND)
-      # (LY) cmake is ugly and nasty. Therefore memcheck-options should be defined before including ctest. Otherwise
-      # ctest may ignore it.
-      set(MEMORYCHECK_SUPPRESSIONS_FILE
-          "${CMAKE_CURRENT_SOURCE_DIR}/test/valgrind_suppress.txt"
-          CACHE FILEPATH "Suppressions file for Valgrind" FORCE)
-      set(MEMORYCHECK_COMMAND_OPTIONS
-          "--trace-children=yes --leak-check=full --track-origins=yes --track-origins=yes --error-exitcode=42 --error-markers=@ --errors-for-leak-kinds=definite --fair-sched=yes --suppressions=${MEMORYCHECK_SUPPRESSIONS_FILE}"
-          CACHE STRING "Valgrind options" FORCE)
-      set(VALGRIND_COMMAND_OPTIONS
-          "${MEMORYCHECK_COMMAND_OPTIONS}"
-          CACHE STRING "Valgrind options" FORCE)
-    endif()
-
-    # Enable 'make tags' target.
-    find_program(CTAGS ctags)
-    if(CTAGS)
-      add_custom_target(
-        tags
-        COMMAND ${CTAGS} -R -f tags
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-      add_custom_target(ctags DEPENDS tags)
-    endif(CTAGS)
-
-    if(UNIX)
-      find_program(CLANG_FORMAT NAMES clang-format-13 clang-format)
-      if(CLANG_FORMAT)
-        execute_process(COMMAND ${CLANG_FORMAT} "--version" OUTPUT_VARIABLE clang_format_version_info)
-        string(REGEX MATCH "version ([0-9]+)\\.([0-9]+)\\.([0-9]+)(.*)?" clang_format_version_info CLANG_FORMAT_VERSION)
-        if(clang_format_version_info AND NOT CLANG_FORMAT_VERSION VERSION_LESS 13.0)
-          # Enable 'make reformat' target.
-          add_custom_target(
-            reformat
-            VERBATIM
-            COMMAND git ls-files | grep -E \\.\(c|cxx|cc|cpp|h|hxx|hpp\)\(\\.in\)?\$ | xargs ${CLANG_FORMAT} -i
-                    --style=file
-            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
-        endif()
-      endif()
-    endif()
-
-    if(NOT "${PROJECT_BINARY_DIR}" STREQUAL "${PROJECT_SOURCE_DIR}")
-      add_custom_target(distclean)
-      add_custom_command(
-        TARGET distclean
-        POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E remove_directory "${PROJECT_BINARY_DIR}"
-        COMMENT "Removing the build directory and its content")
-    elseif(IS_DIRECTORY .git AND GIT)
-      add_custom_target(distclean)
-      add_custom_command(
-        TARGET distclean
-        POST_BUILD
-        WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-        COMMAND ${GIT} submodule foreach --recursive git clean -f -X -d
-        COMMAND ${GIT} clean -f -X -d
-        COMMENT "Removing all build files from the source directory")
-    endif()
-  endif(NOT MDBX_AMALGAMATED_SOURCE)
-
   set(MDBX_MANAGE_BUILD_FLAGS_DEFAULT ON)
 endif(SUBPROJECT)
 
@@ -538,7 +357,8 @@ if(NOT DEFINED MDBX_CXX_STANDARD)
   elseif(CXX_FALLBACK_GNU11 OR CXX_FALLBACK_11)
     set(MDBX_CXX_STANDARD 11)
   else()
-    set(MDBX_CXX_STANDARD 98)
+    message(NOTICE "The C++ example will be skipped, since C++20 standard is unavailable or C++ API of libmdbx was disabled.")
+    set(MDBX_CXX_STANDARD 0)
   endif()
 endif()
 
@@ -574,9 +394,8 @@ if(WIN32 AND EXISTS "${MDBX_SOURCE_DIR}/ntdll.def")
   if(MSVC)
     if(NOT MSVC_LIB_EXE)
       # Find lib.exe
-      get_filename_component(CL_NAME ${CMAKE_C_COMPILER} NAME)
-      string(REPLACE cl.exe lib.exe MSVC_LIB_EXE ${CL_NAME})
-      find_program(MSVC_LIB_EXE ${MSVC_LIB_EXE})
+      get_filename_component(CC_DIR ${CMAKE_C_COMPILER} DIRECTORY)
+      find_program(MSVC_LIB_EXE "lib.exe" HINTS ${CC_DIR})
     endif()
     if(MSVC_LIB_EXE)
       message(STATUS "Found MSVC's lib tool: ${MSVC_LIB_EXE}")
@@ -588,25 +407,24 @@ if(WIN32 AND EXISTS "${MDBX_SOURCE_DIR}/ntdll.def")
         COMMAND ${MSVC_LIB_EXE} /def:"${MDBX_SOURCE_DIR}/ntdll.def" /out:"${MDBX_NTDLL_EXTRA_IMPLIB}"
                 ${INITIAL_CMAKE_STATIC_LINKER_FLAGS})
     else()
-      message(WARNING "MSVC's lib tool not found")
+      message(WARNING "MSVC's lib.exe not found")
     endif()
   elseif(MINGW OR MINGW64)
-    if(NOT DLLTOOL)
-      # Find dlltool
-      get_filename_component(GCC_NAME ${CMAKE_C_COMPILER} NAME)
-      string(REPLACE gcc dlltool DLLTOOL_NAME ${GCC_NAME})
-      find_program(DLLTOOL NAMES ${DLLTOOL_NAME})
+    if(NOT MINGW_DLLTOOL_EXE)
+      # Find dlltool.exe
+      get_filename_component(CC_DIR ${CMAKE_C_COMPILER} DIRECTORY)
+      find_program(MINGW_DLLTOOL_EXE "dlltool.exe" HINTS ${CC_DIR})
     endif()
-    if(DLLTOOL)
-      message(STATUS "Found dlltool: ${DLLTOOL}")
+    if(MINGW_DLLTOOL_EXE)
+      message(STATUS "Found MINGW's dlltool: ${MINGW_DLLTOOL_EXE}")
       set(MDBX_NTDLL_EXTRA_IMPLIB "${CMAKE_CURRENT_BINARY_DIR}/mdbx_ntdll_extra.a")
       add_custom_command(
         OUTPUT "${MDBX_NTDLL_EXTRA_IMPLIB}"
         COMMENT "Create extra-import-library for ntdll.dll"
         MAIN_DEPENDENCY "${MDBX_SOURCE_DIR}/ntdll.def"
-        COMMAND ${DLLTOOL} -d "${MDBX_SOURCE_DIR}/ntdll.def" -l "${MDBX_NTDLL_EXTRA_IMPLIB}")
+        COMMAND ${MINGW_DLLTOOL_EXE} -d "${MDBX_SOURCE_DIR}/ntdll.def" -l "${MDBX_NTDLL_EXTRA_IMPLIB}")
     else()
-      message(WARNING "dlltool not found")
+      message(WARNING "MINGW's dlltool.exe not found")
     endif()
   endif()
 
@@ -688,8 +506,7 @@ add_option(MDBX TRUST_RTC "Does a system have battery-backed Real-Time Clock or
 mark_as_advanced(MDBX_TRUST_RTC)
 add_option(MDBX FORCE_ASSERTIONS "Force enable assertion checking" OFF)
 add_option(
-  MDBX
-  DISABLE_VALIDATION
+  MDBX DISABLE_VALIDATION
   "Disable some checks to reduce an overhead and detection probability of database corruption to a values closer to the LMDB"
   OFF)
 mark_as_advanced(MDBX_DISABLE_VALIDATION)
@@ -702,15 +519,8 @@ mark_as_advanced(MDBX_ENABLE_PROFGC)
 add_option(MDBX ENABLE_DBI_SPARSE
            "Support for sparse sets of DBI handles to reduce overhead when starting and processing transactions" ON)
 add_option(MDBX ENABLE_DBI_LOCKFREE "Support for deferred releasing and a lockfree path to quickly open DBI handles" ON)
-
-if(NOT MDBX_AMALGAMATED_SOURCE)
-  if(CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE_UPPERCASE STREQUAL "DEBUG")
-    set(MDBX_ALLOY_BUILD_DEFAULT OFF)
-  else()
-    set(MDBX_ALLOY_BUILD_DEFAULT ON)
-  endif()
-  add_option(MDBX ALLOY_BUILD "Build MDBX library through single/alloyed object file" ${MDBX_ALLOY_BUILD_DEFAULT})
-endif()
+add_option(MDBX USE_FALLOCATE "Using posix_fallocate() or fcntl(F_PREALLOCATE) on OSX" AUTO)
+mark_as_advanced(MDBX_USE_FALLOCATE)
 
 if((MDBX_BUILD_TOOLS OR MDBX_ENABLE_TESTS) AND MDBX_BUILD_SHARED_LIBRARY)
   add_option(MDBX LINK_TOOLS_NONSTATIC "Link MDBX tools with non-static libmdbx" OFF)
@@ -718,23 +528,34 @@ else()
   unset(MDBX_LINK_TOOLS_NONSTATIC CACHE)
 endif()
 
+set(MDBX_CXX_AVAILABLE FALSE)
 if(CMAKE_CXX_COMPILER_LOADED
-   AND MDBX_CXX_STANDARD LESS 83
    AND NOT MDBX_CXX_STANDARD LESS 11)
-  if(NOT MDBX_AMALGAMATED_SOURCE)
-    option(MDBX_ENABLE_TESTS "Build MDBX tests" ${BUILD_TESTING})
-  endif()
   if(NOT MDBX_WITHOUT_MSVC_CRT
      AND NOT (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8)
      AND NOT (CMAKE_COMPILER_IS_CLANG AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.9)
      AND NOT (MSVC AND MSVC_VERSION LESS 1900))
+    set(MDBX_CXX_AVAILABLE TRUE)
     option(MDBX_BUILD_CXX "Build C++ portion" ON)
   else()
+    if(DEFINED MDBX_BUILD_CXX AND MDBX_BUILD_CXX)
+      if(MDBX_WITHOUT_MSVC_CRT)
+        message(
+          WARNING
+            "MDBX_BUILD_CXX=${MDBX_BUILD_CXX}: But MDBX_WITHOUT_MSVC_CRT=${MDBX_WITHOUT_MSVC_CRT} which does not allow the use of C++."
+        )
+      else()
+        message(WARNING "MDBX_BUILD_CXX=${MDBX_BUILD_CXX}: But there is no suitable C++ compiler available.")
+      endif()
+    endif()
     set(MDBX_BUILD_CXX FALSE)
   endif()
 else()
-  set(MDBX_BUILD_CXX FALSE)
-  set(MDBX_ENABLE_TESTS FALSE)
+  if(DEFINED MDBX_BUILD_CXX AND MDBX_BUILD_CXX)
+    message(WARNING "MDBX_BUILD_CXX=${MDBX_BUILD_CXX}: But there is no suitable C++11 compiler available.")
+  endif()
+  set(MDBX_ENABLE_TESTS OFF)
+  set(MDBX_BUILD_CXX OFF)
 endif()
 
 if(CI)
@@ -743,8 +564,8 @@ endif()
 
 # ######################################################################################################################
 
-if(MDBX_BUILD_CXX AND NOT CMAKE_CXX_COMPILER_LOADED)
-  message(FATAL_ERROR "MDBX_BUILD_CXX=${MDBX_BUILD_CXX}: The C++ compiler is required to build the C++API.")
+if(MDBX_BUILD_CXX AND NOT MDBX_CXX_AVAILABLE)
+  message(FATAL_ERROR "MDBX_BUILD_CXX=${MDBX_BUILD_CXX}: The C++ 11 compiler is required to build the C++API.")
 endif()
 
 if(MDBX_BUILD_CXX)
@@ -754,107 +575,16 @@ endif()
 
 # sources list
 set(LIBMDBX_PUBLIC_HEADERS mdbx.h)
-set(LIBMDBX_SOURCES mdbx.h "${CMAKE_CURRENT_BINARY_DIR}/config.h")
+set(LIBMDBX_SOURCES mdbx.h "${CMAKE_CURRENT_BINARY_DIR}/config-cmake.h")
 if(MDBX_AMALGAMATED_SOURCE)
   list(APPEND LIBMDBX_SOURCES mdbx.c)
 else()
-  # generate version file
-  configure_file("${MDBX_SOURCE_DIR}/version.c.in" "${CMAKE_CURRENT_BINARY_DIR}/version.c" ESCAPE_QUOTES)
-  file(SHA256 "${CMAKE_CURRENT_BINARY_DIR}/version.c" MDBX_SOURCERY_DIGEST)
-  string(MAKE_C_IDENTIFIER "${MDBX_GIT_DESCRIBE}" MDBX_SOURCERY_SUFFIX)
-  set(MDBX_BUILD_SOURCERY "${MDBX_SOURCERY_DIGEST}_${MDBX_SOURCERY_SUFFIX}")
-
-  if(MDBX_ALLOY_BUILD)
-    list(APPEND LIBMDBX_SOURCES "${MDBX_SOURCE_DIR}/alloy.c")
-    include_directories("${MDBX_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}")
-  else()
-    list(
-      APPEND
-      LIBMDBX_SOURCES
-      "${MDBX_SOURCE_DIR}/api-cold.c"
-      "${MDBX_SOURCE_DIR}/api-copy.c"
-      "${MDBX_SOURCE_DIR}/api-cursor.c"
-      "${MDBX_SOURCE_DIR}/api-dbi.c"
-      "${MDBX_SOURCE_DIR}/api-env.c"
-      "${MDBX_SOURCE_DIR}/api-extra.c"
-      "${MDBX_SOURCE_DIR}/api-key-transform.c"
-      "${MDBX_SOURCE_DIR}/api-misc.c"
-      "${MDBX_SOURCE_DIR}/api-opts.c"
-      "${MDBX_SOURCE_DIR}/api-range-estimate.c"
-      "${MDBX_SOURCE_DIR}/api-txn-data.c"
-      "${MDBX_SOURCE_DIR}/api-txn.c"
-      "${MDBX_SOURCE_DIR}/atomics-ops.h"
-      "${MDBX_SOURCE_DIR}/atomics-types.h"
-      "${MDBX_SOURCE_DIR}/audit.c"
-      "${MDBX_SOURCE_DIR}/chk.c"
-      "${MDBX_SOURCE_DIR}/cogs.c"
-      "${MDBX_SOURCE_DIR}/cogs.h"
-      "${MDBX_SOURCE_DIR}/coherency.c"
-      "${MDBX_SOURCE_DIR}/cursor.c"
-      "${MDBX_SOURCE_DIR}/cursor.h"
-      "${MDBX_SOURCE_DIR}/dbi.c"
-      "${MDBX_SOURCE_DIR}/dbi.h"
-      "${MDBX_SOURCE_DIR}/dpl.c"
-      "${MDBX_SOURCE_DIR}/dpl.h"
-      "${MDBX_SOURCE_DIR}/dxb.c"
-      "${MDBX_SOURCE_DIR}/env.c"
-      "${MDBX_SOURCE_DIR}/essentials.h"
-      "${MDBX_SOURCE_DIR}/gc-get.c"
-      "${MDBX_SOURCE_DIR}/gc-put.c"
-      "${MDBX_SOURCE_DIR}/gc.h"
-      "${MDBX_SOURCE_DIR}/global.c"
-      "${MDBX_SOURCE_DIR}/internals.h"
-      "${MDBX_SOURCE_DIR}/layout-dxb.h"
-      "${MDBX_SOURCE_DIR}/layout-lck.h"
-      "${MDBX_SOURCE_DIR}/lck.c"
-      "${MDBX_SOURCE_DIR}/lck.h"
-      "${MDBX_SOURCE_DIR}/logging_and_debug.c"
-      "${MDBX_SOURCE_DIR}/logging_and_debug.h"
-      "${MDBX_SOURCE_DIR}/meta.c"
-      "${MDBX_SOURCE_DIR}/meta.h"
-      "${MDBX_SOURCE_DIR}/mvcc-readers.c"
-      "${MDBX_SOURCE_DIR}/node.c"
-      "${MDBX_SOURCE_DIR}/node.h"
-      "${MDBX_SOURCE_DIR}/options.h"
-      "${MDBX_SOURCE_DIR}/osal.c"
-      "${MDBX_SOURCE_DIR}/osal.h"
-      "${MDBX_SOURCE_DIR}/page-get.c"
-      "${MDBX_SOURCE_DIR}/page-iov.c"
-      "${MDBX_SOURCE_DIR}/page-iov.h"
-      "${MDBX_SOURCE_DIR}/page-ops.c"
-      "${MDBX_SOURCE_DIR}/page-ops.h"
-      "${MDBX_SOURCE_DIR}/tree-search.c"
-      "${MDBX_SOURCE_DIR}/pnl.c"
-      "${MDBX_SOURCE_DIR}/pnl.h"
-      "${MDBX_SOURCE_DIR}/preface.h"
-      "${MDBX_SOURCE_DIR}/proto.h"
-      "${MDBX_SOURCE_DIR}/refund.c"
-      "${MDBX_SOURCE_DIR}/sort.h"
-      "${MDBX_SOURCE_DIR}/spill.c"
-      "${MDBX_SOURCE_DIR}/spill.h"
-      "${MDBX_SOURCE_DIR}/table.c"
-      "${MDBX_SOURCE_DIR}/tls.c"
-      "${MDBX_SOURCE_DIR}/tls.h"
-      "${MDBX_SOURCE_DIR}/tree-ops.c"
-      "${MDBX_SOURCE_DIR}/txl.c"
-      "${MDBX_SOURCE_DIR}/txl.h"
-      "${MDBX_SOURCE_DIR}/txn.c"
-      "${MDBX_SOURCE_DIR}/unaligned.h"
-      "${MDBX_SOURCE_DIR}/utils.c"
-      "${MDBX_SOURCE_DIR}/utils.h"
-      "${MDBX_SOURCE_DIR}/walk.c"
-      "${MDBX_SOURCE_DIR}/walk.h"
-      "${CMAKE_CURRENT_BINARY_DIR}/version.c")
-    if(NOT MSVC)
-      list(APPEND LIBMDBX_SOURCES "${MDBX_SOURCE_DIR}/lck-posix.c")
-    endif()
-    if(NOT APPLE)
-      list(APPEND LIBMDBX_SOURCES "${MDBX_SOURCE_DIR}/windows-import.h" "${MDBX_SOURCE_DIR}/windows-import.c"
-           "${MDBX_SOURCE_DIR}/lck-windows.c")
-    endif()
-    include_directories("${MDBX_SOURCE_DIR}")
+  if(NOT CMAKE_CURRENT_LIST_FILE)
+    set(CMAKE_CURRENT_LIST_FILE "CMakeLists.txt")
   endif()
+  message(FATAL_ERROR "This \"${CMAKE_CURRENT_LIST_FILE}\" has been trimmed and is therefore intended only for build from an amalgamated form of the source code.")
 endif(MDBX_AMALGAMATED_SOURCE)
+
 if(MDBX_BUILD_CXX)
   message(STATUS "Use C${MDBX_C_STANDARD} and C++${MDBX_CXX_STANDARD} for libmdbx")
   list(APPEND LIBMDBX_PUBLIC_HEADERS mdbx.h++)
@@ -938,8 +668,10 @@ target_setup_options(mdbx-static)
 libmdbx_setup_libs(mdbx-static INTERFACE)
 if(MDBX_BUILD_SHARED_LIBRARY)
   set_target_properties(mdbx-static PROPERTIES OUTPUT_NAME mdbx-static)
+  set(MDBX_LIBRARY mdbx)
 else()
   set_target_properties(mdbx-static PROPERTIES OUTPUT_NAME mdbx)
+  set(MDBX_LIBRARY mdbx-static)
 endif()
 target_include_directories(mdbx-static INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}")
 
@@ -1241,17 +973,15 @@ foreach(item IN LISTS options)
   message(STATUS "${item}: ${value}")
 endforeach(item)
 
-# provide config.h for library build info
-configure_file("${MDBX_SOURCE_DIR}/config.h.in" "${CMAKE_CURRENT_BINARY_DIR}/config.h" ESCAPE_QUOTES)
-add_definitions(-DMDBX_CONFIG_H="${CMAKE_CURRENT_BINARY_DIR}/config.h")
+# provide config-cmake.h for library build info
+file(REMOVE "${MDBX_SOURCE_DIR}/config-cmake.h")
+configure_file("${MDBX_SOURCE_DIR}/config.h.in" "${CMAKE_CURRENT_BINARY_DIR}/config-cmake.h" ESCAPE_QUOTES)
+add_definitions(-DMDBX_CONFIG_H="${CMAKE_CURRENT_BINARY_DIR}/config-cmake.h")
 
 # ######################################################################################################################
 
-if(NOT MDBX_AMALGAMATED_SOURCE AND MDBX_ENABLE_TESTS)
-  if(NOT CMAKE_CXX_COMPILER_LOADED)
-    message(FATAL_ERROR "MDBX_ENABLE_TESTS=${MDBX_ENABLE_TESTS}: The C++ compiler is required to build the tests.")
-  endif()
-  add_subdirectory(test)
+if(MDBX_ENABLE_TESTS)
+  add_subdirectory(ut_and_examples)
 endif()
 
 # ######################################################################################################################
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/COPYRIGHT b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/COPYRIGHT
new file mode 100644
index 00000000000..09de19ba504
--- /dev/null
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/COPYRIGHT
@@ -0,0 +1,159 @@
+Copyright (c) 2015-2026 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+-----------------------------------------------------------------------
+
+СМЕНА ЛИЦЕНЗИИ (THE LICENSE CHANGE)
+
+OpenLDAP Public License → Apache 2.0
+
+Briefly:
+  Historically, in 2015 an early MDBX source code was derived from the
+  "LMDB engine" created by Howard Chu <hyc@symas.com> in 2011-2015,
+  which based on btree.c written by Martin Hedenfalk <martin@bzero.se>.
+
+  By 2024, MDBX source code has actually been rewritten and has so
+  little in common with the original LMDB that I thought it admissible
+  to change the license. Below are more detailed explanations.
+
+Кратко:
+
+  Исторически в 2015 году ранний исходный код MDBX был заимствован из
+  «LMDB engine», созданной Howard Chu <hyc@symas.com> в 2011-2015,
+  на основе btree.c, ранее созданного Martin Hedenfalk <martin@bzero.se>.
+
+  К 2024 году исходный код MDBX фактически переписан и имеет настолько
+  мало общего с первоначальным заимствованием из LMDB, что я счел
+  уместным сменить лицензию. Ниже более подробные пояснения.
+
+---
+
+Первоисточник текста формулирован на Русском языке, который является
+родным для автора. Предполагается что все заинтересованные могут легко
+воспользоваться машинным переводом, который при всех недостатках сможет
+донести суть, намерения и местами даже передать тональность.
+
+The original source of this text is in Russian, which is the author's
+native language. It is assumed that all concerned can easily use machine
+translation, which, with all the disadvantages, will be able to convey
+the essence, intentions and, in some places, even convey the tonality of
+a wording.
+
+1. Причины
+
+1.1. Лицензия Apache-2.0 является одной из самых популярных, так как
+содержит ряд уточнений, проясняющих и упрощающих использование исходного
+кода в производных работах и больших проектах. Эти особенности лицензии
+Apache-2.0 я нахожу достаточно ценными и удобными. Соответственно,
+переход на лицензию Apache-2.0 полезным в целом.
+
+1.2. Проект OpenLDAP имеет определенную известность, в том числе, к
+сожалению, среди специалистов славится кране плохим качеством кода и
+сбоями при отходе от простых/базовых сценариев использования. Поэтому
+использование лицензии OpenLDAP, в глазах части аудитории, бросает тень
+на качества кода libmdbx, несмотря на то, что исходный код библиотеки
+переписан, в том числе, с целью повышения качества, надежности,
+стабильности и пригодности к тестированию.
+
+Отмечу, что здесь не место для обсуждения объективности подобных мнений
+и причин, равно как и не место для оценки компетентности специалистов
+высказывающих такие суждения. Однако, здесь необходимо озвучить сам факт
+наличия такой негативной коннотации качества кода при упоминании
+OpenLDAP, совершенно без намерения как-либо задеть или обидеть
+контрибьюторов OpenLDAP.
+
+1.3. С точки зрения исходного кода, к настоящему времени libmdbx стала
+совсем другим продуктом, о котором сейчас правильнее сказать что
+разработка вдохновлена LMDB, нежели основывается на заимствовании кода.
+Смена лицензии на переписанный код подчеркивает, что это действительно
+новый исходный код.
+
+2. Легитимность
+
+2.1. Исходная лицензия OpenLDAP 2.8 и актуальная лицензия Apache 2.0
+совпадают по базовым условиям. При этом лицензия Apache 2.0 уточняет,
+определяет и проясняет многие аспекты. Поэтому смену лицензии я склонен
+трактовать как уточнение, но НЕ как принципиальное изменение, которое
+могло-бы нарушить чьи-либо права.
+
+2.2. С процедурной точки зрения, у меня есть право сменить лицензию на
+новый, написанный мной, исходный код. При этом объективно существует как
+техническая, так и юридическая проблемы отделения «нового кода» от
+«заимствованного», а также выделение/классификация кода, который
+является общественным достоянием и/или общеупотребительным воплощением
+«математических моделей и других публичных знаний».
+
+Основываясь на собственной субъективной оценке кодовой базы, включая
+соотношения «нового», «заимствованного» и «общеупотребительного»
+исходного кода, я считаю что смена лицензии допустима. Одновременно с
+этим, я понимаю и признаю, что можно найти повод, чтобы трактовать
+ситуацию как «стакан наполовину полон/пуст». Поэтому декларирую
+готовность принимать претензии и устранять их путем полного
+переписывания оставшегося исходного кода, который попадает под критерии
+«заимствованного» и кто-то из контрибьюторов которого будет против
+изменения лицензии.
+
+2.3. Вне зависимости от истории происхождения каждой строки исходного
+кода и её буквального авторства, прошу не считать производимую смену
+лицензии, и связанных с этим технических действий, как попытку плагиата,
+присвоения чужого труда, присвоения авторства или принижения вклада
+других авторов/контрибьторов. Безусловно проект MDBX/libmdbx не появился
+бы без LMDB и всех участников проекта LMDB, в особенности Говарда Чу
+(Howard Chu), Холлварда Фурусет (Hallvard Furuseth) и Мартина Хеденфок
+(Martin Hedenfalk). Как-бы исходный код не переписывался он всё равно
+будет основываться на базовых идеях и включать основные концепции LMDB.
+
+3. Последствия и актуальные требования
+
+Всё очень просто. Потребуется обеспечить требования новой лицензии в
+соответствии с 4-м пунктом лицензции Apache 2.0.
+
+В частности, при использовании/распространении libmdbx потребуется
+обеспечить наличие файлов с текстом лицензии и файла NOTICE, а также
+обеспечить пользователям возможность ознакомиться с их содержимым в
+работах/продуктах использующих libmdbx.
+
+-----------------------------------------------------------------------
+
+Далее в справочных целях приведены уведомления об авторских правах из
+первоначально заимствованного кода.
+
+---
+
+Original source code was derived from LMDB in 2015,
+and later evolutionarily rewritten in 2015-2024:
+Copyright (c) 2011-2015 Howard Chu, Symas Corp. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted only as authorized by the OpenLDAP
+Public License.
+
+A copy of this license is available in the file LICENSE in the
+top-level directory of the distribution or, alternatively, at
+<http://www.OpenLDAP.org/license.html>.
+
+LMDB itself devived code from btree.c written by Martin Hedenfalk:
+Copyright (c) 2009, 2010 Martin Hedenfalk <martin@bzero.se>
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+ copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/GNUmakefile b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/GNUmakefile
index 32cfc9a05e6..f40b43dbc05 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/GNUmakefile
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/GNUmakefile
@@ -52,7 +52,7 @@ CC      ?= gcc
 CXX     ?= g++
 CFLAGS_EXTRA ?=
 LD      ?= ld
-CMAKE	?= cmake
+CMAKE	?= "$(shell which cmake 2>&-)"
 CMAKE_OPT ?=
 CTEST	?= ctest
 CTEST_OPT ?=
@@ -78,12 +78,12 @@ ifneq ($(make_ge_4_1),1)
 # don't use variable expansion trick as workaround for bugs of GNU Make before 4.1
 LIBS         ?= $(shell $(uname2libs))
 LDFLAGS      ?= $(shell $(uname2ldflags))
-LIB_STDCXXFS ?= $(shell echo '$(cxx_filesystem_probe)' | cat mdbx.h++ - | sed $$'1s/\xef\xbb\xbf//' | $(CXX) -x c++ $(CXXFLAGS) -Wno-error - -Wl,--allow-multiple-definition -lstdc++fs $(LIBS) $(LDFLAGS) $(EXE_LDFLAGS) -o /dev/null 2>probe4lstdfs.err >/dev/null && echo '-Wl,--allow-multiple-definition -lstdc++fs')
+LIB_STDCXXFS ?= $(shell echo '$(cxx_filesystem_probe)' | cat mdbx.h++ - | sed $$'1s/\xef\xbb\xbf//' | grep -v 'pragma once' | $(CXX) -x c++ $(CXXFLAGS) -Wno-error - -Wl,--allow-multiple-definition -lstdc++fs $(LIBS) $(LDFLAGS) $(EXE_LDFLAGS) -o /dev/null 2>probe4lstdfs.err >/dev/null && echo '-Wl,--allow-multiple-definition -lstdc++fs')
 else
 # using variable expansion trick to avoid repeaded probes
 LIBS         ?= $(eval LIBS := $$(shell $$(uname2libs)))$(LIBS)
 LDFLAGS      ?= $(eval LDFLAGS := $$(shell $$(uname2ldflags)))$(LDFLAGS)
-LIB_STDCXXFS ?= $(eval LIB_STDCXXFS := $$(shell echo '$$(cxx_filesystem_probe)' | cat mdbx.h++ - | sed $$$$'1s/\xef\xbb\xbf//' | $(CXX) -x c++ $(CXXFLAGS) -Wno-error - -Wl,--allow-multiple-definition -lstdc++fs $(LIBS) $(LDFLAGS) $(EXE_LDFLAGS) -o /dev/null 2>probe4lstdfs.err >/dev/null && echo '-Wl,--allow-multiple-definition -lstdc++fs'))$(LIB_STDCXXFS)
+LIB_STDCXXFS ?= $(eval LIB_STDCXXFS := $$(shell echo '$$(cxx_filesystem_probe)' | cat mdbx.h++ - | sed $$$$'1s/\xef\xbb\xbf//' | grep -v '#pragma once' | $(CXX) -x c++ $(CXXFLAGS) -Wno-error - -Wl,--allow-multiple-definition -lstdc++fs $(LIBS) $(LDFLAGS) $(EXE_LDFLAGS) -o /dev/null 2>probe4lstdfs.err >/dev/null && echo '-Wl,--allow-multiple-definition -lstdc++fs'))$(LIB_STDCXXFS)
 endif
 
 ifneq ($(make_ge_4_4),1)
@@ -106,11 +106,12 @@ endef
 define uname2ldflags
   case "$(UNAME)" in
     CYGWIN*|MINGW*|MSYS*|Windows*)
-      echo '-Wl,--gc-sections,-O1';
+      echo '-Wl,--gc-sections,-O1,--as-needed';
       ;;
     *)
       $(LD) --help 2>/dev/null | grep -q -- --gc-sections && echo '-Wl,--gc-sections,-z,relro,-O1';
       $(LD) --help 2>/dev/null | grep -q -- -dead_strip && echo '-Wl,-dead_strip';
+      $(LD) --help 2>/dev/null | grep -q -- --as-needed && echo '-Wl,--as-needed';
       ;;
   esac
 endef
@@ -141,7 +142,7 @@ MDBX_TOOLS := $(addprefix mdbx_,$(TOOLS))
 MANPAGES   := mdbx_stat.1 mdbx_copy.1 mdbx_dump.1 mdbx_load.1 mdbx_chk.1 mdbx_drop.1
 TIP        := // TIP:
 
-.PHONY: all help options lib libs tools clean install uninstall check_buildflags_tag tools-static
+.PHONY: all help options lib libs tools clean install uninstall check_buildflags_tag tools-static run-ut
 .PHONY: install-strip install-no-strip strip libmdbx mdbx show-options lib-static lib-shared cmake-build ninja
 
 boolean = $(if $(findstring $(strip $($1)),YES Yes yes y ON On on 1 true True TRUE),1,$(if $(findstring $(strip $($1)),NO No no n OFF Off off 0 false False FALSE),,$(error Wrong value `$($1)` of $1 for YES/NO option)))
@@ -191,6 +192,11 @@ help:
 	@echo "  make bench-triplet       - run ioarena-benchmark for mdbx, lmdb, sqlite3"
 	@echo "  make bench-quartet       - run ioarena-benchmark for mdbx, lmdb, rocksdb, wiredtiger"
 	@echo "  make bench-clean         - remove temp database(s) after benchmark"
+	@echo "  make test                - basic test(s)"
+	@echo "  make build-test          - build test(s) executable(s)"
+	@echo "  make test-asan           - build with AddressSanitizer and run basic test"
+	@echo "  make test-leak           - build with LeakSanitizer and run basic test"
+	@echo "  make test-ubsan          - build with UndefinedBehaviourSanitizer and run basic test"
 
 show-options:
 	@echo "  MDBX_BUILD_OPTIONS   = $(MDBX_BUILD_OPTIONS)"
@@ -242,21 +248,20 @@ strip: all
 	$(TRACE )strip libmdbx.$(SO_SUFFIX) $(MDBX_TOOLS)
 
 clean:
-	@echo '  REMOVE ...'
+	@echo '  CLEANING...'
 	$(QUIET)rm -rf $(MDBX_TOOLS) mdbx_test @* *.[ao] *.[ls]o *.$(SO_SUFFIX) *.dSYM *~ tmp.db/* \
 		*.gcov *.log *.err src/*.o test/*.o mdbx_example dist @dist-check \
-		config.h src/config.h src/version.c *.tar* @buildflags.tag @dist-checked.tag \
+		config-gnumake.h src/config-gnumake.h *.tar* @buildflags.tag @dist-checked.tag \
 		mdbx_*.static mdbx_*.static-lto CMakeFiles
 
 MDBX_BUILD_FLAGS =$(strip MDBX_BUILD_CXX=$(MDBX_BUILD_CXX) $(MDBX_BUILD_OPTIONS) $(call select_by,MDBX_BUILD_CXX,$(CXXFLAGS) $(LDFLAGS) $(LIB_STDCXXFS) $(LIBS),$(CFLAGS) $(LDFLAGS) $(LIBS)))
 check_buildflags_tag:
 	$(QUIET)if [ "$(MDBX_BUILD_FLAGS)" != "$$(cat @buildflags.tag 2>&1)" ]; then \
-		echo -n "  CLEAN for build with specified flags..." && \
-		$(MAKE) IOARENA=false CXXSTD= -s clean >/dev/null && echo " Ok" && \
+		echo "  TOUCH @buildflags.tag to force re-build with the (new) specified flags..." && \
 		echo '$(MDBX_BUILD_FLAGS)' > @buildflags.tag; \
 	fi
 
-@buildflags.tag: check_buildflags_tag
+@buildflags.tag: check_buildflags_tag $(WAIT)
 
 lib-static libmdbx.a: mdbx-static.o $(call select_by,MDBX_BUILD_CXX,mdbx++-static.o)
 	@echo '  AR $@'
@@ -266,9 +271,9 @@ lib-shared libmdbx.$(SO_SUFFIX): mdbx-dylib.o $(call select_by,MDBX_BUILD_CXX,md
 	@echo '  LD $@'
 	$(QUIET)$(call select_by,MDBX_BUILD_CXX,$(CXX) $(CXXFLAGS),$(CC) $(CFLAGS)) $^ -pthread -shared $(LDFLAGS) $(call select_by,MDBX_BUILD_CXX,$(LIB_STDCXXFS)) $(LIBS) -o $@
 
-ninja-assertions: CMAKE_OPT += -DMDBX_FORCE_ASSERTIONS=ON
+ninja-assertions: CMAKE_OPT += -DMDBX_FORCE_ASSERTIONS=ON $(MDBX_BUILD_OPTIONS)
 ninja-assertions: cmake-build
-ninja-debug: CMAKE_OPT += -DCMAKE_BUILD_TYPE=Debug
+ninja-debug: CMAKE_OPT += -DCMAKE_BUILD_TYPE=Debug $(MDBX_BUILD_OPTIONS)
 ninja-debug: cmake-build
 ninja: cmake-build
 cmake-build:
@@ -279,11 +284,60 @@ ctest: cmake-build
 	@echo "  RUN: ctest .."
 	$(QUIET)$(CTEST) --test-dir @cmake-ninja-build --parallel `(nproc | sysctl -n hw.ncpu | echo 2) 2>/dev/null` --schedule-random $(CTEST_OPT)
 
+run-ut: mdbx_example
+	$(QUIET)for UT in $^; do echo "  Running $$UT" && ./$${UT} || exit -1; done
+
+TEST_TARGETS := mdbx_legacy_example $(call select_by,MDBX_BUILD_CXX,mdbx_modern_example,)
+TEST_BUILD_TARGETS := build-test
+ifneq ($(CMAKE),"")
+TEST_TARGETS += ctest
+TEST_BUILD_TARGETS += cmake-build
+endif
+
+.PHONY: ninja-assertions ninja-debug ninja $(TEST_TARGETS) $(TEST_BUILD_TARGETS) test-ubsan test-asan test-memcheck test-leak test-assertion test build-test smoke check
+test: $(TEST_TARGETS)
+build-test: $(TEST_BUILD_TARGETS)
+
+test-assertion: MDBX_BUILD_OPTIONS += -DMDBX_FORCE_ASSERTIONS=1 -UNDEBUG -DMDBX_DEBUG=0
+test-assertion: CMAKE_OPT += -DMDBX_FORCE_ASSERTIONS=ON -DMDBX_DEBUG=0
+test-assertion: smoke
+
+test-valgrind: test-memcheck
+test-memcheck: CFLAGS_EXTRA += -Ofast -DENABLE_MEMCHECK
+test-memcheck: CMAKE_OPT += -DENABLE_MEMCHECK=ON
+test-memcheck: build-test build-stochastic
+	@echo '  RUNNING `test/stochastic.sh --with-valgrind --loops 2`...'
+	$(QUIET)test/stochastic.sh --with-valgrind --loops 2 --db-upto-mb 256 --skip-make >$(TEST_LOG) || (cat $(TEST_LOG) && false)
+
+test-ubsan:
+	@echo '  RE-TEST with `-fsanitize=undefined` option...'
+	$(QUIET)$(MAKE) IOARENA=false CXXSTD=$(CXXSTD) CMAKE_OPT="-DENABLE_UBSAN=ON" CFLAGS_EXTRA="-DENABLE_UBSAN -Ofast -fsanitize=undefined -fsanitize-undefined-trap-on-error" build-test test-stochastic
+
+test-asan:
+	@echo '  RE-TEST with `-fsanitize=address` option...'
+	$(QUIET)$(MAKE) IOARENA=false CXXSTD=$(CXXSTD) CMAKE_OPT="-DENABLE_ASAN=ON" CFLAGS_EXTRA="-Os -fsanitize=address" build-test test-stochastic
+
+test-leak:
+	@echo '  RE-TEST with `-fsanitize=leak` option...'
+	$(QUIET)$(MAKE) IOARENA=false CXXSTD=$(CXXSTD) CFLAGS_EXTRA="-fsanitize=leak" test-stochastic
+
+mdbx_legacy_example: mdbx.h ut_and_examples/example-mdbx.c libmdbx.$(SO_SUFFIX)
+	@echo '  CC+LD $@'
+	$(QUIET)$(CC) $(CFLAGS) -I. ut_and_examples/example-mdbx.c ./libmdbx.$(SO_SUFFIX) -o $@
+
+mdbx_modern_example: mdbx.h ut_and_examples/example-mdbx.c++ libmdbx.$(SO_SUFFIX)
+	@echo '  CC+LD $@'
+	$(QUIET)$(CXX) $(CXXFLAGS) -I. ut_and_examples/example-mdbx.c++ ./libmdbx.$(SO_SUFFIX) -o $@
+
 ################################################################################
 # Amalgamated source code, i.e. distributed after `make dist`
 MAN_SRCDIR := man1/
 
-config.h: @buildflags.tag $(WAIT) mdbx.c $(lastword $(MAKEFILE_LIST)) LICENSE NOTICE
+dist:
+	@echo '  Starting 2026 libmdbx is distrubuted in an amalgamated source code form.'
+	@echo '  So amalgamation is no longer required. Please update your build scripts.'
+
+config-gnumake.h: @buildflags.tag mdbx.c $(lastword $(MAKEFILE_LIST)) LICENSE NOTICE COPYRIGHT
 	@echo '  MAKE $@'
 	$(QUIET)(echo '#define MDBX_BUILD_TIMESTAMP "$(MDBX_BUILD_TIMESTAMP)"' \
 	&& echo "#define MDBX_BUILD_FLAGS \"$$(cat @buildflags.tag)\"" \
@@ -293,34 +347,36 @@ config.h: @buildflags.tag $(WAIT) mdbx.c $(lastword $(MAKEFILE_LIST)) LICENSE NO
 	&& echo '#define MDBX_BUILD_METADATA "$(MDBX_BUILD_METADATA)"' \
 	) >$@
 
-mdbx-dylib.o: config.h mdbx.c mdbx.h $(lastword $(MAKEFILE_LIST)) LICENSE NOTICE
+mdbx-dylib.o: config-gnumake.h mdbx.c mdbx.h $(lastword $(MAKEFILE_LIST)) LICENSE NOTICE COPYRIGHT
 	@echo '  CC $@'
-	$(QUIET)$(CC) $(CFLAGS) $(MDBX_BUILD_OPTIONS) '-DMDBX_CONFIG_H="config.h"' -DLIBMDBX_EXPORTS=1 -c mdbx.c -o $@
+	$(QUIET)$(CC) $(CFLAGS) $(MDBX_BUILD_OPTIONS) '-DMDBX_CONFIG_H="config-gnumake.h"' -DLIBMDBX_EXPORTS=1 -c mdbx.c -o $@
 
-mdbx-static.o: config.h mdbx.c mdbx.h $(lastword $(MAKEFILE_LIST)) LICENSE NOTICE
+mdbx-static.o: config-gnumake.h mdbx.c mdbx.h $(lastword $(MAKEFILE_LIST)) LICENSE NOTICE COPYRIGHT
 	@echo '  CC $@'
-	$(QUIET)$(CC) $(CFLAGS) $(MDBX_BUILD_OPTIONS) '-DMDBX_CONFIG_H="config.h"' -ULIBMDBX_EXPORTS -c mdbx.c -o $@
+	$(QUIET)$(CC) $(CFLAGS) $(MDBX_BUILD_OPTIONS) '-DMDBX_CONFIG_H="config-gnumake.h"' -ULIBMDBX_EXPORTS -c mdbx.c -o $@
 
-mdbx++-dylib.o: config.h mdbx.c++ mdbx.h mdbx.h++ $(lastword $(MAKEFILE_LIST)) LICENSE NOTICE
+mdbx++-dylib.o: config-gnumake.h mdbx.c++ $(HEADERS) $(lastword $(MAKEFILE_LIST)) LICENSE NOTICE COPYRIGHT
 	@echo '  CC $@'
-	$(QUIET)$(CXX) $(CXXFLAGS) $(MDBX_BUILD_OPTIONS) '-DMDBX_CONFIG_H="config.h"' -DLIBMDBX_EXPORTS=1 -c mdbx.c++ -o $@
+	$(QUIET)$(CXX) $(CXXFLAGS) $(MDBX_BUILD_OPTIONS) '-DMDBX_CONFIG_H="config-gnumake.h"' -DLIBMDBX_EXPORTS=1 -c mdbx.c++ -o $@
 
-mdbx++-static.o: config.h mdbx.c++ mdbx.h mdbx.h++ $(lastword $(MAKEFILE_LIST)) LICENSE NOTICE
+mdbx++-static.o: config-gnumake.h mdbx.c++ $(HEADERS) $(lastword $(MAKEFILE_LIST)) LICENSE NOTICE COPYRIGHT
 	@echo '  CC $@'
-	$(QUIET)$(CXX) $(CXXFLAGS) $(MDBX_BUILD_OPTIONS) '-DMDBX_CONFIG_H="config.h"' -ULIBMDBX_EXPORTS -c mdbx.c++ -o $@
+	$(QUIET)$(CXX) $(CXXFLAGS) $(MDBX_BUILD_OPTIONS) '-DMDBX_CONFIG_H="config-gnumake.h"' -ULIBMDBX_EXPORTS -c mdbx.c++ -o $@
 
 mdbx_%:	mdbx_%.c mdbx-static.o
 	@echo '  CC+LD $@'
-	$(QUIET)$(CC) $(CFLAGS) $(MDBX_BUILD_OPTIONS) '-DMDBX_CONFIG_H="config.h"' $^ $(EXE_LDFLAGS) $(LIBS) -o $@
+	$(QUIET)$(CC) $(CFLAGS) $(MDBX_BUILD_OPTIONS) '-DMDBX_CONFIG_H="config-gnumake.h"' $^ $(LDFLAGS) $(EXE_LDFLAGS) $(LIBS) -o $@
 
 mdbx_%.static: mdbx_%.c mdbx-static.o
 	@echo '  CC+LD $@'
-	$(QUIET)$(CC) $(CFLAGS) $(MDBX_BUILD_OPTIONS) '-DMDBX_CONFIG_H="config.h"' $^ $(EXE_LDFLAGS) -static -Wl,--strip-all -o $@
+	$(QUIET)$(CC) $(CFLAGS) $(MDBX_BUILD_OPTIONS) '-DMDBX_CONFIG_H="config-gnumake.h"' $^ $(LDFLAGS) $(EXE_LDFLAGS) -static -Wl,--strip-all -o $@
 
-mdbx_%.static-lto: mdbx_%.c config.h mdbx.c mdbx.h
+mdbx_%.static-lto: mdbx_%.c config-gnumake.h mdbx.c mdbx.h
 	@echo '  CC+LD $@'
-	$(QUIET)$(CC) $(CFLAGS) -Os -flto $(MDBX_BUILD_OPTIONS) '-DLIBMDBX_API=' '-DMDBX_CONFIG_H="config.h"' \
-		$< mdbx.c $(EXE_LDFLAGS) $(LIBS) -static -Wl,--strip-all -o $@
+	$(QUIET)$(CC) $(CFLAGS) -Os -flto $(MDBX_BUILD_OPTIONS) '-DLIBMDBX_API=' '-DMDBX_CONFIG_H="config-gnumake.h"' \
+		$< mdbx.c $(LDFLAGS) $(EXE_LDFLAGS) $(LIBS) -static -Wl,--strip-all -o $@
+
+check smoke: test
 
 install: $(LIBRARIES) $(MDBX_TOOLS) $(HEADERS)
 	@echo '  INSTALLING...'
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/NOTICE b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/NOTICE
index dd58a0b540d..b9201d4ad89 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/NOTICE
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/NOTICE
@@ -8,10 +8,11 @@ documentation, C++ API description and links to the original git repo
 with the source code. Questions, feedback and suggestions are welcome
 to the Telegram' group https://t.me/libmdbx.
 
-Donations are welcome to the Ethereum/ERC-20 `0xD104d8f8B2dC312aaD74899F83EBf3EEBDC1EA3A`.
+Donations are welcome to ETH `0xD104d8f8B2dC312aaD74899F83EBf3EEBDC1EA3A`,
+BTC `bc1qzvl9uegf2ea6cwlytnanrscyv8snwsvrc0xfsu`, SOL `FTCTgbHajoLVZGr8aEFWMzx3NDMyS5wXJgfeMTmJznRi`.
 Всё будет хорошо!
 
-Copyright 2015-2025 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru>
+Copyright 2015-2026 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru>
 SPDX-License-Identifier: Apache-2.0
 For notes about the license change, credits and acknowledgments,
 please refer to the COPYRIGHT file within libmdbx source.
@@ -30,10 +31,13 @@ As a result of what has happened, I will never, under any circumstances,
 post the primary sources (aka origins) of my projects on Github, or rely
 in any way on the Github infrastructure.
 
-Nevertheless, realizing that it is more convenient for users of
-_libmdbx_ and other my projects to access ones on Github, I do not want
-to restrict their freedom or create inconvenience, and therefore I place
-mirrors (aka mirrors) of such repositories on Github since 2025. At the
-same time, I would like to emphasize once again that these are only
-mirrors that can be frozen, blocked or deleted at any time, as was the
-case in 2022.
+Nonetheless, taking into account that it is more convenient for users of
+my projects to access them on Github, I did not want to restrict their
+freedom or create inconvenience, and therefore I posted mirrors on
+Github. However, it was noticed that despite the development of
+_libmdbx_, free support and consultations, many projects and users
+deviated from the rules of a fair deal and instead of helping and
+building relationships, they began to adjust links and delete references
+in violation of the license. Therefore, in protest against such unworthy
+actions, on December 10, 2025, I decided to abandon the placement of
+mirrors on Github.
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/VERSION.json b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/VERSION.json
index 534d22e15c6..e5440b00498 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/VERSION.json
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/VERSION.json
@@ -1 +1 @@
-{ "git_describe": "v0.13.7-0-g566b0f93", "git_timestamp": "2025-07-30T11:44:04+03:00", "git_tree": "7777cbdf5aa4c1ce85ff902a4c3e6170edd42495", "git_commit": "566b0f93c7c9a3bdffb8fb3dc0ce8ca42641bd72", "semver": "0.13.7" }
+{ "git_describe": "v0.13.12-0-gf619d43d", "git_timestamp": "2026-04-30T16:36:24+03:00", "git_tree": "f5574b87cc64fa7a3a6b21ba33809258498d5f17", "git_commit": "f619d43dfbc36cbc9a1832503ce43f2e5223996e", "semver": "0.13.12" }
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/cmake/compiler.cmake b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/cmake/compiler.cmake
index a3d789ce9af..1165bb3b51d 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/cmake/compiler.cmake
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/cmake/compiler.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2010-2025 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> ###############################################
+# Copyright (c) 2010-2026 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> ###############################################
 # SPDX-License-Identifier: Apache-2.0
 
 if(CMAKE_VERSION VERSION_LESS 3.8.2)
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/cmake/profile.cmake b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/cmake/profile.cmake
index 6a8a466ef34..e2aad1bbc29 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/cmake/profile.cmake
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/cmake/profile.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2012-2025 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> ###############################################
+# Copyright (c) 2012-2026 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> ###############################################
 # SPDX-License-Identifier: Apache-2.0
 
 if(CMAKE_VERSION VERSION_LESS 3.8.2)
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/cmake/utils.cmake b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/cmake/utils.cmake
index abb4cd30980..2bd0680bd73 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/cmake/utils.cmake
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/cmake/utils.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2012-2025 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> ###############################################
+# Copyright (c) 2012-2026 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> ###############################################
 # SPDX-License-Identifier: Apache-2.0
 
 if(CMAKE_VERSION VERSION_LESS 3.8.2)
@@ -121,11 +121,15 @@ macro(semver_parse str)
       set(_semver_ok TRUE)
     else()
       set(_semver_err
-          "Поля prerelease и/или buildmetadata (строка `-foo+bar` в составе `0.0.0[.0][-foo][+bar]`) не соответствуют SemVer-спецификации"
+          # "Поля prerelease и/или buildmetadata (подстрока `-foo+bar` в составе `0.0.0[.0][-foo][+bar]`) не соответствуют SemVer-спецификации"
+          "The prerelease and/or buildmetadata fields (substring `-foo+bar` as part of `0.0.0[.0][-foo][+bar]`) do not comply with the SemVer specification"
       )
     endif()
   else()
-    set(_semver_err "Версионная отметка в целом не соответствует шаблону `0.0.0[.0][-foo][+bar]` SemVer-спецификации")
+    set(_semver_err
+      # "Версионная отметка в целом не соответствует шаблону `0.0.0[.0][-foo][+bar]` SemVer-спецификации"
+      "The version mark as a whole does not match the pattern `0.0.0[.0][-foo][+bar]` of the SemVer specification"
+    )
   endif()
 endmacro(semver_parse)
 
@@ -215,138 +219,6 @@ function(semver_parse_selfcheck)
     FALSE)
 endfunction()
 
-macro(git_get_versioninfo source_root_directory)
-  set(_git_describe "")
-  set(_git_timestamp "")
-  set(_git_tree "")
-  set(_git_commit "")
-  set(_git_last_vtag "")
-  set(_git_trailing_commits 0)
-  set(_git_is_dirty FALSE)
-
-  execute_process(
-    COMMAND ${GIT} show --no-patch --format=%cI HEAD
-    OUTPUT_VARIABLE _git_timestamp
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-    WORKING_DIRECTORY ${source_root_directory}
-    RESULT_VARIABLE _rc)
-  if(_rc OR "${_git_timestamp}" STREQUAL "%cI")
-    execute_process(
-      COMMAND ${GIT} show --no-patch --format=%ci HEAD
-      OUTPUT_VARIABLE _git_timestamp
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-      WORKING_DIRECTORY ${source_root_directory}
-      RESULT_VARIABLE _rc)
-    if(_rc OR "${_git_timestamp}" STREQUAL "%ci")
-      message(FATAL_ERROR "Please install latest version of git (`show --no-patch --format=%cI HEAD` failed)")
-    endif()
-  endif()
-
-  execute_process(
-    COMMAND ${GIT} show --no-patch --format=%T HEAD
-    OUTPUT_VARIABLE _git_tree
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-    WORKING_DIRECTORY ${source_root_directory}
-    RESULT_VARIABLE _rc)
-  if(_rc OR "${_git_tree}" STREQUAL "")
-    message(FATAL_ERROR "Please install latest version of git (`show --no-patch --format=%T HEAD` failed)")
-  endif()
-
-  execute_process(
-    COMMAND ${GIT} show --no-patch --format=%H HEAD
-    OUTPUT_VARIABLE _git_commit
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-    WORKING_DIRECTORY ${source_root_directory}
-    RESULT_VARIABLE _rc)
-  if(_rc OR "${_git_commit}" STREQUAL "")
-    message(FATAL_ERROR "Please install latest version of git (`show --no-patch --format=%H HEAD` failed)")
-  endif()
-
-  execute_process(
-    COMMAND ${GIT} status --untracked-files=no --porcelain
-    OUTPUT_VARIABLE _git_status
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-    WORKING_DIRECTORY ${source_root_directory}
-    RESULT_VARIABLE _rc)
-  if(_rc)
-    message(FATAL_ERROR "Please install latest version of git (`status --untracked-files=no --porcelain` failed)")
-  endif()
-  if(NOT "${_git_status}" STREQUAL "")
-    set(_git_commit "DIRTY-${_git_commit}")
-    set(_git_is_dirty TRUE)
-  endif()
-  unset(_git_status)
-
-  execute_process(
-    COMMAND ${GIT} describe --tags --abbrev=0 "--match=v[0-9]*"
-    OUTPUT_VARIABLE _git_last_vtag
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-    WORKING_DIRECTORY ${source_root_directory}
-    RESULT_VARIABLE _rc)
-  if(_rc OR "${_git_last_vtag}" STREQUAL "")
-    execute_process(
-      COMMAND ${GIT} tag
-      OUTPUT_VARIABLE _git_tags_dump
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-      WORKING_DIRECTORY ${source_root_directory}
-      RESULT_VARIABLE _rc)
-    execute_process(
-      COMMAND ${GIT} rev-list --count --no-merges --remove-empty HEAD
-      OUTPUT_VARIABLE _git_whole_count
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-      WORKING_DIRECTORY ${source_root_directory}
-      RESULT_VARIABLE _rc)
-    if(_rc)
-      message(
-        FATAL_ERROR
-          "Please install latest version of git (`git rev-list --count --no-merges --remove-empty HEAD` failed)")
-    endif()
-    if(_git_whole_count GREATER 42 AND "${_git_tags_dump}" STREQUAL "")
-      message(FATAL_ERROR "Please fetch tags (`describe --tags --abbrev=0 --match=v[0-9]*` failed)")
-    else()
-      message(NOTICE "Falling back to version `0.0.0` (have you made an initial release?")
-    endif()
-    set(_git_last_vtag "0.0.0")
-    set(_git_trailing_commits ${_git_whole_count})
-    execute_process(
-      COMMAND ${GIT} describe --tags --dirty --long --always
-      OUTPUT_VARIABLE _git_describe
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-      WORKING_DIRECTORY ${source_root_directory}
-      RESULT_VARIABLE _rc)
-    if(_rc OR "${_git_describe}" STREQUAL "")
-      execute_process(
-        COMMAND ${GIT} describe --tags --all --dirty --long --always
-        OUTPUT_VARIABLE _git_describe
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-        WORKING_DIRECTORY ${source_root_directory}
-        RESULT_VARIABLE _rc)
-      if(_rc OR "${_git_describe}" STREQUAL "")
-        message(FATAL_ERROR "Please install latest version of git (`describe --tags --all --long` failed)")
-      endif()
-    endif()
-  else()
-    execute_process(
-      COMMAND ${GIT} describe --tags --dirty --long "--match=v[0-9]*"
-      OUTPUT_VARIABLE _git_describe
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-      WORKING_DIRECTORY ${source_root_directory}
-      RESULT_VARIABLE _rc)
-    if(_rc OR "${_git_describe}" STREQUAL "")
-      message(FATAL_ERROR "Please install latest version of git (`describe --tags --long --match=v[0-9]*`)")
-    endif()
-    execute_process(
-      COMMAND ${GIT} rev-list --count "${_git_last_vtag}..HEAD"
-      OUTPUT_VARIABLE _git_trailing_commits
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-      WORKING_DIRECTORY ${source_root_directory}
-      RESULT_VARIABLE _rc)
-    if(_rc OR "${_git_trailing_commits}" STREQUAL "")
-      message(FATAL_ERROR "Please install latest version of git (`rev-list --count ${_git_last_vtag}..HEAD` failed)")
-    endif()
-  endif()
-endmacro(git_get_versioninfo)
-
 macro(semver_provide name source_root_directory build_directory_for_json_output build_metadata parent_scope)
   set(_semver "")
   set(_git_describe "")
@@ -354,43 +226,15 @@ macro(semver_provide name source_root_directory build_directory_for_json_output
   set(_git_tree "")
   set(_git_commit "")
   set(_version_from "")
-  set(_git_root FALSE)
-
-  find_program(GIT git)
-  if(GIT)
-    execute_process(
-      COMMAND ${GIT} rev-parse --show-toplevel
-      OUTPUT_VARIABLE _git_root
-      ERROR_VARIABLE _git_root_error
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-      WORKING_DIRECTORY ${source_root_directory}
-      RESULT_VARIABLE _rc)
-    if(_rc OR "${_git_root}" STREQUAL "")
-      if(EXISTS "${source_root_directory}/.git")
-        message(ERROR "`git rev-parse --show-toplevel` failed '${_git_root_error}'")
-      else()
-        message(VERBOSE "`git rev-parse --show-toplevel` failed '${_git_root_error}'")
-      endif()
-    else()
-      set(_source_root "${source_root_directory}")
-      if(NOT CMAKE_VERSION VERSION_LESS 3.19)
-        file(REAL_PATH "${_git_root}" _git_root)
-        file(REAL_PATH "${_source_root}" _source_root)
-      endif()
-      if(_source_root STREQUAL _git_root AND EXISTS "${_git_root}/VERSION.json")
-        message(
-          FATAL_ERROR
-            "Несколько источников информации о версии, допустим только один из: репозиторий git, либо файл VERSION.json"
-        )
-      endif()
-    endif()
-  endif()
 
   if(EXISTS "${source_root_directory}/VERSION.json")
     set(_version_from "${source_root_directory}/VERSION.json")
 
     if(CMAKE_VERSION VERSION_LESS 3.19)
-      message(FATAL_ERROR "Требуется CMake версии >= 3.19 для чтения VERSION.json")
+      message(FATAL_ERROR
+        # "Требуется CMake версии >= 3.19 для чтения VERSION.json"
+        "Requires CMake version >= 3.19 to parse VERSION.json"
+      )
     endif()
     file(
       STRINGS "${_version_from}" _versioninfo_json NEWLINE_CONSUME
@@ -410,24 +254,11 @@ macro(semver_provide name source_root_directory build_directory_for_json_output
     if(NOT _semver_ok)
       message(FATAL_ERROR "SemVer `${_semver}` from ${_version_from}: ${_semver_err}")
     endif()
-  elseif(_git_root AND _source_root STREQUAL _git_root)
-    set(_version_from git)
-    git_get_versioninfo(${source_root_directory})
-    semver_parse(${_git_last_vtag})
-    if(NOT _semver_ok)
-      message(FATAL_ERROR "Git tag `${_git_last_vtag}`: ${_semver_err}")
-    endif()
-    if(_git_trailing_commits GREATER 0 AND "${_semver_tweak}" STREQUAL "")
-      set(_semver_tweak ${_git_trailing_commits})
-    endif()
-
-  elseif(GIT)
-    message(
-      FATAL_ERROR
-        "Нет источника информации о версии (${source_root_directory}), требуется один из: репозиторий git, либо VERSION.json"
-    )
   else()
-    message(FATAL_ERROR "Требуется git для получения информации о версии")
+    message(FATAL_ERROR
+      # "Отсутствует `VERSION.json` с информацией о версии"
+      "The `VERSION.json` with version information is missing"
+    )
   endif()
 
   if(NOT _git_describe
@@ -506,19 +337,6 @@ macro(semver_provide name source_root_directory build_directory_for_json_output
         PARENT_SCOPE)
   endif()
 
-  if(_version_from STREQUAL "git")
-    string(
-      CONFIGURE
-        "{
-      \"git_describe\" : \"@_git_describe@\",
-      \"git_timestamp\" : \"@_git_timestamp@\",
-      \"git_tree\" : \"@_git_tree@\",
-      \"git_commit\" : \"@_git_commit@\",
-      \"semver\" : \"@_semver@\"\n}"
-        _versioninfo_json
-      @ONLY ESCAPE_QUOTES)
-    file(WRITE "${build_directory_for_json_output}/VERSION.json" "${_versioninfo_json}")
-  endif()
 endmacro(semver_provide)
 
 cmake_policy(POP)
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/config.h.in b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/config.h.in
index 5d53860cfc2..8af2e1818ca 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/config.h.in
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/config.h.in
@@ -11,8 +11,10 @@
 #cmakedefine ENABLE_ASAN
 #cmakedefine ENABLE_UBSAN
 #cmakedefine01 MDBX_FORCE_ASSERTIONS
+
+/* allowing override MDBX_BUILD_CXX=OFF to build the C++ API in "private" mode only for tests */
 #if !defined(MDBX_BUILD_TEST) && !defined(MDBX_BUILD_CXX)
-#cmakedefine01 MDBX_BUILD_CXX
+#cmakedefine01 MDBX_BUILD_CXX /* using MDBX_BUILD_CXX CMake's option */
 #endif
 
 /* Common */
@@ -39,10 +41,11 @@
 #cmakedefine01 MDBX_ENABLE_DBI_LOCKFREE
 
 /* Windows */
+/* allowing override MDBX_WITHOUT_MSVC_CRT=ON to build the C++ API in "private" mode only for tests */
 #if defined(MDBX_BUILD_TEST) || !defined(MDBX_BUILD_CXX) || MDBX_BUILD_CXX
-#define MDBX_WITHOUT_MSVC_CRT 0
+#define MDBX_WITHOUT_MSVC_CRT /* hardcoded zero */ 0
 #else
-#cmakedefine01 MDBX_WITHOUT_MSVC_CRT
+#cmakedefine01 MDBX_WITHOUT_MSVC_CRT /* using MDBX_WITHOUT_MSVC_CRT CMake's option */
 #endif /* MDBX_WITHOUT_MSVC_CRT */
 
 /* MacOS & iOS */
@@ -63,6 +66,11 @@
 
 #cmakedefine01 MDBX_USE_MINCORE
 
+#cmakedefine MDBX_USE_FALLOCATE_AUTO
+#ifndef MDBX_USE_FALLOCATE_AUTO
+#cmakedefine01 MDBX_USE_FALLOCATE
+#endif /* MDBX_USE_FALLOCATE */
+
 /* Build Info */
 #ifndef MDBX_BUILD_TIMESTAMP
 #cmakedefine MDBX_BUILD_TIMESTAMP "@MDBX_BUILD_TIMESTAMP@"
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_chk.1 b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_chk.1
index bc6de4b7758..80a4547d134 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_chk.1
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_chk.1
@@ -1,4 +1,4 @@
-.\" Copyright 2015-2025 Leonid Yuriev <leo@yuriev.ru>.
+.\" Copyright 2015-2026 Leonid Yuriev <leo@yuriev.ru>.
 .\" Copying restrictions apply.  See COPYRIGHT/LICENSE.
 .TH MDBX_CHK 1 "2024-08-29" "MDBX 0.13"
 .SH NAME
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_copy.1 b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_copy.1
index 83ec8553bd4..b0a969d11d6 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_copy.1
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_copy.1
@@ -1,4 +1,4 @@
-.\" Copyright 2015-2025 Leonid Yuriev <leo@yuriev.ru>.
+.\" Copyright 2015-2026 Leonid Yuriev <leo@yuriev.ru>.
 .\" Copyright 2015,2016 Peter-Service R&D LLC <http://billing.ru/>.
 .\" Copyright 2012-2015 Howard Chu, Symas Corp. All Rights Reserved.
 .\" Copying restrictions apply.  See COPYRIGHT/LICENSE.
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_drop.1 b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_drop.1
index a6abbe4198d..11b2c7e404b 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_drop.1
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_drop.1
@@ -1,4 +1,4 @@
-.\" Copyright 2021-2025 Leonid Yuriev <leo@yuriev.ru>.
+.\" Copyright 2021-2026 Leonid Yuriev <leo@yuriev.ru>.
 .\" Copyright 2014-2021 Howard Chu, Symas Corp. All Rights Reserved.
 .\" Copying restrictions apply.  See COPYRIGHT/LICENSE.
 .TH MDBX_DROP 1 "2024-08-29" "MDBX 0.13"
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_dump.1 b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_dump.1
index 030617c3478..70f324027b4 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_dump.1
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_dump.1
@@ -1,4 +1,4 @@
-.\" Copyright 2015-2025 Leonid Yuriev <leo@yuriev.ru>.
+.\" Copyright 2015-2026 Leonid Yuriev <leo@yuriev.ru>.
 .\" Copyright 2015,2016 Peter-Service R&D LLC <http://billing.ru/>.
 .\" Copyright 2014-2015 Howard Chu, Symas Corp. All Rights Reserved.
 .\" Copying restrictions apply.  See COPYRIGHT/LICENSE.
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_load.1 b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_load.1
index 27b533e398a..f8f7b10b623 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_load.1
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_load.1
@@ -1,4 +1,4 @@
-.\" Copyright 2015-2025 Leonid Yuriev <leo@yuriev.ru>.
+.\" Copyright 2015-2026 Leonid Yuriev <leo@yuriev.ru>.
 .\" Copyright 2015,2016 Peter-Service R&D LLC <http://billing.ru/>.
 .\" Copyright 2014-2015 Howard Chu, Symas Corp. All Rights Reserved.
 .\" Copying restrictions apply.  See COPYRIGHT/LICENSE.
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_stat.1 b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_stat.1
index 68a698c1cb2..36bc26d3956 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_stat.1
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1/mdbx_stat.1
@@ -1,4 +1,4 @@
-.\" Copyright 2015-2025 Leonid Yuriev <leo@yuriev.ru>.
+.\" Copyright 2015-2026 Leonid Yuriev <leo@yuriev.ru>.
 .\" Copyright 2015,2016 Peter-Service R&D LLC <http://billing.ru/>.
 .\" Copyright 2012-2015 Howard Chu, Symas Corp. All Rights Reserved.
 .\" Copying restrictions apply.  See COPYRIGHT/LICENSE.
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.c b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.c
index ae5de1be4c9..01b663ba430 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.c
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.c
@@ -1,10 +1,10 @@
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 /* clang-format off */
 
 #define xMDBX_ALLOY 1  /* alloyed build */
 
-#define MDBX_BUILD_SOURCERY 6b5df6869d2bf5419e3a8189d9cc849cc9911b9c8a951b9750ed0a261ce43724_v0_13_7_0_g566b0f93
+#define MDBX_BUILD_SOURCERY a575a490fc080ca11e89ff6db9f0bd38aa830959905998cac0e45274b9e6bb0e_v0_13_12_0_gf619d43d
 
 #define LIBMDBX_INTERNALS
 #define MDBX_DEPRECATED
@@ -1173,6 +1173,14 @@ typedef char pathchar_t;
 #define MDBX_PRIsPATH "s"
 #endif
 
+MDBX_MAYBE_UNUSED static inline bool osal_yield(void) {
+#if defined(_WIN32) || defined(_WIN64)
+  return SleepEx(0, true) == WAIT_IO_COMPLETION;
+#else
+  return sched_yield() != 0;
+#endif
+}
+
 typedef struct osal_mmap {
   union {
     void *base;
@@ -1192,6 +1200,8 @@ typedef struct osal_mmap {
 
 #define MDBX_HAVE_PWRITEV 0
 
+MDBX_INTERNAL int osal_waitstatus2errcode(DWORD result);
+
 #elif defined(__ANDROID_API__)
 
 #if __ANDROID_API__ < 24
@@ -1435,7 +1445,7 @@ enum osal_syncmode_bits {
 };
 
 MDBX_INTERNAL int osal_fsync(mdbx_filehandle_t fd, const enum osal_syncmode_bits mode_bits);
-MDBX_INTERNAL int osal_ftruncate(mdbx_filehandle_t fd, uint64_t length);
+MDBX_INTERNAL int osal_fsetsize(mdbx_filehandle_t fd, const uint64_t length);
 MDBX_INTERNAL int osal_fseek(mdbx_filehandle_t fd, uint64_t pos);
 MDBX_INTERNAL int osal_filesize(mdbx_filehandle_t fd, uint64_t *length);
 
@@ -1471,11 +1481,11 @@ MDBX_INTERNAL int osal_removedirectory(const pathchar_t *pathname);
 MDBX_INTERNAL int osal_is_pipe(mdbx_filehandle_t fd);
 MDBX_INTERNAL int osal_lockfile(mdbx_filehandle_t fd, bool wait);
 
-#define MMAP_OPTION_TRUNCATE 1
+#define MMAP_OPTION_SETLENGTH 1
 #define MMAP_OPTION_SEMAPHORE 2
 MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, const size_t limit, const unsigned options,
                             const pathchar_t *pathname4logging);
-MDBX_INTERNAL int osal_munmap(osal_mmap_t *map);
+MDBX_INTERNAL void osal_munmap(osal_mmap_t *map);
 #define MDBX_MRESIZE_MAY_MOVE 0x00000100
 #define MDBX_MRESIZE_MAY_UNMAP 0x00000200
 MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, size_t limit);
@@ -1878,7 +1888,8 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
     ((defined(_POSIX_THREAD_ROBUST_PRIO_INHERIT) && _POSIX_THREAD_ROBUST_PRIO_INHERIT > 0) ||                          \
      (defined(_POSIX_THREAD_ROBUST_PRIO_PROTECT) && _POSIX_THREAD_ROBUST_PRIO_PROTECT > 0) ||                          \
      defined(PTHREAD_MUTEX_ROBUST) || defined(PTHREAD_MUTEX_ROBUST_NP)) &&                                             \
-    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */)
+    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */) &&                   \
+    !defined(__OHOS__) /* Harmony OS doesn't support robust mutexes at the end of 2025 */
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2008
 #else
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2001
@@ -1933,6 +1944,22 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
 #error MDBX_USE_COPYFILERANGE must be defined as 0 or 1
 #endif /* MDBX_USE_COPYFILERANGE */
 
+/** Advanced: Using posix_fallocate() or fcntl(F_PREALLOCATE) on OSX (autodetection by default). */
+#ifndef MDBX_USE_FALLOCATE
+#if defined(__APPLE__)
+#define MDBX_USE_FALLOCATE 0 /* Too slow and unclean, but not required to prevent SIGBUS */
+#elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || (__GLIBC_PREREQ(2, 10) && defined(_GNU_SOURCE))
+#define MDBX_USE_FALLOCATE 1
+#else
+#define MDBX_USE_FALLOCATE 0
+#endif
+#define MDBX_USE_FALLOCATE_CONFIG "AUTO=" MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#elif !(MDBX_USE_FALLOCATE == 0 || MDBX_USE_FALLOCATE == 1)
+#error MDBX_USE_FALLOCATE must be defined as 0 or 1
+#else
+#define MDBX_USE_FALLOCATE_CONFIG MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#endif /* MDBX_USE_FALLOCATE */
+
 //------------------------------------------------------------------------------
 
 #ifndef MDBX_CPU_WRITEBACK_INCOHERENT
@@ -3361,8 +3388,7 @@ MDBX_MAYBE_UNUSED static
 #if MDBX_64BIT_ATOMIC
     __always_inline
 #endif /* MDBX_64BIT_ATOMIC */
-        uint64_t
-        atomic_load64(const volatile mdbx_atomic_uint64_t *p, enum mdbx_memory_order order) {
+        uint64_t atomic_load64(const volatile mdbx_atomic_uint64_t *p, enum mdbx_memory_order order) {
   STATIC_ASSERT(sizeof(mdbx_atomic_uint64_t) == 8);
 #if MDBX_64BIT_ATOMIC
 #ifdef MDBX_HAVE_C11ATOMICS
@@ -3417,10 +3443,8 @@ MDBX_MAYBE_UNUSED static __always_inline void atomic_yield(void) {
 #elif defined(__mips) || defined(__mips__) || defined(__mips64) || defined(__mips64__) || defined(_M_MRX000) ||        \
     defined(_MIPS_) || defined(__MWERKS__) || defined(__sgi)
   __asm__ __volatile__(".word 0x00000140");
-#elif defined(__linux__) || defined(__gnu_linux__) || defined(_UNIX03_SOURCE)
-  sched_yield();
-#elif (defined(_GNU_SOURCE) && __GLIBC_PREREQ(2, 1)) || defined(_OPEN_THREADS)
-  pthread_yield();
+#else
+  osal_yield();
 #endif
 }
 
@@ -3601,8 +3625,7 @@ MDBX_MAYBE_UNUSED static
 #if MDBX_64BIT_ATOMIC
     __always_inline
 #endif /* MDBX_64BIT_ATOMIC */
-    void
-    safe64_inc(mdbx_atomic_uint64_t *p, const uint64_t v) {
+    void safe64_inc(mdbx_atomic_uint64_t *p, const uint64_t v) {
   assert(v > 0);
   safe64_update(p, safe64_read(p) + v);
 }
@@ -3611,6 +3634,9 @@ MDBX_MAYBE_UNUSED static
 
 /* Internal prototypes */
 
+MDBX_INTERNAL int MDBX_PRINTF_ARGS(2, 3) bad_page(const page_t *mp, const char *fmt, ...);
+MDBX_INTERNAL void MDBX_PRINTF_ARGS(2, 3) poor_page(const page_t *mp, const char *fmt, ...);
+
 /* audit.c */
 MDBX_INTERNAL int audit_ex(MDBX_txn *txn, size_t retired_stored, bool dont_filter_gc);
 
@@ -4158,7 +4184,7 @@ enum txn_flags {
   txn_rw_begin_flags = MDBX_TXN_NOMETASYNC | MDBX_TXN_NOSYNC | MDBX_TXN_TRY,
   txn_shrink_allowed = UINT32_C(0x40000000),
   txn_parked = MDBX_TXN_PARKED,
-  txn_gc_drained = 0x40 /* GC was depleted up to oldest reader */,
+  txn_gc_drained = 0x100 /* GC was depleted up to oldest reader */,
   txn_state_flags = MDBX_TXN_FINISHED | MDBX_TXN_ERROR | MDBX_TXN_DIRTY | MDBX_TXN_SPILLS | MDBX_TXN_HAS_CHILD |
                     MDBX_TXN_INVALID | txn_gc_drained
 };
@@ -4635,8 +4661,35 @@ MDBX_INTERNAL int __must_check_result node_read_bigdata(MDBX_cursor *mc, const n
 static inline int __must_check_result node_read(MDBX_cursor *mc, const node_t *node, MDBX_val *data, const page_t *mp) {
   data->iov_len = node_ds(node);
   data->iov_base = node_data(node);
-  if (likely(node_flags(node) != N_BIG))
+  if (likely(node_flags(node) != N_BIG)) {
+#if 0
+    /* This is an example of a code that checks out-of-bounds by an incorrect/bad/crafted node.
+     * Such checks look useful, but they are unreasonable really:
+     *  - an each such check catches some damage case of the structure, apparently in one of the hot execution paths,
+     *    but LEAVES several dozen more aside;
+     *  - the overhead increases slightly,
+     *    but there is also NO CERTAINTY that all or most of the corruption cases will be solved;
+     *  - libmdbx already has a fairly complete page content validation mode by MDBX_VALIDATION, which leads
+     *    calling the page_check() for each page from all page_get_xxx() variants, excepts page_get_unchecked();
+     *  = So, the MDBX_VALIDATION must be used to work with untrusted data,
+     *    but such checks are not necessary for trusted data.
+     *
+     * Thus, libmdbx allows a user, if necessary, to enable control of the database structure at the cost of reduced
+     * performance. On the other hand, such approach allows not to lose productivity unnecessarily.
+     *
+     * Related issues:
+     *  - https://sourcecraft.dev/dqdkfa/libmdbx/issues/290
+     *  - https://github.com/Mithril-mine/libmdbx/pull/306
+     */
+    const char *data_end = ptr_disp(data->iov_base, data->iov_len);
+    const char *page_tail = (const char *)((intptr_t)mp | /* Using the OR operation to get the tail of a real page
+                                                             in case here is a dupsort nested sub-page even. */
+                                           (intptr_t)(mc->txn->env->ps - 1));
+    if (!MDBX_DISABLE_VALIDATION && unlikely(data_end > page_tail))
+      return bad_page(mp, "node-data (size %zu bytes) beyond the end of page", data->iov_len);
+#endif /* code example */
     return MDBX_SUCCESS;
+  }
   return node_read_bigdata(mc, node, data, mp);
 }
 
@@ -4661,7 +4714,7 @@ MDBX_NOTHROW_CONST_FUNCTION MDBX_MAYBE_UNUSED MDBX_INTERNAL size_t dbi_bitmap_ct
                                                                                            intptr_t bmi);
 
 static inline size_t dbi_bitmap_ctz(const MDBX_txn *txn, intptr_t bmi) {
-  tASSERT(txn, bmi > 0);
+  tASSERT(txn, bmi != 0);
   STATIC_ASSERT(sizeof(bmi) >= sizeof(txn->dbi_sparse[0]));
 #if __GNUC_PREREQ(4, 1) || __has_builtin(__builtin_ctzl)
   if (sizeof(txn->dbi_sparse[0]) <= sizeof(int))
@@ -5522,7 +5575,7 @@ enum cursor_checking {
 MDBX_INTERNAL int __must_check_result cursor_validate(const MDBX_cursor *mc);
 
 MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline size_t cursor_dbi(const MDBX_cursor *mc) {
-  cASSERT(mc, mc->txn && mc->txn->signature == txn_signature);
+  cASSERT(mc, mc->txn->signature == txn_signature);
   size_t dbi = mc->dbi_state - mc->txn->dbi_state;
   cASSERT(mc, dbi < mc->txn->env->n_dbi);
   return dbi;
@@ -5808,7 +5861,7 @@ typedef struct gc_update_context {
   unsigned loop;
   pgno_t prev_first_unallocated;
   bool dense;
-  size_t reserve_adj;
+  size_t reserve_adj, backlog_adj;
   size_t retired_stored;
   size_t amount, reserved, cleaned_slot, reused_slot, fill_idx;
   txnid_t cleaned_id, rid;
@@ -6143,10 +6196,6 @@ MDBX_INTERNAL int __must_check_result page_split(MDBX_cursor *mc, const MDBX_val
 
 /*----------------------------------------------------------------------------*/
 
-MDBX_INTERNAL int MDBX_PRINTF_ARGS(2, 3) bad_page(const page_t *mp, const char *fmt, ...);
-
-MDBX_INTERNAL void MDBX_PRINTF_ARGS(2, 3) poor_page(const page_t *mp, const char *fmt, ...);
-
 MDBX_NOTHROW_PURE_FUNCTION static inline bool is_frozen(const MDBX_txn *txn, const page_t *mp) {
   return mp->txnid < txn->txnid;
 }
@@ -6788,7 +6837,7 @@ MDBX_INTERNAL int walk_pages(MDBX_txn *txn, walk_func *visitor, void *user, walk
     return it;                                                                 \
   }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 __cold size_t mdbx_default_pagesize(void) {
   size_t pagesize = globals.sys_pagesize;
@@ -7331,7 +7380,7 @@ LIBMDBX_API __cold intptr_t mdbx_limits_pgsize_max(void) { return __inline_mdbx_
 /// \copyright SPDX-License-Identifier: Apache-2.0
 /// \note Please refer to the COPYRIGHT file for explanations license change,
 /// credits and acknowledgments.
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 typedef struct compacting_context {
   MDBX_env *env;
@@ -7807,7 +7856,7 @@ __cold static int copy_with_compacting(MDBX_env *env, MDBX_txn *txn, mdbx_fileha
   if (meta->geometry.now != meta->geometry.first_unallocated) {
     const size_t whole_size = pgno2bytes(env, meta->geometry.now);
     if (!dest_is_pipe)
-      return osal_ftruncate(fd, whole_size);
+      return osal_fsetsize(fd, whole_size);
 
     const size_t used_size = pgno2bytes(env, meta->geometry.first_unallocated);
     memset(data_buffer, 0, (size_t)MDBX_ENVCOPY_WRITEBUF);
@@ -7976,7 +8025,7 @@ __cold static int copy_asis(MDBX_env *env, MDBX_txn *txn, mdbx_filehandle_t fd,
   /* Extend file if required */
   if (likely(rc == MDBX_SUCCESS) && whole_size != used_size) {
     if (!dest_is_pipe)
-      rc = osal_ftruncate(fd, whole_size);
+      rc = osal_fsetsize(fd, whole_size);
     else {
       memset(data_buffer, 0, (size_t)MDBX_ENVCOPY_WRITEBUF);
       for (size_t offset = used_size; rc == MDBX_SUCCESS && offset < whole_size;) {
@@ -8239,7 +8288,7 @@ __cold int mdbx_env_copyW(MDBX_env *env, const wchar_t *dest_path, MDBX_copy_fla
   return LOG_IFERR(rc);
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 MDBX_cursor *mdbx_cursor_create(void *context) {
   cursor_couple_t *couple = osal_calloc(1, sizeof(cursor_couple_t));
@@ -8991,7 +9040,7 @@ __cold int mdbx_cursor_ignord(MDBX_cursor *mc) {
   return MDBX_SUCCESS;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 int mdbx_dbi_open2(MDBX_txn *txn, const MDBX_val *name, MDBX_db_flags_t flags, MDBX_dbi *dbi) {
   return LOG_IFERR(dbi_open(txn, name, flags, dbi, nullptr, nullptr));
@@ -9243,8 +9292,8 @@ __cold int mdbx_dbi_stat(const MDBX_txn *txn, MDBX_dbi dbi, MDBX_stat *dest, siz
   if (unlikely(bytes != sizeof(MDBX_stat)) && bytes != size_before_modtxnid)
     return LOG_IFERR(MDBX_EINVAL);
 
-  dest->ms_psize = txn->env->ps;
   stat_get(&txn->dbs[dbi], dest, bytes);
+  dest->ms_psize = txn->env->ps;
   return MDBX_SUCCESS;
 }
 
@@ -9293,6 +9342,7 @@ __cold int mdbx_enumerate_tables(const MDBX_txn *txn, MDBX_table_enum_func *func
 
     MDBX_stat stat;
     stat_get(tree, &stat, sizeof(stat));
+    stat.ms_psize = txn->env->ps;
     rc = func(ctx, txn, &name, tree->flags, &stat, dbi);
     if (rc != MDBX_SUCCESS)
       goto bailout;
@@ -9304,7 +9354,7 @@ __cold int mdbx_enumerate_tables(const MDBX_txn *txn, MDBX_table_enum_func *func
   return LOG_IFERR(rc);
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 __cold static intptr_t reasonable_db_maxsize(void) {
   static intptr_t cached_result;
@@ -9511,10 +9561,19 @@ __cold int mdbx_env_create(MDBX_env **penv) {
   }
 
 #if defined(__linux__) || defined(__gnu_linux__)
-  if (unlikely(globals.linux_kernel_version < 0x04000000)) {
-    /* 2022-09-01: Прошло уже более двух лет после окончания какой-либо
-     * поддержки самого "долгоиграющего" ядра 3.16.85 ветки 3.x */
-    ERROR("too old linux kernel %u.%u.%u.%u, the >= 4.0.0 is required", globals.linux_kernel_version >> 24,
+  if (unlikely(globals.linux_kernel_version < 0x03100000)) {
+    /* 2025-08-05: Ядро 3.16 выпущено 11 лет назад и было самым долго поддерживаемым из 3.x до июля 2020.
+     * Три года назад (в 2022) здесь была заблокирована работа на ядрах меньше 4.x, как устаревших и для которых
+     * крайне затруднительно обеспечить какое-либо тестирование. Теперь же я решил изменить решение и разрешить
+     * работу на старых ядрах начиная с 3.16, логика тут такая:
+     *  - поведение старых ядер уже точно не будет меняться,
+     *    а в текущем коде libmdbx есть всё необходимое для работы начиная с 3.16;
+     *  - есть широко-используемые проекты (Isar), которым требуется поддержка старых ядер;
+     *  - сейчас тестирование для 4.x также затруднено, как и для 3.16, уже не приносит какого-либо облегчения
+     *    с тестированием и мне приходится полагаться на гарантии совместимости API ядра и glibc/musl;
+     *  - использование возможностей из новых ядер всё равно требует проверок/ветвлений;
+     *  = поэтому сейчас нет причин отказываться от работы на 3.16 поддерживая ядра 4.0 */
+    ERROR("too old linux kernel %u.%u.%u.%u, the >= 3.16 is required", globals.linux_kernel_version >> 24,
           (globals.linux_kernel_version >> 16) & 255, (globals.linux_kernel_version >> 8) & 255,
           globals.linux_kernel_version & 255);
     return LOG_IFERR(MDBX_INCOMPATIBLE);
@@ -10322,14 +10381,13 @@ __cold int mdbx_env_set_geometry(MDBX_env *env, intptr_t size_lower, intptr_t si
     /* is requested some auto-value for pagesize ? */
     if (pagesize >= INT_MAX /* maximal */)
       pagesize = MDBX_MAX_PAGESIZE;
-    else if (pagesize <= 0) {
-      if (pagesize < 0 /* default */) {
-        pagesize = globals.sys_pagesize;
-        if ((uintptr_t)pagesize > MDBX_MAX_PAGESIZE)
-          pagesize = MDBX_MAX_PAGESIZE;
-        eASSERT(env, (uintptr_t)pagesize >= MDBX_MIN_PAGESIZE);
-      } else if (pagesize == 0 /* minimal */)
-        pagesize = MDBX_MIN_PAGESIZE;
+    else if (pagesize == 0 /* minimal */)
+      pagesize = MDBX_MIN_PAGESIZE;
+    else if (pagesize < 0 /* default */) {
+      pagesize = globals.sys_pagesize;
+      if ((uintptr_t)pagesize > MDBX_MAX_PAGESIZE)
+        pagesize = MDBX_MAX_PAGESIZE;
+      eASSERT(env, (uintptr_t)pagesize >= MDBX_MIN_PAGESIZE);
 
       /* choose pagesize */
       intptr_t top = (size_now > size_lower) ? size_now : size_lower;
@@ -10736,7 +10794,7 @@ __cold int mdbx_env_stat_ex(const MDBX_env *env, const MDBX_txn *txn, MDBX_stat
   return LOG_IFERR(rc);
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 /*------------------------------------------------------------------------------
  * Readers API */
@@ -10899,7 +10957,7 @@ int mdbx_txn_unlock(MDBX_env *env) {
   return MDBX_SUCCESS;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 static inline double key2double(const int64_t key) {
   union {
@@ -11094,7 +11152,7 @@ int64_t mdbx_int64_from_key(const MDBX_val v) {
   return (int64_t)(unaligned_peek_u64(2, v.iov_base) - UINT64_C(0x8000000000000000));
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 __cold int mdbx_is_readahead_reasonable(size_t volume, intptr_t redundancy) {
   if (volume <= 1024 * 1024 * 4ul)
@@ -11231,7 +11289,7 @@ __cold const char *mdbx_liberr2str(int errnum) {
       nullptr /* MDBX_TLS_FULL (-30789): unused in MDBX */,
       "MDBX_TXN_FULL: Transaction has too many dirty pages,"
       " i.e transaction is too big",
-      "MDBX_CURSOR_FULL: Cursor stack limit reachedn - this usually indicates"
+      "MDBX_CURSOR_FULL: Cursor stack limit reached - this usually indicates"
       " corruption, i.e branch-pages loop",
       "MDBX_PAGE_FULL: Internal error - Page has no more space",
       "MDBX_UNABLE_EXTEND_MAPSIZE: Database engine was unable to extend"
@@ -11378,7 +11436,7 @@ const char *mdbx_strerror_ANSI2OEM(int errnum) {
 }
 #endif /* Bit of madness for Windows */
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 static pgno_t env_max_pgno(const MDBX_env *env) {
   return env->ps ? bytes2pgno(env, env->geo_in_bytes.upper ? env->geo_in_bytes.upper : MAX_MAPSIZE) : PAGELIST_LIMIT;
@@ -11951,7 +12009,7 @@ __cold int mdbx_env_get_option(const MDBX_env *env, const MDBX_option_t option,
   return MDBX_SUCCESS;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 typedef struct diff_result {
   ptrdiff_t diff;
@@ -12314,7 +12372,7 @@ __hot int mdbx_estimate_range(const MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val
   return MDBX_SUCCESS;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 __cold int mdbx_dbi_dupsort_depthmask(const MDBX_txn *txn, MDBX_dbi dbi, uint32_t *mask) {
   if (unlikely(!mask))
@@ -12766,14 +12824,13 @@ int mdbx_replace(MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *key, MDBX_val *new
   return mdbx_replace_ex(txn, dbi, key, new_data, old_data, flags, default_value_preserver, nullptr);
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 #ifdef __SANITIZE_THREAD__
 /* LY: avoid tsan-trap by txn, mm_last_pg and geo.first_unallocated */
 __attribute__((__no_sanitize_thread__, __noinline__))
 #endif
-int mdbx_txn_straggler(const MDBX_txn *txn, int *percent)
-{
+int mdbx_txn_straggler(const MDBX_txn *txn, int *percent) {
   int rc = check_txn(txn, MDBX_TXN_BLOCKED - MDBX_TXN_PARKED);
   if (unlikely(rc != MDBX_SUCCESS))
     return LOG_IFERR((rc > 0) ? -rc : rc);
@@ -13252,8 +13309,8 @@ int mdbx_txn_commit_ex(MDBX_txn *txn, MDBX_commit_latency *latency) {
       goto done;
     }
 
-    /* Preserve space for spill list to avoid parent's state corruption
-     * if allocation fails. */
+    /* Preserve space for parent->tw.repnl and spill list to avoid parent's
+     * state corruption if allocation fails. */
     const size_t parent_retired_len = (uintptr_t)parent->tw.retired_pages;
     tASSERT(txn, parent_retired_len <= MDBX_PNL_GETSIZE(txn->tw.retired_pages));
     const size_t retired_delta = MDBX_PNL_GETSIZE(txn->tw.retired_pages) - parent_retired_len;
@@ -13685,7 +13742,7 @@ int mdbx_txn_info(const MDBX_txn *txn, MDBX_txn_info *info, bool scan_rlt) {
   return MDBX_SUCCESS;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 struct audit_ctx {
   size_t used;
@@ -13792,7 +13849,7 @@ __cold int audit_ex(MDBX_txn *txn, size_t retired_stored, bool dont_filter_gc) {
   return rc;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 typedef struct MDBX_chk_internal {
   MDBX_chk_context_t *usr;
@@ -13804,11 +13861,11 @@ typedef struct MDBX_chk_internal {
   bool got_break;
   bool write_locked;
   uint8_t scope_depth;
+  pgno_t last_nested_root;
 
   MDBX_chk_table_t table_gc, table_main;
   int16_t *pagemap;
   MDBX_chk_table_t *last_lookup;
-  const void *last_nested;
   MDBX_chk_scope_t scope_stack[12];
   MDBX_chk_table_t *table[MDBX_MAX_DBI + CORE_DBS];
 
@@ -14297,9 +14354,9 @@ static void histogram_reduce(struct MDBX_chk_histogram *p) {
   p->ranges[min_i].end = p->ranges[min_i + 1].end;
   p->ranges[min_i].amount += p->ranges[min_i + 1].amount;
   p->ranges[min_i].count += p->ranges[min_i + 1].count;
-  if (min_i < last)
+  if (min_i < last - 1)
     // перемещаем хвост
-    memmove(p->ranges + min_i, p->ranges + min_i + 1, (last - min_i) * sizeof(p->ranges[0]));
+    memmove(p->ranges + min_i + 1, p->ranges + min_i + 2, (last - min_i - 1) * sizeof(p->ranges[0]));
   // обнуляем последний элемент и продолжаем
   p->ranges[last].count = 0;
 }
@@ -14496,8 +14553,7 @@ __cold static int chk_pgvisitor(const size_t pgno, const unsigned npages, void *
                        chk_v2a(chk, &tbl->name), tbl->flags, deep);
       nested = nullptr;
     }
-  } else
-    chk->last_nested = nullptr;
+  }
 
   const char *pagetype_caption;
   bool branch = false;
@@ -14550,9 +14606,9 @@ __cold static int chk_pgvisitor(const size_t pgno, const unsigned npages, void *
     } else {
       pagetype_caption = (pagetype == page_leaf) ? "nested-leaf" : "nested-leaf-dupfix";
       tbl->pages.nested_leaf += 1;
-      if (chk->last_nested != nested) {
+      if (chk->last_nested_root != nested->root) {
         histogram_acc(height, &tbl->histogram.nested_tree);
-        chk->last_nested = nested;
+        chk->last_nested_root = nested->root;
       }
       if (height != nested->height)
         chk_object_issue(scope, "page", pgno, "wrong nested-tree height", "actual %i != %i dupsort-node %s", height,
@@ -15586,7 +15642,7 @@ __cold int mdbx_env_chk(MDBX_env *env, const struct MDBX_chk_callbacks *cb, MDBX
   return LOG_IFERR(rc);
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 /*------------------------------------------------------------------------------
  * Pack/Unpack 16-bit values for Grow step & Shrink threshold */
@@ -15893,7 +15949,7 @@ uint32_t combine_durability_flags(const uint32_t a, const uint32_t b) {
   return r;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 /* check against https://libmdbx.dqdkfa.ru/dead-github/issues/269 */
 static bool coherency_check(const MDBX_env *env, const txnid_t txnid, const volatile tree_t *trees,
@@ -15995,15 +16051,7 @@ __cold int coherency_timeout(uint64_t *timestamp, intptr_t pgno, const MDBX_env
   }
 
   osal_memory_fence(mo_AcquireRelease, true);
-#if defined(_WIN32) || defined(_WIN64)
-  SwitchToThread();
-#elif defined(__linux__) || defined(__gnu_linux__) || defined(_UNIX03_SOURCE)
-  sched_yield();
-#elif (defined(_GNU_SOURCE) && __GLIBC_PREREQ(2, 1)) || defined(_OPEN_THREADS)
-  pthread_yield();
-#else
-  usleep(42);
-#endif
+  osal_yield();
   return MDBX_RESULT_TRUE;
 }
 
@@ -16063,7 +16111,7 @@ bool coherency_check_meta(const MDBX_env *env, const volatile meta_t *meta, bool
 /// \copyright SPDX-License-Identifier: Apache-2.0
 /// \note Please refer to the COPYRIGHT file for explanations license change,
 /// credits and acknowledgments.
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 __cold int cursor_validate(const MDBX_cursor *mc) {
   if (!mc->txn->tw.dirtylist) {
@@ -16282,7 +16330,7 @@ MDBX_cursor *cursor_eot(MDBX_cursor *mc, MDBX_txn *txn, const bool merge) {
   MDBX_cursor *const next = mc->next;
   const unsigned stage = mc->signature;
   MDBX_cursor *const bk = mc->backup;
-  ENSURE(txn->env, stage == cur_signature_live || (stage == cur_signature_wait4eot && bk));
+  ENSURE(txn->env, stage == cur_signature_live || stage == cur_signature_wait4eot);
   tASSERT(txn, mc->txn == txn);
   if (bk) {
     subcur_t *mx = mc->subcur;
@@ -16313,10 +16361,13 @@ MDBX_cursor *cursor_eot(MDBX_cursor *mc, MDBX_txn *txn, const bool merge) {
     bk->signature = 0;
     osal_free(bk);
   } else {
-    ENSURE(mc->txn->env, stage == cur_signature_live);
-    mc->signature = cur_signature_ready4dispose /* Cursor may be reused */;
-    mc->next = mc;
     cursor_drown((cursor_couple_t *)mc);
+    mc->next = mc;
+    if (stage == cur_signature_wait4eot) {
+      mc->signature = 0;
+      osal_free(mc);
+    } else
+      mc->signature = cur_signature_ready4dispose /* Cursor may be reused */;
   }
   return next;
 }
@@ -16863,7 +16914,7 @@ __hot int cursor_put(MDBX_cursor *mc, const MDBX_val *key, MDBX_val *data, unsig
       }
     } else {
       csr_t csr =
-          /* olddata may not be updated in case DUPFIX-page of dupfix-table */
+          /* old_data may not be updated in case DUPFIX-page of dupfix-table */
           cursor_seek(mc, (MDBX_val *)key, &old_data, MDBX_SET);
       rc = csr.err;
       exact = csr.exact;
@@ -16876,12 +16927,9 @@ __hot int cursor_put(MDBX_cursor *mc, const MDBX_val *key, MDBX_val *data, unsig
           return MDBX_KEYEXIST;
         }
         if (unlikely(mc->flags & z_inner)) {
-          /* nested subtree of DUPSORT-database with the same key,
-           * nothing to update */
-          eASSERT(env, data->iov_len == 0 && (old_data.iov_len == 0 ||
-                                              /* olddata may not be updated in case
-                                                 DUPFIX-page of dupfix-table */
-                                              (mc->tree->flags & MDBX_DUPFIXED)));
+          /* nested subtree of DUPSORT-database with the same key, nothing to update */
+          eASSERT(env, data->iov_len == 0 && (/* old_data may not be updated in case DUPFIX-page of dupfix-table */
+                                              (mc->tree->flags & MDBX_DUPFIXED) || old_data.iov_len == 0));
           return MDBX_SUCCESS;
         }
         if (unlikely(flags & MDBX_ALLDUPS) && inner_pointed(mc)) {
@@ -17433,8 +17481,7 @@ insert_node:;
           if (!is_related(mc, m2) || m2->pg[mc->top] != mp)
             continue;
           if (/* пропускаем незаполненные курсоры, иначе получится что у такого
-                 курсора будет инициализирован вложенный,
-                 что антилогично и бесполезно. */
+                 курсора будет инициализирован вложенный, что антилогично и бесполезно. */
               is_filled(m2) && m2->ki[mc->top] == mc->ki[mc->top]) {
             cASSERT(m2, m2->subcur->cursor.clc == mx->cursor.clc);
             m2->subcur->nested_tree = mx->nested_tree;
@@ -17605,7 +17652,7 @@ __hot int cursor_del(MDBX_cursor *mc, unsigned flags) {
       /* will subtract the final entry later */
       mc->tree->items -= mc->subcur->nested_tree.items - 1;
     } else {
-      if (!(node_flags(node) & N_TREE)) {
+      if ((node_flags(node) & N_TREE) == 0) {
         page_t *sp = node_data(node);
         cASSERT(mc, is_subpage(sp));
         sp->txnid = mp->txnid;
@@ -17620,6 +17667,11 @@ __hot int cursor_del(MDBX_cursor *mc, unsigned flags) {
           /* update table info */
           mc->subcur->nested_tree.mod_txnid = mc->txn->txnid;
           memcpy(node_data(node), &mc->subcur->nested_tree, sizeof(tree_t));
+          /* fix other sub-DB cursors pointed at the same sub-tree */
+          for (MDBX_cursor *m2 = mc->txn->cursors[cursor_dbi(mc)]; m2; m2 = m2->next) {
+            if (is_related(mc, m2) && m2->pg[mc->top] == mp && m2->ki[mc->top] == mc->ki[mc->top])
+              m2->subcur->nested_tree = mc->subcur->nested_tree;
+          }
         } else {
           /* shrink sub-page */
           node = node_shrink(mp, mc->ki[mc->top], node);
@@ -17630,16 +17682,17 @@ __hot int cursor_del(MDBX_cursor *mc, unsigned flags) {
               continue;
             const node_t *inner = node;
             if (unlikely(m2->ki[mc->top] >= page_numkeys(mp))) {
-              m2->flags = z_poor_mark;
+              m2->flags |= z_eof_hard | z_eof_soft | z_after_delete;
               m2->subcur->nested_tree.root = 0;
               m2->subcur->cursor.top_and_flags = z_inner | z_poor_mark;
               continue;
             }
             if (m2->ki[mc->top] != mc->ki[mc->top]) {
               inner = page_node(mp, m2->ki[mc->top]);
-              if (node_flags(inner) & N_TREE)
+              if (node_flags(inner) != N_DUP)
                 continue;
-            }
+            } else
+              m2->subcur->nested_tree = mc->subcur->nested_tree;
             m2->subcur->cursor.pg[0] = node_data(inner);
           }
         }
@@ -18455,11 +18508,11 @@ int cursor_check(const MDBX_cursor *mc, int txn_bad_bits) {
   return MDBX_SUCCESS;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 #if MDBX_ENABLE_DBI_SPARSE
 size_t dbi_bitmap_ctz_fallback(const MDBX_txn *txn, intptr_t bmi) {
-  tASSERT(txn, bmi > 0);
+  tASSERT(txn, bmi != 0);
   bmi &= -bmi;
   if (sizeof(txn->dbi_sparse[0]) > 4) {
     static const uint8_t debruijn_ctz64[64] = {0,  1,  2,  53, 3,  7,  54, 27, 4,  38, 41, 8,  34, 55, 48, 28,
@@ -18626,13 +18679,8 @@ int dbi_defer_release(MDBX_env *const env, defer_free_item_t *const chain) {
 #endif /* MDBX_ENABLE_DBI_LOCKFREE */
 
   ENSURE(env, osal_fastmutex_release(&env->dbi_lock) == MDBX_SUCCESS);
-  if (length > 42) {
-#if defined(_WIN32) || defined(_WIN64)
-    SwitchToThread();
-#else
-    sched_yield();
-#endif /* Windows */
-  }
+  if (length > 42)
+    osal_yield();
   while (obsolete_chain) {
     defer_free_item_t *item = obsolete_chain;
     obsolete_chain = obsolete_chain->next;
@@ -18644,7 +18692,7 @@ int dbi_defer_release(MDBX_env *const env, defer_free_item_t *const chain) {
 /* Export or close DBI handles opened in this txn. */
 int dbi_update(MDBX_txn *txn, int keep) {
   MDBX_env *const env = txn->env;
-  tASSERT(txn, !txn->parent && txn == env->basal_txn);
+  tASSERT(txn, (!txn->parent && txn == env->basal_txn) || !keep);
   bool locked = false;
   defer_free_item_t *defer_chain = nullptr;
   TXN_FOREACH_DBI_USER(txn, dbi) {
@@ -19170,7 +19218,7 @@ __cold const tree_t *dbi_dig(const MDBX_txn *txn, const size_t dbi, tree_t *fall
 
 int dbi_close_release(MDBX_env *env, MDBX_dbi dbi) { return dbi_defer_release(env, dbi_close_locked(env, dbi)); }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 static inline size_t dpl_size2bytes(ptrdiff_t size) {
   assert(size > CURSOR_STACK_SIZE && (size_t)size <= PAGELIST_LIMIT);
@@ -19654,7 +19702,7 @@ void dpl_release_shadows(MDBX_txn *txn) {
   dpl_clear(dl);
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 __cold int dxb_read_header(MDBX_env *env, meta_t *dest, const int lck_exclusive, const mdbx_mode_t mode_bits) {
   memset(dest, 0, sizeof(meta_t));
@@ -19755,7 +19803,7 @@ __cold int dxb_read_header(MDBX_env *env, meta_t *dest, const int lck_exclusive,
   if (dest->pagesize == 0 ||
       (env->stuck_meta < 0 && !(meta_is_steady(dest) || meta_weak_acceptable(env, dest, lck_exclusive)))) {
     ERROR("%s", "no usable meta-pages, database is corrupted");
-    if (rc == MDBX_SUCCESS) {
+    if (!MDBX_IS_ERROR(rc)) {
       /* TODO: try to restore the database by fully checking b-tree structure
        * for the each meta page, if the corresponding option was given */
       return MDBX_CORRUPTED;
@@ -20185,7 +20233,7 @@ __cold int dxb_setup(MDBX_env *env, const int lck_rc, const mdbx_mode_t mode_bit
     if (unlikely(err != MDBX_SUCCESS))
       return err;
 
-    err = osal_ftruncate(env->lazy_fd, env->dxb_mmap.filesize = env->dxb_mmap.current = env->geo_in_bytes.now);
+    err = osal_fsetsize(env->lazy_fd, env->dxb_mmap.filesize = env->dxb_mmap.current = env->geo_in_bytes.now);
     if (unlikely(err != MDBX_SUCCESS))
       return err;
 
@@ -20314,9 +20362,8 @@ __cold int dxb_setup(MDBX_env *env, const int lck_rc, const mdbx_mode_t mode_bit
       }
 
       if (env->flags & MDBX_RDONLY) {
-        if (filesize_before & (globals.sys_allocation_granularity - 1)) {
-          ERROR("filesize should be rounded-up to system allocation granularity %u",
-                globals.sys_allocation_granularity);
+        if (filesize_before & (globals.sys_pagesize - 1)) {
+          ERROR("filesize should be rounded-up to system page size %u", globals.sys_pagesize);
           return MDBX_WANNA_RECOVERY;
         }
         WARNING("%s", "ignore filesize mismatch in readonly-mode");
@@ -20335,7 +20382,7 @@ __cold int dxb_setup(MDBX_env *env, const int lck_rc, const mdbx_mode_t mode_bit
       !(env->flags & MDBX_NORDAHEAD) && mdbx_is_readahead_reasonable(used_bytes, 0) == MDBX_RESULT_TRUE;
 
   err = osal_mmap(env->flags, &env->dxb_mmap, env->geo_in_bytes.now, env->geo_in_bytes.upper,
-                  (lck_rc && env->stuck_meta < 0) ? MMAP_OPTION_TRUNCATE : 0, env->pathname.dxb);
+                  (lck_rc && env->stuck_meta < 0) ? MMAP_OPTION_SETLENGTH : 0, env->pathname.dxb);
   if (unlikely(err != MDBX_SUCCESS))
     return err;
 
@@ -20470,14 +20517,14 @@ __cold int dxb_setup(MDBX_env *env, const int lck_rc, const mdbx_mode_t mode_bit
         meta_troika_dump(env, &troika);
         return MDBX_CORRUPTED;
       }
+
+    purge_meta_head:
       if (env->flags & MDBX_RDONLY) {
         ERROR("%s and rollback needed: (from head %" PRIaTXN " to steady %" PRIaTXN ")%s",
               "opening after an unclean shutdown", recent.txnid, prefer_steady.txnid, ", but unable in read-only mode");
         meta_troika_dump(env, &troika);
         return MDBX_WANNA_RECOVERY;
       }
-
-    purge_meta_head:
       NOTICE("%s and doing automatic rollback: "
              "purge%s meta[%u] with%s txnid %" PRIaTXN,
              "opening after an unclean shutdown", last_valid ? "" : " invalid", pgno, last_valid ? " weak" : "",
@@ -20535,7 +20582,13 @@ __cold int dxb_setup(MDBX_env *env, const int lck_rc, const mdbx_mode_t mode_bit
                header.geometry.lower, header.geometry.now, header.geometry.upper, pv2pages(header.geometry.shrink_pv),
                pv2pages(header.geometry.grow_pv), next_txnid);
 
-        ENSURE(env, header.unsafe_txnid == recent.txnid);
+        if (unlikely(header.unsafe_txnid != recent.txnid)) {
+          const pgno_t recent_pgno = bytes2pgno(env, ptr_dist(recent.ptr_c, env->dxb_mmap.base));
+          ERROR("meta[%u] recent steady txnid %" PRIaTXN " != header txnid %" PRIaTXN
+                ", this is too unexpected and requires manual analysis.",
+                recent_pgno, recent.txnid, header.unsafe_txnid);
+          return MDBX_PROBLEM;
+        }
         meta_set_txnid(env, &header, next_txnid);
         err = dxb_sync_locked(env, env->flags | txn_shrink_allowed, &header, &troika);
         if (err) {
@@ -20754,12 +20807,14 @@ int dxb_sync_locked(MDBX_env *env, unsigned flags, meta_t *const pending, troika
 
   /* LY: step#1 - sync previously written/updated data-pages */
   rc = MDBX_RESULT_FALSE /* carry steady */;
-  if (atomic_load64(&env->lck->unsynced_pages, mo_Relaxed)) {
+  const uint64_t snap_unsynced_pages = atomic_load64(&env->lck->unsynced_pages, mo_Relaxed);
+  if (snap_unsynced_pages) {
+    if (snap_unsynced_pages == 1 && (flags & MDBX_NOMETASYNC))
+      goto skip_lastmeta_sync;
+
     eASSERT(env, ((flags ^ env->flags) & MDBX_WRITEMAP) == 0);
     enum osal_syncmode_bits mode_bits = MDBX_SYNC_NONE;
-    unsigned sync_op = 0;
     if ((flags & MDBX_SAFE_NOSYNC) == 0) {
-      sync_op = 1;
       mode_bits = MDBX_SYNC_DATA;
       if (pending->geometry.first_unallocated > meta_prefer_steady(env, troika).ptr_c->geometry.now)
         mode_bits |= MDBX_SYNC_SIZE;
@@ -20767,18 +20822,15 @@ int dxb_sync_locked(MDBX_env *env, unsigned flags, meta_t *const pending, troika
         mode_bits |= MDBX_SYNC_IODQ;
     } else if (unlikely(env->incore))
       goto skip_incore_sync;
+
     if (flags & MDBX_WRITEMAP) {
 #if MDBX_ENABLE_PGOP_STAT
-      env->lck->pgops.msync.weak += sync_op;
-#else
-      (void)sync_op;
+      env->lck->pgops.msync.weak += (mode_bits > MDBX_SYNC_NONE);
 #endif /* MDBX_ENABLE_PGOP_STAT */
       rc = osal_msync(&env->dxb_mmap, 0, pgno_align2os_bytes(env, pending->geometry.first_unallocated), mode_bits);
     } else {
 #if MDBX_ENABLE_PGOP_STAT
-      env->lck->pgops.fsync.weak += sync_op;
-#else
-      (void)sync_op;
+      env->lck->pgops.fsync.weak += (mode_bits > MDBX_SYNC_NONE);
 #endif /* MDBX_ENABLE_PGOP_STAT */
       rc = osal_fsync(env->lazy_fd, mode_bits);
     }
@@ -20801,6 +20853,7 @@ int dxb_sync_locked(MDBX_env *env, unsigned flags, meta_t *const pending, troika
     /* Может быть нулевым если unsynced_pages > 0 в результате спиллинга.
      * eASSERT(env, env->lck->eoos_timestamp.weak != 0); */
     unaligned_poke_u64(4, pending->sign, DATASIGN_WEAK);
+  skip_lastmeta_sync:;
   }
 
   const bool legal4overwrite = head.txnid == pending->unsafe_txnid &&
@@ -20935,13 +20988,17 @@ int dxb_sync_locked(MDBX_env *env, unsigned flags, meta_t *const pending, troika
     }
     osal_flush_incoherent_mmap(target, sizeof(meta_t), globals.sys_pagesize);
     /* sync meta-pages */
-    if ((flags & MDBX_NOMETASYNC) == 0 && env->fd4meta == env->lazy_fd && !env->incore) {
+    if (env->fd4meta == env->lazy_fd && !env->incore) {
+      if (flags & MDBX_NOMETASYNC)
+        env->lck->unsynced_pages.weak += 1;
+      else {
 #if MDBX_ENABLE_PGOP_STAT
-      env->lck->pgops.fsync.weak += 1;
+        env->lck->pgops.fsync.weak += 1;
 #endif /* MDBX_ENABLE_PGOP_STAT */
-      rc = osal_fsync(env->lazy_fd, MDBX_SYNC_DATA | MDBX_SYNC_IODQ);
-      if (rc != MDBX_SUCCESS)
-        goto undo;
+        rc = osal_fsync(env->lazy_fd, MDBX_SYNC_DATA | MDBX_SYNC_IODQ);
+        if (rc != MDBX_SUCCESS)
+          goto undo;
+      }
     }
   }
 
@@ -20987,7 +21044,7 @@ int dxb_sync_locked(MDBX_env *env, unsigned flags, meta_t *const pending, troika
   return rc;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 MDBX_txn *env_owned_wrtxn(const MDBX_env *env) {
   if (likely(env->basal_txn)) {
@@ -21592,7 +21649,7 @@ __cold int env_close(MDBX_env *env, bool resurrect_after_fork) {
   return rc;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 #if MDBX_USE_MINCORE
 /*------------------------------------------------------------------------------
@@ -22734,7 +22791,8 @@ next_gc:;
   /* Does reclaiming stopped at the last steady point? */
   const meta_ptr_t recent = meta_recent(env, &txn->tw.troika);
   const meta_ptr_t prefer_steady = meta_prefer_steady(env, &txn->tw.troika);
-  if (recent.ptr_c != prefer_steady.ptr_c && prefer_steady.is_steady && detent == prefer_steady.txnid + 1) {
+  if ((flags & ALLOC_UNIMPORTANT) == 0 && recent.ptr_c != prefer_steady.ptr_c && prefer_steady.is_steady &&
+      detent == prefer_steady.txnid) {
     DEBUG("gc-kick-steady: recent %" PRIaTXN "-%s, steady %" PRIaTXN "-%s, detent %" PRIaTXN, recent.txnid,
           durable_caption(recent.ptr_c), prefer_steady.txnid, durable_caption(prefer_steady.ptr_c), detent);
     const pgno_t autosync_threshold = atomic_load32(&env->lck->autosync_threshold, mo_Relaxed);
@@ -22772,13 +22830,14 @@ next_gc:;
       env->lck->pgops.gc_prof.flushes += 1;
 #endif /* MDBX_ENABLE_PROFGC */
       meta_t meta = *recent.ptr_c;
-      ret.err = dxb_sync_locked(env, env->flags & MDBX_WRITEMAP, &meta, &txn->tw.troika);
+      ret.err = dxb_sync_locked(env, env->flags & (MDBX_WRITEMAP | MDBX_NOMETASYNC), &meta, &txn->tw.troika);
       DEBUG("gc-make-steady, rc %d", ret.err);
       eASSERT(env, ret.err != MDBX_RESULT_TRUE);
       if (unlikely(ret.err != MDBX_SUCCESS))
         goto fail;
-      eASSERT(env, prefer_steady.ptr_c != meta_prefer_steady(env, &txn->tw.troika).ptr_c);
-      goto retry_gc_refresh_oldest;
+      if (prefer_steady.ptr_c != meta_prefer_steady(env, &txn->tw.troika).ptr_c)
+        goto retry_gc_refresh_oldest;
+      eASSERT(env, env->incore);
     }
   }
 
@@ -22805,14 +22864,11 @@ next_gc:;
 
 no_gc:
   eASSERT(env, pgno == 0);
-#ifndef MDBX_ENABLE_BACKLOG_DEPLETED
-#define MDBX_ENABLE_BACKLOG_DEPLETED 0
-#endif /* MDBX_ENABLE_BACKLOG_DEPLETED*/
-  if (MDBX_ENABLE_BACKLOG_DEPLETED && unlikely(!(txn->flags & txn_gc_drained))) {
+  if (unlikely(!(txn->flags & txn_gc_drained))) {
     ret.err = MDBX_BACKLOG_DEPLETED;
     goto fail;
   }
-  if (flags & ALLOC_RESERVE) {
+  if (flags & (ALLOC_RESERVE | ALLOC_UNIMPORTANT)) {
     ret.err = MDBX_NOTFOUND;
     goto fail;
   }
@@ -22935,7 +22991,7 @@ __hot pgr_t gc_alloc_single(const MDBX_cursor *const mc) {
   return gc_alloc_ex(mc, 1, ALLOC_DEFAULT);
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 MDBX_NOTHROW_PURE_FUNCTION static bool is_lifo(const MDBX_txn *txn) {
   return (txn->env->flags & MDBX_LIFORECLAIM) != 0;
@@ -23020,16 +23076,18 @@ static int prepare_backlog(MDBX_txn *txn, gcu_t *ctx) {
   const size_t for_tree_after_touch = for_rebalance + for_split;
   const size_t for_all_before_touch = for_repnl + for_tree_before_touch;
   const size_t for_all_after_touch = for_repnl + for_tree_after_touch;
+  const size_t enough_before_touch = for_all_before_touch + ctx->backlog_adj;
+  const size_t enough_after_touch = for_all_after_touch + ctx->backlog_adj;
 
-  if (likely(for_repnl < 2 && backlog_size(txn) > for_all_before_touch) &&
+  if (likely(for_repnl < 2 && backlog_size(txn) > enough_before_touch) &&
       (ctx->cursor.top < 0 || is_modifable(txn, ctx->cursor.pg[ctx->cursor.top])))
     return MDBX_SUCCESS;
 
-  TRACE(">> retired-stored %zu, left %zi, backlog %zu, need %zu (4list %zu, "
+  TRACE(">> retired-stored %zu, left %zi, backlog %zu, adj %zu, need %zu (4list %zu, "
         "4split %zu, "
         "4cow %zu, 4tree %zu)",
-        ctx->retired_stored, retired_left, backlog_size(txn), for_all_before_touch, for_repnl, for_split, for_cow,
-        for_tree_before_touch);
+        ctx->retired_stored, retired_left, backlog_size(txn), ctx->backlog_adj, enough_before_touch, for_repnl,
+        for_split, for_cow, for_tree_before_touch);
 
   int err = touch_gc(ctx);
   TRACE("== after-touch, backlog %zu, err %d", backlog_size(txn), err);
@@ -23048,12 +23106,12 @@ static int prepare_backlog(MDBX_txn *txn, gcu_t *ctx) {
     cASSERT(&ctx->cursor, backlog_size(txn) >= for_repnl || err != MDBX_SUCCESS);
   }
 
-  while (backlog_size(txn) < for_all_after_touch && err == MDBX_SUCCESS)
+  while (backlog_size(txn) < enough_after_touch && err == MDBX_SUCCESS)
     err = gc_alloc_ex(&ctx->cursor, 0, ALLOC_RESERVE | ALLOC_UNIMPORTANT).err;
 
-  TRACE("<< backlog %zu, err %d, gc: height %u, branch %zu, leaf %zu, large "
+  TRACE("<< backlog %zu, err %d, adj %zu, gc: height %u, branch %zu, leaf %zu, large "
         "%zu, entries %zu",
-        backlog_size(txn), err, txn->dbs[FREE_DBI].height, (size_t)txn->dbs[FREE_DBI].branch_pages,
+        backlog_size(txn), err, ctx->backlog_adj, txn->dbs[FREE_DBI].height, (size_t)txn->dbs[FREE_DBI].branch_pages,
         (size_t)txn->dbs[FREE_DBI].leaf_pages, (size_t)txn->dbs[FREE_DBI].large_pages,
         (size_t)txn->dbs[FREE_DBI].items);
   tASSERT(txn, err != MDBX_NOTFOUND || (txn->flags & txn_gc_drained) != 0);
@@ -23468,6 +23526,7 @@ int gc_update(MDBX_txn *txn, gcu_t *ctx) {
    * But page numbers cannot disappear from txn->tw.retired_pages[]. */
 retry_clean_adj:
   ctx->reserve_adj = 0;
+  ctx->backlog_adj = 0;
 retry:
   ctx->loop += !(ctx->prev_first_unallocated > txn->geo.first_unallocated);
   TRACE(">> restart, loop %u", ctx->loop);
@@ -23482,8 +23541,13 @@ int gc_update(MDBX_txn *txn, gcu_t *ctx) {
 
   if (unlikely(ctx->dense || ctx->prev_first_unallocated > txn->geo.first_unallocated)) {
     rc = clean_stored_retired(txn, ctx);
-    if (unlikely(rc != MDBX_SUCCESS))
+    if (unlikely(rc != MDBX_SUCCESS)) {
+      if (rc == MDBX_BACKLOG_DEPLETED) {
+        ctx->backlog_adj += ctx->backlog_adj + 1;
+        goto retry;
+      }
       goto bailout;
+    }
   }
 
   ctx->prev_first_unallocated = txn->geo.first_unallocated;
@@ -23525,8 +23589,13 @@ int gc_update(MDBX_txn *txn, gcu_t *ctx) {
           TRACE("%s: cleanup-reclaimed-id [%zu]%" PRIaTXN, dbg_prefix(ctx), ctx->cleaned_slot, ctx->cleaned_id);
           tASSERT(txn, *txn->cursors == &ctx->cursor);
           rc = cursor_del(&ctx->cursor, 0);
-          if (unlikely(rc != MDBX_SUCCESS))
+          if (unlikely(rc != MDBX_SUCCESS)) {
+            if (rc == MDBX_BACKLOG_DEPLETED) {
+              ctx->backlog_adj += ctx->backlog_adj + 1;
+              goto retry;
+            }
             goto bailout;
+          }
         } while (ctx->cleaned_slot < MDBX_PNL_GETSIZE(txn->tw.gc.retxl));
         txl_sort(txn->tw.gc.retxl);
       }
@@ -23564,8 +23633,13 @@ int gc_update(MDBX_txn *txn, gcu_t *ctx) {
         TRACE("%s: cleanup-reclaimed-id %" PRIaTXN, dbg_prefix(ctx), ctx->cleaned_id);
         tASSERT(txn, *txn->cursors == &ctx->cursor);
         rc = cursor_del(&ctx->cursor, 0);
-        if (unlikely(rc != MDBX_SUCCESS))
+        if (unlikely(rc != MDBX_SUCCESS)) {
+          if (rc == MDBX_BACKLOG_DEPLETED) {
+            ctx->backlog_adj += ctx->backlog_adj + 1;
+            goto retry;
+          }
           goto bailout;
+        }
       }
     }
 
@@ -23610,8 +23684,13 @@ int gc_update(MDBX_txn *txn, gcu_t *ctx) {
     if (ctx->retired_stored < MDBX_PNL_GETSIZE(txn->tw.retired_pages)) {
       /* store retired-list into GC */
       rc = gcu_retired(txn, ctx);
-      if (unlikely(rc != MDBX_SUCCESS))
+      if (unlikely(rc != MDBX_SUCCESS)) {
+        if (rc == MDBX_BACKLOG_DEPLETED) {
+          ctx->backlog_adj += ctx->backlog_adj + 1;
+          goto retry;
+        }
         goto bailout;
+      }
       continue;
     }
 
@@ -23640,6 +23719,7 @@ int gc_update(MDBX_txn *txn, gcu_t *ctx) {
         continue;
       if (likely(rc == MDBX_RESULT_TRUE))
         goto retry;
+      eASSERT(env, rc != MDBX_BACKLOG_DEPLETED);
       goto bailout;
     }
     tASSERT(txn, rid_result.err == MDBX_SUCCESS);
@@ -23717,8 +23797,13 @@ int gc_update(MDBX_txn *txn, gcu_t *ctx) {
     prepare_backlog(txn, ctx);
     rc = cursor_put(&ctx->cursor, &key, &data, MDBX_RESERVE | MDBX_NOOVERWRITE);
     tASSERT(txn, pnl_check_allocated(txn->tw.repnl, txn->geo.first_unallocated - MDBX_ENABLE_REFUND));
-    if (unlikely(rc != MDBX_SUCCESS))
+    if (unlikely(rc != MDBX_SUCCESS)) {
+      if (rc == MDBX_BACKLOG_DEPLETED) {
+        ctx->backlog_adj += ctx->backlog_adj + 1;
+        goto retry;
+      }
       goto bailout;
+    }
 
     zeroize_reserved(env, data);
     ctx->reserved += chunk;
@@ -23809,8 +23894,13 @@ int gc_update(MDBX_txn *txn, gcu_t *ctx) {
         chunk = left;
       }
       rc = cursor_put(&ctx->cursor, &key, &data, MDBX_CURRENT | MDBX_RESERVE);
-      if (unlikely(rc != MDBX_SUCCESS))
+      if (unlikely(rc != MDBX_SUCCESS)) {
+        if (rc == MDBX_BACKLOG_DEPLETED) {
+          ctx->backlog_adj += ctx->backlog_adj + 1;
+          goto retry;
+        }
         goto bailout;
+      }
       zeroize_reserved(env, data);
 
       if (unlikely(txn->tw.loose_count || ctx->amount != MDBX_PNL_GETSIZE(txn->tw.repnl))) {
@@ -23903,7 +23993,7 @@ int gc_update(MDBX_txn *txn, gcu_t *ctx) {
   return rc;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 static void mdbx_init(void);
 static void mdbx_fini(void);
@@ -23929,8 +24019,7 @@ BOOL APIENTRY DllMain(HANDLE module, DWORD reason, LPVOID reserved)
 #if !MDBX_MANUAL_MODULE_HANDLER
 static
 #endif /* !MDBX_MANUAL_MODULE_HANDLER */
-    void NTAPI
-    mdbx_module_handler(PVOID module, DWORD reason, PVOID reserved)
+    void NTAPI mdbx_module_handler(PVOID module, DWORD reason, PVOID reserved)
 #endif /* MDBX_BUILD_SHARED_LIBRARY */
 {
   (void)reserved;
@@ -24124,6 +24213,8 @@ __dll_export
 #else
   #if defined(__ANDROID_API__)
     "Android" MDBX_STRINGIFY(__ANDROID_API__)
+  #elif defined(__OHOS__)
+    "Harmony OS"
   #elif defined(__linux__) || defined(__gnu_linux__)
     "Linux"
   #elif defined(EMSCRIPTEN) || defined(__EMSCRIPTEN__)
@@ -24171,7 +24262,9 @@ __dll_export
 
     "-"
 
-  #if defined(__amd64__)
+  #if defined(__e2k__) || defined(__elbrus__)
+    "Elbrus"
+  #elif defined(__amd64__)
     "AMD64"
   #elif defined(__ia32__)
     "IA32"
@@ -24208,6 +24301,8 @@ __dll_export
     "SPARC"
   #elif defined(__s390__) || defined(__s390) || defined(__zarch__) || defined(__zarch)
     "S390"
+  #elif defined(__riscv) || defined(__riscv__) || defined(__RISCV) || defined(__RISCV__)
+    "RISC-V (стеклянные бусы)"
   #else
     "UnknownARCH"
   #endif
@@ -24274,6 +24369,7 @@ __dll_export
 #else /* Windows */
     " MDBX_LOCKING=" MDBX_LOCKING_CONFIG
     " MDBX_USE_OFDLOCKS=" MDBX_USE_OFDLOCKS_CONFIG
+    " MDBX_USE_FALLOCATE=" MDBX_USE_FALLOCATE_CONFIG
 #endif /* !Windows */
     " MDBX_CACHELINE_SIZE=" MDBX_STRINGIFY(MDBX_CACHELINE_SIZE)
     " MDBX_CPU_WRITEBACK_INCOHERENT=" MDBX_STRINGIFY(MDBX_CPU_WRITEBACK_INCOHERENT)
@@ -24366,7 +24462,7 @@ const char *__asan_default_options(void) {
 #endif /* __SANITIZE_ADDRESS__ */
 
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 #if !(defined(_WIN32) || defined(_WIN64))
 /*----------------------------------------------------------------------------*
@@ -24520,7 +24616,28 @@ static int lck_op(const mdbx_filehandle_t fd, int cmd, const int lck, const off_
   }
 }
 
-MDBX_INTERNAL int osal_lockfile(mdbx_filehandle_t fd, bool wait) {
+static int lck_setlk_with3retries(const mdbx_filehandle_t fd, const int lck, const off_t offset, off_t len) {
+  assert(lck != F_UNLCK);
+  int retry_left = 3;
+#if defined(__ANDROID_API__)
+  retry_left *= 3;
+#endif /* Android */
+  while (true) {
+    int rc = lck_op(fd, op_setlk, lck, offset, len);
+    if (!(rc == EAGAIN || rc == EACCES || rc == EBUSY || rc == EWOULDBLOCK || rc == EDEADLK) || --retry_left < 1)
+      return rc;
+#if defined(__ANDROID_API__)
+    if (retry_left == 5 || retry_left == 3) {
+      usleep(1000 * 42 / 2);
+      continue;
+    }
+#endif /* Android */
+    if (osal_yield())
+      return rc;
+  }
+}
+
+int osal_lockfile(mdbx_filehandle_t fd, bool wait) {
 #if MDBX_USE_OFDLOCKS
   if (unlikely(op_setlk == 0))
     choice_fcntl();
@@ -24528,7 +24645,7 @@ MDBX_INTERNAL int osal_lockfile(mdbx_filehandle_t fd, bool wait) {
   return lck_op(fd, wait ? op_setlkw : op_setlk, F_WRLCK, 0, OFF_T_MAX);
 }
 
-MDBX_INTERNAL int lck_rpid_set(MDBX_env *env) {
+int lck_rpid_set(MDBX_env *env) {
   assert(env->lck_mmap.fd != INVALID_HANDLE_VALUE);
   assert(env->pid > 0);
   if (unlikely(osal_getpid() != env->pid))
@@ -24536,13 +24653,13 @@ MDBX_INTERNAL int lck_rpid_set(MDBX_env *env) {
   return lck_op(env->lck_mmap.fd, op_setlk, F_WRLCK, env->pid, 1);
 }
 
-MDBX_INTERNAL int lck_rpid_clear(MDBX_env *env) {
+int lck_rpid_clear(MDBX_env *env) {
   assert(env->lck_mmap.fd != INVALID_HANDLE_VALUE);
   assert(env->pid > 0);
   return lck_op(env->lck_mmap.fd, op_setlk, F_UNLCK, env->pid, 1);
 }
 
-MDBX_INTERNAL int lck_rpid_check(MDBX_env *env, uint32_t pid) {
+int lck_rpid_check(MDBX_env *env, uint32_t pid) {
   assert(env->lck_mmap.fd != INVALID_HANDLE_VALUE);
   assert(pid > 0);
   return lck_op(env->lck_mmap.fd, op_getlk, F_WRLCK, pid, 1);
@@ -24551,7 +24668,7 @@ MDBX_INTERNAL int lck_rpid_check(MDBX_env *env, uint32_t pid) {
 /*---------------------------------------------------------------------------*/
 
 #if MDBX_LOCKING > MDBX_LOCKING_SYSV
-MDBX_INTERNAL int lck_ipclock_stubinit(osal_ipclock_t *ipc) {
+int lck_ipclock_stubinit(osal_ipclock_t *ipc) {
 #if MDBX_LOCKING == MDBX_LOCKING_POSIX1988
   return sem_init(ipc, false, 1) ? errno : 0;
 #elif MDBX_LOCKING == MDBX_LOCKING_POSIX2001 || MDBX_LOCKING == MDBX_LOCKING_POSIX2008
@@ -24561,7 +24678,7 @@ MDBX_INTERNAL int lck_ipclock_stubinit(osal_ipclock_t *ipc) {
 #endif
 }
 
-MDBX_INTERNAL int lck_ipclock_destroy(osal_ipclock_t *ipc) {
+int lck_ipclock_destroy(osal_ipclock_t *ipc) {
 #if MDBX_LOCKING == MDBX_LOCKING_POSIX1988
   return sem_destroy(ipc) ? errno : 0;
 #elif MDBX_LOCKING == MDBX_LOCKING_POSIX2001 || MDBX_LOCKING == MDBX_LOCKING_POSIX2008
@@ -24625,7 +24742,7 @@ static int check_fstat(MDBX_env *env) {
   return rc;
 }
 
-__cold MDBX_INTERNAL int lck_seize(MDBX_env *env) {
+__cold int lck_seize(MDBX_env *env) {
   assert(env->lazy_fd != INVALID_HANDLE_VALUE);
   if (unlikely(osal_getpid() != env->pid))
     return MDBX_PANIC;
@@ -24649,7 +24766,7 @@ __cold MDBX_INTERNAL int lck_seize(MDBX_env *env) {
 
   if (env->lck_mmap.fd == INVALID_HANDLE_VALUE) {
     /* LY: without-lck mode (e.g. exclusive or on read-only filesystem) */
-    rc = lck_op(env->lazy_fd, op_setlk, (env->flags & MDBX_RDONLY) ? F_RDLCK : F_WRLCK, 0, OFF_T_MAX);
+    rc = lck_setlk_with3retries(env->lazy_fd, (env->flags & MDBX_RDONLY) ? F_RDLCK : F_WRLCK, 0, OFF_T_MAX);
     if (rc != MDBX_SUCCESS) {
       ERROR("%s, err %u", "without-lck", rc);
       eASSERT(env, MDBX_IS_ERROR(rc));
@@ -24657,9 +24774,6 @@ __cold MDBX_INTERNAL int lck_seize(MDBX_env *env) {
     }
     return MDBX_RESULT_TRUE /* Done: return with exclusive locking. */;
   }
-#if defined(_POSIX_PRIORITY_SCHEDULING) && _POSIX_PRIORITY_SCHEDULING > 0
-  sched_yield();
-#endif
 
 retry:
   if (rc == MDBX_RESULT_TRUE) {
@@ -24672,14 +24786,14 @@ __cold MDBX_INTERNAL int lck_seize(MDBX_env *env) {
   }
 
   /* Firstly try to get exclusive locking.  */
-  rc = lck_op(env->lck_mmap.fd, op_setlk, F_WRLCK, 0, 1);
+  rc = lck_setlk_with3retries(env->lck_mmap.fd, F_WRLCK, 0, 1);
   if (rc == MDBX_SUCCESS) {
     rc = check_fstat(env);
     if (MDBX_IS_ERROR(rc))
       return rc;
 
   continue_dxb_exclusive:
-    rc = lck_op(env->lazy_fd, op_setlk, (env->flags & MDBX_RDONLY) ? F_RDLCK : F_WRLCK, 0, OFF_T_MAX);
+    rc = lck_setlk_with3retries(env->lazy_fd, (env->flags & MDBX_RDONLY) ? F_RDLCK : F_WRLCK, 0, OFF_T_MAX);
     if (rc == MDBX_SUCCESS)
       return MDBX_RESULT_TRUE /* Done: return with exclusive locking. */;
 
@@ -24727,7 +24841,7 @@ __cold MDBX_INTERNAL int lck_seize(MDBX_env *env) {
   }
 
   /* got shared, retry exclusive */
-  rc = lck_op(env->lck_mmap.fd, op_setlk, F_WRLCK, 0, 1);
+  rc = lck_setlk_with3retries(env->lck_mmap.fd, F_WRLCK, 0, 1);
   if (rc == MDBX_SUCCESS)
     goto continue_dxb_exclusive;
 
@@ -24738,7 +24852,7 @@ __cold MDBX_INTERNAL int lck_seize(MDBX_env *env) {
   }
 
   /* Lock against another process operating in without-lck or exclusive mode. */
-  rc = lck_op(env->lazy_fd, op_setlk, (env->flags & MDBX_RDONLY) ? F_RDLCK : F_WRLCK, env->pid, 1);
+  rc = lck_setlk_with3retries(env->lazy_fd, (env->flags & MDBX_RDONLY) ? F_RDLCK : F_WRLCK, env->pid, 1);
   if (rc != MDBX_SUCCESS) {
     ERROR("%s, err %u", "lock-against-without-lck", rc);
     eASSERT(env, MDBX_IS_ERROR(rc));
@@ -24749,7 +24863,7 @@ __cold MDBX_INTERNAL int lck_seize(MDBX_env *env) {
   return MDBX_RESULT_FALSE;
 }
 
-MDBX_INTERNAL int lck_downgrade(MDBX_env *env) {
+int lck_downgrade(MDBX_env *env) {
   assert(env->lck_mmap.fd != INVALID_HANDLE_VALUE);
   if (unlikely(osal_getpid() != env->pid))
     return MDBX_PANIC;
@@ -24761,7 +24875,7 @@ MDBX_INTERNAL int lck_downgrade(MDBX_env *env) {
       rc = lck_op(env->lazy_fd, op_setlk, F_UNLCK, env->pid + 1, OFF_T_MAX - env->pid - 1);
   }
   if (rc == MDBX_SUCCESS)
-    rc = lck_op(env->lck_mmap.fd, op_setlk, F_RDLCK, 0, 1);
+    rc = lck_setlk_with3retries(env->lck_mmap.fd, F_RDLCK, 0, 1);
   if (unlikely(rc != 0)) {
     ERROR("%s, err %u", "lck", rc);
     assert(MDBX_IS_ERROR(rc));
@@ -24769,7 +24883,7 @@ MDBX_INTERNAL int lck_downgrade(MDBX_env *env) {
   return rc;
 }
 
-MDBX_INTERNAL int lck_upgrade(MDBX_env *env, bool dont_wait) {
+int lck_upgrade(MDBX_env *env, bool dont_wait) {
   assert(env->lck_mmap.fd != INVALID_HANDLE_VALUE);
   if (unlikely(osal_getpid() != env->pid))
     return MDBX_PANIC;
@@ -24780,10 +24894,10 @@ MDBX_INTERNAL int lck_upgrade(MDBX_env *env, bool dont_wait) {
     rc = (env->pid > 1) ? lck_op(env->lazy_fd, cmd, F_WRLCK, 0, env->pid - 1) : MDBX_SUCCESS;
     if (rc == MDBX_SUCCESS) {
       rc = lck_op(env->lazy_fd, cmd, F_WRLCK, env->pid + 1, OFF_T_MAX - env->pid - 1);
-      if (rc != MDBX_SUCCESS && env->pid > 1 && lck_op(env->lazy_fd, op_setlk, F_UNLCK, 0, env->pid - 1))
+      if (rc != MDBX_SUCCESS && env->pid > 1 && lck_setlk_with3retries(env->lazy_fd, F_UNLCK, 0, env->pid - 1))
         rc = MDBX_PANIC;
     }
-    if (rc != MDBX_SUCCESS && lck_op(env->lck_mmap.fd, op_setlk, F_RDLCK, 0, 1))
+    if (rc != MDBX_SUCCESS && lck_setlk_with3retries(env->lck_mmap.fd, F_RDLCK, 0, 1))
       rc = MDBX_PANIC;
   }
   if (unlikely(rc != 0)) {
@@ -24793,7 +24907,7 @@ MDBX_INTERNAL int lck_upgrade(MDBX_env *env, bool dont_wait) {
   return rc;
 }
 
-__cold MDBX_INTERNAL int lck_destroy(MDBX_env *env, MDBX_env *inprocess_neighbor, const uint32_t current_pid) {
+__cold int lck_destroy(MDBX_env *env, MDBX_env *inprocess_neighbor, const uint32_t current_pid) {
   eASSERT(env, osal_getpid() == current_pid);
   int rc = MDBX_SUCCESS;
   struct stat lck_info;
@@ -24882,7 +24996,7 @@ __cold MDBX_INTERNAL int lck_destroy(MDBX_env *env, MDBX_env *inprocess_neighbor
 
 /*---------------------------------------------------------------------------*/
 
-__cold MDBX_INTERNAL int lck_init(MDBX_env *env, MDBX_env *inprocess_neighbor, int global_uniqueness_flag) {
+__cold int lck_init(MDBX_env *env, MDBX_env *inprocess_neighbor, int global_uniqueness_flag) {
 #if MDBX_LOCKING == MDBX_LOCKING_SYSV
   int semid = -1;
   /* don't initialize semaphores twice */
@@ -25092,7 +25206,7 @@ __cold static int osal_ipclock_failed(MDBX_env *env, osal_ipclock_t *ipc, const
 }
 
 #if defined(__ANDROID_API__) || defined(ANDROID) || defined(BIONIC)
-MDBX_INTERNAL int osal_check_tid4bionic(void) {
+int osal_check_tid4bionic(void) {
   /* avoid 32-bit Bionic bug/hang with 32-pit TID */
   if (sizeof(pthread_mutex_t) < sizeof(pid_t) + sizeof(unsigned)) {
     pid_t tid = gettid();
@@ -25175,7 +25289,7 @@ static int osal_ipclock_unlock(MDBX_env *env, osal_ipclock_t *ipc) {
   return rc;
 }
 
-MDBX_INTERNAL int lck_rdt_lock(MDBX_env *env) {
+int lck_rdt_lock(MDBX_env *env) {
   TRACE("%s", ">>");
   jitter4testing(true);
   int rc = osal_ipclock_lock(env, &env->lck->rdt_lock, false);
@@ -25183,7 +25297,7 @@ MDBX_INTERNAL int lck_rdt_lock(MDBX_env *env) {
   return rc;
 }
 
-MDBX_INTERNAL void lck_rdt_unlock(MDBX_env *env) {
+void lck_rdt_unlock(MDBX_env *env) {
   TRACE("%s", ">>");
   int err = osal_ipclock_unlock(env, &env->lck->rdt_lock);
   TRACE("<< err %d", err);
@@ -25223,7 +25337,7 @@ void lck_txn_unlock(MDBX_env *env) {
 
 #endif /* !Windows LCK-implementation */
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 #if defined(_WIN32) || defined(_WIN64)
 
@@ -25362,7 +25476,7 @@ void lck_txn_unlock(MDBX_env *env) {
 #define LCK_LOWER LCK_LO_OFFSET, LCK_LO_LEN
 #define LCK_UPPER LCK_UP_OFFSET, LCK_UP_LEN
 
-MDBX_INTERNAL int lck_rdt_lock(MDBX_env *env) {
+int lck_rdt_lock(MDBX_env *env) {
   imports.srwl_AcquireShared(&env->remap_guard);
   if (env->lck_mmap.fd == INVALID_HANDLE_VALUE)
     return MDBX_SUCCESS; /* readonly database in readonly filesystem */
@@ -25380,7 +25494,7 @@ MDBX_INTERNAL int lck_rdt_lock(MDBX_env *env) {
   return rc;
 }
 
-MDBX_INTERNAL void lck_rdt_unlock(MDBX_env *env) {
+void lck_rdt_unlock(MDBX_env *env) {
   if (env->lck_mmap.fd != INVALID_HANDLE_VALUE && (env->flags & MDBX_EXCLUSIVE) == 0) {
     /* transition from S-E (locked) to S-? (used), e.g. unlock upper-part */
     int err = funlock(env->lck_mmap.fd, LCK_UPPER);
@@ -25390,7 +25504,7 @@ MDBX_INTERNAL void lck_rdt_unlock(MDBX_env *env) {
   imports.srwl_ReleaseShared(&env->remap_guard);
 }
 
-MDBX_INTERNAL int osal_lockfile(mdbx_filehandle_t fd, bool wait) {
+int osal_lockfile(mdbx_filehandle_t fd, bool wait) {
   return flock(fd, wait ? LCK_EXCLUSIVE | LCK_WAITFOR : LCK_EXCLUSIVE | LCK_DONTWAIT, 0, DXB_MAXLEN);
 }
 
@@ -25426,7 +25540,7 @@ static int suspend_and_append(mdbx_handle_array_t **array, const DWORD ThreadId)
   return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL int osal_suspend_threads_before_remap(MDBX_env *env, mdbx_handle_array_t **array) {
+int osal_suspend_threads_before_remap(MDBX_env *env, mdbx_handle_array_t **array) {
   eASSERT(env, (env->flags & MDBX_NOSTICKYTHREADS) == 0);
   const uintptr_t CurrentTid = GetCurrentThreadId();
   int rc;
@@ -25493,7 +25607,7 @@ MDBX_INTERNAL int osal_suspend_threads_before_remap(MDBX_env *env, mdbx_handle_a
   return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL int osal_resume_threads_after_remap(mdbx_handle_array_t *array) {
+int osal_resume_threads_after_remap(mdbx_handle_array_t *array) {
   int rc = MDBX_SUCCESS;
   for (unsigned i = 0; i < array->count; ++i) {
     const HANDLE hThread = array->handles[i];
@@ -25629,7 +25743,7 @@ static int internal_seize_lck(HANDLE lfd) {
   return rc;
 }
 
-MDBX_INTERNAL int lck_seize(MDBX_env *env) {
+int lck_seize(MDBX_env *env) {
   const HANDLE fd4data = env->ioring.overlapped_fd ? env->ioring.overlapped_fd : env->lazy_fd;
   assert(fd4data != INVALID_HANDLE_VALUE);
   if (env->flags & MDBX_EXCLUSIVE)
@@ -25671,7 +25785,7 @@ MDBX_INTERNAL int lck_seize(MDBX_env *env) {
   return rc;
 }
 
-MDBX_INTERNAL int lck_downgrade(MDBX_env *env) {
+int lck_downgrade(MDBX_env *env) {
   const HANDLE fd4data = env->ioring.overlapped_fd ? env->ioring.overlapped_fd : env->lazy_fd;
   /* Transite from exclusive-write state (E-E) to used (S-?) */
   assert(fd4data != INVALID_HANDLE_VALUE);
@@ -25701,7 +25815,7 @@ MDBX_INTERNAL int lck_downgrade(MDBX_env *env) {
   return MDBX_SUCCESS /* 5) now at S-? (used), done */;
 }
 
-MDBX_INTERNAL int lck_upgrade(MDBX_env *env, bool dont_wait) {
+int lck_upgrade(MDBX_env *env, bool dont_wait) {
   /* Transite from used state (S-?) to exclusive-write (E-E) */
   assert(env->lck_mmap.fd != INVALID_HANDLE_VALUE);
 
@@ -25735,7 +25849,7 @@ MDBX_INTERNAL int lck_upgrade(MDBX_env *env, bool dont_wait) {
   return MDBX_SUCCESS /* 6) now at E-E (exclusive-write), done */;
 }
 
-MDBX_INTERNAL int lck_init(MDBX_env *env, MDBX_env *inprocess_neighbor, int global_uniqueness_flag) {
+int lck_init(MDBX_env *env, MDBX_env *inprocess_neighbor, int global_uniqueness_flag) {
   (void)env;
   (void)inprocess_neighbor;
   (void)global_uniqueness_flag;
@@ -25756,7 +25870,7 @@ MDBX_INTERNAL int lck_init(MDBX_env *env, MDBX_env *inprocess_neighbor, int glob
   return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL int lck_destroy(MDBX_env *env, MDBX_env *inprocess_neighbor, const uint32_t current_pid) {
+int lck_destroy(MDBX_env *env, MDBX_env *inprocess_neighbor, const uint32_t current_pid) {
   (void)current_pid;
   /* LY: should unmap before releasing the locks to avoid race condition and
    * STATUS_USER_MAPPED_FILE/ERROR_USER_MAPPED_FILE */
@@ -25768,7 +25882,7 @@ MDBX_INTERNAL int lck_destroy(MDBX_env *env, MDBX_env *inprocess_neighbor, const
     if (synced && !inprocess_neighbor && env->lck_mmap.fd != INVALID_HANDLE_VALUE &&
         lck_upgrade(env, true) == MDBX_SUCCESS)
       /* this will fail if LCK is used/mmapped by other process(es) */
-      osal_ftruncate(env->lck_mmap.fd, 0);
+      osal_fsetsize(env->lck_mmap.fd, 0);
   }
   lck_unlock(env);
   return MDBX_SUCCESS;
@@ -25777,12 +25891,12 @@ MDBX_INTERNAL int lck_destroy(MDBX_env *env, MDBX_env *inprocess_neighbor, const
 /*----------------------------------------------------------------------------*/
 /* reader checking (by pid) */
 
-MDBX_INTERNAL int lck_rpid_set(MDBX_env *env) {
+int lck_rpid_set(MDBX_env *env) {
   (void)env;
   return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL int lck_rpid_clear(MDBX_env *env) {
+int lck_rpid_clear(MDBX_env *env) {
   (void)env;
   return MDBX_SUCCESS;
 }
@@ -25793,7 +25907,7 @@ MDBX_INTERNAL int lck_rpid_clear(MDBX_env *env) {
  *   MDBX_RESULT_TRUE, if pid is live (unable to acquire lock)
  *   MDBX_RESULT_FALSE, if pid is dead (lock acquired)
  *   or otherwise the errcode. */
-MDBX_INTERNAL int lck_rpid_check(MDBX_env *env, uint32_t pid) {
+int lck_rpid_check(MDBX_env *env, uint32_t pid) {
   (void)env;
   HANDLE hProcess = OpenProcess(SYNCHRONIZE, FALSE, pid);
   int rc;
@@ -25828,7 +25942,7 @@ MDBX_INTERNAL int lck_rpid_check(MDBX_env *env, uint32_t pid) {
 
 #endif /* Windows */
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 __cold static int lck_setup_locked(MDBX_env *env) {
   int err = rthc_register(env);
@@ -25889,9 +26003,9 @@ __cold static int lck_setup_locked(MDBX_env *env) {
   }
   env->max_readers = (maxreaders <= MDBX_READERS_LIMIT) ? (unsigned)maxreaders : (unsigned)MDBX_READERS_LIMIT;
 
-  err =
-      osal_mmap((env->flags & MDBX_EXCLUSIVE) | MDBX_WRITEMAP, &env->lck_mmap, (size_t)size, (size_t)size,
-                lck_seize_rc ? MMAP_OPTION_TRUNCATE | MMAP_OPTION_SEMAPHORE : MMAP_OPTION_SEMAPHORE, env->pathname.lck);
+  err = osal_mmap((env->flags & MDBX_EXCLUSIVE) | MDBX_WRITEMAP, &env->lck_mmap, (size_t)size, (size_t)size,
+                  lck_seize_rc ? MMAP_OPTION_SETLENGTH | MMAP_OPTION_SEMAPHORE : MMAP_OPTION_SEMAPHORE,
+                  env->pathname.lck);
   if (unlikely(err != MDBX_SUCCESS))
     return err;
 
@@ -26000,7 +26114,7 @@ void mincore_clean_cache(const MDBX_env *const env) {
   memset(env->lck->mincore_cache.begin, -1, sizeof(env->lck->mincore_cache.begin));
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 __cold void debug_log_va(int level, const char *function, int line, const char *fmt, va_list args) {
   ENSURE(nullptr, osal_fastmutex_acquire(&globals.debug_lock) == 0);
@@ -26248,7 +26362,7 @@ __cold int mdbx_setup_debug(MDBX_log_level_t level, MDBX_debug_flags_t flags, MD
   return setup_debug(level, flags, thunk, nullptr, 0);
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 typedef struct meta_snap {
   uint64_t txnid;
@@ -26507,9 +26621,8 @@ __cold int meta_wipe_steady(MDBX_env *env, txnid_t inclusive_upto) {
 
 int meta_sync(const MDBX_env *env, const meta_ptr_t head) {
   eASSERT(env, atomic_load32(&env->lck->meta_sync_txnid, mo_Relaxed) != (uint32_t)head.txnid);
-  /* Функция может вызываться (в том числе) при (env->flags &
-   * MDBX_NOMETASYNC) == 0 и env->fd4meta == env->dsync_fd, например если
-   * предыдущая транзакция была выполненна с флагом MDBX_NOMETASYNC. */
+  /* Функция может вызываться (в том числе) при (env->flags & MDBX_NOMETASYNC) == 0 и env->fd4meta == env->dsync_fd,
+   * например если предыдущая транзакция была выполненна с флагом MDBX_NOMETASYNC. */
 
   int rc = MDBX_RESULT_TRUE;
   if (env->flags & MDBX_WRITEMAP) {
@@ -26519,7 +26632,7 @@ int meta_sync(const MDBX_env *env, const meta_ptr_t head) {
       env->lck->pgops.msync.weak += 1;
 #endif /* MDBX_ENABLE_PGOP_STAT */
     } else {
-#if MDBX_ENABLE_PGOP_ST
+#if MDBX_ENABLE_PGOP_STAT
       env->lck->pgops.wops.weak += 1;
 #endif /* MDBX_ENABLE_PGOP_STAT */
       const page_t *page = data_page(head.ptr_c);
@@ -26767,6 +26880,7 @@ __cold int meta_validate(MDBX_env *env, meta_t *const meta, const page_t *const
   }
 
   const uint64_t used_bytes = meta->geometry.first_unallocated * (uint64_t)meta->pagesize;
+  const uint64_t dxbsize_pages = env->dxb_mmap.filesize / (uint64_t)meta->pagesize;
   if (unlikely(used_bytes > env->dxb_mmap.filesize)) {
     /* Here could be a race with DB-shrinking performed by other process */
     int err = osal_filesize(env->lazy_fd, &env->dxb_mmap.filesize);
@@ -26809,11 +26923,16 @@ __cold int meta_validate(MDBX_env *env, meta_t *const meta, const page_t *const
     }
   }
 
+  /* It has already been verified above that the size of the allocated space does not exceed the file size. */
   pgno_t geo_upper = meta->geometry.upper;
   uint64_t mapsize_max = geo_upper * (uint64_t)meta->pagesize;
   STATIC_ASSERT(MIN_MAPSIZE < MAX_MAPSIZE);
   if (unlikely(mapsize_max > MAX_MAPSIZE ||
-               (MAX_PAGENO + 1) < ceil_powerof2((size_t)mapsize_max, globals.sys_pagesize) / (size_t)meta->pagesize)) {
+               (MAX_PAGENO + 1) < ceil_powerof2((/* допустимо, так как уже проверили что mapsize_max <= MAX_MAPSIZE,
+                                                  * а следовательно mapsize_max помещается в size_t */
+                                                 size_t)mapsize_max,
+                                                globals.sys_allocation_granularity) /
+                                      meta->pagesize)) {
     if (mapsize_max > MAX_MAPSIZE64) {
       WARNING("meta[%u] has invalid max-mapsize (%" PRIu64 "), skip it", meta_number, mapsize_max);
       return MDBX_VERSION_MISMATCH;
@@ -26824,30 +26943,40 @@ __cold int meta_validate(MDBX_env *env, meta_t *const meta, const page_t *const
             "but size of used space still acceptable (%" PRIu64 ")",
             meta_number, mapsize_max, used_bytes);
     geo_upper = (pgno_t)((mapsize_max = MAX_MAPSIZE) / meta->pagesize);
-    if (geo_upper > MAX_PAGENO + 1) {
+    if (geo_upper > MAX_PAGENO + 1)
       geo_upper = MAX_PAGENO + 1;
-      mapsize_max = geo_upper * (uint64_t)meta->pagesize;
-    }
+  }
+
+  if (geo_upper < meta->geometry.first_unallocated) {
+    WARNING("meta[%u] has too less max-mapsize (%" PRIu64 "), "
+            "but size of allocated space still acceptable (%" PRIu64 ")",
+            meta_number, mapsize_max, used_bytes);
+    geo_upper = meta->geometry.first_unallocated;
+  }
+  if (meta->geometry.upper != geo_upper) {
     WARNING("meta[%u] consider get-%s pageno is %" PRIaPGNO " instead of wrong %" PRIaPGNO
             ", will be corrected on next commit(s)",
             meta_number, "upper", geo_upper, meta->geometry.upper);
     meta->geometry.upper = geo_upper;
+    mapsize_max = geo_upper * (uint64_t)meta->pagesize;
   }
 
   /* LY: check and silently put geometry.now into [geo.lower...geo.upper].
    *
-   * Copy-with-compaction by old version of libmdbx could produce DB-file
-   * less than meta.geo.lower bound, in case actual filling is low or no data
-   * at all. This is not a problem as there is no damage or loss of data.
-   * Therefore it is better not to consider such situation as an error, but
-   * silently correct it. */
+   * It has already been verified above that the size of the allocated space does not exceed the file size.
+   *
+   * Copy-with-compaction by old version of libmdbx could produce DB-file less than meta.geo.lower bound, in case actual
+   * filling is low or no data at all. This is not a problem as there is no damage or loss of data. Therefore it is
+   * better not to consider such situation as an error, but silently correct it. */
   pgno_t geo_now = meta->geometry.now;
   if (geo_now < geo_lower)
     geo_now = geo_lower;
-  if (geo_now > geo_upper && meta->geometry.first_unallocated <= geo_upper)
+  if (geo_now < dxbsize_pages)
+    geo_now = dxbsize_pages;
+  if (geo_now > geo_upper)
     geo_now = geo_upper;
 
-  if (unlikely(meta->geometry.first_unallocated > geo_now)) {
+  if (unlikely(/* paranoid */ meta->geometry.first_unallocated > geo_now)) {
     WARNING("meta[%u] next-pageno (%" PRIaPGNO ") is beyond end-pgno (%" PRIaPGNO "), skip it", meta_number,
             meta->geometry.first_unallocated, geo_now);
     return MDBX_CORRUPTED;
@@ -26866,7 +26995,7 @@ __cold int meta_validate(MDBX_env *env, meta_t *const meta, const page_t *const
       WARNING("meta[%u] has false-empty %s, skip it", meta_number, "GC");
       return MDBX_CORRUPTED;
     }
-  } else if (unlikely(meta->trees.gc.root >= meta->geometry.first_unallocated)) {
+  } else if (unlikely(meta->trees.gc.root >= meta->geometry.first_unallocated || meta->trees.gc.root < NUM_METAS)) {
     WARNING("meta[%u] has invalid %s-root %" PRIaPGNO ", skip it", meta_number, "GC", meta->trees.gc.root);
     return MDBX_CORRUPTED;
   }
@@ -26878,7 +27007,7 @@ __cold int meta_validate(MDBX_env *env, meta_t *const meta, const page_t *const
       WARNING("meta[%u] has false-empty %s", meta_number, "MainDB");
       return MDBX_CORRUPTED;
     }
-  } else if (unlikely(meta->trees.main.root >= meta->geometry.first_unallocated)) {
+  } else if (unlikely(meta->trees.main.root >= meta->geometry.first_unallocated || meta->trees.main.root < NUM_METAS)) {
     WARNING("meta[%u] has invalid %s-root %" PRIaPGNO ", skip it", meta_number, "MainDB", meta->trees.main.root);
     return MDBX_CORRUPTED;
   }
@@ -26902,7 +27031,7 @@ __cold int meta_validate_copy(MDBX_env *env, const meta_t *meta, meta_t *dest) {
   return meta_validate(env, dest, data_page(meta), bytes2pgno(env, ptr_dist(meta, env->dxb_mmap.base)), nullptr);
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 bsr_t mvcc_bind_slot(MDBX_env *env) {
   eASSERT(env, env->lck_mmap.lck);
@@ -27105,7 +27234,7 @@ static bool pid_insert(uint32_t *list, uint32_t pid) {
   return true;
 }
 
-__cold MDBX_INTERNAL int mvcc_cleanup_dead(MDBX_env *env, int rdt_locked, int *dead) {
+__cold int mvcc_cleanup_dead(MDBX_env *env, int rdt_locked, int *dead) {
   int rc = check_env(env, true);
   if (unlikely(rc != MDBX_SUCCESS))
     return rc;
@@ -27316,7 +27445,7 @@ __cold txnid_t mvcc_kick_laggards(MDBX_env *env, const txnid_t straggler) {
 /// \copyright SPDX-License-Identifier: Apache-2.0
 /// \note Please refer to the COPYRIGHT file for explanations license change,
 /// credits and acknowledgments.
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 __hot int __must_check_result node_add_dupfix(MDBX_cursor *mc, size_t indx, const MDBX_val *key) {
   page_t *mp = mc->pg[mc->top];
@@ -27677,7 +27806,7 @@ __hot struct node_search_result node_search(MDBX_cursor *mc, const MDBX_val *key
   return ret;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 ///
 /// https://en.wikipedia.org/wiki/Operating_system_abstraction_layer
 
@@ -27690,7 +27819,18 @@ __hot struct node_search_result node_search(MDBX_cursor *mc, const MDBX_val *key
 #include <crtdbg.h>
 #endif
 
-static int waitstatus2errcode(DWORD result) {
+/* Map a result from an NTAPI call to WIN32 error code. */
+static int osal_ntstatus2errcode(NTSTATUS status) {
+  DWORD dummy;
+  OVERLAPPED ov;
+  memset(&ov, 0, sizeof(ov));
+  ov.Internal = status;
+  /* Zap: '_Param_(1)' could be '0' */
+  MDBX_SUPPRESS_GOOFY_MSVC_ANALYZER(6387);
+  return GetOverlappedResult(nullptr, &ov, &dummy, FALSE) ? MDBX_SUCCESS : (int)GetLastError();
+}
+
+MDBX_INTERNAL int osal_waitstatus2errcode(DWORD result) {
   switch (result) {
   case WAIT_OBJECT_0:
     return MDBX_SUCCESS;
@@ -27703,21 +27843,10 @@ static int waitstatus2errcode(DWORD result) {
   case WAIT_TIMEOUT:
     return ERROR_TIMEOUT;
   default:
-    return ERROR_UNHANDLED_ERROR;
+    return osal_ntstatus2errcode(result);
   }
 }
 
-/* Map a result from an NTAPI call to WIN32 error code. */
-static int ntstatus2errcode(NTSTATUS status) {
-  DWORD dummy;
-  OVERLAPPED ov;
-  memset(&ov, 0, sizeof(ov));
-  ov.Internal = status;
-  /* Zap: '_Param_(1)' could be '0' */
-  MDBX_SUPPRESS_GOOFY_MSVC_ANALYZER(6387);
-  return GetOverlappedResult(nullptr, &ov, &dummy, FALSE) ? MDBX_SUCCESS : (int)GetLastError();
-}
-
 /* We use native NT APIs to setup the memory map, so that we can
  * let the DB file grow incrementally instead of always preallocating
  * the full size. These APIs are defined in <wdm.h> and <ntifs.h>
@@ -27936,7 +28065,7 @@ __cold void mdbx_panic(const char *fmt, ...) {
     if (IsDebuggerPresent())
       DebugBreak();
 #endif
-    FatalExit(ERROR_UNHANDLED_ERROR);
+    FatalExit(ERROR_UNHANDLED_EXCEPTION);
 #else
     __assert_fail(const_message, "mdbx", 0, "panic");
     abort();
@@ -27947,7 +28076,7 @@ __cold void mdbx_panic(const char *fmt, ...) {
 /*----------------------------------------------------------------------------*/
 
 #ifndef osal_vasprintf
-MDBX_INTERNAL int osal_vasprintf(char **strp, const char *fmt, va_list ap) {
+int osal_vasprintf(char **strp, const char *fmt, va_list ap) {
   va_list ones;
   va_copy(ones, ap);
   const int needed = vsnprintf(nullptr, 0, fmt, ones);
@@ -27979,7 +28108,7 @@ MDBX_INTERNAL int osal_vasprintf(char **strp, const char *fmt, va_list ap) {
 #endif /* osal_vasprintf */
 
 #ifndef osal_asprintf
-MDBX_INTERNAL int osal_asprintf(char **strp, const char *fmt, ...) {
+int osal_asprintf(char **strp, const char *fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   const int rc = osal_vasprintf(strp, fmt, ap);
@@ -27989,7 +28118,7 @@ MDBX_INTERNAL int osal_asprintf(char **strp, const char *fmt, ...) {
 #endif /* osal_asprintf */
 
 #ifndef osal_memalign_alloc
-MDBX_INTERNAL int osal_memalign_alloc(size_t alignment, size_t bytes, void **result) {
+int osal_memalign_alloc(size_t alignment, size_t bytes, void **result) {
   assert(is_powerof2(alignment) && alignment >= sizeof(void *));
 #if defined(_WIN32) || defined(_WIN64)
   (void)alignment;
@@ -28011,7 +28140,7 @@ MDBX_INTERNAL int osal_memalign_alloc(size_t alignment, size_t bytes, void **res
 #endif /* osal_memalign_alloc */
 
 #ifndef osal_memalign_free
-MDBX_INTERNAL void osal_memalign_free(void *ptr) {
+void osal_memalign_free(void *ptr) {
 #if defined(_WIN32) || defined(_WIN64)
   VirtualFree(ptr, 0, MEM_RELEASE);
 #else
@@ -28034,7 +28163,7 @@ char *osal_strdup(const char *str) {
 
 /*----------------------------------------------------------------------------*/
 
-MDBX_INTERNAL int osal_condpair_init(osal_condpair_t *condpair) {
+int osal_condpair_init(osal_condpair_t *condpair) {
   int rc;
   memset(condpair, 0, sizeof(osal_condpair_t));
 #if defined(_WIN32) || defined(_WIN64)
@@ -28073,7 +28202,7 @@ MDBX_INTERNAL int osal_condpair_init(osal_condpair_t *condpair) {
   return rc;
 }
 
-MDBX_INTERNAL int osal_condpair_destroy(osal_condpair_t *condpair) {
+int osal_condpair_destroy(osal_condpair_t *condpair) {
 #if defined(_WIN32) || defined(_WIN64)
   int rc = CloseHandle(condpair->mutex) ? MDBX_SUCCESS : (int)GetLastError();
   rc = CloseHandle(condpair->event[0]) ? rc : (int)GetLastError();
@@ -28087,16 +28216,16 @@ MDBX_INTERNAL int osal_condpair_destroy(osal_condpair_t *condpair) {
   return rc;
 }
 
-MDBX_INTERNAL int osal_condpair_lock(osal_condpair_t *condpair) {
+int osal_condpair_lock(osal_condpair_t *condpair) {
 #if defined(_WIN32) || defined(_WIN64)
   DWORD code = WaitForSingleObject(condpair->mutex, INFINITE);
-  return waitstatus2errcode(code);
+  return osal_waitstatus2errcode(code);
 #else
   return osal_pthread_mutex_lock(&condpair->mutex);
 #endif
 }
 
-MDBX_INTERNAL int osal_condpair_unlock(osal_condpair_t *condpair) {
+int osal_condpair_unlock(osal_condpair_t *condpair) {
 #if defined(_WIN32) || defined(_WIN64)
   return ReleaseMutex(condpair->mutex) ? MDBX_SUCCESS : (int)GetLastError();
 #else
@@ -28104,7 +28233,7 @@ MDBX_INTERNAL int osal_condpair_unlock(osal_condpair_t *condpair) {
 #endif
 }
 
-MDBX_INTERNAL int osal_condpair_signal(osal_condpair_t *condpair, bool part) {
+int osal_condpair_signal(osal_condpair_t *condpair, bool part) {
 #if defined(_WIN32) || defined(_WIN64)
   return SetEvent(condpair->event[part]) ? MDBX_SUCCESS : (int)GetLastError();
 #else
@@ -28112,7 +28241,7 @@ MDBX_INTERNAL int osal_condpair_signal(osal_condpair_t *condpair, bool part) {
 #endif
 }
 
-MDBX_INTERNAL int osal_condpair_wait(osal_condpair_t *condpair, bool part) {
+int osal_condpair_wait(osal_condpair_t *condpair, bool part) {
 #if defined(_WIN32) || defined(_WIN64)
   DWORD code = SignalObjectAndWait(condpair->mutex, condpair->event[part], INFINITE, FALSE);
   if (code == WAIT_OBJECT_0) {
@@ -28120,7 +28249,7 @@ MDBX_INTERNAL int osal_condpair_wait(osal_condpair_t *condpair, bool part) {
     if (code == WAIT_OBJECT_0)
       return MDBX_SUCCESS;
   }
-  return waitstatus2errcode(code);
+  return osal_waitstatus2errcode(code);
 #else
   return pthread_cond_wait(&condpair->cond[part], &condpair->mutex);
 #endif
@@ -28128,7 +28257,7 @@ MDBX_INTERNAL int osal_condpair_wait(osal_condpair_t *condpair, bool part) {
 
 /*----------------------------------------------------------------------------*/
 
-MDBX_INTERNAL int osal_fastmutex_init(osal_fastmutex_t *fastmutex) {
+int osal_fastmutex_init(osal_fastmutex_t *fastmutex) {
 #if defined(_WIN32) || defined(_WIN64)
   InitializeCriticalSection(fastmutex);
   return MDBX_SUCCESS;
@@ -28147,7 +28276,7 @@ MDBX_INTERNAL int osal_fastmutex_init(osal_fastmutex_t *fastmutex) {
 #endif
 }
 
-MDBX_INTERNAL int osal_fastmutex_destroy(osal_fastmutex_t *fastmutex) {
+int osal_fastmutex_destroy(osal_fastmutex_t *fastmutex) {
 #if defined(_WIN32) || defined(_WIN64)
   DeleteCriticalSection(fastmutex);
   return MDBX_SUCCESS;
@@ -28156,7 +28285,7 @@ MDBX_INTERNAL int osal_fastmutex_destroy(osal_fastmutex_t *fastmutex) {
 #endif
 }
 
-MDBX_INTERNAL int osal_fastmutex_acquire(osal_fastmutex_t *fastmutex) {
+int osal_fastmutex_acquire(osal_fastmutex_t *fastmutex) {
 #if defined(_WIN32) || defined(_WIN64)
   __try {
     EnterCriticalSection(fastmutex);
@@ -28171,7 +28300,7 @@ MDBX_INTERNAL int osal_fastmutex_acquire(osal_fastmutex_t *fastmutex) {
 #endif
 }
 
-MDBX_INTERNAL int osal_fastmutex_release(osal_fastmutex_t *fastmutex) {
+int osal_fastmutex_release(osal_fastmutex_t *fastmutex) {
 #if defined(_WIN32) || defined(_WIN64)
   LeaveCriticalSection(fastmutex);
   return MDBX_SUCCESS;
@@ -28184,7 +28313,7 @@ MDBX_INTERNAL int osal_fastmutex_release(osal_fastmutex_t *fastmutex) {
 
 #if defined(_WIN32) || defined(_WIN64)
 
-MDBX_INTERNAL int osal_mb2w(const char *const src, wchar_t **const pdst) {
+int osal_mb2w(const char *const src, wchar_t **const pdst) {
   const size_t dst_wlen = MultiByteToWideChar(CP_THREAD_ACP, MB_ERR_INVALID_CHARS, src, -1, nullptr, 0);
   wchar_t *dst = *pdst;
   int rc = ERROR_INVALID_NAME;
@@ -28254,10 +28383,10 @@ static size_t osal_iov_max;
 #undef OSAL_IOV_MAX
 #endif /* OSAL_IOV_MAX */
 
-MDBX_INTERNAL int osal_ioring_create(osal_ioring_t *ior
+int osal_ioring_create(osal_ioring_t *ior
 #if defined(_WIN32) || defined(_WIN64)
-                                     ,
-                                     bool enable_direct, mdbx_filehandle_t overlapped_fd
+                       ,
+                       bool enable_direct, mdbx_filehandle_t overlapped_fd
 #endif /* Windows */
 ) {
   memset(ior, 0, sizeof(osal_ioring_t));
@@ -28300,7 +28429,7 @@ static inline ior_item_t *ior_next(ior_item_t *item, size_t sgvcnt) {
 #endif
 }
 
-MDBX_INTERNAL int osal_ioring_add(osal_ioring_t *ior, const size_t offset, void *data, const size_t bytes) {
+int osal_ioring_add(osal_ioring_t *ior, const size_t offset, void *data, const size_t bytes) {
   assert(bytes && data);
   assert(bytes % MDBX_MIN_PAGESIZE == 0 && bytes <= MAX_WRITE);
   assert(offset % MDBX_MIN_PAGESIZE == 0 && offset + (uint64_t)bytes <= MAX_MAPSIZE);
@@ -28412,8 +28541,8 @@ MDBX_INTERNAL int osal_ioring_add(osal_ioring_t *ior, const size_t offset, void
   return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL void osal_ioring_walk(osal_ioring_t *ior, iov_ctx_t *ctx,
-                                    void (*callback)(iov_ctx_t *ctx, size_t offset, void *data, size_t bytes)) {
+void osal_ioring_walk(osal_ioring_t *ior, iov_ctx_t *ctx,
+                      void (*callback)(iov_ctx_t *ctx, size_t offset, void *data, size_t bytes)) {
   for (ior_item_t *item = ior->pool; item <= ior->last;) {
 #if defined(_WIN32) || defined(_WIN64)
     size_t offset = ior_offset(item);
@@ -28454,7 +28583,7 @@ MDBX_INTERNAL void osal_ioring_walk(osal_ioring_t *ior, iov_ctx_t *ctx,
   }
 }
 
-MDBX_INTERNAL osal_ioring_write_result_t osal_ioring_write(osal_ioring_t *ior, mdbx_filehandle_t fd) {
+osal_ioring_write_result_t osal_ioring_write(osal_ioring_t *ior, mdbx_filehandle_t fd) {
   osal_ioring_write_result_t r = {MDBX_SUCCESS, 0};
 
 #if defined(_WIN32) || defined(_WIN64)
@@ -28675,7 +28804,7 @@ MDBX_INTERNAL osal_ioring_write_result_t osal_ioring_write(osal_ioring_t *ior, m
   return r;
 }
 
-MDBX_INTERNAL void osal_ioring_reset(osal_ioring_t *ior) {
+void osal_ioring_reset(osal_ioring_t *ior) {
 #if defined(_WIN32) || defined(_WIN64)
   if (ior->last) {
     for (ior_item_t *item = ior->pool; item <= ior->last;) {
@@ -28717,7 +28846,7 @@ static void ior_cleanup(osal_ioring_t *ior, const size_t since) {
 #endif /* Windows */
 }
 
-MDBX_INTERNAL int osal_ioring_resize(osal_ioring_t *ior, size_t items) {
+int osal_ioring_resize(osal_ioring_t *ior, size_t items) {
   assert(items > 0 && items < INT_MAX / sizeof(ior_item_t));
 #if defined(_WIN32) || defined(_WIN64)
   if (ior->state & IOR_STATE_LOCKED)
@@ -28769,7 +28898,7 @@ MDBX_INTERNAL int osal_ioring_resize(osal_ioring_t *ior, size_t items) {
   return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL void osal_ioring_destroy(osal_ioring_t *ior) {
+void osal_ioring_destroy(osal_ioring_t *ior) {
   if (ior->allocated)
     ior_cleanup(ior, 0);
 #if defined(_WIN32) || defined(_WIN64)
@@ -28786,7 +28915,7 @@ MDBX_INTERNAL void osal_ioring_destroy(osal_ioring_t *ior) {
 
 /*----------------------------------------------------------------------------*/
 
-MDBX_INTERNAL int osal_removefile(const pathchar_t *pathname) {
+int osal_removefile(const pathchar_t *pathname) {
 #if defined(_WIN32) || defined(_WIN64)
   return DeleteFileW(pathname) ? MDBX_SUCCESS : (int)GetLastError();
 #else
@@ -28798,7 +28927,7 @@ MDBX_INTERNAL int osal_removefile(const pathchar_t *pathname) {
 static bool is_valid_fd(int fd) { return !(isatty(fd) < 0 && errno == EBADF); }
 #endif /*! Windows */
 
-MDBX_INTERNAL int osal_removedirectory(const pathchar_t *pathname) {
+int osal_removedirectory(const pathchar_t *pathname) {
 #if defined(_WIN32) || defined(_WIN64)
   return RemoveDirectoryW(pathname) ? MDBX_SUCCESS : (int)GetLastError();
 #else
@@ -28806,7 +28935,7 @@ MDBX_INTERNAL int osal_removedirectory(const pathchar_t *pathname) {
 #endif
 }
 
-MDBX_INTERNAL int osal_fileexists(const pathchar_t *pathname) {
+int osal_fileexists(const pathchar_t *pathname) {
 #if defined(_WIN32) || defined(_WIN64)
   if (GetFileAttributesW(pathname) != INVALID_FILE_ATTRIBUTES)
     return MDBX_RESULT_TRUE;
@@ -28820,7 +28949,7 @@ MDBX_INTERNAL int osal_fileexists(const pathchar_t *pathname) {
 #endif
 }
 
-MDBX_INTERNAL pathchar_t *osal_fileext(const pathchar_t *pathname, size_t len) {
+pathchar_t *osal_fileext(const pathchar_t *pathname, size_t len) {
   const pathchar_t *ext = nullptr;
   for (size_t i = 0; i < len && pathname[i]; i++)
     if (pathname[i] == '.')
@@ -28830,7 +28959,7 @@ MDBX_INTERNAL pathchar_t *osal_fileext(const pathchar_t *pathname, size_t len) {
   return (pathchar_t *)ext;
 }
 
-MDBX_INTERNAL bool osal_pathequal(const pathchar_t *l, const pathchar_t *r, size_t len) {
+bool osal_pathequal(const pathchar_t *l, const pathchar_t *r, size_t len) {
 #if defined(_WIN32) || defined(_WIN64)
   for (size_t i = 0; i < len; ++i) {
     pathchar_t a = l[i];
@@ -28846,8 +28975,8 @@ MDBX_INTERNAL bool osal_pathequal(const pathchar_t *l, const pathchar_t *r, size
 #endif
 }
 
-MDBX_INTERNAL int osal_openfile(const enum osal_openfile_purpose purpose, const MDBX_env *env,
-                                const pathchar_t *pathname, mdbx_filehandle_t *fd, mdbx_mode_t unix_mode_bits) {
+int osal_openfile(const enum osal_openfile_purpose purpose, const MDBX_env *env, const pathchar_t *pathname,
+                  mdbx_filehandle_t *fd, mdbx_mode_t unix_mode_bits) {
   *fd = INVALID_HANDLE_VALUE;
 
 #if defined(_WIN32) || defined(_WIN64)
@@ -29056,7 +29185,7 @@ MDBX_INTERNAL int osal_openfile(const enum osal_openfile_purpose purpose, const
   return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL int osal_closefile(mdbx_filehandle_t fd) {
+int osal_closefile(mdbx_filehandle_t fd) {
 #if defined(_WIN32) || defined(_WIN64)
   return CloseHandle(fd) ? MDBX_SUCCESS : (int)GetLastError();
 #else
@@ -29065,7 +29194,7 @@ MDBX_INTERNAL int osal_closefile(mdbx_filehandle_t fd) {
 #endif
 }
 
-MDBX_INTERNAL int osal_pread(mdbx_filehandle_t fd, void *buf, size_t bytes, uint64_t offset) {
+int osal_pread(mdbx_filehandle_t fd, void *buf, size_t bytes, uint64_t offset) {
   if (bytes > MAX_WRITE)
     return MDBX_EINVAL;
 #if defined(_WIN32) || defined(_WIN64)
@@ -29076,8 +29205,14 @@ MDBX_INTERNAL int osal_pread(mdbx_filehandle_t fd, void *buf, size_t bytes, uint
 
   DWORD read = 0;
   if (unlikely(!ReadFile(fd, buf, (DWORD)bytes, &read, &ov))) {
-    int rc = (int)GetLastError();
-    return (rc == MDBX_SUCCESS) ? /* paranoia */ ERROR_READ_FAULT : rc;
+    int err = (int)GetLastError();
+    if (err != ERROR_IO_PENDING)
+      return (err == MDBX_SUCCESS) ? /* paranoia */ ERROR_READ_FAULT : err;
+    if (!GetOverlappedResult(fd, &ov, &read, true)) {
+      err = (int)GetLastError();
+      CancelIo(fd);
+      return (err == MDBX_SUCCESS) ? /* paranoia */ ERROR_READ_FAULT : err;
+    }
   }
 #else
   STATIC_ASSERT_MSG(sizeof(off_t) >= sizeof(size_t), "libmdbx requires 64-bit file I/O on 64-bit systems");
@@ -29090,7 +29225,7 @@ MDBX_INTERNAL int osal_pread(mdbx_filehandle_t fd, void *buf, size_t bytes, uint
   return (bytes == (size_t)read) ? MDBX_SUCCESS : MDBX_ENODATA;
 }
 
-MDBX_INTERNAL int osal_pwrite(mdbx_filehandle_t fd, const void *buf, size_t bytes, uint64_t offset) {
+int osal_pwrite(mdbx_filehandle_t fd, const void *buf, size_t bytes, uint64_t offset) {
   while (true) {
 #if defined(_WIN32) || defined(_WIN64)
     OVERLAPPED ov;
@@ -29121,7 +29256,7 @@ MDBX_INTERNAL int osal_pwrite(mdbx_filehandle_t fd, const void *buf, size_t byte
   }
 }
 
-MDBX_INTERNAL int osal_write(mdbx_filehandle_t fd, const void *buf, size_t bytes) {
+int osal_write(mdbx_filehandle_t fd, const void *buf, size_t bytes) {
   while (true) {
 #if defined(_WIN32) || defined(_WIN64)
     DWORD written;
@@ -29174,7 +29309,7 @@ int osal_pwritev(mdbx_filehandle_t fd, struct iovec *iov, size_t sgvcnt, uint64_
 #endif
 }
 
-MDBX_INTERNAL int osal_fsync(mdbx_filehandle_t fd, enum osal_syncmode_bits mode_bits) {
+int osal_fsync(mdbx_filehandle_t fd, enum osal_syncmode_bits mode_bits) {
 #if defined(_WIN32) || defined(_WIN64)
   if ((mode_bits & (MDBX_SYNC_DATA | MDBX_SYNC_IODQ)) && !FlushFileBuffers(fd))
     return (int)GetLastError();
@@ -29237,7 +29372,7 @@ int osal_filesize(mdbx_filehandle_t fd, uint64_t *length) {
   return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL int osal_is_pipe(mdbx_filehandle_t fd) {
+int osal_is_pipe(mdbx_filehandle_t fd) {
 #if defined(_WIN32) || defined(_WIN64)
   switch (GetFileType(fd)) {
   case FILE_TYPE_DISK:
@@ -29268,7 +29403,7 @@ MDBX_INTERNAL int osal_is_pipe(mdbx_filehandle_t fd) {
 #endif
 }
 
-MDBX_INTERNAL int osal_ftruncate(mdbx_filehandle_t fd, uint64_t length) {
+int osal_fsetsize(mdbx_filehandle_t fd, const uint64_t length) {
 #if defined(_WIN32) || defined(_WIN64)
   if (imports.SetFileInformationByHandle) {
     FILE_END_OF_FILE_INFO EndOfFileInfo;
@@ -29283,11 +29418,61 @@ MDBX_INTERNAL int osal_ftruncate(mdbx_filehandle_t fd, uint64_t length) {
   }
 #else
   STATIC_ASSERT_MSG(sizeof(off_t) >= sizeof(size_t), "libmdbx requires 64-bit file I/O on 64-bit systems");
-  return ftruncate(fd, length) == 0 ? MDBX_SUCCESS : errno;
+
+#if MDBX_USE_FALLOCATE
+  struct stat info;
+  if (unlikely(fstat(fd, &info)))
+    return errno;
+
+  const uint64_t allocated = UINT64_C(512) * info.st_blocks;
+  if (length > allocated) {
+#if defined(__APPLE__)
+    fstore_t store = {
+        .fst_flags = F_ALLOCATECONTIG, .fst_posmode = F_PEOFPOSMODE, .fst_offset = 0, .fst_length = length};
+    int err = MDBX_SUCCESS;
+    if (fcntl(fd, F_PREALLOCATE, &store)) {
+      /* TODO: implement step-by-step allocation in chunks of 16384, 8192, 4094, 2048, 1024 Kb */
+      store.fst_flags = F_ALLOCATEALL;
+      if (fcntl(fd, F_PREALLOCATE, &store))
+        err = errno;
+    }
+#elif defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L
+    const int err = posix_fallocate(fd, 0, length);
+    if (!err && length > (uint64_t)info.st_size)
+      info.st_size = length /* posix_fallocate() extends the file */;
+#else
+    const int err = fallocate(fd, 0, 0, length) ? errno : MDBX_SUCCESS;
+    if (!err && length > (uint64_t)info.st_size)
+      info.st_size = length /* fallocate() extends the file */;
 #endif
+    if (unlikely(err) && ignore_enosys_and_eremote(err) != MDBX_RESULT_TRUE) {
+      /* Workaround for testing: ignore ENOSPC for TMPFS/RAMFS.
+       * This is insignificant for production, but it helps in some tests using /dev/shm inside docker/containers. */
+      if (err != ENOSPC || osal_check_fs_incore(fd) != MDBX_RESULT_TRUE)
+        return err;
+    }
+  }
+
+  if (length == (uint64_t)info.st_size)
+    return MDBX_SUCCESS;
+#endif
+
+#if defined(__linux__) || defined(__gnu_linux__)
+  if (globals.linux_kernel_version < 0x05110000 && globals.linux_kernel_version >= 0x050a0000) {
+    struct statfs statfs_info;
+    if (fstatfs(fd, &statfs_info))
+      return errno;
+    if (statfs_info.f_type == 0xEF53 /* EXT4_SUPER_MAGIC */ && unlikely(fdatasync(fd)))
+      return errno;
+  }
+#endif /* Linux */
+
+  return unlikely(ftruncate(fd, length)) ? errno : MDBX_SUCCESS;
+
+#endif /* !Windows */
 }
 
-MDBX_INTERNAL int osal_fseek(mdbx_filehandle_t fd, uint64_t pos) {
+int osal_fseek(mdbx_filehandle_t fd, uint64_t pos) {
 #if defined(_WIN32) || defined(_WIN64)
   LARGE_INTEGER li;
   li.QuadPart = pos;
@@ -29300,8 +29485,7 @@ MDBX_INTERNAL int osal_fseek(mdbx_filehandle_t fd, uint64_t pos) {
 
 /*----------------------------------------------------------------------------*/
 
-MDBX_INTERNAL int osal_thread_create(osal_thread_t *thread, THREAD_RESULT(THREAD_CALL *start_routine)(void *),
-                                     void *arg) {
+int osal_thread_create(osal_thread_t *thread, THREAD_RESULT(THREAD_CALL *start_routine)(void *), void *arg) {
 #if defined(_WIN32) || defined(_WIN64)
   *thread = CreateThread(nullptr, 0, start_routine, arg, 0, nullptr);
   return *thread ? MDBX_SUCCESS : (int)GetLastError();
@@ -29310,10 +29494,10 @@ MDBX_INTERNAL int osal_thread_create(osal_thread_t *thread, THREAD_RESULT(THREAD
 #endif
 }
 
-MDBX_INTERNAL int osal_thread_join(osal_thread_t thread) {
+int osal_thread_join(osal_thread_t thread) {
 #if defined(_WIN32) || defined(_WIN64)
   DWORD code = WaitForSingleObject(thread, INFINITE);
-  return waitstatus2errcode(code);
+  return osal_waitstatus2errcode(code);
 #else
   void *unused_retval = &unused_retval;
   return pthread_join(thread, &unused_retval);
@@ -29322,7 +29506,7 @@ MDBX_INTERNAL int osal_thread_join(osal_thread_t thread) {
 
 /*----------------------------------------------------------------------------*/
 
-MDBX_INTERNAL int osal_msync(const osal_mmap_t *map, size_t offset, size_t length, enum osal_syncmode_bits mode_bits) {
+int osal_msync(const osal_mmap_t *map, size_t offset, size_t length, enum osal_syncmode_bits mode_bits) {
   if (!MDBX_MMAP_NEEDS_JOLT && mode_bits == MDBX_SYNC_NONE)
     return MDBX_SUCCESS;
 
@@ -29353,7 +29537,7 @@ MDBX_INTERNAL int osal_msync(const osal_mmap_t *map, size_t offset, size_t lengt
   return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL int osal_check_fs_rdonly(mdbx_filehandle_t handle, const pathchar_t *pathname, int err) {
+int osal_check_fs_rdonly(mdbx_filehandle_t handle, const pathchar_t *pathname, int err) {
 #if defined(_WIN32) || defined(_WIN64)
   (void)pathname;
   (void)err;
@@ -29380,7 +29564,7 @@ MDBX_INTERNAL int osal_check_fs_rdonly(mdbx_filehandle_t handle, const pathchar_
   return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL int osal_check_fs_incore(mdbx_filehandle_t handle) {
+int osal_check_fs_incore(mdbx_filehandle_t handle) {
 #if defined(_WIN32) || defined(_WIN64)
   (void)handle;
 #else
@@ -29421,7 +29605,7 @@ MDBX_INTERNAL int osal_check_fs_incore(mdbx_filehandle_t handle) {
   return MDBX_RESULT_FALSE;
 }
 
-MDBX_INTERNAL int osal_check_fs_local(mdbx_filehandle_t handle, int flags) {
+int osal_check_fs_local(mdbx_filehandle_t handle, int flags) {
 #if defined(_WIN32) || defined(_WIN64)
   if (globals.running_under_Wine && !(flags & MDBX_EXCLUSIVE))
     return ERROR_NOT_CAPABLE /* workaround for Wine */;
@@ -29458,7 +29642,7 @@ MDBX_INTERNAL int osal_check_fs_local(mdbx_filehandle_t handle, int flags) {
         return MDBX_EREMOTE;
     } else if (rc != STATUS_OBJECT_NOT_EXTERNALLY_BACKED && rc != STATUS_INVALID_DEVICE_REQUEST &&
                rc != STATUS_NOT_SUPPORTED)
-      return ntstatus2errcode(rc);
+      return osal_ntstatus2errcode(rc);
   }
 
   if (imports.GetVolumeInformationByHandleW && imports.GetFinalPathNameByHandleW) {
@@ -29644,7 +29828,7 @@ MDBX_INTERNAL int osal_check_fs_local(mdbx_filehandle_t handle, int flags) {
 #endif /* ST/MNT_LOCAL */
 
 #ifdef ST_EXPORTED
-  if ((st_flags & ST_EXPORTED) != 0 && !(flags & (MDBX_RDONLY | MDBX_EXCLUSIVE))))
+  if ((st_flags & ST_EXPORTED) != 0 && !(flags & (MDBX_RDONLY | MDBX_EXCLUSIVE)))
     return MDBX_RESULT_TRUE;
 #elif defined(MNT_EXPORTED)
   if ((mnt_flags & MNT_EXPORTED) != 0 && !(flags & (MDBX_RDONLY | MDBX_EXCLUSIVE)))
@@ -29699,8 +29883,8 @@ static int check_mmap_limit(const size_t limit) {
   return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, const size_t limit, const unsigned options,
-                            const pathchar_t *pathname4logging) {
+int osal_mmap(const int flags, osal_mmap_t *map, size_t size, const size_t limit, const unsigned options,
+              const pathchar_t *pathname4logging) {
   assert(size <= limit);
   map->limit = 0;
   map->current = 0;
@@ -29737,9 +29921,9 @@ MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, cons
   if (unlikely(err != MDBX_SUCCESS))
     return err;
 
-  if ((flags & MDBX_RDONLY) == 0 && (options & MMAP_OPTION_TRUNCATE) != 0) {
-    err = osal_ftruncate(map->fd, size);
-    VERBOSE("ftruncate %zu, err %d", size, err);
+  if ((flags & MDBX_RDONLY) == 0 && (options & MMAP_OPTION_SETLENGTH) != 0) {
+    err = osal_fsetsize(map->fd, size);
+    VERBOSE("osal_fsetsize %zu, err %d", size, err);
     if (err != MDBX_SUCCESS)
       return err;
     map->filesize = size;
@@ -29775,7 +29959,7 @@ MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, cons
                         (flags & MDBX_RDONLY) ? PAGE_READONLY : PAGE_READWRITE,
                         /* AllocationAttributes */ SEC_RESERVE, map->fd);
   if (!NT_SUCCESS(err))
-    return ntstatus2errcode(err);
+    return osal_ntstatus2errcode(err);
 
   SIZE_T ViewSize = (flags & MDBX_RDONLY) ? 0 : globals.running_under_Wine ? size : limit;
   err = NtMapViewOfSection(map->section, GetCurrentProcess(), &map->base,
@@ -29790,7 +29974,7 @@ MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, cons
     NtClose(map->section);
     map->section = 0;
     map->base = nullptr;
-    return ntstatus2errcode(err);
+    return osal_ntstatus2errcode(err);
   }
   assert(map->base != MAP_FAILED);
 
@@ -29852,7 +30036,7 @@ MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, cons
   return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL int osal_munmap(osal_mmap_t *map) {
+void osal_munmap(osal_mmap_t *map) {
   VALGRIND_MAKE_MEM_NOACCESS(map->base, map->current);
   /* Unpoisoning is required for ASAN to avoid false-positive diagnostic
    * when this memory will re-used by malloc or another mmapping.
@@ -29860,25 +30044,24 @@ MDBX_INTERNAL int osal_munmap(osal_mmap_t *map) {
   MDBX_ASAN_UNPOISON_MEMORY_REGION(map->base,
                                    (map->filesize && map->filesize < map->limit) ? map->filesize : map->limit);
 #if defined(_WIN32) || defined(_WIN64)
-  if (map->section)
+  if (map->section) {
     NtClose(map->section);
-  NTSTATUS rc = NtUnmapViewOfSection(GetCurrentProcess(), map->base);
-  if (!NT_SUCCESS(rc))
-    ntstatus2errcode(rc);
-#else
-  if (unlikely(munmap(map->base, map->limit))) {
-    assert(errno != 0);
-    return errno;
+    map->section = 0;
   }
+  NTSTATUS err = NtUnmapViewOfSection(GetCurrentProcess(), map->base);
+  if (!NT_SUCCESS(err))
+    ERROR("Unexpected NtUnmapViewOfSection(%p, %zi) error %d", map->base, map->limit, osal_ntstatus2errcode(err));
+#else
+  if (unlikely(munmap(map->base, map->limit)))
+    ERROR("Unexpected munmap(%p, %zi) error %d", map->base, map->limit, errno);
 #endif /* ! Windows */
 
   map->limit = 0;
   map->current = 0;
   map->base = nullptr;
-  return MDBX_SUCCESS;
 }
 
-MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, size_t limit) {
+int osal_mresize(const int flags, osal_mmap_t *map, size_t size, size_t limit) {
   int rc = osal_filesize(map->fd, &map->filesize);
   VERBOSE("flags 0x%x, size %zu, limit %zu, filesize %" PRIu64, flags, size, limit, map->filesize);
   assert(size <= limit);
@@ -29904,7 +30087,7 @@ MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, s
       SectionSize.QuadPart = size;
       status = imports.NtExtendSection(map->section, &SectionSize);
       if (!NT_SUCCESS(status))
-        return ntstatus2errcode(status);
+        return osal_ntstatus2errcode(status);
       map->current = size;
       if (map->filesize < size)
         map->filesize = size;
@@ -29924,11 +30107,11 @@ MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, s
     if (status == (NTSTATUS) /* STATUS_CONFLICTING_ADDRESSES */ 0xC0000018)
       return MDBX_UNABLE_EXTEND_MAPSIZE;
     if (!NT_SUCCESS(status))
-      return ntstatus2errcode(status);
+      return osal_ntstatus2errcode(status);
 
     status = NtFreeVirtualMemory(GetCurrentProcess(), &BaseAddress, &RegionSize, MEM_RELEASE);
     if (!NT_SUCCESS(status))
-      return ntstatus2errcode(status);
+      return osal_ntstatus2errcode(status);
   }
 
   /* Windows unable:
@@ -29948,7 +30131,7 @@ MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, s
   MDBX_ASAN_UNPOISON_MEMORY_REGION(map->base, map->limit);
   status = NtUnmapViewOfSection(GetCurrentProcess(), map->base);
   if (!NT_SUCCESS(status))
-    return ntstatus2errcode(status);
+    return osal_ntstatus2errcode(status);
   status = NtClose(map->section);
   map->section = nullptr;
   PVOID ReservedAddress = nullptr;
@@ -29956,7 +30139,7 @@ MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, s
 
   if (!NT_SUCCESS(status)) {
   bailout_ntstatus:
-    err = ntstatus2errcode(status);
+    err = osal_ntstatus2errcode(status);
     map->base = nullptr;
     map->current = map->limit = 0;
     if (ReservedAddress) {
@@ -29984,7 +30167,7 @@ MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, s
   }
 
   if ((flags & MDBX_RDONLY) == 0 && map->filesize != size) {
-    err = osal_ftruncate(map->fd, size);
+    err = osal_fsetsize(map->fd, size);
     if (err == MDBX_SUCCESS)
       map->filesize = size;
     /* ignore error, because Windows unable shrink file
@@ -30062,10 +30245,15 @@ retry_mapview:;
       rc = MDBX_EPERM;
     map->current = (map->filesize > limit) ? limit : (size_t)map->filesize;
   } else {
-    if (size > map->filesize || (size < map->filesize && (flags & txn_shrink_allowed))) {
-      rc = osal_ftruncate(map->fd, size);
-      VERBOSE("ftruncate %zu, err %d", size, rc);
-      if (rc != MDBX_SUCCESS)
+    if (map->filesize != size) {
+      if (size > map->filesize) {
+        rc = osal_fsetsize(map->fd, size);
+        VERBOSE("osal_fsetsize-%s %zu, err %d", "extend", size, rc);
+      } else if (flags & txn_shrink_allowed) {
+        rc = osal_fsetsize(map->fd, size);
+        VERBOSE("osal_fsetsize-%s %zu, err %d", "shrink", size, rc);
+      }
+      if (unlikely(rc != MDBX_SUCCESS))
         return rc;
       map->filesize = size;
     }
@@ -30252,7 +30440,7 @@ retry_mapview:;
 
 /*----------------------------------------------------------------------------*/
 
-__cold MDBX_INTERNAL void osal_jitter(bool tiny) {
+__cold void osal_jitter(bool tiny) {
   for (;;) {
 #if defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || defined(__x86_64__)
     unsigned salt = 5296013u * (unsigned)__rdtsc();
@@ -30270,7 +30458,7 @@ __cold MDBX_INTERNAL void osal_jitter(bool tiny) {
       break;
 #if defined(_WIN32) || defined(_WIN64)
     if (coin < 43 * 2 / 3)
-      SwitchToThread();
+      osal_yield();
     else {
       static HANDLE timer;
       if (!timer)
@@ -30285,7 +30473,7 @@ __cold MDBX_INTERNAL void osal_jitter(bool tiny) {
       break;
     }
 #else
-    sched_yield();
+    osal_yield();
     if (coin > 43 * 2 / 3)
       usleep(coin);
 #endif
@@ -30321,7 +30509,7 @@ __cold static clockid_t choice_monoclock(void) {
 #define posix_clockid CLOCK_REALTIME
 #endif
 
-MDBX_INTERNAL uint64_t osal_16dot16_to_monotime(uint32_t seconds_16dot16) {
+uint64_t osal_16dot16_to_monotime(uint32_t seconds_16dot16) {
 #if defined(_WIN32) || defined(_WIN64)
   const uint64_t ratio = performance_frequency.QuadPart;
 #elif defined(__APPLE__) || defined(__MACH__)
@@ -30334,7 +30522,7 @@ MDBX_INTERNAL uint64_t osal_16dot16_to_monotime(uint32_t seconds_16dot16) {
 }
 
 static uint64_t monotime_limit;
-MDBX_INTERNAL uint32_t osal_monotime_to_16dot16(uint64_t monotime) {
+uint32_t osal_monotime_to_16dot16(uint64_t monotime) {
   if (unlikely(monotime > monotime_limit))
     return UINT32_MAX;
 
@@ -30349,7 +30537,7 @@ MDBX_INTERNAL uint32_t osal_monotime_to_16dot16(uint64_t monotime) {
   return ret;
 }
 
-MDBX_INTERNAL uint64_t osal_monotime(void) {
+uint64_t osal_monotime(void) {
 #if defined(_WIN32) || defined(_WIN64)
   LARGE_INTEGER counter;
   if (QueryPerformanceCounter(&counter))
@@ -30364,7 +30552,7 @@ MDBX_INTERNAL uint64_t osal_monotime(void) {
   return 0;
 }
 
-MDBX_INTERNAL uint64_t osal_cputime(size_t *optional_page_faults) {
+uint64_t osal_cputime(size_t *optional_page_faults) {
 #if defined(_WIN32) || defined(_WIN64)
   if (optional_page_faults) {
     PROCESS_MEMORY_COUNTERS pmc;
@@ -30843,10 +31031,12 @@ __cold static bin128_t osal_bootid(void) {
           case KSTAT_DATA_UINT32:
             bootid_collect(&uuid, &kn->value, sizeof(int32_t));
             got_boottime = true;
+            break;
           case KSTAT_DATA_INT64:
           case KSTAT_DATA_UINT64:
             bootid_collect(&uuid, &kn->value, sizeof(int64_t));
             got_boottime = true;
+            break;
           }
         }
       }
@@ -31029,7 +31219,7 @@ __cold int mdbx_get_sysraminfo(intptr_t *page_size, intptr_t *total_pages, intpt
 #include <wincrypt.h>
 #endif /* Windows */
 
-MDBX_INTERNAL bin128_t osal_guid(const MDBX_env *env) {
+bin128_t osal_guid(const MDBX_env *env) {
   struct {
     uint64_t begin, end, cputime;
     uintptr_t thread, pid;
@@ -31160,7 +31350,7 @@ void osal_ctor(void) {
 
 void osal_dtor(void) {}
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 __cold int MDBX_PRINTF_ARGS(2, 3) bad_page(const page_t *mp, const char *fmt, ...) {
   if (LOG_ENABLED(MDBX_LOG_ERROR)) {
@@ -31641,7 +31831,7 @@ pgr_t page_get_large(const MDBX_cursor *const mc, const pgno_t pgno, const txnid
   return page_get_inline(P_ILL_BITS | P_BRANCH | P_LEAF | P_DUPFIX, mc, pgno, front);
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 int iov_init(MDBX_txn *const txn, iov_ctx_t *ctx, size_t items, size_t npages, mdbx_filehandle_t fd,
              bool check_coherence) {
@@ -31725,19 +31915,22 @@ static void iov_callback4dirtypages(iov_ctx_t *ctx, size_t offset, void *data, s
 #ifndef MDBX_FORCE_CHECK_MMAP_COHERENCY
 #define MDBX_FORCE_CHECK_MMAP_COHERENCY 0
 #endif /* MDBX_FORCE_CHECK_MMAP_COHERENCY */
-    if ((MDBX_FORCE_CHECK_MMAP_COHERENCY || ctx->coherency_timestamp != UINT64_MAX) &&
-        unlikely(memcmp(wp, rp, bytes))) {
-      ctx->coherency_timestamp = 0;
-      env->lck->pgops.incoherence.weak =
-          (env->lck->pgops.incoherence.weak >= INT32_MAX) ? INT32_MAX : env->lck->pgops.incoherence.weak + 1;
-      WARNING("catch delayed/non-arrived page %" PRIaPGNO " %s", wp->pgno,
-              "(workaround for incoherent flaw of unified page/buffer cache)");
-      do
-        if (coherency_timeout(&ctx->coherency_timestamp, wp->pgno, env) != MDBX_RESULT_TRUE) {
-          ctx->err = MDBX_PROBLEM;
-          break;
-        }
-      while (unlikely(memcmp(wp, rp, bytes)));
+    if ((MDBX_FORCE_CHECK_MMAP_COHERENCY || unlikely(ctx->coherency_timestamp != UINT64_MAX))) {
+      VALGRIND_MAKE_MEM_DEFINED(wp, bytes);
+      MDBX_ASAN_UNPOISON_MEMORY_REGION(wp, bytes);
+      if (unlikely(memcmp(wp, rp, bytes))) {
+        ctx->coherency_timestamp = 0;
+        env->lck->pgops.incoherence.weak =
+            (env->lck->pgops.incoherence.weak >= INT32_MAX) ? INT32_MAX : env->lck->pgops.incoherence.weak + 1;
+        WARNING("catch delayed/non-arrived page %" PRIaPGNO " %s", wp->pgno,
+                "(workaround for incoherent flaw of unified page/buffer cache)");
+        do
+          if (coherency_timeout(&ctx->coherency_timestamp, wp->pgno, env) != MDBX_RESULT_TRUE) {
+            ctx->err = MDBX_PROBLEM;
+            break;
+          }
+        while (unlikely(memcmp(wp, rp, bytes)));
+      }
     }
   }
 
@@ -31824,7 +32017,7 @@ int iov_page(MDBX_txn *txn, iov_ctx_t *ctx, page_t *dp, size_t npages) {
   return MDBX_SUCCESS;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 static inline tree_t *outer_tree(MDBX_cursor *mc) {
   cASSERT(mc, (mc->flags & z_inner) != 0);
@@ -32566,7 +32759,7 @@ size_t page_subleaf2_reserve(const MDBX_env *env, size_t host_page_room, size_t
   return reserve + (subpage_len & 1);
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 pnl_t pnl_alloc(size_t size) {
   size_t bytes = pnl_size2bytes(size);
@@ -32800,7 +32993,7 @@ __hot __noinline size_t pnl_search_nochk(const pnl_t pnl, pgno_t pgno) {
   return it - begin + 1;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 #if MDBX_ENABLE_REFUND
 static void refund_reclaimed(MDBX_txn *txn) {
@@ -33010,7 +33203,7 @@ bool txn_refund(MDBX_txn *txn) {
 
 #endif /* MDBX_ENABLE_REFUND */
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 void spill_remove(MDBX_txn *txn, size_t idx, size_t npages) {
   tASSERT(txn, idx > 0 && idx <= MDBX_PNL_GETSIZE(txn->tw.spilled.list) && txn->tw.spilled.least_removed > 0);
@@ -33439,7 +33632,7 @@ __cold int spill_slowpath(MDBX_txn *const txn, MDBX_cursor *const m0, const intp
              : MDBX_TXN_FULL;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 int tbl_setup(const MDBX_env *env, volatile kvx_t *const kvx, const tree_t *const db) {
   osal_memory_fence(mo_AcquireRelease, false);
@@ -33544,7 +33737,7 @@ int tbl_fetch(MDBX_txn *txn, size_t dbi) {
   return MDBX_SUCCESS;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 typedef struct rthc_entry {
   MDBX_env *env;
@@ -33916,25 +34109,27 @@ __cold static int rthc_drown(MDBX_env *const env) {
   int rc = MDBX_SUCCESS;
   MDBX_env *inprocess_neighbor = nullptr;
   if (likely(env->lck_mmap.lck && current_pid == env->pid)) {
-    reader_slot_t *const begin = &env->lck_mmap.lck->rdt[0];
-    reader_slot_t *const end = &env->lck_mmap.lck->rdt[env->max_readers];
-    TRACE("== %s env %p pid %d, readers %p ...%p, current-pid %d", (current_pid == env->pid) ? "cleanup" : "skip",
-          __Wpedantic_format_voidptr(env), env->pid, __Wpedantic_format_voidptr(begin), __Wpedantic_format_voidptr(end),
-          current_pid);
-    bool cleaned = false;
-    for (reader_slot_t *r = begin; r < end; ++r) {
-      if (atomic_load32(&r->pid, mo_Relaxed) == current_pid) {
-        atomic_store32(&r->pid, 0, mo_AcquireRelease);
-        TRACE("== cleanup %p", __Wpedantic_format_voidptr(r));
-        cleaned = true;
-      }
-    }
-    if (cleaned)
-      atomic_store32(&env->lck_mmap.lck->rdt_refresh_flag, true, mo_Relaxed);
     rc = rthc_uniq_check(&env->lck_mmap, &inprocess_neighbor);
-    if (!inprocess_neighbor && env->registered_reader_pid && env->lck_mmap.fd != INVALID_HANDLE_VALUE) {
-      int err = lck_rpid_clear(env);
-      rc = rc ? rc : err;
+    if (!inprocess_neighbor) {
+      reader_slot_t *const begin = &env->lck_mmap.lck->rdt[0];
+      reader_slot_t *const end = &env->lck_mmap.lck->rdt[env->max_readers];
+      TRACE("== %s env %p pid %d, readers %p ...%p, current-pid %d", (current_pid == env->pid) ? "cleanup" : "skip",
+            __Wpedantic_format_voidptr(env), env->pid, __Wpedantic_format_voidptr(begin),
+            __Wpedantic_format_voidptr(end), current_pid);
+      bool cleaned = false;
+      for (reader_slot_t *r = begin; r < end; ++r) {
+        if (atomic_load32(&r->pid, mo_Relaxed) == current_pid) {
+          atomic_store32(&r->pid, 0, mo_AcquireRelease);
+          TRACE("== cleanup %p", __Wpedantic_format_voidptr(r));
+          cleaned = true;
+        }
+      }
+      if (cleaned)
+        atomic_store32(&env->lck_mmap.lck->rdt_refresh_flag, true, mo_Relaxed);
+      if (env->registered_reader_pid && env->lck_mmap.fd != INVALID_HANDLE_VALUE) {
+        int err = lck_rpid_clear(env);
+        rc = rc ? rc : err;
+      }
     }
   }
   int err = lck_destroy(env, inprocess_neighbor, current_pid);
@@ -34056,7 +34251,9 @@ __cold void rthc_dtor(const uint32_t current_pid) {
     MDBX_env *const env = rthc_table[i].env;
     if (env->pid != current_pid)
       continue;
-    if (!(env->flags & ENV_TXKEY))
+    if (!env->lck_mmap.lck || env->lck_mmap.base == MAP_FAILED)
+      continue;
+    if (!(env->flags & ENV_TXKEY) || !env->lck_mmap.lck)
       continue;
     env->flags -= ENV_TXKEY;
     reader_slot_t *const begin = &env->lck_mmap.lck->rdt[0];
@@ -34095,7 +34292,7 @@ __cold void rthc_dtor(const uint32_t current_pid) {
 /// \copyright SPDX-License-Identifier: Apache-2.0
 /// \note Please refer to the COPYRIGHT file for explanations license change,
 /// credits and acknowledgments.
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 static MDBX_cursor *cursor_clone(const MDBX_cursor *csrc, cursor_couple_t *couple) {
   cASSERT(csrc, csrc->txn->txnid >= csrc->txn->env->lck->cached_oldest.weak);
@@ -34689,8 +34886,8 @@ static int page_merge(MDBX_cursor *csrc, MDBX_cursor *cdst) {
   cASSERT(cdst, cdst->top > 0);
   page_t *const top_page = cdst->pg[cdst->top];
   const indx_t top_indx = cdst->ki[cdst->top];
-  const int save_top = cdst->top;
   const uint16_t save_height = cdst->tree->height;
+  const int save_top = cdst->top;
   cursor_pop(cdst);
   rc = tree_rebalance(cdst);
   if (unlikely(rc != MDBX_SUCCESS))
@@ -34710,9 +34907,10 @@ static int page_merge(MDBX_cursor *csrc, MDBX_cursor *cdst) {
   }
 
   cASSERT(cdst, page_numkeys(top_page) == dst_nkeys + src_nkeys);
-
+  const int new_top = save_top - save_height + cdst->tree->height;
   if (unlikely(pagetype != page_type(top_page))) {
     /* LY: LEAF-page becomes BRANCH, unable restore cursor's stack */
+    ERROR("unexpected top-page type 0x%x, expect 0x%x", page_type(top_page), pagetype);
     goto bailout;
   }
 
@@ -34723,9 +34921,10 @@ static int page_merge(MDBX_cursor *csrc, MDBX_cursor *cdst) {
     return MDBX_SUCCESS;
   }
 
-  const int new_top = save_top - save_height + cdst->tree->height;
   if (unlikely(new_top < 0 || new_top >= cdst->tree->height)) {
     /* LY: out of range, unable restore cursor's stack */
+    ERROR("cursor top-new %i is out of range %u..%u (top-before %i, height-before %i, height-new %i)", new_top, 0,
+          cdst->tree->height, save_top, save_height, cdst->tree->height);
     goto bailout;
   }
 
@@ -34738,10 +34937,7 @@ static int page_merge(MDBX_cursor *csrc, MDBX_cursor *cdst) {
     return MDBX_SUCCESS;
   }
 
-  page_t *const stub_page = (page_t *)(~(uintptr_t)top_page);
-  const indx_t stub_indx = top_indx;
-  if (save_height > cdst->tree->height && ((cdst->pg[save_top] == top_page && cdst->ki[save_top] == top_indx) ||
-                                           (cdst->pg[save_top] == stub_page && cdst->ki[save_top] == stub_indx))) {
+  if (save_height > cdst->tree->height && cdst->pg[save_top] == top_page && cdst->ki[save_top] == top_indx) {
     /* LY: restore cursor stack */
     cdst->pg[new_top] = top_page;
     cdst->ki[new_top] = top_indx;
@@ -34756,7 +34952,12 @@ static int page_merge(MDBX_cursor *csrc, MDBX_cursor *cdst) {
   }
 
 bailout:
-  /* LY: unable restore cursor's stack */
+  ERROR("unable restore %scursor stack after merge; "
+        " new: height %i top %i top-idx %i top-page %p;"
+        " before: height %i top %i, top-indx %i top-page %p",
+        is_inner(cdst) ? "sub-" : "", cdst->tree->height, new_top, cdst->ki[save_top],
+        __Wpedantic_format_voidptr(cdst->pg[save_top]), save_height, save_top, top_indx,
+        __Wpedantic_format_voidptr(top_page));
   be_poor(cdst);
   return MDBX_CURSOR_FULL;
 }
@@ -35091,18 +35292,17 @@ int page_split(MDBX_cursor *mc, const MDBX_val *const newkey, MDBX_val *const ne
 
   cASSERT(mc, !is_branch(mp) || newindx > 0);
   MDBX_val sepkey = {nullptr, 0};
-  /* It is reasonable and possible to split the page at the begin */
+  /* It is reasonable and possible to split the page at the begin? */
   if (unlikely(newindx < minkeys)) {
     split_indx = minkeys;
     if (newindx == 0 && !(naf & MDBX_SPLIT_REPLACE)) {
       split_indx = 0;
-      /* Checking for ability of splitting by the left-side insertion
-       * of a pure page with the new key */
-      for (intptr_t i = 0; i < mc->top; ++i)
+      /* Checking for ability of splitting by the left-side insertion of a pure page with the new key. */
+      for (intptr_t i = mc->top; --i >= 0;)
         if (mc->ki[i]) {
           sepkey = get_key(page_node(mc->pg[i], mc->ki[i]));
-          if (mc->clc->k.cmp(newkey, &sepkey) >= 0)
-            split_indx = minkeys;
+          eASSERT(env, mc->clc->k.cmp(newkey, &sepkey) >= 0);
+          split_indx = minkeys;
           break;
         }
       if (split_indx == 0) {
@@ -35647,7 +35847,7 @@ int tree_propagate_key(MDBX_cursor *mc, const MDBX_val *key) {
 /// \copyright SPDX-License-Identifier: Apache-2.0
 /// \note Please refer to the COPYRIGHT file for explanations license change,
 /// credits and acknowledgments.
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 /* Search for the lowest key under the current branch page.
  * This just bypasses a numkeys check in the current page
@@ -35783,7 +35983,7 @@ __hot __noinline int tree_search_finalize(MDBX_cursor *mc, const MDBX_val *key,
   return MDBX_SUCCESS;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 static inline size_t txl_size2bytes(const size_t size) {
   assert(size > 0 && size <= txl_max * 2);
@@ -35880,7 +36080,7 @@ __hot bool txl_contain(const txl_t txl, txnid_t id) {
   return false;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 __hot txnid_t txn_snapshot_oldest(const MDBX_txn *const txn) {
   return mvcc_shapshot_oldest(txn->env, txn->tw.troika.txnid[txn->tw.troika.prefer_steady]);
@@ -35960,7 +36160,8 @@ void txn_merge(MDBX_txn *const parent, MDBX_txn *const txn, const size_t parent_
                         (parent->parent ? parent->parent->tw.dirtyroom : parent->env->options.dp_limit));
   }
 
-  /* Remove reclaimed pages from parent's dirty list */
+  /* Remove reclaimed pages from parent's dirty list.
+   * Here the nested->tw.repnl was already moved into parent->tw.repnl ans space was reserved via retired_delta. */
   const pnl_t reclaimed_list = parent->tw.repnl;
   dpl_sift(parent, reclaimed_list, false);
 
@@ -36016,6 +36217,7 @@ void txn_merge(MDBX_txn *const parent, MDBX_txn *const txn, const size_t parent_
 
     DEBUG("reclaim retired parent's %u -> %zu %s page %" PRIaPGNO, npages, l, kind, pgno);
     int err = pnl_insert_span(&parent->tw.repnl, pgno, l);
+    /* The space for additions to parent->tw.repnl was already reserverd via the retired_delta. */
     ENSURE(txn->env, err == MDBX_SUCCESS);
   }
   MDBX_PNL_SETSIZE(parent->tw.retired_pages, w);
@@ -36809,6 +37011,9 @@ int txn_end(MDBX_txn *txn, unsigned mode) {
       eASSERT(env, pnl_check_allocated(txn->tw.repnl, txn->geo.first_unallocated - MDBX_ENABLE_REFUND));
       eASSERT(env, memcmp(&txn->tw.troika, &parent->tw.troika, sizeof(troika_t)) == 0);
 
+      if ((mode & TXN_END_UPDATE) == 0)
+        dbi_update(txn, false);
+
       txn->owner = 0;
       if (txn->tw.gc.retxl) {
         eASSERT(env, MDBX_PNL_GETSIZE(txn->tw.gc.retxl) >= (uintptr_t)parent->tw.gc.retxl);
@@ -36961,9 +37166,9 @@ int txn_unpark(MDBX_txn *txn) {
   return err ? err : MDBX_OUSTED;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
-MDBX_MAYBE_UNUSED MDBX_NOTHROW_CONST_FUNCTION MDBX_INTERNAL unsigned log2n_powerof2(size_t value_uintptr) {
+MDBX_MAYBE_UNUSED MDBX_NOTHROW_CONST_FUNCTION unsigned log2n_powerof2(size_t value_uintptr) {
   assert(value_uintptr > 0 && value_uintptr < INT32_MAX && is_powerof2(value_uintptr));
   assert((value_uintptr & -(intptr_t)value_uintptr) == value_uintptr);
   const uint32_t value_uint32 = (uint32_t)value_uintptr;
@@ -36982,7 +37187,7 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_CONST_FUNCTION MDBX_INTERNAL unsigned log2n_power
 #endif
 }
 
-MDBX_NOTHROW_CONST_FUNCTION MDBX_INTERNAL uint64_t rrxmrrxmsx_0(uint64_t v) {
+MDBX_NOTHROW_CONST_FUNCTION uint64_t rrxmrrxmsx_0(uint64_t v) {
   /* Pelle Evensen's mixer, https://bit.ly/2HOfynt */
   v ^= (v << 39 | v >> 25) ^ (v << 14 | v >> 50);
   v *= UINT64_C(0xA24BAED4963EE407);
@@ -36991,7 +37196,7 @@ MDBX_NOTHROW_CONST_FUNCTION MDBX_INTERNAL uint64_t rrxmrrxmsx_0(uint64_t v) {
   return v ^ v >> 28;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 typedef struct walk_ctx {
   void *userctx;
@@ -37279,7 +37484,7 @@ __cold int walk_pages(MDBX_txn *txn, walk_func *visitor, void *user, walk_option
   return rc;
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 #if defined(_WIN32) || defined(_WIN64)
 
@@ -37451,11 +37656,11 @@ __dll_export
     const struct MDBX_version_info mdbx_version = {
         0,
         13,
-        7,
+        12,
         0,
         "", /* pre-release suffix of SemVer
-                                        0.13.7 */
-        {"2025-07-30T11:44:04+03:00", "7777cbdf5aa4c1ce85ff902a4c3e6170edd42495", "566b0f93c7c9a3bdffb8fb3dc0ce8ca42641bd72", "v0.13.7-0-g566b0f93"},
+                                        0.13.12 */
+        {"2026-04-30T16:36:24+03:00", "f5574b87cc64fa7a3a6b21ba33809258498d5f17", "f619d43dfbc36cbc9a1832503ce43f2e5223996e", "v0.13.12-0-gf619d43d"},
         sourcery};
 
 __dll_export
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.c++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.c++
index 27220d53088..b38b6e8bbfc 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.c++
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.c++
@@ -1,8 +1,8 @@
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 /* clang-format off */
 
-#define MDBX_BUILD_SOURCERY 6b5df6869d2bf5419e3a8189d9cc849cc9911b9c8a951b9750ed0a261ce43724_v0_13_7_0_g566b0f93
+#define MDBX_BUILD_SOURCERY a575a490fc080ca11e89ff6db9f0bd38aa830959905998cac0e45274b9e6bb0e_v0_13_12_0_gf619d43d
 
 #define LIBMDBX_INTERNALS
 #define MDBX_DEPRECATED
@@ -1171,6 +1171,14 @@ typedef char pathchar_t;
 #define MDBX_PRIsPATH "s"
 #endif
 
+MDBX_MAYBE_UNUSED static inline bool osal_yield(void) {
+#if defined(_WIN32) || defined(_WIN64)
+  return SleepEx(0, true) == WAIT_IO_COMPLETION;
+#else
+  return sched_yield() != 0;
+#endif
+}
+
 typedef struct osal_mmap {
   union {
     void *base;
@@ -1190,6 +1198,8 @@ typedef struct osal_mmap {
 
 #define MDBX_HAVE_PWRITEV 0
 
+MDBX_INTERNAL int osal_waitstatus2errcode(DWORD result);
+
 #elif defined(__ANDROID_API__)
 
 #if __ANDROID_API__ < 24
@@ -1433,7 +1443,7 @@ enum osal_syncmode_bits {
 };
 
 MDBX_INTERNAL int osal_fsync(mdbx_filehandle_t fd, const enum osal_syncmode_bits mode_bits);
-MDBX_INTERNAL int osal_ftruncate(mdbx_filehandle_t fd, uint64_t length);
+MDBX_INTERNAL int osal_fsetsize(mdbx_filehandle_t fd, const uint64_t length);
 MDBX_INTERNAL int osal_fseek(mdbx_filehandle_t fd, uint64_t pos);
 MDBX_INTERNAL int osal_filesize(mdbx_filehandle_t fd, uint64_t *length);
 
@@ -1469,11 +1479,11 @@ MDBX_INTERNAL int osal_removedirectory(const pathchar_t *pathname);
 MDBX_INTERNAL int osal_is_pipe(mdbx_filehandle_t fd);
 MDBX_INTERNAL int osal_lockfile(mdbx_filehandle_t fd, bool wait);
 
-#define MMAP_OPTION_TRUNCATE 1
+#define MMAP_OPTION_SETLENGTH 1
 #define MMAP_OPTION_SEMAPHORE 2
 MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, const size_t limit, const unsigned options,
                             const pathchar_t *pathname4logging);
-MDBX_INTERNAL int osal_munmap(osal_mmap_t *map);
+MDBX_INTERNAL void osal_munmap(osal_mmap_t *map);
 #define MDBX_MRESIZE_MAY_MOVE 0x00000100
 #define MDBX_MRESIZE_MAY_UNMAP 0x00000200
 MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, size_t limit);
@@ -1876,7 +1886,8 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
     ((defined(_POSIX_THREAD_ROBUST_PRIO_INHERIT) && _POSIX_THREAD_ROBUST_PRIO_INHERIT > 0) ||                          \
      (defined(_POSIX_THREAD_ROBUST_PRIO_PROTECT) && _POSIX_THREAD_ROBUST_PRIO_PROTECT > 0) ||                          \
      defined(PTHREAD_MUTEX_ROBUST) || defined(PTHREAD_MUTEX_ROBUST_NP)) &&                                             \
-    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */)
+    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */) &&                   \
+    !defined(__OHOS__) /* Harmony OS doesn't support robust mutexes at the end of 2025 */
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2008
 #else
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2001
@@ -1931,6 +1942,22 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
 #error MDBX_USE_COPYFILERANGE must be defined as 0 or 1
 #endif /* MDBX_USE_COPYFILERANGE */
 
+/** Advanced: Using posix_fallocate() or fcntl(F_PREALLOCATE) on OSX (autodetection by default). */
+#ifndef MDBX_USE_FALLOCATE
+#if defined(__APPLE__)
+#define MDBX_USE_FALLOCATE 0 /* Too slow and unclean, but not required to prevent SIGBUS */
+#elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || (__GLIBC_PREREQ(2, 10) && defined(_GNU_SOURCE))
+#define MDBX_USE_FALLOCATE 1
+#else
+#define MDBX_USE_FALLOCATE 0
+#endif
+#define MDBX_USE_FALLOCATE_CONFIG "AUTO=" MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#elif !(MDBX_USE_FALLOCATE == 0 || MDBX_USE_FALLOCATE == 1)
+#error MDBX_USE_FALLOCATE must be defined as 0 or 1
+#else
+#define MDBX_USE_FALLOCATE_CONFIG MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#endif /* MDBX_USE_FALLOCATE */
+
 //------------------------------------------------------------------------------
 
 #ifndef MDBX_CPU_WRITEBACK_INCOHERENT
@@ -3212,7 +3239,7 @@ MDBX_NOTHROW_CONST_FUNCTION MDBX_MAYBE_UNUSED static inline pgno_t pgno_sub(size
   return int64pgno((int64_t)base - (int64_t)subtrahend);
 }
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2020-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2020-2026
 ///
 /// \brief Non-inline part of the libmdbx C++ API
 ///
@@ -3641,15 +3668,16 @@ __cold void error::throw_exception() const {
 
 bool slice::is_printable(bool disable_utf8) const noexcept {
   enum : byte {
-    LS = 4,                     // shift for UTF8 sequence length
-    P_ = 1 << LS,               // printable ASCII flag
-    N_ = 0,                     // non-printable ASCII
-    second_range_mask = P_ - 1, // mask for range flag
-    r80_BF = 0,                 // flag for UTF8 2nd byte range
-    rA0_BF = 1,                 // flag for UTF8 2nd byte range
-    r80_9F = 2,                 // flag for UTF8 2nd byte range
-    r90_BF = 3,                 // flag for UTF8 2nd byte range
-    r80_8F = 4,                 // flag for UTF8 2nd byte range
+    LS = 4,                // shift for UTF8 sequence length
+    P_ = 1 << LS,          // printable ASCII flag
+    X_ = 1 << (LS - 1),    // printable extended ASCII flag
+    N_ = 0,                // non-printable ASCII
+    r80_BF = 0,            // flag for UTF8 2nd byte range
+    rA0_BF = 1,            // flag for UTF8 2nd byte range
+    r80_9F = 2,            // flag for UTF8 2nd byte range
+    r90_BF = 3,            // flag for UTF8 2nd byte range
+    r80_8F = 4,            // flag for UTF8 2nd byte range
+    second_range_mask = 7, // mask for range flag
 
     // valid utf-8 byte sequences
     // http://www.unicode.org/versions/Unicode6.0.0/ch03.pdf - page 94
@@ -3679,14 +3707,14 @@ bool slice::is_printable(bool disable_utf8) const noexcept {
       P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, // 50
       P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, // 60
       P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, N_, // 70
-      N_, N_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, N_, P_, N_, // 80
-      N_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, N_, P_, P_, // 90
-      P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, // a0
-      P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, // b0
-      P_, P_, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, // c0
+      N_, N_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, N_, X_, N_, // 80
+      N_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, N_, X_, X_, // 90
+      X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, // a0
+      X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, // b0
+      X_, X_, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, // c0
       C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, // df
       E0, E1, E1, E1, E1, E1, E1, E1, E1, E1, E1, E1, E1, ED, EE, EE, // e0
-      F0, F1, F1, F1, F4, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_, P_  // f0
+      F0, F1, F1, F1, F4, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_, X_  // f0
   };
 
   if (MDBX_UNLIKELY(length() < 1))
@@ -3696,7 +3724,7 @@ bool slice::is_printable(bool disable_utf8) const noexcept {
   const auto end = src + length();
   if (MDBX_UNLIKELY(disable_utf8)) {
     do
-      if (MDBX_UNLIKELY((P_ & map[*src]) == 0))
+      if (MDBX_UNLIKELY(((P_ | X_) & map[*src]) == 0))
         MDBX_CXX20_UNLIKELY return false;
     while (++src < end);
     return true;
@@ -4387,11 +4415,11 @@ bool from_base64::is_erroneous() const noexcept {
 #pragma warning(disable : 4251)
 #endif /* MSVC */
 
-MDBX_INSTALL_API_TEMPLATE(LIBMDBX_API_TYPE, buffer<legacy_allocator>);
+MDBX_INSTALL_API_TEMPLATE(LIBMDBX_API_TYPE, buffer<legacy_allocator, default_capacity_policy>);
 
-#if defined(__cpp_lib_memory_resource) && __cpp_lib_memory_resource >= 201603L && _GLIBCXX_USE_CXX11_ABI
-MDBX_INSTALL_API_TEMPLATE(LIBMDBX_API_TYPE, buffer<polymorphic_allocator>);
-#endif /* __cpp_lib_memory_resource >= 201603L */
+#if MDBX_CXX_HAS_POLYMORPHIC_ALLOCATOR
+MDBX_INSTALL_API_TEMPLATE(LIBMDBX_API_TYPE, buffer<polymorphic_allocator, default_capacity_policy>);
+#endif /* MDBX_CXX_HAS_POLYMORPHIC_ALLOCATOR */
 
 #if defined(_MSC_VER)
 #pragma warning(pop)
@@ -4524,12 +4552,12 @@ __cold env &env::copy(const MDBX_STD_FILESYSTEM_PATH &destination, bool compacti
 
 __cold path env::get_path() const {
 #if defined(_WIN32) || defined(_WIN64)
-  const wchar_t *c_wstr;
+  const wchar_t *c_wstr = nullptr;
   error::success_or_throw(::mdbx_env_get_pathW(handle_, &c_wstr));
   static_assert(sizeof(path::value_type) == sizeof(wchar_t), "Oops");
   return path(c_wstr);
 #else
-  const char *c_str;
+  const char *c_str = nullptr;
   error::success_or_throw(::mdbx_env_get_path(handle_, &c_str));
   static_assert(sizeof(path::value_type) == sizeof(char), "Oops");
   return path(c_str);
@@ -4825,13 +4853,13 @@ __cold ::std::ostream &operator<<(::std::ostream &out, const slice &it) {
   else if (it.empty())
     out << "EMPTY->" << it.data();
   else {
-    const slice root(it.head(std::min(it.length(), size_t(64))));
+    const slice head(it.head(std::min(it.length(), size_t(64))));
     out << it.length() << ".";
-    if (root.is_printable())
-      (out << "\"").write(root.char_ptr(), root.length()) << "\"";
+    if (head.is_printable())
+      (out << "\"").write(head.char_ptr(), head.length()) << "\"";
     else
-      out << root.encode_base58();
-    if (root.length() < it.length())
+      out << to_hex(head);
+    if (head.length() < it.length())
       out << "...";
   }
   return out << "}";
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.h b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.h
index 90835d1b9e9..4e26f369c8c 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.h
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.h
@@ -1,6 +1,9 @@
 /**
 
-_libmdbx_ (aka MDBX) is an extremely fast, compact, powerful, embeddable,
+\file mdbx.h
+\brief The libmdbx C API header file.
+
+\details _libmdbx_ (aka MDBX) is an extremely fast, compact, powerful, embeddable,
 transactional [key-value
 store](https://en.wikipedia.org/wiki/Key-value_database), with [Apache 2.0
 license](./LICENSE). _MDBX_ has a specific set of properties and capabilities,
@@ -9,7 +12,7 @@ focused on creating unique lightweight solutions with extraordinary performance.
 _libmdbx_ is superior to [LMDB](https://bit.ly/26ts7tL) in terms of features
 and reliability, not inferior in performance. In comparison to LMDB, _libmdbx_
 makes many things just work perfectly, not silently and catastrophically
-break down. _libmdbx_ supports Linux, Windows, MacOS, OSX, iOS, Android,
+break down. _libmdbx_ supports Linux, Windows, MacOS, OSX, Harmony, iOS, Android,
 FreeBSD, DragonFly, Solaris, OpenSolaris, OpenIndiana, NetBSD, OpenBSD and other
 systems compliant with POSIX.1-2008.
 
@@ -18,24 +21,36 @@ C++ API description and links to the origin git repo with the source code.
 Questions, feedback and suggestions are welcome to the Telegram' group
 https://t.me/libmdbx.
 
-Donations are welcome to ETH `0xD104d8f8B2dC312aaD74899F83EBf3EEBDC1EA3A`.
+Donations are welcome to ETH `0xD104d8f8B2dC312aaD74899F83EBf3EEBDC1EA3A`,
+BTC `bc1qzvl9uegf2ea6cwlytnanrscyv8snwsvrc0xfsu`, SOL `FTCTgbHajoLVZGr8aEFWMzx3NDMyS5wXJgfeMTmJznRi`.
 Всё будет хорошо!
 
-\note The origin has been migrated to
-[GitFlic](https://gitflic.ru/project/erthink/libmdbx) since on 2022-04-15 the
-Github administration, without any warning nor explanation, deleted libmdbx
-along with a lot of other projects, simultaneously blocking access for many
-developers. For the same reason ~~Github~~ is blacklisted forever.
+The _libmdbx_ project has been completely relocated to the jurisdiction of the Russian Federation.
+\note _libmdbx_ is still open and provided with first-class free support.
 
 \section copyright LICENSE & COPYRIGHT
 \copyright SPDX-License-Identifier: Apache-2.0
-\note Please refer to the COPYRIGHT file for explanations license change,
-credits and acknowledgments.
-\author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+Please refer to the COPYRIGHT file for explanations license change, credits and acknowledgments.
+\author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
 *******************************************************************************/
 
 #pragma once
+/*
+ * Tested with, since 2026:
+ *  - Elbrus LCC >= 1.28 (http://www.mcst.ru/lcc);
+ *  - GNU C >= 11.3;
+ *  - CLANG >= 14.0;
+ *  - MSVC >= 19.44 (Visual Studio 2022 toolchain v143),
+ * before 2026:
+ *  - Elbrus LCC >= 1.23 (http://www.mcst.ru/lcc);
+ *  - GNU C >= 4.8;
+ *  - CLANG >= 3.9;
+ *  - MSVC >= 14.0 (Visual Studio 2015),
+ *    but 19.2x could hang due optimizer bug;
+ *  - AppleClang.
+ */
+
 #ifndef LIBMDBX_H
 #define LIBMDBX_H
 
@@ -2525,8 +2540,7 @@ typedef enum MDBX_env_delete_mode {
   /** \brief Make sure that the environment is not being used by other
    * processes, or return an error otherwise. */
   MDBX_ENV_ENSURE_UNUSED = 1,
-  /** \brief Wait until other processes closes the environment before deletion.
-   */
+  /** \brief Wait until other processes closes the environment before deletion. */
   MDBX_ENV_WAIT_FOR_UNUSED = 2,
 } MDBX_env_delete_mode_t;
 
@@ -4992,7 +5006,7 @@ LIBMDBX_API int mdbx_get_equal_or_great(const MDBX_txn *txn, MDBX_dbi dbi, MDBX_
  * \retval MDBX_EINVAL    An invalid parameter was specified. */
 LIBMDBX_API int mdbx_put(MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *key, MDBX_val *data, MDBX_put_flags_t flags);
 
-/** \brief Replace items in a table.
+/** \brief Replaces item in a table.
  * \ingroup c_crud
  *
  * This function allows to update or delete an existing value at the same time
@@ -5032,13 +5046,70 @@ LIBMDBX_API int mdbx_put(MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *key, MDBX_
  *                           combination for selection particular item from
  *                           multi-value/duplicates.
  *
+ * \see mdbx_replace_ex()
  * \see \ref c_crud_hints "Quick reference for Insert/Update/Delete operations"
  *
  * \returns A non-zero error value on failure and 0 on success. */
 LIBMDBX_API int mdbx_replace(MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *key, MDBX_val *new_data, MDBX_val *old_data,
                              MDBX_put_flags_t flags);
 
+/** \brief A data preservation callback for using within \ref mdbx_replace_ex().
+ * \ingroup c_crud */
 typedef int (*MDBX_preserve_func)(void *context, MDBX_val *target, const void *src, size_t bytes);
+
+/** \brief Replaces item in a table using preservation callback for an original data.
+ * \ingroup c_crud
+ *
+ * This function allows to update or delete an existing value at the same time
+ * as the previous value is retrieved. If the argument new_data equal is NULL
+ * zero, the removal is performed, otherwise the update/insert.
+ *
+ * The current value may be in an already changed (aka dirty) page. In this
+ * case, the page will be overwritten during the update, and the old value will
+ * be lost. In such cases, the given preservation callback will be used to save
+ * the source data, that, at your discretion, can perform copying, other necessary
+ * actions, or return a special error code.
+ *
+ * If an original data needs to be saved then the passed preservation callback will be called
+ * with `old_data` as a `target` parameter, and `src` with `bytes` for original data.
+ * Such callback should check necessary conditions, perform appropriate action and return
+ * corresponding error code, which will be returned from function as is.
+ * For example, for behavior similar to \ref mdbx_replace(), the callback should check if there
+ * provided buffer size is enough, then either copy the data or return \ref MDBX_RESULT_TRUE.
+ *
+ * For tables with non-unique keys (i.e. with \ref MDBX_DUPSORT flag),
+ * another use case is also possible, when by old_data argument selects a
+ * specific item from multi-value/duplicates with the same key for deletion or
+ * update. To select this scenario in flags should simultaneously specify
+ * \ref MDBX_CURRENT and \ref MDBX_NOOVERWRITE. This combination is chosen
+ * because it makes no sense, and thus allows you to identify the request of
+ * such a scenario.
+ *
+ * \param [in] txn           A transaction handle returned
+ *                           by \ref mdbx_txn_begin().
+ * \param [in] dbi           A table handle returned by \ref mdbx_dbi_open().
+ * \param [in] key           The key to store in the table.
+ * \param [in] new_data      The data to store, if NULL then deletion will
+ *                           be performed.
+ * \param [in,out] old_data  The buffer for retrieve previous value as describe
+ *                           above.
+ * \param [in] flags         Special options for this operation.
+ *                           This parameter must be set to 0 or by bitwise
+ *                           OR'ing together one or more of the values
+ *                           described in \ref mdbx_put() description above,
+ *                           and additionally
+ *                           (\ref MDBX_CURRENT | \ref MDBX_NOOVERWRITE)
+ *                           combination for selection particular item from
+ *                           multi-value/duplicates.
+ * \param [in] preserver     The callback to preserve an original data in case
+ *                           it is on a dirty page and could be overwritten.
+ * \param [in] preserver_context The optional context pointer for use within the preserving callback.
+ *
+ * \see mdbx_replace_ex()
+ * \see MDBX_preserve_func
+ * \see \ref c_crud_hints "Quick reference for Insert/Update/Delete operations"
+ *
+ * \returns A non-zero error value on failure and 0 on success. */
 LIBMDBX_API int mdbx_replace_ex(MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *key, MDBX_val *new_data,
                                 MDBX_val *old_data, MDBX_put_flags_t flags, MDBX_preserve_func preserver,
                                 void *preserver_context);
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.h++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.h++
index 2d5f62b17d5..4f13dfd28cd 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.h++
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx.h++
@@ -1,31 +1,45 @@
-/// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2020-2025
+/// \file mdbx.h++
+/// \brief The libmdbx C++ API header file.
 ///
-/// Donations are welcome to ETH `0xD104d8f8B2dC312aaD74899F83EBf3EEBDC1EA3A`.
-/// Всё будет хорошо!
+/// \details _libmdbx_ (aka MDBX) is an extremely fast, compact, powerful, embeddable,
+/// transactional [key-value
+/// store](https://en.wikipedia.org/wiki/Key-value_database), with [Apache 2.0
+/// license](./LICENSE). _MDBX_ has a specific set of properties and capabilities,
+/// focused on creating unique lightweight solutions with extraordinary performance.
 ///
-/// \file mdbx.h++
-/// \brief The libmdbx C++ API header file.
+/// Please visit https://libmdbx.dqdkfa.ru for more information, documentation,
+/// C++ API description and links to the origin git repo with the source code.
+/// Questions, feedback and suggestions are welcome to the Telegram' group
+/// https://t.me/libmdbx.
 ///
-/// Tested with:
-///  - Elbrus LCC >= 1.23 (http://www.mcst.ru/lcc);
-///  - GNU C++ >= 4.8;
-///  - clang >= 3.9;
-///  - MSVC >= 14.0 (Visual Studio 2015),
-///    but 19.2x could hang due optimizer bug;
-///  - AppleClang, but without C++20 concepts.
+/// Donations are welcome to ETH `0xD104d8f8B2dC312aaD74899F83EBf3EEBDC1EA3A`,
+/// BTC `bc1qzvl9uegf2ea6cwlytnanrscyv8snwsvrc0xfsu`, SOL `FTCTgbHajoLVZGr8aEFWMzx3NDMyS5wXJgfeMTmJznRi`.
+/// Всё будет хорошо!
 ///
-
+/// The libmdbx project has been completely relocated to the jurisdiction of the Russian Federation.
+/// \note _libmdbx_ is still open and provided with first-class free support.
 ///
-/// The origin has been migrated to https://gitflic.ru/project/erthink/libmdbx
-/// since on 2022-04-15 the Github administration, without any warning nor
-/// explanation, deleted libmdbx along with a lot of other projects,
-/// simultaneously blocking access for many developers.
-/// For the same reason Github is blacklisted forever.
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2020-2026
 ///
 
 #pragma once
 
+//
+// Tested with, since 2026:
+//  - Elbrus LCC >= 1.28 (http://www.mcst.ru/lcc);
+//  - GNU C++ >= 11.3;
+//  - CLANG >= 14.0;
+//  - MSVC >= 19.44 (Visual Studio 2022 toolchain v143),
+// before 2026:
+//  - Elbrus LCC >= 1.23 (http://www.mcst.ru/lcc);
+//  - GNU C++ >= 4.8;
+//  - CLANG >= 3.9;
+//  - MSVC >= 14.0 (Visual Studio 2015),
+//    but 19.2x could hang due optimizer bug;
+//  - AppleClang, but without C++20 concepts.
+//
+
 /* Workaround for modern libstdc++ with CLANG < 4.x */
 #if defined(__SIZEOF_INT128__) && !defined(__GLIBCXX_TYPE_INT_N_0) && defined(__clang__) && __clang_major__ < 4
 #define __GLIBCXX_BITSIZE_INT_N_0 128
@@ -108,13 +122,11 @@
 #endif
 
 #if !defined(_MSC_VER) || defined(__clang__)
-/* adequate compilers */
-#define MDBX_EXTERN_API_TEMPLATE(API_ATTRIBUTES, API_TYPENAME) extern template class API_ATTRIBUTES API_TYPENAME
-#define MDBX_INSTALL_API_TEMPLATE(API_ATTRIBUTES, API_TYPENAME) template class API_TYPENAME
+#define MDBX_EXTERN_API_TEMPLATE(API_ATTRIBUTES, ...) extern template class API_ATTRIBUTES __VA_ARGS__
+#define MDBX_INSTALL_API_TEMPLATE(API_ATTRIBUTES, ...) template class __VA_ARGS__
 #else
-/* stupid microsoft showing off */
-#define MDBX_EXTERN_API_TEMPLATE(API_ATTRIBUTES, API_TYPENAME) extern template class API_TYPENAME
-#define MDBX_INSTALL_API_TEMPLATE(API_ATTRIBUTES, API_TYPENAME) template class API_ATTRIBUTES API_TYPENAME
+#define MDBX_EXTERN_API_TEMPLATE(API_ATTRIBUTES, ...) extern template class __VA_ARGS__
+#define MDBX_INSTALL_API_TEMPLATE(API_ATTRIBUTES, ...) template class API_ATTRIBUTES __VA_ARGS__
 #endif
 
 #if __cplusplus >= 201103L
@@ -307,18 +319,27 @@ namespace mdbx {
 /// \defgroup cxx_api C++ API
 /// @{
 
-// Functions whose signature depends on the `mdbx::byte` type
-// must be strictly defined as inline!
+/// \brief The byte-like type that don't presumes aliases for pointers as does the `char`.
+/// \details Essentially, to enable all kinds of an compiler optimization, we need just
+/// the `unsigned char * restrict` type in C99 terms, i.e. the non-aliasing pointer to `unsigned char`.
+/// However, C++ still doesn't have `restrict` keyword not `non-aliases` type attribute, but a char-pointers may be
+/// aliased.
+///
+/// On the other hand, while `uint8_t` is provided and `CHAR_BIT = 8` the `char8_t *` actually act the same as the C99
+/// `unsigned char * restrict`. So using `char8_t` should not be an issue, since both the `CHAR_BIT = 8` and `uint8_t
+/// `are required.
+///
+/// At the same time, the approach of using `char8_t` has several advantages:
+///  - the `restrict` attribute is defined on level of the base type and is inherited by any derived pointer type;
+///  - some compilers treat `__restrict` as an attribute of an instance of a type (i.e. a variable, a specific
+///    pointer), but not a type attribute.
+///
+/// Nonetheless, I should think about switching to the `uint8_t * __restrict__` for byte pointers.
+/// \note Functions whose signature depends on the `mdbx::byte` type must be strictly defined as inline!
 #if defined(DOXYGEN) || (defined(__cpp_char8_t) && __cpp_char8_t >= 201811)
-// To enable all kinds of an compiler optimizations we use a byte-like type
-// that don't presumes aliases for pointers as does the `char` type and its
-// derivatives/typedefs.
-// Please see https://libmdbx.dqdkfa.ru/dead-github/issues/263
-// for reasoning of the use of `char8_t` type and switching to `__restrict__`.
 using byte = char8_t;
 #else
-// Avoid `std::byte` since it doesn't add features but inconvenient
-// restrictions.
+// Avoid `std::byte` since it doesn't add features but inconvenient restrictions.
 using byte = unsigned char;
 #endif /* __cpp_char8_t >= 201811*/
 
@@ -351,14 +372,22 @@ static MDBX_CXX20_CONSTEXPR int memcmp(const void *a, const void *b, size_t byte
 /// but it is recommended to use \ref polymorphic_allocator.
 using legacy_allocator = ::std::string::allocator_type;
 
-#if defined(DOXYGEN) ||                                                                                                \
-    (defined(__cpp_lib_memory_resource) && __cpp_lib_memory_resource >= 201603L && _GLIBCXX_USE_CXX11_ABI)
+#ifndef MDBX_CXX_POLYMORPHIC_ALLOCATOR
+#if defined(DOXYGEN) || (defined(__cpp_lib_memory_resource) && __cpp_lib_memory_resource >= 201603L &&                 \
+                         (!defined(_GLIBCXX_USE_CXX11_ABI) || _GLIBCXX_USE_CXX11_ABI))
+#define MDBX_CXX_HAS_POLYMORPHIC_ALLOCATOR 1
+#else
+#define MDBX_CXX_HAS_POLYMORPHIC_ALLOCATOR 0
+#endif
+#endif /* MDBX_CXX_HAS_POLYMORPHIC_ALLOCATOR */
+
+#if MDBX_CXX_HAS_POLYMORPHIC_ALLOCATOR
 /// \brief Default polymorphic allocator for modern code.
 using polymorphic_allocator = ::std::pmr::string::allocator_type;
 using default_allocator = polymorphic_allocator;
 #else
 using default_allocator = legacy_allocator;
-#endif /* __cpp_lib_memory_resource >= 201603L */
+#endif /* MDBX_CXX_HAS_POLYMORPHIC_ALLOCATOR */
 
 struct slice;
 struct default_capacity_policy;
@@ -641,7 +670,7 @@ struct LIBMDBX_API_TYPE slice : public ::MDBX_val {
   /// \todo key-to-value (parse/unpack) functions
   /// \todo template<class X> key(X); for decoding keys while reading
 
-  enum { max_length = MDBX_MAXDATASIZE };
+  enum : size_t { max_length = MDBX_MAXDATASIZE };
 
   /// \brief Create an empty slice.
   MDBX_CXX11_CONSTEXPR slice() noexcept;
@@ -852,8 +881,6 @@ struct LIBMDBX_API_TYPE slice : public ::MDBX_val {
   /// break a code group of characters.
   MDBX_NOTHROW_PURE_FUNCTION inline bool is_base64(bool ignore_spaces = false) const noexcept;
 
-  inline void swap(slice &other) noexcept;
-
 #if defined(DOXYGEN) || (defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L)
   template <class CHAR, class T> void swap(::std::basic_string_view<CHAR, T> &view) noexcept {
     static_assert(sizeof(CHAR) == 1, "Must be single byte characters");
@@ -1002,7 +1029,12 @@ struct LIBMDBX_API_TYPE slice : public ::MDBX_val {
   MDBX_CXX11_CONSTEXPR bool is_valid() const noexcept { return !(iov_base == nullptr && iov_len != 0); }
 
   /// \brief Build an invalid slice which non-zero length and refers to null address.
-  MDBX_CXX14_CONSTEXPR static slice invalid() noexcept { return slice(size_t(-1)); }
+  MDBX_CXX14_CONSTEXPR static slice invalid() noexcept {
+    return slice(/* using special constructor without length checking */ ~size_t(0));
+  }
+
+  /// \brief Build a null slice which zero length and refers to null address.
+  MDBX_CXX14_CONSTEXPR static slice null() noexcept { return slice(nullptr, size_t(0)); }
 
   template <typename POD> MDBX_CXX14_CONSTEXPR POD as_pod() const {
     static_assert(::std::is_standard_layout<POD>::value && !::std::is_pointer<POD>::value,
@@ -1073,11 +1105,7 @@ template <typename T, typename A> struct move_assign_alloc<T, A, false> {
   static MDBX_CXX20_CONSTEXPR bool is_moveable(T *target, T &source) noexcept {
     return allocator_is_always_equal<A>() || target->get_allocator() == source.get_allocator();
   }
-  static MDBX_CXX20_CONSTEXPR void propagate(T *target, T &source) noexcept {
-    assert(target->get_allocator() != source.get_allocator());
-    (void)target;
-    (void)source;
-  }
+  static MDBX_CXX20_CONSTEXPR void propagate(T *, T &) noexcept {}
 };
 
 template <typename T, typename A> struct move_assign_alloc<T, A, true> {
@@ -1085,8 +1113,7 @@ template <typename T, typename A> struct move_assign_alloc<T, A, true> {
     return allocator_is_always_equal<A>() || ::std::is_nothrow_move_assignable<A>::value;
   }
   static constexpr bool is_moveable(T *, T &) noexcept { return true; }
-  static MDBX_CXX20_CONSTEXPR void propagate(T *target, T &source) {
-    assert(target->get_allocator() != source.get_allocator());
+  static MDBX_CXX20_CONSTEXPR void propagate(T *target, T &source) noexcept {
     target->get_allocator() = ::std::move(source.get_allocator());
   }
 };
@@ -1097,11 +1124,7 @@ struct copy_assign_alloc;
 
 template <typename T, typename A> struct copy_assign_alloc<T, A, false> {
   static constexpr bool is_nothrow() noexcept { return false; }
-  static MDBX_CXX20_CONSTEXPR void propagate(T *target, const T &source) noexcept {
-    assert(target->get_allocator() != source.get_allocator());
-    (void)target;
-    (void)source;
-  }
+  static MDBX_CXX20_CONSTEXPR void propagate(T *, const T &) noexcept {}
 };
 
 template <typename T, typename A> struct copy_assign_alloc<T, A, true> {
@@ -1127,14 +1150,14 @@ struct swap_alloc;
 
 template <typename T, typename A> struct swap_alloc<T, A, false> {
   static constexpr bool is_nothrow() noexcept { return allocator_is_always_equal<A>(); }
-  static MDBX_CXX20_CONSTEXPR void propagate(T *target, T &source) noexcept(is_nothrow()) {
+  static MDBX_CXX20_CONSTEXPR void propagate(T &left, T &right) noexcept(is_nothrow()) {
     if MDBX_IF_CONSTEXPR (!allocator_is_always_equal<A>()) {
-      if (MDBX_UNLIKELY(target->get_allocator() != source.get_allocator()))
+      if (MDBX_UNLIKELY(left.get_allocator() != right.get_allocator()))
         MDBX_CXX20_UNLIKELY throw_allocators_mismatch();
     } else {
       /* gag for buggy compilers */
-      (void)target;
-      (void)source;
+      (void)left;
+      (void)right;
     }
   }
 };
@@ -1147,14 +1170,14 @@ template <typename T, typename A> struct swap_alloc<T, A, true> {
 #endif /* __cpp_lib_is_swappable >= 201603L */
            (::std::is_nothrow_move_constructible<A>::value && ::std::is_nothrow_move_assignable<A>::value);
   }
-  static MDBX_CXX20_CONSTEXPR void propagate(T *target, T &source) noexcept(is_nothrow()) {
+  static MDBX_CXX20_CONSTEXPR void propagate(T &left, T &right) noexcept(is_nothrow()) {
     if MDBX_IF_CONSTEXPR (!allocator_is_always_equal<A>()) {
-      if (MDBX_UNLIKELY(target->get_allocator() != source.get_allocator()))
-        MDBX_CXX20_UNLIKELY ::std::swap(*target, source);
+      if (MDBX_UNLIKELY(left.get_allocator() != right.get_allocator()))
+        MDBX_CXX20_UNLIKELY ::std::swap(left.get_allocator(), right.get_allocator());
     } else {
       /* gag for buggy compilers */
-      (void)target;
-      (void)source;
+      (void)left;
+      (void)right;
     }
   }
 };
@@ -1177,9 +1200,13 @@ struct default_capacity_policy {
     return (value + pettiness_threshold - 1) & pettiness_mask;
   }
 
-  static MDBX_CXX11_CONSTEXPR size_t advise(const size_t current, const size_t wanna) {
+  static MDBX_CXX11_CONSTEXPR size_t advise(const size_t current, const size_t wanna, const size_t inplace) {
     static_assert(max_reserve % pettiness_threshold == 0, "max_reserve must be a multiple of pettiness_threshold");
     static_assert(max_reserve / 3 > pettiness_threshold, "max_reserve must be > pettiness_threshold * 3");
+
+    if (wanna <= inplace && (current <= inplace || current >= std::max(inplace + inplace, size_t(pettiness_threshold))))
+      return inplace;
+
     if (wanna > current)
       /* doubling capacity, but don't made reserve more than max_reserve */
       return round(wanna + ::std::min(size_t(max_reserve), current));
@@ -1214,7 +1241,7 @@ struct LIBMDBX_API to_hex {
   /// \brief Returns a buffer with a hexadecimal dump of a passed slice.
   template <class ALLOCATOR = default_allocator, typename CAPACITY_POLICY = default_capacity_policy>
   buffer<ALLOCATOR, CAPACITY_POLICY> as_buffer(const ALLOCATOR &allocator = ALLOCATOR()) const {
-    return make_buffer<ALLOCATOR>(*this, allocator);
+    return make_buffer<ALLOCATOR, CAPACITY_POLICY>(*this, allocator);
   }
 
   /// \brief Returns the buffer size in bytes needed for hexadecimal
@@ -1262,7 +1289,7 @@ struct LIBMDBX_API to_base58 {
   /// [Base58](https://en.wikipedia.org/wiki/Base58) dump of a passed slice.
   template <class ALLOCATOR = default_allocator, typename CAPACITY_POLICY = default_capacity_policy>
   buffer<ALLOCATOR, CAPACITY_POLICY> as_buffer(const ALLOCATOR &allocator = ALLOCATOR()) const {
-    return make_buffer<ALLOCATOR>(*this, allocator);
+    return make_buffer<ALLOCATOR, CAPACITY_POLICY>(*this, allocator);
   }
 
   /// \brief Returns the buffer size in bytes needed for
@@ -1308,7 +1335,7 @@ struct LIBMDBX_API to_base64 {
   /// [Base64](https://en.wikipedia.org/wiki/Base64) dump of a passed slice.
   template <class ALLOCATOR = default_allocator, typename CAPACITY_POLICY = default_capacity_policy>
   buffer<ALLOCATOR, CAPACITY_POLICY> as_buffer(const ALLOCATOR &allocator = ALLOCATOR()) const {
-    return make_buffer<ALLOCATOR>(*this, allocator);
+    return make_buffer<ALLOCATOR, CAPACITY_POLICY>(*this, allocator);
   }
 
   /// \brief Returns the buffer size in bytes needed for
@@ -1359,7 +1386,7 @@ struct LIBMDBX_API from_hex {
   /// \brief Decodes hexadecimal dump from a passed slice to returned buffer.
   template <class ALLOCATOR = default_allocator, typename CAPACITY_POLICY = default_capacity_policy>
   buffer<ALLOCATOR, CAPACITY_POLICY> as_buffer(const ALLOCATOR &allocator = ALLOCATOR()) const {
-    return make_buffer<ALLOCATOR>(*this, allocator);
+    return make_buffer<ALLOCATOR, CAPACITY_POLICY>(*this, allocator);
   }
 
   /// \brief Returns the number of bytes needed for conversion
@@ -1399,7 +1426,7 @@ struct LIBMDBX_API from_base58 {
   /// passed slice to returned buffer.
   template <class ALLOCATOR = default_allocator, typename CAPACITY_POLICY = default_capacity_policy>
   buffer<ALLOCATOR, CAPACITY_POLICY> as_buffer(const ALLOCATOR &allocator = ALLOCATOR()) const {
-    return make_buffer<ALLOCATOR>(*this, allocator);
+    return make_buffer<ALLOCATOR, CAPACITY_POLICY>(*this, allocator);
   }
 
   /// \brief Returns the number of bytes needed for conversion
@@ -1442,7 +1469,7 @@ struct LIBMDBX_API from_base64 {
   /// passed slice to returned buffer.
   template <class ALLOCATOR = default_allocator, typename CAPACITY_POLICY = default_capacity_policy>
   buffer<ALLOCATOR, CAPACITY_POLICY> as_buffer(const ALLOCATOR &allocator = ALLOCATOR()) const {
-    return make_buffer<ALLOCATOR>(*this, allocator);
+    return make_buffer<ALLOCATOR, CAPACITY_POLICY>(*this, allocator);
   }
 
   /// \brief Returns the number of bytes needed for conversion
@@ -1487,7 +1514,6 @@ public:
 
 private:
   friend class txn;
-  using swap_alloc = allocation_aware_details::swap_alloc<struct silo, allocator_type>;
   struct silo /* Empty Base Class Optimization */ : public allocator_type {
     MDBX_CXX20_CONSTEXPR const allocator_type &get_allocator() const noexcept { return *this; }
     MDBX_CXX20_CONSTEXPR allocator_type &get_allocator() noexcept { return *this; }
@@ -1503,12 +1529,19 @@ private:
       const size_t n = (bytes + unit - 1) / unit;
       return ::std::make_pair(allocator_traits::allocate(get_allocator(), n), n * unit);
     }
+
     MDBX_CXX20_CONSTEXPR void deallocate_storage(allocator_pointer ptr, size_t bytes) {
       constexpr size_t unit = sizeof(typename allocator_type::value_type);
       assert(ptr && bytes >= sizeof(bin) && bytes >= unit && bytes % unit == 0);
       allocator_traits::deallocate(get_allocator(), ptr, bytes / unit);
     }
 
+    MDBX_CXX20_CONSTEXPR ::std::pair<allocator_pointer, size_t> provide_storage(size_t bytes) {
+      const size_t capacity = bin::advise_capacity(0, bytes);
+      return bin::is_suitable_for_inplace(capacity) ? ::std::pair<allocator_pointer, size_t>(nullptr, capacity)
+                                                    : allocate_storage(capacity);
+    }
+
     static MDBX_CXX17_CONSTEXPR void *to_address(allocator_pointer ptr) noexcept {
 #if defined(__cpp_lib_to_address) && __cpp_lib_to_address >= 201711L
       return static_cast<void *>(::std::to_address(ptr));
@@ -1516,6 +1549,7 @@ private:
       return static_cast<void *>(::std::addressof(*ptr));
 #endif /* __cpp_lib_to_address */
     }
+
     static MDBX_CXX17_CONSTEXPR const void *to_address(allocator_const_pointer ptr) noexcept {
 #if defined(__cpp_lib_to_address) && __cpp_lib_to_address >= 201711L
       return static_cast<const void *>(::std::to_address(ptr));
@@ -1524,11 +1558,16 @@ private:
 #endif /* __cpp_lib_to_address */
     }
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4324) /* structure was padded due to alignment specifier */
+#endif                          /* _MSC_VER */
+
     union alignas(max_align_t) bin {
       struct stub_allocated_holder /* используется только для вычисления (минимального необходимого) размера,
                                       с учетом выравнивания */
       {
-        allocator_pointer ptr_;
+        allocator_pointer stub_ptr_;
         size_t stub_capacity_bytes_;
       };
 
@@ -1549,18 +1588,20 @@ private:
       struct inplace_flag_holder {
         byte buffer_[inplace_size - sizeof(byte)];
         byte lastbyte_;
+        MDBX_CXX11_CONSTEXPR inplace_flag_holder(byte signature) : lastbyte_(signature) {};
       };
 
       allocator_pointer allocated_ptr_;
       capacity_holder capacity_;
       inplace_flag_holder inplace_;
 
+      static constexpr size_t inplace_capacity() noexcept { return sizeof(inplace_flag_holder::buffer_); }
       static constexpr bool is_suitable_for_inplace(size_t capacity_bytes) noexcept {
         static_assert((size_t(reservation_policy::inplace_storage_size_rounding) &
                        (size_t(reservation_policy::inplace_storage_size_rounding) - 1)) == 0,
                       "CAPACITY_POLICY::inplace_storage_size_rounding must be power of 2");
         static_assert(sizeof(bin) == sizeof(inplace_) && sizeof(bin) == sizeof(capacity_), "WTF?");
-        return capacity_bytes < sizeof(bin);
+        return capacity_bytes <= inplace_capacity();
       }
 
       constexpr bool is_inplace() const noexcept {
@@ -1578,88 +1619,43 @@ private:
           /* properly destroy allocator::pointer */
           allocated_ptr_.~allocator_pointer();
         }
-        if (::std::is_trivial<allocator_pointer>::value)
-          /* workaround for "uninitialized" warning from some compilers */
-          memset(&allocated_ptr_, 0, sizeof(allocated_ptr_));
         inplace_.lastbyte_ = lastbyte_inplace_signature;
         MDBX_CONSTEXPR_ASSERT(is_inplace() && address() == inplace_.buffer_ && is_suitable_for_inplace(capacity()));
         return address();
       }
 
       template <bool construct_ptr>
-      MDBX_CXX17_CONSTEXPR byte *make_allocated(allocator_pointer ptr, size_t capacity_bytes) noexcept {
-        MDBX_CONSTEXPR_ASSERT(inplace_signature_limit > capacity_bytes);
+      MDBX_CXX17_CONSTEXPR byte *make_allocated(const ::std::pair<allocator_pointer, size_t> &pair) noexcept {
+        MDBX_CONSTEXPR_ASSERT(inplace_signature_limit > pair.second);
         if (construct_ptr) {
-          /* properly construct allocator::pointer */
-          new (&allocated_ptr_) allocator_pointer(ptr);
-          capacity_.bytes_ = capacity_bytes;
-        } else {
-          MDBX_CONSTEXPR_ASSERT(is_allocated());
-          allocated_ptr_ = ptr;
-          capacity_.bytes_ = capacity_bytes;
-        }
-        MDBX_CONSTEXPR_ASSERT(is_allocated() && address() == to_address(ptr) && capacity() == capacity_bytes);
-        return address();
-      }
-
-      MDBX_CXX20_CONSTEXPR bin(size_t capacity_bytes = 0) noexcept {
-        MDBX_CONSTEXPR_ASSERT(is_suitable_for_inplace(capacity_bytes));
-        make_inplace<false>();
-        (void)capacity_bytes;
-      }
-      MDBX_CXX20_CONSTEXPR bin(allocator_pointer ptr, size_t capacity_bytes) noexcept {
-        MDBX_CONSTEXPR_ASSERT(!is_suitable_for_inplace(capacity_bytes));
-        make_allocated<true>(ptr, capacity_bytes);
-      }
-      MDBX_CXX20_CONSTEXPR ~bin() {
-        if (is_allocated())
-          /* properly destroy allocator::pointer */
-          allocated_ptr_.~allocator_pointer();
-      }
-      MDBX_CXX20_CONSTEXPR bin(bin &&ditto) noexcept {
-        if (ditto.is_inplace()) {
-          // micro-optimization: don't use make_inplace<> here
-          //                     since memcpy() will copy the flag.
-          memcpy(&inplace_, &ditto.inplace_, sizeof(inplace_));
           MDBX_CONSTEXPR_ASSERT(is_inplace());
+          new (&allocated_ptr_) allocator_pointer(pair.first);
         } else {
-          new (&allocated_ptr_) allocator_pointer(::std::move(ditto.allocated_ptr_));
-          capacity_.bytes_ = ditto.capacity_.bytes_;
-          ditto.make_inplace<true>();
           MDBX_CONSTEXPR_ASSERT(is_allocated());
+          allocated_ptr_ = pair.first;
         }
+        capacity_.bytes_ = pair.second;
+        MDBX_CONSTEXPR_ASSERT(is_allocated() && address() == to_address(pair.first) && capacity() == pair.second);
+        return address();
       }
 
-      MDBX_CXX17_CONSTEXPR bin &operator=(const bin &ditto) noexcept {
-        if (ditto.is_inplace()) {
-          // micro-optimization: don't use make_inplace<> here
-          //                     since memcpy() will copy the flag.
-          if (is_allocated())
-            /* properly destroy allocator::pointer */
-            allocated_ptr_.~allocator_pointer();
-          memcpy(&inplace_, &ditto.inplace_, sizeof(inplace_));
-          MDBX_CONSTEXPR_ASSERT(is_inplace());
-        } else if (is_inplace())
-          make_allocated<true>(ditto.allocated_ptr_, ditto.capacity_.bytes_);
-        else
-          make_allocated<false>(ditto.allocated_ptr_, ditto.capacity_.bytes_);
-        return *this;
-      }
-
-      MDBX_CXX17_CONSTEXPR bin &operator=(bin &&ditto) noexcept {
-        operator=(const_cast<const bin &>(ditto));
-        if (ditto.is_allocated())
-          ditto.make_inplace<true>();
-        return *this;
+      MDBX_CXX11_CONSTEXPR bin() noexcept : inplace_(lastbyte_inplace_signature) {
+        if (::std::is_trivial<allocator_pointer>::value)
+          /* workaround for "uninitialized" warning from some compilers */
+          memset(&allocated_ptr_, 0, sizeof(allocated_ptr_));
       }
 
       static MDBX_CXX20_CONSTEXPR size_t advise_capacity(const size_t current, const size_t wanna) {
         if (MDBX_UNLIKELY(wanna > max_capacity))
           MDBX_CXX20_UNLIKELY throw_max_length_exceeded();
 
-        const size_t advised = reservation_policy::advise(current, wanna);
+        const size_t advised = reservation_policy::advise(current, wanna, inplace_capacity());
         assert(advised >= wanna);
-        return ::std::min(size_t(max_capacity), ::std::max(sizeof(bin) - 1, advised));
+        return ::std::min(size_t(max_capacity), ::std::max(inplace_capacity(), advised));
+      }
+
+      constexpr bool is_inplace(const void *ptr) const noexcept {
+        return size_t(static_cast<const byte *>(ptr) - inplace_.buffer_) < inplace_capacity();
       }
 
       constexpr const byte *address() const noexcept {
@@ -1668,25 +1664,21 @@ private:
       MDBX_CXX17_CONSTEXPR byte *address() noexcept {
         return is_inplace() ? inplace_.buffer_ : static_cast<byte *>(to_address(allocated_ptr_));
       }
-      constexpr size_t capacity() const noexcept { return is_inplace() ? sizeof(bin) - 1 : capacity_.bytes_; }
+      constexpr size_t capacity() const noexcept { return is_inplace() ? inplace_capacity() : capacity_.bytes_; }
     } bin_;
 
-    MDBX_CXX20_CONSTEXPR void *init(size_t capacity) {
-      capacity = bin::advise_capacity(0, capacity);
-      if (bin_.is_suitable_for_inplace(capacity))
-        new (&bin_) bin();
-      else {
-        const auto pair = allocate_storage(capacity);
-        assert(pair.second >= capacity);
-        new (&bin_) bin(pair.first, pair.second);
-      }
-      return bin_.address();
-    }
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+    constexpr bool is_inplace(const void *ptr) const noexcept { return bin_.is_inplace(ptr); }
 
     MDBX_CXX20_CONSTEXPR void release() noexcept {
       if (bin_.is_allocated()) {
         deallocate_storage(bin_.allocated_ptr_, bin_.capacity_.bytes_);
-        bin_.template make_inplace<true>();
+        /* properly destroy allocator::pointer */
+        bin_.allocated_ptr_.~allocator_pointer();
+        bin_.inplace_.lastbyte_ = bin::lastbyte_inplace_signature;
       }
     }
 
@@ -1724,13 +1716,13 @@ private:
         return new_place;
       }
 
-      if (!bin_.is_allocated()) {
+      if (bin_.is_inplace()) {
         const auto pair = allocate_storage(new_capacity);
         assert(pair.second >= new_capacity);
         byte *const new_place = static_cast<byte *>(to_address(pair.first)) + wanna_headroom;
         if (MDBX_LIKELY(length))
           MDBX_CXX20_LIKELY memcpy(new_place, content, length);
-        bin_.template make_allocated<true>(pair.first, pair.second);
+        bin_.template make_allocated<true>(pair);
         return new_place;
       }
 
@@ -1739,7 +1731,7 @@ private:
         deallocate_storage(old_allocated, old_capacity);
       const auto pair = allocate_storage(new_capacity);
       assert(pair.second >= new_capacity);
-      byte *const new_place = bin_.template make_allocated<false>(pair.first, pair.second) + wanna_headroom;
+      byte *const new_place = bin_.template make_allocated<false>(pair) + wanna_headroom;
       if (MDBX_LIKELY(length))
         MDBX_CXX20_LIKELY memcpy(new_place, content, length);
       if (!external_content)
@@ -1762,33 +1754,90 @@ private:
 
     //--------------------------------------------------------------------------
 
+    MDBX_CXX20_CONSTEXPR silo(const allocator_type &alloc = allocator_type()) noexcept : allocator_type(alloc) {}
+    MDBX_CXX20_CONSTEXPR silo(size_t capacity, const allocator_type &alloc = allocator_type()) : silo(alloc) {
+      if (!bin::is_suitable_for_inplace(capacity))
+        bin_.template make_allocated<true>(provide_storage(capacity));
+    }
+
+    silo(silo &&other) = delete;
     MDBX_CXX20_CONSTEXPR
-    silo() noexcept : allocator_type() { init(0); }
-    MDBX_CXX20_CONSTEXPR
-    silo(const allocator_type &alloc) noexcept : allocator_type(alloc) { init(0); }
-    MDBX_CXX20_CONSTEXPR silo(size_t capacity) { init(capacity); }
-    MDBX_CXX20_CONSTEXPR silo(size_t capacity, const allocator_type &alloc) : silo(alloc) { init(capacity); }
+    silo(silo &&other, bool is_reference = false) noexcept(::std::is_nothrow_move_constructible<allocator_type>::value)
+        : allocator_type(::std::move(other.get_allocator())) {
+      if (!is_reference) {
+        if (other.bin_.is_inplace()) {
+          memcpy(&bin_, &other.bin_, sizeof(bin));
+          MDBX_CONSTEXPR_ASSERT(bin_.is_inplace());
+        } else {
+          new (&bin_.allocated_ptr_) allocator_pointer(::std::move(other.bin_.allocated_ptr_));
+          bin_.capacity_.bytes_ = other.bin_.capacity_.bytes_;
+          /* properly destroy allocator::pointer.
+           *
+           * CoverityScan issues an erroneous warning here about using an uninitialized object. Which is not true,
+           * since in C++ (unlike Rust) an object remains initialized after a move-assignment operation; Moreover,
+           * a destructor will be called for such an object (this is explicitly stated in all C++ standards, starting
+           * from the 11th). */
+          /* coverity[use_after_move] */
+          other.bin_.allocated_ptr_.~allocator_pointer();
+          other.bin_.inplace_.lastbyte_ = bin::lastbyte_inplace_signature;
+          MDBX_CONSTEXPR_ASSERT(bin_.is_allocated() && other.bin_.is_inplace());
+        }
+      }
+    }
 
-    MDBX_CXX20_CONSTEXPR silo(silo &&ditto) noexcept(::std::is_nothrow_move_constructible<allocator_type>::value)
-        : allocator_type(::std::move(ditto.get_allocator())), bin_(::std::move(ditto.bin_)) {}
+    MDBX_CXX17_CONSTEXPR bool move(silo &&other) noexcept {
+      if (other.bin_.is_inplace()) {
+        memcpy(&bin_, &other.bin_, sizeof(bin));
+        MDBX_CONSTEXPR_ASSERT(bin_.is_inplace());
+        return /* buffer's slice fixup is needed */ true;
+      }
+      new (&bin_.allocated_ptr_) allocator_pointer(::std::move(other.bin_.allocated_ptr_));
+      bin_.capacity_.bytes_ = other.bin_.capacity_.bytes_;
+      /* properly destroy allocator::pointer.
+       *
+       * CoverityScan issues an erroneous warning here about using an uninitialized object. Which is not true,
+       * since in C++ (unlike Rust) an object remains initialized after a move-assignment operation; Moreover,
+       * a destructor will be called for such an object (this is explicitly stated in all C++ standards, starting
+       * from the 11th). */
+      /* coverity[use_after_move] */
+      other.bin_.allocated_ptr_.~allocator_pointer();
+      other.bin_.inplace_.lastbyte_ = bin::lastbyte_inplace_signature;
+      MDBX_CONSTEXPR_ASSERT(bin_.is_allocated() && other.bin_.is_inplace());
+      return false;
+    }
 
-    MDBX_CXX20_CONSTEXPR silo(size_t capacity, size_t headroom, const void *ptr, size_t length) : silo(capacity) {
-      assert(capacity >= headroom + length);
-      if (length)
-        put(headroom, ptr, length);
+    MDBX_CXX17_CONSTEXPR bool assign_move(silo &&other, bool is_reference) noexcept {
+      release();
+      if (!allocation_aware_details::move_assign_alloc<silo, allocator_type>::is_moveable(this, other))
+        allocation_aware_details::move_assign_alloc<silo, allocator_type>::propagate(this, other);
+      return is_reference ? false : move(std::move(other));
+    }
+
+    static MDBX_CXX20_CONSTEXPR std::pair<bool, bool>
+    exchange(silo &left, const bool left_is_reference, silo &right, const bool right_is_reference) noexcept(
+        allocation_aware_details::swap_alloc<silo, allocator_type>::is_nothrow()) {
+      allocation_aware_details::swap_alloc<silo, allocator_type>::propagate(left, right);
+      bool left_need_fixup = false, right_need_fixup = false;
+      if (left_is_reference || right_is_reference) {
+        left_need_fixup = !right_is_reference && left.move(std::move(right));
+        right_need_fixup = !left_is_reference && right.move(std::move(left));
+      } else {
+        silo temp(std::move(left), false);
+        left_need_fixup = left.move(std::move(right));
+        right_need_fixup = right.move(std::move(temp));
+      }
+      return std::make_pair(left_need_fixup, right_need_fixup);
     }
 
-    // select_on_container_copy_construction()
     MDBX_CXX20_CONSTEXPR silo(size_t capacity, size_t headroom, const void *ptr, size_t length,
-                              const allocator_type &alloc)
+                              const allocator_type &alloc = allocator_type())
         : silo(capacity, alloc) {
       assert(capacity >= headroom + length);
       if (length)
         put(headroom, ptr, length);
     }
 
-    MDBX_CXX20_CONSTEXPR silo(const void *ptr, size_t length) : silo(length, 0, ptr, length) {}
-    MDBX_CXX20_CONSTEXPR silo(const void *ptr, size_t length, const allocator_type &alloc)
+    MDBX_CXX20_CONSTEXPR silo(const void *ptr, size_t length, const allocator_type &alloc = allocator_type())
         : silo(length, 0, ptr, length, alloc) {}
 
     ~silo() { release(); }
@@ -1798,53 +1847,17 @@ private:
     MDBX_CXX20_CONSTEXPR void *assign(size_t headroom, const void *ptr, size_t length, size_t tailroom) {
       return reshape<true>(headroom + length + tailroom, headroom, ptr, length);
     }
-    MDBX_CXX20_CONSTEXPR void *assign(const void *ptr, size_t length) { return assign(0, ptr, length, 0); }
 
-    MDBX_CXX20_CONSTEXPR silo &assign(const silo &ditto, size_t headroom, slice &content) {
-      assert(ditto.get() + headroom == content.byte_ptr());
-      if MDBX_IF_CONSTEXPR (!allocation_aware_details::allocator_is_always_equal<allocator_type>()) {
-        if (MDBX_UNLIKELY(get_allocator() != ditto.get_allocator()))
-          MDBX_CXX20_UNLIKELY {
-            release();
-            allocation_aware_details::copy_assign_alloc<silo, allocator_type>::propagate(this, ditto);
-          }
-      }
-      content.iov_base = reshape<true>(ditto.capacity(), headroom, content.data(), content.length());
-      return *this;
-    }
-
-    MDBX_CXX20_CONSTEXPR silo &
-    assign(silo &&ditto, size_t headroom,
-           slice &content) noexcept(allocation_aware_details::move_assign_alloc<silo, allocator_type>::is_nothrow()) {
-      assert(ditto.get() + headroom == content.byte_ptr());
-      if (allocation_aware_details::move_assign_alloc<silo, allocator_type>::is_moveable(this, ditto)) {
-        release();
-        allocation_aware_details::move_assign_alloc<silo, allocator_type>::propagate(this, ditto);
-        /* no reallocation nor copying required */
-        bin_ = ::std::move(ditto.bin_);
-        assert(get() + headroom == content.byte_ptr());
-      } else {
-        /* copy content since allocators are different */
-        content.iov_base = reshape<true>(ditto.capacity(), headroom, content.data(), content.length());
-        ditto.release();
-      }
-      return *this;
-    }
+    MDBX_CXX20_CONSTEXPR void *assign(const void *ptr, size_t length) { return assign(0, ptr, length, 0); }
 
     MDBX_CXX20_CONSTEXPR void *clear() { return reshape<true>(0, 0, nullptr, 0); }
     MDBX_CXX20_CONSTEXPR void *clear_and_reserve(size_t whole_capacity, size_t headroom) {
       return reshape<false>(whole_capacity, headroom, nullptr, 0);
     }
+
     MDBX_CXX20_CONSTEXPR void resize(size_t capacity, size_t headroom, slice &content) {
       content.iov_base = reshape<false>(capacity, headroom, content.iov_base, content.iov_len);
     }
-    MDBX_CXX20_CONSTEXPR void
-    swap(silo &ditto) noexcept(allocation_aware_details::swap_alloc<silo, allocator_type>::is_nothrow()) {
-      allocation_aware_details::swap_alloc<silo, allocator_type>::propagate(this, ditto);
-      ::std::swap(bin_, ditto.bin_);
-    }
-
-    /* MDBX_CXX20_CONSTEXPR void shrink_to_fit() { TODO } */
 
     MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX11_CONSTEXPR size_t capacity() const noexcept { return bin_.capacity(); }
     MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX11_CONSTEXPR const void *data(size_t offset = 0) const noexcept {
@@ -1853,6 +1866,16 @@ private:
     MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX11_CONSTEXPR void *data(size_t offset = 0) noexcept { return get(offset); }
   };
 
+  MDBX_CXX14_CONSTEXPR void fixup_import(const typename silo::bin &src) noexcept {
+    auto ptr = slice_.byte_ptr();
+    if (src.is_inplace(ptr)) {
+      MDBX_CONSTEXPR_ASSERT(silo_.bin_.is_inplace());
+      intptr_t offset = &silo_.bin_.inplace_.buffer_[0] - &src.inplace_.buffer_[0];
+      slice_.iov_base = ptr + offset;
+      MDBX_CONSTEXPR_ASSERT(is_freestanding());
+    }
+  }
+
   silo silo_;
   ::mdbx::slice slice_;
 
@@ -1898,6 +1921,9 @@ public:
 
   using move_assign_alloc = allocation_aware_details::move_assign_alloc<silo, allocator_type>;
   using copy_assign_alloc = allocation_aware_details::copy_assign_alloc<silo, allocator_type>;
+  using swap_alloc = allocation_aware_details::swap_alloc<struct silo, allocator_type>;
+
+  static constexpr bool is_swap_nothrow() noexcept { return swap_alloc::is_nothrow(); }
 
   /// \brief Returns the associated allocator.
   MDBX_CXX20_CONSTEXPR allocator_type get_allocator() const { return silo_.get_allocator(); }
@@ -1905,10 +1931,18 @@ public:
   /// \brief Checks whether data chunk stored inside the buffer, otherwise
   /// buffer just refers to data located outside the buffer.
   MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX20_CONSTEXPR bool is_freestanding() const noexcept {
-    static_assert(size_t(-long(max_length)) > max_length, "WTF?");
+    static_assert(size_t(-intptr_t(max_length)) > max_length, "WTF?");
     return size_t(byte_ptr() - silo_begin()) < silo_.capacity();
   }
 
+  /// \brief Checks whether data chunk stored in place within the buffer instance itself,
+  /// without reference outside nor allocating additional memory resources,
+  /// which also implies buffer is freestanding.
+  MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX20_CONSTEXPR bool is_inplace() const noexcept {
+    static_assert(size_t(-intptr_t(max_length)) > max_length, "WTF?");
+    return silo_.is_inplace(slice_.data());
+  }
+
   /// \brief Checks whether the buffer just refers to data located outside
   /// the buffer, rather than stores it.
   MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX20_CONSTEXPR bool is_reference() const noexcept { return !is_freestanding(); }
@@ -1921,7 +1955,7 @@ public:
   /// \brief Returns the number of bytes that available in currently allocated
   /// storage ahead the currently beginning of data.
   MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX20_CONSTEXPR size_t headroom() const noexcept {
-    return is_freestanding() ? slice_.byte_ptr() - silo_begin() : 0;
+    return is_freestanding() ? byte_ptr() - silo_begin() : 0;
   }
 
   /// \brief Returns the number of bytes that available in currently allocated
@@ -2019,15 +2053,18 @@ public:
   MDBX_CXX20_CONSTEXPR buffer() noexcept = default;
   MDBX_CXX20_CONSTEXPR buffer(const allocator_type &allocator) noexcept : silo_(allocator) {}
 
+  MDBX_CXX20_CONSTEXPR
   buffer(const struct slice &src, bool make_reference, const allocator_type &allocator = allocator_type())
       : silo_(allocator), slice_(src) {
     if (!make_reference)
       insulate();
   }
 
+  MDBX_CXX20_CONSTEXPR
   buffer(const buffer &src, bool make_reference, const allocator_type &allocator = allocator_type())
       : buffer(src.slice_, make_reference, allocator) {}
 
+  MDBX_CXX20_CONSTEXPR
   buffer(const void *ptr, size_t bytes, bool make_reference, const allocator_type &allocator = allocator_type())
       : buffer(::mdbx::slice(ptr, bytes), make_reference, allocator) {}
 
@@ -2039,17 +2076,23 @@ public:
 
 #if defined(DOXYGEN) || (defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L)
   template <class CHAR, class T>
-  buffer(const ::std::basic_string_view<CHAR, T> &view, bool make_reference,
-         const allocator_type &allocator = allocator_type())
+  MDBX_CXX20_CONSTEXPR buffer(const ::std::basic_string_view<CHAR, T> &view, bool make_reference,
+                              const allocator_type &allocator = allocator_type())
       : buffer(::mdbx::slice(view), make_reference, allocator) {}
 #endif /* __cpp_lib_string_view >= 201606L */
 
   MDBX_CXX20_CONSTEXPR
-  buffer(const struct slice &src, const allocator_type &allocator = allocator_type())
-      : silo_(src.data(), src.length(), allocator), slice_(silo_.data(), src.length()) {}
+  buffer(const struct slice &src, const allocator_type &allocator = allocator_type()) : silo_(allocator), slice_(src) {
+    if (!src.empty())
+      insulate();
+  }
+
+  MDBX_CXX20_CONSTEXPR
+  buffer(const buffer &src, const allocator_type &allocator) : buffer(src.slice_, allocator) {}
 
   MDBX_CXX20_CONSTEXPR
-  buffer(const buffer &src, const allocator_type &allocator = allocator_type()) : buffer(src.slice_, allocator) {}
+  buffer(const buffer &src)
+      : buffer(src.slice_, allocator_traits::select_on_container_copy_construction(src.get_allocator())) {}
 
   MDBX_CXX20_CONSTEXPR
   buffer(const void *ptr, size_t bytes, const allocator_type &allocator = allocator_type())
@@ -2071,20 +2114,22 @@ public:
       : buffer(::mdbx::slice(view), allocator) {}
 #endif /* __cpp_lib_string_view >= 201606L */
 
-  buffer(size_t head_room, size_t tail_room, const allocator_type &allocator = allocator_type()) : silo_(allocator) {
-    slice_.iov_base = silo_.init(check_length(head_room, tail_room));
+  buffer(size_t head_room, size_t tail_room, const allocator_type &allocator = allocator_type())
+      : silo_(check_length(head_room, tail_room), allocator) {
+    slice_.iov_base = silo_.get();
     assert(slice_.iov_len == 0);
   }
 
-  buffer(size_t capacity, const allocator_type &allocator = allocator_type()) : silo_(allocator) {
-    slice_.iov_base = silo_.init(check_length(capacity));
+  buffer(size_t capacity, const allocator_type &allocator = allocator_type())
+      : silo_(check_length(capacity), allocator) {
+    slice_.iov_base = silo_.get();
     assert(slice_.iov_len == 0);
   }
 
   buffer(size_t head_room, const struct slice &src, size_t tail_room,
          const allocator_type &allocator = allocator_type())
-      : silo_(allocator) {
-    slice_.iov_base = silo_.init(check_length(head_room, src.length(), tail_room));
+      : silo_(check_length(head_room, src.length(), tail_room), allocator) {
+    slice_.iov_base = silo_.get();
     slice_.iov_len = src.length();
     memcpy(slice_.iov_base, src.data(), src.length());
   }
@@ -2095,7 +2140,24 @@ public:
   inline buffer(const ::mdbx::txn &txn, const struct slice &src, const allocator_type &allocator = allocator_type());
 
   buffer(buffer &&src) noexcept(move_assign_alloc::is_nothrow())
-      : silo_(::std::move(src.silo_)), slice_(::std::move(src.slice_)) {}
+      : silo_(::std::move(src.silo_), src.is_reference()), slice_(::std::move(src.slice_)) {
+    /* CoverityScan issues an erroneous warning here about using an uninitialized object. Which is not true,
+     * since in C++ (unlike Rust) an object remains initialized after a move-assignment operation; Moreover,
+     * a destructor will be called for such an object (this is explicitly stated in all C++ standards, starting from the
+     * 11th). */
+    /* coverity[use_after_move] */
+    fixup_import(src.silo_.bin_);
+  }
+
+  /// \brief Build a null buffer which zero length and refers to null address.
+  MDBX_CXX14_CONSTEXPR static buffer null() noexcept { return buffer(slice::null()); }
+
+  /// \brief Build an invalid buffer which non-zero length and refers to null address.
+  MDBX_CXX14_CONSTEXPR static buffer invalid() noexcept {
+    buffer r;
+    r.slice_ = slice::invalid();
+    return r;
+  }
 
   MDBX_CXX11_CONSTEXPR const struct slice &slice() const noexcept { return slice_; }
 
@@ -2254,8 +2316,12 @@ public:
 
   /// \brief Reserves storage space.
   void reserve(size_t wanna_headroom, size_t wanna_tailroom) {
-    wanna_headroom = ::std::min(::std::max(headroom(), wanna_headroom), wanna_headroom + pettiness_threshold);
-    wanna_tailroom = ::std::min(::std::max(tailroom(), wanna_tailroom), wanna_tailroom + pettiness_threshold);
+    wanna_headroom = ::std::min(
+        ::std::max(headroom(), wanna_headroom),
+        (wanna_headroom < max_length - pettiness_threshold) ? wanna_headroom + pettiness_threshold : wanna_headroom);
+    wanna_tailroom = ::std::min(
+        ::std::max(tailroom(), wanna_tailroom),
+        (wanna_tailroom < max_length - pettiness_threshold) ? wanna_tailroom + pettiness_threshold : wanna_tailroom);
     const size_t wanna_capacity = check_length(wanna_headroom, slice_.length(), wanna_tailroom);
     silo_.resize(wanna_capacity, wanna_headroom, slice_);
     assert(headroom() >= wanna_headroom && headroom() <= wanna_headroom + pettiness_threshold);
@@ -2275,21 +2341,75 @@ public:
   }
 
   buffer &assign_freestanding(const void *ptr, size_t bytes) {
-    silo_.assign(static_cast<const typename silo::value_type *>(ptr), check_length(bytes));
-    slice_.assign(silo_.data(), bytes);
+    slice_.assign(silo_.assign(static_cast<const typename silo::value_type *>(ptr), check_length(bytes)), bytes);
     return *this;
   }
 
   MDBX_CXX20_CONSTEXPR void swap(buffer &other) noexcept(swap_alloc::is_nothrow()) {
-    silo_.swap(other.silo_);
-    slice_.swap(other.slice_);
+    const auto pair = silo::exchange(silo_, is_reference(), other.silo_, other.is_reference());
+    std::swap(slice_, other.slice_);
+    if (pair.first)
+      fixup_import(other.silo_.bin_);
+    if (pair.second)
+      other.fixup_import(silo_.bin_);
+  }
+
+  MDBX_CXX20_CONSTEXPR friend void swap(buffer &left, buffer &right) noexcept(buffer::is_swap_nothrow()) {
+    left.swap(right);
   }
 
   static buffer clone(const buffer &src, const allocator_type &allocator = allocator_type()) {
     return buffer(src.headroom(), src.slice_, src.tailroom(), allocator);
   }
 
-  buffer &assign(const buffer &src, bool make_reference = false) { return assign(src.slice_, make_reference); }
+  MDBX_CXX20_CONSTEXPR buffer make_inplace_or_reference() const {
+    return buffer(slice(), !is_inplace(), allocator_traits::select_on_container_copy_construction(get_allocator()));
+  }
+
+  MDBX_CXX20_CONSTEXPR buffer &assign(size_t headroom, const buffer &src, size_t tailroom) {
+    const size_t whole_capacity = check_length(headroom, src.length(), tailroom);
+    slice_.invalidate();
+    if MDBX_IF_CONSTEXPR (!allocation_aware_details::template allocator_is_always_equal<allocator_type>()) {
+      if (MDBX_UNLIKELY(silo_.get_allocator() != src.silo_.get_allocator()))
+        MDBX_CXX20_UNLIKELY {
+          silo_.release();
+          allocation_aware_details::copy_assign_alloc<silo, allocator_type>::propagate(&silo_, src.silo_);
+        }
+    }
+
+    slice_.iov_base = silo_.template reshape<true>(whole_capacity, headroom, src.data(), src.length());
+    slice_.iov_len = src.length();
+    return *this;
+  }
+
+  MDBX_CXX20_CONSTEXPR buffer &assign(const buffer &src, bool make_reference = false) {
+    slice_.invalidate();
+    if MDBX_IF_CONSTEXPR (!allocation_aware_details::template allocator_is_always_equal<allocator_type>()) {
+      if (MDBX_UNLIKELY(silo_.get_allocator() != src.silo_.get_allocator()))
+        MDBX_CXX20_UNLIKELY {
+          silo_.release();
+          allocation_aware_details::copy_assign_alloc<silo, allocator_type>::propagate(&silo_, src.silo_);
+        }
+    }
+
+    if (make_reference) {
+      silo_.release();
+      slice_ = src.slice_;
+    } else {
+      slice_.iov_base = silo_.template reshape<true>(src.length(), 0, src.data(), src.length());
+      slice_.iov_len = src.length();
+    }
+    return *this;
+  }
+
+  MDBX_CXX20_CONSTEXPR buffer &
+  assign(buffer &&src) noexcept(allocation_aware_details::move_assign_alloc<silo, allocator_type>::is_nothrow()) {
+    const bool is_reference = src.is_reference();
+    slice_ = std::move(src.slice_);
+    if (silo_.assign_move(std::move(src.silo_), is_reference))
+      fixup_import(src.silo_.bin_);
+    return *this;
+  }
 
   buffer &assign(const void *ptr, size_t bytes, bool make_reference = false) {
     return make_reference ? assign_reference(ptr, bytes) : assign_freestanding(ptr, bytes);
@@ -2410,7 +2530,7 @@ public:
   }
 
   /// \brief Reduces memory usage by freeing unused storage space.
-  void shrink_to_fit() { reserve(0, 0); }
+  void shrink_to_fit() { silo_.resize(length(), 0, slice_); }
 
   /// \brief Drops the first "n" bytes from the data chunk.
   /// \pre REQUIRES: `n <= size()`
@@ -2486,6 +2606,14 @@ public:
     return *this;
   }
 
+  buffer &append(const byte c) {
+    if (MDBX_UNLIKELY(tailroom() < 1))
+      MDBX_CXX20_UNLIKELY reserve_tailroom(1);
+    *end_byte_ptr() = c;
+    slice_.iov_len += 1;
+    return *this;
+  }
+
   buffer &append(const struct slice &chunk) { return append(chunk.data(), chunk.size()); }
 
   buffer &add_header(const void *src, size_t bytes) {
@@ -2629,7 +2757,7 @@ public:
     return buffer(src, make_reference);
   }
 
-  static buffer key_from(silo &&src) noexcept { return buffer(::std::move(src)); }
+  static buffer key_from(buffer &&src) noexcept { return buffer(::std::move(src)); }
 
   static buffer key_from_double(const double ieee754_64bit) { return wrap(::mdbx_key_from_double(ieee754_64bit)); }
 
@@ -2708,11 +2836,13 @@ inline string<ALLOCATOR> make_string(const PRODUCER &producer, const ALLOCATOR &
   return result;
 }
 
-MDBX_EXTERN_API_TEMPLATE(LIBMDBX_API_TYPE, buffer<legacy_allocator>);
+#if !(defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)) || defined(LIBMDBX_EXPORTS)
+MDBX_EXTERN_API_TEMPLATE(LIBMDBX_API_TYPE, buffer<legacy_allocator, default_capacity_policy>);
 
-#if defined(__cpp_lib_memory_resource) && __cpp_lib_memory_resource >= 201603L && _GLIBCXX_USE_CXX11_ABI
-MDBX_EXTERN_API_TEMPLATE(LIBMDBX_API_TYPE, buffer<polymorphic_allocator>);
-#endif /* __cpp_lib_memory_resource >= 201603L */
+#if MDBX_CXX_HAS_POLYMORPHIC_ALLOCATOR
+MDBX_EXTERN_API_TEMPLATE(LIBMDBX_API_TYPE, buffer<polymorphic_allocator, default_capacity_policy>);
+#endif /* MDBX_CXX_HAS_POLYMORPHIC_ALLOCATOR */
+#endif /* !MinGW || MDBX_EXPORTS */
 
 /// \brief Combines data slice with boolean flag to represent result of certain operations.
 struct value_result {
@@ -2982,6 +3112,30 @@ struct LIBMDBX_API_TYPE map_handle {
   operator bool() const noexcept { return dbi != 0; }
   operator MDBX_dbi() const { return dbi; }
 
+#if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L
+  friend MDBX_CXX11_CONSTEXPR auto operator<=>(const map_handle &a, const map_handle &b) noexcept {
+    return a.dbi <=> b.dbi;
+  }
+#endif /* __cpp_impl_three_way_comparison */
+  friend MDBX_CXX14_CONSTEXPR bool operator==(const map_handle &a, const map_handle &b) noexcept {
+    return a.dbi == b.dbi;
+  }
+  friend MDBX_CXX14_CONSTEXPR bool operator<(const map_handle &a, const map_handle &b) noexcept {
+    return a.dbi < b.dbi;
+  }
+  friend MDBX_CXX14_CONSTEXPR bool operator>(const map_handle &a, const map_handle &b) noexcept {
+    return a.dbi > b.dbi;
+  }
+  friend MDBX_CXX14_CONSTEXPR bool operator<=(const map_handle &a, const map_handle &b) noexcept {
+    return a.dbi <= b.dbi;
+  }
+  friend MDBX_CXX14_CONSTEXPR bool operator>=(const map_handle &a, const map_handle &b) noexcept {
+    return a.dbi >= b.dbi;
+  }
+  friend MDBX_CXX14_CONSTEXPR bool operator!=(const map_handle &a, const map_handle &b) noexcept {
+    return a.dbi != b.dbi;
+  }
+
   using flags = ::MDBX_db_flags_t;
   using state = ::MDBX_dbi_state_t;
   struct LIBMDBX_API_TYPE info {
@@ -3012,12 +3166,11 @@ enum put_mode {
 
 /// \brief Unmanaged database environment.
 ///
-/// Like other unmanaged classes, `env` allows copying and assignment for
-/// instances, but does not destroys the represented underlying object from the
-/// own class destructor.
+/// Like other unmanaged classes, `env` allows copying and assignment for handles as a values,
+/// but does not manage nor destroys the represented underlying object from the own class destructor.
 ///
 /// An environment supports multiple key-value tables (aka key-value maps,
-/// spaces or sub-databases), all residing in the same shared-memory mapped
+/// tables or sub-databases), all residing in the same shared-memory mapped
 /// file.
 class LIBMDBX_API_TYPE env {
   friend class txn;
@@ -3029,8 +3182,9 @@ protected:
 public:
   MDBX_CXX11_CONSTEXPR env() noexcept = default;
   env(const env &) noexcept = default;
-  inline env &operator=(env &&other) noexcept;
-  inline env(env &&other) noexcept;
+  env &operator=(const env &) noexcept = default;
+  inline env &operator=(env &&) noexcept;
+  inline env(env &&) noexcept;
   inline ~env() noexcept;
 
   MDBX_CXX14_CONSTEXPR operator bool() const noexcept;
@@ -3715,9 +3869,8 @@ public:
 
 /// \brief Unmanaged database transaction.
 ///
-/// Like other unmanaged classes, `txn` allows copying and assignment for
-/// instances, but does not destroys the represented underlying object from the
-/// own class destructor.
+/// Like other unmanaged classes, `txn` allows copying and assignment for handles as a values,
+/// but does not manage nor destroys the represented underlying object from the own class destructor.
 ///
 /// All database operations require a transaction handle. Transactions may be
 /// read-only or read-write.
@@ -3730,8 +3883,9 @@ protected:
 public:
   MDBX_CXX11_CONSTEXPR txn() noexcept = default;
   txn(const txn &) noexcept = default;
-  inline txn &operator=(txn &&other) noexcept;
-  inline txn(txn &&other) noexcept;
+  txn &operator=(const txn &) noexcept = default;
+  inline txn &operator=(txn &&) noexcept;
+  inline txn(txn &&) noexcept;
   inline ~txn() noexcept;
 
   MDBX_CXX14_CONSTEXPR operator bool() const noexcept;
@@ -3756,6 +3910,9 @@ public:
   /// \brief Checks whether the given data is on a dirty page.
   inline bool is_dirty(const void *ptr) const;
 
+  /// \brief Checks whether the given slice is on a dirty page.
+  inline bool is_dirty(const slice &item) const { return item && is_dirty(item.data()); }
+
   /// \brief Checks whether the transaction is read-only.
   bool is_readonly() const { return (flags() & MDBX_TXN_RDONLY) != 0; }
 
@@ -4123,9 +4280,8 @@ public:
 
 /// \brief Unmanaged cursor.
 ///
-/// Like other unmanaged classes, `cursor` allows copying and assignment for
-/// instances, but does not destroys the represented underlying object from the
-/// own class destructor.
+/// Like other unmanaged classes, `cursor` allows copying and assignment for handles as a values,
+/// but does not manage nor destroys the represented underlying object from the own class destructor.
 ///
 /// \copydetails MDBX_cursor
 class LIBMDBX_API_TYPE cursor {
@@ -4136,8 +4292,9 @@ public:
   MDBX_CXX11_CONSTEXPR cursor(MDBX_cursor *ptr) noexcept;
   MDBX_CXX11_CONSTEXPR cursor() noexcept = default;
   cursor(const cursor &) noexcept = default;
-  inline cursor &operator=(cursor &&other) noexcept;
-  inline cursor(cursor &&other) noexcept;
+  cursor &operator=(const cursor &) noexcept = default;
+  inline cursor &operator=(cursor &&) noexcept;
+  inline cursor(cursor &&) noexcept;
   inline ~cursor() noexcept;
   inline cursor_managed clone(void *your_context = nullptr) const;
   MDBX_CXX14_CONSTEXPR operator bool() const noexcept;
@@ -4826,12 +4983,6 @@ inline slice &slice::operator=(slice &&src) noexcept { return assign(::std::move
 
 inline slice &slice::operator=(::MDBX_val &&src) { return assign(::std::move(src)); }
 
-inline void slice::swap(slice &other) noexcept {
-  const auto temp = *this;
-  *this = other;
-  other = temp;
-}
-
 MDBX_CXX11_CONSTEXPR const ::mdbx::byte *slice::byte_ptr() const noexcept {
   return static_cast<const byte *>(iov_base);
 }
@@ -6413,7 +6564,32 @@ inline string to_string(const ::mdbx::error &value) {
 inline string to_string(const ::MDBX_error_t &errcode) { return to_string(::mdbx::error(errcode)); }
 
 template <> struct hash<::mdbx::slice> {
-  MDBX_CXX14_CONSTEXPR size_t operator()(::mdbx::slice const &slice) const noexcept { return slice.hash_value(); }
+  MDBX_CXX14_CONSTEXPR size_t operator()(const ::mdbx::slice &slice) const noexcept { return slice.hash_value(); }
+};
+
+template <> struct hash<::mdbx::map_handle> {
+  MDBX_CXX11_CONSTEXPR size_t operator()(const ::mdbx::map_handle &handle) const noexcept { return handle.dbi; }
+};
+
+template <> struct hash<::mdbx::env> : public std::hash<const MDBX_env *> {
+  using inherited = std::hash<const MDBX_env *>;
+  size_t operator()(const ::mdbx::env &env) const noexcept { return inherited::operator()(env); }
+};
+
+template <> struct hash<::mdbx::txn> : public std::hash<const MDBX_txn *> {
+  using inherited = std::hash<const MDBX_txn *>;
+  size_t operator()(const ::mdbx::txn &txn) const noexcept { return inherited::operator()(txn); }
+};
+
+template <> struct hash<::mdbx::cursor> : public std::hash<const MDBX_cursor *> {
+  using inherited = std::hash<const MDBX_cursor *>;
+  size_t operator()(const ::mdbx::cursor &cursor) const noexcept { return inherited::operator()(cursor); }
+};
+
+template <class ALLOCATOR, typename CAPACITY_POLICY> struct hash<::mdbx::buffer<ALLOCATOR, CAPACITY_POLICY>> {
+  size_t operator()(::mdbx::buffer<ALLOCATOR, CAPACITY_POLICY> const &buffer) const noexcept {
+    return buffer.hash_value();
+  }
 };
 
 /// end cxx_api @}
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_chk.c b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_chk.c
index fdf5f8b406c..c87e543daa8 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_chk.c
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_chk.c
@@ -1,5 +1,5 @@
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 ///
 
 ///
@@ -16,9 +16,9 @@
 
 #define xMDBX_TOOLS /* Avoid using internal eASSERT() */
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
-#define MDBX_BUILD_SOURCERY 6b5df6869d2bf5419e3a8189d9cc849cc9911b9c8a951b9750ed0a261ce43724_v0_13_7_0_g566b0f93
+#define MDBX_BUILD_SOURCERY a575a490fc080ca11e89ff6db9f0bd38aa830959905998cac0e45274b9e6bb0e_v0_13_12_0_gf619d43d
 
 #define LIBMDBX_INTERNALS
 #define MDBX_DEPRECATED
@@ -1187,6 +1187,14 @@ typedef char pathchar_t;
 #define MDBX_PRIsPATH "s"
 #endif
 
+MDBX_MAYBE_UNUSED static inline bool osal_yield(void) {
+#if defined(_WIN32) || defined(_WIN64)
+  return SleepEx(0, true) == WAIT_IO_COMPLETION;
+#else
+  return sched_yield() != 0;
+#endif
+}
+
 typedef struct osal_mmap {
   union {
     void *base;
@@ -1206,6 +1214,8 @@ typedef struct osal_mmap {
 
 #define MDBX_HAVE_PWRITEV 0
 
+MDBX_INTERNAL int osal_waitstatus2errcode(DWORD result);
+
 #elif defined(__ANDROID_API__)
 
 #if __ANDROID_API__ < 24
@@ -1449,7 +1459,7 @@ enum osal_syncmode_bits {
 };
 
 MDBX_INTERNAL int osal_fsync(mdbx_filehandle_t fd, const enum osal_syncmode_bits mode_bits);
-MDBX_INTERNAL int osal_ftruncate(mdbx_filehandle_t fd, uint64_t length);
+MDBX_INTERNAL int osal_fsetsize(mdbx_filehandle_t fd, const uint64_t length);
 MDBX_INTERNAL int osal_fseek(mdbx_filehandle_t fd, uint64_t pos);
 MDBX_INTERNAL int osal_filesize(mdbx_filehandle_t fd, uint64_t *length);
 
@@ -1485,11 +1495,11 @@ MDBX_INTERNAL int osal_removedirectory(const pathchar_t *pathname);
 MDBX_INTERNAL int osal_is_pipe(mdbx_filehandle_t fd);
 MDBX_INTERNAL int osal_lockfile(mdbx_filehandle_t fd, bool wait);
 
-#define MMAP_OPTION_TRUNCATE 1
+#define MMAP_OPTION_SETLENGTH 1
 #define MMAP_OPTION_SEMAPHORE 2
 MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, const size_t limit, const unsigned options,
                             const pathchar_t *pathname4logging);
-MDBX_INTERNAL int osal_munmap(osal_mmap_t *map);
+MDBX_INTERNAL void osal_munmap(osal_mmap_t *map);
 #define MDBX_MRESIZE_MAY_MOVE 0x00000100
 #define MDBX_MRESIZE_MAY_UNMAP 0x00000200
 MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, size_t limit);
@@ -1892,7 +1902,8 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
     ((defined(_POSIX_THREAD_ROBUST_PRIO_INHERIT) && _POSIX_THREAD_ROBUST_PRIO_INHERIT > 0) ||                          \
      (defined(_POSIX_THREAD_ROBUST_PRIO_PROTECT) && _POSIX_THREAD_ROBUST_PRIO_PROTECT > 0) ||                          \
      defined(PTHREAD_MUTEX_ROBUST) || defined(PTHREAD_MUTEX_ROBUST_NP)) &&                                             \
-    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */)
+    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */) &&                   \
+    !defined(__OHOS__) /* Harmony OS doesn't support robust mutexes at the end of 2025 */
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2008
 #else
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2001
@@ -1947,6 +1958,22 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
 #error MDBX_USE_COPYFILERANGE must be defined as 0 or 1
 #endif /* MDBX_USE_COPYFILERANGE */
 
+/** Advanced: Using posix_fallocate() or fcntl(F_PREALLOCATE) on OSX (autodetection by default). */
+#ifndef MDBX_USE_FALLOCATE
+#if defined(__APPLE__)
+#define MDBX_USE_FALLOCATE 0 /* Too slow and unclean, but not required to prevent SIGBUS */
+#elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || (__GLIBC_PREREQ(2, 10) && defined(_GNU_SOURCE))
+#define MDBX_USE_FALLOCATE 1
+#else
+#define MDBX_USE_FALLOCATE 0
+#endif
+#define MDBX_USE_FALLOCATE_CONFIG "AUTO=" MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#elif !(MDBX_USE_FALLOCATE == 0 || MDBX_USE_FALLOCATE == 1)
+#error MDBX_USE_FALLOCATE must be defined as 0 or 1
+#else
+#define MDBX_USE_FALLOCATE_CONFIG MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#endif /* MDBX_USE_FALLOCATE */
+
 //------------------------------------------------------------------------------
 
 #ifndef MDBX_CPU_WRITEBACK_INCOHERENT
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_copy.c b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_copy.c
index 96e8c485c71..f31cb1b973a 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_copy.c
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_copy.c
@@ -1,7 +1,7 @@
 /// \copyright SPDX-License-Identifier: Apache-2.0
 /// \note Please refer to the COPYRIGHT file for explanations license change,
 /// credits and acknowledgments.
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 ///
 /// mdbx_copy.c - memory-mapped database backup tool
 ///
@@ -16,9 +16,9 @@
 
 #define xMDBX_TOOLS /* Avoid using internal eASSERT() */
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
-#define MDBX_BUILD_SOURCERY 6b5df6869d2bf5419e3a8189d9cc849cc9911b9c8a951b9750ed0a261ce43724_v0_13_7_0_g566b0f93
+#define MDBX_BUILD_SOURCERY a575a490fc080ca11e89ff6db9f0bd38aa830959905998cac0e45274b9e6bb0e_v0_13_12_0_gf619d43d
 
 #define LIBMDBX_INTERNALS
 #define MDBX_DEPRECATED
@@ -1187,6 +1187,14 @@ typedef char pathchar_t;
 #define MDBX_PRIsPATH "s"
 #endif
 
+MDBX_MAYBE_UNUSED static inline bool osal_yield(void) {
+#if defined(_WIN32) || defined(_WIN64)
+  return SleepEx(0, true) == WAIT_IO_COMPLETION;
+#else
+  return sched_yield() != 0;
+#endif
+}
+
 typedef struct osal_mmap {
   union {
     void *base;
@@ -1206,6 +1214,8 @@ typedef struct osal_mmap {
 
 #define MDBX_HAVE_PWRITEV 0
 
+MDBX_INTERNAL int osal_waitstatus2errcode(DWORD result);
+
 #elif defined(__ANDROID_API__)
 
 #if __ANDROID_API__ < 24
@@ -1449,7 +1459,7 @@ enum osal_syncmode_bits {
 };
 
 MDBX_INTERNAL int osal_fsync(mdbx_filehandle_t fd, const enum osal_syncmode_bits mode_bits);
-MDBX_INTERNAL int osal_ftruncate(mdbx_filehandle_t fd, uint64_t length);
+MDBX_INTERNAL int osal_fsetsize(mdbx_filehandle_t fd, const uint64_t length);
 MDBX_INTERNAL int osal_fseek(mdbx_filehandle_t fd, uint64_t pos);
 MDBX_INTERNAL int osal_filesize(mdbx_filehandle_t fd, uint64_t *length);
 
@@ -1485,11 +1495,11 @@ MDBX_INTERNAL int osal_removedirectory(const pathchar_t *pathname);
 MDBX_INTERNAL int osal_is_pipe(mdbx_filehandle_t fd);
 MDBX_INTERNAL int osal_lockfile(mdbx_filehandle_t fd, bool wait);
 
-#define MMAP_OPTION_TRUNCATE 1
+#define MMAP_OPTION_SETLENGTH 1
 #define MMAP_OPTION_SEMAPHORE 2
 MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, const size_t limit, const unsigned options,
                             const pathchar_t *pathname4logging);
-MDBX_INTERNAL int osal_munmap(osal_mmap_t *map);
+MDBX_INTERNAL void osal_munmap(osal_mmap_t *map);
 #define MDBX_MRESIZE_MAY_MOVE 0x00000100
 #define MDBX_MRESIZE_MAY_UNMAP 0x00000200
 MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, size_t limit);
@@ -1892,7 +1902,8 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
     ((defined(_POSIX_THREAD_ROBUST_PRIO_INHERIT) && _POSIX_THREAD_ROBUST_PRIO_INHERIT > 0) ||                          \
      (defined(_POSIX_THREAD_ROBUST_PRIO_PROTECT) && _POSIX_THREAD_ROBUST_PRIO_PROTECT > 0) ||                          \
      defined(PTHREAD_MUTEX_ROBUST) || defined(PTHREAD_MUTEX_ROBUST_NP)) &&                                             \
-    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */)
+    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */) &&                   \
+    !defined(__OHOS__) /* Harmony OS doesn't support robust mutexes at the end of 2025 */
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2008
 #else
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2001
@@ -1947,6 +1958,22 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
 #error MDBX_USE_COPYFILERANGE must be defined as 0 or 1
 #endif /* MDBX_USE_COPYFILERANGE */
 
+/** Advanced: Using posix_fallocate() or fcntl(F_PREALLOCATE) on OSX (autodetection by default). */
+#ifndef MDBX_USE_FALLOCATE
+#if defined(__APPLE__)
+#define MDBX_USE_FALLOCATE 0 /* Too slow and unclean, but not required to prevent SIGBUS */
+#elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || (__GLIBC_PREREQ(2, 10) && defined(_GNU_SOURCE))
+#define MDBX_USE_FALLOCATE 1
+#else
+#define MDBX_USE_FALLOCATE 0
+#endif
+#define MDBX_USE_FALLOCATE_CONFIG "AUTO=" MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#elif !(MDBX_USE_FALLOCATE == 0 || MDBX_USE_FALLOCATE == 1)
+#error MDBX_USE_FALLOCATE must be defined as 0 or 1
+#else
+#define MDBX_USE_FALLOCATE_CONFIG MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#endif /* MDBX_USE_FALLOCATE */
+
 //------------------------------------------------------------------------------
 
 #ifndef MDBX_CPU_WRITEBACK_INCOHERENT
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_drop.c b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_drop.c
index 319bcc13744..a0b0b7104a8 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_drop.c
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_drop.c
@@ -1,7 +1,7 @@
 /// \copyright SPDX-License-Identifier: Apache-2.0
 /// \note Please refer to the COPYRIGHT file for explanations license change,
 /// credits and acknowledgments.
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2021-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2021-2026
 ///
 /// mdbx_drop.c - memory-mapped database delete tool
 ///
@@ -16,9 +16,9 @@
 
 #define xMDBX_TOOLS /* Avoid using internal eASSERT() */
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
-#define MDBX_BUILD_SOURCERY 6b5df6869d2bf5419e3a8189d9cc849cc9911b9c8a951b9750ed0a261ce43724_v0_13_7_0_g566b0f93
+#define MDBX_BUILD_SOURCERY a575a490fc080ca11e89ff6db9f0bd38aa830959905998cac0e45274b9e6bb0e_v0_13_12_0_gf619d43d
 
 #define LIBMDBX_INTERNALS
 #define MDBX_DEPRECATED
@@ -1187,6 +1187,14 @@ typedef char pathchar_t;
 #define MDBX_PRIsPATH "s"
 #endif
 
+MDBX_MAYBE_UNUSED static inline bool osal_yield(void) {
+#if defined(_WIN32) || defined(_WIN64)
+  return SleepEx(0, true) == WAIT_IO_COMPLETION;
+#else
+  return sched_yield() != 0;
+#endif
+}
+
 typedef struct osal_mmap {
   union {
     void *base;
@@ -1206,6 +1214,8 @@ typedef struct osal_mmap {
 
 #define MDBX_HAVE_PWRITEV 0
 
+MDBX_INTERNAL int osal_waitstatus2errcode(DWORD result);
+
 #elif defined(__ANDROID_API__)
 
 #if __ANDROID_API__ < 24
@@ -1449,7 +1459,7 @@ enum osal_syncmode_bits {
 };
 
 MDBX_INTERNAL int osal_fsync(mdbx_filehandle_t fd, const enum osal_syncmode_bits mode_bits);
-MDBX_INTERNAL int osal_ftruncate(mdbx_filehandle_t fd, uint64_t length);
+MDBX_INTERNAL int osal_fsetsize(mdbx_filehandle_t fd, const uint64_t length);
 MDBX_INTERNAL int osal_fseek(mdbx_filehandle_t fd, uint64_t pos);
 MDBX_INTERNAL int osal_filesize(mdbx_filehandle_t fd, uint64_t *length);
 
@@ -1485,11 +1495,11 @@ MDBX_INTERNAL int osal_removedirectory(const pathchar_t *pathname);
 MDBX_INTERNAL int osal_is_pipe(mdbx_filehandle_t fd);
 MDBX_INTERNAL int osal_lockfile(mdbx_filehandle_t fd, bool wait);
 
-#define MMAP_OPTION_TRUNCATE 1
+#define MMAP_OPTION_SETLENGTH 1
 #define MMAP_OPTION_SEMAPHORE 2
 MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, const size_t limit, const unsigned options,
                             const pathchar_t *pathname4logging);
-MDBX_INTERNAL int osal_munmap(osal_mmap_t *map);
+MDBX_INTERNAL void osal_munmap(osal_mmap_t *map);
 #define MDBX_MRESIZE_MAY_MOVE 0x00000100
 #define MDBX_MRESIZE_MAY_UNMAP 0x00000200
 MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, size_t limit);
@@ -1892,7 +1902,8 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
     ((defined(_POSIX_THREAD_ROBUST_PRIO_INHERIT) && _POSIX_THREAD_ROBUST_PRIO_INHERIT > 0) ||                          \
      (defined(_POSIX_THREAD_ROBUST_PRIO_PROTECT) && _POSIX_THREAD_ROBUST_PRIO_PROTECT > 0) ||                          \
      defined(PTHREAD_MUTEX_ROBUST) || defined(PTHREAD_MUTEX_ROBUST_NP)) &&                                             \
-    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */)
+    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */) &&                   \
+    !defined(__OHOS__) /* Harmony OS doesn't support robust mutexes at the end of 2025 */
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2008
 #else
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2001
@@ -1947,6 +1958,22 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
 #error MDBX_USE_COPYFILERANGE must be defined as 0 or 1
 #endif /* MDBX_USE_COPYFILERANGE */
 
+/** Advanced: Using posix_fallocate() or fcntl(F_PREALLOCATE) on OSX (autodetection by default). */
+#ifndef MDBX_USE_FALLOCATE
+#if defined(__APPLE__)
+#define MDBX_USE_FALLOCATE 0 /* Too slow and unclean, but not required to prevent SIGBUS */
+#elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || (__GLIBC_PREREQ(2, 10) && defined(_GNU_SOURCE))
+#define MDBX_USE_FALLOCATE 1
+#else
+#define MDBX_USE_FALLOCATE 0
+#endif
+#define MDBX_USE_FALLOCATE_CONFIG "AUTO=" MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#elif !(MDBX_USE_FALLOCATE == 0 || MDBX_USE_FALLOCATE == 1)
+#error MDBX_USE_FALLOCATE must be defined as 0 or 1
+#else
+#define MDBX_USE_FALLOCATE_CONFIG MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#endif /* MDBX_USE_FALLOCATE */
+
 //------------------------------------------------------------------------------
 
 #ifndef MDBX_CPU_WRITEBACK_INCOHERENT
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_dump.c b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_dump.c
index 3193b1d34ce..784b9afd6e8 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_dump.c
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_dump.c
@@ -1,7 +1,7 @@
 /// \copyright SPDX-License-Identifier: Apache-2.0
 /// \note Please refer to the COPYRIGHT file for explanations license change,
 /// credits and acknowledgments.
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 ///
 /// mdbx_dump.c - memory-mapped database dump tool
 ///
@@ -16,9 +16,9 @@
 
 #define xMDBX_TOOLS /* Avoid using internal eASSERT() */
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
-#define MDBX_BUILD_SOURCERY 6b5df6869d2bf5419e3a8189d9cc849cc9911b9c8a951b9750ed0a261ce43724_v0_13_7_0_g566b0f93
+#define MDBX_BUILD_SOURCERY a575a490fc080ca11e89ff6db9f0bd38aa830959905998cac0e45274b9e6bb0e_v0_13_12_0_gf619d43d
 
 #define LIBMDBX_INTERNALS
 #define MDBX_DEPRECATED
@@ -1187,6 +1187,14 @@ typedef char pathchar_t;
 #define MDBX_PRIsPATH "s"
 #endif
 
+MDBX_MAYBE_UNUSED static inline bool osal_yield(void) {
+#if defined(_WIN32) || defined(_WIN64)
+  return SleepEx(0, true) == WAIT_IO_COMPLETION;
+#else
+  return sched_yield() != 0;
+#endif
+}
+
 typedef struct osal_mmap {
   union {
     void *base;
@@ -1206,6 +1214,8 @@ typedef struct osal_mmap {
 
 #define MDBX_HAVE_PWRITEV 0
 
+MDBX_INTERNAL int osal_waitstatus2errcode(DWORD result);
+
 #elif defined(__ANDROID_API__)
 
 #if __ANDROID_API__ < 24
@@ -1449,7 +1459,7 @@ enum osal_syncmode_bits {
 };
 
 MDBX_INTERNAL int osal_fsync(mdbx_filehandle_t fd, const enum osal_syncmode_bits mode_bits);
-MDBX_INTERNAL int osal_ftruncate(mdbx_filehandle_t fd, uint64_t length);
+MDBX_INTERNAL int osal_fsetsize(mdbx_filehandle_t fd, const uint64_t length);
 MDBX_INTERNAL int osal_fseek(mdbx_filehandle_t fd, uint64_t pos);
 MDBX_INTERNAL int osal_filesize(mdbx_filehandle_t fd, uint64_t *length);
 
@@ -1485,11 +1495,11 @@ MDBX_INTERNAL int osal_removedirectory(const pathchar_t *pathname);
 MDBX_INTERNAL int osal_is_pipe(mdbx_filehandle_t fd);
 MDBX_INTERNAL int osal_lockfile(mdbx_filehandle_t fd, bool wait);
 
-#define MMAP_OPTION_TRUNCATE 1
+#define MMAP_OPTION_SETLENGTH 1
 #define MMAP_OPTION_SEMAPHORE 2
 MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, const size_t limit, const unsigned options,
                             const pathchar_t *pathname4logging);
-MDBX_INTERNAL int osal_munmap(osal_mmap_t *map);
+MDBX_INTERNAL void osal_munmap(osal_mmap_t *map);
 #define MDBX_MRESIZE_MAY_MOVE 0x00000100
 #define MDBX_MRESIZE_MAY_UNMAP 0x00000200
 MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, size_t limit);
@@ -1892,7 +1902,8 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
     ((defined(_POSIX_THREAD_ROBUST_PRIO_INHERIT) && _POSIX_THREAD_ROBUST_PRIO_INHERIT > 0) ||                          \
      (defined(_POSIX_THREAD_ROBUST_PRIO_PROTECT) && _POSIX_THREAD_ROBUST_PRIO_PROTECT > 0) ||                          \
      defined(PTHREAD_MUTEX_ROBUST) || defined(PTHREAD_MUTEX_ROBUST_NP)) &&                                             \
-    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */)
+    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */) &&                   \
+    !defined(__OHOS__) /* Harmony OS doesn't support robust mutexes at the end of 2025 */
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2008
 #else
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2001
@@ -1947,6 +1958,22 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
 #error MDBX_USE_COPYFILERANGE must be defined as 0 or 1
 #endif /* MDBX_USE_COPYFILERANGE */
 
+/** Advanced: Using posix_fallocate() or fcntl(F_PREALLOCATE) on OSX (autodetection by default). */
+#ifndef MDBX_USE_FALLOCATE
+#if defined(__APPLE__)
+#define MDBX_USE_FALLOCATE 0 /* Too slow and unclean, but not required to prevent SIGBUS */
+#elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || (__GLIBC_PREREQ(2, 10) && defined(_GNU_SOURCE))
+#define MDBX_USE_FALLOCATE 1
+#else
+#define MDBX_USE_FALLOCATE 0
+#endif
+#define MDBX_USE_FALLOCATE_CONFIG "AUTO=" MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#elif !(MDBX_USE_FALLOCATE == 0 || MDBX_USE_FALLOCATE == 1)
+#error MDBX_USE_FALLOCATE must be defined as 0 or 1
+#else
+#define MDBX_USE_FALLOCATE_CONFIG MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#endif /* MDBX_USE_FALLOCATE */
+
 //------------------------------------------------------------------------------
 
 #ifndef MDBX_CPU_WRITEBACK_INCOHERENT
@@ -3422,10 +3449,10 @@ static int dump_tbl(MDBX_txn *txn, MDBX_dbi dbi, char *name) {
   if (mode & GLOBAL) {
     mode -= GLOBAL;
     if (info.mi_geo.upper != info.mi_geo.lower)
-      printf("geometry=l%" PRIu64 ",c%" PRIu64 ",u%" PRIu64 ",s%" PRIu64 ",g%" PRIu64 "\n", info.mi_geo.lower,
-             info.mi_geo.current, info.mi_geo.upper, info.mi_geo.shrink, info.mi_geo.grow);
+      printf("geometry=l%" PRIu64 ",u%" PRIu64 ",s%" PRIu64 ",g%" PRIu64 "\n", info.mi_geo.lower, info.mi_geo.upper,
+             info.mi_geo.shrink, info.mi_geo.grow);
     printf("mapsize=%" PRIu64 "\n", info.mi_geo.upper);
-    printf("maxreaders=%u\n", info.mi_maxreaders);
+    /* printf("maxreaders=%u\n", info.mi_maxreaders); */
 
     MDBX_canary canary;
     rc = mdbx_canary_get(txn, &canary);
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_load.c b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_load.c
index 0c1ceba53c2..4f4e3bb5629 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_load.c
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_load.c
@@ -1,7 +1,7 @@
 /// \copyright SPDX-License-Identifier: Apache-2.0
 /// \note Please refer to the COPYRIGHT file for explanations license change,
 /// credits and acknowledgments.
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 ///
 /// mdbx_load.c - memory-mapped database load tool
 ///
@@ -16,9 +16,9 @@
 
 #define xMDBX_TOOLS /* Avoid using internal eASSERT() */
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
-#define MDBX_BUILD_SOURCERY 6b5df6869d2bf5419e3a8189d9cc849cc9911b9c8a951b9750ed0a261ce43724_v0_13_7_0_g566b0f93
+#define MDBX_BUILD_SOURCERY a575a490fc080ca11e89ff6db9f0bd38aa830959905998cac0e45274b9e6bb0e_v0_13_12_0_gf619d43d
 
 #define LIBMDBX_INTERNALS
 #define MDBX_DEPRECATED
@@ -1187,6 +1187,14 @@ typedef char pathchar_t;
 #define MDBX_PRIsPATH "s"
 #endif
 
+MDBX_MAYBE_UNUSED static inline bool osal_yield(void) {
+#if defined(_WIN32) || defined(_WIN64)
+  return SleepEx(0, true) == WAIT_IO_COMPLETION;
+#else
+  return sched_yield() != 0;
+#endif
+}
+
 typedef struct osal_mmap {
   union {
     void *base;
@@ -1206,6 +1214,8 @@ typedef struct osal_mmap {
 
 #define MDBX_HAVE_PWRITEV 0
 
+MDBX_INTERNAL int osal_waitstatus2errcode(DWORD result);
+
 #elif defined(__ANDROID_API__)
 
 #if __ANDROID_API__ < 24
@@ -1449,7 +1459,7 @@ enum osal_syncmode_bits {
 };
 
 MDBX_INTERNAL int osal_fsync(mdbx_filehandle_t fd, const enum osal_syncmode_bits mode_bits);
-MDBX_INTERNAL int osal_ftruncate(mdbx_filehandle_t fd, uint64_t length);
+MDBX_INTERNAL int osal_fsetsize(mdbx_filehandle_t fd, const uint64_t length);
 MDBX_INTERNAL int osal_fseek(mdbx_filehandle_t fd, uint64_t pos);
 MDBX_INTERNAL int osal_filesize(mdbx_filehandle_t fd, uint64_t *length);
 
@@ -1485,11 +1495,11 @@ MDBX_INTERNAL int osal_removedirectory(const pathchar_t *pathname);
 MDBX_INTERNAL int osal_is_pipe(mdbx_filehandle_t fd);
 MDBX_INTERNAL int osal_lockfile(mdbx_filehandle_t fd, bool wait);
 
-#define MMAP_OPTION_TRUNCATE 1
+#define MMAP_OPTION_SETLENGTH 1
 #define MMAP_OPTION_SEMAPHORE 2
 MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, const size_t limit, const unsigned options,
                             const pathchar_t *pathname4logging);
-MDBX_INTERNAL int osal_munmap(osal_mmap_t *map);
+MDBX_INTERNAL void osal_munmap(osal_mmap_t *map);
 #define MDBX_MRESIZE_MAY_MOVE 0x00000100
 #define MDBX_MRESIZE_MAY_UNMAP 0x00000200
 MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, size_t limit);
@@ -1892,7 +1902,8 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
     ((defined(_POSIX_THREAD_ROBUST_PRIO_INHERIT) && _POSIX_THREAD_ROBUST_PRIO_INHERIT > 0) ||                          \
      (defined(_POSIX_THREAD_ROBUST_PRIO_PROTECT) && _POSIX_THREAD_ROBUST_PRIO_PROTECT > 0) ||                          \
      defined(PTHREAD_MUTEX_ROBUST) || defined(PTHREAD_MUTEX_ROBUST_NP)) &&                                             \
-    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */)
+    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */) &&                   \
+    !defined(__OHOS__) /* Harmony OS doesn't support robust mutexes at the end of 2025 */
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2008
 #else
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2001
@@ -1947,6 +1958,22 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
 #error MDBX_USE_COPYFILERANGE must be defined as 0 or 1
 #endif /* MDBX_USE_COPYFILERANGE */
 
+/** Advanced: Using posix_fallocate() or fcntl(F_PREALLOCATE) on OSX (autodetection by default). */
+#ifndef MDBX_USE_FALLOCATE
+#if defined(__APPLE__)
+#define MDBX_USE_FALLOCATE 0 /* Too slow and unclean, but not required to prevent SIGBUS */
+#elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || (__GLIBC_PREREQ(2, 10) && defined(_GNU_SOURCE))
+#define MDBX_USE_FALLOCATE 1
+#else
+#define MDBX_USE_FALLOCATE 0
+#endif
+#define MDBX_USE_FALLOCATE_CONFIG "AUTO=" MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#elif !(MDBX_USE_FALLOCATE == 0 || MDBX_USE_FALLOCATE == 1)
+#error MDBX_USE_FALLOCATE must be defined as 0 or 1
+#else
+#define MDBX_USE_FALLOCATE_CONFIG MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#endif /* MDBX_USE_FALLOCATE */
+
 //------------------------------------------------------------------------------
 
 #ifndef MDBX_CPU_WRITEBACK_INCOHERENT
@@ -3584,6 +3611,9 @@ static int readhdr(void) {
                   "%s: line %" PRIiSIZE ": ignore values %s"
                   " for '%s' in non-global context\n",
                   prog, lineno, str, "geometry");
+      } else if (sscanf(str, "l%" PRIu64 ",u%" PRIu64 ",s%" PRIu64 ",g%" PRIu64, &envinfo.mi_geo.lower,
+                        &envinfo.mi_geo.upper, &envinfo.mi_geo.shrink, &envinfo.mi_geo.grow) == 4) {
+        envinfo.mi_geo.current = (uint64_t)INT64_C(-1);
       } else if (sscanf(str, "l%" PRIu64 ",c%" PRIu64 ",u%" PRIu64 ",s%" PRIu64 ",g%" PRIu64, &envinfo.mi_geo.lower,
                         &envinfo.mi_geo.current, &envinfo.mi_geo.upper, &envinfo.mi_geo.shrink,
                         &envinfo.mi_geo.grow) != 5) {
@@ -3902,29 +3932,27 @@ int main(int argc, char *argv[]) {
     }
   }
 
-  if (envinfo.mi_geo.current | envinfo.mi_mapsize) {
-    if (envinfo.mi_geo.current) {
-      err = mdbx_env_set_geometry(env, (intptr_t)envinfo.mi_geo.lower, (intptr_t)envinfo.mi_geo.current,
-                                  (intptr_t)envinfo.mi_geo.upper, (intptr_t)envinfo.mi_geo.shrink,
-                                  (intptr_t)envinfo.mi_geo.grow,
-                                  envinfo.mi_dxb_pagesize ? (intptr_t)envinfo.mi_dxb_pagesize : -1);
-    } else {
-      if (envinfo.mi_mapsize > MAX_MAPSIZE) {
-        if (!quiet)
-          fprintf(stderr,
-                  "Database size is too large for current system (mapsize=%" PRIu64
-                  " is great than system-limit %zu)\n",
-                  envinfo.mi_mapsize, (size_t)MAX_MAPSIZE);
-        goto bailout;
-      }
-      err = mdbx_env_set_geometry(env, (intptr_t)envinfo.mi_mapsize, (intptr_t)envinfo.mi_mapsize,
-                                  (intptr_t)envinfo.mi_mapsize, 0, 0,
-                                  envinfo.mi_dxb_pagesize ? (intptr_t)envinfo.mi_dxb_pagesize : -1);
-    }
-    if (unlikely(err != MDBX_SUCCESS)) {
-      error("mdbx_env_set_geometry", err);
+  err = MDBX_SUCCESS;
+  if (envinfo.mi_geo.lower | envinfo.mi_geo.upper | envinfo.mi_geo.shrink | envinfo.mi_geo.grow) {
+    err = mdbx_env_set_geometry(env, (intptr_t)envinfo.mi_geo.lower, (intptr_t)envinfo.mi_geo.current,
+                                (intptr_t)envinfo.mi_geo.upper, (intptr_t)envinfo.mi_geo.grow,
+                                (intptr_t)envinfo.mi_geo.shrink,
+                                envinfo.mi_dxb_pagesize ? (intptr_t)envinfo.mi_dxb_pagesize : -1);
+  } else if (envinfo.mi_mapsize) {
+    if (envinfo.mi_mapsize > MAX_MAPSIZE) {
+      if (!quiet)
+        fprintf(stderr,
+                "Database size is too large for current system (mapsize=%" PRIu64 " is great than system-limit %zu)\n",
+                envinfo.mi_mapsize, (size_t)MAX_MAPSIZE);
       goto bailout;
     }
+    err = mdbx_env_set_geometry(env, (intptr_t)envinfo.mi_mapsize, (intptr_t)envinfo.mi_mapsize,
+                                (intptr_t)envinfo.mi_mapsize, 0, 0,
+                                envinfo.mi_dxb_pagesize ? (intptr_t)envinfo.mi_dxb_pagesize : -1);
+  }
+  if (unlikely(err != MDBX_SUCCESS)) {
+    error("mdbx_env_set_geometry", err);
+    goto bailout;
   }
 
   err = mdbx_env_open(env, envname, envflags, 0664);
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_stat.c b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_stat.c
index bd052d70a3c..4a0e9b3721d 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_stat.c
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/mdbx_stat.c
@@ -1,7 +1,7 @@
 /// \copyright SPDX-License-Identifier: Apache-2.0
 /// \note Please refer to the COPYRIGHT file for explanations license change,
 /// credits and acknowledgments.
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 ///
 /// mdbx_stat.c - memory-mapped database status tool
 ///
@@ -16,9 +16,9 @@
 
 #define xMDBX_TOOLS /* Avoid using internal eASSERT() */
 /// \copyright SPDX-License-Identifier: Apache-2.0
-/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
-#define MDBX_BUILD_SOURCERY 6b5df6869d2bf5419e3a8189d9cc849cc9911b9c8a951b9750ed0a261ce43724_v0_13_7_0_g566b0f93
+#define MDBX_BUILD_SOURCERY a575a490fc080ca11e89ff6db9f0bd38aa830959905998cac0e45274b9e6bb0e_v0_13_12_0_gf619d43d
 
 #define LIBMDBX_INTERNALS
 #define MDBX_DEPRECATED
@@ -1187,6 +1187,14 @@ typedef char pathchar_t;
 #define MDBX_PRIsPATH "s"
 #endif
 
+MDBX_MAYBE_UNUSED static inline bool osal_yield(void) {
+#if defined(_WIN32) || defined(_WIN64)
+  return SleepEx(0, true) == WAIT_IO_COMPLETION;
+#else
+  return sched_yield() != 0;
+#endif
+}
+
 typedef struct osal_mmap {
   union {
     void *base;
@@ -1206,6 +1214,8 @@ typedef struct osal_mmap {
 
 #define MDBX_HAVE_PWRITEV 0
 
+MDBX_INTERNAL int osal_waitstatus2errcode(DWORD result);
+
 #elif defined(__ANDROID_API__)
 
 #if __ANDROID_API__ < 24
@@ -1449,7 +1459,7 @@ enum osal_syncmode_bits {
 };
 
 MDBX_INTERNAL int osal_fsync(mdbx_filehandle_t fd, const enum osal_syncmode_bits mode_bits);
-MDBX_INTERNAL int osal_ftruncate(mdbx_filehandle_t fd, uint64_t length);
+MDBX_INTERNAL int osal_fsetsize(mdbx_filehandle_t fd, const uint64_t length);
 MDBX_INTERNAL int osal_fseek(mdbx_filehandle_t fd, uint64_t pos);
 MDBX_INTERNAL int osal_filesize(mdbx_filehandle_t fd, uint64_t *length);
 
@@ -1485,11 +1495,11 @@ MDBX_INTERNAL int osal_removedirectory(const pathchar_t *pathname);
 MDBX_INTERNAL int osal_is_pipe(mdbx_filehandle_t fd);
 MDBX_INTERNAL int osal_lockfile(mdbx_filehandle_t fd, bool wait);
 
-#define MMAP_OPTION_TRUNCATE 1
+#define MMAP_OPTION_SETLENGTH 1
 #define MMAP_OPTION_SEMAPHORE 2
 MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, const size_t limit, const unsigned options,
                             const pathchar_t *pathname4logging);
-MDBX_INTERNAL int osal_munmap(osal_mmap_t *map);
+MDBX_INTERNAL void osal_munmap(osal_mmap_t *map);
 #define MDBX_MRESIZE_MAY_MOVE 0x00000100
 #define MDBX_MRESIZE_MAY_UNMAP 0x00000200
 MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, size_t limit);
@@ -1892,7 +1902,8 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
     ((defined(_POSIX_THREAD_ROBUST_PRIO_INHERIT) && _POSIX_THREAD_ROBUST_PRIO_INHERIT > 0) ||                          \
      (defined(_POSIX_THREAD_ROBUST_PRIO_PROTECT) && _POSIX_THREAD_ROBUST_PRIO_PROTECT > 0) ||                          \
      defined(PTHREAD_MUTEX_ROBUST) || defined(PTHREAD_MUTEX_ROBUST_NP)) &&                                             \
-    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */)
+    (!defined(__GLIBC__) || __GLIBC_PREREQ(2, 10) /* troubles with Robust mutexes before 2.10 */) &&                   \
+    !defined(__OHOS__) /* Harmony OS doesn't support robust mutexes at the end of 2025 */
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2008
 #else
 #define MDBX_LOCKING MDBX_LOCKING_POSIX2001
@@ -1947,6 +1958,22 @@ MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t osal_bswap32
 #error MDBX_USE_COPYFILERANGE must be defined as 0 or 1
 #endif /* MDBX_USE_COPYFILERANGE */
 
+/** Advanced: Using posix_fallocate() or fcntl(F_PREALLOCATE) on OSX (autodetection by default). */
+#ifndef MDBX_USE_FALLOCATE
+#if defined(__APPLE__)
+#define MDBX_USE_FALLOCATE 0 /* Too slow and unclean, but not required to prevent SIGBUS */
+#elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || (__GLIBC_PREREQ(2, 10) && defined(_GNU_SOURCE))
+#define MDBX_USE_FALLOCATE 1
+#else
+#define MDBX_USE_FALLOCATE 0
+#endif
+#define MDBX_USE_FALLOCATE_CONFIG "AUTO=" MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#elif !(MDBX_USE_FALLOCATE == 0 || MDBX_USE_FALLOCATE == 1)
+#error MDBX_USE_FALLOCATE must be defined as 0 or 1
+#else
+#define MDBX_USE_FALLOCATE_CONFIG MDBX_STRINGIFY(MDBX_USE_FALLOCATE)
+#endif /* MDBX_USE_FALLOCATE */
+
 //------------------------------------------------------------------------------
 
 #ifndef MDBX_CPU_WRITEBACK_INCOHERENT
@@ -3489,7 +3516,6 @@ int main(int argc, char *argv[]) {
   signal(SIGTERM, signal_handler);
 #endif /* !WINDOWS */
 
-  envname = argv[optind];
   envname = argv[optind];
   if (!quiet) {
     printf("mdbx_stat %s (%s, T-%s)\nRunning for %s...\n", mdbx_version.git.describe, mdbx_version.git.datetime,
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/CMakeLists.txt b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/CMakeLists.txt
new file mode 100644
index 00000000000..6a9ee80de1b
--- /dev/null
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/CMakeLists.txt
@@ -0,0 +1,39 @@
+# Copyright (c) 2020-2026 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> ###############################################
+# SPDX-License-Identifier: Apache-2.0
+#
+project(mdbx_ut_and_examples)
+
+if(NOT DEFINED MDBX_LIBRARY)
+  set(MDBX_LIBRARY mdbx)
+endif()
+
+if(MDBX_BUILD_CXX AND CMAKE_CXX_COMPILER_LOADED AND NOT MDBX_CXX_STANDARD LESS 17)
+  add_executable(mdbx_modern_example example-mdbx.c++)
+  set_target_properties(mdbx_modern_example PROPERTIES CXX_STANDARD ${MDBX_CXX_STANDARD} CXX_STANDARD_REQUIRED ON)
+  target_link_libraries(mdbx_modern_example ${MDBX_LIBRARY})
+  if(DEFINED INTERPROCEDURAL_OPTIMIZATION)
+    set_target_properties(mdbx_modern_example PROPERTIES INTERPROCEDURAL_OPTIMIZATION $<BOOL:${INTERPROCEDURAL_OPTIMIZATION}>)
+  endif()
+else()
+  message(NOTICE "The C++ example will be skipped, since C++17 standard is unavailable or C++ API of libmdbx was disabled.")
+  set(MDBX_BUILD_CXX FALSE)
+endif()
+
+add_executable(mdbx_legacy_example example-mdbx.c)
+target_link_libraries(mdbx_legacy_example ${MDBX_LIBRARY})
+
+if(CMAKE_CROSSCOMPILING AND NOT CMAKE_CROSSCOMPILING_EMULATOR)
+  message(NOTICE "No emulator to run cross-compiled tests")
+  add_test(NAME fake_since_no_crosscompiling_emulator COMMAND ${CMAKE_COMMAND} -E echo
+                                                              "No emulator to run cross-compiled tests")
+else()
+  add_test(NAME c_api COMMAND mdbx_legacy_example)
+  if(MDBX_BUILD_CXX)
+    add_test(NAME c++_api COMMAND mdbx_modern_example)
+  endif()
+endif()
+
+if(UNIX)
+  add_executable(pcrf_simulator pcrf/pcrf_simulator.c)
+  target_link_libraries(pcrf_simulator ${MDBX_LIBRARY})
+endif()
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/README.md b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/README.md
new file mode 100644
index 00000000000..cdfff30d932
--- /dev/null
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/README.md
@@ -0,0 +1,11 @@
+## Examples & Unit tests
+
+This set of examples will be updated, and most of the examples are also publicly available tests.
+
+### C API
+The [`example-mdbx.c`](example-mdbx.c) is the example of using the C API.
+However, it is strongly recommended to use the modern [C++ API](https://libmdbx.dqdkfa.ru/group__cxx__api.html), which requires less effort
+and insures against many errors related to resource leaks.
+
+### Berkeley DB
+If you have already used Berkeley DB, then it will be useful to make a line-by-line comparison of [`example-mdbx.c`](example-mdbx.c) and the [`sample-bdb.txt`](sample-bdb.txt) file.
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/example-mdbx.c b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/example-mdbx.c
new file mode 100644
index 00000000000..c9b19b77f04
--- /dev/null
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/example-mdbx.c
@@ -0,0 +1,167 @@
+/** \file The example of using the libmdbx C API.
+ * However, it is strongly recommended to use the modern C++ API, which requires less effort
+ * and insures against many errors related to resource leaks.
+ *
+ * \note If you have already used Berkeley DB,
+ * it will be useful to make a line-by-line comparison of this example and the sample-bdb.txt
+ */
+
+/*
+ * Copyright 2015-2026 Leonid Yuriev <leo@yuriev.ru>.
+ * Copyright 2017 Ilya Shipitsin <chipitsine@gmail.com>.
+ * Copyright 2012-2015 Howard Chu, Symas Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+
+#if (defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)) && !defined(__USE_MINGW_ANSI_STDIO)
+#define __USE_MINGW_ANSI_STDIO 1
+#endif /* MinGW */
+
+#include "mdbx.h"
+
+#include <limits.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[]) {
+  (void)argc;
+  (void)argv;
+
+  int rc;
+  MDBX_env *env = NULL;
+  MDBX_dbi dbi = 0;
+  MDBX_val key, data;
+  MDBX_txn *txn = NULL;
+  MDBX_cursor *cursor = NULL;
+  char sval[32];
+
+  printf("MDBX limits:\n");
+#if UINTPTR_MAX > 0xffffFFFFul || ULONG_MAX > 0xffffFFFFul
+  const double scale_factor = 1099511627776.0;
+  const char *const scale_unit = "TiB";
+#else
+  const double scale_factor = 1073741824.0;
+  const char *const scale_unit = "GiB";
+#endif
+  const size_t pagesize_min = mdbx_limits_pgsize_min();
+  const size_t pagesize_max = mdbx_limits_pgsize_max();
+  const size_t pagesize_default = mdbx_default_pagesize();
+
+  printf("\tPage size: a power of 2, minimum %zu, maximum %zu bytes,"
+         " default %zu bytes.\n",
+         pagesize_min, pagesize_max, pagesize_default);
+  printf("\tKey size: minimum %zu, maximum ≈¼ pagesize (%zu bytes for default"
+         " %zuK pagesize, %zu bytes for %zuK pagesize).\n",
+         (size_t)0, mdbx_limits_keysize_max(-1, MDBX_DB_DEFAULTS), pagesize_default / 1024,
+         mdbx_limits_keysize_max(pagesize_max, MDBX_DB_DEFAULTS), pagesize_max / 1024);
+  printf("\tValue size: minimum %zu, maximum %zu (0x%08zX) bytes for maps,"
+         " ≈¼ pagesize for multimaps (%zu bytes for default %zuK pagesize,"
+         " %zu bytes for %zuK pagesize).\n",
+         (size_t)0, mdbx_limits_valsize_max(pagesize_min, MDBX_DB_DEFAULTS),
+         mdbx_limits_valsize_max(pagesize_min, MDBX_DB_DEFAULTS), mdbx_limits_valsize_max(-1, MDBX_DUPSORT),
+         pagesize_default / 1024, mdbx_limits_valsize_max(pagesize_max, MDBX_DUPSORT), pagesize_max / 1024);
+  printf("\tWrite transaction size: up to %zu (0x%zX) pages (%f %s for default "
+         "%zuK pagesize, %f %s for %zuK pagesize).\n",
+         mdbx_limits_txnsize_max(pagesize_min) / pagesize_min, mdbx_limits_txnsize_max(pagesize_min) / pagesize_min,
+         mdbx_limits_txnsize_max(-1) / scale_factor, scale_unit, pagesize_default / 1024,
+         mdbx_limits_txnsize_max(pagesize_max) / scale_factor, scale_unit, pagesize_max / 1024);
+  printf("\tDatabase size: up to %zu pages (%f %s for default %zuK "
+         "pagesize, %f %s for %zuK pagesize).\n",
+         mdbx_limits_dbsize_max(pagesize_min) / pagesize_min, mdbx_limits_dbsize_max(-1) / scale_factor, scale_unit,
+         pagesize_default / 1024, mdbx_limits_dbsize_max(pagesize_max) / scale_factor, scale_unit, pagesize_max / 1024);
+  printf("\tMaximum sub-databases: %u.\n", MDBX_MAX_DBI);
+  printf("-----\n");
+
+  rc = mdbx_env_create(&env);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_env_create: (%d) %s\n", rc, mdbx_strerror(rc));
+    goto bailout;
+  }
+
+  /* This deletion is not necessary, but it has been added here for full reproducibility of the conditions when running
+   * this example again as a simplest test. */
+  rc = mdbx_env_delete("./example-db", MDBX_ENV_JUST_DELETE);
+  if (rc != /* file was successfully deleted */ MDBX_SUCCESS &&
+      rc != /* nothing has been done because the file is missing */ MDBX_RESULT_TRUE) {
+    fprintf(stderr, "mdbx_env_delete: (%d) %s\n", rc, mdbx_strerror(rc));
+    goto bailout;
+  }
+
+  rc = mdbx_env_open(env, "./example-db", MDBX_NOSUBDIR | MDBX_LIFORECLAIM, 0664);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_env_open: (%d) %s\n", rc, mdbx_strerror(rc));
+    goto bailout;
+  }
+
+  rc = mdbx_txn_begin(env, NULL, 0, &txn);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_txn_begin: (%d) %s\n", rc, mdbx_strerror(rc));
+    goto bailout;
+  }
+  rc = mdbx_dbi_open(txn, NULL, 0, &dbi);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_dbi_open: (%d) %s\n", rc, mdbx_strerror(rc));
+    goto bailout;
+  }
+
+  key.iov_len = sizeof(int);
+  key.iov_base = sval;
+  data.iov_len = sizeof(sval);
+  data.iov_base = sval;
+
+  snprintf(sval, sizeof(sval), "%03x %d foo bar", 32, 3141592);
+  rc = mdbx_put(txn, dbi, &key, &data, 0);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_put: (%d) %s\n", rc, mdbx_strerror(rc));
+    goto bailout;
+  }
+  rc = mdbx_txn_commit(txn);
+  if (rc) {
+    fprintf(stderr, "mdbx_txn_commit: (%d) %s\n", rc, mdbx_strerror(rc));
+    goto bailout;
+  }
+  txn = NULL;
+
+  rc = mdbx_txn_begin(env, NULL, MDBX_TXN_RDONLY, &txn);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_txn_begin: (%d) %s\n", rc, mdbx_strerror(rc));
+    goto bailout;
+  }
+  rc = mdbx_cursor_open(txn, dbi, &cursor);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_cursor_open: (%d) %s\n", rc, mdbx_strerror(rc));
+    goto bailout;
+  }
+
+  int found = 0;
+  while ((rc = mdbx_cursor_get(cursor, &key, &data, MDBX_NEXT)) == 0) {
+    printf("key: %p %.*s, data: %p %.*s\n", key.iov_base, (int)key.iov_len, (char *)key.iov_base, data.iov_base,
+           (int)data.iov_len, (char *)data.iov_base);
+    found += 1;
+  }
+  if (rc != MDBX_NOTFOUND || found == 0) {
+    fprintf(stderr, "mdbx_cursor_get: (%d) %s\n", rc, mdbx_strerror(rc));
+    goto bailout;
+  } else {
+    rc = MDBX_SUCCESS;
+  }
+bailout:
+  if (cursor)
+    mdbx_cursor_close(cursor);
+  if (txn)
+    mdbx_txn_abort(txn);
+  if (dbi)
+    mdbx_dbi_close(env, dbi);
+  if (env)
+    mdbx_env_close(env);
+  return (rc != MDBX_SUCCESS) ? EXIT_FAILURE : EXIT_SUCCESS;
+}
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/example-mdbx.c++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/example-mdbx.c++
new file mode 100644
index 00000000000..7e1a9ed2dc3
--- /dev/null
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/example-mdbx.c++
@@ -0,0 +1,99 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2026
+/// \file The example of using the libmdbx modern C++ API.
+
+#include <iostream>
+#include <mdbx.h++>
+
+/* This is a minimal example now, which will be expanded soon. */
+
+static void тысяча(const mdbx::path &database_pathname, const mdbx::env::mode mode, mdbx::env::durability durability) {
+  mdbx::env::remove(database_pathname);
+  std::cout << "INSERTIONx1000(" << mode << ", " << durability << ")" << std::endl;
+
+  mdbx::env_managed env(database_pathname, mdbx::env_managed::create_parameters(),
+                        mdbx::env::operate_parameters(3, 0, mode, durability));
+  for (int i = 0; i < 1000; ++i) {
+    auto txn = env.start_write();
+    auto map = txn.create_map("table-data", mdbx::key_mode::usual, mdbx::value_mode::single);
+
+    auto k = std::to_string(i);
+    auto v = mdbx::to_base58(mdbx::slice::wrap(i)).as_string();
+    txn.insert(map, mdbx::slice(k), mdbx::slice(v));
+    txn.commit();
+  }
+
+  auto info = env.get_info();
+
+  // std::cout << "  pgop.newly: " << info.mi_pgop_stat.newly << "\n";
+  // std::cout << "  pgop.cow: " << info.mi_pgop_stat.cow << "\n";
+  // std::cout << "  pgop.clone: " << info.mi_pgop_stat.clone << "\n";
+  // std::cout << "  pgop.split: " << info.mi_pgop_stat.split << "\n";
+  // std::cout << "  pgop.merge: " << info.mi_pgop_stat.merge << "\n  --\n";
+
+  // std::cout << "  pgop.spill: " << info.mi_pgop_stat.spill << "\n";
+  // std::cout << "  pgop.unspill: " << info.mi_pgop_stat.unspill << "\n";
+  // std::cout << "  pgop.mincore: " << info.mi_pgop_stat.mincore << "\n  --\n";
+
+  std::cout << "  pgop.prefault: " << info.mi_pgop_stat.prefault << "\n";
+  std::cout << "  pgop.msync: " << info.mi_pgop_stat.msync << "\n";
+  std::cout << "  pgop.fsync: " << info.mi_pgop_stat.fsync << "\n";
+  std::cout << "  pgop.wops: " << info.mi_pgop_stat.wops << "\n=====\n" << std::endl;
+}
+
+static bool doit(const mdbx::path &database_pathname) {
+  using buffer = mdbx::buffer<mdbx::default_allocator, mdbx::default_capacity_policy>;
+  mdbx::env::remove(database_pathname);
+  auto operate_parameters = mdbx::env::operate_parameters();
+  operate_parameters.max_maps = 11;
+  operate_parameters.options.nested_write_transactions = true;
+  mdbx::env_managed env(database_pathname, mdbx::env_managed::create_parameters(), operate_parameters);
+
+  auto txn = env.start_write();
+  auto map = txn.create_map("table-ordinals", mdbx::key_mode::ordinal, mdbx::value_mode::single);
+  txn.insert(map, buffer::key_from_u64(42), "a");
+  txn.insert(map, buffer::key_from_double(0.1), mdbx::slice("b"));
+  txn.insert(map, buffer::key_from_jsonInteger(1), buffer("c"));
+  txn.insert(map, mdbx::slice::wrap(uint64_t(0xaBad1dea)), buffer::base58("aBad1dea"));
+
+  auto cursor = txn.open_cursor(map);
+  cursor.to_first();
+  while (!cursor.eof()) {
+    std::cout << cursor.current() << std::endl;
+    cursor.to_next(false);
+  }
+
+  auto nested = txn.start_nested();
+  cursor = nested.open_cursor(map);
+  size_t count = 0;
+  cursor.fullscan([&](const mdbx::pair &) -> bool {
+    count += 1;
+    return /* don't breaking/existing the scanning loop */ false;
+  });
+  nested.commit();
+  nested = txn.start_nested();
+
+  return count == nested.get_map_stat(map).ms_entries;
+}
+
+int main(int, const char *[]) {
+  try {
+    const mdbx::path bench_database =
+#if !(defined(_WIN32) || defined(_WIN64))
+        "/tmp/"
+#endif /* !Windows */
+        "bench_example_database.mdbx";
+    тысяча(bench_database, mdbx::env::mode::write_file_io, mdbx::env::durability::robust_synchronous);
+    тысяча(bench_database, mdbx::env::mode::write_file_io, mdbx::env::durability::half_synchronous_weak_last);
+    тысяча(bench_database, mdbx::env::mode::write_file_io, mdbx::env::durability::lazy_weak_tail);
+    тысяча(bench_database, mdbx::env::mode::write_file_io, mdbx::env::durability::whole_fragile);
+    тысяча(bench_database, mdbx::env::mode::write_mapped_io, mdbx::env::durability::robust_synchronous);
+    тысяча(bench_database, mdbx::env::mode::write_mapped_io, mdbx::env::durability::half_synchronous_weak_last);
+    тысяча(bench_database, mdbx::env::mode::write_mapped_io, mdbx::env::durability::lazy_weak_tail);
+    тысяча(bench_database, mdbx::env::mode::write_mapped_io, mdbx::env::durability::whole_fragile);
+    return doit("example_database") ? EXIT_SUCCESS : EXIT_FAILURE;
+  } catch (const std::exception &ex) {
+    std::cerr << "Exception: " << ex.what() << "\n";
+    return EXIT_FAILURE;
+  }
+}
diff --git a/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/pcrf/pcrf_simulator.c b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/pcrf/pcrf_simulator.c
new file mode 100644
index 00000000000..89f912441f4
--- /dev/null
+++ b/crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/pcrf/pcrf_simulator.c
@@ -0,0 +1,367 @@
+/*
+ * Copyright 2015 Vladimir Romanov
+ * <https://www.linkedin.com/in/vladimirromanov>, Yota Lab.
+ * SPDX-License-Identifier: AGPL-3.0
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. */
+
+#include <sys/stat.h>
+#include <sys/time.h>
+
+#include "mdbx.h"
+#include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define IP_PRINTF_ARG_HOST(addr)                                                                                       \
+  (int)((addr) >> 24), (int)((addr) >> 16 & 0xff), (int)((addr) >> 8 & 0xff), (int)((addr) & 0xff)
+
+char opt_db_path[PATH_MAX] = "./mdbx_bench2";
+static MDBX_env *env;
+#define REC_COUNT 10240000
+int64_t ids[REC_COUNT * 10];
+int32_t ids_count = 0;
+
+int64_t mdbx_add_count = 0;
+int64_t mdbx_del_count = 0;
+uint64_t mdbx_add_time = 0;
+uint64_t mdbx_del_time = 0;
+int64_t obj_id = 0;
+int64_t mdbx_data_size = 0;
+int64_t mdbx_key_size = 0;
+
+typedef struct {
+  char session_id1[100];
+  char session_id2[100];
+  char ip[20];
+  uint8_t fill[100];
+} session_data_t;
+
+typedef struct {
+  int64_t obj_id;
+  int8_t event_type;
+} __attribute__((__packed__)) event_data_t;
+
+static void add_id_to_pool(int64_t id) {
+  ids[ids_count] = id;
+  ids_count++;
+}
+
+static inline int64_t getClockUs(void) {
+  struct timespec val;
+#ifdef CYGWIN
+  clock_gettime(CLOCK_REALTIME, &val);
+#else
+  clock_gettime(CLOCK_MONOTONIC, &val);
+#endif
+  return val.tv_sec * ((int64_t)1000000) + val.tv_nsec / 1000;
+}
+
+static int64_t get_id_from_pool() {
+  if (ids_count == 0) {
+    return -1;
+  }
+  int32_t index = rand() % ids_count;
+  int64_t id = ids[index];
+  ids[index] = ids[ids_count - 1];
+  ids_count--;
+  return id;
+}
+
+#define MDBX_CHECK(x)                                                                                                  \
+  do {                                                                                                                 \
+    const int rc = (x);                                                                                                \
+    if (rc != MDBX_SUCCESS) {                                                                                          \
+      printf("Error [%d] %s in %s at %s:%d\n", rc, mdbx_strerror(rc), #x, __FILE__, __LINE__);                         \
+      exit(EXIT_FAILURE);                                                                                              \
+    }                                                                                                                  \
+  } while (0)
+
+static void db_connect() {
+  MDBX_dbi dbi_session;
+  MDBX_dbi dbi_session_id;
+  MDBX_dbi dbi_event;
+  MDBX_dbi dbi_ip;
+
+  MDBX_CHECK(mdbx_env_create(&env));
+  MDBX_CHECK(mdbx_env_set_geometry(env, 0, 0, REC_COUNT * sizeof(session_data_t) * 10, -1, -1, -1));
+  MDBX_CHECK(mdbx_env_set_maxdbs(env, 30));
+  MDBX_CHECK(
+      mdbx_env_open(env, opt_db_path, MDBX_CREATE | MDBX_WRITEMAP | MDBX_UTTERLY_NOSYNC | MDBX_LIFORECLAIM, 0664));
+  MDBX_txn *txn;
+
+  // transaction init
+  MDBX_CHECK(mdbx_txn_begin(env, NULL, 0, &txn));
+  // open database in read-write mode
+  MDBX_CHECK(mdbx_dbi_open(txn, "session", MDBX_CREATE, &dbi_session));
+  MDBX_CHECK(mdbx_dbi_open(txn, "session_id", MDBX_CREATE, &dbi_session_id));
+  MDBX_CHECK(mdbx_dbi_open(txn, "event", MDBX_CREATE, &dbi_event));
+  MDBX_CHECK(mdbx_dbi_open(txn, "ip", MDBX_CREATE, &dbi_ip));
+  // transaction commit
+  MDBX_CHECK(mdbx_txn_commit(txn));
+  printf("Connection open\n");
+}
+
+static void create_record(uint64_t record_id) {
+  MDBX_dbi dbi_session;
+  MDBX_dbi dbi_session_id;
+  MDBX_dbi dbi_event;
+  MDBX_dbi dbi_ip;
+  event_data_t event;
+  MDBX_txn *txn;
+  session_data_t data;
+  // transaction init
+  snprintf(data.session_id1, sizeof(data.session_id1), "prefix%02u_%02u.fill.fill.fill.fill.fill.fill;%" PRIu64,
+           (unsigned)(record_id % 3) + 1, (unsigned)(record_id % 9) + 1, record_id);
+  snprintf(data.session_id2, sizeof(data.session_id2), "dprefix%" PRIu64 ";%" PRIu64 ".fill.fill.;suffix", record_id,
+           (record_id + UINT64_C(1442695040888963407)) % UINT64_C(6364136223846793005));
+  snprintf(data.ip, sizeof(data.ip), "%d.%d.%d.%d", IP_PRINTF_ARG_HOST(record_id & 0xFFFFFFFF));
+  event.obj_id = record_id;
+  event.event_type = 1;
+
+  MDBX_val _session_id1_rec = {data.session_id1, strlen(data.session_id1)};
+  MDBX_val _session_id2_rec = {data.session_id2, strlen(data.session_id2)};
+  MDBX_val _ip_rec = {data.ip, strlen(data.ip)};
+  MDBX_val _obj_id_rec = {&record_id, sizeof(record_id)};
+  MDBX_val _data_rec = {&data, offsetof(session_data_t, fill) + (rand() % sizeof(data.fill))};
+  MDBX_val _event_rec = {&event, sizeof(event)};
+
+  uint64_t start = getClockUs();
+  MDBX_CHECK(mdbx_txn_begin(env, NULL, 0, &txn));
+  MDBX_CHECK(mdbx_dbi_open(txn, "session", MDBX_CREATE, &dbi_session));
+  MDBX_CHECK(mdbx_dbi_open(txn, "session_id", MDBX_CREATE, &dbi_session_id));
+  MDBX_CHECK(mdbx_dbi_open(txn, "event", MDBX_CREATE, &dbi_event));
+  MDBX_CHECK(mdbx_dbi_open(txn, "ip", MDBX_CREATE, &dbi_ip));
+  MDBX_CHECK(mdbx_put(txn, dbi_session, &_obj_id_rec, &_data_rec, MDBX_NOOVERWRITE | MDBX_NODUPDATA));
+  MDBX_CHECK(mdbx_put(txn, dbi_session_id, &_session_id1_rec, &_obj_id_rec, MDBX_NOOVERWRITE | MDBX_NODUPDATA));
+  MDBX_CHECK(mdbx_put(txn, dbi_session_id, &_session_id2_rec, &_obj_id_rec, MDBX_NOOVERWRITE | MDBX_NODUPDATA));
+  MDBX_CHECK(mdbx_put(txn, dbi_ip, &_ip_rec, &_obj_id_rec, 0));
+  MDBX_CHECK(mdbx_put(txn, dbi_event, &_event_rec, &_obj_id_rec, 0));
+  MDBX_CHECK(mdbx_txn_commit(txn));
+
+  mdbx_data_size += (_data_rec.iov_len + _obj_id_rec.iov_len * 4);
+  mdbx_key_size += (_obj_id_rec.iov_len + _session_id1_rec.iov_len + _session_id2_rec.iov_len + _ip_rec.iov_len +
+                    _event_rec.iov_len);
+
+  // transaction commit
+  mdbx_add_count++;
+  mdbx_add_time += (getClockUs() - start);
+}
+
+static void delete_record(int64_t record_id) {
+  MDBX_dbi dbi_session;
+  MDBX_dbi dbi_session_id;
+  MDBX_dbi dbi_event;
+  MDBX_dbi dbi_ip;
+  event_data_t event;
+  MDBX_txn *txn;
+
+  // transaction init
+  uint64_t start = getClockUs();
+  MDBX_CHECK(mdbx_txn_begin(env, NULL, 0, &txn));
+  // open database in read-write mode
+  MDBX_CHECK(mdbx_dbi_open(txn, "session", MDBX_CREATE, &dbi_session));
+  MDBX_CHECK(mdbx_dbi_open(txn, "session_id", MDBX_CREATE, &dbi_session_id));
+  MDBX_CHECK(mdbx_dbi_open(txn, "event", MDBX_CREATE, &dbi_event));
+  MDBX_CHECK(mdbx_dbi_open(txn, "ip", MDBX_CREATE, &dbi_ip));
+  // put data
+  MDBX_val _obj_id_rec = {&record_id, sizeof(record_id)};
+  MDBX_val _data_rec;
+  // get data
+  MDBX_CHECK(mdbx_get(txn, dbi_session, &_obj_id_rec, &_data_rec));
+  session_data_t *data = (session_data_t *)_data_rec.iov_base;
+
+  MDBX_val _session_id1_rec = {data->session_id1, strlen(data->session_id1)};
+  MDBX_val _session_id2_rec = {data->session_id2, strlen(data->session_id2)};
+  MDBX_val _ip_rec = {data->ip, strlen(data->ip)};
+  MDBX_CHECK(mdbx_del(txn, dbi_session_id, &_session_id1_rec, NULL));
+  MDBX_CHECK(mdbx_del(txn, dbi_session_id, &_session_id2_rec, NULL));
+  MDBX_CHECK(mdbx_del(txn, dbi_ip, &_ip_rec, NULL));
+  event.obj_id = record_id;
+  event.event_type = 1;
+  MDBX_val _event_rec = {&event, sizeof(event)};
+  MDBX_CHECK(mdbx_del(txn, dbi_event, &_event_rec, NULL));
+  MDBX_CHECK(mdbx_del(txn, dbi_session, &_obj_id_rec, NULL));
+
+  mdbx_data_size -= (_data_rec.iov_len + _obj_id_rec.iov_len * 4);
+  mdbx_key_size -= (_obj_id_rec.iov_len + _session_id1_rec.iov_len + _session_id2_rec.iov_len + _ip_rec.iov_len +
+                    _event_rec.iov_len);
+
+  // transaction commit
+  MDBX_CHECK(mdbx_txn_commit(txn));
+  mdbx_del_count++;
+  mdbx_del_time += (getClockUs() - start);
+}
+
+static void db_disconnect() {
+  mdbx_env_close(env);
+  printf("Connection closed\n");
+}
+
+static void get_db_stat(const char *db, int64_t *ms_branch_pages, int64_t *ms_leaf_pages) {
+  MDBX_txn *txn;
+  MDBX_stat stat;
+  MDBX_dbi dbi;
+
+  MDBX_CHECK(mdbx_txn_begin(env, NULL, MDBX_TXN_RDONLY, &txn));
+  MDBX_CHECK(mdbx_dbi_open(txn, db, MDBX_DB_ACCEDE, &dbi));
+  MDBX_CHECK(mdbx_dbi_stat(txn, dbi, &stat, sizeof(stat)));
+  mdbx_txn_abort(txn);
+  printf("%15s | %15" PRIu64 " | %5u | %10" PRIu64 " | %10" PRIu64 " | %11" PRIu64 " |\n", db, stat.ms_branch_pages,
+         stat.ms_depth, stat.ms_entries, stat.ms_leaf_pages, stat.ms_overflow_pages);
+  (*ms_branch_pages) += stat.ms_branch_pages;
+  (*ms_leaf_pages) += stat.ms_leaf_pages;
+}
+
+static void periodic_stat(void) {
+  int64_t ms_branch_pages = 0;
+  int64_t ms_leaf_pages = 0;
+  MDBX_stat mst;
+  MDBX_envinfo mei;
+  MDBX_CHECK(mdbx_env_stat_ex(env, NULL, &mst, sizeof(mst)));
+  MDBX_CHECK(mdbx_env_info_ex(env, NULL, &mei, sizeof(mei)));
+  printf("Environment Info\n");
+  printf("  Pagesize: %u\n", mst.ms_psize);
+  if (mei.mi_geo.lower != mei.mi_geo.upper) {
+    printf("  Dynamic datafile: %" PRIu64 "..%" PRIu64 " bytes (+%" PRIu64 "/-%" PRIu64 "), %" PRIu64 "..%" PRIu64
+           " pages (+%" PRIu64 "/-%" PRIu64 ")\n",
+           mei.mi_geo.lower, mei.mi_geo.upper, mei.mi_geo.grow, mei.mi_geo.shrink, mei.mi_geo.lower / mst.ms_psize,
+           mei.mi_geo.upper / mst.ms_psize, mei.mi_geo.grow / mst.ms_psize, mei.mi_geo.shrink / mst.ms_psize);
+    printf("  Current datafile: %" PRIu64 " bytes, %" PRIu64 " pages\n", mei.mi_geo.current,
+           mei.mi_geo.current / mst.ms_psize);
+  } else {
+    printf("  Fixed datafile: %" PRIu64 " bytes, %" PRIu64 " pages\n", mei.mi_geo.current,
+           mei.mi_geo.current / mst.ms_psize);
+  }
+  printf("  Current mapsize: %" PRIu64 " bytes, %" PRIu64 " pages \n", mei.mi_mapsize, mei.mi_mapsize / mst.ms_psize);
+  printf("  Number of pages used: %" PRIu64 "\n", mei.mi_last_pgno + 1);
+  printf("  Last transaction ID: %" PRIu64 "\n", mei.mi_recent_txnid);
+  printf("  Tail transaction ID: %" PRIu64 " (%" PRIi64 ")\n", mei.mi_latter_reader_txnid,
+         mei.mi_latter_reader_txnid - mei.mi_recent_txnid);
+  printf("  Max readers: %u\n", mei.mi_maxreaders);
+  printf("  Number of readers used: %u\n", mei.mi_numreaders);
+
+  printf("           Name | ms_branch_pages | depth |    entries | leaf_pages "
+         "| overf_pages |\n");
+  get_db_stat("session", &ms_branch_pages, &ms_leaf_pages);
+  get_db_stat("session_id", &ms_branch_pages, &ms_leaf_pages);
+  get_db_stat("event", &ms_branch_pages, &ms_leaf_pages);
+  get_db_stat("ip", &ms_branch_pages, &ms_leaf_pages);
+  printf("%15s | %15" PRIu64 " | %5s | %10s | %10" PRIu64 " | %11s |\n", "", ms_branch_pages, "", "", ms_leaf_pages,
+         "");
+
+  static int64_t prev_add_count;
+  static int64_t prev_del_count;
+  static uint64_t prev_add_time;
+  static uint64_t prev_del_time;
+  static int64_t t = -1;
+  if (t > 0) {
+    int64_t delta = (getClockUs() - t);
+    printf("CPS: add %" PRIu64 ", delete %" PRIu64 ", items processed - %" PRIu64 "K data=%" PRIu64 "K key=%" PRIu64
+           "K\n",
+           (mdbx_add_count - prev_add_count) * 1000000 / delta, (mdbx_del_count - prev_del_count) * 1000000 / delta,
+           obj_id / 1024, mdbx_data_size / 1024, mdbx_key_size / 1024);
+    printf("usage data=%" PRIu64 "%%",
+           ((mdbx_data_size + mdbx_key_size) * 100) / ((ms_leaf_pages + ms_branch_pages) * 4096));
+    if (prev_add_time != mdbx_add_time) {
+      printf(" Add : %" PRIu64 " c/s", (mdbx_add_count - prev_add_count) * 1000000 / (mdbx_add_time - prev_add_time));
+    }
+    if (prev_del_time != mdbx_del_time) {
+      printf(" Del : %" PRIu64 " c/s", (mdbx_del_count - prev_del_count) * 1000000 / (mdbx_del_time - prev_del_time));
+    }
+    if (mdbx_add_time) {
+      printf(" tAdd : %" PRIu64 " c/s", mdbx_add_count * 1000000 / mdbx_add_time);
+    }
+    if (mdbx_del_time) {
+      printf(" tDel : %" PRIu64 " c/s", mdbx_del_count * 1000000 / mdbx_del_time);
+    }
+    puts("");
+  }
+  t = getClockUs();
+  prev_add_count = mdbx_add_count;
+  prev_del_count = mdbx_del_count;
+  prev_add_time = mdbx_add_time;
+  prev_del_time = mdbx_del_time;
+}
+
+#if 0 /* unused */
+static void periodic_add_rec() {
+  for (int i = 0; i < 10240; i++) {
+    if (ids_count <= REC_COUNT) {
+      int64_t id = obj_id++;
+      create_record(id);
+      add_id_to_pool(id);
+    }
+    if (ids_count > REC_COUNT) {
+      int64_t id = get_id_from_pool();
+      delete_record(id);
+    }
+  }
+  periodic_stat();
+}
+#endif
+
+int main(int argc, char **argv) {
+  (void)argc;
+  (void)argv;
+
+  char filename[PATH_MAX];
+  int i;
+
+  strcpy(filename, opt_db_path);
+  strcat(filename, MDBX_DATANAME);
+  remove(filename);
+
+  strcpy(filename, opt_db_path);
+  strcat(filename, MDBX_LOCKNAME);
+  remove(filename);
+
+  puts("Open DB...");
+  db_connect();
+  puts("Create data...");
+  int64_t t = getClockUs();
+  for (i = 0; i < REC_COUNT; i++) {
+    int64_t id = obj_id++;
+    create_record(id);
+    add_id_to_pool(id);
+    if (i % 1000 == 0) {
+      int64_t now = getClockUs();
+      if ((now - t) > 1000000L) {
+        periodic_stat();
+        t = now;
+      }
+    }
+  }
+  periodic_stat();
+  while (1) {
+    int i;
+    for (i = 0; i < 1000; i++) {
+      int64_t id = obj_id++;
+      create_record(id);
+      add_id_to_pool(id);
+      id = get_id_from_pool();
+      delete_record(id);
+    }
+    for (i = 0; i < 50; i++) {
+      int64_t id = obj_id++;
+      create_record(id);
+      add_id_to_pool(id);
+    }
+    int64_t id = obj_id++;
+    create_record(id);
+    add_id_to_pool(id);
+    int64_t now = getClockUs();
+    if ((now - t) > 10000000L) {
+      periodic_stat();
+      t = now;
+    }
+  }
+  db_disconnect();
+  return 0;
+}
diff --git a/crates/storage/libmdbx-rs/src/flags.rs b/crates/storage/libmdbx-rs/src/flags.rs
index 6aefab57b19..d1f7da4fd49 100644
--- a/crates/storage/libmdbx-rs/src/flags.rs
+++ b/crates/storage/libmdbx-rs/src/flags.rs
@@ -199,7 +199,7 @@ impl EnvironmentFlags {
             flags |= ffi::MDBX_LIFORECLAIM;
         }
 
-        flags |= ffi::MDBX_NOTLS;
+        flags |= ffi::MDBX_NOSTICKYTHREADS;
 
         flags
     }
diff --git a/crates/storage/libmdbx-rs/src/txn_pool.rs b/crates/storage/libmdbx-rs/src/txn_pool.rs
index f8d09a3a6b4..e429ba124c2 100644
--- a/crates/storage/libmdbx-rs/src/txn_pool.rs
+++ b/crates/storage/libmdbx-rs/src/txn_pool.rs
@@ -3,8 +3,8 @@ use crossbeam_queue::ArrayQueue;
 
 /// Lock-free pool of reset read-only MDBX transaction handles.
 ///
-/// With `MDBX_NOTLS` (which reth always sets), every `mdbx_txn_begin_ex` for a read transaction
-/// calls `mvcc_bind_slot`, which acquires `lck_rdt_lock` — a pthread mutex. Under high
+/// With `MDBX_NOSTICKYTHREADS` (which reth always sets), every `mdbx_txn_begin_ex` for a read
+/// transaction calls `mvcc_bind_slot`, which acquires `lck_rdt_lock` — a pthread mutex. Under high
 /// concurrency (e.g., prewarming), this becomes a contention point.
 ///
 /// This pool caches transaction handles that have been reset via `mdbx_txn_reset`. A reset handle
diff --git a/crates/storage/provider/Cargo.toml b/crates/storage/provider/Cargo.toml
index f5ca403530f..6558dff131e 100644
--- a/crates/storage/provider/Cargo.toml
+++ b/crates/storage/provider/Cargo.toml
@@ -35,6 +35,7 @@ reth-static-file-types = { workspace = true, features = ["std"] }
 reth-fs-util.workspace = true
 
 # ethereum
+alloy-eip7928.workspace = true
 alloy-eips.workspace = true
 alloy-genesis.workspace = true
 alloy-primitives.workspace = true
@@ -54,12 +55,14 @@ metrics.workspace = true
 itertools.workspace = true
 notify = { workspace = true, default-features = false, features = ["macos_fsevent"] }
 parking_lot.workspace = true
+smallvec.workspace = true
 strum.workspace = true
 eyre.workspace = true
+reth-tokio-util.workspace = true
+tokio = { workspace = true, features = ["sync"], optional = true }
 
 # test-utils
 reth-ethereum-engine-primitives = { workspace = true, optional = true }
-tokio = { workspace = true, features = ["sync"], optional = true }
 
 # parallel utils
 rayon.workspace = true
@@ -84,6 +87,7 @@ assert_matches.workspace = true
 rand.workspace = true
 
 tokio = { workspace = true, features = ["sync", "macros", "rt-multi-thread"] }
+tokio-stream = { workspace = true, features = ["sync"] }
 
 [features]
 jemalloc = ["rocksdb/jemalloc"]
@@ -102,6 +106,6 @@ test-utils = [
     "reth-prune-types/test-utils",
     "reth-stages-types/test-utils",
     "revm-state",
-    "tokio",
     "reth-tasks/test-utils",
+    "dep:tokio",
 ]
diff --git a/crates/storage/provider/src/bal.rs b/crates/storage/provider/src/bal.rs
index b6804a1b456..184a8207596 100644
--- a/crates/storage/provider/src/bal.rs
+++ b/crates/storage/provider/src/bal.rs
@@ -1,32 +1,180 @@
+use alloy_eip7928::BAL_RETENTION_PERIOD_SLOTS;
+use alloy_eips::NumHash;
 use alloy_primitives::{BlockHash, BlockNumber, Bytes};
 use parking_lot::RwLock;
-use reth_storage_api::{BalStore, GetBlockAccessListLimit};
+use reth_prune_types::PruneMode;
+use reth_storage_api::{
+    BalNotification, BalNotificationStream, BalStore, GetBlockAccessListLimit, SealedBal,
+};
 use reth_storage_errors::provider::ProviderResult;
-use std::{collections::HashMap, sync::Arc};
+use reth_tokio_util::EventSender;
+use std::{
+    collections::{BTreeMap, HashMap},
+    sync::Arc,
+};
 
 /// Basic in-memory BAL store keyed by block hash.
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct InMemoryBalStore {
-    entries: Arc<RwLock<HashMap<BlockHash, Bytes>>>,
+    config: BalConfig,
+    inner: Arc<RwLock<InMemoryBalStoreInner>>,
+    notifications: EventSender<BalNotification>,
+}
+
+impl InMemoryBalStore {
+    /// Creates a new in-memory BAL store with the given config.
+    pub fn new(config: BalConfig) -> Self {
+        let notifications = EventSender::new(DEFAULT_BAL_NOTIFICATION_CHANNEL_SIZE);
+        Self {
+            config,
+            inner: Arc::new(RwLock::new(InMemoryBalStoreInner::default())),
+            notifications,
+        }
+    }
+}
+
+// Match the canonical state broadcast buffer so BAL subscriptions behave like the existing
+// in-memory notification path. This is a bounded best-effort channel, not a durability boundary.
+const DEFAULT_BAL_NOTIFICATION_CHANNEL_SIZE: usize = 256;
+
+impl Default for InMemoryBalStore {
+    fn default() -> Self {
+        Self::new(BalConfig::default())
+    }
+}
+
+/// Configuration for BAL storage.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct BalConfig {
+    /// Retention policy for BALs kept in memory.
+    in_memory_retention: Option<PruneMode>,
+}
+
+impl BalConfig {
+    /// Default block distance for BALs kept in memory.
+    pub const DEFAULT_IN_MEMORY_RETENTION_DISTANCE: u64 = BAL_RETENTION_PERIOD_SLOTS;
+
+    /// Returns a config with no in-memory BAL retention limit.
+    pub const fn unbounded() -> Self {
+        Self { in_memory_retention: None }
+    }
+
+    /// Returns a config that keeps BALs within the given block distance in memory.
+    pub const fn with_in_memory_retention_distance(blocks: u64) -> Self {
+        Self::with_in_memory_retention(PruneMode::Distance(blocks))
+    }
+
+    /// Returns a config with the given in-memory BAL retention policy.
+    pub const fn with_in_memory_retention(in_memory_retention: PruneMode) -> Self {
+        Self { in_memory_retention: Some(in_memory_retention) }
+    }
+}
+
+impl Default for BalConfig {
+    fn default() -> Self {
+        Self::with_in_memory_retention_distance(Self::DEFAULT_IN_MEMORY_RETENTION_DISTANCE)
+    }
+}
+
+#[derive(Debug, Default)]
+struct InMemoryBalStoreInner {
+    entries: HashMap<BlockHash, BalEntry>,
+    hashes_by_number: BTreeMap<BlockNumber, Vec<BlockHash>>,
+    highest_block_number: Option<BlockNumber>,
+}
+
+impl InMemoryBalStoreInner {
+    // Inserts a BAL and keeps the block-number index in sync.
+    fn insert(&mut self, block_hash: BlockHash, block_number: BlockNumber, bal: Bytes) {
+        let empty_block_number =
+            self.entries.insert(block_hash, BalEntry { block_number, bal }).and_then(|entry| {
+                let hashes = self.hashes_by_number.get_mut(&entry.block_number)?;
+                hashes.retain(|hash| *hash != block_hash);
+                hashes.is_empty().then_some(entry.block_number)
+            });
+
+        if let Some(block_number) = empty_block_number {
+            self.hashes_by_number.remove(&block_number);
+        }
+
+        self.hashes_by_number.entry(block_number).or_default().push(block_hash);
+        self.highest_block_number = Some(
+            self.highest_block_number.map_or(block_number, |highest| highest.max(block_number)),
+        );
+    }
+
+    // Removes BALs outside the configured retention window for the given chain tip.
+    fn prune(&mut self, prune_mode: Option<PruneMode>, tip: BlockNumber) -> usize {
+        let Some(prune_mode) = prune_mode else { return 0 };
+
+        let mut pruned = 0;
+        while let Some((&block_number, _)) = self.hashes_by_number.first_key_value() {
+            if !prune_mode.should_prune(block_number, tip) {
+                break
+            }
+
+            let Some((_, hashes)) = self.hashes_by_number.pop_first() else { break };
+            for hash in hashes {
+                pruned += usize::from(self.entries.remove(&hash).is_some());
+            }
+        }
+        pruned
+    }
+}
+
+#[derive(Debug)]
+struct BalEntry {
+    block_number: BlockNumber,
+    bal: Bytes,
 }
 
 impl BalStore for InMemoryBalStore {
-    fn insert(
-        &self,
-        block_hash: BlockHash,
-        _block_number: BlockNumber,
-        bal: Bytes,
-    ) -> ProviderResult<()> {
-        self.entries.write().insert(block_hash, bal);
+    fn insert(&self, num_hash: NumHash, bal: SealedBal) -> ProviderResult<()> {
+        let mut inner = self.inner.write();
+        inner.insert(num_hash.hash, num_hash.number, bal.clone_inner());
+        if let Some(highest_block_number) = inner.highest_block_number {
+            // This preserves insert-time cleanup based on the highest inserted BAL block.
+            inner.prune(self.config.in_memory_retention, highest_block_number);
+        }
+        self.notifications.notify(BalNotification::new(num_hash, bal));
+        Ok(())
+    }
+
+    fn insert_many(&self, entries: Vec<(NumHash, SealedBal)>) -> ProviderResult<()> {
+        if entries.is_empty() {
+            return Ok(())
+        }
+
+        let mut inner = self.inner.write();
+        inner.entries.reserve(entries.len());
+        for (num_hash, bal) in &entries {
+            inner.insert(num_hash.hash, num_hash.number, bal.clone_inner());
+        }
+        if let Some(highest_block_number) = inner.highest_block_number {
+            inner.prune(self.config.in_memory_retention, highest_block_number);
+        }
+        drop(inner);
+
+        for (num_hash, bal) in entries {
+            self.notifications.notify(BalNotification::new(num_hash, bal));
+        }
+        Ok(())
+    }
+
+    fn flush(&self) -> ProviderResult<()> {
         Ok(())
     }
 
+    fn prune(&self, tip: BlockNumber) -> ProviderResult<usize> {
+        Ok(self.inner.write().prune(self.config.in_memory_retention, tip))
+    }
+
     fn get_by_hashes(&self, block_hashes: &[BlockHash]) -> ProviderResult<Vec<Option<Bytes>>> {
-        let entries = self.entries.read();
+        let inner = self.inner.read();
         let mut result = Vec::with_capacity(block_hashes.len());
 
         for hash in block_hashes {
-            result.push(entries.get(hash).cloned());
+            result.push(inner.entries.get(hash).map(|entry| entry.bal.clone()));
         }
 
         Ok(result)
@@ -36,14 +184,14 @@ impl BalStore for InMemoryBalStore {
         &self,
         block_hashes: &[BlockHash],
         limit: GetBlockAccessListLimit,
-        out: &mut Vec<Bytes>,
+        out: &mut Vec<Option<Bytes>>,
     ) -> ProviderResult<()> {
-        let entries = self.entries.read();
+        let inner = self.inner.read();
         let mut size = 0;
 
         for hash in block_hashes {
-            let bal = entries.get(hash).cloned().unwrap_or_else(|| Bytes::from_static(&[0xc0]));
-            size += bal.len();
+            let bal = inner.entries.get(hash).map(|entry| entry.bal.clone());
+            size += bal.as_ref().map_or(1, |bytes| bytes.len());
             out.push(bal);
 
             if limit.exceeds(size) {
@@ -54,15 +202,20 @@ impl BalStore for InMemoryBalStore {
         Ok(())
     }
 
-    fn get_by_range(&self, _start: BlockNumber, _count: u64) -> ProviderResult<Vec<Bytes>> {
-        Ok(Vec::new())
+    fn bal_stream(&self) -> BalNotificationStream {
+        self.notifications.new_listener()
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy_primitives::B256;
+    use alloy_primitives::{keccak256, Sealed, B256};
+    use tokio_stream::StreamExt;
+
+    fn sealed_bal(bal: Bytes) -> SealedBal {
+        Sealed::new_unchecked(bal.clone(), keccak256(&bal))
+    }
 
     #[test]
     fn insert_and_lookup_by_hash() {
@@ -71,16 +224,37 @@ mod tests {
         let missing = B256::random();
         let bal = Bytes::from_static(b"bal");
 
-        store.insert(hash, 1, bal.clone()).unwrap();
+        store.insert(NumHash::new(1, hash), sealed_bal(bal.clone())).unwrap();
 
         assert_eq!(store.get_by_hashes(&[hash, missing]).unwrap(), vec![Some(bal), None]);
     }
 
     #[test]
-    fn range_lookup_is_empty() {
+    fn insert_many_and_lookup_by_hash() {
         let store = InMemoryBalStore::default();
+        let hash0 = B256::random();
+        let hash1 = B256::random();
+        let bal0 = sealed_bal(Bytes::from_static(b"bal0"));
+        let bal1 = sealed_bal(Bytes::from_static(b"bal1"));
+
+        store
+            .insert_many(vec![
+                (NumHash::new(1, hash0), bal0.clone()),
+                (NumHash::new(2, hash1), bal1),
+            ])
+            .unwrap();
 
-        assert!(store.get_by_range(1, 10).unwrap().is_empty());
+        assert_eq!(
+            store.get_by_hashes(&[hash0, hash1]).unwrap(),
+            vec![Some(bal0.clone_inner()), Some(Bytes::from_static(b"bal1"))]
+        );
+    }
+
+    #[test]
+    fn flush_is_noop() {
+        let store = InMemoryBalStore::default();
+
+        store.flush().unwrap();
     }
 
     #[test]
@@ -93,9 +267,9 @@ mod tests {
         let bal1 = Bytes::from_static(&[0xc1, 0x02]);
         let bal2 = Bytes::from_static(&[0xc1, 0x03]);
 
-        store.insert(hash0, 1, bal0.clone()).unwrap();
-        store.insert(hash1, 2, bal1.clone()).unwrap();
-        store.insert(hash2, 3, bal2).unwrap();
+        store.insert(NumHash::new(1, hash0), sealed_bal(bal0.clone())).unwrap();
+        store.insert(NumHash::new(2, hash1), sealed_bal(bal1.clone())).unwrap();
+        store.insert(NumHash::new(3, hash2), sealed_bal(bal2)).unwrap();
 
         let limited = store
             .get_by_hashes_with_limit(
@@ -104,6 +278,224 @@ mod tests {
             )
             .unwrap();
 
-        assert_eq!(limited, vec![bal0, bal1]);
+        assert_eq!(limited, vec![Some(bal0), Some(bal1)]);
+    }
+
+    #[test]
+    fn default_retention_prunes_old_bals() {
+        let store = InMemoryBalStore::default();
+        let old_hash = B256::random();
+        let retained_hash = B256::random();
+        let tip_hash = B256::random();
+        let old_bal = Bytes::from_static(b"old");
+        let retained_bal = Bytes::from_static(b"retained");
+        let tip_bal = Bytes::from_static(b"tip");
+
+        store.insert(NumHash::new(1, old_hash), sealed_bal(old_bal)).unwrap();
+        store
+            .insert(
+                NumHash::new(BAL_RETENTION_PERIOD_SLOTS, retained_hash),
+                sealed_bal(retained_bal.clone()),
+            )
+            .unwrap();
+        store
+            .insert(
+                NumHash::new(BAL_RETENTION_PERIOD_SLOTS + 2, tip_hash),
+                sealed_bal(tip_bal.clone()),
+            )
+            .unwrap();
+
+        assert_eq!(
+            store.get_by_hashes(&[old_hash, retained_hash, tip_hash]).unwrap(),
+            vec![None, Some(retained_bal), Some(tip_bal)]
+        );
+    }
+
+    #[test]
+    fn prune_uses_chain_tip() {
+        let store =
+            InMemoryBalStore::new(BalConfig::with_in_memory_retention(PruneMode::Distance(2)));
+        let old_hash = B256::random();
+        let retained_hash = B256::random();
+        let old_bal = Bytes::from_static(b"old");
+        let retained_bal = Bytes::from_static(b"retained");
+
+        store.insert(NumHash::new(7, old_hash), sealed_bal(old_bal)).unwrap();
+        store.insert(NumHash::new(8, retained_hash), sealed_bal(retained_bal.clone())).unwrap();
+
+        assert_eq!(store.prune(10).unwrap(), 1);
+        assert_eq!(
+            store.get_by_hashes(&[old_hash, retained_hash]).unwrap(),
+            vec![None, Some(retained_bal)]
+        );
+    }
+
+    #[test]
+    fn insert_prunes_from_highest_inserted_block() {
+        let store =
+            InMemoryBalStore::new(BalConfig::with_in_memory_retention(PruneMode::Distance(2)));
+        let old_hash = B256::random();
+        let high_hash = B256::random();
+        let late_hash = B256::random();
+        let high_bal = Bytes::from_static(b"high");
+        let late_bal = Bytes::from_static(b"late");
+
+        store.insert(NumHash::new(7, old_hash), sealed_bal(Bytes::from_static(b"old"))).unwrap();
+        store.insert(NumHash::new(10, high_hash), sealed_bal(high_bal.clone())).unwrap();
+        store.insert(NumHash::new(8, late_hash), sealed_bal(late_bal.clone())).unwrap();
+
+        assert_eq!(
+            store.get_by_hashes(&[old_hash, high_hash, late_hash]).unwrap(),
+            vec![None, Some(high_bal), Some(late_bal)]
+        );
+    }
+
+    #[test]
+    fn unbounded_retention_keeps_old_bals() {
+        let store = InMemoryBalStore::new(BalConfig::unbounded());
+        let old_hash = B256::random();
+        let tip_hash = B256::random();
+        let old_bal = Bytes::from_static(b"old");
+        let tip_bal = Bytes::from_static(b"tip");
+
+        store.insert(NumHash::new(1, old_hash), sealed_bal(old_bal.clone())).unwrap();
+        store
+            .insert(
+                NumHash::new(BAL_RETENTION_PERIOD_SLOTS + 1, tip_hash),
+                sealed_bal(tip_bal.clone()),
+            )
+            .unwrap();
+
+        assert_eq!(
+            store.get_by_hashes(&[old_hash, tip_hash]).unwrap(),
+            vec![Some(old_bal), Some(tip_bal)]
+        );
+        assert_eq!(store.prune(BAL_RETENTION_PERIOD_SLOTS + 2).unwrap(), 0);
+    }
+
+    #[test]
+    fn in_memory_retention_distance_prunes_old_bals() {
+        let store = InMemoryBalStore::new(BalConfig::with_in_memory_retention_distance(2));
+        let old_hash = B256::random();
+        let retained_hash = B256::random();
+        let tip_hash = B256::random();
+        let old_bal = Bytes::from_static(b"old");
+        let retained_bal = Bytes::from_static(b"retained");
+        let tip_bal = Bytes::from_static(b"tip");
+
+        store.insert(NumHash::new(1, old_hash), sealed_bal(old_bal)).unwrap();
+        store.insert(NumHash::new(2, retained_hash), sealed_bal(retained_bal.clone())).unwrap();
+        store.insert(NumHash::new(4, tip_hash), sealed_bal(tip_bal.clone())).unwrap();
+
+        assert_eq!(
+            store.get_by_hashes(&[old_hash, retained_hash, tip_hash]).unwrap(),
+            vec![None, Some(retained_bal), Some(tip_bal)]
+        );
+    }
+
+    #[test]
+    fn reinserting_hash_updates_number_index() {
+        let store =
+            InMemoryBalStore::new(BalConfig::with_in_memory_retention(PruneMode::Before(2)));
+        let hash = B256::random();
+        let bal = Bytes::from_static(b"bal");
+
+        store.insert(NumHash::new(1, hash), sealed_bal(Bytes::from_static(b"old"))).unwrap();
+        store.insert(NumHash::new(2, hash), sealed_bal(bal.clone())).unwrap();
+
+        assert_eq!(store.get_by_hashes(&[hash]).unwrap(), vec![Some(bal)]);
+    }
+
+    #[tokio::test]
+    async fn insert_notifies_subscribers() {
+        let store = InMemoryBalStore::default();
+        let hash = B256::random();
+        let block_number = 7;
+        let bal = Bytes::from_static(b"bal");
+        let mut stream = store.bal_stream();
+
+        let sealed_bal = sealed_bal(bal);
+
+        store.insert(NumHash::new(block_number, hash), sealed_bal.clone()).unwrap();
+
+        assert_eq!(
+            stream.next().await.unwrap(),
+            BalNotification::new(NumHash::new(block_number, hash), sealed_bal)
+        );
+    }
+
+    #[tokio::test]
+    async fn insert_many_notifies_subscribers() {
+        let store = InMemoryBalStore::default();
+        let mut stream = store.bal_stream();
+        let hash0 = B256::random();
+        let hash1 = B256::random();
+        let bal0 = sealed_bal(Bytes::from_static(b"bal0"));
+        let bal1 = sealed_bal(Bytes::from_static(b"bal1"));
+
+        store
+            .insert_many(vec![
+                (NumHash::new(1, hash0), bal0.clone()),
+                (NumHash::new(2, hash1), bal1.clone()),
+            ])
+            .unwrap();
+
+        assert_eq!(
+            stream.next().await.unwrap(),
+            BalNotification::new(NumHash::new(1, hash0), bal0)
+        );
+        assert_eq!(
+            stream.next().await.unwrap(),
+            BalNotification::new(NumHash::new(2, hash1), bal1)
+        );
+    }
+
+    #[test]
+    fn insert_without_subscribers_still_succeeds() {
+        let store = InMemoryBalStore::default();
+
+        assert!(store
+            .insert(NumHash::new(1, B256::random()), sealed_bal(Bytes::from_static(b"bal")))
+            .is_ok());
+    }
+
+    #[tokio::test]
+    async fn bal_stream_skips_lagged_notifications() {
+        let store = InMemoryBalStore::new(BalConfig::unbounded());
+        let mut stream = store.bal_stream();
+
+        for number in 0..=DEFAULT_BAL_NOTIFICATION_CHANNEL_SIZE as u64 {
+            store
+                .insert(
+                    NumHash::new(number, B256::random()),
+                    sealed_bal(Bytes::from(vec![number as u8])),
+                )
+                .unwrap();
+        }
+
+        let first = stream.next().await.unwrap();
+        let second = stream.next().await.unwrap();
+
+        assert_eq!(first.num_hash.number, 1);
+        assert_eq!(second.num_hash.number, 2);
+    }
+
+    #[tokio::test]
+    async fn cloned_store_shares_notification_channel() {
+        let store = InMemoryBalStore::default();
+        let clone = store.clone();
+        let hash = B256::random();
+        let block_number = 9;
+        let bal = Bytes::from_static(b"bal");
+        let mut stream = clone.bal_stream();
+
+        let sealed_bal = sealed_bal(bal);
+
+        store.insert(NumHash::new(block_number, hash), sealed_bal.clone()).unwrap();
+
+        assert_eq!(
+            stream.next().await.unwrap(),
+            BalNotification::new(NumHash::new(block_number, hash), sealed_bal)
+        );
     }
 }
diff --git a/crates/storage/provider/src/lib.rs b/crates/storage/provider/src/lib.rs
index 890051b9d1b..909a9c24b38 100644
--- a/crates/storage/provider/src/lib.rs
+++ b/crates/storage/provider/src/lib.rs
@@ -39,7 +39,7 @@ pub mod either_writer;
 pub use either_writer::*;
 
 mod bal;
-pub use bal::InMemoryBalStore;
+pub use bal::{BalConfig, InMemoryBalStore};
 
 pub use reth_chain_state::{
     CanonStateNotification, CanonStateNotificationSender, CanonStateNotificationStream,
@@ -51,9 +51,9 @@ pub use revm_database::states::OriginalValuesKnown;
 // reexport traits to avoid breaking changes
 pub use reth_static_file_types as static_file;
 pub use reth_storage_api::{
-    BalProvider, BalStore, BalStoreHandle, GetBlockAccessListLimit, HistoryWriter,
-    MetadataProvider, MetadataWriter, NoopBalStore, StateWriteConfig, StatsReader, StorageSettings,
-    StorageSettingsCache,
+    BalNotification, BalNotificationStream, BalProvider, BalStore, BalStoreHandle,
+    GetBlockAccessListLimit, HistoryWriter, MetadataProvider, MetadataWriter, NoopBalStore,
+    SealedBal, StateWriteConfig, StatsReader, StorageSettings, StorageSettingsCache,
 };
 /// Re-export provider error.
 pub use reth_storage_errors::provider::{ProviderError, ProviderResult};
diff --git a/crates/storage/provider/src/providers/blockchain_provider.rs b/crates/storage/provider/src/providers/blockchain_provider.rs
index de0f6b85401..676311d321e 100644
--- a/crates/storage/provider/src/providers/blockchain_provider.rs
+++ b/crates/storage/provider/src/providers/blockchain_provider.rs
@@ -6,8 +6,8 @@ use crate::{
     AccountReader, BalProvider, BalStoreHandle, BlockHashReader, BlockIdReader, BlockNumReader,
     BlockReader, BlockReaderIdExt, BlockSource, CanonChainTracker, CanonStateNotifications,
     CanonStateSubscriptions, ChainSpecProvider, ChainStateBlockReader, ChangeSetReader,
-    DatabaseProviderFactory, HashedPostStateProvider, HeaderProvider, InMemoryBalStore,
-    ProviderError, ProviderFactory, PruneCheckpointReader, ReceiptProvider, ReceiptProviderIdExt,
+    DatabaseProviderFactory, HashedPostStateProvider, HeaderProvider, ProviderError,
+    ProviderFactory, PruneCheckpointReader, ReceiptProvider, ReceiptProviderIdExt,
     RocksDBProviderFactory, StageCheckpointReader, StateProviderBox, StateProviderFactory,
     StateReader, StaticFileProviderFactory, TransactionVariant, TransactionsProvider,
 };
@@ -104,6 +104,8 @@ impl<N: ProviderNodeTypes> BlockchainProvider<N> {
             .map(|num| provider.sealed_header(num))
             .transpose()?
             .flatten();
+        let bal_store = storage.bal_store().clone();
+
         Ok(Self {
             database: storage,
             canonical_in_memory_state: CanonicalInMemoryState::with_head(
@@ -111,7 +113,7 @@ impl<N: ProviderNodeTypes> BlockchainProvider<N> {
                 finalized_header,
                 safe_header,
             ),
-            bal_store: BalStoreHandle::new(InMemoryBalStore::default()),
+            bal_store,
         })
     }
 
diff --git a/crates/storage/provider/src/providers/consistent.rs b/crates/storage/provider/src/providers/consistent.rs
index 9402a8734e6..ea3d1d66c23 100644
--- a/crates/storage/provider/src/providers/consistent.rs
+++ b/crates/storage/provider/src/providers/consistent.rs
@@ -7,11 +7,11 @@ use crate::{
     StageCheckpointReader, StateReader, StaticFileProviderFactory, TransactionVariant,
     TransactionsProvider,
 };
-use alloy_consensus::{transaction::TransactionMeta, BlockHeader};
-use alloy_eips::{
-    eip2718::Encodable2718, BlockHashOrNumber, BlockId, BlockNumHash, BlockNumberOrTag,
-    HashOrNumber,
+use alloy_consensus::{
+    transaction::{TransactionMeta, TxHashRef},
+    BlockHeader,
 };
+use alloy_eips::{BlockHashOrNumber, BlockId, BlockNumHash, BlockNumberOrTag, HashOrNumber};
 use alloy_primitives::{Address, BlockHash, BlockNumber, TxHash, TxNumber, B256};
 use reth_chain_state::{BlockState, CanonicalInMemoryState, MemoryOverlayStateProviderRef};
 use reth_chainspec::ChainInfo;
@@ -399,7 +399,7 @@ impl<N: ProviderNodeTypes> ConsistentProvider<N> {
             for tx_index in 0..block.body().transactions().len() {
                 match id {
                     HashOrNumber::Hash(tx_hash) => {
-                        if tx_hash == block.body().transactions()[tx_index].trie_hash() {
+                        if tx_hash == *block.body().transactions()[tx_index].tx_hash() {
                             return fetch_from_block_state(tx_index, in_memory_tx_num, block_state)
                         }
                     }
@@ -914,7 +914,7 @@ impl<N: ProviderNodeTypes> ReceiptProvider for ConsistentProvider<N> {
             );
 
             if let Some(tx_index) =
-                block.body().transactions_iter().position(|tx| tx.trie_hash() == hash)
+                block.body().transactions_iter().position(|tx| *tx.tx_hash() == hash)
             {
                 // safe to use tx_index for receipts due to 1:1 correspondence
                 return Ok(receipts.get(tx_index).cloned());
diff --git a/crates/storage/provider/src/providers/database/mod.rs b/crates/storage/provider/src/providers/database/mod.rs
index 0cc2ced3aa6..fea5267e35b 100644
--- a/crates/storage/provider/src/providers/database/mod.rs
+++ b/crates/storage/provider/src/providers/database/mod.rs
@@ -7,9 +7,9 @@ use crate::{
     traits::{BlockSource, ReceiptProvider},
     BalProvider, BalStoreHandle, BlockHashReader, BlockNumReader, BlockReader, ChainSpecProvider,
     DatabaseProviderFactory, EitherWriterDestination, HashedPostStateProvider, HeaderProvider,
-    HeaderSyncGapProvider, MetadataProvider, ProviderError, PruneCheckpointReader,
-    RocksDBProviderFactory, StageCheckpointReader, StateProviderBox, StaticFileProviderFactory,
-    StaticFileWriter, TransactionVariant, TransactionsProvider,
+    HeaderSyncGapProvider, InMemoryBalStore, MetadataProvider, ProviderError,
+    PruneCheckpointReader, RocksDBProviderFactory, StageCheckpointReader, StateProviderBox,
+    StaticFileProviderFactory, StaticFileWriter, TransactionVariant, TransactionsProvider,
 };
 use alloy_consensus::transaction::TransactionMeta;
 use alloy_eips::BlockHashOrNumber;
@@ -154,7 +154,7 @@ impl<N: ProviderNodeTypes> ProviderFactory<N> {
             storage_settings: Arc::new(RwLock::new(storage_settings)),
             rocksdb_provider,
             changeset_cache: ChangesetCache::new(),
-            bal_store: BalStoreHandle::default(),
+            bal_store: BalStoreHandle::new(InMemoryBalStore::default()),
             runtime,
             minimum_pruning_distance: MINIMUM_UNWIND_SAFE_DISTANCE,
             read_only_sync: None,
@@ -186,6 +186,12 @@ impl<N: NodeTypesWithDB> ProviderFactory<N> {
         self
     }
 
+    /// Sets the BAL store for an existing [`ProviderFactory`].
+    pub fn with_bal_store(mut self, bal_store: BalStoreHandle) -> Self {
+        self.bal_store = bal_store;
+        self
+    }
+
     /// Sets the changeset cache for an existing [`ProviderFactory`].
     pub fn with_changeset_cache(mut self, changeset_cache: ChangesetCache) -> Self {
         self.changeset_cache = changeset_cache;
diff --git a/crates/storage/provider/src/providers/database/provider.rs b/crates/storage/provider/src/providers/database/provider.rs
index b95ce3cd221..58e24c38e88 100644
--- a/crates/storage/provider/src/providers/database/provider.rs
+++ b/crates/storage/provider/src/providers/database/provider.rs
@@ -73,6 +73,7 @@ use reth_trie_db::{ChangesetCache, DatabaseStorageTrieCursor, TrieTableAdapter};
 use revm_database::states::{
     PlainStateReverts, PlainStorageChangeset, PlainStorageRevert, StateChangeset,
 };
+use smallvec::SmallVec;
 use std::{
     cmp::Ordering,
     collections::{BTreeMap, BTreeSet},
@@ -595,8 +596,8 @@ impl<TX: DbTx + DbTxMut + 'static, N: NodeTypesForProvider> DatabaseProvider<TX,
             .map(|(n, _)| n + 1)
             .unwrap_or_default();
 
-        let tx_nums: Vec<TxNumber> = {
-            let mut nums = Vec::with_capacity(blocks.len());
+        let tx_nums: SmallVec<[TxNumber; 4]> = {
+            let mut nums = SmallVec::with_capacity(blocks.len());
             let mut current = first_tx_num;
             for block in &blocks {
                 nums.push(current);
@@ -1098,6 +1099,10 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> DatabaseProvider<TX, N> {
         BF: FnOnce(H, BodyTy<N>, Vec<Address>) -> ProviderResult<Option<B>>,
     {
         let Some(block_number) = self.convert_hash_or_number(id)? else { return Ok(None) };
+        let earliest_available = self.static_file_provider.earliest_history_height();
+        if block_number < earliest_available {
+            return Err(ProviderError::BlockExpired { requested: block_number, earliest_available })
+        }
         let Some(header) = header_by_number(block_number)? else { return Ok(None) };
 
         // Get the block body
diff --git a/crates/storage/provider/src/providers/rocksdb/invariants.rs b/crates/storage/provider/src/providers/rocksdb/invariants.rs
index eb8e60e70b2..232c629afe1 100644
--- a/crates/storage/provider/src/providers/rocksdb/invariants.rs
+++ b/crates/storage/provider/src/providers/rocksdb/invariants.rs
@@ -6,7 +6,7 @@
 
 use super::RocksDBProvider;
 use crate::StaticFileProviderFactory;
-use alloy_eips::eip2718::Encodable2718;
+use alloy_consensus::transaction::TxHashRef;
 use alloy_primitives::BlockNumber;
 use rayon::prelude::*;
 use reth_chainspec::{ChainSpecProvider, EthChainSpec};
@@ -45,7 +45,7 @@ impl RocksDBProvider {
     /// # Requirements
     ///
     /// For pruning `TransactionHashNumbers`, the provider must be able to supply transaction
-    /// data (typically from static files) so that transaction hashes can be computed. This
+    /// data (typically from static files) so that transaction hashes can be read. This
     /// implies that static files should be ahead of or in sync with `RocksDB`.
     pub fn check_consistency<Provider>(
         &self,
@@ -59,7 +59,7 @@ impl RocksDBProvider {
             + BlockBodyIndicesProvider
             + StorageChangeSetReader
             + ChangeSetReader
-            + TransactionsProvider<Transaction: Encodable2718>
+            + TransactionsProvider
             + ChainSpecProvider,
     {
         let mut unwind_target: Option<BlockNumber> = None;
@@ -103,7 +103,7 @@ impl RocksDBProvider {
             + StageCheckpointReader
             + StaticFileProviderFactory
             + BlockBodyIndicesProvider
-            + TransactionsProvider<Transaction: Encodable2718>,
+            + TransactionsProvider,
     {
         let checkpoint = provider
             .get_stage_checkpoint(StageId::TransactionLookup)?
@@ -205,7 +205,7 @@ impl RocksDBProvider {
 
     /// Prunes `TransactionHashNumbers` entries for transactions in the given range.
     ///
-    /// This fetches transactions from the provider, computes their hashes in parallel,
+    /// This fetches transactions from the provider, reads their hashes in parallel,
     /// and deletes the corresponding entries from `RocksDB` by key. This approach is more
     /// scalable than iterating all rows because it only processes the transactions that
     /// need to be pruned.
@@ -213,7 +213,7 @@ impl RocksDBProvider {
     /// # Requirements
     ///
     /// The provider must be able to supply transaction data (typically from static files)
-    /// so that transaction hashes can be computed. This implies that static files should
+    /// so that transaction hashes can be read. This implies that static files should
     /// be ahead of or in sync with `RocksDB`.
     fn prune_transaction_hash_numbers_in_range<Provider>(
         &self,
@@ -221,17 +221,17 @@ impl RocksDBProvider {
         tx_range: std::ops::RangeInclusive<u64>,
     ) -> ProviderResult<()>
     where
-        Provider: TransactionsProvider<Transaction: Encodable2718>,
+        Provider: TransactionsProvider,
     {
         if tx_range.is_empty() {
             return Ok(());
         }
 
-        // Fetch transactions in the range and compute their hashes in parallel
+        // Fetch transactions in the range and read their hashes in parallel.
         let hashes: Vec<_> = provider
             .transactions_by_tx_range(tx_range.clone())?
             .into_par_iter()
-            .map(|tx| tx.trie_hash())
+            .map(|tx| *tx.tx_hash())
             .collect();
 
         if !hashes.is_empty() {
@@ -273,6 +273,28 @@ impl RocksDBProvider {
             .map(|cp| cp.block_number)
             .unwrap_or(0);
 
+        let sf_tip = provider
+            .static_file_provider()
+            .get_highest_static_file_block(StaticFileSegment::StorageChangeSets)
+            .unwrap_or(0);
+
+        if sf_tip < checkpoint {
+            // This should never happen in normal operation - static files are always
+            // committed before RocksDB. If we get here, something is seriously wrong.
+            // The unwind is a best-effort attempt but is probably futile.
+            tracing::warn!(
+                target: "reth::providers::rocksdb",
+                sf_tip,
+                checkpoint,
+                "StoragesHistory: static file tip behind checkpoint, unwind needed"
+            );
+            return Ok(Some(sf_tip));
+        }
+
+        if sf_tip == checkpoint {
+            return Ok(None);
+        }
+
         // Fast path: clear and re-insert genesis history.
         if checkpoint == 0 {
             tracing::info!(
@@ -298,28 +320,6 @@ impl RocksDBProvider {
             return Ok(None);
         }
 
-        let sf_tip = provider
-            .static_file_provider()
-            .get_highest_static_file_block(StaticFileSegment::StorageChangeSets)
-            .unwrap_or(0);
-
-        if sf_tip < checkpoint {
-            // This should never happen in normal operation - static files are always
-            // committed before RocksDB. If we get here, something is seriously wrong.
-            // The unwind is a best-effort attempt but is probably futile.
-            tracing::warn!(
-                target: "reth::providers::rocksdb",
-                sf_tip,
-                checkpoint,
-                "StoragesHistory: static file tip behind checkpoint, unwind needed"
-            );
-            return Ok(Some(sf_tip));
-        }
-
-        if sf_tip == checkpoint {
-            return Ok(None);
-        }
-
         let total_blocks = sf_tip - checkpoint;
         tracing::info!(
             target: "reth::providers::rocksdb",
@@ -386,24 +386,6 @@ impl RocksDBProvider {
             .map(|cp| cp.block_number)
             .unwrap_or(0);
 
-        // Fast path: clear and re-insert genesis history.
-        if checkpoint == 0 {
-            tracing::info!(
-                target: "reth::providers::rocksdb",
-                "AccountsHistory: checkpoint is 0, clearing stale data"
-            );
-            self.clear::<tables::AccountsHistory>()?;
-
-            let chain_spec = provider.chain_spec();
-            let genesis = chain_spec.genesis();
-            let list = tables::BlockNumberList::new([0]).expect("single block always fits");
-            for addr in genesis.alloc.keys() {
-                self.put::<tables::AccountsHistory>(ShardedKey::last(*addr), &list)?;
-            }
-
-            return Ok(None);
-        }
-
         let sf_tip = provider
             .static_file_provider()
             .get_highest_static_file_block(StaticFileSegment::AccountChangeSets)
@@ -426,6 +408,24 @@ impl RocksDBProvider {
             return Ok(None);
         }
 
+        // Fast path: clear and re-insert genesis history.
+        if checkpoint == 0 {
+            tracing::info!(
+                target: "reth::providers::rocksdb",
+                "AccountsHistory: checkpoint is 0, clearing stale data"
+            );
+            self.clear::<tables::AccountsHistory>()?;
+
+            let chain_spec = provider.chain_spec();
+            let genesis = chain_spec.genesis();
+            let list = tables::BlockNumberList::new([0]).expect("single block always fits");
+            for addr in genesis.alloc.keys() {
+                self.put::<tables::AccountsHistory>(ShardedKey::last(*addr), &list)?;
+            }
+
+            return Ok(None);
+        }
+
         let total_blocks = sf_tip - checkpoint;
         tracing::info!(
             target: "reth::providers::rocksdb",
@@ -572,11 +572,7 @@ mod tests {
 
         let result = rocksdb.heal_accounts_history(&provider).unwrap();
         assert_eq!(result, None, "AccountsHistory should return early at checkpoint 0");
-        // Genesis account history entries are re-inserted
-        assert_eq!(
-            rocksdb.iter::<tables::AccountsHistory>().unwrap().count(),
-            factory.chain_spec().genesis().alloc.len()
-        );
+        assert_eq!(rocksdb.iter::<tables::AccountsHistory>().unwrap().count(), 0);
     }
 
     #[test]
@@ -632,7 +628,7 @@ mod tests {
                     .insert_block(&block.clone().try_recover().expect("recover block"))
                     .unwrap();
                 for tx in &block.body().transactions {
-                    let hash = tx.trie_hash();
+                    let hash = *tx.tx_hash();
                     tx_hashes.push(hash);
                     rocksdb.put::<tables::TransactionHashNumbers>(hash, &tx_count).unwrap();
                     tx_count += 1;
@@ -759,7 +755,7 @@ mod tests {
                     .insert_block(&block.clone().try_recover().expect("recover block"))
                     .unwrap();
                 for tx in &block.body().transactions {
-                    let hash = tx.trie_hash();
+                    let hash = *tx.tx_hash();
                     rocksdb.put::<tables::TransactionHashNumbers>(hash, &tx_count).unwrap();
                     tx_count += 1;
                 }
@@ -821,7 +817,7 @@ mod tests {
                     .insert_block(&block.clone().try_recover().expect("recover block"))
                     .unwrap();
                 for tx in &block.body().transactions {
-                    let hash = tx.trie_hash();
+                    let hash = *tx.tx_hash();
                     tx_hashes.push(hash);
                     rocksdb.put::<tables::TransactionHashNumbers>(hash, &tx_count).unwrap();
                     tx_count += 1;
@@ -972,7 +968,7 @@ mod tests {
         assert_eq!(result, Some(0), "sf_tip=0 < checkpoint=100 returns unwind target");
     }
 
-    /// Test that pruning works by fetching transactions and computing their hashes,
+    /// Test that pruning works by fetching transactions and reading their hashes,
     /// rather than iterating all rows. This test uses random blocks with unique
     /// transactions so we can verify the correct entries are pruned.
     #[test]
@@ -1010,7 +1006,7 @@ mod tests {
 
                 // Store transaction hash -> tx_number mappings in RocksDB
                 for tx in &block.body().transactions {
-                    let hash = tx.trie_hash();
+                    let hash = *tx.tx_hash();
                     tx_hashes.push(hash);
                     rocksdb.put::<tables::TransactionHashNumbers>(hash, &tx_count).unwrap();
                     tx_count += 1;
@@ -1045,13 +1041,13 @@ mod tests {
         let all_txs = provider.transactions_by_tx_range(0..tx_count).unwrap();
         assert_eq!(all_txs.len(), tx_count as usize, "Should be able to fetch all transactions");
 
-        // Verify the hashes match between what we stored and what we compute from fetched txs
+        // Verify the hashes match between what we stored and what we read from fetched txs.
         for (i, tx) in all_txs.iter().enumerate() {
-            let computed_hash = tx.trie_hash();
+            let fetched_hash = *tx.tx_hash();
             assert_eq!(
-                computed_hash, tx_hashes[i],
-                "Hash mismatch for tx {}: stored {:?} vs computed {:?}",
-                i, tx_hashes[i], computed_hash
+                fetched_hash, tx_hashes[i],
+                "Hash mismatch for tx {}: stored {:?} vs fetched {:?}",
+                i, tx_hashes[i], fetched_hash
             );
         }
 
diff --git a/crates/storage/provider/src/providers/rocksdb/provider.rs b/crates/storage/provider/src/providers/rocksdb/provider.rs
index 76d9a439cf4..1d855bbea7b 100644
--- a/crates/storage/provider/src/providers/rocksdb/provider.rs
+++ b/crates/storage/provider/src/providers/rocksdb/provider.rs
@@ -28,7 +28,7 @@ use rocksdb::{
     BlockBasedOptions, Cache, ColumnFamilyDescriptor, CompactionPri, DBCompressionType,
     DBRawIteratorWithThreadMode, IteratorMode, OptimisticTransactionDB,
     OptimisticTransactionOptions, Options, SnapshotWithThreadMode, Transaction,
-    WriteBatchWithTransaction, WriteOptions, DB,
+    WriteBatchWithTransaction, WriteBufferManager, WriteOptions, DB,
 };
 use std::{
     collections::BTreeMap,
@@ -133,17 +133,24 @@ const DEFAULT_BYTES_PER_SYNC: u64 = 1_048_576;
 /// to 64 MB default, with negligible impact on mean throughput.
 const DEFAULT_WRITE_BUFFER_SIZE: usize = 128 << 20;
 
+/// Default total `RocksDB` memtable memory budget across column families (4 GiB).
+///
+/// This is a soft limit; with write stalls enabled, `RocksDB` waits for flushes once
+/// memtable arena usage exceeds the budget.
+const DEFAULT_WRITE_BUFFER_MANAGER_SIZE: usize = 4 * 1024 * 1024 * 1024;
+
 /// Default buffer capacity for compression in batches.
 /// 4 KiB matches common block/page sizes and comfortably holds typical history values,
 /// reducing the first few reallocations without over-allocating.
 const DEFAULT_COMPRESS_BUF_CAPACITY: usize = 4096;
 
-/// Default auto-commit threshold for batch writes (4 GiB).
+/// Default auto-commit threshold for batch writes (512 MiB).
 ///
 /// When a batch exceeds this size, it is automatically committed to prevent OOM
-/// during large bulk writes. The consistency check on startup heals any crash
-/// that occurs between auto-commits.
-const DEFAULT_AUTO_COMMIT_THRESHOLD: usize = 4 * 1024 * 1024 * 1024;
+/// during large bulk writes. Keep this below the `RocksDB` write buffer manager
+/// budget so stalls can recover without waiting on a single large flush.
+/// The consistency check on startup heals any crash that occurs between auto-commits.
+const DEFAULT_AUTO_COMMIT_THRESHOLD: usize = 512 * 1024 * 1024;
 
 /// Builder for [`RocksDBProvider`].
 pub struct RocksDBBuilder {
@@ -207,6 +214,9 @@ impl RocksDBBuilder {
         options.create_missing_column_families(true);
         options.set_max_background_jobs(DEFAULT_MAX_BACKGROUND_JOBS);
         options.set_bytes_per_sync(DEFAULT_BYTES_PER_SYNC);
+        let write_buffer_manager =
+            WriteBufferManager::new_write_buffer_manager(DEFAULT_WRITE_BUFFER_MANAGER_SIZE, true);
+        options.set_write_buffer_manager(&write_buffer_manager);
 
         options.set_bottommost_compression_type(DBCompressionType::Zstd);
         options.set_bottommost_zstd_max_train_bytes(0, true);
diff --git a/crates/storage/provider/src/providers/state/overlay.rs b/crates/storage/provider/src/providers/state/overlay.rs
index 35b860fb110..1d45351f0a8 100644
--- a/crates/storage/provider/src/providers/state/overlay.rs
+++ b/crates/storage/provider/src/providers/state/overlay.rs
@@ -1,7 +1,7 @@
 use alloy_eips::BlockNumHash;
 use alloy_primitives::{BlockHash, BlockNumber, B256};
 use metrics::{Counter, Histogram};
-use reth_chain_state::{EthPrimitives, LazyOverlay};
+use reth_chain_state::{EthPrimitives, StateTrieOverlayManager};
 use reth_db_api::{tables, transaction::DbTx, DatabaseError};
 use reth_errors::{ProviderError, ProviderResult};
 use reth_metrics::Metrics;
@@ -62,31 +62,38 @@ pub(super) struct Overlay {
 }
 
 /// Source of overlay data for [`OverlayStateProviderFactory`].
-///
-/// Either provides immediate pre-computed overlay data, or a lazy overlay that computes
-/// on first access.
 #[derive(Debug, Clone)]
 pub(super) enum OverlaySource<N: NodePrimitives = EthPrimitives> {
     /// Immediate overlay with already-computed data.
     Immediate {
         /// Trie updates overlay.
+        ///
+        /// This can be non-empty when a caller starts with an explicit `TrieInputSorted`, such
+        /// as historical providers.
         trie: Arc<TrieUpdatesSorted>,
         /// Hashed state overlay.
         state: Arc<HashedPostStateSorted>,
     },
-    /// Lazy overlay computed on first access.
-    Lazy(LazyOverlay<N>),
+    /// Manager-backed overlay for in-memory state, with optional immediate overlay data.
+    Managed {
+        /// Manager used to resolve in-memory parent state if the parent is not persisted.
+        manager: StateTrieOverlayManager<N>,
+        /// Immediate hashed state overlay applied on top of any manager-produced overlay.
+        ///
+        /// This is populated by the `with_hashed_state_overlay` methods.
+        state: Arc<HashedPostStateSorted>,
+    },
 }
 
 /// Builder for calculating trie and hashed-state overlays.
 ///
-/// This stores the overlay configuration and the logic for resolving immediate/lazy overlays and
-/// collecting reverts. It is intentionally independent from any provider factory or overlay cache.
+/// This stores the overlay configuration and the logic for resolving overlays and collecting
+/// reverts. It is intentionally independent from any provider factory or overlay cache.
 #[derive(Debug, Clone)]
 pub struct OverlayBuilder<N: NodePrimitives = EthPrimitives> {
-    /// Anchor hash to revert the DB state to before applying overlays.
-    anchor_hash: B256,
-    /// Optional overlay source (lazy or immediate).
+    /// Parent hash requested by the caller.
+    parent_hash: B256,
+    /// Optional overlay source.
     overlay_source: Option<OverlaySource<N>>,
     /// Changeset cache handle for retrieving trie changesets
     changeset_cache: ChangesetCache,
@@ -96,44 +103,32 @@ pub struct OverlayBuilder<N: NodePrimitives = EthPrimitives> {
 
 impl<N: NodePrimitives> OverlayBuilder<N> {
     /// Create a new overlay builder.
-    pub fn new(anchor_hash: B256, changeset_cache: ChangesetCache) -> Self {
+    pub fn new(parent_hash: B256, changeset_cache: ChangesetCache) -> Self {
         Self {
-            anchor_hash,
+            parent_hash,
             overlay_source: None,
             changeset_cache,
             metrics: OverlayStateProviderMetrics::default(),
         }
     }
 
-    /// Set the overlay source (lazy or immediate).
+    /// Set the overlay source.
     ///
-    /// This overlay will be applied on top of any reverts applied via `anchor_hash`.
+    /// This overlay will be applied on top of any reverts.
     pub(super) fn with_overlay_source(mut self, source: Option<OverlaySource<N>>) -> Self {
-        if let Some(OverlaySource::Lazy(lazy_overlay)) = source.as_ref() {
-            self.assert_lazy_overlay_anchor(lazy_overlay);
-        }
         self.overlay_source = source;
         self
     }
 
-    fn assert_lazy_overlay_anchor(&self, lazy_overlay: &LazyOverlay<N>) {
-        let Some(lazy_overlay_anchor) = lazy_overlay.anchor_hash() else { return };
-        assert!(
-            lazy_overlay_anchor == self.anchor_hash,
-            "LazyOverlay's anchor ({}) != OverlayBuilder's anchor ({})",
-            lazy_overlay_anchor,
-            self.anchor_hash,
-        );
-    }
-
-    /// Set a lazy overlay that will be computed on first access.
-    ///
-    /// Panics if the [`LazyOverlay`]'s anchor hash does not match [`Self`]'s `anchor_hash`.
-    pub fn with_lazy_overlay(mut self, lazy_overlay: Option<LazyOverlay<N>>) -> Self {
-        if let Some(lazy_overlay) = lazy_overlay.as_ref() {
-            self.assert_lazy_overlay_anchor(lazy_overlay);
-        }
-        self.overlay_source = lazy_overlay.map(OverlaySource::Lazy);
+    /// Set the state trie overlay manager used to resolve in-memory parent state.
+    pub fn with_state_trie_overlay_manager(
+        mut self,
+        state_trie_overlay_manager: StateTrieOverlayManager<N>,
+    ) -> Self {
+        self.overlay_source = Some(OverlaySource::Managed {
+            manager: state_trie_overlay_manager,
+            state: Arc::new(HashedPostStateSorted::default()),
+        });
         self
     }
 
@@ -143,29 +138,29 @@ impl<N: NodePrimitives> OverlayBuilder<N> {
         hashed_state_overlay: Option<Arc<HashedPostStateSorted>>,
     ) -> Self {
         if let Some(state) = hashed_state_overlay {
-            self.overlay_source = Some(OverlaySource::Immediate {
-                trie: Arc::new(TrieUpdatesSorted::default()),
-                state,
-            });
+            match &mut self.overlay_source {
+                Some(OverlaySource::Managed { state: managed_state, .. }) => {
+                    *managed_state = state;
+                }
+                _ => {
+                    self.overlay_source = Some(OverlaySource::Immediate {
+                        trie: Arc::new(TrieUpdatesSorted::default()),
+                        state,
+                    });
+                }
+            }
         }
         self
     }
 
     /// Extends the existing hashed state overlay with the given [`HashedPostStateSorted`].
     ///
-    /// If no overlay exists, creates a new immediate overlay with the given state.
-    /// If a lazy overlay exists, it is resolved first then extended.
+    /// If no overlay exists, creates an immediate overlay with the given state.
     pub fn with_extended_hashed_state_overlay(mut self, other: HashedPostStateSorted) -> Self {
         match &mut self.overlay_source {
-            Some(OverlaySource::Immediate { state, .. }) => {
+            Some(OverlaySource::Immediate { state, .. } | OverlaySource::Managed { state, .. }) => {
                 Arc::make_mut(state).extend_ref_and_sort(&other);
             }
-            Some(OverlaySource::Lazy(overlay)) => {
-                // Resolve lazy overlay and convert to immediate with extension
-                let (trie, mut state) = overlay.as_overlay(self.anchor_hash);
-                Arc::make_mut(&mut state).extend_ref_and_sort(&other);
-                self.overlay_source = Some(OverlaySource::Immediate { trie, state });
-            }
             None => {
                 self.overlay_source = Some(OverlaySource::Immediate {
                     trie: Arc::new(TrieUpdatesSorted::default()),
@@ -177,20 +172,36 @@ impl<N: NodePrimitives> OverlayBuilder<N> {
     }
 
     /// Resolves the effective overlay (trie updates, hashed state).
-    ///
-    /// If an overlay source is set, it is resolved (blocking if lazy).
-    /// Otherwise, returns empty defaults.
     fn resolve_overlays(
         &self,
         anchor_hash: BlockHash,
     ) -> ProviderResult<(Arc<TrieUpdatesSorted>, Arc<HashedPostStateSorted>)> {
         match &self.overlay_source {
-            Some(OverlaySource::Lazy(lazy_overlay)) => Ok(lazy_overlay.as_overlay(anchor_hash)),
+            Some(OverlaySource::Managed { manager, state }) => {
+                let (trie, mut overlay_state) = if anchor_hash == self.parent_hash {
+                    (
+                        Arc::new(TrieUpdatesSorted::default()),
+                        Arc::new(HashedPostStateSorted::default()),
+                    )
+                } else {
+                    manager
+                        .overlay_for_parent(self.parent_hash, anchor_hash)
+                        .map_err(ProviderError::other)?
+                };
+
+                if overlay_state.is_empty() {
+                    overlay_state = Arc::clone(state);
+                } else if !state.is_empty() {
+                    Arc::make_mut(&mut overlay_state).extend_ref_and_sort(state);
+                }
+
+                Ok((trie, overlay_state))
+            }
             Some(OverlaySource::Immediate { trie, state }) => {
-                if anchor_hash != self.anchor_hash {
+                if anchor_hash != self.parent_hash {
                     return Err(ProviderError::other(std::io::Error::other(format!(
-                        "anchor_hash {anchor_hash} doesn't match OverlayBuilder's configured anchor ({})",
-                        self.anchor_hash
+                        "anchor_hash {anchor_hash} doesn't match OverlayBuilder's configured parent ({})",
+                        self.parent_hash
                     ))))
                 }
                 Ok((Arc::clone(trie), Arc::clone(state)))
@@ -202,16 +213,6 @@ impl<N: NodePrimitives> OverlayBuilder<N> {
         }
     }
 
-    /// Returns the block number for [`Self`]'s `anchor_hash` field.
-    fn get_block_number<Provider>(&self, provider: &Provider) -> ProviderResult<BlockNumber>
-    where
-        Provider: BlockNumReader,
-    {
-        provider
-            .convert_hash_or_number(self.anchor_hash.into())?
-            .ok_or(ProviderError::BlockHashNotFound(self.anchor_hash))
-    }
-
     /// Returns the block which is at the tip of the DB, i.e. the block which the state tables of
     /// the DB are currently synced to.
     fn get_db_tip_block<Provider>(&self, provider: &Provider) -> ProviderResult<BlockNumHash>
@@ -241,25 +242,19 @@ impl<N: NodePrimitives> OverlayBuilder<N> {
         &self,
         provider: &Provider,
         db_tip_block: BlockNumHash,
+        anchor_hash: B256,
     ) -> ProviderResult<Option<RangeInclusive<BlockNumber>>>
     where
         Provider: BlockNumReader + PruneCheckpointReader,
     {
         // If the anchor is the DB tip then there won't be any reverts necessary.
-        if db_tip_block.hash == self.anchor_hash {
-            return Ok(None)
-        }
-
-        // If the DB tip has moved forward into the `LazyOverlay` then we still don't need to
-        // revert, the `LazyOverlay` will generate a new in-memory overlay using only the relevant
-        // blocks data.
-        if let Some(OverlaySource::Lazy(lazy_overlay)) = &self.overlay_source &&
-            lazy_overlay.has_anchor_hash(db_tip_block.hash)
-        {
+        if db_tip_block.hash == anchor_hash {
             return Ok(None)
         }
 
-        let anchor_number = self.get_block_number(provider)?;
+        let anchor_number = provider
+            .convert_hash_or_number(anchor_hash.into())?
+            .ok_or(ProviderError::BlockHashNotFound(anchor_hash))?;
 
         // Check account history prune checkpoint to determine the lower bound of available data.
         // The prune checkpoint's block_number is the highest pruned block, so data is available
@@ -288,7 +283,7 @@ impl<N: NodePrimitives> OverlayBuilder<N> {
         level = "debug",
         target = "providers::state::overlay",
         skip_all,
-        fields(?db_tip_block, anchor_hash = ?self.anchor_hash)
+        fields(?db_tip_block, parent_hash = ?self.parent_hash)
     )]
     fn calculate_overlay<Provider>(
         &self,
@@ -311,10 +306,25 @@ impl<N: NodePrimitives> OverlayBuilder<N> {
         let retrieve_hashed_state_reverts_duration;
         let trie_updates_total_len;
         let hashed_state_updates_total_len;
+        let anchor_hash = match &self.overlay_source {
+            Some(OverlaySource::Managed { manager, .. }) => {
+                let parent_is_persisted = provider
+                    .convert_hash_or_number(self.parent_hash.into())?
+                    .is_some_and(|parent_number| parent_number <= db_tip_block.number);
+                if parent_is_persisted {
+                    self.parent_hash
+                } else {
+                    manager
+                        .anchor_for_parent(self.parent_hash, db_tip_block.hash)
+                        .ok_or(ProviderError::BlockHashNotFound(self.parent_hash))?
+                }
+            }
+            _ => self.parent_hash,
+        };
 
         // Collect any reverts which are required to bring the DB view back to the anchor hash.
         let (trie_updates, hashed_post_state) = if let Some(revert_blocks) =
-            self.reverts_required(provider, db_tip_block)?
+            self.reverts_required(provider, db_tip_block, anchor_hash)?
         {
             debug!(
                 target: "providers::state::overlay",
@@ -349,9 +359,9 @@ impl<N: NodePrimitives> OverlayBuilder<N> {
                 res
             };
 
-            // Resolve overlays (lazy or immediate) and extend reverts with them.
+            // Resolve overlays and extend reverts with them.
             // If reverts are empty, use overlays directly to avoid cloning.
-            let (overlay_trie, overlay_state) = self.resolve_overlays(self.anchor_hash)?;
+            let (overlay_trie, overlay_state) = self.resolve_overlays(anchor_hash)?;
 
             let trie_updates = if trie_reverts.is_empty() {
                 overlay_trie
@@ -378,13 +388,12 @@ impl<N: NodePrimitives> OverlayBuilder<N> {
                 target: "providers::state::overlay",
                 num_trie_updates = ?trie_updates_total_len,
                 num_state_updates = ?hashed_state_updates_total_len,
-                "Reverted to target block",
+                "Reverted to anchor block",
             );
 
             (trie_updates, hashed_state_updates)
         } else {
-            // If no reverts are needed then we can assume that the db tip is the anchor hash or
-            // overlaps with the `LazyOverlay`. Use overlays directly.
+            // If no reverts are needed then the db tip is the anchor hash. Use overlays directly.
             let (trie_updates, hashed_state) = self.resolve_overlays(db_tip_block.hash)?;
 
             retrieve_trie_reverts_duration = Duration::ZERO;
@@ -446,13 +455,6 @@ impl<F, N: NodePrimitives> OverlayStateProviderFactory<F, N> {
         Self { factory, overlay_builder, overlay_cache: Default::default() }
     }
 
-    /// Set a lazy overlay that will be computed on first access.
-    pub fn with_lazy_overlay(mut self, lazy_overlay: Option<LazyOverlay<N>>) -> Self {
-        self.overlay_builder = self.overlay_builder.with_lazy_overlay(lazy_overlay);
-        self.overlay_cache = Default::default();
-        self
-    }
-
     /// Set the hashed state overlay.
     pub fn with_hashed_state_overlay(
         mut self,
@@ -651,3 +653,49 @@ where
         hashed_cursor_factory.hashed_storage_cursor(hashed_address)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use reth_primitives_traits::Account;
+    use reth_trie::HashedPostState;
+
+    #[test]
+    fn managed_overlay_skips_manager_for_persisted_parent() {
+        let parent_hash = B256::with_last_byte(1);
+        let builder = OverlayBuilder::<EthPrimitives>::new(parent_hash, ChangesetCache::default())
+            .with_state_trie_overlay_manager(StateTrieOverlayManager::default());
+
+        let (trie, state) = builder.resolve_overlays(parent_hash).unwrap();
+        assert!(trie.is_empty());
+        assert!(state.is_empty());
+    }
+
+    #[test]
+    fn managed_overlay_errors_if_parent_is_not_persisted_or_managed() {
+        let parent_hash = B256::with_last_byte(1);
+        let anchor_hash = B256::with_last_byte(2);
+        let builder = OverlayBuilder::<EthPrimitives>::new(parent_hash, ChangesetCache::default())
+            .with_state_trie_overlay_manager(StateTrieOverlayManager::default());
+
+        let err = builder.resolve_overlays(anchor_hash).unwrap_err();
+
+        assert!(err.to_string().contains("cannot be anchored"));
+    }
+
+    #[test]
+    fn extending_hashed_state_keeps_managed_overlay_source() {
+        let parent_hash = B256::with_last_byte(1);
+        let hashed_state = HashedPostState::default()
+            .with_accounts([(B256::with_last_byte(2), Some(Account::default()))])
+            .into_sorted();
+        let builder = OverlayBuilder::<EthPrimitives>::new(parent_hash, ChangesetCache::default())
+            .with_state_trie_overlay_manager(StateTrieOverlayManager::default())
+            .with_extended_hashed_state_overlay(hashed_state);
+
+        let Some(OverlaySource::Managed { state, .. }) = builder.overlay_source else {
+            panic!("expected managed overlay source")
+        };
+        assert_eq!(state.total_len(), 1);
+    }
+}
diff --git a/crates/storage/provider/src/providers/static_file/jar.rs b/crates/storage/provider/src/providers/static_file/jar.rs
index d1d97e1f229..7e619569e7a 100644
--- a/crates/storage/provider/src/providers/static_file/jar.rs
+++ b/crates/storage/provider/src/providers/static_file/jar.rs
@@ -6,8 +6,8 @@ use crate::{
     to_range, BlockHashReader, BlockNumReader, HeaderProvider, ReceiptProvider,
     TransactionsProvider,
 };
-use alloy_consensus::transaction::TransactionMeta;
-use alloy_eips::{eip2718::Encodable2718, BlockHashOrNumber};
+use alloy_consensus::transaction::{TransactionMeta, TxHashRef};
+use alloy_eips::BlockHashOrNumber;
 use alloy_primitives::{Address, BlockHash, BlockNumber, TxHash, TxNumber, B256};
 use reth_chainspec::ChainInfo;
 use reth_db::static_file::{
@@ -264,7 +264,7 @@ impl<N: NodePrimitives<SignedTx: Decompress + SignedTransaction>> TransactionsPr
 
         Ok(cursor
             .get_one::<TransactionMask<Self::Transaction>>((&hash).into())?
-            .and_then(|res| (res.trie_hash() == hash).then(|| cursor.number()).flatten()))
+            .and_then(|res| (*res.tx_hash() == hash).then(|| cursor.number()).flatten()))
     }
 
     fn transaction_by_id(&self, num: TxNumber) -> ProviderResult<Option<Self::Transaction>> {
diff --git a/crates/storage/provider/src/providers/static_file/manager.rs b/crates/storage/provider/src/providers/static_file/manager.rs
index dc79d779097..6f8ef1c916a 100644
--- a/crates/storage/provider/src/providers/static_file/manager.rs
+++ b/crates/storage/provider/src/providers/static_file/manager.rs
@@ -8,9 +8,12 @@ use crate::{
     EitherWriterDestination, HeaderProvider, ReceiptProvider, StageCheckpointReader, StatsReader,
     TransactionVariant, TransactionsProvider, TransactionsProviderExt,
 };
-use alloy_consensus::{transaction::TransactionMeta, Header};
-use alloy_eips::{eip2718::Encodable2718, BlockHashOrNumber};
-use alloy_primitives::{b256, keccak256, Address, BlockHash, BlockNumber, TxHash, TxNumber, B256};
+use alloy_consensus::{
+    transaction::{TransactionMeta, TxHashRef},
+    Header,
+};
+use alloy_eips::BlockHashOrNumber;
+use alloy_primitives::{b256, Address, BlockHash, BlockNumber, TxHash, TxNumber, B256};
 
 use parking_lot::RwLock;
 use reth_chain_state::ExecutedBlock;
@@ -933,6 +936,8 @@ impl<N: NodePrimitives> StaticFileProvider<N> {
     pub fn delete_segment(&self, segment: StaticFileSegment) -> ProviderResult<Vec<SegmentHeader>> {
         let mut deleted_headers = Vec::new();
 
+        self.writers.remove(segment);
+
         while let Some(block_height) = self.get_highest_static_file_block(segment) {
             debug!(
                 target: "providers::static_file",
@@ -2713,10 +2718,8 @@ impl<N: NodePrimitives<SignedTx: Value, Receipt: Value, BlockHeader: Value>> Tra
             let manager = self.clone();
 
             // Spawn the task onto the global rayon pool
-            // This task will send the results through the channel after it has calculated
-            // the hash.
+            // This task will send the cached transaction hash through the channel.
             rayon::spawn(move || {
-                let mut rlp_buf = Vec::with_capacity(128);
                 let _ = manager.fetch_range_with_predicate(
                     StaticFileSegment::Transactions,
                     chunk_range,
@@ -2724,9 +2727,7 @@ impl<N: NodePrimitives<SignedTx: Value, Receipt: Value, BlockHeader: Value>> Tra
                         Ok(cursor
                             .get_one::<TransactionMask<Self::Transaction>>(number.into())?
                             .map(|transaction| {
-                                rlp_buf.clear();
-                                let _ = channel_tx
-                                    .send(calculate_hash((number, transaction), &mut rlp_buf));
+                                let _ = channel_tx.send(transaction_hash((number, transaction)));
                             }))
                     },
                     |_| true,
@@ -2758,7 +2759,7 @@ impl<N: NodePrimitives<SignedTx: Decompress + SignedTransaction>> TransactionsPr
             let mut cursor = jar_provider.cursor()?;
             if cursor
                 .get_one::<TransactionMask<Self::Transaction>>((&tx_hash).into())?
-                .and_then(|tx| (tx.trie_hash() == tx_hash).then_some(tx))
+                .and_then(|tx| (*tx.tx_hash() == tx_hash).then_some(tx))
                 .is_some()
             {
                 Ok(cursor.number())
@@ -2800,7 +2801,7 @@ impl<N: NodePrimitives<SignedTx: Decompress + SignedTransaction>> TransactionsPr
             Ok(jar_provider
                 .cursor()?
                 .get_one::<TransactionMask<Self::Transaction>>((&hash).into())?
-                .and_then(|tx| (tx.trie_hash() == hash).then_some(tx)))
+                .and_then(|tx| (*tx.tx_hash() == hash).then_some(tx)))
         })
     }
 
@@ -3002,18 +3003,14 @@ impl<N: NodePrimitives> StatsReader for StaticFileProvider<N> {
     }
 }
 
-/// Calculates the tx hash for the given transaction and its id.
+/// Returns the tx hash for the given transaction and its id.
 #[inline]
-fn calculate_hash<T>(
-    entry: (TxNumber, T),
-    rlp_buf: &mut Vec<u8>,
-) -> Result<(B256, TxNumber), Box<ProviderError>>
+fn transaction_hash<T>(entry: (TxNumber, T)) -> Result<(B256, TxNumber), Box<ProviderError>>
 where
-    T: Encodable2718,
+    T: TxHashRef,
 {
     let (tx_id, tx) = entry;
-    tx.encode_2718(rlp_buf);
-    Ok((keccak256(rlp_buf), tx_id))
+    Ok((*tx.tx_hash(), tx_id))
 }
 
 #[cfg(test)]
diff --git a/crates/storage/provider/src/providers/static_file/writer.rs b/crates/storage/provider/src/providers/static_file/writer.rs
index b98569a6106..7a0196714e2 100644
--- a/crates/storage/provider/src/providers/static_file/writer.rs
+++ b/crates/storage/provider/src/providers/static_file/writer.rs
@@ -115,6 +115,20 @@ impl<N: NodePrimitives> StaticFileWriters<N> {
         Ok(StaticFileProviderRWRefMut(write_guard))
     }
 
+    /// Drops the cached writer for a segment before destructive segment-level operations.
+    pub(crate) fn remove(&self, segment: StaticFileSegment) {
+        let mut write_guard = match segment {
+            StaticFileSegment::Headers => self.headers.write(),
+            StaticFileSegment::Transactions => self.transactions.write(),
+            StaticFileSegment::Receipts => self.receipts.write(),
+            StaticFileSegment::TransactionSenders => self.transaction_senders.write(),
+            StaticFileSegment::AccountChangeSets => self.account_change_sets.write(),
+            StaticFileSegment::StorageChangeSets => self.storage_change_sets.write(),
+        };
+
+        *write_guard = None;
+    }
+
     #[instrument(
         name = "StaticFileWriters::commit",
         level = "debug",
@@ -1371,6 +1385,34 @@ impl<N: NodePrimitives> StaticFileProviderRW<N> {
         Ok(())
     }
 
+    /// Starts a block account changeset that will be appended one entry at a time.
+    ///
+    /// Callers must append entries sorted by address and keep the writer open until the block is
+    /// complete so the changeset offset sidecar is finalized with the correct row count.
+    pub fn begin_account_changeset(&mut self, block_number: u64) -> ProviderResult<()> {
+        debug_assert!(self.writer.user_header().segment() == StaticFileSegment::AccountChangeSets);
+
+        self.increment_block(block_number)?;
+        self.ensure_no_queued_prune()
+    }
+
+    /// Appends one account changeset entry to the current block.
+    ///
+    /// [`Self::begin_account_changeset`] must be called first.
+    pub fn append_account_changeset_entry(
+        &mut self,
+        change: AccountBeforeTx,
+    ) -> ProviderResult<()> {
+        debug_assert!(self.writer.user_header().segment() == StaticFileSegment::AccountChangeSets);
+        if self.current_changeset_offset.is_none() {
+            return Err(ProviderError::other(StaticFileWriterError::new(
+                "account changeset stream must be started before appending entries",
+            )))
+        }
+
+        self.append_change(&change)
+    }
+
     /// Appends a block storage changeset to the static file.
     ///
     /// It **CALLS** `increment_block()`.
@@ -1406,6 +1448,35 @@ impl<N: NodePrimitives> StaticFileProviderRW<N> {
         Ok(())
     }
 
+    /// Starts a block storage changeset that will be appended one entry at a time.
+    ///
+    /// Callers must append entries sorted by address and storage key and keep the writer open until
+    /// the block is complete so the changeset offset sidecar is finalized with the correct row
+    /// count.
+    pub fn begin_storage_changeset(&mut self, block_number: u64) -> ProviderResult<()> {
+        debug_assert!(self.writer.user_header().segment() == StaticFileSegment::StorageChangeSets);
+
+        self.increment_block(block_number)?;
+        self.ensure_no_queued_prune()
+    }
+
+    /// Appends one storage changeset entry to the current block.
+    ///
+    /// [`Self::begin_storage_changeset`] must be called first.
+    pub fn append_storage_changeset_entry(
+        &mut self,
+        change: StorageBeforeTx,
+    ) -> ProviderResult<()> {
+        debug_assert!(self.writer.user_header().segment() == StaticFileSegment::StorageChangeSets);
+        if self.current_changeset_offset.is_none() {
+            return Err(ProviderError::other(StaticFileWriterError::new(
+                "storage changeset stream must be started before appending entries",
+            )))
+        }
+
+        self.append_change(&change)
+    }
+
     /// Adds an instruction to prune `to_delete` transactions during commit.
     ///
     /// Note: `last_block` refers to the block the unwinds ends at.
diff --git a/crates/storage/provider/src/test_utils/mock.rs b/crates/storage/provider/src/test_utils/mock.rs
index 72fa695a0a2..04f1bab12ff 100644
--- a/crates/storage/provider/src/test_utils/mock.rs
+++ b/crates/storage/provider/src/test_utils/mock.rs
@@ -441,7 +441,7 @@ impl<T: NodePrimitives, ChainSpec: EthChainSpec + 'static> TransactionsProvider
     ) -> ProviderResult<Vec<Vec<Self::Transaction>>> {
         // init btreemap so we can return in order
         let mut map = BTreeMap::new();
-        for (_, block) in self.blocks.lock().iter() {
+        for block in self.blocks.lock().values() {
             if range.contains(&block.header().number()) {
                 map.insert(block.header().number(), block.body().clone_transactions());
             }
diff --git a/crates/storage/provider/src/traits/full.rs b/crates/storage/provider/src/traits/full.rs
index b4b057ab43c..070d8bfefd5 100644
--- a/crates/storage/provider/src/traits/full.rs
+++ b/crates/storage/provider/src/traits/full.rs
@@ -43,6 +43,7 @@ pub trait FullProvider<N: NodeTypesWithDB>:
     + ForkChoiceSubscriptions<Header = HeaderTy<N>>
     + PersistedBlockSubscriptions
     + StageCheckpointReader
+    + PruneCheckpointReader
     + Clone
     + Debug
     + Unpin
@@ -79,6 +80,7 @@ impl<T, N: NodeTypesWithDB> FullProvider<N> for T where
         + ForkChoiceSubscriptions<Header = HeaderTy<N>>
         + PersistedBlockSubscriptions
         + StageCheckpointReader
+        + PruneCheckpointReader
         + Clone
         + Debug
         + Unpin
diff --git a/crates/storage/storage-api/Cargo.toml b/crates/storage/storage-api/Cargo.toml
index 591b3205016..eb75a1c014c 100644
--- a/crates/storage/storage-api/Cargo.toml
+++ b/crates/storage/storage-api/Cargo.toml
@@ -27,12 +27,19 @@ reth-ethereum-primitives.workspace = true
 
 # ethereum
 alloy-eips.workspace = true
+alloy-eip7928.workspace = true
 alloy-primitives.workspace = true
 alloy-consensus.workspace = true
 alloy-rpc-types-engine.workspace = true
 
 auto_impl.workspace = true
 serde_json = { workspace = true, optional = true }
+reth-tokio-util = { workspace = true, optional = true }
+
+[dev-dependencies]
+alloy-primitives = { workspace = true, features = ["getrandom"] }
+tokio = { workspace = true, features = ["macros", "rt"] }
+tokio-stream.workspace = true
 
 [features]
 default = ["std"]
@@ -52,6 +59,8 @@ std = [
     "reth-db-models/std",
     "reth-trie-common/std",
     "serde_json?/std",
+    "dep:reth-tokio-util",
+    "alloy-eip7928/std",
 ]
 
 db-api = [
@@ -72,6 +81,7 @@ serde = [
     "alloy-primitives/serde",
     "alloy-consensus/serde",
     "alloy-rpc-types-engine/serde",
+    "alloy-eip7928/serde",
 ]
 
 serde-bincode-compat = [
diff --git a/crates/storage/storage-api/src/bal.rs b/crates/storage/storage-api/src/bal.rs
index 4e82595d3d2..d280e0fceb7 100644
--- a/crates/storage/storage-api/src/bal.rs
+++ b/crates/storage/storage-api/src/bal.rs
@@ -1,6 +1,39 @@
 use alloc::{sync::Arc, vec::Vec};
-use alloy_primitives::{BlockHash, BlockNumber, Bytes};
+use alloy_eip7928::bal::DecodedBal;
+use alloy_eips::NumHash;
+use alloy_primitives::{BlockHash, BlockNumber, Bytes, Sealed};
 use reth_storage_errors::provider::ProviderResult;
+use revm_database::state::bal::Bal as RevmBal;
+
+/// Raw BAL RLP bytes sealed by the BAL hash.
+pub type SealedBal = Sealed<Bytes>;
+
+/// Notification emitted when a new BAL is inserted into the store.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct BalNotification {
+    /// Number and hash of the block the BAL belongs to.
+    pub num_hash: NumHash,
+    /// Raw BAL RLP payload sealed by the BAL hash.
+    pub bal: SealedBal,
+}
+
+impl BalNotification {
+    /// Creates a new [`BalNotification`].
+    pub const fn new(num_hash: NumHash, bal: SealedBal) -> Self {
+        Self { num_hash, bal }
+    }
+}
+
+#[cfg(feature = "std")]
+pub use self::subscriptions::BalNotificationStream;
+
+#[cfg(feature = "std")]
+mod subscriptions {
+    use super::BalNotification;
+
+    /// A stream of [`BalNotification`]s.
+    pub type BalNotificationStream = reth_tokio_util::EventStream<BalNotification>;
+}
 
 /// Store for Block Access Lists (BALs).
 ///
@@ -10,28 +43,76 @@ use reth_storage_errors::provider::ProviderResult;
 #[auto_impl::auto_impl(&, Arc, Box)]
 pub trait BalStore: Send + Sync + 'static {
     /// Insert the BAL for the given block.
-    fn insert(
-        &self,
-        block_hash: BlockHash,
-        block_number: BlockNumber,
-        bal: Bytes,
-    ) -> ProviderResult<()>;
+    ///
+    /// Implementations may buffer inserts. Call [`Self::flush`] when pending BALs need to be made
+    /// durable.
+    fn insert(&self, num_hash: NumHash, bal: SealedBal) -> ProviderResult<()>;
+
+    /// Insert multiple BALs.
+    ///
+    /// The default implementation preserves the behavior of repeated [`Self::insert`] calls.
+    fn insert_many(&self, entries: Vec<(NumHash, SealedBal)>) -> ProviderResult<()> {
+        for (num_hash, bal) in entries {
+            self.insert(num_hash, bal)?;
+        }
+        Ok(())
+    }
+
+    /// Flushes any pending BALs to the backing store.
+    ///
+    /// In-memory implementations may treat this as a no-op.
+    fn flush(&self) -> ProviderResult<()> {
+        Ok(())
+    }
+
+    /// Prunes expired BALs according to the store's retention policy and the given chain tip.
+    ///
+    /// Returns the number of BALs pruned.
+    fn prune(&self, tip: BlockNumber) -> ProviderResult<usize>;
 
     /// Fetch BALs for the given block hashes.
     ///
     /// The returned vector must align with `block_hashes`.
     fn get_by_hashes(&self, block_hashes: &[BlockHash]) -> ProviderResult<Vec<Option<Bytes>>>;
 
+    /// Fetches the BAL for the given block hash.
+    fn get_by_hash(&self, block_hash: BlockHash) -> ProviderResult<Option<Bytes>> {
+        Ok(self.get_by_hashes(&[block_hash])?.into_iter().next().flatten())
+    }
+
+    /// Fetches and decodes the BAL for the given block hash.
+    fn get_decoded_by_hash(&self, block_hash: BlockHash) -> ProviderResult<Option<DecodedBal>> {
+        self.get_by_hash(block_hash)?
+            .map(DecodedBal::from_rlp_bytes)
+            .transpose()
+            .map_err(Into::into)
+    }
+
+    /// Fetches the BAL for the given block hash in revm representation.
+    fn revm_bal_by_hash(
+        &self,
+        block_hash: BlockHash,
+    ) -> ProviderResult<Option<DecodedBal<RevmBal>>> {
+        self.get_decoded_by_hash(block_hash)?
+            .map(|decoded| {
+                decoded.try_map(|bal| {
+                    RevmBal::try_from(Vec::from(bal))
+                        .map_err(reth_storage_errors::provider::ProviderError::other)
+                })
+            })
+            .transpose()
+    }
+
     /// Fetch BAL response entries for the given block hashes, stopping after the soft limit is
     /// exceeded.
     ///
-    /// Entries are returned in request order. Unavailable BALs are represented as an RLP-encoded
-    /// empty list (`0xc0`). The limit is soft: the entry that exceeds the limit is included.
+    /// Entries are returned in request order. Unavailable BALs are represented as `None`. The
+    /// limit is soft: the entry that exceeds the limit is included.
     fn get_by_hashes_with_limit(
         &self,
         block_hashes: &[BlockHash],
         limit: GetBlockAccessListLimit,
-    ) -> ProviderResult<Vec<Bytes>> {
+    ) -> ProviderResult<Vec<Option<Bytes>>> {
         let mut out = Vec::new();
         self.append_by_hashes_with_limit(block_hashes, limit, &mut out)?;
         out.shrink_to_fit();
@@ -45,12 +126,11 @@ pub trait BalStore: Send + Sync + 'static {
         &self,
         block_hashes: &[BlockHash],
         limit: GetBlockAccessListLimit,
-        out: &mut Vec<Bytes>,
+        out: &mut Vec<Option<Bytes>>,
     ) -> ProviderResult<()> {
         let mut size = 0;
         for bal in self.get_by_hashes(block_hashes)? {
-            let bal = bal.unwrap_or_else(|| Bytes::from_static(&[0xc0]));
-            size += bal.len();
+            size += bal.as_ref().map_or(1, |bytes| bytes.len());
             out.push(bal);
 
             if limit.exceeds(size) {
@@ -60,10 +140,12 @@ pub trait BalStore: Send + Sync + 'static {
         Ok(())
     }
 
-    /// Fetch BALs for the requested range.
+    /// Returns a stream of BAL insert notifications.
     ///
-    /// Implementations may stop at the first gap and return the contiguous prefix.
-    fn get_by_range(&self, start: BlockNumber, count: u64) -> ProviderResult<Vec<Bytes>>;
+    /// Notifications are emitted only after a BAL has been successfully inserted into the store.
+    /// They do not imply canonicality.
+    #[cfg(feature = "std")]
+    fn bal_stream(&self) -> BalNotificationStream;
 }
 
 /// The limit to enforce for [`BalStore::get_by_hashes_with_limit`].
@@ -105,13 +187,26 @@ impl BalStoreHandle {
 
     /// Insert the BAL for the given block.
     #[inline]
-    pub fn insert(
-        &self,
-        block_hash: BlockHash,
-        block_number: BlockNumber,
-        bal: Bytes,
-    ) -> ProviderResult<()> {
-        self.inner.insert(block_hash, block_number, bal)
+    pub fn insert(&self, num_hash: NumHash, bal: SealedBal) -> ProviderResult<()> {
+        self.inner.insert(num_hash, bal)
+    }
+
+    /// Insert multiple BALs.
+    #[inline]
+    pub fn insert_many(&self, entries: Vec<(NumHash, SealedBal)>) -> ProviderResult<()> {
+        self.inner.insert_many(entries)
+    }
+
+    /// Flushes any pending BALs to the backing store.
+    #[inline]
+    pub fn flush(&self) -> ProviderResult<()> {
+        self.inner.flush()
+    }
+
+    /// Prunes expired BALs according to the store's retention policy and the given chain tip.
+    #[inline]
+    pub fn prune(&self, tip: BlockNumber) -> ProviderResult<usize> {
+        self.inner.prune(tip)
     }
 
     /// Fetch BALs for the given block hashes.
@@ -120,6 +215,27 @@ impl BalStoreHandle {
         self.inner.get_by_hashes(block_hashes)
     }
 
+    /// Fetches the BAL for the given block hash.
+    #[inline]
+    pub fn get_by_hash(&self, block_hash: BlockHash) -> ProviderResult<Option<Bytes>> {
+        self.inner.get_by_hash(block_hash)
+    }
+
+    /// Fetches and decodes the BAL for the given block hash.
+    #[inline]
+    pub fn get_decoded_by_hash(&self, block_hash: BlockHash) -> ProviderResult<Option<DecodedBal>> {
+        self.inner.get_decoded_by_hash(block_hash)
+    }
+
+    /// Fetches the BAL for the given block hash in revm representation.
+    #[inline]
+    pub fn revm_bal_by_hash(
+        &self,
+        block_hash: BlockHash,
+    ) -> ProviderResult<Option<DecodedBal<RevmBal>>> {
+        self.inner.revm_bal_by_hash(block_hash)
+    }
+
     /// Fetch BAL response entries for the given block hashes, stopping after the soft limit is
     /// exceeded.
     #[inline]
@@ -127,7 +243,7 @@ impl BalStoreHandle {
         &self,
         block_hashes: &[BlockHash],
         limit: GetBlockAccessListLimit,
-    ) -> ProviderResult<Vec<Bytes>> {
+    ) -> ProviderResult<Vec<Option<Bytes>>> {
         self.inner.get_by_hashes_with_limit(block_hashes, limit)
     }
 
@@ -137,15 +253,16 @@ impl BalStoreHandle {
         &self,
         block_hashes: &[BlockHash],
         limit: GetBlockAccessListLimit,
-        out: &mut Vec<Bytes>,
+        out: &mut Vec<Option<Bytes>>,
     ) -> ProviderResult<()> {
         self.inner.append_by_hashes_with_limit(block_hashes, limit, out)
     }
 
-    /// Fetch BALs for the requested range.
+    /// Returns a stream of BAL insert notifications.
+    #[cfg(feature = "std")]
     #[inline]
-    pub fn get_by_range(&self, start: BlockNumber, count: u64) -> ProviderResult<Vec<Bytes>> {
-        self.inner.get_by_range(start, count)
+    pub fn bal_stream(&self) -> BalNotificationStream {
+        self.inner.bal_stream()
     }
 }
 
@@ -173,15 +290,18 @@ pub trait BalProvider {
 pub struct NoopBalStore;
 
 impl BalStore for NoopBalStore {
-    fn insert(
-        &self,
-        _block_hash: BlockHash,
-        _block_number: BlockNumber,
-        _bal: Bytes,
-    ) -> ProviderResult<()> {
+    fn insert(&self, _num_hash: NumHash, _bal: SealedBal) -> ProviderResult<()> {
+        Ok(())
+    }
+
+    fn insert_many(&self, _entries: Vec<(NumHash, SealedBal)>) -> ProviderResult<()> {
         Ok(())
     }
 
+    fn prune(&self, _tip: BlockNumber) -> ProviderResult<usize> {
+        Ok(0)
+    }
+
     fn get_by_hashes(&self, block_hashes: &[BlockHash]) -> ProviderResult<Vec<Option<Bytes>>> {
         Ok(block_hashes.iter().map(|_| None).collect())
     }
@@ -190,13 +310,12 @@ impl BalStore for NoopBalStore {
         &self,
         block_hashes: &[BlockHash],
         limit: GetBlockAccessListLimit,
-        out: &mut Vec<Bytes>,
+        out: &mut Vec<Option<Bytes>>,
     ) -> ProviderResult<()> {
         let mut size = 0;
         for _ in block_hashes {
-            let bal = Bytes::from_static(&[0xc0]);
-            size += bal.len();
-            out.push(bal);
+            size += 1;
+            out.push(None);
 
             if limit.exceeds(size) {
                 break
@@ -205,8 +324,9 @@ impl BalStore for NoopBalStore {
         Ok(())
     }
 
-    fn get_by_range(&self, _start: BlockNumber, _count: u64) -> ProviderResult<Vec<Bytes>> {
-        Ok(Vec::new())
+    #[cfg(feature = "std")]
+    fn bal_stream(&self) -> BalNotificationStream {
+        reth_tokio_util::EventSender::new(1).new_listener()
     }
 }
 
@@ -214,6 +334,10 @@ impl BalStore for NoopBalStore {
 mod tests {
     use super::*;
     use alloy_primitives::B256;
+    #[cfg(feature = "std")]
+    use tokio_stream::StreamExt;
+
+    const EMPTY_LIST_CODE: u8 = 0xc0;
 
     #[test]
     fn noop_store_returns_empty_results() {
@@ -221,10 +345,42 @@ mod tests {
         let hashes = [B256::random(), B256::random()];
 
         let by_hash = store.get_by_hashes(&hashes).unwrap();
-        let by_range = store.get_by_range(1, 10).unwrap();
 
         assert_eq!(by_hash, vec![None, None]);
-        assert!(by_range.is_empty());
+        assert!(store.get_by_hash(B256::random()).unwrap().is_none());
+        assert_eq!(store.prune(10).unwrap(), 0);
+    }
+
+    #[test]
+    fn noop_store_flush_is_noop() {
+        let store = BalStoreHandle::default();
+
+        store.flush().unwrap();
+    }
+
+    #[test]
+    fn noop_store_decoded_lookup_returns_none() {
+        let store = BalStoreHandle::default();
+
+        assert!(store.get_decoded_by_hash(B256::random()).unwrap().is_none());
+    }
+
+    #[test]
+    fn decoded_lookup_decodes_raw_bal() {
+        let hash = B256::random();
+        let raw_bal = Bytes::from_static(&[EMPTY_LIST_CODE]);
+        let store = BalStoreHandle::new(TestBalStore { hash, raw_bal: raw_bal.clone() });
+
+        assert_eq!(store.get_by_hash(hash).unwrap(), Some(raw_bal.clone()));
+
+        let decoded = store.get_decoded_by_hash(hash).unwrap().unwrap();
+
+        assert_eq!(decoded.as_raw(), &raw_bal);
+
+        let revm_bal = store.revm_bal_by_hash(hash).unwrap().unwrap();
+
+        assert_eq!(revm_bal.as_raw(), &raw_bal);
+        assert!(revm_bal.as_bal().accounts.is_empty());
     }
 
     #[test]
@@ -236,7 +392,7 @@ mod tests {
             .get_by_hashes_with_limit(&hashes, GetBlockAccessListLimit::ResponseSizeSoftLimit(1))
             .unwrap();
 
-        assert_eq!(limited, vec![Bytes::from_static(&[0xc0]), Bytes::from_static(&[0xc0])]);
+        assert_eq!(limited, vec![None, None]);
     }
 
     #[test]
@@ -249,4 +405,41 @@ mod tests {
         assert!(!size_limit_2mb.exceeds(2 * 1024 * 1024));
         assert!(size_limit_2mb.exceeds(3 * 1024 * 1024));
     }
+
+    #[cfg(feature = "std")]
+    #[tokio::test]
+    async fn noop_store_stream_is_empty() {
+        let store = BalStoreHandle::default();
+        let mut stream = store.bal_stream();
+
+        assert!(stream.next().await.is_none());
+    }
+
+    #[derive(Debug)]
+    struct TestBalStore {
+        hash: B256,
+        raw_bal: Bytes,
+    }
+
+    impl BalStore for TestBalStore {
+        fn insert(&self, _num_hash: NumHash, _bal: SealedBal) -> ProviderResult<()> {
+            Ok(())
+        }
+
+        fn prune(&self, _tip: BlockNumber) -> ProviderResult<usize> {
+            Ok(0)
+        }
+
+        fn get_by_hashes(&self, block_hashes: &[BlockHash]) -> ProviderResult<Vec<Option<Bytes>>> {
+            Ok(block_hashes
+                .iter()
+                .map(|hash| (*hash == self.hash).then(|| self.raw_bal.clone()))
+                .collect())
+        }
+
+        #[cfg(feature = "std")]
+        fn bal_stream(&self) -> BalNotificationStream {
+            reth_tokio_util::EventSender::new(1).new_listener()
+        }
+    }
 }
diff --git a/crates/tasks/Cargo.toml b/crates/tasks/Cargo.toml
index ef01fc76cba..455ab217e5e 100644
--- a/crates/tasks/Cargo.toml
+++ b/crates/tasks/Cargo.toml
@@ -23,6 +23,7 @@ metrics.workspace = true
 
 # misc
 dashmap.workspace = true
+parking_lot.workspace = true
 thread-priority.workspace = true
 tracing.workspace = true
 thiserror.workspace = true
@@ -30,7 +31,6 @@ thiserror.workspace = true
 # feature `rayon`
 rayon = { workspace = true, optional = true }
 crossbeam-utils = { workspace = true, optional = true }
-parking_lot = { workspace = true, optional = true }
 pin-project = { workspace = true, optional = true }
 
 [target.'cfg(target_os = "linux")'.dependencies]
@@ -40,5 +40,5 @@ libc.workspace = true
 tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread", "time", "macros"] }
 
 [features]
-rayon = ["dep:rayon", "dep:crossbeam-utils", "dep:parking_lot", "pin-project"]
+rayon = ["dep:rayon", "dep:crossbeam-utils", "pin-project"]
 test-utils = []
diff --git a/crates/tasks/src/lazy.rs b/crates/tasks/src/lazy.rs
index 22debe02c27..dcd1e4f7bce 100644
--- a/crates/tasks/src/lazy.rs
+++ b/crates/tasks/src/lazy.rs
@@ -1,5 +1,6 @@
 //! A lazily-resolved handle to a value computed on a background thread.
 
+use parking_lot::Mutex;
 use std::sync::{Arc, OnceLock};
 use tokio::sync::oneshot;
 
@@ -19,7 +20,7 @@ pub struct LazyHandle<T> {
 
 struct LazyHandleInner<T> {
     /// Pending receiver, taken on first access.
-    rx: std::sync::Mutex<Option<oneshot::Receiver<T>>>,
+    rx: Mutex<Option<oneshot::Receiver<T>>>,
     /// Cached result after the first successful receive.
     value: OnceLock<T>,
 }
@@ -28,17 +29,13 @@ impl<T: Send + 'static> LazyHandle<T> {
     /// Creates a new handle from a background task receiver.
     pub(crate) fn new(rx: oneshot::Receiver<T>) -> Self {
         Self {
-            inner: Arc::new(LazyHandleInner {
-                rx: std::sync::Mutex::new(Some(rx)),
-                value: OnceLock::new(),
-            }),
+            inner: Arc::new(LazyHandleInner { rx: Mutex::new(Some(rx)), value: OnceLock::new() }),
         }
     }
 
     /// Creates a handle that is already resolved with the given value.
     pub fn ready(value: T) -> Self {
-        let inner =
-            LazyHandleInner { rx: std::sync::Mutex::new(None), value: OnceLock::from(value) };
+        let inner = LazyHandleInner { rx: Mutex::new(None), value: OnceLock::from(value) };
         Self { inner: Arc::new(inner) }
     }
 
@@ -56,7 +53,6 @@ impl<T: Send + 'static> LazyHandle<T> {
                 .inner
                 .rx
                 .lock()
-                .expect("lock poisoned")
                 .take()
                 .expect("LazyHandle receiver already taken without value being set");
             rx.blocking_recv().expect("LazyHandle task dropped without producing a value")
diff --git a/crates/tasks/src/runtime.rs b/crates/tasks/src/runtime.rs
index 2e7c6684b64..52af910bda5 100644
--- a/crates/tasks/src/runtime.rs
+++ b/crates/tasks/src/runtime.rs
@@ -23,6 +23,7 @@ use std::{
         atomic::{AtomicUsize, Ordering},
         Arc, Mutex,
     },
+    thread,
     time::{Duration, Instant},
 };
 use tokio::{runtime::Handle, sync::mpsc::UnboundedSender, task::JoinHandle};
@@ -40,6 +41,10 @@ pub const DEFAULT_RESERVED_CPU_CORES: usize = 2;
 /// Default number of threads for the storage I/O pool.
 pub const DEFAULT_STORAGE_POOL_THREADS: usize = 16;
 
+/// Default number of threads for the state trie overlay worker pool.
+#[cfg(feature = "rayon")]
+pub const DEFAULT_STATE_TRIE_OVERLAY_WORKER_THREADS: usize = 4;
+
 /// Default maximum number of concurrent blocking tasks (for RPC tracing guard).
 pub const DEFAULT_MAX_BLOCKING_TASKS: usize = 512;
 
@@ -114,6 +119,9 @@ pub struct RayonConfig {
     /// Number of threads for the BAL streaming pool (BAL hashed state streaming).
     /// If `None`, derived from available parallelism.
     pub bal_streaming_threads: Option<usize>,
+    /// Number of threads for the state trie overlay worker pool.
+    /// If `None`, uses [`DEFAULT_STATE_TRIE_OVERLAY_WORKER_THREADS`].
+    pub state_trie_overlay_worker_threads: Option<usize>,
 }
 
 #[cfg(feature = "rayon")]
@@ -129,6 +137,7 @@ impl Default for RayonConfig {
             proof_account_worker_threads: None,
             prewarming_threads: None,
             bal_streaming_threads: None,
+            state_trie_overlay_worker_threads: None,
         }
     }
 }
@@ -189,6 +198,15 @@ impl RayonConfig {
         self
     }
 
+    /// Set the number of threads for the state trie overlay worker pool.
+    pub const fn with_state_trie_overlay_worker_threads(
+        mut self,
+        state_trie_overlay_worker_threads: usize,
+    ) -> Self {
+        self.state_trie_overlay_worker_threads = Some(state_trie_overlay_worker_threads);
+        self
+    }
+
     /// Compute the default number of threads based on available parallelism.
     fn default_thread_count(&self) -> usize {
         // TODO: reserved_cpu_cores is currently ignored because subtracting from thread pool
@@ -274,6 +292,9 @@ struct RuntimeInner {
     /// BAL streaming pool (BAL hashed state streaming).
     #[cfg(feature = "rayon")]
     bal_streaming_pool: WorkerPool,
+    /// State trie overlay worker pool.
+    #[cfg(feature = "rayon")]
+    state_trie_overlay_worker_pool: Arc<WorkerPool>,
     /// Named single-thread worker map. Each unique name gets a dedicated OS thread
     /// that is reused across all tasks submitted under that name.
     worker_map: WorkerMap,
@@ -364,6 +385,12 @@ impl Runtime {
     pub fn bal_streaming_pool(&self) -> &WorkerPool {
         &self.0.bal_streaming_pool
     }
+
+    /// Get the state trie overlay worker pool.
+    #[cfg(feature = "rayon")]
+    pub fn state_trie_overlay_worker_pool(&self) -> Arc<WorkerPool> {
+        Arc::clone(&self.0.state_trie_overlay_worker_pool)
+    }
 }
 
 // ── Test helpers ──────────────────────────────────────────────────────
@@ -399,6 +426,7 @@ impl Runtime {
                 proof_account_worker_threads: Some(2),
                 prewarming_threads: Some(2),
                 bal_streaming_threads: Some(2),
+                state_trie_overlay_worker_threads: Some(2),
             },
         }
     }
@@ -522,6 +550,50 @@ impl Runtime {
         crate::LazyHandle::new(self.0.worker_map.spawn_on(name, func))
     }
 
+    /// Attempts to spawn a blocking closure on a dedicated, named OS thread.
+    ///
+    /// Returns `None` if the named worker already has a task running or queued, allowing the caller
+    /// to fall back to another executor instead of serializing behind the named worker.
+    pub fn try_spawn_blocking_named<F, R>(
+        &self,
+        name: &'static str,
+        func: F,
+    ) -> Option<crate::LazyHandle<R>>
+    where
+        F: FnOnce() -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        self.0.worker_map.try_spawn_on(name, func).map(crate::LazyHandle::new)
+    }
+
+    /// Spawns a blocking closure on a named OS thread if it is idle, otherwise falls back to
+    /// tokio's unnamed blocking thread pool.
+    ///
+    /// Returns `true` if the closure was spawned on the named thread.
+    pub fn spawn_blocking_named_or_tokio<F>(&self, name: &'static str, func: F) -> bool
+    where
+        F: FnOnce() + Send + 'static,
+    {
+        let func = Arc::new(parking_lot::Mutex::new(Some(func)));
+        let named_func = func.clone();
+
+        if self
+            .try_spawn_blocking_named(name, move || {
+                if let Some(func) = named_func.lock().take() {
+                    func();
+                }
+            })
+            .is_some()
+        {
+            return true
+        }
+
+        if let Some(func) = func.lock().take() {
+            self.spawn_blocking(func);
+        }
+        false
+    }
+
     /// Spawns the task onto the runtime.
     /// The given future resolves as soon as the [Shutdown] signal is received.
     ///
@@ -593,6 +665,50 @@ impl Runtime {
         self.spawn_critical_as(name, fut, TaskKind::Blocking)
     }
 
+    /// This spawns a critical task onto a dedicated named OS thread.
+    /// The given future resolves as soon as the [`Shutdown`] signal is received.
+    ///
+    /// If this task panics, the [`TaskManager`] is notified.
+    pub fn spawn_critical_os_thread<F>(
+        &self,
+        thread_name: &'static str,
+        task_name: &'static str,
+        fut: F,
+    ) -> thread::JoinHandle<()>
+    where
+        F: Future<Output = ()> + Send + 'static,
+    {
+        self.0.metrics.inc_critical_tasks();
+        let handle = self.0.handle.clone();
+        let panicked_tasks_tx = self.0.task_events_tx.clone();
+        let on_shutdown = self.0.on_shutdown.clone();
+
+        let task = std::panic::AssertUnwindSafe(fut)
+            .catch_unwind()
+            .map_err(move |error| {
+                let task_error = PanickedTaskError::new(task_name, error);
+                error!("{task_error}");
+                let _ = panicked_tasks_tx.send(TaskEvent::Panic(task_error));
+            })
+            .in_current_span();
+
+        let finished_critical_tasks_total_metrics =
+            self.0.metrics.finished_critical_tasks_total.clone();
+        let task = async move {
+            let _inc_counter_on_drop = IncCounterOnDrop::new(finished_critical_tasks_total_metrics);
+            let task = pin!(task);
+            let _ = select(on_shutdown, task).await;
+        };
+
+        thread::Builder::new()
+            .name(thread_name.to_string())
+            .spawn(move || {
+                let _guard = handle.enter();
+                handle.block_on(task);
+            })
+            .unwrap_or_else(|e| panic!("failed to spawn critical OS thread {thread_name:?}: {e}"))
+    }
+
     /// This spawns a critical task onto the runtime.
     ///
     /// If this task panics, the [`TaskManager`] is notified.
@@ -778,6 +894,7 @@ impl RuntimeBuilder {
             proof_account_worker_pool,
             prewarming_pool,
             bal_streaming_pool,
+            state_trie_overlay_worker_pool,
         ) = {
             let default_threads = config.rayon.default_thread_count();
             let rpc_threads = config.rayon.rpc_threads.unwrap_or(default_threads);
@@ -822,6 +939,13 @@ impl RuntimeBuilder {
                 config.rayon.bal_streaming_threads.unwrap_or(default_threads);
             let bal_streaming_pool = WorkerPool::new(bal_streaming_threads, "bal-stream");
 
+            let state_trie_overlay_worker_threads = config
+                .rayon
+                .state_trie_overlay_worker_threads
+                .unwrap_or(DEFAULT_STATE_TRIE_OVERLAY_WORKER_THREADS);
+            let state_trie_overlay_worker_pool =
+                Arc::new(WorkerPool::new(state_trie_overlay_worker_threads, "state-ovly"));
+
             debug!(
                 default_threads,
                 rpc_threads,
@@ -830,6 +954,7 @@ impl RuntimeBuilder {
                 proof_account_worker_threads,
                 prewarming_threads,
                 bal_streaming_threads,
+                state_trie_overlay_worker_threads,
                 max_blocking_tasks = config.rayon.max_blocking_tasks,
                 "Configured lazy rayon worker pools"
             );
@@ -843,6 +968,7 @@ impl RuntimeBuilder {
                 proof_account_worker_pool,
                 prewarming_pool,
                 bal_streaming_pool,
+                state_trie_overlay_worker_pool,
             )
         };
 
@@ -877,6 +1003,8 @@ impl RuntimeBuilder {
             prewarming_pool,
             #[cfg(feature = "rayon")]
             bal_streaming_pool,
+            #[cfg(feature = "rayon")]
+            state_trie_overlay_worker_pool,
             worker_map: WorkerMap::new(),
             task_manager_handle: Mutex::new(Some(task_manager_handle)),
         };
@@ -920,6 +1048,43 @@ mod tests {
         let _ = runtime.handle();
     }
 
+    #[test]
+    fn critical_os_thread_uses_requested_name() {
+        let runtime = Runtime::test();
+        let (tx, rx) = std::sync::mpsc::channel();
+
+        let handle = runtime.spawn_critical_os_thread(
+            "critical-os-test",
+            "critical os thread test",
+            async move {
+                let name = thread::current().name().unwrap().to_string();
+                tx.send(name).unwrap();
+            },
+        );
+
+        let name = rx.recv_timeout(Duration::from_secs(5)).unwrap();
+        assert_eq!(name, "critical-os-test");
+        handle.join().unwrap();
+    }
+
+    #[test]
+    fn critical_os_thread_panic_is_reported() {
+        let runtime = Runtime::test();
+        let manager_handle = runtime.take_task_manager_handle().unwrap();
+
+        let handle = runtime.spawn_critical_os_thread(
+            "critical-os-panic",
+            "critical os thread panic test",
+            async { panic!("critical os thread panic") },
+        );
+
+        let err =
+            runtime.handle().block_on(async move { manager_handle.await.unwrap().unwrap_err() });
+        assert_eq!(err.task_name, "critical os thread panic test");
+        assert_eq!(err.error, Some("critical os thread panic".to_string()));
+        handle.join().unwrap();
+    }
+
     #[cfg(feature = "rayon")]
     #[test]
     fn test_worker_pools_are_lazy() {
@@ -928,6 +1093,7 @@ mod tests {
         // Worker pools are lazy — not initialized until first access.
         assert!(!runtime.0.bal_streaming_pool.is_initialized());
         assert!(!runtime.0.proof_storage_worker_pool.is_initialized());
+        assert!(!runtime.0.state_trie_overlay_worker_pool.is_initialized());
 
         // Accessing them triggers initialization and returns the configured thread count.
         assert_eq!(runtime.bal_streaming_pool().current_num_threads(), 2);
@@ -936,5 +1102,6 @@ mod tests {
         assert_eq!(runtime.proof_storage_worker_pool().current_num_threads(), 2);
         assert_eq!(runtime.proof_account_worker_pool().current_num_threads(), 2);
         assert_eq!(runtime.prewarming_pool().current_num_threads(), 2);
+        assert_eq!(runtime.state_trie_overlay_worker_pool().current_num_threads(), 2);
     }
 }
diff --git a/crates/tasks/src/worker_map.rs b/crates/tasks/src/worker_map.rs
index 60816f93282..a8bd966b267 100644
--- a/crates/tasks/src/worker_map.rs
+++ b/crates/tasks/src/worker_map.rs
@@ -5,7 +5,14 @@
 //! named task, like a 1-thread thread pool keyed by name.
 
 use dashmap::DashMap;
-use std::{panic::AssertUnwindSafe, thread};
+use std::{
+    panic::AssertUnwindSafe,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+    thread,
+};
 use tokio::sync::{mpsc, oneshot};
 
 type BoxedTask = Box<dyn FnOnce() + Send + 'static>;
@@ -14,6 +21,8 @@ type BoxedTask = Box<dyn FnOnce() + Send + 'static>;
 struct WorkerThread {
     /// Sender to submit work to this worker's thread.
     tx: mpsc::UnboundedSender<BoxedTask>,
+    /// Number of tasks currently running or queued on this worker.
+    pending: Arc<AtomicUsize>,
     /// The OS thread handle. Taken during shutdown to join.
     handle: Option<thread::JoinHandle<()>>,
 }
@@ -31,7 +40,63 @@ impl WorkerThread {
             })
             .unwrap_or_else(|e| panic!("failed to spawn worker thread {name:?}: {e}"));
 
-        Self { tx, handle: Some(handle) }
+        Self { tx, pending: Arc::new(AtomicUsize::new(0)), handle: Some(handle) }
+    }
+
+    /// Spawns a closure on this worker.
+    fn spawn<F, R>(&self, f: F) -> oneshot::Receiver<R>
+    where
+        F: FnOnce() -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        self.pending.fetch_add(1, Ordering::AcqRel);
+
+        let (result_tx, result_rx) = oneshot::channel();
+        let pending = self.pending.clone();
+
+        let task: BoxedTask = Box::new(move || {
+            let _decrement_pending = DecrementPendingOnDrop(pending);
+            let _ = result_tx.send(f());
+        });
+
+        if self.tx.send(task).is_err() {
+            self.pending.fetch_sub(1, Ordering::AcqRel);
+        }
+
+        result_rx
+    }
+
+    /// Attempts to spawn a closure if this worker has no task running or queued.
+    fn try_spawn<F, R>(&self, f: F) -> Option<oneshot::Receiver<R>>
+    where
+        F: FnOnce() -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        self.pending.compare_exchange(0, 1, Ordering::AcqRel, Ordering::Acquire).ok()?;
+
+        let (result_tx, result_rx) = oneshot::channel();
+        let pending = self.pending.clone();
+
+        let task: BoxedTask = Box::new(move || {
+            let _decrement_pending = DecrementPendingOnDrop(pending);
+            let _ = result_tx.send(f());
+        });
+
+        if self.tx.send(task).is_err() {
+            self.pending.fetch_sub(1, Ordering::AcqRel);
+            return None
+        }
+
+        Some(result_rx)
+    }
+}
+
+/// Decrements a worker's pending task count when a task finishes, including after panic.
+struct DecrementPendingOnDrop(Arc<AtomicUsize>);
+
+impl Drop for DecrementPendingOnDrop {
+    fn drop(&mut self) {
+        self.0.fetch_sub(1, Ordering::AcqRel);
     }
 }
 
@@ -65,16 +130,24 @@ impl WorkerMap {
         F: FnOnce() -> R + Send + 'static,
         R: Send + 'static,
     {
-        let (result_tx, result_rx) = oneshot::channel();
-
-        let task: BoxedTask = Box::new(move || {
-            let _ = result_tx.send(f());
-        });
-
         let worker = self.workers.entry(name).or_insert_with(|| WorkerThread::new(name));
-        let _ = worker.tx.send(task);
+        worker.spawn(f)
+    }
 
-        result_rx
+    /// Attempts to spawn a closure on the dedicated worker thread for the given name.
+    ///
+    /// Returns `None` if the named worker already has a task running or queued.
+    pub(crate) fn try_spawn_on<F, R>(
+        &self,
+        name: &'static str,
+        f: F,
+    ) -> Option<oneshot::Receiver<R>>
+    where
+        F: FnOnce() -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        let worker = self.workers.entry(name).or_insert_with(|| WorkerThread::new(name));
+        worker.try_spawn(f)
     }
 }
 
@@ -163,4 +236,25 @@ mod tests {
             .unwrap();
         assert_eq!(name, "custom-worker");
     }
+
+    #[tokio::test]
+    async fn worker_map_try_spawn_busy() {
+        let map = WorkerMap::new();
+        let (release_tx, release_rx) = std::sync::mpsc::channel();
+
+        let first = map.try_spawn_on("busy-worker", move || {
+            release_rx.recv().unwrap();
+            1
+        });
+        assert!(first.is_some());
+
+        let second = map.try_spawn_on("busy-worker", || 2);
+        assert!(second.is_none(), "busy worker should reject queued work");
+
+        release_tx.send(()).unwrap();
+        assert_eq!(first.unwrap().await.unwrap(), 1);
+
+        let third = map.try_spawn_on("busy-worker", || 3).expect("worker should be idle");
+        assert_eq!(third.await.unwrap(), 3);
+    }
 }
diff --git a/crates/tracing-otlp/Cargo.toml b/crates/tracing-otlp/Cargo.toml
index 9a51ffd575c..1176e1507b0 100644
--- a/crates/tracing-otlp/Cargo.toml
+++ b/crates/tracing-otlp/Cargo.toml
@@ -20,6 +20,7 @@ tracing-subscriber.workspace = true
 tracing.workspace = true
 
 # misc
+base64 = "0.22"
 clap = { workspace = true, features = ["derive"] }
 eyre.workspace = true
 url.workspace = true
diff --git a/crates/tracing-otlp/src/lib.rs b/crates/tracing-otlp/src/lib.rs
index bd0549b4a34..9451129e183 100644
--- a/crates/tracing-otlp/src/lib.rs
+++ b/crates/tracing-otlp/src/lib.rs
@@ -23,10 +23,14 @@ use tracing_opentelemetry::OpenTelemetryLayer;
 use tracing_subscriber::registry::LookupSpan;
 use url::Url;
 
+use base64::{prelude::BASE64_STANDARD, Engine};
+
 // Otlp http endpoint is expected to end with this path.
 // See also <https://opentelemetry.io/docs/languages/sdk-configuration/otlp-exporter/#otel_exporter_otlp_traces_endpoint>.
 const HTTP_TRACE_ENDPOINT: &str = "/v1/traces";
 const HTTP_LOGS_ENDPOINT: &str = "/v1/logs";
+const OTEL_EXPORTER_OTLP_TRACES_HEADERS: &str = "OTEL_EXPORTER_OTLP_TRACES_HEADERS";
+const OTEL_EXPORTER_OTLP_LOGS_HEADERS: &str = "OTEL_EXPORTER_OTLP_LOGS_HEADERS";
 
 /// Creates a tracing [`OpenTelemetryLayer`] that exports spans to an OTLP endpoint.
 ///
@@ -38,7 +42,8 @@ where
 {
     global::set_text_map_propagator(TraceContextPropagator::new());
 
-    let resource = build_resource(otlp_config.service_name.clone());
+    let resource =
+        build_resource(otlp_config.service_name.clone(), otlp_config.service_version.as_deref());
 
     let span_builder = SpanExporter::builder();
 
@@ -85,7 +90,8 @@ pub fn log_layer(
     use opentelemetry_otlp::LogExporter;
     use opentelemetry_sdk::logs::SdkLoggerProvider;
 
-    let resource = build_resource(otlp_config.service_name.clone());
+    let resource =
+        build_resource(otlp_config.service_name.clone(), otlp_config.service_version.as_deref());
 
     let log_builder = LogExporter::builder();
 
@@ -111,6 +117,8 @@ pub fn log_layer(
 pub struct OtlpConfig {
     /// Service name for trace identification
     service_name: String,
+    /// Optional service version override. Falls back to `CARGO_PKG_VERSION` if `None`.
+    service_version: Option<String>,
     /// Otlp endpoint URL
     endpoint: Url,
     /// Transport protocol, HTTP or gRPC
@@ -135,7 +143,20 @@ impl OtlpConfig {
             );
         }
 
-        Ok(Self { service_name: service_name.into(), endpoint, protocol, sample_ratio })
+        set_otlp_auth_header_from_endpoint(&endpoint, OTEL_EXPORTER_OTLP_TRACES_HEADERS)?;
+        Ok(Self {
+            service_name: service_name.into(),
+            service_version: None,
+            endpoint: endpoint_without_credentials(endpoint),
+            protocol,
+            sample_ratio,
+        })
+    }
+
+    /// Sets the service version for OTLP resource identification.
+    pub fn with_service_version(mut self, version: impl Into<String>) -> Self {
+        self.service_version = Some(version.into());
+        self
     }
 
     /// Returns the service name.
@@ -164,6 +185,8 @@ impl OtlpConfig {
 pub struct OtlpLogsConfig {
     /// Service name for log identification
     service_name: String,
+    /// Optional service version override. Falls back to `CARGO_PKG_VERSION` if `None`.
+    service_version: Option<String>,
     /// Otlp endpoint URL
     endpoint: Url,
     /// Transport protocol, HTTP or gRPC
@@ -177,7 +200,19 @@ impl OtlpLogsConfig {
         endpoint: Url,
         protocol: OtlpProtocol,
     ) -> eyre::Result<Self> {
-        Ok(Self { service_name: service_name.into(), endpoint, protocol })
+        set_otlp_auth_header_from_endpoint(&endpoint, OTEL_EXPORTER_OTLP_LOGS_HEADERS)?;
+        Ok(Self {
+            service_name: service_name.into(),
+            service_version: None,
+            endpoint: endpoint_without_credentials(endpoint),
+            protocol,
+        })
+    }
+
+    /// Sets the service version for OTLP resource identification.
+    pub fn with_service_version(mut self, version: impl Into<String>) -> Self {
+        self.service_version = Some(version.into());
+        self
     }
 
     /// Returns the service name.
@@ -197,13 +232,63 @@ impl OtlpLogsConfig {
 }
 
 // Builds OTLP resource with service information.
-fn build_resource(service_name: impl Into<Value>) -> Resource {
+fn build_resource(service_name: impl Into<Value>, service_version: Option<&str>) -> Resource {
+    let version = service_version.unwrap_or(env!("CARGO_PKG_VERSION"));
     Resource::builder()
         .with_service_name(service_name)
-        .with_schema_url([KeyValue::new(SERVICE_VERSION, env!("CARGO_PKG_VERSION"))], SCHEMA_URL)
+        .with_schema_url([KeyValue::new(SERVICE_VERSION, version.to_string())], SCHEMA_URL)
         .build()
 }
 
+/// Returns an OTLP endpoint URL with username and password removed.
+fn endpoint_without_credentials(mut endpoint: Url) -> Url {
+    if !endpoint.username().is_empty() {
+        endpoint.set_username("").ok();
+    }
+    if endpoint.password().is_some() {
+        endpoint.set_password(None).ok();
+    }
+    endpoint
+}
+
+/// Builds an OTLP `Authorization` header from endpoint `username:password` credentials.
+fn otlp_auth_header_from_endpoint(endpoint: &Url) -> eyre::Result<Option<String>> {
+    let username = endpoint.username();
+    if username.is_empty() && endpoint.password().is_none() {
+        return Ok(None);
+    }
+
+    let Some(password) = endpoint.password() else {
+        eyre::bail!("OTLP endpoint credentials must include both username and password");
+    };
+    if username.is_empty() {
+        eyre::bail!("OTLP endpoint credentials must include both username and password");
+    }
+
+    let credentials = format!("{username}:{password}");
+    let encoded = BASE64_STANDARD.encode(credentials.as_bytes());
+    Ok(Some(format!("Authorization=Basic {encoded}")))
+}
+
+/// Sets the OTLP signal-specific header env var from endpoint credentials if it is unset.
+fn set_otlp_auth_header_from_endpoint(endpoint: &Url, header_env: &str) -> eyre::Result<()> {
+    if std::env::var_os(header_env).is_some() {
+        return Ok(());
+    }
+
+    let Some(auth_header) = otlp_auth_header_from_endpoint(endpoint)? else {
+        return Ok(());
+    };
+
+    // SAFETY: OTLP exporters are initialized during process startup before exporter worker threads
+    // are spawned.
+    unsafe {
+        std::env::set_var(header_env, auth_header);
+    }
+
+    Ok(())
+}
+
 /// Builds the appropriate sampler based on the sample ratio.
 fn build_sampler(sample_ratio: Option<f64>) -> eyre::Result<Sampler> {
     match sample_ratio {
@@ -262,3 +347,74 @@ impl OtlpProtocol {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn strips_credentials_from_trace_endpoint_and_preserves_auth_header() {
+        let config = OtlpConfig::new(
+            "reth",
+            "https://user:pass@example.com/v1/traces".parse().unwrap(),
+            OtlpProtocol::Http,
+            None,
+        )
+        .unwrap();
+
+        assert_eq!(config.endpoint.as_str(), "https://example.com/v1/traces");
+        assert_eq!(
+            otlp_auth_header_from_endpoint(
+                &"https://user:pass@example.com/v1/traces".parse().unwrap()
+            )
+            .unwrap()
+            .as_deref(),
+            Some("Authorization=Basic dXNlcjpwYXNz")
+        );
+    }
+
+    #[test]
+    fn strips_credentials_from_logs_endpoint_and_preserves_auth_header() {
+        let config = OtlpLogsConfig::new(
+            "reth",
+            "https://logs:secret@example.com/v1/logs".parse().unwrap(),
+            OtlpProtocol::Http,
+        )
+        .unwrap();
+
+        assert_eq!(config.endpoint.as_str(), "https://example.com/v1/logs");
+        assert_eq!(
+            otlp_auth_header_from_endpoint(
+                &"https://logs:secret@example.com/v1/logs".parse().unwrap()
+            )
+            .unwrap()
+            .as_deref(),
+            Some("Authorization=Basic bG9nczpzZWNyZXQ=")
+        );
+    }
+
+    #[test]
+    fn leaves_endpoint_without_credentials_unchanged() {
+        let config = OtlpConfig::new(
+            "reth",
+            "https://example.com/v1/traces".parse().unwrap(),
+            OtlpProtocol::Http,
+            None,
+        )
+        .unwrap();
+
+        assert_eq!(config.endpoint.as_str(), "https://example.com/v1/traces");
+        assert_eq!(otlp_auth_header_from_endpoint(config.endpoint()).unwrap(), None);
+    }
+
+    #[test]
+    fn rejects_partial_credentials() {
+        assert!(OtlpConfig::new(
+            "reth",
+            "https://user@example.com/v1/traces".parse().unwrap(),
+            OtlpProtocol::Http,
+            None,
+        )
+        .is_err());
+    }
+}
diff --git a/crates/tracing/Cargo.toml b/crates/tracing/Cargo.toml
index 58c18ff7ed4..ca141c22cc3 100644
--- a/crates/tracing/Cargo.toml
+++ b/crates/tracing/Cargo.toml
@@ -17,21 +17,35 @@ reth-tracing-otlp = { workspace = true, optional = true }
 
 # obs
 tracing.workspace = true
-tracing-subscriber = { workspace = true, features = ["env-filter", "fmt", "ansi", "json"] }
-tracing-appender.workspace = true
-tracing-journald.workspace = true
-tracing-logfmt.workspace = true
-tracing-samply.workspace = true
+tracing-subscriber = { workspace = true, features = ["env-filter", "fmt", "ansi", "json"], optional = true }
+tracing-appender = { workspace = true, optional = true }
+tracing-chrome = { workspace = true, optional = true }
+tracing-journald = { workspace = true, optional = true }
+tracing-logfmt = { workspace = true, optional = true }
+tracing-samply = { workspace = true, optional = true }
 tracing-tracy = { workspace = true, optional = true }
 tracy-client = { workspace = true, optional = true }
 
 # misc
-clap = { workspace = true, features = ["derive"] }
-eyre.workspace = true
-rolling-file.workspace = true
+clap = { workspace = true, features = ["derive"], optional = true }
+eyre = { workspace = true, optional = true }
+rolling-file = { workspace = true, optional = true }
 
 [features]
-default = ["otlp"]
+default = ["std", "otlp"]
+std = [
+    "tracing-subscriber",
+    "tracing-appender",
+    "tracing-chrome",
+    "tracing-journald",
+    "tracing-logfmt",
+    "tracing-samply",
+    "clap",
+    "eyre",
+    "rolling-file",
+    "tracing/std",
+    "tracing-subscriber?/std",
+]
 otlp = ["reth-tracing-otlp"]
 otlp-logs = ["reth-tracing-otlp/otlp-logs"]
 tracy = ["tracing-tracy", "tracy-client"]
diff --git a/crates/tracing/src/layers.rs b/crates/tracing/src/layers.rs
index b4bc3a3042a..301d7224cc0 100644
--- a/crates/tracing/src/layers.rs
+++ b/crates/tracing/src/layers.rs
@@ -6,6 +6,7 @@ use reth_tracing_otlp::{span_layer, OtlpConfig};
 use rolling_file::{RollingConditionBasic, RollingFileAppender};
 use std::{
     fmt,
+    fs::File,
     path::{Path, PathBuf},
 };
 use tracing_appender::non_blocking::WorkerGuard;
@@ -17,6 +18,32 @@ use tracing_subscriber::{filter::Directive, reload, EnvFilter, Layer, Registry};
 ///  belongs to.
 pub type FileWorkerGuard = tracing_appender::non_blocking::WorkerGuard;
 
+/// Guards for tracing layers that must stay alive until shutdown.
+#[derive(Default)]
+pub struct TracingGuards {
+    _file: Option<FileWorkerGuard>,
+    _chrome: Option<tracing_chrome::FlushGuard>,
+}
+
+impl fmt::Debug for TracingGuards {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TracingGuards")
+            .field("file", &self._file.is_some())
+            .field("chrome", &self._chrome.is_some())
+            .finish()
+    }
+}
+
+impl TracingGuards {
+    /// Creates tracing guards from active layer guards.
+    pub const fn new(
+        file: Option<FileWorkerGuard>,
+        chrome: Option<tracing_chrome::FlushGuard>,
+    ) -> Self {
+        Self { _file: file, _chrome: chrome }
+    }
+}
+
 ///  A boxed tracing [Layer].
 pub(crate) type BoxedLayer<S> = Box<dyn Layer<S> + Send + Sync>;
 
@@ -171,6 +198,25 @@ impl Layers {
         Ok(())
     }
 
+    pub(crate) fn chrome(
+        &mut self,
+        config: LayerInfo,
+        file: &Path,
+    ) -> eyre::Result<tracing_chrome::FlushGuard> {
+        let writer = File::create(file)
+            .map_err(|err| eyre::eyre!("Failed to create Chrome trace file {file:?}: {err}"))?;
+        let (layer, guard) = tracing_chrome::ChromeLayerBuilder::new()
+            .writer(writer)
+            .include_args(true)
+            .include_locations(false)
+            .build();
+        self.add_layer(layer.with_filter(build_env_filter(
+            Some(config.default_directive.parse()?),
+            &config.filters,
+        )?));
+        Ok(guard)
+    }
+
     #[cfg(feature = "tracy")]
     pub(crate) fn tracy(&mut self, config: LayerInfo) -> eyre::Result<()> {
         // Newtype wrapper around `DefaultFields` so that `FormattedFields<TracyFields>` uses a
diff --git a/crates/tracing/src/lib.rs b/crates/tracing/src/lib.rs
index 22bc829616b..e2b2620340e 100644
--- a/crates/tracing/src/lib.rs
+++ b/crates/tracing/src/lib.rs
@@ -39,58 +39,75 @@
     html_favicon_url = "https://avatars0.githubusercontent.com/u/97369466?s=256",
     issue_tracker_base_url = "https://github.com/paradigmxyz/reth/issues/"
 )]
+#![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(not(test), warn(unused_crate_dependencies))]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
 // Re-export tracing crates
 pub use tracing;
+#[cfg(feature = "std")]
 pub use tracing_appender;
+#[cfg(feature = "std")]
 pub use tracing_subscriber;
 
-#[cfg(feature = "tracy")]
+#[cfg(all(feature = "tracy", feature = "std"))]
 tracy_client::register_demangler!();
 
 // Re-export our types
+#[cfg(feature = "std")]
 pub use formatter::LogFormat;
-pub use layers::{FileInfo, FileWorkerGuard, Layers};
+#[cfg(feature = "std")]
+pub use layers::{FileInfo, FileWorkerGuard, Layers, TracingGuards};
+#[cfg(feature = "std")]
 pub use log_handle::{
     install_log_handle, log_handle_available, set_log_verbosity, set_log_vmodule,
     LogFilterReloadHandle,
 };
+#[cfg(feature = "std")]
 pub use test_tracer::TestTracer;
 
+#[cfg(feature = "std")]
 #[doc(hidden)]
 pub mod __private {
     pub use super::throttle::*;
 }
 
+#[cfg(feature = "std")]
 mod formatter;
+#[cfg(feature = "std")]
 mod layers;
+#[cfg(feature = "std")]
 pub mod log_handle;
+#[cfg(feature = "std")]
 mod test_tracer;
+#[cfg(feature = "std")]
 mod throttle;
 
+#[cfg(feature = "std")]
 use tracing::level_filters::LevelFilter;
-use tracing_appender::non_blocking::WorkerGuard;
+#[cfg(feature = "std")]
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
 ///  Tracer for application logging.
 ///
 ///  Manages the configuration and initialization of logging layers,
 /// including standard output, optional journald, and optional file logging.
+#[cfg(feature = "std")]
 #[derive(Debug, Clone)]
 pub struct RethTracer {
     stdout: LayerInfo,
     journald: Option<String>,
     file: Option<(LayerInfo, FileInfo)>,
     samply: Option<LayerInfo>,
+    chrome: Option<(LayerInfo, std::path::PathBuf)>,
     #[cfg(feature = "tracy")]
     tracy: Option<LayerInfo>,
     /// When true, the stdout filter is wrapped in a reload layer so log levels
-    /// can be changed at runtime via RPC (`debug_verbosity`, `debug_vmodule`).
+    /// can be changed at runtime.
     enable_reload: bool,
 }
 
+#[cfg(feature = "std")]
 impl RethTracer {
     /// Constructs a new `Tracer` with default settings.
     ///
@@ -102,6 +119,7 @@ impl RethTracer {
             journald: None,
             file: None,
             samply: None,
+            chrome: None,
             #[cfg(feature = "tracy")]
             tracy: None,
             enable_reload: false,
@@ -142,6 +160,12 @@ impl RethTracer {
         self
     }
 
+    /// Sets the Chrome trace layer configuration.
+    pub fn with_chrome(mut self, config: LayerInfo, file: std::path::PathBuf) -> Self {
+        self.chrome = Some((config, file));
+        self
+    }
+
     /// Sets the tracy layer configuration.
     #[cfg(feature = "tracy")]
     pub fn with_tracy(mut self, config: LayerInfo) -> Self {
@@ -149,13 +173,14 @@ impl RethTracer {
         self
     }
 
-    /// Enables runtime log filter reloading via RPC (`debug_verbosity`, `debug_vmodule`).
+    /// Enables runtime log filter reloading.
     pub const fn with_reload(mut self, enable: bool) -> Self {
         self.enable_reload = enable;
         self
     }
 }
 
+#[cfg(feature = "std")]
 impl Default for RethTracer {
     fn default() -> Self {
         Self::new()
@@ -166,6 +191,7 @@ impl Default for RethTracer {
 ///
 ///  This struct holds configuration parameters for a tracing layer, including
 ///  the format, filtering directives, optional coloring, and directive.
+#[cfg(feature = "std")]
 #[derive(Debug, Clone)]
 pub struct LayerInfo {
     format: LogFormat,
@@ -174,6 +200,7 @@ pub struct LayerInfo {
     color: Option<String>,
 }
 
+#[cfg(feature = "std")]
 impl LayerInfo {
     ///  Constructs a new `LayerInfo`.
     ///
@@ -195,6 +222,7 @@ impl LayerInfo {
     }
 }
 
+#[cfg(feature = "std")]
 impl Default for LayerInfo {
     ///  Provides default values for `LayerInfo`.
     ///
@@ -216,15 +244,16 @@ impl Default for LayerInfo {
 /// in an application. Implementations of this trait can specify different logging setups,
 /// such as standard output logging, file logging, journald logging, or custom logging
 /// configurations tailored for specific environments (like testing).
+#[cfg(feature = "std")]
 pub trait Tracer: Sized {
     /// Initialize the logging configuration.
     ///
     /// By default, this method creates a new `Layers` instance and delegates to `init_with_layers`.
     ///
     /// # Returns
-    /// An `eyre::Result` which is `Ok` with an optional `WorkerGuard` if a file layer is used,
-    /// or an `Err` in case of an error during initialization.
-    fn init(self) -> eyre::Result<Option<WorkerGuard>> {
+    /// An `eyre::Result` with guards for layers that need to stay alive, or an `Err` in case of an
+    /// error during initialization.
+    fn init(self) -> eyre::Result<TracingGuards> {
         self.init_with_layers(Layers::new())
     }
 
@@ -236,13 +265,14 @@ pub trait Tracer: Sized {
     /// * `layers` - Pre-configured `Layers` instance to use for initialization
     ///
     /// # Returns
-    /// An `eyre::Result` which is `Ok` with an optional `WorkerGuard` if a file layer is used,
-    /// or an `Err` in case of an error during initialization.
-    fn init_with_layers(self, layers: Layers) -> eyre::Result<Option<WorkerGuard>>;
+    /// An `eyre::Result` with guards for layers that need to stay alive, or an `Err` in case of an
+    /// error during initialization.
+    fn init_with_layers(self, layers: Layers) -> eyre::Result<TracingGuards>;
 }
 
+#[cfg(feature = "std")]
 impl Tracer for RethTracer {
-    fn init_with_layers(self, mut layers: Layers) -> eyre::Result<Option<WorkerGuard>> {
+    fn init_with_layers(self, mut layers: Layers) -> eyre::Result<TracingGuards> {
         // Configure stdout layer - reloadable if requested for runtime log level changes
         if let Some(handle) = layers.stdout(
             self.stdout.format,
@@ -273,6 +303,12 @@ impl Tracer for RethTracer {
             layers.samply(config)?;
         }
 
+        let chrome_guard = if let Some((config, file)) = self.chrome {
+            Some(layers.chrome(config, &file)?)
+        } else {
+            None
+        };
+
         #[cfg(feature = "tracy")]
         if let Some(config) = self.tracy {
             layers.tracy(config)?;
@@ -282,7 +318,7 @@ impl Tracer for RethTracer {
         // so it's safe to ignore it
         let _ = tracing_subscriber::registry().with(layers.into_inner()).try_init();
 
-        Ok(file_guard)
+        Ok(TracingGuards::new(file_guard, chrome_guard))
     }
 }
 
@@ -293,6 +329,7 @@ impl Tracer for RethTracer {
 ///  # Note
 ///
 ///  The subscriber will silently fail if it could not be installed.
+#[cfg(feature = "std")]
 pub fn init_test_tracing() {
     let _ = TestTracer::default().init();
 }
diff --git a/crates/tracing/src/test_tracer.rs b/crates/tracing/src/test_tracer.rs
index 2cdf007dc89..fc78f1f346b 100644
--- a/crates/tracing/src/test_tracer.rs
+++ b/crates/tracing/src/test_tracer.rs
@@ -1,7 +1,6 @@
-use tracing_appender::non_blocking::WorkerGuard;
 use tracing_subscriber::EnvFilter;
 
-use crate::{Layers, Tracer};
+use crate::{Layers, Tracer, TracingGuards};
 
 ///  Initializes a tracing subscriber for tests.
 ///
@@ -15,11 +14,11 @@ use crate::{Layers, Tracer};
 pub struct TestTracer;
 
 impl Tracer for TestTracer {
-    fn init_with_layers(self, _layers: Layers) -> eyre::Result<Option<WorkerGuard>> {
+    fn init_with_layers(self, _layers: Layers) -> eyre::Result<TracingGuards> {
         let _ = tracing_subscriber::fmt()
             .with_env_filter(EnvFilter::from_default_env())
             .with_writer(std::io::stderr)
             .try_init();
-        Ok(None)
+        Ok(TracingGuards::default())
     }
 }
diff --git a/crates/transaction-pool/src/batcher.rs b/crates/transaction-pool/src/batcher.rs
index d1f6c1e453a..d34954153bb 100644
--- a/crates/transaction-pool/src/batcher.rs
+++ b/crates/transaction-pool/src/batcher.rs
@@ -80,6 +80,21 @@ where
             return
         }
 
+        // Same-origin batches can skip the per-transaction origins allocation.
+        let mut batch_iter = batch.iter();
+        if let Some(origin) = batch_iter.next().map(|req| req.origin) &&
+            batch_iter.all(|req| req.origin == origin)
+        {
+            let (transactions, response_txs): (Vec<_>, Vec<_>) =
+                batch.into_iter().map(|req| (req.pool_tx, req.response_tx)).unzip();
+
+            let pool_results = pool.add_transactions(origin, transactions).await;
+            for (response_tx, pool_result) in response_txs.into_iter().zip(pool_results) {
+                let _ = response_tx.send(pool_result);
+            }
+            return
+        }
+
         let (transactions, response_txs): (Vec<_>, Vec<_>) =
             batch.into_iter().map(|req| ((req.origin, req.pool_tx), req.response_tx)).unzip();
 
@@ -154,6 +169,36 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn test_process_batch_mixed_origins() {
+        let pool = testing_pool();
+
+        let mut batch_requests = Vec::new();
+        let mut responses = Vec::new();
+
+        for (nonce, origin) in [
+            (0, TransactionOrigin::Local),
+            (1, TransactionOrigin::External),
+            (2, TransactionOrigin::Private),
+        ] {
+            let tx = MockTransaction::legacy().with_nonce(nonce).with_gas_price(100);
+            let (response_tx, response_rx) = tokio::sync::oneshot::channel();
+
+            batch_requests.push(BatchTxRequest::new(origin, tx, response_tx));
+            responses.push(response_rx);
+        }
+
+        BatchTxProcessor::process_batch(&pool, batch_requests).await;
+
+        for response_rx in responses {
+            let result = timeout(Duration::from_millis(5), response_rx)
+                .await
+                .expect("Timeout waiting for response")
+                .expect("Response channel was closed unexpectedly");
+            assert!(result.is_ok());
+        }
+    }
+
     #[tokio::test]
     async fn test_batch_processor() {
         let pool = testing_pool();
diff --git a/crates/transaction-pool/src/blobstore/disk.rs b/crates/transaction-pool/src/blobstore/disk.rs
index 3b6df2af971..ec7b2cd4528 100644
--- a/crates/transaction-pool/src/blobstore/disk.rs
+++ b/crates/transaction-pool/src/blobstore/disk.rs
@@ -3,7 +3,7 @@
 use crate::blobstore::{BlobStore, BlobStoreCleanupStat, BlobStoreError, BlobStoreSize};
 use alloy_eips::{
     eip4844::{BlobAndProofV1, BlobAndProofV2, BlobCellsAndProofsV1},
-    eip7594::{BlobCellMask, BlobTransactionSidecarVariant},
+    eip7594::{BlobCellMask, BlobTransactionSidecarVariant, Cell},
     eip7840::BlobParams,
     merge::EPOCH_SLOTS,
 };
@@ -379,6 +379,25 @@ impl BlobStore for DiskFileBlobStore {
         self.get_by_versioned_hashes_cells_eip7594(versioned_hashes, indices_bitarray)
     }
 
+    fn get_cells(
+        &self,
+        tx: B256,
+        indices_bitarray: B128,
+    ) -> Result<Option<Vec<Cell>>, BlobStoreError> {
+        let Some(sidecar) = self.get(tx)? else {
+            return Ok(None);
+        };
+
+        let Some(sidecar) = sidecar.as_eip7594() else {
+            return Ok(None);
+        };
+
+        sidecar
+            .compute_matching_cells(BlobCellMask::new(indices_bitarray))
+            .map(Some)
+            .map_err(|err| BlobStoreError::Other(Box::new(err)))
+    }
+
     fn data_size_hint(&self) -> Option<usize> {
         Some(self.inner.size_tracker.data_size())
     }
@@ -1048,6 +1067,31 @@ mod tests {
         assert_eq!(cells_and_proofs.proofs, vec![Some(Bytes48::default())]);
     }
 
+    #[test]
+    fn disk_get_cells_can_fallback_to_disk() {
+        let (store, _dir) = tmp_store();
+
+        let tx_hash = TxHash::random();
+        let (sidecar, versioned_hash, _) = eip7594_single_blob_sidecar();
+        store.insert(tx_hash, sidecar).unwrap();
+
+        let indices_bitarray = B128::from((1u128 << 0) | (1u128 << 7));
+        let expected = store
+            .get_by_versioned_hashes_v4(&[versioned_hash], indices_bitarray)
+            .unwrap()
+            .pop()
+            .unwrap()
+            .unwrap()
+            .blob_cells
+            .into_iter()
+            .collect::<Option<Vec<_>>>()
+            .unwrap();
+
+        store.clear_cache();
+
+        assert_eq!(store.get_cells(tx_hash, indices_bitarray).unwrap(), Some(expected));
+    }
+
     #[test]
     fn disk_double_cleanup_no_failure() {
         let (store, _dir) = tmp_store();
diff --git a/crates/transaction-pool/src/blobstore/mem.rs b/crates/transaction-pool/src/blobstore/mem.rs
index dc7672e9859..dfaaec160fd 100644
--- a/crates/transaction-pool/src/blobstore/mem.rs
+++ b/crates/transaction-pool/src/blobstore/mem.rs
@@ -1,7 +1,7 @@
 use crate::blobstore::{BlobStore, BlobStoreCleanupStat, BlobStoreError, BlobStoreSize};
 use alloy_eips::{
     eip4844::{BlobAndProofV1, BlobAndProofV2, BlobCellsAndProofsV1},
-    eip7594::{BlobCellMask, BlobTransactionSidecarVariant},
+    eip7594::{BlobCellMask, BlobTransactionSidecarVariant, Cell},
 };
 use alloy_primitives::{map::B256Map, B128, B256};
 use parking_lot::RwLock;
@@ -25,7 +25,7 @@ impl InMemoryBlobStore {
     ) -> Vec<Option<BlobAndProofV2>> {
         let mut result = vec![None; versioned_hashes.len()];
         let mut missing_count = result.len();
-        for (_tx_hash, blob_sidecar) in self.inner.store.read().iter() {
+        for blob_sidecar in self.inner.store.read().values() {
             if let Some(blob_sidecar) = blob_sidecar.as_eip7594() {
                 for (hash_idx, match_result) in
                     blob_sidecar.match_versioned_hashes(versioned_hashes)
@@ -181,7 +181,7 @@ impl BlobStore for InMemoryBlobStore {
         versioned_hashes: &[B256],
     ) -> Result<Vec<Option<BlobAndProofV1>>, BlobStoreError> {
         let mut result = vec![None; versioned_hashes.len()];
-        for (_tx_hash, blob_sidecar) in self.inner.store.read().iter() {
+        for blob_sidecar in self.inner.store.read().values() {
             if let Some(blob_sidecar) = blob_sidecar.as_eip4844() {
                 for (hash_idx, match_result) in
                     blob_sidecar.match_versioned_hashes(versioned_hashes)
@@ -225,6 +225,25 @@ impl BlobStore for InMemoryBlobStore {
         self.get_by_versioned_hashes_cells_eip7594(versioned_hashes, indices_bitarray)
     }
 
+    fn get_cells(
+        &self,
+        tx: B256,
+        indices_bitarray: B128,
+    ) -> Result<Option<Vec<Cell>>, BlobStoreError> {
+        let Some(sidecar) = self.get(tx)? else {
+            return Ok(None);
+        };
+
+        let Some(sidecar) = sidecar.as_eip7594() else {
+            return Ok(None);
+        };
+
+        sidecar
+            .compute_matching_cells(BlobCellMask::new(indices_bitarray))
+            .map(Some)
+            .map_err(|err| BlobStoreError::Other(Box::new(err)))
+    }
+
     fn data_size_hint(&self) -> Option<usize> {
         Some(self.inner.size_tracker.data_size())
     }
@@ -315,4 +334,27 @@ mod tests {
         assert!(cells_and_proofs.blob_cells.iter().all(Option::is_some));
         assert_eq!(cells_and_proofs.proofs, vec![Some(Bytes48::default()); 2]);
     }
+
+    #[test]
+    fn mem_get_cells_returns_requested_cells() {
+        let store = InMemoryBlobStore::default();
+
+        let tx_hash = B256::random();
+        let (sidecar, versioned_hash, _) = eip7594_single_blob_sidecar();
+        store.insert(tx_hash, sidecar).unwrap();
+
+        let indices_bitarray = B128::from((1u128 << 0) | (1u128 << 7));
+        let expected = store
+            .get_by_versioned_hashes_v4(&[versioned_hash], indices_bitarray)
+            .unwrap()
+            .pop()
+            .unwrap()
+            .unwrap()
+            .blob_cells
+            .into_iter()
+            .collect::<Option<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(store.get_cells(tx_hash, indices_bitarray).unwrap(), Some(expected));
+    }
 }
diff --git a/crates/transaction-pool/src/blobstore/mod.rs b/crates/transaction-pool/src/blobstore/mod.rs
index 60dee34558b..4e2d90adde3 100644
--- a/crates/transaction-pool/src/blobstore/mod.rs
+++ b/crates/transaction-pool/src/blobstore/mod.rs
@@ -2,9 +2,9 @@
 
 use alloy_eips::{
     eip4844::{BlobAndProofV1, BlobAndProofV2, BlobCellsAndProofsV1},
-    eip7594::BlobTransactionSidecarVariant,
+    eip7594::{BlobTransactionSidecarVariant, Cell},
 };
-use alloy_primitives::{B128, B256};
+use alloy_primitives::{TxHash, B128, B256};
 pub use converter::BlobSidecarConverter;
 pub use disk::{DiskFileBlobStore, DiskFileBlobStoreConfig, OpenDiskFileBlobStore};
 pub use mem::InMemoryBlobStore;
@@ -120,6 +120,32 @@ pub trait BlobStore: fmt::Debug + Send + Sync + 'static {
         indices_bitarray: B128,
     ) -> Result<Vec<Option<BlobCellsAndProofsV1>>, BlobStoreError>;
 
+    /// Returns all requested cells for all blobs belonging to the transaction.
+    ///
+    /// The `indices_bitarray` is applied independently to every blob in the tx.
+    ///
+    /// Returned cells are flattened in blob order, then cell-index order.
+    ///
+    /// Example:
+    /// If the tx contains blobs `[blob0, blob1]` and the requested indices are
+    /// `[2, 5, 9]`, the returned vector is:
+    ///
+    /// ```text
+    /// [
+    ///   blob0_cell2,
+    ///   blob0_cell5,
+    ///   blob0_cell9,
+    ///   blob1_cell2,
+    ///   blob1_cell5,
+    ///   blob1_cell9,
+    /// ]
+    /// ```
+    fn get_cells(
+        &self,
+        tx_hash: TxHash,
+        indices_bitarray: B128,
+    ) -> Result<Option<Vec<Cell>>, BlobStoreError>;
+
     /// Data size of all transactions in the blob store.
     fn data_size_hint(&self) -> Option<usize>;
 
diff --git a/crates/transaction-pool/src/blobstore/noop.rs b/crates/transaction-pool/src/blobstore/noop.rs
index 571778e5528..1c0de6289ce 100644
--- a/crates/transaction-pool/src/blobstore/noop.rs
+++ b/crates/transaction-pool/src/blobstore/noop.rs
@@ -1,9 +1,9 @@
 use crate::blobstore::{BlobStore, BlobStoreCleanupStat, BlobStoreError};
 use alloy_eips::{
     eip4844::{BlobAndProofV1, BlobAndProofV2, BlobCellsAndProofsV1},
-    eip7594::BlobTransactionSidecarVariant,
+    eip7594::{BlobTransactionSidecarVariant, Cell},
 };
-use alloy_primitives::{B128, B256};
+use alloy_primitives::{TxHash, B128, B256};
 use std::sync::Arc;
 
 /// A blobstore implementation that does nothing
@@ -93,6 +93,15 @@ impl BlobStore for NoopBlobStore {
         Ok(vec![None; versioned_hashes.len()])
     }
 
+    fn get_cells(
+        &self,
+        tx_hash: TxHash,
+        indices_bitarray: B128,
+    ) -> Result<Option<Vec<Cell>>, BlobStoreError> {
+        let _ = (tx_hash, indices_bitarray);
+        Ok(None)
+    }
+
     fn data_size_hint(&self) -> Option<usize> {
         Some(0)
     }
diff --git a/crates/transaction-pool/src/blobstore/tracker.rs b/crates/transaction-pool/src/blobstore/tracker.rs
index f2a93bd6453..fadbbd9e374 100644
--- a/crates/transaction-pool/src/blobstore/tracker.rs
+++ b/crates/transaction-pool/src/blobstore/tracker.rs
@@ -1,7 +1,6 @@
 //! Support for maintaining the blob pool.
 
-use alloy_consensus::Typed2718;
-use alloy_eips::eip2718::Encodable2718;
+use alloy_consensus::{transaction::TxHashRef, Typed2718};
 use alloy_primitives::{BlockNumber, B256};
 use reth_execution_types::ChainBlocks;
 use reth_primitives_traits::{Block, BlockBody, SignedTransaction};
@@ -50,7 +49,7 @@ impl BlobStoreCanonTracker {
                 .transactions()
                 .iter()
                 .filter(|tx| tx.is_eip4844())
-                .map(|tx| tx.trie_hash());
+                .map(|tx| *tx.tx_hash());
             (*num, iter)
         });
         self.add_blocks(blob_txs);
diff --git a/crates/transaction-pool/src/config.rs b/crates/transaction-pool/src/config.rs
index 5afe5613894..0b22ac7970c 100644
--- a/crates/transaction-pool/src/config.rs
+++ b/crates/transaction-pool/src/config.rs
@@ -37,11 +37,11 @@ pub const DEFAULT_MAX_INFLIGHT_DELEGATED_SLOTS: usize = 1;
 /// Configuration options for the Transaction pool.
 #[derive(Debug, Clone)]
 pub struct PoolConfig {
-    /// Max number of transaction in the pending sub-pool
+    /// Max number of transactions in the pending sub-pool
     pub pending_limit: SubPoolLimit,
-    /// Max number of transaction in the basefee sub-pool
+    /// Max number of transactions in the basefee sub-pool
     pub basefee_limit: SubPoolLimit,
-    /// Max number of transaction in the queued sub-pool
+    /// Max number of transactions in the queued sub-pool
     pub queued_limit: SubPoolLimit,
     /// Max number of transactions in the blob sub-pool
     pub blob_limit: SubPoolLimit,
diff --git a/crates/transaction-pool/src/lib.rs b/crates/transaction-pool/src/lib.rs
index 3a20090724c..525ebe01554 100644
--- a/crates/transaction-pool/src/lib.rs
+++ b/crates/transaction-pool/src/lib.rs
@@ -470,7 +470,7 @@ where
     V: TransactionValidator,
     <V as TransactionValidator>::Transaction: EthPoolTransaction,
     T: TransactionOrdering<Transaction = <V as TransactionValidator>::Transaction>,
-    S: BlobStore,
+    S: BlobStore + Clone,
 {
     type Transaction = T::Transaction;
 
@@ -682,6 +682,13 @@ where
         self.pool.retain_unknown(announcement)
     }
 
+    fn retain_contains<A>(&self, announcement: &mut A)
+    where
+        A: HandleMempoolData,
+    {
+        self.pool.retain_contains(announcement)
+    }
+
     fn get(&self, tx_hash: &TxHash) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>> {
         self.inner().get(tx_hash)
     }
@@ -816,6 +823,10 @@ where
     ) -> Result<Vec<Option<BlobCellsAndProofsV1>>, BlobStoreError> {
         self.pool.blob_store().get_by_versioned_hashes_v4(versioned_hashes, indices_bitarray)
     }
+
+    fn blob_store(&self) -> Box<dyn BlobStore> {
+        Box::new(self.pool.blob_store().clone())
+    }
 }
 
 impl<V, T, S> TransactionPoolExt for Pool<V, T, S>
@@ -823,7 +834,7 @@ where
     V: TransactionValidator,
     <V as TransactionValidator>::Transaction: EthPoolTransaction,
     T: TransactionOrdering<Transaction = <V as TransactionValidator>::Transaction>,
-    S: BlobStore,
+    S: BlobStore + Clone,
 {
     type Block = V::Block;
 
@@ -854,6 +865,20 @@ where
     }
 }
 
+impl<V, T, S> ValidatingPool for Pool<V, T, S>
+where
+    V: TransactionValidator,
+    <V as TransactionValidator>::Transaction: EthPoolTransaction,
+    T: TransactionOrdering<Transaction = <V as TransactionValidator>::Transaction>,
+    S: BlobStore + Clone,
+{
+    type Validator = V;
+
+    fn validator(&self) -> &Self::Validator {
+        self.inner().validator()
+    }
+}
+
 impl<V, T: TransactionOrdering, S> Clone for Pool<V, T, S> {
     fn clone(&self) -> Self {
         Self { pool: Arc::clone(&self.pool) }
diff --git a/crates/transaction-pool/src/maintain.rs b/crates/transaction-pool/src/maintain.rs
index a0e632181c7..8f9fbe0ebb8 100644
--- a/crates/transaction-pool/src/maintain.rs
+++ b/crates/transaction-pool/src/maintain.rs
@@ -380,7 +380,7 @@ pub async fn maintain_transaction_pool<N, Client, P, St>(
                 changed_accounts.extend(new_changed_accounts.into_iter().map(|entry| entry.0));
 
                 // all transactions mined in the new chain
-                let new_mined_transactions: HashSet<_> = new_blocks.transaction_hashes().collect();
+                let new_mined_transactions = new_blocks.transaction_hashes_set();
 
                 // update the pool then re-inject the pruned transactions
                 // find all transactions that were mined in the old chain but not in the new chain
@@ -416,7 +416,7 @@ pub async fn maintain_transaction_pool<N, Client, P, St>(
                     pending_block_blob_fee,
                     changed_accounts,
                     // all transactions mined in the new chain need to be removed from the pool
-                    mined_transactions: new_blocks.transaction_hashes().collect(),
+                    mined_transactions: new_blocks.transaction_hashes_vec(),
                     update_kind: PoolUpdateKind::Reorg,
                 };
                 pool.on_canonical_state_change(update);
@@ -483,7 +483,7 @@ pub async fn maintain_transaction_pool<N, Client, P, St>(
                     changed_accounts.push(acc);
                 }
 
-                let mined_transactions = blocks.transaction_hashes().collect();
+                let mined_transactions = blocks.transaction_hashes_vec();
 
                 // check if the range of the commit is canonical with the pool's block
                 if first_block.parent_hash() != pool_info.last_seen_block_hash {
diff --git a/crates/transaction-pool/src/noop.rs b/crates/transaction-pool/src/noop.rs
index 6e4b53757ac..6f2c12af89e 100644
--- a/crates/transaction-pool/src/noop.rs
+++ b/crates/transaction-pool/src/noop.rs
@@ -4,7 +4,7 @@
 //! to be generic over it.
 
 use crate::{
-    blobstore::BlobStoreError,
+    blobstore::{BlobStore, BlobStoreError, NoopBlobStore},
     error::{InvalidPoolTransactionError, PoolError},
     pool::TransactionListenerKind,
     traits::{BestTransactionsAttributes, GetPooledTransactionLimit, NewBlobSidecar},
@@ -257,6 +257,12 @@ impl<T: EthPoolTransaction> TransactionPool for NoopTransactionPool<T> {
     {
     }
 
+    fn retain_contains<A>(&self, _announcement: &mut A)
+    where
+        A: HandleMempoolData,
+    {
+    }
+
     fn get(&self, _tx_hash: &TxHash) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>> {
         None
     }
@@ -388,6 +394,10 @@ impl<T: EthPoolTransaction> TransactionPool for NoopTransactionPool<T> {
     ) -> Result<Vec<Option<BlobCellsAndProofsV1>>, BlobStoreError> {
         Ok(vec![None; versioned_hashes.len()])
     }
+
+    fn blob_store(&self) -> Box<dyn BlobStore> {
+        Box::new(NoopBlobStore)
+    }
 }
 
 /// A [`TransactionValidator`] that does nothing.
diff --git a/crates/transaction-pool/src/pool/best.rs b/crates/transaction-pool/src/pool/best.rs
index e04bdc3b79e..6d6b46cdf8e 100644
--- a/crates/transaction-pool/src/pool/best.rs
+++ b/crates/transaction-pool/src/pool/best.rs
@@ -9,8 +9,9 @@ use alloy_primitives::map::AddressSet;
 use core::fmt;
 use imbl::OrdMap;
 use reth_primitives_traits::transaction::error::InvalidTransactionError;
+use rustc_hash::FxHashSet;
 use std::{
-    collections::{BTreeSet, HashSet, VecDeque},
+    collections::{BTreeSet, VecDeque},
     sync::Arc,
 };
 use tokio::sync::broadcast::{error::TryRecvError, Receiver};
@@ -32,7 +33,7 @@ pub(crate) struct BestTransactionsWithFees<T: TransactionOrdering> {
 }
 
 impl<T: TransactionOrdering> crate::traits::BestTransactions for BestTransactionsWithFees<T> {
-    fn mark_invalid(&mut self, tx: &Self::Item, kind: &InvalidPoolTransactionError) {
+    fn mark_invalid(&mut self, tx: &Self::Item, kind: InvalidPoolTransactionError) {
         BestTransactions::mark_invalid(&mut self.best, tx, kind)
     }
 
@@ -68,10 +69,15 @@ impl<T: TransactionOrdering> Iterator for BestTransactionsWithFees<T> {
             crate::traits::BestTransactions::mark_invalid(
                 self,
                 &best,
-                &InvalidPoolTransactionError::Underpriced,
+                InvalidPoolTransactionError::Underpriced,
             );
         }
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let (_, upper) = self.best.size_hint();
+        (0, upper)
+    }
 }
 
 /// An iterator that returns transactions that can be executed on the current state (*best*
@@ -92,7 +98,7 @@ pub struct BestTransactions<T: TransactionOrdering> {
     /// then can be moved from the `all` set to the `independent` set.
     pub(crate) independent: BTreeSet<PendingTransaction<T>>,
     /// There might be the case where a yielded transactions is invalid, this will track it.
-    pub(crate) invalid: HashSet<SenderId>,
+    pub(crate) invalid: FxHashSet<SenderId>,
     /// Used to receive any new pending transactions that have been added to the pool after this
     /// iterator was static filtered
     ///
@@ -112,7 +118,7 @@ impl<T: TransactionOrdering> BestTransactions<T> {
     pub(crate) fn mark_invalid(
         &mut self,
         tx: &Arc<ValidPoolTransaction<T::Transaction>>,
-        _kind: &InvalidPoolTransactionError,
+        _kind: InvalidPoolTransactionError,
     ) {
         self.invalid.insert(tx.sender_id());
     }
@@ -221,7 +227,7 @@ impl<T: TransactionOrdering> BestTransactions<T> {
                 // transactions are returned
                 self.mark_invalid(
                     &best.transaction,
-                    &InvalidPoolTransactionError::Eip4844(
+                    InvalidPoolTransactionError::Eip4844(
                         Eip4844PoolTransactionError::NoEip4844Blobs,
                     ),
                 )
@@ -263,7 +269,7 @@ enum IncomingTransaction<T: TransactionOrdering> {
 }
 
 impl<T: TransactionOrdering> crate::traits::BestTransactions for BestTransactions<T> {
-    fn mark_invalid(&mut self, tx: &Self::Item, kind: &InvalidPoolTransactionError) {
+    fn mark_invalid(&mut self, tx: &Self::Item, kind: InvalidPoolTransactionError) {
         Self::mark_invalid(self, tx, kind)
     }
 
@@ -287,6 +293,10 @@ impl<T: TransactionOrdering> Iterator for BestTransactions<T> {
     fn next(&mut self) -> Option<Self::Item> {
         self.next_tx_and_priority().map(|(tx, _)| tx)
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, self.new_transaction_receiver.is_none().then_some(self.all.len()))
+    }
 }
 
 /// A [`BestTransactions`](crate::traits::BestTransactions) implementation that filters the
@@ -321,12 +331,15 @@ where
             }
             self.best.mark_invalid(
                 &best,
-                &InvalidPoolTransactionError::Consensus(
-                    InvalidTransactionError::TxTypeNotSupported,
-                ),
+                InvalidPoolTransactionError::Consensus(InvalidTransactionError::TxTypeNotSupported),
             );
         }
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let (_, upper) = self.best.size_hint();
+        (0, upper)
+    }
 }
 
 impl<I, P> crate::traits::BestTransactions for BestTransactionFilter<I, P>
@@ -334,7 +347,7 @@ where
     I: crate::traits::BestTransactions,
     P: FnMut(&<I as Iterator>::Item) -> bool + Send,
 {
-    fn mark_invalid(&mut self, tx: &Self::Item, kind: &InvalidPoolTransactionError) {
+    fn mark_invalid(&mut self, tx: &Self::Item, kind: InvalidPoolTransactionError) {
         crate::traits::BestTransactions::mark_invalid(&mut self.best, tx, kind)
     }
 
@@ -416,6 +429,16 @@ where
             self.inner.next()
         }
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let buffered = self.buffer.len();
+        let (inner_lower, inner_upper) = self.inner.size_hint();
+
+        (
+            buffered.saturating_add(inner_lower),
+            inner_upper.and_then(|upper| upper.checked_add(buffered)),
+        )
+    }
 }
 
 impl<I, T> crate::traits::BestTransactions for BestTransactionsWithPrioritizedSenders<I>
@@ -423,7 +446,7 @@ where
     I: crate::traits::BestTransactions<Item = Arc<ValidPoolTransaction<T>>>,
     T: PoolTransaction,
 {
-    fn mark_invalid(&mut self, tx: &Self::Item, kind: &InvalidPoolTransactionError) {
+    fn mark_invalid(&mut self, tx: &Self::Item, kind: InvalidPoolTransactionError) {
         self.inner.mark_invalid(tx, kind)
     }
 
@@ -474,6 +497,90 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_best_transactions_size_hint() {
+        let mut pool = PendingPool::new(MockOrdering::default());
+        let mut f = MockTransactionFactory::default();
+
+        for nonce in 0..3 {
+            let tx = MockTransaction::eip1559().rng_hash().with_nonce(nonce);
+            pool.add_transaction(Arc::new(f.validated(tx)), 0);
+        }
+
+        let mut best = pool.best();
+        assert_eq!(best.size_hint(), (0, None));
+
+        best.no_updates();
+        assert_eq!(best.size_hint(), (0, Some(3)));
+
+        assert_eq!(best.next().unwrap().nonce(), 0);
+        assert_eq!(best.size_hint(), (0, Some(2)));
+    }
+
+    #[test]
+    fn test_best_transactions_with_fees_size_hint() {
+        let mut pool = PendingPool::new(MockOrdering::default());
+        let mut f = MockTransactionFactory::default();
+
+        for nonce in 0..3 {
+            let tx = MockTransaction::eip1559().rng_hash().with_nonce(nonce).with_max_fee(100);
+            pool.add_transaction(Arc::new(f.validated(tx)), 0);
+        }
+
+        let mut best = pool.best_with_basefee_and_blobfee(10, 0);
+        best.no_updates();
+
+        assert_eq!(best.size_hint(), (0, Some(3)));
+        assert_eq!(best.next().unwrap().nonce(), 0);
+        assert_eq!(best.size_hint(), (0, Some(2)));
+    }
+
+    #[test]
+    fn test_best_transaction_filter_size_hint() {
+        let mut pool = PendingPool::new(MockOrdering::default());
+        let mut f = MockTransactionFactory::default();
+
+        for nonce in 0..3 {
+            let tx = MockTransaction::eip1559().rng_hash().with_nonce(nonce);
+            pool.add_transaction(Arc::new(f.validated(tx)), 0);
+        }
+
+        let best = pool.best().without_updates();
+        let mut filter =
+            BestTransactionFilter::new(best, |_: &Arc<ValidPoolTransaction<MockTransaction>>| {
+                false
+            });
+
+        assert_eq!(filter.size_hint(), (0, Some(3)));
+        assert!(filter.next().is_none());
+        assert_eq!(filter.size_hint(), (0, Some(0)));
+    }
+
+    #[test]
+    fn test_best_transactions_with_prioritized_senders_size_hint() {
+        let mut pool = PendingPool::new(MockOrdering::default());
+        let mut f = MockTransactionFactory::default();
+
+        for gas_price in 0..5 {
+            let tx = MockTransaction::eip1559().with_gas_price((gas_price + 1) * 10);
+            pool.add_transaction(Arc::new(f.validated(tx)), 0);
+        }
+
+        let prioritized_tx = MockTransaction::eip1559().with_gas_price(5).with_gas_limit(200);
+        let prioritized_sender = prioritized_tx.sender();
+        pool.add_transaction(Arc::new(f.validated(prioritized_tx)), 0);
+
+        let mut best = BestTransactionsWithPrioritizedSenders::new(
+            AddressSet::from_iter([prioritized_sender]),
+            200,
+            pool.best().without_updates(),
+        );
+
+        assert_eq!(best.size_hint(), (0, Some(6)));
+        assert_eq!(best.next().unwrap().sender(), prioritized_sender);
+        assert_eq!(best.size_hint(), (5, Some(5)));
+    }
+
     #[test]
     fn test_best_iter_invalid() {
         let mut pool = PendingPool::new(MockOrdering::default());
@@ -494,7 +601,7 @@ mod tests {
         let invalid = best.independent.iter().next().unwrap();
         best.mark_invalid(
             &invalid.transaction.clone(),
-            &InvalidPoolTransactionError::Consensus(InvalidTransactionError::TxTypeNotSupported),
+            InvalidPoolTransactionError::Consensus(InvalidTransactionError::TxTypeNotSupported),
         );
 
         // iterator is empty
@@ -523,7 +630,7 @@ mod tests {
         crate::traits::BestTransactions::mark_invalid(
             &mut *best,
             &tx,
-            &InvalidPoolTransactionError::Consensus(InvalidTransactionError::TxTypeNotSupported),
+            InvalidPoolTransactionError::Consensus(InvalidTransactionError::TxTypeNotSupported),
         );
         assert!(Iterator::next(&mut best).is_none());
     }
@@ -1089,7 +1196,7 @@ mod tests {
                     crate::traits::BestTransactions::mark_invalid(
                         &mut best,
                         &tx,
-                        &InvalidPoolTransactionError::Eip4844(
+                        InvalidPoolTransactionError::Eip4844(
                             Eip4844PoolTransactionError::TooManyEip4844Blobs {
                                 have: block_blob_count + tx_blob_count,
                                 permitted: max_blob_count,
diff --git a/crates/transaction-pool/src/pool/listener.rs b/crates/transaction-pool/src/pool/listener.rs
index d711bb27e12..86470399e54 100644
--- a/crates/transaction-pool/src/pool/listener.rs
+++ b/crates/transaction-pool/src/pool/listener.rs
@@ -8,10 +8,12 @@ use crate::{
     traits::{NewBlobSidecar, PropagateKind},
     PoolTransaction, ValidPoolTransaction,
 };
-use alloy_primitives::{TxHash, B256};
+use alloy_primitives::{
+    map::{hash_map::Entry, B256Map},
+    TxHash, B256,
+};
 use futures_util::Stream;
 use std::{
-    collections::{hash_map::Entry, HashMap},
     pin::Pin,
     sync::Arc,
     task::{Context, Poll},
@@ -86,14 +88,14 @@ pub struct PoolEventBroadcast<T: PoolTransaction> {
     /// All listeners for all transaction events.
     all_events_broadcaster: AllPoolEventsBroadcaster<T>,
     /// All listeners for events for a certain transaction hash.
-    broadcasters_by_hash: HashMap<TxHash, PoolEventBroadcaster>,
+    broadcasters_by_hash: B256Map<PoolEventBroadcaster>,
 }
 
 impl<T: PoolTransaction> Default for PoolEventBroadcast<T> {
     fn default() -> Self {
         Self {
             all_events_broadcaster: AllPoolEventsBroadcaster::default(),
-            broadcasters_by_hash: HashMap::default(),
+            broadcasters_by_hash: B256Map::default(),
         }
     }
 }
diff --git a/crates/transaction-pool/src/pool/mod.rs b/crates/transaction-pool/src/pool/mod.rs
index 2c6f3a68820..4780a1d6987 100644
--- a/crates/transaction-pool/src/pool/mod.rs
+++ b/crates/transaction-pool/src/pool/mod.rs
@@ -383,8 +383,13 @@ where
         &self,
         max: usize,
     ) -> Vec<Arc<ValidPoolTransaction<T::Transaction>>> {
-        let mut out = Vec::new();
-        self.append_pooled_transactions_max(max, &mut out);
+        if max == 0 {
+            return Vec::new()
+        }
+
+        let pool = self.get_pool_data();
+        let mut out = Vec::with_capacity(max.min(pool.all().len()));
+        out.extend(pool.all().transactions_iter().filter(|tx| tx.propagate).take(max).cloned());
         out
     }
 
@@ -459,13 +464,13 @@ where
         if max == 0 {
             return Vec::new();
         }
-        self.get_pool_data()
-            .all()
-            .transactions_iter()
-            .filter(|tx| tx.propagate)
-            .take(max)
-            .map(|tx| *tx.hash())
-            .collect()
+
+        let pool = self.get_pool_data();
+        let mut out = Vec::with_capacity(max.min(pool.all().len()));
+        out.extend(
+            pool.all().transactions_iter().filter(|tx| tx.propagate).take(max).map(|tx| *tx.hash()),
+        );
+        out
     }
 
     /// Converts the internally tracked transaction to the pooled format.
@@ -1113,7 +1118,7 @@ where
         self.pool.write().prune_transactions(hashes)
     }
 
-    /// Removes and returns all transactions that are present in the pool.
+    /// Retains only transactions that are not present in the pool.
     pub fn retain_unknown<A>(&self, announcement: &mut A)
     where
         A: HandleMempoolData,
@@ -1125,6 +1130,18 @@ where
         announcement.retain_by_hash(|tx| !pool.contains(tx))
     }
 
+    /// Retains only transactions that are present in the pool.
+    pub fn retain_contains<A>(&self, announcement: &mut A)
+    where
+        A: HandleMempoolData,
+    {
+        if announcement.is_empty() {
+            return
+        }
+        let pool = self.get_pool_data();
+        announcement.retain_by_hash(|tx| pool.contains(tx))
+    }
+
     /// Returns the transaction by hash.
     pub fn get(&self, tx_hash: &TxHash) -> Option<Arc<ValidPoolTransaction<T::Transaction>>> {
         self.get_pool_data().get(tx_hash)
diff --git a/crates/transaction-pool/src/traits.rs b/crates/transaction-pool/src/traits.rs
index 2fdd0cb8f5a..9974bb569ae 100644
--- a/crates/transaction-pool/src/traits.rs
+++ b/crates/transaction-pool/src/traits.rs
@@ -51,13 +51,13 @@
 //! - Conversion from consensus to pooled always fails
 
 use crate::{
-    blobstore::BlobStoreError,
+    blobstore::{BlobStore, BlobStoreError},
     error::{InvalidPoolTransactionError, PoolError, PoolResult},
     pool::{
         state::SubPool, BestTransactionFilter, NewTransactionEvent, TransactionEvents,
         TransactionListenerKind,
     },
-    validate::ValidPoolTransaction,
+    validate::{TransactionValidationOutcome, TransactionValidator, ValidPoolTransaction},
     AddedTransactionOutcome, AllTransactionsEvents,
 };
 use alloy_consensus::{error::ValueError, transaction::TxHashRef, BlockHeader, Signed, Typed2718};
@@ -71,7 +71,10 @@ use alloy_eips::{
     eip7594::BlobTransactionSidecarVariant,
     eip7702::SignedAuthorization,
 };
-use alloy_primitives::{map::AddressSet, Address, Bytes, TxHash, TxKind, B128, B256, U256};
+use alloy_primitives::{
+    map::{AddressSet, B256Map},
+    Address, Bytes, TxHash, TxKind, B128, B256, U256,
+};
 use futures_util::{ready, Stream};
 use reth_eth_wire_types::HandleMempoolData;
 use reth_ethereum_primitives::{PooledTransactionVariant, TransactionSigned};
@@ -79,7 +82,6 @@ use reth_execution_types::ChangedAccount;
 use reth_primitives_traits::{Block, InMemorySize, Recovered, SealedBlock, SignedTransaction};
 use serde::{Deserialize, Serialize};
 use std::{
-    collections::HashMap,
     fmt,
     fmt::Debug,
     future::Future,
@@ -548,14 +550,25 @@ pub trait TransactionPool: Clone + Debug + Send + Sync {
     ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>;
 
     /// Retains only those hashes that are unknown to the pool.
+    ///
     /// In other words, removes all transactions from the given set that are currently present in
-    /// the pool. Returns hashes already known to the pool.
+    /// the pool.
     ///
     /// Consumer: P2P
     fn retain_unknown<A>(&self, announcement: &mut A)
     where
         A: HandleMempoolData;
 
+    /// Retains only those hashes that are known to the pool.
+    ///
+    /// In other words, removes all transactions from the given set that are not currently present
+    /// in the pool.
+    ///
+    /// Consumer: P2P
+    fn retain_contains<A>(&self, announcement: &mut A)
+    where
+        A: HandleMempoolData;
+
     /// Returns if the transaction for the given hash is already included in this pool.
     fn contains(&self, tx_hash: &TxHash) -> bool {
         self.get(tx_hash).is_some()
@@ -564,9 +577,9 @@ pub trait TransactionPool: Clone + Debug + Send + Sync {
     /// Returns the transaction for the given hash.
     fn get(&self, tx_hash: &TxHash) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>>;
 
-    /// Returns all transactions objects for the given hashes.
+    /// Returns all transaction objects for the given hashes.
     ///
-    /// Caution: This in case of blob transactions, this does not include the sidecar.
+    /// Caution: In case of blob transactions, this does not include the sidecar.
     fn get_all(&self, txs: Vec<TxHash>) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>;
 
     /// Notify the pool about transactions that are propagated to peers.
@@ -734,6 +747,9 @@ pub trait TransactionPool: Clone + Debug + Send + Sync {
         versioned_hashes: &[B256],
         indices_bitarray: B128,
     ) -> Result<Vec<Option<BlobCellsAndProofsV1>>, BlobStoreError>;
+
+    /// Returns the blob store used by the pool.
+    fn blob_store(&self) -> Box<dyn BlobStore>;
 }
 
 /// Extension for [`TransactionPool`] trait that allows to set the current block info.
@@ -775,6 +791,30 @@ pub trait TransactionPoolExt: TransactionPool {
     fn cleanup_blobs(&self);
 }
 
+/// Extension for [`TransactionPool`] that exposes the pool's underlying [`TransactionValidator`].
+///
+/// This is implemented by pools that validate transactions through a single validator before
+/// insertion (e.g. [`Pool`](crate::Pool)). It lets consumers and wrapper pools reach the validator
+/// directly, for example to validate a transaction without inserting it into the pool.
+pub trait ValidatingPool: TransactionPool {
+    /// The validator used to validate transactions before they are inserted into the pool.
+    type Validator: TransactionValidator<Transaction = Self::Transaction>;
+
+    /// Returns a reference to the pool's transaction validator.
+    fn validator(&self) -> &Self::Validator;
+
+    /// Validates the given transaction without inserting it into the pool.
+    ///
+    /// This is a convenience wrapper around [`TransactionValidator::validate_transaction`].
+    fn validate(
+        &self,
+        origin: TransactionOrigin,
+        transaction: Self::Transaction,
+    ) -> impl Future<Output = TransactionValidationOutcome<Self::Transaction>> + Send {
+        self.validator().validate_transaction(origin, transaction)
+    }
+}
+
 /// A Helper type that bundles all transactions in the pool.
 #[derive(Debug, Clone)]
 pub struct AllPoolTransactions<T: PoolTransaction> {
@@ -794,6 +834,11 @@ impl<T: PoolTransaction> AllPoolTransactions<T> {
         self.pending.len() + self.queued.len()
     }
 
+    /// Returns an iterator over all pending and queued transactions.
+    pub fn iter(&self) -> impl Iterator<Item = &Arc<ValidPoolTransaction<T>>> + '_ {
+        self.pending.iter().chain(self.queued.iter())
+    }
+
     /// Returns an iterator over all pending [`Recovered`] transactions.
     pub fn pending_recovered(&self) -> impl Iterator<Item = Recovered<T::Consensus>> + '_ {
         self.pending.iter().map(|tx| tx.to_consensus())
@@ -830,7 +875,7 @@ impl<T: PoolTransaction> IntoIterator for AllPoolTransactions<T> {
 
 /// Represents transactions that were propagated over the network.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
-pub struct PropagatedTransactions(pub HashMap<TxHash, Vec<PropagateKind>>);
+pub struct PropagatedTransactions(pub B256Map<Vec<PropagateKind>>);
 
 impl PropagatedTransactions {
     /// Records a propagation of a transaction to a peer.
@@ -856,7 +901,7 @@ impl PropagatedTransactions {
 
 impl IntoIterator for PropagatedTransactions {
     type Item = (TxHash, Vec<PropagateKind>);
-    type IntoIter = std::collections::hash_map::IntoIter<TxHash, Vec<PropagateKind>>;
+    type IntoIter = alloy_primitives::map::hash_map::IntoIter<TxHash, Vec<PropagateKind>>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.0.into_iter()
@@ -1057,7 +1102,7 @@ pub trait BestTransactions: Iterator + Send {
     /// Implementers must ensure all subsequent transaction _don't_ depend on this transaction.
     /// In other words, this must remove the given transaction _and_ drain all transaction that
     /// depend on it.
-    fn mark_invalid(&mut self, transaction: &Self::Item, kind: &InvalidPoolTransactionError);
+    fn mark_invalid(&mut self, transaction: &Self::Item, kind: InvalidPoolTransactionError);
 
     /// An iterator may be able to receive additional pending transactions that weren't present it
     /// the pool when it was created.
@@ -1119,7 +1164,7 @@ impl<T> BestTransactions for Box<T>
 where
     T: BestTransactions + ?Sized,
 {
-    fn mark_invalid(&mut self, transaction: &Self::Item, kind: &InvalidPoolTransactionError) {
+    fn mark_invalid(&mut self, transaction: &Self::Item, kind: InvalidPoolTransactionError) {
         (**self).mark_invalid(transaction, kind)
     }
 
@@ -1138,7 +1183,7 @@ where
 
 /// A no-op implementation that yields no transactions.
 impl<T> BestTransactions for std::iter::Empty<T> {
-    fn mark_invalid(&mut self, _tx: &T, _kind: &InvalidPoolTransactionError) {}
+    fn mark_invalid(&mut self, _tx: &T, _kind: InvalidPoolTransactionError) {}
 
     fn no_updates(&mut self) {}
 
@@ -1447,7 +1492,7 @@ pub struct EthPooledTransaction<T = TransactionSigned> {
 impl<T: SignedTransaction> EthPooledTransaction<T> {
     /// Create new instance of [Self].
     ///
-    /// Caution: In case of blob transactions, this does marks the blob sidecar as
+    /// Caution: In case of blob transactions, this marks the blob sidecar as
     /// [`EthBlobTransactionSidecar::Missing`]
     pub fn new(transaction: Recovered<T>, encoded_length: usize) -> Self {
         let mut blob_sidecar = EthBlobTransactionSidecar::None;
diff --git a/crates/transaction-pool/src/validate/eth.rs b/crates/transaction-pool/src/validate/eth.rs
index 6fa760a1db1..ebffeab38d5 100644
--- a/crates/transaction-pool/src/validate/eth.rs
+++ b/crates/transaction-pool/src/validate/eth.rs
@@ -1427,7 +1427,7 @@ pub fn ensure_intrinsic_gas<T: EthPoolTransaction>(
     );
 
     let gas_limit = transaction.gas_limit();
-    if gas_limit < gas.initial_total_gas || gas_limit < gas.floor_gas {
+    if gas_limit < gas.initial_total_gas() || gas_limit < gas.floor_gas {
         Err(InvalidPoolTransactionError::IntrinsicGasTooLow)
     } else {
         Ok(())
diff --git a/crates/trie/common/Cargo.toml b/crates/trie/common/Cargo.toml
index fc5b7617ed4..c53eb885187 100644
--- a/crates/trie/common/Cargo.toml
+++ b/crates/trie/common/Cargo.toml
@@ -48,6 +48,7 @@ rayon = { workspace = true, optional = true }
 [dev-dependencies]
 reth-primitives-traits = { workspace = true, features = ["serde"] }
 reth-codecs.workspace = true
+alloy-eips.workspace = true
 alloy-genesis.workspace = true
 
 alloy-primitives = { workspace = true, features = ["getrandom"] }
@@ -86,6 +87,7 @@ std = [
     "revm-database/std",
     "revm-state/std",
     "reth-codecs?/std",
+    "alloy-eips/std",
 ]
 eip1186 = ["alloy-rpc-types-eth/serde", "dep:alloy-serde"]
 serde = [
@@ -101,6 +103,7 @@ serde = [
     "reth-codecs?/serde",
     "revm-database/serde",
     "revm-state/serde",
+    "alloy-eips/serde",
 ]
 reth-codec = ["dep:reth-codecs", "dep:bytes", "dep:arrayvec"]
 serde-bincode-compat = [
@@ -109,6 +112,7 @@ serde-bincode-compat = [
     "dep:serde_with",
     "alloy-genesis/serde-bincode-compat",
     "alloy-rpc-types-eth?/serde-bincode-compat",
+    "alloy-eips/serde-bincode-compat",
 ]
 test-utils = [
     "dep:plain_hasher",
@@ -129,5 +133,6 @@ arbitrary = [
     "nybbles/arbitrary",
     "reth-codecs/arbitrary",
     "alloy-rpc-types-eth?/arbitrary",
+    "alloy-eips/arbitrary",
 ]
 rayon = ["dep:rayon"]
diff --git a/crates/trie/common/src/ordered_root.rs b/crates/trie/common/src/ordered_root.rs
index ed02a369f73..03a30db0e20 100644
--- a/crates/trie/common/src/ordered_root.rs
+++ b/crates/trie/common/src/ordered_root.rs
@@ -1,257 +1,143 @@
-//! Incremental ordered trie root computation.
+//! Incremental ordered trie root computation for append-only streams.
 //!
-//! This module provides builders for computing ordered trie roots incrementally as items
-//! arrive, rather than requiring all items upfront. This is useful for receipt root
-//! calculation during block execution, where we know the total count but receive receipts
-//! one by one as transactions are executed.
+//! Ethereum block transaction and receipt roots are ordered trie roots keyed by the RLP encoding of
+//! each item index.
+//! [`OrderedTrieRootEncodedBuilder`](crate::ordered_root::OrderedTrieRootEncodedBuilder) accepts
+//! items in their final contiguous order, without requiring the final item count until the stream
+//! ends.
+//!
+//! # Why this works
+//!
+//! RLP-encoded integer keys sort differently around small indices:
+//!
+//! - indices `1..=127` encode as single bytes `0x01..=0x7f`;
+//! - index `0` encodes as `0x80`, so it sorts after `1..=127`;
+//! - indices `>= 128` encode as longer byte strings and sort after `0`.
+//!
+//! This means the final insertion order for a dense list is:
+//!
+//! ```text
+//! len = 0:      []
+//! len = 1:      [0]
+//! 2..=128:     [1, 2, ..., len - 1, 0]
+//! >=129:       [1, 2, ..., 127, 0, 128, 129, ...]
+//! ```
+//!
+//! While the stream is open, the only ambiguous leaf is index `0`: for short lists it is inserted
+//! when the stream ends, and for lists with at least 129 items it can be inserted as soon as index
+//! `128` arrives. All other leaves can be added as they arrive in append-only order.
+//!
+//! # Example
+//!
+//! ```
+//! use reth_trie_common::ordered_root::OrderedTrieRootEncodedBuilder;
+//!
+//! let mut builder = OrderedTrieRootEncodedBuilder::new();
+//! builder.push_next(b"encoded_item_0");
+//! builder.push_next(b"encoded_item_1");
+//!
+//! let root = builder.finalize();
+//! ```
 
 use crate::{HashBuilder, Nibbles, EMPTY_ROOT_HASH};
 use alloc::vec::Vec;
 use alloy_primitives::B256;
-use alloy_trie::root::adjust_index_for_rlp;
-use core::fmt;
-
-/// Error returned when using [`OrderedTrieRootEncodedBuilder`].
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum OrderedRootError {
-    /// Called `finalize()` before all items were pushed.
-    Incomplete {
-        /// The expected number of items.
-        expected: usize,
-        /// The number of items received.
-        received: usize,
-    },
-    /// Index is out of bounds.
-    IndexOutOfBounds {
-        /// The index that was provided.
-        index: usize,
-        /// The expected length.
-        len: usize,
-    },
-    /// Item at this index was already pushed.
-    DuplicateIndex {
-        /// The duplicate index.
-        index: usize,
-    },
-}
-
-impl OrderedRootError {
-    /// Returns `true` if the error is [`OrderedRootError::Incomplete`].
-    #[inline]
-    pub const fn is_incomplete(&self) -> bool {
-        matches!(self, Self::Incomplete { .. })
-    }
-
-    /// Returns `true` if the error is [`OrderedRootError::IndexOutOfBounds`].
-    #[inline]
-    pub const fn is_index_out_of_bounds(&self) -> bool {
-        matches!(self, Self::IndexOutOfBounds { .. })
-    }
-
-    /// Returns `true` if the error is [`OrderedRootError::DuplicateIndex`].
-    #[inline]
-    pub const fn is_duplicate_index(&self) -> bool {
-        matches!(self, Self::DuplicateIndex { .. })
-    }
-
-    /// Returns the index associated with the error, if any.
-    #[inline]
-    pub const fn index(&self) -> Option<usize> {
-        match self {
-            Self::Incomplete { .. } => None,
-            Self::IndexOutOfBounds { index, .. } | Self::DuplicateIndex { index } => Some(*index),
-        }
-    }
-}
-
-impl fmt::Display for OrderedRootError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Incomplete { expected, received } => {
-                write!(f, "incomplete: expected {expected} items, received {received}")
-            }
-            Self::IndexOutOfBounds { index, len } => {
-                write!(f, "index {index} out of bounds for length {len}")
-            }
-            Self::DuplicateIndex { index } => {
-                write!(f, "duplicate item at index {index}")
-            }
-        }
-    }
-}
 
-#[cfg(feature = "std")]
-impl std::error::Error for OrderedRootError {}
-
-/// A builder for computing ordered trie roots incrementally from pre-encoded items.
-///
-/// This builder allows pushing items one by one as they become available
-/// (e.g., receipts after each transaction execution), rather than requiring
-/// all items upfront.
-///
-/// # Use Case
-///
-/// When executing a block, the receipt root must be computed from all transaction
-/// receipts. With the standard `ordered_trie_root`, you must wait until all
-/// transactions are executed before computing the root. This builder enables
-/// **incremental computation** - you can start building the trie as soon as
-/// receipts become available, potentially in parallel with continued execution.
-///
-/// The builder requires knowing the total item count upfront (the number of
-/// transactions in the block), but items can be pushed in any order by index.
-///
-/// # How It Works
-///
-/// Items can be pushed in any order by specifying their index. The builder
-/// internally buffers items and flushes them to the underlying [`HashBuilder`]
-/// in the correct order for RLP key encoding (as determined by [`adjust_index_for_rlp`]).
-///
-/// # Memory
-///
-/// Each pushed item is stored in an internal buffer until it can be flushed.
-/// In the worst case (e.g., pushing index 0 last), all items except one will
-/// be buffered. For receipt roots, index 0 is typically flushed late due to
-/// RLP key ordering, so expect to buffer most items until near the end.
-///
-/// # Example
+/// First index whose RLP-encoded key sorts after index 0.
 ///
-/// ```
-/// use reth_trie_common::ordered_root::OrderedTrieRootEncodedBuilder;
-///
-/// // Create a builder for 2 pre-encoded items
-/// let mut builder = OrderedTrieRootEncodedBuilder::new(2);
+/// Indices `1..=0x7f` encode as their own single byte, so they sort before the RLP encoding of
+/// index 0 (`0x80`). Index `0x80` and larger use long-form RLP integer encoding and sort after
+/// index 0, so index 0 must be flushed before inserting this index.
+const ZERO_KEY_FLUSH_INDEX: usize = 0x80;
+
+/// A builder for computing ordered trie roots from an append-only stream of pre-encoded items.
 ///
-/// // Push pre-encoded items as they arrive (can be out of order)
-/// builder.push(1, b"encoded_item_1").unwrap();
-/// builder.push(0, b"encoded_item_0").unwrap();
+/// This type does not require the total item count up front. It relies on a strict input contract
+/// instead: every pushed item must be the next contiguous item in the final list.
 ///
-/// // Finalize to get the root hash
-/// let root = builder.finalize().unwrap();
-/// ```
-#[derive(Debug)]
+/// This builder is intended for transaction and receipt root computation while a block is still
+/// being built. It buffers only index `0`, then streams all other leaves directly into the
+/// [`HashBuilder`] in the same order as `alloy_trie::root::ordered_trie_root_encoded`.
+#[derive(Debug, Default)]
 pub struct OrderedTrieRootEncodedBuilder {
-    /// Total expected number of items.
+    /// Number of items pushed so far. This is also the next append-only index.
     len: usize,
-    /// Number of items received so far.
-    received: usize,
-    /// Next insertion loop counter (determines which adjusted index to flush next).
-    next_insert_i: usize,
-    /// Buffer for pending items, indexed by execution index.
-    pending: Vec<Option<Vec<u8>>>,
+    /// Index 0 is the only item whose final insertion position depends on whether more items
+    /// arrive.
+    zero: Option<Vec<u8>>,
     /// The underlying hash builder.
     hb: HashBuilder,
 }
 
 impl OrderedTrieRootEncodedBuilder {
-    /// Creates a new builder for `len` pre-encoded items.
-    pub fn new(len: usize) -> Self {
-        Self {
-            len,
-            received: 0,
-            next_insert_i: 0,
-            pending: alloc::vec![None; len],
-            hb: HashBuilder::default(),
-        }
-    }
-
-    /// Pushes a pre-encoded item at the given index to the builder.
-    ///
-    /// Items can be pushed in any order. The builder will automatically
-    /// flush items to the underlying [`HashBuilder`] when they become
-    /// available in the correct order.
-    ///
-    /// # Errors
-    ///
-    /// - [`OrderedRootError::IndexOutOfBounds`] if `index >= len`
-    /// - [`OrderedRootError::DuplicateIndex`] if an item was already pushed at this index
-    #[inline]
-    pub fn push(&mut self, index: usize, bytes: &[u8]) -> Result<(), OrderedRootError> {
-        if index >= self.len {
-            return Err(OrderedRootError::IndexOutOfBounds { index, len: self.len });
-        }
-
-        if self.pending[index].is_some() {
-            return Err(OrderedRootError::DuplicateIndex { index });
-        }
-
-        self.push_unchecked(index, bytes);
-        Ok(())
+    /// Creates an empty builder.
+    pub fn new() -> Self {
+        Self::default()
     }
 
-    /// Pushes a pre-encoded item at the given index without bounds or duplicate checking.
-    ///
-    /// This is a performance-critical method for callers that can guarantee:
-    /// - `index < len`
-    /// - No item has been pushed at this index before
+    /// Pushes the next pre-encoded item.
     ///
-    /// # Panics
-    ///
-    /// Panics in debug mode if `index >= len`.
+    /// Items must be pushed in their final contiguous order.
     #[inline]
-    pub fn push_unchecked(&mut self, index: usize, bytes: &[u8]) {
-        debug_assert!(index < self.len, "index {index} out of bounds for length {}", self.len);
-        debug_assert!(self.pending[index].is_none(), "duplicate item at index {index}");
-
-        self.pending[index] = Some(bytes.to_vec());
-        self.received += 1;
-
-        self.flush();
-    }
-
-    /// Attempts to flush pending items to the hash builder.
-    fn flush(&mut self) {
-        while self.next_insert_i < self.len {
-            let exec_index_needed = adjust_index_for_rlp(self.next_insert_i, self.len);
-
-            let Some(value) = self.pending[exec_index_needed].take() else {
-                break;
-            };
-
-            let index_buffer = alloy_rlp::encode_fixed_size(&exec_index_needed);
-            self.hb.add_leaf(Nibbles::unpack(&index_buffer), &value);
+    pub fn push_next(&mut self, bytes: &[u8]) {
+        let index = self.len;
+        self.len += 1;
 
-            self.next_insert_i += 1;
+        match index {
+            0 => {
+                self.zero = Some(bytes.to_vec());
+            }
+            1..=0x7f => {
+                self.add_leaf(index, bytes);
+            }
+            ZERO_KEY_FLUSH_INDEX => {
+                self.flush_zero();
+                self.add_leaf(index, bytes);
+            }
+            _ => {
+                debug_assert!(self.zero.is_none(), "index 0 must be flushed before indices > 128");
+                self.add_leaf(index, bytes);
+            }
         }
     }
 
-    /// Returns `true` if all items have been pushed.
-    #[inline]
-    pub const fn is_complete(&self) -> bool {
-        self.received == self.len
-    }
-
     /// Returns the number of items pushed so far.
     #[inline]
     pub const fn pushed_count(&self) -> usize {
-        self.received
+        self.len
     }
 
-    /// Returns the expected total number of items.
+    /// Returns `true` if no items have been pushed.
     #[inline]
-    pub const fn expected_count(&self) -> usize {
-        self.len
+    pub const fn is_empty(&self) -> bool {
+        self.len == 0
     }
 
     /// Finalizes the builder and returns the trie root.
     ///
-    /// # Errors
-    ///
-    /// Returns [`OrderedRootError::Incomplete`] if not all items have been pushed.
-    pub fn finalize(mut self) -> Result<B256, OrderedRootError> {
+    /// This method is the end-of-stream signal. If fewer than 129 items were pushed, index `0` is
+    /// inserted here because it is the final leaf in RLP key order for that short list.
+    pub fn finalize(mut self) -> B256 {
         if self.len == 0 {
-            return Ok(EMPTY_ROOT_HASH);
+            return EMPTY_ROOT_HASH;
         }
 
-        if self.received != self.len {
-            return Err(OrderedRootError::Incomplete {
-                expected: self.len,
-                received: self.received,
-            });
+        self.flush_zero();
+        self.hb.root()
+    }
+
+    fn flush_zero(&mut self) {
+        if self.zero.is_none() {
+            return;
         }
 
-        debug_assert_eq!(self.next_insert_i, self.len, "not all items were flushed");
+        let zero = self.zero.take().expect("index 0 must be buffered before it is flushed");
+        self.add_leaf(0, &zero);
+    }
 
-        Ok(self.hb.root())
+    fn add_leaf(&mut self, index: usize, bytes: &[u8]) {
+        let index_buffer = alloy_rlp::encode_fixed_size(&index);
+        self.hb.add_leaf(Nibbles::unpack(&index_buffer), bytes);
     }
 }
 
@@ -259,6 +145,23 @@ impl OrderedTrieRootEncodedBuilder {
 mod tests {
     use super::*;
     use alloy_trie::root::ordered_trie_root_encoded;
+    use proptest::prelude::*;
+
+    fn item(index: usize) -> Vec<u8> {
+        format!("encoded_item_{index}").into_bytes()
+    }
+
+    fn items(len: usize) -> Vec<Vec<u8>> {
+        (0..len).map(item).collect()
+    }
+
+    fn root_with_push_next(items: &[Vec<u8>]) -> B256 {
+        let mut builder = OrderedTrieRootEncodedBuilder::new();
+        for item in items {
+            builder.push_next(item);
+        }
+        builder.finalize()
+    }
 
     #[test]
     fn test_ordered_encoded_builder_equivalence() {
@@ -268,13 +171,13 @@ mod tests {
 
             let expected = ordered_trie_root_encoded(&items);
 
-            let mut builder = OrderedTrieRootEncodedBuilder::new(len);
+            let mut builder = OrderedTrieRootEncodedBuilder::new();
 
-            for (i, item) in items.iter().enumerate() {
-                builder.push(i, item).unwrap();
+            for item in &items {
+                builder.push_next(item);
             }
 
-            let actual = builder.finalize().unwrap();
+            let actual = builder.finalize();
             assert_eq!(
                 expected, actual,
                 "mismatch for len={len}: expected {expected:?}, got {actual:?}"
@@ -283,72 +186,132 @@ mod tests {
     }
 
     #[test]
-    fn test_ordered_builder_out_of_order() {
-        for len in [2, 3, 5, 10, 50] {
-            let items: Vec<Vec<u8>> =
-                (0..len).map(|i| format!("item_{i}_data").into_bytes()).collect();
+    fn empty_builder_returns_empty_root() {
+        let builder = OrderedTrieRootEncodedBuilder::new();
+        assert!(builder.is_empty());
+        assert_eq!(builder.pushed_count(), 0);
+        assert_eq!(builder.finalize(), EMPTY_ROOT_HASH);
+    }
 
-            let expected = ordered_trie_root_encoded(&items);
+    #[test]
+    fn test_ordered_builder_count_tracks_pushed_items() {
+        let mut builder = OrderedTrieRootEncodedBuilder::new();
+        assert!(builder.is_empty());
 
-            // Push in reverse order
-            let mut builder = OrderedTrieRootEncodedBuilder::new(len);
-            for i in (0..len).rev() {
-                builder.push(i, &items[i]).unwrap();
-            }
-            let actual = builder.finalize().unwrap();
-            assert_eq!(expected, actual, "mismatch for reverse order len={len}");
+        builder.push_next(b"item_0");
+        assert!(!builder.is_empty());
+        assert_eq!(builder.pushed_count(), 1);
 
-            // Push odds first, then evens
-            let mut builder = OrderedTrieRootEncodedBuilder::new(len);
-            for i in (1..len).step_by(2) {
-                builder.push(i, &items[i]).unwrap();
-            }
-            for i in (0..len).step_by(2) {
-                builder.push(i, &items[i]).unwrap();
-            }
-            let actual = builder.finalize().unwrap();
-            assert_eq!(expected, actual, "mismatch for odd/even order len={len}");
-        }
+        builder.push_next(b"item_1");
+        assert_eq!(builder.pushed_count(), 2);
     }
 
     #[test]
-    fn test_ordered_builder_empty() {
-        let builder = OrderedTrieRootEncodedBuilder::new(0);
-        assert!(builder.is_complete());
-        assert_eq!(builder.finalize().unwrap(), EMPTY_ROOT_HASH);
+    fn matches_ordered_root_for_boundary_lengths() {
+        for len in [0, 1, 2, 3, 4, 126, 127, 128, 129, 130, 200, 255, 256, 512] {
+            let items = items(len);
+            let expected = ordered_trie_root_encoded(&items);
+
+            assert_eq!(root_with_push_next(&items), expected, "push_next mismatch for len={len}");
+        }
     }
 
     #[test]
-    fn test_ordered_builder_incomplete_error() {
-        let mut builder = OrderedTrieRootEncodedBuilder::new(3);
+    fn short_lists_flush_zero_on_finalize() {
+        for len in 1..=128 {
+            let items = items(len);
+            let expected = ordered_trie_root_encoded(&items);
 
-        builder.push(0, b"item_0").unwrap();
-        builder.push(1, b"item_1").unwrap();
+            let mut builder = OrderedTrieRootEncodedBuilder::new();
+            for item in &items {
+                builder.push_next(item);
+            }
 
-        assert!(!builder.is_complete());
-        assert_eq!(
-            builder.finalize(),
-            Err(OrderedRootError::Incomplete { expected: 3, received: 2 })
-        );
+            assert_eq!(builder.pushed_count(), len);
+            assert_eq!(builder.finalize(), expected, "mismatch for short len={len}");
+        }
     }
 
     #[test]
-    fn test_ordered_builder_index_errors() {
-        let mut builder = OrderedTrieRootEncodedBuilder::new(2);
+    fn long_lists_flush_zero_when_index_128_arrives() {
+        let items = items(129);
+        let expected = ordered_trie_root_encoded(&items);
 
-        assert_eq!(
-            builder.push(5, b"item"),
-            Err(OrderedRootError::IndexOutOfBounds { index: 5, len: 2 })
-        );
+        let mut builder = OrderedTrieRootEncodedBuilder::new();
+        for item in &items {
+            builder.push_next(item);
+        }
+
+        assert_eq!(builder.pushed_count(), 129);
+        assert_eq!(builder.finalize(), expected);
+    }
+
+    proptest! {
+        #[test]
+        fn arbitrary_encoded_items_match_ordered_root(items in proptest::collection::vec(
+            proptest::collection::vec(any::<u8>(), 0..128),
+            0..1024,
+        )) {
+            let expected = ordered_trie_root_encoded(&items);
+
+            prop_assert_eq!(root_with_push_next(&items), expected);
+        }
+    }
 
-        builder.push(0, b"item_0").unwrap();
+    #[cfg(feature = "arbitrary")]
+    mod arbitrary_consensus_roots {
+        use super::*;
+        use alloy_consensus::{
+            proofs::{calculate_receipt_root, calculate_transaction_root},
+            EthereumReceipt, ReceiptWithBloom, Signed, TxLegacy,
+        };
+        use alloy_eips::eip2718::Encodable2718;
+        use alloy_primitives::Signature;
+        use proptest::test_runner::Config;
+        use proptest_arbitrary_interop::arb;
+
+        fn open_ended_2718_root<T: Encodable2718>(items: &[T]) -> B256 {
+            let mut builder = OrderedTrieRootEncodedBuilder::new();
+            let mut buf = Vec::new();
+
+            for item in items {
+                buf.clear();
+                item.encode_2718(&mut buf);
+                builder.push_next(&buf);
+            }
 
-        assert_eq!(
-            builder.push(0, b"item_0_dup"),
-            Err(OrderedRootError::DuplicateIndex { index: 0 })
-        );
+            builder.finalize()
+        }
 
-        builder.push(1, b"item_1").unwrap();
-        assert!(builder.is_complete());
+        proptest! {
+            #![proptest_config(Config::with_cases(32))]
+
+            #[test]
+            fn arbitrary_transactions_match_alloy_consensus_root(
+                transactions in proptest::collection::vec(
+                    (arb::<TxLegacy>(), arb::<Signature>())
+                        .prop_map(|(tx, signature)| Signed::new_unhashed(tx, signature)),
+                    0..1024,
+                ),
+            ) {
+                let expected = calculate_transaction_root(&transactions);
+                let actual = open_ended_2718_root(&transactions);
+
+                prop_assert_eq!(actual, expected);
+            }
+
+            #[test]
+            fn arbitrary_receipts_match_alloy_consensus_root(
+                receipts in proptest::collection::vec(
+                    arb::<ReceiptWithBloom<EthereumReceipt>>(),
+                    0..1024,
+                ),
+            ) {
+                let expected = calculate_receipt_root(&receipts);
+                let actual = open_ended_2718_root(&receipts);
+
+                prop_assert_eq!(actual, expected);
+            }
+        }
     }
 }
diff --git a/crates/trie/common/src/proofs.rs b/crates/trie/common/src/proofs.rs
index 6a8adbc621a..c700ad479d2 100644
--- a/crates/trie/common/src/proofs.rs
+++ b/crates/trie/common/src/proofs.rs
@@ -724,18 +724,48 @@ pub struct AccountProof {
 
 #[cfg(feature = "eip1186")]
 impl AccountProof {
-    /// Convert into an EIP-1186 account proof response
+    /// Convert into an EIP-1186 account proof response.
+    ///
+    /// For non-existent accounts, this returns `KECCAK_EMPTY` for `codeHash` and
+    /// `EMPTY_ROOT_HASH` for `storageHash`, matching reth's default behavior.
+    ///
+    /// Use [`Self::into_eip1186_response_with`] to customize the behavior for
+    /// non-existent accounts (e.g. returning `B256::ZERO` for geth compatibility).
     pub fn into_eip1186_response(
         self,
         slots: Vec<alloy_serde::JsonStorageKey>,
     ) -> alloy_rpc_types_eth::EIP1186AccountProofResponse {
+        self.into_eip1186_response_with(slots, false)
+    }
+
+    /// Convert into an EIP-1186 account proof response, with optional geth-compatible
+    /// zero hashes for non-existent accounts.
+    ///
+    /// When `zero_empty_account` is `true`, non-existent accounts return `B256::ZERO`
+    /// for both `codeHash` and `storageHash`, matching geth's behavior since v1.13.4
+    /// ([go-ethereum#28357](https://github.com/ethereum/go-ethereum/pull/28357)).
+    ///
+    /// When `false`, returns `KECCAK_EMPTY` / `EMPTY_ROOT_HASH` (reth default).
+    ///
+    /// See: <https://github.com/ethereum/go-ethereum/issues/28441>
+    pub fn into_eip1186_response_with(
+        self,
+        slots: Vec<alloy_serde::JsonStorageKey>,
+        zero_empty_account: bool,
+    ) -> alloy_rpc_types_eth::EIP1186AccountProofResponse {
+        let is_non_existent = self.info.is_none();
         let info = self.info.unwrap_or_default();
+        let (code_hash, storage_hash) = if is_non_existent && zero_empty_account {
+            (B256::ZERO, B256::ZERO)
+        } else {
+            (info.get_bytecode_hash(), self.storage_root)
+        };
         alloy_rpc_types_eth::EIP1186AccountProofResponse {
             address: self.address,
             balance: info.balance,
-            code_hash: info.get_bytecode_hash(),
+            code_hash,
             nonce: info.nonce,
-            storage_hash: self.storage_root,
+            storage_hash,
             account_proof: self.proof,
             storage_proof: self
                 .storage_proofs
@@ -768,11 +798,17 @@ impl AccountProof {
 
         let (storage_root, info) = if nonce == 0 &&
             balance.is_zero() &&
-            storage_hash.is_zero() &&
-            code_hash == KECCAK_EMPTY
+            (storage_hash.is_zero() || storage_hash == EMPTY_ROOT_HASH) &&
+            (code_hash == KECCAK_EMPTY || code_hash.is_zero())
         {
             // Account does not exist in state. Return `None` here to prevent proof
             // verification.
+            //
+            // Note: geth (since v1.13.4, go-ethereum#28357) returns `B256::ZERO` for
+            // both `codeHash` and `storageHash` in exclusion proofs, while reth
+            // returns `KECCAK_EMPTY` / `EMPTY_ROOT_HASH`. We accept both formats here
+            // so that proofs obtained from any client can be deserialized correctly.
+            // See: https://github.com/ethereum/go-ethereum/issues/28441
             (EMPTY_ROOT_HASH, None)
         } else {
             (storage_hash, Some(Account { nonce, balance, bytecode_hash: code_hash.into() }))
@@ -1209,6 +1245,91 @@ mod tests {
         assert_eq!(acc, inverse);
     }
 
+    #[test]
+    #[cfg(feature = "eip1186")]
+    fn from_eip1186_proof_accepts_geth_zero_hashes() {
+        // geth (since v1.13.4) returns B256::ZERO for codeHash and storageHash
+        // in exclusion proofs for non-existent accounts, instead of
+        // KECCAK_EMPTY / EMPTY_ROOT_HASH. Verify that from_eip1186_proof
+        // correctly recognizes this format as a non-existent account.
+        let geth_proof = alloy_rpc_types_eth::EIP1186AccountProofResponse {
+            address: Address::random(),
+            balance: U256::ZERO,
+            code_hash: B256::ZERO,
+            nonce: 0,
+            storage_hash: B256::ZERO,
+            account_proof: vec![],
+            storage_proof: vec![],
+        };
+
+        let acc: AccountProof = geth_proof.into();
+        // Should be interpreted as a non-existent account (info = None)
+        assert!(acc.info.is_none());
+        assert_eq!(acc.storage_root, EMPTY_ROOT_HASH);
+    }
+
+    #[test]
+    #[cfg(feature = "eip1186")]
+    fn from_eip1186_proof_accepts_empty_hashes() {
+        let proof = alloy_rpc_types_eth::EIP1186AccountProofResponse {
+            address: Address::random(),
+            balance: U256::ZERO,
+            code_hash: KECCAK_EMPTY,
+            nonce: 0,
+            storage_hash: EMPTY_ROOT_HASH,
+            account_proof: vec![],
+            storage_proof: vec![],
+        };
+
+        let acc: AccountProof = proof.into();
+        assert!(acc.info.is_none());
+        assert_eq!(acc.storage_root, EMPTY_ROOT_HASH);
+    }
+
+    #[test]
+    #[cfg(feature = "eip1186")]
+    fn into_eip1186_response_zero_empty_account() {
+        // Non-existent account (info = None)
+        let acc = AccountProof {
+            address: Address::random(),
+            info: None,
+            proof: vec![],
+            storage_root: EMPTY_ROOT_HASH,
+            storage_proofs: vec![],
+        };
+
+        // Default behavior: KECCAK_EMPTY / EMPTY_ROOT_HASH
+        let rpc_default = acc.clone().into_eip1186_response(Vec::new());
+        assert_eq!(rpc_default.code_hash, KECCAK_EMPTY);
+        assert_eq!(rpc_default.storage_hash, EMPTY_ROOT_HASH);
+
+        // zero_empty_account = false: same as default
+        let rpc_compat_off = acc.clone().into_eip1186_response_with(Vec::new(), false);
+        assert_eq!(rpc_compat_off.code_hash, KECCAK_EMPTY);
+        assert_eq!(rpc_compat_off.storage_hash, EMPTY_ROOT_HASH);
+
+        // zero_empty_account = true: B256::ZERO (geth-compat)
+        let rpc_compat_on = acc.into_eip1186_response_with(Vec::new(), true);
+        assert_eq!(rpc_compat_on.code_hash, B256::ZERO);
+        assert_eq!(rpc_compat_on.storage_hash, B256::ZERO);
+
+        // Existing account should NOT be affected by zero_empty_account
+        let existing_acc = AccountProof {
+            address: Address::random(),
+            info: Some(Account {
+                nonce: 42,
+                balance: U256::from(100),
+                bytecode_hash: Some(KECCAK_EMPTY),
+            }),
+            proof: vec![],
+            storage_root: B256::random(),
+            storage_proofs: vec![],
+        };
+        let rpc_existing = existing_acc.clone().into_eip1186_response_with(Vec::new(), true);
+        assert_eq!(rpc_existing.code_hash, KECCAK_EMPTY);
+        assert_eq!(rpc_existing.storage_hash, existing_acc.storage_root);
+    }
+
     #[test]
     fn test_multiproof_targets_chunking_length() {
         let mut targets = MultiProofTargets::default();
diff --git a/crates/trie/parallel/src/proof_task.rs b/crates/trie/parallel/src/proof_task.rs
index 2fc01af6ec8..81df832db04 100644
--- a/crates/trie/parallel/src/proof_task.rs
+++ b/crates/trie/parallel/src/proof_task.rs
@@ -1064,8 +1064,12 @@ fn dispatch_v2_storage_proofs(
     account_targets: &[ProofV2Target],
     mut storage_targets: B256Map<Vec<ProofV2Target>>,
 ) -> Result<B256Map<CrossbeamReceiver<StorageProofResultMessage>>, ParallelStateRootError> {
+    if storage_targets.is_empty() {
+        return Ok(B256Map::default())
+    }
+
     let mut storage_proof_receivers =
-        B256Map::with_capacity_and_hasher(account_targets.len(), Default::default());
+        B256Map::with_capacity_and_hasher(storage_targets.len(), Default::default());
 
     // Collect hashed addresses from account targets that need their storage roots computed
     let account_target_addresses: B256Set = account_targets.iter().map(|t| t.key()).collect();
diff --git a/crates/trie/parallel/src/state_root_task.rs b/crates/trie/parallel/src/state_root_task.rs
index 24a1e3269d9..6f1619bd0aa 100644
--- a/crates/trie/parallel/src/state_root_task.rs
+++ b/crates/trie/parallel/src/state_root_task.rs
@@ -2,7 +2,6 @@
 
 use crate::root::ParallelStateRootError;
 use alloy_eip7928::BlockAccessList;
-use alloy_evm::block::StateChangeSource;
 use alloy_primitives::{keccak256, B256};
 use derive_more::derive::Deref;
 use reth_trie::{updates::TrieUpdates, HashedPostState, HashedStorage, MultiProofTargetsV2};
@@ -10,37 +9,13 @@ use revm_state::EvmState;
 use std::sync::Arc;
 use tracing::trace;
 
-/// Source of state changes, either from EVM execution or from a Block Access List.
-#[derive(Clone, Copy)]
-pub enum Source {
-    /// State changes from EVM execution.
-    Evm(StateChangeSource),
-    /// State changes from Block Access List (EIP-7928).
-    BlockAccessList,
-}
-
-impl std::fmt::Debug for Source {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Evm(source) => source.fmt(f),
-            Self::BlockAccessList => f.write_str("BlockAccessList"),
-        }
-    }
-}
-
-impl From<StateChangeSource> for Source {
-    fn from(source: StateChangeSource) -> Self {
-        Self::Evm(source)
-    }
-}
-
 /// Messages used internally by the multi proof task.
 #[derive(Debug)]
 pub enum StateRootMessage {
     /// Prefetch proof targets
     PrefetchProofs(MultiProofTargetsV2),
     /// New state update from transaction execution with its source
-    StateUpdate(Source, EvmState),
+    StateUpdate(EvmState),
     /// Pre-hashed state update from BAL conversion that can be applied directly without proofs.
     HashedStateUpdate(HashedPostState),
     /// Block Access List (EIP-7928; BAL) containing complete state changes for the block.
@@ -85,6 +60,8 @@ pub struct StateRootHandle {
     /// Receiver for the final state root result.
     state_root_rx:
         Option<std::sync::mpsc::Receiver<Result<StateRootComputeOutcome, ParallelStateRootError>>>,
+    /// Receiver for the hashed post state.
+    hashed_state_rx: Option<std::sync::mpsc::Receiver<HashedPostState>>,
 }
 
 impl StateRootHandle {
@@ -95,8 +72,14 @@ impl StateRootHandle {
         state_root_rx: std::sync::mpsc::Receiver<
             Result<StateRootComputeOutcome, ParallelStateRootError>,
         >,
+        hashed_state_rx: std::sync::mpsc::Receiver<HashedPostState>,
     ) -> Self {
-        Self { cached_trie_state_root, updates_tx, state_root_rx: Some(state_root_rx) }
+        Self {
+            cached_trie_state_root,
+            updates_tx,
+            state_root_rx: Some(state_root_rx),
+            hashed_state_rx: Some(hashed_state_rx),
+        }
     }
 
     /// Returns the state root that the cached sparse trie is anchored at.
@@ -115,8 +98,8 @@ impl StateRootHandle {
     pub fn state_hook(&self) -> impl alloy_evm::block::OnStateHook {
         let sender = StateHookSender::new(self.updates_tx.clone());
 
-        move |source: StateChangeSource, state: &EvmState| {
-            let _ = sender.send(StateRootMessage::StateUpdate(source.into(), state.clone()));
+        move |state: &EvmState| {
+            let _ = sender.send(StateRootMessage::StateUpdate(state.clone()));
         }
     }
 
@@ -143,6 +126,15 @@ impl StateRootHandle {
     ) -> std::sync::mpsc::Receiver<Result<StateRootComputeOutcome, ParallelStateRootError>> {
         self.state_root_rx.take().expect("state_root already taken")
     }
+
+    /// Takes the hashed state receiver
+    ///
+    /// # Panics
+    ///
+    /// If called more than once.
+    pub const fn take_hashed_state_rx(&mut self) -> std::sync::mpsc::Receiver<HashedPostState> {
+        self.hashed_state_rx.take().expect("hashed_state already taken")
+    }
 }
 
 /// A wrapper for the sender that signals completion when dropped.
@@ -177,8 +169,10 @@ pub fn evm_state_to_hashed_post_state(update: EvmState) -> HashedPostState {
             trace!(target: "trie::parallel::sparse", ?address, ?hashed_address, "Adding account to state update");
 
             let destroyed = account.is_selfdestructed();
-            let info = if destroyed { None } else { Some(account.info.into()) };
-            hashed_state.accounts.insert(hashed_address, info);
+            if account.info != account.original_info() {
+                let info = if destroyed { None } else { Some(account.info.into()) };
+                hashed_state.accounts.insert(hashed_address, info);
+            }
 
             let mut changed_storage_iter = account
                 .storage
diff --git a/crates/trie/sparse/Cargo.toml b/crates/trie/sparse/Cargo.toml
index 035947987ca..8cb9e678440 100644
--- a/crates/trie/sparse/Cargo.toml
+++ b/crates/trie/sparse/Cargo.toml
@@ -24,6 +24,7 @@ alloy-primitives.workspace = true
 alloy-rlp.workspace = true
 
 # misc
+either.workspace = true
 rayon = { workspace = true, optional = true }
 serde = { workspace = true, features = ["derive"], optional = true }
 serde_json = { workspace = true, optional = true }
@@ -68,6 +69,8 @@ std = [
     "tracing/std",
     "serde?/std",
     "serde_json?/std",
+    "reth-tracing/std",
+    "either/std",
 ]
 metrics = ["dep:reth-metrics", "dep:metrics", "std"]
 trie-debug = ["std", "dep:serde", "dep:serde_json", "alloy-primitives/serde", "alloy-trie/serde"]
diff --git a/crates/trie/sparse/src/parallel.rs b/crates/trie/sparse/src/parallel.rs
index 6e17e1d01f2..71f5c88e215 100644
--- a/crates/trie/sparse/src/parallel.rs
+++ b/crates/trie/sparse/src/parallel.rs
@@ -956,7 +956,7 @@ impl ParallelSparseTrie {
         #[cfg(not(feature = "std"))]
         {
             let _ = num_nodes;
-            return false;
+            false
         }
 
         #[cfg(feature = "std")]
@@ -971,7 +971,7 @@ impl ParallelSparseTrie {
         #[cfg(not(feature = "std"))]
         {
             let _ = num_changed_keys;
-            return false;
+            false
         }
 
         #[cfg(feature = "std")]
diff --git a/crates/trie/sparse/src/state.rs b/crates/trie/sparse/src/state.rs
index 7cccfbbb2e0..d35e907b4d6 100644
--- a/crates/trie/sparse/src/state.rs
+++ b/crates/trie/sparse/src/state.rs
@@ -7,12 +7,13 @@ use crate::{
 use alloc::vec::Vec;
 use alloy_primitives::{map::B256Map, B256};
 use alloy_rlp::{Decodable, Encodable};
+use either::Either;
 use reth_execution_errors::{SparseStateTrieResult, SparseTrieErrorKind};
 use reth_primitives_traits::Account;
 use reth_trie_common::{
     updates::{StorageTrieUpdates, TrieUpdates},
-    DecodedMultiProof, MultiProof, Nibbles, ProofTrieNodeV2, TrieAccount, TrieNodeV2,
-    EMPTY_ROOT_HASH, TRIE_ACCOUNT_RLP_MAX_SIZE,
+    DecodedMultiProof, MultiProof, Nibbles, ProofTrieNodeV2, TrieAccount, EMPTY_ROOT_HASH,
+    TRIE_ACCOUNT_RLP_MAX_SIZE,
 };
 #[cfg(feature = "std")]
 use tracing::debug;
@@ -300,158 +301,78 @@ where
         &mut self,
         multiproof: reth_trie_common::DecodedMultiProofV2,
     ) -> SparseStateTrieResult<()> {
-        // Reveal the account proof nodes.
-        //
-        // Skip revealing account nodes if this result only contains storage proofs.
-        // `reveal_account_v2_proof_nodes` will return an error if empty `nodes` are passed into it
-        // before the accounts trie root was revealed. This might happen in cases when first account
-        // trie proof arrives later than first storage trie proof even though the account trie proof
-        // was requested first.
-        if !multiproof.account_proofs.is_empty() {
-            self.reveal_account_v2_proof_nodes(multiproof.account_proofs)?;
+        let reth_trie_common::DecodedMultiProofV2 { account_proofs, mut storage_proofs, .. } =
+            multiproof;
+
+        // Collect `(trie, proof_nodes)` pairs for both the account trie and every storage trie
+        // touched by this multiproof.
+        let mut targets = Vec::with_capacity(storage_proofs.len() + 1);
+
+        if !account_proofs.is_empty() {
+            #[cfg(feature = "metrics")]
+            self.metrics.increment_total_account_nodes(account_proofs.len() as u64);
+            targets.push((Either::Left(&mut self.state), account_proofs));
         }
 
-        #[cfg(not(feature = "std"))]
-        // If nostd then serially reveal storage proof nodes for each storage trie
-        {
-            for (account, storage_proofs) in multiproof.storage_proofs {
-                self.reveal_storage_v2_proof_nodes(account, storage_proofs)?;
-            }
+        // Ensure a storage trie exists for every address whose proofs we're about to reveal
+        for &account in storage_proofs.keys() {
+            let _ = self.storage.get_or_create_trie_mut(account);
+        }
 
-            Ok(())
+        for (account, trie) in &mut self.storage.tries {
+            if let Some(nodes) = storage_proofs.remove(account) {
+                #[cfg(feature = "metrics")]
+                self.metrics.increment_total_storage_nodes(nodes.len() as u64);
+                targets.push((Either::Right(trie), nodes));
+            }
         }
 
+        let retain_updates = self.retain_updates;
+
+        #[cfg(not(feature = "std"))]
+        let results: Vec<_> = targets
+            .into_iter()
+            .map(|(target, mut nodes)| {
+                let result = match target {
+                    Either::Left(trie) => trie.reveal_v2_proof_nodes(&mut nodes, retain_updates),
+                    Either::Right(trie) => trie.reveal_v2_proof_nodes(&mut nodes, retain_updates),
+                };
+                (result, nodes)
+            })
+            .collect();
+
         #[cfg(feature = "std")]
-        // If std then reveal storage proofs in parallel
-        {
+        let results: Vec<_> = {
             use rayon::iter::ParallelIterator;
             use reth_primitives_traits::ParallelBridgeBuffered;
 
-            let retain_updates = self.retain_updates;
-
-            // Process all storage trie revealings in parallel, having first removed the
-            // `RevealableSparseTrie`s for each account from their HashMaps. These will be
-            // returned after processing.
-            let results: Vec<_> = multiproof
-                .storage_proofs
+            targets
                 .into_iter()
-                .map(|(account, storage_proofs)| {
-                    let trie = self.storage.take_or_create_trie(&account);
-                    (account, storage_proofs, trie)
-                })
                 .par_bridge_buffered()
-                .map(|(account, storage_proofs, mut trie)| {
-                    let mut bufs = Vec::new();
-                    let result = Self::reveal_storage_v2_proof_nodes_inner(
-                        account,
-                        storage_proofs,
-                        &mut trie,
-                        &mut bufs,
-                        retain_updates,
-                    );
-                    (account, result, trie, bufs)
+                .map(|(target, mut nodes)| {
+                    let result = match target {
+                        Either::Left(trie) => {
+                            trie.reveal_v2_proof_nodes(&mut nodes, retain_updates)
+                        }
+                        Either::Right(trie) => {
+                            trie.reveal_v2_proof_nodes(&mut nodes, retain_updates)
+                        }
+                    };
+                    (result, nodes)
                 })
-                .collect();
-
-            let mut any_err = Ok(());
-            for (account, result, trie, bufs) in results {
-                self.storage.tries.insert(account, trie);
-                if let Ok(_total_nodes) = result {
-                    #[cfg(feature = "metrics")]
-                    {
-                        self.metrics.increment_total_storage_nodes(_total_nodes as u64);
-                    }
-                } else {
-                    any_err = result.map(|_| ());
-                }
-
-                // Keep buffers for deferred dropping
-                self.deferred_drops.proof_nodes_bufs.extend(bufs);
-            }
-
-            any_err
-        }
-    }
-
-    /// Reveals account proof nodes from a V2 proof.
-    ///
-    /// V2 proofs already include the masks in the `ProofTrieNode` structure,
-    /// so no separate masks map is needed.
-    pub fn reveal_account_v2_proof_nodes(
-        &mut self,
-        mut nodes: Vec<ProofTrieNodeV2>,
-    ) -> SparseStateTrieResult<()> {
-        let capacity = estimate_v2_proof_capacity(&nodes);
-
-        #[cfg(feature = "metrics")]
-        self.metrics.increment_total_account_nodes(nodes.len() as u64);
-
-        let root_node = nodes.iter().find(|n| n.path.is_empty());
-        let trie = if let Some(root_node) = root_node {
-            trace!(target: "trie::sparse", ?root_node, "Revealing root account node from V2 proof");
-            self.state.reveal_root(root_node.node.clone(), root_node.masks, self.retain_updates)?
-        } else {
-            self.state.as_revealed_mut().ok_or(SparseTrieErrorKind::Blind)?
+                .collect()
         };
-        trie.reserve_nodes(capacity);
-        trace!(target: "trie::sparse", total_nodes = ?nodes.len(), "Revealing account nodes from V2 proof");
-        trie.reveal_nodes(&mut nodes)?;
 
-        self.deferred_drops.proof_nodes_bufs.push(nodes);
-        Ok(())
-    }
-
-    /// Reveals storage proof nodes from a V2 proof for the given address.
-    ///
-    /// V2 proofs already include the masks in the `ProofTrieNode` structure,
-    /// so no separate masks map is needed.
-    pub fn reveal_storage_v2_proof_nodes(
-        &mut self,
-        account: B256,
-        nodes: Vec<ProofTrieNodeV2>,
-    ) -> SparseStateTrieResult<()> {
-        let trie = self.storage.get_or_create_trie_mut(account);
-        let _total_nodes = Self::reveal_storage_v2_proof_nodes_inner(
-            account,
-            nodes,
-            trie,
-            &mut self.deferred_drops.proof_nodes_bufs,
-            self.retain_updates,
-        )?;
-
-        #[cfg(feature = "metrics")]
-        {
-            self.metrics.increment_total_storage_nodes(_total_nodes as u64);
+        // Accumulate the first error and defer dropping the proof node buffers.
+        let mut any_err = Ok(());
+        for (result, nodes) in results {
+            if result.is_err() && any_err.is_ok() {
+                any_err = result.map_err(Into::into);
+            }
+            self.deferred_drops.proof_nodes_bufs.push(nodes);
         }
 
-        Ok(())
-    }
-
-    /// Reveals storage V2 proof nodes for the given address. This is an internal static function
-    /// designed to handle a variety of associated public functions.
-    fn reveal_storage_v2_proof_nodes_inner(
-        account: B256,
-        mut nodes: Vec<ProofTrieNodeV2>,
-        trie: &mut RevealableSparseTrie<S>,
-        bufs: &mut Vec<Vec<ProofTrieNodeV2>>,
-        retain_updates: bool,
-    ) -> SparseStateTrieResult<usize> {
-        let capacity = estimate_v2_proof_capacity(&nodes);
-        let total_nodes = nodes.len();
-
-        let root_node = nodes.iter().find(|n| n.path.is_empty());
-        let trie = if let Some(root_node) = root_node {
-            trace!(target: "trie::sparse", ?account, ?root_node, "Revealing root storage node from V2 proof");
-            trie.reveal_root(root_node.node.clone(), root_node.masks, retain_updates)?
-        } else {
-            trie.as_revealed_mut().ok_or(SparseTrieErrorKind::Blind)?
-        };
-        trie.reserve_nodes(capacity);
-        trace!(target: "trie::sparse", ?account, total_nodes, "Revealing storage nodes from V2 proof");
-        trie.reveal_nodes(&mut nodes)?;
-
-        bufs.push(nodes);
-        Ok(total_nodes)
+        any_err
     }
 
     /// Wipe the storage trie at the provided address.
@@ -972,15 +893,6 @@ impl<S: SparseTrieTrait + Clone> StorageTries<S> {
             self.cleared_tries.pop().unwrap_or_else(|| self.default_trie.clone())
         })
     }
-
-    /// Takes the storage trie for the account from the internal `HashMap`, creating it if it
-    /// doesn't already exist.
-    #[cfg(feature = "std")]
-    fn take_or_create_trie(&mut self, account: &B256) -> RevealableSparseTrie<S> {
-        self.tries.remove(account).unwrap_or_else(|| {
-            self.cleared_tries.pop().unwrap_or_else(|| self.default_trie.clone())
-        })
-    }
 }
 
 /// Key for identifying a storage slot in the global LFU cache.
@@ -1010,22 +922,6 @@ impl BucketedLfu<HotSlotKey> {
     }
 }
 
-/// Calculates capacity estimation for V2 proof nodes.
-///
-/// This counts nodes and their children (for branch and extension nodes) to provide
-/// proper capacity hints for `reserve_nodes`.
-fn estimate_v2_proof_capacity(nodes: &[ProofTrieNodeV2]) -> usize {
-    let mut capacity = nodes.len();
-
-    for node in nodes {
-        if let TrieNodeV2::Branch(branch) = &node.node {
-            capacity += branch.state_mask.count_ones() as usize;
-        }
-    }
-
-    capacity
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1043,7 +939,7 @@ mod tests {
     use reth_trie_common::{
         proof::{ProofNodes, ProofRetainer},
         BranchNodeMasks, BranchNodeMasksMap, BranchNodeV2, LeafNode, RlpNode, StorageMultiProof,
-        TrieMask,
+        TrieMask, TrieNodeV2,
     };
 
     /// Create a leaf key (suffix) with given nibbles padded with zeros to reach `total_len`.
@@ -1233,7 +1129,12 @@ mod tests {
         ];
 
         // Reveal V2 proof nodes
-        sparse.reveal_account_v2_proof_nodes(v2_proof_nodes).unwrap();
+        sparse
+            .reveal_decoded_multiproof_v2(reth_trie_common::DecodedMultiProofV2 {
+                account_proofs: v2_proof_nodes,
+                ..Default::default()
+            })
+            .unwrap();
 
         // Check that the state trie contains the leaf node and value
         assert!(matches!(
@@ -1278,7 +1179,12 @@ mod tests {
         ];
 
         // Reveal V2 storage proof nodes for account
-        sparse.reveal_storage_v2_proof_nodes(B256::ZERO, v2_proof_nodes).unwrap();
+        sparse
+            .reveal_decoded_multiproof_v2(reth_trie_common::DecodedMultiProofV2 {
+                storage_proofs: B256Map::from_iter([(B256::ZERO, v2_proof_nodes)]),
+                ..Default::default()
+            })
+            .unwrap();
 
         // Check that the storage trie contains the leaf node and value
         assert!(matches!(
diff --git a/crates/trie/sparse/src/trie.rs b/crates/trie/sparse/src/trie.rs
index 2a65d62dec9..f2e947302ba 100644
--- a/crates/trie/sparse/src/trie.rs
+++ b/crates/trie/sparse/src/trie.rs
@@ -2,7 +2,7 @@ use crate::{LeafUpdate, ParallelSparseTrie, SparseTrie as SparseTrieTrait, Spars
 use alloc::{borrow::Cow, boxed::Box, vec::Vec};
 use alloy_primitives::{map::B256Map, B256};
 use reth_execution_errors::{SparseTrieErrorKind, SparseTrieResult};
-use reth_trie_common::{BranchNodeMasks, Nibbles, RlpNode, TrieMask, TrieNodeV2};
+use reth_trie_common::{BranchNodeMasks, Nibbles, ProofTrieNodeV2, RlpNode, TrieMask, TrieNodeV2};
 use tracing::instrument;
 
 /// A sparse trie that is either in a "blind" state (no nodes are revealed, root node hash is
@@ -79,6 +79,47 @@ impl<T: SparseTrieTrait + Default> RevealableSparseTrie<T> {
 
         Ok(self.as_revealed_mut().unwrap())
     }
+
+    /// Reveals a batch of V2 proof nodes into this trie.
+    ///
+    /// If `nodes` contains a node at the empty path it is used to reveal the root (transitioning
+    /// the trie from blind to revealed). Otherwise the trie must already be revealed.
+    ///
+    /// Reserves capacity for the expected number of nodes (including branch children) before
+    /// revealing them.
+    pub fn reveal_v2_proof_nodes(
+        &mut self,
+        nodes: &mut [ProofTrieNodeV2],
+        retain_updates: bool,
+    ) -> SparseTrieResult<()> {
+        let capacity = estimate_v2_proof_capacity(nodes);
+
+        let trie = if let Some(root_node) = nodes.iter().find(|n| n.path.is_empty()) {
+            self.reveal_root(root_node.node.clone(), root_node.masks, retain_updates)?
+        } else {
+            self.as_revealed_mut().ok_or(SparseTrieErrorKind::Blind)?
+        };
+        trie.reserve_nodes(capacity);
+        trie.reveal_nodes(nodes)?;
+
+        Ok(())
+    }
+}
+
+/// Calculates capacity estimation for V2 proof nodes.
+///
+/// This counts nodes and their children (for branch nodes) to provide proper capacity hints for
+/// `reserve_nodes`.
+fn estimate_v2_proof_capacity(nodes: &[ProofTrieNodeV2]) -> usize {
+    let mut capacity = nodes.len();
+
+    for node in nodes {
+        if let TrieNodeV2::Branch(branch) = &node.node {
+            capacity += branch.state_mask.count_ones() as usize;
+        }
+    }
+
+    capacity
 }
 
 impl<T: SparseTrieTrait> RevealableSparseTrie<T> {
diff --git a/crates/trie/trie/src/forward_cursor.rs b/crates/trie/trie/src/forward_cursor.rs
index eafdfbb8ed5..a3114f2c6e5 100644
--- a/crates/trie/trie/src/forward_cursor.rs
+++ b/crates/trie/trie/src/forward_cursor.rs
@@ -44,36 +44,37 @@ impl<'a, K, V> ForwardInMemoryCursor<'a, K, V> {
     pub const fn reset(&mut self) {
         self.idx = 0;
     }
-
-    #[inline]
-    fn next(&mut self) -> Option<&(K, V)> {
-        let entry = self.entries.get(self.idx)?;
-        self.idx += 1;
-        Some(entry)
-    }
 }
 
 /// Threshold for remaining entries above which binary search is used instead of linear scan.
 /// For small slices, linear scan has better cache locality and lower overhead.
-const BINARY_SEARCH_THRESHOLD: usize = 64;
+const BINARY_SEARCH_THRESHOLD: usize = 128;
 
 impl<K: Ord, V> ForwardInMemoryCursor<'_, K, V> {
     /// Returns the first entry from the current cursor position that's greater or equal to the
     /// provided key. This method advances the cursor forward.
     pub fn seek(&mut self, key: &K) -> Option<&(K, V)> {
+        if self.current().is_some_and(|(k, _)| k >= key) {
+            return self.current()
+        }
+
         self.advance_while(|k| k < key)
     }
 
     /// Returns the first entry from the current cursor position that's greater than the provided
     /// key. This method advances the cursor forward.
     pub fn first_after(&mut self, key: &K) -> Option<&(K, V)> {
+        if self.current().is_some_and(|(k, _)| k > key) {
+            return self.current()
+        }
+
         self.advance_while(|k| k <= key)
     }
 
     /// Advances the cursor forward while `predicate` returns `true` or until the collection is
     /// exhausted.
     ///
-    /// Uses binary search for large remaining slices (>= 64 entries), linear scan for small ones.
+    /// Uses binary search for large remaining slices (>= 128 entries), linear scan for small ones.
     ///
     /// Returns the first entry for which `predicate` returns `false` or `None`. The cursor will
     /// point to the returned entry.
@@ -84,8 +85,8 @@ impl<K: Ord, V> ForwardInMemoryCursor<'_, K, V> {
             let pos = slice.partition_point(|(k, _)| predicate(k));
             self.idx += pos;
         } else {
-            while self.current().is_some_and(|(k, _)| predicate(k)) {
-                self.next();
+            while self.idx < self.entries.len() && predicate(&self.entries[self.idx].0) {
+                self.idx += 1;
             }
         }
         self.current()
diff --git a/crates/trie/trie/src/hashed_cursor/post_state.rs b/crates/trie/trie/src/hashed_cursor/post_state.rs
index 9e5bf66990a..3a821d68a66 100644
--- a/crates/trie/trie/src/hashed_cursor/post_state.rs
+++ b/crates/trie/trie/src/hashed_cursor/post_state.rs
@@ -92,22 +92,52 @@ where
 {
     /// The underlying cursor.
     cursor: C,
-    /// Whether the underlying cursor should be ignored (when storage was wiped).
-    cursor_wiped: bool,
-    /// Entry that `database_cursor` is currently pointing to.
-    cursor_entry: Option<(B256, V::NonZero)>,
+    /// Tracks whether the DB cursor is available, positioned, or exhausted.
+    db_cursor_state: DbCursorState<V::NonZero>,
     /// Forward-only in-memory cursor over underlying V.
     post_state_cursor: ForwardInMemoryCursor<'a, B256, V>,
     /// The last hashed key that was returned by the cursor.
     /// De facto, this is a current cursor position.
     last_key: Option<B256>,
-    /// Tracks whether `seek` has been called. Used to prevent re-seeking the DB cursor
-    /// when it has been exhausted by iteration.
+    #[cfg(debug_assertions)]
+    /// Tracks whether `seek` has been called.
     seeked: bool,
     /// Reference to the full post state.
     post_state: &'a HashedPostStateSorted,
 }
 
+#[derive(Debug)]
+enum DbCursorState<V> {
+    NeedsPosition,
+    Positioned((B256, V)),
+    Exhausted,
+    Wiped,
+}
+
+impl<V> DbCursorState<V> {
+    const fn new(cursor_wiped: bool) -> Self {
+        if cursor_wiped {
+            Self::Wiped
+        } else {
+            Self::NeedsPosition
+        }
+    }
+
+    const fn entry(&self) -> Option<&(B256, V)> {
+        match self {
+            Self::Positioned(entry) => Some(entry),
+            Self::NeedsPosition | Self::Exhausted | Self::Wiped => None,
+        }
+    }
+
+    fn set_entry(&mut self, entry: Option<(B256, V)>) {
+        *self = match entry {
+            Some(entry) => Self::Positioned(entry),
+            None => Self::Exhausted,
+        };
+    }
+}
+
 impl<'a, C> HashedPostStateCursor<'a, C, Option<Account>>
 where
     C: HashedCursor<Value = Account>,
@@ -117,10 +147,10 @@ where
         let post_state_cursor = ForwardInMemoryCursor::new(&post_state.accounts);
         Self {
             cursor,
-            cursor_wiped: false,
-            cursor_entry: None,
+            db_cursor_state: DbCursorState::NeedsPosition,
             post_state_cursor,
             last_key: None,
+            #[cfg(debug_assertions)]
             seeked: false,
             post_state,
         }
@@ -142,10 +172,10 @@ where
             Self::get_storage_overlay(post_state, hashed_address);
         Self {
             cursor,
-            cursor_wiped,
-            cursor_entry: None,
+            db_cursor_state: DbCursorState::new(cursor_wiped),
             post_state_cursor,
             last_key: None,
+            #[cfg(debug_assertions)]
             seeked: false,
             post_state,
         }
@@ -171,7 +201,7 @@ where
 {
     /// Returns a mutable reference to the underlying cursor if it's not wiped, None otherwise.
     fn get_cursor_mut(&mut self) -> Option<&mut C> {
-        (!self.cursor_wiped).then_some(&mut self.cursor)
+        (!matches!(self.db_cursor_state, DbCursorState::Wiped)).then_some(&mut self.cursor)
     }
 
     /// Asserts that the next entry to be returned from the cursor is not previous to the last entry
@@ -187,31 +217,36 @@ where
         self.last_key = next_key;
     }
 
-    /// Seeks the `cursor_entry` field of the struct using the cursor.
+    /// Positions the DB cursor state using the underlying cursor when needed.
     fn cursor_seek(&mut self, key: B256) -> Result<(), DatabaseError> {
         // Only seek if:
         // 1. We have a cursor entry and need to seek forward (entry.0 < key), OR
-        // 2. We have no cursor entry and haven't seeked yet (!self.seeked)
-        let should_seek = match self.cursor_entry.as_ref() {
-            Some(entry) => entry.0 < key,
-            None => !self.seeked,
+        // 2. The DB cursor needs to be positioned.
+        let should_seek = match &self.db_cursor_state {
+            DbCursorState::NeedsPosition => true,
+            DbCursorState::Positioned((entry_key, _)) => entry_key < &key,
+            DbCursorState::Exhausted | DbCursorState::Wiped => false,
         };
 
         if should_seek {
-            self.cursor_entry = self.get_cursor_mut().map(|c| c.seek(key)).transpose()?.flatten();
+            let entry = self.get_cursor_mut().map(|c| c.seek(key)).transpose()?.flatten();
+            self.db_cursor_state.set_entry(entry);
         }
 
         Ok(())
     }
 
-    /// Seeks the `cursor_entry` field of the struct to the subsequent entry using the cursor.
+    /// Advances the DB cursor state to the subsequent entry using the underlying cursor.
     fn cursor_next(&mut self) -> Result<(), DatabaseError> {
-        debug_assert!(self.seeked);
+        #[cfg(debug_assertions)]
+        {
+            debug_assert!(self.seeked);
+        }
 
-        // If the previous entry is `None`, and we've done a seek previously, then the cursor is
-        // exhausted, and we shouldn't call `next` again.
-        if self.cursor_entry.is_some() {
-            self.cursor_entry = self.get_cursor_mut().map(|c| c.next()).transpose()?.flatten();
+        // Exhausted DB state is stable; only advance when the DB cursor is positioned at an entry.
+        if matches!(self.db_cursor_state, DbCursorState::Positioned(_)) {
+            let entry = self.get_cursor_mut().map(|c| c.next()).transpose()?.flatten();
+            self.db_cursor_state.set_entry(entry);
         }
 
         Ok(())
@@ -226,10 +261,11 @@ where
         loop {
             let post_state_current =
                 self.post_state_cursor.current().copied().map(|(k, v)| (k, v.into_option()));
+            let db_entry = self.db_cursor_state.entry();
 
-            match (post_state_current, &self.cursor_entry) {
+            match (post_state_current, db_entry) {
                 (Some((mem_key, None)), _)
-                    if self.cursor_entry.as_ref().is_none_or(|(db_key, _)| &mem_key < db_key) =>
+                    if db_entry.is_none_or(|(db_key, _)| &mem_key < db_key) =>
                 {
                     // If overlay has a removed value but DB cursor is exhausted or ahead of the
                     // in-memory cursor then move ahead in-memory, as there might be further
@@ -243,7 +279,7 @@ where
                     self.cursor_next()?;
                 }
                 (Some((mem_key, Some(value))), _)
-                    if self.cursor_entry.as_ref().is_none_or(|(db_key, _)| &mem_key <= db_key) =>
+                    if db_entry.is_none_or(|(db_key, _)| &mem_key <= db_key) =>
                 {
                     // If overlay returns a value prior to the DB's value, or the DB is exhausted,
                     // then we return the overlay's value.
@@ -253,7 +289,7 @@ where
                 // - mem_key > db_key
                 // - overlay is exhausted
                 // Return the db_entry. If DB is also exhausted then this returns None.
-                _ => return Ok(self.cursor_entry),
+                _ => return Ok(db_entry.copied()),
             }
         }
     }
@@ -275,10 +311,35 @@ where
     /// The returned account key is memoized and the cursor remains positioned at that key until
     /// [`HashedCursor::seek`] or [`HashedCursor::next`] are called.
     fn seek(&mut self, key: B256) -> Result<Option<(B256, Self::Value)>, DatabaseError> {
+        let post_state_entry =
+            self.post_state_cursor.seek(&key).copied().map(|(k, v)| (k, v.into_option()));
+
+        if let Some((mem_key, Some(value))) = post_state_entry &&
+            mem_key == key
+        {
+            #[cfg(debug_assertions)]
+            {
+                self.seeked = true;
+            }
+
+            // An exact overlay hit is the first logical entry at or after `key`, so the DB cursor
+            // can stay lazy until a later operation needs it.
+            if matches!(&self.db_cursor_state, DbCursorState::Positioned((db_key, _)) if db_key < &key)
+            {
+                self.db_cursor_state = DbCursorState::NeedsPosition;
+            }
+
+            let entry = Some((key, value));
+            self.set_last_key(&entry);
+            return Ok(entry)
+        }
+
         self.cursor_seek(key)?;
-        self.post_state_cursor.seek(&key);
 
-        self.seeked = true;
+        #[cfg(debug_assertions)]
+        {
+            self.seeked = true;
+        }
 
         let entry = self.choose_next_entry()?;
         self.set_last_key(&entry);
@@ -292,7 +353,10 @@ where
     ///
     /// NOTE: This function will not return any entry unless [`HashedCursor::seek`] has been called.
     fn next(&mut self) -> Result<Option<(B256, Self::Value)>, DatabaseError> {
-        debug_assert!(self.seeked, "Cursor must be seek'd before next is called");
+        #[cfg(debug_assertions)]
+        {
+            debug_assert!(self.seeked, "Cursor must be seek'd before next is called");
+        }
 
         // A `last_key` of `None` indicates that the cursor is exhausted.
         let Some(last_key) = self.last_key else {
@@ -307,7 +371,11 @@ where
             self.post_state_cursor.first_after(&last_key);
         }
 
-        if let Some((key, _)) = &self.cursor_entry &&
+        if matches!(self.db_cursor_state, DbCursorState::NeedsPosition) {
+            self.cursor_seek(last_key)?;
+        }
+
+        if let Some((key, _)) = self.db_cursor_state.entry() &&
             key == &last_key
         {
             self.cursor_next()?;
@@ -319,23 +387,17 @@ where
     }
 
     fn reset(&mut self) {
-        let Self {
-            cursor,
-            cursor_wiped,
-            cursor_entry,
-            post_state_cursor,
-            last_key,
-            seeked,
-            post_state: _,
-        } = self;
+        let Self { cursor, db_cursor_state, post_state_cursor, last_key, .. } = self;
 
         cursor.reset();
         post_state_cursor.reset();
 
-        *cursor_wiped = false;
-        *cursor_entry = None;
+        *db_cursor_state = DbCursorState::NeedsPosition;
         *last_key = None;
-        *seeked = false;
+        #[cfg(debug_assertions)]
+        {
+            self.seeked = false;
+        }
     }
 }
 
@@ -363,8 +425,10 @@ where
     fn set_hashed_address(&mut self, hashed_address: B256) {
         self.reset();
         self.cursor.set_hashed_address(hashed_address);
-        (self.post_state_cursor, self.cursor_wiped) =
+        let (post_state_cursor, cursor_wiped) =
             HashedPostStateCursor::<C, U256>::get_storage_overlay(self.post_state, hashed_address);
+        self.post_state_cursor = post_state_cursor;
+        self.db_cursor_state = DbCursorState::new(cursor_wiped);
     }
 }
 
@@ -375,6 +439,82 @@ mod tests {
     use parking_lot::Mutex;
     use std::{collections::BTreeMap, sync::Arc};
 
+    fn key(byte: u8) -> B256 {
+        B256::repeat_byte(byte)
+    }
+
+    fn storage_post_state(storage_slots: Vec<(B256, U256)>) -> HashedPostStateSorted {
+        let storage_sorted = reth_trie_common::HashedStorageSorted { storage_slots, wiped: false };
+        let mut storages = alloy_primitives::map::B256Map::default();
+        storages.insert(B256::ZERO, storage_sorted);
+        HashedPostStateSorted::new(Vec::new(), storages)
+    }
+
+    #[test]
+    fn test_seek_overlay_exact_hit_does_not_touch_db_until_next() {
+        let db_nodes = vec![(key(0x02), U256::from(2)), (key(0x03), U256::from(3))];
+        let post_state_nodes = vec![(key(0x02), U256::from(42))];
+
+        let db_nodes_map: BTreeMap<B256, U256> = db_nodes.into_iter().collect();
+        let db_nodes_arc = Arc::new(db_nodes_map);
+        let visited_keys = Arc::new(Mutex::new(Vec::new()));
+        let mock_cursor = MockHashedCursor::new(db_nodes_arc, visited_keys.clone());
+
+        let post_state = storage_post_state(post_state_nodes);
+        let mut cursor = HashedPostStateCursor::new_storage(mock_cursor, &post_state, B256::ZERO);
+
+        let result = cursor.seek(key(0x02)).unwrap();
+        assert_eq!(result, Some((key(0x02), U256::from(42))));
+        assert!(visited_keys.lock().is_empty(), "exact overlay hit should not touch the DB cursor");
+
+        let result = cursor.next().unwrap();
+        assert_eq!(result, Some((key(0x03), U256::from(3))));
+        assert!(!visited_keys.lock().is_empty(), "next should lazily position the DB cursor");
+    }
+
+    #[test]
+    fn test_seek_overlay_exact_hit_repositions_stale_db_on_next() {
+        let db_nodes = vec![(key(0x01), U256::from(1)), (key(0x03), U256::from(3))];
+        let post_state_nodes = vec![(key(0x02), U256::from(2))];
+
+        let db_nodes_map: BTreeMap<B256, U256> = db_nodes.into_iter().collect();
+        let db_nodes_arc = Arc::new(db_nodes_map);
+        let visited_keys = Arc::new(Mutex::new(Vec::new()));
+        let mock_cursor = MockHashedCursor::new(db_nodes_arc, visited_keys.clone());
+
+        let post_state = storage_post_state(post_state_nodes);
+        let mut cursor = HashedPostStateCursor::new_storage(mock_cursor, &post_state, B256::ZERO);
+
+        let result = cursor.seek(key(0x01)).unwrap();
+        assert_eq!(result, Some((key(0x01), U256::from(1))));
+        assert_eq!(visited_keys.lock().len(), 1);
+
+        let result = cursor.seek(key(0x02)).unwrap();
+        assert_eq!(result, Some((key(0x02), U256::from(2))));
+        assert_eq!(visited_keys.lock().len(), 1, "exact overlay hit should not seek the DB");
+
+        let result = cursor.next().unwrap();
+        assert_eq!(result, Some((key(0x03), U256::from(3))));
+    }
+
+    #[test]
+    fn test_seek_overlay_exact_deletion_still_seeks_db() {
+        let db_nodes = vec![(key(0x02), U256::from(2)), (key(0x03), U256::from(3))];
+        let post_state_nodes = vec![(key(0x02), U256::ZERO)];
+
+        let db_nodes_map: BTreeMap<B256, U256> = db_nodes.into_iter().collect();
+        let db_nodes_arc = Arc::new(db_nodes_map);
+        let visited_keys = Arc::new(Mutex::new(Vec::new()));
+        let mock_cursor = MockHashedCursor::new(db_nodes_arc, visited_keys.clone());
+
+        let post_state = storage_post_state(post_state_nodes);
+        let mut cursor = HashedPostStateCursor::new_storage(mock_cursor, &post_state, B256::ZERO);
+
+        let result = cursor.seek(key(0x02)).unwrap();
+        assert_eq!(result, Some((key(0x03), U256::from(3))));
+        assert!(!visited_keys.lock().is_empty(), "exact overlay deletion should consult the DB");
+    }
+
     mod proptest_tests {
         use super::*;
         use itertools::Itertools;
diff --git a/crates/trie/trie/src/proof_v2/mod.rs b/crates/trie/trie/src/proof_v2/mod.rs
index db52a0e6bda..7a8cd904a89 100644
--- a/crates/trie/trie/src/proof_v2/mod.rs
+++ b/crates/trie/trie/src/proof_v2/mod.rs
@@ -365,18 +365,15 @@ where
         &mut self,
         targets: &mut Option<TargetsCursor<'a>>,
     ) -> Result<(), StateProofError> {
+        if matches!(self.child_stack.last(), Some(ProofTrieBranchChild::RlpNode(_))) {
+            trace!(target: TRACE_TARGET, "Last child already committed, leaving stack unchanged");
+            return Ok(())
+        }
+
         let Some(child_path) = self.last_child_path() else { return Ok(()) };
         let child =
             self.child_stack.pop().expect("child_stack can't be empty if there's a child path");
 
-        // If the child is already an `RlpNode` then there is nothing to do, push it back on with no
-        // changes.
-        if let ProofTrieBranchChild::RlpNode(_rlp_node) = &child {
-            trace!(target: TRACE_TARGET, ?_rlp_node, "Already RlpNode, pushing onto stack");
-            self.child_stack.push(child);
-            return Ok(())
-        }
-
         // Only commit immediately if retained for the proof. Otherwise, defer conversion
         // to pop_branch() to give DeferredEncoder time for async work.
         if self.should_retain(targets, &child_path, true) {
@@ -538,6 +535,7 @@ where
         );
 
         // Collect children into RlpNode Vec. Children are in lexicographic order.
+        rlp_nodes_buf.reserve(num_children);
         for child in self.child_stack.drain(self.child_stack.len() - num_children..) {
             let child_rlp_node = match child {
                 ProofTrieBranchChild::RlpNode(rlp_node) => rlp_node,
@@ -557,7 +555,7 @@ where
 
         debug_assert_eq!(
             rlp_nodes_buf.len(),
-            branch.state_mask.count_ones() as usize,
+            num_children,
             "children length must match number of bits set in state_mask"
         );
 
diff --git a/crates/trie/trie/src/trie_cursor/in_memory.rs b/crates/trie/trie/src/trie_cursor/in_memory.rs
index 5fde874017e..d2316ac27a2 100644
--- a/crates/trie/trie/src/trie_cursor/in_memory.rs
+++ b/crates/trie/trie/src/trie_cursor/in_memory.rs
@@ -293,8 +293,29 @@ impl<C: TrieCursor> TrieCursor for InMemoryTrieCursor<'_, C> {
         &mut self,
         key: Nibbles,
     ) -> Result<Option<(Nibbles, BranchNodeCompact)>, DatabaseError> {
+        let mem_entry = self.in_memory_cursor.seek(&key);
+
+        if let Some((mem_key, Some(node))) = mem_entry &&
+            *mem_key == key
+        {
+            #[cfg(debug_assertions)]
+            {
+                self.seeked = true;
+            }
+
+            // An exact overlay hit is the first logical entry at or after `key`, so the DB cursor
+            // can stay lazy until a later operation needs it.
+            if matches!(&self.db_cursor_state, DbCursorState::Positioned((db_key, _)) if db_key < &key)
+            {
+                self.db_cursor_state = DbCursorState::NeedsPosition;
+            }
+
+            let entry = Some((key, node.clone()));
+            self.set_last_key(&entry);
+            return Ok(entry)
+        }
+
         self.cursor_seek(key)?;
-        self.in_memory_cursor.seek(&key);
 
         #[cfg(debug_assertions)]
         {
@@ -602,6 +623,97 @@ mod tests {
         assert_eq!(result, None);
     }
 
+    #[test]
+    fn test_seek_overlay_exact_hit_does_not_touch_db_until_next() {
+        let db_nodes = vec![
+            (Nibbles::from_nibbles([0x2]), BranchNodeCompact::new(0b0010, 0b0010, 0, vec![], None)),
+            (Nibbles::from_nibbles([0x3]), BranchNodeCompact::new(0b0011, 0b0011, 0, vec![], None)),
+        ];
+
+        let in_memory_nodes = vec![(
+            Nibbles::from_nibbles([0x2]),
+            Some(BranchNodeCompact::new(0b1111, 0b1111, 0, vec![], None)),
+        )];
+
+        let db_nodes_map: BTreeMap<Nibbles, BranchNodeCompact> = db_nodes.into_iter().collect();
+        let db_nodes_arc = Arc::new(db_nodes_map);
+        let visited_keys = Arc::new(Mutex::new(Vec::new()));
+        let mock_cursor = MockTrieCursor::new(db_nodes_arc, visited_keys.clone());
+
+        let trie_updates = TrieUpdatesSorted::new(in_memory_nodes, Default::default());
+        let mut cursor = InMemoryTrieCursor::new_account(mock_cursor, &trie_updates);
+
+        let result = cursor.seek(Nibbles::from_nibbles([0x2])).unwrap();
+        assert_eq!(
+            result,
+            Some((
+                Nibbles::from_nibbles([0x2]),
+                BranchNodeCompact::new(0b1111, 0b1111, 0, vec![], None)
+            ))
+        );
+        assert!(visited_keys.lock().is_empty(), "exact overlay hit should not touch the DB cursor");
+
+        let result = cursor.next().unwrap();
+        assert_eq!(
+            result,
+            Some((
+                Nibbles::from_nibbles([0x3]),
+                BranchNodeCompact::new(0b0011, 0b0011, 0, vec![], None)
+            ))
+        );
+        assert!(!visited_keys.lock().is_empty(), "next should lazily position the DB cursor");
+    }
+
+    #[test]
+    fn test_seek_overlay_exact_hit_repositions_stale_db_on_next() {
+        let db_nodes = vec![
+            (Nibbles::from_nibbles([0x1]), BranchNodeCompact::new(0b0001, 0b0001, 0, vec![], None)),
+            (Nibbles::from_nibbles([0x3]), BranchNodeCompact::new(0b0011, 0b0011, 0, vec![], None)),
+        ];
+
+        let in_memory_nodes = vec![(
+            Nibbles::from_nibbles([0x2]),
+            Some(BranchNodeCompact::new(0b0010, 0b0010, 0, vec![], None)),
+        )];
+
+        let db_nodes_map: BTreeMap<Nibbles, BranchNodeCompact> = db_nodes.into_iter().collect();
+        let db_nodes_arc = Arc::new(db_nodes_map);
+        let visited_keys = Arc::new(Mutex::new(Vec::new()));
+        let mock_cursor = MockTrieCursor::new(db_nodes_arc, visited_keys.clone());
+
+        let trie_updates = TrieUpdatesSorted::new(in_memory_nodes, Default::default());
+        let mut cursor = InMemoryTrieCursor::new_account(mock_cursor, &trie_updates);
+
+        let result = cursor.seek(Nibbles::from_nibbles([0x1])).unwrap();
+        assert_eq!(
+            result,
+            Some((
+                Nibbles::from_nibbles([0x1]),
+                BranchNodeCompact::new(0b0001, 0b0001, 0, vec![], None)
+            ))
+        );
+        assert_eq!(visited_keys.lock().len(), 1);
+
+        let result = cursor.seek(Nibbles::from_nibbles([0x2])).unwrap();
+        assert_eq!(
+            result,
+            Some((
+                Nibbles::from_nibbles([0x2]),
+                BranchNodeCompact::new(0b0010, 0b0010, 0, vec![], None)
+            ))
+        );
+        assert_eq!(visited_keys.lock().len(), 1, "exact overlay hit should not seek the DB");
+
+        let result = cursor.next().unwrap();
+        assert_eq!(
+            result,
+            Some((
+                Nibbles::from_nibbles([0x3]),
+                BranchNodeCompact::new(0b0011, 0b0011, 0, vec![], None)
+            ))
+        );
+    }
+
     #[test]
     fn test_multiple_consecutive_deletes() {
         let db_nodes: Vec<(Nibbles, BranchNodeCompact)> = (1..=10)
diff --git a/deny.toml b/deny.toml
index 7f792c3016f..0d2486046ba 100644
--- a/deny.toml
+++ b/deny.toml
@@ -16,6 +16,15 @@ ignore = [
     "RUSTSEC-2026-0002",
     # https://rustsec.org/advisories/RUSTSEC-2026-0097 rand is unsound with a custom logger
     "RUSTSEC-2026-0097",
+    # https://rustsec.org/advisories/RUSTSEC-2026-0173 proc-macro-error2 is unmaintained
+    "RUSTSEC-2026-0173",
+    # https://rustsec.org/advisories/RUSTSEC-2026-0118 vulnerable DnssecDnsHandle code was
+    # moved from hickory-proto to hickory-net in 0.26.0; we use hickory-net 0.26.1 which has
+    # the fix, and no patched hickory-proto release exists
+    "RUSTSEC-2026-0118",
+    # https://rustsec.org/advisories/RUSTSEC-2026-0173 proc-macro-error2 is unmaintained
+    # and is pulled in transitively by upstream crates with no safe upgrade available.
+    "RUSTSEC-2026-0173",
 ]
 
 # This section is considered when running `cargo deny check bans`.
diff --git a/docs/cli/help.rs b/docs/cli/help.rs
index 5fc67ed42f1..c8806340bef 100755
--- a/docs/cli/help.rs
+++ b/docs/cli/help.rs
@@ -414,7 +414,7 @@ fn generate_sidebar_ts(
         _ => "cliSidebar",
     };
 
-    let mut ts_code = String::from("import { SidebarItem } from \"vocs\";\n\n");
+    let mut ts_code = String::from("import type { SidebarItem } from \"./types\";\n\n");
     ts_code.push_str(&format!("export const {}: SidebarItem = {{\n", var_name));
     ts_code.push_str(&format!("    text: \"{}\",\n", root_name));
     ts_code.push_str(&format!("    link: \"/cli/{}\",\n", root_name));
diff --git a/docs/vocs/bun.lock b/docs/vocs/bun.lock
index 0817326dc32..9567e477fc0 100644
--- a/docs/vocs/bun.lock
+++ b/docs/vocs/bun.lock
@@ -1,29 +1,28 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "vocs",
       "dependencies": {
-        "react": "^19.2.5",
-        "react-dom": "^19.2.5",
-        "vocs": "~1.0.13",
+        "mermaid": "^11",
+        "react": "19.2.6",
+        "react-dom": "19.2.6",
+        "react-server-dom-webpack": "19.2.6",
+        "vocs": "^2.0.11",
+        "waku": "1.0.0-beta.0",
       },
       "devDependencies": {
         "@types/node": "^24.12.2",
         "@types/react": "^19.2.14",
         "glob": "^11.1.0",
         "typescript": "^5.9.3",
+        "vite": "^8.0.16",
       },
     },
   },
   "packages": {
-    "@ampproject/remapping": ["@ampproject/remapping@2.3.0", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw=="],
-
     "@antfu/install-pkg": ["@antfu/install-pkg@1.1.0", "", { "dependencies": { "package-manager-detector": "^1.3.0", "tinyexec": "^1.0.1" } }, "sha512-MGQsmw10ZyI+EJo45CdSER4zEb+p31LpDAFp2Z3gkSd1yqVZGi0Ebx++YTEMonJy4oChEMLsxZ64j8FH6sSqtQ=="],
 
-    "@antfu/utils": ["@antfu/utils@8.1.1", "", {}, "sha512-Mex9nXf9vR6AhcXmMrlz/HVgYYZpVGJ6YlPgwl7UnaFpnshXs6EK/oa5Gpf3CzENMjkvEx2tQtntGnb7UtSTOQ=="],
-
     "@babel/code-frame": ["@babel/code-frame@7.29.0", "", { "dependencies": { "@babel/helper-validator-identifier": "^7.28.5", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" } }, "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw=="],
 
     "@babel/compat-data": ["@babel/compat-data@7.29.0", "", {}, "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg=="],
@@ -40,8 +39,6 @@
 
     "@babel/helper-module-transforms": ["@babel/helper-module-transforms@7.28.6", "", { "dependencies": { "@babel/helper-module-imports": "^7.28.6", "@babel/helper-validator-identifier": "^7.28.5", "@babel/traverse": "^7.28.6" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA=="],
 
-    "@babel/helper-plugin-utils": ["@babel/helper-plugin-utils@7.27.1", "", {}, "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw=="],
-
     "@babel/helper-string-parser": ["@babel/helper-string-parser@7.27.1", "", {}, "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA=="],
 
     "@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.28.5", "", {}, "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q=="],
@@ -52,13 +49,7 @@
 
     "@babel/parser": ["@babel/parser@7.29.2", "", { "dependencies": { "@babel/types": "^7.29.0" }, "bin": "./bin/babel-parser.js" }, "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA=="],
 
-    "@babel/plugin-syntax-typescript": ["@babel/plugin-syntax-typescript@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ=="],
-
-    "@babel/plugin-transform-react-jsx-self": ["@babel/plugin-transform-react-jsx-self@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw=="],
-
-    "@babel/plugin-transform-react-jsx-source": ["@babel/plugin-transform-react-jsx-source@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw=="],
-
-    "@babel/runtime": ["@babel/runtime@7.27.6", "", {}, "sha512-vbavdySgbTTrmFE+EsiqUTzlOr5bzlnJtUv9PynGCAKvfQqjIXbvFdumPM/GxMDfyuGMJaJAU6TO4zc1Jf1i8Q=="],
+    "@babel/runtime": ["@babel/runtime@7.29.7", "", {}, "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw=="],
 
     "@babel/template": ["@babel/template@7.28.6", "", { "dependencies": { "@babel/code-frame": "^7.28.6", "@babel/parser": "^7.28.6", "@babel/types": "^7.28.6" } }, "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ=="],
 
@@ -66,247 +57,197 @@
 
     "@babel/types": ["@babel/types@7.29.0", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.28.5" } }, "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A=="],
 
-    "@braintree/sanitize-url": ["@braintree/sanitize-url@7.1.1", "", {}, "sha512-i1L7noDNxtFyL5DmZafWy1wRVhGehQmzZaz1HiN5e7iylJMSZR7ekOV7NsIqa5qBldlLrsKv4HbgFUVlQrz8Mw=="],
-
-    "@chevrotain/cst-dts-gen": ["@chevrotain/cst-dts-gen@11.0.3", "", { "dependencies": { "@chevrotain/gast": "11.0.3", "@chevrotain/types": "11.0.3", "lodash-es": "4.17.21" } }, "sha512-BvIKpRLeS/8UbfxXxgC33xOumsacaeCKAjAeLyOn7Pcp95HiRbrpl14S+9vaZLolnbssPIUuiUd8IvgkRyt6NQ=="],
-
-    "@chevrotain/gast": ["@chevrotain/gast@11.0.3", "", { "dependencies": { "@chevrotain/types": "11.0.3", "lodash-es": "4.17.21" } }, "sha512-+qNfcoNk70PyS/uxmj3li5NiECO+2YKZZQMbmjTqRI3Qchu8Hig/Q9vgkHpI3alNjr7M+a2St5pw5w5F6NL5/Q=="],
-
-    "@chevrotain/regexp-to-ast": ["@chevrotain/regexp-to-ast@11.0.3", "", {}, "sha512-1fMHaBZxLFvWI067AVbGJav1eRY7N8DDvYCTwGBiE/ytKBgP8azTdgyrKyWZ9Mfh09eHWb5PgTSO8wi7U824RA=="],
-
-    "@chevrotain/types": ["@chevrotain/types@11.0.3", "", {}, "sha512-gsiM3G8b58kZC2HaWR50gu6Y1440cHiJ+i3JUvcp/35JchYejb2+5MVeJK0iKThYpAa/P2PYFV4hoi44HD+aHQ=="],
-
-    "@chevrotain/utils": ["@chevrotain/utils@11.0.3", "", {}, "sha512-YslZMgtJUyuMbZ+aKvfF3x1f5liK4mWNxghFRv7jqRR9C3R3fAOGTTKvxXDa2Y1s9zSbcpuO0cAxDYsc9SrXoQ=="],
+    "@base-ui/react": ["@base-ui/react@1.5.0", "", { "dependencies": { "@babel/runtime": "^7.29.2", "@base-ui/utils": "0.2.9", "@floating-ui/react-dom": "^2.1.8", "@floating-ui/utils": "^0.2.11", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "@date-fns/tz": "^1.2.0", "@types/react": "^17 || ^18 || ^19", "date-fns": "^4.0.0", "react": "^17 || ^18 || ^19", "react-dom": "^17 || ^18 || ^19" }, "optionalPeers": ["@date-fns/tz", "@types/react", "date-fns"] }, "sha512-z1gSAlced1yY+iM+mHDEtIkD8UI3Ebs52MuBPxvV6f5hRutk+xvCH/wuB7hDqDzK9JG5FoMz5nhrqtSs1wjt1A=="],
 
-    "@clack/core": ["@clack/core@0.3.5", "", { "dependencies": { "picocolors": "^1.0.0", "sisteransi": "^1.0.5" } }, "sha512-5cfhQNH+1VQ2xLQlmzXMqUoiaH0lRBq9/CLW9lTyMbuKLC3+xEK01tHVvyut++mLOn5urSHmkm6I0Lg9MaJSTQ=="],
+    "@base-ui/utils": ["@base-ui/utils@0.2.9", "", { "dependencies": { "@babel/runtime": "^7.29.2", "@floating-ui/utils": "^0.2.11", "reselect": "^5.1.1", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "@types/react": "^17 || ^18 || ^19", "react": "^17 || ^18 || ^19", "react-dom": "^17 || ^18 || ^19" }, "optionalPeers": ["@types/react"] }, "sha512-x/PDDCYzoqPpjrdyb3VcyylTI2IjUXEtYDGi5foh7KsnmNJIIaVwA2GLgDH1dps1GgXiJbA60hM+AyuTfQzIvw=="],
 
-    "@clack/prompts": ["@clack/prompts@0.7.0", "", { "dependencies": { "@clack/core": "^0.3.3", "is-unicode-supported": "*", "picocolors": "^1.0.0", "sisteransi": "^1.0.5" } }, "sha512-0MhX9/B4iL6Re04jPrttDm+BsP8y6mS7byuv0BvXgdXhbV5PdlsHt55dvNsuBCPZ7xq1oTAOOuotR9NFbQyMSA=="],
+    "@braintree/sanitize-url": ["@braintree/sanitize-url@7.1.2", "", {}, "sha512-jigsZK+sMF/cuiB7sERuo9V7N9jx+dhmHHnQyDSVdpZwVutaBu7WvNYqMDLSgFgfB30n452TP3vjDAvFC973mA=="],
 
-    "@emotion/hash": ["@emotion/hash@0.9.2", "", {}, "sha512-MyqliTZGuOm3+5ZRSaaBGP3USLw6+EGykkwZns2EPC5g8jJ4z9OrdZY9apkl3+UP9+sdz76YYkwCKP5gh8iY3g=="],
+    "@chevrotain/types": ["@chevrotain/types@11.1.2", "", {}, "sha512-U+HFai5+zmJCkK86QsaJtoITlboZHBqrVketcO2ROv865xfCMSFpELQoz1GkX5GzME8pTa+3kbKrZHQtI0gdbw=="],
 
-    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.6", "", { "os": "aix", "cpu": "ppc64" }, "sha512-ShbM/3XxwuxjFiuVBHA+d3j5dyac0aEVVq1oluIDf71hUw0aRF59dV/efUsIwFnR6m8JNM2FjZOzmaZ8yG61kw=="],
+    "@codemirror/autocomplete": ["@codemirror/autocomplete@6.20.3", "", { "dependencies": { "@codemirror/language": "^6.0.0", "@codemirror/state": "^6.0.0", "@codemirror/view": "^6.17.0", "@lezer/common": "^1.0.0" } }, "sha512-tlosUqb+3BbxCxZdu4tKeRghPFC+QM7q4X5YhKV2eCmPG+1r2F3f4AaSz5sCrFqUtX4Jh20VFTKecl16MgiV9g=="],
 
-    "@esbuild/android-arm": ["@esbuild/android-arm@0.25.6", "", { "os": "android", "cpu": "arm" }, "sha512-S8ToEOVfg++AU/bHwdksHNnyLyVM+eMVAOf6yRKFitnwnbwwPNqKr3srzFRe7nzV69RQKb5DgchIX5pt3L53xg=="],
+    "@codemirror/commands": ["@codemirror/commands@6.10.3", "", { "dependencies": { "@codemirror/language": "^6.0.0", "@codemirror/state": "^6.6.0", "@codemirror/view": "^6.27.0", "@lezer/common": "^1.1.0" } }, "sha512-JFRiqhKu+bvSkDLI+rUhJwSxQxYb759W5GBezE8Uc8mHLqC9aV/9aTC7yJSqCtB3F00pylrLCwnyS91Ap5ej4Q=="],
 
-    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.6", "", { "os": "android", "cpu": "arm64" }, "sha512-hd5zdUarsK6strW+3Wxi5qWws+rJhCCbMiC9QZyzoxfk5uHRIE8T287giQxzVpEvCwuJ9Qjg6bEjcRJcgfLqoA=="],
+    "@codemirror/lang-css": ["@codemirror/lang-css@6.3.1", "", { "dependencies": { "@codemirror/autocomplete": "^6.0.0", "@codemirror/language": "^6.0.0", "@codemirror/state": "^6.0.0", "@lezer/common": "^1.0.2", "@lezer/css": "^1.1.7" } }, "sha512-kr5fwBGiGtmz6l0LSJIbno9QrifNMUusivHbnA1H6Dmqy4HZFte3UAICix1VuKo0lMPKQr2rqB+0BkKi/S3Ejg=="],
 
-    "@esbuild/android-x64": ["@esbuild/android-x64@0.25.6", "", { "os": "android", "cpu": "x64" }, "sha512-0Z7KpHSr3VBIO9A/1wcT3NTy7EB4oNC4upJ5ye3R7taCc2GUdeynSLArnon5G8scPwaU866d3H4BCrE5xLW25A=="],
+    "@codemirror/lang-html": ["@codemirror/lang-html@6.4.11", "", { "dependencies": { "@codemirror/autocomplete": "^6.0.0", "@codemirror/lang-css": "^6.0.0", "@codemirror/lang-javascript": "^6.0.0", "@codemirror/language": "^6.4.0", "@codemirror/state": "^6.0.0", "@codemirror/view": "^6.17.0", "@lezer/common": "^1.0.0", "@lezer/css": "^1.1.0", "@lezer/html": "^1.3.12" } }, "sha512-9NsXp7Nwp891pQchI7gPdTwBuSuT3K65NGTHWHNJ55HjYcHLllr0rbIZNdOzas9ztc1EUVBlHou85FFZS4BNnw=="],
 
-    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.6", "", { "os": "darwin", "cpu": "arm64" }, "sha512-FFCssz3XBavjxcFxKsGy2DYK5VSvJqa6y5HXljKzhRZ87LvEi13brPrf/wdyl/BbpbMKJNOr1Sd0jtW4Ge1pAA=="],
+    "@codemirror/lang-javascript": ["@codemirror/lang-javascript@6.2.5", "", { "dependencies": { "@codemirror/autocomplete": "^6.0.0", "@codemirror/language": "^6.6.0", "@codemirror/lint": "^6.0.0", "@codemirror/state": "^6.0.0", "@codemirror/view": "^6.17.0", "@lezer/common": "^1.0.0", "@lezer/javascript": "^1.0.0" } }, "sha512-zD4e5mS+50htS7F+TYjBPsiIFGanfVqg4HyUz6WNFikgOPf2BgKlx+TQedI1w6n/IqRBVBbBWmGFdLB/7uxO4A=="],
 
-    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.6", "", { "os": "darwin", "cpu": "x64" }, "sha512-GfXs5kry/TkGM2vKqK2oyiLFygJRqKVhawu3+DOCk7OxLy/6jYkWXhlHwOoTb0WqGnWGAS7sooxbZowy+pK9Yg=="],
+    "@codemirror/language": ["@codemirror/language@6.12.3", "", { "dependencies": { "@codemirror/state": "^6.0.0", "@codemirror/view": "^6.23.0", "@lezer/common": "^1.5.0", "@lezer/highlight": "^1.0.0", "@lezer/lr": "^1.0.0", "style-mod": "^4.0.0" } }, "sha512-QwCZW6Tt1siP37Jet9Tb02Zs81TQt6qQrZR2H+eGMcFsL1zMrk2/b9CLC7/9ieP1fjIUMgviLWMmgiHoJrj+ZA=="],
 
-    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.6", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-aoLF2c3OvDn2XDTRvn8hN6DRzVVpDlj2B/F66clWd/FHLiHaG3aVZjxQX2DYphA5y/evbdGvC6Us13tvyt4pWg=="],
+    "@codemirror/lint": ["@codemirror/lint@6.9.6", "", { "dependencies": { "@codemirror/state": "^6.0.0", "@codemirror/view": "^6.42.0", "crelt": "^1.0.5" } }, "sha512-6Kp7r6XfCi/D/5sdXieMfg9pJU1bUEx96WITuLU6ESaKizCz0QHFMjY/TaFSbigDdEAIgi93itLBIUETP4oK+A=="],
 
-    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.6", "", { "os": "freebsd", "cpu": "x64" }, "sha512-2SkqTjTSo2dYi/jzFbU9Plt1vk0+nNg8YC8rOXXea+iA3hfNJWebKYPs3xnOUf9+ZWhKAaxnQNUf2X9LOpeiMQ=="],
+    "@codemirror/state": ["@codemirror/state@6.6.0", "", { "dependencies": { "@marijn/find-cluster-break": "^1.0.0" } }, "sha512-4nbvra5R5EtiCzr9BTHiTLc+MLXK2QGiAVYMyi8PkQd3SR+6ixar/Q/01Fa21TBIDOZXgeWV4WppsQolSreAPQ=="],
 
-    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.6", "", { "os": "linux", "cpu": "arm" }, "sha512-SZHQlzvqv4Du5PrKE2faN0qlbsaW/3QQfUUc6yO2EjFcA83xnwm91UbEEVx4ApZ9Z5oG8Bxz4qPE+HFwtVcfyw=="],
+    "@codemirror/view": ["@codemirror/view@6.43.0", "", { "dependencies": { "@codemirror/state": "^6.6.0", "crelt": "^1.0.6", "style-mod": "^4.1.0", "w3c-keyname": "^2.2.4" } }, "sha512-V7ZCLQO3Jus9hzh2jVCCPW3mO4IBMr43O37PqSUYautJSnnJF41YlgLw21x0fLJTYvJ+Vkm6Gp+qKGH9pltgXA=="],
 
-    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.6", "", { "os": "linux", "cpu": "arm64" }, "sha512-b967hU0gqKd9Drsh/UuAm21Khpoh6mPBSgz8mKRq4P5mVK8bpA+hQzmm/ZwGVULSNBzKdZPQBRT3+WuVavcWsQ=="],
+    "@codesandbox/nodebox": ["@codesandbox/nodebox@0.1.8", "", { "dependencies": { "outvariant": "^1.4.0", "strict-event-emitter": "^0.4.3" } }, "sha512-2VRS6JDSk+M+pg56GA6CryyUSGPjBEe8Pnae0QL3jJF1mJZJVMDKr93gJRtBbLkfZN6LD/DwMtf+2L0bpWrjqg=="],
 
-    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.6", "", { "os": "linux", "cpu": "ia32" }, "sha512-aHWdQ2AAltRkLPOsKdi3xv0mZ8fUGPdlKEjIEhxCPm5yKEThcUjHpWB1idN74lfXGnZ5SULQSgtr5Qos5B0bPw=="],
+    "@codesandbox/sandpack-client": ["@codesandbox/sandpack-client@2.19.8", "", { "dependencies": { "@codesandbox/nodebox": "0.1.8", "buffer": "^6.0.3", "dequal": "^2.0.2", "mime-db": "^1.52.0", "outvariant": "1.4.0", "static-browser-server": "1.0.3" } }, "sha512-CMV4nr1zgKzVpx4I3FYvGRM5YT0VaQhALMW9vy4wZRhEyWAtJITQIqZzrTGWqB1JvV7V72dVEUCUPLfYz5hgJQ=="],
 
-    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.6", "", { "os": "linux", "cpu": "none" }, "sha512-VgKCsHdXRSQ7E1+QXGdRPlQ/e08bN6WMQb27/TMfV+vPjjTImuT9PmLXupRlC90S1JeNNW5lzkAEO/McKeJ2yg=="],
+    "@codesandbox/sandpack-react": ["@codesandbox/sandpack-react@2.20.0", "", { "dependencies": { "@codemirror/autocomplete": "^6.4.0", "@codemirror/commands": "^6.1.3", "@codemirror/lang-css": "^6.0.1", "@codemirror/lang-html": "^6.4.0", "@codemirror/lang-javascript": "^6.1.2", "@codemirror/language": "^6.3.2", "@codemirror/state": "^6.2.0", "@codemirror/view": "^6.7.1", "@codesandbox/sandpack-client": "^2.19.8", "@lezer/highlight": "^1.1.3", "@react-hook/intersection-observer": "^3.1.1", "@stitches/core": "^1.2.6", "anser": "^2.1.1", "clean-set": "^1.1.2", "dequal": "^2.0.2", "escape-carriage": "^1.3.1", "lz-string": "^1.4.4", "react-devtools-inline": "4.4.0", "react-is": "^17.0.2" }, "peerDependencies": { "react": "^16.8.0 || ^17 || ^18 || ^19", "react-dom": "^16.8.0 || ^17 || ^18 || ^19" } }, "sha512-takd1YpW/PMQ6KPQfvseWLHWklJovGY8QYj8MtWnskGKbjOGJ6uZfyZbcJ6aCFLQMpNyjTqz9AKNbvhCOZ1TUQ=="],
 
-    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.6", "", { "os": "linux", "cpu": "none" }, "sha512-WViNlpivRKT9/py3kCmkHnn44GkGXVdXfdc4drNmRl15zVQ2+D2uFwdlGh6IuK5AAnGTo2qPB1Djppj+t78rzw=="],
+    "@emnapi/core": ["@emnapi/core@1.10.0", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.1", "tslib": "^2.4.0" } }, "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw=="],
 
-    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.6", "", { "os": "linux", "cpu": "ppc64" }, "sha512-wyYKZ9NTdmAMb5730I38lBqVu6cKl4ZfYXIs31Baf8aoOtB4xSGi3THmDYt4BTFHk7/EcVixkOV2uZfwU3Q2Jw=="],
+    "@emnapi/runtime": ["@emnapi/runtime@1.10.0", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA=="],
 
-    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.6", "", { "os": "linux", "cpu": "none" }, "sha512-KZh7bAGGcrinEj4qzilJ4hqTY3Dg2U82c8bv+e1xqNqZCrCyc+TL9AUEn5WGKDzm3CfC5RODE/qc96OcbIe33w=="],
+    "@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.1", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w=="],
 
-    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.6", "", { "os": "linux", "cpu": "s390x" }, "sha512-9N1LsTwAuE9oj6lHMyyAM+ucxGiVnEqUdp4v7IaMmrwb06ZTEVCIs3oPPplVsnjPfyjmxwHxHMF8b6vzUVAUGw=="],
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.28.0", "", { "os": "aix", "cpu": "ppc64" }, "sha512-lhRUCeuOyJQURhTxl4WkpFTjIsbDayJHih5kZC1giwE+MhIzAb7mEsQMqMf18rHLsrb5qI1tafG20mLxEWcWlA=="],
 
-    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.6", "", { "os": "linux", "cpu": "x64" }, "sha512-A6bJB41b4lKFWRKNrWoP2LHsjVzNiaurf7wyj/XtFNTsnPuxwEBWHLty+ZE0dWBKuSK1fvKgrKaNjBS7qbFKig=="],
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.28.0", "", { "os": "android", "cpu": "arm" }, "sha512-wqh0ByljabXLKHeWXYLqoJ5jKC4XBaw6Hk08OfMrCRd2nP2ZQ5eleDZC41XHyCNgktBGYMbqnrJKq/K/lzPMSQ=="],
 
-    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.6", "", { "os": "none", "cpu": "arm64" }, "sha512-IjA+DcwoVpjEvyxZddDqBY+uJ2Snc6duLpjmkXm/v4xuS3H+3FkLZlDm9ZsAbF9rsfP3zeA0/ArNDORZgrxR/Q=="],
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.28.0", "", { "os": "android", "cpu": "arm64" }, "sha512-+WzIXQOSaGs33tLEgYPYe/yQHf0WTU0X42Jca3y8NWMbUVhp7rUnw+vAsRC/QiDrdD31IszMrZy+qwPOPjd+rw=="],
 
-    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.6", "", { "os": "none", "cpu": "x64" }, "sha512-dUXuZr5WenIDlMHdMkvDc1FAu4xdWixTCRgP7RQLBOkkGgwuuzaGSYcOpW4jFxzpzL1ejb8yF620UxAqnBrR9g=="],
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.28.0", "", { "os": "android", "cpu": "x64" }, "sha512-+VJggoaKhk2VNNqVL7f6S189UzShHC/mR9EE8rDdSkdpN0KflSwWY/gWjDrNxxisg8Fp1ZCD9jLMo4m0OUfeUA=="],
 
-    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.6", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-l8ZCvXP0tbTJ3iaqdNf3pjaOSd5ex/e6/omLIQCVBLmHTlfXW3zAxQ4fnDmPLOB1x9xrcSi/xtCWFwCZRIaEwg=="],
-
-    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.6", "", { "os": "openbsd", "cpu": "x64" }, "sha512-hKrmDa0aOFOr71KQ/19JC7az1P0GWtCN1t2ahYAf4O007DHZt/dW8ym5+CUdJhQ/qkZmI1HAF8KkJbEFtCL7gw=="],
-
-    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.6", "", { "os": "none", "cpu": "arm64" }, "sha512-+SqBcAWoB1fYKmpWoQP4pGtx+pUUC//RNYhFdbcSA16617cchuryuhOCRpPsjCblKukAckWsV+aQ3UKT/RMPcA=="],
-
-    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.6", "", { "os": "sunos", "cpu": "x64" }, "sha512-dyCGxv1/Br7MiSC42qinGL8KkG4kX0pEsdb0+TKhmJZgCUDBGmyo1/ArCjNGiOLiIAgdbWgmWgib4HoCi5t7kA=="],
-
-    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.6", "", { "os": "win32", "cpu": "arm64" }, "sha512-42QOgcZeZOvXfsCBJF5Afw73t4veOId//XD3i+/9gSkhSV6Gk3VPlWncctI+JcOyERv85FUo7RxuxGy+z8A43Q=="],
-
-    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.6", "", { "os": "win32", "cpu": "ia32" }, "sha512-4AWhgXmDuYN7rJI6ORB+uU9DHLq/erBbuMoAuB4VWJTu5KtCgcKYPynF0YI1VkBNuEfjNlLrFr9KZPJzrtLkrQ=="],
-
-    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.6", "", { "os": "win32", "cpu": "x64" }, "sha512-NgJPHHbEpLQgDH2MjQu90pzW/5vvXIZ7KOnPyNBm92A6WgZ/7b6fJyUBjoumLqeOQQGqY2QjQxRo97ah4Sj0cA=="],
-
-    "@floating-ui/core": ["@floating-ui/core@1.7.5", "", { "dependencies": { "@floating-ui/utils": "^0.2.11" } }, "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ=="],
-
-    "@floating-ui/dom": ["@floating-ui/dom@1.7.6", "", { "dependencies": { "@floating-ui/core": "^1.7.5", "@floating-ui/utils": "^0.2.11" } }, "sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ=="],
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.28.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-0T+A9WZm+bZ84nZBtk1ckYsOvyA3x7e2Acj1KdVfV4/2tdG4fzUp91YHx+GArWLtwqp77pBXVCPn2We7Letr0Q=="],
 
-    "@floating-ui/react": ["@floating-ui/react@0.27.19", "", { "dependencies": { "@floating-ui/react-dom": "^2.1.8", "@floating-ui/utils": "^0.2.11", "tabbable": "^6.0.0" }, "peerDependencies": { "react": ">=17.0.0", "react-dom": ">=17.0.0" } }, "sha512-31B8h5mm8YxotlE7/AU/PhNAl8eWxAmjL/v2QOxroDNkTFLk3Uu82u63N3b6TXa4EGJeeZLVcd/9AlNlVqzeog=="],
-
-    "@floating-ui/react-dom": ["@floating-ui/react-dom@2.1.8", "", { "dependencies": { "@floating-ui/dom": "^1.7.6" }, "peerDependencies": { "react": ">=16.8.0", "react-dom": ">=16.8.0" } }, "sha512-cC52bHwM/n/CxS87FH0yWdngEZrjdtLW/qVruo68qg+prK7ZQ4YGdut2GyDVpoGeAYe/h899rVeOVm6Oi40k2A=="],
-
-    "@floating-ui/utils": ["@floating-ui/utils@0.2.11", "", {}, "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg=="],
-
-    "@fortawesome/fontawesome-free": ["@fortawesome/fontawesome-free@6.7.2", "", {}, "sha512-JUOtgFW6k9u4Y+xeIaEiLr3+cjoUPiAuLXoyKOJSia6Duzb7pq+A76P9ZdPDoAoxHdHzq6gE9/jKBGXlZT8FbA=="],
-
-    "@hono/node-server": ["@hono/node-server@1.19.14", "", { "peerDependencies": { "hono": "^4" } }, "sha512-GwtvgtXxnWsucXvbQXkRgqksiH2Qed37H9xHZocE5sA3N8O8O8/8FA3uclQXxXVzc9XBZuEOMK7+r02FmSpHtw=="],
-
-    "@iconify/types": ["@iconify/types@2.0.0", "", {}, "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg=="],
-
-    "@iconify/utils": ["@iconify/utils@2.3.0", "", { "dependencies": { "@antfu/install-pkg": "^1.0.0", "@antfu/utils": "^8.1.0", "@iconify/types": "^2.0.0", "debug": "^4.4.0", "globals": "^15.14.0", "kolorist": "^1.8.0", "local-pkg": "^1.0.0", "mlly": "^1.7.4" } }, "sha512-GmQ78prtwYW6EtzXRU1rY+KwOKfz32PD7iJh6Iyqw68GiKuoZ2A6pRtzWONz5VQJbp50mEjXh/7NkumtrAgRKA=="],
-
-    "@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="],
-
-    "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.12", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-OuLGC46TjB5BbN1dH8JULVVZY4WTdkF7tV9Ys6wLL1rubZnCMstOhNHueU5bLCrnRuDhKPDM4g6sw4Bel5Gzqg=="],
-
-    "@jridgewell/remapping": ["@jridgewell/remapping@2.3.5", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ=="],
-
-    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
-
-    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.4", "", {}, "sha512-VT2+G1VQs/9oz078bLrYbecdZKs912zQlkelYpuf+SXF+QvZDYJlbx/LSx+meSAwdDFnF8FVXW92AVjjkVmgFw=="],
-
-    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.29", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-uw6guiW/gcAGPDhLmd77/6lW8QLeiV5RUTsAX46Db6oLhGaVj4lhnPwb184s1bkc8kdVg/+h988dro8GRDpmYQ=="],
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.28.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-fyzLm/DLDl/84OCfp2f/XQ4flmORsjU7VKt8HLjvIXChJoFFOIL6pLJPH4Yhd1n1gGFF9mPwtlN5Wf82DZs+LQ=="],
 
-    "@mdx-js/mdx": ["@mdx-js/mdx@3.1.1", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdx": "^2.0.0", "acorn": "^8.0.0", "collapse-white-space": "^2.0.0", "devlop": "^1.0.0", "estree-util-is-identifier-name": "^3.0.0", "estree-util-scope": "^1.0.0", "estree-walker": "^3.0.0", "hast-util-to-jsx-runtime": "^2.0.0", "markdown-extensions": "^2.0.0", "recma-build-jsx": "^1.0.0", "recma-jsx": "^1.0.0", "recma-stringify": "^1.0.0", "rehype-recma": "^1.0.0", "remark-mdx": "^3.0.0", "remark-parse": "^11.0.0", "remark-rehype": "^11.0.0", "source-map": "^0.7.0", "unified": "^11.0.0", "unist-util-position-from-estree": "^2.0.0", "unist-util-stringify-position": "^4.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" } }, "sha512-f6ZO2ifpwAQIpzGWaBQT2TXxPv6z3RBzQKpVftEWN78Vl/YweF1uwussDx8ECAXVtr3Rs89fKyG9YlzUs9DyGQ=="],
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.28.0", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-l9GeW5UZBT9k9brBYI+0WDffcRxgHQD8ShN2Ur4xWq/NFzUKm3k5lsH4PdaRgb2w7mI9u61nr2gI2mLI27Nh3Q=="],
 
-    "@mdx-js/react": ["@mdx-js/react@3.1.1", "", { "dependencies": { "@types/mdx": "^2.0.0" }, "peerDependencies": { "@types/react": ">=16", "react": ">=16" } }, "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw=="],
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.28.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-BXoQai/A0wPO6Es3yFJ7APCiKGc1tdAEOgeTNy3SsB491S3aHn4S4r3e976eUnPdU+NbdtmBuLncYir2tMU9Nw=="],
 
-    "@mdx-js/rollup": ["@mdx-js/rollup@3.1.1", "", { "dependencies": { "@mdx-js/mdx": "^3.0.0", "@rollup/pluginutils": "^5.0.0", "source-map": "^0.7.0", "vfile": "^6.0.0" }, "peerDependencies": { "rollup": ">=2" } }, "sha512-v8satFmBB+DqDzYohnm1u2JOvxx6Hl3pUvqzJvfs2Zk/ngZ1aRUhsWpXvwPkNeGN9c2NCm/38H29ZqXQUjf8dw=="],
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.28.0", "", { "os": "linux", "cpu": "arm" }, "sha512-CjaaREJagqJp7iTaNQjjidaNbCKYcd4IDkzbwwxtSvjI7NZm79qiHc8HqciMddQ6CKvJT6aBd8lO9kN/ZudLlw=="],
 
-    "@mermaid-js/parser": ["@mermaid-js/parser@0.6.2", "", { "dependencies": { "langium": "3.3.1" } }, "sha512-+PO02uGF6L6Cs0Bw8RpGhikVvMWEysfAyl27qTlroUB8jSWr1lL0Sf6zi78ZxlSnmgSY2AMMKVgghnN9jTtwkQ=="],
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.28.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-RVyzfb3FWsGA55n6WY0MEIEPURL1FcbhFE6BffZEMEekfCzCIMtB5yyDcFnVbTnwk+CLAgTujmV/Lgvih56W+A=="],
 
-    "@noble/hashes": ["@noble/hashes@1.8.0", "", {}, "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A=="],
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.28.0", "", { "os": "linux", "cpu": "ia32" }, "sha512-KBnSTt1kxl9x70q+ydterVdl+Cn0H18ngRMRCEQfrbqdUuntQQ0LoMZv47uB97NljZFzY6HcfqEZ2SAyIUTQBQ=="],
 
-    "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="],
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.28.0", "", { "os": "linux", "cpu": "none" }, "sha512-zpSlUce1mnxzgBADvxKXX5sl8aYQHo2ezvMNI8I0lbblJtp8V4odlm3Yzlj7gPyt3T8ReksE6bK+pT3WD+aJRg=="],
 
-    "@nodelib/fs.stat": ["@nodelib/fs.stat@2.0.5", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="],
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.28.0", "", { "os": "linux", "cpu": "none" }, "sha512-2jIfP6mmjkdmeTlsX/9vmdmhBmKADrWqN7zcdtHIeNSCH1SqIoNI63cYsjQR8J+wGa4Y5izRcSHSm8K3QWmk3w=="],
 
-    "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="],
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.28.0", "", { "os": "linux", "cpu": "ppc64" }, "sha512-bc0FE9wWeC0WBm49IQMPSPILRocGTQt3j5KPCA8os6VprfuJ7KD+5PzESSrJ6GmPIPJK965ZJHTUlSA6GNYEhg=="],
 
-    "@radix-ui/colors": ["@radix-ui/colors@3.0.0", "", {}, "sha512-FUOsGBkHrYJwCSEtWRCIfQbZG7q1e6DgxCIOe1SUQzDe/7rXXeA47s8yCn6fuTNQAj1Zq4oTFi9Yjp3wzElcxg=="],
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.28.0", "", { "os": "linux", "cpu": "none" }, "sha512-SQPZOwoTTT/HXFXQJG/vBX8sOFagGqvZyXcgLA3NhIqcBv1BJU1d46c0rGcrij2B56Z2rNiSLaZOYW5cUk7yLQ=="],
 
-    "@radix-ui/number": ["@radix-ui/number@1.1.1", "", {}, "sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g=="],
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.28.0", "", { "os": "linux", "cpu": "s390x" }, "sha512-SCfR0HN8CEEjnYnySJTd2cw0k9OHB/YFzt5zgJEwa+wL/T/raGWYMBqwDNAC6dqFKmJYZoQBRfHjgwLHGSrn3Q=="],
 
-    "@radix-ui/primitive": ["@radix-ui/primitive@1.1.2", "", {}, "sha512-XnbHrrprsNqZKQhStrSwgRUQzoCI1glLzdw79xiZPoofhGICeZRSQ3dIxAKH1gb3OHfNf4d6f+vAv3kil2eggA=="],
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.28.0", "", { "os": "linux", "cpu": "x64" }, "sha512-us0dSb9iFxIi8srnpl931Nvs65it/Jd2a2K3qs7fz2WfGPHqzfzZTfec7oxZJRNPXPnNYZtanmRc4AL/JwVzHQ=="],
 
-    "@radix-ui/react-accessible-icon": ["@radix-ui/react-accessible-icon@1.1.7", "", { "dependencies": { "@radix-ui/react-visually-hidden": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-XM+E4WXl0OqUJFovy6GjmxxFyx9opfCAIUku4dlKRd5YEPqt4kALOkQOp0Of6reHuUkJuiPBEc5k0o4z4lTC8A=="],
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.28.0", "", { "os": "none", "cpu": "arm64" }, "sha512-CR/RYotgtCKwtftMwJlUU7xCVNg3lMYZ0RzTmAHSfLCXw3NtZtNpswLEj/Kkf6kEL3Gw+BpOekRX0BYCtklhUw=="],
 
-    "@radix-ui/react-accordion": ["@radix-ui/react-accordion@1.2.11", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-collapsible": "1.1.11", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-l3W5D54emV2ues7jjeG1xcyN7S3jnK3zE2zHqgn0CmMsy9lNJwmgcrmaxS+7ipw15FAivzKNzH3d5EcGoFKw0A=="],
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.28.0", "", { "os": "none", "cpu": "x64" }, "sha512-nU1yhmYutL+fQ71Kxnhg8uEOdC0pwEW9entHykTgEbna2pw2dkbFSMeqjjyHZoCmt8SBkOSvV+yNmm94aUrrqw=="],
 
-    "@radix-ui/react-alert-dialog": ["@radix-ui/react-alert-dialog@1.1.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dialog": "1.1.14", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-IOZfZ3nPvN6lXpJTBCunFQPRSvK8MDgSc1FB85xnIpUKOw9en0dJj8JmCAxV7BiZdtYlUpmrQjoTFkVYtdoWzQ=="],
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.28.0", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-cXb5vApOsRsxsEl4mcZ1XY3D4DzcoMxR/nnc4IyqYs0rTI8ZKmW6kyyg+11Z8yvgMfAEldKzP7AdP64HnSC/6g=="],
 
-    "@radix-ui/react-arrow": ["@radix-ui/react-arrow@1.1.7", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w=="],
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.28.0", "", { "os": "openbsd", "cpu": "x64" }, "sha512-8wZM2qqtv9UP3mzy7HiGYNH/zjTA355mpeuA+859TyR+e+Tc08IHYpLJuMsfpDJwoLo1ikIJI8jC3GFjnRClzA=="],
 
-    "@radix-ui/react-aspect-ratio": ["@radix-ui/react-aspect-ratio@1.1.7", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Yq6lvO9HQyPwev1onK1daHCHqXVLzPhSVjmsNjCa2Zcxy2f7uJD2itDtxknv6FzAKCwD1qQkeVDmX/cev13n/g=="],
+    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.28.0", "", { "os": "none", "cpu": "arm64" }, "sha512-FLGfyizszcef5C3YtoyQDACyg95+dndv79i2EekILBofh5wpCa1KuBqOWKrEHZg3zrL3t5ouE5jgr94vA+Wb2w=="],
 
-    "@radix-ui/react-avatar": ["@radix-ui/react-avatar@1.1.10", "", { "dependencies": { "@radix-ui/react-context": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-is-hydrated": "0.1.0", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-V8piFfWapM5OmNCXTzVQY+E1rDa53zY+MQ4Y7356v4fFz6vqCyUtIz2rUD44ZEdwg78/jKmMJHj07+C/Z/rcog=="],
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.28.0", "", { "os": "sunos", "cpu": "x64" }, "sha512-1ZgjUoEdHZZl/YlV76TSCz9Hqj9h9YmMGAgAPYd+q4SicWNX3G5GCyx9uhQWSLcbvPW8Ni7lj4gDa1T40akdlw=="],
 
-    "@radix-ui/react-checkbox": ["@radix-ui/react-checkbox@1.3.2", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-use-size": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-yd+dI56KZqawxKZrJ31eENUwqc1QSqg4OZ15rybGjF2ZNwMO+wCyHzAVLRp9qoYJf7kYy0YpZ2b0JCzJ42HZpA=="],
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.28.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-Q9StnDmQ/enxnpxCCLSg0oo4+34B9TdXpuyPeTedN/6+iXBJ4J+zwfQI28u/Jl40nOYAxGoNi7mFP40RUtkmUA=="],
 
-    "@radix-ui/react-collapsible": ["@radix-ui/react-collapsible@1.1.11", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-2qrRsVGSCYasSz1RFOorXwl0H7g7J1frQtgpQgYrt+MOidtPAINHn9CPovQXb83r8ahapdx3Tu0fa/pdFFSdPg=="],
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.28.0", "", { "os": "win32", "cpu": "ia32" }, "sha512-zF3ag/gfiCe6U2iczcRzSYJKH1DCI+ByzSENHlM2FcDbEeo5Zd2C86Aq0tKUYAJJ1obRP84ymxIAksZUcdztHA=="],
 
-    "@radix-ui/react-collection": ["@radix-ui/react-collection@1.1.7", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw=="],
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.28.0", "", { "os": "win32", "cpu": "x64" }, "sha512-pEl1bO9mfAmIC+tW5btTmrKaujg3zGtUmWNdCw/xs70FBjwAL3o9OEKNHvNmnyylD6ubxUERiEhdsL0xBQ9efw=="],
 
-    "@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg=="],
+    "@floating-ui/core": ["@floating-ui/core@1.7.5", "", { "dependencies": { "@floating-ui/utils": "^0.2.11" } }, "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ=="],
 
-    "@radix-ui/react-context": ["@radix-ui/react-context@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA=="],
+    "@floating-ui/dom": ["@floating-ui/dom@1.7.6", "", { "dependencies": { "@floating-ui/core": "^1.7.5", "@floating-ui/utils": "^0.2.11" } }, "sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ=="],
 
-    "@radix-ui/react-context-menu": ["@radix-ui/react-context-menu@2.2.15", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-menu": "2.1.15", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-UsQUMjcYTsBjTSXw0P3GO0werEQvUY2plgRQuKoCTtkNr45q1DiL51j4m7gxhABzZ0BadoXNsIbg7F3KwiUBbw=="],
+    "@floating-ui/react-dom": ["@floating-ui/react-dom@2.1.8", "", { "dependencies": { "@floating-ui/dom": "^1.7.6" }, "peerDependencies": { "react": ">=16.8.0", "react-dom": ">=16.8.0" } }, "sha512-cC52bHwM/n/CxS87FH0yWdngEZrjdtLW/qVruo68qg+prK7ZQ4YGdut2GyDVpoGeAYe/h899rVeOVm6Oi40k2A=="],
 
-    "@radix-ui/react-dialog": ["@radix-ui/react-dialog@1.1.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.10", "@radix-ui/react-focus-guards": "1.1.2", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-controllable-state": "1.2.2", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.6.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-+CpweKjqpzTmwRwcYECQcNYbI8V9VSQt0SNFKeEBLgfucbsLssU6Ppq7wUdNXEGb573bMjFhVjKVll8rmV6zMw=="],
+    "@floating-ui/utils": ["@floating-ui/utils@0.2.11", "", {}, "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg=="],
 
-    "@radix-ui/react-direction": ["@radix-ui/react-direction@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-1UEWRX6jnOA2y4H5WczZ44gOOjTEmlqv1uNW4GAJEO5+bauCBhv8snY65Iw5/VOS/ghKN9gr2KjnLKxrsvoMVw=="],
+    "@hono/node-server": ["@hono/node-server@2.0.4", "", { "peerDependencies": { "hono": "^4" } }, "sha512-Ut3y0dMMPWy6bZ2kVfx25EOVbZlm15dhF4mOsezMlhpNHy+4MkU1qN9Y6lnruYi4wPmFzimGX2X7LF/FwHli4A=="],
 
-    "@radix-ui/react-dismissable-layer": ["@radix-ui/react-dismissable-layer@1.1.10", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-escape-keydown": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-IM1zzRV4W3HtVgftdQiiOmA0AdJlCtMLe00FXaHwgt3rAnNsIyDqshvkIW3hj/iu5hu8ERP7KIYki6NkqDxAwQ=="],
+    "@iconify-json/lucide": ["@iconify-json/lucide@1.2.111", "", { "dependencies": { "@iconify/types": "*" } }, "sha512-S6oXom2YOKuXFxWofhHa2oq++Z3WeZ78dRFDA7aEEJqyNCJlQd1UGAfN8u2gD2NzvYotmm+j5kH678viWfZbGQ=="],
 
-    "@radix-ui/react-dropdown-menu": ["@radix-ui/react-dropdown-menu@2.1.15", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-menu": "2.1.15", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-mIBnOjgwo9AH3FyKaSWoSu/dYj6VdhJ7frEPiGTeXCdUFHjl9h3mFh2wwhEtINOmYXWhdpf1rY2minFsmaNgVQ=="],
+    "@iconify-json/simple-icons": ["@iconify-json/simple-icons@1.2.85", "", { "dependencies": { "@iconify/types": "*" } }, "sha512-Hp5LXvd3LRk+e+1558wtonA7c1Z0/Phmi7xCqpgtb8bs8cuyGnP34GDbt5uhhUXxKlzacnnhAcXgcDxe9bUa1w=="],
 
-    "@radix-ui/react-focus-guards": ["@radix-ui/react-focus-guards@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-fyjAACV62oPV925xFCrH8DR5xWhg9KYtJT4s3u54jxp+L/hbpTY2kIeEFFbFe+a/HCE94zGQMZLIpVTPVZDhaA=="],
+    "@iconify-json/vscode-icons": ["@iconify-json/vscode-icons@1.2.54", "", { "dependencies": { "@iconify/types": "*" } }, "sha512-WxGA+FE5AP7mbKuy7lMClIKc/iY9hCKgafZsrCeQjyO2G3MvP/2cZev1W1QPn3tAbXDmVak5K3HB3rxvi+066g=="],
 
-    "@radix-ui/react-focus-scope": ["@radix-ui/react-focus-scope@1.1.7", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw=="],
+    "@iconify/types": ["@iconify/types@2.0.0", "", {}, "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg=="],
 
-    "@radix-ui/react-form": ["@radix-ui/react-form@0.1.7", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-label": "2.1.7", "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-IXLKFnaYvFg/KkeV5QfOX7tRnwHXp127koOFUjLWMTrRv5Rny3DQcAtIFFeA/Cli4HHM8DuJCXAUsgnFVJndlw=="],
+    "@iconify/utils": ["@iconify/utils@3.1.3", "", { "dependencies": { "@antfu/install-pkg": "^1.1.0", "@iconify/types": "^2.0.0", "import-meta-resolve": "^4.2.0" } }, "sha512-LPKOXPn/zV+zis1oOfGWogaXVpqUybF3ZS6SCZIsz8vg0ivVp9+fVqyYB7xq0aiST/VhUQYGO1qo6uoYSiEJqw=="],
 
-    "@radix-ui/react-hover-card": ["@radix-ui/react-hover-card@1.1.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.10", "@radix-ui/react-popper": "1.2.7", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-CPYZ24Mhirm+g6D8jArmLzjYu4Eyg3TTUHswR26QgzXBHBe64BO/RHOJKzmF/Dxb4y4f9PKyJdwm/O/AhNkb+Q=="],
+    "@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="],
 
-    "@radix-ui/react-icons": ["@radix-ui/react-icons@1.3.2", "", { "peerDependencies": { "react": "^16.x || ^17.x || ^18.x || ^19.0.0 || ^19.0.0-rc" } }, "sha512-fyQIhGDhzfc9pK2kH6Pl9c4BDJGfMkPqkyIgYDthyNYoNg3wVhoJMMh19WS4Up/1KMPFVpNsT2q3WmXn2N1m6g=="],
+    "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.12", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-OuLGC46TjB5BbN1dH8JULVVZY4WTdkF7tV9Ys6wLL1rubZnCMstOhNHueU5bLCrnRuDhKPDM4g6sw4Bel5Gzqg=="],
 
-    "@radix-ui/react-id": ["@radix-ui/react-id@1.1.1", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg=="],
+    "@jridgewell/remapping": ["@jridgewell/remapping@2.3.5", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ=="],
 
-    "@radix-ui/react-label": ["@radix-ui/react-label@2.1.7", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-YT1GqPSL8kJn20djelMX7/cTRp/Y9w5IZHvfxQTVHrOqa2yMl7i/UfMqKRU5V7mEyKTrUVgJXhNQPVCG8PBLoQ=="],
+    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
 
-    "@radix-ui/react-menu": ["@radix-ui/react-menu@2.1.15", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-dismissable-layer": "1.1.10", "@radix-ui/react-focus-guards": "1.1.2", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-popper": "1.2.7", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.10", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-callback-ref": "1.1.1", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.6.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-tVlmA3Vb9n8SZSd+YSbuFR66l87Wiy4du+YE+0hzKQEANA+7cWKH1WgqcEX4pXqxUFQKrWQGHdvEfw00TjFiew=="],
+    "@jridgewell/source-map": ["@jridgewell/source-map@0.3.11", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.25" } }, "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA=="],
 
-    "@radix-ui/react-menubar": ["@radix-ui/react-menubar@1.1.15", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-menu": "2.1.15", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.10", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Z71C7LGD+YDYo3TV81paUs8f3Zbmkvg6VLRQpKYfzioOE6n7fOhA3ApK/V/2Odolxjoc4ENk8AYCjohCNayd5A=="],
+    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
 
-    "@radix-ui/react-navigation-menu": ["@radix-ui/react-navigation-menu@1.2.13", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-dismissable-layer": "1.1.10", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-visually-hidden": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-WG8wWfDiJlSF5hELjwfjSGOXcBR/ZMhBFCGYe8vERpC39CQYZeq1PQ2kaYHdye3V95d06H89KGMsVCIE4LWo3g=="],
+    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.29", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-uw6guiW/gcAGPDhLmd77/6lW8QLeiV5RUTsAX46Db6oLhGaVj4lhnPwb184s1bkc8kdVg/+h988dro8GRDpmYQ=="],
 
-    "@radix-ui/react-one-time-password-field": ["@radix-ui/react-one-time-password-field@0.1.7", "", { "dependencies": { "@radix-ui/number": "1.1.1", "@radix-ui/primitive": "1.1.2", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.10", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-is-hydrated": "0.1.0", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-w1vm7AGI8tNXVovOK7TYQHrAGpRF7qQL+ENpT1a743De5Zmay2RbWGKAiYDKIyIuqptns+znCKwNztE2xl1n0Q=="],
+    "@lezer/common": ["@lezer/common@1.5.2", "", {}, "sha512-sxQE460fPZyU3sdc8lafxiPwJHBzZRy/udNFynGQky1SePYBdhkBl1kOagA9uT3pxR8K09bOrmTUqA9wb/PjSQ=="],
 
-    "@radix-ui/react-password-toggle-field": ["@radix-ui/react-password-toggle-field@0.1.2", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-is-hydrated": "0.1.0" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-F90uYnlBsLPU1UbSLciLsWQmk8+hdWa6SFw4GXaIdNWxFxI5ITKVdAG64f+Twaa9ic6xE7pqxPyUmodrGjT4pQ=="],
+    "@lezer/css": ["@lezer/css@1.3.3", "", { "dependencies": { "@lezer/common": "^1.2.0", "@lezer/highlight": "^1.0.0", "@lezer/lr": "^1.3.0" } }, "sha512-RzBo8r+/6QJeow7aPHIpGVIH59xTcJXp399820gZoMo9noQDRVpJLheIBUicYwKcsbOYoBRoLZlf2720dG/4Tg=="],
 
-    "@radix-ui/react-popover": ["@radix-ui/react-popover@1.1.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.10", "@radix-ui/react-focus-guards": "1.1.2", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-popper": "1.2.7", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-controllable-state": "1.2.2", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.6.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-ODz16+1iIbGUfFEfKx2HTPKizg2MN39uIOV8MXeHnmdd3i/N9Wt7vU46wbHsqA0xoaQyXVcs0KIlBdOA2Y95bw=="],
+    "@lezer/highlight": ["@lezer/highlight@1.2.3", "", { "dependencies": { "@lezer/common": "^1.3.0" } }, "sha512-qXdH7UqTvGfdVBINrgKhDsVTJTxactNNxLk7+UMwZhU13lMHaOBlJe9Vqp907ya56Y3+ed2tlqzys7jDkTmW0g=="],
 
-    "@radix-ui/react-popper": ["@radix-ui/react-popper@1.2.7", "", { "dependencies": { "@floating-ui/react-dom": "^2.0.0", "@radix-ui/react-arrow": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-use-rect": "1.1.1", "@radix-ui/react-use-size": "1.1.1", "@radix-ui/rect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-IUFAccz1JyKcf/RjB552PlWwxjeCJB8/4KxT7EhBHOJM+mN7LdW+B3kacJXILm32xawcMMjb2i0cIZpo+f9kiQ=="],
+    "@lezer/html": ["@lezer/html@1.3.13", "", { "dependencies": { "@lezer/common": "^1.2.0", "@lezer/highlight": "^1.0.0", "@lezer/lr": "^1.0.0" } }, "sha512-oI7n6NJml729m7pjm9lvLvmXbdoMoi2f+1pwSDJkl9d68zGr7a9Btz8NdHTGQZtW2DA25ybeuv/SyDb9D5tseg=="],
 
-    "@radix-ui/react-portal": ["@radix-ui/react-portal@1.1.9", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ=="],
+    "@lezer/javascript": ["@lezer/javascript@1.5.4", "", { "dependencies": { "@lezer/common": "^1.2.0", "@lezer/highlight": "^1.1.3", "@lezer/lr": "^1.3.0" } }, "sha512-vvYx3MhWqeZtGPwDStM2dwgljd5smolYD2lR2UyFcHfxbBQebqx8yjmFmxtJ/E6nN6u1D9srOiVWm3Rb4tmcUA=="],
 
-    "@radix-ui/react-presence": ["@radix-ui/react-presence@1.1.4", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-ueDqRbdc4/bkaQT3GIpLQssRlFgWaL/U2z/S31qRwwLWoxHLgry3SIfCwhxeQNbirEUXFa+lq3RL3oBYXtcmIA=="],
+    "@lezer/lr": ["@lezer/lr@1.4.10", "", { "dependencies": { "@lezer/common": "^1.0.0" } }, "sha512-rnCpTIBafOx4mRp43xOxDJbFipJm/c0cia/V5TiGlhmMa+wsSdoGmUN3w5Bqrks/09Q/D4tNAmWaT8p6NRi77A=="],
 
-    "@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+    "@marijn/find-cluster-break": ["@marijn/find-cluster-break@1.0.2", "", {}, "sha512-l0h88YhZFyKdXIFNfSWpyjStDjGHwZ/U7iobcK1cQQD8sejsONdQtTVU+1wVN1PBw40PiiHB1vA5S7VTfQiP9g=="],
 
-    "@radix-ui/react-progress": ["@radix-ui/react-progress@1.1.7", "", { "dependencies": { "@radix-ui/react-context": "1.1.2", "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-vPdg/tF6YC/ynuBIJlk1mm7Le0VgW6ub6J2UWnTQ7/D23KXcPI1qy+0vBkgKgd38RCMJavBXpB83HPNFMTb0Fg=="],
+    "@mdx-js/mdx": ["@mdx-js/mdx@3.1.1", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdx": "^2.0.0", "acorn": "^8.0.0", "collapse-white-space": "^2.0.0", "devlop": "^1.0.0", "estree-util-is-identifier-name": "^3.0.0", "estree-util-scope": "^1.0.0", "estree-walker": "^3.0.0", "hast-util-to-jsx-runtime": "^2.0.0", "markdown-extensions": "^2.0.0", "recma-build-jsx": "^1.0.0", "recma-jsx": "^1.0.0", "recma-stringify": "^1.0.0", "rehype-recma": "^1.0.0", "remark-mdx": "^3.0.0", "remark-parse": "^11.0.0", "remark-rehype": "^11.0.0", "source-map": "^0.7.0", "unified": "^11.0.0", "unist-util-position-from-estree": "^2.0.0", "unist-util-stringify-position": "^4.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" } }, "sha512-f6ZO2ifpwAQIpzGWaBQT2TXxPv6z3RBzQKpVftEWN78Vl/YweF1uwussDx8ECAXVtr3Rs89fKyG9YlzUs9DyGQ=="],
 
-    "@radix-ui/react-radio-group": ["@radix-ui/react-radio-group@1.3.7", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.10", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-use-size": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-9w5XhD0KPOrm92OTTE0SysH3sYzHsSTHNvZgUBo/VZ80VdYyB5RneDbc0dKpURS24IxkoFRu/hI0i4XyfFwY6g=="],
+    "@mdx-js/react": ["@mdx-js/react@3.1.1", "", { "dependencies": { "@types/mdx": "^2.0.0" }, "peerDependencies": { "@types/react": ">=16", "react": ">=16" } }, "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw=="],
 
-    "@radix-ui/react-roving-focus": ["@radix-ui/react-roving-focus@1.1.10", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-dT9aOXUen9JSsxnMPv/0VqySQf5eDQ6LCk5Sw28kamz8wSOW2bJdlX2Bg5VUIIcV+6XlHpWTIuTPCf/UNIyq8Q=="],
+    "@mdx-js/rollup": ["@mdx-js/rollup@3.1.1", "", { "dependencies": { "@mdx-js/mdx": "^3.0.0", "@rollup/pluginutils": "^5.0.0", "source-map": "^0.7.0", "vfile": "^6.0.0" }, "peerDependencies": { "rollup": ">=2" } }, "sha512-v8satFmBB+DqDzYohnm1u2JOvxx6Hl3pUvqzJvfs2Zk/ngZ1aRUhsWpXvwPkNeGN9c2NCm/38H29ZqXQUjf8dw=="],
 
-    "@radix-ui/react-scroll-area": ["@radix-ui/react-scroll-area@1.2.9", "", { "dependencies": { "@radix-ui/number": "1.1.1", "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-YSjEfBXnhUELsO2VzjdtYYD4CfQjvao+lhhrX5XsHD7/cyUNzljF1FHEbgTPN7LH2MClfwRMIsYlqTYpKTTe2A=="],
+    "@mermaid-js/parser": ["@mermaid-js/parser@1.1.1", "", { "dependencies": { "@chevrotain/types": "~11.1.1" } }, "sha512-VuHdsYMK1bT6X2JbcAaWAhugTRvRBRyuZgd+c22swUeI9g/ntaxF7CY7dYarhZovofCbUNO0G7JesfmNtjYOCw=="],
 
-    "@radix-ui/react-select": ["@radix-ui/react-select@2.2.5", "", { "dependencies": { "@radix-ui/number": "1.1.1", "@radix-ui/primitive": "1.1.2", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-dismissable-layer": "1.1.10", "@radix-ui/react-focus-guards": "1.1.2", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-popper": "1.2.7", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-visually-hidden": "1.2.3", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.6.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-HnMTdXEVuuyzx63ME0ut4+sEMYW6oouHWNGUZc7ddvUWIcfCva/AMoqEW/3wnEllriMWBa0RHspCYnfCWJQYmA=="],
+    "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.29.0", "", { "dependencies": { "@hono/node-server": "^1.19.9", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.2.1", "express-rate-limit": "^8.2.1", "hono": "^4.11.4", "jose": "^6.1.3", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.1" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ=="],
 
-    "@radix-ui/react-separator": ["@radix-ui/react-separator@1.1.7", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-0HEb8R9E8A+jZjvmFCy/J4xhbXy3TV+9XSnGJ3KvTtjlIUy/YQ/p6UYZvi7YbeoeXdyU9+Y3scizK6hkY37baA=="],
+    "@napi-rs/wasm-runtime": ["@napi-rs/wasm-runtime@1.1.4", "", { "dependencies": { "@tybys/wasm-util": "^0.10.1" }, "peerDependencies": { "@emnapi/core": "^1.7.1", "@emnapi/runtime": "^1.7.1" } }, "sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow=="],
 
-    "@radix-ui/react-slider": ["@radix-ui/react-slider@1.3.5", "", { "dependencies": { "@radix-ui/number": "1.1.1", "@radix-ui/primitive": "1.1.2", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-use-size": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-rkfe2pU2NBAYfGaxa3Mqosi7VZEWX5CxKaanRv0vZd4Zhl9fvQrg0VM93dv3xGLGfrHuoTRF3JXH8nb9g+B3fw=="],
+    "@open-draft/deferred-promise": ["@open-draft/deferred-promise@2.2.0", "", {}, "sha512-CecwLWx3rhxVQF6V4bAgPS5t+So2sTbPgAzafKkVizyi7tlwpcFpdFqq+wqF2OwNBmqFuu6tOyouTuxgpMfzmA=="],
 
-    "@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+    "@oxc-project/types": ["@oxc-project/types@0.133.0", "", {}, "sha512-KzkdCd6Uxqnf6l3HOw1xfatAlUURA0g14cvBYFyJ5SaNOQbOUvBr9PKArcPcrNIeRsBdgcUzOGrhKveVpvOIGA=="],
 
-    "@radix-ui/react-switch": ["@radix-ui/react-switch@1.2.5", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-use-size": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-5ijLkak6ZMylXsaImpZ8u4Rlf5grRmoc0p0QeX9VJtlrM4f5m3nCTX8tWga/zOA8PZYIR/t0p2Mnvd7InrJ6yQ=="],
+    "@react-hook/intersection-observer": ["@react-hook/intersection-observer@3.1.2", "", { "dependencies": { "@react-hook/passive-layout-effect": "^1.2.0", "intersection-observer": "^0.10.0" }, "peerDependencies": { "react": ">=16.8" } }, "sha512-mWU3BMkmmzyYMSuhO9wu3eJVP21N8TcgYm9bZnTrMwuM818bEk+0NRM3hP+c/TqA9Ln5C7qE53p1H0QMtzYdvQ=="],
 
-    "@radix-ui/react-tabs": ["@radix-ui/react-tabs@1.1.12", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.10", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-GTVAlRVrQrSw3cEARM0nAx73ixrWDPNZAruETn3oHCNP6SbZ/hNxdxp+u7VkIEv3/sFoLq1PfcHrl7Pnp0CDpw=="],
+    "@react-hook/passive-layout-effect": ["@react-hook/passive-layout-effect@1.2.1", "", { "peerDependencies": { "react": ">=16.8" } }, "sha512-IwEphTD75liO8g+6taS+4oqz+nnroocNfWVHWz7j+N+ZO2vYrc6PV1q7GQhuahL0IOR7JccFTsFKQ/mb6iZWAg=="],
 
-    "@radix-ui/react-toast": ["@radix-ui/react-toast@1.2.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.10", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-visually-hidden": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-nAP5FBxBJGQ/YfUB+r+O6USFVkWq3gAInkxyEnmvEV5jtSbfDhfa4hwX8CraCnbjMLsE7XSf/K75l9xXY7joWg=="],
+    "@remix-run/node-fetch-server": ["@remix-run/node-fetch-server@0.13.3", "", {}, "sha512-UfjOXed/DQteaM5VyTfqTeGpHwyL2J5aoRGY6cydip4tt1ehNNeSwuXCC7AEGE0RWBs/7bgKxYkL/B/+UDe4AA=="],
 
-    "@radix-ui/react-toggle": ["@radix-ui/react-toggle@1.1.9", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-ZoFkBBz9zv9GWer7wIjvdRxmh2wyc2oKWw6C6CseWd6/yq1DK/l5lJ+wnsmFwJZbBYqr02mrf8A2q/CVCuM3ZA=="],
+    "@rolldown/binding-android-arm64": ["@rolldown/binding-android-arm64@1.0.3", "", { "os": "android", "cpu": "arm64" }, "sha512-454rs7jHngixp/NMxd5srYD57OnzSlZ/eFTETjORQHLwJG1lRtmNOJcBerZlfu4GjKqeq8aCCIQrMdHyhI51Hw=="],
 
-    "@radix-ui/react-toggle-group": ["@radix-ui/react-toggle-group@1.1.10", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.10", "@radix-ui/react-toggle": "1.1.9", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-kiU694Km3WFLTC75DdqgM/3Jauf3rD9wxeS9XtyWFKsBUeZA337lC+6uUazT7I1DhanZ5gyD5Stf8uf2dbQxOQ=="],
+    "@rolldown/binding-darwin-arm64": ["@rolldown/binding-darwin-arm64@1.0.3", "", { "os": "darwin", "cpu": "arm64" }, "sha512-PcAhP+ynjURNyy8SKGl5DQP94aGuB/7JrXJb/t7P+hanXvQVMWzUvRRhBAcg/lNRadBhoUPqSoP4xw5tR/KBEA=="],
 
-    "@radix-ui/react-toolbar": ["@radix-ui/react-toolbar@1.1.10", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.10", "@radix-ui/react-separator": "1.1.7", "@radix-ui/react-toggle-group": "1.1.10" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-jiwQsduEL++M4YBIurjSa+voD86OIytCod0/dbIxFZDLD8NfO1//keXYMfsW8BPcfqwoNjt+y06XcJqAb4KR7A=="],
+    "@rolldown/binding-darwin-x64": ["@rolldown/binding-darwin-x64@1.0.3", "", { "os": "darwin", "cpu": "x64" }, "sha512-9YpfeUvSE2RS7wysJ81uOZkXJz7f7Q55H2Gvp3VEw/EsahqDtrphrZ0EwDLK5vvKOzaCrBsjF8JmnMLcUt78Gg=="],
 
-    "@radix-ui/react-tooltip": ["@radix-ui/react-tooltip@1.2.7", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.10", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-popper": "1.2.7", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-visually-hidden": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Ap+fNYwKTYJ9pzqW+Xe2HtMRbQ/EeWkj2qykZ6SuEV4iS/o1bZI5ssJbk4D2r8XuDuOBVz/tIx2JObtuqU+5Zw=="],
+    "@rolldown/binding-freebsd-x64": ["@rolldown/binding-freebsd-x64@1.0.3", "", { "os": "freebsd", "cpu": "x64" }, "sha512-yB1IlAsSNHncV6SCTL27/MVGR5htvQsoGxIv5KMGXALp+Ll1wYsn+x98M9MW7qa+NdSbvrrY7ANI4wLJ0n1e6g=="],
 
-    "@radix-ui/react-use-callback-ref": ["@radix-ui/react-use-callback-ref@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg=="],
+    "@rolldown/binding-linux-arm-gnueabihf": ["@rolldown/binding-linux-arm-gnueabihf@1.0.3", "", { "os": "linux", "cpu": "arm" }, "sha512-Yi30IVAAfLUCy2MseFjbB1jAMDl1VMCAas5StnYp8da9+CKvMd2H2cbEjWcw5NPaPqzvYkVIaF1nNUG+b7u/sw=="],
 
-    "@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+    "@rolldown/binding-linux-arm64-gnu": ["@rolldown/binding-linux-arm64-gnu@1.0.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-jsO7R8To+AdlYgUmN5sHSCZbfhtMBkO0WUx8iORQnPcMMdgr7qM2DQmMwgabs3GhNztdmoKkMKQFHD6DTMCIQw=="],
 
-    "@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+    "@rolldown/binding-linux-arm64-musl": ["@rolldown/binding-linux-arm64-musl@1.0.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-VWkUHwWriDciit80wleYwKILoR/KMvxh/IdwS/paX+ZgpuRpCrKLUdadJbc0NpBEiyhpYawsJ73j9aCvOH+f7Q=="],
 
-    "@radix-ui/react-use-escape-keydown": ["@radix-ui/react-use-escape-keydown@1.1.1", "", { "dependencies": { "@radix-ui/react-use-callback-ref": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g=="],
+    "@rolldown/binding-linux-ppc64-gnu": ["@rolldown/binding-linux-ppc64-gnu@1.0.3", "", { "os": "linux", "cpu": "ppc64" }, "sha512-5f1laC0SlIR0yDbFCd8acUhvJIag6N3zC5P7oUPN6wX0aOma+uKJ0wBDH5aq7I1PVI2ttTlhJwzwRIBnLiSGEg=="],
 
-    "@radix-ui/react-use-is-hydrated": ["@radix-ui/react-use-is-hydrated@0.1.0", "", { "dependencies": { "use-sync-external-store": "^1.5.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-U+UORVEq+cTnRIaostJv9AGdV3G6Y+zbVd+12e18jQ5A3c0xL03IhnHuiU4UV69wolOQp5GfR58NW/EgdQhwOA=="],
+    "@rolldown/binding-linux-s390x-gnu": ["@rolldown/binding-linux-s390x-gnu@1.0.3", "", { "os": "linux", "cpu": "s390x" }, "sha512-Iq4ko0r4XsgbrF/LunNgHtAGLRRVE2kXonAXQ/MV0mC6jQpMOhW1SvtZja2EhC/kd05++bP78dsqBeIQyYJ6Yg=="],
 
-    "@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+    "@rolldown/binding-linux-x64-gnu": ["@rolldown/binding-linux-x64-gnu@1.0.3", "", { "os": "linux", "cpu": "x64" }, "sha512-B8m6tD5+/N5FeNQFbKlLA/2yVq9ycQP1SeedyEYYKWBNR3ZQbkvIUcNnDNM03lO1l5F2roiiFJGgvoLLyZXtSg=="],
 
-    "@radix-ui/react-use-previous": ["@radix-ui/react-use-previous@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ=="],
+    "@rolldown/binding-linux-x64-musl": ["@rolldown/binding-linux-x64-musl@1.0.3", "", { "os": "linux", "cpu": "x64" }, "sha512-pSdpdUJHkuCxun9LE7jvgUB9qsRgaiyNNCX7m/AvHTcq67AiT/Yhoxvw5zPfhrM8k/BfP8ce/hMOpthKDpEUow=="],
 
-    "@radix-ui/react-use-rect": ["@radix-ui/react-use-rect@1.1.1", "", { "dependencies": { "@radix-ui/rect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w=="],
+    "@rolldown/binding-openharmony-arm64": ["@rolldown/binding-openharmony-arm64@1.0.3", "", { "os": "none", "cpu": "arm64" }, "sha512-OXXS3RKJgX2uLwM+gYyuH5omcH8fL1LJs96pZGgtetVCahON57+d4SJHzTgZiOjxgGkSnpXpOsWuPDGAKAigEg=="],
 
-    "@radix-ui/react-use-size": ["@radix-ui/react-use-size@1.1.1", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ=="],
+    "@rolldown/binding-wasm32-wasi": ["@rolldown/binding-wasm32-wasi@1.0.3", "", { "dependencies": { "@emnapi/core": "1.10.0", "@emnapi/runtime": "1.10.0", "@napi-rs/wasm-runtime": "^1.1.4" }, "cpu": "none" }, "sha512-JTtb8BWFynicNSoPrehsCzBtOKjZ6jhMiPFEmOiuXg1Fl8dn2KHQob+GuPSGR0dryQa1PQJbzjF3dqO/whhjLg=="],
 
-    "@radix-ui/react-visually-hidden": ["@radix-ui/react-visually-hidden@1.2.3", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug=="],
+    "@rolldown/binding-win32-arm64-msvc": ["@rolldown/binding-win32-arm64-msvc@1.0.3", "", { "os": "win32", "cpu": "arm64" }, "sha512-gEdFFEN70A/jxb2svrWsN3aDL7OUtmvlOy+6fa2jxG8K0wQ1ZbdeLGnidov6Yu5/733dI5ySfzFlQ/cb0bSz1g=="],
 
-    "@radix-ui/rect": ["@radix-ui/rect@1.1.1", "", {}, "sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw=="],
+    "@rolldown/binding-win32-x64-msvc": ["@rolldown/binding-win32-x64-msvc@1.0.3", "", { "os": "win32", "cpu": "x64" }, "sha512-eXB7CHuaQdqmJcc3koCNtNPmT/bj2gc999kUFgBxG8Ac0NdgXc4rkCHhqrgrhN3zddvvvrgzj1e90SuSfmyIXA=="],
 
-    "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.0-beta.27", "", {}, "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA=="],
+    "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.1", "", {}, "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw=="],
 
     "@rollup/pluginutils": ["@rollup/pluginutils@5.2.0", "", { "dependencies": { "@types/estree": "^1.0.0", "estree-walker": "^2.0.2", "picomatch": "^4.0.2" }, "peerDependencies": { "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-qWJ2ZTbmumwiLFomfzTyt5Kng4hwPi9rwCYN4SHb6eaRU1KNO4ccxINHr/VhH4GgPlt1XfSTLX2LBTme8ne4Zw=="],
 
@@ -350,69 +291,113 @@
 
     "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.45.1", "", { "os": "win32", "cpu": "x64" }, "sha512-M/fKi4sasCdM8i0aWJjCSFm2qEnYRR8AMLG2kxp6wD13+tMGA4Z1tVAuHkNRjud5SW2EM3naLuK35w9twvf6aA=="],
 
-    "@shikijs/core": ["@shikijs/core@1.29.2", "", { "dependencies": { "@shikijs/engine-javascript": "1.29.2", "@shikijs/engine-oniguruma": "1.29.2", "@shikijs/types": "1.29.2", "@shikijs/vscode-textmate": "^10.0.1", "@types/hast": "^3.0.4", "hast-util-to-html": "^9.0.4" } }, "sha512-vju0lY9r27jJfOY4Z7+Rt/nIOjzJpZ3y+nYpqtUZInVoXQ/TJZcfGnNOGnKjFdVZb8qexiCuSlZRKcGfhhTTZQ=="],
+    "@shikijs/core": ["@shikijs/core@3.23.0", "", { "dependencies": { "@shikijs/types": "3.23.0", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4", "hast-util-to-html": "^9.0.5" } }, "sha512-NSWQz0riNb67xthdm5br6lAkvpDJRTgB36fxlo37ZzM2yq0PQFFzbd8psqC2XMPgCzo1fW6cVi18+ArJ44wqgA=="],
 
-    "@shikijs/engine-javascript": ["@shikijs/engine-javascript@1.29.2", "", { "dependencies": { "@shikijs/types": "1.29.2", "@shikijs/vscode-textmate": "^10.0.1", "oniguruma-to-es": "^2.2.0" } }, "sha512-iNEZv4IrLYPv64Q6k7EPpOCE/nuvGiKl7zxdq0WFuRPF5PAE9PRo2JGq/d8crLusM59BRemJ4eOqrFrC4wiQ+A=="],
+    "@shikijs/engine-javascript": ["@shikijs/engine-javascript@3.23.0", "", { "dependencies": { "@shikijs/types": "3.23.0", "@shikijs/vscode-textmate": "^10.0.2", "oniguruma-to-es": "^4.3.4" } }, "sha512-aHt9eiGFobmWR5uqJUViySI1bHMqrAgamWE1TYSUoftkAeCCAiGawPMwM+VCadylQtF4V3VNOZ5LmfItH5f3yA=="],
 
-    "@shikijs/engine-oniguruma": ["@shikijs/engine-oniguruma@1.29.2", "", { "dependencies": { "@shikijs/types": "1.29.2", "@shikijs/vscode-textmate": "^10.0.1" } }, "sha512-7iiOx3SG8+g1MnlzZVDYiaeHe7Ez2Kf2HrJzdmGwkRisT7r4rak0e655AcM/tF9JG/kg5fMNYlLLKglbN7gBqA=="],
+    "@shikijs/engine-oniguruma": ["@shikijs/engine-oniguruma@3.23.0", "", { "dependencies": { "@shikijs/types": "3.23.0", "@shikijs/vscode-textmate": "^10.0.2" } }, "sha512-1nWINwKXxKKLqPibT5f4pAFLej9oZzQTsby8942OTlsJzOBZ0MWKiwzMsd+jhzu8YPCHAswGnnN1YtQfirL35g=="],
 
-    "@shikijs/langs": ["@shikijs/langs@1.29.2", "", { "dependencies": { "@shikijs/types": "1.29.2" } }, "sha512-FIBA7N3LZ+223U7cJDUYd5shmciFQlYkFXlkKVaHsCPgfVLiO+e12FmQE6Tf9vuyEsFe3dIl8qGWKXgEHL9wmQ=="],
+    "@shikijs/langs": ["@shikijs/langs@3.23.0", "", { "dependencies": { "@shikijs/types": "3.23.0" } }, "sha512-2Ep4W3Re5aB1/62RSYQInK9mM3HsLeB91cHqznAJMuylqjzNVAVCMnNWRHFtcNHXsoNRayP9z1qj4Sq3nMqYXg=="],
 
-    "@shikijs/rehype": ["@shikijs/rehype@1.29.2", "", { "dependencies": { "@shikijs/types": "1.29.2", "@types/hast": "^3.0.4", "hast-util-to-string": "^3.0.1", "shiki": "1.29.2", "unified": "^11.0.5", "unist-util-visit": "^5.0.0" } }, "sha512-sxi53HZe5XDz0s2UqF+BVN/kgHPMS9l6dcacM4Ra3ZDzCJa5rDGJ+Ukpk4LxdD1+MITBM6hoLbPfGv9StV8a5Q=="],
+    "@shikijs/rehype": ["@shikijs/rehype@3.23.0", "", { "dependencies": { "@shikijs/types": "3.23.0", "@types/hast": "^3.0.4", "hast-util-to-string": "^3.0.1", "shiki": "3.23.0", "unified": "^11.0.5", "unist-util-visit": "^5.1.0" } }, "sha512-GepKJxXHbXFfAkiZZZ+4V7x71Lw3s0ALYmydUxJRdvpKjSx9FOMSaunv6WRLFBXR6qjYerUq1YZQno+2gLEPwA=="],
 
-    "@shikijs/themes": ["@shikijs/themes@1.29.2", "", { "dependencies": { "@shikijs/types": "1.29.2" } }, "sha512-i9TNZlsq4uoyqSbluIcZkmPL9Bfi3djVxRnofUHwvx/h6SRW3cwgBC5SML7vsDcWyukY0eCzVN980rqP6qNl9g=="],
+    "@shikijs/themes": ["@shikijs/themes@3.23.0", "", { "dependencies": { "@shikijs/types": "3.23.0" } }, "sha512-5qySYa1ZgAT18HR/ypENL9cUSGOeI2x+4IvYJu4JgVJdizn6kG4ia5Q1jDEOi7gTbN4RbuYtmHh0W3eccOrjMA=="],
 
-    "@shikijs/transformers": ["@shikijs/transformers@1.29.2", "", { "dependencies": { "@shikijs/core": "1.29.2", "@shikijs/types": "1.29.2" } }, "sha512-NHQuA+gM7zGuxGWP9/Ub4vpbwrYCrho9nQCLcCPfOe3Yc7LOYwmSuhElI688oiqIXk9dlZwDiyAG9vPBTuPJMA=="],
+    "@shikijs/transformers": ["@shikijs/transformers@3.23.0", "", { "dependencies": { "@shikijs/core": "3.23.0", "@shikijs/types": "3.23.0" } }, "sha512-F9msZVxdF+krQNSdQ4V+Ja5QemeAoTQ2jxt7nJCwhDsdF1JWS3KxIQXA3lQbyKwS3J61oHRUSv4jYWv3CkaKTQ=="],
 
-    "@shikijs/twoslash": ["@shikijs/twoslash@1.29.2", "", { "dependencies": { "@shikijs/core": "1.29.2", "@shikijs/types": "1.29.2", "twoslash": "^0.2.12" } }, "sha512-2S04ppAEa477tiaLfGEn1QJWbZUmbk8UoPbAEw4PifsrxkBXtAtOflIZJNtuCwz8ptc/TPxy7CO7gW4Uoi6o/g=="],
+    "@shikijs/twoslash": ["@shikijs/twoslash@3.23.0", "", { "dependencies": { "@shikijs/core": "3.23.0", "@shikijs/types": "3.23.0", "twoslash": "^0.3.6" }, "peerDependencies": { "typescript": ">=5.5.0" } }, "sha512-pNaLJWMA3LU7PhT8tm9OQBZ1epy0jmdgeJzntBtr1EVXLbHxGzTj3mnf9vOdcl84l96qnlJXkJ/NGXZYBpXl5g=="],
 
-    "@shikijs/types": ["@shikijs/types@1.29.2", "", { "dependencies": { "@shikijs/vscode-textmate": "^10.0.1", "@types/hast": "^3.0.4" } }, "sha512-VJjK0eIijTZf0QSTODEXCqinjBn0joAHQ+aPSBzrv4O2d/QSbsMw+ZeSRx03kV34Hy7NzUvV/7NqfYGRLrASmw=="],
+    "@shikijs/types": ["@shikijs/types@3.23.0", "", { "dependencies": { "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-3JZ5HXOZfYjsYSk0yPwBrkupyYSLpAE26Qc0HLghhZNGTZg/SKxXIIgoxOpmmeQP0RRSDJTk1/vPfw9tbw+jSQ=="],
 
     "@shikijs/vscode-textmate": ["@shikijs/vscode-textmate@10.0.2", "", {}, "sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg=="],
 
-    "@sindresorhus/merge-streams": ["@sindresorhus/merge-streams@2.3.0", "", {}, "sha512-LtoMMhxAlorcGhmFYI+LhPgbPZCkgP6ra1YL604EeF6U98pLlQ3iWIGMdWSC+vWmPBWBNgmDBAhnAobLROJmwg=="],
-
     "@standard-schema/spec": ["@standard-schema/spec@1.0.0", "", {}, "sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA=="],
 
-    "@tailwindcss/node": ["@tailwindcss/node@4.0.7", "", { "dependencies": { "enhanced-resolve": "^5.18.1", "jiti": "^2.4.2", "tailwindcss": "4.0.7" } }, "sha512-dkFXufkbRB2mu3FPsW5xLAUWJyexpJA+/VtQj18k3SUiJVLdpgzBd1v1gRRcIpEJj7K5KpxBKfOXlZxT3ZZRuA=="],
+    "@stitches/core": ["@stitches/core@1.2.8", "", {}, "sha512-Gfkvwk9o9kE9r9XNBmJRfV8zONvXThnm1tcuojL04Uy5uRyqg93DC83lDebl0rocZCfKSjUv+fWYtMQmEDJldg=="],
+
+    "@svgr/babel-plugin-add-jsx-attribute": ["@svgr/babel-plugin-add-jsx-attribute@8.0.0", "", { "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-b9MIk7yhdS1pMCZM8VeNfUlSKVRhsHZNMl5O9SfaX0l0t5wjdgu4IDzGB8bpnGBBOjGST3rRFVsaaEtI4W6f7g=="],
+
+    "@svgr/babel-plugin-remove-jsx-attribute": ["@svgr/babel-plugin-remove-jsx-attribute@8.0.0", "", { "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-BcCkm/STipKvbCl6b7QFrMh/vx00vIP63k2eM66MfHJzPr6O2U0jYEViXkHJWqXqQYjdeA9cuCl5KWmlwjDvbA=="],
+
+    "@svgr/babel-plugin-remove-jsx-empty-expression": ["@svgr/babel-plugin-remove-jsx-empty-expression@8.0.0", "", { "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-5BcGCBfBxB5+XSDSWnhTThfI9jcO5f0Ai2V24gZpG+wXF14BzwxxdDb4g6trdOux0rhibGs385BeFMSmxtS3uA=="],
+
+    "@svgr/babel-plugin-replace-jsx-attribute-value": ["@svgr/babel-plugin-replace-jsx-attribute-value@8.0.0", "", { "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-KVQ+PtIjb1BuYT3ht8M5KbzWBhdAjjUPdlMtpuw/VjT8coTrItWX6Qafl9+ji831JaJcu6PJNKCV0bp01lBNzQ=="],
 
-    "@tailwindcss/oxide": ["@tailwindcss/oxide@4.0.7", "", { "optionalDependencies": { "@tailwindcss/oxide-android-arm64": "4.0.7", "@tailwindcss/oxide-darwin-arm64": "4.0.7", "@tailwindcss/oxide-darwin-x64": "4.0.7", "@tailwindcss/oxide-freebsd-x64": "4.0.7", "@tailwindcss/oxide-linux-arm-gnueabihf": "4.0.7", "@tailwindcss/oxide-linux-arm64-gnu": "4.0.7", "@tailwindcss/oxide-linux-arm64-musl": "4.0.7", "@tailwindcss/oxide-linux-x64-gnu": "4.0.7", "@tailwindcss/oxide-linux-x64-musl": "4.0.7", "@tailwindcss/oxide-win32-arm64-msvc": "4.0.7", "@tailwindcss/oxide-win32-x64-msvc": "4.0.7" } }, "sha512-yr6w5YMgjy+B+zkJiJtIYGXW+HNYOPfRPtSs+aqLnKwdEzNrGv4ZuJh9hYJ3mcA+HMq/K1rtFV+KsEr65S558g=="],
+    "@svgr/babel-plugin-svg-dynamic-title": ["@svgr/babel-plugin-svg-dynamic-title@8.0.0", "", { "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-omNiKqwjNmOQJ2v6ge4SErBbkooV2aAWwaPFs2vUY7p7GhVkzRkJ00kILXQvRhA6miHnNpXv7MRnnSjdRjK8og=="],
 
-    "@tailwindcss/oxide-android-arm64": ["@tailwindcss/oxide-android-arm64@4.0.7", "", { "os": "android", "cpu": "arm64" }, "sha512-5iQXXcAeOHBZy8ASfHFm1k0O/9wR2E3tKh6+P+ilZZbQiMgu+qrnfpBWYPc3FPuQdWiWb73069WT5D+CAfx/tg=="],
+    "@svgr/babel-plugin-svg-em-dimensions": ["@svgr/babel-plugin-svg-em-dimensions@8.0.0", "", { "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-mURHYnu6Iw3UBTbhGwE/vsngtCIbHE43xCRK7kCw4t01xyGqb2Pd+WXekRRoFOBIY29ZoOhUCTEweDMdrjfi9g=="],
 
-    "@tailwindcss/oxide-darwin-arm64": ["@tailwindcss/oxide-darwin-arm64@4.0.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-7yGZtEc5IgVYylqK/2B0yVqoofk4UAbkn1ygNpIJZyrOhbymsfr8uUFCueTu2fUxmAYIfMZ8waWo2dLg/NgLgg=="],
+    "@svgr/babel-plugin-transform-react-native-svg": ["@svgr/babel-plugin-transform-react-native-svg@8.1.0", "", { "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-Tx8T58CHo+7nwJ+EhUwx3LfdNSG9R2OKfaIXXs5soiy5HtgoAEkDay9LIimLOcG8dJQH1wPZp/cnAv6S9CrR1Q=="],
 
-    "@tailwindcss/oxide-darwin-x64": ["@tailwindcss/oxide-darwin-x64@4.0.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-tPQDV20fBjb26yWbPqT1ZSoDChomMCiXTKn4jupMSoMCFyU7+OJvIY1ryjqBuY622dEBJ8LnCDDWsnj1lX9nNQ=="],
+    "@svgr/babel-plugin-transform-svg-component": ["@svgr/babel-plugin-transform-svg-component@8.0.0", "", { "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-DFx8xa3cZXTdb/k3kfPeaixecQLgKh5NVBMwD0AQxOzcZawK4oo1Jh9LbrcACUivsCA7TLG8eeWgrDXjTMhRmw=="],
 
-    "@tailwindcss/oxide-freebsd-x64": ["@tailwindcss/oxide-freebsd-x64@4.0.7", "", { "os": "freebsd", "cpu": "x64" }, "sha512-sZqJpTyTZiknU9LLHuByg5GKTW+u3FqM7q7myequAXxKOpAFiOfXpY710FuMY+gjzSapyRbDXJlsTQtCyiTo5w=="],
+    "@svgr/babel-preset": ["@svgr/babel-preset@8.1.0", "", { "dependencies": { "@svgr/babel-plugin-add-jsx-attribute": "8.0.0", "@svgr/babel-plugin-remove-jsx-attribute": "8.0.0", "@svgr/babel-plugin-remove-jsx-empty-expression": "8.0.0", "@svgr/babel-plugin-replace-jsx-attribute-value": "8.0.0", "@svgr/babel-plugin-svg-dynamic-title": "8.0.0", "@svgr/babel-plugin-svg-em-dimensions": "8.0.0", "@svgr/babel-plugin-transform-react-native-svg": "8.1.0", "@svgr/babel-plugin-transform-svg-component": "8.0.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-7EYDbHE7MxHpv4sxvnVPngw5fuR6pw79SkcrILHJ/iMpuKySNCl5W1qcwPEpU+LgyRXOaAFgH0KhwD18wwg6ug=="],
 
-    "@tailwindcss/oxide-linux-arm-gnueabihf": ["@tailwindcss/oxide-linux-arm-gnueabihf@4.0.7", "", { "os": "linux", "cpu": "arm" }, "sha512-PBgvULgeSswjd8cbZ91gdIcIDMdc3TUHV5XemEpxlqt9M8KoydJzkuB/Dt910jYdofOIaTWRL6adG9nJICvU4A=="],
+    "@svgr/core": ["@svgr/core@8.1.0", "", { "dependencies": { "@babel/core": "^7.21.3", "@svgr/babel-preset": "8.1.0", "camelcase": "^6.2.0", "cosmiconfig": "^8.1.3", "snake-case": "^3.0.4" } }, "sha512-8QqtOQT5ACVlmsvKOJNEaWmRPmcojMOzCz4Hs2BGG/toAp/K38LcsMRyLp349glq5AzJbCEeimEoxaX6v/fLrA=="],
 
-    "@tailwindcss/oxide-linux-arm64-gnu": ["@tailwindcss/oxide-linux-arm64-gnu@4.0.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-By/a2yeh+e9b+C67F88ndSwVJl2A3tcUDb29FbedDi+DZ4Mr07Oqw9Y1DrDrtHIDhIZ3bmmiL1dkH2YxrtV+zw=="],
+    "@svgr/hast-util-to-babel-ast": ["@svgr/hast-util-to-babel-ast@8.0.0", "", { "dependencies": { "@babel/types": "^7.21.3", "entities": "^4.4.0" } }, "sha512-EbDKwO9GpfWP4jN9sGdYwPBU0kdomaPIL2Eu4YwmgP+sJeXT+L7bMwJUBnhzfH8Q2qMBqZ4fJwpCyYsAN3mt2Q=="],
 
-    "@tailwindcss/oxide-linux-arm64-musl": ["@tailwindcss/oxide-linux-arm64-musl@4.0.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-WHYs3cpPEJb/ccyT20NOzopYQkl7JKncNBUbb77YFlwlXMVJLLV3nrXQKhr7DmZxz2ZXqjyUwsj2rdzd9stYdw=="],
+    "@svgr/plugin-jsx": ["@svgr/plugin-jsx@8.1.0", "", { "dependencies": { "@babel/core": "^7.21.3", "@svgr/babel-preset": "8.1.0", "@svgr/hast-util-to-babel-ast": "8.0.0", "svg-parser": "^2.0.4" }, "peerDependencies": { "@svgr/core": "*" } }, "sha512-0xiIyBsLlr8quN+WyuxooNW9RJ0Dpr8uOnH/xrCVO8GLUcwHISwj1AG0k+LFzteTkAA0GbX0kj9q6Dk70PTiPA=="],
 
-    "@tailwindcss/oxide-linux-x64-gnu": ["@tailwindcss/oxide-linux-x64-gnu@4.0.7", "", { "os": "linux", "cpu": "x64" }, "sha512-7bP1UyuX9kFxbOwkeIJhBZNevKYPXB6xZI37v09fqi6rqRJR8elybwjMUHm54GVP+UTtJ14ueB1K54Dy1tIO6w=="],
+    "@tailwindcss/node": ["@tailwindcss/node@4.3.0", "", { "dependencies": { "@jridgewell/remapping": "^2.3.5", "enhanced-resolve": "^5.21.0", "jiti": "^2.6.1", "lightningcss": "1.32.0", "magic-string": "^0.30.21", "source-map-js": "^1.2.1", "tailwindcss": "4.3.0" } }, "sha512-aFb4gUhFOgdh9AXo4IzBEOzBkkAxm9VigwDJnMIYv3lcfXCJVesNfbEaBl4BNgVRyid92AmdviqwBUBRKSeY3g=="],
 
-    "@tailwindcss/oxide-linux-x64-musl": ["@tailwindcss/oxide-linux-x64-musl@4.0.7", "", { "os": "linux", "cpu": "x64" }, "sha512-gBQIV8nL/LuhARNGeroqzXymMzzW5wQzqlteVqOVoqwEfpHOP3GMird5pGFbnpY+NP0fOlsZGrxxOPQ4W/84bQ=="],
+    "@tailwindcss/oxide": ["@tailwindcss/oxide@4.3.0", "", { "optionalDependencies": { "@tailwindcss/oxide-android-arm64": "4.3.0", "@tailwindcss/oxide-darwin-arm64": "4.3.0", "@tailwindcss/oxide-darwin-x64": "4.3.0", "@tailwindcss/oxide-freebsd-x64": "4.3.0", "@tailwindcss/oxide-linux-arm-gnueabihf": "4.3.0", "@tailwindcss/oxide-linux-arm64-gnu": "4.3.0", "@tailwindcss/oxide-linux-arm64-musl": "4.3.0", "@tailwindcss/oxide-linux-x64-gnu": "4.3.0", "@tailwindcss/oxide-linux-x64-musl": "4.3.0", "@tailwindcss/oxide-wasm32-wasi": "4.3.0", "@tailwindcss/oxide-win32-arm64-msvc": "4.3.0", "@tailwindcss/oxide-win32-x64-msvc": "4.3.0" } }, "sha512-F7HZGBeN9I0/AuuJS5PwcD8xayx5ri5GhjYUDBEVYUkexyA/giwbDNjRVrxSezE3T250OU2K/wp/ltWx3UOefg=="],
 
-    "@tailwindcss/oxide-win32-arm64-msvc": ["@tailwindcss/oxide-win32-arm64-msvc@4.0.7", "", { "os": "win32", "cpu": "arm64" }, "sha512-aH530NFfx0kpQpvYMfWoeG03zGnRCMVlQG8do/5XeahYydz+6SIBxA1tl/cyITSJyWZHyVt6GVNkXeAD30v0Xg=="],
+    "@tailwindcss/oxide-android-arm64": ["@tailwindcss/oxide-android-arm64@4.3.0", "", { "os": "android", "cpu": "arm64" }, "sha512-TJPiq67tKlLuObP6RkwvVGDoxCMBVtDgKkLfa/uyj7/FyxvQwHS+UOnVrXXgbEsfUaMgiVvC4KbJnRr26ho4Ng=="],
 
-    "@tailwindcss/oxide-win32-x64-msvc": ["@tailwindcss/oxide-win32-x64-msvc@4.0.7", "", { "os": "win32", "cpu": "x64" }, "sha512-8Cva6bbJN7ZJx320k7vxGGdU0ewmpfS5A4PudyzUuofdi8MgeINuiiWiPQ0VZCda/GX88K6qp+6UpDZNVr8HMQ=="],
+    "@tailwindcss/oxide-darwin-arm64": ["@tailwindcss/oxide-darwin-arm64@4.3.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-oMN/WZRb+SO37BmUElEgeEWuU8E/HXRkiODxJxLe1UTHVXLrdVSgfaJV7pSlhRGMSOiXLuxTIjfsF3wYvz8cgQ=="],
 
-    "@tailwindcss/vite": ["@tailwindcss/vite@4.0.7", "", { "dependencies": { "@tailwindcss/node": "4.0.7", "@tailwindcss/oxide": "4.0.7", "lightningcss": "^1.29.1", "tailwindcss": "4.0.7" }, "peerDependencies": { "vite": "^5.2.0 || ^6" } }, "sha512-GYx5sxArfIMtdZCsxfya3S/efMmf4RvfqdiLUozkhmSFBNUFnYVodatpoO/en4/BsOIGvq/RB6HwcTLn9prFnQ=="],
+    "@tailwindcss/oxide-darwin-x64": ["@tailwindcss/oxide-darwin-x64@4.3.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-N6CUmu4a6bKVADfw77p+iw6Yd9Q3OBhe0veaDX+QazfuVYlQsHfDgxBrsjQ/IW+zywL8mTrNd0SdJT/zgtvMdA=="],
 
-    "@types/babel__core": ["@types/babel__core@7.20.5", "", { "dependencies": { "@babel/parser": "^7.20.7", "@babel/types": "^7.20.7", "@types/babel__generator": "*", "@types/babel__template": "*", "@types/babel__traverse": "*" } }, "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA=="],
+    "@tailwindcss/oxide-freebsd-x64": ["@tailwindcss/oxide-freebsd-x64@4.3.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-zDL5hBkQdH5C6MpqbK3gQAgP80tsMwSI26vjOzjJtNCMUo0lFgOItzHKBIupOZNQxt3ouPH7RPhvNhiTfCe5CQ=="],
 
-    "@types/babel__generator": ["@types/babel__generator@7.27.0", "", { "dependencies": { "@babel/types": "^7.0.0" } }, "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg=="],
+    "@tailwindcss/oxide-linux-arm-gnueabihf": ["@tailwindcss/oxide-linux-arm-gnueabihf@4.3.0", "", { "os": "linux", "cpu": "arm" }, "sha512-R06HdNi7A7OEoMsf6d4tjZ71RCWnZQPHj2mnotSFURjNLdBC+cIgXQ7l81CqeoiQftjf6OOblxXMInMgN2VzMA=="],
 
-    "@types/babel__template": ["@types/babel__template@7.4.4", "", { "dependencies": { "@babel/parser": "^7.1.0", "@babel/types": "^7.0.0" } }, "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A=="],
+    "@tailwindcss/oxide-linux-arm64-gnu": ["@tailwindcss/oxide-linux-arm64-gnu@4.3.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-qTJHELX8jetjhRQHCLilkVLmybpzNQAtaI/gaoVoidn/ufbNDbAo8KlK2J+yPoc8wQxvDxCmh/5lr8nC1+lTbg=="],
 
-    "@types/babel__traverse": ["@types/babel__traverse@7.20.7", "", { "dependencies": { "@babel/types": "^7.20.7" } }, "sha512-dkO5fhS7+/oos4ciWxyEyjWe48zmG6wbCheo/G2ZnHx4fs3EU6YC6UM8rk56gAjNJ9P3MTH2jo5jb92/K6wbng=="],
+    "@tailwindcss/oxide-linux-arm64-musl": ["@tailwindcss/oxide-linux-arm64-musl@4.3.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-Z6sukiQsngnWO+l39X4pPbiWT81IC+PLKF+PHxIlyZbGNb9MODfYlXEVlFvej5BOZInWX01kVyzeLvHsXhfczQ=="],
+
+    "@tailwindcss/oxide-linux-x64-gnu": ["@tailwindcss/oxide-linux-x64-gnu@4.3.0", "", { "os": "linux", "cpu": "x64" }, "sha512-DRNdQRpSGzRGfARVuVkxvM8Q12nh19l4BF/G7zGA1oe+9wcC6saFBHTISrpIcKzhiXtSrlSrluCfvMuledoCTQ=="],
+
+    "@tailwindcss/oxide-linux-x64-musl": ["@tailwindcss/oxide-linux-x64-musl@4.3.0", "", { "os": "linux", "cpu": "x64" }, "sha512-Z0IADbDo8bh6I7h2IQMx601AdXBLfFpEdUotft86evd/8ZPflZe9COPO8Q1vw+pfLWIUo9zN/JGZvwuAJqduqg=="],
+
+    "@tailwindcss/oxide-wasm32-wasi": ["@tailwindcss/oxide-wasm32-wasi@4.3.0", "", { "dependencies": { "@emnapi/core": "^1.10.0", "@emnapi/runtime": "^1.10.0", "@emnapi/wasi-threads": "^1.2.1", "@napi-rs/wasm-runtime": "^1.1.4", "@tybys/wasm-util": "^0.10.1", "tslib": "^2.8.1" }, "cpu": "none" }, "sha512-HNZGOUxEmElksYR7S6sC5jTeNGpobAsy9u7Gu0AskJ8/20FR9GqebUyB+HBcU/ax6BHuiuJi+Oda4B+YX6H1yA=="],
+
+    "@tailwindcss/oxide-win32-arm64-msvc": ["@tailwindcss/oxide-win32-arm64-msvc@4.3.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-Pe+RPVTi1T+qymuuRpcdvwSVZjnll/f7n8gBxMMh3xLTctMDKqpdfGimbMyioqtLhUYZxdJ9wGNhV7MKHvgZsQ=="],
+
+    "@tailwindcss/oxide-win32-x64-msvc": ["@tailwindcss/oxide-win32-x64-msvc@4.3.0", "", { "os": "win32", "cpu": "x64" }, "sha512-Mvrf2kXW/yeW/OTezZlCGOirXRcUuLIBx/5Y12BaPM7wJoryG6dfS/NJL8aBPqtTEx/Vm4T4vKzFUcKDT+TKUA=="],
+
+    "@tailwindcss/vite": ["@tailwindcss/vite@4.3.0", "", { "dependencies": { "@tailwindcss/node": "4.3.0", "@tailwindcss/oxide": "4.3.0", "tailwindcss": "4.3.0" }, "peerDependencies": { "vite": "^5.2.0 || ^6 || ^7 || ^8" } }, "sha512-t6J3OrB5Fc0ExuhohouH0fWUGMYL6PTLhW+E7zIk/pdbnJARZDCwjBznFnkh5ynRnIRSI4YjtTH0t6USjJISrw=="],
+
+    "@takumi-rs/core": ["@takumi-rs/core@0.62.8", "", { "optionalDependencies": { "@takumi-rs/core-darwin-arm64": "0.62.8", "@takumi-rs/core-darwin-x64": "0.62.8", "@takumi-rs/core-linux-arm64-gnu": "0.62.8", "@takumi-rs/core-linux-arm64-musl": "0.62.8", "@takumi-rs/core-linux-x64-gnu": "0.62.8", "@takumi-rs/core-linux-x64-musl": "0.62.8", "@takumi-rs/core-win32-arm64-msvc": "0.62.8", "@takumi-rs/core-win32-x64-msvc": "0.62.8" } }, "sha512-1KNknsY0r9+fhvMD4gijFuJ2qx63JIVII1dZLiz8/YuZ3mFd9IFW90RTeeAdsP83lNCn6nWCrR8W2hLQgjjCCg=="],
+
+    "@takumi-rs/core-darwin-arm64": ["@takumi-rs/core-darwin-arm64@0.62.8", "", { "os": "darwin", "cpu": "arm64" }, "sha512-TxVakpycL4g99i2mmLp7abKaQXMCirkrmIXOmQtOaezwsX+yKzDqfm8XH3fhhj5febqgtpHkNvKus8F5k81RHQ=="],
+
+    "@takumi-rs/core-darwin-x64": ["@takumi-rs/core-darwin-x64@0.62.8", "", { "os": "darwin", "cpu": "x64" }, "sha512-2a9TzXpPkpUUBc3dSU3BZAriBuLTPpVc0LzIvI72sp9qyYAVn5Itry+z1Xl+nt5As/xkFdOJccqQxe7tLLBtpQ=="],
+
+    "@takumi-rs/core-linux-arm64-gnu": ["@takumi-rs/core-linux-arm64-gnu@0.62.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-e8Oe1aOFew+1rbu9y5JRaDvLqw4FqGJx1uPLo5mfdYQKWZ3ltdFseRUCCQI3rOXMXKz6uIWRuHd3Qw5sBp+wJg=="],
+
+    "@takumi-rs/core-linux-arm64-musl": ["@takumi-rs/core-linux-arm64-musl@0.62.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-qR04H4DQfFsKmkl2kq/fh48zTC3QqBdvHjmHzJUckIktvJPKk1aK+jERIXeARkH6pfQuq+NI5Kbl1t9//qb8nQ=="],
+
+    "@takumi-rs/core-linux-x64-gnu": ["@takumi-rs/core-linux-x64-gnu@0.62.8", "", { "os": "linux", "cpu": "x64" }, "sha512-/LouBAUVqK5/H3pwzOnitRz4JEJNrGJEN/L3TU0375M+uXFewWAl2iSwFqgMt9vCtKPrKa/oK+Iy3pdvFAnX2w=="],
+
+    "@takumi-rs/core-linux-x64-musl": ["@takumi-rs/core-linux-x64-musl@0.62.8", "", { "os": "linux", "cpu": "x64" }, "sha512-FIt0fpowyh9dse8F29cYBPVhrdc7Zzjz1pEyJunNzIzCIpC0yG3eUwFnK0wsoYoyzbgVZkbLRFRRAFmUORLvDg=="],
+
+    "@takumi-rs/core-win32-arm64-msvc": ["@takumi-rs/core-win32-arm64-msvc@0.62.8", "", { "os": "win32", "cpu": "arm64" }, "sha512-ucQmG2bp6yH+7oNQUev+0re+6FBHUOUcee4mwpQa+BKCtUSgkgQuw3ZAGdyXBQEfr3NrNsMqfc47b3Ljv3bIWA=="],
+
+    "@takumi-rs/core-win32-x64-msvc": ["@takumi-rs/core-win32-x64-msvc@0.62.8", "", { "os": "win32", "cpu": "x64" }, "sha512-KxntZ5d7Cu87WQx0AUw0yzZ3AQuTjeTPZMe4MhYdQbgqw4y6hyOqUL3fz8z80/jh6XxLNHBgcBC0nn9FvJnvSw=="],
+
+    "@takumi-rs/helpers": ["@takumi-rs/helpers@0.62.8", "", {}, "sha512-9qRFeuk0yTvAeVAaQoU2uW1XeigbTBta/fTReHxEsa0hYqyJe4gM4YicA0D29tfObhSRJUN/j2b2WmHuADAmcQ=="],
+
+    "@takumi-rs/image-response": ["@takumi-rs/image-response@0.62.8", "", { "dependencies": { "@takumi-rs/core": "0.62.8", "@takumi-rs/helpers": "0.62.8", "@takumi-rs/wasm": "0.62.8" } }, "sha512-he79pvjif5psP8jyDiugUph3qbvKl7SaMetIuYUCI1asES5NMW3yw/nY2zQd73gqwqverhfnOEO/k4we6UxiIA=="],
+
+    "@takumi-rs/wasm": ["@takumi-rs/wasm@0.62.8", "", {}, "sha512-V3L4LMoa1hqUxYel+j2oaIYhx7TdfSI/5iStU+7sTDru3o0gwJxw923jG66/F+lLSPGeY4rmYejcJCJN5VfpBA=="],
+
+    "@tybys/wasm-util": ["@tybys/wasm-util@0.10.2", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg=="],
 
     "@types/d3": ["@types/d3@7.4.3", "", { "dependencies": { "@types/d3-array": "*", "@types/d3-axis": "*", "@types/d3-brush": "*", "@types/d3-chord": "*", "@types/d3-color": "*", "@types/d3-contour": "*", "@types/d3-delaunay": "*", "@types/d3-dispatch": "*", "@types/d3-drag": "*", "@types/d3-dsv": "*", "@types/d3-ease": "*", "@types/d3-fetch": "*", "@types/d3-force": "*", "@types/d3-format": "*", "@types/d3-geo": "*", "@types/d3-hierarchy": "*", "@types/d3-interpolate": "*", "@types/d3-path": "*", "@types/d3-polygon": "*", "@types/d3-quadtree": "*", "@types/d3-random": "*", "@types/d3-scale": "*", "@types/d3-scale-chromatic": "*", "@types/d3-selection": "*", "@types/d3-shape": "*", "@types/d3-time": "*", "@types/d3-time-format": "*", "@types/d3-timer": "*", "@types/d3-transition": "*", "@types/d3-zoom": "*" } }, "sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww=="],
 
-    "@types/d3-array": ["@types/d3-array@3.2.1", "", {}, "sha512-Y2Jn2idRrLzUfAKV2LyRImR+y4oa2AntrgID95SHJxuMUrkNXmanDSed71sRNZysveJVt1hLLemQZIady0FpEg=="],
+    "@types/d3-array": ["@types/d3-array@3.2.2", "", {}, "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw=="],
 
     "@types/d3-axis": ["@types/d3-axis@3.0.6", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-pYeijfZuBd87T0hGn0FO1vQ/cgLk6E1ALJjfkC0oJ8cbwkZl3TpgS8bVBLZN+2jjGgg38epgxb2zmoGtSfvgMw=="],
 
@@ -426,7 +411,7 @@
 
     "@types/d3-delaunay": ["@types/d3-delaunay@6.0.4", "", {}, "sha512-ZMaSKu4THYCU6sV64Lhg6qjf1orxBthaC161plr5KuPHo3CNm8DTHiLw/5Eq2b6TsNP0W0iJrUOFscY6Q450Hw=="],
 
-    "@types/d3-dispatch": ["@types/d3-dispatch@3.0.6", "", {}, "sha512-4fvZhzMeeuBJYZXRXrRIQnvUYfyXwYmLsdiN7XXmVNQKKw1cM8a5WdID0g1hVFZDqT9ZqZEY5pD44p24VS7iZQ=="],
+    "@types/d3-dispatch": ["@types/d3-dispatch@3.0.7", "", {}, "sha512-5o9OIAdKkhN1QItV2oqaE5KMIiXAvDWBDPrD85e58Qlz1c1kI/J0NcqbEG88CoTwJrYe7ntUCVfeUl2UJKbWgA=="],
 
     "@types/d3-drag": ["@types/d3-drag@3.0.7", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ=="],
 
@@ -460,7 +445,7 @@
 
     "@types/d3-selection": ["@types/d3-selection@3.0.11", "", {}, "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w=="],
 
-    "@types/d3-shape": ["@types/d3-shape@3.1.7", "", { "dependencies": { "@types/d3-path": "*" } }, "sha512-VLvUQ33C+3J+8p+Daf+nYSOsjB4GXp19/S/aGo60m9h1v6XaxjiT82lKVWJCfzhtuZ3yD7i/TPeC/fuKLLOSmg=="],
+    "@types/d3-shape": ["@types/d3-shape@3.1.8", "", { "dependencies": { "@types/d3-path": "*" } }, "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w=="],
 
     "@types/d3-time": ["@types/d3-time@3.0.4", "", {}, "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g=="],
 
@@ -482,6 +467,8 @@
 
     "@types/hast": ["@types/hast@3.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ=="],
 
+    "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="],
+
     "@types/mdast": ["@types/mdast@4.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA=="],
 
     "@types/mdx": ["@types/mdx@2.0.13", "", {}, "sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw=="],
@@ -496,39 +483,77 @@
 
     "@types/unist": ["@types/unist@3.0.3", "", {}, "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q=="],
 
-    "@typescript/vfs": ["@typescript/vfs@1.6.1", "", { "dependencies": { "debug": "^4.1.1" }, "peerDependencies": { "typescript": "*" } }, "sha512-JwoxboBh7Oz1v38tPbkrZ62ZXNHAk9bJ7c9x0eI5zBfBnBYGhURdbnh7Z4smN/MV48Y5OCcZb58n972UtbazsA=="],
+    "@typescript/vfs": ["@typescript/vfs@1.6.4", "", { "dependencies": { "debug": "^4.4.3" }, "peerDependencies": { "typescript": "*" } }, "sha512-PJFXFS4ZJKiJ9Qiuix6Dz/OwEIqHD7Dme1UwZhTK11vR+5dqW2ACbdndWQexBzCx+CPuMe5WBYQWCsFyGlQLlQ=="],
 
     "@ungap/structured-clone": ["@ungap/structured-clone@1.3.0", "", {}, "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g=="],
 
-    "@vanilla-extract/babel-plugin-debug-ids": ["@vanilla-extract/babel-plugin-debug-ids@1.2.2", "", { "dependencies": { "@babel/core": "^7.23.9" } }, "sha512-MeDWGICAF9zA/OZLOKwhoRlsUW+fiMwnfuOAqFVohL31Agj7Q/RBWAYweqjHLgFBCsdnr6XIfwjJnmb2znEWxw=="],
+    "@upsetjs/venn.js": ["@upsetjs/venn.js@2.0.0", "", { "optionalDependencies": { "d3-selection": "^3.0.0", "d3-transition": "^3.0.1" } }, "sha512-WbBhLrooyePuQ1VZxrJjtLvTc4NVfpOyKx0sKqioq9bX1C1m7Jgykkn8gLrtwumBioXIqam8DLxp88Adbue6Hw=="],
 
-    "@vanilla-extract/compiler": ["@vanilla-extract/compiler@0.7.0", "", { "dependencies": { "@vanilla-extract/css": "^1.20.1", "@vanilla-extract/integration": "^8.0.9", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0", "vite-node": "^3.2.2 || ^5.0.0 || ^6.0.0" } }, "sha512-rZQ40HVmsxfGLjoflwwsaUBLfpbpKDoZC19oiDA0FHq4LdrYtyVbFkc0MfqkNo/qBCvaZfsRezCqk0QQxCqZ8w=="],
+    "@vitejs/plugin-react": ["@vitejs/plugin-react@6.0.2", "", { "dependencies": { "@rolldown/pluginutils": "^1.0.0" }, "peerDependencies": { "@rolldown/plugin-babel": "^0.1.7 || ^0.2.0", "babel-plugin-react-compiler": "^1.0.0", "vite": "^8.0.0" }, "optionalPeers": ["@rolldown/plugin-babel", "babel-plugin-react-compiler"] }, "sha512-DlSMqo4WhThw4vB8Mpn0Woe9J+Jfq1geJ61AKW0QEgLzGMNwtIMdxbDUzLxcun8W7NbJO0e2Jg/Nxm3cCSVzzg=="],
 
-    "@vanilla-extract/css": ["@vanilla-extract/css@1.20.1", "", { "dependencies": { "@emotion/hash": "^0.9.0", "@vanilla-extract/private": "^1.0.9", "css-what": "^6.1.0", "csstype": "^3.2.3", "dedent": "^1.5.3", "deep-object-diff": "^1.1.9", "deepmerge": "^4.2.2", "lru-cache": "^10.4.3", "media-query-parser": "^2.0.2", "modern-ahocorasick": "^1.0.0", "picocolors": "^1.0.0" } }, "sha512-5I9RNo5uZW9tsBnqrWzJqELegOqTHBrZyDFnES0gR9gJJHBB9dom1N0bwITM9tKwBcfKrTX4a6DHVeQdJ2ubQA=="],
+    "@vitejs/plugin-rsc": ["@vitejs/plugin-rsc@0.5.27", "", { "dependencies": { "@rolldown/pluginutils": "^1.0.1", "es-module-lexer": "^2.1.0", "estree-walker": "^3.0.3", "magic-string": "^0.30.21", "srvx": "^0.11.15", "strip-literal": "^3.1.0", "turbo-stream": "^3.2.0", "vitefu": "^1.1.3" }, "peerDependencies": { "react": "*", "react-dom": "*", "react-server-dom-webpack": "*", "vite": "*" }, "optionalPeers": ["react-server-dom-webpack"] }, "sha512-s1fd5DUkPXk86DDHPM/kP93WrvI0MoA8klxdDZmD1fMSaA9xujfgunsm8ZoUH0FemR+63vNalFsIDR0AJH4ktg=="],
 
-    "@vanilla-extract/dynamic": ["@vanilla-extract/dynamic@2.1.5", "", { "dependencies": { "@vanilla-extract/private": "^1.0.9" } }, "sha512-QGIFGb1qyXQkbzx6X6i3+3LMc/iv/ZMBttMBL+Wm/DetQd36KsKsFg5CtH3qy+1hCA/5w93mEIIAiL4fkM8ycw=="],
+    "@webassemblyjs/ast": ["@webassemblyjs/ast@1.14.1", "", { "dependencies": { "@webassemblyjs/helper-numbers": "1.13.2", "@webassemblyjs/helper-wasm-bytecode": "1.13.2" } }, "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ=="],
 
-    "@vanilla-extract/integration": ["@vanilla-extract/integration@8.0.10", "", { "dependencies": { "@babel/core": "^7.23.9", "@babel/plugin-syntax-typescript": "^7.23.3", "@vanilla-extract/babel-plugin-debug-ids": "^1.2.2", "@vanilla-extract/css": "^1.20.1", "dedent": "^1.5.3", "esbuild": "npm:esbuild@>=0.17.6 <0.29.0", "eval": "0.1.8", "find-up": "^5.0.0", "javascript-stringify": "^2.0.1", "mlly": "^1.4.2" } }, "sha512-01IB5gbrgTe8IIrtfRXXTmACl5D8Enzqp2cKbCWaMKXmnoilXXVCPbJoA96q88PXkNDXsXepCxUugMvEmL3c7A=="],
+    "@webassemblyjs/floating-point-hex-parser": ["@webassemblyjs/floating-point-hex-parser@1.13.2", "", {}, "sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA=="],
 
-    "@vanilla-extract/private": ["@vanilla-extract/private@1.0.9", "", {}, "sha512-gT2jbfZuaaCLrAxwXbRgIhGhcXbRZCG3v4TTUnjw0EJ7ArdBRxkq4msNJkbuRkCgfIK5ATmprB5t9ljvLeFDEA=="],
+    "@webassemblyjs/helper-api-error": ["@webassemblyjs/helper-api-error@1.13.2", "", {}, "sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ=="],
 
-    "@vanilla-extract/vite-plugin": ["@vanilla-extract/vite-plugin@5.2.2", "", { "dependencies": { "@vanilla-extract/compiler": "^0.7.0", "@vanilla-extract/integration": "^8.0.9" }, "peerDependencies": { "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-AUyB4fDR2b/Mo0lcXhhlf6RxnDPYwFMyKKopalJ4BwQNKYzZSoTwHJ1PLPO9SKhpz7lzXc0Z18GHQZOewzl3YA=="],
+    "@webassemblyjs/helper-buffer": ["@webassemblyjs/helper-buffer@1.14.1", "", {}, "sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA=="],
 
-    "@vitejs/plugin-react": ["@vitejs/plugin-react@4.7.0", "", { "dependencies": { "@babel/core": "^7.28.0", "@babel/plugin-transform-react-jsx-self": "^7.27.1", "@babel/plugin-transform-react-jsx-source": "^7.27.1", "@rolldown/pluginutils": "1.0.0-beta.27", "@types/babel__core": "^7.20.5", "react-refresh": "^0.17.0" }, "peerDependencies": { "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" } }, "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA=="],
+    "@webassemblyjs/helper-numbers": ["@webassemblyjs/helper-numbers@1.13.2", "", { "dependencies": { "@webassemblyjs/floating-point-hex-parser": "1.13.2", "@webassemblyjs/helper-api-error": "1.13.2", "@xtuc/long": "4.2.2" } }, "sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA=="],
 
-    "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+    "@webassemblyjs/helper-wasm-bytecode": ["@webassemblyjs/helper-wasm-bytecode@1.13.2", "", {}, "sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA=="],
+
+    "@webassemblyjs/helper-wasm-section": ["@webassemblyjs/helper-wasm-section@1.14.1", "", { "dependencies": { "@webassemblyjs/ast": "1.14.1", "@webassemblyjs/helper-buffer": "1.14.1", "@webassemblyjs/helper-wasm-bytecode": "1.13.2", "@webassemblyjs/wasm-gen": "1.14.1" } }, "sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw=="],
+
+    "@webassemblyjs/ieee754": ["@webassemblyjs/ieee754@1.13.2", "", { "dependencies": { "@xtuc/ieee754": "^1.2.0" } }, "sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw=="],
+
+    "@webassemblyjs/leb128": ["@webassemblyjs/leb128@1.13.2", "", { "dependencies": { "@xtuc/long": "4.2.2" } }, "sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw=="],
+
+    "@webassemblyjs/utf8": ["@webassemblyjs/utf8@1.13.2", "", {}, "sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ=="],
+
+    "@webassemblyjs/wasm-edit": ["@webassemblyjs/wasm-edit@1.14.1", "", { "dependencies": { "@webassemblyjs/ast": "1.14.1", "@webassemblyjs/helper-buffer": "1.14.1", "@webassemblyjs/helper-wasm-bytecode": "1.13.2", "@webassemblyjs/helper-wasm-section": "1.14.1", "@webassemblyjs/wasm-gen": "1.14.1", "@webassemblyjs/wasm-opt": "1.14.1", "@webassemblyjs/wasm-parser": "1.14.1", "@webassemblyjs/wast-printer": "1.14.1" } }, "sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ=="],
+
+    "@webassemblyjs/wasm-gen": ["@webassemblyjs/wasm-gen@1.14.1", "", { "dependencies": { "@webassemblyjs/ast": "1.14.1", "@webassemblyjs/helper-wasm-bytecode": "1.13.2", "@webassemblyjs/ieee754": "1.13.2", "@webassemblyjs/leb128": "1.13.2", "@webassemblyjs/utf8": "1.13.2" } }, "sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg=="],
+
+    "@webassemblyjs/wasm-opt": ["@webassemblyjs/wasm-opt@1.14.1", "", { "dependencies": { "@webassemblyjs/ast": "1.14.1", "@webassemblyjs/helper-buffer": "1.14.1", "@webassemblyjs/wasm-gen": "1.14.1", "@webassemblyjs/wasm-parser": "1.14.1" } }, "sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw=="],
+
+    "@webassemblyjs/wasm-parser": ["@webassemblyjs/wasm-parser@1.14.1", "", { "dependencies": { "@webassemblyjs/ast": "1.14.1", "@webassemblyjs/helper-api-error": "1.13.2", "@webassemblyjs/helper-wasm-bytecode": "1.13.2", "@webassemblyjs/ieee754": "1.13.2", "@webassemblyjs/leb128": "1.13.2", "@webassemblyjs/utf8": "1.13.2" } }, "sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ=="],
+
+    "@webassemblyjs/wast-printer": ["@webassemblyjs/wast-printer@1.14.1", "", { "dependencies": { "@webassemblyjs/ast": "1.14.1", "@xtuc/long": "4.2.2" } }, "sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw=="],
+
+    "@xtuc/ieee754": ["@xtuc/ieee754@1.2.0", "", {}, "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA=="],
+
+    "@xtuc/long": ["@xtuc/long@4.2.2", "", {}, "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ=="],
+
+    "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="],
+
+    "acorn": ["acorn@8.16.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw=="],
+
+    "acorn-import-phases": ["acorn-import-phases@1.0.4", "", { "peerDependencies": { "acorn": "^8.14.0" } }, "sha512-wKmbr/DDiIXzEOiWrTTUcDm24kQ2vGfZQvM2fwg2vXqR5uW6aapr7ObPtj1th32b9u90/Pf4AItvdTh42fBmVQ=="],
 
     "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="],
 
+    "acorn-loose": ["acorn-loose@8.5.2", "", { "dependencies": { "acorn": "^8.15.0" } }, "sha512-PPvV6g8UGMGgjrMu+n/f9E/tCSkNQ2Y97eFvuVdJfG11+xdIeDcLyNdC8SHcrHbRqkfwLASdplyR6B6sKM1U4A=="],
+
+    "ajv": ["ajv@8.20.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA=="],
+
+    "ajv-formats": ["ajv-formats@3.0.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ=="],
+
+    "ajv-keywords": ["ajv-keywords@5.1.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3" }, "peerDependencies": { "ajv": "^8.8.2" } }, "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw=="],
+
+    "anser": ["anser@2.3.5", "", {}, "sha512-vcZjxvvVoxTeR5XBNJB38oTu/7eDCZlwdz32N1eNgpyPF7j/Z7Idf+CUwQOkKKpJ7RJyjxgLHCM7vdIK0iCNMQ=="],
+
     "ansi-regex": ["ansi-regex@6.1.0", "", {}, "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA=="],
 
     "ansi-styles": ["ansi-styles@6.2.1", "", {}, "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug=="],
 
-    "aria-hidden": ["aria-hidden@1.2.6", "", { "dependencies": { "tslib": "^2.0.0" } }, "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA=="],
+    "any-promise": ["any-promise@1.3.0", "", {}, "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A=="],
 
-    "astring": ["astring@1.9.0", "", { "bin": { "astring": "bin/astring" } }, "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg=="],
+    "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],
 
-    "autoprefixer": ["autoprefixer@10.4.21", "", { "dependencies": { "browserslist": "^4.24.4", "caniuse-lite": "^1.0.30001702", "fraction.js": "^4.3.7", "normalize-range": "^0.1.2", "picocolors": "^1.1.1", "postcss-value-parser": "^4.2.0" }, "peerDependencies": { "postcss": "^8.1.0" }, "bin": { "autoprefixer": "bin/autoprefixer" } }, "sha512-O+A6LWV5LDHSJD3LjHYoNi4VLsj/Whi7k6zG12xTYaU4cQ8oxQGckXNX8cRHK5yOZ/ppVHe0ZBXGzSV9jXdVbQ=="],
+    "astring": ["astring@1.9.0", "", { "bin": { "astring": "bin/astring" } }, "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg=="],
 
     "bail": ["bail@2.0.2", "", {}, "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw=="],
 
@@ -536,29 +561,33 @@
 
     "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="],
 
-    "bcp-47-match": ["bcp-47-match@2.0.3", "", {}, "sha512-JtTezzbAibu8G0R9op9zb3vcWZd9JF6M0xOYGPn0fNCd7wOpRB1mU2mH9T8gaBGbAAyIIVgB2G7xG0GP98zMAQ=="],
+    "baseline-browser-mapping": ["baseline-browser-mapping@2.10.33", "", { "bin": { "baseline-browser-mapping": "dist/cli.cjs" } }, "sha512-bA6+tcSLpz2tIEdDXZPpPTIuxBcC4+w6SieaYyfigIa4h8GlFxbA17v22Vx3JUtuZQj9SgOsnbK+aTBzyDyEuw=="],
 
-    "bl": ["bl@5.1.0", "", { "dependencies": { "buffer": "^6.0.3", "inherits": "^2.0.4", "readable-stream": "^3.4.0" } }, "sha512-tv1ZJHLfTDnXE6tMHv73YgSJaWR2AFuPwMntBe7XL/GBFHnT0CLnsHMogfk5+GzCDC5ZWarSCYaIGATZt9dNsQ=="],
-
-    "boolbase": ["boolbase@1.0.0", "", {}, "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww=="],
+    "body-parser": ["body-parser@2.2.2", "", { "dependencies": { "bytes": "^3.1.2", "content-type": "^1.0.5", "debug": "^4.4.3", "http-errors": "^2.0.0", "iconv-lite": "^0.7.0", "on-finished": "^2.4.1", "qs": "^6.14.1", "raw-body": "^3.0.1", "type-is": "^2.0.1" } }, "sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA=="],
 
     "brace-expansion": ["brace-expansion@5.0.5", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ=="],
 
-    "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="],
-
-    "browserslist": ["browserslist@4.25.1", "", { "dependencies": { "caniuse-lite": "^1.0.30001726", "electron-to-chromium": "^1.5.173", "node-releases": "^2.0.19", "update-browserslist-db": "^1.1.3" }, "bin": { "browserslist": "cli.js" } }, "sha512-KGj0KoOMXLpSNkkEI6Z6mShmQy0bc1I+T7K9N81k4WWMrfz+6fQ6es80B/YLAeRoKvjYE1YSHHOW1qe9xIVzHw=="],
+    "browserslist": ["browserslist@4.28.2", "", { "dependencies": { "baseline-browser-mapping": "^2.10.12", "caniuse-lite": "^1.0.30001782", "electron-to-chromium": "^1.5.328", "node-releases": "^2.0.36", "update-browserslist-db": "^1.2.3" }, "bin": { "browserslist": "cli.js" } }, "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg=="],
 
     "buffer": ["buffer@6.0.3", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.2.1" } }, "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA=="],
 
+    "buffer-from": ["buffer-from@1.1.2", "", {}, "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="],
+
     "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],
 
     "cac": ["cac@6.7.14", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="],
 
-    "caniuse-lite": ["caniuse-lite@1.0.30001727", "", {}, "sha512-pB68nIHmbN6L/4C6MH1DokyR3bYqFwjaSs/sWDHGj4CTcFtQUQMuJftVwWkXq7mNWOybD3KhUv3oWHoGxgP14Q=="],
+    "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="],
 
-    "ccount": ["ccount@2.0.1", "", {}, "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg=="],
+    "call-bound": ["call-bound@1.0.4", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" } }, "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg=="],
+
+    "callsites": ["callsites@3.1.0", "", {}, "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="],
 
-    "chalk": ["chalk@5.4.1", "", {}, "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w=="],
+    "camelcase": ["camelcase@6.3.0", "", {}, "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA=="],
+
+    "caniuse-lite": ["caniuse-lite@1.0.30001793", "", {}, "sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA=="],
+
+    "ccount": ["ccount@2.0.1", "", {}, "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg=="],
 
     "character-entities": ["character-entities@2.0.2", "", {}, "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ=="],
 
@@ -568,15 +597,9 @@
 
     "character-reference-invalid": ["character-reference-invalid@2.0.1", "", {}, "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw=="],
 
-    "chevrotain": ["chevrotain@11.0.3", "", { "dependencies": { "@chevrotain/cst-dts-gen": "11.0.3", "@chevrotain/gast": "11.0.3", "@chevrotain/regexp-to-ast": "11.0.3", "@chevrotain/types": "11.0.3", "@chevrotain/utils": "11.0.3", "lodash-es": "4.17.21" } }, "sha512-ci2iJH6LeIkvP9eJW6gpueU8cnZhv85ELY8w8WiFtNjMHA5ad6pQLaJo9mEly/9qUyCpvqX8/POVUTf18/HFdw=="],
-
-    "chevrotain-allstar": ["chevrotain-allstar@0.3.1", "", { "dependencies": { "lodash-es": "^4.17.21" }, "peerDependencies": { "chevrotain": "^11.0.0" } }, "sha512-b7g+y9A0v4mxCW1qUhf3BSVPg+/NvGErk/dOkrDaHA0nQIQGAtrOjlX//9OQtRlSCy+x9rfB5N8yC71lH1nvMw=="],
-
-    "chroma-js": ["chroma-js@3.1.2", "", {}, "sha512-IJnETTalXbsLx1eKEgx19d5L6SRM7cH4vINw/99p/M11HCuXGRWL+6YmCm7FWFGIo6dtWuQoQi1dc5yQ7ESIHg=="],
+    "chrome-trace-event": ["chrome-trace-event@1.0.4", "", {}, "sha512-rNjApaLzuwaOTjCiT8lSDdGN1APCiqkChLMJxJPWLunPAt5fy8xgU9/jNOchV84wfIxrA0lRQB7oCT8jrn/wrQ=="],
 
-    "cli-cursor": ["cli-cursor@4.0.0", "", { "dependencies": { "restore-cursor": "^4.0.0" } }, "sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg=="],
-
-    "cli-spinners": ["cli-spinners@2.9.2", "", {}, "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg=="],
+    "clean-set": ["clean-set@1.1.2", "", {}, "sha512-cA8uCj0qSoG9e0kevyOWXwPaELRPVg5Pxp6WskLMwerx257Zfnh8Nl0JBH59d7wQzij2CK7qEfJQK3RjuKKIug=="],
 
     "clsx": ["clsx@2.1.1", "", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="],
 
@@ -588,36 +611,42 @@
 
     "comma-separated-tokens": ["comma-separated-tokens@2.0.3", "", {}, "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg=="],
 
-    "commander": ["commander@8.3.0", "", {}, "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww=="],
+    "commander": ["commander@2.20.3", "", {}, "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="],
 
-    "compressible": ["compressible@2.0.18", "", { "dependencies": { "mime-db": ">= 1.43.0 < 2" } }, "sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg=="],
+    "confbox": ["confbox@0.2.4", "", {}, "sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ=="],
 
-    "compression": ["compression@1.8.1", "", { "dependencies": { "bytes": "3.1.2", "compressible": "~2.0.18", "debug": "2.6.9", "negotiator": "~0.6.4", "on-headers": "~1.1.0", "safe-buffer": "5.2.1", "vary": "~1.1.2" } }, "sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w=="],
+    "content-disposition": ["content-disposition@1.1.0", "", {}, "sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g=="],
 
-    "confbox": ["confbox@0.1.8", "", {}, "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w=="],
+    "content-type": ["content-type@1.0.5", "", {}, "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA=="],
 
     "convert-source-map": ["convert-source-map@2.0.0", "", {}, "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="],
 
-    "cookie": ["cookie@1.0.2", "", {}, "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA=="],
+    "cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="],
 
-    "cose-base": ["cose-base@1.0.3", "", { "dependencies": { "layout-base": "^1.0.0" } }, "sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg=="],
+    "cookie-signature": ["cookie-signature@1.2.2", "", {}, "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg=="],
 
-    "create-vocs": ["create-vocs@1.0.0", "", { "dependencies": { "@clack/prompts": "^0.7.0", "cac": "^6.7.14", "detect-package-manager": "^3.0.2", "fs-extra": "^11.3.0", "picocolors": "^1.1.1" }, "bin": { "create-vocs": "_lib/bin.js" } }, "sha512-Lv1Bd3WZEgwG4nrogkM54m8viW+TWPlGivLyEi7aNb3cuKPsEfMDZ/kTbo87fzOGtsZ2yh7scO54ZmVhhgBgTw=="],
+    "cors": ["cors@2.8.6", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw=="],
 
-    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
+    "cose-base": ["cose-base@1.0.3", "", { "dependencies": { "layout-base": "^1.0.0" } }, "sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg=="],
+
+    "cosmiconfig": ["cosmiconfig@8.3.6", "", { "dependencies": { "import-fresh": "^3.3.0", "js-yaml": "^4.1.0", "parse-json": "^5.2.0", "path-type": "^4.0.0" }, "peerDependencies": { "typescript": ">=4.9.5" }, "optionalPeers": ["typescript"] }, "sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA=="],
 
-    "css-selector-parser": ["css-selector-parser@3.1.3", "", {}, "sha512-gJMigczVZqYAk0hPVzx/M4Hm1D9QOtqkdQk9005TNzDIUGzo5cnHEDiKUT7jGPximL/oYb+LIitcHFQ4aKupxg=="],
+    "crelt": ["crelt@1.0.6", "", {}, "sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g=="],
 
-    "css-what": ["css-what@6.2.2", "", {}, "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA=="],
+    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
 
     "csstype": ["csstype@3.2.3", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="],
 
-    "cytoscape": ["cytoscape@3.32.1", "", {}, "sha512-dbeqFTLYEwlFg7UGtcZhCCG/2WayX72zK3Sq323CEX29CY81tYfVhw1MIdduCtpstB0cTOhJswWlM/OEB3Xp+Q=="],
+    "cva": ["class-variance-authority@0.7.1", "", { "dependencies": { "clsx": "^2.1.1" } }, "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg=="],
+
+    "cytoscape": ["cytoscape@3.34.0", "", {}, "sha512-62rNSrioXw93uliKFBwjukeQyeWwH2PqDrTac31r2P6464u3AUvTk0xS4LVvT251g7IgkFunrI48ZEZGjywSOg=="],
 
     "cytoscape-cose-bilkent": ["cytoscape-cose-bilkent@4.1.0", "", { "dependencies": { "cose-base": "^1.0.0" }, "peerDependencies": { "cytoscape": "^3.2.0" } }, "sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ=="],
 
     "cytoscape-fcose": ["cytoscape-fcose@2.2.0", "", { "dependencies": { "cose-base": "^2.2.0" }, "peerDependencies": { "cytoscape": "^3.2.0" } }, "sha512-ki1/VuRIHFCzxWNrsshHYPs6L7TvLu3DL+TyIGEsRcvVERmxokbf5Gdk7mFxZnTdiGtnA4cfSmjZJMviqSuZrQ=="],
 
+    "d": ["d@1.0.2", "", { "dependencies": { "es5-ext": "^0.10.64", "type": "^2.7.2" } }, "sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw=="],
+
     "d3": ["d3@7.9.0", "", { "dependencies": { "d3-array": "3", "d3-axis": "3", "d3-brush": "3", "d3-chord": "3", "d3-color": "3", "d3-contour": "4", "d3-delaunay": "6", "d3-dispatch": "3", "d3-drag": "3", "d3-dsv": "3", "d3-ease": "3", "d3-fetch": "3", "d3-force": "3", "d3-format": "3", "d3-geo": "3", "d3-hierarchy": "3", "d3-interpolate": "3", "d3-path": "3", "d3-polygon": "3", "d3-quadtree": "3", "d3-random": "3", "d3-scale": "4", "d3-scale-chromatic": "3", "d3-selection": "3", "d3-shape": "3", "d3-time": "3", "d3-time-format": "4", "d3-timer": "3", "d3-transition": "3", "d3-zoom": "3" } }, "sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA=="],
 
     "d3-array": ["d3-array@3.2.4", "", { "dependencies": { "internmap": "1 - 2" } }, "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg=="],
@@ -646,7 +675,7 @@
 
     "d3-force": ["d3-force@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-quadtree": "1 - 3", "d3-timer": "1 - 3" } }, "sha512-zxV/SsA+U4yte8051P4ECydjD/S+qeYtnaIyAs9tgHCqfguma/aAQDjo85A9Z6EKhBirHRJHXIgJUlffT4wdLg=="],
 
-    "d3-format": ["d3-format@3.1.0", "", {}, "sha512-YyUI6AEuY/Wpt8KWLgZHsIU86atmikuoOmCfommt0LYHiQSPjvX2AcFc38PX0CBpr2RCyZhjex+NS/LPOv6YqA=="],
+    "d3-format": ["d3-format@3.1.2", "", {}, "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg=="],
 
     "d3-geo": ["d3-geo@3.1.1", "", { "dependencies": { "d3-array": "2.5.0 - 3" } }, "sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q=="],
 
@@ -682,70 +711,86 @@
 
     "d3-zoom": ["d3-zoom@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-drag": "2 - 3", "d3-interpolate": "1 - 3", "d3-selection": "2 - 3", "d3-transition": "2 - 3" } }, "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw=="],
 
-    "dagre-d3-es": ["dagre-d3-es@7.0.11", "", { "dependencies": { "d3": "^7.9.0", "lodash-es": "^4.17.21" } }, "sha512-tvlJLyQf834SylNKax8Wkzco/1ias1OPw8DcUMDE7oUIoSEW25riQVuiu/0OWEFqT0cxHT3Pa9/D82Jr47IONw=="],
+    "dagre-d3-es": ["dagre-d3-es@7.0.14", "", { "dependencies": { "d3": "^7.9.0", "lodash-es": "^4.17.21" } }, "sha512-P4rFMVq9ESWqmOgK+dlXvOtLwYg0i7u0HBGJER0LZDJT2VHIPAMZ/riPxqJceWMStH5+E61QxFra9kIS3AqdMg=="],
 
-    "dayjs": ["dayjs@1.11.13", "", {}, "sha512-oaMBel6gjolK862uaPQOVTA7q3TZhuSvuMQAAglQDOWYO9A91IrAOUJEyKVlqJlHE0vq5p5UXxzdPfMH/x6xNg=="],
+    "dayjs": ["dayjs@1.11.21", "", {}, "sha512-98IT+HOahAisibz/yjKbzuOBwYcjJ7BCLPzARyHiyEBmRz4fatF+KPJszEHXsGYjUG234aH/cOjW1wwTbKUZlA=="],
 
-    "debug": ["debug@2.6.9", "", { "dependencies": { "ms": "2.0.0" } }, "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA=="],
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
 
     "decode-named-character-reference": ["decode-named-character-reference@1.2.0", "", { "dependencies": { "character-entities": "^2.0.0" } }, "sha512-c6fcElNV6ShtZXmsgNgFFV5tVX2PaV4g+MOAkb8eXHvn6sryJBrZa9r0zV6+dtTyoCKxtDy5tyQ5ZwQuidtd+Q=="],
 
-    "dedent": ["dedent@1.6.0", "", { "peerDependencies": { "babel-plugin-macros": "^3.1.0" }, "optionalPeers": ["babel-plugin-macros"] }, "sha512-F1Z+5UCFpmQUzJa11agbyPVMbpgT/qA3/SKyJ1jyBgm7dUcUEa8v9JwDkerSQXfakBwFljIxhOJqGkjUwZ9FSA=="],
-
-    "deep-object-diff": ["deep-object-diff@1.1.9", "", {}, "sha512-Rn+RuwkmkDwCi2/oXOFS9Gsr5lJZu/yTGpK7wAaAIE75CC+LCGEZHpY6VQJa/RoJcrmaA/docWJZvYohlNkWPA=="],
-
-    "deepmerge": ["deepmerge@4.3.1", "", {}, "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A=="],
-
-    "delaunator": ["delaunator@5.0.1", "", { "dependencies": { "robust-predicates": "^3.0.2" } }, "sha512-8nvh+XBe96aCESrGOqMp/84b13H9cdKbG5P2ejQCh4d4sK9RL4371qou9drQjMhvnPmhWl5hnmqbEE0fXr9Xnw=="],
+    "delaunator": ["delaunator@5.1.0", "", { "dependencies": { "robust-predicates": "^3.0.2" } }, "sha512-AGrQ4QSgssa1NGmWmLPqN5NY2KajF5MqxetNEO+o0n3ZwZZeTmt7bBnvzHWrmkZFxGgr4HdyFgelzgi06otLuQ=="],
 
     "depd": ["depd@2.0.0", "", {}, "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="],
 
     "dequal": ["dequal@2.0.3", "", {}, "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA=="],
 
-    "destroy": ["destroy@1.2.0", "", {}, "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg=="],
-
     "detect-libc": ["detect-libc@2.0.4", "", {}, "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA=="],
 
-    "detect-node-es": ["detect-node-es@1.1.0", "", {}, "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ=="],
+    "devlop": ["devlop@1.1.0", "", { "dependencies": { "dequal": "^2.0.0" } }, "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA=="],
 
-    "detect-package-manager": ["detect-package-manager@3.0.2", "", { "dependencies": { "execa": "^5.1.1" } }, "sha512-8JFjJHutStYrfWwzfretQoyNGoZVW1Fsrp4JO9spa7h/fBfwgTMEIy4/LBzRDGsxwVPHU0q+T9YvwLDJoOApLQ=="],
+    "dompurify": ["dompurify@3.4.8", "", { "optionalDependencies": { "@types/trusted-types": "^2.0.7" } }, "sha512-yb1cEmaOum7wFvOCSQxyfgVlv5D47Rc30iZWoMpbDIWTnJ6grDDQyu2KFJzB2k7u0pMuJcQ1zphH//fFnw2tjQ=="],
 
-    "devlop": ["devlop@1.1.0", "", { "dependencies": { "dequal": "^2.0.0" } }, "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA=="],
+    "dot-case": ["dot-case@3.0.4", "", { "dependencies": { "no-case": "^3.0.4", "tslib": "^2.0.3" } }, "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w=="],
 
-    "direction": ["direction@2.0.1", "", { "bin": { "direction": "cli.js" } }, "sha512-9S6m9Sukh1cZNknO1CWAr2QAWsbKLafQiyM5gZ7VgXHeuaoUwffKN4q6NC4A/Mf9iiPlOXQEKW/Mv/mh9/3YFA=="],
+    "dotenv": ["dotenv@17.4.2", "", {}, "sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw=="],
 
-    "dompurify": ["dompurify@3.2.6", "", { "optionalDependencies": { "@types/trusted-types": "^2.0.7" } }, "sha512-/2GogDQlohXPZe6D6NOgQvXLPSYBqIWMnZ8zzOhn09REE4eyAzb+Hed3jhoM9OkuaJ8P6ZGTTVWQKAi8ieIzfQ=="],
+    "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="],
 
     "eastasianwidth": ["eastasianwidth@0.2.0", "", {}, "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA=="],
 
     "ee-first": ["ee-first@1.1.1", "", {}, "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="],
 
-    "electron-to-chromium": ["electron-to-chromium@1.5.186", "", {}, "sha512-lur7L4BFklgepaJxj4DqPk7vKbTEl0pajNlg2QjE5shefmlmBLm2HvQ7PMf1R/GvlevT/581cop33/quQcfX3A=="],
-
-    "emoji-regex": ["emoji-regex@10.4.0", "", {}, "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw=="],
+    "electron-to-chromium": ["electron-to-chromium@1.5.367", "", {}, "sha512-4Mk/mrynCNQ+atY40D3UpmhLWB6AHMbYMlIrPhHcMF6x0L7O0b052FCAsxw1LlaR++UFuNg3D/A6XCuGDa0guQ=="],
 
-    "emoji-regex-xs": ["emoji-regex-xs@1.0.0", "", {}, "sha512-LRlerrMYoIDrT6jgpeZ2YYl/L8EulRTt5hQcYjy5AInh7HWXKimpqx68aknBFpGL2+/IcogTcaydJEgaTmOpDg=="],
+    "emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
 
     "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="],
 
-    "enhanced-resolve": ["enhanced-resolve@5.20.1", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.0" } }, "sha512-Qohcme7V1inbAfvjItgw0EaxVX5q2rdVEZHRBrEQdRZTssLDGsL8Lwrznl8oQ/6kuTJONLaDcGjkNP247XEhcA=="],
+    "enhanced-resolve": ["enhanced-resolve@5.22.2", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.3" } }, "sha512-0rxICaFZ7NQho/sHely2bvOPRP0Eu2B0NZ9zM54YvRvWMn7jfz3DmnOZDR9LlXDdDcqntAVc6Hfy4gr/tdH/Ag=="],
+
+    "entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
+
+    "error-ex": ["error-ex@1.3.4", "", { "dependencies": { "is-arrayish": "^0.2.1" } }, "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ=="],
+
+    "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="],
+
+    "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="],
+
+    "es-module-lexer": ["es-module-lexer@2.1.0", "", {}, "sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ=="],
+
+    "es-object-atoms": ["es-object-atoms@1.1.2", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw=="],
 
-    "entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="],
+    "es-toolkit": ["es-toolkit@1.47.0", "", {}, "sha512-n1GuoD0WEQZMBk5tttoZSqwgyLx01oqa5XsBmCHwPyNe1S9jPBEmtR2pSgp2kJuWE3ciFZ6yRHmY4pM4C3OOkw=="],
 
-    "es-module-lexer": ["es-module-lexer@1.7.0", "", {}, "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA=="],
+    "es5-ext": ["es5-ext@0.10.64", "", { "dependencies": { "es6-iterator": "^2.0.3", "es6-symbol": "^3.1.3", "esniff": "^2.0.1", "next-tick": "^1.1.0" } }, "sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg=="],
+
+    "es6-iterator": ["es6-iterator@2.0.3", "", { "dependencies": { "d": "1", "es5-ext": "^0.10.35", "es6-symbol": "^3.1.1" } }, "sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g=="],
+
+    "es6-symbol": ["es6-symbol@3.1.4", "", { "dependencies": { "d": "^1.0.2", "ext": "^1.7.0" } }, "sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg=="],
 
     "esast-util-from-estree": ["esast-util-from-estree@2.0.0", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "devlop": "^1.0.0", "estree-util-visit": "^2.0.0", "unist-util-position-from-estree": "^2.0.0" } }, "sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ=="],
 
     "esast-util-from-js": ["esast-util-from-js@2.0.1", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "acorn": "^8.0.0", "esast-util-from-estree": "^2.0.0", "vfile-message": "^4.0.0" } }, "sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw=="],
 
-    "esbuild": ["esbuild@0.25.6", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.6", "@esbuild/android-arm": "0.25.6", "@esbuild/android-arm64": "0.25.6", "@esbuild/android-x64": "0.25.6", "@esbuild/darwin-arm64": "0.25.6", "@esbuild/darwin-x64": "0.25.6", "@esbuild/freebsd-arm64": "0.25.6", "@esbuild/freebsd-x64": "0.25.6", "@esbuild/linux-arm": "0.25.6", "@esbuild/linux-arm64": "0.25.6", "@esbuild/linux-ia32": "0.25.6", "@esbuild/linux-loong64": "0.25.6", "@esbuild/linux-mips64el": "0.25.6", "@esbuild/linux-ppc64": "0.25.6", "@esbuild/linux-riscv64": "0.25.6", "@esbuild/linux-s390x": "0.25.6", "@esbuild/linux-x64": "0.25.6", "@esbuild/netbsd-arm64": "0.25.6", "@esbuild/netbsd-x64": "0.25.6", "@esbuild/openbsd-arm64": "0.25.6", "@esbuild/openbsd-x64": "0.25.6", "@esbuild/openharmony-arm64": "0.25.6", "@esbuild/sunos-x64": "0.25.6", "@esbuild/win32-arm64": "0.25.6", "@esbuild/win32-ia32": "0.25.6", "@esbuild/win32-x64": "0.25.6" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-GVuzuUwtdsghE3ocJ9Bs8PNoF13HNQ5TXbEi2AhvVb8xU1Iwt9Fos9FEamfoee+u/TOsn7GUWc04lz46n2bbTg=="],
+    "esbuild": ["esbuild@0.28.0", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.28.0", "@esbuild/android-arm": "0.28.0", "@esbuild/android-arm64": "0.28.0", "@esbuild/android-x64": "0.28.0", "@esbuild/darwin-arm64": "0.28.0", "@esbuild/darwin-x64": "0.28.0", "@esbuild/freebsd-arm64": "0.28.0", "@esbuild/freebsd-x64": "0.28.0", "@esbuild/linux-arm": "0.28.0", "@esbuild/linux-arm64": "0.28.0", "@esbuild/linux-ia32": "0.28.0", "@esbuild/linux-loong64": "0.28.0", "@esbuild/linux-mips64el": "0.28.0", "@esbuild/linux-ppc64": "0.28.0", "@esbuild/linux-riscv64": "0.28.0", "@esbuild/linux-s390x": "0.28.0", "@esbuild/linux-x64": "0.28.0", "@esbuild/netbsd-arm64": "0.28.0", "@esbuild/netbsd-x64": "0.28.0", "@esbuild/openbsd-arm64": "0.28.0", "@esbuild/openbsd-x64": "0.28.0", "@esbuild/openharmony-arm64": "0.28.0", "@esbuild/sunos-x64": "0.28.0", "@esbuild/win32-arm64": "0.28.0", "@esbuild/win32-ia32": "0.28.0", "@esbuild/win32-x64": "0.28.0" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-sNR9MHpXSUV/XB4zmsFKN+QgVG82Cc7+/aaxJ8Adi8hyOac+EXptIp45QBPaVyX3N70664wRbTcLTOemCAnyqw=="],
 
     "escalade": ["escalade@3.2.0", "", {}, "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="],
 
+    "escape-carriage": ["escape-carriage@1.3.1", "", {}, "sha512-GwBr6yViW3ttx1kb7/Oh+gKQ1/TrhYwxKqVmg5gS+BK+Qe2KrOa/Vh7w3HPBvgGf0LfcDGoY9I6NHKoA5Hozhw=="],
+
     "escape-html": ["escape-html@1.0.3", "", {}, "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="],
 
     "escape-string-regexp": ["escape-string-regexp@5.0.0", "", {}, "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="],
 
+    "eslint-scope": ["eslint-scope@5.1.1", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^4.1.1" } }, "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw=="],
+
+    "esniff": ["esniff@2.0.1", "", { "dependencies": { "d": "^1.0.1", "es5-ext": "^0.10.62", "event-emitter": "^0.3.5", "type": "^2.7.2" } }, "sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg=="],
+
+    "esrecurse": ["esrecurse@4.3.0", "", { "dependencies": { "estraverse": "^5.2.0" } }, "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag=="],
+
+    "estraverse": ["estraverse@4.3.0", "", {}, "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw=="],
+
     "estree-util-attach-comments": ["estree-util-attach-comments@3.0.0", "", { "dependencies": { "@types/estree": "^1.0.0" } }, "sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw=="],
 
     "estree-util-build-jsx": ["estree-util-build-jsx@3.0.1", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "devlop": "^1.0.0", "estree-util-is-identifier-name": "^3.0.0", "estree-walker": "^3.0.0" } }, "sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ=="],
@@ -756,7 +801,7 @@
 
     "estree-util-to-js": ["estree-util-to-js@2.0.0", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "astring": "^1.8.0", "source-map": "^0.7.0" } }, "sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg=="],
 
-    "estree-util-value-to-estree": ["estree-util-value-to-estree@3.4.0", "", { "dependencies": { "@types/estree": "^1.0.0" } }, "sha512-Zlp+gxis+gCfK12d3Srl2PdX2ybsEA8ZYy6vQGVQTNNYLEGRQQ56XB64bjemN8kxIKXP1nC9ip4Z+ILy9LGzvQ=="],
+    "estree-util-value-to-estree": ["estree-util-value-to-estree@3.5.0", "", { "dependencies": { "@types/estree": "^1.0.0" } }, "sha512-aMV56R27Gv3QmfmF1MY12GWkGzzeAezAX+UplqHVASfjc9wNzI/X6hC0S9oxq61WT4aQesLGslWP9tKk6ghRZQ=="],
 
     "estree-util-visit": ["estree-util-visit@2.0.0", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/unist": "^3.0.0" } }, "sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww=="],
 
@@ -764,78 +809,74 @@
 
     "etag": ["etag@1.8.1", "", {}, "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="],
 
-    "eval": ["eval@0.1.8", "", { "dependencies": { "@types/node": "*", "require-like": ">= 0.1.1" } }, "sha512-EzV94NYKoO09GLXGjXj9JIlXijVck4ONSr5wiCWDvhsvj5jxSrzTmRU/9C1DyB6uToszLs8aifA6NQ7lEQdvFw=="],
+    "event-emitter": ["event-emitter@0.3.5", "", { "dependencies": { "d": "1", "es5-ext": "~0.10.14" } }, "sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA=="],
+
+    "events": ["events@3.3.0", "", {}, "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q=="],
+
+    "eventsource": ["eventsource@3.0.7", "", { "dependencies": { "eventsource-parser": "^3.0.1" } }, "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA=="],
+
+    "eventsource-parser": ["eventsource-parser@3.1.0", "", {}, "sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg=="],
 
-    "execa": ["execa@5.1.1", "", { "dependencies": { "cross-spawn": "^7.0.3", "get-stream": "^6.0.0", "human-signals": "^2.1.0", "is-stream": "^2.0.0", "merge-stream": "^2.0.0", "npm-run-path": "^4.0.1", "onetime": "^5.1.2", "signal-exit": "^3.0.3", "strip-final-newline": "^2.0.0" } }, "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg=="],
+    "express": ["express@5.2.1", "", { "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.1", "content-disposition": "^1.0.0", "content-type": "^1.0.5", "cookie": "^0.7.1", "cookie-signature": "^1.2.1", "debug": "^4.4.0", "depd": "^2.0.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "finalhandler": "^2.1.0", "fresh": "^2.0.0", "http-errors": "^2.0.0", "merge-descriptors": "^2.0.0", "mime-types": "^3.0.0", "on-finished": "^2.4.1", "once": "^1.4.0", "parseurl": "^1.3.3", "proxy-addr": "^2.0.7", "qs": "^6.14.0", "range-parser": "^1.2.1", "router": "^2.2.0", "send": "^1.1.0", "serve-static": "^2.2.0", "statuses": "^2.0.1", "type-is": "^2.0.1", "vary": "^1.1.2" } }, "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw=="],
 
-    "exsolve": ["exsolve@1.0.7", "", {}, "sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw=="],
+    "express-rate-limit": ["express-rate-limit@8.5.2", "", { "dependencies": { "ip-address": "^10.2.0" }, "peerDependencies": { "express": ">= 4.11" } }, "sha512-5Kb34ipNX694DH48vN9irak1Qx30nb0PLYHXfJgw4YEjiC3ZEmZJhwOp+VfiCYwFzvFTdB9QkArYS5kXa2cx2A=="],
+
+    "exsolve": ["exsolve@1.0.8", "", {}, "sha512-LmDxfWXwcTArk8fUEnOfSZpHOJ6zOMUJKOtFLFqJLoKJetuQG874Uc7/Kki7zFLzYybmZhp1M7+98pfMqeX8yA=="],
+
+    "ext": ["ext@1.7.0", "", { "dependencies": { "type": "^2.7.2" } }, "sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw=="],
 
     "extend": ["extend@3.0.2", "", {}, "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="],
 
-    "fast-glob": ["fast-glob@3.3.3", "", { "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.8" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="],
+    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
 
-    "fastq": ["fastq@1.20.1", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw=="],
+    "fast-uri": ["fast-uri@3.1.2", "", {}, "sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ=="],
 
     "fault": ["fault@2.0.1", "", { "dependencies": { "format": "^0.2.0" } }, "sha512-WtySTkS4OKev5JtpHXnib4Gxiurzh5NCGvWrFaZ34m6JehfTUhKZvn9njTfw48t6JumVQOmrKqpmGcdwxnhqBQ=="],
 
-    "fdir": ["fdir@6.4.6", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w=="],
-
-    "fill-range": ["fill-range@7.1.1", "", { "dependencies": { "to-regex-range": "^5.0.1" } }, "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg=="],
+    "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
 
-    "find-up": ["find-up@5.0.0", "", { "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="],
+    "finalhandler": ["finalhandler@2.1.1", "", { "dependencies": { "debug": "^4.4.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "on-finished": "^2.4.1", "parseurl": "^1.3.3", "statuses": "^2.0.1" } }, "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA=="],
 
     "foreground-child": ["foreground-child@3.3.1", "", { "dependencies": { "cross-spawn": "^7.0.6", "signal-exit": "^4.0.1" } }, "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw=="],
 
     "format": ["format@0.2.2", "", {}, "sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww=="],
 
-    "fraction.js": ["fraction.js@4.3.7", "", {}, "sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew=="],
+    "forwarded": ["forwarded@0.2.0", "", {}, "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="],
 
-    "fresh": ["fresh@0.5.2", "", {}, "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q=="],
+    "fresh": ["fresh@2.0.0", "", {}, "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A=="],
 
-    "fs-extra": ["fs-extra@11.3.4", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA=="],
+    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
 
-    "fsevents": ["fsevents@2.3.2", "", { "os": "darwin" }, "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA=="],
+    "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
 
     "gensync": ["gensync@1.0.0-beta.2", "", {}, "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg=="],
 
-    "get-nonce": ["get-nonce@1.0.1", "", {}, "sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q=="],
+    "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="],
 
-    "get-stream": ["get-stream@6.0.1", "", {}, "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg=="],
+    "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],
 
     "github-slugger": ["github-slugger@2.0.0", "", {}, "sha512-IaOQ9puYtjrkq7Y0Ygl9KDZnrf/aiUJYUpVf89y8kyaxbRG7Y1SrX/jaumrv81vc61+kiMempujsM3Yw7w5qcw=="],
 
     "glob": ["glob@11.1.0", "", { "dependencies": { "foreground-child": "^3.3.1", "jackspeak": "^4.1.1", "minimatch": "^10.1.1", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^2.0.0" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw=="],
 
-    "glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
+    "glob-to-regexp": ["glob-to-regexp@0.4.1", "", {}, "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw=="],
 
-    "globals": ["globals@15.15.0", "", {}, "sha512-7ACyT3wmyp3I61S4fG682L0VA2RGD9otkqGJIwNUMF1SWUombIIk+af1unuDYgMm082aHYwD+mzJvv9Iu8dsgg=="],
-
-    "globby": ["globby@14.1.0", "", { "dependencies": { "@sindresorhus/merge-streams": "^2.1.0", "fast-glob": "^3.3.3", "ignore": "^7.0.3", "path-type": "^6.0.0", "slash": "^5.1.0", "unicorn-magic": "^0.3.0" } }, "sha512-0Ia46fDOaT7k4og1PDW4YbodWWr3scS2vAr2lTbsplOt2WkKp0vQbkI9wKis/T5LV/dqPjO3bpS/z6GTJB82LA=="],
+    "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
 
     "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
 
     "hachure-fill": ["hachure-fill@0.5.2", "", {}, "sha512-3GKBOn+m2LX9iq+JC1064cSFprJY4jL1jCXTcpnfER5HYE2l/4EfWSGzkPa/ZDBmYI0ZOEj5VHV/eKnPGkHuOg=="],
 
-    "hast-util-classnames": ["hast-util-classnames@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "space-separated-tokens": "^2.0.0" } }, "sha512-tI3JjoGDEBVorMAWK4jNRsfLMYmih1BUOG3VV36pH36njs1IEl7xkNrVTD2mD2yYHmQCa5R/fj61a8IAF4bRaQ=="],
-
-    "hast-util-from-dom": ["hast-util-from-dom@5.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "hastscript": "^9.0.0", "web-namespaces": "^2.0.0" } }, "sha512-N+LqofjR2zuzTjCPzyDUdSshy4Ma6li7p/c3pA78uTwzFgENbgbUrm2ugwsOdcjI1muO+o6Dgzp9p8WHtn/39Q=="],
+    "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
 
-    "hast-util-from-html": ["hast-util-from-html@2.0.3", "", { "dependencies": { "@types/hast": "^3.0.0", "devlop": "^1.1.0", "hast-util-from-parse5": "^8.0.0", "parse5": "^7.0.0", "vfile": "^6.0.0", "vfile-message": "^4.0.0" } }, "sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw=="],
+    "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
 
-    "hast-util-from-html-isomorphic": ["hast-util-from-html-isomorphic@2.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-from-dom": "^5.0.0", "hast-util-from-html": "^2.0.0", "unist-util-remove-position": "^5.0.0" } }, "sha512-zJfpXq44yff2hmE0XmwEOzdWin5xwH+QIhMLOScpX91e/NSGPsAzNCvLQDIEPyO2TXi+lBmU6hjLIhV8MwP2kw=="],
-
-    "hast-util-from-parse5": ["hast-util-from-parse5@8.0.3", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "devlop": "^1.0.0", "hastscript": "^9.0.0", "property-information": "^7.0.0", "vfile": "^6.0.0", "vfile-location": "^5.0.0", "web-namespaces": "^2.0.0" } }, "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg=="],
-
-    "hast-util-has-property": ["hast-util-has-property@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-MNilsvEKLFpV604hwfhVStK0usFY/QmM5zX16bo7EjnAEGofr5YyI37kzopBlZJkHD4t887i+q/C8/tr5Q94cA=="],
+    "hasown": ["hasown@2.0.4", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A=="],
 
     "hast-util-heading-rank": ["hast-util-heading-rank@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-EJKb8oMUXVHcWZTDepnr+WNbfnXKFNf9duMesmr4S8SXTJBJ9M4Yok08pu9vxdJwdlGRhVumk9mEhkEvKGifwA=="],
 
     "hast-util-is-element": ["hast-util-is-element@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g=="],
 
-    "hast-util-parse-selector": ["hast-util-parse-selector@4.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A=="],
-
-    "hast-util-select": ["hast-util-select@6.0.4", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "bcp-47-match": "^2.0.0", "comma-separated-tokens": "^2.0.0", "css-selector-parser": "^3.0.0", "devlop": "^1.0.0", "direction": "^2.0.0", "hast-util-has-property": "^3.0.0", "hast-util-to-string": "^3.0.0", "hast-util-whitespace": "^3.0.0", "nth-check": "^2.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "unist-util-visit": "^5.0.0", "zwitch": "^2.0.0" } }, "sha512-RqGS1ZgI0MwxLaKLDxjprynNzINEkRHY2i8ln4DDjgv9ZhcYVIHN9rlpiYsqtFwrgpYU361SyWDQcGNIBVu3lw=="],
-
     "hast-util-to-estree": ["hast-util-to-estree@3.1.3", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "comma-separated-tokens": "^2.0.0", "devlop": "^1.0.0", "estree-util-attach-comments": "^3.0.0", "estree-util-is-identifier-name": "^3.0.0", "hast-util-whitespace": "^3.0.0", "mdast-util-mdx-expression": "^2.0.0", "mdast-util-mdx-jsx": "^3.0.0", "mdast-util-mdxjs-esm": "^2.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "style-to-js": "^1.0.0", "unist-util-position": "^5.0.0", "zwitch": "^2.0.0" } }, "sha512-48+B/rJWAp0jamNbAAf9M7Uf//UVqAoMmgXhBdxTDJLGKY+LRnZ99qcG+Qjl5HfMpYNzS5v4EAwVEF34LeAj7w=="],
 
     "hast-util-to-html": ["hast-util-to-html@9.0.5", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "ccount": "^2.0.0", "comma-separated-tokens": "^2.0.0", "hast-util-whitespace": "^3.0.0", "html-void-elements": "^3.0.0", "mdast-util-to-hast": "^13.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "stringify-entities": "^4.0.0", "zwitch": "^2.0.4" } }, "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw=="],
@@ -844,125 +885,131 @@
 
     "hast-util-to-string": ["hast-util-to-string@3.0.1", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-XelQVTDWvqcl3axRfI0xSeoVKzyIFPwsAGSLIsKdJKQMXDYJS4WYrBNF/8J7RdhIcFI2BOHgAifggsvsxp/3+A=="],
 
-    "hast-util-to-text": ["hast-util-to-text@4.0.2", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "hast-util-is-element": "^3.0.0", "unist-util-find-after": "^5.0.0" } }, "sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A=="],
-
     "hast-util-whitespace": ["hast-util-whitespace@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw=="],
 
-    "hastscript": ["hastscript@8.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "comma-separated-tokens": "^2.0.0", "hast-util-parse-selector": "^4.0.0", "property-information": "^6.0.0", "space-separated-tokens": "^2.0.0" } }, "sha512-dMOtzCEd3ABUeSIISmrETiKuyydk1w0pa+gE/uormcTpSYuaNJPbX1NU3JLyscSLjwAQM8bWMhhIlnCqnRvDTw=="],
-
     "hono": ["hono@4.12.14", "", {}, "sha512-am5zfg3yu6sqn5yjKBNqhnTX7Cv+m00ox+7jbaKkrLMRJ4rAdldd1xPd/JzbBWspqaQv6RSTrgFN95EsfhC+7w=="],
 
     "html-void-elements": ["html-void-elements@3.0.0", "", {}, "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg=="],
 
     "http-errors": ["http-errors@2.0.0", "", { "dependencies": { "depd": "2.0.0", "inherits": "2.0.4", "setprototypeof": "1.2.0", "statuses": "2.0.1", "toidentifier": "1.0.1" } }, "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ=="],
 
-    "human-signals": ["human-signals@2.1.0", "", {}, "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw=="],
-
     "iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="],
 
     "ieee754": ["ieee754@1.2.1", "", {}, "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="],
 
-    "ignore": ["ignore@7.0.5", "", {}, "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg=="],
+    "image-size": ["image-size@2.0.2", "", { "bin": { "image-size": "bin/image-size.js" } }, "sha512-IRqXKlaXwgSMAMtpNzZa1ZAe8m+Sa1770Dhk8VkSsP9LS+iHD62Zd8FQKs8fbPiagBE7BzoFX23cxFnwshpV6w=="],
+
+    "import-fresh": ["import-fresh@3.3.1", "", { "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" } }, "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ=="],
+
+    "import-meta-resolve": ["import-meta-resolve@4.2.0", "", {}, "sha512-Iqv2fzaTQN28s/FwZAoFq0ZSs/7hMAHJVX+w8PZl3cY19Pxk6jFFalxQoIfW2826i/fDLXv8IiEZRIT0lDuWcg=="],
 
     "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],
 
     "inline-style-parser": ["inline-style-parser@0.2.4", "", {}, "sha512-0aO8FkhNZlj/ZIbNi7Lxxr12obT7cL1moPfE4tg1LkX7LlLfC6DeX4l2ZEud1ukP9jNQyNnfzQVqwbwmAATY4Q=="],
 
-    "internmap": ["internmap@1.0.1", "", {}, "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw=="],
+    "internmap": ["internmap@2.0.3", "", {}, "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg=="],
+
+    "intersection-observer": ["intersection-observer@0.10.0", "", {}, "sha512-fn4bQ0Xq8FTej09YC/jqKZwtijpvARlRp6wxL5WTA6yPe2YWSJ5RJh7Nm79rK2qB0wr6iDQzH60XGq5V/7u8YQ=="],
+
+    "ip-address": ["ip-address@10.2.0", "", {}, "sha512-/+S6j4E9AHvW9SWMSEY9Xfy66O5PWvVEJ08O0y5JGyEKQpojb0K0GKpz/v5HJ/G0vi3D2sjGK78119oXZeE0qA=="],
+
+    "ipaddr.js": ["ipaddr.js@1.9.1", "", {}, "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="],
 
     "is-alphabetical": ["is-alphabetical@2.0.1", "", {}, "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ=="],
 
     "is-alphanumerical": ["is-alphanumerical@2.0.1", "", { "dependencies": { "is-alphabetical": "^2.0.0", "is-decimal": "^2.0.0" } }, "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw=="],
 
-    "is-decimal": ["is-decimal@2.0.1", "", {}, "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A=="],
+    "is-arrayish": ["is-arrayish@0.2.1", "", {}, "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg=="],
 
-    "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="],
+    "is-decimal": ["is-decimal@2.0.1", "", {}, "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A=="],
 
     "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
 
-    "is-glob": ["is-glob@4.0.3", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="],
-
     "is-hexadecimal": ["is-hexadecimal@2.0.1", "", {}, "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg=="],
 
-    "is-interactive": ["is-interactive@2.0.0", "", {}, "sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ=="],
-
-    "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="],
-
     "is-plain-obj": ["is-plain-obj@4.1.0", "", {}, "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg=="],
 
-    "is-stream": ["is-stream@2.0.1", "", {}, "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg=="],
-
-    "is-unicode-supported": ["is-unicode-supported@1.3.0", "", {}, "sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ=="],
+    "is-promise": ["is-promise@4.0.0", "", {}, "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ=="],
 
     "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
 
     "jackspeak": ["jackspeak@4.1.1", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" } }, "sha512-zptv57P3GpL+O0I7VdMJNBZCu+BPHVQUk55Ft8/QCJjTVxrnJHuVuX/0Bl2A6/+2oyR/ZMEuFKwmzqqZ/U5nPQ=="],
 
-    "javascript-stringify": ["javascript-stringify@2.1.0", "", {}, "sha512-JVAfqNPTvNq3sB/VHQJAFxN/sPgKnsKrCwyRt15zwNCdrMMJDdcEOdubuy+DuJYYdm0ox1J4uzEuYKkN+9yhVg=="],
+    "jest-worker": ["jest-worker@27.5.1", "", { "dependencies": { "@types/node": "*", "merge-stream": "^2.0.0", "supports-color": "^8.0.0" } }, "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg=="],
 
     "jiti": ["jiti@2.6.1", "", { "bin": { "jiti": "lib/jiti-cli.mjs" } }, "sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ=="],
 
-    "js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="],
+    "jose": ["jose@6.2.3", "", {}, "sha512-YYVDInQKFJfR/xa3ojUTl8c2KoTwiL1R5Wg9YCydwH0x0B9grbzlg5HC7mMjCtUJjbQ/YnGEZIhI5tCgfTb4Hw=="],
+
+    "js-tokens": ["js-tokens@9.0.1", "", {}, "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ=="],
+
+    "js-yaml": ["js-yaml@4.2.0", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw=="],
 
     "jsesc": ["jsesc@3.1.0", "", { "bin": { "jsesc": "bin/jsesc" } }, "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA=="],
 
-    "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="],
+    "json-parse-even-better-errors": ["json-parse-even-better-errors@2.3.1", "", {}, "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="],
 
-    "jsonfile": ["jsonfile@6.1.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ=="],
+    "json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
 
-    "katex": ["katex@0.16.22", "", { "dependencies": { "commander": "^8.3.0" }, "bin": { "katex": "cli.js" } }, "sha512-XCHRdUw4lf3SKBaJe4EvgqIuWwkPSo9XoeO8GjQW94Bp7TWv9hNhzZjZ+OH9yf1UmLygb7DIT5GSFQiyt16zYg=="],
+    "json-schema-typed": ["json-schema-typed@8.0.2", "", {}, "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA=="],
 
-    "khroma": ["khroma@2.1.0", "", {}, "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw=="],
+    "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="],
 
-    "kolorist": ["kolorist@1.8.0", "", {}, "sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ=="],
+    "katex": ["katex@0.16.47", "", { "dependencies": { "commander": "^8.3.0" }, "bin": { "katex": "cli.js" } }, "sha512-Eeo8Ys1doU1z+x8AZsPpQu+p/QcZBI5PeOo7QGQdy2x2m0MU/hYagBbGOmXwr5KVbEfVuWv9LpnQWeehogurjg=="],
 
-    "langium": ["langium@3.3.1", "", { "dependencies": { "chevrotain": "~11.0.3", "chevrotain-allstar": "~0.3.0", "vscode-languageserver": "~9.0.1", "vscode-languageserver-textdocument": "~1.0.11", "vscode-uri": "~3.0.8" } }, "sha512-QJv/h939gDpvT+9SiLVlY7tZC3xB2qK57v0J04Sh9wpMb6MP1q8gB21L3WIo8T5P1MSMg3Ep14L7KkDCFG3y4w=="],
+    "khroma": ["khroma@2.1.0", "", {}, "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw=="],
 
     "layout-base": ["layout-base@1.0.2", "", {}, "sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg=="],
 
-    "lightningcss": ["lightningcss@1.30.2", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-android-arm64": "1.30.2", "lightningcss-darwin-arm64": "1.30.2", "lightningcss-darwin-x64": "1.30.2", "lightningcss-freebsd-x64": "1.30.2", "lightningcss-linux-arm-gnueabihf": "1.30.2", "lightningcss-linux-arm64-gnu": "1.30.2", "lightningcss-linux-arm64-musl": "1.30.2", "lightningcss-linux-x64-gnu": "1.30.2", "lightningcss-linux-x64-musl": "1.30.2", "lightningcss-win32-arm64-msvc": "1.30.2", "lightningcss-win32-x64-msvc": "1.30.2" } }, "sha512-utfs7Pr5uJyyvDETitgsaqSyjCb2qNRAtuqUeWIAKztsOYdcACf2KtARYXg2pSvhkt+9NfoaNY7fxjl6nuMjIQ=="],
+    "lightningcss": ["lightningcss@1.32.0", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-android-arm64": "1.32.0", "lightningcss-darwin-arm64": "1.32.0", "lightningcss-darwin-x64": "1.32.0", "lightningcss-freebsd-x64": "1.32.0", "lightningcss-linux-arm-gnueabihf": "1.32.0", "lightningcss-linux-arm64-gnu": "1.32.0", "lightningcss-linux-arm64-musl": "1.32.0", "lightningcss-linux-x64-gnu": "1.32.0", "lightningcss-linux-x64-musl": "1.32.0", "lightningcss-win32-arm64-msvc": "1.32.0", "lightningcss-win32-x64-msvc": "1.32.0" } }, "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ=="],
 
-    "lightningcss-android-arm64": ["lightningcss-android-arm64@1.30.2", "", { "os": "android", "cpu": "arm64" }, "sha512-BH9sEdOCahSgmkVhBLeU7Hc9DWeZ1Eb6wNS6Da8igvUwAe0sqROHddIlvU06q3WyXVEOYDZ6ykBZQnjTbmo4+A=="],
+    "lightningcss-android-arm64": ["lightningcss-android-arm64@1.32.0", "", { "os": "android", "cpu": "arm64" }, "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg=="],
 
-    "lightningcss-darwin-arm64": ["lightningcss-darwin-arm64@1.30.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-ylTcDJBN3Hp21TdhRT5zBOIi73P6/W0qwvlFEk22fkdXchtNTOU4Qc37SkzV+EKYxLouZ6M4LG9NfZ1qkhhBWA=="],
+    "lightningcss-darwin-arm64": ["lightningcss-darwin-arm64@1.32.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ=="],
 
-    "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.30.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-oBZgKchomuDYxr7ilwLcyms6BCyLn0z8J0+ZZmfpjwg9fRVZIR5/GMXd7r9RH94iDhld3UmSjBM6nXWM2TfZTQ=="],
+    "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.32.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w=="],
 
-    "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.30.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-c2bH6xTrf4BDpK8MoGG4Bd6zAMZDAXS569UxCAGcA7IKbHNMlhGQ89eRmvpIUGfKWNVdbhSbkQaWhEoMGmGslA=="],
+    "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.32.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig=="],
 
-    "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.30.2", "", { "os": "linux", "cpu": "arm" }, "sha512-eVdpxh4wYcm0PofJIZVuYuLiqBIakQ9uFZmipf6LF/HRj5Bgm0eb3qL/mr1smyXIS1twwOxNWndd8z0E374hiA=="],
+    "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.32.0", "", { "os": "linux", "cpu": "arm" }, "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw=="],
 
-    "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.30.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-UK65WJAbwIJbiBFXpxrbTNArtfuznvxAJw4Q2ZGlU8kPeDIWEX1dg3rn2veBVUylA2Ezg89ktszWbaQnxD/e3A=="],
+    "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.32.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ=="],
 
-    "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.30.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA=="],
+    "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.32.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg=="],
 
-    "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.30.2", "", { "os": "linux", "cpu": "x64" }, "sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w=="],
+    "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.32.0", "", { "os": "linux", "cpu": "x64" }, "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA=="],
 
-    "lightningcss-linux-x64-musl": ["lightningcss-linux-x64-musl@1.30.2", "", { "os": "linux", "cpu": "x64" }, "sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA=="],
+    "lightningcss-linux-x64-musl": ["lightningcss-linux-x64-musl@1.32.0", "", { "os": "linux", "cpu": "x64" }, "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg=="],
 
-    "lightningcss-win32-arm64-msvc": ["lightningcss-win32-arm64-msvc@1.30.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-FZn+vaj7zLv//D/192WFFVA0RgHawIcHqLX9xuWiQt7P0PtdFEVaxgF9rjM/IRYHQXNnk61/H/gb2Ei+kUQ4xQ=="],
+    "lightningcss-win32-arm64-msvc": ["lightningcss-win32-arm64-msvc@1.32.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw=="],
 
-    "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.30.2", "", { "os": "win32", "cpu": "x64" }, "sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw=="],
+    "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.32.0", "", { "os": "win32", "cpu": "x64" }, "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q=="],
 
-    "local-pkg": ["local-pkg@1.1.1", "", { "dependencies": { "mlly": "^1.7.4", "pkg-types": "^2.0.1", "quansync": "^0.2.8" } }, "sha512-WunYko2W1NcdfAFpuLUoucsgULmgDBRkdxHxWQ7mK0cQqwPiy8E1enjuRBrhLtZkB5iScJ1XIPdhVEFK8aOLSg=="],
+    "lines-and-columns": ["lines-and-columns@1.2.4", "", {}, "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="],
 
-    "locate-path": ["locate-path@6.0.0", "", { "dependencies": { "p-locate": "^5.0.0" } }, "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="],
+    "loader-runner": ["loader-runner@4.3.2", "", {}, "sha512-DFEqQ3ihfS9blba08cLfYf1NRAIEm+dDjic073DRDc3/JspI/8wYmtDsHwd3+4hwvdxSK7PGaElfTmm0awWJ4w=="],
 
-    "lodash-es": ["lodash-es@4.17.21", "", {}, "sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw=="],
+    "local-pkg": ["local-pkg@1.2.1", "", { "dependencies": { "mlly": "^1.7.4", "pkg-types": "^2.3.0", "quansync": "^0.2.11" } }, "sha512-++gUqRDEvcnN6Zhqrr+y/CkVEHhlrR96vZn3nZZPYzMcBUyBtTKzB9NadClFIsIVSsu+3i9tfk/erqy9kAmt7Q=="],
 
-    "log-symbols": ["log-symbols@5.1.0", "", { "dependencies": { "chalk": "^5.0.0", "is-unicode-supported": "^1.1.0" } }, "sha512-l0x2DvrW294C9uDCoQe1VSU4gf529FkSZ6leBl4TiqZH/e+0R7hSfHQBNut2mNygDgHwvYHfFLn6Oxb3VWj2rA=="],
+    "lodash-es": ["lodash-es@4.18.1", "", {}, "sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A=="],
 
     "longest-streak": ["longest-streak@3.1.0", "", {}, "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g=="],
 
+    "lower-case": ["lower-case@2.0.2", "", { "dependencies": { "tslib": "^2.0.3" } }, "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg=="],
+
     "lru-cache": ["lru-cache@11.1.0", "", {}, "sha512-QIXZUBJUx+2zHUdQujWejBkcD9+cs94tLn0+YL8UrCh+D5sCXZ4c7LaEH48pNwRY3MLDgqUFyhlCyjJPf1WP0A=="],
 
-    "mark.js": ["mark.js@8.11.1", "", {}, "sha512-1I+1qpDt4idfgLQG+BNWmrqku+7/2bi5nLf4YwF8y8zXvmfiTBY3PV3ZibfrjBueCByROpuBjLLFCajqkgYoLQ=="],
+    "lz-string": ["lz-string@1.5.0", "", { "bin": { "lz-string": "bin/bin.js" } }, "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ=="],
+
+    "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="],
 
     "markdown-extensions": ["markdown-extensions@2.0.0", "", {}, "sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q=="],
 
     "markdown-table": ["markdown-table@3.0.4", "", {}, "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw=="],
 
-    "marked": ["marked@16.0.0", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-MUKMXDjsD/eptB7GPzxo4xcnLS6oo7/RHimUMHEDRhUooPwmN9BEpMl7AEOJv3bmso169wHI2wUF9VQgL7zfmA=="],
+    "marked": ["marked@16.4.2", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-TI3V8YYWvkVf3KJe1dRkpnjs68JUPyEa5vjKrp1XEEJUAOaQc+Qj+L1qWbPd0SJuAdQkFU0h73sXXqwDYxsiDA=="],
+
+    "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],
 
     "mdast-util-directive": ["mdast-util-directive@3.1.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "ccount": "^2.0.0", "devlop": "^1.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0", "parse-entities": "^4.0.0", "stringify-entities": "^4.0.0", "unist-util-visit-parents": "^6.0.0" } }, "sha512-I3fNFt+DHmpWCYAT7quoM6lHf9wuqtI+oCOfvILnoicNIqjh5E3dEJWiXuYME2gNe8vl1iMQwyUHa7bgFmak6Q=="],
 
@@ -994,27 +1041,25 @@
 
     "mdast-util-phrasing": ["mdast-util-phrasing@4.1.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "unist-util-is": "^6.0.0" } }, "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w=="],
 
-    "mdast-util-to-hast": ["mdast-util-to-hast@13.2.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@ungap/structured-clone": "^1.0.0", "devlop": "^1.0.0", "micromark-util-sanitize-uri": "^2.0.0", "trim-lines": "^3.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" } }, "sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA=="],
+    "mdast-util-to-hast": ["mdast-util-to-hast@13.2.1", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@ungap/structured-clone": "^1.0.0", "devlop": "^1.0.0", "micromark-util-sanitize-uri": "^2.0.0", "trim-lines": "^3.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" } }, "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA=="],
 
     "mdast-util-to-markdown": ["mdast-util-to-markdown@2.1.2", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "longest-streak": "^3.0.0", "mdast-util-phrasing": "^4.0.0", "mdast-util-to-string": "^4.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-decode-string": "^2.0.0", "unist-util-visit": "^5.0.0", "zwitch": "^2.0.0" } }, "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA=="],
 
     "mdast-util-to-string": ["mdast-util-to-string@4.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0" } }, "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg=="],
 
-    "media-query-parser": ["media-query-parser@2.0.2", "", { "dependencies": { "@babel/runtime": "^7.12.5" } }, "sha512-1N4qp+jE0pL5Xv4uEcwVUhIkwdUO3S/9gML90nqKA7v7FcOS5vUtatfzok9S9U1EJU8dHWlcv95WLnKmmxZI9w=="],
-
-    "merge-stream": ["merge-stream@2.0.0", "", {}, "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w=="],
+    "media-typer": ["media-typer@1.1.0", "", {}, "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw=="],
 
-    "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="],
+    "merge-descriptors": ["merge-descriptors@2.0.0", "", {}, "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g=="],
 
-    "mermaid": ["mermaid@11.9.0", "", { "dependencies": { "@braintree/sanitize-url": "^7.0.4", "@iconify/utils": "^2.1.33", "@mermaid-js/parser": "^0.6.2", "@types/d3": "^7.4.3", "cytoscape": "^3.29.3", "cytoscape-cose-bilkent": "^4.1.0", "cytoscape-fcose": "^2.2.0", "d3": "^7.9.0", "d3-sankey": "^0.12.3", "dagre-d3-es": "7.0.11", "dayjs": "^1.11.13", "dompurify": "^3.2.5", "katex": "^0.16.22", "khroma": "^2.1.0", "lodash-es": "^4.17.21", "marked": "^16.0.0", "roughjs": "^4.6.6", "stylis": "^4.3.6", "ts-dedent": "^2.2.0", "uuid": "^11.1.0" } }, "sha512-YdPXn9slEwO0omQfQIsW6vS84weVQftIyyTGAZCwM//MGhPzL1+l6vO6bkf0wnP4tHigH1alZ5Ooy3HXI2gOag=="],
+    "merge-stream": ["merge-stream@2.0.0", "", {}, "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w=="],
 
-    "mermaid-isomorphic": ["mermaid-isomorphic@3.0.4", "", { "dependencies": { "@fortawesome/fontawesome-free": "^6.0.0", "mermaid": "^11.0.0" }, "peerDependencies": { "playwright": "1" }, "optionalPeers": ["playwright"] }, "sha512-XQTy7H1XwHK3DPEHf+ZNWiqUEd9BwX3Xws38R9Fj2gx718srmgjlZoUzHr+Tca+O+dqJOJsAJaKzCoP65QDfDg=="],
+    "mermaid": ["mermaid@11.15.0", "", { "dependencies": { "@braintree/sanitize-url": "^7.1.1", "@iconify/utils": "^3.0.2", "@mermaid-js/parser": "^1.1.1", "@types/d3": "^7.4.3", "@upsetjs/venn.js": "^2.0.0", "cytoscape": "^3.33.1", "cytoscape-cose-bilkent": "^4.1.0", "cytoscape-fcose": "^2.2.0", "d3": "^7.9.0", "d3-sankey": "^0.12.3", "dagre-d3-es": "7.0.14", "dayjs": "^1.11.19", "dompurify": "^3.3.1", "es-toolkit": "^1.45.1", "katex": "^0.16.25", "khroma": "^2.1.0", "marked": "^16.3.0", "roughjs": "^4.6.6", "stylis": "^4.3.6", "ts-dedent": "^2.2.0", "uuid": "^11.1.0 || ^12 || ^13 || ^14.0.0" } }, "sha512-pTMbcf3rWdtLiYGpmoTjHEpeY8seiy6sR+9nD7LOs8KfUbHE4lOUAprTRqRAcWSQ6MQpdX+YEsxShtGsINtPtw=="],
 
     "micromark": ["micromark@4.0.2", "", { "dependencies": { "@types/debug": "^4.0.0", "debug": "^4.0.0", "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-core-commonmark": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-combine-extensions": "^2.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-encode": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-sanitize-uri": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA=="],
 
     "micromark-core-commonmark": ["micromark-core-commonmark@2.0.3", "", { "dependencies": { "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-factory-destination": "^2.0.0", "micromark-factory-label": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-factory-title": "^2.0.0", "micromark-factory-whitespace": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-html-tag-name": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg=="],
 
-    "micromark-extension-directive": ["micromark-extension-directive@3.0.2", "", { "dependencies": { "devlop": "^1.0.0", "micromark-factory-space": "^2.0.0", "micromark-factory-whitespace": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0", "parse-entities": "^4.0.0" } }, "sha512-wjcXHgk+PPdmvR58Le9d7zQYWy+vKEU9Se44p2CrCDPiLr2FMyiT4Fyb5UFKFC66wGB3kPlgD7q3TnoqPS7SZA=="],
+    "micromark-extension-directive": ["micromark-extension-directive@4.0.0", "", { "dependencies": { "devlop": "^1.0.0", "micromark-factory-space": "^2.0.0", "micromark-factory-whitespace": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0", "parse-entities": "^4.0.0" } }, "sha512-/C2nqVmXXmiseSSuCdItCMho7ybwwop6RrrRPk0KbOHW21JKoCldC+8rFOaundDoRBUWBnJJcxeA/Kvi34WQXg=="],
 
     "micromark-extension-frontmatter": ["micromark-extension-frontmatter@2.0.0", "", { "dependencies": { "fault": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-C4AkuM3dA58cgZha7zVnuVxBhDsbttIMiytjgsM2XbHAB2faRVaHRle40558FBN+DJcrLNCoqG5mlrpdU4cRtg=="],
 
@@ -1084,123 +1129,115 @@
 
     "micromark-util-types": ["micromark-util-types@2.0.2", "", {}, "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA=="],
 
-    "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="],
-
-    "mime": ["mime@1.6.0", "", { "bin": { "mime": "cli.js" } }, "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg=="],
-
     "mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="],
 
-    "mimic-fn": ["mimic-fn@2.1.0", "", {}, "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg=="],
-
-    "mini-svg-data-uri": ["mini-svg-data-uri@1.4.4", "", { "bin": { "mini-svg-data-uri": "cli.js" } }, "sha512-r9deDe9p5FJUPZAk3A59wGH7Ii9YrjjWw0jmw/liSbHl2CHiyXj6FcDXDu2K3TjVAXqiJdaw3xxwlZZr9E6nHg=="],
+    "mime-types": ["mime-types@3.0.2", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A=="],
 
     "minimatch": ["minimatch@10.2.5", "", { "dependencies": { "brace-expansion": "^5.0.5" } }, "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg=="],
 
     "minipass": ["minipass@7.1.2", "", {}, "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw=="],
 
-    "minisearch": ["minisearch@6.3.0", "", {}, "sha512-ihFnidEeU8iXzcVHy74dhkxh/dn8Dc08ERl0xwoMMGqp4+LvRSCgicb+zGqWthVokQKvCSxITlh3P08OzdTYCQ=="],
+    "minisearch": ["minisearch@7.2.0", "", {}, "sha512-dqT2XBYUOZOiC5t2HRnwADjhNS2cecp9u+TJRiJ1Qp/f5qjkeT5APcGPjHw+bz89Ms8Jp+cG4AlE+QZ/QnDglg=="],
 
     "mlly": ["mlly@1.7.4", "", { "dependencies": { "acorn": "^8.14.0", "pathe": "^2.0.1", "pkg-types": "^1.3.0", "ufo": "^1.5.4" } }, "sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw=="],
 
-    "modern-ahocorasick": ["modern-ahocorasick@1.1.0", "", {}, "sha512-sEKPVl2rM+MNVkGQt3ChdmD8YsigmXdn5NifZn6jiwn9LRJpWm8F3guhaqrJT/JOat6pwpbXEk6kv+b9DMIjsQ=="],
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
 
-    "ms": ["ms@2.0.0", "", {}, "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="],
+    "mz": ["mz@2.7.0", "", { "dependencies": { "any-promise": "^1.0.0", "object-assign": "^4.0.1", "thenify-all": "^1.0.0" } }, "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q=="],
 
-    "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
+    "nanoid": ["nanoid@3.3.12", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ=="],
 
-    "negotiator": ["negotiator@0.6.4", "", {}, "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w=="],
+    "negotiator": ["negotiator@1.0.0", "", {}, "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg=="],
 
-    "node-releases": ["node-releases@2.0.19", "", {}, "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw=="],
+    "neo-async": ["neo-async@2.6.2", "", {}, "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw=="],
 
-    "normalize-range": ["normalize-range@0.1.2", "", {}, "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA=="],
+    "next-tick": ["next-tick@1.1.0", "", {}, "sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ=="],
 
-    "npm-run-path": ["npm-run-path@4.0.1", "", { "dependencies": { "path-key": "^3.0.0" } }, "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw=="],
+    "no-case": ["no-case@3.0.4", "", { "dependencies": { "lower-case": "^2.0.2", "tslib": "^2.0.3" } }, "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg=="],
 
-    "nth-check": ["nth-check@2.1.1", "", { "dependencies": { "boolbase": "^1.0.0" } }, "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w=="],
+    "node-releases": ["node-releases@2.0.47", "", {}, "sha512-Uzmd6LXpouKo8EUK68IjH4+E01w/hXyV3R3g/geCJo+rXLNfh1xucB+LOzYEOQPSiUK3h/xZf0cQGcSsmyL2Og=="],
 
     "nuqs": ["nuqs@2.8.9", "", { "dependencies": { "@standard-schema/spec": "1.0.0" }, "peerDependencies": { "@remix-run/react": ">=2", "@tanstack/react-router": "^1", "next": ">=14.2.0", "react": ">=18.2.0 || ^19.0.0-0", "react-router": "^5 || ^6 || ^7", "react-router-dom": "^5 || ^6 || ^7" }, "optionalPeers": ["@remix-run/react", "@tanstack/react-router", "next", "react-router", "react-router-dom"] }, "sha512-8ou6AEwsxMWSYo2qkfZtYFVzngwbKmg4c00HVxC1fF6CEJv3Fwm6eoZmfVPALB+vw8Udo7KL5uy96PFcYe1BIQ=="],
 
-    "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="],
+    "object-assign": ["object-assign@4.1.1", "", {}, "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg=="],
 
-    "on-headers": ["on-headers@1.1.0", "", {}, "sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A=="],
+    "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="],
 
-    "onetime": ["onetime@5.1.2", "", { "dependencies": { "mimic-fn": "^2.1.0" } }, "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg=="],
+    "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="],
 
-    "oniguruma-to-es": ["oniguruma-to-es@2.3.0", "", { "dependencies": { "emoji-regex-xs": "^1.0.0", "regex": "^5.1.1", "regex-recursion": "^5.1.1" } }, "sha512-bwALDxriqfKGfUufKGGepCzu9x7nJQuoRoAFp4AnwehhC2crqrDIAP/uN2qdlsAvSMpeRC3+Yzhqc7hLmle5+g=="],
+    "once": ["once@1.4.0", "", { "dependencies": { "wrappy": "1" } }, "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w=="],
 
-    "ora": ["ora@7.0.1", "", { "dependencies": { "chalk": "^5.3.0", "cli-cursor": "^4.0.0", "cli-spinners": "^2.9.0", "is-interactive": "^2.0.0", "is-unicode-supported": "^1.3.0", "log-symbols": "^5.1.0", "stdin-discarder": "^0.1.0", "string-width": "^6.1.0", "strip-ansi": "^7.1.0" } }, "sha512-0TUxTiFJWv+JnjWm4o9yvuskpEJLXTcng8MJuKd+SzAzp2o+OP3HWqNhB4OdJRt1Vsd9/mR0oyaEYlOnL7XIRw=="],
+    "oniguruma-parser": ["oniguruma-parser@0.12.2", "", {}, "sha512-6HVa5oIrgMC6aA6WF6XyyqbhRPJrKR02L20+2+zpDtO5QAzGHAUGw5TKQvwi5vctNnRHkJYmjAhRVQF2EKdTQw=="],
 
-    "p-limit": ["p-limit@5.0.0", "", { "dependencies": { "yocto-queue": "^1.0.0" } }, "sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ=="],
+    "oniguruma-to-es": ["oniguruma-to-es@4.3.6", "", { "dependencies": { "oniguruma-parser": "^0.12.2", "regex": "^6.1.0", "regex-recursion": "^6.0.2" } }, "sha512-csuQ9x3Yr0cEIs/Zgx/OEt9iBw9vqIunAPQkx19R/fiMq2oGVTgcMqO/V3Ybqefr1TBvosI6jU539ksaBULJyA=="],
 
-    "p-locate": ["p-locate@5.0.0", "", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="],
+    "outvariant": ["outvariant@1.4.0", "", {}, "sha512-AlWY719RF02ujitly7Kk/0QlV+pXGFDHrHf9O2OKqyqgBieaPOIeuSkL8sRK6j2WK+/ZAURq2kZsY0d8JapUiw=="],
 
     "package-json-from-dist": ["package-json-from-dist@1.0.1", "", {}, "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw=="],
 
     "package-manager-detector": ["package-manager-detector@1.3.0", "", {}, "sha512-ZsEbbZORsyHuO00lY1kV3/t72yp6Ysay6Pd17ZAlNGuGwmWDLCJxFpRs0IzfXfj1o4icJOkUEioexFHzyPurSQ=="],
 
+    "parent-module": ["parent-module@1.0.1", "", { "dependencies": { "callsites": "^3.0.0" } }, "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g=="],
+
     "parse-entities": ["parse-entities@4.0.2", "", { "dependencies": { "@types/unist": "^2.0.0", "character-entities-legacy": "^3.0.0", "character-reference-invalid": "^2.0.0", "decode-named-character-reference": "^1.0.0", "is-alphanumerical": "^2.0.0", "is-decimal": "^2.0.0", "is-hexadecimal": "^2.0.0" } }, "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw=="],
 
-    "parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="],
+    "parse-json": ["parse-json@5.2.0", "", { "dependencies": { "@babel/code-frame": "^7.0.0", "error-ex": "^1.3.1", "json-parse-even-better-errors": "^2.3.0", "lines-and-columns": "^1.1.6" } }, "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg=="],
 
     "parseurl": ["parseurl@1.3.3", "", {}, "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="],
 
     "path-data-parser": ["path-data-parser@0.1.0", "", {}, "sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w=="],
 
-    "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="],
-
     "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
 
     "path-scurry": ["path-scurry@2.0.0", "", { "dependencies": { "lru-cache": "^11.0.0", "minipass": "^7.1.2" } }, "sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg=="],
 
-    "path-type": ["path-type@6.0.0", "", {}, "sha512-Vj7sf++t5pBD637NSfkxpHSMfWaeig5+DKWLhcqIYx6mWQz5hdJTGDVMQiJcw1ZYkhs7AazKDGpRVji1LJCZUQ=="],
+    "path-to-regexp": ["path-to-regexp@8.4.2", "", {}, "sha512-qRcuIdP69NPm4qbACK+aDogI5CBDMi1jKe0ry5rSQJz8JVLsC7jV8XpiJjGRLLol3N+R5ihGYcrPLTno6pAdBA=="],
+
+    "path-type": ["path-type@4.0.0", "", {}, "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw=="],
 
     "pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
 
     "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
 
-    "picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="],
+    "picomatch": ["picomatch@4.0.4", "", {}, "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A=="],
 
-    "pkg-types": ["pkg-types@1.3.1", "", { "dependencies": { "confbox": "^0.1.8", "mlly": "^1.7.4", "pathe": "^2.0.1" } }, "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ=="],
+    "pirates": ["pirates@4.0.7", "", {}, "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA=="],
 
-    "playwright": ["playwright@1.54.1", "", { "dependencies": { "playwright-core": "1.54.1" }, "optionalDependencies": { "fsevents": "2.3.2" }, "bin": { "playwright": "cli.js" } }, "sha512-peWpSwIBmSLi6aW2auvrUtf2DqY16YYcCMO8rTVx486jKmDTJg7UAhyrraP98GB8BoPURZP8+nxO7TSd4cPr5g=="],
+    "pkce-challenge": ["pkce-challenge@5.0.1", "", {}, "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ=="],
 
-    "playwright-core": ["playwright-core@1.54.1", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-Nbjs2zjj0htNhzgiy5wu+3w09YetDx5pkrpI/kZotDlDUaYk0HVA5xrBVPdow4SAUIlhgKcJeJg4GRKW6xHusA=="],
+    "pkg-types": ["pkg-types@2.3.1", "", { "dependencies": { "confbox": "^0.2.4", "exsolve": "^1.0.8", "pathe": "^2.0.3" } }, "sha512-y+ichcgc2LrADuhLNAx8DFjVfgz91pRxfZdI3UDhxHvcVEZsenLO+7XaU5vOp0u/7V/wZ+plyuQxtrDlZJ+yeg=="],
 
     "points-on-curve": ["points-on-curve@0.2.0", "", {}, "sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A=="],
 
     "points-on-path": ["points-on-path@0.2.1", "", { "dependencies": { "path-data-parser": "0.1.0", "points-on-curve": "0.2.0" } }, "sha512-25ClnWWuw7JbWZcgqY/gJ4FQWadKxGWk+3kR/7kD0tCaDtPPMj7oHu2ToLaVhfpnHrZzYby2w6tUA0eOIuUg8g=="],
 
-    "postcss": ["postcss@8.5.6", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg=="],
-
-    "postcss-value-parser": ["postcss-value-parser@4.2.0", "", {}, "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ=="],
+    "postcss": ["postcss@8.5.15", "", { "dependencies": { "nanoid": "^3.3.12", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A=="],
 
-    "property-information": ["property-information@6.5.0", "", {}, "sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig=="],
+    "property-information": ["property-information@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
 
-    "quansync": ["quansync@0.2.10", "", {}, "sha512-t41VRkMYbkHyCYmOvx/6URnN80H7k4X0lLdBMGsz+maAwrJQYB1djpV6vHrQIBE0WBSGqhtEHrK9U3DWWH8v7A=="],
+    "proxy-addr": ["proxy-addr@2.0.7", "", { "dependencies": { "forwarded": "0.2.0", "ipaddr.js": "1.9.1" } }, "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg=="],
 
-    "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
+    "qs": ["qs@6.15.2", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw=="],
 
-    "radix-ui": ["radix-ui@1.4.2", "", { "dependencies": { "@radix-ui/primitive": "1.1.2", "@radix-ui/react-accessible-icon": "1.1.7", "@radix-ui/react-accordion": "1.2.11", "@radix-ui/react-alert-dialog": "1.1.14", "@radix-ui/react-arrow": "1.1.7", "@radix-ui/react-aspect-ratio": "1.1.7", "@radix-ui/react-avatar": "1.1.10", "@radix-ui/react-checkbox": "1.3.2", "@radix-ui/react-collapsible": "1.1.11", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-context-menu": "2.2.15", "@radix-ui/react-dialog": "1.1.14", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-dismissable-layer": "1.1.10", "@radix-ui/react-dropdown-menu": "2.1.15", "@radix-ui/react-focus-guards": "1.1.2", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-form": "0.1.7", "@radix-ui/react-hover-card": "1.1.14", "@radix-ui/react-label": "2.1.7", "@radix-ui/react-menu": "2.1.15", "@radix-ui/react-menubar": "1.1.15", "@radix-ui/react-navigation-menu": "1.2.13", "@radix-ui/react-one-time-password-field": "0.1.7", "@radix-ui/react-password-toggle-field": "0.1.2", "@radix-ui/react-popover": "1.1.14", "@radix-ui/react-popper": "1.2.7", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.4", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-progress": "1.1.7", "@radix-ui/react-radio-group": "1.3.7", "@radix-ui/react-roving-focus": "1.1.10", "@radix-ui/react-scroll-area": "1.2.9", "@radix-ui/react-select": "2.2.5", "@radix-ui/react-separator": "1.1.7", "@radix-ui/react-slider": "1.3.5", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-switch": "1.2.5", "@radix-ui/react-tabs": "1.1.12", "@radix-ui/react-toast": "1.2.14", "@radix-ui/react-toggle": "1.1.9", "@radix-ui/react-toggle-group": "1.1.10", "@radix-ui/react-toolbar": "1.1.10", "@radix-ui/react-tooltip": "1.2.7", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-escape-keydown": "1.1.1", "@radix-ui/react-use-is-hydrated": "0.1.0", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-use-size": "1.1.1", "@radix-ui/react-visually-hidden": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-fT/3YFPJzf2WUpqDoQi005GS8EpCi+53VhcLaHUj5fwkPYiZAjk1mSxFvbMA8Uq71L03n+WysuYC+mlKkXxt/Q=="],
+    "quansync": ["quansync@0.2.11", "", {}, "sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA=="],
 
     "range-parser": ["range-parser@1.2.1", "", {}, "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg=="],
 
-    "react": ["react@19.2.5", "", {}, "sha512-llUJLzz1zTUBrskt2pwZgLq59AemifIftw4aB7JxOqf1HY2FDaGDxgwpAPVzHU1kdWabH7FauP4i1oEeer2WCA=="],
+    "raw-body": ["raw-body@3.0.2", "", { "dependencies": { "bytes": "~3.1.2", "http-errors": "~2.0.1", "iconv-lite": "~0.7.0", "unpipe": "~1.0.0" } }, "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA=="],
 
-    "react-dom": ["react-dom@19.2.5", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.5" } }, "sha512-J5bAZz+DXMMwW/wV3xzKke59Af6CHY7G4uYLN1OvBcKEsWOs4pQExj86BBKamxl/Ik5bx9whOrvBlSDfWzgSag=="],
+    "react": ["react@19.2.6", "", {}, "sha512-sfWGGfavi0xr8Pg0sVsyHMAOziVYKgPLNrS7ig+ivMNb3wbCBw3KxtflsGBAwD3gYQlE/AEZsTLgToRrSCjb0Q=="],
 
-    "react-intersection-observer": ["react-intersection-observer@9.16.0", "", { "peerDependencies": { "react": "^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0" }, "optionalPeers": ["react-dom"] }, "sha512-w9nJSEp+DrW9KmQmeWHQyfaP6b03v+TdXynaoA964Wxt7mdR3An11z4NNCQgL4gKSK7y1ver2Fq+JKH6CWEzUA=="],
+    "react-devtools-inline": ["react-devtools-inline@4.4.0", "", { "dependencies": { "es6-symbol": "^3" } }, "sha512-ES0GolSrKO8wsKbsEkVeiR/ZAaHQTY4zDh1UW8DImVmm8oaGLl3ijJDvSGe+qDRKPZdPRnDtWWnSvvrgxXdThQ=="],
 
-    "react-refresh": ["react-refresh@0.17.0", "", {}, "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ=="],
+    "react-dom": ["react-dom@19.2.6", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.6" } }, "sha512-0prMI+hvBbPjsWnxDLxlCGyM8PN6UuWjEUCYmZhO67xIV9Xasa/r/vDnq+Xyq4Lo27g8QSbO5YzARu0D1Sps3g=="],
 
-    "react-remove-scroll": ["react-remove-scroll@2.7.1", "", { "dependencies": { "react-remove-scroll-bar": "^2.3.7", "react-style-singleton": "^2.2.3", "tslib": "^2.1.0", "use-callback-ref": "^1.3.3", "use-sidecar": "^1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-HpMh8+oahmIdOuS5aFKKY6Pyog+FNaZV/XyJOq7b4YFwsFHe5yYfdbIalI4k3vU2nSDql7YskmUseHsRrJqIPA=="],
+    "react-error-boundary": ["react-error-boundary@6.1.2", "", { "peerDependencies": { "react": "^18.0.0 || ^19.0.0" } }, "sha512-3DpCr5HVdZ0caUjYE/kIHBEJN0mNP3ZCgf16c48uJ5TbWjorKVp+YG8W3XqlJ7vJAVNw6wNIImyPXmFydwmyng=="],
 
-    "react-remove-scroll-bar": ["react-remove-scroll-bar@2.3.8", "", { "dependencies": { "react-style-singleton": "^2.2.2", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" }, "optionalPeers": ["@types/react"] }, "sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q=="],
+    "react-is": ["react-is@17.0.2", "", {}, "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w=="],
 
     "react-router": ["react-router@7.14.1", "", { "dependencies": { "cookie": "^1.0.1", "set-cookie-parser": "^2.6.0" }, "peerDependencies": { "react": ">=18", "react-dom": ">=18" }, "optionalPeers": ["react-dom"] }, "sha512-5BCvFskyAAVumqhEKh/iPhLOIkfxcEUz8WqFIARCkMg8hZZzDYX9CtwxXA0e+qT8zAxmMC0x3Ckb9iMONwc5jg=="],
 
-    "react-style-singleton": ["react-style-singleton@2.2.3", "", { "dependencies": { "get-nonce": "^1.0.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ=="],
-
-    "readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="],
+    "react-server-dom-webpack": ["react-server-dom-webpack@19.2.6", "", { "dependencies": { "acorn-loose": "^8.3.0", "neo-async": "^2.6.1", "webpack-sources": "^3.2.0" }, "peerDependencies": { "react": "^19.2.6", "react-dom": "^19.2.6", "webpack": "^5.59.0" } }, "sha512-762YXjBPc6hw2V16k4x1sdnw0mxghcSPzoiOhefGYjiTguJLCImGBUz6EjznPIfqKhWgLtpaQMlBhp66N8dKrw=="],
 
     "recma-build-jsx": ["recma-build-jsx@1.0.0", "", { "dependencies": { "@types/estree": "^1.0.0", "estree-util-build-jsx": "^3.0.0", "vfile": "^6.0.0" } }, "sha512-8GtdyqaBcDfva+GUKDr3nev3VpKAhup1+RvkMvUxURHpW7QyIvk9F5wz7Vzo06CEMSilw6uArgRqhpiUcWp8ew=="],
 
@@ -1210,23 +1247,21 @@
 
     "recma-stringify": ["recma-stringify@1.0.0", "", { "dependencies": { "@types/estree": "^1.0.0", "estree-util-to-js": "^2.0.0", "unified": "^11.0.0", "vfile": "^6.0.0" } }, "sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g=="],
 
-    "regex": ["regex@5.1.1", "", { "dependencies": { "regex-utilities": "^2.3.0" } }, "sha512-dN5I359AVGPnwzJm2jN1k0W9LPZ+ePvoOeVMMfqIMFz53sSwXkxaJoxr50ptnsC771lK95BnTrVSZxq0b9yCGw=="],
+    "regex": ["regex@6.1.0", "", { "dependencies": { "regex-utilities": "^2.3.0" } }, "sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg=="],
 
-    "regex-recursion": ["regex-recursion@5.1.1", "", { "dependencies": { "regex": "^5.1.1", "regex-utilities": "^2.3.0" } }, "sha512-ae7SBCbzVNrIjgSbh7wMznPcQel1DNlDtzensnFxpiNpXt1U2ju/bHugH422r+4LAVS1FpW1YCwilmnNsjum9w=="],
+    "regex-recursion": ["regex-recursion@6.0.2", "", { "dependencies": { "regex-utilities": "^2.3.0" } }, "sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg=="],
 
     "regex-utilities": ["regex-utilities@2.3.0", "", {}, "sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng=="],
 
     "rehype-autolink-headings": ["rehype-autolink-headings@7.1.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@ungap/structured-clone": "^1.0.0", "hast-util-heading-rank": "^3.0.0", "hast-util-is-element": "^3.0.0", "unified": "^11.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-rItO/pSdvnvsP4QRB1pmPiNHUskikqtPojZKJPPPAVx9Hj8i8TwMBhofrrAYRhYOOBZH9tgmG5lPqDLuIWPWmw=="],
 
-    "rehype-class-names": ["rehype-class-names@2.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-classnames": "^3.0.0", "hast-util-select": "^6.0.0", "unified": "^11.0.4" } }, "sha512-jldCIiAEvXKdq8hqr5f5PzNdIDkvHC6zfKhwta9oRoMu7bn0W7qLES/JrrjBvr9rKz3nJ8x4vY1EWI+dhjHVZQ=="],
-
-    "rehype-mermaid": ["rehype-mermaid@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-from-html-isomorphic": "^2.0.0", "hast-util-to-text": "^4.0.0", "mermaid-isomorphic": "^3.0.0", "mini-svg-data-uri": "^1.0.0", "space-separated-tokens": "^2.0.0", "unified": "^11.0.0", "unist-util-visit-parents": "^6.0.0", "vfile": "^6.0.0" }, "peerDependencies": { "playwright": "1" }, "optionalPeers": ["playwright"] }, "sha512-fxrD5E4Fa1WXUjmjNDvLOMT4XB1WaxcfycFIWiYU0yEMQhcTDElc9aDFnbDFRLxG1Cfo1I3mfD5kg4sjlWaB+Q=="],
-
     "rehype-recma": ["rehype-recma@1.0.0", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/hast": "^3.0.0", "hast-util-to-estree": "^3.0.0" } }, "sha512-lqA4rGUf1JmacCNWWZx0Wv1dHqMwxzsDWYMTowuplHF3xH0N/MmrZ/G3BDZnzAkRmxDadujCjaKM2hqYdCBOGw=="],
 
     "rehype-slug": ["rehype-slug@6.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "github-slugger": "^2.0.0", "hast-util-heading-rank": "^3.0.0", "hast-util-to-string": "^3.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-lWyvf/jwu+oS5+hL5eClVd3hNdmwM1kAC0BUvEGD19pajQMIzcNUd/k9GsfQ+FfECvX+JE+e9/btsKH0EjJT6A=="],
 
-    "remark-directive": ["remark-directive@3.0.1", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-directive": "^3.0.0", "micromark-extension-directive": "^3.0.0", "unified": "^11.0.0" } }, "sha512-gwglrEQEZcZYgVyG1tQuA+h58EZfq5CSULw7J90AFuCTyib1thgHPoqQ+h9iFvU6R+vnZ5oNFQR5QKgGpk741A=="],
+    "rehype-stringify": ["rehype-stringify@10.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-to-html": "^9.0.0", "unified": "^11.0.0" } }, "sha512-k9ecfXHmIPuFVI61B9DeLPN0qFHfawM6RsuX48hoqlaKSF61RskNjSm1lI8PhBEM0MRdLxVVm4WmTqJQccH9mA=="],
+
+    "remark-directive": ["remark-directive@4.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-directive": "^3.0.0", "micromark-extension-directive": "^4.0.0", "unified": "^11.0.0" } }, "sha512-7sxn4RfF1o3izevPV1DheyGDD6X4c9hrGpfdUpm7uC++dqrnJxIZVkk7CoKqcLm0VUMAuOol7Mno3m6g8cfMuA=="],
 
     "remark-frontmatter": ["remark-frontmatter@5.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-frontmatter": "^2.0.0", "micromark-extension-frontmatter": "^2.0.0", "unified": "^11.0.0" } }, "sha512-XTFYvNASMe5iPN0719nPrdItC9aU0ssC4v14mH1BCi1u0n1gAocqcujWUrByftZTbLhRtiKRyjYTSIOcr69UVQ=="],
 
@@ -1242,33 +1277,37 @@
 
     "remark-stringify": ["remark-stringify@11.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-to-markdown": "^2.0.0", "unified": "^11.0.0" } }, "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw=="],
 
-    "require-like": ["require-like@0.1.2", "", {}, "sha512-oyrU88skkMtDdauHDuKVrgR+zuItqr6/c//FXzvmxRGMexSDc6hNvJInGW3LL46n+8b50RykrvwSUIIQH2LQ5A=="],
+    "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="],
+
+    "reselect": ["reselect@5.2.0", "", {}, "sha512-AgZ3UOZm3YndfrJ4OYjgrT7bmCm/1iqkjvEfH/oYjzh6PD2qw4QuT3jjnXIrpdt4MTpMXclMT3lXbmRY+XRakw=="],
 
-    "restore-cursor": ["restore-cursor@4.0.0", "", { "dependencies": { "onetime": "^5.1.0", "signal-exit": "^3.0.2" } }, "sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg=="],
+    "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="],
 
-    "reusify": ["reusify@1.1.0", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="],
+    "robust-predicates": ["robust-predicates@3.0.3", "", {}, "sha512-NS3levdsRIUOmiJ8FZWCP7LG3QpJyrs/TE0Zpf1yvZu8cAJJ6QMW92H1c7kWpdIHo8RvmLxN/o2JXTKHp74lUA=="],
 
-    "robust-predicates": ["robust-predicates@3.0.2", "", {}, "sha512-IXgzBWvWQwE6PrDI05OvmXUIruQTcoMDzRsOd5CDvHCVLcLHMTSYvOK5Cm46kWqlV3yAbuSpBZdJ5oP5OUoStg=="],
+    "rolldown": ["rolldown@1.0.3", "", { "dependencies": { "@oxc-project/types": "=0.133.0", "@rolldown/pluginutils": "^1.0.0" }, "optionalDependencies": { "@rolldown/binding-android-arm64": "1.0.3", "@rolldown/binding-darwin-arm64": "1.0.3", "@rolldown/binding-darwin-x64": "1.0.3", "@rolldown/binding-freebsd-x64": "1.0.3", "@rolldown/binding-linux-arm-gnueabihf": "1.0.3", "@rolldown/binding-linux-arm64-gnu": "1.0.3", "@rolldown/binding-linux-arm64-musl": "1.0.3", "@rolldown/binding-linux-ppc64-gnu": "1.0.3", "@rolldown/binding-linux-s390x-gnu": "1.0.3", "@rolldown/binding-linux-x64-gnu": "1.0.3", "@rolldown/binding-linux-x64-musl": "1.0.3", "@rolldown/binding-openharmony-arm64": "1.0.3", "@rolldown/binding-wasm32-wasi": "1.0.3", "@rolldown/binding-win32-arm64-msvc": "1.0.3", "@rolldown/binding-win32-x64-msvc": "1.0.3" }, "bin": { "rolldown": "./bin/cli.mjs" } }, "sha512-i00lAJ2ks1BYr7rjNjKC7BcqAS7nVfiT3QX1SI5aY+AFHblCmaUf9OE9dbdzDvW6dJxbi2ZCZiy9v3CcwOiX3g=="],
 
     "rollup": ["rollup@4.45.1", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.45.1", "@rollup/rollup-android-arm64": "4.45.1", "@rollup/rollup-darwin-arm64": "4.45.1", "@rollup/rollup-darwin-x64": "4.45.1", "@rollup/rollup-freebsd-arm64": "4.45.1", "@rollup/rollup-freebsd-x64": "4.45.1", "@rollup/rollup-linux-arm-gnueabihf": "4.45.1", "@rollup/rollup-linux-arm-musleabihf": "4.45.1", "@rollup/rollup-linux-arm64-gnu": "4.45.1", "@rollup/rollup-linux-arm64-musl": "4.45.1", "@rollup/rollup-linux-loongarch64-gnu": "4.45.1", "@rollup/rollup-linux-powerpc64le-gnu": "4.45.1", "@rollup/rollup-linux-riscv64-gnu": "4.45.1", "@rollup/rollup-linux-riscv64-musl": "4.45.1", "@rollup/rollup-linux-s390x-gnu": "4.45.1", "@rollup/rollup-linux-x64-gnu": "4.45.1", "@rollup/rollup-linux-x64-musl": "4.45.1", "@rollup/rollup-win32-arm64-msvc": "4.45.1", "@rollup/rollup-win32-ia32-msvc": "4.45.1", "@rollup/rollup-win32-x64-msvc": "4.45.1", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-4iya7Jb76fVpQyLoiVpzUrsjQ12r3dM7fIVz+4NwoYvZOShknRmiv+iu9CClZml5ZLGb0XMcYLutK6w9tgxHDw=="],
 
     "roughjs": ["roughjs@4.6.6", "", { "dependencies": { "hachure-fill": "^0.5.2", "path-data-parser": "^0.1.0", "points-on-curve": "^0.2.0", "points-on-path": "^0.2.1" } }, "sha512-ZUz/69+SYpFN/g/lUlo2FXcIjRkSu3nDarreVdGGndHEBJ6cXPdKguS8JGxwj5HA5xIbVKSmLgr5b3AWxtRfvQ=="],
 
-    "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="],
+    "router": ["router@2.2.0", "", { "dependencies": { "debug": "^4.4.0", "depd": "^2.0.0", "is-promise": "^4.0.0", "parseurl": "^1.3.3", "path-to-regexp": "^8.0.0" } }, "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ=="],
 
-    "rw": ["rw@1.3.3", "", {}, "sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ=="],
+    "rsc-html-stream": ["rsc-html-stream@0.0.7", "", {}, "sha512-v9+fuY7usTgvXdNl8JmfXCvSsQbq2YMd60kOeeMIqCJFZ69fViuIxztHei7v5mlMMa2h3SqS+v44Gu9i9xANZA=="],
 
-    "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
+    "rw": ["rw@1.3.3", "", {}, "sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ=="],
 
     "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="],
 
     "scheduler": ["scheduler@0.27.0", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="],
 
+    "schema-utils": ["schema-utils@4.3.3", "", { "dependencies": { "@types/json-schema": "^7.0.9", "ajv": "^8.9.0", "ajv-formats": "^2.1.1", "ajv-keywords": "^5.1.0" } }, "sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA=="],
+
     "semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
 
-    "send": ["send@0.19.0", "", { "dependencies": { "debug": "2.6.9", "depd": "2.0.0", "destroy": "1.2.0", "encodeurl": "~1.0.2", "escape-html": "~1.0.3", "etag": "~1.8.1", "fresh": "0.5.2", "http-errors": "2.0.0", "mime": "1.6.0", "ms": "2.1.3", "on-finished": "2.4.1", "range-parser": "~1.2.1", "statuses": "2.0.1" } }, "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw=="],
+    "send": ["send@1.2.1", "", { "dependencies": { "debug": "^4.4.3", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "fresh": "^2.0.0", "http-errors": "^2.0.1", "mime-types": "^3.0.2", "ms": "^2.1.3", "on-finished": "^2.4.1", "range-parser": "^1.2.1", "statuses": "^2.0.2" } }, "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ=="],
 
-    "serve-static": ["serve-static@1.16.2", "", { "dependencies": { "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "parseurl": "~1.3.3", "send": "0.19.0" } }, "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw=="],
+    "serve-static": ["serve-static@2.2.1", "", { "dependencies": { "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "parseurl": "^1.3.3", "send": "^1.2.0" } }, "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw=="],
 
     "set-cookie-parser": ["set-cookie-parser@2.7.1", "", {}, "sha512-IOc8uWeOZgnb3ptbCURJWNjWUPcO3ZnTTdzsurqERrP6nPyv+paC55vJM0LpOlT2ne+Ix+9+CRG1MNLlyZ4GjQ=="],
 
@@ -1278,55 +1317,79 @@
 
     "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
 
-    "shiki": ["shiki@1.29.2", "", { "dependencies": { "@shikijs/core": "1.29.2", "@shikijs/engine-javascript": "1.29.2", "@shikijs/engine-oniguruma": "1.29.2", "@shikijs/langs": "1.29.2", "@shikijs/themes": "1.29.2", "@shikijs/types": "1.29.2", "@shikijs/vscode-textmate": "^10.0.1", "@types/hast": "^3.0.4" } }, "sha512-njXuliz/cP+67jU2hukkxCNuH1yUi4QfdZZY+sMr5PPrIyXSu5iTb/qYC4BiWWB0vZ+7TbdvYUCeL23zpwCfbg=="],
+    "shiki": ["shiki@3.23.0", "", { "dependencies": { "@shikijs/core": "3.23.0", "@shikijs/engine-javascript": "3.23.0", "@shikijs/engine-oniguruma": "3.23.0", "@shikijs/langs": "3.23.0", "@shikijs/themes": "3.23.0", "@shikijs/types": "3.23.0", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-55Dj73uq9ZXL5zyeRPzHQsK7Nbyt6Y10k5s7OjuFZGMhpp4r/rsLBH0o/0fstIzX1Lep9VxefWljK/SKCzygIA=="],
 
-    "signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="],
+    "side-channel": ["side-channel@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3", "side-channel-list": "^1.0.0", "side-channel-map": "^1.0.1", "side-channel-weakmap": "^1.0.2" } }, "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw=="],
+
+    "side-channel-list": ["side-channel-list@1.0.1", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.4" } }, "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w=="],
+
+    "side-channel-map": ["side-channel-map@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3" } }, "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA=="],
+
+    "side-channel-weakmap": ["side-channel-weakmap@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3", "side-channel-map": "^1.0.1" } }, "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A=="],
 
-    "sisteransi": ["sisteransi@1.0.5", "", {}, "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="],
+    "signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="],
 
-    "slash": ["slash@5.1.0", "", {}, "sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg=="],
+    "snake-case": ["snake-case@3.0.4", "", { "dependencies": { "dot-case": "^3.0.4", "tslib": "^2.0.3" } }, "sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg=="],
 
     "source-map": ["source-map@0.7.4", "", {}, "sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA=="],
 
     "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
 
+    "source-map-support": ["source-map-support@0.5.21", "", { "dependencies": { "buffer-from": "^1.0.0", "source-map": "^0.6.0" } }, "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w=="],
+
     "space-separated-tokens": ["space-separated-tokens@2.0.2", "", {}, "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q=="],
 
+    "srvx": ["srvx@0.11.16", "", { "bin": { "srvx": "bin/srvx.mjs" } }, "sha512-bp07zRuycfTY43IjAvvTFnmnJi8ikW0VFiHwOhhYcVW/L4xQ1XY4PAd4Nuum1rsA17C39zL7x+CDhrn5AL32Rw=="],
+
+    "static-browser-server": ["static-browser-server@1.0.3", "", { "dependencies": { "@open-draft/deferred-promise": "^2.1.0", "dotenv": "^16.0.3", "mime-db": "^1.52.0", "outvariant": "^1.3.0" } }, "sha512-ZUyfgGDdFRbZGGJQ1YhiM930Yczz5VlbJObrQLlk24+qNHVQx4OlLcYswEUo3bIyNAbQUIUR9Yr5/Hqjzqb4zA=="],
+
     "statuses": ["statuses@2.0.1", "", {}, "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ=="],
 
-    "stdin-discarder": ["stdin-discarder@0.1.0", "", { "dependencies": { "bl": "^5.0.0" } }, "sha512-xhV7w8S+bUwlPTb4bAOUQhv8/cSS5offJuX8GQGq32ONF0ZtDWKfkdomM3HMRA+LhX6um/FZ0COqlwsjD53LeQ=="],
+    "strict-event-emitter": ["strict-event-emitter@0.4.6", "", {}, "sha512-12KWeb+wixJohmnwNFerbyiBrAlq5qJLwIt38etRtKtmmHyDSoGlIqFE9wx+4IwG0aDjI7GV8tc8ZccjWZZtTg=="],
 
-    "string-width": ["string-width@6.1.0", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^10.2.1", "strip-ansi": "^7.0.1" } }, "sha512-k01swCJAgQmuADB0YIc+7TuatfNvTBVOoaUWJjTB9R4VJzR5vNWzf5t42ESVZFPS8xTySF7CAdV4t/aaIm3UnQ=="],
+    "string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
 
     "string-width-cjs": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
 
-    "string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="],
-
     "stringify-entities": ["stringify-entities@4.0.4", "", { "dependencies": { "character-entities-html4": "^2.0.0", "character-entities-legacy": "^3.0.0" } }, "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg=="],
 
     "strip-ansi": ["strip-ansi@7.1.0", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ=="],
 
     "strip-ansi-cjs": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
 
-    "strip-final-newline": ["strip-final-newline@2.0.0", "", {}, "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA=="],
+    "strip-literal": ["strip-literal@3.1.0", "", { "dependencies": { "js-tokens": "^9.0.1" } }, "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg=="],
+
+    "style-mod": ["style-mod@4.1.3", "", {}, "sha512-i/n8VsZydrugj3Iuzll8+x/00GH2vnYsk1eomD8QiRrSAeW6ItbCQDtfXCeJHd0iwiNagqjQkvpvREEPtW3IoQ=="],
 
     "style-to-js": ["style-to-js@1.1.17", "", { "dependencies": { "style-to-object": "1.0.9" } }, "sha512-xQcBGDxJb6jjFCTzvQtfiPn6YvvP2O8U1MDIPNfJQlWMYfktPy+iGsHE7cssjs7y84d9fQaK4UF3RIJaAHSoYA=="],
 
     "style-to-object": ["style-to-object@1.0.9", "", { "dependencies": { "inline-style-parser": "0.2.4" } }, "sha512-G4qppLgKu/k6FwRpHiGiKPaPTFcG3g4wNVX/Qsfu+RqQM30E7Tyu/TEgxcL9PNLF5pdRLwQdE3YKKf+KF2Dzlw=="],
 
-    "stylis": ["stylis@4.3.6", "", {}, "sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ=="],
+    "stylis": ["stylis@4.4.0", "", {}, "sha512-5Z9ZpRzfuH6l/UAvCPAPUo3665Nk2wLaZU3x+TLHKVzIz33+sbJqbtrYoC3KD4/uVOr2Zp+L0LySezP9OHV9yA=="],
 
-    "tabbable": ["tabbable@6.2.0", "", {}, "sha512-Cat63mxsVJlzYvN51JmVXIgNoUokrIaT2zLclCXjRd8boZ0004U4KCs/sToJ75C6sdlByWxpYnb5Boif1VSFew=="],
+    "sucrase": ["sucrase@3.35.1", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.2", "commander": "^4.0.0", "lines-and-columns": "^1.1.6", "mz": "^2.7.0", "pirates": "^4.0.1", "tinyglobby": "^0.2.11", "ts-interface-checker": "^0.1.9" }, "bin": { "sucrase": "bin/sucrase", "sucrase-node": "bin/sucrase-node" } }, "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw=="],
 
-    "tailwindcss": ["tailwindcss@4.0.7", "", {}, "sha512-yH5bPPyapavo7L+547h3c4jcBXcrKwybQRjwdEIVAd9iXRvy/3T1CC6XSQEgZtRySjKfqvo3Cc0ZF1DTheuIdA=="],
+    "supports-color": ["supports-color@8.1.1", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q=="],
 
-    "tapable": ["tapable@2.3.2", "", {}, "sha512-1MOpMXuhGzGL5TTCZFItxCc0AARf1EZFQkGqMm7ERKj8+Hgr5oLvJOVFcC+lRmR8hCe2S3jC4T5D7Vg/d7/fhA=="],
+    "svg-parser": ["svg-parser@2.0.4", "", {}, "sha512-e4hG1hRwoOdRb37cIMSgzNsxyzKfayW6VOflrwvR+/bzrkyxY/31WkbgnQpgtrNp1SdpJvpUAGTa/ZoiPNDuRQ=="],
 
-    "tinyexec": ["tinyexec@1.0.1", "", {}, "sha512-5uC6DDlmeqiOwCPmK9jMSdOuZTh8bU39Ys6yidB+UTt5hfZUPGAypSgFRiEp+jbi9qH40BLDvy85jIU88wKSqw=="],
+    "tailwindcss": ["tailwindcss@4.3.0", "", {}, "sha512-y6nxMGB1nMW9R6k96e5gdIFzcfL/gTJRNaqGes1YvkLnPVXzWgbqFF2yLC0T8G774n24cx3Pe8XrKoniCOAH+Q=="],
+
+    "tailwindcss-logical": ["tailwindcss-logical@4.2.0", "", { "peerDependencies": { "tailwindcss": ">=4.0.0" } }, "sha512-G+7NFU8xiMczeaykFRvaDbfbpqvFWv05YG6RtS2klW1wvTRkUs96P/e+Zy/Qse6y0HL8tLQ+da8M7trDfu12sw=="],
+
+    "tapable": ["tapable@2.3.3", "", {}, "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A=="],
+
+    "terser": ["terser@5.48.0", "", { "dependencies": { "@jridgewell/source-map": "^0.3.3", "acorn": "^8.15.0", "commander": "^2.20.0", "source-map-support": "~0.5.20" }, "bin": { "terser": "bin/terser" } }, "sha512-J/9An6vs9Us6wKRriSFXBWdRZapREHqFzdNUKk0pmu804EMR6dr6winwo7e5JDxN4xahxQsuysyYFwlwj4XN/Q=="],
+
+    "terser-webpack-plugin": ["terser-webpack-plugin@5.6.1", "", { "dependencies": { "@jridgewell/trace-mapping": "^0.3.25", "jest-worker": "^27.4.5", "schema-utils": "^4.3.0", "terser": "^5.31.1" }, "peerDependencies": { "webpack": "^5.1.0" } }, "sha512-201R5j+sJpK8nFWwKVyNfZot8FaJbLZDq5evriVzbV1wDtSXDjRUDRfJzHpAaxFDMEhsZL1QkeqM61wgsS3KaQ=="],
 
-    "tinyglobby": ["tinyglobby@0.2.14", "", { "dependencies": { "fdir": "^6.4.4", "picomatch": "^4.0.2" } }, "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ=="],
+    "thenify": ["thenify@3.3.1", "", { "dependencies": { "any-promise": "^1.0.0" } }, "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw=="],
 
-    "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="],
+    "thenify-all": ["thenify-all@1.6.0", "", { "dependencies": { "thenify": ">= 3.1.0 < 4" } }, "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA=="],
+
+    "tinyexec": ["tinyexec@1.0.1", "", {}, "sha512-5uC6DDlmeqiOwCPmK9jMSdOuZTh8bU39Ys6yidB+UTt5hfZUPGAypSgFRiEp+jbi9qH40BLDvy85jIU88wKSqw=="],
+
+    "tinyglobby": ["tinyglobby@0.2.17", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.4" } }, "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g=="],
 
     "toidentifier": ["toidentifier@1.0.1", "", {}, "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA=="],
 
@@ -1338,26 +1401,30 @@
 
     "ts-dedent": ["ts-dedent@2.2.0", "", {}, "sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ=="],
 
+    "ts-interface-checker": ["ts-interface-checker@0.1.13", "", {}, "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA=="],
+
     "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
 
-    "twoslash": ["twoslash@0.2.12", "", { "dependencies": { "@typescript/vfs": "^1.6.0", "twoslash-protocol": "0.2.12" }, "peerDependencies": { "typescript": "*" } }, "sha512-tEHPASMqi7kqwfJbkk7hc/4EhlrKCSLcur+TcvYki3vhIfaRMXnXjaYFgXpoZRbT6GdprD4tGuVBEmTpUgLBsw=="],
+    "tsx": ["tsx@4.22.4", "", { "dependencies": { "esbuild": "~0.28.0" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "bin": { "tsx": "dist/cli.mjs" } }, "sha512-X8EX+XV4QR5xCsrgxaED954zTDfY8KqlDtskKEL0cHhyS/P8b4IFOvGDQpsC9Q1XnLq915wEfwwY/zzskCtmhg=="],
 
-    "twoslash-protocol": ["twoslash-protocol@0.2.12", "", {}, "sha512-5qZLXVYfZ9ABdjqbvPc4RWMr7PrpPaaDSeaYY55vl/w1j6H6kzsWK/urAEIXlzYlyrFmyz1UbwIt+AA0ck+wbg=="],
+    "turbo-stream": ["turbo-stream@3.2.0", "", {}, "sha512-EK+bZ9UVrVh7JLslVFOV0GEMsociOqVOvEMTAd4ixMyffN5YNIEdLZWXUx5PJqDbTxSIBWw04HS9gCY4frYQDQ=="],
 
-    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+    "twoslash": ["twoslash@0.3.8", "", { "dependencies": { "@typescript/vfs": "^1.6.4", "twoslash-protocol": "0.3.8" }, "peerDependencies": { "typescript": "^5.5.0 || ^6.0.0" } }, "sha512-OeDz0kDl8sqPUN3nr7gqcvOs70f5lZsdhKYTX3/SgB9OvdadzzoYJI/4SBXhXV1HG8E9fLc+e17itoRYTxmoig=="],
 
-    "ua-parser-js": ["ua-parser-js@1.0.40", "", { "bin": { "ua-parser-js": "script/cli.js" } }, "sha512-z6PJ8Lml+v3ichVojCiB8toQJBuwR42ySM4ezjXIqXK3M0HczmKQ3LF4rhU55PfD99KEEXQG6yb7iOMyvYuHew=="],
+    "twoslash-protocol": ["twoslash-protocol@0.3.8", "", {}, "sha512-HmvAHoiEviK8LqvAQyc9/irkdvwTUiR1fHmNwH/0gq8EHxyBt4PWVPixjEXg6wJu1u6yBrILEWXGK9Kw58/8yQ=="],
+
+    "type": ["type@2.7.3", "", {}, "sha512-8j+1QmAbPvLZow5Qpi6NCaN8FB60p/6x8/vfNqOk/hC+HuvFZhL4+WfekuhQLiqFZXOgQdrs3B+XxEmCc6b3FQ=="],
+
+    "type-is": ["type-is@2.1.0", "", { "dependencies": { "content-type": "^2.0.0", "media-typer": "^1.1.0", "mime-types": "^3.0.0" } }, "sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
 
     "ufo": ["ufo@1.6.1", "", {}, "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA=="],
 
     "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
 
-    "unicorn-magic": ["unicorn-magic@0.3.0", "", {}, "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA=="],
-
     "unified": ["unified@11.0.5", "", { "dependencies": { "@types/unist": "^3.0.0", "bail": "^2.0.0", "devlop": "^1.0.0", "extend": "^3.0.0", "is-plain-obj": "^4.0.0", "trough": "^2.0.0", "vfile": "^6.0.0" } }, "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA=="],
 
-    "unist-util-find-after": ["unist-util-find-after@5.0.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" } }, "sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ=="],
-
     "unist-util-is": ["unist-util-is@6.0.0", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw=="],
 
     "unist-util-mdx-define": ["unist-util-mdx-define@1.1.2", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "estree-util-is-identifier-name": "^3.0.0", "estree-util-scope": "^1.0.0", "estree-walker": "^3.0.0", "vfile": "^6.0.0" } }, "sha512-9ncH7i7TN5Xn7/tzX5bE3rXgz1X/u877gYVAUB3mLeTKYJmQHmqKTDBi6BTGXV7AeolBCI9ErcVsOt2qryoD0g=="],
@@ -1366,55 +1433,53 @@
 
     "unist-util-position-from-estree": ["unist-util-position-from-estree@2.0.0", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-KaFVRjoqLyF6YXCbVLNad/eS4+OfPQQn2yOd7zF/h5T/CSL2v8NpN6a5TPvtbXthAGw5nG+PuTtq+DdIZr+cRQ=="],
 
-    "unist-util-remove-position": ["unist-util-remove-position@5.0.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-Hp5Kh3wLxv0PHj9m2yZhhLt58KzPtEYKQQ4yxfYFEO7EvHwzyDYnduhHnY1mDxoqr7VUwVuHXk9RXKIiYS1N8Q=="],
-
     "unist-util-stringify-position": ["unist-util-stringify-position@4.0.0", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ=="],
 
     "unist-util-visit": ["unist-util-visit@5.0.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.0.0" } }, "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg=="],
 
     "unist-util-visit-parents": ["unist-util-visit-parents@6.0.1", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" } }, "sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw=="],
 
-    "universalify": ["universalify@2.0.1", "", {}, "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw=="],
+    "unpipe": ["unpipe@1.0.0", "", {}, "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="],
 
-    "update-browserslist-db": ["update-browserslist-db@1.1.3", "", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw=="],
+    "unplugin": ["unplugin@2.3.11", "", { "dependencies": { "@jridgewell/remapping": "^2.3.5", "acorn": "^8.15.0", "picomatch": "^4.0.3", "webpack-virtual-modules": "^0.6.2" } }, "sha512-5uKD0nqiYVzlmCRs01Fhs2BdkEgBS3SAVP6ndrBsuK42iC2+JHyxM05Rm9G8+5mkmRtzMZGY8Ct5+mliZxU/Ww=="],
 
-    "use-callback-ref": ["use-callback-ref@1.3.3", "", { "dependencies": { "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg=="],
+    "unplugin-icons": ["unplugin-icons@22.5.0", "", { "dependencies": { "@antfu/install-pkg": "^1.1.0", "@iconify/utils": "^3.0.2", "debug": "^4.4.3", "local-pkg": "^1.1.2", "unplugin": "^2.3.10" }, "peerDependencies": { "@svgr/core": ">=7.0.0", "@svgx/core": "^1.0.1", "@vue/compiler-sfc": "^3.0.2 || ^2.7.0", "svelte": "^3.0.0 || ^4.0.0 || ^5.0.0", "vue-template-compiler": "^2.6.12", "vue-template-es2015-compiler": "^1.9.0" }, "optionalPeers": ["@svgr/core", "@svgx/core", "@vue/compiler-sfc", "svelte", "vue-template-compiler", "vue-template-es2015-compiler"] }, "sha512-MBlMtT5RuMYZy4TZgqUL2OTtOdTUVsS1Mhj6G1pEzMlFJlEnq6mhUfoIt45gBWxHcsOdXJDWLg3pRZ+YmvAVWQ=="],
 
-    "use-sidecar": ["use-sidecar@1.1.3", "", { "dependencies": { "detect-node-es": "^1.1.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ=="],
+    "update-browserslist-db": ["update-browserslist-db@1.2.3", "", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w=="],
 
-    "use-sync-external-store": ["use-sync-external-store@1.5.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-Rb46I4cGGVBmjamjphe8L/UnvJD+uPPtTkNvX5mZgqdbavhI4EbgIWJiIHXJ8bc/i9EQGPRh4DwEURJ552Do0A=="],
+    "urlpattern-polyfill": ["urlpattern-polyfill@10.1.0", "", {}, "sha512-IGjKp/o0NL3Bso1PymYURCJxMPNAf/ILOpendP9f5B6e1rTJgdgiOvgfoT8VxCAdY+Wisb9uhGaJJf3yZ2V9nw=="],
 
-    "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="],
+    "use-sync-external-store": ["use-sync-external-store@1.6.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w=="],
 
-    "uuid": ["uuid@11.1.0", "", { "bin": { "uuid": "dist/esm/bin/uuid" } }, "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A=="],
+    "uuid": ["uuid@14.0.0", "", { "bin": { "uuid": "dist-node/bin/uuid" } }, "sha512-Qo+uWgilfSmAhXCMav1uYFynlQO7fMFiMVZsQqZRMIXp0O7rR7qjkj+cPvBHLgBqi960QCoo/PH2/6ZtVqKvrg=="],
 
     "vary": ["vary@1.1.2", "", {}, "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="],
 
     "vfile": ["vfile@6.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "vfile-message": "^4.0.0" } }, "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q=="],
 
-    "vfile-location": ["vfile-location@5.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "vfile": "^6.0.0" } }, "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg=="],
-
     "vfile-message": ["vfile-message@4.0.2", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-stringify-position": "^4.0.0" } }, "sha512-jRDZ1IMLttGj41KcZvlrYAaI3CfqpLpfpf+Mfig13viT6NKvRzWZ+lXz0Y5D60w6uJIBAOGq9mSHf0gktF0duw=="],
 
-    "vite": ["vite@6.3.5", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.4.4", "picomatch": "^4.0.2", "postcss": "^8.5.3", "rollup": "^4.34.9", "tinyglobby": "^0.2.13" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "jiti": ">=1.21.0", "less": "*", "lightningcss": "^1.21.0", "sass": "*", "sass-embedded": "*", "stylus": "*", "sugarss": "*", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ=="],
+    "vite": ["vite@8.0.16", "", { "dependencies": { "lightningcss": "^1.32.0", "picomatch": "^4.0.4", "postcss": "^8.5.15", "rolldown": "1.0.3", "tinyglobby": "^0.2.17" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "@vitejs/devtools": "^0.1.18", "esbuild": "^0.27.0 || ^0.28.0", "jiti": ">=1.21.0", "less": "^4.0.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "@vitejs/devtools", "esbuild", "jiti", "less", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-h9bXPmJichP5fLmVQo3PyaGSDE2n3aPuomeAlVRm0JLmt4rY6zmPKd59HYI4LNW8oTK7tlTsuC7l/m7awx9Jcw=="],
 
-    "vite-node": ["vite-node@3.2.4", "", { "dependencies": { "cac": "^6.7.14", "debug": "^4.4.1", "es-module-lexer": "^1.7.0", "pathe": "^2.0.3", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "bin": { "vite-node": "vite-node.mjs" } }, "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg=="],
+    "vite-plugin-arraybuffer": ["vite-plugin-arraybuffer@0.1.4", "", {}, "sha512-Ubfsw/g4PhdjlgsKYDm2Hlc0qmNJheX8VCeOMayq1k9fMVB1nNuqtWjDH1fj9hSlhlSnlndz/ehMKIuXpB0SeA=="],
 
-    "vocs": ["vocs@1.0.16", "", { "dependencies": { "@floating-ui/react": "^0.27.4", "@hono/node-server": "^1.13.8", "@mdx-js/react": "^3.1.0", "@mdx-js/rollup": "^3.1.0", "@noble/hashes": "^1.7.1", "@radix-ui/colors": "^3.0.0", "@radix-ui/react-accordion": "^1.2.3", "@radix-ui/react-dialog": "^1.1.6", "@radix-ui/react-icons": "^1.3.2", "@radix-ui/react-label": "^2.1.2", "@radix-ui/react-navigation-menu": "^1.2.5", "@radix-ui/react-popover": "^1.1.6", "@radix-ui/react-tabs": "^1.1.3", "@shikijs/rehype": "^1", "@shikijs/transformers": "^1", "@shikijs/twoslash": "^1", "@tailwindcss/vite": "4.0.7", "@vanilla-extract/css": "^1.17.1", "@vanilla-extract/dynamic": "^2.1.2", "@vanilla-extract/vite-plugin": "^5.0.1", "@vitejs/plugin-react": "^4.3.4", "autoprefixer": "^10.4.20", "cac": "^6.7.14", "chroma-js": "^3.1.2", "clsx": "^2.1.1", "compression": "^1.8.0", "create-vocs": "^1.0.0-alpha.5", "cross-spawn": "^7.0.6", "fs-extra": "^11.3.0", "globby": "^14.1.0", "hastscript": "^8.0.0", "hono": "^4.7.1", "mark.js": "^8.11.1", "mdast-util-directive": "^3.1.0", "mdast-util-from-markdown": "^2.0.2", "mdast-util-frontmatter": "^2.0.1", "mdast-util-gfm": "^3.1.0", "mdast-util-mdx": "^3.0.0", "mdast-util-mdx-jsx": "^3.2.0", "mdast-util-to-hast": "^13.2.0", "mdast-util-to-markdown": "^2.1.2", "minimatch": "^9.0.5", "minisearch": "^6.3.0", "nuqs": "^2.4.3", "ora": "^7.0.1", "p-limit": "^5.0.0", "playwright": "^1.52.0", "postcss": "^8.5.2", "radix-ui": "^1.1.3", "react-intersection-observer": "^9.15.1", "react-router": "^7.2.0", "rehype-autolink-headings": "^7.1.0", "rehype-class-names": "^2.0.0", "rehype-mermaid": "^3.0.0", "rehype-slug": "^6.0.0", "remark-directive": "^3.0.1", "remark-frontmatter": "^5.0.0", "remark-gfm": "^4.0.1", "remark-mdx": "^3.1.0", "remark-mdx-frontmatter": "^5.0.0", "remark-parse": "^11.0.0", "serve-static": "^1.16.2", "shiki": "^1", "toml": "^3.0.0", "twoslash": "~0.2.12", "ua-parser-js": "^1.0.40", "unified": "^11.0.5", "unist-util-visit": "^5.0.0", "vite": "^6.1.0" }, "peerDependencies": { "react": "^19", "react-dom": "^19" }, "bin": { "vocs": "_lib/cli/index.js" } }, "sha512-Jqe9SgqAxdjpWFV0WzvL/OHVha8ArF1wvwQd+WEBfzRLFHlFGIl35zUW0CczM0EuoePi85LU0axF9s1ToAR0Wg=="],
+    "vite-plugin-wasm": ["vite-plugin-wasm@3.6.0", "", { "peerDependencies": { "vite": "^2 || ^3 || ^4 || ^5 || ^6 || ^7 || ^8" } }, "sha512-mL/QPziiIA4RAA6DkaZZzOstdwbW5jO4Vz7Zenj0wieKWBlNvIvX5L5ljum9lcUX0ShNfBgCNLKTjNkRVVqcsw=="],
 
-    "vscode-jsonrpc": ["vscode-jsonrpc@8.2.0", "", {}, "sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA=="],
+    "vitefu": ["vitefu@1.1.3", "", { "peerDependencies": { "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" }, "optionalPeers": ["vite"] }, "sha512-ub4okH7Z5KLjb6hDyjqrGXqWtWvoYdU3IGm/NorpgHncKoLTCfRIbvlhBm7r0YstIaQRYlp4yEbFqDcKSzXSSg=="],
 
-    "vscode-languageserver": ["vscode-languageserver@9.0.1", "", { "dependencies": { "vscode-languageserver-protocol": "3.17.5" }, "bin": { "installServerIntoExtension": "bin/installServerIntoExtension" } }, "sha512-woByF3PDpkHFUreUa7Hos7+pUWdeWMXRd26+ZX2A8cFx6v/JPTtd4/uN0/jB6XQHYaOlHbio03NTHCqrgG5n7g=="],
+    "vocs": ["vocs@2.0.11", "", { "dependencies": { "@base-ui/react": "^1.0.0", "@codesandbox/sandpack-react": "^2.20.0", "@hono/node-server": "^2.0.2", "@iconify-json/lucide": "^1.2.82", "@iconify-json/simple-icons": "^1.2.65", "@iconify-json/vscode-icons": "^1.2.39", "@iconify/types": "^2.0.0", "@iconify/utils": "^3.1.0", "@mdx-js/mdx": "^3.1.1", "@mdx-js/react": "^3.1.1", "@mdx-js/rollup": "^3.1.1", "@modelcontextprotocol/sdk": "^1.25.2", "@remix-run/node-fetch-server": "^0.13.0", "@shikijs/rehype": "^3.20.0", "@shikijs/transformers": "^3.20.0", "@shikijs/twoslash": "^3.20.0", "@shikijs/types": "^3.20.0", "@svgr/core": "^8.1.0", "@svgr/plugin-jsx": "^8.1.0", "@tailwindcss/vite": "^4.3.0", "@takumi-rs/image-response": "^0.62.7", "@takumi-rs/wasm": "^0.62.7", "@vitejs/plugin-react": "^6.0.2", "@vitejs/plugin-rsc": "^0.5.26", "cac": "^6.7.14", "cva": "npm:class-variance-authority@^0.7.1", "debug": "^4.4.0", "esast-util-from-js": "^2.0.1", "estree-util-value-to-estree": "^3.5.0", "estree-util-visit": "^2.0.0", "extend": "^3.0.2", "github-slugger": "^2.0.0", "hono": "^4.12.14", "image-size": "^2.0.2", "lz-string": "^1.5.0", "magic-string": "^0.30.21", "mdast-util-from-markdown": "^2.0.2", "mdast-util-gfm": "^3.1.0", "mdast-util-mdx": "^3.0.0", "mdast-util-to-hast": "^13.2.1", "mdast-util-to-markdown": "^2.1.2", "mdast-util-to-string": "^4.0.0", "micromark-extension-gfm": "^3.0.0", "minisearch": "^7.2.0", "nuqs": "^2.4.3", "react-error-boundary": "^6.0.2", "rehype-autolink-headings": "^7.1.0", "rehype-slug": "^6.0.0", "rehype-stringify": "^10.0.1", "remark-directive": "^4.0.0", "remark-frontmatter": "^5.0.0", "remark-gfm": "^4.0.1", "remark-mdx": "^3.1.1", "remark-mdx-frontmatter": "^5.2.0", "remark-parse": "^11.0.0", "remark-rehype": "^11.1.2", "remark-stringify": "^11.0.0", "shiki": "^3.20.0", "sucrase": "^3.35.1", "tailwindcss": "^4.3.0", "tailwindcss-logical": "^4.1.0", "tsx": "^4.21.0", "twoslash": "^0.3.6", "unified": "^11.0.5", "unist-util-visit": "^5.0.0", "unplugin-icons": "^22.5.0", "urlpattern-polyfill": "^10.1.0", "vfile": "^6.0.3", "vite-plugin-arraybuffer": "^0.1.1", "vite-plugin-wasm": "^3.6.0", "yaml": "^2.8.2", "zod": "^4.3.5" }, "peerDependencies": { "@vocs/twoslash-rust": "^0.1.0", "mermaid": "^11", "react": "^19", "react-dom": "^19", "vite": "^8", "waku": "^1.0.0-beta.0" }, "optionalPeers": ["@vocs/twoslash-rust", "mermaid", "vite", "waku"], "bin": { "vocs": "dist/cli.js" } }, "sha512-TsRIELb0hW5+hMGOez7YI3K2LW+6snJfw0GmMYu7skJ1Yy31p792qxBm6for8MjGVI9OVZA4VeGvgLYGH9WDXw=="],
 
-    "vscode-languageserver-protocol": ["vscode-languageserver-protocol@3.17.5", "", { "dependencies": { "vscode-jsonrpc": "8.2.0", "vscode-languageserver-types": "3.17.5" } }, "sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg=="],
+    "w3c-keyname": ["w3c-keyname@2.2.8", "", {}, "sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ=="],
 
-    "vscode-languageserver-textdocument": ["vscode-languageserver-textdocument@1.0.12", "", {}, "sha512-cxWNPesCnQCcMPeenjKKsOCKQZ/L6Tv19DTRIGuLWe32lyzWhihGVJ/rcckZXJxfdKCFvRLS3fpBIsV/ZGX4zA=="],
+    "waku": ["waku@1.0.0-beta.0", "", { "dependencies": { "@hono/node-server": "^2.0.2", "@vitejs/plugin-react": "^6.0.1", "@vitejs/plugin-rsc": "^0.5.26", "dotenv": "^17.4.2", "hono": "^4.12.14", "magic-string": "^0.30.21", "picocolors": "^1.1.1", "rsc-html-stream": "^0.0.7", "vite": "^8.0.0" }, "peerDependencies": { "react": "~19.2.4", "react-dom": "~19.2.4", "react-server-dom-webpack": "~19.2.4" }, "bin": { "waku": "cli.js" } }, "sha512-6UhIsxrN70g1nsACoEAmCriT15pnyH3CunhrckFZuARBkaFXUvN22dIQWdCTiA8JVeNXAnhFV85Tuko8uEqZKQ=="],
 
-    "vscode-languageserver-types": ["vscode-languageserver-types@3.17.5", "", {}, "sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg=="],
+    "watchpack": ["watchpack@2.5.1", "", { "dependencies": { "glob-to-regexp": "^0.4.1", "graceful-fs": "^4.1.2" } }, "sha512-Zn5uXdcFNIA1+1Ei5McRd+iRzfhENPCe7LeABkJtNulSxjma+l7ltNx55BWZkRlwRnpOgHqxnjyaDgJnNXnqzg=="],
 
-    "vscode-uri": ["vscode-uri@3.0.8", "", {}, "sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw=="],
+    "webpack": ["webpack@5.107.2", "", { "dependencies": { "@types/estree": "^1.0.8", "@types/json-schema": "^7.0.15", "@webassemblyjs/ast": "^1.14.1", "@webassemblyjs/wasm-edit": "^1.14.1", "@webassemblyjs/wasm-parser": "^1.14.1", "acorn": "^8.16.0", "acorn-import-phases": "^1.0.3", "browserslist": "^4.28.1", "chrome-trace-event": "^1.0.2", "enhanced-resolve": "^5.22.0", "es-module-lexer": "^2.1.0", "eslint-scope": "5.1.1", "events": "^3.2.0", "glob-to-regexp": "^0.4.1", "graceful-fs": "^4.2.11", "loader-runner": "^4.3.2", "mime-db": "^1.54.0", "neo-async": "^2.6.2", "schema-utils": "^4.3.3", "tapable": "^2.3.0", "terser-webpack-plugin": "^5.5.0", "watchpack": "^2.5.1", "webpack-sources": "^3.5.0" }, "bin": { "webpack": "bin/webpack.js" } }, "sha512-v7RhXaJbpMlV0D7hC7lb2EbnxkoeUqf9qhKr6lozx3Q48pmFrqqNRmZFUEGmi7pSwm6fCQ2H1IjvCkHqdpVdjQ=="],
 
-    "web-namespaces": ["web-namespaces@2.0.1", "", {}, "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ=="],
+    "webpack-sources": ["webpack-sources@3.5.0", "", {}, "sha512-HPuy+uuoTCaaoEoI1LQ3JN9+vrPBvEesnnX1jADHy728cHSMlq4wUc4afYqahq2B1mhQVZxCXOkNTnXltr+2vQ=="],
+
+    "webpack-virtual-modules": ["webpack-virtual-modules@0.6.2", "", {}, "sha512-66/V2i5hQanC51vBQKPH4aI8NMAcBW59FVBs+rC7eGHupMyfn34q7rZIE+ETlJ+XTevqfUhVVBgSUNSW2flEUQ=="],
 
     "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
 
@@ -1422,53 +1487,55 @@
 
     "wrap-ansi-cjs": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="],
 
+    "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="],
+
     "yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="],
 
-    "yaml": ["yaml@2.8.0", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-4lLa/EcQCB0cJkyts+FpIRx5G/llPxfP6VQU5KByHEhLxY3IJCH0f0Hy1MHI8sClTvsIb8qwRJ6R/ZdlDJ/leQ=="],
+    "yaml": ["yaml@2.9.0", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA=="],
 
-    "yocto-queue": ["yocto-queue@1.2.1", "", {}, "sha512-AyeEbWOu/TAXdxlV9wmGcR0+yh2j3vYPGOECcIj2S7MkrLyC7ne+oye2BKTItt0ii2PHk4cDy+95+LshzbXnGg=="],
+    "zod": ["zod@4.4.3", "", {}, "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ=="],
+
+    "zod-to-json-schema": ["zod-to-json-schema@3.25.2", "", { "peerDependencies": { "zod": "^3.25.28 || ^4" } }, "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA=="],
 
     "zwitch": ["zwitch@2.0.4", "", {}, "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A=="],
 
-    "@babel/core/debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+    "@babel/code-frame/js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="],
 
-    "@babel/helper-compilation-targets/lru-cache": ["lru-cache@5.1.1", "", { "dependencies": { "yallist": "^3.0.2" } }, "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w=="],
+    "@babel/helper-compilation-targets/browserslist": ["browserslist@4.25.1", "", { "dependencies": { "caniuse-lite": "^1.0.30001726", "electron-to-chromium": "^1.5.173", "node-releases": "^2.0.19", "update-browserslist-db": "^1.1.3" }, "bin": { "browserslist": "cli.js" } }, "sha512-KGj0KoOMXLpSNkkEI6Z6mShmQy0bc1I+T7K9N81k4WWMrfz+6fQ6es80B/YLAeRoKvjYE1YSHHOW1qe9xIVzHw=="],
 
-    "@babel/traverse/debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+    "@babel/helper-compilation-targets/lru-cache": ["lru-cache@5.1.1", "", { "dependencies": { "yallist": "^3.0.2" } }, "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w=="],
 
-    "@clack/prompts/is-unicode-supported": ["is-unicode-supported@1.3.0", "", { "bundled": true }, "sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ=="],
+    "@jridgewell/gen-mapping/@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.4", "", {}, "sha512-VT2+G1VQs/9oz078bLrYbecdZKs912zQlkelYpuf+SXF+QvZDYJlbx/LSx+meSAwdDFnF8FVXW92AVjjkVmgFw=="],
 
-    "@iconify/utils/debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
+    "@jridgewell/trace-mapping/@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.4", "", {}, "sha512-VT2+G1VQs/9oz078bLrYbecdZKs912zQlkelYpuf+SXF+QvZDYJlbx/LSx+meSAwdDFnF8FVXW92AVjjkVmgFw=="],
 
-    "@isaacs/cliui/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
+    "@mdx-js/mdx/acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
 
-    "@radix-ui/react-popper/@floating-ui/react-dom": ["@floating-ui/react-dom@2.1.4", "", { "dependencies": { "@floating-ui/dom": "^1.7.2" }, "peerDependencies": { "react": ">=16.8.0", "react-dom": ">=16.8.0" } }, "sha512-JbbpPhp38UmXDDAu60RJmbeme37Jbgsm7NrHGgzYYFKmblzRUh6Pa641dII6LsjwF4XlScDrde2UAzDo/b9KPw=="],
+    "@modelcontextprotocol/sdk/@hono/node-server": ["@hono/node-server@1.19.14", "", { "peerDependencies": { "hono": "^4" } }, "sha512-GwtvgtXxnWsucXvbQXkRgqksiH2Qed37H9xHZocE5sA3N8O8O8/8FA3uclQXxXVzc9XBZuEOMK7+r02FmSpHtw=="],
 
     "@rollup/pluginutils/estree-walker": ["estree-walker@2.0.2", "", {}, "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w=="],
 
-    "@types/babel__core/@babel/parser": ["@babel/parser@7.28.0", "", { "dependencies": { "@babel/types": "^7.28.0" }, "bin": "./bin/babel-parser.js" }, "sha512-jVZGvOxOuNSsuQuLRTh13nU0AogFlw32w/MT+LV6D3sP5WdbW61E77RnkbaO2dUvmPAYrBDJXGn5gGS6tH4j8g=="],
+    "@rollup/pluginutils/picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="],
 
-    "@types/babel__core/@babel/types": ["@babel/types@7.28.1", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1" } }, "sha512-x0LvFTekgSX+83TI28Y9wYPUfzrnl2aT5+5QLnO6v7mSJYtEEevuDRN0F0uSHRk1G1IWZC43o00Y0xDDrpBGPQ=="],
+    "@shikijs/rehype/unist-util-visit": ["unist-util-visit@5.1.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.0.0" } }, "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg=="],
 
-    "@types/babel__generator/@babel/types": ["@babel/types@7.28.1", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1" } }, "sha512-x0LvFTekgSX+83TI28Y9wYPUfzrnl2aT5+5QLnO6v7mSJYtEEevuDRN0F0uSHRk1G1IWZC43o00Y0xDDrpBGPQ=="],
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/core": ["@emnapi/core@1.10.0", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.1", "tslib": "^2.4.0" }, "bundled": true }, "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw=="],
 
-    "@types/babel__template/@babel/parser": ["@babel/parser@7.28.0", "", { "dependencies": { "@babel/types": "^7.28.0" }, "bin": "./bin/babel-parser.js" }, "sha512-jVZGvOxOuNSsuQuLRTh13nU0AogFlw32w/MT+LV6D3sP5WdbW61E77RnkbaO2dUvmPAYrBDJXGn5gGS6tH4j8g=="],
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/runtime": ["@emnapi/runtime@1.10.0", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA=="],
 
-    "@types/babel__template/@babel/types": ["@babel/types@7.28.1", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1" } }, "sha512-x0LvFTekgSX+83TI28Y9wYPUfzrnl2aT5+5QLnO6v7mSJYtEEevuDRN0F0uSHRk1G1IWZC43o00Y0xDDrpBGPQ=="],
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.1", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w=="],
 
-    "@types/babel__traverse/@babel/types": ["@babel/types@7.28.1", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1" } }, "sha512-x0LvFTekgSX+83TI28Y9wYPUfzrnl2aT5+5QLnO6v7mSJYtEEevuDRN0F0uSHRk1G1IWZC43o00Y0xDDrpBGPQ=="],
+    "@tailwindcss/oxide-wasm32-wasi/@napi-rs/wasm-runtime": ["@napi-rs/wasm-runtime@1.1.4", "", { "dependencies": { "@tybys/wasm-util": "^0.10.1" }, "peerDependencies": { "@emnapi/core": "^1.7.1", "@emnapi/runtime": "^1.7.1" }, "bundled": true }, "sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow=="],
 
-    "@typescript/vfs/debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
+    "@tailwindcss/oxide-wasm32-wasi/@tybys/wasm-util": ["@tybys/wasm-util@0.10.2", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg=="],
 
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core": ["@babel/core@7.28.0", "", { "dependencies": { "@ampproject/remapping": "^2.2.0", "@babel/code-frame": "^7.27.1", "@babel/generator": "^7.28.0", "@babel/helper-compilation-targets": "^7.27.2", "@babel/helper-module-transforms": "^7.27.3", "@babel/helpers": "^7.27.6", "@babel/parser": "^7.28.0", "@babel/template": "^7.27.2", "@babel/traverse": "^7.28.0", "@babel/types": "^7.28.0", "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", "json5": "^2.2.3", "semver": "^6.3.1" } }, "sha512-UlLAnTPrFdNGoFtbSXwcGFQBtQZJCNjaN6hQNP3UPvuNXT1i82N26KL3dZeIpNalWywr9IuQuncaAfUaS1g6sQ=="],
+    "@tailwindcss/oxide-wasm32-wasi/tslib": ["tslib@2.8.1", "", { "bundled": true }, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
 
-    "@vanilla-extract/compiler/vite": ["vite@7.3.2", "", { "dependencies": { "esbuild": "^0.27.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-Bby3NOsna2jsjfLVOHKes8sGwgl4TT0E6vvpYgnAYDIF/tie7MRaFthmKuHx1NSXjiTueXH3do80FMQgvEktRg=="],
+    "acorn-loose/acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
 
-    "@vanilla-extract/css/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
+    "body-parser/http-errors": ["http-errors@2.0.1", "", { "dependencies": { "depd": "~2.0.0", "inherits": "~2.0.4", "setprototypeof": "~1.2.0", "statuses": "~2.0.2", "toidentifier": "~1.0.1" } }, "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ=="],
 
-    "@vanilla-extract/integration/esbuild": ["esbuild@0.27.7", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.7", "@esbuild/android-arm": "0.27.7", "@esbuild/android-arm64": "0.27.7", "@esbuild/android-x64": "0.27.7", "@esbuild/darwin-arm64": "0.27.7", "@esbuild/darwin-x64": "0.27.7", "@esbuild/freebsd-arm64": "0.27.7", "@esbuild/freebsd-x64": "0.27.7", "@esbuild/linux-arm": "0.27.7", "@esbuild/linux-arm64": "0.27.7", "@esbuild/linux-ia32": "0.27.7", "@esbuild/linux-loong64": "0.27.7", "@esbuild/linux-mips64el": "0.27.7", "@esbuild/linux-ppc64": "0.27.7", "@esbuild/linux-riscv64": "0.27.7", "@esbuild/linux-s390x": "0.27.7", "@esbuild/linux-x64": "0.27.7", "@esbuild/netbsd-arm64": "0.27.7", "@esbuild/netbsd-x64": "0.27.7", "@esbuild/openbsd-arm64": "0.27.7", "@esbuild/openbsd-x64": "0.27.7", "@esbuild/openharmony-arm64": "0.27.7", "@esbuild/sunos-x64": "0.27.7", "@esbuild/win32-arm64": "0.27.7", "@esbuild/win32-ia32": "0.27.7", "@esbuild/win32-x64": "0.27.7" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w=="],
-
-    "create-vocs/fs-extra": ["fs-extra@11.3.0", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew=="],
+    "body-parser/iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
 
     "cytoscape-fcose/cose-base": ["cose-base@2.2.0", "", { "dependencies": { "layout-base": "^2.0.0" } }, "sha512-AzlgcsCbUMymkADOJtQm3wO9S3ltPfYOFD5033keQn9NJzIbtnZj+UdBJe7DYml/8TdbtHJW3j58SOnKhWY/5g=="],
 
@@ -1478,41 +1545,47 @@
 
     "d3-sankey/d3-shape": ["d3-shape@1.3.7", "", { "dependencies": { "d3-path": "1" } }, "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw=="],
 
-    "eval/@types/node": ["@types/node@24.0.14", "", { "dependencies": { "undici-types": "~7.8.0" } }, "sha512-4zXMWD91vBLGRtHK3YbIoFMia+1nqEz72coM42C5ETjnNCa/heoj7NT1G67iAfOqMmcfhuCZ4uNpyz8EjlAejw=="],
+    "esast-util-from-js/acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+
+    "esrecurse/estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="],
 
-    "execa/signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
+    "finalhandler/statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
 
-    "hast-util-from-dom/hastscript": ["hastscript@9.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "comma-separated-tokens": "^2.0.0", "hast-util-parse-selector": "^4.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0" } }, "sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w=="],
+    "hast-util-to-html/mdast-util-to-hast": ["mdast-util-to-hast@13.2.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@ungap/structured-clone": "^1.0.0", "devlop": "^1.0.0", "micromark-util-sanitize-uri": "^2.0.0", "trim-lines": "^3.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" } }, "sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA=="],
 
-    "hast-util-from-parse5/hastscript": ["hastscript@9.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "comma-separated-tokens": "^2.0.0", "hast-util-parse-selector": "^4.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0" } }, "sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w=="],
+    "katex/commander": ["commander@8.3.0", "", {}, "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww=="],
 
-    "hast-util-from-parse5/property-information": ["property-information@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
+    "micromark/debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
 
-    "hast-util-select/property-information": ["property-information@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
+    "micromark-extension-mdxjs/acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
 
-    "hast-util-to-estree/property-information": ["property-information@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
+    "mlly/acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
 
-    "hast-util-to-html/property-information": ["property-information@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
+    "mlly/pkg-types": ["pkg-types@1.3.1", "", { "dependencies": { "confbox": "^0.1.8", "mlly": "^1.7.4", "pathe": "^2.0.1" } }, "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ=="],
 
-    "hast-util-to-jsx-runtime/property-information": ["property-information@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
+    "parse-entities/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
 
-    "local-pkg/pkg-types": ["pkg-types@2.2.0", "", { "dependencies": { "confbox": "^0.2.2", "exsolve": "^1.0.7", "pathe": "^2.0.3" } }, "sha512-2SM/GZGAEkPp3KWORxQZns4M+WSeXbC2HEvmOIJe3Cmiv6ieAJvdVhDldtHqM5J1Y7MrR1XhkBT/rMlhh9FdqQ=="],
+    "raw-body/http-errors": ["http-errors@2.0.1", "", { "dependencies": { "depd": "~2.0.0", "inherits": "~2.0.4", "setprototypeof": "~1.2.0", "statuses": "~2.0.2", "toidentifier": "~1.0.1" } }, "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ=="],
 
-    "micromark/debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
+    "raw-body/iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
 
-    "micromatch/picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="],
+    "react-router/cookie": ["cookie@1.0.2", "", {}, "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA=="],
 
-    "p-locate/p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="],
+    "remark-mdx-frontmatter/estree-util-value-to-estree": ["estree-util-value-to-estree@3.4.0", "", { "dependencies": { "@types/estree": "^1.0.0" } }, "sha512-Zlp+gxis+gCfK12d3Srl2PdX2ybsEA8ZYy6vQGVQTNNYLEGRQQ56XB64bjemN8kxIKXP1nC9ip4Z+ILy9LGzvQ=="],
 
-    "parse-entities/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+    "remark-mdx-frontmatter/yaml": ["yaml@2.8.0", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-4lLa/EcQCB0cJkyts+FpIRx5G/llPxfP6VQU5KByHEhLxY3IJCH0f0Hy1MHI8sClTvsIb8qwRJ6R/ZdlDJ/leQ=="],
+
+    "remark-rehype/mdast-util-to-hast": ["mdast-util-to-hast@13.2.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@ungap/structured-clone": "^1.0.0", "devlop": "^1.0.0", "micromark-util-sanitize-uri": "^2.0.0", "trim-lines": "^3.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" } }, "sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA=="],
 
-    "restore-cursor/signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
+    "schema-utils/ajv-formats": ["ajv-formats@2.1.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA=="],
 
-    "rollup/fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+    "send/http-errors": ["http-errors@2.0.1", "", { "dependencies": { "depd": "~2.0.0", "inherits": "~2.0.4", "setprototypeof": "~1.2.0", "statuses": "~2.0.2", "toidentifier": "~1.0.1" } }, "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ=="],
 
-    "send/encodeurl": ["encodeurl@1.0.2", "", {}, "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w=="],
+    "send/statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
 
-    "send/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+    "source-map-support/source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="],
+
+    "static-browser-server/dotenv": ["dotenv@16.6.1", "", {}, "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow=="],
 
     "string-width-cjs/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
 
@@ -1520,13 +1593,11 @@
 
     "strip-ansi-cjs/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
 
-    "vite/fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
-
-    "vite-node/debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
+    "sucrase/commander": ["commander@4.1.1", "", {}, "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA=="],
 
-    "vocs/minimatch": ["minimatch@9.0.9", "", { "dependencies": { "brace-expansion": "^2.0.2" } }, "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg=="],
+    "type-is/content-type": ["content-type@2.0.0", "", {}, "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ=="],
 
-    "wrap-ansi/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
+    "unplugin/acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
 
     "wrap-ansi-cjs/ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
 
@@ -1534,204 +1605,30 @@
 
     "wrap-ansi-cjs/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
 
-    "@babel/core/debug/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
-
-    "@babel/traverse/debug/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
-
-    "@iconify/utils/debug/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
-
-    "@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
-
-    "@radix-ui/react-popper/@floating-ui/react-dom/@floating-ui/dom": ["@floating-ui/dom@1.7.2", "", { "dependencies": { "@floating-ui/core": "^1.7.2", "@floating-ui/utils": "^0.2.10" } }, "sha512-7cfaOQuCS27HD7DX+6ib2OrnW+b4ZBwDNnCcT0uTyidcmyWb03FnQqJybDBoCnpdxwBSfA94UAYlRCt7mV+TbA=="],
-
-    "@types/babel__core/@babel/types/@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.27.1", "", {}, "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="],
-
-    "@types/babel__generator/@babel/types/@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.27.1", "", {}, "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="],
-
-    "@types/babel__template/@babel/types/@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.27.1", "", {}, "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="],
-
-    "@types/babel__traverse/@babel/types/@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.27.1", "", {}, "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="],
+    "@babel/helper-compilation-targets/browserslist/caniuse-lite": ["caniuse-lite@1.0.30001727", "", {}, "sha512-pB68nIHmbN6L/4C6MH1DokyR3bYqFwjaSs/sWDHGj4CTcFtQUQMuJftVwWkXq7mNWOybD3KhUv3oWHoGxgP14Q=="],
 
-    "@typescript/vfs/debug/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+    "@babel/helper-compilation-targets/browserslist/electron-to-chromium": ["electron-to-chromium@1.5.186", "", {}, "sha512-lur7L4BFklgepaJxj4DqPk7vKbTEl0pajNlg2QjE5shefmlmBLm2HvQ7PMf1R/GvlevT/581cop33/quQcfX3A=="],
 
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/code-frame": ["@babel/code-frame@7.27.1", "", { "dependencies": { "@babel/helper-validator-identifier": "^7.27.1", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" } }, "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg=="],
+    "@babel/helper-compilation-targets/browserslist/node-releases": ["node-releases@2.0.19", "", {}, "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw=="],
 
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/generator": ["@babel/generator@7.28.0", "", { "dependencies": { "@babel/parser": "^7.28.0", "@babel/types": "^7.28.0", "@jridgewell/gen-mapping": "^0.3.12", "@jridgewell/trace-mapping": "^0.3.28", "jsesc": "^3.0.2" } }, "sha512-lJjzvrbEeWrhB4P3QBsH7tey117PjLZnDbLiQEKjQ/fNJTjuq4HSqgFA+UNSwZT8D7dxxbnuSBMsa1lrWzKlQg=="],
+    "@babel/helper-compilation-targets/browserslist/update-browserslist-db": ["update-browserslist-db@1.1.3", "", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw=="],
 
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/helper-compilation-targets": ["@babel/helper-compilation-targets@7.27.2", "", { "dependencies": { "@babel/compat-data": "^7.27.2", "@babel/helper-validator-option": "^7.27.1", "browserslist": "^4.24.0", "lru-cache": "^5.1.1", "semver": "^6.3.1" } }, "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/helper-module-transforms": ["@babel/helper-module-transforms@7.27.3", "", { "dependencies": { "@babel/helper-module-imports": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1", "@babel/traverse": "^7.27.3" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "sha512-dSOvYwvyLsWBeIRyOeHXp5vPj5l1I011r52FM1+r1jCERv+aFXYk4whgQccYEGYxK2H3ZAIA8nuPkQ0HaUo3qg=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/helpers": ["@babel/helpers@7.27.6", "", { "dependencies": { "@babel/template": "^7.27.2", "@babel/types": "^7.27.6" } }, "sha512-muE8Tt8M22638HU31A3CgfSUciwz1fhATfoVai05aPXGor//CdWDCbnlY1yvBPo07njuVOCNGCSp/GTt12lIug=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/parser": ["@babel/parser@7.28.0", "", { "dependencies": { "@babel/types": "^7.28.0" }, "bin": "./bin/babel-parser.js" }, "sha512-jVZGvOxOuNSsuQuLRTh13nU0AogFlw32w/MT+LV6D3sP5WdbW61E77RnkbaO2dUvmPAYrBDJXGn5gGS6tH4j8g=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/template": ["@babel/template@7.27.2", "", { "dependencies": { "@babel/code-frame": "^7.27.1", "@babel/parser": "^7.27.2", "@babel/types": "^7.27.1" } }, "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/traverse": ["@babel/traverse@7.28.0", "", { "dependencies": { "@babel/code-frame": "^7.27.1", "@babel/generator": "^7.28.0", "@babel/helper-globals": "^7.28.0", "@babel/parser": "^7.28.0", "@babel/template": "^7.27.2", "@babel/types": "^7.28.0", "debug": "^4.3.1" } }, "sha512-mGe7UK5wWyh0bKRfupsUchrQGqvDbZDbKJw+kcRGSmdHVYrv+ltd0pnpDTVpiTqnaBru9iEvA8pz8W46v0Amwg=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/types": ["@babel/types@7.28.1", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1" } }, "sha512-x0LvFTekgSX+83TI28Y9wYPUfzrnl2aT5+5QLnO6v7mSJYtEEevuDRN0F0uSHRk1G1IWZC43o00Y0xDDrpBGPQ=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
-
-    "@vanilla-extract/compiler/vite/esbuild": ["esbuild@0.27.7", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.7", "@esbuild/android-arm": "0.27.7", "@esbuild/android-arm64": "0.27.7", "@esbuild/android-x64": "0.27.7", "@esbuild/darwin-arm64": "0.27.7", "@esbuild/darwin-x64": "0.27.7", "@esbuild/freebsd-arm64": "0.27.7", "@esbuild/freebsd-x64": "0.27.7", "@esbuild/linux-arm": "0.27.7", "@esbuild/linux-arm64": "0.27.7", "@esbuild/linux-ia32": "0.27.7", "@esbuild/linux-loong64": "0.27.7", "@esbuild/linux-mips64el": "0.27.7", "@esbuild/linux-ppc64": "0.27.7", "@esbuild/linux-riscv64": "0.27.7", "@esbuild/linux-s390x": "0.27.7", "@esbuild/linux-x64": "0.27.7", "@esbuild/netbsd-arm64": "0.27.7", "@esbuild/netbsd-x64": "0.27.7", "@esbuild/openbsd-arm64": "0.27.7", "@esbuild/openbsd-x64": "0.27.7", "@esbuild/openharmony-arm64": "0.27.7", "@esbuild/sunos-x64": "0.27.7", "@esbuild/win32-arm64": "0.27.7", "@esbuild/win32-ia32": "0.27.7", "@esbuild/win32-x64": "0.27.7" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w=="],
-
-    "@vanilla-extract/compiler/vite/fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
-
-    "@vanilla-extract/compiler/vite/fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
-
-    "@vanilla-extract/compiler/vite/tinyglobby": ["tinyglobby@0.2.16", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.4" } }, "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.7", "", { "os": "aix", "cpu": "ppc64" }, "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.27.7", "", { "os": "android", "cpu": "arm" }, "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/android-arm64": ["@esbuild/android-arm64@0.27.7", "", { "os": "android", "cpu": "arm64" }, "sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/android-x64": ["@esbuild/android-x64@0.27.7", "", { "os": "android", "cpu": "x64" }, "sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.27.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.27.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.27.7", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.27.7", "", { "os": "freebsd", "cpu": "x64" }, "sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/linux-arm": ["@esbuild/linux-arm@0.27.7", "", { "os": "linux", "cpu": "arm" }, "sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.27.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.27.7", "", { "os": "linux", "cpu": "ia32" }, "sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.27.7", "", { "os": "linux", "cpu": "none" }, "sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.27.7", "", { "os": "linux", "cpu": "none" }, "sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.27.7", "", { "os": "linux", "cpu": "ppc64" }, "sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.27.7", "", { "os": "linux", "cpu": "none" }, "sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.27.7", "", { "os": "linux", "cpu": "s390x" }, "sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/linux-x64": ["@esbuild/linux-x64@0.27.7", "", { "os": "linux", "cpu": "x64" }, "sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.27.7", "", { "os": "none", "cpu": "arm64" }, "sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.27.7", "", { "os": "none", "cpu": "x64" }, "sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.27.7", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.27.7", "", { "os": "openbsd", "cpu": "x64" }, "sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.27.7", "", { "os": "none", "cpu": "arm64" }, "sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.27.7", "", { "os": "sunos", "cpu": "x64" }, "sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.27.7", "", { "os": "win32", "cpu": "arm64" }, "sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.27.7", "", { "os": "win32", "cpu": "ia32" }, "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw=="],
-
-    "@vanilla-extract/integration/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.7", "", { "os": "win32", "cpu": "x64" }, "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg=="],
+    "body-parser/http-errors/statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
 
     "cytoscape-fcose/cose-base/layout-base": ["layout-base@2.0.1", "", {}, "sha512-dp3s92+uNI1hWIpPGH3jK2kxE2lMjdXdr+DH8ynZHpd6PUlH6x6cbuXnoMmiNumznqaNO31xu9e79F0uuZ0JFg=="],
 
-    "d3-sankey/d3-shape/d3-path": ["d3-path@1.0.9", "", {}, "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg=="],
-
-    "eval/@types/node/undici-types": ["undici-types@7.8.0", "", {}, "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw=="],
+    "d3-sankey/d3-array/internmap": ["internmap@1.0.1", "", {}, "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw=="],
 
-    "hast-util-from-dom/hastscript/property-information": ["property-information@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
-
-    "local-pkg/pkg-types/confbox": ["confbox@0.2.2", "", {}, "sha512-1NB+BKqhtNipMsov4xI/NnhCKp9XG9NamYp5PVm9klAT0fsrNPjaFICsCFhNhwZJKNh7zB/3q8qXz0E9oaMNtQ=="],
+    "d3-sankey/d3-shape/d3-path": ["d3-path@1.0.9", "", {}, "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg=="],
 
-    "micromark/debug/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+    "mlly/pkg-types/confbox": ["confbox@0.1.8", "", {}, "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w=="],
 
-    "p-locate/p-limit/yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="],
+    "raw-body/http-errors/statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
 
     "string-width-cjs/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
 
-    "vite-node/debug/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
-
-    "vocs/minimatch/brace-expansion": ["brace-expansion@2.1.0", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w=="],
-
     "wrap-ansi-cjs/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
 
     "wrap-ansi-cjs/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
-
-    "wrap-ansi/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
-
-    "@radix-ui/react-popper/@floating-ui/react-dom/@floating-ui/dom/@floating-ui/core": ["@floating-ui/core@1.7.2", "", { "dependencies": { "@floating-ui/utils": "^0.2.10" } }, "sha512-wNB5ooIKHQc+Kui96jE/n69rHFWAVoxn5CAzL1Xdd8FG03cgY3MLO+GF9U3W737fYDSgPWA6MReKhBQBop6Pcw=="],
-
-    "@radix-ui/react-popper/@floating-ui/react-dom/@floating-ui/dom/@floating-ui/utils": ["@floating-ui/utils@0.2.10", "", {}, "sha512-aGTxbpbg8/b5JfU1HXSrbH3wXZuLPJcNEcZQFMxLs3oSzgtVu6nFPkbbGGUvBcUjKV2YyB9Wxxabo+HEH9tcRQ=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/code-frame/@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.27.1", "", {}, "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/helper-compilation-targets/@babel/compat-data": ["@babel/compat-data@7.28.0", "", {}, "sha512-60X7qkglvrap8mn1lh2ebxXdZYtUcpd7gsmy9kLaBJ4i/WdY8PqTSdxyA8qraikqKQK5C1KRBKXqznrVapyNaw=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/helper-compilation-targets/lru-cache": ["lru-cache@5.1.1", "", { "dependencies": { "yallist": "^3.0.2" } }, "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/helper-module-transforms/@babel/helper-module-imports": ["@babel/helper-module-imports@7.27.1", "", { "dependencies": { "@babel/traverse": "^7.27.1", "@babel/types": "^7.27.1" } }, "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/helper-module-transforms/@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.27.1", "", {}, "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/@babel/types/@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.27.1", "", {}, "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="],
-
-    "@vanilla-extract/babel-plugin-debug-ids/@babel/core/debug/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.7", "", { "os": "aix", "cpu": "ppc64" }, "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.27.7", "", { "os": "android", "cpu": "arm" }, "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/android-arm64": ["@esbuild/android-arm64@0.27.7", "", { "os": "android", "cpu": "arm64" }, "sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/android-x64": ["@esbuild/android-x64@0.27.7", "", { "os": "android", "cpu": "x64" }, "sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.27.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.27.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.27.7", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.27.7", "", { "os": "freebsd", "cpu": "x64" }, "sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/linux-arm": ["@esbuild/linux-arm@0.27.7", "", { "os": "linux", "cpu": "arm" }, "sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.27.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.27.7", "", { "os": "linux", "cpu": "ia32" }, "sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.27.7", "", { "os": "linux", "cpu": "none" }, "sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.27.7", "", { "os": "linux", "cpu": "none" }, "sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.27.7", "", { "os": "linux", "cpu": "ppc64" }, "sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.27.7", "", { "os": "linux", "cpu": "none" }, "sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.27.7", "", { "os": "linux", "cpu": "s390x" }, "sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/linux-x64": ["@esbuild/linux-x64@0.27.7", "", { "os": "linux", "cpu": "x64" }, "sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.27.7", "", { "os": "none", "cpu": "arm64" }, "sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.27.7", "", { "os": "none", "cpu": "x64" }, "sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.27.7", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.27.7", "", { "os": "openbsd", "cpu": "x64" }, "sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.27.7", "", { "os": "none", "cpu": "arm64" }, "sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.27.7", "", { "os": "sunos", "cpu": "x64" }, "sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.27.7", "", { "os": "win32", "cpu": "arm64" }, "sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.27.7", "", { "os": "win32", "cpu": "ia32" }, "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw=="],
-
-    "@vanilla-extract/compiler/vite/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.7", "", { "os": "win32", "cpu": "x64" }, "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg=="],
-
-    "@vanilla-extract/compiler/vite/tinyglobby/picomatch": ["picomatch@4.0.4", "", {}, "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A=="],
-
-    "vocs/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="],
   }
 }
diff --git a/docs/vocs/docs/components/SdkShowcase.tsx b/docs/vocs/docs/components/SdkShowcase.tsx
index 442d6676f4f..e23e7df0788 100644
--- a/docs/vocs/docs/components/SdkShowcase.tsx
+++ b/docs/vocs/docs/components/SdkShowcase.tsx
@@ -40,46 +40,32 @@ const projects: SdkProject[] = [
 
 export function SdkShowcase() {
   return (
-    <div className="grid grid-cols-1 md:grid-cols-2 gap-6">
+    <div className="reth-sdk-grid">
       {projects.map((project) => (
-        <div
+        <article
           key={project.name}
-          className="relative bg-white/5 dark:bg-white/5 border border-black/10 dark:border-white/10 rounded-xl p-6 hover:bg-black/5 dark:hover:bg-white/10 transition-colors group"
+          className="reth-sdk-card"
         >
-          {/* LoC Badge */}
-          <div className="absolute top-4 right-4 bg-black/10 dark:bg-white/10 text-black dark:text-white px-3 py-1 rounded-full text-sm font-medium">
+          <div className="reth-sdk-badge">
             {project.loc} LoC
           </div>
 
-          {/* Content */}
-          <div className="space-y-3">
-            <div>
-              <h3 className="text-xl font-semibold text-black dark:text-white mb-1">
-                {project.name}
-              </h3>
-              <p className="text-sm text-gray-600 dark:text-gray-400">
-                {project.company}
-              </p>
-            </div>
+          <h3>{project.name}</h3>
+          <p className="reth-sdk-company">{project.company}</p>
+          <p className="reth-sdk-description">{project.description}</p>
 
-            <p className="text-gray-700 dark:text-gray-300 text-sm leading-relaxed">
-              {project.description}
-            </p>
-
-            {/* GitHub Link */}
-            <a
-              href={project.githubUrl}
-              target="_blank"
-              rel="noopener noreferrer"
-              className="inline-flex items-center gap-2 text-sm text-black dark:text-white hover:text-gray-700 dark:hover:text-gray-300 font-medium transition-colors"
-            >
-              <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 24 24">
-                <path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/>
-              </svg>
-              View on GitHub
-            </a>
-          </div>
-        </div>
+          <a
+            href={project.githubUrl}
+            target="_blank"
+            rel="noopener noreferrer"
+            className="reth-sdk-link"
+          >
+            <svg aria-hidden="true" className="reth-sdk-link-icon" fill="currentColor" viewBox="0 0 24 24">
+              <path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/>
+            </svg>
+            View on GitHub
+          </a>
+        </article>
       ))}
     </div>
   )
diff --git a/docs/vocs/docs/components/TrustedBy.tsx b/docs/vocs/docs/components/TrustedBy.tsx
index 41b78e8787a..b6029f769ed 100644
--- a/docs/vocs/docs/components/TrustedBy.tsx
+++ b/docs/vocs/docs/components/TrustedBy.tsx
@@ -1,46 +1,54 @@
 interface TrustedCompany {
   name: string
   logoUrl: string
+  slug: string
+  href: string
 }
 
 const companies: TrustedCompany[] = [
   {
     name: 'Flashbots',
-    logoUrl: '/flashbots.png'
+    logoUrl: '/flashbots.png',
+    slug: 'flashbots',
+    href: 'https://www.flashbots.net/'
   },
   {
     name: 'Coinbase',
-    logoUrl: '/coinbase.png'
+    logoUrl: '/coinbase.png',
+    slug: 'coinbase',
+    href: 'https://www.coinbase.com/'
   },
   {
     name: 'Alchemy',
-    logoUrl: '/alchemy.png'
+    logoUrl: '/alchemy.png',
+    slug: 'alchemy',
+    href: 'https://www.alchemy.com/'
   },
   {
     name: 'Succinct Labs',
-    logoUrl: '/succinct.png'
+    logoUrl: '/succinct.png',
+    slug: 'succinct',
+    href: 'https://www.succinct.xyz/'
   }
 ]
 
 export function TrustedBy() {
   return (
-    <div className="grid grid-cols-2 md:grid-cols-4 gap-6">
+    <div className="reth-trusted-grid">
       {companies.map((company) => (
-        <div
+        <a
           key={company.name}
-          className="relative bg-white/5 dark:bg-white/5 border border-black/10 dark:border-white/10 rounded-xl p-8 hover:bg-black/5 dark:hover:bg-white/10 transition-colors flex flex-col items-center justify-center h-40 group"
+          className="reth-trusted-card"
+          href={company.href}
+          rel="noreferrer noopener"
+          target="_blank"
         >
-          {/* Company Logo */}
-          <div className={`flex items-center justify-center ${
-            company.name === 'Coinbase' || company.name === 'Alchemy' ? 'w-32 h-32' : 'w-24 h-24'
-          }`}>
-            <img
-              src={company.logoUrl}
-              alt={`${company.name} logo`}
-              className="max-w-full max-h-full object-contain"
-            />
-          </div>
-        </div>
+          <img
+            src={company.logoUrl}
+            alt={`${company.name} logo`}
+            className={`reth-trusted-logo reth-trusted-logo-${company.slug}`}
+          />
+        </a>
       ))}
     </div>
   )
diff --git a/docs/vocs/docs/pages/_root.css b/docs/vocs/docs/pages/_root.css
new file mode 100644
index 00000000000..d029a3f79c0
--- /dev/null
+++ b/docs/vocs/docs/pages/_root.css
@@ -0,0 +1,524 @@
+@import "tailwindcss" important;
+
+@custom-variant dark (&:where(.dark, .dark *, [data-vocs-theme="dark"], [data-vocs-theme="dark"] *));
+
+[data-v-content]:has(.reth-home-page) {
+  max-width: min(940px, calc(100vw - 48px));
+  width: 100%;
+  padding-top: 32px;
+  padding-bottom: 88px;
+}
+
+.reth-home-page,
+.reth-home-page * {
+  box-sizing: border-box;
+  letter-spacing: 0;
+}
+
+.reth-home-page {
+  display: flex;
+  flex-direction: column;
+  gap: 26px;
+  color: var(--vocs-text-color-primary);
+}
+
+.reth-home-page a {
+  color: inherit;
+  text-decoration: none;
+}
+
+.reth-home-hero {
+  display: flex;
+  flex-direction: column;
+  gap: 22px;
+}
+
+.reth-home-hero-top {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(320px, 0.95fr);
+  gap: 28px;
+  align-items: end;
+}
+
+.reth-home-hero-heading {
+  display: flex;
+  min-width: 0;
+  flex-direction: column;
+  align-items: flex-start;
+}
+
+.reth-home-hero-media {
+  overflow: hidden;
+  border: 1px solid var(--vocs-border-color-primary);
+  border-radius: 10px;
+  background: #0b0b0d;
+}
+
+.reth-home-hero-media img {
+  display: block;
+  width: 100%;
+  aspect-ratio: 16 / 9;
+  object-fit: cover;
+  object-position: center;
+}
+
+.reth-home-hero-body {
+  max-width: 760px;
+  min-width: 0;
+}
+
+.reth-home-hero-heading .reth-home-kicker {
+  margin-bottom: 12px;
+}
+
+.reth-home-kicker {
+  margin: 0 0 10px;
+  color: var(--vocs-text-color-muted);
+  font-size: 12px;
+  font-weight: 650;
+  line-height: 1.25;
+  text-transform: uppercase;
+}
+
+.reth-home-hero h1 {
+  margin: 0;
+  color: var(--vocs-text-color-heading);
+  font-size: clamp(68px, 8vw, 92px);
+  font-weight: 650;
+  line-height: 0.94;
+}
+
+.reth-home-lede,
+.reth-home-detail,
+.reth-home-section-copy {
+  margin-top: 14px;
+  color: var(--vocs-text-color-secondary);
+  font-size: 17px;
+  line-height: 1.58;
+}
+
+.reth-home-lede {
+  max-width: 760px;
+  color: var(--vocs-text-color-primary);
+  font-size: clamp(19px, 1.6vw, 22px);
+  line-height: 1.38;
+}
+
+.reth-home-detail {
+  max-width: 760px;
+  margin-top: 10px;
+  font-size: 16px;
+}
+
+.reth-home-hero-body .reth-home-lede {
+  margin-top: 0;
+}
+
+.reth-home-actions,
+.reth-home-metrics {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+}
+
+.reth-home-actions {
+  margin-top: 18px;
+}
+
+.reth-home-button {
+  display: inline-flex;
+  min-height: 40px;
+  align-items: center;
+  justify-content: center;
+  border: 1px solid var(--vocs-border-color-primary);
+  border-radius: 8px;
+  padding: 0 16px;
+  background: var(--vocs-background-color-surface);
+  color: var(--vocs-text-color-heading);
+  font-size: 14px;
+  font-weight: 650;
+  line-height: 1;
+  transition: background 150ms ease, border-color 150ms ease, transform 150ms ease;
+}
+
+.reth-home-button:hover,
+.reth-home-metrics a:hover,
+.reth-home-feature-grid a:hover,
+.reth-sdk-card:hover,
+.reth-trusted-card:hover,
+.reth-home-supporter-grid a:hover {
+  transform: translateY(-1px);
+  border-color: var(--vocs-text-color-muted);
+  background: var(--vocs-background-color-surfaceTint);
+}
+
+.reth-home-button-primary {
+  border-color: #111111;
+  background: #111111;
+  color: #ffffff !important;
+}
+
+.reth-home-button-primary:hover {
+  background: #2a2a2a;
+}
+
+[data-vocs-theme="dark"] .reth-home-button-primary {
+  border-color: #ffffff;
+  background: #ffffff;
+  color: #111111 !important;
+}
+
+[data-vocs-theme="dark"] .reth-home-button-primary:hover {
+  background: rgba(255, 255, 255, 0.88);
+}
+
+.reth-home-quickstart {
+  display: grid;
+  grid-template-columns: minmax(0, 0.78fr) minmax(360px, 1.22fr);
+  gap: 24px;
+  align-items: start;
+  border: 1px solid var(--vocs-border-color-primary);
+  border-radius: 10px;
+  padding: 24px;
+  background: color-mix(in srgb, var(--vocs-background-color-surface) 92%, transparent);
+}
+
+.reth-home-section-header {
+  max-width: 760px;
+}
+
+.reth-home-quickstart h2,
+.reth-home-section h2 {
+  margin: 0;
+  color: var(--vocs-text-color-heading);
+  font-weight: 650;
+  line-height: 1.1;
+}
+
+.reth-home-quickstart h2 {
+  font-size: clamp(24px, 2.6vw, 30px);
+}
+
+.reth-home-section h2 {
+  font-size: clamp(27px, 3vw, 34px);
+}
+
+.reth-home-code {
+  min-width: 0;
+}
+
+#home-install .vocs_CodeGroup {
+  display: flex;
+  min-height: 260px;
+  flex-direction: column;
+  margin: 0;
+}
+
+#home-install .vocs_Tabs_content {
+  flex: 1;
+}
+
+#home-install .vocs_Code {
+  font-size: 15px;
+}
+
+.reth-home-metrics-section {
+  display: flex;
+  justify-content: flex-start;
+  margin: -4px 0 8px;
+}
+
+.reth-home-metrics-section .reth-home-metrics {
+  justify-content: flex-start;
+}
+
+.reth-home-metrics a {
+  display: inline-flex;
+  min-height: 36px;
+  align-items: center;
+  gap: 10px;
+  border: 1px solid var(--vocs-border-color-primary);
+  border-radius: 8px;
+  padding: 5px 10px 5px 6px;
+  background: var(--vocs-background-color-surface);
+  transition: background 150ms ease, border-color 150ms ease, transform 150ms ease;
+}
+
+.reth-home-metrics span {
+  display: inline-flex;
+  height: 24px;
+  align-items: center;
+  border-radius: 6px;
+  padding: 0 8px;
+  background: var(--vocs-background-color-surfaceMuted);
+  color: var(--vocs-text-color-muted);
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.reth-home-metrics strong {
+  color: var(--vocs-text-color-heading);
+  font-size: 15px;
+  font-weight: 700;
+}
+
+.reth-home-metric-highlight {
+  border-color: color-mix(in srgb, var(--vocs-color-green) 58%, transparent) !important;
+}
+
+.reth-home-metric-highlight strong {
+  color: var(--vocs-color-green);
+}
+
+.reth-home-feature-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 12px;
+}
+
+.reth-home-feature-grid a,
+.reth-sdk-card,
+.reth-trusted-card,
+.reth-home-supporter-grid a {
+  border: 1px solid var(--vocs-border-color-primary);
+  border-radius: 10px;
+  background: color-mix(in srgb, var(--vocs-background-color-surface) 90%, transparent);
+  transition: background 150ms ease, border-color 150ms ease, transform 150ms ease;
+}
+
+.reth-home-feature-grid a {
+  display: flex;
+  min-height: 132px;
+  flex-direction: column;
+  justify-content: space-between;
+  padding: 18px;
+}
+
+.reth-home-feature-grid span,
+.reth-sdk-card h3 {
+  color: var(--vocs-text-color-heading);
+  font-size: 18px;
+  font-weight: 650;
+  line-height: 1.18;
+}
+
+.reth-home-feature-grid strong {
+  color: var(--vocs-text-color-secondary);
+  font-size: 14px;
+  font-weight: 450;
+  line-height: 1.5;
+}
+
+.reth-home-section {
+  margin-top: 36px;
+}
+
+.reth-home-section .reth-home-section-header {
+  margin-bottom: 20px;
+}
+
+.reth-trusted-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 12px;
+}
+
+.reth-trusted-card {
+  display: grid;
+  height: 138px;
+  place-items: center;
+  padding: 22px;
+}
+
+.reth-trusted-logo {
+  display: block;
+  width: auto;
+  height: auto;
+  object-fit: contain;
+}
+
+.reth-trusted-logo-flashbots,
+.reth-trusted-logo-succinct {
+  max-width: 76px;
+  max-height: 76px;
+}
+
+.reth-trusted-logo-coinbase,
+.reth-trusted-logo-alchemy {
+  max-width: 148px;
+  max-height: 52px;
+}
+
+.reth-sdk-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 14px;
+}
+
+.reth-sdk-card {
+  position: relative;
+  display: flex;
+  min-height: 198px;
+  flex-direction: column;
+  padding: 22px;
+}
+
+.reth-sdk-badge {
+  position: absolute;
+  top: 18px;
+  right: 18px;
+  border-radius: 999px;
+  padding: 5px 10px;
+  background: var(--vocs-background-color-surfaceMuted);
+  color: var(--vocs-text-color-heading);
+  font-size: 13px;
+  font-weight: 650;
+}
+
+.reth-sdk-card h3 {
+  max-width: calc(100% - 82px);
+  margin: 0;
+}
+
+.reth-sdk-company {
+  margin: 8px 0 0;
+  color: var(--vocs-text-color-secondary);
+  font-size: 15px;
+  line-height: 1.4;
+}
+
+.reth-sdk-description {
+  margin: 20px 0 24px;
+  color: var(--vocs-text-color-secondary);
+  font-size: 15px;
+  line-height: 1.5;
+}
+
+.reth-sdk-link {
+  display: inline-flex;
+  width: fit-content;
+  align-items: center;
+  gap: 8px;
+  margin-top: auto;
+  color: var(--vocs-text-color-heading);
+  font-size: 14px;
+  font-weight: 650;
+}
+
+.reth-sdk-link:hover {
+  color: var(--vocs-color-accent7);
+}
+
+.reth-sdk-link-icon {
+  width: 17px;
+  height: 17px;
+  flex: none;
+}
+
+.reth-home-supporter-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px;
+}
+
+.reth-home-supporter-grid a {
+  display: grid;
+  height: 152px;
+  place-items: center;
+  padding: 24px;
+}
+
+.reth-home-supporter-grid img {
+  display: block;
+  max-width: min(290px, 76%);
+  max-height: 70px;
+  object-fit: contain;
+}
+
+[data-vocs-theme="dark"] .reth-home-supporter-grid img {
+  filter: invert(1);
+}
+
+.border-accent {
+  border: 1px solid var(--vocs-color_borderAccent) !important;
+}
+
+@media (max-width: 1180px) {
+  .reth-home-quickstart {
+    grid-template-columns: 1fr;
+  }
+
+  .reth-home-hero-top {
+    grid-template-columns: minmax(0, 0.95fr) minmax(280px, 0.78fr);
+    gap: 24px;
+  }
+}
+
+@media (min-width: 1376px) {
+  [data-v-content]:has(.reth-home-page) {
+    max-width: min(860px, calc(100vw - 48px));
+  }
+}
+
+@media (max-width: 900px) {
+  [data-v-content]:has(.reth-home-page) {
+    max-width: calc(100vw - 32px);
+    padding-top: 24px;
+    padding-bottom: 64px;
+  }
+
+  .reth-home-hero-top {
+    grid-template-columns: 1fr;
+    align-items: start;
+  }
+
+  .reth-home-hero-media img {
+    aspect-ratio: 16 / 8;
+  }
+
+  .reth-home-hero-body {
+    max-width: 680px;
+  }
+
+  .reth-home-feature-grid,
+  .reth-trusted-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+
+@media (max-width: 620px) {
+  .reth-home-page {
+    gap: 24px;
+  }
+
+  .reth-home-actions,
+  .reth-home-metrics {
+    flex-direction: column;
+    align-items: stretch;
+  }
+
+  .reth-home-button,
+  .reth-home-metrics a {
+    width: 100%;
+  }
+
+  .reth-home-quickstart {
+    padding: 18px;
+  }
+
+  .reth-home-feature-grid,
+  .reth-trusted-grid,
+  .reth-sdk-grid,
+  .reth-home-supporter-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .reth-trusted-card {
+    height: 122px;
+  }
+
+  .reth-sdk-card {
+    min-height: 0;
+    padding: 20px;
+  }
+}
diff --git a/docs/vocs/docs/pages/cli/reth/db.mdx b/docs/vocs/docs/pages/cli/reth/db.mdx
index 7b558671a3b..0f589c0af89 100644
--- a/docs/vocs/docs/pages/cli/reth/db.mdx
+++ b/docs/vocs/docs/pages/cli/reth/db.mdx
@@ -118,6 +118,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
diff --git a/docs/vocs/docs/pages/cli/reth/db/diff.mdx b/docs/vocs/docs/pages/cli/reth/db/diff.mdx
index d4fb7527d98..868ebac93cd 100644
--- a/docs/vocs/docs/pages/cli/reth/db/diff.mdx
+++ b/docs/vocs/docs/pages/cli/reth/db/diff.mdx
@@ -67,6 +67,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
       --table <TABLE>
           The table name to diff. If not specified, all tables are diffed.
 
diff --git a/docs/vocs/docs/pages/cli/reth/download.mdx b/docs/vocs/docs/pages/cli/reth/download.mdx
index e56a3522220..d1e9ebfa7ae 100644
--- a/docs/vocs/docs/pages/cli/reth/download.mdx
+++ b/docs/vocs/docs/pages/cli/reth/download.mdx
@@ -97,6 +97,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
@@ -199,6 +205,9 @@ Storage:
   -y, --non-interactive
           Skip interactive component selection. Downloads the minimal set (state + headers + transactions + changesets) unless explicit --with-* flags narrow it
 
+      --force
+          Overwrite existing snapshot data by removing db, rocksdb, static_files, and reth.toml
+
       --resumable [<RESUMABLE>]
           Enable resumable two-phase downloads (download to disk first, then extract).
 
diff --git a/docs/vocs/docs/pages/cli/reth/export-era.mdx b/docs/vocs/docs/pages/cli/reth/export-era.mdx
index 42ec8b264de..c7477ff7a69 100644
--- a/docs/vocs/docs/pages/cli/reth/export-era.mdx
+++ b/docs/vocs/docs/pages/cli/reth/export-era.mdx
@@ -97,6 +97,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
diff --git a/docs/vocs/docs/pages/cli/reth/import-era.mdx b/docs/vocs/docs/pages/cli/reth/import-era.mdx
index ea23c981f10..20299d61886 100644
--- a/docs/vocs/docs/pages/cli/reth/import-era.mdx
+++ b/docs/vocs/docs/pages/cli/reth/import-era.mdx
@@ -97,6 +97,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
diff --git a/docs/vocs/docs/pages/cli/reth/import.mdx b/docs/vocs/docs/pages/cli/reth/import.mdx
index 8428972c72b..c6b66c57cf1 100644
--- a/docs/vocs/docs/pages/cli/reth/import.mdx
+++ b/docs/vocs/docs/pages/cli/reth/import.mdx
@@ -97,6 +97,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
diff --git a/docs/vocs/docs/pages/cli/reth/init-state.mdx b/docs/vocs/docs/pages/cli/reth/init-state.mdx
index 47bc421214b..fb369df3f95 100644
--- a/docs/vocs/docs/pages/cli/reth/init-state.mdx
+++ b/docs/vocs/docs/pages/cli/reth/init-state.mdx
@@ -97,6 +97,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
diff --git a/docs/vocs/docs/pages/cli/reth/init.mdx b/docs/vocs/docs/pages/cli/reth/init.mdx
index 657f56c4315..2803a1f5c24 100644
--- a/docs/vocs/docs/pages/cli/reth/init.mdx
+++ b/docs/vocs/docs/pages/cli/reth/init.mdx
@@ -97,6 +97,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
diff --git a/docs/vocs/docs/pages/cli/reth/node.mdx b/docs/vocs/docs/pages/cli/reth/node.mdx
index 4e88bde832d..0b2057cf142 100644
--- a/docs/vocs/docs/pages/cli/reth/node.mdx
+++ b/docs/vocs/docs/pages/cli/reth/node.mdx
@@ -94,7 +94,9 @@ Networking:
           Disable Nat discovery
 
       --discovery.addr <DISCOVERY_ADDR>
-          The UDP address to use for devp2p peer discovery version 4
+          The UDP address to use for devp2p peer discovery version 4.
+
+          If unset and `--net-if.experimental` is used, discv4 binds to the resolved interface address.
 
           [default: 0.0.0.0]
 
@@ -115,7 +117,9 @@ Networking:
           [default: 9200]
 
       --discovery.v5.port.ipv6 <DISCOVERY_V5_PORT_IPV6>
-          The UDP IPv6 port to use for devp2p peer discovery version 5. Not used unless `--addr` is IPv6, or `--discovery.addr.ipv6` is set
+          The UDP IPv6 port to use for devp2p peer discovery version 5. Not used unless `--addr` is IPv6, or `--discovery.addr.ipv6` is set.
+
+          If not provided, discovery V5 defaults to same port as discovery V4 (--discovery.port).
 
           [default: 9200]
 
@@ -262,7 +266,7 @@ Networking:
       --net-if.experimental <IF_NAME>
           Name of network interface used to communicate with peers.
 
-          If flag is set, but no value is passed, the default interface for docker `eth0` is tried.
+          If flag is set, but no value is passed, the default interface for docker `eth0` is tried. If `--discovery.addr` is left at its default, discv4 will also bind to the resolved interface address.
 
       --tx-propagation-policy <TX_PROPAGATION_POLICY>
           Transaction Propagation Policy
@@ -405,6 +409,9 @@ RPC:
 
           This is __not__ used for the authenticated engine-API RPC server, see `--authrpc.jwtsecret`.
 
+      --rpc.disable-metrics
+          Disable built-in RPC request metrics
+
       --rpc.max-request-size <RPC_MAX_REQUEST_SIZE>
           Set the maximum RPC request payload size for both HTTP and WS in megabytes
 
@@ -475,6 +482,11 @@ RPC:
 
           [default: 256]
 
+      --rpc.compute-state-root-for-eth-simulate
+          Compute state roots for `eth_simulateV1` responses
+
+          [env: RETH_RPC_COMPUTE_STATE_ROOT_FOR_ETH_SIMULATE=]
+
       --rpc.eth-proof-window <RPC_ETH_PROOF_WINDOW>
           The maximum proof window for historical proof generation. This value allows for generating historical proofs up to configured number of blocks from current tip (up to `tip - window`)
 
@@ -514,6 +526,11 @@ RPC State Cache:
 
           [default: 1000]
 
+      --rpc-cache.max-bals <MAX_BALS>
+          Max number of revm block access lists in cache
+
+          [default: 1000]
+
       --rpc-cache.max-concurrent-db-requests <MAX_CONCURRENT_DB_REQUESTS>
           Max number of concurrent database requests
 
@@ -565,7 +582,7 @@ Gas Price Oracle:
 
 TxPool:
       --txpool.pending-max-count <PENDING_MAX_COUNT>
-          Max number of transaction in the pending sub-pool
+          Max number of transactions in the pending sub-pool
 
           [default: 10000]
 
@@ -575,7 +592,7 @@ TxPool:
           [default: 20]
 
       --txpool.basefee-max-count <BASEFEE_MAX_COUNT>
-          Max number of transaction in the basefee sub-pool
+          Max number of transactions in the basefee sub-pool
 
           [default: 10000]
 
@@ -585,7 +602,7 @@ TxPool:
           [default: 20]
 
       --txpool.queued-max-count <QUEUED_MAX_COUNT>
-          Max number of transaction in the queued sub-pool
+          Max number of transactions in the queued sub-pool
 
           [default: 10000]
 
@@ -595,7 +612,7 @@ TxPool:
           [default: 20]
 
       --txpool.blobpool-max-count <BLOBPOOL_MAX_COUNT>
-          Max number of transaction in the blobpool
+          Max number of transactions in the blobpool
 
           [default: 10000]
 
@@ -751,6 +768,9 @@ Debug:
       --debug.skip-new-payload <SKIP_NEW_PAYLOAD>
           If provided, the engine will skip `n` consecutive new payloads
 
+      --debug.skip-genesis-validation
+          If set, bypasses genesis hash validation during init. Intended for tools that direct-write the database (e.g. snapshot importers, state-actor) and want reth to trust the DB-resident genesis state instead of recomputing it from the chainspec's alloc. When the bypass fires, a structured `tracing::warn!` is emitted so the divergence stays observable in operator logs
+
       --debug.reorg-frequency <REORG_FREQUENCY>
           If provided, the chain will be reorged at specified frequency
 
@@ -836,6 +856,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Dev testnet:
       --dev
           Start the node in dev mode
@@ -956,9 +982,9 @@ Engine:
       --engine.persistence-backpressure-threshold <PERSISTENCE_BACKPRESSURE_THRESHOLD>
           Configure the maximum canonical-minus-persisted gap before engine API processing stalls.
 
-          This value must be greater than `--engine.persistence-threshold`.
+          If omitted, this defaults to the larger of the default backpressure threshold and twice `--engine.persistence-threshold`.
 
-          [default: 16]
+          This value must be greater than `--engine.persistence-threshold`.
 
       --engine.memory-block-buffer-target <MEMORY_BLOCK_BUFFER_TARGET>
           Configure the target number of blocks to keep in memory
@@ -1056,11 +1082,11 @@ Engine:
       --engine.state-root-task-timeout <STATE_ROOT_TASK_TIMEOUT>
           Configure the timeout for the state root task before spawning a sequential fallback. If the state root task takes longer than this, a sequential computation starts in parallel and whichever finishes first is used.
 
-          --engine.state-root-task-timeout 1s --engine.state-root-task-timeout 400ms
+          --engine.state-root-task-timeout 4s --engine.state-root-task-timeout 400ms
 
           Set to 0s to disable.
 
-          [default: 1s]
+          [default: 4s]
 
       --engine.share-execution-cache-with-payload-builder
           Whether to share execution cache with the payload builder.
@@ -1084,10 +1110,10 @@ Engine:
           When enabled, persistence cycles are deferred from the moment an FCU with payload attributes arrives until the next FCU clears the build. Useful on chains with short block times where persistence I/O can interfere with block building latency.
 
       --engine.disable-bal-parallel-execution
-          Disable BAL (Block Access List, EIP-7928) based parallel execution. Defaults to disabled, falling back to transaction-based prewarming even when a BAL is available
+          Disable BAL (Block Access List, EIP-7928) based parallel execution
 
       --engine.disable-bal-parallel-state-root
-          Disable BAL-driven parallel state root computation. When set, the BAL hashed post state is not sent to the multiproof task for early parallel state root computation
+          Disable BAL-driven parallel state root computation. This is only valid together with `--engine.disable-bal-parallel-execution`
 
       --engine.disable-bal-batch-io
           Disable BAL (Block Access List) storage prefetch IO during prewarming. When set, BAL storage slots are not read into the execution cache
diff --git a/docs/vocs/docs/pages/cli/reth/p2p/body.mdx b/docs/vocs/docs/pages/cli/reth/p2p/body.mdx
index a12a5741da6..a149443834e 100644
--- a/docs/vocs/docs/pages/cli/reth/p2p/body.mdx
+++ b/docs/vocs/docs/pages/cli/reth/p2p/body.mdx
@@ -34,7 +34,9 @@ Networking:
           Disable Nat discovery
 
       --discovery.addr <DISCOVERY_ADDR>
-          The UDP address to use for devp2p peer discovery version 4
+          The UDP address to use for devp2p peer discovery version 4.
+
+          If unset and `--net-if.experimental` is used, discv4 binds to the resolved interface address.
 
           [default: 0.0.0.0]
 
@@ -55,7 +57,9 @@ Networking:
           [default: 9200]
 
       --discovery.v5.port.ipv6 <DISCOVERY_V5_PORT_IPV6>
-          The UDP IPv6 port to use for devp2p peer discovery version 5. Not used unless `--addr` is IPv6, or `--discovery.addr.ipv6` is set
+          The UDP IPv6 port to use for devp2p peer discovery version 5. Not used unless `--addr` is IPv6, or `--discovery.addr.ipv6` is set.
+
+          If not provided, discovery V5 defaults to same port as discovery V4 (--discovery.port).
 
           [default: 9200]
 
@@ -202,7 +206,7 @@ Networking:
       --net-if.experimental <IF_NAME>
           Name of network interface used to communicate with peers.
 
-          If flag is set, but no value is passed, the default interface for docker `eth0` is tried.
+          If flag is set, but no value is passed, the default interface for docker `eth0` is tried. If `--discovery.addr` is left at its default, discv4 will also bind to the resolved interface address.
 
       --tx-propagation-policy <TX_PROPAGATION_POLICY>
           Transaction Propagation Policy
diff --git a/docs/vocs/docs/pages/cli/reth/p2p/header.mdx b/docs/vocs/docs/pages/cli/reth/p2p/header.mdx
index da60a42d03d..fcdfbed536c 100644
--- a/docs/vocs/docs/pages/cli/reth/p2p/header.mdx
+++ b/docs/vocs/docs/pages/cli/reth/p2p/header.mdx
@@ -34,7 +34,9 @@ Networking:
           Disable Nat discovery
 
       --discovery.addr <DISCOVERY_ADDR>
-          The UDP address to use for devp2p peer discovery version 4
+          The UDP address to use for devp2p peer discovery version 4.
+
+          If unset and `--net-if.experimental` is used, discv4 binds to the resolved interface address.
 
           [default: 0.0.0.0]
 
@@ -55,7 +57,9 @@ Networking:
           [default: 9200]
 
       --discovery.v5.port.ipv6 <DISCOVERY_V5_PORT_IPV6>
-          The UDP IPv6 port to use for devp2p peer discovery version 5. Not used unless `--addr` is IPv6, or `--discovery.addr.ipv6` is set
+          The UDP IPv6 port to use for devp2p peer discovery version 5. Not used unless `--addr` is IPv6, or `--discovery.addr.ipv6` is set.
+
+          If not provided, discovery V5 defaults to same port as discovery V4 (--discovery.port).
 
           [default: 9200]
 
@@ -202,7 +206,7 @@ Networking:
       --net-if.experimental <IF_NAME>
           Name of network interface used to communicate with peers.
 
-          If flag is set, but no value is passed, the default interface for docker `eth0` is tried.
+          If flag is set, but no value is passed, the default interface for docker `eth0` is tried. If `--discovery.addr` is left at its default, discv4 will also bind to the resolved interface address.
 
       --tx-propagation-policy <TX_PROPAGATION_POLICY>
           Transaction Propagation Policy
diff --git a/docs/vocs/docs/pages/cli/reth/prune.mdx b/docs/vocs/docs/pages/cli/reth/prune.mdx
index 4e826ef2bc0..75be037c504 100644
--- a/docs/vocs/docs/pages/cli/reth/prune.mdx
+++ b/docs/vocs/docs/pages/cli/reth/prune.mdx
@@ -97,6 +97,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
diff --git a/docs/vocs/docs/pages/cli/reth/re-execute.mdx b/docs/vocs/docs/pages/cli/reth/re-execute.mdx
index 49951459d26..0fecdb8eb40 100644
--- a/docs/vocs/docs/pages/cli/reth/re-execute.mdx
+++ b/docs/vocs/docs/pages/cli/reth/re-execute.mdx
@@ -97,6 +97,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
diff --git a/docs/vocs/docs/pages/cli/reth/stage/drop.mdx b/docs/vocs/docs/pages/cli/reth/stage/drop.mdx
index 77875555f69..8ba0951fb90 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/drop.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/drop.mdx
@@ -97,6 +97,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
diff --git a/docs/vocs/docs/pages/cli/reth/stage/dump.mdx b/docs/vocs/docs/pages/cli/reth/stage/dump.mdx
index 2cc718a1da2..653d6d53ab2 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/dump.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/dump.mdx
@@ -104,6 +104,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
diff --git a/docs/vocs/docs/pages/cli/reth/stage/run.mdx b/docs/vocs/docs/pages/cli/reth/stage/run.mdx
index 667c4cb2c45..5997110158d 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/run.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/run.mdx
@@ -97,6 +97,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
@@ -187,7 +193,9 @@ Networking:
           Disable Nat discovery
 
       --discovery.addr <DISCOVERY_ADDR>
-          The UDP address to use for devp2p peer discovery version 4
+          The UDP address to use for devp2p peer discovery version 4.
+
+          If unset and `--net-if.experimental` is used, discv4 binds to the resolved interface address.
 
           [default: 0.0.0.0]
 
@@ -208,7 +216,9 @@ Networking:
           [default: 9200]
 
       --discovery.v5.port.ipv6 <DISCOVERY_V5_PORT_IPV6>
-          The UDP IPv6 port to use for devp2p peer discovery version 5. Not used unless `--addr` is IPv6, or `--discovery.addr.ipv6` is set
+          The UDP IPv6 port to use for devp2p peer discovery version 5. Not used unless `--addr` is IPv6, or `--discovery.addr.ipv6` is set.
+
+          If not provided, discovery V5 defaults to same port as discovery V4 (--discovery.port).
 
           [default: 9200]
 
@@ -355,7 +365,7 @@ Networking:
       --net-if.experimental <IF_NAME>
           Name of network interface used to communicate with peers.
 
-          If flag is set, but no value is passed, the default interface for docker `eth0` is tried.
+          If flag is set, but no value is passed, the default interface for docker `eth0` is tried. If `--discovery.addr` is left at its default, discv4 will also bind to the resolved interface address.
 
       --tx-propagation-policy <TX_PROPAGATION_POLICY>
           Transaction Propagation Policy
diff --git a/docs/vocs/docs/pages/cli/reth/stage/unwind.mdx b/docs/vocs/docs/pages/cli/reth/stage/unwind.mdx
index 830766788e5..8b16062a733 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/unwind.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/unwind.mdx
@@ -102,6 +102,12 @@ Database:
 
           Controls the size of the in-memory LRU cache for decompressed `RocksDB` blocks. A larger cache reduces repeated decompression of hot blocks, improving read performance for history lookups.
 
+      --db.balstore-cache-size <BALSTORE_CACHE_SIZE>
+          Number of recent blocks to keep in the in-memory BAL store cache
+
+      --db.disable-metrics
+          Disable built-in database metrics
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment
diff --git a/docs/vocs/docs/pages/index.mdx b/docs/vocs/docs/pages/index.mdx
index 8fcf352cf81..bcab93f5b7b 100644
--- a/docs/vocs/docs/pages/index.mdx
+++ b/docs/vocs/docs/pages/index.mdx
@@ -1,162 +1,105 @@
 ---
-content:
-    width: 100%
-layout: landing
-showLogo: false
 title: Reth
-description: Secure, performant and modular blockchain SDK and node.
+description: Secure, performant, and modular blockchain SDK and node.
 ---
 
-import { HomePage, Sponsors } from "vocs/components";
 import { SdkShowcase } from "../components/SdkShowcase";
 import { TrustedBy } from "../components/TrustedBy";
 
-<div className="max-w-[1120px] mx-auto vp-doc relative px-[24px] mb-[64px] mt-[32px] md:px-0 md:mb-[32px]">
-  <div className="pt-[48px] max-sm:pt-0">
-    <div className="max-sm:px-0 space-x-2 flex justify-between z-0 max-md:justify-center max-md:flex-col max-md:items-center max-md:space-y-6">
-      <div className="space-y-4 max-w-[500px] flex flex-col justify-between items-start max-md:items-center">
-        <div className="space-y-4 w-full lg:mb-[40px]">
-          <img
-          src="/reth-prod.png"
-          alt="Reth"
-          className="w-full h-auto rounded-xl"
-          />
-          <div className="font-regular text-[21px] max-sm:text-[18px] text-[#919193] max-md:text-center"><span className="text-black dark:text-white">Secure</span>, <span className="text-black dark:text-white">performant</span>, and <span className="text-black dark:text-white">modular</span> blockchain SDK and node.</div>
-        </div>
-        <div className="flex justify-center space-x-2">
-          <HomePage.Button href="/run/ethereum" variant="accent">Run a Node</HomePage.Button>
-          <HomePage.Button href="/sdk" variant="accent">Build a Node</HomePage.Button>
-          <HomePage.Button href="/introduction/why-reth">Why Reth?</HomePage.Button>
-        </div>
-      </div>
-        <div className="flex flex-col justify-between space-y-4 w-full max-w-[500px]">
-          <div id="home-install">
-            :::code-group
-
-            ```bash [Run a Node]
-            # Install the binary
-            brew install paradigmxyz/brew/reth
-
-            # Run the node with JSON-RPC enabled
-            reth node --http --http.api eth,trace
-            ```
-
-            ```rust [Build a Node]
-            // .. snip ..
-            let handle = node_builder
-              .with_types::<EthereumNode>()
-              .with_components(EthereumNode::components())
-              .with_add_ons(EthereumAddOns::default())
-              .launch()
-              .await?;
-            ```
-
-            :::
-          </div>
-          <div className="flex justify-between space-x-2">
-                <a href="https://github.com/paradigmxyz/reth/stargazers" className="cursor-pointer h-[36px] max-w-[120px] flex-1 relative rounded-lg overflow-hidden border border-black/10 dark:border-white/20" style={{ color: 'inherit' }} rel="noreferrer noopener" target="_blank">
-      <div className="absolute flex z-[1] p-[6px] h-full w-full">
-        <div className="bg-white/60 dark:bg-black/40 flex items-center justify-center rounded-md px-3 py-1">
-          <span className="font-medium text-[15px] opacity-80 leading-none text-center">stars</span>
-        </div>
-        <div className="flex items-center h-full px-2 ml-1">
-          <span className="font-medium text-[15px] text-center leading-none w-full text-black dark:text-white">4.7K</span>
+<div className="reth-home-page">
+  <section className="reth-home-hero" aria-labelledby="reth-home-title">
+    <div className="reth-home-hero-top">
+      <div className="reth-home-hero-heading">
+        <div className="reth-home-kicker">Ethereum execution client and node SDK</div>
+        <h1 id="reth-home-title">Reth</h1>
+        <div className="reth-home-actions">
+          <a className="reth-home-button reth-home-button-primary" href="/run/ethereum">Run a Node</a>
+          <a className="reth-home-button reth-home-button-primary" href="/sdk">Build a Node</a>
+          <a className="reth-home-button" href="/introduction/why-reth">Why Reth?</a>
         </div>
       </div>
-      <div className="absolute left-0 right-0 top-0 bottom-0 bg-black/5 dark:bg-white/5 z-[0]" />
-      <div className="absolute left-0 right-0 top-0 bottom-0 backdrop-blur-[2px] backdrop-filter z-0" />
-    </a>
-    <a href="https://github.com/paradigmxyz/reth/graphs/contributors" className="cursor-pointer h-[36px] max-w-[160px] flex-1 relative rounded-lg overflow-hidden border border-green-400/50" style={{ color: 'inherit' }} rel="noreferrer noopener" target="_blank">
-      <div className="absolute flex z-[1] p-[6px] h-full w-full">
-        <div className="flex-1 bg-white/60 dark:bg-black/40 flex items-center w-full h-full rounded-md">
-          <span className="font-medium text-[15px] leading-none opacity-80 w-full text-center">contributors</span>
-        </div>
-        <div className="flex items-center h-full px-2">
-          <span className="font-medium text-[15px] leading-none text-center w-full text-green-400">580+</span>
-        </div>
+      <div className="reth-home-hero-media">
+        <img src="/reth-prod.png" alt="Reth chip on a dark circuit grid" />
       </div>
-      <div className="absolute left-0 right-0 top-0 bottom-0 bg-green-400 opacity-10 z-[0]" />
-      <div className="absolute left-0 right-0 top-0 bottom-0 backdrop-blur-[2px] backdrop-filter z-[0]" />
-    </a>
-    <a href="https://github.com/paradigmxyz/reth/blob/main/LICENSE-MIT" className="cursor-pointer h-[36px] max-w-[130px] flex-1 relative rounded-lg overflow-hidden border border-black/10 dark:border-white/20 max-lg:hidden" style={{ color: 'inherit' }} rel="noreferrer noopener" target="_blank">
-      <div className="absolute flex z-[1] p-[6px] h-full w-full">
-        <div className="flex-1 bg-white/60 dark:bg-black/40 flex items-center w-full h-full rounded-md">
-          <span className="font-medium text-[15px] leading-none opacity-80 w-full text-center">license</span>
-        </div>
-        <div className="flex items-center h-full px-2">
-          <span className="font-medium text-[15px] leading-none text-center w-full text-black dark:text-white">MIT</span>
-        </div>
-      </div>
-      <div className="absolute left-0 right-0 top-0 bottom-0 bg-black/5 dark:bg-white/5 z-[0]" />
-      <div className="absolute left-0 right-0 top-0 bottom-0 backdrop-blur-[2px] backdrop-filter z-[0]" />
-    </a>
-          </div>
-        </div>
+    </div>
+    <div className="reth-home-hero-body">
+      <div className="reth-home-lede">Secure, performant, and modular blockchain SDK and node.</div>
+      <div className="reth-home-detail">Production-grade Rust infrastructure for running nodes, building chains, and extending Ethereum.</div>
+    </div>
+  </section>
 
-  </div>
-  <div className="flex justify-between flex-wrap mt-10 lg:mt-30">
-      <div className="pr-2 w-1/4 max-lg:pb-3 max-sm:px-0 max-lg:w-1/2 max-sm:w-full z-0">
-        <div className="relative w-full h-[168px] max-lg:h-[142px] overflow-hidden">
-          <a href="/run/ethereum" className="hover:bg-black/2 dark:hover:bg-white/2 border-black/10 dark:border-white/10 border border-solid rounded-lg h-full px-5 py-6 absolute z-10 flex flex-col justify-between w-full vocs_Link vocs_Link_styleless">
-            <div className="text-xl font-medium text-black dark:text-white">Institutional Security</div>
-            <div className="text-[17px] text-[#919193]">Run reliable staking nodes trusted by Coinbase Staking</div>
-          </a>
-          <div className="absolute left-0 right-0 top-0 bottom-0 dark:bg-[#313136] opacity-20 z-0" />
-          <div className="absolute left-0 right-0 top-0 bottom-0 backdrop-filter backdrop-blur-[2px] z-0" />
-        </div>
-      </div>
-      <div className="pl-2 pr-2 max-sm:px-0 max-lg:pb-3 max-lg:pr-0 w-1/4 max-lg:w-1/2 max-sm:w-full z-0">
-        <div className="relative w-full h-[168px] max-lg:h-[142px]">
-          <a href="/overview" className="hover:bg-black/2 dark:hover:bg-white/2 border-black/10 dark:border-white/10 border border-solid rounded-lg h-full px-5 py-6 absolute z-10 flex flex-col justify-between w-full vocs_Link vocs_Link_styleless">
-            <div className="text-xl font-medium text-black dark:text-white">Performant</div>
-            <div className="text-[17px] text-[#919193]">Sync faster with optimal transaction processing</div>
-          </a>
-          <div className="absolute left-0 right-0 top-0 bottom-0 dark:bg-[#313136] opacity-20 z-0" />
-          <div className="absolute left-0 right-0 top-0 bottom-0 backdrop-filter backdrop-blur-[2px] z-0" />
-        </div>
-      </div>
-      <div className="pl-2 pr-2 max-lg:pb-3 max-sm:px-0 max-lg:pl-0 w-1/4 max-lg:w-1/2 max-sm:w-full z-0">
-        <div className="relative w-full h-[168px] max-lg:h-[142px]">
-          <a href="/sdk" className="hover:bg-black/2 dark:hover:bg-white/2 border-black/10 dark:border-white/10 border border-solid rounded-lg h-full px-5 py-6 absolute z-10 flex flex-col justify-between w-full vocs_Link vocs_Link_styleless">
-            <div className="text-xl font-medium text-black dark:text-white">Customizable</div>
-            <div className="text-[17px] text-[#919193]">Build custom nodes with tailored transaction handling</div>
-          </a>
-          <div className="absolute left-0 right-0 top-0 bottom-0 dark:bg-[#313136] opacity-20 z-0" />
-          <div className="absolute left-0 right-0 top-0 bottom-0 backdrop-filter backdrop-blur-[2px] z-0" />
-        </div>
-      </div>
-      <div className="pl-2 w-1/4 max-sm:px-0 max-lg:w-1/2 max-sm:w-full z-0">
-        <div className="relative w-full h-[168px] max-lg:h-[142px]">
-          <a href="/exex/overview" className="hover:bg-black/2 dark:hover:bg-white/2 border-black/10 dark:border-white/10 border border-solid rounded-lg h-full px-5 py-6 absolute z-10 flex flex-col justify-between w-full vocs_Link vocs_Link_styleless">
-            <div className="text-xl font-medium text-black dark:text-white">Extensible</div>
-            <div className="text-[17px] text-[#919193]">Build indexers and offchain services with ExExs</div>
-          </a>
-          <div className="absolute left-0 right-0 top-0 bottom-0 dark:bg-[#313136] opacity-20 z-0" />
-          <div className="absolute left-0 right-0 top-0 bottom-0 backdrop-filter backdrop-blur-[2px] z-0" />
-        </div>
-      </div>
+  <section className="reth-home-metrics-section" aria-label="Reth project metrics">
+    <div className="reth-home-metrics">
+      <a href="https://github.com/paradigmxyz/reth/stargazers" rel="noreferrer noopener" target="_blank"><span>stars</span><strong>5K+</strong></a>
+      <a className="reth-home-metric-highlight" href="https://github.com/paradigmxyz/reth/graphs/contributors" rel="noreferrer noopener" target="_blank"><span>contributors</span><strong>580+</strong></a>
+      <a href="https://github.com/paradigmxyz/reth/blob/main/LICENSE-MIT" rel="noreferrer noopener" target="_blank"><span>license</span><strong>MIT</strong></a>
     </div>
+  </section>
+
+  <section className="reth-home-quickstart" aria-labelledby="quickstart">
+    <div className="reth-home-section-header">
+      <div className="reth-home-kicker">Quickstart</div>
+      <h2 id="quickstart">Run or build with Reth</h2>
+      <div className="reth-home-section-copy">Start with the production binary, or use the same modular components to assemble your own Ethereum-compatible node.</div>
     </div>
-</div>
-<article className="vocs_Content max-w-5xl mx-auto">
+    <div id="home-install" className="reth-home-code">
+      :::code-group
 
-## Trusted by the Best
+      ```bash [Run a Node]
+      # Install the binary
+      brew install paradigmxyz/brew/reth
 
-Leading infra companies use Reth for MEV applications, staking, RPC services and generating zero-knowledge proofs.
+      # Run the node with JSON-RPC enabled
+      reth node --http --http.api eth,trace
+      ```
 
-<div className="mb-12">
-    <TrustedBy />
-</div>
+      ```rust [Build a Node]
+      // .. snip ..
+      let handle = node_builder
+        .with_types::<EthereumNode>()
+        .with_components(EthereumNode::components())
+        .with_add_ons(EthereumAddOns::default())
+        .launch()
+        .await?;
+      ```
 
-## Built with Reth SDK
+      :::
+    </div>
+  </section>
 
-Production chains and networks are powered by Reth's modular architecture. These nodes are built using existing components without forking, saving several engineering hours while improving maintainability.
+  <section className="reth-home-feature-grid" aria-label="Reth capabilities">
+    <a href="/run/ethereum"><span>Institutional Security</span><strong>Run reliable staking nodes trusted by Coinbase Staking.</strong></a>
+    <a href="/overview"><span>Performance</span><strong>Sync faster with optimized transaction processing and storage.</strong></a>
+    <a href="/sdk"><span>Customizable</span><strong>Build custom nodes with tailored transaction handling.</strong></a>
+    <a href="/exex/overview"><span>Extensible</span><strong>Build indexers and offchain services with ExExs.</strong></a>
+  </section>
 
-<div className="mb-12">
-    <SdkShowcase />
-</div>
+  <section className="reth-home-section" id="trusted-by-the-best">
+    <div className="reth-home-section-header">
+      <div className="reth-home-kicker">Operators and infra teams</div>
+      <h2>Trusted by the Best</h2>
+      <div className="reth-home-section-copy">Leading infra companies use Reth for MEV applications, staking, RPC services, and zero-knowledge proofs.</div>
+    </div>
+    <TrustedBy />
+  </section>
 
-## Supporters
+  <section className="reth-home-section" id="built-with-reth-sdk">
+    <div className="reth-home-section-header">
+      <div className="reth-home-kicker">Built with Reth SDK</div>
+      <h2>Built with Reth SDK</h2>
+      <div className="reth-home-section-copy">Teams use Reth's modular architecture to build nodes from existing components while keeping maintenance overhead low.</div>
+    </div>
+    <SdkShowcase />
+  </section>
 
-<Sponsors />
-</article>
+  <section className="reth-home-section reth-home-supporters" id="supporters">
+    <div className="reth-home-section-header">
+      <div className="reth-home-kicker">Supporters</div>
+      <h2>Supporters</h2>
+    </div>
+    <div className="reth-home-supporter-grid">
+      <a href="https://paradigm.xyz" rel="noreferrer noopener" target="_blank"><img src="https://raw.githubusercontent.com/wevm/.github/main/content/sponsors/paradigm-light.svg" alt="Paradigm" /></a>
+      <a href="https://ithaca.xyz" rel="noreferrer noopener" target="_blank"><img src="https://raw.githubusercontent.com/wevm/.github/main/content/sponsors/ithaca-light.svg" alt="Ithaca" /></a>
+    </div>
+  </section>
+</div>
diff --git a/docs/vocs/docs/pages/installation/source.mdx b/docs/vocs/docs/pages/installation/source.mdx
index d6283d83350..fb34e5a0d3a 100644
--- a/docs/vocs/docs/pages/installation/source.mdx
+++ b/docs/vocs/docs/pages/installation/source.mdx
@@ -110,11 +110,11 @@ RUSTFLAGS="-C target-cpu=native" cargo build --profile maxperf
 
 **Features**
 
-The following performance features are enabled by default: `jemalloc` (except on Windows), `asm-keccak`, and `min-debug-logs`.
+The following performance features are enabled by default: `jemalloc` (except on Windows), `asm-keccak`, and `min-trace-logs`.
 
 Some additional optional features are available:
 
--   `min-LEVEL-logs`, where `LEVEL` is one of `error`, `warn`, `info`, `debug`, `trace`: disables compilation of logs of lower level than the given one; `min-debug-logs` is enabled by default
+-   `min-LEVEL-logs`, where `LEVEL` is one of `error`, `warn`, `info`, `debug`, `trace`: disables compilation of logs of lower level than the given one; `min-trace-logs` is enabled by default
 
 You can build with maximum performance optimizations using:
 
diff --git a/docs/vocs/docs/pages/jsonrpc/admin.mdx b/docs/vocs/docs/pages/jsonrpc/admin.mdx
index f8dd678ebc3..7280f2b128f 100644
--- a/docs/vocs/docs/pages/jsonrpc/admin.mdx
+++ b/docs/vocs/docs/pages/jsonrpc/admin.mdx
@@ -80,6 +80,7 @@ Returns true if the peer was successfully removed.
 Returns all information known about the running node.
 
 These include general information about the node itself, as well as what protocols it participates in, its IP and ports.
+The `id` field is the keccak256 hash of the node's `enode` public key, encoded as 64 lowercase hex characters without a `0x` prefix.
 
 | Client | Method invocation              |
 | ------ | ------------------------------ |
@@ -94,7 +95,7 @@ These include general information about the node itself, as well as what protoco
     "id": 1,
     "result": {
         "enode": "enode://44826a5d6a55f88a18298bca4773fca5749cdc3a5c9f308aa7d810e9b31123f3e7c5fba0b1d70aac5308426f47df2a128a6747040a3815cc7dd7167d03be320d@[::]:30303",
-            "id": "44826a5d6a55f88a18298bca4773fca5749cdc3a5c9f308aa7d810e9b31123f3e7c5fba0b1d70aac5308426f47df2a128a6747040a3815cc7dd7167d03be320d",
+            "id": "8915d6ec2f53ede650d5b9bea77d7756f177092171648ee1d8cbc550d334fa7a",
             "ip": "::",
             "listenAddr": "[::]:30303",
             "name": "reth/v0.0.1/x86_64-unknown-linux-gnu",
@@ -117,6 +118,7 @@ These include general information about the node itself, as well as what protoco
 ## `admin_peers`
 
 Returns information about peers currently known to the node.
+For each peer, `id` is the keccak256 hash of the peer `enode` public key, encoded as 64 lowercase hex characters without a `0x` prefix.
 
 | Client | Method invocation              |
 | ------ | ------------------------------ |
@@ -128,7 +130,7 @@ Returns information about peers currently known to the node.
 // > {"jsonrpc":"2.0","id":1,"method":"admin_peers","params":[]}
 {"jsonrpc":"2.0","id":1,"result":[
   {
-    "id":"44826a5d6a55f88a18298bca4773fca...",
+    "id":"8915d6ec2f53ede650d5b9bea77d7756f177092171648ee1d8cbc550d334fa7a",
     "name":"reth/v0.0.1/x86_64-unknown-linux-gnu",
     "enode":"enode://44826a5d6a55f88a18298bca4773fca5749cdc3a5c9f308aa7d810e9b31123f3e7c5fba0b1d70aac5308426f47df2a128a6747040a3815cc7dd7167d03be320d@192.168.1.1:30303",
     "enr":"enr:-IS4QHCYr...",
@@ -190,7 +192,7 @@ The subscription emits events with the following structure:
         "result": {
             "type": "add", // or "drop", "error"
             "peer": {
-                "id": "44826a5d6a55f88a18298bca4773fca5749cdc3a5c9f308aa7d810e9b31123f3e7c5fba0b1d70aac5308426f47df2a128a6747040a3815cc7dd7167d03be320d",
+                "id": "8915d6ec2f53ede650d5b9bea77d7756f177092171648ee1d8cbc550d334fa7a",
                 "enode": "enode://44826a5d6a55f88a18298bca4773fca5749cdc3a5c9f308aa7d810e9b31123f3e7c5fba0b1d70aac5308426f47df2a128a6747040a3815cc7dd7167d03be320d@192.168.1.1:30303",
                 "addr": "192.168.1.1:30303"
             },
@@ -208,7 +210,7 @@ The subscription emits events with the following structure:
 {"jsonrpc": "2.0", "id": 1, "result": "0xcd0c3e8af590364c09d0fa6a1210faf5"}
 
 // Example event when a peer connects
-{"jsonrpc":"2.0","method":"admin_subscription","params":{"subscription":"0xcd0c3e8af590364c09d0fa6a1210faf5","result":{"type":"add","peer":{"id":"44826a5d6a55f88a18298bca4773fca5749cdc3a5c9f308aa7d810e9b31123f3e7c5fba0b1d70aac5308426f47df2a128a6747040a3815cc7dd7167d03be320d","enode":"enode://44826a5d6a55f88a18298bca4773fca5749cdc3a5c9f308aa7d810e9b31123f3e7c5fba0b1d70aac5308426f47df2a128a6747040a3815cc7dd7167d03be320d@192.168.1.1:30303","addr":"192.168.1.1:30303"}}}}
+{"jsonrpc":"2.0","method":"admin_subscription","params":{"subscription":"0xcd0c3e8af590364c09d0fa6a1210faf5","result":{"type":"add","peer":{"id":"8915d6ec2f53ede650d5b9bea77d7756f177092171648ee1d8cbc550d334fa7a","enode":"enode://44826a5d6a55f88a18298bca4773fca5749cdc3a5c9f308aa7d810e9b31123f3e7c5fba0b1d70aac5308426f47df2a128a6747040a3815cc7dd7167d03be320d@192.168.1.1:30303","addr":"192.168.1.1:30303"}}}}
 
 // Unsubscribe
 // > {"jsonrpc":"2.0","id":2,"method":"admin_peerEvents_unsubscribe","params":["0xcd0c3e8af590364c09d0fa6a1210faf5"]}
diff --git a/docs/vocs/docs/pages/jsonrpc/debug.mdx b/docs/vocs/docs/pages/jsonrpc/debug.mdx
index a6541267e17..4d65af843ab 100644
--- a/docs/vocs/docs/pages/jsonrpc/debug.mdx
+++ b/docs/vocs/docs/pages/jsonrpc/debug.mdx
@@ -139,6 +139,30 @@ Similar to [`debug_executionWitness`](#debug_executionwitness), but accepts a bl
 | ------ | ---------------------------------------------------------------------- |
 | RPC    | `{"method": "debug_executionWitnessByBlockHash", "params": [hash]}` |
 
+## `debug_intermediateRoots`
+
+Executes a block and returns a list of intermediate state roots: the state root after each transaction within the block. Accepts both canonical and non-canonical (bad or side) blocks by hash.
+
+| Client | Method invocation                                                   |
+| ------ | ------------------------------------------------------------------- |
+| RPC    | `{"method": "debug_intermediateRoots", "params": [block_hash]}` |
+
+## `debug_accountAt`
+
+Returns account information, including the storage root, after replaying a block through the transaction at the given index.
+
+| Client | Method invocation                                                   |
+| ------ | ------------------------------------------------------------------- |
+| RPC    | `{"method": "debug_accountAt", "params": [block_id, tx_index, address]}` |
+
+## `debug_accountInfoAt`
+
+Returns account information, including balance, nonce, and code, after replaying a block through the transaction at the given index. Unlike `debug_accountAt`, the response does not include the storage root.
+
+| Client | Method invocation                                                       |
+| ------ | ----------------------------------------------------------------------- |
+| RPC    | `{"method": "debug_accountInfoAt", "params": [block_id, tx_index, address]}` |
+
 ## `debug_dbGet`
 
 Retrieves a raw value from the database.
@@ -154,3 +178,19 @@ Returns the storage at the given block height and transaction index. The result
 | Client | Method invocation                                                                                 |
 | ------ | ------------------------------------------------------------------------------------------------- |
 | RPC    | `{"method": "debug_storageRangeAt", "params": [block_hash, tx_index, address, key_start, limit]}` |
+
+## `debug_chainConfig`
+
+Returns the chain's genesis configuration as a `ChainConfig` object. Useful for confirming the active network parameters (chain ID, hard fork block numbers and timestamps, consensus settings) without parsing the genesis file manually.
+
+| Client | Method invocation                                    |
+| ------ | ---------------------------------------------------- |
+| RPC    | `{"method": "debug_chainConfig", "params": []}` |
+
+## `debug_codeByHash`
+
+Returns the contract bytecode associated with the given code hash at the specified block. If no block identifier is provided it defaults to `latest`. Returns `null` when no bytecode is found for the hash.
+
+| Client | Method invocation                                                        |
+| ------ | ------------------------------------------------------------------------ |
+| RPC    | `{"method": "debug_codeByHash", "params": [code_hash, block]}` |
diff --git a/docs/vocs/docs/pages/run/ethereum.mdx b/docs/vocs/docs/pages/run/ethereum.mdx
index ced480171ae..c77e9be93ef 100644
--- a/docs/vocs/docs/pages/run/ethereum.mdx
+++ b/docs/vocs/docs/pages/run/ethereum.mdx
@@ -33,7 +33,7 @@ And to start the full node, run:
 reth node --full
 ```
 
-On differences between archive and full nodes, see [Pruning & Full Node](/run/faq/pruning#basic-concepts) section.
+On differences between archive and full nodes, see [Pruning & Node Modes](/run/storage/pruning#basic-concepts).
 
 :::note
 These commands will not open any HTTP/WS ports by default.
diff --git a/docs/vocs/docs/pages/run/ethereum/snapshots.mdx b/docs/vocs/docs/pages/run/ethereum/snapshots.mdx
deleted file mode 100644
index 116d4359e53..00000000000
--- a/docs/vocs/docs/pages/run/ethereum/snapshots.mdx
+++ /dev/null
@@ -1 +0,0 @@
-# Snapshots
\ No newline at end of file
diff --git a/docs/vocs/docs/pages/run/faq.mdx b/docs/vocs/docs/pages/run/faq.mdx
index 8779dba8d0e..945f7465dbc 100644
--- a/docs/vocs/docs/pages/run/faq.mdx
+++ b/docs/vocs/docs/pages/run/faq.mdx
@@ -1,9 +1,10 @@
 # FAQ
 
-1. [Transaction Types](/run/faq/transactions) - Learn about the transaction types supported by Reth.
+Storage layout, snapshots, minimal mode, and pruning now live in the
+[Storage](/run/storage) section.
 
-2. [Pruning & Full Node](/run/faq/pruning) - Understand the differences between archive nodes, full nodes, and pruned nodes. Learn how to configure pruning options and what RPC methods are available for each node type.
+1. [Transaction Types](/run/faq/transactions) - Learn about the transaction types supported by Reth.
 
-3. [Ports](/run/faq/ports) - Information about the network ports used by Reth for P2P communication, JSON-RPC APIs, and the Engine API for consensus layer communication.
+2. [Ports](/run/faq/ports) - Information about the network ports used by Reth for P2P communication, JSON-RPC APIs, and the Engine API for consensus layer communication.
 
-4. [Profiling](/run/faq/profiling) - Performance profiling techniques and tools for analyzing Reth node performance, including CPU profiling, memory analysis, and bottleneck identification.
+3. [Profiling](/run/faq/profiling) - Performance profiling techniques and tools for analyzing Reth node performance, including CPU profiling, memory analysis, and bottleneck identification.
diff --git a/docs/vocs/docs/pages/run/faq/storage-v2.mdx b/docs/vocs/docs/pages/run/faq/storage-v2.mdx
deleted file mode 100644
index ee219885b56..00000000000
--- a/docs/vocs/docs/pages/run/faq/storage-v2.mdx
+++ /dev/null
@@ -1,73 +0,0 @@
----
-description: Experimental hot/cold storage architecture in Reth v1.11.
----
-
-# Storage V2 (Experimental)
-
-:::warning
-`--storage.v2` is **experimental**. It is stable enough for testing and non-critical workloads,
-but may change in future releases. Please report issues on [GitHub](https://github.com/paradigmxyz/reth/issues)
-or in the [Telegram group](https://t.me/paradigm_reth).
-:::
-
-Reth v1.11 introduces an experimental hot/cold storage architecture behind the `--storage.v2` flag.
-It routes history indices and transaction hash lookups to RocksDB, writes changesets to static files,
-and drops the legacy plain state tables — resulting in significantly lower disk usage.
-
-## Disk savings
-
-Measured at block `24,396,823` on Ethereum mainnet:
-
-| Node Type | Without `--storage.v2` | With `--storage.v2` | Savings |
-| --------- | ---------------------- | ------------------- | ------- |
-| Full      | 1.46 TB                | 1.02 TB             | **-30%** |
-| Minimal   | 449 GB                 | 224 GB              | **-50%** |
-| Archive   | 2.99 TB                | 2.31 TB             | **-23%** |
-
-## Quick start
-
-### Fresh sync
-
-`--storage.v2` is a **genesis-initialization-only** setting. You must start a fresh sync — it cannot be enabled on an existing database.
-
-```bash
-reth node \
-    --storage.v2 \
-    --authrpc.jwtsecret /path/to/secret
-```
-
-Combine with other flags as usual (`--full`, `--minimal`, `--http`, etc.):
-
-```bash
-reth node \
-    --storage.v2 \
-    --full \
-    --http --http.api eth,trace \
-    --authrpc.jwtsecret /path/to/secret
-```
-
-### Using snapshots
-
-To avoid syncing from genesis, download a pre-built snapshot from
-[snapshots.reth.rs](https://snapshots.reth.rs) and start from there:
-
-```bash
-# Download and extract a v2 snapshot (see snapshots.reth.rs for available options)
-reth download --chain mainnet
-
-# Then start the node
-reth node \
-    --authrpc.jwtsecret /path/to/secret
-```
-
-## Important caveats
-
-- **Fresh sync required** — you cannot enable `--storage.v2` on an existing v1 database. If you have an existing node, you need to either resync from scratch or restore from a v2 snapshot.
-- **Cannot switch back** — once a database is initialized with `--storage.v2`, it stays that way. Switching back to v1 storage requires a full resync without the flag.
-- **Experimental** — the storage format may change between releases. Future upgrades could require a resync.
-
-## Further reading
-
-- [v1.11.0 release notes](https://github.com/paradigmxyz/reth/releases/tag/v1.11.0) — full details on storage v2 and other changes
-- [Pruning & Full Node](/run/faq/pruning) — configure pruning modes alongside storage v2
-- [Configuration](/run/configuration) — general node configuration reference
diff --git a/docs/vocs/docs/pages/run/overview.mdx b/docs/vocs/docs/pages/run/overview.mdx
index 5a9439cbf44..6d883daa773 100644
--- a/docs/vocs/docs/pages/run/overview.mdx
+++ b/docs/vocs/docs/pages/run/overview.mdx
@@ -20,6 +20,10 @@ Choose the network you want to run your node on:
 Learn how to configure and monitor your node:
 
 -   **[Configuration](/run/configuration)** - Configure your node using reth.toml
+-   **[Storage V2](/run/storage)** - Understand the default storage layout
+-   **[Snapshots](/run/storage/snapshots)** - Start from public modular snapshots
+-   **[Minimal Storage Mode](/run/storage/minimal)** - Run Reth with the smallest built-in storage profile
+-   **[Pruning & Node Modes](/run/storage/pruning)** - Choose archive, full, minimal, or custom-pruned storage
 -   **[Monitoring](/run/monitoring)** - Set up logs, metrics, and observability
 
 ## Frequently Asked Questions
@@ -27,7 +31,6 @@ Learn how to configure and monitor your node:
 Find answers to common questions and troubleshooting tips:
 
 -   **[Transaction Types](/run/faq/transactions)** - Understanding different transaction types
--   **[Pruning & Full Node](/run/faq/pruning)** - Storage management and node types
 -   **[Ports](/run/faq/ports)** - Network port configuration
 -   **[Profiling](/run/faq/profiling)** - Performance profiling and optimization
 
diff --git a/docs/vocs/docs/pages/run/storage.mdx b/docs/vocs/docs/pages/run/storage.mdx
new file mode 100644
index 00000000000..276a90f98cf
--- /dev/null
+++ b/docs/vocs/docs/pages/run/storage.mdx
@@ -0,0 +1,96 @@
+---
+description: Default hot/cold storage architecture in Reth.
+---
+
+# Storage V2
+
+Reth uses the V2 hot/cold storage layout by default for new databases. This
+layout routes history indices and transaction hash lookups to RocksDB, writes
+account and storage changesets to static files, and avoids the legacy plain
+state tables.
+
+For normal node operation, you do not need to pass `--storage.v2`; the default
+is already `true`.
+
+## Defaults
+
+-   New databases initialize with storage V2 by default.
+-   Existing databases keep the storage mode persisted in their metadata. The
+    `--storage.v2` flag does not rewrite an initialized data directory.
+-   Legacy V1 storage can still be requested for a new database with
+    `--storage.v2=false`.
+-   Existing V1 databases can be migrated with [`reth db migrate-v2`](/cli/reth/db/migrate-v2),
+    restored from a V2 snapshot, or resynced from scratch.
+
+## Disk savings
+
+Measured on disk at block `24,396,823` on Ethereum mainnet:
+
+| Node Type | Legacy V1 storage | V2 storage | Savings |
+| --------- | ----------------- | ---------- | ------- |
+| Full      | 1.46 TB           | 1.02 TB    | **-30%** |
+| Minimal   | 449 GB            | 224 GB     | **-50%** |
+| Archive   | 2.99 TB           | 2.31 TB    | **-23%** |
+
+Snapshot download sizes are compressed and change with each published snapshot.
+For current download sizes, use [snapshots.reth.rs](https://snapshots.reth.rs)
+or `reth download --list`.
+
+## Quick start
+
+### Fresh sync
+
+Start Reth normally. A new data directory uses storage V2 automatically:
+
+```bash
+reth node \
+    --authrpc.jwtsecret /path/to/secret
+```
+
+Combine storage V2 with node modes and RPC flags as usual:
+
+```bash
+reth node \
+    --full \
+    --http --http.api eth,trace \
+    --authrpc.jwtsecret /path/to/secret
+```
+
+Use [`--minimal`](/run/storage/minimal) when disk usage matters more than
+retaining older historical RPC data:
+
+```bash
+reth node \
+    --minimal \
+    --authrpc.jwtsecret /path/to/secret
+```
+
+### Using snapshots
+
+To avoid syncing from genesis, download a pre-built snapshot from
+[snapshots.reth.rs](https://snapshots.reth.rs) or the
+[`reth download`](/cli/reth/download) command:
+
+```bash
+reth download -y
+
+reth node \
+    --authrpc.jwtsecret /path/to/secret
+```
+
+## Operational notes
+
+-   Storage mode is selected when a database is initialized. After that, Reth
+    reads the mode from database metadata.
+-   If you need to opt out for a new database, pass `--storage.v2=false` before
+    the first run.
+-   Storage V2 and pruning are separate controls: storage V2 changes where data
+    is stored, while pruning decides how much historical data is retained.
+
+## Further reading
+
+-   [Snapshots](/run/storage/snapshots) - start from public modular snapshots
+-   [Minimal Storage Mode](/run/storage/minimal) - run Reth with the smallest built-in storage profile
+-   [Pruning & Node Modes](/run/storage/pruning) - choose archive, full, minimal, or custom pruning
+-   [Configuration](/run/configuration) - general node configuration reference
+-   [`reth node` CLI reference](/cli/reth/node) - current storage and pruning flags
diff --git a/docs/vocs/docs/pages/run/storage/minimal.mdx b/docs/vocs/docs/pages/run/storage/minimal.mdx
new file mode 100644
index 00000000000..30e34106ef3
--- /dev/null
+++ b/docs/vocs/docs/pages/run/storage/minimal.mdx
@@ -0,0 +1,64 @@
+---
+description: Run Reth with the smallest built-in storage profile.
+---
+
+# Minimal Storage Mode
+
+Minimal storage mode is Reth's smallest built-in node profile. It uses the
+default [storage V2 layout](/run/storage) with the most aggressive built-in
+pruning settings and smaller static file segments.
+
+Use `--minimal` when disk usage matters more than serving old historical RPC
+data.
+
+## Size
+
+Measured on disk at block `24,396,823` on Ethereum mainnet, minimal mode with
+storage V2 used `224 GB`, compared to `449 GB` with legacy V1 storage.
+
+The latest snapshot download size is compressed and changes as new snapshots
+are published. Check [snapshots.reth.rs](https://snapshots.reth.rs) or run
+`reth download --list` for the current compressed size.
+
+## Run a minimal node
+
+```bash
+reth node \
+    --minimal \
+    --authrpc.jwtsecret /path/to/secret \
+    --authrpc.addr 127.0.0.1 \
+    --authrpc.port 8551
+```
+
+## Retention profile
+
+| Data segment | Minimal mode behavior |
+| ------------ | --------------------- |
+| Sender recovery | Fully pruned |
+| Transaction lookup | Fully pruned |
+| Receipts | Retains the last 64 blocks |
+| Account history | Retains the last 10,064 blocks |
+| Storage history | Retains the last 10,064 blocks |
+| Block bodies | Retains the last 10,064 blocks |
+| Static files | Uses 10,000 blocks per file segment |
+
+## Trade-offs
+
+Minimal mode is suitable for nodes that need to follow the chain, serve recent
+state, and keep disk usage low. It is not suitable for workloads that require
+older transaction lookup, receipts, logs, traces, or historical state.
+
+For more detail on which RPC methods are affected by pruning, see
+[Pruning & Node Modes](/run/storage/pruning#rpc-support).
+
+## Snapshots
+
+To start from a [snapshot](/run/storage/snapshots) with the minimal component
+set:
+
+```bash
+reth download --chain mainnet --minimal
+
+reth node \
+    --authrpc.jwtsecret /path/to/secret
+```
diff --git a/docs/vocs/docs/pages/run/faq/pruning.mdx b/docs/vocs/docs/pages/run/storage/pruning.mdx
similarity index 80%
rename from docs/vocs/docs/pages/run/faq/pruning.mdx
rename to docs/vocs/docs/pages/run/storage/pruning.mdx
index 4aac4ff542e..e5a3117003a 100644
--- a/docs/vocs/docs/pages/run/faq/pruning.mdx
+++ b/docs/vocs/docs/pages/run/storage/pruning.mdx
@@ -1,48 +1,45 @@
 ---
-description: Pruning and full node options in Reth.
+description: Pruning and node modes in Reth.
 ---
 
-# Pruning & Full Node
+# Pruning & Node Modes
 
-:::info
-Pruning and full node are new features of Reth,
-and we will be happy to hear about your experience using them either
-on [GitHub](https://github.com/paradigmxyz/reth/issues) or in the [Telegram group](https://t.me/paradigm_reth).
-:::
+Reth supports archive, full, minimal, and custom-pruned nodes. Archive mode is
+the default when no pruning profile or pruning configuration is set.
 
-By default, Reth runs as an archive node. Such nodes have all historical blocks and the state at each of these blocks
-available for querying and tracing.
-
-Reth also supports pruning of historical data and running as a full node. This chapter will walk through
-the steps for running Reth as a full node, what caveats to expect and how to configure your own pruned node.
+For new databases, these modes run on the default [storage V2 layout](/run/storage).
+Storage V2 controls where data is stored; pruning controls how much historical
+data is retained.
 
 ## Basic concepts
 
--   Archive node – Reth node that has all historical data from genesis.
--   Pruned node – Reth node that has its historical data pruned partially or fully through
-    a [custom configuration](/run/configuration#the-prune-section).
--   Full Node – Reth node that has the latest state and historical data for only the last 10064 blocks available
-    for querying in the same way as an archive node.
+-   Archive node - retains all historical data from genesis.
+-   Full node - keeps current state and a 10,064-block historical state window,
+    while pruning selected historical data.
+-   Minimal node - uses the most aggressive built-in pruning profile for small
+    disk usage.
+-   Custom-pruned node - uses [custom pruning configuration](/run/configuration#the-prune-section)
+    or individual `--prune.*` flags.
 
-The node type that was chosen when first [running a node](/run/overview) **cannot** be changed after
-the initial sync. Turning Archive into Pruned, or Pruned into Full is not supported.
+Pruning is destructive. Once historical data has been pruned, Reth cannot serve
+that data again unless you restore it from a snapshot or resync with a mode that
+retains it.
 
 ## Modes
 
 ### Archive Node
 
-Default mode, follow the steps from the previous chapter on [how to run on mainnet or official testnets](/run/ethereum).
-
-### Pruned Node
+Archive mode is the default. Follow the steps from
+[Running Reth on Ethereum Mainnet or testnets](/run/ethereum) and start Reth
+without a pruning profile:
 
-To run Reth as a pruned node configured through a [custom configuration](/run/configuration#the-prune-section),
-modify the `reth.toml` file and run Reth in the same way as archive node by following the steps from
-the previous chapter on [how to run on mainnet or official testnets](/run/ethereum).
+```bash
+reth node
+```
 
 ### Full Node
 
-To run Reth as a full node, follow the steps from the previous chapter on
-[how to run on mainnet or official testnets](/run/ethereum), and add a `--full` flag. For example:
+Use `--full` to run the default full-node pruning profile:
 
 ```bash
 reth node \
@@ -52,10 +49,19 @@ reth node \
     --authrpc.port 8551
 ```
 
+Full mode configures:
+
+-   sender recovery pruning: full
+-   transaction lookup pruning: disabled
+-   receipts pruning: retain the last 10,064 blocks
+-   account history pruning: retain the last 10,064 blocks
+-   storage history pruning: retain the last 10,064 blocks
+-   bodies pruning: prune pre-Merge bodies on chains with a Paris activation
+
 ### Minimal Storage Mode
 
-To run Reth in minimal storage mode, follow the steps from the previous chapter on
-[how to run on mainnet or official testnets](/run/ethereum), and add a `--minimal` flag. For example:
+Use [`--minimal`](/run/storage/minimal) to run the most aggressive built-in
+pruning profile:
 
 ```bash
 reth node \
@@ -65,69 +71,31 @@ reth node \
     --authrpc.port 8551
 ```
 
-Minimal storage mode is a preconfigured pruned node profile that aims to minimize disk usage by fully
-pruning sender recovery, transaction lookup, and receipts, and by keeping only the last 10,064 blocks
-of account history, storage history, and block bodies with smaller static file segments.
-
-## Size
-
-All numbers are as of April 2024 at block number 19.6M for mainnet.
-
-### Archive Node
-
-Archive node occupies at least 2.14TB.
-
-You can track the growth of Reth archive node size with our
-[public Ethereum Grafana dashboard](https://reth.ithaca.xyz/public-dashboards/a49fa110dc9149298fa6763d5c89c8c0).
-[public Base Grafana dashboard](https://reth.ithaca.xyz/public-dashboards/b3e9f2e668ee4b86960b7fac691b5e64).
-
-### Pruned Node
-
-Different segments take up different amounts of disk space.
-If pruned fully, this is the total freed space you'll get, per segment:
+Minimal mode configures:
 
-| Segment            | Size  |
-| ------------------ | ----- |
-| Sender Recovery    | 85GB  |
-| Transaction Lookup | 200GB |
-| Receipts           | 250GB |
-| Account History    | 235GB |
-| Storage History    | 590GB |
+-   sender recovery pruning: full
+-   transaction lookup pruning: full
+-   receipts pruning: retain the last 64 blocks
+-   account history pruning: retain the last 10,064 blocks
+-   storage history pruning: retain the last 10,064 blocks
+-   bodies pruning: retain the last 10,064 blocks
+-   static file segments: 10,000 blocks per file
 
-### Full Node
+### Custom Pruned Node
 
-Full node occupies at least 1.13TB.
-
-Essentially, the full node is the same as following configuration for the pruned node:
-
-```toml
-[prune]
-block_interval = 5
-
-[prune.segments]
-sender_recovery = "full"
-# transaction_lookup is not pruned
-receipts = { before = 11052984 } # Beacon Deposit Contract deployment block: https://etherscan.io/tx/0xe75fb554e433e03763a1560646ee22dcb74e5274b34c5ad644e7c0f619a7e1d0
-account_history = { distance = 10_064 }
-storage_history = { distance = 10_064 }
-
-[prune.segments.receipts_log_filter]
-# Prune all receipts, leaving only those which contain logs from address `0x00000000219ab540356cbb839cbe05303d7705fa`,
-# starting from the block 11052984. This leaves receipts with the logs from the Beacon Deposit Contract.
-"0x00000000219ab540356cbb839cbe05303d7705fa" = { before = 11052984 }
-```
+Use `reth.toml` or individual `--prune.*` flags to configure each pruning
+segment yourself. See the [pruning configuration](/run/configuration#the-prune-section)
+reference for the TOML format.
 
-Meaning, it prunes:
+## Disk usage
 
--   Account History and Storage History up to the last 10064 blocks
--   All of Sender Recovery data. The caveat is that it's pruned gradually after the initial sync
-    is completed, so the disk space is reclaimed slowly.
--   Receipts up to the last 10064 blocks, preserving all receipts with the logs from Beacon Deposit Contract
+Disk usage changes as networks grow and depends on the selected node mode. For
+current storage V2 measurements, see [Storage V2](/run/storage#disk-savings).
 
 ## RPC support
 
-As it was mentioned in the [pruning configuration chapter](/run/configuration#the-prune-section), there are several segments which can be pruned
-independently of each other:
+The [pruning configuration](/run/configuration#the-prune-section) can prune
+several independent data segments:
 
 -   Sender Recovery
 -   Transaction Lookup
@@ -135,8 +103,8 @@ independently of each other:
 -   Account History
 -   Storage History
 
-Pruning of each of these segments disables different RPC methods, because the historical data or lookup indexes
-become unavailable.
+Pruning a segment limits RPC methods that need the removed historical data or
+lookup indexes.
 
 ### Full Node
 
@@ -146,6 +114,8 @@ The following tables describe RPC methods available in the full node.
 
 | RPC                                 | Note                                                       |
 | ----------------------------------- | ---------------------------------------------------------- |
+| `debug_accountAt`                   | Only for the last 10064 blocks                             |
+| `debug_accountInfoAt`               | Only for the last 10064 blocks                             |
 | `debug_chainConfig`                 |                                                            |
 | `debug_codeByHash`                  | Only for the last 10064 blocks                             |
 | `debug_dbGet`                       |                                                            |
@@ -154,7 +124,7 @@ The following tables describe RPC methods available in the full node.
 | `debug_getBadBlocks`                |                                                            |
 | `debug_getRawBlock`                 |                                                            |
 | `debug_getRawHeader`                |                                                            |
-| `debug_getRawReceipts`              | Only for the last 10064 blocks and Beacon Deposit Contract |
+| `debug_getRawReceipts`              | Only for the last 10064 blocks                             |
 | `debug_getRawTransaction`           |                                                            |
 | `debug_getRawTransactions`          |                                                            |
 | `debug_stateRootWithUpdates`        | Only for the last 10064 blocks                             |
@@ -180,19 +150,19 @@ The following tables describe RPC methods available in the full node.
 | `eth_getBalance`                          | Only for the last 10064 blocks                             |
 | `eth_getBlockByHash`                      |                                                            |
 | `eth_getBlockByNumber`                    |                                                            |
-| `eth_getBlockReceipts`                    | Only for the last 10064 blocks and Beacon Deposit Contract |
+| `eth_getBlockReceipts`                    | Only for the last 10064 blocks                             |
 | `eth_getBlockTransactionCountByHash`      |                                                            |
 | `eth_getBlockTransactionCountByNumber`    |                                                            |
 | `eth_getCode`                             |                                                            |
 | `eth_getFilterChanges`                    |                                                            |
-| `eth_getFilterLogs`                       | Only for the last 10064 blocks and Beacon Deposit Contract |
-| `eth_getLogs`                             | Only for the last 10064 blocks and Beacon Deposit Contract |
+| `eth_getFilterLogs`                       | Only for the last 10064 blocks                             |
+| `eth_getLogs`                             | Only for the last 10064 blocks                             |
 | `eth_getStorageAt`                        | Only for the last 10064 blocks                             |
 | `eth_getTransactionByBlockHashAndIndex`   |                                                            |
 | `eth_getTransactionByBlockNumberAndIndex` |                                                            |
 | `eth_getTransactionByHash`                |                                                            |
 | `eth_getTransactionCount`                 | Only for the last 10064 blocks                             |
-| `eth_getTransactionReceipt`               | Only for the last 10064 blocks and Beacon Deposit Contract |
+| `eth_getTransactionReceipt`               | Only for the last 10064 blocks                             |
 | `eth_getUncleByBlockHashAndIndex`         |                                                            |
 | `eth_getUncleByBlockNumberAndIndex`       |                                                            |
 | `eth_getUncleCountByBlockHash`            |                                                            |
@@ -257,6 +227,8 @@ The following tables describe the requirements for prune segments, per RPC metho
 
 | RPC / Segment                       | Sender Recovery | Transaction Lookup | Receipts | Account History | Storage History |
 | ----------------------------------- | --------------- | ------------------ | -------- | --------------- | --------------- |
+| `debug_accountAt`                   | ✅              | ✅                 | ✅       | ❌              | ❌              |
+| `debug_accountInfoAt`               | ✅              | ✅                 | ✅       | ❌              | ❌              |
 | `debug_chainConfig`                 | ✅              | ✅                 | ✅       | ✅              | ✅              |
 | `debug_codeByHash`                  | ✅              | ✅                 | ✅       | ❌              | ✅              |
 | `debug_dbGet`                       | ✅              | ✅                 | ✅       | ✅              | ✅              |
diff --git a/docs/vocs/docs/pages/run/storage/snapshots.mdx b/docs/vocs/docs/pages/run/storage/snapshots.mdx
new file mode 100644
index 00000000000..acf97fe00e8
--- /dev/null
+++ b/docs/vocs/docs/pages/run/storage/snapshots.mdx
@@ -0,0 +1,69 @@
+---
+description: Start Reth from public modular snapshots.
+---
+
+# Snapshots
+
+Reth publishes modular node snapshots at
+[snapshots.reth.rs](https://snapshots.reth.rs). The snapshot UI lets you choose
+minimal, full, or archive components and gives you the matching `reth download`
+command.
+
+Use snapshots when you want to avoid syncing from genesis. `reth download`
+extracts the selected components into your Reth data directory. It also writes
+`reth.toml` for the selected components if the file does not already exist;
+after extraction, start `reth node` normally.
+
+## Latest minimal snapshot
+
+For the default minimal component set:
+
+```bash
+reth download -y
+
+reth node
+```
+
+## Snapshot sizes
+
+Snapshot download sizes are compressed and change with the selected profile,
+selected components, and latest published block. The
+[snapshots.reth.rs](https://snapshots.reth.rs) UI shows the estimated download
+size for the current selection.
+
+You can also list snapshot sizes from the CLI:
+
+```bash
+reth download --list
+```
+
+## Choose a profile
+
+```bash
+# Smallest built-in profile
+reth download --minimal
+
+# Full-node profile
+reth download --full
+
+# Archive profile
+reth download --archive
+```
+
+## Custom components
+
+Use the website or `reth download` flags to include specific components, such
+as transaction files, receipts, state history, senders, or RocksDB indices:
+
+```bash
+reth download \
+    --with-txs-distance 100000 \
+    --with-receipts-distance 100000 \
+    -y
+```
+
+## Further reading
+
+-   [Storage V2](/run/storage) - understand the default storage layout
+-   [Minimal Storage Mode](/run/storage/minimal) - run the smallest built-in profile
+-   [`reth download` CLI reference](/cli/reth/download) - all snapshot download flags
diff --git a/docs/vocs/docs/styles.css b/docs/vocs/docs/styles.css
deleted file mode 100644
index fcfc8cf2cd6..00000000000
--- a/docs/vocs/docs/styles.css
+++ /dev/null
@@ -1,31 +0,0 @@
-@import "tailwindcss" important;
-
-@custom-variant dark (&:where(.dark, .dark *));
-
-[data-layout="landing"] .vocs_Button_button {
-  border-radius: 4px !important;
-  height: 36px !important;
-  padding: 0 16px !important;
-}
-
-[data-layout="landing"] .vocs_Content {
-  position: inherit;
-}
-
-#home-install .vocs_CodeGroup {
-  display: flex;
-  height: 100%;
-  flex-direction: column;
-}
-
-#home-install .vocs_Tabs_content {
-  flex: 1;
-}
-
-#home-install .vocs_Code {
-  font-size: 18px;
-}
-
-.border-accent {
-  border: 1px solid var(--vocs-color_borderAccent) !important;
-}
diff --git a/docs/vocs/package.json b/docs/vocs/package.json
index dbbc3858f4f..5c989c5dc0e 100644
--- a/docs/vocs/package.json
+++ b/docs/vocs/package.json
@@ -13,14 +13,18 @@
     "inject-cargo-docs": "bun scripts/inject-cargo-docs.ts"
   },
   "dependencies": {
-    "react": "^19.2.5",
-    "react-dom": "^19.2.5",
-    "vocs": "~1.0.13"
+    "mermaid": "^11",
+    "react": "19.2.6",
+    "react-dom": "19.2.6",
+    "react-server-dom-webpack": "19.2.6",
+    "vocs": "^2.0.11",
+    "waku": "1.0.0-beta.0"
   },
   "devDependencies": {
     "@types/node": "^24.12.2",
     "@types/react": "^19.2.14",
     "glob": "^11.1.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vite": "^8.0.16"
   }
-}
\ No newline at end of file
+}
diff --git a/docs/vocs/docs/public/alchemy.png b/docs/vocs/public/alchemy.png
similarity index 100%
rename from docs/vocs/docs/public/alchemy.png
rename to docs/vocs/public/alchemy.png
diff --git a/docs/vocs/docs/public/coinbase.png b/docs/vocs/public/coinbase.png
similarity index 100%
rename from docs/vocs/docs/public/coinbase.png
rename to docs/vocs/public/coinbase.png
diff --git a/docs/vocs/docs/public/flashbots.png b/docs/vocs/public/flashbots.png
similarity index 100%
rename from docs/vocs/docs/public/flashbots.png
rename to docs/vocs/public/flashbots.png
diff --git a/docs/vocs/docs/public/logo.png b/docs/vocs/public/logo.png
similarity index 100%
rename from docs/vocs/docs/public/logo.png
rename to docs/vocs/public/logo.png
diff --git a/docs/vocs/docs/public/remote_exex.png b/docs/vocs/public/remote_exex.png
similarity index 100%
rename from docs/vocs/docs/public/remote_exex.png
rename to docs/vocs/public/remote_exex.png
diff --git a/docs/vocs/docs/public/reth-prod.png b/docs/vocs/public/reth-prod.png
similarity index 100%
rename from docs/vocs/docs/public/reth-prod.png
rename to docs/vocs/public/reth-prod.png
diff --git a/docs/vocs/docs/public/succinct.png b/docs/vocs/public/succinct.png
similarity index 100%
rename from docs/vocs/docs/public/succinct.png
rename to docs/vocs/public/succinct.png
diff --git a/docs/vocs/redirects.config.ts b/docs/vocs/redirects.config.ts
index 33a924bc747..dc06e7edc9c 100644
--- a/docs/vocs/redirects.config.ts
+++ b/docs/vocs/redirects.config.ts
@@ -12,7 +12,13 @@ export const redirects: Record<string, string> = {
   '/run/observability': '/run/monitoring',
   '/run/config': '/run/configuration',
   '/run/transactions': '/run/faq/transactions',
-  '/run/pruning': '/run/faq/pruning',
+  '/run/snapshots': '/run/storage/snapshots',
+  '/run/ethereum/snapshots': '/run/storage/snapshots',
+  '/run/pruning': '/run/storage/pruning',
+  '/run/faq/pruning': '/run/storage/pruning',
+  '/run/storage-v2': '/run/storage',
+  '/run/faq/storage-v2': '/run/storage',
+  '/run/minimal': '/run/storage/minimal',
   '/run/ports': '/run/faq/ports',
   '/run/troubleshooting': '/run/faq/troubleshooting',
   // SDK
@@ -27,4 +33,4 @@ export const redirects: Record<string, string> = {
   '/developers/contribute': '/introduction/contributing',
 }
 
-export const basePath = '/';
\ No newline at end of file
+export const basePath = '/';
diff --git a/docs/vocs/scripts/build-cargo-docs.sh b/docs/vocs/scripts/build-cargo-docs.sh
index a1a8eeec0a7..634f4acf77b 100755
--- a/docs/vocs/scripts/build-cargo-docs.sh
+++ b/docs/vocs/scripts/build-cargo-docs.sh
@@ -1,4 +1,5 @@
 #!/bin/bash
+set -euo pipefail
 
 # Script to build cargo docs with the same flags as used in CI
 
@@ -9,6 +10,6 @@ echo "Building cargo docs..."
 
 # Build the documentation
 export RUSTDOCFLAGS="--cfg docsrs --show-type-layout --generate-link-to-definition --enable-index-page -Zunstable-options"
-cargo docs --exclude "example-*"
+cargo +nightly docs --exclude "example-*"
 
-echo "Cargo docs built successfully at ./target/doc"
\ No newline at end of file
+echo "Cargo docs built successfully at ./target/doc"
diff --git a/docs/vocs/scripts/fix-search-index.ts b/docs/vocs/scripts/fix-search-index.ts
index 99b53971f7b..f3f61f45c74 100644
--- a/docs/vocs/scripts/fix-search-index.ts
+++ b/docs/vocs/scripts/fix-search-index.ts
@@ -1,60 +1,123 @@
 #!/usr/bin/env bun
-import { readdir, copyFile, readFile, writeFile } from 'fs/promises';
+import { createHash } from 'crypto';
+import { mkdir, readdir, readFile, unlink, writeFile } from 'fs/promises';
 import { join } from 'path';
 
+type SearchIndex = {
+  documentIds?: Record<string, string>;
+  storedFields?: Record<string, { href?: unknown }>;
+  [key: string]: unknown;
+};
+
 async function fixSearchIndex() {
   const distDir = 'docs/dist';
-  const vocsDir = join(distDir, '.vocs');
+  const publicDir = join(distDir, 'public');
+  const publicAssetsDir = join(publicDir, 'assets');
   
   try {
-    // 1. Find the search index file
-    const files = await readdir(vocsDir);
-    const searchIndexFile = files.find(f => f.startsWith('search-index-') && f.endsWith('.json'));
-    
-    if (!searchIndexFile) {
-      console.error('❌ No search index file found in .vocs directory');
+    const source = await findSearchIndex(distDir, publicAssetsDir);
+    if (!source) {
+      console.error('No Vocs search index file found');
       process.exit(1);
       return;
     }
-    
-    console.log(`📁 Found search index: ${searchIndexFile}`);
-    
-    // 2. Copy search index to root of dist
-    const sourcePath = join(vocsDir, searchIndexFile);
-    const destPath = join(distDir, searchIndexFile);
-    await copyFile(sourcePath, destPath);
-    console.log(`✅ Copied search index to root: ${destPath}`);
-    
-    // 3. Find and update all HTML and JS files that reference the search index
-    const htmlFiles = await findFiles(distDir, '.html');
-    const jsFiles = await findFiles(distDir, '.js');
-    console.log(`📝 Found ${htmlFiles.length} HTML files and ${jsFiles.length} JS files to update`);
-    
-    // 4. Replace references in all files
+
+    console.log(`Found search index: ${join(source.dir, source.file)}`);
+
+    await mkdir(publicAssetsDir, { recursive: true });
+    const sourcePath = join(source.dir, source.file);
+    let jsonText = await readFile(sourcePath, 'utf-8');
+    const json = JSON.parse(jsonText) as SearchIndex;
+    const normalizedCount = normalizeDocumentIds(json);
+    jsonText = JSON.stringify(json);
+
+    const hash = createHash('md5').update(jsonText).digest('hex').slice(0, 12);
+    const searchIndexFile = `search-index-${hash}.json`;
+    const destPath = join(publicAssetsDir, searchIndexFile);
+    await writeFile(destPath, jsonText);
+    await removeStaleSearchIndexes(publicAssetsDir, searchIndexFile);
+
+    console.log(`Wrote public search index: ${destPath}`);
+    if (normalizedCount > 0) {
+      console.log(`Normalized ${normalizedCount} search result ids`);
+    }
+
+    const htmlFiles = await findFiles(publicDir, '.html');
+    const jsFiles = await findFiles(publicDir, '.js');
+    console.log(`Found ${htmlFiles.length} HTML files and ${jsFiles.length} JS files to update`);
+
     const allFiles = [...htmlFiles, ...jsFiles];
     for (const file of allFiles) {
       const content = await readFile(file, 'utf-8');
-      
-      // Replace /.vocs/search-index-*.json with /search-index-*.json
       const updatedContent = content.replace(
-        /\/.vocs\/search-index-[a-f0-9]+\.json/g,
-        `/${searchIndexFile}`
+        /\/(?:\.vocs|assets)\/search-index-[A-Za-z0-9_-]+\.json/g,
+        `/assets/${searchIndexFile}`
       );
       
       if (content !== updatedContent) {
         await writeFile(file, updatedContent);
-        console.log(`  ✓ Updated ${file}`);
+        console.log(`  Updated ${file}`);
       }
     }
     
-    console.log('✨ Search index fix complete!');
+    console.log('Search index fix complete!');
     
   } catch (error) {
-    console.error('❌ Error fixing search index:', error);
+    console.error('Error fixing search index:', error);
     process.exit(1);
   }
 }
 
+async function removeStaleSearchIndexes(publicAssetsDir: string, keepFile: string): Promise<void> {
+  const files = await readdir(publicAssetsDir);
+  await Promise.all(
+    files
+      .filter((file) => file.startsWith('search-index-') && file.endsWith('.json') && file !== keepFile)
+      .map((file) => unlink(join(publicAssetsDir, file))),
+  );
+}
+
+async function findSearchIndex(
+  distDir: string,
+  publicAssetsDir: string,
+): Promise<{ dir: string; file: string } | undefined> {
+  const candidateDirs = [
+    publicAssetsDir,
+    join(distDir, 'server', 'assets'),
+    join(distDir, '.vocs'),
+    join(distDir, 'assets'),
+  ];
+
+  for (const dir of candidateDirs) {
+    let files: string[];
+    try {
+      files = await readdir(dir);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') continue;
+      throw error;
+    }
+
+    const file = files.find((entry) => entry.startsWith('search-index-') && entry.endsWith('.json'));
+    if (file) return { dir, file };
+  }
+}
+
+function normalizeDocumentIds(searchIndex: SearchIndex): number {
+  const { documentIds, storedFields } = searchIndex;
+  if (!documentIds || !storedFields) return 0;
+
+  let normalizedCount = 0;
+  for (const [id, currentId] of Object.entries(documentIds)) {
+    const href = storedFields[id]?.href;
+    if (typeof href !== 'string' || href.length === 0 || currentId === href) continue;
+
+    documentIds[id] = href;
+    normalizedCount++;
+  }
+
+  return normalizedCount;
+}
+
 async function findFiles(dir: string, extension: string, files: string[] = []): Promise<string[]> {
   const { readdir } = await import('fs/promises');
   const entries = await readdir(dir, { withFileTypes: true });
@@ -62,8 +125,8 @@ async function findFiles(dir: string, extension: string, files: string[] = []):
   for (const entry of entries) {
     const fullPath = join(dir, entry.name);
     
-    // Skip .vocs, docs, and _site directories
-    if (entry.name === '.vocs' || entry.name === 'docs' || entry.name === '_site') continue;
+    // Skip injected rustdocs and internal build directories
+    if (entry.name === 'docs' || entry.name === '_site') continue;
     
     if (entry.isDirectory()) {
       files = await findFiles(fullPath, extension, files);
diff --git a/docs/vocs/scripts/generate-redirects.ts b/docs/vocs/scripts/generate-redirects.ts
index c56861a5a90..5738e633569 100644
--- a/docs/vocs/scripts/generate-redirects.ts
+++ b/docs/vocs/scripts/generate-redirects.ts
@@ -2,7 +2,8 @@
 import { writeFileSync, mkdirSync } from 'fs'
 import { join, dirname } from 'path'
 import { redirects, basePath } from '../redirects.config'
-// Base path for the site
+
+const DIST_DIR = './docs/dist/public'
 
 function generateRedirectHtml(targetPath: string): string {
   return `<!DOCTYPE html>
@@ -37,10 +38,10 @@ Object.entries(redirects).forEach(([from, to]) => {
   }
   
   paths.forEach(path => {
-    const filePath = join('./docs/dist', path)
+    const filePath = join(DIST_DIR, path)
     if (!path.includes('.')) {
       // It's a directory path, create index.html
-      const indexPath = join('./docs/dist', path, 'index.html')
+      const indexPath = join(DIST_DIR, path, 'index.html')
       mkdirSync(dirname(indexPath), { recursive: true })
       writeFileSync(indexPath, generateRedirectHtml(finalTarget))
     } else {
@@ -51,4 +52,4 @@ Object.entries(redirects).forEach(([from, to]) => {
   })
 })
 
-console.log('Redirects generated successfully!')
\ No newline at end of file
+console.log('Redirects generated successfully!')
diff --git a/docs/vocs/scripts/inject-cargo-docs.ts b/docs/vocs/scripts/inject-cargo-docs.ts
index 74857cb03e9..5a9d28b3195 100644
--- a/docs/vocs/scripts/inject-cargo-docs.ts
+++ b/docs/vocs/scripts/inject-cargo-docs.ts
@@ -2,7 +2,8 @@ import { promises as fs } from 'fs';
 import { glob } from 'glob';
 
 const CARGO_DOCS_PATH = '../../target/doc';
-const VOCS_DIST_PATH = './docs/dist/docs';
+const VOCS_DIST_ROOT = './docs/dist/public';
+const VOCS_DIST_PATH = `${VOCS_DIST_ROOT}/docs`;
 const BASE_PATH = '/docs';
 
 async function injectCargoDocs() {
@@ -19,7 +20,7 @@ async function injectCargoDocs() {
 
   // Check if Vocs dist exists
   try {
-    await fs.access('./docs/dist');
+    await fs.access(VOCS_DIST_ROOT);
   } catch {
     console.error('Error: Vocs dist not found. Please run: bun run build');
     process.exit(1);
@@ -43,7 +44,7 @@ async function injectCargoDocs() {
     // Extract the current crate name and module path from the file path
     // Remove the base path to get the relative path within the docs
     const relativePath = file.startsWith('./') ? file.slice(2) : file;
-    const docsRelativePath = relativePath.replace(/^docs\/dist\/docs\//, '');
+    const docsRelativePath = relativePath.replace(/^docs\/dist\/public\/docs\//, '');
     const pathParts = docsRelativePath.split('/');
     const fileName = pathParts[pathParts.length - 1];
     
@@ -210,4 +211,4 @@ async function injectCargoDocs() {
 }
 
 // Run the script
-injectCargoDocs().catch(console.error);
\ No newline at end of file
+injectCargoDocs().catch(console.error);
diff --git a/docs/vocs/sidebar-cli-reth.ts b/docs/vocs/sidebar-cli-reth.ts
index b4e875c8908..6ca212b10ea 100644
--- a/docs/vocs/sidebar-cli-reth.ts
+++ b/docs/vocs/sidebar-cli-reth.ts
@@ -1,4 +1,4 @@
-import { SidebarItem } from "vocs";
+import type { SidebarItem } from "./types";
 
 export const rethCliSidebar: SidebarItem = {
     text: "reth",
diff --git a/docs/vocs/sidebar.ts b/docs/vocs/sidebar.ts
index a52bcebddbd..37c5d56dee2 100644
--- a/docs/vocs/sidebar.ts
+++ b/docs/vocs/sidebar.ts
@@ -1,5 +1,6 @@
-import { SidebarItem } from "vocs";
 import { rethCliSidebar } from "./sidebar-cli-reth";
+import type { SidebarItem } from "./types";
+
 export const sidebar: SidebarItem[] = [
     {
         text: "Introduction",
@@ -73,12 +74,6 @@ export const sidebar: SidebarItem[] = [
                             {
                                 text: "Ethereum",
                                 link: "/run/ethereum",
-                                // items: [
-                                //     {
-                                //         text: "Snapshots",
-                                //         link: "/run/ethereum/snapshots"
-                                //     }
-                                // ]
                             },
                             {
                                 text: "Private testnets",
@@ -86,6 +81,27 @@ export const sidebar: SidebarItem[] = [
                             }
                         ]
                     },
+                    {
+                        text: "Storage",
+                        items: [
+                            {
+                                text: "Storage V2",
+                                link: "/run/storage"
+                            },
+                            {
+                                text: "Snapshots",
+                                link: "/run/storage/snapshots"
+                            },
+                            {
+                                text: "Minimal Storage Mode",
+                                link: "/run/storage/minimal"
+                            },
+                            {
+                                text: "Pruning & Node Modes",
+                                link: "/run/storage/pruning"
+                            }
+                        ]
+                    },
                 ]
             },
             {
@@ -105,14 +121,6 @@ export const sidebar: SidebarItem[] = [
                         text: "Transaction Types",
                         link: "/run/faq/transactions"
                     },
-                    {
-                        text: "Pruning & Full Node",
-                        link: "/run/faq/pruning"
-                    },
-                    {
-                        text: "Storage V2 (Experimental)",
-                        link: "/run/faq/storage-v2"
-                    },
                     {
                         text: "Ports",
                         link: "/run/faq/ports"
@@ -248,4 +256,4 @@ export const sidebar: SidebarItem[] = [
             rethCliSidebar
         ]
     },
-]
\ No newline at end of file
+]
diff --git a/docs/vocs/types.ts b/docs/vocs/types.ts
new file mode 100644
index 00000000000..7e530e56568
--- /dev/null
+++ b/docs/vocs/types.ts
@@ -0,0 +1,12 @@
+export type SidebarItem = {
+    badge?: string | {
+        text: string;
+        variant?: "note" | "info" | "warning" | "danger" | "tip" | "success";
+    };
+    collapsed?: boolean;
+    disabled?: boolean;
+    external?: boolean;
+    items?: SidebarItem[];
+    link?: string;
+    text?: string;
+};
diff --git a/docs/vocs/vocs.config.ts b/docs/vocs/vocs.config.ts
index 4a9090cd70d..0c905d62d3d 100644
--- a/docs/vocs/vocs.config.ts
+++ b/docs/vocs/vocs.config.ts
@@ -1,125 +1,82 @@
-import React from "react";
-import { defineConfig } from "vocs";
-import { sidebar } from "./sidebar";
-import { basePath } from "./redirects.config";
+import { defineConfig } from 'vocs/config'
+import { sidebar } from './sidebar'
+import { basePath } from './redirects.config'
 
 export default defineConfig({
-    title: "Reth",
-    description:
-        "Reth is a secure, performant, and modular Ethereum execution client built in Rust.",
-    logoUrl: "/logo.png",
-    iconUrl: "/logo.png",
-    ogImageUrl: "/reth-prod.png",
-    sidebar,
-    basePath,
-    search: {
-        fuzzy: true,
-    },
-    topNav: [
-        { text: "Run", link: "/run/ethereum" },
-        { text: "SDK", link: "/sdk" },
-        {
-            element: React.createElement(
-                "a",
-                { href: "/docs", target: "_self" },
-                "Rustdocs",
-            ),
-        },
-        { text: "GitHub", link: "https://github.com/paradigmxyz/reth" },
-        {
-            text: "v2.2.0",
-            items: [
-                {
-                    text: "Releases",
-                    link: "https://github.com/paradigmxyz/reth/releases",
-                },
-                {
-                    text: "Contributing",
-                    link: "https://github.com/paradigmxyz/reth/blob/main/CONTRIBUTING.md",
-                },
-            ],
-        },
-    ],
-    socials: [
+  title: 'Reth',
+  description: 'Reth is a secure, performant, and modular Ethereum execution client built in Rust.',
+  accentColor: 'light-dark(#1f1f1f, #ffffff)',
+  srcDir: 'docs',
+  logoUrl: '/logo.png',
+  iconUrl: '/logo.png',
+  ogImageUrl: '/reth-prod.png',
+  outDir: 'docs/dist',
+  renderStrategy: 'full-static',
+  sidebar,
+  basePath,
+  search: {
+    fuzzy: true
+  },
+  topNav: [
+    { text: 'Run', link: '/run/ethereum' },
+    { text: 'SDK', link: '/sdk' },
+    { text: 'Rustdocs', link: '/docs' },
+    { text: 'GitHub', link: 'https://github.com/paradigmxyz/reth' },
+    {
+      text: 'v2.3.0',
+      items: [
         {
-            icon: "github",
-            link: "https://github.com/paradigmxyz/reth",
+          text: 'Releases',
+          link: 'https://github.com/paradigmxyz/reth/releases'
         },
         {
-            icon: "telegram",
-            link: "https://t.me/paradigm_reth",
-        },
-    ],
-    sponsors: [
-        {
-            name: "Collaborators",
-            height: 120,
-            items: [
-                [
-                    {
-                        name: "Paradigm",
-                        link: "https://paradigm.xyz",
-                        image: "https://raw.githubusercontent.com/wevm/.github/main/content/sponsors/paradigm-light.svg",
-                    },
-                    {
-                        name: "Ithaca",
-                        link: "https://ithaca.xyz",
-                        image: "https://raw.githubusercontent.com/wevm/.github/main/content/sponsors/ithaca-light.svg",
-                    },
-                ],
-            ],
-        },
-    ],
-    theme: {
-        accentColor: {
-            light: "#1f1f1f",
-            dark: "#ffffff",
-        },
-    },
-    editLink: {
-        pattern:
-            "https://github.com/paradigmxyz/reth/edit/main/docs/vocs/docs/pages/:path",
+          text: 'Contributing',
+          link: 'https://github.com/paradigmxyz/reth/blob/main/CONTRIBUTING.md'
+        }
+      ]
+    }
+  ],
+  socials: [
+    {
+      icon: 'github',
+      link: 'https://github.com/paradigmxyz/reth',
     },
-    vite: {
-        plugins: [
-            {
-                name: "transform-summary-links",
-                apply: "serve", // only during dev for faster feedback
-                enforce: "pre",
-                async load(id) {
-                    if (
-                        id.endsWith("pages/cli/SUMMARY.mdx") ||
-                        id.endsWith("pages/cli/summary.mdx")
-                    ) {
-                        const { readFileSync } = await import("node:fs");
-                        let code = readFileSync(id, "utf-8");
-                        code = code.replace(
-                            /\]\(\.\/([^)]+)\.mdx\)/g,
-                            "](/cli/\$1)",
-                        );
-                        return code;
-                    }
-                },
-            },
-            {
-                name: "transform-summary-links-build",
-                apply: "build", // only apply during build
-                enforce: "pre",
-                async load(id) {
-                    if (
-                        id.endsWith("pages/cli/SUMMARY.mdx") ||
-                        id.endsWith("pages/cli/summary.mdx")
-                    ) {
-                        const { readFileSync } = await import("node:fs");
-                        let code = readFileSync(id, "utf-8");
-                        code = code.replace(
-                            /\]\(\.\/([^)]+)\.mdx\)/g,
-                            "](/cli/\$1)",
-                        );
-                        return code;
-                    }
-                },
-            },
-        ],
+    {
+      icon: 'telegram',
+      link: 'https://t.me/paradigm_reth',
     },
-});
+  ],
+  editLink: {
+    link: "https://github.com/paradigmxyz/reth/edit/main/docs/vocs/docs/pages/:path",
+  },
+  vite: {
+    plugins: [
+      {
+        name: 'transform-summary-links',
+        apply: 'serve', // only during dev for faster feedback
+        enforce: 'pre',
+        async load(id) {
+          if (id.endsWith('pages/cli/SUMMARY.mdx') || id.endsWith('pages/cli/summary.mdx')) {
+            const { readFileSync } = await import('node:fs')
+            let code = readFileSync(id, 'utf-8')
+            code = code.replace(/\]\(\.\/([^)]+)\.mdx\)/g, '](/cli/\$1)')
+            return code
+          }
+        }
+      },
+      {
+        name: 'transform-summary-links-build',
+        apply: 'build', // only apply during build
+        enforce: 'pre',
+        async load(id) {
+          if (id.endsWith('pages/cli/SUMMARY.mdx') || id.endsWith('pages/cli/summary.mdx')) {
+            const { readFileSync } = await import('node:fs')
+            let code = readFileSync(id, 'utf-8')
+            code = code.replace(/\]\(\.\/([^)]+)\.mdx\)/g, '](/cli/\$1)')
+            return code
+          }
+        }
+      }
+    ]
+  }
+})
diff --git a/etc/grafana/dashboards/overview.json b/etc/grafana/dashboards/overview.json
index 97e3e22521a..65aea889411 100644
--- a/etc/grafana/dashboards/overview.json
+++ b/etc/grafana/dashboards/overview.json
@@ -42,12 +42,6 @@
       "name": "Gauge",
       "version": ""
     },
-    {
-      "type": "grafana",
-      "id": "grafana",
-      "name": "Grafana",
-      "version": "12.2.1"
-    },
     {
       "type": "panel",
       "id": "heatmap",
@@ -60,12 +54,6 @@
       "name": "Pie chart",
       "version": ""
     },
-    {
-      "type": "datasource",
-      "id": "prometheus",
-      "name": "Prometheus",
-      "version": "1.0.0"
-    },
     {
       "type": "panel",
       "id": "stat",
@@ -83,6 +71,18 @@
       "id": "timeseries",
       "name": "Time series",
       "version": ""
+    },
+    {
+      "type": "grafana",
+      "id": "grafana",
+      "name": "Grafana",
+      "version": "13.1.0"
+    },
+    {
+      "type": "datasource",
+      "id": "prometheus",
+      "name": "Prometheus",
+      "version": "1.0.0"
     }
   ],
   "annotations": {
@@ -107,10 +107,25 @@
       }
     ]
   },
+  "description": "",
   "editable": true,
   "fiscalYearStartMonth": 0,
   "graphTooltip": 0,
-  "links": [],
+  "links": [
+    {
+      "asDropdown": false,
+      "icon": "external link",
+      "includeVars": false,
+      "keepTime": false,
+      "tags": [],
+      "targetBlank": true,
+      "title": "Source (GitHub)",
+      "tooltip": "View source file in repository",
+      "type": "link",
+      "url": "https://github.com/paradigmxyz/reth/tree/main/etc/grafana/dashboards"
+    }
+  ],
+  "liveNow": false,
   "panels": [
     {
       "collapsed": false,
@@ -120,8 +135,7 @@
         "x": 0,
         "y": 0
       },
-      "id": 96,
-      "panels": [],
+      "id": 1021,
       "repeat": "instance",
       "title": "Overview",
       "type": "row"
@@ -136,7 +150,6 @@
           "color": {
             "mode": "thresholds"
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -146,8 +159,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 3,
@@ -176,7 +188,7 @@
         "textMode": "name",
         "wideLayout": true
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24556818486",
       "targets": [
         {
           "datasource": {
@@ -206,7 +218,6 @@
           "color": {
             "mode": "thresholds"
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -216,8 +227,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 3,
@@ -246,7 +256,7 @@
         "textMode": "name",
         "wideLayout": true
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24556818486",
       "targets": [
         {
           "datasource": {
@@ -276,7 +286,6 @@
           "color": {
             "mode": "thresholds"
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -286,8 +295,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 3,
@@ -316,7 +324,7 @@
         "textMode": "name",
         "wideLayout": true
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24556818486",
       "targets": [
         {
           "datasource": {
@@ -346,7 +354,6 @@
           "color": {
             "mode": "thresholds"
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -356,8 +363,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 3,
@@ -386,7 +392,7 @@
         "textMode": "name",
         "wideLayout": true
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24556818486",
       "targets": [
         {
           "datasource": {
@@ -416,7 +422,6 @@
           "color": {
             "mode": "thresholds"
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -426,8 +431,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 3,
@@ -456,7 +460,7 @@
         "textMode": "name",
         "wideLayout": true
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24556818486",
       "targets": [
         {
           "datasource": {
@@ -486,7 +490,6 @@
           "color": {
             "mode": "thresholds"
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -496,8 +499,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 3,
@@ -526,7 +528,7 @@
         "textMode": "name",
         "wideLayout": true
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24556818486",
       "targets": [
         {
           "datasource": {
@@ -556,7 +558,6 @@
           "color": {
             "mode": "thresholds"
           },
-          "mappings": [],
           "max": 100,
           "min": 0,
           "thresholds": {
@@ -580,8 +581,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 9,
@@ -591,6 +591,14 @@
       },
       "id": 194,
       "options": {
+        "barShape": "flat",
+        "barWidthFactor": 0.5,
+        "effects": {
+          "barGlow": false,
+          "centerGlow": false,
+          "gradient": false
+        },
+        "endpointMarker": "point",
         "minVizHeight": 75,
         "minVizWidth": 75,
         "orientation": "auto",
@@ -601,11 +609,16 @@
           "fields": "",
           "values": false
         },
+        "segmentCount": 1,
+        "segmentSpacing": 0.3,
+        "shape": "gauge",
         "showThresholdLabels": false,
         "showThresholdMarkers": true,
-        "sizing": "auto"
+        "sizing": "auto",
+        "sparkline": false,
+        "textMode": "auto"
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24556818486",
       "targets": [
         {
           "datasource": {
@@ -636,7 +649,6 @@
           "color": {
             "mode": "continuous-RdYlGr"
           },
-          "mappings": [],
           "min": 0,
           "thresholds": {
             "mode": "absolute",
@@ -647,8 +659,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 9,
@@ -681,7 +692,7 @@
         "sizing": "auto",
         "valueMode": "color"
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24556818486",
       "targets": [
         {
           "datasource": {
@@ -745,7 +756,6 @@
           "color": {
             "mode": "thresholds"
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -756,8 +766,7 @@
             ]
           },
           "unit": "bytes"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 9,
@@ -783,7 +792,7 @@
         "textMode": "auto",
         "wideLayout": true
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24556818486",
       "targets": [
         {
           "datasource": {
@@ -893,7 +902,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "max": 1,
           "min": 0,
           "thresholds": {
@@ -906,8 +914,7 @@
             ]
           },
           "unit": "percentunit"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -917,6 +924,10 @@
       },
       "id": 69,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -929,7 +940,7 @@
           "sort": "none"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24251769778",
       "targets": [
         {
           "datasource": {
@@ -990,7 +1001,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -1004,8 +1014,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -1015,6 +1024,10 @@
       },
       "id": 12,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -1027,7 +1040,7 @@
           "sort": "none"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24251769778",
       "targets": [
         {
           "datasource": {
@@ -1089,7 +1102,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -1136,6 +1148,10 @@
       },
       "id": 211,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -1148,7 +1164,7 @@
           "sort": "none"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24251769778",
       "targets": [
         {
           "datasource": {
@@ -1274,7 +1290,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -1321,6 +1336,10 @@
       },
       "id": 210,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -1333,7 +1352,7 @@
           "sort": "none"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24251769778",
       "targets": [
         {
           "datasource": {
@@ -1459,7 +1478,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -1470,8 +1488,7 @@
             ]
           },
           "unit": "sishort"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -1481,6 +1498,10 @@
       },
       "id": 1004,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -1493,7 +1514,7 @@
           "sort": "none"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24251769778",
       "targets": [
         {
           "datasource": {
@@ -1588,7 +1609,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -1599,8 +1619,7 @@
             ]
           },
           "unit": "si: gas/s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -1610,6 +1629,10 @@
       },
       "id": 1003,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -1622,7 +1645,7 @@
           "sort": "none"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24251769778",
       "targets": [
         {
           "datasource": {
@@ -1717,7 +1740,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -1728,8 +1750,7 @@
             ]
           },
           "unit": "si: gas/s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -1902,7 +1923,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -1917,8 +1937,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -1986,8 +2005,7 @@
         "x": 0,
         "y": 45
       },
-      "id": 87,
-      "panels": [],
+      "id": 1022,
       "repeat": "instance",
       "title": "Engine API",
       "type": "row"
@@ -2037,7 +2055,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -2051,8 +2068,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -2147,7 +2163,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -2162,8 +2177,7 @@
             ]
           },
           "unit": "none"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -2258,7 +2272,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -2273,8 +2286,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -2358,7 +2370,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -2373,8 +2384,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -2596,7 +2606,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -2607,8 +2616,7 @@
             ]
           },
           "unit": "none"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -2702,7 +2710,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -2717,8 +2724,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -2866,7 +2872,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -2880,8 +2885,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -2964,7 +2968,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -2978,8 +2981,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -3026,8 +3028,7 @@
         "x": 0,
         "y": 78
       },
-      "id": 46,
-      "panels": [],
+      "id": 1023,
       "repeat": "instance",
       "title": "Execution",
       "type": "row"
@@ -3076,7 +3077,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -3091,8 +3091,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -3196,7 +3195,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -3211,8 +3209,7 @@
             ]
           },
           "unit": "percentunit"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -3333,7 +3330,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -3348,8 +3344,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -3437,7 +3432,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "max": 1,
           "thresholds": {
             "mode": "absolute",
@@ -3531,8 +3525,7 @@
         "x": 0,
         "y": 95
       },
-      "id": 214,
-      "panels": [],
+      "id": 1024,
       "title": "State Root Task",
       "type": "row"
     },
@@ -3581,7 +3574,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -3596,8 +3588,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 9,
@@ -3607,6 +3598,10 @@
       },
       "id": 1006,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -3619,7 +3614,7 @@
           "sort": "desc"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24556818486",
       "targets": [
         {
           "datasource": {
@@ -3682,7 +3677,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "min": 0,
           "thresholds": {
             "mode": "absolute",
@@ -3698,8 +3692,7 @@
             ]
           },
           "unit": "percentunit"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -3709,6 +3702,10 @@
       },
       "id": 255,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -3721,7 +3718,7 @@
           "sort": "none"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24556818486",
       "targets": [
         {
           "datasource": {
@@ -3784,7 +3781,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "min": 0,
           "thresholds": {
             "mode": "absolute",
@@ -3800,8 +3796,7 @@
             ]
           },
           "unit": "percentunit"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -3811,6 +3806,10 @@
       },
       "id": 1018,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -3823,7 +3822,7 @@
           "sort": "none"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24556818486",
       "targets": [
         {
           "datasource": {
@@ -3886,7 +3885,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -3901,8 +3899,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -3912,6 +3909,10 @@
       },
       "id": 257,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -3924,7 +3925,7 @@
           "sort": "desc"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24251769778",
       "targets": [
         {
           "datasource": {
@@ -3987,7 +3988,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -4002,8 +4002,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -4013,6 +4012,10 @@
       },
       "id": 256,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -4025,7 +4028,7 @@
           "sort": "desc"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24251769778",
       "targets": [
         {
           "datasource": {
@@ -4088,7 +4091,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -4103,8 +4105,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -4114,6 +4115,10 @@
       },
       "id": 1019,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -4126,7 +4131,7 @@
           "sort": "desc"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24251769778",
       "targets": [
         {
           "datasource": {
@@ -4189,7 +4194,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -4204,8 +4208,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -4215,6 +4218,10 @@
       },
       "id": 1020,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -4227,7 +4234,7 @@
           "sort": "desc"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24251769778",
       "targets": [
         {
           "datasource": {
@@ -4289,7 +4296,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -4304,8 +4310,7 @@
             ]
           },
           "unit": "none"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -4315,6 +4320,10 @@
       },
       "id": 260,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -4327,7 +4336,7 @@
           "sort": "desc"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24251769778",
       "targets": [
         {
           "datasource": {
@@ -4389,7 +4398,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -4404,8 +4412,7 @@
             ]
           },
           "unit": "none"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -4415,6 +4422,10 @@
       },
       "id": 259,
       "options": {
+        "annotations": {
+          "clustering": -1,
+          "multiLane": false
+        },
         "legend": {
           "calcs": [],
           "displayMode": "list",
@@ -4427,7 +4438,7 @@
           "sort": "desc"
         }
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "13.1.0-24251769778",
       "targets": [
         {
           "datasource": {
@@ -4453,8 +4464,7 @@
         "x": 0,
         "y": 129
       },
-      "id": 38,
-      "panels": [],
+      "id": 1025,
       "repeat": "instance",
       "title": "Database",
       "type": "row"
@@ -4505,7 +4515,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -4516,8 +4525,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -4576,8 +4584,7 @@
               "type": "linear"
             }
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -4607,7 +4614,7 @@
           "color": "rgba(255,0,255,0.7)"
         },
         "filterValues": {
-          "le": 1e-9
+          "le": 1e-09
         },
         "legend": {
           "show": true
@@ -4694,7 +4701,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -4705,8 +4711,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -4793,7 +4798,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -4804,8 +4808,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -4849,8 +4852,8 @@
     },
     {
       "datasource": {
-        "type": "prometheus",
-        "uid": "${datasource}"
+        "type": "mixed",
+        "uid": "-- Mixed --"
       },
       "fieldConfig": {
         "defaults": {
@@ -4894,7 +4897,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -5008,8 +5010,8 @@
     },
     {
       "datasource": {
-        "type": "prometheus",
-        "uid": "${datasource}"
+        "type": "mixed",
+        "uid": "-- Mixed --"
       },
       "fieldConfig": {
         "defaults": {
@@ -5053,7 +5055,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -5162,7 +5163,6 @@
             "uid": "${DS_EXPRESSION}"
           },
           "expression": "${A} - ${B}",
-          "hide": false,
           "refId": "Diff(opened, closed)",
           "type": "math"
         }
@@ -5188,10 +5188,8 @@
               "viz": false
             }
           },
-          "mappings": [],
           "unit": "bytes"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -5290,7 +5288,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -5305,8 +5302,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -5366,10 +5362,8 @@
               "viz": false
             }
           },
-          "mappings": [],
           "unit": "short"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -5465,7 +5459,6 @@
             }
           },
           "decimals": 4,
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -5480,8 +5473,7 @@
             ]
           },
           "unit": "bytes"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -5565,7 +5557,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -5580,8 +5571,7 @@
             ]
           },
           "unit": "none"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -5640,7 +5630,6 @@
             },
             "inspect": false
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -5785,8 +5774,7 @@
         "x": 0,
         "y": 178
       },
-      "id": 203,
-      "panels": [],
+      "id": 1026,
       "title": "Static Files",
       "type": "row"
     },
@@ -5808,10 +5796,8 @@
               "viz": false
             }
           },
-          "mappings": [],
           "unit": "bytes"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -5885,7 +5871,6 @@
             },
             "inspect": false
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -6030,7 +6015,6 @@
             },
             "inspect": false
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -6200,7 +6184,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -6215,8 +6198,7 @@
             ]
           },
           "unit": "bytes"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -6300,7 +6282,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -6315,8 +6296,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -6363,8 +6343,7 @@
         "x": 0,
         "y": 195
       },
-      "id": 1008,
-      "panels": [],
+      "id": 1027,
       "title": "RocksDB",
       "type": "row"
     },
@@ -6386,10 +6365,8 @@
               "viz": false
             }
           },
-          "mappings": [],
           "unit": "bytes"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -6470,7 +6447,6 @@
             },
             "inspect": false
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -6481,8 +6457,7 @@
             ]
           },
           "unit": "none"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -6559,8 +6534,8 @@
           "id": "organize",
           "options": {
             "renameByName": {
-              "table": "Table",
-              "Value (lastNotNull)": "Entries"
+              "Value (lastNotNull)": "Entries",
+              "table": "Table"
             }
           }
         }
@@ -6585,7 +6560,6 @@
             },
             "inspect": false
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -6596,8 +6570,7 @@
             ]
           },
           "unit": "decbytes"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -6674,8 +6647,8 @@
           "id": "organize",
           "options": {
             "renameByName": {
-              "table": "Table",
-              "Value (lastNotNull)": "Pending Bytes"
+              "Value (lastNotNull)": "Pending Bytes",
+              "table": "Table"
             }
           }
         }
@@ -6687,46 +6660,19 @@
         "type": "prometheus",
         "uid": "${datasource}"
       },
-      "description": "Total RocksDB size over time",
+      "description": "SST file size and memtable size per RocksDB table",
       "fieldConfig": {
         "defaults": {
           "color": {
-            "mode": "palette-classic"
+            "mode": "thresholds"
           },
           "custom": {
-            "axisBorderShow": false,
-            "axisCenteredZero": false,
-            "axisColorMode": "text",
-            "axisLabel": "",
-            "axisPlacement": "auto",
-            "barAlignment": 0,
-            "barWidthFactor": 0.6,
-            "drawStyle": "line",
-            "fillOpacity": 0,
-            "gradientMode": "none",
-            "hideFrom": {
-              "legend": false,
-              "tooltip": false,
-              "viz": false
-            },
-            "insertNulls": false,
-            "lineInterpolation": "linear",
-            "lineWidth": 1,
-            "pointSize": 5,
-            "scaleDistribution": {
-              "type": "linear"
-            },
-            "showPoints": "auto",
-            "spanNulls": false,
-            "stacking": {
-              "group": "A",
-              "mode": "none"
+            "align": "left",
+            "cellOptions": {
+              "type": "auto"
             },
-            "thresholdsStyle": {
-              "mode": "off"
-            }
+            "inspect": false
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -6736,31 +6682,29 @@
               }
             ]
           },
-          "unit": "bytes"
-        },
-        "overrides": []
+          "unit": "decbytes"
+        }
       },
       "gridPos": {
         "h": 8,
-        "w": 6,
-        "x": 12,
+        "w": 12,
+        "x": 0,
         "y": 204
       },
-      "id": 1012,
+      "id": 1017,
       "options": {
-        "legend": {
-          "calcs": [],
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
+        "cellHeight": "sm",
+        "footer": {
+          "countRows": false,
+          "fields": "",
+          "reducer": [
+            "sum"
+          ],
+          "show": false
         },
-        "tooltip": {
-          "hideZeros": false,
-          "mode": "single",
-          "sort": "none"
-        }
+        "showHeader": true
       },
-      "pluginVersion": "12.4.2",
+      "pluginVersion": "12.2.1",
       "targets": [
         {
           "datasource": {
@@ -6768,25 +6712,201 @@
             "uid": "${datasource}"
           },
           "editorMode": "code",
-          "expr": "sum by (job) ( reth_rocksdb_table_size{$instance_label=\"$instance\"} ) + (sum by (job) ( reth_rocksdb_wal_size{$instance_label=\"$instance\"} ) or vector(0))",
+          "expr": "reth_rocksdb_sst_size{$instance_label=\"$instance\"}",
+          "format": "table",
           "legendFormat": "__auto",
           "range": true,
           "refId": "A"
-        }
-      ],
-      "title": "RocksDB Growth",
-      "type": "timeseries"
-    },
-    {
-      "datasource": {
-        "type": "prometheus",
-        "uid": "${datasource}"
-      },
-      "description": "Pending compaction bytes over time",
-      "fieldConfig": {
-        "defaults": {
-          "color": {
-            "mode": "palette-classic"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "editorMode": "code",
+          "expr": "reth_rocksdb_memtable_size{$instance_label=\"$instance\"}",
+          "format": "table",
+          "legendFormat": "__auto",
+          "range": true,
+          "refId": "B"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "editorMode": "code",
+          "expr": "label_replace(reth_rocksdb_wal_size{$instance_label=\"$instance\"}, \"table\", \"WAL\", \"\", \"\")",
+          "format": "table",
+          "legendFormat": "__auto",
+          "range": true,
+          "refId": "C"
+        }
+      ],
+      "title": "RocksDB Storage Breakdown",
+      "transformations": [
+        {
+          "id": "merge",
+          "options": {}
+        },
+        {
+          "id": "groupBy",
+          "options": {
+            "fields": {
+              "Value #A": {
+                "aggregations": [
+                  "lastNotNull"
+                ],
+                "operation": "aggregate"
+              },
+              "Value #B": {
+                "aggregations": [
+                  "lastNotNull"
+                ],
+                "operation": "aggregate"
+              },
+              "Value #C": {
+                "aggregations": [
+                  "lastNotNull"
+                ],
+                "operation": "aggregate"
+              },
+              "table": {
+                "aggregations": [],
+                "operation": "groupby"
+              }
+            }
+          }
+        },
+        {
+          "id": "sortBy",
+          "options": {
+            "fields": {},
+            "sort": [
+              {
+                "desc": true,
+                "field": "Value #A (lastNotNull)"
+              }
+            ]
+          }
+        },
+        {
+          "id": "organize",
+          "options": {
+            "renameByName": {
+              "Value #A (lastNotNull)": "SST Size",
+              "Value #B (lastNotNull)": "Memtable Size",
+              "Value #C (lastNotNull)": "WAL Size",
+              "table": "Table"
+            }
+          }
+        }
+      ],
+      "type": "table"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "description": "Total RocksDB size over time",
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "barWidthFactor": 0.6,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "insertNulls": false,
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "bytes"
+        }
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 6,
+        "x": 12,
+        "y": 204
+      },
+      "id": 1012,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "hideZeros": false,
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "pluginVersion": "12.4.2",
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "editorMode": "code",
+          "expr": "sum by (job) ( reth_rocksdb_table_size{$instance_label=\"$instance\"} ) + (sum by (job) ( reth_rocksdb_wal_size{$instance_label=\"$instance\"} ) or vector(0))",
+          "legendFormat": "__auto",
+          "range": true,
+          "refId": "A"
+        }
+      ],
+      "title": "RocksDB Growth",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "description": "Pending compaction bytes over time",
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
           },
           "custom": {
             "axisBorderShow": false,
@@ -6822,7 +6942,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -6833,8 +6952,7 @@
             ]
           },
           "unit": "bytes"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -6881,8 +6999,7 @@
         "x": 0,
         "y": 212
       },
-      "id": 79,
-      "panels": [],
+      "id": 1028,
       "repeat": "instance",
       "title": "Blockchain Tree",
       "type": "row"
@@ -6932,7 +7049,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -6946,8 +7062,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -7031,7 +7146,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -7045,8 +7159,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -7129,7 +7242,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -7144,8 +7256,7 @@
             ]
           },
           "unit": "none"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -7229,7 +7340,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -7244,8 +7354,7 @@
             ]
           },
           "unit": "none"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -7293,8 +7402,7 @@
         "x": 0,
         "y": 229
       },
-      "id": 108,
-      "panels": [],
+      "id": 1029,
       "title": "RPC server",
       "type": "row"
     },
@@ -7342,7 +7450,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -7444,8 +7551,7 @@
               "type": "linear"
             }
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -7475,7 +7581,7 @@
           "color": "rgba(255,0,255,0.7)"
         },
         "filterValues": {
-          "le": 1e-9
+          "le": 1e-09
         },
         "legend": {
           "show": true
@@ -7560,7 +7666,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -7575,8 +7680,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -7633,8 +7737,7 @@
               "type": "linear"
             }
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -7664,7 +7767,7 @@
           "color": "rgba(255,0,255,0.7)"
         },
         "filterValues": {
-          "le": 1e-9
+          "le": 1e-09
         },
         "legend": {
           "show": true
@@ -7749,7 +7852,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -8001,7 +8103,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -8016,8 +8117,7 @@
             ]
           },
           "unit": "reqps"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -8065,8 +8165,7 @@
         "x": 0,
         "y": 254
       },
-      "id": 24,
-      "panels": [],
+      "id": 1030,
       "repeat": "instance",
       "title": "Downloader: Headers",
       "type": "row"
@@ -8115,7 +8214,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -8273,7 +8371,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -8288,8 +8385,7 @@
             ]
           },
           "unit": "cps"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -8395,7 +8491,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -8409,8 +8504,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -8468,8 +8562,7 @@
         "x": 0,
         "y": 271
       },
-      "id": 32,
-      "panels": [],
+      "id": 1031,
       "repeat": "instance",
       "title": "Downloader: Bodies",
       "type": "row"
@@ -8519,7 +8612,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -8718,7 +8810,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "min": 0,
           "thresholds": {
             "mode": "absolute",
@@ -8730,8 +8821,7 @@
             ]
           },
           "unit": "cps"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -8837,7 +8927,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -8851,8 +8940,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -8947,7 +9035,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -9075,7 +9162,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -9178,8 +9264,7 @@
         "x": 0,
         "y": 296
       },
-      "id": 226,
-      "panels": [],
+      "id": 1032,
       "title": "Eth Requests",
       "type": "row"
     },
@@ -9227,7 +9312,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -9357,7 +9441,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -9487,7 +9570,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -9617,7 +9699,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -9711,8 +9792,7 @@
         "x": 0,
         "y": 313
       },
-      "id": 68,
-      "panels": [],
+      "id": 1033,
       "repeat": "instance",
       "title": "Payload Builder",
       "type": "row"
@@ -9762,7 +9842,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -9776,8 +9855,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -9861,7 +9939,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -9875,8 +9952,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -9960,7 +10036,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -9974,8 +10049,7 @@
               }
             ]
           }
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -10022,8 +10096,7 @@
         "x": 0,
         "y": 330
       },
-      "id": 105,
-      "panels": [],
+      "id": 1034,
       "title": "Pruning",
       "type": "row"
     },
@@ -10071,7 +10144,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "min": 0,
           "thresholds": {
             "mode": "absolute",
@@ -10087,8 +10159,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -10172,7 +10243,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "min": 0,
           "thresholds": {
             "mode": "absolute",
@@ -10188,8 +10258,7 @@
             ]
           },
           "unit": "s"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -10273,7 +10342,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -10288,8 +10356,7 @@
             ]
           },
           "unit": "none"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -10338,8 +10405,7 @@
         "x": 0,
         "y": 347
       },
-      "id": 97,
-      "panels": [],
+      "id": 1035,
       "title": "Process",
       "type": "row"
     },
@@ -10387,7 +10453,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -10560,7 +10625,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -10575,8 +10639,7 @@
             ]
           },
           "unit": "decbytes"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -10661,7 +10724,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -10676,8 +10738,7 @@
             ]
           },
           "unit": "percentunit"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -10761,7 +10822,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -10776,8 +10836,7 @@
             ]
           },
           "unit": "none"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -10862,7 +10921,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -10877,8 +10935,7 @@
             ]
           },
           "unit": "tasks"
-        },
-        "overrides": []
+        }
       },
       "gridPos": {
         "h": 8,
@@ -10963,7 +11020,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -11094,7 +11150,6 @@
               "mode": "off"
             }
           },
-          "mappings": [],
           "thresholds": {
             "mode": "absolute",
             "steps": [
@@ -11188,7 +11243,7 @@
         "x": 0,
         "y": 380
       },
-      "id": 236,
+      "id": 1036,
       "panels": [
         {
           "datasource": {
@@ -11233,12 +11288,12 @@
                   "mode": "off"
                 }
               },
-              "mappings": [],
               "thresholds": {
                 "mode": "absolute",
                 "steps": [
                   {
-                    "color": "green"
+                    "color": "green",
+                    "value": null
                   },
                   {
                     "color": "red",
@@ -11246,14 +11301,13 @@
                   }
                 ]
               }
-            },
-            "overrides": []
+            }
           },
           "gridPos": {
             "h": 8,
             "w": 12,
             "x": 0,
-            "y": 387
+            "y": 381
           },
           "id": 237,
           "options": {
@@ -11328,12 +11382,12 @@
                   "mode": "off"
                 }
               },
-              "mappings": [],
               "thresholds": {
                 "mode": "absolute",
                 "steps": [
                   {
-                    "color": "green"
+                    "color": "green",
+                    "value": null
                   },
                   {
                     "color": "red",
@@ -11341,14 +11395,13 @@
                   }
                 ]
               }
-            },
-            "overrides": []
+            }
           },
           "gridPos": {
             "h": 8,
             "w": 12,
             "x": 12,
-            "y": 387
+            "y": 381
           },
           "id": 238,
           "options": {
@@ -11423,12 +11476,12 @@
                   "mode": "off"
                 }
               },
-              "mappings": [],
               "thresholds": {
                 "mode": "absolute",
                 "steps": [
                   {
-                    "color": "green"
+                    "color": "green",
+                    "value": null
                   },
                   {
                     "color": "red",
@@ -11436,14 +11489,13 @@
                   }
                 ]
               }
-            },
-            "overrides": []
+            }
           },
           "gridPos": {
             "h": 8,
             "w": 12,
             "x": 0,
-            "y": 395
+            "y": 389
           },
           "id": 239,
           "options": {
@@ -11529,12 +11581,12 @@
                   "mode": "off"
                 }
               },
-              "mappings": [],
               "thresholds": {
                 "mode": "absolute",
                 "steps": [
                   {
-                    "color": "green"
+                    "color": "green",
+                    "value": null
                   },
                   {
                     "color": "red",
@@ -11542,14 +11594,13 @@
                   }
                 ]
               }
-            },
-            "overrides": []
+            }
           },
           "gridPos": {
             "h": 8,
             "w": 12,
             "x": 12,
-            "y": 395
+            "y": 389
           },
           "id": 219,
           "options": {
@@ -11592,12 +11643,12 @@
               "color": {
                 "mode": "palette-classic"
               },
-              "mappings": [],
               "thresholds": {
                 "mode": "absolute",
                 "steps": [
                   {
-                    "color": "green"
+                    "color": "green",
+                    "value": null
                   },
                   {
                     "color": "red",
@@ -11606,14 +11657,13 @@
                 ]
               },
               "unit": "none"
-            },
-            "overrides": []
+            }
           },
           "gridPos": {
             "h": 8,
             "w": 12,
             "x": 0,
-            "y": 403
+            "y": 397
           },
           "id": 220,
           "options": {
@@ -11662,7 +11712,7 @@
         "x": 0,
         "y": 381
       },
-      "id": 241,
+      "id": 1037,
       "panels": [
         {
           "datasource": {
@@ -11706,13 +11756,12 @@
                   "mode": "off"
                 }
               },
-              "fieldMinMax": false,
-              "mappings": [],
               "thresholds": {
                 "mode": "absolute",
                 "steps": [
                   {
-                    "color": "green"
+                    "color": "green",
+                    "value": null
                   },
                   {
                     "color": "red",
@@ -11720,14 +11769,13 @@
                   }
                 ]
               }
-            },
-            "overrides": []
+            }
           },
           "gridPos": {
             "h": 8,
             "w": 12,
             "x": 0,
-            "y": 388
+            "y": 382
           },
           "id": 243,
           "options": {
@@ -11814,13 +11862,12 @@
                   "mode": "off"
                 }
               },
-              "fieldMinMax": false,
-              "mappings": [],
               "thresholds": {
                 "mode": "absolute",
                 "steps": [
                   {
-                    "color": "green"
+                    "color": "green",
+                    "value": null
                   },
                   {
                     "color": "red",
@@ -11828,14 +11875,13 @@
                   }
                 ]
               }
-            },
-            "overrides": []
+            }
           },
           "gridPos": {
             "h": 8,
             "w": 12,
             "x": 12,
-            "y": 388
+            "y": 382
           },
           "id": 244,
           "options": {
@@ -11922,13 +11968,12 @@
                   "mode": "off"
                 }
               },
-              "fieldMinMax": false,
-              "mappings": [],
               "thresholds": {
                 "mode": "absolute",
                 "steps": [
                   {
-                    "color": "green"
+                    "color": "green",
+                    "value": null
                   },
                   {
                     "color": "red",
@@ -11937,14 +11982,13 @@
                 ]
               },
               "unit": "bytes"
-            },
-            "overrides": []
+            }
           },
           "gridPos": {
             "h": 8,
             "w": 12,
             "x": 0,
-            "y": 396
+            "y": 390
           },
           "id": 245,
           "options": {
@@ -11980,162 +12024,14 @@
       ],
       "title": "Execution Extensions Write-Ahead Log",
       "type": "row"
-    },
-    {
-      "datasource": {
-        "type": "prometheus",
-        "uid": "${datasource}"
-      },
-      "description": "SST file size and memtable size per RocksDB table",
-      "fieldConfig": {
-        "defaults": {
-          "color": {
-            "mode": "thresholds"
-          },
-          "custom": {
-            "align": "left",
-            "cellOptions": {
-              "type": "auto"
-            },
-            "inspect": false
-          },
-          "mappings": [],
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "green",
-                "value": null
-              }
-            ]
-          },
-          "unit": "decbytes"
-        },
-        "overrides": []
-      },
-      "gridPos": {
-        "h": 8,
-        "w": 12,
-        "x": 0,
-        "y": 211
-      },
-      "id": 1017,
-      "options": {
-        "cellHeight": "sm",
-        "footer": {
-          "countRows": false,
-          "fields": "",
-          "reducer": [
-            "sum"
-          ],
-          "show": false
-        },
-        "showHeader": true
-      },
-      "pluginVersion": "12.2.1",
-      "targets": [
-        {
-          "datasource": {
-            "type": "prometheus",
-            "uid": "${datasource}"
-          },
-          "editorMode": "code",
-          "expr": "reth_rocksdb_sst_size{$instance_label=\"$instance\"}",
-          "format": "table",
-          "legendFormat": "__auto",
-          "range": true,
-          "refId": "A"
-        },
-        {
-          "datasource": {
-            "type": "prometheus",
-            "uid": "${datasource}"
-          },
-          "editorMode": "code",
-          "expr": "reth_rocksdb_memtable_size{$instance_label=\"$instance\"}",
-          "format": "table",
-          "legendFormat": "__auto",
-          "range": true,
-          "refId": "B"
-        },
-        {
-          "datasource": {
-            "type": "prometheus",
-            "uid": "${datasource}"
-          },
-          "editorMode": "code",
-          "expr": "label_replace(reth_rocksdb_wal_size{$instance_label=\"$instance\"}, \"table\", \"WAL\", \"\", \"\")",
-          "format": "table",
-          "legendFormat": "__auto",
-          "range": true,
-          "refId": "C"
-        }
-      ],
-      "transformations": [
-        {
-          "id": "merge",
-          "options": {}
-        },
-        {
-          "id": "groupBy",
-          "options": {
-            "fields": {
-              "Value #A": {
-                "aggregations": [
-                  "lastNotNull"
-                ],
-                "operation": "aggregate"
-              },
-              "Value #B": {
-                "aggregations": [
-                  "lastNotNull"
-                ],
-                "operation": "aggregate"
-              },
-              "Value #C": {
-                "aggregations": [
-                  "lastNotNull"
-                ],
-                "operation": "aggregate"
-              },
-              "table": {
-                "aggregations": [],
-                "operation": "groupby"
-              }
-            }
-          }
-        },
-        {
-          "id": "sortBy",
-          "options": {
-            "fields": {},
-            "sort": [
-              {
-                "desc": true,
-                "field": "Value #A (lastNotNull)"
-              }
-            ]
-          }
-        },
-        {
-          "id": "organize",
-          "options": {
-            "renameByName": {
-              "table": "Table",
-              "Value #A (lastNotNull)": "SST Size",
-              "Value #B (lastNotNull)": "Memtable Size",
-              "Value #C (lastNotNull)": "WAL Size"
-            }
-          }
-        }
-      ],
-      "title": "RocksDB Storage Breakdown",
-      "type": "table"
     }
   ],
-  "refresh": "5s",
+  "preload": false,
+  "refresh": "30s",
   "schemaVersion": 42,
-  "tags": [],
+  "tags": [
+    "reth"
+  ],
   "templating": {
     "list": [
       {
@@ -12171,17 +12067,17 @@
         "type": "datasource"
       },
       {
+        "current": {
+          "value": "${VAR_INSTANCE_LABEL}",
+          "text": "${VAR_INSTANCE_LABEL}",
+          "selected": false
+        },
         "hide": 2,
         "label": "Instance Label",
         "name": "instance_label",
         "query": "${VAR_INSTANCE_LABEL}",
         "skipUrlSync": true,
         "type": "constant",
-        "current": {
-          "value": "${VAR_INSTANCE_LABEL}",
-          "text": "${VAR_INSTANCE_LABEL}",
-          "selected": false
-        },
         "options": [
           {
             "value": "${VAR_INSTANCE_LABEL}",
@@ -12196,10 +12092,22 @@
     "from": "now-12h",
     "to": "now"
   },
-  "timepicker": {},
-  "timezone": "",
+  "timepicker": {
+    "refresh_intervals": [
+      "5s",
+      "10s",
+      "30s",
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ]
+  },
+  "timezone": "browser",
   "title": "Reth",
   "uid": "2k8BXz24x",
-  "version": 9,
-  "weekStart": ""
+  "version": 8
 }
diff --git a/examples/beacon-api-sidecar-fetcher/src/mined_sidecar.rs b/examples/beacon-api-sidecar-fetcher/src/mined_sidecar.rs
index 47c8b8bd30a..5ebf273a404 100644
--- a/examples/beacon-api-sidecar-fetcher/src/mined_sidecar.rs
+++ b/examples/beacon-api-sidecar-fetcher/src/mined_sidecar.rs
@@ -188,13 +188,13 @@ where
                 {
                     match notification {
                         CanonStateNotification::Commit { new } => {
-                            for (_, block) in new.blocks().iter() {
+                            for block in new.blocks().values() {
                                 this.process_block(block);
                             }
                         }
                         CanonStateNotification::Reorg { old, new } => {
                             // handle reorged blocks
-                            for (_, block) in old.blocks().iter() {
+                            for block in old.blocks().values() {
                                 let txs: Vec<BlobTransactionEvent> = block
                                     .body()
                                     .transactions()
@@ -215,7 +215,7 @@ where
                                 this.queued_actions.extend(txs);
                             }
 
-                            for (_, block) in new.blocks().iter() {
+                            for block in new.blocks().values() {
                                 this.process_block(block);
                             }
                         }
diff --git a/examples/bsc-p2p/src/block_import/service.rs b/examples/bsc-p2p/src/block_import/service.rs
index 4e4029d7e95..2b37fcdce00 100644
--- a/examples/bsc-p2p/src/block_import/service.rs
+++ b/examples/bsc-p2p/src/block_import/service.rs
@@ -93,7 +93,7 @@ where
 
         Box::pin(async move {
             let sealed_block = block.block.block.clone().seal();
-            let payload = T::block_to_payload(sealed_block);
+            let payload = T::block_to_payload(sealed_block, None);
 
             match engine.new_payload(payload).await {
                 Ok(payload_status) => match payload_status.status {
diff --git a/examples/custom-beacon-withdrawals/src/main.rs b/examples/custom-beacon-withdrawals/src/main.rs
index 2e7d66d466b..efd6b0e5d97 100644
--- a/examples/custom-beacon-withdrawals/src/main.rs
+++ b/examples/custom-beacon-withdrawals/src/main.rs
@@ -20,7 +20,6 @@ use reth_ethereum::{
             block::StateDB,
             execute::{BlockExecutionError, BlockExecutor, InternalBlockExecutionError},
             Evm, EvmEnv, EvmEnvFor, ExecutionCtxFor, InspectorFor, NextBlockEnvAttributes,
-            OnStateHook,
         },
         revm::{
             context::TxEnv,
@@ -227,10 +226,6 @@ where
         self.inner.finish()
     }
 
-    fn set_state_hook(&mut self, _hook: Option<Box<dyn OnStateHook>>) {
-        self.inner.set_state_hook(_hook)
-    }
-
     fn evm_mut(&mut self) -> &mut Self::Evm {
         self.inner.evm_mut()
     }
diff --git a/examples/custom-engine-types/src/main.rs b/examples/custom-engine-types/src/main.rs
index 1d94be5b059..1d8ca06d744 100644
--- a/examples/custom-engine-types/src/main.rs
+++ b/examples/custom-engine-types/src/main.rs
@@ -18,7 +18,7 @@
 #![warn(unused_crate_dependencies)]
 
 use alloy_genesis::Genesis;
-use alloy_primitives::B256;
+use alloy_primitives::{Bytes, B256};
 use alloy_rpc_types::{
     engine::{
         ExecutionData, ExecutionPayloadEnvelopeV2, ExecutionPayloadEnvelopeV3,
@@ -101,6 +101,10 @@ impl PayloadAttributes for CustomPayloadAttributes {
     fn slot_number(&self) -> Option<u64> {
         self.inner.slot_number()
     }
+
+    fn target_gas_limit(&self) -> Option<u64> {
+        self.inner.target_gas_limit()
+    }
 }
 
 /// Custom engine types - uses a custom payload attributes RPC type, but uses the default
@@ -118,6 +122,7 @@ impl PayloadTypes for CustomEngineTypes {
         block: SealedBlock<
                 <<Self::BuiltPayload as reth_ethereum::node::api::BuiltPayload>::Primitives as reth_ethereum::node::api::NodePrimitives>::Block,
             >,
+        _bal: Option<Bytes>,
     ) -> ExecutionData {
         let (payload, sidecar) =
             ExecutionPayload::from_block_unchecked(block.hash(), &block.into_block());
@@ -338,7 +343,7 @@ where
             cancel,
             best_payload,
         } = args;
-        let PayloadConfig { parent_header, attributes, payload_id } = config;
+        let PayloadConfig { parent_header, parent_block_info, attributes, payload_id } = config;
 
         // This reuses the default EthereumPayloadBuilder to build the payload
         // but any custom logic can be implemented here
@@ -346,7 +351,12 @@ where
             cached_reads,
             execution_cache,
             trie_handle,
-            config: PayloadConfig { parent_header, attributes: attributes.inner, payload_id },
+            config: PayloadConfig {
+                parent_header,
+                parent_block_info,
+                attributes: attributes.inner,
+                payload_id,
+            },
             cancel,
             best_payload,
         })
@@ -356,9 +366,10 @@ where
         &self,
         config: PayloadConfig<Self::Attributes>,
     ) -> Result<Self::BuiltPayload, PayloadBuilderError> {
-        let PayloadConfig { parent_header, attributes, payload_id } = config;
+        let PayloadConfig { parent_header, parent_block_info, attributes, payload_id } = config;
         self.inner.build_empty_payload(PayloadConfig {
             parent_header,
+            parent_block_info,
             attributes: attributes.inner,
             payload_id,
         })
diff --git a/examples/custom-evm/src/main.rs b/examples/custom-evm/src/main.rs
index abcfaf80fda..97f014f99ea 100644
--- a/examples/custom-evm/src/main.rs
+++ b/examples/custom-evm/src/main.rs
@@ -6,6 +6,7 @@ use alloy_evm::{
     eth::EthEvmContext,
     precompiles::PrecompilesMap,
     revm::{
+        context::DBErrorMarker,
         handler::EthPrecompiles,
         precompile::{Precompile, PrecompileId},
     },
@@ -50,7 +51,7 @@ impl EvmFactory for MyEvmFactory {
     type Evm<DB: Database, I: Inspector<EthEvmContext<DB>, EthInterpreter>> =
         EthEvm<DB, I, Self::Precompiles>;
     type Tx = TxEnv;
-    type Error<DBError: core::error::Error + Send + Sync + 'static> = EVMError<DBError>;
+    type Error<DBError: DBErrorMarker> = EVMError<DBError>;
     type HaltReason = HaltReason;
     type Context<DB: Database> = EthEvmContext<DB>;
     type Spec = SpecId;
diff --git a/examples/custom-state-root/Cargo.toml b/examples/custom-state-root/Cargo.toml
new file mode 100644
index 00000000000..0116e5b5a28
--- /dev/null
+++ b/examples/custom-state-root/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "example-custom-state-root"
+version = "0.0.0"
+publish = false
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+reth-ethereum = { workspace = true, features = ["node", "test-utils"] }
+reth-engine-tree.workspace = true
+reth-trie.workspace = true
+
+eyre.workspace = true
+tokio.workspace = true
+serde_json.workspace = true
+
+alloy-genesis.workspace = true
+alloy-primitives.workspace = true
+alloy-network.workspace = true
+alloy-rpc-types-engine.workspace = true
diff --git a/examples/custom-state-root/src/main.rs b/examples/custom-state-root/src/main.rs
new file mode 100644
index 00000000000..d9c091bcce6
--- /dev/null
+++ b/examples/custom-state-root/src/main.rs
@@ -0,0 +1,169 @@
+//! Example: Running a reth node with a custom state root strategy.
+//!
+//! This demonstrates how to use the [`CustomStateRoot`] hook to override state
+//! root computation. The example always returns `B256::ZERO` as the state root.
+//!
+//! The key integration point is wrapping [`BasicEngineValidatorBuilder`] to call
+//! [`BasicEngineValidator::with_custom_state_root`] on the resulting validator.
+//!
+//! # Usage
+//!
+//! ```sh
+//! cargo run -p example-custom-state-root -- node --dev --http
+//! ```
+
+#![warn(unused_crate_dependencies)]
+
+use std::sync::Arc;
+
+use alloy_genesis::Genesis;
+use alloy_primitives::B256;
+use reth_engine_tree::tree::{payload_validator::CustomStateRoot, BasicEngineValidator};
+use reth_ethereum::{
+    chainspec::ChainSpec,
+    node::{
+        builder::{
+            rpc::{
+                BasicEngineApiBuilder, BasicEngineValidatorBuilder, ChangesetCache,
+                EngineValidatorBuilder, Identity, RpcAddOns,
+            },
+            FullNodeComponents, NodeBuilder, NodeHandle, TreeConfig,
+        },
+        core::{args::RpcServerArgs, node_config::NodeConfig},
+        EthereumAddOns, EthereumEngineValidatorBuilder, EthereumEthApiBuilder, EthereumNode,
+    },
+    tasks::Runtime,
+    EthPrimitives,
+};
+use reth_trie::updates::TrieUpdates;
+
+// ---------------------------------------------------------------------------
+// Custom Engine Validator Builder
+// ---------------------------------------------------------------------------
+
+/// An [`EngineValidatorBuilder`] that wraps [`BasicEngineValidatorBuilder`] and
+/// installs a [`CustomStateRoot`] on the resulting [`BasicEngineValidator`].
+#[derive(Clone)]
+struct ZeroStateRootValidatorBuilder {
+    inner: BasicEngineValidatorBuilder<EthereumEngineValidatorBuilder>,
+    custom_state_root: CustomStateRoot<EthPrimitives>,
+}
+
+impl std::fmt::Debug for ZeroStateRootValidatorBuilder {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ZeroStateRootValidatorBuilder")
+            .field("inner", &self.inner)
+            .finish_non_exhaustive()
+    }
+}
+
+impl<N> EngineValidatorBuilder<N> for ZeroStateRootValidatorBuilder
+where
+    N: FullNodeComponents<
+        Types = EthereumNode,
+        Evm: reth_ethereum::node::builder::ConfigureEngineEvm<
+            alloy_rpc_types_engine::ExecutionData,
+        >,
+    >,
+{
+    type EngineValidator = BasicEngineValidator<
+        N::Provider,
+        N::Evm,
+        <EthereumEngineValidatorBuilder as reth_ethereum::node::builder::rpc::PayloadValidatorBuilder<N>>::Validator,
+    >;
+
+    async fn build_tree_validator(
+        self,
+        ctx: &reth_ethereum::node::builder::AddOnsContext<'_, N>,
+        tree_config: TreeConfig,
+        changeset_cache: ChangesetCache,
+    ) -> eyre::Result<Self::EngineValidator> {
+        let validator = self.inner.build_tree_validator(ctx, tree_config, changeset_cache).await?;
+        Ok(validator.with_custom_state_root(self.custom_state_root))
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+#[tokio::main]
+async fn main() -> eyre::Result<()> {
+    let runtime = Runtime::test();
+
+    // A custom state root handler that always returns B256::ZERO.
+    let zero_state_root: CustomStateRoot<EthPrimitives> =
+        Arc::new(|_input| Ok((B256::ZERO, TrieUpdates::default())));
+
+    let node_config = NodeConfig::test()
+        .dev()
+        .with_rpc(RpcServerArgs::default().with_http())
+        .with_chain(custom_chain());
+
+    // Build add-ons with our custom engine validator builder.
+    let add_ons: EthereumAddOns<_, _, _, _, ZeroStateRootValidatorBuilder> =
+        EthereumAddOns::new(RpcAddOns::new(
+            EthereumEthApiBuilder::<alloy_network::Ethereum>::default(),
+            EthereumEngineValidatorBuilder::default(),
+            BasicEngineApiBuilder::<EthereumEngineValidatorBuilder>::default(),
+            ZeroStateRootValidatorBuilder {
+                inner: BasicEngineValidatorBuilder::default(),
+                custom_state_root: zero_state_root,
+            },
+            Default::default(),
+            Identity::new(),
+        ));
+
+    let NodeHandle { node: _node, node_exit_future } = NodeBuilder::new(node_config)
+        .testing_node(runtime)
+        .with_types::<EthereumNode>()
+        .with_components(EthereumNode::components())
+        .with_add_ons(add_ons)
+        .launch_with_debug_capabilities()
+        .await?;
+
+    println!("Node running with custom zero state root — press Ctrl+C to exit");
+
+    node_exit_future.await
+}
+
+fn custom_chain() -> Arc<ChainSpec> {
+    let custom_genesis = r#"
+{
+    "nonce": "0x42",
+    "timestamp": "0x0",
+    "extraData": "0x5343",
+    "gasLimit": "0x1c9c380",
+    "difficulty": "0x0",
+    "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "coinbase": "0x0000000000000000000000000000000000000000",
+    "alloc": {
+        "0x6Be02d1d3665660d22FF9624b7BE0551ee1Ac91b": {
+            "balance": "0x4a47e3c12448f4ad000000"
+        }
+    },
+    "number": "0x0",
+    "gasUsed": "0x0",
+    "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "config": {
+        "ethash": {},
+        "chainId": 2600,
+        "homesteadBlock": 0,
+        "eip150Block": 0,
+        "eip155Block": 0,
+        "eip158Block": 0,
+        "byzantiumBlock": 0,
+        "constantinopleBlock": 0,
+        "petersburgBlock": 0,
+        "istanbulBlock": 0,
+        "berlinBlock": 0,
+        "londonBlock": 0,
+        "terminalTotalDifficulty": 0,
+        "terminalTotalDifficultyPassed": true,
+        "shanghaiTime": 0
+    }
+}
+"#;
+    let genesis: Genesis = serde_json::from_str(custom_genesis).unwrap();
+    Arc::new(genesis.into())
+}
diff --git a/examples/manual-p2p/src/main.rs b/examples/manual-p2p/src/main.rs
index 447230a2d9b..e315d67107b 100644
--- a/examples/manual-p2p/src/main.rs
+++ b/examples/manual-p2p/src/main.rs
@@ -137,6 +137,9 @@ async fn snoop(peer: NodeRecord, mut eth_stream: AuthedEthStream) {
             EthMessage::NewPooledTransactionHashes68(txs) => {
                 println!("Got {} new tx hashes from peer {}", txs.hashes.len(), peer.address);
             }
+            EthMessage::NewPooledTransactionHashes72(txs) => {
+                println!("Got {} new tx hashes from peer {}", txs.hashes.len(), peer.address);
+            }
             EthMessage::NewBlockHashes(block_hashes) => {
                 println!("Got {} new block hashes from peer {}", block_hashes.len(), peer.address);
             }
diff --git a/examples/network-proxy/src/main.rs b/examples/network-proxy/src/main.rs
index a1b6db3e539..27fe251adc8 100644
--- a/examples/network-proxy/src/main.rs
+++ b/examples/network-proxy/src/main.rs
@@ -93,6 +93,7 @@ async fn main() -> eyre::Result<()> {
                         IncomingEthRequest::GetReceipts69 { .. } => {}
                         IncomingEthRequest::GetReceipts70 { .. } => {}
                         IncomingEthRequest::GetBlockAccessLists { .. } => {}
+                        IncomingEthRequest::GetCells { .. } => {}
                     }
              }
              transaction_message = transactions_rx.recv() => {
diff --git a/examples/precompile-cache/src/main.rs b/examples/precompile-cache/src/main.rs
index 2378ef23e02..44f937835a4 100644
--- a/examples/precompile-cache/src/main.rs
+++ b/examples/precompile-cache/src/main.rs
@@ -5,7 +5,7 @@
 use alloy_evm::{
     eth::EthEvmContext,
     precompiles::{DynPrecompile, Precompile, PrecompileInput, PrecompilesMap},
-    revm::{handler::EthPrecompiles, precompile::PrecompileId},
+    revm::{context::DBErrorMarker, handler::EthPrecompiles, precompile::PrecompileId},
     Evm, EvmFactory,
 };
 use alloy_genesis::Genesis;
@@ -65,7 +65,7 @@ impl EvmFactory for MyEvmFactory {
     type Evm<DB: Database, I: Inspector<EthEvmContext<DB>, EthInterpreter>> =
         EthEvm<DB, I, PrecompilesMap>;
     type Tx = TxEnv;
-    type Error<DBError: core::error::Error + Send + Sync + 'static> = EVMError<DBError>;
+    type Error<DBError: DBErrorMarker> = EVMError<DBError>;
     type HaltReason = HaltReason;
     type Context<DB: Database> = EthEvmContext<DB>;
     type Spec = SpecId;
diff --git a/testing/ef-tests/src/cases/blockchain_test.rs b/testing/ef-tests/src/cases/blockchain_test.rs
index 338e70cf60b..5ec5b9cdbc2 100644
--- a/testing/ef-tests/src/cases/blockchain_test.rs
+++ b/testing/ef-tests/src/cases/blockchain_test.rs
@@ -252,7 +252,7 @@ fn run_case(case: &BlockchainTest) -> Result<(), Error> {
             .map_err(|err| Error::block_failed(block_number, err))?;
 
         // Consensus checks after block execution
-        validate_block_post_execution(block, &chain_spec, &output, None)
+        validate_block_post_execution(block, &chain_spec, &output, None, None)
             .map_err(|err| Error::block_failed(block_number, err))?;
 
         // Compute and check the post state root
diff --git a/testing/prestate/tx-selfdestruct-prestate.json b/testing/prestate/tx-selfdestruct-prestate.json
index 5ab17b6c2c7..7548d89c656 100644
--- a/testing/prestate/tx-selfdestruct-prestate.json
+++ b/testing/prestate/tx-selfdestruct-prestate.json
@@ -5,10 +5,6 @@
     "0x5cf6756af36644fc13b2d5d8637a50ae7e6c5fef": {
       "balance": "0x1b1989a1deedbd"
     },
-    "0x95222290dd7278aa3ddd389cc1e1d165cc4bafe5": {
-      "balance": "0xc8714456682467dc",
-      "nonce": 797368
-    },
     "0xa7fb5ca286fc3fd67525629048a4de3ba24cba2e": {
       "balance": "0x23af8fab959cdfb42",
       "nonce": 236280