diff --git a/.github/scripts/bench-reth-summary.py b/.github/scripts/bench-reth-summary.py
index 300006cad6c..da6b7de1d11 100755
--- a/.github/scripts/bench-reth-summary.py
+++ b/.github/scripts/bench-reth-summary.py
@@ -521,6 +521,7 @@ 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("--driver", default=None, help="Benchmark driver used for this run")
     parser.add_argument("--grafana-url", default=None, help="Grafana dashboard URL for this benchmark run")
     args = parser.parse_args()
 
@@ -605,6 +606,7 @@ def main():
 
     summary = {
         "blocks": paired_stats["blocks"],
+        "driver": args.driver,
         "big_blocks": args.big_blocks,
         "warmup_blocks": args.warmup_blocks,
         "wait_time": args.wait_time,
diff --git a/.github/scripts/bench-txgen-build.sh b/.github/scripts/bench-txgen-build.sh
new file mode 100755
index 00000000000..80b1ab3a753
--- /dev/null
+++ b/.github/scripts/bench-txgen-build.sh
@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+#
+# Builds the node binary for the txgen-backed PR benchmark path.
+#
+# Usage: bench-txgen-build.sh <baseline|feature> <source-dir> <commit>
+#
+# This intentionally does not build or install reth-bench. Big-block benchmarks
+# still use the legacy reth-bench path because txgen does not yet replay the
+# reth-bb payload/env-switch/BAL format.
+set -euxo pipefail
+
+MODE="$1"
+SOURCE_DIR="$2"
+COMMIT="$3"
+
+if [ "${BENCH_BIG_BLOCKS:-false}" = "true" ]; then
+  echo "::error::txgen path does not support big-block benchmarks yet; use the reth-bench driver"
+  exit 1
+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 --bin reth $workspace_arg $features_arg
+}
+
+case "$MODE" in
+  baseline|main)
+    echo "Building baseline reth (${COMMIT}) from source for txgen benchmark..."
+    build_node_binary
+    ;;
+
+  feature|branch)
+    echo "Building feature reth (${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.py b/.github/scripts/bench-txgen-extract.py
new file mode 100755
index 00000000000..445585a61fb
--- /dev/null
+++ b/.github/scripts/bench-txgen-extract.py
@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Extract raw blocks for txgen send-blocks.
+
+This intentionally uses a numeric `debug_getRawBlock` parameter because some
+public RPC providers reject the hex quantity form that alloy's Debug API emits.
+"""
+
+import argparse
+import json
+import sys
+import time
+import urllib.error
+import urllib.request
+
+
+def rpc_call(url: str, method: str, params: list, retries: int = 12):
+    payload = json.dumps({"jsonrpc": "2.0", "method": method, "params": params, "id": 1}).encode()
+    last_err = None
+    for attempt in range(retries):
+        try:
+            req = urllib.request.Request(
+                url,
+                data=payload,
+                headers={"Content-Type": "application/json", "User-Agent": "reth-bench-txgen"},
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=30) as resp:
+                data = json.loads(resp.read())
+            if "error" in data:
+                raise RuntimeError(data["error"].get("message", data["error"]))
+            return data["result"]
+        except (urllib.error.URLError, TimeoutError, json.JSONDecodeError, RuntimeError) as err:
+            last_err = err
+            if attempt + 1 == retries:
+                break
+            time.sleep(min(10.0, 0.5 * (2**attempt)))
+    raise RuntimeError(last_err)
+
+
+def parse_quantity(value: str) -> int:
+    return int(value, 16) if isinstance(value, str) and value.startswith("0x") else int(value)
+
+
+def validate_top_level_rlp(raw: str) -> None:
+    if not isinstance(raw, str) or not raw.startswith("0x"):
+        raise ValueError("raw block is not a hex string")
+    data = bytes.fromhex(raw[2:])
+    if not data:
+        raise ValueError("raw block is empty")
+
+    prefix = data[0]
+    if prefix <= 0x7F:
+        total = 1
+    elif prefix <= 0xB7:
+        total = 1 + prefix - 0x80
+    elif prefix <= 0xBF:
+        len_len = prefix - 0xB7
+        total = 1 + len_len + int.from_bytes(data[1 : 1 + len_len], "big")
+    elif prefix <= 0xF7:
+        total = 1 + prefix - 0xC0
+    else:
+        len_len = prefix - 0xF7
+        total = 1 + len_len + int.from_bytes(data[1 : 1 + len_len], "big")
+
+    if total != len(data):
+        raise ValueError(f"raw block RLP length mismatch: expected {total} bytes, got {len(data)}")
+
+
+def fetch_raw_block(url: str, number: int, retries: int = 12) -> str:
+    last_err = None
+    for attempt in range(retries):
+        try:
+            raw = rpc_call(url, "debug_getRawBlock", [number], retries=1)
+            validate_top_level_rlp(raw)
+            return raw
+        except (RuntimeError, ValueError) as err:
+            last_err = err
+            if attempt + 1 == retries:
+                break
+            time.sleep(min(10.0, 0.5 * (2**attempt)))
+    raise RuntimeError(last_err)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--rpc", required=True)
+    parser.add_argument("--metadata-rpc")
+    parser.add_argument("--from", dest="from_block", type=int, required=True)
+    parser.add_argument("--to", dest="to_block", type=int, required=True)
+    parser.add_argument("-o", "--output", required=True)
+    args = parser.parse_args()
+
+    if args.from_block > args.to_block:
+        parser.error("--from must be <= --to")
+
+    metadata_rpc = args.metadata_rpc or args.rpc
+    total = args.to_block - args.from_block + 1
+    started = time.monotonic()
+    last_log = started
+
+    with open(args.output, "w", encoding="utf-8") as out:
+        for idx, number in enumerate(range(args.from_block, args.to_block + 1), start=1):
+            try:
+                raw = fetch_raw_block(args.rpc, number)
+                block = rpc_call(metadata_rpc, "eth_getBlockByNumber", [hex(number), False])
+            except RuntimeError as err:
+                print(f"failed to fetch block {number}: {err}", file=sys.stderr)
+                return 1
+
+            if not raw or not block:
+                print(f"missing block {number}", file=sys.stderr)
+                return 1
+
+            line = {
+                "raw": raw,
+                "key": block["hash"],
+                "number": parse_quantity(block["number"]),
+                "timestamp": parse_quantity(block["timestamp"]),
+                "gas_used": parse_quantity(block["gasUsed"]),
+                "gas_limit": parse_quantity(block["gasLimit"]),
+                "tx_count": len(block.get("transactions", [])),
+            }
+            out.write(json.dumps(line, separators=(",", ":")) + "\n")
+
+            now = time.monotonic()
+            if idx == total or idx % 100 == 0 or now - last_log >= 5:
+                elapsed = now - started
+                rate = idx / elapsed if elapsed else 0
+                print(f"extracted {idx}/{total} blocks ({idx / total * 100:.1f}%) - {rate:.0f} blocks/s", file=sys.stderr)
+                last_log = now
+
+    print(f"wrote {total} blocks to {args.output}", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/.github/scripts/bench-txgen-install.sh b/.github/scripts/bench-txgen-install.sh
new file mode 100755
index 00000000000..e3334dc2a3b
--- /dev/null
+++ b/.github/scripts/bench-txgen-install.sh
@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+#
+# Installs the txgen tools used by the txgen-backed PR benchmark path.
+# Keep this separate from bench-reth-build.sh so scheduled benchmarks can keep
+# using the legacy reth-bench runner until they are migrated explicitly.
+#
+# Required env:
+#   TXGEN_REV   – pinned txgen git revision
+# Optional env:
+#   TXGEN_REPO  – txgen repository URL (default: https://github.com/tempoxyz/txgen)
+set -euxo pipefail
+
+: "${TXGEN_REV:?TXGEN_REV must be set to a pinned txgen revision}"
+
+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" --rev "$TXGEN_REV" txgen-ethereum --bin txgen-ethereum --locked
+cargo install --git "$TXGEN_REPO" --rev "$TXGEN_REV" bench-cli --bin bench --locked
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..01620d94260
--- /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 the legacy reth-bench CSVs.
+
+The PR benchmark rendering pipeline still consumes `combined_latency.csv` and
+`total_gas.csv`. This adapter lets the txgen-backed 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 reth-bench 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..a02130c37a9
--- /dev/null
+++ b/.github/scripts/bench-txgen-run.sh
@@ -0,0 +1,260 @@
+#!/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 the legacy reth-bench 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_WORK_DIR, BENCH_BASELINE_ARGS, BENCH_FEATURE_ARGS,
+#               BENCH_OTLP_TRACES_ENDPOINT, BENCH_OTLP_LOGS_ENDPOINT,
+#               BENCH_OTLP_DISABLED
+set -euxo pipefail
+
+LABEL="$1"
+BINARY="$2"
+OUTPUT_DIR="$3"
+DATADIR="$SCHELK_MOUNT/datadir"
+mkdir -p "$OUTPUT_DIR"
+LOG="${OUTPUT_DIR}/node.log"
+
+RETH_SCOPE="${RETH_SCOPE:-reth-bench.scope}"
+
+# Unsupported txgen-path behavior is made explicit here. Keep these checks near
+# the top so new txgen support can be added one feature at a time.
+if [ "${BENCH_BIG_BLOCKS:-false}" = "true" ]; then
+  echo "::error::txgen driver does not support big-block benchmarks yet; use the reth-bench driver"
+  exit 1
+fi
+if [ -n "${BENCH_WAIT_TIME:-}" ]; then
+  echo "::error::txgen driver does not support BENCH_WAIT_TIME yet"
+  exit 1
+fi
+if [ -n "${BENCH_BAL:-}" ] && [ "${BENCH_BAL}" != "false" ]; then
+  echo "::error::txgen driver does not support BAL replay yet; use big-blocks with the reth-bench driver"
+  exit 1
+fi
+
+cleanup() {
+  kill "${TAIL_PID:-}" 2>/dev/null || true
+  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
+      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=
+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=$(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}"
+
+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)
+  fi
+  if [ -n "${BENCH_OTLP_LOGS_ENDPOINT:-}" ]; then
+    RETH_ARGS+=(--logs-otlp="${BENCH_OTLP_LOGS_ENDPOINT}" --logs-otlp.filter=debug)
+  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 / 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
+
+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_ETHEREUM="$(which txgen-ethereum)"
+TXGEN_BENCH="$(which bench)"
+BENCH_NICE="sudo nice -n -20 sudo -u $(id -un)"
+
+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}))
+
+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"
+ALL_BLOCKS="$TXGEN_DIR/all-blocks.ndjson"
+WARMUP_BLOCKS="$TXGEN_DIR/warmup-blocks.ndjson"
+BENCHMARK_BLOCKS="$TXGEN_DIR/benchmark-blocks.ndjson"
+
+EXTRACT_FROM=$(( HEAD_DEC + 1 ))
+EXTRACT_TO=$(( HEAD_DEC + TOTAL ))
+SOURCE_RPC_URL="${BENCH_TXGEN_RPC_URL:-$BENCH_RPC_URL}"
+echo "Extracting blocks ${EXTRACT_FROM}..${EXTRACT_TO} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured)"
+python3 .github/scripts/bench-txgen-extract.py \
+  --rpc "$SOURCE_RPC_URL" \
+  --metadata-rpc "$BENCH_RPC_URL" \
+  --from "$EXTRACT_FROM" \
+  --to "$EXTRACT_TO" \
+  -o "$ALL_BLOCKS"
+
+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"
+
+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" \
+    --wait-for-persistence never \
+    --report json:"$TXGEN_DIR/warmup-report.json" 2>&1 | sed -u "s/^/[bench] /"
+else
+  echo "Skipping warmup (0 blocks)..."
+fi
+
+# TODO(txgen): expose a wait-time flag and plumb BENCH_WAIT_TIME here.
+# TODO(txgen): expose microsecond client-side FCU latency to avoid ms rounding.
+# TODO(txgen): support reth-bb payload/env-switch/BAL replay so big-blocks can move here.
+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" \
+  --wait-for-persistence never \
+  --report json:"$OUTPUT_DIR/report.json" 2>&1 | sed -u "s/^/[bench] /"
+
+python3 .github/scripts/bench-txgen-report-to-reth-csv.py "$OUTPUT_DIR/report.json" "$OUTPUT_DIR"
diff --git a/.github/scripts/bench-utils.js b/.github/scripts/bench-utils.js
index 393c402fb25..6e67a95bdcd 100644
--- a/.github/scripts/bench-utils.js
+++ b/.github/scripts/bench-utils.js
@@ -54,6 +54,8 @@ function balModeLabel(mode) {
 
 function blocksLabel(summary) {
   const parts = [];
+  const driver = summary.driver || process.env.BENCH_DRIVER || '';
+  if (driver) parts.push({ key: 'Driver', value: driver });
   if (summary.big_blocks) {
     parts.push({ key: 'Big Blocks', value: summary.blocks });
     const balMode = balModeLabel(summary.bal_mode || summary.bal || process.env.BENCH_BAL || 'false');
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 3274d26d471..53e4a456129 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -432,8 +432,10 @@ jobs:
             const baselineArgsNote = baselineArgsVal ? `, baseline-args: \`${baselineArgsVal}\`` : '';
             const featureArgsVal = '${{ steps.args.outputs.feature-args }}';
             const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
+            const driver = bigBlocks ? 'reth-bench' : 'txgen';
+            const driverNote = `, driver: \`${driver}\``;
             const blocksDesc = bigBlocks ? 'blocks: `big`' : `${blocks} blocks, ${warmup} warmup blocks`;
-            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
+            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${driverNote}${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
 
             const { data: comment } = await github.rest.issues.createComment({
               owner: context.repo.owner,
@@ -476,8 +478,10 @@ jobs:
             const baselineArgsNote = baselineArgsVal ? `, baseline-args: \`${baselineArgsVal}\`` : '';
             const featureArgsVal = '${{ steps.args.outputs.feature-args }}';
             const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
+            const driver = bigBlocks ? 'reth-bench' : 'txgen';
+            const driverNote = `, driver: \`${driver}\``;
             const blocksDesc = bigBlocks ? 'blocks: `big`' : `${blocks} blocks, ${warmup} warmup blocks`;
-            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
+            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${driverNote}${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${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;
@@ -528,7 +532,7 @@ jobs:
 
   reth-bench:
     needs: reth-bench-ack
-    name: reth-bench
+    name: bench-${{ needs.reth-bench-ack.outputs.big-blocks == 'true' && 'reth-bench' || 'txgen' }}
     runs-on: [self-hosted, Linux, X64, available]
     permissions:
       contents: read
@@ -536,6 +540,7 @@ jobs:
     timeout-minutes: 120
     env:
       BENCH_RPC_URL: https://ethereum.reth.rs/rpc
+      BENCH_TXGEN_RPC_URL: https://eth.llamarpc.com
       SCHELK_MOUNT: /reth-bench
       RETH_SCOPE: reth-bench.scope
       BENCH_WORK_DIR: ${{ github.workspace }}/bench-work
@@ -554,8 +559,10 @@ jobs:
       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_DRIVER: ${{ needs.reth-bench-ack.outputs.big-blocks == 'true' && 'reth-bench' || 'txgen' }}
       BENCH_NODE_BIN: ${{ needs.reth-bench-ack.outputs.big-blocks == 'true' && 'reth-bb' || 'reth' }}
       BENCH_METRICS_ADDR: "127.0.0.1:9100"
+      TXGEN_REV: 420cad10ad2d1ffa10d5708a892a910e101d7811
       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 || '' }}
     steps:
@@ -600,7 +607,8 @@ jobs:
               repo: context.repo.repo,
               run_id: context.runId,
             });
-            const job = jobs.jobs.find(j => j.name === 'reth-bench');
+            const expectedJobName = `bench-${process.env.BENCH_DRIVER || '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);
 
@@ -627,8 +635,10 @@ jobs:
             const baselineArgsNote = baselineArgsVal ? `, baseline-args: \`${baselineArgsVal}\`` : '';
             const featureArgsVal = process.env.BENCH_FEATURE_ARGS || '';
             const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
+            const driver = process.env.BENCH_DRIVER || (bigBlocks ? 'reth-bench' : 'txgen');
+            const driverNote = `, driver: \`${driver}\``;
             const blocksDesc = bigBlocks ? 'blocks: `big`' : `${blocks} blocks, ${warmup} warmup blocks`;
-            core.exportVariable('BENCH_CONFIG', `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`);
+            core.exportVariable('BENCH_CONFIG', `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${driverNote}${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`);
 
             const { buildBody } = require('./.github/scripts/bench-update-status.js');
             await github.rest.issues.updateComment({
@@ -833,14 +843,26 @@ 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 }}" &
+          if [ "$BENCH_DRIVER" = "txgen" ]; then
+            .github/scripts/bench-txgen-install.sh
+            BUILD_SCRIPT=.github/scripts/bench-txgen-build.sh
+          else
+            BUILD_SCRIPT=.github/scripts/bench-reth-build.sh
+          fi
+
+          "$BUILD_SCRIPT" baseline "${BASELINE_DIR}" "${{ steps.refs.outputs.baseline-ref }}" &
           PID_BASELINE=$!
-          .github/scripts/bench-reth-build.sh feature "${FEATURE_DIR}" "${{ steps.refs.outputs.feature-ref }}" &
+          "$BUILD_SCRIPT" feature "${FEATURE_DIR}" "${{ steps.refs.outputs.feature-ref }}" &
           PID_FEATURE=$!
 
           FAIL=0
@@ -963,7 +985,11 @@ 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":"${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"
+          RUN_SCRIPT=.github/scripts/bench-reth-run.sh
+          if [ "$BENCH_DRIVER" = "txgen" ]; then
+            RUN_SCRIPT=.github/scripts/bench-txgen-run.sh
+          fi
+          taskset -c 0 "$RUN_SCRIPT" feature "../reth-feature/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/feature-1"
 
       - name: "Run benchmark: baseline (1/2)"
         id: run-baseline-1
@@ -976,7 +1002,11 @@ 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":"${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"
+          RUN_SCRIPT=.github/scripts/bench-reth-run.sh
+          if [ "$BENCH_DRIVER" = "txgen" ]; then
+            RUN_SCRIPT=.github/scripts/bench-txgen-run.sh
+          fi
+          taskset -c 0 "$RUN_SCRIPT" baseline "../reth-baseline/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/baseline-1"
 
       - name: "Run benchmark: baseline (2/2)"
         if: env.BENCH_ABBA != 'false'
@@ -990,7 +1020,11 @@ 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/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/baseline-2"
+          RUN_SCRIPT=.github/scripts/bench-reth-run.sh
+          if [ "$BENCH_DRIVER" = "txgen" ]; then
+            RUN_SCRIPT=.github/scripts/bench-txgen-run.sh
+          fi
+          taskset -c 0 "$RUN_SCRIPT" baseline "../reth-baseline/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/baseline-2"
 
       - name: "Run benchmark: feature (2/2)"
         if: env.BENCH_ABBA != 'false'
@@ -1004,7 +1038,11 @@ 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":"${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"
+          RUN_SCRIPT=.github/scripts/bench-reth-run.sh
+          if [ "$BENCH_DRIVER" = "txgen" ]; then
+            RUN_SCRIPT=.github/scripts/bench-txgen-run.sh
+          fi
+          taskset -c 0 "$RUN_SCRIPT" feature "../reth-feature/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/feature-2"
 
       - name: Stop metrics proxy & generate Grafana URL
         id: metrics
@@ -1143,6 +1181,9 @@ jobs:
           if [ -n "${BENCH_BAL:-}" ] && [ "${BENCH_BAL}" != "false" ]; then
             SUMMARY_ARGS="$SUMMARY_ARGS --bal-mode $BENCH_BAL"
           fi
+          if [ -n "${BENCH_DRIVER:-}" ]; then
+            SUMMARY_ARGS="$SUMMARY_ARGS --driver $BENCH_DRIVER"
+          fi
           GRAFANA_URL='${{ steps.metrics.outputs.grafana-url }}'
           if [ -n "$GRAFANA_URL" ]; then
             SUMMARY_ARGS="$SUMMARY_ARGS --grafana-url $GRAFANA_URL"
@@ -1174,7 +1215,7 @@ 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