From 709485dcb7f76f55b882b5070f93c13b71bc1689 Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Wed, 29 Apr 2026 20:57:05 +0800
Subject: [PATCH 001/335] perf(bench): buffer RPC fetches in generate-big-block
 (#23830)

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../src/bench/generate_big_block.rs           | 168 ++++++++++++------
 1 file changed, 112 insertions(+), 56 deletions(-)

diff --git a/bin/reth-bench/src/bench/generate_big_block.rs b/bin/reth-bench/src/bench/generate_big_block.rs
index 5826cce7712..53a504c054a 100644
--- a/bin/reth-bench/src/bench/generate_big_block.rs
+++ b/bin/reth-bench/src/bench/generate_big_block.rs
@@ -21,6 +21,7 @@ use alloy_rpc_types_engine::{
 };
 use clap::Parser;
 use eyre::Context;
+use futures::{stream, StreamExt};
 use reth_chainspec::EthChainSpec;
 use reth_cli::chainspec::ChainSpecParser;
 use reth_cli_runner::CliContext;
@@ -270,6 +271,15 @@ pub struct Command {
     /// the flattened BAL on the stored payload.
     #[arg(long, default_value_t = false)]
     bal: bool,
+
+    /// Maximum number of in-flight RPC fetches to keep buffered ahead of the merger.
+    ///
+    /// Each entry is one full per-block fetch (block + receipts, plus BAL when `--bal` is
+    /// set). Larger values absorb RPC latency at the cost of more concurrent connections
+    /// and memory; the buffer persists across `--num-big-blocks` so prefetching continues
+    /// across big-block boundaries.
+    #[arg(long, value_name = "PREFETCH_BUFFER", default_value_t = 32)]
+    prefetch_buffer: usize,
 }
 
 impl Command {
@@ -322,13 +332,27 @@ impl Command {
         }
         let mut prev_big_block_header: Option<PrevBigBlockHeader> = None;
 
-        // Track the next block to fetch across big blocks so they don't overlap.
+        // Persistent prefetch stream: keeps `prefetch_buffer` per-block fetches in flight
+        // ahead of the merger across all big blocks. Each item is a fully materialized
+        // `FetchedBlock` (or `None` once the chain tip is reached on this fetch).
+        let prefetch_buffer = self.prefetch_buffer.max(1);
+        let bal_enabled = self.bal;
+        let block_stream = stream::iter(self.from_block..)
+            .map(|block_number| {
+                let provider = provider.clone();
+                async move { fetch_one_block(provider, block_number, bal_enabled).await }
+            })
+            .buffered(prefetch_buffer);
+        let mut block_stream = Box::pin(block_stream);
+
+        // Track the next block number we expect from the stream (purely for logging /
+        // big-block range bookkeeping; the stream produces blocks in `from_block..` order).
         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.
+            // Drain the prefetch stream until the gas target is reached for this big block.
             let mut blocks = Vec::new();
             let mut block_receipts: Vec<Vec<Receipt>> = Vec::new();
             let mut block_access_lists: Vec<Option<BlockAccessList>> = Vec::new();
@@ -337,16 +361,11 @@ impl Command {
             let mut reached_chain_tip = false;
             while accumulated_block_gas < self.target_gas {
                 let block_number = next_block;
-                info!(target: "reth-bench", block_number, big_block = big_block_idx, "Fetching block");
+                info!(target: "reth-bench", block_number, big_block = big_block_idx, "Awaiting prefetched 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)) => {
+                let fetched = match block_stream.next().await {
+                    Some(Ok(Some(fetched))) => fetched,
+                    Some(Ok(None)) => {
                         warn!(
                             target: "reth-bench",
                             block_number,
@@ -355,52 +374,16 @@ impl Command {
                         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
+                    Some(Err(e)) => return Err(e),
+                    // The block-number stream is open-ended; this only fires if the
+                    // upstream `iter(from..)` is somehow exhausted.
+                    None => {
+                        reached_chain_tip = true;
+                        break;
+                    }
                 };
-
-                // 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 FetchedBlock { execution_data, consensus_receipts, block_access_list } =
+                    fetched;
 
                 let block_gas = execution_data.payload.as_v1().gas_used;
                 let block_blob_gas =
@@ -674,6 +657,79 @@ impl Command {
     }
 }
 
+/// One fully-materialized block fetched by the prefetcher.
+struct FetchedBlock {
+    /// Execution payload with sidecar derived from the RPC block.
+    execution_data: ExecutionData,
+    /// Consensus-format receipts (`cumulative_gas_used` is still per-block, callers offset
+    /// it when merging).
+    consensus_receipts: Vec<Receipt>,
+    /// `eth_getBlockAccessListByBlockNumber` result when `--bal` is enabled.
+    block_access_list: Option<BlockAccessList>,
+}
+
+/// Fetches one block + receipts (and optionally its BAL) from the RPC. Returns `Ok(None)`
+/// when the block doesn't exist yet (chain-tip reached).
+async fn fetch_one_block(
+    provider: RootProvider<AnyNetwork>,
+    block_number: u64,
+    bal_enabled: bool,
+) -> eyre::Result<Option<FetchedBlock>> {
+    let (rpc_block, receipts) = tokio::try_join!(
+        provider.get_block_by_number(block_number.into()).full(),
+        provider.get_block_receipts(block_number.into()),
+    )?;
+    let (rpc_block, receipts) = match (rpc_block, receipts) {
+        (Some(b), Some(r)) => (b, r),
+        _ => return Ok(None),
+    };
+
+    let block_access_list = if bal_enabled {
+        Some(
+            fetch_block_access_list(&provider, block_number)
+                .await
+                .wrap_err_with(|| format!("Failed to fetch BAL for block {block_number}"))?,
+        )
+    } else {
+        None
+    };
+
+    let consensus_receipts: Vec<Receipt> = receipts
+        .iter()
+        .map(|r| {
+            let inner = &r.inner.inner.inner;
+            let tx_type = r.inner.inner.r#type.try_into().unwrap_or_default();
+            Receipt {
+                tx_type,
+                success: inner.receipt.status.coerce_status(),
+                cumulative_gas_used: inner.receipt.cumulative_gas_used,
+                logs: inner
+                    .receipt
+                    .logs
+                    .iter()
+                    .map(|log| alloy_primitives::Log {
+                        address: log.inner.address,
+                        data: log.inner.data.clone(),
+                    })
+                    .collect(),
+            }
+        })
+        .collect();
+
+    let block = rpc_block
+        .into_inner()
+        .map_header(|header| header.map(|h| h.into_header_with_defaults()))
+        .try_map_transactions(|tx| -> eyre::Result<TxEnvelope> {
+            tx.try_into().map_err(|_| eyre::eyre!("unsupported tx type"))
+        })?
+        .into_consensus();
+
+    let (payload, sidecar) = ExecutionPayload::from_block_slow(&block);
+    let execution_data = ExecutionData { payload, sidecar };
+
+    Ok(Some(FetchedBlock { execution_data, consensus_receipts, block_access_list }))
+}
+
 fn merge_block_access_list(
     merged: &mut BlockAccessList,
     incoming: BlockAccessList,

From 077e5eecfef02e2fc32d35cd6f79ab5975b975a1 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Wed, 29 Apr 2026 18:36:44 +0400
Subject: [PATCH 002/335] chore: don't enforce non-empty blocks in e2e payload
 building (#23837)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/e2e-test-utils/src/payload.rs | 30 +++++++---------------------
 1 file changed, 7 insertions(+), 23 deletions(-)

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

From 4ffde69d94a96b29dcf12d955b0880156df5109b Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Wed, 29 Apr 2026 08:29:42 -0700
Subject: [PATCH 003/335] fix(engine): apply finalized state after syncing FCU
 head import (#23838)

Co-authored-by: Centaur AI <ai@centaur.local>
Co-authored-by: Amp <amp@ampcode.com>
Co-authored-by: klkvr <klkvrr@gmail.com>
---
 crates/engine/primitives/src/forkchoice.rs | 22 ++++++--
 crates/engine/tree/src/tree/mod.rs         | 28 ++++++++++
 crates/engine/tree/src/tree/tests.rs       | 62 ++++++++++++++++++++++
 3 files changed, 108 insertions(+), 4 deletions(-)

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/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index 7837063decc..1edf1496e23 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -1917,9 +1917,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 {
diff --git a/crates/engine/tree/src/tree/tests.rs b/crates/engine/tree/src/tree/tests.rs
index 552a21d11a5..193200f2a32 100644
--- a/crates/engine/tree/src/tree/tests.rs
+++ b/crates/engine/tree/src/tree/tests.rs
@@ -2254,3 +2254,65 @@ 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());
+}

From d25de30050c0cf89e97a08222ae108f81fa2d4c7 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Thu, 30 Apr 2026 02:59:10 +0400
Subject: [PATCH 004/335] feat: customizable discovery defaults (#23843)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/node/core/src/args/mod.rs             |   2 +-
 crates/node/core/src/args/network.rs         | 267 +++++++++++++++----
 docs/vocs/docs/pages/cli/reth/node.mdx       |   4 +-
 docs/vocs/docs/pages/cli/reth/p2p/body.mdx   |   4 +-
 docs/vocs/docs/pages/cli/reth/p2p/header.mdx |   4 +-
 docs/vocs/docs/pages/cli/reth/stage/run.mdx  |   4 +-
 6 files changed, 230 insertions(+), 55 deletions(-)

diff --git a/crates/node/core/src/args/mod.rs b/crates/node/core/src/args/mod.rs
index 3703d4144f0..6d6fbbd0078 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;
diff --git a/crates/node/core/src/args/network.rs b/crates/node/core/src/args/network.rs
index 614bcf30259..b682633805e 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;
@@ -569,15 +572,8 @@ impl NetworkArgs {
                 let rlpx_socket = (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(addr, self.port))
+            .discovery_addr(SocketAddr::new(self.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 +723,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 +899,57 @@ 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)]
+    #[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 +999,7 @@ impl DiscoveryArgs {
             discv5_lookup_interval,
             discv5_bootstrap_lookup_interval,
             discv5_bootstrap_lookup_countdown,
+            port,
             ..
         } = self;
 
@@ -867,8 +1017,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 +1049,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 +1068,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,
         }
     }
 }
diff --git a/docs/vocs/docs/pages/cli/reth/node.mdx b/docs/vocs/docs/pages/cli/reth/node.mdx
index 4e88bde832d..3d5a60beb57 100644
--- a/docs/vocs/docs/pages/cli/reth/node.mdx
+++ b/docs/vocs/docs/pages/cli/reth/node.mdx
@@ -115,7 +115,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]
 
diff --git a/docs/vocs/docs/pages/cli/reth/p2p/body.mdx b/docs/vocs/docs/pages/cli/reth/p2p/body.mdx
index a12a5741da6..f55534e616a 100644
--- a/docs/vocs/docs/pages/cli/reth/p2p/body.mdx
+++ b/docs/vocs/docs/pages/cli/reth/p2p/body.mdx
@@ -55,7 +55,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]
 
diff --git a/docs/vocs/docs/pages/cli/reth/p2p/header.mdx b/docs/vocs/docs/pages/cli/reth/p2p/header.mdx
index da60a42d03d..33f17e8e80a 100644
--- a/docs/vocs/docs/pages/cli/reth/p2p/header.mdx
+++ b/docs/vocs/docs/pages/cli/reth/p2p/header.mdx
@@ -55,7 +55,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]
 
diff --git a/docs/vocs/docs/pages/cli/reth/stage/run.mdx b/docs/vocs/docs/pages/cli/reth/stage/run.mdx
index 667c4cb2c45..8d4e7411e68 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/run.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/run.mdx
@@ -208,7 +208,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]
 

From fcfa8287f69a3509fcfef95d1b4dc8948ec86665 Mon Sep 17 00:00:00 2001
From: DaniPopes <57450786+DaniPopes@users.noreply.github.com>
Date: Thu, 30 Apr 2026 05:19:09 +0200
Subject: [PATCH 005/335] chore(mdbx): replace deprecated MDBX_NOTLS with
 MDBX_NOSTICKYTHREADS (#23378)

---
 crates/storage/libmdbx-rs/mdbx-sys/build.rs | 1 +
 crates/storage/libmdbx-rs/src/flags.rs      | 2 +-
 crates/storage/libmdbx-rs/src/txn_pool.rs   | 4 ++--
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/storage/libmdbx-rs/mdbx-sys/build.rs b/crates/storage/libmdbx-rs/mdbx-sys/build.rs
index c265d02e233..d3d3234e1bc 100644
--- a/crates/storage/libmdbx-rs/mdbx-sys/build.rs
+++ b/crates/storage/libmdbx-rs/mdbx-sys/build.rs
@@ -97,6 +97,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/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

From 0eeb8c5ef7e6df23afd7ef2d413246d9131d754c Mon Sep 17 00:00:00 2001
From: figtracer <me@figtracer.com>
Date: Thu, 30 Apr 2026 12:10:12 +0100
Subject: [PATCH 006/335] fix(net): prevent eth/68 tx request packing overflow
 (#23848)

---
 .../net/network/src/transactions/fetcher.rs   | 48 +++++++++++++++++--
 1 file changed, 43 insertions(+), 5 deletions(-)

diff --git a/crates/net/network/src/transactions/fetcher.rs b/crates/net/network/src/transactions/fetcher.rs
index 3310c3eef16..dd7f46592b3 100644
--- a/crates/net/network/src/transactions/fetcher.rs
+++ b/crates/net/network/src/transactions/fetcher.rs
@@ -283,11 +283,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;
@@ -721,7 +722,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
@@ -1368,6 +1369,43 @@ mod test {
         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::<HashSet<_>>();
+        let expected_surplus_hashes = std::iter::once(eth68_hashes[1]).collect::<HashSet<_>>();
+
+        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::<HashSet<_>>();
+        let surplus_eth68_hashes = surplus_eth68_hashes.into_iter().collect::<HashSet<_>>();
+
+        assert_eq!(expected_request_hashes, eth68_hashes_to_request);
+        assert_eq!(expected_surplus_hashes, surplus_eth68_hashes);
+    }
+
     #[tokio::test]
     async fn test_on_fetch_pending_hashes() {
         reth_tracing::init_test_tracing();

From fa2279ff4cedeb6b2c8b25df129aef9d8d48b9bc Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Thu, 30 Apr 2026 05:12:26 -0700
Subject: [PATCH 007/335] chore: default to min-trace-logs (#23851)

Co-authored-by: Centaur AI <ai@centaur.local>
Co-authored-by: Amp <amp@ampcode.com>
---
 Makefile                                     | 2 +-
 bin/reth-bb/Cargo.toml                       | 7 ++++++-
 bin/reth-bench/README.md                     | 2 +-
 bin/reth/Cargo.toml                          | 2 +-
 docs/vocs/docs/pages/installation/source.mdx | 4 ++--
 5 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/Makefile b/Makefile
index fd04a20d35c..65db2e6d8b3 100644
--- a/Makefile
+++ b/Makefile
@@ -245,7 +245,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/bin/reth-bb/Cargo.toml b/bin/reth-bb/Cargo.toml
index d0e5526bb45..eb3ab1d0ce1 100644
--- a/bin/reth-bb/Cargo.toml
+++ b/bin/reth-bb/Cargo.toml
@@ -70,7 +70,7 @@ default = [
     "reth-cli-util/jemalloc",
     "asm-keccak",
     "keccak-cache-global",
-    "min-debug-logs",
+    "min-trace-logs",
 ]
 
 jemalloc = [
@@ -101,6 +101,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-bench/README.md b/bin/reth-bench/README.md
index aa63c6ec336..f44245e82b0 100644
--- a/bin/reth-bench/README.md
+++ b/bin/reth-bench/README.md
@@ -86,7 +86,7 @@ RUSTFLAGS="-C target-cpu=native" cargo build --profile profiling --features "jem
 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"
+RUSTFLAGS="-C target-cpu=native" cargo build --profile profiling --no-default-features --features "snmalloc-native,asm-keccak,min-trace-logs"
 ```
 
 ### Run the Benchmark:
diff --git a/bin/reth/Cargo.toml b/bin/reth/Cargo.toml
index 424f93a5d23..471bc8293ed 100644
--- a/bin/reth/Cargo.toml
+++ b/bin/reth/Cargo.toml
@@ -88,7 +88,7 @@ default = [
     "js-tracer",
     "keccak-cache-global",
     "asm-keccak",
-    "min-debug-logs",
+    "min-trace-logs",
 ]
 
 otlp = [
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:
 

From e98fb4af981d84ff2c50f6f86d863060a77484e6 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Thu, 30 Apr 2026 14:15:41 +0200
Subject: [PATCH 008/335] feat(engine): convert built payload to execution data
 (#23859)

---
 .../ethereum/engine-primitives/src/payload.rs | 106 +++++++++++++++++-
 1 file changed, 103 insertions(+), 3 deletions(-)

diff --git a/crates/ethereum/engine-primitives/src/payload.rs b/crates/ethereum/engine-primitives/src/payload.rs
index 0318b095ef9..1e9a9eaaf59 100644
--- a/crates/ethereum/engine-primitives/src/payload.rs
+++ b/crates/ethereum/engine-primitives/src/payload.rs
@@ -8,9 +8,11 @@ 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;
@@ -189,6 +191,39 @@ 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> {
@@ -264,6 +299,12 @@ impl TryFrom<EthBuiltPayload> for ExecutionPayloadEnvelopeV6 {
     }
 }
 
+impl From<EthBuiltPayload> for ExecutionData {
+    fn from(value: EthBuiltPayload) -> Self {
+        value.into_execution_data()
+    }
+}
+
 /// An enum representing blob transaction sidecars belonging to [`EthBuiltPayload`].
 #[derive(Clone, Default, Debug)]
 pub enum BlobSidecars {
@@ -350,3 +391,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 _;
+
+    #[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(block.seal_slow()),
+            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(block.seal_slow()),
+            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>();
+    }
+}

From 8d7c15f38e7358b7bef9ee01d107fe0f49d6a523 Mon Sep 17 00:00:00 2001
From: Karl Yu <43113774+0xKarl98@users.noreply.github.com>
Date: Fri, 1 May 2026 14:23:53 +0800
Subject: [PATCH 009/335] feat(net): add optional BAL fetching for block ranges
 (#23779)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/p2p/src/full_block.rs | 379 ++++++++++++++++++++++++++++---
 crates/net/p2p/src/lib.rs        |   1 +
 crates/net/peers/src/lib.rs      |  24 +-
 3 files changed, 374 insertions(+), 30 deletions(-)

diff --git a/crates/net/p2p/src/full_block.rs b/crates/net/p2p/src/full_block.rs
index 45bedcbd39c..22055d6bf62 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,
@@ -30,6 +30,10 @@ use std::{
 };
 use tracing::debug;
 
+/// Response returned by [`FetchFullBlockRangeWithOptionalAccessListsFuture`].
+pub type FullBlockRangeWithOptionalAccessListsResponse<B> =
+    (Vec<SealedBlock<B>>, Option<BlockAccessLists>);
+
 /// A Client that can fetch full blocks from the network.
 #[derive(Debug, Clone)]
 pub struct FullBlockClient<Client>
@@ -72,7 +76,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,25 +105,6 @@ 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,
@@ -142,6 +127,26 @@ where
             bal_request_state: BalRequestState::Pending(client.get_block_access_lists(vec![hash])),
         }
     }
+
+    /// Returns a future that fetches [`SealedBlock`]s and optionally their [`BlockAccessLists`] for
+    /// the given hash and count.
+    ///
+    /// The block range is always the primary result. Access lists are requested after the block
+    /// range is downloaded. `Some` may contain a partial prefix when the peer truncates the BAL
+    /// response, while `None` means the optional BAL lookup failed or was unavailable.
+    pub fn get_full_block_range_with_optional_access_lists(
+        &self,
+        hash: B256,
+        count: u64,
+    ) -> FetchFullBlockRangeWithOptionalAccessListsFuture<Client> {
+        let client = self.client.clone();
+        FetchFullBlockRangeWithOptionalAccessListsFuture {
+            blocks: self.get_full_block_range(hash, count),
+            client,
+            block_result: None,
+            access_lists: OptionalBlockAccessListsState::WaitingForBlocks,
+        }
+    }
 }
 
 /// A future that downloads a full block from the network.
@@ -165,6 +170,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
@@ -435,6 +454,145 @@ 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 FetchFullBlockRangeWithOptionalAccessListsFuture<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> FetchFullBlockRangeWithOptionalAccessListsFuture<Client>
+where
+    Client: BlockClient<Header: Debug + BlockHeader + Sealable + Clone + Hash + Eq>
+        + BlockAccessListsClient,
+{
+    fn start_access_lists_request_if_possible(&mut self) {
+        if !matches!(self.access_lists, OptionalBlockAccessListsState::WaitingForBlocks) {
+            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, BalRequirement::Optional),
+        );
+    }
+
+    fn on_access_lists_response(&mut self, response: WithPeerId<BlockAccessLists>) {
+        let (peer, access_lists) = response.split();
+        let expected =
+            self.block_result.as_ref().expect("blocks should be ready before BAL response").len();
+        let received = access_lists.0.len();
+
+        if received > expected {
+            debug!(
+                target: "downloaders",
+                start_hash = ?self.blocks.start_hash(),
+                expected,
+                received,
+                "Received wrong access list range response",
+            );
+            self.client.report_bad_message(peer);
+            self.access_lists = OptionalBlockAccessListsState::Ready(None);
+            return
+        }
+
+        // Short BAL responses are allowed by the wire protocol. Preserve the returned prefix and
+        // let callers decide whether they need to fetch the remaining entries.
+        self.access_lists = OptionalBlockAccessListsState::Ready(Some(access_lists));
+    }
+
+    /// 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.on_access_lists_response(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<FullBlockRangeWithOptionalAccessListsResponse<Client::Block>> {
+        let OptionalBlockAccessListsState::Ready(access_lists) = &mut self.access_lists else {
+            return None
+        };
+
+        let blocks = self.block_result.take()?;
+        Some((blocks, access_lists.take()))
+    }
+}
+
+impl<Client> Future for FetchFullBlockRangeWithOptionalAccessListsFuture<Client>
+where
+    Client: BlockClient<Header: Debug + BlockHeader + Sealable + Clone + Hash + Eq>
+        + BlockAccessListsClient
+        + 'static,
+{
+    type Output = FullBlockRangeWithOptionalAccessListsResponse<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,
+    /// A `GetBlockAccessLists` request is in flight.
+    Pending(Req),
+    /// `None` means the block range is available but optional BAL data is not.
+    Ready(Option<BlockAccessLists>),
+}
+
 impl<Client> Debug for FetchFullBlockFuture<Client>
 where
     Client: BlockClient<Header: Debug, Body: Debug>,
@@ -534,11 +692,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
@@ -1046,6 +1199,9 @@ mod tests {
         inner: TestFullBlockClient,
         access_lists: Arc<Mutex<HashMap<B256, Bytes>>>,
         access_list_requests: Arc<AtomicUsize>,
+        access_list_soft_limit: Arc<AtomicUsize>,
+        extra_access_list_entries: Arc<AtomicUsize>,
+        unsupported_access_lists: Arc<AtomicBool>,
         bad_messages: Arc<AtomicUsize>,
         empty_first_response: Arc<AtomicBool>,
     }
@@ -1056,6 +1212,9 @@ mod tests {
                 inner: TestFullBlockClient::default(),
                 access_lists: Arc::new(Mutex::new(HashMap::default())),
                 access_list_requests: Arc::new(AtomicUsize::new(0)),
+                access_list_soft_limit: Arc::new(AtomicUsize::new(usize::MAX)),
+                extra_access_list_entries: Arc::new(AtomicUsize::new(0)),
+                unsupported_access_lists: Arc::new(AtomicBool::new(false)),
                 bad_messages: Arc::new(AtomicUsize::new(0)),
                 empty_first_response: Arc::new(AtomicBool::new(false)),
             }
@@ -1067,6 +1226,39 @@ 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_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;
+
+            sealed_header = SealedHeader::seal_slow(header);
+            let access_list = Bytes::from(vec![EMPTY_LIST_CODE, block_idx as u8]);
+
+            client.insert(sealed_header.clone(), body.clone(), access_list);
+        }
+
+        (sealed_header, body)
     }
 
     impl DownloadClient for FullBlockWithAccessListsClient {
@@ -1118,6 +1310,10 @@ mod tests {
         ) -> Self::Output {
             self.access_list_requests.fetch_add(1, Ordering::SeqCst);
 
+            if self.unsupported_access_lists.load(Ordering::SeqCst) {
+                return futures::future::ready(Err(RequestError::UnsupportedCapability))
+            }
+
             if self.empty_first_response.swap(false, Ordering::SeqCst) {
                 return futures::future::ready(Ok(WithPeerId::new(
                     PeerId::random(),
@@ -1125,8 +1321,9 @@ mod tests {
                 )))
             }
 
-            let access_lists = hashes
+            let mut access_lists: Vec<_> = hashes
                 .into_iter()
+                .take(self.access_list_soft_limit.load(Ordering::SeqCst))
                 .map(|hash| {
                     self.access_lists
                         .lock()
@@ -1135,6 +1332,9 @@ mod tests {
                         .unwrap_or_else(|| Bytes::from_static(&[EMPTY_LIST_CODE]))
                 })
                 .collect();
+            for _ in 0..self.extra_access_list_entries.load(Ordering::SeqCst) {
+                access_lists.push(Bytes::from_static(&[EMPTY_LIST_CODE]));
+            }
 
             futures::future::ready(Ok(WithPeerId::new(
                 PeerId::random(),
@@ -1262,6 +1462,131 @@ 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 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, received_access_lists) = response;
+        assert_eq!(blocks.len(), 3);
+        let expected = {
+            let access_lists = access_lists.lock();
+            blocks
+                .iter()
+                .map(|block| access_lists.get(&block.hash()).cloned().expect("access list exists"))
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(received_access_lists, Some(BlockAccessLists(expected)));
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn download_full_block_range_with_access_lists_preserves_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, received_access_lists) = response;
+        assert_eq!(blocks.len(), 3);
+        assert_eq!(received_access_lists, Some(BlockAccessLists(Vec::new())));
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+    }
+
+    #[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, received_access_lists) = 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()
+                .take(2)
+                .map(|block| access_lists.get(&block.hash()).cloned().expect("access list exists"))
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(received_access_lists, Some(BlockAccessLists(expected)));
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+    }
+
+    #[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, received_access_lists) = 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!(received_access_lists.is_none());
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn download_full_block_range_with_access_lists_rejects_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, received_access_lists) = 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!(received_access_lists.is_none());
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+        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/src/lib.rs b/crates/net/peers/src/lib.rs
index 9b6ee1f0280..fe02ffe59cc 100644
--- a/crates/net/peers/src/lib.rs
+++ b/crates/net/peers/src/lib.rs
@@ -125,20 +125,38 @@ pub enum AnyNode {
 
 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,
+        }
+    }
+
+    /// 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,
         }
     }
 
     /// 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(_) => 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,7 +170,7 @@ impl AnyNode {
                 .into_ipv4_mapped();
                 Some(node_record)
             }
-            _ => None,
+            Self::PeerId(_) => None,
         }
     }
 }

From c77e449e4ed75f952c4713f2f6feb26467c57948 Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Fri, 1 May 2026 08:35:24 +0200
Subject: [PATCH 010/335] fix(cli): verify repaired trie state root before
 commit (#23854)

Co-authored-by: Brian Picciano <933154+mediocregopher@users.noreply.github.com>
Co-authored-by: Amp <amp@ampcode.com>
---
 crates/cli/commands/src/db/repair_trie.rs | 50 +++++++++++++++++++++--
 1 file changed, 47 insertions(+), 3 deletions(-)

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

From 0d07d6ae69d4226881fec2bf1a83f8183c453101 Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Fri, 1 May 2026 16:56:40 +0530
Subject: [PATCH 011/335] chore: update rpc-compat expected failures (#23867)

---
 .github/scripts/hive/expected_failures.yaml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

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)

From 70fc51e3de5e8f7fc901b99b7d15aeb7c96d663e Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Fri, 1 May 2026 20:12:22 +0800
Subject: [PATCH 012/335] fix(reth-bb): renumber bal_index space at segment
 boundaries (#23868)

---
 bin/reth-bb/src/evm.rs                        | 83 ++++++++++++++++++-
 bin/reth-bb/src/evm_config.rs                 | 26 +++++-
 .../src/bench/generate_big_block.rs           | 40 +++++++--
 3 files changed, 136 insertions(+), 13 deletions(-)

diff --git a/bin/reth-bb/src/evm.rs b/bin/reth-bb/src/evm.rs
index a4cd0761be2..92360024391 100644
--- a/bin/reth-bb/src/evm.rs
+++ b/bin/reth-bb/src/evm.rs
@@ -106,6 +106,28 @@ pub(crate) type BlockHashSeeder<DB> = fn(&mut DB, &[(u64, B256)]);
 /// Function pointer that reads the BAL index from the DB.
 pub(crate) type BalIndexReader<DB> = fn(&DB) -> u64;
 
+/// 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.
 ///
@@ -143,6 +165,14 @@ where
     block_hash_seeder: Option<BlockHashSeeder<DB>>,
     /// Callback to read the BAL index from the DB.
     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,6 +193,7 @@ where
     >,
     TxEnv: FromRecoveredTx<TransactionSigned> + FromTxWithEncoded<TransactionSigned>,
 {
+    #[expect(clippy::too_many_arguments)]
     pub(crate) fn new(
         evm: EthEvm<DB, I, P>,
         ctx: EthBlockExecutionCtx<'a>,
@@ -171,6 +202,8 @@ where
         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);
         Self {
@@ -182,6 +215,8 @@ where
             shared_hook: Arc::new(Mutex::new(None)),
             block_hash_seeder,
             bal_index_reader,
+            bal_index_bumper,
+            bal_index_setter,
             initialized: false,
         }
     }
@@ -232,6 +267,17 @@ where
         self.reseed_block_hashes_for(block_number);
 
         if bal_index > 0 {
+            // 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);
+            }
             self.plan = None;
         }
 
@@ -329,13 +375,22 @@ where
 
         // 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;
         let spec = inner.spec.clone();
         let receipt_builder = inner.receipt_builder;
         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.
@@ -387,9 +442,17 @@ where
             .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()?;
 
+        // Renumbering: bump bal_index so the upcoming `inner.commit_transaction`
+        // for tx 0 of this segment lands at K+2 (visible to its worker via
+        // strict less-than reads of K+2, which include both K and K+1).
+        if let Some(bumper) = self.bal_index_bumper {
+            bumper(self.inner_mut().evm_mut().db_mut());
+        }
+
         trace!(target: "engine::bb::evm", "Started segment {seg_idx}");
 
         Ok(())
@@ -586,6 +649,8 @@ impl<Spec> BbBlockExecutorFactory<Spec> {
         ctx: EthBlockExecutionCtx<'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,
@@ -601,6 +666,8 @@ impl<Spec> BbBlockExecutorFactory<Spec> {
             plan,
             block_hash_seeder,
             bal_index_reader,
+            bal_index_bumper,
+            bal_index_setter,
         )
     }
 }
@@ -635,6 +702,16 @@ where
         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,
+            plan,
+            None,
+            None,
+            None,
+            None,
+        )
     }
 }
diff --git a/bin/reth-bb/src/evm_config.rs b/bin/reth-bb/src/evm_config.rs
index c371f6afce6..a0e1e437065 100644
--- a/bin/reth-bb/src/evm_config.rs
+++ b/bin/reth-bb/src/evm_config.rs
@@ -110,6 +110,27 @@ fn read_bal_index<DB>(state: &&mut revm::database::State<DB>) -> u64 {
     state.bal_state.bal_index()
 }
 
+/// 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`.
+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).
+fn set_bal_index<DB: revm::Database>(state: &mut &mut revm::database::State<DB>, index: u64) {
+    state.set_bal_index(index);
+}
+
 // ---------------------------------------------------------------------------
 // ConfigureEvm
 // ---------------------------------------------------------------------------
@@ -183,12 +204,15 @@ 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>),
         )
     }
 }
diff --git a/bin/reth-bench/src/bench/generate_big_block.rs b/bin/reth-bench/src/bench/generate_big_block.rs
index 53a504c054a..6b1bbad54e6 100644
--- a/bin/reth-bench/src/bench/generate_big_block.rs
+++ b/bin/reth-bench/src/bench/generate_big_block.rs
@@ -456,9 +456,12 @@ impl Command {
                 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)
+                for (block_idx, ((block_data, receipts), block_access_list)) in
+                    blocks.into_iter().zip(block_receipts).zip(block_access_lists).enumerate()
                 {
+                    // Segment index in the merged big block. The base block is
+                    // segment 0; subsequent blocks are segments 1, 2, ...
+                    let segment_idx = (block_idx + 1) as u64;
                     let block_v1 = block_data.payload.as_v1();
                     let block_gas = block_v1.gas_used;
                     total_gas_used += block_gas;
@@ -469,6 +472,7 @@ impl Command {
                             merged_block_access_list.get_or_insert_with(Default::default),
                             block_access_list,
                             cumulative_tx_count as u64,
+                            segment_idx,
                         );
                     }
 
@@ -734,6 +738,7 @@ fn merge_block_access_list(
     merged: &mut BlockAccessList,
     incoming: BlockAccessList,
     tx_index_offset: u64,
+    segment_idx: u64,
 ) {
     let mut account_positions = merged
         .iter()
@@ -742,7 +747,7 @@ fn merge_block_access_list(
         .collect::<HashMap<_, _>>();
 
     for mut account_changes in incoming {
-        shift_account_changes(&mut account_changes, tx_index_offset);
+        shift_account_changes(&mut account_changes, tx_index_offset, segment_idx);
 
         if let Some(&idx) = account_positions.get(&account_changes.address) {
             merge_account_changes(&mut merged[idx], account_changes);
@@ -753,20 +758,37 @@ fn merge_block_access_list(
     }
 }
 
-fn shift_account_changes(account_changes: &mut AccountChanges, tx_index_offset: u64) {
+fn shift_account_changes(
+    account_changes: &mut AccountChanges,
+    tx_index_offset: u64,
+    segment_idx: u64,
+) {
+    // Per-block BALs use block_access_index = 0 for pre-execution writes
+    // (system contract calls before any tx), 1..tx_count for tx commits, and
+    // tx_count+1 for post-execution.
+    //
+    // Renumbering: each segment boundary reserves two distinct bal_indexes —
+    // one for the prior segment's `finish()` (post-execution withdrawals +
+    // EIP-7002/7251 system calls) and one for the new segment's
+    // `apply_pre_execution_changes()` (EIP-2935/EIP-4788). The renumbered
+    // bal_index for a block-local idx in segment `k` is
+    // `idx + tx_index_offset + 2*k`. This ensures BAL workers reading via
+    // `BalWrites::get` (strict less-than) see all prior segments' boundary
+    // writes.
+    let shift = tx_index_offset + 2 * segment_idx;
     for slot_changes in &mut account_changes.storage_changes {
         for change in &mut slot_changes.changes {
-            change.block_access_index += tx_index_offset;
+            change.block_access_index += shift;
         }
     }
     for change in &mut account_changes.balance_changes {
-        change.block_access_index += tx_index_offset;
+        change.block_access_index += shift;
     }
     for change in &mut account_changes.nonce_changes {
-        change.block_access_index += tx_index_offset;
+        change.block_access_index += shift;
     }
     for change in &mut account_changes.code_changes {
-        change.block_access_index += tx_index_offset;
+        change.block_access_index += shift;
     }
 }
 
@@ -865,7 +887,7 @@ mod tests {
             },
         ];
 
-        merge_block_access_list(&mut merged, incoming, 3);
+        merge_block_access_list(&mut merged, incoming, 3, 0);
 
         assert_eq!(merged.len(), 2);
 

From 38c627ce8f1a3bb82bed8a6beb3016f62c50016d Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Fri, 1 May 2026 20:47:26 +0400
Subject: [PATCH 013/335] chore(deps): bump hickory-resolver (#23914)

---
 Cargo.lock                      | 190 +++++++++++++++++++++++++++-----
 Cargo.toml                      |   2 +-
 crates/net/dns/src/resolver.rs  |  15 ++-
 crates/net/network/src/error.rs |   4 +-
 deny.toml                       |   4 +
 5 files changed, 180 insertions(+), 35 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d185cfdcc14..6abc29632f3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2173,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"
@@ -2592,6 +2603,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"
@@ -3373,18 +3394,6 @@ dependencies = [
  "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"
@@ -4254,6 +4263,7 @@ dependencies = [
  "cfg-if",
  "libc",
  "r-efi 6.0.0",
+ "rand_core 0.10.1",
  "wasip2",
  "wasip3",
 ]
@@ -4503,48 +4513,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",
@@ -5073,6 +5107,9 @@ name = "ipnet"
 version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "iri-string"
@@ -5167,6 +5204,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"
@@ -5995,6 +6062,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"
@@ -6712,6 +6785,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"
@@ -7015,6 +7099,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"
@@ -7054,6 +7149,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"
@@ -10968,9 +11069,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",
@@ -10989,9 +11090,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",
@@ -11189,7 +11290,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",
@@ -11479,6 +11580,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"
@@ -11751,6 +11868,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"
diff --git a/Cargo.toml b/Cargo.toml
index bb76b5ffb4b..f30a175896b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -666,7 +666,7 @@ 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"
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/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/deny.toml b/deny.toml
index 7f792c3016f..f4888f42900 100644
--- a/deny.toml
+++ b/deny.toml
@@ -16,6 +16,10 @@ 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-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",
 ]
 
 # This section is considered when running `cargo deny check bans`.

From 6d9ea5af49c2b405e9bf2fc56cd88ea97db9d763 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Sat, 2 May 2026 17:11:29 +0200
Subject: [PATCH 014/335] feat(engine): add shared block accessor to
 EthBuiltPayload (#23862)

---
 crates/ethereum/engine-primitives/src/payload.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/crates/ethereum/engine-primitives/src/payload.rs b/crates/ethereum/engine-primitives/src/payload.rs
index 1e9a9eaaf59..fa21d67a0fb 100644
--- a/crates/ethereum/engine-primitives/src/payload.rs
+++ b/crates/ethereum/engine-primitives/src/payload.rs
@@ -62,6 +62,11 @@ impl<N: NodePrimitives> EthBuiltPayload<N> {
         &self.block
     }
 
+    /// Returns the built block with shared ownership.
+    pub const fn block_arc(&self) -> &Arc<SealedBlock<N::Block>> {
+        &self.block
+    }
+
     /// Fees of the block
     pub const fn fees(&self) -> U256 {
         self.fees

From b2794548e98a153be0a7f689f1a917944d823856 Mon Sep 17 00:00:00 2001
From: joshieDo <93316087+joshieDo@users.noreply.github.com>
Date: Sat, 2 May 2026 17:27:23 +0200
Subject: [PATCH 015/335] feat(eth-wire): add capability message id helpers
 (#23908)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/eth-wire/src/capability.rs | 64 ++++++++++++++++++++++++++-
 1 file changed, 63 insertions(+), 1 deletion(-)

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

From 44879c32020594ce9e322b264e4ce59022b964db Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Sat, 2 May 2026 17:55:26 +0200
Subject: [PATCH 016/335] feat(payload): expose built payload block access list
 (#23860)

---
 crates/ethereum/engine-primitives/src/payload.rs | 4 ++++
 crates/payload/basic/src/stack.rs                | 9 ++++++++-
 crates/payload/primitives/src/traits.rs          | 9 ++++++++-
 3 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/crates/ethereum/engine-primitives/src/payload.rs b/crates/ethereum/engine-primitives/src/payload.rs
index fa21d67a0fb..7f52d8e2a3c 100644
--- a/crates/ethereum/engine-primitives/src/payload.rs
+++ b/crates/ethereum/engine-primitives/src/payload.rs
@@ -242,6 +242,10 @@ impl<N: NodePrimitives> BuiltPayload for EthBuiltPayload<N> {
         self.fees
     }
 
+    fn block_access_list(&self) -> Option<&Bytes> {
+        self.block_access_list.as_ref()
+    }
+
     fn requests(&self) -> Option<Requests> {
         self.requests.clone()
     }
diff --git a/crates/payload/basic/src/stack.rs b/crates/payload/basic/src/stack.rs
index f953f16be23..9f390dd4d9a 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(),
diff --git a/crates/payload/primitives/src/traits.rs b/crates/payload/primitives/src/traits.rs
index c031b604f53..3bc340922ed 100644
--- a/crates/payload/primitives/src/traits.rs
+++ b/crates/payload/primitives/src/traits.rs
@@ -3,7 +3,7 @@
 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;
@@ -81,6 +81,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.

From 30fe86d25568399bd2b64ff93562b440a5000ca4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Viktor=20Horv=C3=A1th?= <viktorhorvathhorth@gmail.com>
Date: Sat, 2 May 2026 23:54:39 +0800
Subject: [PATCH 017/335] docs: update admin namespace docs (#23916)

---
 docs/vocs/docs/pages/jsonrpc/admin.mdx | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

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

From ddb3819ec945958ca01032390b8c7a1c83e8df2f Mon Sep 17 00:00:00 2001
From: Karl Yu <43113774+0xKarl98@users.noreply.github.com>
Date: Sun, 3 May 2026 15:13:58 +0800
Subject: [PATCH 018/335] feat(storage): add in-memory BAL retention (#23873)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 Cargo.lock                         |   5 +-
 Cargo.toml                         |   2 +-
 crates/storage/provider/Cargo.toml |   1 +
 crates/storage/provider/src/bal.rs | 169 +++++++++++++++++++++++++++--
 crates/storage/provider/src/lib.rs |   2 +-
 5 files changed, 166 insertions(+), 13 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6abc29632f3..4dfd3c8b791 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -250,9 +250,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-eip7928"
-version = "0.3.4"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "407510740da514b694fecb44d8b3cebdc60d448f70cc5d24743e8ba273448a6e"
+checksum = "ec6ae911a2fc304a7cb80a79fb7bed6d1474aed4e7c203df1f8ff538f64fc78d"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
@@ -9557,6 +9557,7 @@ name = "reth-provider"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
+ "alloy-eip7928",
  "alloy-eips 2.0.4",
  "alloy-genesis",
  "alloy-primitives",
diff --git a/Cargo.toml b/Cargo.toml
index f30a175896b..f93cd646b90 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -449,7 +449,7 @@ alloy-sol-types = { version = "1.5.6", default-features = false }
 
 alloy-chains = { version = "0.2.33", default-features = false }
 alloy-eip2124 = { version = "0.2.0", default-features = false }
-alloy-eip7928 = { version = "0.3.4", default-features = false }
+alloy-eip7928 = { version = "0.3.5", 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-trie = { version = "0.9.4", default-features = false }
diff --git a/crates/storage/provider/Cargo.toml b/crates/storage/provider/Cargo.toml
index f5ca403530f..40c4f13268d 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
diff --git a/crates/storage/provider/src/bal.rs b/crates/storage/provider/src/bal.rs
index b6804a1b456..2f7e6013709 100644
--- a/crates/storage/provider/src/bal.rs
+++ b/crates/storage/provider/src/bal.rs
@@ -1,32 +1,129 @@
+use alloy_eip7928::BAL_RETENTION_PERIOD_SLOTS;
 use alloy_primitives::{BlockHash, BlockNumber, Bytes};
 use parking_lot::RwLock;
+use reth_prune_types::PruneMode;
 use reth_storage_api::{BalStore, GetBlockAccessListLimit};
 use reth_storage_errors::provider::ProviderResult;
-use std::{collections::HashMap, sync::Arc};
+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>>,
+}
+
+impl InMemoryBalStore {
+    /// Creates a new in-memory BAL store with the given config.
+    pub fn new(config: BalConfig) -> Self {
+        Self { config, inner: Arc::new(RwLock::new(InMemoryBalStoreInner::default())) }
+    }
+}
+
+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 {
+    /// Returns a config with no in-memory BAL retention limit.
+    pub const fn unbounded() -> Self {
+        Self { in_memory_retention: None }
+    }
+
+    /// 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(PruneMode::Distance(BAL_RETENTION_PERIOD_SLOTS))
+    }
+}
+
+#[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.
+    fn prune(&mut self, prune_mode: Option<PruneMode>) {
+        let Some(prune_mode) = prune_mode else { return };
+        let Some(tip) = self.highest_block_number else { return };
+
+        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 {
+                self.entries.remove(&hash);
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+struct BalEntry {
+    block_number: BlockNumber,
+    bal: Bytes,
 }
 
 impl BalStore for InMemoryBalStore {
     fn insert(
         &self,
         block_hash: BlockHash,
-        _block_number: BlockNumber,
+        block_number: BlockNumber,
         bal: Bytes,
     ) -> ProviderResult<()> {
-        self.entries.write().insert(block_hash, bal);
+        let mut inner = self.inner.write();
+        inner.insert(block_hash, block_number, bal);
+        inner.prune(self.config.in_memory_retention);
         Ok(())
     }
 
     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)
@@ -38,11 +135,15 @@ impl BalStore for InMemoryBalStore {
         limit: GetBlockAccessListLimit,
         out: &mut Vec<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]));
+            let bal = inner
+                .entries
+                .get(hash)
+                .map(|entry| entry.bal.clone())
+                .unwrap_or_else(|| Bytes::from_static(&[0xc0]));
             size += bal.len();
             out.push(bal);
 
@@ -106,4 +207,54 @@ mod tests {
 
         assert_eq!(limited, vec![bal0, 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(old_hash, 1, old_bal).unwrap();
+        store.insert(retained_hash, BAL_RETENTION_PERIOD_SLOTS, retained_bal.clone()).unwrap();
+        store.insert(tip_hash, BAL_RETENTION_PERIOD_SLOTS + 2, 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 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(old_hash, 1, old_bal.clone()).unwrap();
+        store.insert(tip_hash, BAL_RETENTION_PERIOD_SLOTS + 1, tip_bal.clone()).unwrap();
+
+        assert_eq!(
+            store.get_by_hashes(&[old_hash, tip_hash]).unwrap(),
+            vec![Some(old_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(hash, 1, Bytes::from_static(b"old")).unwrap();
+        store.insert(hash, 2, bal.clone()).unwrap();
+
+        assert_eq!(store.get_by_hashes(&[hash]).unwrap(), vec![Some(bal)]);
+    }
 }
diff --git a/crates/storage/provider/src/lib.rs b/crates/storage/provider/src/lib.rs
index 890051b9d1b..dfadfbc0ae1 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,

From d2b4ab53d4189b682afe12af090111347df3b1c5 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 4 May 2026 11:03:18 +0200
Subject: [PATCH 019/335] chore: fix nightly clippy warnings (#23923)

---
 crates/cli/commands/src/test_vectors/compact.rs          | 8 ++++----
 crates/consensus/debug-client/src/providers/etherscan.rs | 2 +-
 crates/storage/provider/src/test_utils/mock.rs           | 2 +-
 crates/transaction-pool/src/blobstore/mem.rs             | 4 ++--
 examples/beacon-api-sidecar-fetcher/src/mined_sidecar.rs | 6 +++---
 5 files changed, 11 insertions(+), 11 deletions(-)

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/debug-client/src/providers/etherscan.rs b/crates/consensus/debug-client/src/providers/etherscan.rs
index ea21d95e73d..92dab80bf7f 100644
--- a/crates/consensus/debug-client/src/providers/etherscan.rs
+++ b/crates/consensus/debug-client/src/providers/etherscan.rs
@@ -55,7 +55,7 @@ where
         block_number_or_tag: BlockNumberOrTag,
     ) -> eyre::Result<PrimitiveBlock> {
         let tag = match block_number_or_tag {
-            BlockNumberOrTag::Number(num) => format!("{num:#02x}"),
+            BlockNumberOrTag::Number(num) => format!("{num:#x}"),
             tag => tag.to_string(),
         };
 
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/transaction-pool/src/blobstore/mem.rs b/crates/transaction-pool/src/blobstore/mem.rs
index dc7672e9859..a7a98a574f2 100644
--- a/crates/transaction-pool/src/blobstore/mem.rs
+++ b/crates/transaction-pool/src/blobstore/mem.rs
@@ -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)
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);
                             }
                         }

From 8940f2f0d66757ac35dd7d8d632c67d701c4c0ea Mon Sep 17 00:00:00 2001
From: Karl Yu <43113774+0xKarl98@users.noreply.github.com>
Date: Mon, 4 May 2026 17:21:41 +0800
Subject: [PATCH 020/335] feat(storage): add BAL notification stream (#23918)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 Cargo.lock                              |   5 +
 crates/net/network/tests/it/requests.rs |  27 +++--
 crates/storage/provider/Cargo.toml      |   6 +-
 crates/storage/provider/src/bal.rs      | 143 ++++++++++++++++++++----
 crates/storage/provider/src/lib.rs      |   6 +-
 crates/storage/storage-api/Cargo.toml   |   7 ++
 crates/storage/storage-api/src/bal.rs   |  86 ++++++++++----
 crates/trie/sparse/src/parallel.rs      |   4 +-
 8 files changed, 225 insertions(+), 59 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4dfd3c8b791..cfb2bc8b0d2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9591,6 +9591,7 @@ dependencies = [
  "reth-storage-errors",
  "reth-tasks",
  "reth-testing-utils",
+ "reth-tokio-util",
  "reth-tracing",
  "reth-trie",
  "reth-trie-db",
@@ -9601,6 +9602,7 @@ dependencies = [
  "strum",
  "tempfile",
  "tokio",
+ "tokio-stream",
  "tracing",
 ]
 
@@ -10251,9 +10253,12 @@ dependencies = [
  "reth-prune-types",
  "reth-stages-types",
  "reth-storage-errors",
+ "reth-tokio-util",
  "reth-trie-common",
  "revm-database",
  "serde_json",
+ "tokio",
+ "tokio-stream",
 ]
 
 [[package]]
diff --git a/crates/net/network/tests/it/requests.rs b/crates/net/network/tests/it/requests.rs
index ce5d57cfe4b..a209537c9af 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, Bytes, Sealed, B256};
 use rand::Rng;
 use reth_eth_wire::{BlockAccessLists, EthVersion, GetBlockAccessLists, HeadersDirection};
 use reth_ethereum_primitives::Block;
@@ -18,7 +19,7 @@ use reth_network_p2p::{
     headers::client::{HeadersClient, HeadersRequest},
     BalRequirement, BlockAccessListsClient,
 };
-use reth_provider::{test_utils::MockEthProvider, BalStoreHandle, InMemoryBalStore};
+use reth_provider::{test_utils::MockEthProvider, BalStoreHandle, InMemoryBalStore, SealedBal};
 use reth_transaction_pool::test_utils::{TestPool, TransactionGenerator};
 use std::sync::Arc;
 use tokio::sync::oneshot;
@@ -544,8 +545,8 @@ 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!(
@@ -568,9 +569,9 @@ 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;
 
@@ -588,8 +589,8 @@ 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;
 
@@ -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,7 +638,7 @@ 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();
@@ -727,3 +728,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/storage/provider/Cargo.toml b/crates/storage/provider/Cargo.toml
index 40c4f13268d..052ba6c3e9c 100644
--- a/crates/storage/provider/Cargo.toml
+++ b/crates/storage/provider/Cargo.toml
@@ -57,10 +57,11 @@ notify = { workspace = true, default-features = false, features = ["macos_fseven
 parking_lot.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
@@ -85,6 +86,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"]
@@ -103,6 +105,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 2f7e6013709..fa68bbc3446 100644
--- a/crates/storage/provider/src/bal.rs
+++ b/crates/storage/provider/src/bal.rs
@@ -1,9 +1,13 @@
 use alloy_eip7928::BAL_RETENTION_PERIOD_SLOTS;
+use alloy_eips::NumHash;
 use alloy_primitives::{BlockHash, BlockNumber, Bytes};
 use parking_lot::RwLock;
 use reth_prune_types::PruneMode;
-use reth_storage_api::{BalStore, GetBlockAccessListLimit};
+use reth_storage_api::{
+    BalNotification, BalNotificationStream, BalStore, GetBlockAccessListLimit, SealedBal,
+};
 use reth_storage_errors::provider::ProviderResult;
+use reth_tokio_util::EventSender;
 use std::{
     collections::{BTreeMap, HashMap},
     sync::Arc,
@@ -14,15 +18,25 @@ use std::{
 pub struct InMemoryBalStore {
     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 {
-        Self { config, inner: Arc::new(RwLock::new(InMemoryBalStoreInner::default())) }
+        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())
@@ -106,15 +120,11 @@ struct BalEntry {
 }
 
 impl BalStore for InMemoryBalStore {
-    fn insert(
-        &self,
-        block_hash: BlockHash,
-        block_number: BlockNumber,
-        bal: Bytes,
-    ) -> ProviderResult<()> {
+    fn insert(&self, num_hash: NumHash, bal: SealedBal) -> ProviderResult<()> {
         let mut inner = self.inner.write();
-        inner.insert(block_hash, block_number, bal);
+        inner.insert(num_hash.hash, num_hash.number, bal.clone_inner());
         inner.prune(self.config.in_memory_retention);
+        self.notifications.notify(BalNotification::new(num_hash, bal));
         Ok(())
     }
 
@@ -158,12 +168,21 @@ impl BalStore for InMemoryBalStore {
     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() {
@@ -172,7 +191,7 @@ 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]);
     }
@@ -194,9 +213,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(
@@ -218,9 +237,19 @@ mod tests {
         let retained_bal = Bytes::from_static(b"retained");
         let tip_bal = Bytes::from_static(b"tip");
 
-        store.insert(old_hash, 1, old_bal).unwrap();
-        store.insert(retained_hash, BAL_RETENTION_PERIOD_SLOTS, retained_bal.clone()).unwrap();
-        store.insert(tip_hash, BAL_RETENTION_PERIOD_SLOTS + 2, tip_bal.clone()).unwrap();
+        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(),
@@ -236,8 +265,13 @@ mod tests {
         let old_bal = Bytes::from_static(b"old");
         let tip_bal = Bytes::from_static(b"tip");
 
-        store.insert(old_hash, 1, old_bal.clone()).unwrap();
-        store.insert(tip_hash, BAL_RETENTION_PERIOD_SLOTS + 1, tip_bal.clone()).unwrap();
+        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(),
@@ -252,9 +286,76 @@ mod tests {
         let hash = B256::random();
         let bal = Bytes::from_static(b"bal");
 
-        store.insert(hash, 1, Bytes::from_static(b"old")).unwrap();
-        store.insert(hash, 2, bal.clone()).unwrap();
+        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)
+        );
+    }
+
+    #[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 dfadfbc0ae1..909a9c24b38 100644
--- a/crates/storage/provider/src/lib.rs
+++ b/crates/storage/provider/src/lib.rs
@@ -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/storage-api/Cargo.toml b/crates/storage/storage-api/Cargo.toml
index 591b3205016..d00ad0e5dcd 100644
--- a/crates/storage/storage-api/Cargo.toml
+++ b/crates/storage/storage-api/Cargo.toml
@@ -33,6 +33,12 @@ 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 +58,7 @@ std = [
     "reth-db-models/std",
     "reth-trie-common/std",
     "serde_json?/std",
+    "dep:reth-tokio-util",
 ]
 
 db-api = [
diff --git a/crates/storage/storage-api/src/bal.rs b/crates/storage/storage-api/src/bal.rs
index 4e82595d3d2..c6dead0bb36 100644
--- a/crates/storage/storage-api/src/bal.rs
+++ b/crates/storage/storage-api/src/bal.rs
@@ -1,7 +1,38 @@
 use alloc::{sync::Arc, vec::Vec};
-use alloy_primitives::{BlockHash, BlockNumber, Bytes};
+use alloy_eips::NumHash;
+use alloy_primitives::{BlockHash, BlockNumber, Bytes, Sealed};
 use reth_storage_errors::provider::ProviderResult;
 
+/// 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).
 ///
 /// This abstraction intentionally does not prescribe where BALs live. Implementations may keep
@@ -10,12 +41,7 @@ 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<()>;
+    fn insert(&self, num_hash: NumHash, bal: SealedBal) -> ProviderResult<()>;
 
     /// Fetch BALs for the given block hashes.
     ///
@@ -64,6 +90,13 @@ pub trait BalStore: Send + Sync + 'static {
     ///
     /// Implementations may stop at the first gap and return the contiguous prefix.
     fn get_by_range(&self, start: BlockNumber, count: u64) -> ProviderResult<Vec<Bytes>>;
+
+    /// Returns a stream of BAL insert notifications.
+    ///
+    /// 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 +138,8 @@ 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)
     }
 
     /// Fetch BALs for the given block hashes.
@@ -147,6 +175,13 @@ impl BalStoreHandle {
     pub fn get_by_range(&self, start: BlockNumber, count: u64) -> ProviderResult<Vec<Bytes>> {
         self.inner.get_by_range(start, count)
     }
+
+    /// Returns a stream of BAL insert notifications.
+    #[cfg(feature = "std")]
+    #[inline]
+    pub fn bal_stream(&self) -> BalNotificationStream {
+        self.inner.bal_stream()
+    }
 }
 
 impl Default for BalStoreHandle {
@@ -173,12 +208,7 @@ 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(())
     }
 
@@ -208,12 +238,19 @@ impl BalStore for NoopBalStore {
     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()
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use alloy_primitives::B256;
+    #[cfg(feature = "std")]
+    use tokio_stream::StreamExt;
 
     #[test]
     fn noop_store_returns_empty_results() {
@@ -249,4 +286,13 @@ 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());
+    }
 }
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")]

From 0b55b2c5db1f3058937f989751c289d3ff0987ed Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 4 May 2026 13:22:28 +0200
Subject: [PATCH 021/335] refactor(payload): require built payload conversion
 (#23928)

---
 crates/e2e-test-utils/src/node.rs             |  6 +-----
 crates/engine/local/src/miner.rs              |  3 +--
 crates/ethereum/engine-primitives/src/lib.rs  | 16 +++++++++-------
 crates/node/builder/src/components/payload.rs |  5 ++++-
 crates/payload/primitives/src/lib.rs          |  2 +-
 5 files changed, 16 insertions(+), 16 deletions(-)

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/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/ethereum/engine-primitives/src/lib.rs b/crates/ethereum/engine-primitives/src/lib.rs
index 962f6241f4e..e08dbc22b42 100644
--- a/crates/ethereum/engine-primitives/src/lib.rs
+++ b/crates/ethereum/engine-primitives/src/lib.rs
@@ -34,14 +34,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;
@@ -59,6 +60,7 @@ impl<
 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>
diff --git a/crates/node/builder/src/components/payload.rs b/crates/node/builder/src/components/payload.rs
index 5afe08ee5e9..f245aff5c60 100644
--- a/crates/node/builder/src/components/payload.rs
+++ b/crates/node/builder/src/components/payload.rs
@@ -105,7 +105,10 @@ where
             payload_builder,
         );
         let (payload_service, payload_service_handle) =
-            PayloadBuilderService::new(payload_generator, ctx.provider().canonical_state_stream());
+            PayloadBuilderService::<_, _, <Node::Types as NodeTypes>::Payload>::new(
+                payload_generator,
+                ctx.provider().canonical_state_stream(),
+            );
 
         ctx.task_executor().spawn_critical_task("payload builder service", payload_service);
 
diff --git a/crates/payload/primitives/src/lib.rs b/crates/payload/primitives/src/lib.rs
index 4123f4ea168..f2db62acfd1 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;
 

From d50fed35cb8f9ecb967d72c6c636bcfe26180d27 Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Mon, 4 May 2026 13:29:31 +0200
Subject: [PATCH 022/335] perf(engine): acknowledge save_blocks before prune
 (#23904)

Co-authored-by: Amp <amp@users.noreply.github.com>
Co-authored-by: Amp <amp@ampcode.com>
---
 crates/engine/tree/src/persistence.rs | 32 ++++++++++++++-------------
 1 file changed, 17 insertions(+), 15 deletions(-)

diff --git a/crates/engine/tree/src/persistence.rs b/crates/engine/tree/src/persistence.rs
index da778e1a30f..e526a41c7ee 100644
--- a/crates/engine/tree/src/persistence.rs
+++ b/crates/engine/tree/src/persistence.rs
@@ -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) => {
@@ -179,21 +180,6 @@ where
 
             provider_rw.commit()?;
             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 +188,22 @@ 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()?;
+            debug!(target: "engine::persistence", tip=?block_number, "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.

From e2ad1e44c2ca3470f3b5612d70aecb7e4ddc8e96 Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Mon, 4 May 2026 17:08:30 +0530
Subject: [PATCH 023/335] feat: add bal validation in post execution (#23496)

Co-authored-by: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
---
 crates/cli/commands/src/re_execute.rs            |  2 +-
 crates/consensus/consensus/Cargo.toml            |  5 +----
 crates/consensus/consensus/src/lib.rs            |  4 ++++
 crates/consensus/consensus/src/noop.rs           |  2 ++
 crates/consensus/consensus/src/test_utils.rs     |  2 ++
 crates/engine/tree/src/tree/payload_validator.rs |  2 +-
 crates/ethereum/consensus/src/lib.rs             | 11 +++++++++--
 crates/ethereum/consensus/src/validation.rs      | 15 +++++++++++++++
 crates/rpc/rpc/src/validation.rs                 |  2 +-
 crates/stages/stages/src/stages/execution/mod.rs |  4 +++-
 testing/ef-tests/src/cases/blockchain_test.rs    |  2 +-
 11 files changed, 40 insertions(+), 11 deletions(-)

diff --git a/crates/cli/commands/src/re_execute.rs b/crates/cli/commands/src/re_execute.rs
index 5923fde9f3c..04e2f6dfc25 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 {} {}",
diff --git a/crates/consensus/consensus/Cargo.toml b/crates/consensus/consensus/Cargo.toml
index 4d2c0ac0768..b5c394ac014 100644
--- a/crates/consensus/consensus/Cargo.toml
+++ b/crates/consensus/consensus/Cargo.toml
@@ -29,10 +29,7 @@ std = [
     "reth-primitives-traits/std",
     "alloy-primitives/std",
     "alloy-consensus/std",
-    "reth-primitives-traits/std",
     "reth-execution-types/std",
     "thiserror/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..6e9ed1950dc 100644
--- a/crates/consensus/consensus/src/lib.rs
+++ b/crates/consensus/consensus/src/lib.rs
@@ -85,6 +85,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>;
 }
 
@@ -474,6 +475,9 @@ pub enum ConsensusError {
     /// EIP-7825: Transaction gas limit exceeds maximum allowed
     #[error(transparent)]
     TransactionGasLimitTooHigh(Box<TxGasLimitTooHighErr>),
+    /// Error when the block access list hash doesn't match the expected value.
+    #[error("block access list hash mismatch: {0}")]
+    BlockAccessListHashMismatch(GotExpectedBoxed<B256>),
     /// Any additional consensus error, for example L2-specific errors.
     #[error(transparent)]
     Other(#[from] Arc<dyn Error + Send + Sync>),
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/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index d661bf02784..c7f603cfc20 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -1389,7 +1389,7 @@ where
             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)
+            self.consensus.validate_block_post_execution(block, output, receipt_root_bloom, None)
         {
             // call post-block hook
             self.on_invalid_block(parent_block, block, output, None, ctx.state_mut());
diff --git a/crates/ethereum/consensus/src/lib.rs b/crates/ethereum/consensus/src/lib.rs
index f1113898c0d..316b2e43589 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,
@@ -108,9 +109,15 @@ 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 = validate_block_post_execution(
+            block,
+            &self.chain_spec,
+            result,
+            receipt_root_bloom,
+            block_access_list_hash,
+        );
 
         if self.skip_requests_hash_check &&
             let Err(ConsensusError::BodyRequestsHashDiff(_)) = &res
diff --git a/crates/ethereum/consensus/src/validation.rs b/crates/ethereum/consensus/src/validation.rs
index 56ba60c5860..2d44c1cf660 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,7 @@ 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,
@@ -79,6 +81,19 @@ where
         }
     }
 
+    // Validate that the header block access list hash matches the calculated block access list hash
+    if chain_spec.is_amsterdam_active_at_timestamp(block.header().timestamp()) &&
+        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/rpc/rpc/src/validation.rs b/crates/rpc/rpc/src/validation.rs
index e1b3171d628..b5ab60a1c7f 100644
--- a/crates/rpc/rpc/src/validation.rs
+++ b/crates/rpc/rpc/src/validation.rs
@@ -202,7 +202,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)?;
 
diff --git a/crates/stages/stages/src/stages/execution/mod.rs b/crates/stages/stages/src/stages/execution/mod.rs
index bfd3b87104a..a2154fe54a7 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/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

From b45e99b8e7b6a890d8731a47cfde0f763f6084d3 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 4 May 2026 17:03:03 +0400
Subject: [PATCH 024/335] refactor(generate-big-blocks): don't recompute
 receipts root (#23930)

---
 .../src/bench/generate_big_block.rs           | 44 ++-----------------
 1 file changed, 4 insertions(+), 40 deletions(-)

diff --git a/bin/reth-bench/src/bench/generate_big_block.rs b/bin/reth-bench/src/bench/generate_big_block.rs
index 6b1bbad54e6..77774363558 100644
--- a/bin/reth-bench/src/bench/generate_big_block.rs
+++ b/bin/reth-bench/src/bench/generate_big_block.rs
@@ -5,14 +5,14 @@
 //! 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_consensus::TxEnvelope;
 use alloy_eips::{
     eip1559::BaseFeeParams,
     eip7840::BlobParams,
     eip7928::{AccountChanges, BlockAccessList, SlotChanges},
     Typed2718,
 };
-use alloy_primitives::{Bloom, Bytes, B256};
+use alloy_primitives::{Bytes, B256};
 use alloy_provider::{network::AnyNetwork, Provider, RootProvider};
 use alloy_rpc_client::ClientBuilder;
 use alloy_rpc_types_engine::{
@@ -28,7 +28,6 @@ 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},
@@ -354,7 +353,6 @@ impl Command {
 
             // Drain the prefetch stream until the gas target is reached for this big block.
             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;
 
@@ -401,7 +399,6 @@ impl Command {
 
                 accumulated_block_gas += block_gas;
                 blocks.push(execution_data);
-                block_receipts.push(consensus_receipts);
                 block_access_lists.push(block_access_list);
                 next_block += 1;
             }
@@ -419,25 +416,9 @@ impl Command {
 
             // 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
@@ -456,8 +437,8 @@ impl Command {
                 let mut total_gas_limit = base.payload.as_v1().gas_limit;
 
                 // Concatenate transactions from subsequent blocks and build env_switches
-                for (block_idx, ((block_data, receipts), block_access_list)) in
-                    blocks.into_iter().zip(block_receipts).zip(block_access_lists).enumerate()
+                for (block_idx, (block_data, block_access_list)) in
+                    blocks.into_iter().zip(block_access_lists).enumerate()
                 {
                     // Segment index in the merged big block. The base block is
                     // segment 0; subsequent blocks are segments 1, 2, ...
@@ -476,13 +457,6 @@ impl Command {
                         );
                     }
 
-                    // 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()));
 
@@ -492,21 +466,11 @@ impl Command {
                     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,

From d5c5b0b63308eb6ff3e3391a79ef4dbcfc4f8b52 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 4 May 2026 18:36:14 +0400
Subject: [PATCH 025/335] feat: spawn deferred trie work for directly inserted
 payloads (#23935)

---
 Cargo.lock                                    |  1 -
 crates/engine/tree/src/engine.rs              |  9 ++--
 crates/engine/tree/src/tree/mod.rs            | 16 ++++--
 .../engine/tree/src/tree/payload_validator.rs | 50 +++++++++++++------
 crates/node/builder/src/launch/engine.rs      |  2 +-
 crates/payload/builder-primitives/Cargo.toml  |  2 +-
 crates/payload/primitives/Cargo.toml          |  1 -
 crates/payload/primitives/src/traits.rs       | 48 ++----------------
 8 files changed, 60 insertions(+), 69 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cfb2bc8b0d2..0da98b255a1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9488,7 +9488,6 @@ dependencies = [
  "assert_matches",
  "auto_impl",
  "either",
- "reth-chain-state",
  "reth-chainspec",
  "reth-errors",
  "reth-execution-types",
diff --git a/crates/engine/tree/src/engine.rs b/crates/engine/tree/src/engine.rs
index 154b3b01e4f..c15acfc227d 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,
@@ -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/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index 1edf1496e23..41bd429373d 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -1548,8 +1548,8 @@ 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(()))
@@ -1558,6 +1558,17 @@ where
                         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 +1579,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()),
diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index c7f603cfc20..43e1d5a5703 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -73,7 +73,8 @@ use reth_evm::{
 };
 use reth_execution_cache::{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,
@@ -837,9 +838,9 @@ where
             ensure_ok_post_block!(overlay_factory.database_provider_ro(), block);
 
         let executed_block = self.spawn_deferred_trie_task(
-            block,
+            Arc::new(block),
             output,
-            &ctx,
+            ctx.state(),
             hashed_state,
             trie_output,
             changeset_provider,
@@ -1616,16 +1617,15 @@ where
     /// from the completed task or via fallback computation.
     fn spawn_deferred_trie_task(
         &self,
-        block: RecoveredBlock<N::Block>,
+        block: Arc<RecoveredBlock<N::Block>>,
         execution_outcome: Arc<BlockExecutionOutput<N::Receipt>>,
-        ctx: &TreeCtx<'_, N>,
+        state: &EngineApiTreeState<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()
+        let (anchor_hash, overlay_blocks) = state
             .tree_state
             .blocks_by_hash(block.parent_hash())
             .unwrap_or_else(|| (block.parent_hash(), Vec::new()));
@@ -1732,11 +1732,7 @@ where
             .executor()
             .spawn_blocking_named("trie-input", 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(
@@ -1940,7 +1936,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>;
@@ -2009,11 +2009,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 (lazy_overlay, anchor_hash) =
+            Self::get_parent_lazy_overlay(block.recovered_block.parent_hash(), state);
+        let overlay_factory = OverlayStateProviderFactory::new(
+            self.provider.clone(),
+            OverlayBuilder::<N>::new(anchor_hash, self.changeset_cache.clone())
+                .with_lazy_overlay(lazy_overlay),
+        );
+        let changeset_provider = overlay_factory.database_provider_ro()?;
+
+        Ok(self.spawn_deferred_trie_task(
+            block.recovered_block,
+            block.execution_output,
+            state,
+            LazyHashedPostState::ready(Arc::unwrap_or_clone(block.hashed_state)),
+            block.trie_updates,
+            changeset_provider,
+        ))
     }
 
     fn cache_for(&self, block_hash: B256) -> Option<SavedCache> {
diff --git a/crates/node/builder/src/launch/engine.rs b/crates/node/builder/src/launch/engine.rs
index 0b568564930..7e39de7f538 100644
--- a/crates/node/builder/src/launch/engine.rs
+++ b/crates/node/builder/src/launch/engine.rs
@@ -363,7 +363,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 => {
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/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/traits.rs b/crates/payload/primitives/src/traits.rs
index 3bc340922ed..4345cefea99 100644
--- a/crates/payload/primitives/src/traits.rs
+++ b/crates/payload/primitives/src/traits.rs
@@ -8,13 +8,9 @@ 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).

From a60c3ee3404cbb11be79f3fb250d354eccf7b489 Mon Sep 17 00:00:00 2001
From: sashass1315 <sashass1315@gmail.com>
Date: Mon, 4 May 2026 20:38:04 +0300
Subject: [PATCH 026/335] fix(net): validate EIP-1459 hash labels before
 caching entries (#22582)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/dns/src/error.rs |  4 ++
 crates/net/dns/src/lib.rs   | 64 ++++++++++++++++++++++++++----
 crates/net/dns/src/query.rs | 77 ++++++++++++++++++++++++++++++++++++-
 3 files changed, 137 insertions(+), 8 deletions(-)

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

From a8cab01133fed37e99624e7b114131a882c26740 Mon Sep 17 00:00:00 2001
From: Karl Yu <43113774+0xKarl98@users.noreply.github.com>
Date: Tue, 5 May 2026 15:03:22 +0800
Subject: [PATCH 027/335] feat(debug-client): pass execution data from
 providers (#23969)

---
 Cargo.lock                                    |  2 -
 crates/consensus/debug-client/Cargo.toml      |  2 -
 crates/consensus/debug-client/src/client.rs   | 59 +++++++++----------
 crates/consensus/debug-client/src/lib.rs      |  4 +-
 .../debug-client/src/providers/etherscan.rs   | 36 +++++------
 .../debug-client/src/providers/rpc.rs         | 25 ++++----
 crates/ethereum/node/src/node.rs              |  8 ++-
 crates/node/builder/src/launch/debug.rs       | 52 ++++++++--------
 8 files changed, 95 insertions(+), 93 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0da98b255a1..619b2419c61 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7891,7 +7891,6 @@ dependencies = [
 name = "reth-consensus-debug-client"
 version = "2.2.0"
 dependencies = [
- "alloy-consensus",
  "alloy-eips 2.0.4",
  "alloy-json-rpc",
  "alloy-primitives",
@@ -7904,7 +7903,6 @@ dependencies = [
  "futures",
  "reqwest 0.13.2",
  "reth-node-api",
- "reth-primitives-traits",
  "reth-tracing",
  "ringbuffer",
  "serde",
diff --git a/crates/consensus/debug-client/Cargo.toml b/crates/consensus/debug-client/Cargo.toml
index 86d3145a12f..64ed9f7ebf9 100644
--- a/crates/consensus/debug-client/Cargo.toml
+++ b/crates/consensus/debug-client/Cargo.toml
@@ -14,10 +14,8 @@ 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-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 92dab80bf7f..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,10 +50,10 @@ 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:#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..03680d3efa2 100644
--- a/crates/consensus/debug-client/src/providers/rpc.rs
+++ b/crates/consensus/debug-client/src/providers/rpc.rs
@@ -1,8 +1,8 @@
-use crate::BlockProvider;
+use crate::PayloadProvider;
 use alloy_provider::{ConnectionConfig, Network, Provider, ProviderBuilder, WebSocketConfig};
 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 +10,19 @@ 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,
     #[debug(skip)]
-    convert: Arc<dyn Fn(N::BlockResponse) -> PrimitiveBlock + Send + Sync>,
+    convert: Arc<dyn Fn(N::BlockResponse) -> 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) -> ExecutionData + Send + Sync + 'static,
     ) -> eyre::Result<Self> {
         Ok(Self {
             provider: Arc::new(
@@ -66,13 +66,13 @@ impl<N: Network, PrimitiveBlock> RpcBlockProvider<N, PrimitiveBlock> {
     }
 }
 
-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 +94,8 @@ where
             while let Some(res) = stream.next().await {
                 match res {
                     Ok(block) => {
-                        if tx.send((self.convert)(block)).await.is_err() {
+                        let payload = (self.convert)(block);
+                        if tx.send(payload).await.is_err() {
                             // Channel closed - receiver dropped, exit completely.
                             return;
                         }
@@ -118,7 +119,7 @@ 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())
diff --git a/crates/ethereum/node/src/node.rs b/crates/ethereum/node/src/node.rs
index eca9d36fbdc..be1219982e2 100644
--- a/crates/ethereum/node/src/node.rs
+++ b/crates/ethereum/node/src/node.rs
@@ -452,8 +452,12 @@ where
 impl<N: FullNodeComponents<Types = Self>> DebugNode<N> for EthereumNode {
     type RpcBlock = alloy_rpc_types_eth::Block;
 
-    fn rpc_to_primitive_block(rpc_block: Self::RpcBlock) -> reth_ethereum_primitives::Block {
-        rpc_block.into_consensus().convert_transactions()
+    fn rpc_to_execution_data(rpc_block: Self::RpcBlock) -> ExecutionData {
+        let (block, hash) = rpc_block.into_consensus_sealed().into_parts();
+        ExecutionData::from_block_unchecked(
+            hash,
+            &block.convert_transactions::<TransactionSigned>(),
+        )
     }
 
     fn local_payload_attributes_builder(
diff --git a/crates/node/builder/src/launch/debug.rs b/crates/node/builder/src/launch/debug.rs
index 3a5644d83ae..c8e1207fafe 100644
--- a/crates/node/builder/src/launch/debug.rs
+++ b/crates/node/builder/src/launch/debug.rs
@@ -5,12 +5,12 @@ 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,
+    FullNodeComponents, FullNodeTypes, HeaderTy, NodeTypes, PayloadAttrTy,
+    PayloadAttributesBuilder, PayloadTypes,
 };
 use std::{
     future::{Future, IntoFuture},
@@ -19,11 +19,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 +41,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,27 +49,28 @@ 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,
+///     ) -> 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.
+    /// Converts an RPC block to execution payload data.
     ///
-    /// This method handles the conversion between the RPC block format and the internal primitive
-    /// block format used by the node's consensus engine.
+    /// This method handles the conversion between the RPC block format and the internal Engine API
+    /// payload data used by the node's consensus engine.
     ///
     /// # Example
     ///
     /// For Ethereum nodes, this typically converts from `alloy_rpc_types_eth::Block`
-    /// to the node's internal block representation.
-    fn rpc_to_primitive_block(rpc_block: Self::RpcBlock) -> BlockTy<Self>;
+    /// to the node's internal execution payload data representation.
+    fn rpc_to_execution_data(rpc_block: Self::RpcBlock) -> PayloadDataTy<Self>;
 
     /// Creates a payload attributes builder for local mining in dev mode.
     ///
@@ -116,7 +120,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 +144,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 +185,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 +194,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,
@@ -239,7 +243,7 @@ where
                         .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)
+                    N::Types::rpc_to_execution_data(rpc_block)
                 })
                 .await?;
 
@@ -270,7 +274,7 @@ where
                     )
                 })?,
                 chain.id(),
-                N::Types::rpc_to_primitive_block,
+                N::Types::rpc_to_execution_data,
             );
             let rpc_consensus_client = DebugConsensusClient::new(
                 handle.node.add_ons_handle.beacon_engine_handle.clone(),
@@ -339,7 +343,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 +359,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>;

From dc9b33b9b4c0d9d3acb6bfbaccb2ef3256a3ff05 Mon Sep 17 00:00:00 2001
From: figtracer <me@figtracer.com>
Date: Tue, 5 May 2026 13:15:42 +0100
Subject: [PATCH 028/335] fix(rpc): fill `maxUsedGas` in simulate results
 (#23983)

---
 crates/ethereum/node/tests/e2e/simulate.rs | 6 ++++--
 crates/rpc/rpc-eth-types/src/simulate.rs   | 6 +++---
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/crates/ethereum/node/tests/e2e/simulate.rs b/crates/ethereum/node/tests/e2e/simulate.rs
index 32405511f08..d30b58c7e4b 100644
--- a/crates/ethereum/node/tests/e2e/simulate.rs
+++ b/crates/ethereum/node/tests/e2e/simulate.rs
@@ -73,8 +73,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/rpc/rpc-eth-types/src/simulate.rs b/crates/rpc/rpc-eth-types/src/simulate.rs
index 7946459cfe3..79b4889780e 100644
--- a/crates/rpc/rpc-eth-types/src/simulate.rs
+++ b/crates/rpc/rpc-eth-types/src/simulate.rs
@@ -315,9 +315,9 @@ where
                         ..SimulateError::invalid_params()
                     }),
                     gas_used: gas.tx_gas_used(),
+                    max_used_gas: Some(gas.total_gas_spent()),
                     logs: Vec::new(),
                     status: false,
-                    ..Default::default()
                 }
             }
             ExecutionResult::Revert { output, gas, .. } => {
@@ -330,15 +330,16 @@ where
                         ..SimulateError::invalid_params()
                     }),
                     gas_used: gas.tx_gas_used(),
+                    max_used_gas: Some(gas.total_gas_spent()),
                     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()),
                 logs: logs
                     .into_iter()
                     .map(|log| {
@@ -356,7 +357,6 @@ where
                     })
                     .collect(),
                 status: true,
-                ..Default::default()
             },
         };
 

From 12ec7c57281c611355a02a2032ea7330ed9d3c68 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Tue, 5 May 2026 16:25:37 +0400
Subject: [PATCH 029/335] fix: skip already-known executed blocks (#23987)

---
 crates/engine/tree/src/tree/mod.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index 41bd429373d..624501bc7bf 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -1555,6 +1555,11 @@ where
                             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();
 

From 83287322d5d15a7a72bd9419f3ee766f7ae1426a Mon Sep 17 00:00:00 2001
From: Dan Cline <6798349+Rjected@users.noreply.github.com>
Date: Tue, 5 May 2026 08:52:41 -0400
Subject: [PATCH 030/335] fix(engine): increase state root task timeout to 4s
 (#23949)

---
 crates/node/core/src/args/engine.rs    | 6 +++---
 docs/vocs/docs/pages/cli/reth/node.mdx | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/node/core/src/args/engine.rs b/crates/node/core/src/args/engine.rs
index 5dedc68747b..382df972b71 100644
--- a/crates/node/core/src/args/engine.rs
+++ b/crates/node/core/src/args/engine.rs
@@ -285,7 +285,7 @@ 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,
@@ -459,14 +459,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>,
 
diff --git a/docs/vocs/docs/pages/cli/reth/node.mdx b/docs/vocs/docs/pages/cli/reth/node.mdx
index 3d5a60beb57..0b687232dcb 100644
--- a/docs/vocs/docs/pages/cli/reth/node.mdx
+++ b/docs/vocs/docs/pages/cli/reth/node.mdx
@@ -1058,11 +1058,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.

From 1497ee78aaf9f2807f234433f7e106caac14a845 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 5 May 2026 16:42:37 +0200
Subject: [PATCH 031/335] fix(rpc): relax forkchoice update error match
 (#23941)

---
 crates/rpc/rpc-engine-api/src/error.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

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(_) => {

From 883505692f84d8ac4388f6c2753ab23041cf643a Mon Sep 17 00:00:00 2001
From: Alexey Shekhirin <github@shekhirin.com>
Date: Tue, 5 May 2026 15:41:10 +0100
Subject: [PATCH 032/335] ci(bench): update snapshots with `reth download`
 (#23984)

---
 .github/scripts/bench-reth-local.sh    |  18 ++--
 .github/scripts/bench-reth-run.sh      |   7 +-
 .github/scripts/bench-reth-snapshot.sh | 132 ++++++++++++++++++++-----
 .github/workflows/bench-scheduled.yml  |  13 ++-
 .github/workflows/bench.yml            |  15 +--
 5 files changed, 135 insertions(+), 50 deletions(-)

diff --git a/.github/scripts/bench-reth-local.sh b/.github/scripts/bench-reth-local.sh
index 4d2565592d8..2e8a1cc8dcb 100755
--- a/.github/scripts/bench-reth-local.sh
+++ b/.github/scripts/bench-reth-local.sh
@@ -18,7 +18,8 @@
 #   --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)
+# Requires: the reth repo at RETH_REPO (default: ~/reth) and
+# BENCH_SNAPSHOT_MANIFEST_URL pointing at the benchmark snapshot manifest.
 #
 # Dependencies (install before first run):
 #   schelk, cpupower, taskset, stdbuf, python3, curl,
@@ -240,14 +241,7 @@ 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 ───────────────────────────────
+# ── Step 3: Build binaries in parallel ───────────────────────────────
 echo "▸ Building binaries (parallel)..."
 cd "$RETH_REPO"
 
@@ -269,6 +263,12 @@ fi
 echo "  Binaries built successfully."
 echo
 
+# ── Step 4: Sync snapshot ────────────────────────────────────────────
+echo "▸ Syncing snapshot..."
+BENCH_RETH_BINARY="${FEATURE_SRC}/target/profiling/reth" "${SCRIPTS_DIR}/bench-reth-snapshot.sh"
+echo "  Snapshot is ready."
+echo
+
 # ── Step 5: System tuning (optional) ────────────────────────────────
 if [ "$TUNE" = "true" ]; then
   echo "▸ Applying system tuning..."
diff --git a/.github/scripts/bench-reth-run.sh b/.github/scripts/bench-reth-run.sh
index 7c272ad74ea..37dbb848af5 100755
--- a/.github/scripts/bench-reth-run.sh
+++ b/.github/scripts/bench-reth-run.sh
@@ -130,8 +130,8 @@ RETH_ARGS=(
   --no-persist-peers
 )
 
-# Gate flag on binary support (older baselines may not have it).
-# Uses --help which exits immediately via clap without node init.
+# Keep the engine in startup sync mode until the pipeline is idle. Older
+# baselines may not have this flag, so gate it on clap help output.
 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)
@@ -220,9 +220,6 @@ for i in $(seq 1 60); do
   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 \
diff --git a/.github/scripts/bench-reth-snapshot.sh b/.github/scripts/bench-reth-snapshot.sh
index 5d8b883e544..7672c2a1980 100755
--- a/.github/scripts/bench-reth-snapshot.sh
+++ b/.github/scripts/bench-reth-snapshot.sh
@@ -1,56 +1,138 @@
 #!/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 configured
+# 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_SNAPSHOT_MANIFEST_URL - exact manifest URL to sync from
+#   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
+set -euo pipefail
 
 : "${SCHELK_MOUNT:?SCHELK_MOUNT must be set}"
+: "${BENCH_SNAPSHOT_MANIFEST_URL:?BENCH_SNAPSHOT_MANIFEST_URL 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"
 
-describe_snapshot() {
-  if [ -n "${BENCH_SNAPSHOT_NAME:-}" ]; then
-    printf '%s' "${BENCH_SNAPSHOT_NAME}"
-  elif [ "${BENCH_BIG_BLOCKS:-false}" = "true" ]; then
-    printf '%s' 'big-block weekly snapshot'
-  else
-    printf '%s' 'benchmark snapshot'
-  fi
-}
+MANIFEST_URL="$BENCH_SNAPSHOT_MANIFEST_URL"
+MANIFEST_BASE_URL="${MANIFEST_URL%/*}"
+
+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
+}
+
+echo "Using snapshot manifest from BENCH_SNAPSHOT_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 BENCH_SNAPSHOT_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")"
 
 sudo schelk recover -y --kill || sudo schelk full-recover -y || true
-sudo schelk mount -y || true
+sudo schelk mount -y
+
+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/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 3996a18e6c0..f849b301e93 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -272,6 +272,7 @@ jobs:
       BENCH_ABBA: "true"
       BENCH_COMMENT_ID: ""
       BENCH_SLACK: ${{ github.event_name == 'workflow_dispatch' && inputs.slack || 'always' }}
+      BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
       BENCH_METRICS_ADDR: "127.0.0.1:9100"
       BENCH_OTLP_DISABLED: "true"
       BASELINE_REF: ${{ needs.resolve-refs.outputs.baseline-ref }}
@@ -372,10 +373,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() {
@@ -419,6 +416,12 @@ jobs:
             exit 1
           fi
 
+      - name: Sync snapshot
+        id: snapshot-check
+        run: |
+          BENCH_RETH_BINARY="$(pwd)/../reth-feature/target/profiling/reth" \
+            .github/scripts/bench-reth-snapshot.sh
+
       # System tuning for reproducible benchmarks
       - name: System setup
         run: |
@@ -919,8 +922,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 }}'],
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 3274d26d471..0088bad730c 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -555,6 +555,7 @@ jobs:
       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_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
       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 || '' }}
@@ -802,10 +803,6 @@ jobs:
           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() {
@@ -851,6 +848,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: |
@@ -1340,8 +1343,8 @@ jobs:
             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 }}'],
+              ['syncing snapshot', '${{ steps.snapshot-check.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 }}']] : []),
@@ -1378,8 +1381,8 @@ jobs:
             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 }}'],
+              ['syncing snapshot', '${{ steps.snapshot-check.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 }}']] : []),

From b5f32d4d6600ee93b6d6d253ac7f4a21a243126c Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Tue, 5 May 2026 17:31:13 +0200
Subject: [PATCH 033/335] fix(bench): skip big-block snapshot downloads
 (#23992)

Co-authored-by: Brian Picciano <933154+mediocregopher@users.noreply.github.com>
Co-authored-by: Amp <amp@ampcode.com>
---
 .github/scripts/bench-reth-snapshot.sh | 39 +++++++++++++++++++++++---
 1 file changed, 35 insertions(+), 4 deletions(-)

diff --git a/.github/scripts/bench-reth-snapshot.sh b/.github/scripts/bench-reth-snapshot.sh
index 7672c2a1980..ca29801e1a9 100755
--- a/.github/scripts/bench-reth-snapshot.sh
+++ b/.github/scripts/bench-reth-snapshot.sh
@@ -15,10 +15,10 @@
 #
 # Optional env:
 #   BENCH_BIG_BLOCKS            - true when syncing the big-blocks datadir
+#   BENCH_SNAPSHOT_NAME         - expected snapshot label for log/error output
 set -euo pipefail
 
 : "${SCHELK_MOUNT:?SCHELK_MOUNT must be set}"
-: "${BENCH_SNAPSHOT_MANIFEST_URL:?BENCH_SNAPSHOT_MANIFEST_URL must be set}"
 
 if [ "${1:-}" != "" ] && [ "${1:-}" != "--check" ]; then
   echo "Usage: $0 [--check]"
@@ -37,6 +37,40 @@ fi
 DATADIR="$SCHELK_MOUNT/$DATADIR_NAME"
 LOCAL_MANIFEST="$DATADIR/manifest.json"
 
+describe_snapshot() {
+  if [ -n "${BENCH_SNAPSHOT_NAME:-}" ]; then
+    printf '%s' "${BENCH_SNAPSHOT_NAME}"
+  elif [ "${BENCH_BIG_BLOCKS:-false}" = "true" ]; then
+    printf '%s' 'big-block weekly snapshot'
+  else
+    printf '%s' 'benchmark snapshot'
+  fi
+}
+
+EXPECTED_SNAPSHOT="$(describe_snapshot)"
+
+sudo schelk recover -y --kill || sudo schelk full-recover -y || true
+sudo schelk mount -y
+
+if [ "${BENCH_BIG_BLOCKS:-false}" = "true" ]; then
+  if [ -d "$DATADIR/db" ] && [ -d "$DATADIR/static_files" ]; then
+    echo "Found local ${EXPECTED_SNAPSHOT} at ${DATADIR}; skipping manifest sync for big-block benchmarks"
+    exit 0
+  fi
+
+  echo "::error::Missing local ${EXPECTED_SNAPSHOT} at ${DATADIR}. Big-block benchmarks require a pre-populated schelk data volume."
+  ls -la "$SCHELK_MOUNT" || true
+  ls -la "$DATADIR" || true
+
+  if [ "$CHECK_ONLY" = true ]; then
+    exit 10
+  fi
+
+  exit 1
+fi
+
+: "${BENCH_SNAPSHOT_MANIFEST_URL:?BENCH_SNAPSHOT_MANIFEST_URL must be set}"
+
 MANIFEST_URL="$BENCH_SNAPSHOT_MANIFEST_URL"
 MANIFEST_BASE_URL="${MANIFEST_URL%/*}"
 
@@ -71,9 +105,6 @@ if ! jq -S . "$REMOTE_MANIFEST" > "$REMOTE_CANONICAL"; then
 fi
 REMOTE_HASH="$(sha256_file "$REMOTE_CANONICAL")"
 
-sudo schelk recover -y --kill || sudo schelk full-recover -y || true
-sudo schelk mount -y
-
 LOCAL_HASH=""
 LOCAL_MATCH=false
 if [ -f "$LOCAL_MANIFEST" ] && jq -S . "$LOCAL_MANIFEST" > "$LOCAL_CANONICAL"; then

From a9c85ad97ccd4b6cc630f4f5b68dea08bea5bb25 Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Tue, 5 May 2026 17:40:54 +0200
Subject: [PATCH 034/335] fix: disable OTLP by default in bench workflow
 (#23994)

Co-authored-by: Brian Picciano <933154+mediocregopher@users.noreply.github.com>
Co-authored-by: Amp <amp@ampcode.com>
---
 .github/workflows/bench.yml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 0088bad730c..df9ec9ee49e 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -89,7 +89,7 @@ on:
       otlp:
         description: "Export OTLP traces and logs"
         required: false
-        default: "true"
+        default: "false"
         type: boolean
 
 env:
@@ -176,7 +176,7 @@ jobs:
               bigBlocks = '${{ github.event.inputs.big_blocks }}' === 'true' ? 'true' : 'false';
               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 otlp = '${{ github.event.inputs.otlp }}' === 'true' ? 'true' : 'false';
               var waitTime = '${{ github.event.inputs.wait_time }}' || '';
               var baselineNodeArgs = '${{ github.event.inputs.baseline_args }}' || '';
               var featureNodeArgs = '${{ github.event.inputs.feature_args }}' || '';
@@ -202,11 +202,11 @@ jobs:
               const intArgs = new Set(['warmup', 'cores', 'blocks']);
               const refArgs = new Set(['baseline', 'feature']);
               const boolArgs = new Set(['samply', 'big-blocks']);
-              const boolDefaultTrue = new Set(['abba', 'otlp']);
+              const boolDefaultTrue = new Set(['abba']);
               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: '500', warmup: '200', baseline: '', feature: '', samply: 'false', slack: 'always', 'big-blocks': 'false', bal: 'false', cores: '0', abba: 'true', otlp: 'false', 'wait-time': '', 'baseline-args': '', 'feature-args': '' };
               const unknown = [];
               const invalid = [];
               const args = body.replace(/^(?:@decofe|derek) bench\s*/, '');
@@ -620,7 +620,7 @@ jobs:
             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 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}\`` : '';

From b3262d466fa204667835330af2744372ef646f81 Mon Sep 17 00:00:00 2001
From: figtracer <me@figtracer.com>
Date: Tue, 5 May 2026 17:27:57 +0100
Subject: [PATCH 035/335] fix(rpc): support block overrides in estimateGas
 (#23990)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/rpc/rpc-builder/tests/it/http.rs       |  1 +
 crates/rpc/rpc-eth-api/src/core.rs            |  4 +-
 crates/rpc/rpc-eth-api/src/helpers/call.rs    |  4 +-
 .../rpc/rpc-eth-api/src/helpers/estimate.rs   | 40 ++++++++++++-------
 .../rpc-eth-api/src/helpers/transaction.rs    | 12 +++---
 5 files changed, 39 insertions(+), 22 deletions(-)

diff --git a/crates/rpc/rpc-builder/tests/it/http.rs b/crates/rpc/rpc-builder/tests/it/http.rs
index 120721a82f6..dc904bb98fa 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();
diff --git a/crates/rpc/rpc-eth-api/src/core.rs b/crates/rpc/rpc-eth-api/src/core.rs
index e7fde53e5a4..6c884279b63 100644
--- a/crates/rpc/rpc-eth-api/src/core.rs
+++ b/crates/rpc/rpc-eth-api/src/core.rs
@@ -295,6 +295,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.
@@ -773,13 +774,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?)
     }
diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs
index e417943fea8..2ab5bf2d074 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/call.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/call.rs
@@ -57,9 +57,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.
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/transaction.rs b/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
index 77f5e4699c8..d451cfece29 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::{
@@ -470,8 +470,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 +534,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());
             }
 

From b41250350ea9d4c34af519b2dfffea55863838b7 Mon Sep 17 00:00:00 2001
From: Tim <tim@tempo.xyz>
Date: Wed, 6 May 2026 10:52:24 +0200
Subject: [PATCH 036/335] fix: reth-bench: use per-run bench metrics labels
 file (#24005)

---
 .github/scripts/bench-reth-local.sh   | 2 +-
 .github/workflows/bench-scheduled.yml | 2 +-
 .github/workflows/bench.yml           | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/scripts/bench-reth-local.sh b/.github/scripts/bench-reth-local.sh
index 2e8a1cc8dcb..1895770c3d1 100755
--- a/.github/scripts/bench-reth-local.sh
+++ b/.github/scripts/bench-reth-local.sh
@@ -399,7 +399,7 @@ 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"
+LABELS_FILE="$(mktemp "${TMPDIR:-/tmp}/bench-metrics-labels.XXXXXX")"
 echo '{}' > "$LABELS_FILE"
 METRICS_SUBNET="${METRICS_SUBNET:-10.10.0.0/24}"
 METRICS_PORT="${METRICS_PORT:-9090}"
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index f849b301e93..9261c776194 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -475,7 +475,7 @@ jobs:
           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"
 
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index df9ec9ee49e..8ec4bf8bbc3 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -931,7 +931,7 @@ jobs:
           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"
 

From ea31b9ca99dbbfff4d918bd034e525a5bb7beee6 Mon Sep 17 00:00:00 2001
From: Tim <tim@tempo.xyz>
Date: Wed, 6 May 2026 10:59:09 +0200
Subject: [PATCH 037/335] chore: fix grafana-fetch gh setup-git (#23999)

---
 .github/workflows/fetch-grafana-dashboard.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

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}\`)."

From 360332258ad5f8fbbdba2d1c400c4b8dc039d96c Mon Sep 17 00:00:00 2001
From: Alexey Shekhirin <github@shekhirin.com>
Date: Wed, 6 May 2026 10:01:47 +0100
Subject: [PATCH 038/335] ci(bench): reenable minio binaries cache (#23993)

---
 .github/scripts/bench-reth-build.sh   | 107 +++++++++++++++++++++++---
 .github/workflows/bench-scheduled.yml |   8 +-
 .github/workflows/bench.yml           |   8 +-
 3 files changed, 109 insertions(+), 14 deletions(-)

diff --git a/.github/scripts/bench-reth-build.sh b/.github/scripts/bench-reth-build.sh
index 6127f23b765..13e5c171e42 100755
--- a/.github/scripts/bench-reth-build.sh
+++ b/.github/scripts/bench-reth-build.sh
@@ -1,24 +1,30 @@
 #!/usr/bin/env bash
 #
-# Builds reth binaries for benchmarking from local source only.
+# Builds (or fetches from cache) reth binaries for benchmarking.
 #
-# Usage: bench-reth-build.sh <baseline|feature> <source-dir> <commit>
+# Usage: bench-reth-build.sh <baseline|feature> <source-dir> <commit> [cache-sha]
 #
-#   baseline — build the baseline binary at <commit> (merge-base)
+#   baseline — build/fetch the baseline binary at <commit> (merge-base)
 #              source-dir must be checked out at <commit>
-#   feature  — build the candidate binary + reth-bench at <commit>
+#   feature  — build/fetch the candidate binary + reth-bench at <commit>
 #              source-dir must be checked out at <commit>
+#              optional cache-sha is the PR head commit for cache key
 #
 # 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
+# Optional env:
+#   BENCH_BIG_BLOCKS (true/false) — build reth-bb instead of reth
+#   BENCH_BINARY_CACHE_ROOT       — MinIO cache root (default: minio/reth-binaries)
 set -euxo pipefail
 
+MC="${MC:-mc}"
 MODE="$1"
 SOURCE_DIR="$2"
 COMMIT="$3"
+CACHE_ROOT="${BENCH_BINARY_CACHE_ROOT:-minio/reth-binaries}"
+RETH_BENCH_BIN="${CARGO_HOME:-$HOME/.cargo}/bin/reth-bench"
 
 BIG_BLOCKS="${BENCH_BIG_BLOCKS:-false}"
 # The node binary to build: reth-bb for big blocks, reth otherwise
@@ -39,6 +45,46 @@ if [ "${BENCH_TRACY:-off}" != "off" ]; then
   EXTRA_RUSTFLAGS=" -C force-frame-pointers=yes"
 fi
 
+hash_build_config() {
+  if command -v sha256sum &>/dev/null; then
+    sha256sum | cut -c1-12
+  else
+    shasum -a 256 | cut -c1-12
+  fi
+}
+
+# Cache suffix: hash of features+rustflags so different build configs get separate cache entries.
+if [ -n "$EXTRA_FEATURES" ] || [ -n "$EXTRA_RUSTFLAGS" ]; then
+  BUILD_SUFFIX="-$(printf '%s' "${EXTRA_FEATURES}${EXTRA_RUSTFLAGS}" | hash_build_config)"
+else
+  BUILD_SUFFIX=""
+fi
+
+# Verify a cached reth binary was built from the expected commit.
+# `reth --version` outputs "Commit SHA: <full-sha>" on its own line.
+verify_binary() {
+  local binary="$1" expected_commit="$2"
+  local version binary_sha
+  version=$("$binary" --version 2>/dev/null) || return 1
+  binary_sha=$(echo "$version" | sed -n 's/^Commit SHA: *//p')
+  if [ -z "$binary_sha" ]; then
+    echo "Warning: could not extract commit SHA from version output"
+    return 1
+  fi
+  if [ "$binary_sha" = "$expected_commit" ]; then
+    return 0
+  fi
+  echo "Cache mismatch: binary built from ${binary_sha} but expected ${expected_commit}"
+  return 1
+}
+
+upload_cache_artifact() {
+  local source="$1" destination="$2"
+  if ! $MC cp "$source" "$destination"; then
+    echo "::warning::Failed to upload binary cache artifact to ${destination}; continuing without remote cache write"
+  fi
+}
+
 # Build the requested node binary with the benchmark profile.
 build_node_binary() {
   local features_arg=""
@@ -58,19 +104,56 @@ build_node_binary() {
 
 case "$MODE" in
   baseline|main)
-    echo "Building baseline ${NODE_BIN} (${COMMIT}) from source..."
-    build_node_binary
+    BUCKET="${CACHE_ROOT}/${COMMIT}${BUILD_SUFFIX}"
+    mkdir -p "${SOURCE_DIR}/target/profiling"
+
+    CACHE_VALID=false
+    if $MC stat --no-list "${BUCKET}/${NODE_BIN}" &>/dev/null; then
+      echo "Cache hit for baseline (${COMMIT}), downloading ${NODE_BIN}..."
+      if $MC cp "${BUCKET}/${NODE_BIN}" "${SOURCE_DIR}/target/profiling/${NODE_BIN}" && \
+         chmod +x "${SOURCE_DIR}/target/profiling/${NODE_BIN}" && \
+         verify_binary "${SOURCE_DIR}/target/profiling/${NODE_BIN}" "${COMMIT}"; then
+        CACHE_VALID=true
+      else
+        echo "Cached baseline binary is stale or download failed, rebuilding..."
+      fi
+    fi
+    if [ "$CACHE_VALID" = false ]; then
+      echo "Building baseline ${NODE_BIN} (${COMMIT}) from source..."
+      build_node_binary
+      upload_cache_artifact "${SOURCE_DIR}/target/profiling/${NODE_BIN}" "${BUCKET}/${NODE_BIN}"
+    fi
     ;;
 
   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
+    CACHE_SHA="${4:-$COMMIT}"
+    BUCKET="${CACHE_ROOT}/${CACHE_SHA}${BUILD_SUFFIX}"
+
+    CACHE_VALID=false
+    if $MC stat --no-list "${BUCKET}/${NODE_BIN}" &>/dev/null && $MC stat --no-list "${BUCKET}/reth-bench" &>/dev/null; then
+      echo "Cache hit for ${CACHE_SHA}, downloading binaries..."
+      mkdir -p "${SOURCE_DIR}/target/profiling" "$(dirname "$RETH_BENCH_BIN")"
+      if $MC cp "${BUCKET}/${NODE_BIN}" "${SOURCE_DIR}/target/profiling/${NODE_BIN}" && \
+         $MC cp "${BUCKET}/reth-bench" "$RETH_BENCH_BIN" && \
+         chmod +x "${SOURCE_DIR}/target/profiling/${NODE_BIN}" "$RETH_BENCH_BIN" && \
+         verify_binary "${SOURCE_DIR}/target/profiling/${NODE_BIN}" "${COMMIT}"; then
+        CACHE_VALID=true
+      else
+        echo "Cached feature binary is stale or download failed, rebuilding..."
+      fi
+    fi
+    if [ "$CACHE_VALID" = false ]; then
+      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
+      upload_cache_artifact "${SOURCE_DIR}/target/profiling/${NODE_BIN}" "${BUCKET}/${NODE_BIN}"
+      upload_cache_artifact "$RETH_BENCH_BIN" "${BUCKET}/reth-bench"
+    fi
     ;;
 
   *)
-    echo "Usage: $0 <baseline|feature> <source-dir> <commit>"
+    echo "Usage: $0 <baseline|feature> <source-dir> <commit> [cache-sha]"
     exit 1
     ;;
 esac
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 9261c776194..2055fe952c1 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -320,6 +320,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
@@ -347,7 +353,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
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 8ec4bf8bbc3..d33adae12be 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -657,6 +657,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
@@ -691,7 +697,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

From 39b2c738a84d661a1f09750a582dde951da122d1 Mon Sep 17 00:00:00 2001
From: Alexey Shekhirin <github@shekhirin.com>
Date: Wed, 6 May 2026 11:10:14 +0100
Subject: [PATCH 039/335] deps: bump libmdbx to v0.13.12 (#24007)

---
 .../mdbx-sys/libmdbx/CMakeLists.txt           | 404 ++-----
 .../libmdbx-rs/mdbx-sys/libmdbx/COPYRIGHT     | 159 +++
 .../libmdbx-rs/mdbx-sys/libmdbx/GNUmakefile   | 108 +-
 .../libmdbx-rs/mdbx-sys/libmdbx/NOTICE        |  22 +-
 .../libmdbx-rs/mdbx-sys/libmdbx/VERSION.json  |   2 +-
 .../mdbx-sys/libmdbx/cmake/compiler.cmake     |   2 +-
 .../mdbx-sys/libmdbx/cmake/profile.cmake      |   2 +-
 .../mdbx-sys/libmdbx/cmake/utils.cmake        | 212 +---
 .../libmdbx-rs/mdbx-sys/libmdbx/config.h.in   |  14 +-
 .../mdbx-sys/libmdbx/man1/mdbx_chk.1          |   2 +-
 .../mdbx-sys/libmdbx/man1/mdbx_copy.1         |   2 +-
 .../mdbx-sys/libmdbx/man1/mdbx_drop.1         |   2 +-
 .../mdbx-sys/libmdbx/man1/mdbx_dump.1         |   2 +-
 .../mdbx-sys/libmdbx/man1/mdbx_load.1         |   2 +-
 .../mdbx-sys/libmdbx/man1/mdbx_stat.1         |   2 +-
 .../libmdbx-rs/mdbx-sys/libmdbx/mdbx.c        | 999 +++++++++++-------
 .../libmdbx-rs/mdbx-sys/libmdbx/mdbx.c++      |  96 +-
 .../libmdbx-rs/mdbx-sys/libmdbx/mdbx.h        |  99 +-
 .../libmdbx-rs/mdbx-sys/libmdbx/mdbx.h++      | 682 +++++++-----
 .../libmdbx-rs/mdbx-sys/libmdbx/mdbx_chk.c    |  41 +-
 .../libmdbx-rs/mdbx-sys/libmdbx/mdbx_copy.c   |  41 +-
 .../libmdbx-rs/mdbx-sys/libmdbx/mdbx_drop.c   |  41 +-
 .../libmdbx-rs/mdbx-sys/libmdbx/mdbx_dump.c   |  47 +-
 .../libmdbx-rs/mdbx-sys/libmdbx/mdbx_load.c   |  84 +-
 .../libmdbx-rs/mdbx-sys/libmdbx/mdbx_stat.c   |  42 +-
 .../libmdbx/ut_and_examples/CMakeLists.txt    |  39 +
 .../libmdbx/ut_and_examples/README.md         |  11 +
 .../libmdbx/ut_and_examples/example-mdbx.c    | 167 +++
 .../libmdbx/ut_and_examples/example-mdbx.c++  |  99 ++
 .../ut_and_examples/pcrf/pcrf_simulator.c     | 367 +++++++
 30 files changed, 2446 insertions(+), 1346 deletions(-)
 create mode 100644 crates/storage/libmdbx-rs/mdbx-sys/libmdbx/COPYRIGHT
 create mode 100644 crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/CMakeLists.txt
 create mode 100644 crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/README.md
 create mode 100644 crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/example-mdbx.c
 create mode 100644 crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/example-mdbx.c++
 create mode 100644 crates/storage/libmdbx-rs/mdbx-sys/libmdbx/ut_and_examples/pcrf/pcrf_simulator.c

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;
+}

From 098ede2b3c85e7899c7bcc3cd471d0a3504fa77f Mon Sep 17 00:00:00 2001
From: Alexey Shekhirin <github@shekhirin.com>
Date: Wed, 6 May 2026 11:19:13 +0100
Subject: [PATCH 040/335] ci(bench): move metrics to port 9001 (#24009)

---
 .github/scripts/bench-metrics-proxy.py | 4 ++--
 .github/scripts/bench-reth-local.sh    | 2 +-
 .github/workflows/bench-scheduled.yml  | 2 +-
 .github/workflows/bench.yml            | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/scripts/bench-metrics-proxy.py b/.github/scripts/bench-metrics-proxy.py
index 2a6044a0eb8..5adfba751cc 100644
--- a/.github/scripts/bench-metrics-proxy.py
+++ b/.github/scripts/bench-metrics-proxy.py
@@ -241,8 +241,8 @@ 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/)")
+    parser.add_argument("--upstream", default="http://127.0.0.1:9001/",
+                        help="Upstream reth metrics URL (default: http://127.0.0.1:9001/)")
 
     bind_group = parser.add_mutually_exclusive_group()
     bind_group.add_argument("--bind", default=None,
diff --git a/.github/scripts/bench-reth-local.sh b/.github/scripts/bench-reth-local.sh
index 1895770c3d1..dc6812a3a32 100755
--- a/.github/scripts/bench-reth-local.sh
+++ b/.github/scripts/bench-reth-local.sh
@@ -199,7 +199,7 @@ 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"
+export BENCH_METRICS_ADDR="127.0.0.1:9001"
 
 # ── Step 1: Resolve refs to full SHAs ────────────────────────────────
 echo "▸ Resolving git refs..."
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 2055fe952c1..f6c613e8b0c 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -273,7 +273,7 @@ jobs:
       BENCH_COMMENT_ID: ""
       BENCH_SLACK: ${{ github.event_name == 'workflow_dispatch' && inputs.slack || 'always' }}
       BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
-      BENCH_METRICS_ADDR: "127.0.0.1:9100"
+      BENCH_METRICS_ADDR: "127.0.0.1:9001"
       BENCH_OTLP_DISABLED: "true"
       BASELINE_REF: ${{ needs.resolve-refs.outputs.baseline-ref }}
       FEATURE_REF: ${{ needs.resolve-refs.outputs.feature-ref }}
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index d33adae12be..951fdfe0426 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -556,7 +556,7 @@ jobs:
       BENCH_SLACK: ${{ needs.reth-bench-ack.outputs.slack }}
       BENCH_NODE_BIN: ${{ needs.reth-bench-ack.outputs.big-blocks == 'true' && 'reth-bb' || 'reth' }}
       BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
-      BENCH_METRICS_ADDR: "127.0.0.1:9100"
+      BENCH_METRICS_ADDR: "127.0.0.1:9001"
       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:

From 0dd0de65d84e37115be22def507fd8e98f5d6833 Mon Sep 17 00:00:00 2001
From: Karl Yu <43113774+0xKarl98@users.noreply.github.com>
Date: Wed, 6 May 2026 18:30:50 +0800
Subject: [PATCH 041/335] refactor(storage): add decoded BAL lookup (#23998)

---
 crates/storage/storage-api/src/bal.rs | 76 ++++++++++++++++++++++++++-
 1 file changed, 75 insertions(+), 1 deletion(-)

diff --git a/crates/storage/storage-api/src/bal.rs b/crates/storage/storage-api/src/bal.rs
index c6dead0bb36..c5dac1854f1 100644
--- a/crates/storage/storage-api/src/bal.rs
+++ b/crates/storage/storage-api/src/bal.rs
@@ -1,5 +1,5 @@
 use alloc::{sync::Arc, vec::Vec};
-use alloy_eips::NumHash;
+use alloy_eips::{eip7928::bal::DecodedBal, NumHash};
 use alloy_primitives::{BlockHash, BlockNumber, Bytes, Sealed};
 use reth_storage_errors::provider::ProviderResult;
 
@@ -48,6 +48,19 @@ pub trait BalStore: Send + Sync + 'static {
     /// 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)
+    }
+
     /// Fetch BAL response entries for the given block hashes, stopping after the soft limit is
     /// exceeded.
     ///
@@ -148,6 +161,18 @@ 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)
+    }
+
     /// Fetch BAL response entries for the given block hashes, stopping after the soft limit is
     /// exceeded.
     #[inline]
@@ -261,9 +286,30 @@ mod tests {
         let by_range = store.get_by_range(1, 10).unwrap();
 
         assert_eq!(by_hash, vec![None, None]);
+        assert!(store.get_by_hash(B256::random()).unwrap().is_none());
         assert!(by_range.is_empty());
     }
 
+    #[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(&[0xc0]);
+        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);
+    }
+
     #[test]
     fn noop_store_limited_lookup_returns_prefix() {
         let store = BalStoreHandle::default();
@@ -295,4 +341,32 @@ mod tests {
 
         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 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())
+        }
+
+        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()
+        }
+    }
 }

From b46f961237450b632c4cbece3b844e99d3064bba Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Wed, 6 May 2026 16:32:37 +0400
Subject: [PATCH 042/335] perf(generate-big-blocks): don't fetch receipts
 (#24011)

---
 Cargo.lock                                    |  1 -
 bin/reth-bench/Cargo.toml                     |  1 -
 .../src/bench/generate_big_block.rs           | 61 ++++---------------
 3 files changed, 12 insertions(+), 51 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 619b2419c61..3d9fece03f7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7611,7 +7611,6 @@ dependencies = [
  "reth-cli-util",
  "reth-engine-primitives",
  "reth-ethereum-cli",
- "reth-ethereum-primitives",
  "reth-fs-util",
  "reth-node-api",
  "reth-node-core",
diff --git a/bin/reth-bench/Cargo.toml b/bin/reth-bench/Cargo.toml
index f74e34f7d8b..63f0fc0e80b 100644
--- a/bin/reth-bench/Cargo.toml
+++ b/bin/reth-bench/Cargo.toml
@@ -20,7 +20,6 @@ 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
diff --git a/bin/reth-bench/src/bench/generate_big_block.rs b/bin/reth-bench/src/bench/generate_big_block.rs
index 77774363558..dabc9549745 100644
--- a/bin/reth-bench/src/bench/generate_big_block.rs
+++ b/bin/reth-bench/src/bench/generate_big_block.rs
@@ -27,7 +27,6 @@ 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 serde::{Deserialize, Serialize};
 use std::{
     collections::{HashMap, HashSet},
@@ -35,8 +34,6 @@ use std::{
 };
 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 {
@@ -380,8 +377,7 @@ impl Command {
                         break;
                     }
                 };
-                let FetchedBlock { execution_data, consensus_receipts, block_access_list } =
-                    fetched;
+                let FetchedBlock { execution_data, block_access_list } = fetched;
 
                 let block_gas = execution_data.payload.as_v1().gas_used;
                 let block_blob_gas =
@@ -393,7 +389,6 @@ impl Command {
                     gas_used = block_gas,
                     blob_gas_used = block_blob_gas,
                     tx_count = execution_data.payload.transactions().len(),
-                    receipts = consensus_receipts.len(),
                     "Fetched block"
                 );
 
@@ -629,9 +624,6 @@ impl Command {
 struct FetchedBlock {
     /// Execution payload with sidecar derived from the RPC block.
     execution_data: ExecutionData,
-    /// Consensus-format receipts (`cumulative_gas_used` is still per-block, callers offset
-    /// it when merging).
-    consensus_receipts: Vec<Receipt>,
     /// `eth_getBlockAccessListByBlockNumber` result when `--bal` is enabled.
     block_access_list: Option<BlockAccessList>,
 }
@@ -643,46 +635,17 @@ async fn fetch_one_block(
     block_number: u64,
     bal_enabled: bool,
 ) -> eyre::Result<Option<FetchedBlock>> {
-    let (rpc_block, receipts) = tokio::try_join!(
-        provider.get_block_by_number(block_number.into()).full(),
-        provider.get_block_receipts(block_number.into()),
-    )?;
-    let (rpc_block, receipts) = match (rpc_block, receipts) {
-        (Some(b), Some(r)) => (b, r),
-        _ => return Ok(None),
-    };
-
-    let block_access_list = if bal_enabled {
-        Some(
-            fetch_block_access_list(&provider, block_number)
-                .await
-                .wrap_err_with(|| format!("Failed to fetch BAL for block {block_number}"))?,
-        )
-    } else {
-        None
-    };
-
-    let consensus_receipts: Vec<Receipt> = receipts
-        .iter()
-        .map(|r| {
-            let inner = &r.inner.inner.inner;
-            let tx_type = r.inner.inner.r#type.try_into().unwrap_or_default();
-            Receipt {
-                tx_type,
-                success: inner.receipt.status.coerce_status(),
-                cumulative_gas_used: inner.receipt.cumulative_gas_used,
-                logs: inner
-                    .receipt
-                    .logs
-                    .iter()
-                    .map(|log| alloy_primitives::Log {
-                        address: log.inner.address,
-                        data: log.inner.data.clone(),
-                    })
-                    .collect(),
+    let (rpc_block, block_access_list) =
+        tokio::try_join!(provider.get_block_by_number(block_number.into()).full(), async {
+            if bal_enabled {
+                provider.get_block_access_list_by_number(block_number.into()).await
+            } else {
+                Ok(None)
             }
-        })
-        .collect();
+        })?;
+    let Some(rpc_block) = rpc_block else {
+        return Ok(None);
+    };
 
     let block = rpc_block
         .into_inner()
@@ -695,7 +658,7 @@ async fn fetch_one_block(
     let (payload, sidecar) = ExecutionPayload::from_block_slow(&block);
     let execution_data = ExecutionData { payload, sidecar };
 
-    Ok(Some(FetchedBlock { execution_data, consensus_receipts, block_access_list }))
+    Ok(Some(FetchedBlock { execution_data, block_access_list }))
 }
 
 fn merge_block_access_list(

From 96be18816d351e4409f404d063f2013297528f56 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Wed, 6 May 2026 17:03:07 +0400
Subject: [PATCH 043/335] perf: avoid clone (#23940)

---
 crates/engine/tree/src/tree/payload_validator.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 43e1d5a5703..5066e47e93f 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -109,7 +109,7 @@ pub type ValidationOutcome<N, E = InsertPayloadError<BlockTy<N>>> =
     Result<(ExecutedBlock<N>, Option<Box<ExecutionTimingStats>>), E>;
 
 /// 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<
@@ -600,7 +600,7 @@ where
                     "hashed_post_state",
                 )
                 .entered();
-                hashed_state_provider.hashed_post_state(&hashed_state_output.state)
+                Arc::new(hashed_state_provider.hashed_post_state(&hashed_state_output.state))
             });
 
         let block = convert_to_block(input)?;
@@ -1125,7 +1125,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.
@@ -1639,8 +1639,8 @@ where
         // 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);
@@ -2032,7 +2032,7 @@ where
             block.recovered_block,
             block.execution_output,
             state,
-            LazyHashedPostState::ready(Arc::unwrap_or_clone(block.hashed_state)),
+            LazyHashedPostState::ready(block.hashed_state),
             block.trie_updates,
             changeset_provider,
         ))

From 5acc992ebfc7f6db10a1dd35f2fc317c91db7a8c Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 6 May 2026 15:58:42 +0200
Subject: [PATCH 044/335] fix(discv5): advertise configured NAT IP in ENR
 (#24013)

---
 Cargo.lock                            |  1 +
 crates/ethereum/node/Cargo.toml       |  1 +
 crates/ethereum/node/tests/e2e/rpc.rs | 47 +++++++++++++++++++++++++++
 crates/net/discv5/src/config.rs       | 26 +++++++++++++++
 crates/net/discv5/src/lib.rs          | 12 +++++--
 crates/net/network/src/config.rs      | 12 +++++--
 6 files changed, 94 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3d9fece03f7..18e78831e9e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9310,6 +9310,7 @@ dependencies = [
  "alloy-rpc-types-trace",
  "alloy-signer",
  "alloy-sol-types",
+ "enr",
  "eyre",
  "futures",
  "jsonrpsee-core",
diff --git a/crates/ethereum/node/Cargo.toml b/crates/ethereum/node/Cargo.toml
index 3a52f188a90..24737c34f19 100644
--- a/crates/ethereum/node/Cargo.toml
+++ b/crates/ethereum/node/Cargo.toml
@@ -78,6 +78,7 @@ 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
 
diff --git a/crates/ethereum/node/tests/e2e/rpc.rs b/crates/ethereum/node/tests/e2e/rpc.rs
index 89f4300daf1..2fc1b670d01 100644
--- a/crates/ethereum/node/tests/e2e/rpc.rs
+++ b/crates/ethereum/node/tests/e2e/rpc.rs
@@ -23,6 +23,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},
 };
@@ -419,3 +420,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/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/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();

From 1021fc2c27fc212ad591328ae189011df812bc13 Mon Sep 17 00:00:00 2001
From: CPerezz <37264926+CPerezz@users.noreply.github.com>
Date: Wed, 6 May 2026 16:29:25 +0200
Subject: [PATCH 045/335] feat(node, db-common): add
 --debug.skip-genesis-validation (#23919)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/node/builder/src/launch/common.rs | 10 +++-
 crates/node/core/src/args/debug.rs       | 10 ++++
 crates/storage/db-common/src/init.rs     | 69 ++++++++++++++++++++++++
 docs/vocs/docs/pages/cli/reth/node.mdx   |  3 ++
 4 files changed, 90 insertions(+), 2 deletions(-)

diff --git a/crates/node/builder/src/launch/common.rs b/crates/node/builder/src/launch/common.rs
index 94272368775..b1fc0d914c4 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};
@@ -660,7 +662,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)
     }
 
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/storage/db-common/src/init.rs b/crates/storage/db-common/src/init.rs
index f42eca05925..ada8fec152a 100644
--- a/crates/storage/db-common/src/init.rs
+++ b/crates/storage/db-common/src/init.rs
@@ -138,6 +138,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 +229,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,
@@ -1044,6 +1086,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/docs/vocs/docs/pages/cli/reth/node.mdx b/docs/vocs/docs/pages/cli/reth/node.mdx
index 0b687232dcb..14b9c127ce5 100644
--- a/docs/vocs/docs/pages/cli/reth/node.mdx
+++ b/docs/vocs/docs/pages/cli/reth/node.mdx
@@ -753,6 +753,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
 

From 63cd25010282800fb45bfbe977c5cc73afa73755 Mon Sep 17 00:00:00 2001
From: onbjerg <onbjerg@users.noreply.github.com>
Date: Wed, 6 May 2026 16:52:26 +0200
Subject: [PATCH 046/335] feat(bench): route PR benchmarks through txgen
 (#23869)

---
 .github/scripts/bench-reth-summary.py         |  13 +
 .github/scripts/bench-txgen-build.sh          |  59 ++++
 .github/scripts/bench-txgen-install.sh        |  37 +++
 .../scripts/bench-txgen-report-to-reth-csv.py | 107 +++++++
 .github/scripts/bench-txgen-run.sh            | 293 ++++++++++++++++++
 .github/scripts/bench-utils.js                |   6 +
 .github/workflows/bench.yml                   |  86 ++++-
 7 files changed, 588 insertions(+), 13 deletions(-)
 create mode 100755 .github/scripts/bench-txgen-build.sh
 create mode 100755 .github/scripts/bench-txgen-install.sh
 create mode 100755 .github/scripts/bench-txgen-report-to-reth-csv.py
 create mode 100755 .github/scripts/bench-txgen-run.sh

diff --git a/.github/scripts/bench-reth-summary.py b/.github/scripts/bench-reth-summary.py
index 300006cad6c..9871409178e 100755
--- a/.github/scripts/bench-reth-summary.py
+++ b/.github/scripts/bench-reth-summary.py
@@ -385,6 +385,8 @@ def generate_comparison_table(
     warmup_blocks: str | None = None,
     wait_time: str | None = None,
     bal_mode: str | None = None,
+    driver: str | None = None,
+    driver_reason: str | None = None,
 ) -> str:
     """Generate a markdown comparison table between baseline and feature."""
     n = paired["blocks"]
@@ -431,6 +433,11 @@ def pct(base: float, feat: float) -> float:
         "",
     ]
     meta_parts = [f"{n} {'big blocks' if big_blocks else 'blocks'}"]
+    if driver:
+        driver_label = driver
+        if driver_reason:
+            driver_label += f" (fallback: {driver_reason})"
+        meta_parts.append(f"driver: {driver_label}")
     if warmup_blocks:
         meta_parts.append(f"{warmup_blocks} warmup")
     if wait_time:
@@ -521,6 +528,8 @@ 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("--driver-reason", default=None, help="Why the benchmark fell back to this driver")
     parser.add_argument("--grafana-url", default=None, help="Grafana dashboard URL for this benchmark run")
     args = parser.parse_args()
 
@@ -575,6 +584,8 @@ def main():
         warmup_blocks=args.warmup_blocks,
         wait_time=args.wait_time,
         bal_mode=bal_mode,
+        driver=args.driver,
+        driver_reason=args.driver_reason,
     )
     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)")
@@ -605,6 +616,8 @@ def main():
 
     summary = {
         "blocks": paired_stats["blocks"],
+        "driver": args.driver,
+        "driver_reason": args.driver_reason,
         "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-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..e759ab19024
--- /dev/null
+++ b/.github/scripts/bench-txgen-run.sh
@@ -0,0 +1,293 @@
+#!/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_WAIT_TIME, BENCH_BASELINE_ARGS,
+#               BENCH_FEATURE_ARGS, BENCH_OTLP_TRACES_ENDPOINT,
+#               BENCH_OTLP_LOGS_ENDPOINT, BENCH_OTLP_DISABLED,
+#               BENCH_TRACY, BENCH_TRACY_FILTER, BENCH_TRACY_SAMPLING_HZ
+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_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 [ -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
+      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=$(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
+
+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 / 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)"
+TXGEN_SEND_ARGS=()
+if [ -n "${BENCH_WAIT_TIME:-}" ]; then
+  TXGEN_SEND_ARGS+=(--wait-time "$BENCH_WAIT_TIME")
+fi
+
+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 ))
+echo "Extracting blocks ${EXTRACT_FROM}..${EXTRACT_TO} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured)"
+"$TXGEN_ETHEREUM" extract \
+  --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" \
+    "${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.
+# 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" \
+  "${TXGEN_SEND_ARGS[@]}" \
+  --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..2889e706d85 100644
--- a/.github/scripts/bench-utils.js
+++ b/.github/scripts/bench-utils.js
@@ -54,6 +54,12 @@ function balModeLabel(mode) {
 
 function blocksLabel(summary) {
   const parts = [];
+  const driver = summary.driver || process.env.BENCH_DRIVER || '';
+  const driverReason = summary.driver_reason || process.env.BENCH_DRIVER_REASON || '';
+  if (driver) {
+    const value = driverReason ? `${driver} (fallback: ${driverReason})` : driver;
+    parts.push({ key: 'Driver', value });
+  }
   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 951fdfe0426..1ad30c1eb37 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -130,6 +130,9 @@ jobs:
       feature-args: ${{ steps.args.outputs.feature-args }}
       abba: ${{ steps.args.outputs.abba }}
       otlp: ${{ steps.args.outputs.otlp }}
+      driver: ${{ steps.args.outputs.driver }}
+      node-bin: ${{ steps.args.outputs.node-bin }}
+      driver-reason: ${{ steps.args.outputs.driver-reason }}
       comment-id: ${{ steps.ack.outputs.comment-id }}
     steps:
       - name: Check org membership
@@ -339,6 +342,13 @@ jobs:
               }
             }
 
+            const fallbackReasons = [];
+            if (bigBlocks === 'true') fallbackReasons.push('big-blocks');
+            if (bal !== 'false') fallbackReasons.push('BAL');
+            const driver = fallbackReasons.length ? 'reth-bench' : 'txgen';
+            const nodeBin = bigBlocks === 'true' ? 'reth-bb' : 'reth';
+            const driverReason = fallbackReasons.join(',');
+
             core.setOutput('pr', pr || '');
             core.setOutput('actor', actor);
             core.setOutput('blocks', blocks);
@@ -357,6 +367,9 @@ jobs:
             core.setOutput('feature-args', featureNodeArgs);
             core.setOutput('abba', abba);
             core.setOutput('otlp', otlp);
+            core.setOutput('driver', driver);
+            core.setOutput('node-bin', nodeBin);
+            core.setOutput('driver-reason', driverReason);
 
       - name: Acknowledge request
         id: ack
@@ -432,8 +445,11 @@ jobs:
             const baselineArgsNote = baselineArgsVal ? `, baseline-args: \`${baselineArgsVal}\`` : '';
             const featureArgsVal = '${{ steps.args.outputs.feature-args }}';
             const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
+            const driver = '${{ steps.args.outputs.driver }}' || (bigBlocks ? 'reth-bench' : 'txgen');
+            const driverReason = '${{ steps.args.outputs.driver-reason }}';
+            const driverNote = driverReason ? `, driver: \`${driver}\` (fallback: \`${driverReason}\`)` : `, 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 +492,11 @@ jobs:
             const baselineArgsNote = baselineArgsVal ? `, baseline-args: \`${baselineArgsVal}\`` : '';
             const featureArgsVal = '${{ steps.args.outputs.feature-args }}';
             const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
+            const driver = '${{ steps.args.outputs.driver }}' || (bigBlocks ? 'reth-bench' : 'txgen');
+            const driverReason = '${{ steps.args.outputs.driver-reason }}';
+            const driverNote = driverReason ? `, driver: \`${driver}\` (fallback: \`${driverReason}\`)` : `, 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 +547,7 @@ jobs:
 
   reth-bench:
     needs: reth-bench-ack
-    name: reth-bench
+    name: bench-${{ needs.reth-bench-ack.outputs.driver }}
     runs-on: [self-hosted, Linux, X64, available]
     permissions:
       contents: read
@@ -554,9 +573,12 @@ 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_NODE_BIN: ${{ needs.reth-bench-ack.outputs.big-blocks == 'true' && 'reth-bb' || 'reth' }}
+      BENCH_DRIVER: ${{ needs.reth-bench-ack.outputs.driver }}
+      BENCH_NODE_BIN: ${{ needs.reth-bench-ack.outputs.node-bin }}
+      BENCH_DRIVER_REASON: ${{ needs.reth-bench-ack.outputs.driver-reason }}
       BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
       BENCH_METRICS_ADDR: "127.0.0.1:9001"
+      TXGEN_REV: 5b04a80d557cc6658573db6ccf49ce04cbf07ea3
       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:
@@ -601,7 +623,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);
 
@@ -628,8 +651,11 @@ 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 driverReason = process.env.BENCH_DRIVER_REASON || '';
+            const driverNote = driverReason ? `, driver: \`${driver}\` (fallback: \`${driverReason}\`)` : `, 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({
@@ -836,14 +862,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
@@ -972,7 +1010,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
@@ -985,7 +1027,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'
@@ -999,7 +1045,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'
@@ -1013,7 +1063,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
@@ -1152,6 +1206,12 @@ 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
+          if [ -n "${BENCH_DRIVER_REASON:-}" ]; then
+            SUMMARY_ARGS="$SUMMARY_ARGS --driver-reason $BENCH_DRIVER_REASON"
+          fi
           GRAFANA_URL='${{ steps.metrics.outputs.grafana-url }}'
           if [ -n "$GRAFANA_URL" ]; then
             SUMMARY_ARGS="$SUMMARY_ARGS --grafana-url $GRAFANA_URL"
@@ -1183,7 +1243,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

From 6cc20bf9e7a6271a1715abaf43f0a3263f234f31 Mon Sep 17 00:00:00 2001
From: Dan Cline <6798349+Rjected@users.noreply.github.com>
Date: Wed, 6 May 2026 11:35:19 -0400
Subject: [PATCH 047/335] fix(provider): add default rocksdb write buffer
 manager (#24001)

---
 .../src/providers/rocksdb/provider.rs         | 20 ++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

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

From df18e75bda0de4af9e6d3af784b665aba703078a Mon Sep 17 00:00:00 2001
From: Alexey Shekhirin <github@shekhirin.com>
Date: Wed, 6 May 2026 16:36:44 +0100
Subject: [PATCH 048/335] feat(metrics): add storage settings metric (#24018)

---
 crates/node/builder/src/launch/common.rs | 33 ++++++++--
 crates/node/core/src/args/mod.rs         |  2 +-
 crates/node/core/src/args/pruning.rs     | 77 ++++++++++++++++++++++++
 crates/node/metrics/src/lib.rs           |  1 +
 crates/node/metrics/src/server.rs        | 25 +++++++-
 crates/node/metrics/src/storage.rs       | 29 +++++++++
 6 files changed, 161 insertions(+), 6 deletions(-)
 create mode 100644 crates/node/metrics/src/storage.rs

diff --git a/crates/node/builder/src/launch/common.rs b/crates/node/builder/src/launch/common.rs
index b1fc0d914c4..0afef017616 100644
--- a/crates/node/builder/src/launch/common.rs
+++ b/crates/node/builder/src/launch/common.rs
@@ -53,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,
@@ -64,13 +64,14 @@ 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,
+    StaticFileProviderFactory, StorageSettingsCache,
 };
 use reth_prune::{PruneModes, PrunerBuilder};
 use reth_rpc_builder::config::RethRpcServerConfig;
@@ -622,18 +623,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 {
@@ -649,6 +668,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,
diff --git a/crates/node/core/src/args/mod.rs b/crates/node/core/src/args/mod.rs
index 6d6fbbd0078..f885111cb42 100644
--- a/crates/node/core/src/args/mod.rs
+++ b/crates/node/core/src/args/mod.rs
@@ -54,7 +54,7 @@ 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;
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/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);
+    }
+}

From 02d1776786abc61721ae8876898ad19a702e0070 Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Wed, 6 May 2026 22:39:14 +0530
Subject: [PATCH 049/335] chore: add eth72 version (#24012)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/eth-wire-types/src/broadcast.rs  |  6 +++-
 crates/net/eth-wire-types/src/capability.rs | 38 +++++++++++++++++----
 crates/net/eth-wire-types/src/version.rs    |  9 +++++
 crates/net/network/src/transactions/mod.rs  |  8 +++--
 4 files changed, 50 insertions(+), 11 deletions(-)

diff --git a/crates/net/eth-wire-types/src/broadcast.rs b/crates/net/eth-wire-types/src/broadcast.rs
index aa939a152cd..56d5ad347ec 100644
--- a/crates/net/eth-wire-types/src/broadcast.rs
+++ b/crates/net/eth-wire-types/src/broadcast.rs
@@ -237,7 +237,11 @@ impl NewPooledTransactionHashes {
             Self::Eth68(_) => {
                 matches!(
                     version,
-                    EthVersion::Eth68 | EthVersion::Eth69 | EthVersion::Eth70 | EthVersion::Eth71
+                    EthVersion::Eth68 |
+                        EthVersion::Eth69 |
+                        EthVersion::Eth70 |
+                        EthVersion::Eth71 |
+                        EthVersion::Eth72
                 )
             }
         }
diff --git a/crates/net/eth-wire-types/src/capability.rs b/crates/net/eth-wire-types/src/capability.rs
index 69c64038e74..acac45e580c 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,
         }
     }
 
@@ -334,6 +357,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/version.rs b/crates/net/eth-wire-types/src/version.rs
index d9921c44b9c..8854993a4c6 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 {
@@ -117,6 +119,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 +146,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 +178,7 @@ impl From<EthVersion> for &'static str {
             EthVersion::Eth69 => "69",
             EthVersion::Eth70 => "70",
             EthVersion::Eth71 => "71",
+            EthVersion::Eth72 => "72",
         }
     }
 }
@@ -232,6 +237,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 +248,7 @@ 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]
@@ -253,6 +260,7 @@ mod tests {
             EthVersion::Eth69,
             EthVersion::Eth70,
             EthVersion::Eth71,
+            EthVersion::Eth72,
         ];
 
         for version in versions {
@@ -272,6 +280,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/network/src/transactions/mod.rs b/crates/net/network/src/transactions/mod.rs
index 3920cc3056e..5fe91c7ab1d 100644
--- a/crates/net/network/src/transactions/mod.rs
+++ b/crates/net/network/src/transactions/mod.rs
@@ -1974,9 +1974,11 @@ impl PooledTransactionsHashesBuilder {
     fn new(version: EthVersion) -> Self {
         match version {
             EthVersion::Eth66 | EthVersion::Eth67 => Self::Eth66(Default::default()),
-            EthVersion::Eth68 | EthVersion::Eth69 | EthVersion::Eth70 | EthVersion::Eth71 => {
-                Self::Eth68(Default::default())
-            }
+            EthVersion::Eth68 |
+            EthVersion::Eth69 |
+            EthVersion::Eth70 |
+            EthVersion::Eth71 |
+            EthVersion::Eth72 => Self::Eth68(Default::default()),
         }
     }
 

From 1a45f10d074bbde171cfc26cf81a764ed5b17d4e Mon Sep 17 00:00:00 2001
From: Karl Yu <43113774+0xKarl98@users.noreply.github.com>
Date: Thu, 7 May 2026 14:43:53 +0800
Subject: [PATCH 050/335] feat(storage): add BAL store pruning (#24023)

---
 crates/storage/provider/src/bal.rs    | 60 ++++++++++++++++++++++++---
 crates/storage/storage-api/src/bal.rs | 20 +++++++++
 2 files changed, 74 insertions(+), 6 deletions(-)

diff --git a/crates/storage/provider/src/bal.rs b/crates/storage/provider/src/bal.rs
index fa68bbc3446..9f436d03557 100644
--- a/crates/storage/provider/src/bal.rs
+++ b/crates/storage/provider/src/bal.rs
@@ -95,11 +95,11 @@ impl InMemoryBalStoreInner {
         );
     }
 
-    // Removes BALs outside the configured retention window.
-    fn prune(&mut self, prune_mode: Option<PruneMode>) {
-        let Some(prune_mode) = prune_mode else { return };
-        let Some(tip) = self.highest_block_number else { return };
+    // 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
@@ -107,9 +107,10 @@ impl InMemoryBalStoreInner {
 
             let Some((_, hashes)) = self.hashes_by_number.pop_first() else { break };
             for hash in hashes {
-                self.entries.remove(&hash);
+                pruned += usize::from(self.entries.remove(&hash).is_some());
             }
         }
+        pruned
     }
 }
 
@@ -123,11 +124,18 @@ impl BalStore for InMemoryBalStore {
     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());
-        inner.prune(self.config.in_memory_retention);
+        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 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 inner = self.inner.read();
         let mut result = Vec::with_capacity(block_hashes.len());
@@ -257,6 +265,45 @@ mod tests {
         );
     }
 
+    #[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());
@@ -277,6 +324,7 @@ mod tests {
             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]
diff --git a/crates/storage/storage-api/src/bal.rs b/crates/storage/storage-api/src/bal.rs
index c5dac1854f1..9b118731d40 100644
--- a/crates/storage/storage-api/src/bal.rs
+++ b/crates/storage/storage-api/src/bal.rs
@@ -43,6 +43,11 @@ pub trait BalStore: Send + Sync + 'static {
     /// Insert the BAL for the given block.
     fn insert(&self, num_hash: NumHash, bal: SealedBal) -> ProviderResult<()>;
 
+    /// 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`.
@@ -155,6 +160,12 @@ impl BalStoreHandle {
         self.inner.insert(num_hash, bal)
     }
 
+    /// 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.
     #[inline]
     pub fn get_by_hashes(&self, block_hashes: &[BlockHash]) -> ProviderResult<Vec<Option<Bytes>>> {
@@ -237,6 +248,10 @@ impl BalStore for NoopBalStore {
         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())
     }
@@ -288,6 +303,7 @@ mod tests {
         assert_eq!(by_hash, vec![None, None]);
         assert!(store.get_by_hash(B256::random()).unwrap().is_none());
         assert!(by_range.is_empty());
+        assert_eq!(store.prune(10).unwrap(), 0);
     }
 
     #[test]
@@ -353,6 +369,10 @@ mod tests {
             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()

From 8e5cece4bad88c9168f3d6cd3ef84d4f96a243cc Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Thu, 7 May 2026 16:43:20 +0800
Subject: [PATCH 051/335] chore: extract spawn_receipt_root_task (#24031)

---
 .../engine/tree/src/tree/payload_validator.rs | 36 +++++++++++--------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 5066e47e93f..3fdd3b6311b 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -117,6 +117,10 @@ type InsertPayloadResult<N> = Result<
     InsertPayloadError<<N as NodePrimitives>::Block>,
 >;
 
+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.
 ///
 /// This context is provided to the [`EngineValidator`] and includes the state of the tree's
@@ -903,11 +907,7 @@ where
         input: &BlockOrPayload<T>,
         handle: &mut PayloadHandle<impl ExecutableTxFor<Evm>, Err, N::Receipt>,
     ) -> Result<
-        (
-            BlockExecutionOutput<N::Receipt>,
-            Vec<Address>,
-            tokio::sync::oneshot::Receiver<(B256, alloy_primitives::Bloom)>,
-        ),
+        (BlockExecutionOutput<N::Receipt>, Vec<Address>, ReceiptRootReceiver),
         InsertBlockErrorKind,
     >
     where
@@ -956,17 +956,8 @@ 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>),
@@ -1005,6 +996,21 @@ where
         Ok((output, senders, result_rx))
     }
 
+    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:

From e9a6664862b7e8787bcead65c92ab945300379b1 Mon Sep 17 00:00:00 2001
From: JOJO <wataxiwajojo@protonmail.com>
Date: Thu, 7 May 2026 09:36:35 +0000
Subject: [PATCH 052/335] feat(engine): include rejection reason in
 InvalidBlock event (#23945)

---
 crates/engine/primitives/src/event.rs | 13 ++++--
 crates/engine/tree/src/tree/mod.rs    | 12 ++++--
 crates/node/events/src/node.rs        |  4 +-
 crates/rpc/rpc/src/debug.rs           | 58 ++++++++++++++++-----------
 4 files changed, 53 insertions(+), 34 deletions(-)

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/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index 624501bc7bf..c39b20262e9 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -2350,7 +2350,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)
     }
@@ -3083,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/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/rpc/rpc/src/debug.rs b/crates/rpc/rpc/src/debug.rs
index 86e1fe8b42c..f38efa79c75 100644
--- a/crates/rpc/rpc/src/debug.rs
+++ b/crates/rpc/rpc/src/debug.rs
@@ -71,10 +71,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);
                 }
             }
         });
@@ -697,21 +697,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 +721,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);
         }
@@ -1068,7 +1071,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,12 +1080,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)
+        self.trace_block(entry.block.clone(), evm_env, opts).await.map_err(Into::into)
     }
 
     async fn debug_verbosity(&self, level: usize) -> RpcResult<()> {
@@ -1130,43 +1133,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()
     }
 }
 

From 9d3542d8bfcd495c3e470a9d9bbf5feab33f806a Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Thu, 7 May 2026 18:09:08 +0800
Subject: [PATCH 053/335] refactor: use crossbeam receiver for tx recovery
 (#24032)

---
 .../tree/src/tree/payload_processor/mod.rs    | 47 ++++++++++++++-----
 1 file changed, 34 insertions(+), 13 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_processor/mod.rs b/crates/engine/tree/src/tree/payload_processor/mod.rs
index c21b541deb8..2554c5fcce7 100644
--- a/crates/engine/tree/src/tree/payload_processor/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/mod.rs
@@ -80,12 +80,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>
@@ -388,18 +408,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.
@@ -448,7 +464,7 @@ where
                             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");
                         });
                         });
@@ -730,7 +746,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,
@@ -745,7 +761,7 @@ fn convert_serial<RawTx, Tx, TxEnv, InnerTx, Recovered, Err, C>(
         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 +778,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,
 }
@@ -846,7 +862,12 @@ 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()
     }
 }
 

From d497929a72c5bcda4f56974d640a677fe5b7f736 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Thu, 7 May 2026 15:28:59 +0400
Subject: [PATCH 054/335] refactor: further simplify generate-big-block
 (#24025)

---
 .../src/bench/generate_big_block.rs           | 74 +------------------
 1 file changed, 4 insertions(+), 70 deletions(-)

diff --git a/bin/reth-bench/src/bench/generate_big_block.rs b/bin/reth-bench/src/bench/generate_big_block.rs
index dabc9549745..43bc6f7e5ad 100644
--- a/bin/reth-bench/src/bench/generate_big_block.rs
+++ b/bin/reth-bench/src/bench/generate_big_block.rs
@@ -7,8 +7,6 @@
 
 use alloy_consensus::TxEnvelope;
 use alloy_eips::{
-    eip1559::BaseFeeParams,
-    eip7840::BlobParams,
     eip7928::{AccountChanges, BlockAccessList, SlotChanges},
     Typed2718,
 };
@@ -317,17 +315,6 @@ impl Command {
         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;
-
         // Persistent prefetch stream: keeps `prefetch_buffer` per-block fetches in flight
         // ahead of the merger across all big blocks. Each item is a fully materialized
         // `FetchedBlock` (or `None` once the chain tip is reached on this fetch).
@@ -380,14 +367,11 @@ impl Command {
                 let FetchedBlock { execution_data, block_access_list } = fetched;
 
                 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(),
                     "Fetched block"
                 );
@@ -468,9 +452,8 @@ impl Command {
                 base_v1.gas_limit = total_gas_limit;
             }
 
-            // 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
+            // Chain sequential big blocks: set parent_hash, block_number.
+            // 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;
@@ -478,53 +461,17 @@ impl Command {
                 // 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.
+            // Merge blob data from all constituent blocks:  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,
@@ -550,19 +497,6 @@ impl Command {
             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 {

From ba6ed3eef99118c2619694980c91b2f3330ea8c7 Mon Sep 17 00:00:00 2001
From: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
Date: Thu, 7 May 2026 18:29:44 +0530
Subject: [PATCH 055/335] chore: added structs for eip 8070 (#24024)

---
 crates/net/eth-wire-types/src/transactions.rs | 39 +++++++++++++++++--
 1 file changed, 36 insertions(+), 3 deletions(-)

diff --git a/crates/net/eth-wire-types/src/transactions.rs b/crates/net/eth-wire-types/src/transactions.rs
index 730a1bbf8d5..f43e4e1d928 100644
--- a/crates/net/eth-wire-types/src/transactions.rs
+++ b/crates/net/eth-wire-types/src/transactions.rs
@@ -3,9 +3,9 @@
 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_eips::{eip2718::Encodable2718, 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;
@@ -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};

From 36ccbaef56acedddd806672e079d6c128d09a000 Mon Sep 17 00:00:00 2001
From: Emma Jamieson-Hoare <emmajam@users.noreply.github.com>
Date: Thu, 7 May 2026 15:37:47 +0100
Subject: [PATCH 056/335] ci(bench): link Reth repo in Slack notifications
 (#24039)

---
 .github/scripts/bench-slack-notify.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/scripts/bench-slack-notify.js b/.github/scripts/bench-slack-notify.js
index e6a78a3a0fc..c9c3ccc3333 100644
--- a/.github/scripts/bench-slack-notify.js
+++ b/.github/scripts/bench-slack-notify.js
@@ -76,11 +76,12 @@ function buildSuccessBlocks({ summary, prNumber, actor, actorSlackId, jobUrl, re
 
   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}`}`);
 
@@ -180,8 +181,10 @@ function buildSuccessBlocks({ summary, prNumber, actor, actorSlackId, jobUrl, re
 
 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}*`,

From e89258ae8d546fec0df4cd10b4119d3b7387a662 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Thu, 7 May 2026 18:43:24 +0400
Subject: [PATCH 057/335] feat: support big blocks in `reth-bench
 new-payload-fcu` (#24028)

---
 Cargo.lock                                    |   1 +
 bin/reth-bench/Cargo.toml                     |   1 +
 bin/reth-bench/src/bench/context.rs           |   7 +
 .../src/bench/generate_big_block.rs           | 177 +++++++-------
 bin/reth-bench/src/bench/new_payload_fcu.rs   | 215 ++++++++++++++----
 bin/reth-bench/src/bench_mode.rs              |   2 +-
 crates/node/core/src/args/benchmark_args.rs   |   5 +
 7 files changed, 291 insertions(+), 117 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 18e78831e9e..4f2f22ecdd9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7621,6 +7621,7 @@ dependencies = [
  "serde_json",
  "thiserror 2.0.18",
  "tokio",
+ "tokio-stream",
  "tower",
  "tracing",
  "url",
diff --git a/bin/reth-bench/Cargo.toml b/bin/reth-bench/Cargo.toml
index 63f0fc0e80b..99a76e0a442 100644
--- a/bin/reth-bench/Cargo.toml
+++ b/bin/reth-bench/Cargo.toml
@@ -65,6 +65,7 @@ url.workspace = true
 async-trait.workspace = true
 futures.workspace = true
 tokio = { workspace = true, features = ["sync", "macros", "time", "rt-multi-thread"] }
+tokio-stream.workspace = true
 
 # misc
 clap = { workspace = true, features = ["derive", "env"] }
diff --git a/bin/reth-bench/src/bench/context.rs b/bin/reth-bench/src/bench/context.rs
index 4df7e5f534c..f3579c1ed71 100644
--- a/bin/reth-bench/src/bench/context.rs
+++ b/bin/reth-bench/src/bench/context.rs
@@ -117,6 +117,13 @@ impl BenchContext {
             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 if bench_args.big_blocks.is_some() && bench_args.from.is_none() {
+            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;
+            (Some(head_number), bench_args.to)
         } else {
             (bench_args.from, bench_args.to)
         };
diff --git a/bin/reth-bench/src/bench/generate_big_block.rs b/bin/reth-bench/src/bench/generate_big_block.rs
index 43bc6f7e5ad..5aa51c0804b 100644
--- a/bin/reth-bench/src/bench/generate_big_block.rs
+++ b/bin/reth-bench/src/bench/generate_big_block.rs
@@ -11,7 +11,10 @@ use alloy_eips::{
     Typed2718,
 };
 use alloy_primitives::{Bytes, B256};
-use alloy_provider::{network::AnyNetwork, Provider, RootProvider};
+use alloy_provider::{
+    network::{AnyNetwork, AnyRpcBlock},
+    Provider, RootProvider,
+};
 use alloy_rpc_client::ClientBuilder;
 use alloy_rpc_types_engine::{
     CancunPayloadFields, ExecutionData, ExecutionPayload, ExecutionPayloadSidecar,
@@ -19,7 +22,7 @@ use alloy_rpc_types_engine::{
 };
 use clap::Parser;
 use eyre::Context;
-use futures::{stream, StreamExt};
+use futures::{stream, Stream, StreamExt};
 use reth_chainspec::EthChainSpec;
 use reth_cli::chainspec::ChainSpecParser;
 use reth_cli_runner::CliContext;
@@ -312,9 +315,6 @@ impl Command {
             .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();
-
         // Persistent prefetch stream: keeps `prefetch_buffer` per-block fetches in flight
         // ahead of the merger across all big blocks. Each item is a fully materialized
         // `FetchedBlock` (or `None` once the chain tip is reached on this fetch).
@@ -326,31 +326,79 @@ impl Command {
                 async move { fetch_one_block(provider, block_number, bal_enabled).await }
             })
             .buffered(prefetch_buffer);
-        let mut block_stream = Box::pin(block_stream);
 
-        // Track the next block number we expect from the stream (purely for logging /
-        // big-block range bookkeeping; the stream produces blocks in `from_block..` order).
-        let mut next_block = self.from_block;
+        let mut big_blocks_stream =
+            Box::pin(big_blocks_stream(self.num_big_blocks, self.target_gas, block_stream));
 
-        for big_block_idx in 0..self.num_big_blocks {
-            let range_start = next_block;
+        while let Some(big_block) = big_blocks_stream.next().await {
+            let big_block = big_block?;
+            // Save to disk
+            let range_start = big_block.big_block_data.env_switches[0].1.block_number();
+            let range_end = big_block.big_block_data.env_switches.last().unwrap().1.block_number();
+            let block_hash = big_block.execution_data.payload.as_v1().block_hash;
+            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"
+            );
+        }
+
+        Ok(())
+    }
+}
+
+/// Produces a stream of big block payloads given a stream of regular blocks.
+pub(crate) fn big_blocks_stream(
+    num_big_blocks: u64,
+    target_gas: u64,
+    block_stream: impl Stream<Item = eyre::Result<Option<(AnyRpcBlock, Option<BlockAccessList>)>>>
+        + Unpin,
+) -> impl Stream<Item = eyre::Result<BigBlockPayload>> {
+    futures::stream::try_unfold(
+        (block_stream, Vec::new(), 0, None, false, 0),
+        move |(
+            mut block_stream,
+            mut accumulated_block_hashes,
+            mut big_block_idx,
+            mut prev_big_block_hash,
+            mut reached_chain_tip,
+            mut first_block,
+        )| async move {
+            if reached_chain_tip || num_big_blocks == big_block_idx {
+                warn!(
+                    target: "reth-bench",
+                    generated = big_block_idx + 1,
+                    requested = num_big_blocks,
+                    "Reached chain tip, stopping generation early"
+                );
+                return Ok(None);
+            }
 
             // Drain the prefetch stream until the gas target is reached for this big block.
             let mut blocks = 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, "Awaiting prefetched block");
+            while accumulated_block_gas < target_gas {
+                info!(target: "reth-bench", big_block = big_block_idx, "Awaiting prefetched block");
 
-                let fetched = match block_stream.next().await {
+                let (block, block_access_list) = match block_stream.next().await {
                     Some(Ok(Some(fetched))) => fetched,
                     Some(Ok(None)) => {
                         warn!(
                             target: "reth-bench",
-                            block_number,
                             "Block not found — reached chain tip"
                         );
                         reached_chain_tip = true;
@@ -364,13 +412,27 @@ impl Command {
                         break;
                     }
                 };
-                let FetchedBlock { execution_data, block_access_list } = fetched;
+
+                if first_block == 0 {
+                    first_block = block.header.number;
+                }
+
+                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 (payload, sidecar) = ExecutionPayload::from_block_slow(&block);
+                let execution_data = ExecutionData { payload, sidecar };
 
                 let block_gas = execution_data.payload.as_v1().gas_used;
 
                 info!(
                     target: "reth-bench",
-                    block_number,
+                    block_number = block.header.number,
                     gas_used = block_gas,
                     tx_count = execution_data.payload.transactions().len(),
                     "Fetched block"
@@ -379,7 +441,6 @@ impl Command {
                 accumulated_block_gas += block_gas;
                 blocks.push(execution_data);
                 block_access_lists.push(block_access_list);
-                next_block += 1;
             }
 
             // If we hit the chain tip without fetching any blocks, stop generating.
@@ -387,10 +448,10 @@ impl Command {
                 warn!(
                     target: "reth-bench",
                     big_block = big_block_idx,
-                    requested = self.num_big_blocks,
+                    requested = num_big_blocks,
                     "No blocks available, stopping generation early"
                 );
-                break;
+                return Ok(None);
             }
 
             // Block 0 is the base
@@ -459,7 +520,7 @@ impl Command {
                 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;
+                base.payload.as_v1_mut().block_number = first_block + big_block_idx;
             }
 
             // Merge blob data from all constituent blocks:  concatenate versioned
@@ -519,47 +580,20 @@ impl Command {
                 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(())
-    }
-}
-
-/// One fully-materialized block fetched by the prefetcher.
-struct FetchedBlock {
-    /// Execution payload with sidecar derived from the RPC block.
-    execution_data: ExecutionData,
-    /// `eth_getBlockAccessListByBlockNumber` result when `--bal` is enabled.
-    block_access_list: Option<BlockAccessList>,
+            big_block_idx += 1;
+            Ok(Some((
+                big_block,
+                (
+                    block_stream,
+                    accumulated_block_hashes,
+                    big_block_idx,
+                    prev_big_block_hash,
+                    reached_chain_tip,
+                    first_block,
+                ),
+            )))
+        },
+    )
 }
 
 /// Fetches one block + receipts (and optionally its BAL) from the RPC. Returns `Ok(None)`
@@ -568,7 +602,7 @@ async fn fetch_one_block(
     provider: RootProvider<AnyNetwork>,
     block_number: u64,
     bal_enabled: bool,
-) -> eyre::Result<Option<FetchedBlock>> {
+) -> eyre::Result<Option<(AnyRpcBlock, Option<BlockAccessList>)>> {
     let (rpc_block, block_access_list) =
         tokio::try_join!(provider.get_block_by_number(block_number.into()).full(), async {
             if bal_enabled {
@@ -581,18 +615,7 @@ async fn fetch_one_block(
         return Ok(None);
     };
 
-    let block = rpc_block
-        .into_inner()
-        .map_header(|header| header.map(|h| h.into_header_with_defaults()))
-        .try_map_transactions(|tx| -> eyre::Result<TxEnvelope> {
-            tx.try_into().map_err(|_| eyre::eyre!("unsupported tx type"))
-        })?
-        .into_consensus();
-
-    let (payload, sidecar) = ExecutionPayload::from_block_slow(&block);
-    let execution_data = ExecutionData { payload, sidecar };
-
-    Ok(Some(FetchedBlock { execution_data, block_access_list }))
+    Ok(Some((rpc_block, block_access_list)))
 }
 
 fn merge_block_access_list(
diff --git a/bin/reth-bench/src/bench/new_payload_fcu.rs b/bin/reth-bench/src/bench/new_payload_fcu.rs
index a3de7c4f1f5..d44f9b8f132 100644
--- a/bin/reth-bench/src/bench/new_payload_fcu.rs
+++ b/bin/reth-bench/src/bench/new_payload_fcu.rs
@@ -4,19 +4,22 @@
 use crate::{
     bench::{
         context::BenchContext,
+        generate_big_block::big_blocks_stream,
         helpers::{fetch_block_access_list, parse_duration},
         metrics_scraper::MetricsScraper,
         output::{
             write_benchmark_results, CombinedResult, NewPayloadResult, TotalGasOutput, TotalGasRow,
         },
+        BigBlockPayload,
     },
     valid_payload::{
         block_to_new_payload, call_forkchoice_updated_with_reth, call_new_payload_with_reth,
     },
 };
 use alloy_consensus::TxEnvelope;
+use alloy_eip7928::BlockAccessList;
 use alloy_eips::Encodable2718;
-use alloy_primitives::B256;
+use alloy_primitives::{Bytes, B256};
 use alloy_provider::{
     ext::DebugApi,
     network::{AnyNetwork, AnyRpcBlock},
@@ -27,12 +30,18 @@ use alloy_rpc_types_engine::{
 };
 use clap::Parser;
 use eyre::{bail, ensure, Context, OptionExt};
-use futures::{stream, StreamExt, TryStreamExt};
+use futures::{stream, Stream, StreamExt, TryStreamExt};
 use reth_cli_runner::CliContext;
 use reth_engine_primitives::config::DEFAULT_PERSISTENCE_THRESHOLD;
-use reth_node_core::args::BenchmarkArgs;
+use reth_node_api::{EngineApiMessageVersion, ExecutionPayload};
+use reth_node_core::args::{BenchmarkArgs, WaitForPersistence};
 use reth_rpc_api::{RethNewPayloadInput, TestingBuildBlockRequestV1};
-use std::time::{Duration, Instant};
+use std::{
+    pin::Pin,
+    time::{Duration, Instant},
+};
+use tokio::{runtime::Handle, sync::mpsc};
+use tokio_stream::wrappers::ReceiverStream;
 use tracing::{debug, info, warn};
 
 /// `reth benchmark new-payload-fcu` command
@@ -105,6 +114,10 @@ pub struct Command {
     #[arg(long, default_value = "false", verbatim_doc_comment)]
     enable_bal: bool,
 
+    /// The target gas for the big blocks.
+    #[arg(long, value_name = "TARGET_GAS", default_value = "1G", value_parser = super::helpers::parse_gas_limit)]
+    pub big_blocks_target_gas: u64,
+
     #[command(flatten)]
     benchmark: BenchmarkArgs,
 }
@@ -198,14 +211,15 @@ impl Command {
         }
 
         let buffer_size = self.rpc_block_buffer_size;
-
-        let mut blocks = Box::pin(
+        let provider = block_provider.clone();
+        let bench_mode = benchmark_mode.clone();
+        let mut blocks: Pin<Box<dyn Stream<Item = eyre::Result<Payload>> + Send>> = Box::pin(
             stream::iter((next_block..)
-                .take_while(|next_block| {
-                    benchmark_mode.contains(*next_block)
+                .take_while(move |next_block| {
+                    bench_mode.contains(*next_block)
                 }))
-                .map(|next_block| {
-                    let block_provider = block_provider.clone();
+                .map(move |next_block| {
+                    let block_provider = provider.clone();
                     async move {
                         let block_res = block_provider
                             .get_block_by_number(next_block.into())
@@ -223,6 +237,15 @@ impl Command {
                                 }
                             };
 
+
+                        let bal = if !rlp_blocks &&
+                            (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 rlp = if rlp_blocks {
                             let rlp = match block_provider
                                 .debug_get_raw_block(next_block.into())
@@ -259,58 +282,75 @@ impl Command {
                             Ok(None) | Err(_) => head_block_hash,
                         };
 
-                        Ok((block, head_block_hash, safe_block_hash, finalized_block_hash, rlp))
+                        let forkchoice = ForkchoiceState {
+                            head_block_hash,
+                            safe_block_hash,
+                            finalized_block_hash,
+                        };
+
+                        Ok(Payload::Block(block, rlp, bal, forkchoice))
                     }
                 })
                 .buffered(buffer_size),
         );
 
+        // Big blocks: convert the stream of regular blocks into a stream of big blocks.
+        if let Some(num_big_blocks) = self.benchmark.big_blocks {
+            let block_stream = blocks.map(|res| {
+                res.map(|payload| {
+                    let Payload::Block(block, _, bal, _) = payload else {
+                        unreachable!();
+                    };
+                    Some((block, bal))
+                })
+            });
+            let mut big_blocks = Box::pin(big_blocks_stream(
+                num_big_blocks as u64,
+                self.big_blocks_target_gas,
+                block_stream,
+            ));
+            let (tx, rx) = mpsc::channel(buffer_size);
+            tokio::task::spawn_blocking(|| {
+                Handle::current().block_on(async move {
+                    while let Some(big_block) = big_blocks.next().await {
+                        tx.send(big_block.map(Payload::BigBlock)).await.unwrap();
+                    }
+                });
+            });
+
+            blocks = Box::pin(ReceiverStream::new(rx));
+        }
+
         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)) = {
+        while let Some(payload) = {
             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 gas_used = payload.gas_used();
+            let gas_limit = payload.gas_limit();
+            let block_number = payload.block_number();
+            let canonical_parent_hash = payload.parent_hash();
+            let transaction_count = payload.transaction_count() 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,
-            };
+                .map(|_| payload.block().cloned());
 
-            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,
+            debug!(target: "reth-bench", ?block_number, "Sending payload");
+            let start = Instant::now();
+            let canonical_forkchoice_state = payload.forkchoice_state();
+            let (version, params) = payload.into_new_payload_params(
                 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 =
@@ -359,7 +399,9 @@ impl Command {
                         block_number,
                         prepared: prepare_built_block(
                             &local_rpc_provider,
-                            block,
+                            block
+                                .as_ref()
+                                .ok_or_eyre("missing deferred fork block for reorg branch start")?,
                             canonical_parent_hash,
                             no_wait_for_caches,
                         )
@@ -638,3 +680,98 @@ fn parse_reorg_depth(value: &str) -> Result<usize, String> {
 
     Ok(depth)
 }
+
+/// Payload types used during benchmarking.
+#[expect(clippy::large_enum_variant)]
+enum Payload {
+    /// A regular block payload.
+    Block(AnyRpcBlock, Option<Bytes>, Option<BlockAccessList>, ForkchoiceState),
+    /// A big block payload.
+    BigBlock(BigBlockPayload),
+}
+
+impl Payload {
+    fn into_new_payload_params(
+        self,
+        use_reth_namespace: bool,
+        wait_for_persistence: WaitForPersistence,
+        no_wait_for_caches: bool,
+    ) -> eyre::Result<(Option<EngineApiMessageVersion>, serde_json::Value)> {
+        match self {
+            Self::Block(block, rlp, bal, _) => block_to_new_payload(
+                block,
+                rlp,
+                use_reth_namespace,
+                wait_for_persistence,
+                no_wait_for_caches,
+                bal,
+            ),
+            Self::BigBlock(big_block) => {
+                let wait_for_persistence =
+                    wait_for_persistence.rpc_value(big_block.execution_data.block_number());
+                Ok((
+                    None,
+                    serde_json::to_value((
+                        RethNewPayloadInput::ExecutionData(big_block.execution_data),
+                        wait_for_persistence,
+                        no_wait_for_caches.then_some(false),
+                        Some(big_block.big_block_data),
+                    ))?,
+                ))
+            }
+        }
+    }
+
+    fn gas_used(&self) -> u64 {
+        match self {
+            Self::Block(block, _, _, _) => block.header.gas_used,
+            Self::BigBlock(big_block) => big_block.execution_data.gas_used(),
+        }
+    }
+
+    fn gas_limit(&self) -> u64 {
+        match self {
+            Self::Block(block, _, _, _) => block.header.gas_limit,
+            Self::BigBlock(big_block) => big_block.execution_data.gas_limit(),
+        }
+    }
+
+    fn block_number(&self) -> u64 {
+        match self {
+            Self::Block(block, _, _, _) => block.header.number,
+            Self::BigBlock(big_block) => big_block.execution_data.block_number(),
+        }
+    }
+
+    fn parent_hash(&self) -> B256 {
+        match self {
+            Self::Block(block, _, _, _) => block.header.parent_hash,
+            Self::BigBlock(big_block) => big_block.execution_data.parent_hash(),
+        }
+    }
+
+    fn transaction_count(&self) -> usize {
+        match self {
+            Self::Block(block, _, _, _) => block.transactions.len(),
+            Self::BigBlock(big_block) => big_block.execution_data.transaction_count(),
+        }
+    }
+
+    const fn block(&self) -> Option<&AnyRpcBlock> {
+        match self {
+            Self::Block(block, _, _, _) => Some(block),
+            Self::BigBlock(_) => None,
+        }
+    }
+
+    const fn forkchoice_state(&self) -> ForkchoiceState {
+        match self {
+            Self::Block(_, _, _, forkchoice) => *forkchoice,
+            Self::BigBlock(big_block) => ForkchoiceState {
+                head_block_hash: big_block.execution_data.block_hash(),
+                safe_block_hash: big_block.execution_data.block_hash(),
+                finalized_block_hash: big_block.execution_data.block_hash(),
+            },
+        }
+    }
+}
diff --git a/bin/reth-bench/src/bench_mode.rs b/bin/reth-bench/src/bench_mode.rs
index f040246b2aa..ebf8c540a72 100644
--- a/bin/reth-bench/src/bench_mode.rs
+++ b/bin/reth-bench/src/bench_mode.rs
@@ -3,7 +3,7 @@
 use std::ops::RangeInclusive;
 
 /// Whether or not the benchmark should run as a continuous stream of payloads.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum BenchMode {
     /// Run the benchmark as a continuous stream of payloads, until the benchmark is interrupted.
     Continuous(u64),
diff --git a/crates/node/core/src/args/benchmark_args.rs b/crates/node/core/src/args/benchmark_args.rs
index 983b74cc870..9c2f671a9f6 100644
--- a/crates/node/core/src/args/benchmark_args.rs
+++ b/crates/node/core/src/args/benchmark_args.rs
@@ -130,6 +130,11 @@ pub struct BenchmarkArgs {
     /// Fetch and replay RLP-encoded blocks. Implies `reth_new_payload`.
     #[arg(long, default_value = "false", verbatim_doc_comment)]
     pub rlp_blocks: bool,
+
+    /// If provided, the benchmark will generate the specified number of big blocks and use them
+    /// instead of regular blocks.
+    #[arg(long, verbatim_doc_comment)]
+    pub big_blocks: Option<usize>,
 }
 
 /// Retry strategy for fetching blocks from the benchmark RPC provider.

From fcc65301e96fa4e67886edc31793f0a951e0003c Mon Sep 17 00:00:00 2001
From: Alexey Shekhirin <github@shekhirin.com>
Date: Thu, 7 May 2026 17:15:59 +0100
Subject: [PATCH 058/335] feat: run payload builder on a named os thread
 (#24038)

---
 crates/node/builder/src/components/payload.rs | 38 +++++----
 crates/tasks/src/runtime.rs                   | 82 +++++++++++++++++++
 2 files changed, 105 insertions(+), 15 deletions(-)

diff --git a/crates/node/builder/src/components/payload.rs b/crates/node/builder/src/components/payload.rs
index f245aff5c60..f5cf1dd02b0 100644
--- a/crates/node/builder/src/components/payload.rs
+++ b/crates/node/builder/src/components/payload.rs
@@ -110,7 +110,11 @@ where
                 ctx.provider().canonical_state_stream(),
             );
 
-        ctx.task_executor().spawn_critical_task("payload builder service", payload_service);
+        ctx.task_executor().spawn_critical_os_thread(
+            "payload-builder",
+            "payload builder service",
+            payload_service,
+        );
 
         Ok(payload_service_handle)
     }
@@ -136,22 +140,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-builder",
+            "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);
+                        }
+                        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/tasks/src/runtime.rs b/crates/tasks/src/runtime.rs
index 2e7c6684b64..646da171165 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};
@@ -593,6 +594,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.
@@ -920,6 +965,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() {

From 194ece23c3e9b03a26042ea887246d359e4fc47e Mon Sep 17 00:00:00 2001
From: Dan Cline <6798349+Rjected@users.noreply.github.com>
Date: Thu, 7 May 2026 15:05:34 -0400
Subject: [PATCH 059/335] fix: update snapshot CLI references for tempo
 (#23953)

---
 crates/cli/commands/src/download/mod.rs    | 113 +++++++++++++++++++--
 crates/cli/commands/src/download/source.rs |  22 ++--
 crates/cli/commands/src/download/tui.rs    |   3 +-
 3 files changed, 120 insertions(+), 18 deletions(-)

diff --git a/crates/cli/commands/src/download/mod.rs b/crates/cli/commands/src/download/mod.rs
index f3ab259b8d3..6884b4968bb 100644
--- a/crates/cli/commands/src/download/mod.rs
+++ b/crates/cli/commands/src/download/mod.rs
@@ -122,6 +122,8 @@ 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";
 
 /// Maximum number of simultaneous HTTP downloads across the entire snapshot job.
 const MAX_CONCURRENT_DOWNLOADS: usize = 8;
@@ -185,7 +187,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 +216,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 +239,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 +271,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 +310,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 {
@@ -760,7 +804,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(),
                     );
                 }
 
@@ -875,6 +919,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 +1047,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 +1280,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

From 3628a38f06a070ed1f443440ffcbd9f95946b6b8 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Fri, 8 May 2026 12:07:32 +0400
Subject: [PATCH 060/335] feat: generate big blocks in flight (#24048)

---
 .github/scripts/bench-reth-run.sh             | 38 ++++----
 .github/workflows/bench.yml                   | 58 +++++++-----
 bin/reth-bench/src/bench/context.rs           | 90 +++++++++++++++++--
 .../src/bench/generate_big_block.rs           | 56 ++++++++----
 bin/reth-bench/src/bench/new_payload_fcu.rs   |  2 +
 5 files changed, 178 insertions(+), 66 deletions(-)

diff --git a/.github/scripts/bench-reth-run.sh b/.github/scripts/bench-reth-run.sh
index 37dbb848af5..96b999d97c7 100755
--- a/.github/scripts/bench-reth-run.sh
+++ b/.github/scripts/bench-reth-run.sh
@@ -251,28 +251,30 @@ if [ -n "${BENCH_WAIT_TIME:-}" ]; then
 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}"
+  # Big blocks mode: generate synthetic payloads in flight with new-payload-fcu.
   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
+  if [ -n "${BENCH_BIG_BLOCKS_TARGET_GAS:-}" ]; then
+    BB_BENCH_ARGS+=(--big-blocks-target-gas "$BENCH_BIG_BLOCKS_TARGET_GAS")
+  fi
   case "$BENCH_BAL_MODE" in
     false)
       ;;
     true)
-      BB_BENCH_ARGS+=(--bal)
+      BB_BENCH_ARGS+=(--enable-bal)
       ;;
     baseline)
       if [[ "$LABEL" == baseline* ]]; then
-        BB_BENCH_ARGS+=(--bal)
+        BB_BENCH_ARGS+=(--enable-bal)
       fi
       ;;
     feature)
       if [[ "$LABEL" == feature* ]]; then
-        BB_BENCH_ARGS+=(--bal)
+        BB_BENCH_ARGS+=(--enable-bal)
       fi
       ;;
     *)
@@ -285,12 +287,14 @@ if [ "$BIG_BLOCKS" = "true" ]; then
   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 \
+    $BENCH_NICE "$RETH_BENCH" new-payload-fcu \
+      --rpc-url "$BENCH_RPC_URL" \
       "${BB_BENCH_ARGS[@]}" \
-      --count "$WARMUP" \
-      --payload-dir "$BIG_BLOCKS_DIR/payloads" \
+      --big-blocks "$WARMUP" \
       --engine-rpc-url http://127.0.0.1:8551 \
       --jwt-secret "$DATADIR/jwt.hex" 2>&1 | sed -u "s/^/[bench] /"
+  else
+    echo "Skipping big blocks warmup (0 payloads)..."
   fi
 
   # Start tracy-capture after warmup so profile only covers the benchmark
@@ -301,20 +305,16 @@ if [ "$BIG_BLOCKS" = "true" ]; then
     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")
+  if [ "${BENCH_BLOCKS:-0}" -le 0 ] 2>/dev/null; then
+    echo "::error::BENCH_BLOCKS must be greater than 0 for big-block benchmarks"
+    exit 1
   fi
 
-  echo "Running big blocks benchmark (replay-payloads, skip=${BB_SKIP})..."
-  $BENCH_NICE "$RETH_BENCH" replay-payloads \
+  echo "Running big blocks benchmark (new-payload-fcu, count=${BENCH_BLOCKS})..."
+  $BENCH_NICE "$RETH_BENCH" new-payload-fcu \
+    --rpc-url "$BENCH_RPC_URL" \
     "${BB_BENCH_ARGS[@]}" \
-    --skip "$BB_SKIP" \
-    --payload-dir "$BIG_BLOCKS_DIR/payloads" \
+    --big-blocks "$BENCH_BLOCKS" \
     --engine-rpc-url http://127.0.0.1:8551 \
     --jwt-secret "$DATADIR/jwt.hex" \
     --output "$OUTPUT_DIR" 2>&1 | sed -u "s/^/[bench] /"
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 1ad30c1eb37..cf9118af76b 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -17,10 +17,10 @@ on:
         default: "500"
         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
@@ -124,6 +124,7 @@ jobs:
       slack: ${{ steps.args.outputs.slack }}
       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 }}
@@ -162,10 +163,19 @@ 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="..."]`';
+            const usage = '`@decofe bench [blocks=N] [big-blocks[=true|false|100M|2G]] [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;
+            let bigBlocksTargetGas = '';
             let explicitWarmup = 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;
+            };
+
             if (context.eventName === 'workflow_dispatch') {
               actor = '${{ github.actor }}';
               blocks = '${{ github.event.inputs.blocks }}' || '500';
@@ -176,7 +186,13 @@ jobs:
               samply = '${{ github.event.inputs.samply }}' === '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 }}' === 'true' ? 'true' : 'false';
@@ -204,7 +220,7 @@ jobs:
               const body = context.payload.comment.body.trim();
               const intArgs = new Set(['warmup', 'cores', 'blocks']);
               const refArgs = new Set(['baseline', 'feature']);
-              const boolArgs = new Set(['samply', 'big-blocks']);
+              const boolArgs = new Set(['samply']);
               const boolDefaultTrue = new Set(['abba']);
               const enumArgs = new Map([['bal', validBalModes], ['slack', validSlackModes]]);
               const durationArgs = new Set(['wait-time']);
@@ -221,7 +237,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 (boolArgs.has(part)) {
                     defaults[part] = 'true';
                   } else if (boolDefaultTrue.has(part)) {
                     defaults[part] = 'true';
@@ -236,7 +254,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) || boolDefaultTrue.has(key)) {
                   if (value === 'true' || value === 'false') {
                     defaults[key] = value;
                   } else {
@@ -294,7 +319,9 @@ jobs:
               samply = defaults.samply;
               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 otlp = defaults.otlp;
@@ -361,6 +388,7 @@ jobs:
             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);
@@ -565,6 +593,7 @@ jobs:
       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_BIG_BLOCKS_TARGET_GAS: ${{ needs.reth-bench-ack.outputs.big-blocks-target-gas }}
       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 }}
@@ -805,7 +834,6 @@ jobs:
         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"
 
@@ -820,19 +848,7 @@ jobs:
             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: Prepare source dirs
diff --git a/bin/reth-bench/src/bench/context.rs b/bin/reth-bench/src/bench/context.rs
index f3579c1ed71..b0f665bebd9 100644
--- a/bin/reth-bench/src/bench/context.rs
+++ b/bin/reth-bench/src/bench/context.rs
@@ -1,8 +1,12 @@
 //! 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 crate::{
+    authenticated_transport::AuthenticatedTransportConnect,
+    bench::generate_big_block::BigBlocksInitialState, bench_mode::BenchMode,
+};
 use alloy_eips::BlockNumberOrTag;
+use alloy_primitives::B256;
 use alloy_provider::{network::AnyNetwork, Provider, RootProvider};
 use alloy_rpc_client::ClientBuilder;
 use alloy_rpc_types_engine::JwtSecret;
@@ -36,6 +40,8 @@ pub(crate) struct BenchContext {
     pub(crate) wait_for_persistence: WaitForPersistence,
     /// Whether to skip waiting for caches (pass `wait_for_caches: false`).
     pub(crate) no_wait_for_caches: bool,
+    /// Initial state for generated big blocks.
+    pub(crate) big_blocks_initial_state: Option<BigBlocksInitialState>,
 }
 
 impl BenchContext {
@@ -98,6 +104,7 @@ impl BenchContext {
         // - 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 mut big_blocks_initial_state = None;
         let (from, to) = if let Some(advance) = bench_args.advance {
             if advance == 0 {
                 return Err(eyre::eyre!("--advance must be greater than 0"));
@@ -109,6 +116,12 @@ impl BenchContext {
                 .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.big_blocks.is_some() && bench_args.from.is_none() {
+            let (from, initial_state) =
+                derive_big_blocks_initial_state(&auth_provider, &block_provider).await?;
+            big_blocks_initial_state = initial_state;
+
+            (Some(from), bench_args.to)
         } else if bench_args.from.is_none() && bench_args.to.is_some() {
             let head_block = auth_provider
                 .get_block_by_number(BlockNumberOrTag::Latest)
@@ -117,13 +130,6 @@ impl BenchContext {
             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 if bench_args.big_blocks.is_some() && bench_args.from.is_none() {
-            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;
-            (Some(head_number), bench_args.to)
         } else {
             (bench_args.from, bench_args.to)
         };
@@ -180,6 +186,74 @@ impl BenchContext {
             rlp_blocks,
             wait_for_persistence,
             no_wait_for_caches,
+            big_blocks_initial_state,
         })
     }
 }
+
+/// Derives the initial state for big blocks benchmark from RPC of the local node.
+async fn derive_big_blocks_initial_state(
+    local_provider: &RootProvider<AnyNetwork>,
+    source_provider: &RootProvider<AnyNetwork>,
+) -> eyre::Result<(u64, Option<BigBlocksInitialState>)> {
+    let local_head = local_provider
+        .get_block_by_number(BlockNumberOrTag::Latest)
+        .full()
+        .await?
+        .ok_or_else(|| eyre::eyre!("Failed to fetch latest block from engine"))?;
+
+    let local_head_number = local_head.header.number;
+    let local_head_hash = local_head.header.hash;
+
+    let source_block_at_local_head = source_provider
+        .get_block_by_number(local_head_number.into())
+        .await?
+        .ok_or_else(|| eyre::eyre!("Failed to fetch block {local_head_number} from RPC"))?;
+
+    // Node's tip is not synthetic, no initial state needed
+    if source_block_at_local_head.header.number == local_head_number &&
+        source_block_at_local_head.header.hash == local_head_hash
+    {
+        return Ok((local_head_number, None));
+    }
+
+    // If the tip is synthetic, derive last regular block from the last transaction the node has.
+    let last_regular_block = if let Some(tx_hash) = local_head.transactions.hashes().last() {
+        let tx = source_provider
+            .get_transaction_by_hash(tx_hash)
+            .await?
+            .ok_or_else(|| eyre::eyre!("Failed to fetch transaction {tx_hash} from RPC"))?;
+        tx.block_number
+            .ok_or_else(|| eyre::eyre!("Transaction {tx_hash} from local head is pending on RPC"))?
+    } else {
+        return Err(eyre::eyre!(
+            "Synthetic local tip has no transactions, can't derive last regular block"
+        ));
+    };
+
+    let initial_state = BigBlocksInitialState {
+        prior_block_hashes: fetch_recent_block_hashes(source_provider, last_regular_block).await?,
+        parent_hash: local_head_hash,
+        next_synthetic_block_number: local_head_number + 1,
+    };
+
+    Ok((last_regular_block, Some(initial_state)))
+}
+
+async fn fetch_recent_block_hashes(
+    provider: &RootProvider<AnyNetwork>,
+    latest_regular_block: u64,
+) -> eyre::Result<Vec<(u64, B256)>> {
+    const BLOCKHASH_HISTORY: u64 = 256;
+
+    let start = latest_regular_block.saturating_sub(BLOCKHASH_HISTORY - 1);
+    let mut hashes = Vec::with_capacity((latest_regular_block - start + 1) as usize);
+    for block_number in start..=latest_regular_block {
+        let Some(block) = provider.get_block_by_number(block_number.into()).await? else {
+            continue;
+        };
+        hashes.push((block_number, block.header.hash));
+    }
+
+    Ok(hashes)
+}
diff --git a/bin/reth-bench/src/bench/generate_big_block.rs b/bin/reth-bench/src/bench/generate_big_block.rs
index 5aa51c0804b..a7b079d984b 100644
--- a/bin/reth-bench/src/bench/generate_big_block.rs
+++ b/bin/reth-bench/src/bench/generate_big_block.rs
@@ -228,6 +228,17 @@ pub struct BigBlockPayload {
     pub block_access_list: Option<BlockAccessList>,
 }
 
+/// State used to continue generated big block replay from the benchmark node's current tip.
+#[derive(Debug, Clone, Default)]
+pub(crate) struct BigBlocksInitialState {
+    /// Real block hashes from previous big blocks, used for BLOCKHASH lookups.
+    pub prior_block_hashes: Vec<(u64, B256)>,
+    /// Hash of the previous synthetic big block.
+    pub parent_hash: B256,
+    /// Block number to assign to the first generated synthetic block.
+    pub next_synthetic_block_number: u64,
+}
+
 /// `reth bench generate-big-block` command
 ///
 /// Generates a large block by fetching consecutive blocks from an RPC, merging their
@@ -328,7 +339,7 @@ impl Command {
             .buffered(prefetch_buffer);
 
         let mut big_blocks_stream =
-            Box::pin(big_blocks_stream(self.num_big_blocks, self.target_gas, block_stream));
+            Box::pin(big_blocks_stream(self.num_big_blocks, self.target_gas, block_stream, None));
 
         while let Some(big_block) = big_blocks_stream.next().await {
             let big_block = big_block?;
@@ -346,11 +357,6 @@ impl Command {
                 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"
             );
         }
@@ -365,14 +371,24 @@ pub(crate) fn big_blocks_stream(
     target_gas: u64,
     block_stream: impl Stream<Item = eyre::Result<Option<(AnyRpcBlock, Option<BlockAccessList>)>>>
         + Unpin,
+    initial_state: Option<BigBlocksInitialState>,
 ) -> impl Stream<Item = eyre::Result<BigBlockPayload>> {
     futures::stream::try_unfold(
-        (block_stream, Vec::new(), 0, None, false, 0),
+        (
+            block_stream,
+            initial_state.as_ref().map(|s| s.prior_block_hashes.clone()).unwrap_or_default(),
+            0,
+            initial_state.as_ref().map(|s| s.parent_hash),
+            initial_state.as_ref().map(|s| s.next_synthetic_block_number),
+            false,
+            0,
+        ),
         move |(
             mut block_stream,
             mut accumulated_block_hashes,
             mut big_block_idx,
             mut prev_big_block_hash,
+            next_synthetic_block_number,
             mut reached_chain_tip,
             mut first_block,
         )| async move {
@@ -392,8 +408,6 @@ pub(crate) fn big_blocks_stream(
             let mut accumulated_block_gas: u64 = 0;
 
             while accumulated_block_gas < target_gas {
-                info!(target: "reth-bench", big_block = big_block_idx, "Awaiting prefetched block");
-
                 let (block, block_access_list) = match block_stream.next().await {
                     Some(Ok(Some(fetched))) => fetched,
                     Some(Ok(None)) => {
@@ -430,14 +444,6 @@ pub(crate) fn big_blocks_stream(
 
                 let block_gas = execution_data.payload.as_v1().gas_used;
 
-                info!(
-                    target: "reth-bench",
-                    block_number = block.header.number,
-                    gas_used = block_gas,
-                    tx_count = execution_data.payload.transactions().len(),
-                    "Fetched block"
-                );
-
                 accumulated_block_gas += block_gas;
                 blocks.push(execution_data);
                 block_access_lists.push(block_access_list);
@@ -520,7 +526,9 @@ pub(crate) fn big_blocks_stream(
                 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 = first_block + big_block_idx;
+                let synthetic_block_number =
+                    next_synthetic_block_number.unwrap_or(first_block) + big_block_idx;
+                base.payload.as_v1_mut().block_number = synthetic_block_number;
             }
 
             // Merge blob data from all constituent blocks:  concatenate versioned
@@ -580,6 +588,17 @@ pub(crate) fn big_blocks_stream(
                 accumulated_block_hashes.drain(..excess);
             }
 
+            info!(
+                target: "reth-bench",
+                block_hash = %big_block.execution_data.payload.as_v1().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),
+                "Generated big block"
+            );
+
             big_block_idx += 1;
             Ok(Some((
                 big_block,
@@ -588,6 +607,7 @@ pub(crate) fn big_blocks_stream(
                     accumulated_block_hashes,
                     big_block_idx,
                     prev_big_block_hash,
+                    next_synthetic_block_number,
                     reached_chain_tip,
                     first_block,
                 ),
diff --git a/bin/reth-bench/src/bench/new_payload_fcu.rs b/bin/reth-bench/src/bench/new_payload_fcu.rs
index d44f9b8f132..d757f41ea69 100644
--- a/bin/reth-bench/src/bench/new_payload_fcu.rs
+++ b/bin/reth-bench/src/bench/new_payload_fcu.rs
@@ -200,6 +200,7 @@ impl Command {
             rlp_blocks,
             wait_for_persistence,
             no_wait_for_caches,
+            big_blocks_initial_state,
         } = BenchContext::new(&self.benchmark, self.rpc_url).await?;
 
         let total_blocks = benchmark_mode.total_blocks();
@@ -308,6 +309,7 @@ impl Command {
                 num_big_blocks as u64,
                 self.big_blocks_target_gas,
                 block_stream,
+                big_blocks_initial_state,
             ));
             let (tx, rx) = mpsc::channel(buffer_size);
             tokio::task::spawn_blocking(|| {

From 4a3884034d99722d669bdfecc275e8704454432f Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Fri, 8 May 2026 13:47:35 +0530
Subject: [PATCH 061/335] chore: add GetCells and Cells message (#24041)

Co-authored-by: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/eth-wire-types/src/message.rs | 49 ++++++++++++++++++++++--
 crates/net/eth-wire-types/src/version.rs |  7 +++-
 crates/net/network-api/src/events.rs     | 28 +++++++++++++-
 crates/net/network/src/eth_requests.rs   | 29 ++++++++++++--
 crates/net/network/src/manager.rs        |  2 +
 crates/net/network/src/message.rs        | 22 ++++++++++-
 crates/net/network/src/session/active.rs |  6 +++
 examples/network-proxy/src/main.rs       |  1 +
 8 files changed, 133 insertions(+), 11 deletions(-)

diff --git a/crates/net/eth-wire-types/src/message.rs b/crates/net/eth-wire-types/src/message.rs
index c07dcc8c408..0dda77dc827 100644
--- a/crates/net/eth-wire-types/src/message.rs
+++ b/crates/net/eth-wire-types/src/message.rs
@@ -13,8 +13,8 @@ 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, RawCapabilityMessage, Receipts69, Receipts70, SharedTransactions,
 };
 use alloc::{boxed::Box, string::String, sync::Arc};
 use alloy_primitives::{
@@ -206,6 +206,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());
@@ -376,6 +388,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",
@@ -410,6 +426,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 +441,7 @@ impl<N: NetworkPrimitives> EthMessage<N> {
                 Self::GetReceipts(_) |
                 Self::GetReceipts70(_) |
                 Self::GetBlockAccessLists(_) |
+                Self::GetCells(_) |
                 Self::GetPooledTransactions(_) |
                 Self::GetNodeData(_)
         )
@@ -439,7 +458,8 @@ impl<N: NetworkPrimitives> EthMessage<N> {
                 Self::BlockAccessLists(_) |
                 Self::BlockHeaders(_) |
                 Self::BlockBodies(_) |
-                Self::NodeData(_)
+                Self::NodeData(_) |
+                Self::Cells(_)
         )
     }
 
@@ -492,11 +512,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),
         }
     }
@@ -519,11 +541,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 +643,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 +678,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 +737,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 +769,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/version.rs b/crates/net/eth-wire-types/src/version.rs
index 8854993a4c6..e23a98e1029 100644
--- a/crates/net/eth-wire-types/src/version.rs
+++ b/crates/net/eth-wire-types/src/version.rs
@@ -72,9 +72,14 @@ impl EthVersion {
         matches!(self, Self::Eth71)
     }
 
+    /// Returns true if the version is eth/71
+    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)
     }
 }
 
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/src/eth_requests.rs b/crates/net/network/src/eth_requests.rs
index a954c321d3e..81b5bacd2ce 100644
--- a/crates/net/network/src/eth_requests.rs
+++ b/crates/net/network/src/eth_requests.rs
@@ -10,9 +10,9 @@ 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;
@@ -314,6 +314,15 @@ where
 
         receipts
     }
+
+    fn on_cells_request(
+        &self,
+        _peer_id: PeerId,
+        _request: GetCells,
+        response: oneshot::Sender<RequestResult<Cells>>,
+    ) {
+        let _ = response.send(Ok(Cells::default()));
+    }
 }
 
 impl<C, N> EthRequestHandler<C, N>
@@ -405,6 +414,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 +513,15 @@ 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>>,
+    },
 }
diff --git a/crates/net/network/src/manager.rs b/crates/net/network/src/manager.rs
index 4a37707516c..84913aca0d9 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,
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/session/active.rs b/crates/net/network/src/session/active.rs
index e5765dcbcf3..d5b8386459e 100644
--- a/crates/net/network/src/session/active.rs
+++ b/crates/net/network/src/session/active.rs
@@ -343,6 +343,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 +374,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(),
         }
     }
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() => {

From b29668ec7d9e352b5e0eb57746900c7971da4dbf Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Fri, 8 May 2026 10:51:08 +0200
Subject: [PATCH 062/335] feat(storage): add BAL store flush hook (#24071)

---
 crates/storage/provider/src/bal.rs    | 11 +++++++++++
 crates/storage/storage-api/src/bal.rs | 23 +++++++++++++++++++++++
 2 files changed, 34 insertions(+)

diff --git a/crates/storage/provider/src/bal.rs b/crates/storage/provider/src/bal.rs
index 9f436d03557..6e3b619f60e 100644
--- a/crates/storage/provider/src/bal.rs
+++ b/crates/storage/provider/src/bal.rs
@@ -132,6 +132,10 @@ impl BalStore for InMemoryBalStore {
         Ok(())
     }
 
+    fn flush(&self) -> ProviderResult<()> {
+        Ok(())
+    }
+
     fn prune(&self, tip: BlockNumber) -> ProviderResult<usize> {
         Ok(self.inner.write().prune(self.config.in_memory_retention, tip))
     }
@@ -211,6 +215,13 @@ mod tests {
         assert!(store.get_by_range(1, 10).unwrap().is_empty());
     }
 
+    #[test]
+    fn flush_is_noop() {
+        let store = InMemoryBalStore::default();
+
+        store.flush().unwrap();
+    }
+
     #[test]
     fn limited_lookup_returns_prefix() {
         let store = InMemoryBalStore::default();
diff --git a/crates/storage/storage-api/src/bal.rs b/crates/storage/storage-api/src/bal.rs
index 9b118731d40..b53ac5fbd0b 100644
--- a/crates/storage/storage-api/src/bal.rs
+++ b/crates/storage/storage-api/src/bal.rs
@@ -41,8 +41,18 @@ mod subscriptions {
 #[auto_impl::auto_impl(&, Arc, Box)]
 pub trait BalStore: Send + Sync + 'static {
     /// Insert the BAL for the given block.
+    ///
+    /// Implementations may buffer inserts. Call [`Self::flush`] when pending BALs need to be made
+    /// durable.
     fn insert(&self, num_hash: NumHash, bal: SealedBal) -> ProviderResult<()>;
 
+    /// 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.
@@ -160,6 +170,12 @@ impl BalStoreHandle {
         self.inner.insert(num_hash, bal)
     }
 
+    /// 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> {
@@ -306,6 +322,13 @@ mod tests {
         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();

From 5713ed530cb0f65522be9ab3b82d31c560917564 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 8 May 2026 11:04:29 +0200
Subject: [PATCH 063/335] chore: update Grafana dashboard overview.json
 (#24067)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 etc/grafana/dashboards/overview.json | 1088 ++++++++++++--------------
 1 file changed, 498 insertions(+), 590 deletions(-)

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
 }

From 4645ef02dab5e472682fc7fa5d3efe03dfd970e1 Mon Sep 17 00:00:00 2001
From: Karl Yu <43113774+0xKarl98@users.noreply.github.com>
Date: Fri, 8 May 2026 17:16:19 +0800
Subject: [PATCH 064/335] feat(storage): add BalStore insert_many (#24066)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/storage/provider/src/bal.rs    | 68 +++++++++++++++++++++++++++
 crates/storage/storage-api/src/bal.rs | 20 ++++++++
 2 files changed, 88 insertions(+)

diff --git a/crates/storage/provider/src/bal.rs b/crates/storage/provider/src/bal.rs
index 6e3b619f60e..0d593ffcaf5 100644
--- a/crates/storage/provider/src/bal.rs
+++ b/crates/storage/provider/src/bal.rs
@@ -132,6 +132,27 @@ impl BalStore for InMemoryBalStore {
         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(())
     }
@@ -208,6 +229,27 @@ mod tests {
         assert_eq!(store.get_by_hashes(&[hash, missing]).unwrap(), vec![Some(bal), None]);
     }
 
+    #[test]
+    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_eq!(
+            store.get_by_hashes(&[hash0, hash1]).unwrap(),
+            vec![Some(bal0.clone_inner()), Some(Bytes::from_static(b"bal1"))]
+        );
+    }
+
     #[test]
     fn range_lookup_is_empty() {
         let store = InMemoryBalStore::default();
@@ -369,6 +411,32 @@ mod tests {
         );
     }
 
+    #[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();
diff --git a/crates/storage/storage-api/src/bal.rs b/crates/storage/storage-api/src/bal.rs
index b53ac5fbd0b..067f66d30ce 100644
--- a/crates/storage/storage-api/src/bal.rs
+++ b/crates/storage/storage-api/src/bal.rs
@@ -46,6 +46,16 @@ pub trait BalStore: Send + Sync + 'static {
     /// 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.
@@ -170,6 +180,12 @@ impl BalStoreHandle {
         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<()> {
@@ -264,6 +280,10 @@ impl BalStore for NoopBalStore {
         Ok(())
     }
 
+    fn insert_many(&self, _entries: Vec<(NumHash, SealedBal)>) -> ProviderResult<()> {
+        Ok(())
+    }
+
     fn prune(&self, _tip: BlockNumber) -> ProviderResult<usize> {
         Ok(0)
     }

From 4d7c9ca9c240380e250214dd2a0750f1721ec648 Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Fri, 8 May 2026 12:10:02 +0200
Subject: [PATCH 065/335] fix(ci): configure bench chart git identity (#24073)

Co-authored-by: Brian Picciano <933154+mediocregopher@users.noreply.github.com>
Co-authored-by: Amp <amp@ampcode.com>
---
 .github/scripts/configure-git-token-user.sh | 20 ++++++++++++++++++++
 .github/workflows/bench-scheduled.yml       |  8 ++++----
 .github/workflows/bench.yml                 |  4 ++--
 3 files changed, 26 insertions(+), 6 deletions(-)
 create mode 100755 .github/scripts/configure-git-token-user.sh

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/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index f6c613e8b0c..8846222e9d7 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -671,12 +671,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}"
@@ -1012,12 +1012,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 cf9118af76b..96e37c693e9 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -1280,6 +1280,7 @@ 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}/"
@@ -1290,8 +1291,7 @@ jobs:
             rm -rf "${TMP_DIR}"
             exit 0
           fi
-          git -C "${TMP_DIR}" -c user.name="github-actions" -c user.email="github-actions@github.com" \
-            commit -m "bench charts for PR #${PR_NUMBER} run ${RUN_ID}"
+          git -C "${TMP_DIR}" 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

From 316218c44ec0a44029a2ff29de0acdff2e268b52 Mon Sep 17 00:00:00 2001
From: Karl Yu <43113774+0xKarl98@users.noreply.github.com>
Date: Fri, 8 May 2026 18:18:51 +0800
Subject: [PATCH 066/335] feat(rpc): cache revm BAL in eth state cache (#24037)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 Cargo.lock                                   |   1 +
 crates/node/core/src/args/rpc_server.rs      |   3 +
 crates/node/core/src/args/rpc_state_cache.rs |  13 +-
 crates/rpc/rpc-builder/src/config.rs         |   1 +
 crates/rpc/rpc-eth-api/src/node.rs           |   4 +-
 crates/rpc/rpc-eth-types/Cargo.toml          |   2 +
 crates/rpc/rpc-eth-types/src/cache/config.rs |   9 +-
 crates/rpc/rpc-eth-types/src/cache/mod.rs    | 631 +++++++++++++++++--
 crates/rpc/rpc-server-types/src/constants.rs |   3 +
 crates/rpc/rpc/src/eth/core.rs               |   3 +-
 crates/storage/storage-api/src/bal.rs        |  18 +
 docs/vocs/docs/pages/cli/reth/node.mdx       |   5 +
 12 files changed, 647 insertions(+), 46 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4f2f22ecdd9..99e7fb8f0f4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10008,6 +10008,7 @@ dependencies = [
  "reqwest 0.13.2",
  "reth-chain-state",
  "reth-chainspec",
+ "reth-db-models",
  "reth-errors",
  "reth-ethereum-primitives",
  "reth-evm",
diff --git a/crates/node/core/src/args/rpc_server.rs b/crates/node/core/src/args/rpc_server.rs
index cdd4c681129..6c03333c2f1 100644
--- a/crates/node/core/src/args/rpc_server.rs
+++ b/crates/node/core/src/args/rpc_server.rs
@@ -1060,6 +1060,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 +1151,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/rpc/rpc-builder/src/config.rs b/crates/rpc/rpc-builder/src/config.rs
index d89866c955f..5576a4cc9db 100644
--- a/crates/rpc/rpc-builder/src/config.rs
+++ b/crates/rpc/rpc-builder/src/config.rs
@@ -122,6 +122,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,
         }
diff --git a/crates/rpc/rpc-eth-api/src/node.rs b/crates/rpc/rpc-eth-api/src/node.rs
index bde95b9c572..e4852e82990 100644
--- a/crates/rpc/rpc-eth-api/src/node.rs
+++ b/crates/rpc/rpc-eth-api/src/node.rs
@@ -8,7 +8,7 @@ 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, StageCheckpointReader, StateProviderFactory,
 };
 use reth_transaction_pool::{PoolTransaction, TransactionPool};
 
@@ -37,6 +37,7 @@ pub trait RpcNodeCore: Clone + Send + Sync + Unpin + 'static {
         > + StateProviderFactory
         + CanonStateSubscriptions<Primitives = Self::Primitives>
         + StageCheckpointReader
+        + BalProvider
         + Send
         + Sync
         + Clone
@@ -130,6 +131,7 @@ where
         > + StateProviderFactory
         + CanonStateSubscriptions<Primitives = Evm::Primitives>
         + StageCheckpointReader
+        + BalProvider
         + Send
         + Sync
         + Unpin
diff --git a/crates/rpc/rpc-eth-types/Cargo.toml b/crates/rpc/rpc-eth-types/Cargo.toml
index 1ef87874dbd..ab8782352b6 100644
--- a/crates/rpc/rpc-eth-types/Cargo.toml
+++ b/crates/rpc/rpc-eth-types/Cargo.toml
@@ -65,6 +65,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/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..1c1e5f0b8c5 100644
--- a/crates/rpc/rpc-eth-types/src/cache/mod.rs
+++ b/crates/rpc/rpc-eth-types/src/cache/mod.rs
@@ -4,13 +4,21 @@ use super::{EthStateCacheConfig, MultiConsumerLruCache};
 use crate::block::CachedTransaction;
 use alloy_consensus::{transaction::TxHashRef, BlockHeader};
 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 +59,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 +70,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 +92,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 +112,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 +133,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 +272,17 @@ 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<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 +318,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 +337,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 +355,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 +408,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 +456,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 +598,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 +673,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 +738,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 +762,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 +818,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 +861,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 +884,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,26 +919,94 @@ pub async fn cache_new_blocks_task<St, N: NodePrimitives>(
     }
 }
 
+/// Cached revm BAL.
+#[derive(Clone, Debug)]
+pub(crate) struct CachedRevmBal(Arc<RevmBal>);
+
+impl CachedRevmBal {
+    /// Creates a cached revm BAL from an owned BAL.
+    #[inline]
+    fn new(bal: RevmBal) -> Self {
+        Self(Arc::new(bal))
+    }
+}
+
+impl InMemorySize for CachedRevmBal {
+    fn size(&self) -> usize {
+        core::mem::size_of::<Self>() + revm_bal_size(&self.0)
+    }
+}
+
+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_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
     }
@@ -914,4 +1071,398 @@ 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(RevmBal::default())));
+        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(RevmBal::default());
+
+        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((1, 1));
+        account.account_info.balance.writes.push((2, StorageValue::from(1u64)));
+        account.account_info.code.writes.push((
+            3,
+            (B256::repeat_byte(0xaa), Bytecode::new_raw(Bytes::from_static(&[0x60, 0x00]))),
+        ));
+        account.storage.storage.insert(
+            StorageKey::from(1u64),
+            RevmBalWrites::new(vec![(4, StorageValue::from(2u64))]),
+        );
+
+        let mut bal = RevmBal::default();
+        bal.accounts.insert(Address::ZERO, account);
+
+        let previous_estimate =
+            core::mem::size_of::<CachedRevmBal>() + core::mem::size_of::<RevmBal>();
+        assert!(CachedRevmBal::new(bal).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<RevmBal>> {
+            self.fetches.fetch_add(1, Ordering::SeqCst);
+            Ok(Some(RevmBal::default()))
+        }
+
+        fn get_by_range(&self, _start: BlockNumber, _count: u64) -> ProviderResult<Vec<Bytes>> {
+            Ok(Vec::new())
+        }
+
+        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-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/src/eth/core.rs b/crates/rpc/rpc/src/eth/core.rs
index d6bc1884481..9747f4ef00d 100644
--- a/crates/rpc/rpc/src/eth/core.rs
+++ b/crates/rpc/rpc/src/eth/core.rs
@@ -579,7 +579,7 @@ mod tests {
         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 +599,7 @@ mod tests {
             + StateProviderFactory
             + CanonStateSubscriptions<Primitives = reth_ethereum_primitives::EthPrimitives>
             + StageCheckpointReader
+            + BalProvider
             + Unpin
             + Clone
             + 'static,
diff --git a/crates/storage/storage-api/src/bal.rs b/crates/storage/storage-api/src/bal.rs
index 067f66d30ce..f7b681346ad 100644
--- a/crates/storage/storage-api/src/bal.rs
+++ b/crates/storage/storage-api/src/bal.rs
@@ -2,6 +2,7 @@ use alloc::{sync::Arc, vec::Vec};
 use alloy_eips::{eip7928::bal::DecodedBal, 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>;
@@ -86,6 +87,17 @@ pub trait BalStore: Send + Sync + 'static {
             .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<RevmBal>> {
+        self.get_decoded_by_hash(block_hash)?
+            .map(|decoded| {
+                let (bal, _) = decoded.split();
+                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.
     ///
@@ -216,6 +228,12 @@ impl BalStoreHandle {
         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<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]
diff --git a/docs/vocs/docs/pages/cli/reth/node.mdx b/docs/vocs/docs/pages/cli/reth/node.mdx
index 14b9c127ce5..3d30abf8f80 100644
--- a/docs/vocs/docs/pages/cli/reth/node.mdx
+++ b/docs/vocs/docs/pages/cli/reth/node.mdx
@@ -516,6 +516,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
 

From d9850419d5cd70ddbfe90069f39f1d508d837ff4 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Fri, 8 May 2026 12:43:21 +0200
Subject: [PATCH 067/335] chore(deps): bump alloy-eip7928 to 0.3.6 (#24075)

---
 Cargo.lock | 5 +++--
 Cargo.toml | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 99e7fb8f0f4..ed482ac8bd0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -250,9 +250,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-eip7928"
-version = "0.3.5"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec6ae911a2fc304a7cb80a79fb7bed6d1474aed4e7c203df1f8ff538f64fc78d"
+checksum = "72bc95fd73591644f0022065bef3c027d1a5ed875a53cb19a898d71a00818c1d"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
@@ -260,6 +260,7 @@ dependencies = [
  "borsh",
  "once_cell",
  "serde",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index f93cd646b90..d86314f39be 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -449,7 +449,7 @@ alloy-sol-types = { version = "1.5.6", default-features = false }
 
 alloy-chains = { version = "0.2.33", default-features = false }
 alloy-eip2124 = { version = "0.2.0", default-features = false }
-alloy-eip7928 = { version = "0.3.5", default-features = false }
+alloy-eip7928 = { version = "0.3.6", 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-trie = { version = "0.9.4", default-features = false }

From 479a487ce09eff4421a7442521f6bda8e53c5c6c Mon Sep 17 00:00:00 2001
From: William Morriss <wjmelements@gmail.com>
Date: Fri, 8 May 2026 05:52:17 -0500
Subject: [PATCH 068/335] feat(rpc): implement eth_baseFee (#24050)

---
 crates/rpc/rpc-eth-api/src/core.rs        | 10 ++++++++++
 crates/rpc/rpc-eth-api/src/helpers/fee.rs | 24 +++++++++++++++++++++++
 2 files changed, 34 insertions(+)

diff --git a/crates/rpc/rpc-eth-api/src/core.rs b/crates/rpc/rpc-eth-api/src/core.rs
index 6c884279b63..de7909aa47d 100644
--- a/crates/rpc/rpc-eth-api/src/core.rs
+++ b/crates/rpc/rpc-eth-api/src/core.rs
@@ -314,6 +314,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>;
@@ -814,6 +818,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
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

From 5057a6bd490303f1ec91f20d1a656de467485a35 Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Fri, 8 May 2026 16:56:13 +0530
Subject: [PATCH 069/335] chore: add eth_getBlockAccessList method (#24080)

---
 crates/rpc/rpc-api/src/engine.rs   |  4 ++++
 crates/rpc/rpc-eth-api/src/core.rs | 17 +++++++++++++++++
 crates/rpc/rpc/src/engine.rs       |  5 +++++
 3 files changed, 26 insertions(+)

diff --git a/crates/rpc/rpc-api/src/engine.rs b/crates/rpc/rpc-api/src/engine.rs
index b34a7934f9c..3c3e46d66c5 100644
--- a/crates/rpc/rpc-api/src/engine.rs
+++ b/crates/rpc/rpc-api/src/engine.rs
@@ -419,6 +419,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-eth-api/src/core.rs b/crates/rpc/rpc-eth-api/src/core.rs
index de7909aa47d..3467a9bea7e 100644
--- a/crates/rpc/rpc-eth-api/src/core.rs
+++ b/crates/rpc/rpc-eth-api/src/core.rs
@@ -422,6 +422,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>>;
@@ -940,6 +944,7 @@ where
 
         Ok(Some(json))
     }
+
     /// Handler for: `eth_getBlockAccessListByBlockNumber`
     async fn block_access_list_by_block_number(
         &self,
@@ -953,6 +958,18 @@ 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");
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

From ccf28c292d4d89de0aa4cc2213178b6abf467d86 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Fri, 8 May 2026 13:59:10 +0200
Subject: [PATCH 070/335] refactor(rpc): cache decoded revm BALs (#24079)

---
 crates/rpc/rpc-eth-types/src/cache/mod.rs | 45 ++++++++++++++++-------
 crates/storage/storage-api/src/bal.rs     | 22 ++++++++---
 2 files changed, 48 insertions(+), 19 deletions(-)

diff --git a/crates/rpc/rpc-eth-types/src/cache/mod.rs b/crates/rpc/rpc-eth-types/src/cache/mod.rs
index 1c1e5f0b8c5..9fd8c63cf99 100644
--- a/crates/rpc/rpc-eth-types/src/cache/mod.rs
+++ b/crates/rpc/rpc-eth-types/src/cache/mod.rs
@@ -3,7 +3,7 @@
 use super::{EthStateCacheConfig, MultiConsumerLruCache};
 use crate::block::CachedTransaction;
 use alloy_consensus::{transaction::TxHashRef, BlockHeader};
-use alloy_eips::BlockHashOrNumber;
+use alloy_eips::{eip7928::bal::DecodedBal, BlockHashOrNumber};
 use alloy_primitives::{Address, TxHash, B256};
 use futures::{stream::FuturesOrdered, Stream, StreamExt};
 use reth_chain_state::CanonStateNotification;
@@ -276,7 +276,10 @@ impl<N: NodePrimitives> EthStateCache<N> {
     /// 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<RevmBal>>> {
+    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
@@ -919,24 +922,28 @@ pub async fn cache_new_blocks_task<St, N: NodePrimitives>(
     }
 }
 
-/// Cached revm BAL.
+/// Cached decoded revm BAL.
 #[derive(Clone, Debug)]
-pub(crate) struct CachedRevmBal(Arc<RevmBal>);
+pub(crate) struct CachedRevmBal(Arc<DecodedBal<RevmBal>>);
 
 impl CachedRevmBal {
-    /// Creates a cached revm BAL from an owned BAL.
+    /// Creates a cached revm BAL from an owned decoded BAL.
     #[inline]
-    fn new(bal: RevmBal) -> Self {
+    fn new(bal: DecodedBal<RevmBal>) -> Self {
         Self(Arc::new(bal))
     }
 }
 
 impl InMemorySize for CachedRevmBal {
     fn size(&self) -> usize {
-        core::mem::size_of::<Self>() + revm_bal_size(&self.0)
+        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)>() +
@@ -1011,6 +1018,10 @@ mod tests {
         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 {
@@ -1077,7 +1088,7 @@ mod tests {
         let mut service = test_service();
         let block_hash = B256::repeat_byte(0x44);
 
-        assert!(service.bal_cache.insert(block_hash, CachedRevmBal::new(RevmBal::default())));
+        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));
@@ -1090,7 +1101,7 @@ mod tests {
         let mut service = test_service();
         let block_hash = B256::repeat_byte(0x55);
         let (response_tx, mut response_rx) = oneshot::channel();
-        let bal = CachedRevmBal::new(RevmBal::default());
+        let bal = CachedRevmBal::new(test_decoded_revm_bal());
 
         assert!(service.bal_cache.queue(block_hash, response_tx));
 
@@ -1118,9 +1129,12 @@ mod tests {
         let mut bal = RevmBal::default();
         bal.accounts.insert(Address::ZERO, account);
 
-        let previous_estimate =
-            core::mem::size_of::<CachedRevmBal>() + core::mem::size_of::<RevmBal>();
-        assert!(CachedRevmBal::new(bal).size() > previous_estimate);
+        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]
@@ -1211,9 +1225,12 @@ mod tests {
             Ok(block_hashes.iter().map(|_| None).collect())
         }
 
-        fn revm_bal_by_hash(&self, _block_hash: BlockHash) -> ProviderResult<Option<RevmBal>> {
+        fn revm_bal_by_hash(
+            &self,
+            _block_hash: BlockHash,
+        ) -> ProviderResult<Option<DecodedBal<RevmBal>>> {
             self.fetches.fetch_add(1, Ordering::SeqCst);
-            Ok(Some(RevmBal::default()))
+            Ok(Some(test_decoded_revm_bal()))
         }
 
         fn get_by_range(&self, _start: BlockNumber, _count: u64) -> ProviderResult<Vec<Bytes>> {
diff --git a/crates/storage/storage-api/src/bal.rs b/crates/storage/storage-api/src/bal.rs
index f7b681346ad..44d8d9f3fce 100644
--- a/crates/storage/storage-api/src/bal.rs
+++ b/crates/storage/storage-api/src/bal.rs
@@ -88,12 +88,16 @@ pub trait BalStore: Send + Sync + 'static {
     }
 
     /// Fetches the BAL for the given block hash in revm representation.
-    fn revm_bal_by_hash(&self, block_hash: BlockHash) -> ProviderResult<Option<RevmBal>> {
+    fn revm_bal_by_hash(
+        &self,
+        block_hash: BlockHash,
+    ) -> ProviderResult<Option<DecodedBal<RevmBal>>> {
         self.get_decoded_by_hash(block_hash)?
             .map(|decoded| {
-                let (bal, _) = decoded.split();
-                RevmBal::try_from(Vec::from(bal))
-                    .map_err(reth_storage_errors::provider::ProviderError::other)
+                decoded.try_map(|bal| {
+                    RevmBal::try_from(Vec::from(bal))
+                        .map_err(reth_storage_errors::provider::ProviderError::other)
+                })
             })
             .transpose()
     }
@@ -230,7 +234,10 @@ impl BalStoreHandle {
 
     /// Fetches the BAL for the given block hash in revm representation.
     #[inline]
-    pub fn revm_bal_by_hash(&self, block_hash: BlockHash) -> ProviderResult<Option<RevmBal>> {
+    pub fn revm_bal_by_hash(
+        &self,
+        block_hash: BlockHash,
+    ) -> ProviderResult<Option<DecodedBal<RevmBal>>> {
         self.inner.revm_bal_by_hash(block_hash)
     }
 
@@ -385,6 +392,11 @@ mod tests {
         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]

From 9e4e249e32db4ada982f32c03be25c3e0688d944 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Fri, 8 May 2026 14:26:55 +0200
Subject: [PATCH 071/335] feat: parallel execution (#23924)

Co-authored-by: Emma Jamieson-Hoare <ejamieson19@gmail.com>
Co-authored-by: Amp <amp@ampcode.com>
Co-authored-by: Emma Jamieson-Hoare <emmajam@users.noreply.github.com>
Co-authored-by: Alexey Shekhirin <github@shekhirin.com>
Co-authored-by: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
Co-authored-by: Soubhik Singha Mahapatra <soubhiksmp2004@gmail.com>
Co-authored-by: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Co-authored-by: Brian Picciano <me@mediocregopher.com>
Co-authored-by: Dan Cline <6798349+Rjected@users.noreply.github.com>
Co-authored-by: Sergei Shulepov <s.pepyakin@gmail.com>
Co-authored-by: Arsenii Kulikov <klkvrr@gmail.com>
---
 .github/scripts/hive/build_simulators.sh      |    4 +-
 Cargo.lock                                    |   28 +-
 bin/reth-bb/src/evm.rs                        |   54 +-
 bin/reth-bb/src/evm_config.rs                 |  124 +-
 bin/reth-bb/src/main.rs                       |    4 +
 crates/consensus/consensus/Cargo.toml         |    2 +
 crates/consensus/consensus/src/lib.rs         |   20 +
 crates/engine/primitives/src/config.rs        |   13 +-
 crates/engine/tree/Cargo.toml                 |    6 +-
 crates/engine/tree/src/tree/error.rs          |   24 +
 .../src/tree/payload_processor/bal/debug.rs   |  297 +++++
 .../src/tree/payload_processor/bal/error.rs   |   44 +
 .../src/tree/payload_processor/bal/execute.rs | 1016 +++++++++++++++++
 .../src/tree/payload_processor/bal/mod.rs     |   19 +
 .../payload_processor/bal/ordered_outputs.rs  |  192 ++++
 .../src/tree/payload_processor/bal/worker.rs  |   91 ++
 .../tree/src/tree/payload_processor/mod.rs    |   70 +-
 .../src/tree/payload_processor/prewarm.rs     |   32 +-
 .../engine/tree/src/tree/payload_validator.rs |  188 ++-
 crates/ethereum/consensus/src/validation.rs   |    1 -
 crates/ethereum/evm/src/build.rs              |    5 +-
 crates/ethereum/payload/src/lib.rs            |   10 +-
 crates/evm/evm/src/either.rs                  |    7 +
 crates/evm/evm/src/execute.rs                 |   76 +-
 crates/node/core/src/args/engine.rs           |   26 +-
 docs/vocs/docs/pages/cli/reth/node.mdx        |    4 +-
 26 files changed, 2177 insertions(+), 180 deletions(-)
 create mode 100644 crates/engine/tree/src/tree/payload_processor/bal/debug.rs
 create mode 100644 crates/engine/tree/src/tree/payload_processor/bal/error.rs
 create mode 100644 crates/engine/tree/src/tree/payload_processor/bal/execute.rs
 create mode 100644 crates/engine/tree/src/tree/payload_processor/bal/mod.rs
 create mode 100644 crates/engine/tree/src/tree/payload_processor/bal/ordered_outputs.rs
 create mode 100644 crates/engine/tree/src/tree/payload_processor/bal/worker.rs

diff --git a/.github/scripts/hive/build_simulators.sh b/.github/scripts/hive/build_simulators.sh
index 8024a192be4..46f29bac05e 100755
--- a/.github/scripts/hive/build_simulators.sh
+++ b/.github/scripts/hive/build_simulators.sh
@@ -5,8 +5,8 @@ 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@v5.6.1/fixtures_bal.tar.gz"
+        eels_branch="devnets/bal/3"
         ;;
     osaka)
         eels_fixtures="https://github.com/ethereum/execution-spec-tests/releases/download/v5.3.0/fixtures_develop.tar.gz"
diff --git a/Cargo.lock b/Cargo.lock
index ed482ac8bd0..a821463c344 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1065,7 +1065,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1076,7 +1076,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -3448,7 +3448,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4213,8 +4213,8 @@ dependencies = [
  "libc",
  "log",
  "rustversion",
- "windows-link 0.2.1",
- "windows-result 0.4.1",
+ "windows-link 0.1.3",
+ "windows-result 0.3.4",
 ]
 
 [[package]]
@@ -4763,7 +4763,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.62.2",
+ "windows-core 0.61.2",
 ]
 
 [[package]]
@@ -5130,7 +5130,7 @@ checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
 dependencies = [
  "hermit-abi",
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -6142,7 +6142,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -7867,6 +7867,7 @@ name = "reth-consensus"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
+ "alloy-eip7928",
  "alloy-primitives",
  "auto_impl",
  "reth-execution-types",
@@ -8331,6 +8332,7 @@ dependencies = [
  "reth-trie-parallel",
  "reth-trie-sparse",
  "revm",
+ "revm-database-interface",
  "revm-primitives",
  "revm-state",
  "schnellru",
@@ -11028,7 +11030,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -11108,7 +11110,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs 1.0.7",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -11713,7 +11715,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -11934,7 +11936,7 @@ dependencies = [
  "getrandom 0.4.2",
  "once_cell",
  "rustix",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -13203,7 +13205,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
diff --git a/bin/reth-bb/src/evm.rs b/bin/reth-bb/src/evm.rs
index 92360024391..324e74ec797 100644
--- a/bin/reth-bb/src/evm.rs
+++ b/bin/reth-bb/src/evm.rs
@@ -76,6 +76,7 @@ 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)
     }
@@ -104,6 +105,12 @@ 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.
@@ -163,7 +170,7 @@ where
     /// Callback to reseed block hashes into the DB's cache at segment
     /// boundaries. See [`BlockHashSeeder`].
     block_hash_seeder: Option<BlockHashSeeder<DB>>,
-    /// Callback to read the BAL index from the DB.
+    /// 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
@@ -221,34 +228,40 @@ where
         }
     }
 
+    /// 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(());
         }
+        self.initialized = true;
 
         let plan = match &self.plan {
-            Some(plan) => plan,
+            Some(p) => p,
             None => return Ok(()),
         };
 
-        self.initialized = true;
-
         let bal_index =
             self.bal_index_reader.map(|reader| reader(self.inner().evm().db())).unwrap_or(0);
-        let segment_idx =
-            if bal_index == 0 { 0 } else { plan.segment_index_for_tx((bal_index - 1) as usize) };
+        let segment_idx = if bal_index == 0 {
+            0
+        } else {
+            let tx_index = (bal_index - 1) as usize;
+            plan.segment_index_for_tx(tx_index)
+        };
         let segment = &plan.segments[segment_idx];
-
-        // Swap the EVM's block_env and executor ctx to the selected segment's
-        // values so that EIP-2935/EIP-4788 system calls use the correct block
-        // number and parent hash. Without this, the outer big block header's
-        // block_number (which is synthetic) would be used, writing to wrong
-        // EIP-2935 slots and corrupting state.
         let block_env = segment.evm_env.block_env.clone();
         let block_number = block_env.number.saturating_to::<u64>();
         let mut cfg_env = segment.evm_env.cfg_env.clone();
         cfg_env.disable_base_fee = true;
-        let ctx = EthBlockExecutionCtx {
+        let segment_ctx = EthBlockExecutionCtx {
             parent_hash: segment.ctx.parent_hash,
             parent_beacon_block_root: segment.ctx.parent_beacon_block_root,
             ommers: segment.ctx.ommers,
@@ -262,7 +275,7 @@ where
         let evm_ctx = inner.evm.ctx_mut();
         evm_ctx.block = block_env;
         evm_ctx.cfg = cfg_env;
-        inner.ctx = ctx;
+        inner.ctx = segment_ctx;
 
         self.reseed_block_hashes_for(block_number);
 
@@ -481,8 +494,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()
     }
@@ -606,7 +622,7 @@ pub struct BbBlockExecutorFactory<Spec> {
     receipt_builder: RethReceiptBuilder,
     spec: Spec,
     evm_factory: EthEvmFactory,
-    /// Staged plan cloned into each [`BbBlockExecutor`].
+    /// Staged plan consumed by the next [`BbBlockExecutor`].
     pub(crate) staged_plan: Arc<Mutex<Option<BbEvmPlan>>>,
 }
 
@@ -639,6 +655,10 @@ impl<Spec> BbBlockExecutorFactory<Spec> {
         *self.staged_plan.lock().unwrap() = None;
     }
 
+    /// Returns a clone of the currently staged plan without consuming it.
+    ///
+    /// Cloning lets multiple executors (canonical + N parallel BAL workers
+    /// for the same block) each own their own plan state.
     fn peek_plan(&self) -> Option<BbEvmPlan> {
         self.staged_plan.lock().unwrap().clone()
     }
diff --git a/bin/reth-bb/src/evm_config.rs b/bin/reth-bb/src/evm_config.rs
index a0e1e437065..27c22d5adbd 100644
--- a/bin/reth-bb/src/evm_config.rs
+++ b/bin/reth-bb/src/evm_config.rs
@@ -30,7 +30,6 @@ use reth_evm_ethereum::{EthBlockAssembler, EthEvmConfig, RethReceiptBuilder};
 use reth_primitives_traits::{SealedBlock, SealedHeader};
 use revm::primitives::hardfork::SpecId;
 use std::sync::Arc;
-use tracing::debug;
 
 // ---------------------------------------------------------------------------
 // Execution plan types
@@ -55,7 +54,7 @@ pub(crate) struct BigBlockSegment {
 ///
 /// Wraps [`EthEvmConfig`] and a shared [`BigBlockMap`]. When a big-block
 /// payload is received, the plan is staged on the [`BbBlockExecutorFactory`]
-/// and cloned when executors are created. Block hashes for inter-segment
+/// and consumed when the executor is created. Block hashes for inter-segment
 /// BLOCKHASH resolution are reseeded into `State::block_hashes` at each
 /// segment boundary via a [`BlockHashSeeder`](crate::evm::BlockHashSeeder)
 /// callback injected in [`ConfigureEvm::create_executor`].
@@ -106,6 +105,11 @@ fn seed_state_block_hashes<DB>(state: &mut &mut revm::database::State<DB>, hashe
     }
 }
 
+/// 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`.
 fn read_bal_index<DB>(state: &&mut revm::database::State<DB>) -> u64 {
     state.bal_state.bal_index()
 }
@@ -165,19 +169,6 @@ where
         self.inner.next_evm_env(parent, attributes)
     }
 
-    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)
-    }
-
     fn context_for_next_block(
         &self,
         parent: &SealedHeader,
@@ -215,6 +206,22 @@ where
             Some(set_bal_index::<DB>),
         )
     }
+
+    fn context_for_block<'a>(
+        &self,
+        block: &'a SealedBlock<reth_ethereum_primitives::Block>,
+    ) -> Result<EthBlockExecutionCtx<'a>, Self::Error> {
+        // Refresh the staged plan based on this block's hash so subsequent
+        // `create_executor` calls - both canonical and parallel BAL workers -
+        // see the right plan. Cleared explicitly when this block isn't a
+        // big-block payload, so a stale plan from a prior big block doesn't
+        // leak into a regular block.
+        match self.plan_for_payload_hash(&block.hash()) {
+            Some(plan) => self.executor_factory.stage_plan(plan),
+            None => self.executor_factory.clear_staged_plan(),
+        }
+        self.inner.context_for_block(block)
+    }
 }
 
 // ---------------------------------------------------------------------------
@@ -227,16 +234,15 @@ where
 {
     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 first_exec_data = {
+            let pending = self.pending.lock().unwrap();
+            pending
+                .get(&payload_hash)
+                .and_then(|bb_data| bb_data.env_switches.first().map(|(_, data)| data.clone()))
+        };
+
+        if let Some(first_exec_data) = first_exec_data {
+            // Compute the env from the first segment before the executor is created.
             let mut env = self.inner.evm_env_for_payload(&first_exec_data)?;
 
             // Disable basefee validation: transactions from different
@@ -244,12 +250,8 @@ where
             // 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)
         }
     }
@@ -270,61 +272,49 @@ where
 }
 
 // ---------------------------------------------------------------------------
-// Plan construction and staging
+// Plan construction
 // ---------------------------------------------------------------------------
 
 impl<C> BbEvmConfig<C>
 where
     C: EthExecutorSpec + EthChainSpec<Header = Header> + Hardforks + 'static,
 {
-    /// 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 pending = self.pending.lock().unwrap();
+        self.build_plan(pending.get(payload_hash)?)
     }
 
-    fn plan_for_payload_hash(&self, payload_hash: &B256) -> Option<BbEvmPlan> {
-        let bb = self.pending.lock().unwrap().remove(payload_hash)?;
+    fn build_plan(&self, bb: &BigBlockData<ExecutionData>) -> Option<BbEvmPlan> {
+        if bb.env_switches.is_empty() {
+            return None;
+        }
 
         let segments: Vec<_> = bb
             .env_switches
-            .into_iter()
+            .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 }
+                let mut evm_env = self.inner.evm_env_for_payload(exec_data).unwrap();
+                evm_env.cfg_env.disable_base_fee = true;
+                let ctx = self.inner.context_for_payload(exec_data).unwrap();
+                BigBlockSegment { start_tx: *start_tx, evm_env, ctx: clone_ctx(&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.extend(bb.prior_block_hashes.iter().copied());
         plan.block_hashes_to_seed.sort_unstable_by_key(|(n, _)| *n);
-
         Some(plan)
     }
 }
+
+fn clone_ctx<'a>(ctx: &EthBlockExecutionCtx<'_>) -> EthBlockExecutionCtx<'a> {
+    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.clone().map(|w| std::borrow::Cow::Owned(w.into_owned())),
+        extra_data: ctx.extra_data.clone(),
+        slot_number: ctx.slot_number,
+    }
+}
diff --git a/bin/reth-bb/src/main.rs b/bin/reth-bb/src/main.rs
index 9bf967e67bd..51e4922562d 100644
--- a/bin/reth-bb/src/main.rs
+++ b/bin/reth-bb/src/main.rs
@@ -33,6 +33,7 @@ use reth_node_builder::{
     },
     BuilderContext, Node,
 };
+use reth_node_core::args::DefaultEngineValues;
 use reth_node_ethereum::{
     EthEngineTypes, EthereumEngineValidatorBuilder, EthereumEthApiBuilder, EthereumNetworkBuilder,
     EthereumNode, EthereumPayloadBuilder, EthereumPoolBuilder,
@@ -356,8 +357,11 @@ fn main() {
 
     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?;
 
         handle.wait_for_node_exit().await
diff --git a/crates/consensus/consensus/Cargo.toml b/crates/consensus/consensus/Cargo.toml
index b5c394ac014..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
@@ -31,5 +32,6 @@ std = [
     "alloy-consensus/std",
     "reth-execution-types/std",
     "thiserror/std",
+    "alloy-eip7928/std",
 ]
 test-utils = ["reth-primitives-traits/test-utils"]
diff --git a/crates/consensus/consensus/src/lib.rs b/crates/consensus/consensus/src/lib.rs
index 6e9ed1950dc..531c500e38a 100644
--- a/crates/consensus/consensus/src/lib.rs
+++ b/crates/consensus/consensus/src/lib.rs
@@ -475,6 +475,9 @@ pub enum ConsensusError {
     /// EIP-7825: Transaction gas limit exceeds maximum allowed
     #[error(transparent)]
     TransactionGasLimitTooHigh(Box<TxGasLimitTooHighErr>),
+    /// Error when an unexpected block access list cost is encountered.
+    #[error("block access list cost exceeds gas limit")]
+    BlockAccessListCostMoreThanGasLimit,
     /// Error when the block access list hash doesn't match the expected value.
     #[error("block access list hash mismatch: {0}")]
     BlockAccessListHashMismatch(GotExpectedBoxed<B256>),
@@ -523,6 +526,23 @@ impl ConsensusError {
     }
 }
 
+/// Validates the block access list against the gas limit.
+///
+/// EIP-7925 specifies that the total cost of the block access list items must not exceed
+/// the gas limit. Each item costs `ITEM_COST` gas.
+pub fn validate_block_access_list_gas(
+    block_access_list: Option<&alloy_eip7928::BlockAccessList>,
+    gas_limit: u64,
+) -> Result<(), ConsensusError> {
+    if let Some(bal) = block_access_list {
+        let bal_items = alloy_eip7928::total_bal_items(bal);
+        if bal_items > gas_limit / alloy_eip7928::ITEM_COST as u64 {
+            return Err(ConsensusError::BlockAccessListCostMoreThanGasLimit)
+        }
+    }
+    Ok(())
+}
+
 impl From<InvalidTransactionError> for ConsensusError {
     fn from(value: InvalidTransactionError) -> Self {
         Self::InvalidTransaction(value)
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/tree/Cargo.toml b/crates/engine/tree/Cargo.toml
index c94083fd255..7e35cf36854 100644
--- a/crates/engine/tree/Cargo.toml
+++ b/crates/engine/tree/Cargo.toml
@@ -48,6 +48,7 @@ alloy-rpc-types-engine.workspace = true
 
 revm.workspace = true
 revm-primitives.workspace = true
+revm-state.workspace = true
 
 # common
 futures.workspace = true
@@ -95,8 +96,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
@@ -131,9 +131,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/tree/error.rs b/crates/engine/tree/src/tree/error.rs
index 8899542af64..5110fa8b0d7 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};
@@ -116,11 +117,27 @@ pub enum InsertBlockErrorKind {
     /// Provider error.
     #[error(transparent)]
     Provider(#[from] ProviderError),
+    /// BAL-driven block execution rejected the block. Covers structural BAL errors and the
+    /// final-hash mismatch.
+    #[error(transparent)]
+    InvalidBlockAccessList(BalExecutionError),
     /// Other errors.
     #[error(transparent)]
     Other(#[from] Box<dyn core::error::Error + Send + Sync + 'static>),
 }
 
+impl From<BalExecutionError> for InsertBlockErrorKind {
+    fn from(e: BalExecutionError) -> Self {
+        match e {
+            // Worker EVM errors flow through the standard execution-error path so existing
+            // metrics and routing apply.
+            BalExecutionError::Evm(inner) => Self::Execution(inner),
+            BalExecutionError::Provider(inner) => Self::Provider(inner),
+            other => Self::InvalidBlockAccessList(other),
+        }
+    }
+}
+
 impl InsertBlockErrorKind {
     /// Returns an [`InsertBlockValidationError`] if the error is caused by an invalid block.
     ///
@@ -147,6 +164,9 @@ impl InsertBlockErrorKind {
                 }
             }
             Self::Provider(err) => Err(InsertBlockFatalError::Provider(err)),
+            Self::InvalidBlockAccessList(err) => {
+                Ok(InsertBlockValidationError::InvalidBlockAccessList(err))
+            }
             Self::Other(err) => Err(InternalBlockExecutionError::Other(err).into()),
         }
     }
@@ -172,6 +192,10 @@ pub enum InsertBlockValidationError {
     /// Validation error, transparently wrapping [`BlockValidationError`]
     #[error(transparent)]
     Validation(#[from] BlockValidationError),
+    /// BAL-driven block execution rejected the block. Covers structural BAL errors and the
+    /// final-hash mismatch.
+    #[error(transparent)]
+    InvalidBlockAccessList(BalExecutionError),
 }
 
 /// Errors that may occur when inserting a payload.
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/debug.rs b/crates/engine/tree/src/tree/payload_processor/bal/debug.rs
new file mode 100644
index 00000000000..43506c02b79
--- /dev/null
+++ b/crates/engine/tree/src/tree/payload_processor/bal/debug.rs
@@ -0,0 +1,297 @@
+//! BAL divergence diagnostics.
+
+use alloy_eip7928::AccountChanges;
+use alloy_primitives::Address;
+
+/// Compact summary of where two BALs first diverge.
+#[derive(Debug, PartialEq, Eq)]
+pub(super) struct BalDivergence {
+    received_accounts: usize,
+    rebuilt_accounts: usize,
+    first_diff: Option<AccountDivergence>,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+struct AccountDivergence {
+    index: usize,
+    received: Option<AccountSummary>,
+    rebuilt: Option<AccountSummary>,
+    fields_differ: AccountFieldFlags,
+}
+
+impl AccountDivergence {
+    fn received_only(index: usize, account: &AccountChanges) -> Self {
+        Self {
+            index,
+            received: Some(AccountSummary::from_account(account)),
+            rebuilt: None,
+            fields_differ: AccountFieldFlags::default(),
+        }
+    }
+
+    fn rebuilt_only(index: usize, account: &AccountChanges) -> Self {
+        Self {
+            index,
+            received: None,
+            rebuilt: Some(AccountSummary::from_account(account)),
+            fields_differ: AccountFieldFlags::default(),
+        }
+    }
+
+    fn address_mismatch(index: usize, received: &AccountChanges, rebuilt: &AccountChanges) -> Self {
+        Self {
+            index,
+            received: Some(AccountSummary::from_account(received)),
+            rebuilt: Some(AccountSummary::from_account(rebuilt)),
+            fields_differ: AccountFieldFlags::default(),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+struct AccountSummary {
+    address: Address,
+    storage_changes: usize,
+    storage_reads: usize,
+    balance_changes: usize,
+    nonce_changes: usize,
+    code_changes: usize,
+}
+
+impl AccountSummary {
+    const fn from_account(account: &AccountChanges) -> Self {
+        Self {
+            address: account.address,
+            storage_changes: account.storage_changes.len(),
+            storage_reads: account.storage_reads.len(),
+            balance_changes: account.balance_changes.len(),
+            nonce_changes: account.nonce_changes.len(),
+            code_changes: account.code_changes.len(),
+        }
+    }
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+struct AccountFieldFlags {
+    storage_changes: bool,
+    storage_reads: bool,
+    balance_changes: bool,
+    nonce_changes: bool,
+    code_changes: bool,
+}
+
+impl AccountFieldFlags {
+    fn new(received: &AccountChanges, rebuilt: &AccountChanges) -> Self {
+        Self {
+            storage_changes: received.storage_changes != rebuilt.storage_changes,
+            storage_reads: received.storage_reads != rebuilt.storage_reads,
+            balance_changes: received.balance_changes != rebuilt.balance_changes,
+            nonce_changes: received.nonce_changes != rebuilt.nonce_changes,
+            code_changes: received.code_changes != rebuilt.code_changes,
+        }
+    }
+
+    const fn is_divergent(&self) -> bool {
+        self.storage_changes ||
+            self.storage_reads ||
+            self.balance_changes ||
+            self.nonce_changes ||
+            self.code_changes
+    }
+}
+
+pub(super) fn first_bal_divergence(
+    received: &[AccountChanges],
+    rebuilt: &[AccountChanges],
+) -> BalDivergence {
+    use core::cmp::Ordering;
+
+    let mut change_index = 0;
+    let first_diff = loop {
+        match (received.get(change_index), rebuilt.get(change_index)) {
+            (Some(received_account), Some(rebuilt_account)) => {
+                match received_account.address.cmp(&rebuilt_account.address) {
+                    Ordering::Less | Ordering::Greater => {
+                        break Some(AccountDivergence::address_mismatch(
+                            change_index,
+                            received_account,
+                            rebuilt_account,
+                        ));
+                    }
+                    Ordering::Equal => {
+                        let fields_differ =
+                            AccountFieldFlags::new(received_account, rebuilt_account);
+                        if fields_differ.is_divergent() {
+                            break Some(AccountDivergence {
+                                index: change_index,
+                                received: Some(AccountSummary::from_account(received_account)),
+                                rebuilt: Some(AccountSummary::from_account(rebuilt_account)),
+                                fields_differ,
+                            });
+                        }
+                        change_index += 1;
+                    }
+                }
+            }
+            (Some(account), None) => {
+                break Some(AccountDivergence::received_only(change_index, account));
+            }
+            (None, Some(account)) => {
+                break Some(AccountDivergence::rebuilt_only(change_index, account));
+            }
+            (None, None) => break None,
+        }
+    };
+
+    BalDivergence { received_accounts: received.len(), rebuilt_accounts: rebuilt.len(), first_diff }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy_eip7928::{AccountChanges, BalanceChange};
+    use alloy_primitives::{Address, U256};
+
+    fn diagnostic_addr(byte: u8) -> Address {
+        let mut address = [0u8; 20];
+        address[19] = byte;
+        Address::from(address)
+    }
+
+    fn diagnostic_account(address: Address, balance: u64) -> AccountChanges {
+        AccountChanges {
+            address,
+            balance_changes: vec![BalanceChange::new(1, U256::from(balance))],
+            ..Default::default()
+        }
+    }
+
+    fn first_diff(received: &[AccountChanges], rebuilt: &[AccountChanges]) -> AccountDivergence {
+        first_bal_divergence(received, rebuilt).first_diff.expect("expected BAL divergence")
+    }
+
+    fn assert_summary_address(summary: &Option<AccountSummary>, address: Address) {
+        match summary {
+            Some(summary) => assert_eq!(summary.address, address),
+            None => panic!("expected account summary"),
+        }
+    }
+
+    #[test]
+    fn none_for_equal_bals() {
+        let account = diagnostic_account(diagnostic_addr(1), 1);
+        let rebuilt = vec![account.clone()];
+
+        let div = first_bal_divergence(core::slice::from_ref(&account), &rebuilt);
+
+        assert_eq!(
+            div,
+            BalDivergence { received_accounts: 1, rebuilt_accounts: 1, first_diff: None }
+        );
+    }
+
+    #[test]
+    fn reports_account_only_in_received() {
+        let received = vec![diagnostic_account(diagnostic_addr(1), 1)];
+
+        let diff = first_diff(&received, &[]);
+
+        assert_eq!(diff.index, 0);
+        assert_eq!(diff.received, Some(AccountSummary::from_account(&received[0])));
+        assert_eq!(diff.rebuilt, None);
+    }
+
+    #[test]
+    fn reports_tail_account_only_in_received_after_matching_prefix() {
+        let shared = diagnostic_account(diagnostic_addr(1), 1);
+        let received = vec![shared.clone(), diagnostic_account(diagnostic_addr(2), 2)];
+        let rebuilt = vec![shared];
+
+        let diff = first_diff(&received, &rebuilt);
+
+        assert_eq!(diff.index, 1);
+        assert_summary_address(&diff.received, diagnostic_addr(2));
+        assert_eq!(diff.rebuilt, None);
+    }
+
+    #[test]
+    fn reports_account_only_in_rebuilt() {
+        let rebuilt = vec![diagnostic_account(diagnostic_addr(1), 1)];
+
+        let diff = first_diff(&[], &rebuilt);
+
+        assert_eq!(diff.index, 0);
+        assert_eq!(diff.received, None);
+        assert_eq!(diff.rebuilt, Some(AccountSummary::from_account(&rebuilt[0])));
+    }
+
+    #[test]
+    fn reports_tail_account_only_in_rebuilt_after_matching_prefix() {
+        let shared = diagnostic_account(diagnostic_addr(1), 1);
+        let received = vec![shared.clone()];
+        let rebuilt = vec![shared, diagnostic_account(diagnostic_addr(2), 2)];
+
+        let diff = first_diff(&received, &rebuilt);
+
+        assert_eq!(diff.index, 1);
+        assert_eq!(diff.received, None);
+        assert_summary_address(&diff.rebuilt, diagnostic_addr(2));
+    }
+
+    #[test]
+    fn reports_changed_balance_field() {
+        let received = vec![diagnostic_account(diagnostic_addr(1), 1)];
+        let rebuilt = vec![diagnostic_account(diagnostic_addr(1), 2)];
+
+        let diff = first_diff(&received, &rebuilt);
+
+        assert_eq!(diff.index, 0);
+        assert_eq!(
+            diff.fields_differ,
+            AccountFieldFlags { balance_changes: true, ..Default::default() }
+        );
+        assert!(diff.received.is_some());
+        assert!(diff.rebuilt.is_some());
+    }
+
+    #[test]
+    fn reports_both_addresses_for_address_mismatch() {
+        let received = vec![
+            diagnostic_account(diagnostic_addr(1), 1),
+            diagnostic_account(diagnostic_addr(3), 1),
+        ];
+        let rebuilt = vec![
+            diagnostic_account(diagnostic_addr(2), 1),
+            diagnostic_account(diagnostic_addr(3), 2),
+        ];
+
+        let diff = first_diff(&received, &rebuilt);
+
+        assert_eq!(diff.index, 0);
+        assert_summary_address(&diff.received, diagnostic_addr(1));
+        assert_summary_address(&diff.rebuilt, diagnostic_addr(2));
+        assert_eq!(diff.fields_differ, AccountFieldFlags::default());
+    }
+
+    #[test]
+    fn stops_at_first_mismatch_after_matching_prefix() {
+        let shared = diagnostic_account(diagnostic_addr(1), 1);
+        let received = vec![
+            shared.clone(),
+            diagnostic_account(diagnostic_addr(2), 2),
+            diagnostic_account(diagnostic_addr(4), 4),
+        ];
+        let rebuilt = vec![
+            shared,
+            diagnostic_account(diagnostic_addr(3), 3),
+            diagnostic_account(diagnostic_addr(4), 5),
+        ];
+
+        let diff = first_diff(&received, &rebuilt);
+
+        assert_eq!(diff.index, 1);
+        assert_summary_address(&diff.received, diagnostic_addr(2));
+        assert_summary_address(&diff.rebuilt, diagnostic_addr(3));
+        assert_eq!(diff.fields_differ, AccountFieldFlags::default());
+    }
+}
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..efa6f621f2c
--- /dev/null
+++ b/crates/engine/tree/src/tree/payload_processor/bal/error.rs
@@ -0,0 +1,44 @@
+//! Errors for the BAL execution path.
+
+use alloy_evm::block::BlockExecutionError;
+use alloy_primitives::B256;
+use reth_provider::ProviderError;
+
+/// Errors surfaced by `execute_block`.
+#[derive(Debug, thiserror::Error)]
+pub enum BalExecutionError {
+    /// BAL-specific rejection.
+    #[error("BAL rejection: {0:?}")]
+    Reject(RejectReason),
+    /// Worker or canonical EVM failure.
+    ///
+    /// This includes revm `BalError` for undeclared accesses. Revm does not yet report the
+    /// offending address or storage slot here.
+    #[error("evm execution failed: {0}")]
+    Evm(#[from] BlockExecutionError),
+    /// Provider setup failed before EVM execution could start.
+    #[error("provider setup failed: {0}")]
+    Provider(#[from] ProviderError),
+    /// The received BAL could not be converted from alloy-format to revm-format.
+    #[error("alloy→revm BAL conversion failed: {0}")]
+    BalConversion(String),
+}
+
+impl From<RejectReason> for BalExecutionError {
+    fn from(r: RejectReason) -> Self {
+        Self::Reject(r)
+    }
+}
+
+/// Reasons a block may be rejected on the BAL execution path.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum RejectReason {
+    /// The rebuilt BAL's hash disagrees with `header.block_access_list_hash` at end-of-block.
+    /// Catches over-declared addresses and any divergence the per-tx fragment compares missed.
+    FinalHashMismatch {
+        /// Hash of the rebuilt BAL.
+        rebuilt: B256,
+        /// Hash committed in the block header.
+        expected: B256,
+    },
+}
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..5dcb7723a6c
--- /dev/null
+++ b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
@@ -0,0 +1,1016 @@
+//! BAL executor.
+//!
+//! Read `execute_block` as two execution paths over the same parent state.
+//!
+//! Worker states run transactions speculatively. Each worker gets one fresh database from
+//! `make_db`, 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 final hash check compares that rebuilt BAL with the header commitment. The outer payload
+//! validator still handles consensus checks, receipt-root validation, state-root work, and block
+//! insertion.
+
+use super::{
+    debug, ordered_outputs::ordered_worker_outputs, worker, BalExecutionError, RejectReason,
+};
+use alloy_eip7928::{
+    bal::{Bal as AlloyBal, DecodedBal},
+    compute_block_access_list_hash,
+};
+use alloy_evm::{
+    block::{BlockExecutionError, BlockExecutor, BlockValidationError, TxResult},
+    Evm,
+};
+use alloy_primitives::Address;
+use crossbeam_channel::{Receiver, Sender};
+use reth_evm::{
+    block::BlockExecutorFactory, execute::ExecutableTxFor, ConfigureEvm, Database, EvmEnvFor,
+    ExecutionCtxFor,
+};
+use reth_primitives_traits::ReceiptTy;
+use reth_provider::BlockExecutionOutput;
+use reth_tasks::Runtime;
+use revm::{
+    context::{result::ResultAndState, Block},
+    database::{states::bundle_state::BundleRetention, State},
+    primitives::{eip7825::TX_GAS_LIMIT_CAP, hardfork::SpecId},
+};
+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,
+    received_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>), BalExecutionError>
+where
+    Evm: ConfigureEvm + 'static,
+    Tx: ExecutableTxFor<Evm> + Send + 'a,
+    Err: core::error::Error + Send + Sync + 'static,
+    DB: Database + Send + 'a,
+    MakeDb: Fn() -> 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,
+            received_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,
+    received_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>), BalExecutionError>
+where
+    Evm: ConfigureEvm + 'scope,
+    Tx: ExecutableTxFor<Evm> + Send + 'scope,
+    Err: core::error::Error + Send + Sync + 'static,
+    DB: Database + Send + 'scope,
+    MakeDb: Fn() -> Result<DB, BalExecutionError> + Sync + 'scope,
+    ReceiptTy<Evm::Primitives>: Clone,
+{
+    let bal = received_bal.as_bal();
+    let received_bal_revm: Arc<RevmBal> = Arc::new(
+        RevmBal::try_from(Vec::<_>::from(bal.clone()))
+            .map_err(|e| BalExecutionError::BalConversion(format!("{e:?}")))?,
+    );
+
+    // NOTE: technically Amsterdam implies BAL (the current path) we are on.
+    // TODO: should we do this
+    let is_amsterdam = evm_env.cfg_env.spec.into().is_enabled_in(SpecId::AMSTERDAM);
+    let block_gas_limit = evm_env.block_env.gas_limit();
+    let mut canonical_state =
+        State::builder().with_database(make_db()?).with_bundle_update().with_bal_builder().build();
+    load_bal_accounts(&mut canonical_state, bal)?;
+
+    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(&received_bal_revm),
+                evm_env.clone(),
+                ctx.clone(),
+            );
+        }
+        drop(result_tx);
+
+        let mut gas_tracker = BlockGasTracker::new(block_gas_limit, is_amsterdam);
+        let evm = evm_config.evm_with_env(&mut canonical_state, evm_env);
+        let mut canonical_executor =
+            evm_config.block_executor_factory().create_executor(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)
+    };
+
+    validate_bal(&mut canonical_state, bal)?;
+
+    canonical_state.merge_transitions(BundleRetention::Reverts);
+    Ok((
+        BlockExecutionOutput { state: canonical_state.take_bundle(), result: block_result },
+        senders,
+    ))
+}
+
+fn load_bal_accounts<DB>(
+    canonical_state: &mut State<DB>,
+    bal: &AlloyBal,
+) -> Result<(), BalExecutionError>
+where
+    DB: Database,
+{
+    // Pre-load every BAL-declared address into canonical state's cache. `State::commit`
+    // (called by `commit_transaction`) panics at revm-database's
+    // `cache.rs:195` ("All accounts should be present inside cache") when it tries to
+    // apply a diff for an address not previously loaded. In the normal serial flow the
+    // EVM loads the account itself during execution, but here workers execute the tx EVM
+    // and the canonical loop only commits their outputs, so canonical may never have read
+    // those accounts itself.
+    for account_changes in bal {
+        canonical_state
+            .load_cache_account(account_changes.address)
+            .map_err(|e| BalExecutionError::Evm(BlockExecutionError::other(e)))?;
+    }
+
+    Ok(())
+}
+
+fn validate_bal<DB>(
+    canonical_state: &mut State<DB>,
+    received_bal: &AlloyBal,
+) -> Result<(), BalExecutionError>
+where
+    DB: Database,
+{
+    let composed_alloy = canonical_state.take_built_alloy_bal().expect("with_bal_builder set");
+    if composed_alloy == received_bal.as_ref() {
+        return Ok(());
+    }
+    let rebuilt = compute_block_access_list_hash(&composed_alloy);
+    let header_bal_hash = compute_block_access_list_hash(received_bal);
+
+    if tracing::enabled!(
+        target: "engine::tree::payload_processor::bal",
+        tracing::Level::DEBUG
+    ) {
+        let div = debug::first_bal_divergence(received_bal, &composed_alloy);
+        tracing::debug!(
+            target: "engine::tree::payload_processor::bal",
+            %rebuilt,
+            expected = %header_bal_hash,
+            ?div,
+            "first BAL divergence",
+        );
+    }
+
+    Err(BalExecutionError::Reject(RejectReason::FinalHashMismatch {
+        rebuilt,
+        expected: header_bal_hash,
+    }))
+}
+
+/// 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,
+    is_amsterdam: bool,
+    cumulative_tx_gas_used: u64,
+    block_regular_gas_used: u64,
+}
+
+impl BlockGasTracker {
+    const fn new(block_gas_limit: u64, is_amsterdam: bool) -> Self {
+        Self { block_gas_limit, is_amsterdam, 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.is_amsterdam {
+            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 = tx_gas_limit.min(TX_GAS_LIMIT_CAP);
+
+        if tx_min_gas_limit > block_available_gas {
+            return Err(BlockValidationError::TransactionGasLimitMoreThanAvailableBlockGas {
+                transaction_gas_limit: tx_gas_limit,
+                block_available_gas,
+            }
+            .into());
+        }
+
+        Ok(())
+    }
+
+    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, EthereumReceipt, 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, 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 received_bal = reference_bal_for_empty_block(&evm_config);
+        let bal_hash = alloy_eip7928::compute_block_access_list_hash(&received_bal);
+        // Sanity: reference BAL is non-empty (system calls populated it).
+        assert!(!received_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(received_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,
+        received_bal: Arc<DecodedBal>,
+        block: &SealedBlock<Block>,
+        txs: Vec<Tx>,
+    ) -> Result<BlockExecutionOutput<EthereumReceipt>, 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();
+        execute_block(
+            runtime,
+            &evm_config,
+            &make_db,
+            received_bal,
+            evm_env,
+            execution_ctx,
+            transaction_count,
+            tx_stream(txs),
+            receipt_tx,
+        )
+        .map(|(output, _)| output)
+    }
+
+    /// 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::Evm(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 — this is the first scenario that
+        // exercises a real storage diff, validating that our account-only pre-load path
+        // (`load_cache_account` in execute_block) is sufficient even when commits include
+        // storage writes.
+        //
+        // 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]);
+    }
+}
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..49da947a393
--- /dev/null
+++ b/crates/engine/tree/src/tree/payload_processor/bal/mod.rs
@@ -0,0 +1,19 @@
+//! 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 debug;
+mod ordered_outputs;
+mod worker;
+
+pub mod error;
+pub mod execute;
+
+pub use error::{BalExecutionError, RejectReason};
+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..ab6fa364d48
--- /dev/null
+++ b/crates/engine/tree/src/tree/payload_processor/bal/ordered_outputs.rs
@@ -0,0 +1,192 @@
+//! Ordering adapter for speculative BAL worker results.
+
+use super::{worker::BalWorkerOutput, BalExecutionError};
+use alloy_evm::block::BlockExecutionError;
+use crossbeam_channel::Receiver;
+
+/// 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.
+///
+/// Contract for callers:
+/// - each yielded `Ok` output has the next transaction index
+/// - worker errors are forwarded unchanged
+/// - closed channels before `total` outputs, out-of-bounds indices, and duplicate indices yield
+///   `Err`
+/// - after the first error, the iterator is exhausted
+///
+/// Callers that intentionally abort workers must stop polling this iterator after initiating
+/// abort. Before `total` outputs are yielded, channel closure is treated as an execution error.
+pub(super) fn ordered_worker_outputs<R>(
+    result_rx: &Receiver<Result<BalWorkerOutput<R>, BalExecutionError>>,
+    total: usize,
+) -> impl Iterator<Item = Result<BalWorkerOutput<R>, BalExecutionError>> + '_ {
+    OrderedWorkerOutputs::new(result_rx, total)
+}
+
+struct OrderedWorkerOutputs<'a, R> {
+    result_rx: &'a Receiver<Result<BalWorkerOutput<R>, BalExecutionError>>,
+    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>, BalExecutionError>>,
+        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>, BalExecutionError>;
+
+    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));
+                }
+                Err(_) => {
+                    self.failed = true;
+                    return Some(Err(BalExecutionError::Evm(BlockExecutionError::msg(
+                        "BAL worker result channel closed while waiting for ordered outputs",
+                    ))));
+                }
+            };
+
+            let index = output.index;
+            if index >= self.total {
+                self.failed = true;
+                return Some(Err(BalExecutionError::Evm(BlockExecutionError::msg(
+                    "BAL worker returned out-of-bounds transaction index",
+                ))));
+            }
+
+            if index < self.next || self.pending[index].is_some() {
+                self.failed = true;
+                return Some(Err(BalExecutionError::Evm(BlockExecutionError::msg(
+                    "BAL worker returned duplicate transaction index",
+                ))));
+            }
+
+            self.pending[index] = Some(output);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    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>, BalExecutionError>, 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(BalExecutionError::Evm(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]
+    fn rejects_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);
+
+        expect_err_contains(outputs.next().expect("first item"), "out-of-bounds");
+        assert!(outputs.next().is_none());
+    }
+
+    #[test]
+    fn rejects_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);
+
+        expect_err_contains(outputs.next().expect("first item"), "duplicate");
+        assert!(outputs.next().is_none());
+    }
+
+    #[test]
+    fn rejects_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);
+        expect_err_contains(outputs.next().expect("second item"), "duplicate");
+        assert!(outputs.next().is_none());
+    }
+}
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..ce24a05da40
--- /dev/null
+++ b/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
@@ -0,0 +1,91 @@
+use super::BalExecutionError;
+use alloy_consensus::Transaction;
+use alloy_evm::{
+    block::{BlockExecutionError, BlockExecutor},
+    Evm,
+};
+use alloy_primitives::Address;
+use crossbeam_channel::{Receiver, Sender};
+use reth_evm::{
+    block::BlockExecutorFactory, execute::ExecutableTxFor, ConfigureEvm, Database, EvmEnvFor,
+    ExecutionCtxFor,
+};
+use revm::database::State;
+use revm_state::bal::Bal as RevmBal;
+use std::sync::Arc;
+
+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>>, BalExecutionError>>;
+
+#[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() -> Result<DB, BalExecutionError> + Sync + 'scope,
+{
+    scope.spawn(move |_| {
+        let worker_result = (|| -> Result<(), BalExecutionError> {
+            let mut worker_state = State::builder()
+                .with_database(make_db()?)
+                .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.block_executor_factory().create_executor(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| BalExecutionError::Evm(BlockExecutionError::other(e)))?;
+                let signer = *tx.signer();
+                let tx_gas_limit = tx.tx().gas_limit();
+
+                executor.evm_mut().db_mut().set_bal_index(index as u64 + 1);
+                let result = executor
+                    .execute_transaction_without_commit(tx)
+                    .map_err(BalExecutionError::Evm)?;
+
+                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/mod.rs b/crates/engine/tree/src/tree/payload_processor/mod.rs
index 2554c5fcce7..174cf49b4f3 100644
--- a/crates/engine/tree/src/tree/payload_processor/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/mod.rs
@@ -44,6 +44,7 @@ use std::{
 };
 use tracing::{debug, debug_span, instrument, trace, warn, Span};
 
+pub mod bal;
 pub mod multiproof;
 mod preserved_sparse_trie;
 pub mod prewarm;
@@ -142,11 +143,10 @@ 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,
 }
 
@@ -183,7 +183,6 @@ 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(),
             disable_bal_parallel_state_root: config.disable_bal_parallel_state_root(),
             disable_bal_batch_io: config.disable_bal_batch_io(),
         }
@@ -292,12 +291,24 @@ where
             halve_workers,
             config,
         );
-        let install_state_hook = env.decoded_bal.is_none();
+        // BAL blocks only bypass the normal execution state hook when the parallel BAL executor
+        // consumes the BAL. If parallel BAL execution is disabled, or if state caching is
+        // disabled so the BAL executor cannot use a shared cache, 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. `disable_bal_batch_io` controls the prefetch half inside
+        // prewarm, not this dispatch decision.
+        let parallel_bal_execution = !config.disable_state_cache() &&
+            !config.disable_bal_parallel_execution() &&
+            env.decoded_bal.is_some();
+        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 {
@@ -324,7 +335,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,
@@ -474,29 +486,36 @@ 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,
@@ -521,17 +540,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);
             });
         }
@@ -814,13 +823,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())
diff --git a/crates/engine/tree/src/tree/payload_processor/prewarm.rs b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
index 04c0671de3f..afad0d9225d 100644
--- a/crates/engine/tree/src/tree/payload_processor/prewarm.rs
+++ b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
@@ -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,
@@ -398,7 +399,7 @@ where
             let _ = stream_tx.send(());
         }
 
-        if ctx.saved_cache.is_some() {
+        if ctx.saved_cache.is_some() && !ctx.disable_bal_batch_io {
             executor.prewarming_pool().spawn(move || {
                 let branch_span = debug_span!(
                     target: "engine::tree::payload_processor::prewarm",
@@ -544,8 +545,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,
 }
 
@@ -669,7 +671,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 +686,17 @@ 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,
+                        self.cache_metrics.clone().unwrap_or_default(),
+                    ))
+                }
+                _ => Box::new(inner),
             };
             *provider = Some(boxed);
         }
diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 3fdd3b6311b..2495a4c5c39 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -50,7 +50,7 @@ use crate::tree::{
 use alloy_consensus::transaction::{Either, TxHashRef};
 use alloy_eip7928::{
     bal::{Bal, DecodedBal},
-    BlockAccessList,
+    compute_block_access_list_hash, BlockAccessList,
 };
 use alloy_eips::{eip1898::BlockWithParent, eip4895::Withdrawal, NumHash};
 use alloy_evm::Evm;
@@ -62,7 +62,9 @@ use crate::tree::payload_processor::receipt_root_task::{IndexedReceipt, ReceiptR
 use reth_chain_state::{
     CanonicalInMemoryState, DeferredTrieData, ExecutedBlock, ExecutionTimingStats, LazyOverlay,
 };
-use reth_consensus::{ConsensusError, FullConsensus, ReceiptRootBloom};
+use reth_consensus::{
+    validate_block_access_list_gas, ConsensusError, FullConsensus, ReceiptRootBloom,
+};
 use reth_engine_primitives::{
     ConfigureEngineEvm, ExecutableTxIterator, ExecutionPayload, InvalidBlockHook, PayloadValidator,
 };
@@ -537,6 +539,11 @@ where
         let overlay_factory =
             OverlayStateProviderFactory::new(provider_factory.clone(), overlay_builder.clone());
 
+        // BAL execute path eligibility. Computed up front because the BAL arm needs a clone of
+        // `provider_builder` (consumed by `spawn_payload_processor` below).
+        let bal_eligible = ensure_ok!(self.bal_path_eligible(env.decoded_bal.as_deref()));
+        let bal_provider_builder = bal_eligible.then(|| provider_builder.clone());
+
         // Spawn the appropriate processor based on strategy
         let mut handle = ensure_ok!(self.spawn_payload_processor(
             env.clone(),
@@ -573,11 +580,30 @@ where
         // The receipt root task is spawned before execution and receives receipts incrementally
         // as transactions complete, allowing parallel computation during execution.
         let execute_block_start = Instant::now();
-        let (output, senders, receipt_root_rx) =
+        let (output, senders, receipt_root_rx, built_bal) = if bal_eligible {
+            let decoded_bal = env.decoded_bal.clone().expect("eligibility implies BAL is present");
+            let built_bal = Some(decoded_bal.as_bal().clone().into());
+            let provider_builder =
+                bal_provider_builder.expect("eligibility implies builder was cloned");
+            match self.execute_block_bal(
+                state_provider,
+                env,
+                &input,
+                &handle,
+                decoded_bal,
+                provider_builder,
+            ) {
+                Ok((output, senders, receipt_root_rx)) => {
+                    (output, senders, receipt_root_rx, built_bal)
+                }
+                Err(err) => return self.handle_execution_error(input, err, &parent_block),
+            }
+        } else {
             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();
 
         // After executing the block we can stop prewarming transactions
@@ -655,6 +681,7 @@ where
                 transaction_root,
                 receipt_root_bloom,
                 hashed_state,
+                built_bal
             ),
             block
         );
@@ -907,7 +934,12 @@ where
         input: &BlockOrPayload<T>,
         handle: &mut PayloadHandle<impl ExecutableTxFor<Evm>, Err, N::Receipt>,
     ) -> Result<
-        (BlockExecutionOutput<N::Receipt>, Vec<Address>, ReceiptRootReceiver),
+        (
+            BlockExecutionOutput<N::Receipt>,
+            Vec<Address>,
+            ReceiptRootReceiver,
+            Option<BlockAccessList>,
+        ),
         InsertBlockErrorKind,
     >
     where
@@ -919,10 +951,21 @@ where
     {
         debug!(target: "engine::tree::payload_validator", "Executing block");
 
+        if let Some(bal_opt) = input.block_access_list() {
+            let bal = bal_opt.map_err(BlockExecutionError::other)?;
+            validate_block_access_list_gas(Some(&bal), input.gas_limit())
+                .map_err(|e| {
+                    debug!(target: "engine::tree::payload_validator", "BAL is invalid since it contains more items than the gas limit allows");
+                    InsertBlockErrorKind::Consensus(e)
+                })?
+        }
+
+        let has_bal = input.block_access_list().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()
         });
 
@@ -972,6 +1015,7 @@ where
             handle.iter_transactions(),
             &receipt_tx,
             &executed_tx_index,
+            has_bal,
         )?;
         drop(receipt_tx);
 
@@ -986,6 +1030,9 @@ where
         debug_span!(target: "engine::tree", "merge_transitions")
             .in_scope(|| db.merge_transitions(BundleRetention::Reverts));
 
+        // Extract the built bal if payload has bal
+        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();
@@ -993,6 +1040,108 @@ 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, built_bal))
+    }
+
+    /// 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_state_cache() &&
+            !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. Adapts the BAL output to a [`BlockExecutionOutput`].
+    #[instrument(level = "debug", target = "engine::tree::payload_validator", skip_all)]
+    #[expect(clippy::type_complexity)]
+    fn execute_block_bal<S, Tx, Err, BalP, T>(
+        &self,
+        _state_provider: S,
+        env: ExecutionEnv<Evm>,
+        input: &BlockOrPayload<T>,
+        handle: &PayloadHandle<Tx, Err, N::Receipt>,
+        decoded_bal: Arc<DecodedBal>,
+        provider_builder: StateProviderBuilder<N, BalP>,
+    ) -> Result<
+        (BlockExecutionOutput<N::Receipt>, Vec<Address>, ReceiptRootReceiver),
+        InsertBlockErrorKind,
+    >
+    where
+        S: StateProvider + Send,
+        Tx: ExecutableTxFor<Evm> + Send,
+        Err: core::error::Error + Send + Sync + 'static,
+        BalP: BlockReader + StateProviderFactory + StateReader + Clone + Send + Sync + 'static,
+        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 cache = handle.caches().ok_or_else(|| {
+            InsertBlockErrorKind::Other("BAL execute path: no execution cache available".into())
+        })?;
+        let cache_metrics = handle.cache_metrics().unwrap_or_default();
+        let saved_cache = SavedCache::new(env.parent_hash, cache);
+
+        let (receipt_tx, result_rx) = self.spawn_receipt_root_task(env.transaction_count);
+
+        let make_db = move || {
+            let provider = provider_builder
+                .build()
+                .map_err(crate::tree::payload_processor::bal::BalExecutionError::Provider)?;
+            Ok(StateProviderDatabase::new(CachedStateProvider::new_prewarm(
+                provider,
+                saved_cache.cache().clone(),
+                cache_metrics.clone(),
+            )))
+        };
+        let execution_start = Instant::now();
+        let ctx =
+            self.execution_ctx_for(input).map_err(|e| InsertBlockErrorKind::Other(Box::new(e)))?;
+        let (output, senders) = crate::tree::payload_processor::bal::execute_block(
+            &self.runtime,
+            &self.evm_config,
+            &make_db,
+            decoded_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))
     }
 
@@ -1020,18 +1169,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);
@@ -1042,6 +1193,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();
@@ -1086,7 +1242,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))
@@ -1369,6 +1530,7 @@ where
         transaction_root: Option<B256>,
         receipt_root_bloom: Option<ReceiptRootBloom>,
         hashed_state: LazyHashedPostState,
+        built_bal: Option<BlockAccessList>,
     ) -> Result<LazyHashedPostState, InsertBlockErrorKind>
     where
         V: PayloadValidator<T, Block = N::Block>,
@@ -1395,9 +1557,15 @@ where
         let _enter =
             debug_span!(target: "engine::tree::payload_validator", "validate_block_post_execution")
                 .entered();
-        if let Err(err) =
-            self.consensus.validate_block_post_execution(block, output, receipt_root_bloom, None)
-        {
+        let block_access_list_hash =
+            built_bal.as_ref().map(|bal| compute_block_access_list_hash(bal));
+
+        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())
diff --git a/crates/ethereum/consensus/src/validation.rs b/crates/ethereum/consensus/src/validation.rs
index 2d44c1cf660..4be126c1bf0 100644
--- a/crates/ethereum/consensus/src/validation.rs
+++ b/crates/ethereum/consensus/src/validation.rs
@@ -86,7 +86,6 @@ where
         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(),
diff --git a/crates/ethereum/evm/src/build.rs b/crates/ethereum/evm/src/build.rs
index 4de9e8361ed..548f3ecbdf0 100644
--- a/crates/ethereum/evm/src/build.rs
+++ b/crates/ethereum/evm/src/build.rs
@@ -47,6 +47,7 @@ where
             transactions,
             output: BlockExecutionResult { receipts, requests, gas_used, blob_gas_used },
             state_root,
+            block_access_list_hash,
             ..
         } = input;
 
@@ -112,8 +113,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 {
diff --git a/crates/ethereum/payload/src/lib.rs b/crates/ethereum/payload/src/lib.rs
index 2d6c2e2d022..34b293800a1 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::{
@@ -446,7 +446,9 @@ 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.
@@ -486,7 +488,9 @@ where
         }));
     }
 
-    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(sealed_block, total_fees, requests, block_access_list)
         // add blob sidecars from the executed txs
         .with_sidecars(blob_sidecars);
 
diff --git a/crates/evm/evm/src/either.rs b/crates/evm/evm/src/either.rs
index 904ce7ebbd6..ff64cf54c58 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_eips::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 eb1c70c3deb..19c148c31f6 100644
--- a/crates/evm/evm/src/execute.rs
+++ b/crates/evm/evm/src/execute.rs
@@ -3,7 +3,10 @@
 use crate::{ConfigureEvm, Database, OnStateHook, TxEnvFor};
 use alloc::{boxed::Box, sync::Arc, vec::Vec};
 use alloy_consensus::{BlockHeader, Header};
-use alloy_eips::eip2718::WithEncoded;
+use alloy_eips::{
+    eip2718::WithEncoded,
+    eip7928::{compute_block_access_list_hash, BlockAccessList},
+};
 pub use alloy_evm::block::{BlockExecutor, BlockExecutorFactory, GasOutput};
 use alloy_evm::{
     block::{CommitChanges, ExecutableTxParts},
@@ -21,7 +24,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.
@@ -145,6 +151,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`].
@@ -162,6 +171,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
 ///
@@ -178,6 +188,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)?;
@@ -205,6 +216,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> {
@@ -222,6 +235,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,
@@ -232,6 +246,7 @@ impl<'a, 'b, F: BlockExecutorFactory, H> BlockAssemblerInput<'a, 'b, F, H> {
             bundle_state,
             state_provider,
             state_root,
+            block_access_list_hash,
         }
     }
 }
@@ -301,6 +316,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.
@@ -453,7 +470,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(
@@ -466,6 +486,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)
@@ -483,6 +504,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));
+
         let hashed_state = state.hashed_post_state(&db.bundle_state);
         let (state_root, trie_updates) = match state_root_precomputed {
             Some(precomputed) => precomputed,
@@ -503,11 +528,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 {
@@ -554,11 +586,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);
 
@@ -592,6 +646,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
@@ -697,6 +755,10 @@ mod tests {
         fn size_hint(&self) -> usize {
             0
         }
+
+        fn take_bal(&mut self) -> Option<BlockAccessList> {
+            None
+        }
     }
 
     #[test]
diff --git a/crates/node/core/src/args/engine.rs b/crates/node/core/src/args/engine.rs
index 382df972b71..ab6536486b3 100644
--- a/crates/node/core/src/args/engine.rs
+++ b/crates/node/core/src/args/engine.rs
@@ -289,7 +289,7 @@ impl Default for DefaultEngineValues {
             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,
         }
     }
@@ -511,13 +511,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,
 
@@ -630,6 +629,10 @@ impl EngineArgs {
             self.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(())
     }
 
@@ -801,6 +804,19 @@ mod tests {
         assert!(err.contains("engine.persistence-threshold"));
     }
 
+    #[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/docs/vocs/docs/pages/cli/reth/node.mdx b/docs/vocs/docs/pages/cli/reth/node.mdx
index 3d30abf8f80..c8674a40fcf 100644
--- a/docs/vocs/docs/pages/cli/reth/node.mdx
+++ b/docs/vocs/docs/pages/cli/reth/node.mdx
@@ -1094,10 +1094,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

From 95ec83ab1f138159bcaa92e299ab97d377b4a92c Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Fri, 8 May 2026 16:19:42 +0200
Subject: [PATCH 072/335] refactor(engine): add validation output type (#24089)

---
 crates/engine/tree/src/tree/mod.rs            | 12 +++----
 .../engine/tree/src/tree/payload_validator.rs | 15 +++------
 crates/engine/tree/src/tree/types.rs          | 31 +++++++++++++++++++
 3 files changed, 40 insertions(+), 18 deletions(-)
 create mode 100644 crates/engine/tree/src/tree/types.rs

diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index c39b20262e9..efdea2db935 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -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;
@@ -74,6 +75,7 @@ pub use reth_execution_cache::{
     CachedStateMetrics, CachedStateMetricsSource, CachedStateProvider, ExecutionCache,
     PayloadExecutionCache, SavedCache,
 };
+pub use types::{ValidationOutcome, ValidationOutput};
 
 pub mod state;
 
@@ -2923,12 +2925,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
@@ -2998,7 +2995,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).
diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 2495a4c5c39..041d37c4e98 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -39,11 +39,12 @@
 //! [`SealedBlock`]: reth_primitives_traits::SealedBlock
 
 use crate::tree::{
-    error::{InsertBlockError, InsertBlockErrorKind, InsertPayloadError},
+    error::{InsertBlockError, InsertBlockErrorKind},
     instrumented_state::{InstrumentedStateProvider, 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,
 };
@@ -106,19 +107,11 @@ use std::{
 };
 use tracing::{debug, debug_span, error, info, instrument, trace, warn, 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<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>,
->;
-
 type ReceiptRootSender<N> =
     crossbeam_channel::Sender<IndexedReceipt<<N as NodePrimitives>::Receipt>>;
 type ReceiptRootReceiver = tokio::sync::oneshot::Receiver<(B256, alloy_primitives::Bloom)>;
@@ -876,7 +869,7 @@ where
             trie_output,
             changeset_provider,
         );
-        Ok((executed_block, timing_stats))
+        Ok(ValidationOutput::new(executed_block, timing_stats))
     }
 
     /// Return sealed block header from database or in-memory state by hash.
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 }
+    }
+}

From e873a930eb7bfdc7bb159f5dec055612d5c5a0ac Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Fri, 8 May 2026 21:19:47 +0200
Subject: [PATCH 073/335] fix(engine): prune BAL store from persistence task
 (#24084)

---
 crates/engine/tree/src/persistence.rs         | 109 ++++++++++++++++--
 .../src/providers/blockchain_provider.rs      |   8 +-
 .../provider/src/providers/database/mod.rs    |  14 ++-
 3 files changed, 117 insertions(+), 14 deletions(-)

diff --git a/crates/engine/tree/src/persistence.rs b/crates/engine/tree/src/persistence.rs
index e526a41c7ee..5ac2d2e1ecf 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)]
@@ -198,7 +198,15 @@ where
             let provider_rw = self.provider.database_provider_rw()?;
             let _ = self.pruner.run_with_provider(&provider_rw, block_number)?;
             provider_rw.commit()?;
-            debug!(target: "engine::persistence", tip=?block_number, "Finished pruning after saving blocks");
+            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());
         }
 
@@ -376,16 +384,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> {
@@ -401,6 +412,90 @@ 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 get_by_range(&self, _start: BlockNumber, _count: u64) -> ProviderResult<Vec<Bytes>> {
+            Ok(Vec::new())
+        }
+
+        fn bal_stream(&self) -> BalNotificationStream {
+            BalStoreHandle::noop().bal_stream()
+        }
+    }
+
     #[test]
     fn test_save_blocks_empty() {
         reth_tracing::init_test_tracing();
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/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;

From 3f7ae3e34976b1bd88338292ce16938b2e897b4d Mon Sep 17 00:00:00 2001
From: Karl Yu <43113774+0xKarl98@users.noreply.github.com>
Date: Sat, 9 May 2026 04:27:27 +0800
Subject: [PATCH 074/335] feat(db): add balstore cache size arg (#24002)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/cli/commands/src/common.rs             | 11 +++++--
 crates/node/builder/src/launch/common.rs      | 17 ++++++++---
 crates/node/core/src/args/database.rs         | 14 +++++++++
 crates/storage/provider/src/bal.rs            | 30 ++++++++++++++++++-
 docs/vocs/docs/pages/cli/reth/db.mdx          |  3 ++
 docs/vocs/docs/pages/cli/reth/db/diff.mdx     |  3 ++
 docs/vocs/docs/pages/cli/reth/download.mdx    |  3 ++
 docs/vocs/docs/pages/cli/reth/export-era.mdx  |  3 ++
 docs/vocs/docs/pages/cli/reth/import-era.mdx  |  3 ++
 docs/vocs/docs/pages/cli/reth/import.mdx      |  3 ++
 docs/vocs/docs/pages/cli/reth/init-state.mdx  |  3 ++
 docs/vocs/docs/pages/cli/reth/init.mdx        |  3 ++
 docs/vocs/docs/pages/cli/reth/node.mdx        |  3 ++
 docs/vocs/docs/pages/cli/reth/prune.mdx       |  3 ++
 docs/vocs/docs/pages/cli/reth/re-execute.mdx  |  3 ++
 docs/vocs/docs/pages/cli/reth/stage/drop.mdx  |  3 ++
 docs/vocs/docs/pages/cli/reth/stage/dump.mdx  |  3 ++
 docs/vocs/docs/pages/cli/reth/stage/run.mdx   |  3 ++
 .../vocs/docs/pages/cli/reth/stage/unwind.mdx |  3 ++
 19 files changed, 110 insertions(+), 7 deletions(-)

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/node/builder/src/launch/common.rs b/crates/node/builder/src/launch/common.rs
index 0afef017616..c963618d25e 100644
--- a/crates/node/builder/src/launch/common.rs
+++ b/crates/node/builder/src/launch/common.rs
@@ -69,9 +69,9 @@ use reth_node_metrics::{
 };
 use reth_provider::{
     providers::{NodeTypesForProvider, ProviderNodeTypes, RocksDBProvider, StaticFileProvider},
-    BlockHashReader, BlockNumReader, ProviderError, ProviderFactory, ProviderResult,
-    RocksDBProviderFactory, StageCheckpointReader, StaticFileProviderBuilder,
-    StaticFileProviderFactory, StorageSettingsCache,
+    BalConfig, BalStoreHandle, BlockHashReader, BlockNumReader, InMemoryBalStore, ProviderError,
+    ProviderFactory, ProviderResult, RocksDBProviderFactory, StageCheckpointReader,
+    StaticFileProviderBuilder, StaticFileProviderFactory, StorageSettingsCache,
 };
 use reth_prune::{PruneModes, PrunerBuilder};
 use reth_rpc_builder::config::RethRpcServerConfig;
@@ -506,6 +506,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(),
@@ -515,7 +523,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
diff --git a/crates/node/core/src/args/database.rs b/crates/node/core/src/args/database.rs
index 81a6aeea6da..ce0cfe7ca8c 100644
--- a/crates/node/core/src/args/database.rs
+++ b/crates/node/core/src/args/database.rs
@@ -67,6 +67,9 @@ 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>,
 }
 
 impl DatabaseArgs {
@@ -442,4 +445,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/storage/provider/src/bal.rs b/crates/storage/provider/src/bal.rs
index 0d593ffcaf5..07f355c2773 100644
--- a/crates/storage/provider/src/bal.rs
+++ b/crates/storage/provider/src/bal.rs
@@ -51,11 +51,19 @@ pub struct BalConfig {
 }
 
 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) }
@@ -64,7 +72,7 @@ impl BalConfig {
 
 impl Default for BalConfig {
     fn default() -> Self {
-        Self::with_in_memory_retention(PruneMode::Distance(BAL_RETENTION_PERIOD_SLOTS))
+        Self::with_in_memory_retention_distance(Self::DEFAULT_IN_MEMORY_RETENTION_DISTANCE)
     }
 }
 
@@ -380,6 +388,26 @@ mod tests {
         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 =
diff --git a/docs/vocs/docs/pages/cli/reth/db.mdx b/docs/vocs/docs/pages/cli/reth/db.mdx
index 7b558671a3b..b4cd2cfb1ca 100644
--- a/docs/vocs/docs/pages/cli/reth/db.mdx
+++ b/docs/vocs/docs/pages/cli/reth/db.mdx
@@ -118,6 +118,9 @@ 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
+
 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..d4a4dc3abfa 100644
--- a/docs/vocs/docs/pages/cli/reth/db/diff.mdx
+++ b/docs/vocs/docs/pages/cli/reth/db/diff.mdx
@@ -67,6 +67,9 @@ 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
+
       --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..4f47697e9d4 100644
--- a/docs/vocs/docs/pages/cli/reth/download.mdx
+++ b/docs/vocs/docs/pages/cli/reth/download.mdx
@@ -97,6 +97,9 @@ 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
+
 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/export-era.mdx b/docs/vocs/docs/pages/cli/reth/export-era.mdx
index 42ec8b264de..84232b6e0c3 100644
--- a/docs/vocs/docs/pages/cli/reth/export-era.mdx
+++ b/docs/vocs/docs/pages/cli/reth/export-era.mdx
@@ -97,6 +97,9 @@ 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
+
 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..e4bcc450965 100644
--- a/docs/vocs/docs/pages/cli/reth/import-era.mdx
+++ b/docs/vocs/docs/pages/cli/reth/import-era.mdx
@@ -97,6 +97,9 @@ 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
+
 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..26952df89f7 100644
--- a/docs/vocs/docs/pages/cli/reth/import.mdx
+++ b/docs/vocs/docs/pages/cli/reth/import.mdx
@@ -97,6 +97,9 @@ 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
+
 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..1350b48b0dc 100644
--- a/docs/vocs/docs/pages/cli/reth/init-state.mdx
+++ b/docs/vocs/docs/pages/cli/reth/init-state.mdx
@@ -97,6 +97,9 @@ 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
+
 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..cdca695d468 100644
--- a/docs/vocs/docs/pages/cli/reth/init.mdx
+++ b/docs/vocs/docs/pages/cli/reth/init.mdx
@@ -97,6 +97,9 @@ 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
+
 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 c8674a40fcf..9255cb8998c 100644
--- a/docs/vocs/docs/pages/cli/reth/node.mdx
+++ b/docs/vocs/docs/pages/cli/reth/node.mdx
@@ -846,6 +846,9 @@ 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
+
 Dev testnet:
       --dev
           Start the node in dev mode
diff --git a/docs/vocs/docs/pages/cli/reth/prune.mdx b/docs/vocs/docs/pages/cli/reth/prune.mdx
index 4e826ef2bc0..5a729e2bf6a 100644
--- a/docs/vocs/docs/pages/cli/reth/prune.mdx
+++ b/docs/vocs/docs/pages/cli/reth/prune.mdx
@@ -97,6 +97,9 @@ 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
+
 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..f1126ad1045 100644
--- a/docs/vocs/docs/pages/cli/reth/re-execute.mdx
+++ b/docs/vocs/docs/pages/cli/reth/re-execute.mdx
@@ -97,6 +97,9 @@ 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
+
 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..715ee03a6b0 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/drop.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/drop.mdx
@@ -97,6 +97,9 @@ 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
+
 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..3b95b4eb440 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/dump.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/dump.mdx
@@ -104,6 +104,9 @@ 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
+
 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 8d4e7411e68..87dd3230b35 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/run.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/run.mdx
@@ -97,6 +97,9 @@ 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
+
 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/unwind.mdx b/docs/vocs/docs/pages/cli/reth/stage/unwind.mdx
index 830766788e5..75130dbd604 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/unwind.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/unwind.mdx
@@ -102,6 +102,9 @@ 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
+
 Static Files:
       --static-files.blocks-per-file.headers <BLOCKS_PER_FILE_HEADERS>
           Number of blocks per file for the headers segment

From deb1526d484a7dcea2a0529423fb2356ca1a9591 Mon Sep 17 00:00:00 2001
From: Karl Yu <43113774+0xKarl98@users.noreply.github.com>
Date: Sat, 9 May 2026 04:46:14 +0800
Subject: [PATCH 075/335] feat(net): make full block BAL lookup optional
 (#24074)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 Cargo.lock                       |   1 +
 crates/net/p2p/Cargo.toml        |   2 +
 crates/net/p2p/src/full_block.rs | 306 ++++++++++++++++++++++---------
 3 files changed, 222 insertions(+), 87 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a821463c344..78b2cd10b2f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9082,6 +9082,7 @@ name = "reth-network-p2p"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
+ "alloy-eip7928",
  "alloy-eips 2.0.4",
  "alloy-primitives",
  "auto_impl",
diff --git a/crates/net/p2p/Cargo.toml b/crates/net/p2p/Cargo.toml
index d6a5978932e..7098642e27c 100644
--- a/crates/net/p2p/Cargo.toml
+++ b/crates/net/p2p/Cargo.toml
@@ -23,6 +23,7 @@ reth-storage-errors.workspace = true
 
 # ethereum
 alloy-consensus.workspace = true
+alloy-eip7928.workspace = true
 alloy-eips.workspace = true
 alloy-primitives = { workspace = true, features = ["rand"] }
 
@@ -55,6 +56,7 @@ test-utils = [
 std = [
     "reth-consensus/std",
     "reth-ethereum-primitives/std",
+    "alloy-eip7928/std",
     "alloy-eips/std",
     "alloy-primitives/std",
     "reth-primitives-traits/std",
diff --git a/crates/net/p2p/src/full_block.rs b/crates/net/p2p/src/full_block.rs
index 22055d6bf62..23e8ddfcd34 100644
--- a/crates/net/p2p/src/full_block.rs
+++ b/crates/net/p2p/src/full_block.rs
@@ -9,6 +9,7 @@ use crate::{
     BlockClient,
 };
 use alloy_consensus::BlockHeader;
+use alloy_eip7928::bal::Bal;
 use alloy_primitives::{Sealable, B256};
 use core::marker::PhantomData;
 use futures::FutureExt;
@@ -17,7 +18,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},
@@ -34,6 +35,53 @@ use tracing::debug;
 pub type FullBlockRangeWithOptionalAccessListsResponse<B> =
     (Vec<SealedBlock<B>>, Option<BlockAccessLists>);
 
+/// A sealed block with associated data.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SealedBlockWith<B: Block, T = Option<Bal>> {
+    block: SealedBlock<B>,
+    data: T,
+}
+
+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> SealedBlockWith<B, Option<BlockAccessLists>> {
+    /// 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.
+    pub const fn access_lists(&self) -> Option<&BlockAccessLists> {
+        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)]
 pub struct FullBlockClient<Client>
@@ -109,8 +157,8 @@ 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 [`BlockAccessLists`]
+    /// for the given hash.
     ///
     /// Note: this future is cancel safe
     ///
@@ -119,12 +167,15 @@ where
     pub fn get_full_block_with_access_lists(
         &self,
         hash: B256,
-    ) -> FetchFullBlockWithAccessListsFuture<Client> {
+    ) -> 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], BalRequirement::Optional),
+            ),
         }
     }
 
@@ -305,12 +356,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,
 {
@@ -319,7 +370,7 @@ where
     bal_request_state: BalRequestState<<Client as BlockAccessListsClient>::Output>,
 }
 
-impl<Client> FetchFullBlockWithAccessListsFuture<Client>
+impl<Client> FetchFullBlockWithBalFuture<Client>
 where
     Client: BlockClient<Header: BlockHeader> + BlockAccessListsClient,
 {
@@ -329,7 +380,7 @@ where
     }
 }
 
-impl<Client> FetchFullBlockWithAccessListsFuture<Client>
+impl<Client> FetchFullBlockWithBalFuture<Client>
 where
     Client: BlockClient<Header: BlockHeader + Sealable> + BlockAccessListsClient + 'static,
 {
@@ -338,77 +389,69 @@ 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 => self.bal_request_state = BalRequestState::Ready(Some(access_lists)),
+                    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);
             }
         }
+
+        Poll::Ready(())
     }
 
+    /// 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<(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))
-        }
-
-        None
+    ) -> Option<SealedBlockWith<Client::Block, Option<BlockAccessLists>>> {
+        let BalRequestState::Ready(access_lists) = &mut self.bal_request_state else { return None };
+        let block = self.block_result.take()?;
+        Some(SealedBlockWith::new(block, access_lists.take()))
     }
 }
 
-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 = SealedBlockWith<Client::Block, Option<BlockAccessLists>>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
@@ -419,7 +462,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)
@@ -429,12 +472,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())
@@ -445,7 +488,7 @@ where
 /// Tracks the BAL request and its completed result.
 enum BalRequestState<Req> {
     Pending(Req),
-    Ready(BlockAccessLists),
+    Ready(Option<BlockAccessLists>),
 }
 
 impl<Req> BalRequestState<Req> {
@@ -1140,16 +1183,38 @@ mod tests {
         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;
+
+        assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
+        assert_eq!(received.access_lists(), Some(&BlockAccessLists(vec![access_list])));
+        assert_eq!(request_count.load(Ordering::SeqCst), 1);
+    }
+
+    #[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]);
+        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");
 
-        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_lists(), Some(&BlockAccessLists(vec![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_returns_none_after_empty_response() {
         let client = FullBlockWithAccessListsClient::default();
         client.empty_first_response.store(true, Ordering::SeqCst);
 
@@ -1162,15 +1227,44 @@ mod tests {
         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!(bad_messages.load(Ordering::SeqCst), 1);
+        assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
+        assert!(received.access_lists().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 header: SealedHeader = SealedHeader::default();
+        let body = BlockBody::default();
+        let access_list = Bytes::from_static(&[EMPTY_LIST_CODE]);
+        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_lists().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.
@@ -1200,8 +1294,10 @@ mod tests {
         access_lists: Arc<Mutex<HashMap<B256, 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>,
     }
@@ -1213,8 +1309,10 @@ mod tests {
                 access_lists: Arc::new(Mutex::new(HashMap::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)),
             }
@@ -1231,6 +1329,10 @@ mod tests {
             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);
         }
@@ -1299,26 +1401,56 @@ 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 futures::future::ready(Err(RequestError::UnsupportedCapability))
+                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 mut access_lists: Vec<_> = hashes
@@ -1336,10 +1468,10 @@ mod tests {
                 access_lists.push(Bytes::from_static(&[EMPTY_LIST_CODE]));
             }
 
-            futures::future::ready(Ok(WithPeerId::new(
-                PeerId::random(),
-                BlockAccessLists(access_lists),
-            )))
+            MaybePendingAccessLists::new(
+                Ok(WithPeerId::new(PeerId::random(), BlockAccessLists(access_lists))),
+                pending_polls,
+            )
         }
     }
 

From 145fc7899fc233a6ce8eba26955749973ca2b9e7 Mon Sep 17 00:00:00 2001
From: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
Date: Sun, 10 May 2026 20:53:41 +0530
Subject: [PATCH 076/335] chore: added NewPooledTransactionHashes72 for eth/72
 (#24101)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/eth-wire-types/src/broadcast.rs | 211 ++++++++++++++++++++-
 1 file changed, 210 insertions(+), 1 deletion(-)

diff --git a/crates/net/eth-wire-types/src/broadcast.rs b/crates/net/eth-wire-types/src/broadcast.rs
index 56d5ad347ec..07a3a3a97bc 100644
--- a/crates/net/eth-wire-types/src/broadcast.rs
+++ b/crates/net/eth-wire-types/src/broadcast.rs
@@ -4,7 +4,7 @@ use crate::{EthMessage, EthVersion, NetworkPrimitives};
 use alloc::{sync::Arc, vec::Vec};
 use alloy_primitives::{
     map::{HashMap, HashSet},
-    Bytes, TxHash, B256, U128,
+    Bytes, TxHash, B128, B256, U128,
 };
 use alloy_rlp::{
     Decodable, Encodable, Header, RlpDecodable, RlpDecodableWrapper, RlpEncodable,
@@ -584,6 +584,178 @@ impl Decodable for NewPooledTransactionHashes68 {
     }
 }
 
+/// Same as [`NewPooledTransactionHashes68`] but adds cell mask of B128.
+#[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 mask for new transactions that have appeared on the network.
+    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.
@@ -1077,6 +1249,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(

From 5fa1f450019c7364cca35ba32ba4c32c535b26e2 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Sun, 10 May 2026 23:04:44 +0200
Subject: [PATCH 077/335] fix(payload): avoid tx pool for empty payloads
 (#24103)

---
 crates/ethereum/payload/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/ethereum/payload/src/lib.rs b/crates/ethereum/payload/src/lib.rs
index 34b293800a1..3d8ad02127d 100644
--- a/crates/ethereum/payload/src/lib.rs
+++ b/crates/ethereum/payload/src/lib.rs
@@ -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)

From f9c39fc0136965d2407a1318a8bc06d88967d2b7 Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Mon, 11 May 2026 03:17:43 +0530
Subject: [PATCH 078/335] chore: add get_cell fn in BlobStore trait (#24098)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/transaction-pool/src/blobstore/disk.rs | 39 ++++++++++++++++++-
 crates/transaction-pool/src/blobstore/mem.rs  | 39 ++++++++++++++++++-
 crates/transaction-pool/src/blobstore/mod.rs  | 30 +++++++++++++-
 crates/transaction-pool/src/blobstore/noop.rs | 13 ++++++-
 4 files changed, 115 insertions(+), 6 deletions(-)

diff --git a/crates/transaction-pool/src/blobstore/disk.rs b/crates/transaction-pool/src/blobstore/disk.rs
index 3b6df2af971..d061f5de98d 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,43 @@ 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);
+        };
+
+        let versioned_hashes = sidecar.versioned_hashes().collect::<Vec<_>>();
+
+        let matches =
+            self.get_by_versioned_hashes_cells_eip7594(&versioned_hashes, indices_bitarray)?;
+
+        let mut cells = Vec::new();
+
+        for matched in matches {
+            let Some(matched) = matched else {
+                return Ok(None);
+            };
+
+            for cell in matched.blob_cells {
+                let Some(cell) = cell else {
+                    return Ok(None);
+                };
+
+                cells.push(cell);
+            }
+        }
+
+        Ok(Some(cells))
+    }
+
     fn data_size_hint(&self) -> Option<usize> {
         Some(self.inner.size_tracker.data_size())
     }
diff --git a/crates/transaction-pool/src/blobstore/mem.rs b/crates/transaction-pool/src/blobstore/mem.rs
index a7a98a574f2..35642e363c5 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;
@@ -225,6 +225,43 @@ 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);
+        };
+
+        let versioned_hashes = sidecar.versioned_hashes().collect::<Vec<_>>();
+
+        let matches =
+            self.get_by_versioned_hashes_cells_eip7594(&versioned_hashes, indices_bitarray)?;
+
+        let mut cells = Vec::new();
+
+        for matched in matches {
+            let Some(matched) = matched else {
+                return Ok(None);
+            };
+
+            for cell in matched.blob_cells {
+                let Some(cell) = cell else {
+                    return Ok(None);
+                };
+
+                cells.push(cell);
+            }
+        }
+
+        Ok(Some(cells))
+    }
+
     fn data_size_hint(&self) -> Option<usize> {
         Some(self.inner.size_tracker.data_size())
     }
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)
     }

From d3af3801429b015a0fba0cfb4515a84abac5c352 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 11 May 2026 09:36:13 +0200
Subject: [PATCH 079/335] feat(net): default BAL requests to optional (#24095)

---
 crates/net/network/src/fetch/client.rs        |  13 --
 crates/net/network/tests/it/requests.rs       |  11 +-
 .../net/p2p/src/block_access_lists/client.rs  |   6 +-
 crates/net/p2p/src/full_block.rs              | 193 ++++++++++++++----
 4 files changed, 163 insertions(+), 60 deletions(-)

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/tests/it/requests.rs b/crates/net/network/tests/it/requests.rs
index a209537c9af..19cd8c354c1 100644
--- a/crates/net/network/tests/it/requests.rs
+++ b/crates/net/network/tests/it/requests.rs
@@ -17,7 +17,7 @@ use reth_network_p2p::{
     bodies::client::BodiesClient,
     error::RequestError,
     headers::client::{HeadersClient, HeadersRequest},
-    BalRequirement, BlockAccessListsClient,
+    BlockAccessListsClient,
 };
 use reth_provider::{test_utils::MockEthProvider, BalStoreHandle, InMemoryBalStore, SealedBal};
 use reth_transaction_pool::test_utils::{TestPool, TransactionGenerator};
@@ -649,17 +649,14 @@ async fn test_eth71_fetch_client_get_block_access_lists() {
     );
 }
 
-// Ensures fetch client BAL requests are rejected when no eth/71 peer is available.
+// 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_optional_block_access_lists_request() {
+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);
 }
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 23e8ddfcd34..0feadb984f6 100644
--- a/crates/net/p2p/src/full_block.rs
+++ b/crates/net/p2p/src/full_block.rs
@@ -31,10 +31,6 @@ use std::{
 };
 use tracing::debug;
 
-/// Response returned by [`FetchFullBlockRangeWithOptionalAccessListsFuture`].
-pub type FullBlockRangeWithOptionalAccessListsResponse<B> =
-    (Vec<SealedBlock<B>>, Option<BlockAccessLists>);
-
 /// A sealed block with associated data.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SealedBlockWith<B: Block, T = Option<Bal>> {
@@ -167,14 +163,28 @@ where
     pub fn get_full_block_with_access_lists(
         &self,
         hash: B256,
+    ) -> FetchFullBlockWithBalFuture<Client> {
+        self.get_full_block_with_access_lists_with_requirement(hash, BalRequirement::default())
+    }
+
+    /// Returns a future that fetches the [`SealedBlock`] and optionally its [`BlockAccessLists`]
+    /// 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();
         FetchFullBlockWithBalFuture {
             block: FetchFullBlockFuture::new(client.clone(), self.consensus.clone(), hash),
             block_result: None,
             bal_request_state: BalRequestState::Pending(
-                client
-                    .get_block_access_lists_with_requirement(vec![hash], BalRequirement::Optional),
+                client.get_block_access_lists_with_requirement(vec![hash], requirement),
             ),
         }
     }
@@ -183,19 +193,38 @@ where
     /// the given hash and count.
     ///
     /// The block range is always the primary result. Access lists are requested after the block
-    /// range is downloaded. `Some` may contain a partial prefix when the peer truncates the BAL
-    /// response, while `None` means the optional BAL lookup failed or was unavailable.
+    /// 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,
-    ) -> FetchFullBlockRangeWithOptionalAccessListsFuture<Client> {
+    ) -> 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 [`BlockAccessLists`] 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();
-        FetchFullBlockRangeWithOptionalAccessListsFuture {
+        FetchFullBlockRangeWithBalFuture {
             blocks: self.get_full_block_range(hash, count),
             client,
             block_result: None,
-            access_lists: OptionalBlockAccessListsState::WaitingForBlocks,
+            access_lists: OptionalBlockAccessListsState::WaitingForBlocks { requirement },
         }
     }
 }
@@ -505,7 +534,7 @@ impl<Req> BalRequestState<Req> {
 /// [`FetchFullBlockRangeFuture`].
 #[must_use = "futures do nothing unless polled"]
 #[expect(missing_debug_implementations)]
-pub struct FetchFullBlockRangeWithOptionalAccessListsFuture<Client>
+pub struct FetchFullBlockRangeWithBalFuture<Client>
 where
     Client: BlockClient + BlockAccessListsClient,
 {
@@ -515,21 +544,24 @@ where
     access_lists: OptionalBlockAccessListsState<<Client as BlockAccessListsClient>::Output>,
 }
 
-impl<Client> FetchFullBlockRangeWithOptionalAccessListsFuture<Client>
+impl<Client> FetchFullBlockRangeWithBalFuture<Client>
 where
     Client: BlockClient<Header: Debug + BlockHeader + Sealable + Clone + Hash + Eq>
         + BlockAccessListsClient,
 {
     fn start_access_lists_request_if_possible(&mut self) {
-        if !matches!(self.access_lists, OptionalBlockAccessListsState::WaitingForBlocks) {
-            return
-        }
+        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, BalRequirement::Optional),
+            self.client.get_block_access_lists_with_requirement(hashes, requirement),
         );
     }
 
@@ -563,7 +595,7 @@ where
 
         let poll = match &mut self.access_lists {
             OptionalBlockAccessListsState::Pending(fut) => fut.poll_unpin(cx),
-            OptionalBlockAccessListsState::WaitingForBlocks |
+            OptionalBlockAccessListsState::WaitingForBlocks { .. } |
             OptionalBlockAccessListsState::Ready(_) => return,
         };
 
@@ -588,23 +620,37 @@ where
     /// Returns the block range once blocks and the optional BAL lookup are both complete.
     fn take_response(
         &mut self,
-    ) -> Option<FullBlockRangeWithOptionalAccessListsResponse<Client::Block>> {
+    ) -> Option<Vec<SealedBlockWith<Client::Block, Option<BlockAccessLists>>>> {
         let OptionalBlockAccessListsState::Ready(access_lists) = &mut self.access_lists else {
             return None
         };
 
         let blocks = self.block_result.take()?;
-        Some((blocks, access_lists.take()))
+        let mut access_lists = access_lists.take().map(|access_lists| access_lists.0.into_iter());
+
+        Some(
+            blocks
+                .into_iter()
+                .map(|block| {
+                    let access_lists = access_lists
+                        .as_mut()
+                        .and_then(|access_lists| access_lists.next())
+                        .map(|access_list| BlockAccessLists(vec![access_list]));
+
+                    SealedBlockWith::new(block, access_lists)
+                })
+                .collect(),
+        )
     }
 }
 
-impl<Client> Future for FetchFullBlockRangeWithOptionalAccessListsFuture<Client>
+impl<Client> Future for FetchFullBlockRangeWithBalFuture<Client>
 where
     Client: BlockClient<Header: Debug + BlockHeader + Sealable + Clone + Hash + Eq>
         + BlockAccessListsClient
         + 'static,
 {
-    type Output = FullBlockRangeWithOptionalAccessListsResponse<Client::Block>;
+    type Output = Vec<SealedBlockWith<Client::Block, Option<BlockAccessLists>>>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
@@ -629,7 +675,10 @@ where
 /// Tracks an optional BAL range request and its completed result.
 enum OptionalBlockAccessListsState<Req> {
     /// The block hashes needed for `GetBlockAccessLists` are not known yet.
-    WaitingForBlocks,
+    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.
@@ -1147,6 +1196,12 @@ mod tests {
     // RLP encoding for an empty list.
     const EMPTY_LIST_CODE: u8 = 0xc0;
 
+    fn range_access_lists<B: Block>(
+        blocks: &[SealedBlockWith<B, Option<BlockAccessLists>>],
+    ) -> Vec<Option<BlockAccessLists>> {
+        blocks.iter().map(|block| block.access_lists().cloned()).collect()
+    }
+
     #[tokio::test]
     async fn download_single_full_block() {
         let client = TestFullBlockClient::default();
@@ -1190,6 +1245,29 @@ mod tests {
         assert_eq!(request_count.load(Ordering::SeqCst), 1);
     }
 
+    #[tokio::test]
+    async fn download_single_full_block_with_access_lists_uses_requested_requirement() {
+        let client = FullBlockWithAccessListsClient::default();
+        let header: SealedHeader = SealedHeader::default();
+        let body = BlockBody::default();
+        let access_list = Bytes::from_static(&[EMPTY_LIST_CODE]);
+        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;
+
+        assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
+        assert_eq!(received.access_lists(), Some(&BlockAccessLists(vec![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();
@@ -1601,6 +1679,7 @@ mod tests {
 
         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(
@@ -1610,21 +1689,28 @@ mod tests {
         .await
         .expect("range request should complete");
 
-        let (blocks, received_access_lists) = response;
+        let blocks = response;
         assert_eq!(blocks.len(), 3);
         let expected = {
             let access_lists = access_lists.lock();
             blocks
                 .iter()
-                .map(|block| access_lists.get(&block.hash()).cloned().expect("access list exists"))
+                .map(|block| {
+                    let access_list = access_lists
+                        .get(&block.block().hash())
+                        .cloned()
+                        .expect("access list exists");
+                    Some(BlockAccessLists(vec![access_list]))
+                })
                 .collect::<Vec<_>>()
         };
-        assert_eq!(received_access_lists, Some(BlockAccessLists(expected)));
+        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_preserves_empty_response() {
+    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);
@@ -1639,12 +1725,35 @@ mod tests {
         .await
         .expect("range request should complete without access lists");
 
-        let (blocks, received_access_lists) = response;
+        let blocks = response;
         assert_eq!(blocks.len(), 3);
-        assert_eq!(received_access_lists, Some(BlockAccessLists(Vec::new())));
+        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();
@@ -1655,7 +1764,7 @@ mod tests {
         let request_count = Arc::clone(&client.access_list_requests);
         let client = FullBlockClient::test_client(client);
 
-        let (blocks, received_access_lists) = timeout(
+        let blocks = timeout(
             Duration::from_secs(1),
             client.get_full_block_range_with_optional_access_lists(header.hash(), 5),
         )
@@ -1667,11 +1776,21 @@ mod tests {
             let access_lists = access_lists.lock();
             blocks
                 .iter()
-                .take(2)
-                .map(|block| access_lists.get(&block.hash()).cloned().expect("access list exists"))
+                .enumerate()
+                .map(|(idx, block)| {
+                    if idx >= 2 {
+                        return None
+                    }
+
+                    let access_list = access_lists
+                        .get(&block.block().hash())
+                        .cloned()
+                        .expect("access list exists");
+                    Some(BlockAccessLists(vec![access_list]))
+                })
                 .collect::<Vec<_>>()
         };
-        assert_eq!(received_access_lists, Some(BlockAccessLists(expected)));
+        assert_eq!(range_access_lists(&blocks), expected);
         assert_eq!(request_count.load(Ordering::SeqCst), 1);
     }
 
@@ -1684,7 +1803,7 @@ mod tests {
         let request_count = Arc::clone(&client.access_list_requests);
         let client = FullBlockClient::test_client(client);
 
-        let (blocks, received_access_lists) = timeout(
+        let blocks = timeout(
             Duration::from_secs(1),
             client.get_full_block_range_with_optional_access_lists(header.hash(), 3),
         )
@@ -1692,7 +1811,7 @@ mod tests {
         .expect("range request should complete without access lists");
 
         assert_eq!(blocks.len(), 3);
-        assert!(received_access_lists.is_none());
+        assert_eq!(range_access_lists(&blocks), vec![None; blocks.len()]);
         assert_eq!(request_count.load(Ordering::SeqCst), 1);
     }
 
@@ -1706,7 +1825,7 @@ mod tests {
         let bad_messages = Arc::clone(&client.bad_messages);
         let client = FullBlockClient::test_client(client);
 
-        let (blocks, received_access_lists) = timeout(
+        let blocks = timeout(
             Duration::from_secs(1),
             client.get_full_block_range_with_optional_access_lists(header.hash(), 3),
         )
@@ -1714,7 +1833,7 @@ mod tests {
         .expect("range request should complete without access lists");
 
         assert_eq!(blocks.len(), 3);
-        assert!(received_access_lists.is_none());
+        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), 1);
     }

From 15cdd606b43f49f065437c5d533dbd809d8cf631 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 11 May 2026 10:04:40 +0200
Subject: [PATCH 080/335] fix(engine): flush BAL store after saving blocks
 (#24087)

---
 crates/engine/tree/src/persistence.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/crates/engine/tree/src/persistence.rs b/crates/engine/tree/src/persistence.rs
index 5ac2d2e1ecf..e9b1c0fb1e0 100644
--- a/crates/engine/tree/src/persistence.rs
+++ b/crates/engine/tree/src/persistence.rs
@@ -179,6 +179,9 @@ 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");
         }
 

From d2212eca1e4dc2b1f08090767e2b78e2bf50bf12 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Mon, 11 May 2026 02:17:24 -0700
Subject: [PATCH 081/335] fix(mdbx): disable posix_fallocate to fix ENOSPC on
 ZFS (#24108)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 crates/storage/libmdbx-rs/mdbx-sys/build.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/crates/storage/libmdbx-rs/mdbx-sys/build.rs b/crates/storage/libmdbx-rs/mdbx-sys/build.rs
index d3d3234e1bc..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)]

From 0e4ba0aeb2e99630ccf5a9ff87181800c2b7767f Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Mon, 11 May 2026 02:24:58 -0700
Subject: [PATCH 082/335] ci(bench): require PR author to be an org member
 (#24115)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/workflows/bench.yml | 87 +++++++++++++++++++++----------------
 1 file changed, 49 insertions(+), 38 deletions(-)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 96e37c693e9..3c33916db4a 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -135,6 +135,8 @@ jobs:
       node-bin: ${{ steps.args.outputs.node-bin }}
       driver-reason: ${{ steps.args.outputs.driver-reason }}
       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 }}
     steps:
       - name: Check org membership
         if: github.event_name == 'issue_comment'
@@ -142,17 +144,30 @@ jobs:
         with:
           github-token: ${{ secrets.GITHUB_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 checkMembership = async (username) => {
+              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
@@ -356,17 +371,17 @@ jobs:
             // 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);
+              if (!featureName) featureName = prData.head.ref;
+            } else {
+              if (!featureName) featureName = '${{ github.ref_name }}';
             }
 
             const fallbackReasons = [];
@@ -587,6 +602,8 @@ jobs:
       RETH_SCOPE: reth-bench.scope
       BENCH_WORK_DIR: ${{ github.workspace }}/bench-work
       BENCH_PR: ${{ needs.reth-bench-ack.outputs.pr }}
+      BENCH_PR_HEAD_SHA: ${{ needs.reth-bench-ack.outputs.pr-head-sha }}
+      BENCH_PR_HEAD_REF: ${{ needs.reth-bench-ack.outputs.pr-head-ref }}
       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 }}
@@ -623,16 +640,13 @@ jobs:
               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;
+            }
+            core.info(`PR #${process.env.BENCH_PR}, using pinned head SHA ${sha}`);
+            core.setOutput('ref', sha);
 
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
@@ -768,13 +782,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 }}');

From 146d73f1be596695e92d70868f137e5dcaf7ebe0 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 11 May 2026 11:45:40 +0200
Subject: [PATCH 083/335] fix(engine): validate BAL gas limit without
 redecoding (#24109)

---
 crates/consensus/consensus/src/lib.rs         | 28 ++++++-----------
 .../engine/tree/src/tree/payload_validator.rs | 30 +++++--------------
 2 files changed, 17 insertions(+), 41 deletions(-)

diff --git a/crates/consensus/consensus/src/lib.rs b/crates/consensus/consensus/src/lib.rs
index 531c500e38a..58070efad8b 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};
 
@@ -476,8 +477,8 @@ pub enum ConsensusError {
     #[error(transparent)]
     TransactionGasLimitTooHigh(Box<TxGasLimitTooHighErr>),
     /// Error when an unexpected block access list cost is encountered.
-    #[error("block access list cost exceeds gas limit")]
-    BlockAccessListCostMoreThanGasLimit,
+    #[error(transparent)]
+    BlockAccessListCostMoreThanGasLimit(Box<BlockAccessListGasError>),
     /// Error when the block access list hash doesn't match the expected value.
     #[error("block access list hash mismatch: {0}")]
     BlockAccessListHashMismatch(GotExpectedBoxed<B256>),
@@ -526,23 +527,6 @@ impl ConsensusError {
     }
 }
 
-/// Validates the block access list against the gas limit.
-///
-/// EIP-7925 specifies that the total cost of the block access list items must not exceed
-/// the gas limit. Each item costs `ITEM_COST` gas.
-pub fn validate_block_access_list_gas(
-    block_access_list: Option<&alloy_eip7928::BlockAccessList>,
-    gas_limit: u64,
-) -> Result<(), ConsensusError> {
-    if let Some(bal) = block_access_list {
-        let bal_items = alloy_eip7928::total_bal_items(bal);
-        if bal_items > gas_limit / alloy_eip7928::ITEM_COST as u64 {
-            return Err(ConsensusError::BlockAccessListCostMoreThanGasLimit)
-        }
-    }
-    Ok(())
-}
-
 impl From<InvalidTransactionError> for ConsensusError {
     fn from(value: InvalidTransactionError) -> Self {
         Self::InvalidTransaction(value)
@@ -555,6 +539,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/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 041d37c4e98..67b886075a4 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -49,10 +49,7 @@ use crate::tree::{
     PayloadHandle, StateProviderBuilder, StateProviderDatabase, TreeConfig, WaitForCaches,
 };
 use alloy_consensus::transaction::{Either, TxHashRef};
-use alloy_eip7928::{
-    bal::{Bal, DecodedBal},
-    compute_block_access_list_hash, 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};
@@ -63,9 +60,7 @@ use crate::tree::payload_processor::receipt_root_task::{IndexedReceipt, ReceiptR
 use reth_chain_state::{
     CanonicalInMemoryState, DeferredTrieData, ExecutedBlock, ExecutionTimingStats, LazyOverlay,
 };
-use reth_consensus::{
-    validate_block_access_list_gas, ConsensusError, FullConsensus, ReceiptRootBloom,
-};
+use reth_consensus::{ConsensusError, FullConsensus, ReceiptRootBloom};
 use reth_engine_primitives::{
     ConfigureEngineEvm, ExecutableTxIterator, ExecutionPayload, InvalidBlockHook, PayloadValidator,
 };
@@ -944,16 +939,17 @@ where
     {
         debug!(target: "engine::tree::payload_validator", "Executing block");
 
-        if let Some(bal_opt) = input.block_access_list() {
-            let bal = bal_opt.map_err(BlockExecutionError::other)?;
-            validate_block_access_list_gas(Some(&bal), input.gas_limit())
+        if let Some(decoded_bal) = &env.decoded_bal {
+            decoded_bal
+                .as_bal()
+                .validate_gas_limit(input.gas_limit())
                 .map_err(|e| {
                     debug!(target: "engine::tree::payload_validator", "BAL is invalid since it contains more items than the gas limit allows");
-                    InsertBlockErrorKind::Consensus(e)
+                    InsertBlockErrorKind::Consensus(ConsensusError::from(e))
                 })?
         }
 
-        let has_bal = input.block_access_list().is_some();
+        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))
@@ -2291,16 +2287,6 @@ 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 the decoded block access list, if present and successfully decoded.
     pub fn try_decoded_access_list(&self) -> Result<Option<DecodedBal>, alloy_rlp::Error> {
         match self {

From 12f167c045e8bed3272eece2aa17c5a6f5862427 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 11 May 2026 12:20:27 +0200
Subject: [PATCH 084/335] refactor(bal): use native BAL diff diagnostics
 (#24118)

---
 Cargo.lock                                    |   4 +-
 Cargo.toml                                    |   2 +-
 .../src/tree/payload_processor/bal/debug.rs   | 297 ------------------
 .../src/tree/payload_processor/bal/execute.rs |   8 +-
 .../src/tree/payload_processor/bal/mod.rs     |   1 -
 5 files changed, 6 insertions(+), 306 deletions(-)
 delete mode 100644 crates/engine/tree/src/tree/payload_processor/bal/debug.rs

diff --git a/Cargo.lock b/Cargo.lock
index 78b2cd10b2f..79506998d4c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -250,9 +250,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-eip7928"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72bc95fd73591644f0022065bef3c027d1a5ed875a53cb19a898d71a00818c1d"
+checksum = "6b827a6d7784fe3eb3489d40699407a4cdcce74271421a01bdffe60cf573bb16"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
diff --git a/Cargo.toml b/Cargo.toml
index d86314f39be..379d32c24bc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -449,7 +449,7 @@ alloy-sol-types = { version = "1.5.6", default-features = false }
 
 alloy-chains = { version = "0.2.33", default-features = false }
 alloy-eip2124 = { version = "0.2.0", default-features = false }
-alloy-eip7928 = { version = "0.3.6", default-features = false }
+alloy-eip7928 = { version = "0.3.7", 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-trie = { version = "0.9.4", default-features = false }
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/debug.rs b/crates/engine/tree/src/tree/payload_processor/bal/debug.rs
deleted file mode 100644
index 43506c02b79..00000000000
--- a/crates/engine/tree/src/tree/payload_processor/bal/debug.rs
+++ /dev/null
@@ -1,297 +0,0 @@
-//! BAL divergence diagnostics.
-
-use alloy_eip7928::AccountChanges;
-use alloy_primitives::Address;
-
-/// Compact summary of where two BALs first diverge.
-#[derive(Debug, PartialEq, Eq)]
-pub(super) struct BalDivergence {
-    received_accounts: usize,
-    rebuilt_accounts: usize,
-    first_diff: Option<AccountDivergence>,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-struct AccountDivergence {
-    index: usize,
-    received: Option<AccountSummary>,
-    rebuilt: Option<AccountSummary>,
-    fields_differ: AccountFieldFlags,
-}
-
-impl AccountDivergence {
-    fn received_only(index: usize, account: &AccountChanges) -> Self {
-        Self {
-            index,
-            received: Some(AccountSummary::from_account(account)),
-            rebuilt: None,
-            fields_differ: AccountFieldFlags::default(),
-        }
-    }
-
-    fn rebuilt_only(index: usize, account: &AccountChanges) -> Self {
-        Self {
-            index,
-            received: None,
-            rebuilt: Some(AccountSummary::from_account(account)),
-            fields_differ: AccountFieldFlags::default(),
-        }
-    }
-
-    fn address_mismatch(index: usize, received: &AccountChanges, rebuilt: &AccountChanges) -> Self {
-        Self {
-            index,
-            received: Some(AccountSummary::from_account(received)),
-            rebuilt: Some(AccountSummary::from_account(rebuilt)),
-            fields_differ: AccountFieldFlags::default(),
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-struct AccountSummary {
-    address: Address,
-    storage_changes: usize,
-    storage_reads: usize,
-    balance_changes: usize,
-    nonce_changes: usize,
-    code_changes: usize,
-}
-
-impl AccountSummary {
-    const fn from_account(account: &AccountChanges) -> Self {
-        Self {
-            address: account.address,
-            storage_changes: account.storage_changes.len(),
-            storage_reads: account.storage_reads.len(),
-            balance_changes: account.balance_changes.len(),
-            nonce_changes: account.nonce_changes.len(),
-            code_changes: account.code_changes.len(),
-        }
-    }
-}
-
-#[derive(Debug, Default, PartialEq, Eq)]
-struct AccountFieldFlags {
-    storage_changes: bool,
-    storage_reads: bool,
-    balance_changes: bool,
-    nonce_changes: bool,
-    code_changes: bool,
-}
-
-impl AccountFieldFlags {
-    fn new(received: &AccountChanges, rebuilt: &AccountChanges) -> Self {
-        Self {
-            storage_changes: received.storage_changes != rebuilt.storage_changes,
-            storage_reads: received.storage_reads != rebuilt.storage_reads,
-            balance_changes: received.balance_changes != rebuilt.balance_changes,
-            nonce_changes: received.nonce_changes != rebuilt.nonce_changes,
-            code_changes: received.code_changes != rebuilt.code_changes,
-        }
-    }
-
-    const fn is_divergent(&self) -> bool {
-        self.storage_changes ||
-            self.storage_reads ||
-            self.balance_changes ||
-            self.nonce_changes ||
-            self.code_changes
-    }
-}
-
-pub(super) fn first_bal_divergence(
-    received: &[AccountChanges],
-    rebuilt: &[AccountChanges],
-) -> BalDivergence {
-    use core::cmp::Ordering;
-
-    let mut change_index = 0;
-    let first_diff = loop {
-        match (received.get(change_index), rebuilt.get(change_index)) {
-            (Some(received_account), Some(rebuilt_account)) => {
-                match received_account.address.cmp(&rebuilt_account.address) {
-                    Ordering::Less | Ordering::Greater => {
-                        break Some(AccountDivergence::address_mismatch(
-                            change_index,
-                            received_account,
-                            rebuilt_account,
-                        ));
-                    }
-                    Ordering::Equal => {
-                        let fields_differ =
-                            AccountFieldFlags::new(received_account, rebuilt_account);
-                        if fields_differ.is_divergent() {
-                            break Some(AccountDivergence {
-                                index: change_index,
-                                received: Some(AccountSummary::from_account(received_account)),
-                                rebuilt: Some(AccountSummary::from_account(rebuilt_account)),
-                                fields_differ,
-                            });
-                        }
-                        change_index += 1;
-                    }
-                }
-            }
-            (Some(account), None) => {
-                break Some(AccountDivergence::received_only(change_index, account));
-            }
-            (None, Some(account)) => {
-                break Some(AccountDivergence::rebuilt_only(change_index, account));
-            }
-            (None, None) => break None,
-        }
-    };
-
-    BalDivergence { received_accounts: received.len(), rebuilt_accounts: rebuilt.len(), first_diff }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use alloy_eip7928::{AccountChanges, BalanceChange};
-    use alloy_primitives::{Address, U256};
-
-    fn diagnostic_addr(byte: u8) -> Address {
-        let mut address = [0u8; 20];
-        address[19] = byte;
-        Address::from(address)
-    }
-
-    fn diagnostic_account(address: Address, balance: u64) -> AccountChanges {
-        AccountChanges {
-            address,
-            balance_changes: vec![BalanceChange::new(1, U256::from(balance))],
-            ..Default::default()
-        }
-    }
-
-    fn first_diff(received: &[AccountChanges], rebuilt: &[AccountChanges]) -> AccountDivergence {
-        first_bal_divergence(received, rebuilt).first_diff.expect("expected BAL divergence")
-    }
-
-    fn assert_summary_address(summary: &Option<AccountSummary>, address: Address) {
-        match summary {
-            Some(summary) => assert_eq!(summary.address, address),
-            None => panic!("expected account summary"),
-        }
-    }
-
-    #[test]
-    fn none_for_equal_bals() {
-        let account = diagnostic_account(diagnostic_addr(1), 1);
-        let rebuilt = vec![account.clone()];
-
-        let div = first_bal_divergence(core::slice::from_ref(&account), &rebuilt);
-
-        assert_eq!(
-            div,
-            BalDivergence { received_accounts: 1, rebuilt_accounts: 1, first_diff: None }
-        );
-    }
-
-    #[test]
-    fn reports_account_only_in_received() {
-        let received = vec![diagnostic_account(diagnostic_addr(1), 1)];
-
-        let diff = first_diff(&received, &[]);
-
-        assert_eq!(diff.index, 0);
-        assert_eq!(diff.received, Some(AccountSummary::from_account(&received[0])));
-        assert_eq!(diff.rebuilt, None);
-    }
-
-    #[test]
-    fn reports_tail_account_only_in_received_after_matching_prefix() {
-        let shared = diagnostic_account(diagnostic_addr(1), 1);
-        let received = vec![shared.clone(), diagnostic_account(diagnostic_addr(2), 2)];
-        let rebuilt = vec![shared];
-
-        let diff = first_diff(&received, &rebuilt);
-
-        assert_eq!(diff.index, 1);
-        assert_summary_address(&diff.received, diagnostic_addr(2));
-        assert_eq!(diff.rebuilt, None);
-    }
-
-    #[test]
-    fn reports_account_only_in_rebuilt() {
-        let rebuilt = vec![diagnostic_account(diagnostic_addr(1), 1)];
-
-        let diff = first_diff(&[], &rebuilt);
-
-        assert_eq!(diff.index, 0);
-        assert_eq!(diff.received, None);
-        assert_eq!(diff.rebuilt, Some(AccountSummary::from_account(&rebuilt[0])));
-    }
-
-    #[test]
-    fn reports_tail_account_only_in_rebuilt_after_matching_prefix() {
-        let shared = diagnostic_account(diagnostic_addr(1), 1);
-        let received = vec![shared.clone()];
-        let rebuilt = vec![shared, diagnostic_account(diagnostic_addr(2), 2)];
-
-        let diff = first_diff(&received, &rebuilt);
-
-        assert_eq!(diff.index, 1);
-        assert_eq!(diff.received, None);
-        assert_summary_address(&diff.rebuilt, diagnostic_addr(2));
-    }
-
-    #[test]
-    fn reports_changed_balance_field() {
-        let received = vec![diagnostic_account(diagnostic_addr(1), 1)];
-        let rebuilt = vec![diagnostic_account(diagnostic_addr(1), 2)];
-
-        let diff = first_diff(&received, &rebuilt);
-
-        assert_eq!(diff.index, 0);
-        assert_eq!(
-            diff.fields_differ,
-            AccountFieldFlags { balance_changes: true, ..Default::default() }
-        );
-        assert!(diff.received.is_some());
-        assert!(diff.rebuilt.is_some());
-    }
-
-    #[test]
-    fn reports_both_addresses_for_address_mismatch() {
-        let received = vec![
-            diagnostic_account(diagnostic_addr(1), 1),
-            diagnostic_account(diagnostic_addr(3), 1),
-        ];
-        let rebuilt = vec![
-            diagnostic_account(diagnostic_addr(2), 1),
-            diagnostic_account(diagnostic_addr(3), 2),
-        ];
-
-        let diff = first_diff(&received, &rebuilt);
-
-        assert_eq!(diff.index, 0);
-        assert_summary_address(&diff.received, diagnostic_addr(1));
-        assert_summary_address(&diff.rebuilt, diagnostic_addr(2));
-        assert_eq!(diff.fields_differ, AccountFieldFlags::default());
-    }
-
-    #[test]
-    fn stops_at_first_mismatch_after_matching_prefix() {
-        let shared = diagnostic_account(diagnostic_addr(1), 1);
-        let received = vec![
-            shared.clone(),
-            diagnostic_account(diagnostic_addr(2), 2),
-            diagnostic_account(diagnostic_addr(4), 4),
-        ];
-        let rebuilt = vec![
-            shared,
-            diagnostic_account(diagnostic_addr(3), 3),
-            diagnostic_account(diagnostic_addr(4), 5),
-        ];
-
-        let diff = first_diff(&received, &rebuilt);
-
-        assert_eq!(diff.index, 1);
-        assert_summary_address(&diff.received, diagnostic_addr(2));
-        assert_summary_address(&diff.rebuilt, diagnostic_addr(3));
-        assert_eq!(diff.fields_differ, AccountFieldFlags::default());
-    }
-}
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
index 5dcb7723a6c..3d8ace46420 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
@@ -14,9 +14,7 @@
 //! validator still handles consensus checks, receipt-root validation, state-root work, and block
 //! insertion.
 
-use super::{
-    debug, ordered_outputs::ordered_worker_outputs, worker, BalExecutionError, RejectReason,
-};
+use super::{ordered_outputs::ordered_worker_outputs, worker, BalExecutionError, RejectReason};
 use alloy_eip7928::{
     bal::{Bal as AlloyBal, DecodedBal},
     compute_block_access_list_hash,
@@ -222,12 +220,12 @@ where
         target: "engine::tree::payload_processor::bal",
         tracing::Level::DEBUG
     ) {
-        let div = debug::first_bal_divergence(received_bal, &composed_alloy);
+        let div = received_bal.diff(&composed_alloy);
         tracing::debug!(
             target: "engine::tree::payload_processor::bal",
             %rebuilt,
             expected = %header_bal_hash,
-            ?div,
+            %div,
             "first BAL divergence",
         );
     }
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/mod.rs b/crates/engine/tree/src/tree/payload_processor/bal/mod.rs
index 49da947a393..d8cdf6e5907 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/mod.rs
@@ -8,7 +8,6 @@
 //! 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 debug;
 mod ordered_outputs;
 mod worker;
 

From 849e9446c82432921a5b45225cf5254c63e41476 Mon Sep 17 00:00:00 2001
From: Alexey Shekhirin <github@shekhirin.com>
Date: Mon, 11 May 2026 11:25:31 +0100
Subject: [PATCH 085/335] ci(bench): route scheduled benchmarks through txgen
 (#24117)

---
 .github/workflows/bench-scheduled.yml | 52 +++++++++++++++++++++++----
 1 file changed, 45 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 8846222e9d7..b2486cc84e7 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -272,8 +272,12 @@ jobs:
       BENCH_ABBA: "true"
       BENCH_COMMENT_ID: ""
       BENCH_SLACK: ${{ github.event_name == 'workflow_dispatch' && inputs.slack || 'always' }}
+      BENCH_DRIVER: txgen
+      BENCH_NODE_BIN: reth
+      BENCH_DRIVER_REASON: ""
       BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
       BENCH_METRICS_ADDR: "127.0.0.1:9001"
+      TXGEN_REV: 5b04a80d557cc6658573db6ccf49ce04cbf07ea3
       BENCH_OTLP_DISABLED: "true"
       BASELINE_REF: ${{ needs.resolve-refs.outputs.baseline-ref }}
       FEATURE_REF: ${{ needs.resolve-refs.outputs.feature-ref }}
@@ -404,14 +408,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}" "$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}" "$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
@@ -425,7 +441,7 @@ jobs:
       - name: Sync snapshot
         id: snapshot-check
         run: |
-          BENCH_RETH_BINARY="$(pwd)/../reth-feature/target/profiling/reth" \
+          BENCH_RETH_BINARY="$(pwd)/../reth-feature/target/profiling/${BENCH_NODE_BIN}" \
             .github/scripts/bench-reth-snapshot.sh
 
       # System tuning for reproducible benchmarks
@@ -501,7 +517,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":"$(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"
+          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: feature (1/2)"
         id: run-feature-1
@@ -509,7 +529,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":"$(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"
+          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: feature (2/2)"
         id: run-feature-2
@@ -517,7 +541,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":"$(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"
+          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: "Run benchmark: baseline (2/2)"
         id: run-baseline-2
@@ -527,7 +555,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/reth "$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: Stop metrics proxy & generate Grafana URL
         id: metrics
@@ -602,6 +634,12 @@ jobs:
           if [ -n "$GRAFANA_URL" ]; then
             SUMMARY_ARGS="$SUMMARY_ARGS --grafana-url $GRAFANA_URL"
           fi
+          if [ -n "${BENCH_DRIVER:-}" ]; then
+            SUMMARY_ARGS="$SUMMARY_ARGS --driver $BENCH_DRIVER"
+          fi
+          if [ -n "${BENCH_DRIVER_REASON:-}" ]; then
+            SUMMARY_ARGS="$SUMMARY_ARGS --driver-reason $BENCH_DRIVER_REASON"
+          fi
           # shellcheck disable=SC2086
           python3 .github/scripts/bench-reth-summary.py $SUMMARY_ARGS
 

From 0e5fdaaaa9577560f2b928400f916516fbe46608 Mon Sep 17 00:00:00 2001
From: figtracer <me@figtracer.com>
Date: Mon, 11 May 2026 12:02:52 +0100
Subject: [PATCH 086/335] fix(init-state): reduce memory during large imports
 (#23825)

---
 crates/storage/db-common/src/init.rs | 67 ++++++++++++++++++++--------
 1 file changed, 49 insertions(+), 18 deletions(-)

diff --git a/crates/storage/db-common/src/init.rs b/crates/storage/db-common/src/init.rs
index ada8fec152a..c2ea1e7f606 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)]
@@ -645,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)
@@ -719,6 +722,7 @@ where
                 "Committed chunk"
             );
             storage_units = 0;
+            seen_bytecodes = B256Set::default();
         }
 
         write_account_to_db(
@@ -801,11 +805,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
@@ -941,8 +941,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) => {
@@ -1031,6 +1032,36 @@ 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 success_init_genesis_mainnet() {
         let genesis_hash =

From 735417251bbcc55036672be53a3ce343aefabdb1 Mon Sep 17 00:00:00 2001
From: Alexey Shekhirin <github@shekhirin.com>
Date: Mon, 11 May 2026 12:14:14 +0100
Subject: [PATCH 087/335] refactor(pool): pass error by value to `mark_invalid`
 (#24121)

---
 crates/ethereum/payload/src/lib.rs            | 12 +++++-----
 .../rpc-eth-api/src/helpers/pending_block.rs  | 10 ++++----
 crates/transaction-pool/src/pool/best.rs      | 24 +++++++++----------
 crates/transaction-pool/src/traits.rs         |  6 ++---
 4 files changed, 25 insertions(+), 27 deletions(-)

diff --git a/crates/ethereum/payload/src/lib.rs b/crates/ethereum/payload/src/lib.rs
index 3d8ad02127d..257ca2da5d5 100644
--- a/crates/ethereum/payload/src/lib.rs
+++ b/crates/ethereum/payload/src/lib.rs
@@ -278,7 +278,7 @@ where
             // continue
             best_txs.mark_invalid(
                 &pool_tx,
-                &InvalidPoolTransactionError::ExceedsGasLimit(
+                InvalidPoolTransactionError::ExceedsGasLimit(
                     transaction_gas_limit,
                     block_available_gas,
                 ),
@@ -302,7 +302,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 +324,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 +357,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 +383,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 +401,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,
                     ),
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..643bc1ef13d 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
@@ -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,
                                 ),
diff --git a/crates/transaction-pool/src/pool/best.rs b/crates/transaction-pool/src/pool/best.rs
index e04bdc3b79e..80d1e7d805d 100644
--- a/crates/transaction-pool/src/pool/best.rs
+++ b/crates/transaction-pool/src/pool/best.rs
@@ -32,7 +32,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,7 +68,7 @@ impl<T: TransactionOrdering> Iterator for BestTransactionsWithFees<T> {
             crate::traits::BestTransactions::mark_invalid(
                 self,
                 &best,
-                &InvalidPoolTransactionError::Underpriced,
+                InvalidPoolTransactionError::Underpriced,
             );
         }
     }
@@ -112,7 +112,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 +221,7 @@ impl<T: TransactionOrdering> BestTransactions<T> {
                 // transactions are returned
                 self.mark_invalid(
                     &best.transaction,
-                    &InvalidPoolTransactionError::Eip4844(
+                    InvalidPoolTransactionError::Eip4844(
                         Eip4844PoolTransactionError::NoEip4844Blobs,
                     ),
                 )
@@ -263,7 +263,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)
     }
 
@@ -321,9 +321,7 @@ where
             }
             self.best.mark_invalid(
                 &best,
-                &InvalidPoolTransactionError::Consensus(
-                    InvalidTransactionError::TxTypeNotSupported,
-                ),
+                InvalidPoolTransactionError::Consensus(InvalidTransactionError::TxTypeNotSupported),
             );
         }
     }
@@ -334,7 +332,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)
     }
 
@@ -423,7 +421,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)
     }
 
@@ -494,7 +492,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 +521,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 +1087,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/traits.rs b/crates/transaction-pool/src/traits.rs
index 2fdd0cb8f5a..4547fb3e9d4 100644
--- a/crates/transaction-pool/src/traits.rs
+++ b/crates/transaction-pool/src/traits.rs
@@ -1057,7 +1057,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 +1119,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 +1138,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) {}
 

From a5bd8d6824e7212e610fb7a838cbfc6c7df1bc9a Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 11 May 2026 13:46:29 +0200
Subject: [PATCH 088/335] refactor(engine): remove redundant BAL argument
 (#24123)

---
 .../engine/tree/src/tree/payload_validator.rs | 23 ++++++++++---------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 67b886075a4..51e6f9eb7b3 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -569,18 +569,17 @@ where
         // as transactions complete, allowing parallel computation during execution.
         let execute_block_start = Instant::now();
         let (output, senders, receipt_root_rx, built_bal) = if bal_eligible {
-            let decoded_bal = env.decoded_bal.clone().expect("eligibility implies BAL is present");
-            let built_bal = Some(decoded_bal.as_bal().clone().into());
+            let built_bal = Some(
+                env.decoded_bal
+                    .as_ref()
+                    .expect("eligibility implies BAL is present")
+                    .as_bal()
+                    .clone()
+                    .into(),
+            );
             let provider_builder =
                 bal_provider_builder.expect("eligibility implies builder was cloned");
-            match self.execute_block_bal(
-                state_provider,
-                env,
-                &input,
-                &handle,
-                decoded_bal,
-                provider_builder,
-            ) {
+            match self.execute_block_bal(state_provider, env, &input, &handle, provider_builder) {
                 Ok((output, senders, receipt_root_rx)) => {
                     (output, senders, receipt_root_rx, built_bal)
                 }
@@ -1072,7 +1071,6 @@ where
         env: ExecutionEnv<Evm>,
         input: &BlockOrPayload<T>,
         handle: &PayloadHandle<Tx, Err, N::Receipt>,
-        decoded_bal: Arc<DecodedBal>,
         provider_builder: StateProviderBuilder<N, BalP>,
     ) -> Result<
         (BlockExecutionOutput<N::Receipt>, Vec<Address>, ReceiptRootReceiver),
@@ -1096,6 +1094,9 @@ where
         let saved_cache = SavedCache::new(env.parent_hash, cache);
 
         let (receipt_tx, result_rx) = self.spawn_receipt_root_task(env.transaction_count);
+        let decoded_bal = env.decoded_bal.ok_or_else(|| {
+            InsertBlockErrorKind::Other("BAL execute path: no decoded BAL available".into())
+        })?;
 
         let make_db = move || {
             let provider = provider_builder

From bb3aaccd6448870d4bc92e73af27359b65ad5005 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Mon, 11 May 2026 05:19:02 -0700
Subject: [PATCH 089/335] ci(bench): add checkout step to save-state job
 (#24125)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/workflows/bench-scheduled.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index b2486cc84e7..6bf825081d6 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -1035,6 +1035,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 }}

From c607b331f0c446821ccbd90f5029fd19c1733b6a Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Mon, 11 May 2026 14:42:27 +0200
Subject: [PATCH 090/335] fix(ci): clean up scheduled bench cpu latency helper
 (#24124)

Co-authored-by: Brian Picciano <933154+mediocregopher@users.noreply.github.com>
---
 .github/workflows/bench-scheduled.yml | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 6bf825081d6..dc4a7e0856d 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -466,8 +466,11 @@ 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
@@ -1024,6 +1027,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
 
   # ---------------------------------------------------------------------------

From 11928d125c6d0845c9f6ce15b6babe6c7adc894c Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Mon, 11 May 2026 14:49:58 +0200
Subject: [PATCH 091/335] ci: stop collector timers during reth benchmarks
 (#24083)

Co-authored-by: Brian Picciano <933154+mediocregopher@users.noreply.github.com>
Co-authored-by: Amp <amp@ampcode.com>
---
 .github/scripts/bench-reth-local.sh   | 9 ++++++++-
 .github/workflows/bench-scheduled.yml | 9 ++++++++-
 .github/workflows/bench.yml           | 9 ++++++++-
 3 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/.github/scripts/bench-reth-local.sh b/.github/scripts/bench-reth-local.sh
index dc6812a3a32..6e2ccda383f 100755
--- a/.github/scripts/bench-reth-local.sh
+++ b/.github/scripts/bench-reth-local.sh
@@ -312,7 +312,14 @@ if [ "$TUNE" = "true" ]; then
   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
 
   TUNING_APPLIED=true
 
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index dc4a7e0856d..1a0261f5f8d 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -476,7 +476,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
           echo "=== Benchmark environment ==="
           uname -r
           lscpu | grep -E 'Model name|CPU\(s\)|MHz|NUMA'
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 3c33916db4a..e8cb8984eba 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -974,7 +974,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

From 3ea2d063b534f64ebfeeff1376b9c11048a642bc Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 11 May 2026 15:20:24 +0200
Subject: [PATCH 092/335] refactor(engine): add block or payload type helpers
 (#24119)

---
 crates/engine/tree/src/tree/payload_validator.rs | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 51e6f9eb7b3..e79d3a91197 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -393,7 +393,7 @@ where
         // 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 is_payload = input.is_payload();
         let convert_to_block = match &input {
             BlockOrPayload::Payload(_) => {
                 let payload_clone = input.clone();
@@ -2288,6 +2288,16 @@ impl<T: PayloadTypes> BlockOrPayload<T> {
         }
     }
 
+    /// 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.
     pub fn try_decoded_access_list(&self) -> Result<Option<DecodedBal>, alloy_rlp::Error> {
         match self {

From 8b10a417faeb2cbb0361480802e6113b5043fac9 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 11 May 2026 15:45:36 +0200
Subject: [PATCH 093/335] fix(engine): validate received BAL on serial path
 (#24122)

---
 .../src/tree/payload_processor/bal/error.rs   |  5 +-
 .../src/tree/payload_processor/bal/execute.rs | 49 +++++++++++--------
 .../src/tree/payload_processor/bal/mod.rs     |  1 +
 .../engine/tree/src/tree/payload_validator.rs | 48 +++++++-----------
 4 files changed, 50 insertions(+), 53 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_processor/bal/error.rs b/crates/engine/tree/src/tree/payload_processor/bal/error.rs
index efa6f621f2c..5c99954d87e 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/error.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/error.rs
@@ -33,12 +33,11 @@ impl From<RejectReason> for BalExecutionError {
 /// Reasons a block may be rejected on the BAL execution path.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum RejectReason {
-    /// The rebuilt BAL's hash disagrees with `header.block_access_list_hash` at end-of-block.
-    /// Catches over-declared addresses and any divergence the per-tx fragment compares missed.
+    /// The rebuilt BAL disagrees with the received BAL at end-of-block.
     FinalHashMismatch {
         /// Hash of the rebuilt BAL.
         rebuilt: B256,
-        /// Hash committed in the block header.
+        /// Hash of the received BAL.
         expected: B256,
     },
 }
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
index 3d8ace46420..a98d1141a00 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
@@ -48,7 +48,7 @@ pub fn execute_block<'a, Evm, Tx, Err, DB, MakeDb>(
     runtime: &Runtime,
     evm_config: &'a Evm,
     make_db: &'a MakeDb,
-    received_bal: Arc<DecodedBal>,
+    input_bal: Arc<DecodedBal>,
     evm_env: EvmEnvFor<Evm>,
     ctx: ExecutionCtxFor<'a, Evm>,
     transaction_count: usize,
@@ -71,7 +71,7 @@ where
             scope,
             evm_config,
             make_db,
-            received_bal,
+            input_bal,
             evm_env,
             ctx,
             transaction_count,
@@ -87,7 +87,7 @@ fn execute_block_inner<'scope, Evm, Tx, Err, DB, MakeDb>(
     scope: &rayon::Scope<'scope>,
     evm_config: &'scope Evm,
     make_db: &'scope MakeDb,
-    received_bal: Arc<DecodedBal>,
+    input_bal: Arc<DecodedBal>,
     evm_env: EvmEnvFor<Evm>,
     ctx: ExecutionCtxFor<'scope, Evm>,
     transaction_count: usize,
@@ -103,8 +103,8 @@ where
     MakeDb: Fn() -> Result<DB, BalExecutionError> + Sync + 'scope,
     ReceiptTy<Evm::Primitives>: Clone,
 {
-    let bal = received_bal.as_bal();
-    let received_bal_revm: Arc<RevmBal> = Arc::new(
+    let bal = input_bal.as_bal();
+    let input_bal_revm: Arc<RevmBal> = Arc::new(
         RevmBal::try_from(Vec::<_>::from(bal.clone()))
             .map_err(|e| BalExecutionError::BalConversion(format!("{e:?}")))?,
     );
@@ -129,7 +129,7 @@ where
                 result_tx.clone(),
                 evm_config,
                 make_db,
-                Arc::clone(&received_bal_revm),
+                Arc::clone(&input_bal_revm),
                 evm_env.clone(),
                 ctx.clone(),
             );
@@ -144,6 +144,10 @@ where
         canonical_executor.apply_pre_execution_changes()?;
         let mut senders = Vec::with_capacity(transaction_count);
         let mut last_sent_len = 0usize;
+        // `DecodedBal::hash` is lazy-cached. Compute the hash after workers are spawned and before
+        // waiting on ordered results, so the callsite can read the header commitment hash once
+        // execution finishes without adding serial work after the BAL equality check.
+        let _ = input_bal.hash();
         for output in ordered_worker_outputs(&result_rx, transaction_count) {
             let output = output?;
 
@@ -170,7 +174,7 @@ where
         (block_result, senders)
     };
 
-    validate_bal(&mut canonical_state, bal)?;
+    validate_bal(&mut canonical_state, input_bal.as_ref())?;
 
     canonical_state.merge_transitions(BundleRetention::Reverts);
     Ok((
@@ -202,29 +206,34 @@ where
     Ok(())
 }
 
-fn validate_bal<DB>(
+/// Validates that execution rebuilt the same BAL that was provided with the payload.
+///
+/// This consumes the BAL built by `canonical_state` and compares it against the decoded input
+/// BAL before post-execution validation relies on `DecodedBal::hash()` as the header commitment.
+pub(crate) fn validate_bal<DB>(
     canonical_state: &mut State<DB>,
-    received_bal: &AlloyBal,
+    input_bal: &DecodedBal,
 ) -> Result<(), BalExecutionError>
 where
     DB: Database,
 {
     let composed_alloy = canonical_state.take_built_alloy_bal().expect("with_bal_builder set");
-    if composed_alloy == received_bal.as_ref() {
+    let input_bal_entries = input_bal.as_bal();
+    if composed_alloy == input_bal_entries.as_slice() {
         return Ok(());
     }
     let rebuilt = compute_block_access_list_hash(&composed_alloy);
-    let header_bal_hash = compute_block_access_list_hash(received_bal);
+    let expected_bal_hash = input_bal.hash();
 
     if tracing::enabled!(
         target: "engine::tree::payload_processor::bal",
         tracing::Level::DEBUG
     ) {
-        let div = received_bal.diff(&composed_alloy);
+        let div = input_bal_entries.diff(&composed_alloy);
         tracing::debug!(
             target: "engine::tree::payload_processor::bal",
             %rebuilt,
-            expected = %header_bal_hash,
+            expected = %expected_bal_hash,
             %div,
             "first BAL divergence",
         );
@@ -232,7 +241,7 @@ where
 
     Err(BalExecutionError::Reject(RejectReason::FinalHashMismatch {
         rebuilt,
-        expected: header_bal_hash,
+        expected: expected_bal_hash,
     }))
 }
 
@@ -423,10 +432,10 @@ mod tests {
         //      pass (A, B, D, F).
         let evm_config = EthEvmConfig::mainnet();
 
-        let received_bal = reference_bal_for_empty_block(&evm_config);
-        let bal_hash = alloy_eip7928::compute_block_access_list_hash(&received_bal);
+        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!(!received_bal.is_empty(), "empty BAL means system calls didn't record state");
+        assert!(!input_bal.is_empty(), "empty BAL means system calls didn't record state");
 
         let block = empty_amsterdam_block(bal_hash);
 
@@ -434,7 +443,7 @@ mod tests {
             &Runtime::test(),
             evm_config,
             db_factory(system_contracts_db()),
-            to_arc_decoded(received_bal),
+            to_arc_decoded(input_bal),
             &block,
             Vec::<Recovered<TransactionSigned>>::new(),
         );
@@ -465,7 +474,7 @@ mod tests {
         runtime: &Runtime,
         evm_config: EthEvmConfig,
         make_db: MakeDb,
-        received_bal: Arc<DecodedBal>,
+        input_bal: Arc<DecodedBal>,
         block: &SealedBlock<Block>,
         txs: Vec<Tx>,
     ) -> Result<BlockExecutionOutput<EthereumReceipt>, BalExecutionError>
@@ -482,7 +491,7 @@ mod tests {
             runtime,
             &evm_config,
             &make_db,
-            received_bal,
+            input_bal,
             evm_env,
             execution_ctx,
             transaction_count,
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/mod.rs b/crates/engine/tree/src/tree/payload_processor/bal/mod.rs
index d8cdf6e5907..35aea31a60b 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/mod.rs
@@ -16,3 +16,4 @@ pub mod execute;
 
 pub use error::{BalExecutionError, RejectReason};
 pub use execute::execute_block;
+pub(crate) use execute::validate_bal;
diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index e79d3a91197..f4e7c431ff2 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -49,7 +49,7 @@ use crate::tree::{
     PayloadHandle, StateProviderBuilder, StateProviderDatabase, TreeConfig, WaitForCaches,
 };
 use alloy_consensus::transaction::{Either, TxHashRef};
-use alloy_eip7928::{bal::DecodedBal, compute_block_access_list_hash, BlockAccessList};
+use alloy_eip7928::bal::DecodedBal;
 use alloy_eips::{eip1898::BlockWithParent, eip4895::Withdrawal, NumHash};
 use alloy_evm::Evm;
 use alloy_primitives::{map::B256Set, B256};
@@ -568,21 +568,12 @@ where
         // The receipt root task is spawned before execution and receives receipts incrementally
         // as transactions complete, allowing parallel computation during execution.
         let execute_block_start = Instant::now();
-        let (output, senders, receipt_root_rx, built_bal) = if bal_eligible {
-            let built_bal = Some(
-                env.decoded_bal
-                    .as_ref()
-                    .expect("eligibility implies BAL is present")
-                    .as_bal()
-                    .clone()
-                    .into(),
-            );
+        let decoded_bal = env.decoded_bal.clone();
+        let (output, senders, receipt_root_rx) = if bal_eligible {
             let provider_builder =
                 bal_provider_builder.expect("eligibility implies builder was cloned");
             match self.execute_block_bal(state_provider, env, &input, &handle, provider_builder) {
-                Ok((output, senders, receipt_root_rx)) => {
-                    (output, senders, receipt_root_rx, built_bal)
-                }
+                Ok(output) => output,
                 Err(err) => return self.handle_execution_error(input, err, &parent_block),
             }
         } else {
@@ -591,6 +582,7 @@ where
                 Err(err) => return self.handle_execution_error(input, err, &parent_block),
             }
         };
+        let block_access_list_hash = decoded_bal.as_ref().map(|decoded_bal| decoded_bal.hash());
         let execution_duration = execute_block_start.elapsed();
 
         // After executing the block we can stop prewarming transactions
@@ -668,7 +660,7 @@ where
                 transaction_root,
                 receipt_root_bloom,
                 hashed_state,
-                built_bal
+                block_access_list_hash
             ),
             block
         );
@@ -921,12 +913,7 @@ where
         input: &BlockOrPayload<T>,
         handle: &mut PayloadHandle<impl ExecutableTxFor<Evm>, Err, N::Receipt>,
     ) -> Result<
-        (
-            BlockExecutionOutput<N::Receipt>,
-            Vec<Address>,
-            ReceiptRootReceiver,
-            Option<BlockAccessList>,
-        ),
+        (BlockExecutionOutput<N::Receipt>, Vec<Address>, ReceiptRootReceiver),
         InsertBlockErrorKind,
     >
     where
@@ -1014,13 +1001,17 @@ where
             .map(|(evm, result)| (evm.into_db(), result))?;
         self.metrics.record_post_execution(post_exec_start.elapsed());
 
+        if let Some(decoded_bal) = &env.decoded_bal {
+            // Regular execution still handles BAL payloads when the parallel BAL path is
+            // disabled. Prove that execution rebuilt the payload-provided BAL before
+            // post-execution validation uses `decoded_bal.hash()` as the header commitment.
+            crate::tree::payload_processor::bal::validate_bal(&mut db, decoded_bal)?;
+        }
+
         // Merge transitions into bundle state
         debug_span!(target: "engine::tree", "merge_transitions")
             .in_scope(|| db.merge_transitions(BundleRetention::Reverts));
 
-        // Extract the built bal if payload has bal
-        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();
@@ -1028,7 +1019,7 @@ 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, built_bal))
+        Ok((output, senders, result_rx))
     }
 
     /// Returns true when the BAL execute path should be used for this block.
@@ -1094,7 +1085,7 @@ where
         let saved_cache = SavedCache::new(env.parent_hash, cache);
 
         let (receipt_tx, result_rx) = self.spawn_receipt_root_task(env.transaction_count);
-        let decoded_bal = env.decoded_bal.ok_or_else(|| {
+        let input_bal = env.decoded_bal.ok_or_else(|| {
             InsertBlockErrorKind::Other("BAL execute path: no decoded BAL available".into())
         })?;
 
@@ -1115,7 +1106,7 @@ where
             &self.runtime,
             &self.evm_config,
             &make_db,
-            decoded_bal,
+            input_bal,
             env.evm_env,
             ctx,
             env.transaction_count,
@@ -1520,7 +1511,7 @@ where
         transaction_root: Option<B256>,
         receipt_root_bloom: Option<ReceiptRootBloom>,
         hashed_state: LazyHashedPostState,
-        built_bal: Option<BlockAccessList>,
+        block_access_list_hash: Option<B256>,
     ) -> Result<LazyHashedPostState, InsertBlockErrorKind>
     where
         V: PayloadValidator<T, Block = N::Block>,
@@ -1547,9 +1538,6 @@ where
         let _enter =
             debug_span!(target: "engine::tree::payload_validator", "validate_block_post_execution")
                 .entered();
-        let block_access_list_hash =
-            built_bal.as_ref().map(|bal| compute_block_access_list_hash(bal));
-
         if let Err(err) = self.consensus.validate_block_post_execution(
             block,
             output,

From 0552b869771cb613fbe5bcbef708b447648bf667 Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Mon, 11 May 2026 17:48:13 +0200
Subject: [PATCH 094/335] ci(bench): derive default warmup from block count
 (#24131)

Co-authored-by: Brian Picciano <933154+mediocregopher@users.noreply.github.com>
Co-authored-by: Amp <amp@ampcode.com>
---
 .github/workflows/bench-scheduled.yml | 40 +++++++++++++++++++++++++--
 .github/workflows/bench.yml           | 24 ++++++++++------
 2 files changed, 54 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 1a0261f5f8d..43dd2ee4346 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:
@@ -261,8 +297,8 @@ jobs:
       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"
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index e8cb8984eba..d2162a30079 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -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)"
@@ -190,12 +190,13 @@ jobs:
               if (/^\d+([kKmMgG])?$/.test(value)) return { enabled: 'true', targetGas: value };
               return null;
             };
+            const defaultWarmup = (blockCount) => String(Math.floor(Number(blockCount) / 4));
 
             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;
+              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';
@@ -240,7 +241,7 @@ jobs:
               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: 'false', 'wait-time': '', 'baseline-args': '', 'feature-args': '' };
+              const defaults = { blocks: '500', warmup: '', baseline: '', feature: '', samply: 'false', slack: 'always', 'big-blocks': 'false', bal: 'false', cores: '0', abba: 'true', otlp: 'false', 'wait-time': '', 'baseline-args': '', 'feature-args': '' };
               const unknown = [];
               const invalid = [];
               const args = body.replace(/^(?:@decofe|derek) bench\s*/, '');
@@ -345,9 +346,16 @@ jobs:
               var featureNodeArgs = defaults['feature-args'];
             }
 
-            // Default warmup to 20 for big-blocks mode unless explicitly set
-            if (bigBlocks === 'true' && !explicitWarmup) {
-              warmup = '20';
+            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 (!validBalModes.has(bal)) {

From abaccb269fa1b1c39cf998d5c0b4b1ada3b8c2f0 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 11 May 2026 19:55:25 +0400
Subject: [PATCH 095/335] feat: support custom state root strategies (#24130)

Co-authored-by: ControlCplusControlV <randomlikeabledude@gmail.com>
---
 .../engine/tree/src/tree/payload_validator.rs | 62 ++++++++++++++++---
 1 file changed, 55 insertions(+), 7 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index f4e7c431ff2..09ae6767f6f 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -195,6 +195,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>
@@ -250,9 +252,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>>>(
@@ -538,7 +547,7 @@ where
             txs,
             provider_builder.clone(),
             overlay_factory.clone(),
-            strategy,
+            &strategy,
         ));
 
         // Create optional cache stats for detailed block logging
@@ -764,6 +773,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.
@@ -1601,7 +1622,7 @@ where
         txs: T,
         provider_builder: StateProviderBuilder<N, P>,
         overlay_factory: OverlayStateProviderFactory<P, N>,
-        strategy: StateRootStrategy,
+        strategy: &StateRootStrategy<N>,
     ) -> Result<
         PayloadHandle<
             impl ExecutableTxFor<Evm> + use<N, P, Evm, V, T>,
@@ -1631,7 +1652,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);
@@ -1682,8 +1705,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
@@ -2024,14 +2049,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.
@@ -2341,3 +2368,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,
+>;

From 5e2c16912e1af16b289fd82fc88f3a909c1ac653 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 11 May 2026 20:48:14 +0400
Subject: [PATCH 096/335] refactor: simplify reth-bb (#23912)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 bin/reth-bb/src/evm.rs                        | 261 +++------
 bin/reth-bb/src/evm_config.rs                 | 232 ++++----
 bin/reth-bb/src/main.rs                       | 315 +++-------
 bin/reth-bench/src/bench/context.rs           |   1 -
 .../src/bench/generate_big_block.rs           | 183 ++----
 bin/reth-bench/src/bench/mod.rs               |  17 +-
 bin/reth-bench/src/bench/new_payload_fcu.rs   |  29 +-
 bin/reth-bench/src/bench/replay_payloads.rs   | 552 ------------------
 crates/engine/primitives/Cargo.toml           |   8 +-
 crates/engine/primitives/src/message.rs       |  59 +-
 .../src/tree/payload_processor/bal/execute.rs |   8 +-
 .../src/tree/payload_processor/bal/worker.rs  |  10 +-
 .../ethereum/engine-primitives/src/payload.rs |   7 +
 crates/ethereum/node/Cargo.toml               |   2 +-
 crates/ethereum/node/src/lib.rs               |   2 +-
 crates/evm/evm/src/lib.rs                     |  18 +-
 16 files changed, 436 insertions(+), 1268 deletions(-)
 delete mode 100644 bin/reth-bench/src/bench/replay_payloads.rs

diff --git a/bin/reth-bb/src/evm.rs b/bin/reth-bb/src/evm.rs
index 324e74ec797..56be39d34dc 100644
--- a/bin/reth-bb/src/evm.rs
+++ b/bin/reth-bb/src/evm.rs
@@ -37,10 +37,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 +50,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) {
@@ -82,17 +82,6 @@ impl BbEvmPlan {
     }
 }
 
-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
 // ---------------------------------------------------------------------------
@@ -153,7 +142,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,
@@ -203,16 +192,15 @@ where
     #[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,
@@ -241,59 +229,49 @@ where
         if self.initialized {
             return Ok(());
         }
-        self.initialized = true;
 
-        let plan = match &self.plan {
-            Some(p) => p,
-            None => return Ok(()),
-        };
+        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);
 
-        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
+            // 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);
+            }
+
+            segment_idx
         } else {
-            let tx_index = (bal_index - 1) as usize;
-            plan.segment_index_for_tx(tx_index)
+            if self.initialized {
+                return Ok(());
+            }
+
+            self.initialized = true;
+            0
         };
-        let segment = &plan.segments[segment_idx];
+        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 segment_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 = segment_ctx;
+        inner.ctx = segment.ctx.clone();
 
         self.reseed_block_hashes_for(block_number);
 
-        if bal_index > 0 {
-            // 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);
-            }
-            self.plan = None;
-        }
-
         Ok(())
     }
 
@@ -319,32 +297,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;
 
@@ -359,30 +317,12 @@ 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;
 
@@ -391,9 +331,14 @@ where
         // 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
@@ -433,7 +378,8 @@ 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;
@@ -448,24 +394,14 @@ where
 
         // 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)
         // at bal_index K+1.
         self.inner_mut().apply_pre_execution_changes()?;
 
-        // Renumbering: bump bal_index so the upcoming `inner.commit_transaction`
-        // for tx 0 of this segment lands at K+2 (visible to its worker via
-        // strict less-than reads of K+2, which include both K and K+1).
-        if let Some(bumper) = self.bal_index_bumper {
-            bumper(self.inner_mut().evm_mut().db_mut());
-        }
-
         trace!(target: "engine::bb::evm", "Started segment {seg_idx}");
 
         Ok(())
@@ -508,14 +444,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
@@ -528,9 +460,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
     }
 
@@ -540,18 +477,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()?;
 
@@ -586,16 +522,12 @@ where
     }
 
     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);
-        }
+        // 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);
     }
 
     fn evm_mut(&mut self) -> &mut Self::Evm {
@@ -622,17 +554,15 @@ pub struct BbBlockExecutorFactory<Spec> {
     receipt_builder: RethReceiptBuilder,
     spec: Spec,
     evm_factory: EthEvmFactory,
-    /// Staged plan consumed by the next [`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 {
@@ -647,26 +577,10 @@ 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;
-    }
-
-    /// Returns a clone of the currently staged plan without consuming it.
-    ///
-    /// Cloning lets multiple executors (canonical + N parallel BAL workers
-    /// for the same block) each own their own plan state.
-    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>>,
@@ -674,16 +588,14 @@ impl<Spec> BbBlockExecutorFactory<Spec> {
     ) -> 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,
@@ -698,7 +610,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<
@@ -715,23 +627,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,
-            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 27c22d5adbd..12935c70063 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,13 +22,13 @@ 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 reth_evm_ethereum::{EthEvmConfig, RethReceiptBuilder};
+use reth_primitives_traits::{SealedBlock, SealedHeader, SignedTransaction, TxTy};
 use revm::primitives::hardfork::SpecId;
 use std::sync::Arc;
 
@@ -37,13 +38,13 @@ use std::sync::Arc;
 
 /// 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>,
 }
 
 // ---------------------------------------------------------------------------
@@ -52,8 +53,8 @@ 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`]
+/// 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)
@@ -62,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,
     {
@@ -82,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() }
     }
 }
 
@@ -147,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
@@ -169,18 +167,25 @@ where
         self.inner.next_evm_env(parent, attributes)
     }
 
+    fn context_for_block<'a>(
+        &self,
+        _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,
@@ -207,20 +212,31 @@ where
         )
     }
 
-    fn context_for_block<'a>(
-        &self,
-        block: &'a SealedBlock<reth_ethereum_primitives::Block>,
-    ) -> Result<EthBlockExecutionCtx<'a>, Self::Error> {
-        // Refresh the staged plan based on this block's hash so subsequent
-        // `create_executor` calls - both canonical and parallel BAL workers -
-        // see the right plan. Cleared explicitly when this block isn't a
-        // big-block payload, so a stale plan from a prior big block doesn't
-        // leak into a regular block.
-        match self.plan_for_payload_hash(&block.hash()) {
-            Some(plan) => self.executor_factory.stage_plan(plan),
-            None => self.executor_factory.clear_staged_plan(),
-        }
-        self.inner.context_for_block(block)
+    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>),
+        )
     }
 }
 
@@ -228,93 +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 first_exec_data = {
-            let pending = self.pending.lock().unwrap();
-            pending
-                .get(&payload_hash)
-                .and_then(|bb_data| bb_data.env_switches.first().map(|(_, data)| data.clone()))
-        };
-
-        if let Some(first_exec_data) = first_exec_data {
-            // Compute the env from the first segment before the executor is created.
-            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;
-
-            Ok(env)
-        } else {
-            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>>()?;
 
-    fn tx_iterator_for_payload(
-        &self,
-        payload: &ExecutionData,
-    ) -> Result<impl ExecutableTxIterator<Self>, Self::Error> {
-        self.inner.tx_iterator_for_payload(payload)
-    }
-}
+        let mut plan = BbEvmPlan::new(segments);
 
-// ---------------------------------------------------------------------------
-// Plan construction
-// ---------------------------------------------------------------------------
+        // 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);
 
-impl<C> BbEvmConfig<C>
-where
-    C: EthExecutorSpec + EthChainSpec<Header = Header> + Hardforks + 'static,
-{
-    fn plan_for_payload_hash(&self, payload_hash: &B256) -> Option<BbEvmPlan> {
-        let pending = self.pending.lock().unwrap();
-        self.build_plan(pending.get(payload_hash)?)
+        Ok(plan)
     }
 
-    fn build_plan(&self, bb: &BigBlockData<ExecutionData>) -> Option<BbEvmPlan> {
-        if bb.env_switches.is_empty() {
-            return None;
-        }
-
-        let segments: Vec<_> = bb
+    fn tx_iterator_for_payload(
+        &self,
+        payload: &BigBlockData<ExecutionData>,
+    ) -> Result<impl ExecutableTxIterator<Self>, Self::Error> {
+        let transactions = payload
             .env_switches
             .iter()
-            .map(|(start_tx, exec_data)| {
-                let mut evm_env = self.inner.evm_env_for_payload(exec_data).unwrap();
-                evm_env.cfg_env.disable_base_fee = true;
-                let ctx = self.inner.context_for_payload(exec_data).unwrap();
-                BigBlockSegment { start_tx: *start_tx, evm_env, ctx: clone_ctx(&ctx) }
-            })
-            .collect();
+            .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))
+        };
 
-        let mut plan = BbEvmPlan::new(segments);
-        plan.block_hashes_to_seed.extend(bb.prior_block_hashes.iter().copied());
-        plan.block_hashes_to_seed.sort_unstable_by_key(|(n, _)| *n);
-        Some(plan)
+        Ok((transactions, convert))
     }
 }
 
-fn clone_ctx<'a>(ctx: &EthBlockExecutionCtx<'_>) -> EthBlockExecutionCtx<'a> {
-    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.clone().map(|w| std::borrow::Cow::Owned(w.into_owned())),
-        extra_data: ctx.extra_data.clone(),
-        slot_number: ctx.slot_number,
+#[derive(Debug, Default, Clone)]
+pub struct BbBlockAssembler;
+
+impl<Spec: EthExecutorSpec + 'static> BlockAssembler<BbBlockExecutorFactory<Spec>>
+    for BbBlockAssembler
+{
+    type Block = Block;
+
+    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 51e4922562d..e03c6cab3eb 100644
--- a/bin/reth-bb/src/main.rs
+++ b/bin/reth-bb/src/main.rs
@@ -7,244 +7,109 @@ 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 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,
+            >,
+    ) -> 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;
+        }
+
+        // Update block's gas usage to make sure metrics are correct
+        block.header.gas_used += blocks.iter().map(|b| b.gas_used).sum::<u64>();
 
-    fn engine_validator_builder(&self) -> Self::ValidatorBuilder {
-        BasicEngineValidatorBuilder::default()
+        // 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))
     }
 }
 
@@ -253,10 +118,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
@@ -272,7 +136,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())))
     }
 }
 
@@ -281,22 +145,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
@@ -312,16 +169,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()
     }
 }
 
@@ -355,14 +217,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/src/bench/context.rs b/bin/reth-bench/src/bench/context.rs
index b0f665bebd9..d87d2db3d31 100644
--- a/bin/reth-bench/src/bench/context.rs
+++ b/bin/reth-bench/src/bench/context.rs
@@ -233,7 +233,6 @@ async fn derive_big_blocks_initial_state(
 
     let initial_state = BigBlocksInitialState {
         prior_block_hashes: fetch_recent_block_hashes(source_provider, last_regular_block).await?,
-        parent_hash: local_head_hash,
         next_synthetic_block_number: local_head_number + 1,
     };
 
diff --git a/bin/reth-bench/src/bench/generate_big_block.rs b/bin/reth-bench/src/bench/generate_big_block.rs
index a7b079d984b..148b3ae6a70 100644
--- a/bin/reth-bench/src/bench/generate_big_block.rs
+++ b/bin/reth-bench/src/bench/generate_big_block.rs
@@ -2,7 +2,7 @@
 //!
 //! 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
+//! and saves the result to disk as a [`BigBlockData`] JSON file containing the merged
 //! [`ExecutionData`] and environment switches at each block boundary.
 
 use alloy_consensus::TxEnvelope;
@@ -16,19 +16,15 @@ use alloy_provider::{
     Provider, RootProvider,
 };
 use alloy_rpc_client::ClientBuilder;
-use alloy_rpc_types_engine::{
-    CancunPayloadFields, ExecutionData, ExecutionPayload, ExecutionPayloadSidecar,
-    PraguePayloadFields,
-};
+use alloy_rpc_types_engine::{ExecutionData, ExecutionPayload};
 use clap::Parser;
 use eyre::Context;
 use futures::{stream, Stream, StreamExt};
 use reth_chainspec::EthChainSpec;
 use reth_cli::chainspec::ChainSpecParser;
 use reth_cli_runner::CliContext;
-use reth_engine_primitives::BigBlockData;
+use reth_engine_primitives::{BigBlockData, ExecutionPayload as _};
 use reth_ethereum_cli::chainspec::EthereumChainSpecParser;
-use serde::{Deserialize, Serialize};
 use std::{
     collections::{HashMap, HashSet},
     future::Future,
@@ -215,26 +211,11 @@ pub struct CollectionResult {
     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>,
-}
-
 /// State used to continue generated big block replay from the benchmark node's current tip.
 #[derive(Debug, Clone, Default)]
 pub(crate) struct BigBlocksInitialState {
     /// Real block hashes from previous big blocks, used for BLOCKHASH lookups.
     pub prior_block_hashes: Vec<(u64, B256)>,
-    /// Hash of the previous synthetic big block.
-    pub parent_hash: B256,
     /// Block number to assign to the first generated synthetic block.
     pub next_synthetic_block_number: u64,
 }
@@ -344,9 +325,9 @@ impl Command {
         while let Some(big_block) = big_blocks_stream.next().await {
             let big_block = big_block?;
             // Save to disk
-            let range_start = big_block.big_block_data.env_switches[0].1.block_number();
-            let range_end = big_block.big_block_data.env_switches.last().unwrap().1.block_number();
-            let block_hash = big_block.execution_data.payload.as_v1().block_hash;
+            let range_start = big_block.env_switches[0].block_number();
+            let range_end = big_block.env_switches.last().unwrap().block_number();
+            let block_hash = big_block.block_hash();
             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)?;
@@ -372,13 +353,12 @@ pub(crate) fn big_blocks_stream(
     block_stream: impl Stream<Item = eyre::Result<Option<(AnyRpcBlock, Option<BlockAccessList>)>>>
         + Unpin,
     initial_state: Option<BigBlocksInitialState>,
-) -> impl Stream<Item = eyre::Result<BigBlockPayload>> {
+) -> impl Stream<Item = eyre::Result<BigBlockData<ExecutionData>>> {
     futures::stream::try_unfold(
         (
             block_stream,
             initial_state.as_ref().map(|s| s.prior_block_hashes.clone()).unwrap_or_default(),
             0,
-            initial_state.as_ref().map(|s| s.parent_hash),
             initial_state.as_ref().map(|s| s.next_synthetic_block_number),
             false,
             0,
@@ -387,7 +367,6 @@ pub(crate) fn big_blocks_stream(
             mut block_stream,
             mut accumulated_block_hashes,
             mut big_block_idx,
-            mut prev_big_block_hash,
             next_synthetic_block_number,
             mut reached_chain_tip,
             mut first_block,
@@ -460,127 +439,46 @@ pub(crate) fn big_blocks_stream(
                 return Ok(None);
             }
 
-            // Block 0 is the base
-            let mut base = blocks.remove(0);
-            let mut merged_block_access_list = block_access_lists.remove(0);
-            let mut env_switches = Vec::new();
-
-            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_idx, (block_data, block_access_list)) in
-                    blocks.into_iter().zip(block_access_lists).enumerate()
-                {
-                    // Segment index in the merged big block. The base block is
-                    // segment 0; subsequent blocks are segments 1, 2, ...
-                    let segment_idx = (block_idx + 1) as u64;
-                    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,
-                            segment_idx,
-                        );
-                    }
-
-                    // Record environment switch at this block boundary
-                    env_switches.push((cumulative_tx_count, block_data.clone()));
+            let mut merged_block_access_list = None;
+            let mut cumulative_tx_count = 0;
 
-                    // 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);
+            for (block_idx, (block_data, block_access_list)) in
+                blocks.iter().zip(block_access_lists).enumerate()
+            {
+                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,
+                        block_idx as u64,
+                    );
                 }
 
-                // 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;
-            }
-
-            // Chain sequential big blocks: set parent_hash, block_number.
-            // 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.
-                let synthetic_block_number =
-                    next_synthetic_block_number.unwrap_or(first_block) + big_block_idx;
-                base.payload.as_v1_mut().block_number = synthetic_block_number;
+                cumulative_tx_count += block_data.transaction_count();
             }
 
-            // Merge blob data from all constituent blocks:  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();
-                // 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(block_access_list) = &mut merged_block_access_list {
+                block_access_list.sort_unstable_by_key(|account| account.address);
+                for account in block_access_list {
+                    account.sort();
                 }
-                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);
-
-            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,
+            let big_block = BigBlockData {
+                env_switches: blocks,
+                prior_block_hashes: accumulated_block_hashes.clone(),
+                block_number: next_synthetic_block_number.unwrap_or(first_block) + big_block_idx,
+                merged_block_access_list: merged_block_access_list
+                    .as_ref()
+                    .map(|list| alloy_rlp::encode(list).into()),
             };
 
             // 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;
+            for switch_data in &big_block.env_switches {
+                let block_number = switch_data.block_number();
+                let block_hash = switch_data.block_hash();
                 accumulated_block_hashes.push((block_number, block_hash));
             }
             if accumulated_block_hashes.len() > 256 {
@@ -590,12 +488,12 @@ pub(crate) fn big_blocks_stream(
 
             info!(
                 target: "reth-bench",
-                block_hash = %big_block.execution_data.payload.as_v1().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),
+                block_hash = %big_block.block_hash(),
+                total_txs = %big_block.transaction_count(),
+                total_gas_used = %big_block.gas_used(),
+                env_switches = %big_block.env_switches.len(),
+                prior_block_hashes = %big_block.prior_block_hashes.len(),
+                bal_accounts = %merged_block_access_list.as_ref().map_or(0, Vec::len),
                 "Generated big block"
             );
 
@@ -606,7 +504,6 @@ pub(crate) fn big_blocks_stream(
                     block_stream,
                     accumulated_block_hashes,
                     big_block_idx,
-                    prev_big_block_hash,
                     next_synthetic_block_number,
                     reached_chain_tip,
                     first_block,
diff --git a/bin/reth-bench/src/bench/mod.rs b/bin/reth-bench/src/bench/mod.rs
index 79e21d5fca9..ffc567f2b3f 100644
--- a/bin/reth-bench/src/bench/mod.rs
+++ b/bin/reth-bench/src/bench/mod.rs
@@ -9,14 +9,13 @@ mod context;
 mod generate_big_block;
 pub(crate) mod helpers;
 pub use generate_big_block::{
-    compute_payload_block_hash, BigBlockPayload, RawTransaction, RpcTransactionSource,
-    TransactionCollector, TransactionSource,
+    compute_payload_block_hash, 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;
 
@@ -63,17 +62,6 @@ pub enum Subcommands {
     /// --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
@@ -98,7 +86,6 @@ impl BenchmarkCommand {
             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,
         }
     }
diff --git a/bin/reth-bench/src/bench/new_payload_fcu.rs b/bin/reth-bench/src/bench/new_payload_fcu.rs
index d757f41ea69..66d3e876f41 100644
--- a/bin/reth-bench/src/bench/new_payload_fcu.rs
+++ b/bin/reth-bench/src/bench/new_payload_fcu.rs
@@ -10,7 +10,6 @@ use crate::{
         output::{
             write_benchmark_results, CombinedResult, NewPayloadResult, TotalGasOutput, TotalGasRow,
         },
-        BigBlockPayload,
     },
     valid_payload::{
         block_to_new_payload, call_forkchoice_updated_with_reth, call_new_payload_with_reth,
@@ -33,7 +32,7 @@ use eyre::{bail, ensure, Context, OptionExt};
 use futures::{stream, Stream, StreamExt, TryStreamExt};
 use reth_cli_runner::CliContext;
 use reth_engine_primitives::config::DEFAULT_PERSISTENCE_THRESHOLD;
-use reth_node_api::{EngineApiMessageVersion, ExecutionPayload};
+use reth_node_api::{BigBlockData, EngineApiMessageVersion, ExecutionPayload};
 use reth_node_core::args::{BenchmarkArgs, WaitForPersistence};
 use reth_rpc_api::{RethNewPayloadInput, TestingBuildBlockRequestV1};
 use std::{
@@ -689,7 +688,7 @@ enum Payload {
     /// A regular block payload.
     Block(AnyRpcBlock, Option<Bytes>, Option<BlockAccessList>, ForkchoiceState),
     /// A big block payload.
-    BigBlock(BigBlockPayload),
+    BigBlock(BigBlockData<ExecutionData>),
 }
 
 impl Payload {
@@ -709,15 +708,13 @@ impl Payload {
                 bal,
             ),
             Self::BigBlock(big_block) => {
-                let wait_for_persistence =
-                    wait_for_persistence.rpc_value(big_block.execution_data.block_number());
+                let wait_for_persistence = wait_for_persistence.rpc_value(big_block.block_number());
                 Ok((
                     None,
                     serde_json::to_value((
-                        RethNewPayloadInput::ExecutionData(big_block.execution_data),
+                        RethNewPayloadInput::ExecutionData(big_block),
                         wait_for_persistence,
                         no_wait_for_caches.then_some(false),
-                        Some(big_block.big_block_data),
                     ))?,
                 ))
             }
@@ -727,35 +724,35 @@ impl Payload {
     fn gas_used(&self) -> u64 {
         match self {
             Self::Block(block, _, _, _) => block.header.gas_used,
-            Self::BigBlock(big_block) => big_block.execution_data.gas_used(),
+            Self::BigBlock(big_block) => big_block.gas_used(),
         }
     }
 
     fn gas_limit(&self) -> u64 {
         match self {
             Self::Block(block, _, _, _) => block.header.gas_limit,
-            Self::BigBlock(big_block) => big_block.execution_data.gas_limit(),
+            Self::BigBlock(big_block) => big_block.gas_limit(),
         }
     }
 
     fn block_number(&self) -> u64 {
         match self {
             Self::Block(block, _, _, _) => block.header.number,
-            Self::BigBlock(big_block) => big_block.execution_data.block_number(),
+            Self::BigBlock(big_block) => big_block.block_number(),
         }
     }
 
     fn parent_hash(&self) -> B256 {
         match self {
             Self::Block(block, _, _, _) => block.header.parent_hash,
-            Self::BigBlock(big_block) => big_block.execution_data.parent_hash(),
+            Self::BigBlock(big_block) => big_block.parent_hash(),
         }
     }
 
     fn transaction_count(&self) -> usize {
         match self {
             Self::Block(block, _, _, _) => block.transactions.len(),
-            Self::BigBlock(big_block) => big_block.execution_data.transaction_count(),
+            Self::BigBlock(big_block) => big_block.transaction_count(),
         }
     }
 
@@ -766,13 +763,13 @@ impl Payload {
         }
     }
 
-    const fn forkchoice_state(&self) -> ForkchoiceState {
+    fn forkchoice_state(&self) -> ForkchoiceState {
         match self {
             Self::Block(_, _, _, forkchoice) => *forkchoice,
             Self::BigBlock(big_block) => ForkchoiceState {
-                head_block_hash: big_block.execution_data.block_hash(),
-                safe_block_hash: big_block.execution_data.block_hash(),
-                finalized_block_hash: big_block.execution_data.block_hash(),
+                head_block_hash: big_block.block_hash(),
+                safe_block_hash: big_block.block_hash(),
+                finalized_block_hash: big_block.block_hash(),
             },
         }
     }
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/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/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/src/tree/payload_processor/bal/execute.rs b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
index a98d1141a00..00754c1ec81 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
@@ -25,10 +25,7 @@ use alloy_evm::{
 };
 use alloy_primitives::Address;
 use crossbeam_channel::{Receiver, Sender};
-use reth_evm::{
-    block::BlockExecutorFactory, execute::ExecutableTxFor, ConfigureEvm, Database, EvmEnvFor,
-    ExecutionCtxFor,
-};
+use reth_evm::{execute::ExecutableTxFor, ConfigureEvm, Database, EvmEnvFor, ExecutionCtxFor};
 use reth_primitives_traits::ReceiptTy;
 use reth_provider::BlockExecutionOutput;
 use reth_tasks::Runtime;
@@ -138,8 +135,7 @@ where
 
         let mut gas_tracker = BlockGasTracker::new(block_gas_limit, is_amsterdam);
         let evm = evm_config.evm_with_env(&mut canonical_state, evm_env);
-        let mut canonical_executor =
-            evm_config.block_executor_factory().create_executor(evm, ctx.clone());
+        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);
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/worker.rs b/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
index ce24a05da40..efd1262dff5 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
@@ -1,15 +1,12 @@
 use super::BalExecutionError;
 use alloy_consensus::Transaction;
 use alloy_evm::{
-    block::{BlockExecutionError, BlockExecutor},
+    block::{BlockExecutionError, BlockExecutor, BlockExecutorFactory},
     Evm,
 };
 use alloy_primitives::Address;
 use crossbeam_channel::{Receiver, Sender};
-use reth_evm::{
-    block::BlockExecutorFactory, execute::ExecutableTxFor, ConfigureEvm, Database, EvmEnvFor,
-    ExecutionCtxFor,
-};
+use reth_evm::{execute::ExecutableTxFor, ConfigureEvm, Database, EvmEnvFor, ExecutionCtxFor};
 use revm::database::State;
 use revm_state::bal::Bal as RevmBal;
 use std::sync::Arc;
@@ -53,8 +50,7 @@ pub(super) fn spawn_worker<'scope, Evm, Tx, Err, DB, MakeDb>(
                 .with_bundle_update()
                 .build();
             let evm = evm_config.evm_with_env(&mut worker_state, evm_env);
-            let mut executor =
-                evm_config.block_executor_factory().create_executor(evm, ctx.clone());
+            let mut executor = evm_config.create_executor_with_state(evm, ctx.clone());
 
             loop {
                 let (index, tx) = crossbeam_channel::select_biased! {
diff --git a/crates/ethereum/engine-primitives/src/payload.rs b/crates/ethereum/engine-primitives/src/payload.rs
index 7f52d8e2a3c..44c40d6160f 100644
--- a/crates/ethereum/engine-primitives/src/payload.rs
+++ b/crates/ethereum/engine-primitives/src/payload.rs
@@ -314,6 +314,13 @@ impl From<EthBuiltPayload> for ExecutionData {
     }
 }
 
+#[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 {
diff --git a/crates/ethereum/node/Cargo.toml b/crates/ethereum/node/Cargo.toml
index 24737c34f19..6ec5804e844 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
diff --git a/crates/ethereum/node/src/lib.rs b/crates/ethereum/node/src/lib.rs
index 60d2c8ee2a7..8b27be1bc78 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;
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,

From db1b5e58894ee1625d6aa2e8a15a281d011284f3 Mon Sep 17 00:00:00 2001
From: onbjerg <onbjerg@users.noreply.github.com>
Date: Tue, 12 May 2026 10:32:28 +0200
Subject: [PATCH 097/335] feat(bench): support txgen big-block benchmarks
 (#24104)

---
 .github/scripts/bench-txgen-build.sh | 22 +++++++----
 .github/scripts/bench-txgen-run.sh   | 56 +++++++++++++++++++---------
 .github/workflows/bench.yml          |  9 ++---
 3 files changed, 58 insertions(+), 29 deletions(-)

diff --git a/.github/scripts/bench-txgen-build.sh b/.github/scripts/bench-txgen-build.sh
index 80b1ab3a753..80329db9cd8 100755
--- a/.github/scripts/bench-txgen-build.sh
+++ b/.github/scripts/bench-txgen-build.sh
@@ -5,19 +5,27 @@
 # 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.
+# build reth-bb because txgen replays reth-bb's extended payload 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"
+if [ -n "${BENCH_BAL:-}" ] && [ "${BENCH_BAL}" != "false" ]; then
+  echo "::error::txgen path does not support BAL replay yet; use big-blocks with the reth-bench driver"
   exit 1
 fi
 
+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
@@ -37,17 +45,17 @@ build_node_binary() {
 
   # shellcheck disable=SC2086
   RUSTFLAGS="-C target-cpu=native${EXTRA_RUSTFLAGS}" \
-    cargo build --locked --profile profiling --bin reth $workspace_arg $features_arg
+    cargo build --locked --profile profiling $NODE_PKG $workspace_arg $features_arg
 }
 
 case "$MODE" in
   baseline|main)
-    echo "Building baseline reth (${COMMIT}) from source for txgen benchmark..."
+    echo "Building baseline ${NODE_BIN} (${COMMIT}) from source for txgen benchmark..."
     build_node_binary
     ;;
 
   feature|branch)
-    echo "Building feature reth (${COMMIT}) from source for txgen benchmark..."
+    echo "Building feature ${NODE_BIN} (${COMMIT}) from source for txgen benchmark..."
     rustup show active-toolchain || rustup default stable
     build_node_binary
     ;;
diff --git a/.github/scripts/bench-txgen-run.sh b/.github/scripts/bench-txgen-run.sh
index e759ab19024..3600a70e952 100755
--- a/.github/scripts/bench-txgen-run.sh
+++ b/.github/scripts/bench-txgen-run.sh
@@ -7,7 +7,8 @@
 # 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_WAIT_TIME, BENCH_BASELINE_ARGS,
+# 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_TRACY, BENCH_TRACY_FILTER, BENCH_TRACY_SAMPLING_HZ
@@ -16,18 +17,19 @@ set -euxo pipefail
 LABEL="$1"
 BINARY="$2"
 OUTPUT_DIR="$3"
-DATADIR="$SCHELK_MOUNT/datadir"
+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"
 
 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
+# Unsupported txgen-path behavior is made explicit here. Keep this check near
+# the top so BAL support can be added when txgen supports it.
 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
@@ -54,6 +56,7 @@ cleanup() {
   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
@@ -157,12 +160,13 @@ if [ -n "${OTEL_RESOURCE_ATTRIBUTES:-}" ]; then
 fi
 
 TOTAL_MEM_KB=$(awk '/^MemTotal:/ {print $2}' /proc/meminfo)
-MEM_LIMIT=$(( TOTAL_MEM_KB * 95 / 100 * 1024 ))
+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)
   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 \
@@ -171,6 +175,7 @@ if [ "${BENCH_SAMPLY:-false}" = "true" ]; then
     -- "$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[@]}" \
@@ -242,15 +247,33 @@ 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"
+if [ "$BIG_BLOCKS" = "true" ]; then
+  ALL_BIG_BLOCKS="$TXGEN_DIR/all-big-blocks.ndjson"
+  WARMUP_BIG_BLOCKS="$TXGEN_DIR/warmup-big-blocks.ndjson"
+  MEASURED_BIG_BLOCKS="$TXGEN_DIR/measured-big-blocks.ndjson"
+  ALL_BLOCKS="$ALL_BIG_BLOCKS"
+  WARMUP_BLOCKS="$WARMUP_BIG_BLOCKS"
+  BENCHMARK_BLOCKS="$MEASURED_BIG_BLOCKS"
+fi
 
 EXTRACT_FROM=$(( HEAD_DEC + 1 ))
-EXTRACT_TO=$(( HEAD_DEC + TOTAL ))
-echo "Extracting blocks ${EXTRACT_FROM}..${EXTRACT_TO} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured)"
-"$TXGEN_ETHEREUM" extract \
-  --rpc "$BENCH_RPC_URL" \
-  --from "$EXTRACT_FROM" \
-  --to "$EXTRACT_TO" \
-  -o "$ALL_BLOCKS"
+if [ "$BIG_BLOCKS" = "true" ]; then
+  echo "Extracting ${TOTAL} big blocks from ${EXTRACT_FROM} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured)"
+  "$TXGEN_ETHEREUM" extract-big-blocks \
+    --rpc "$BENCH_RPC_URL" \
+    --from "$EXTRACT_FROM" \
+    --count "$TOTAL" \
+    --target-gas "${BENCH_BIG_BLOCKS_TARGET_GAS:-1G}" \
+    -o "$ALL_BIG_BLOCKS"
+else
+  EXTRACT_TO=$(( HEAD_DEC + TOTAL ))
+  echo "Extracting blocks ${EXTRACT_FROM}..${EXTRACT_TO} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured)"
+  "$TXGEN_ETHEREUM" extract \
+    --rpc "$BENCH_RPC_URL" \
+    --from "$EXTRACT_FROM" \
+    --to "$EXTRACT_TO" \
+    -o "$ALL_BLOCKS"
+fi
 
 if [ "$WARMUP" -gt 0 ] 2>/dev/null; then
   head -n "$WARMUP" "$ALL_BLOCKS" > "$WARMUP_BLOCKS"
@@ -280,7 +303,6 @@ if [ "${BENCH_TRACY:-off}" != "off" ]; then
 fi
 
 # 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 \
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index d2162a30079..40ecae43f4c 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -393,7 +393,6 @@ jobs:
             }
 
             const fallbackReasons = [];
-            if (bigBlocks === 'true') fallbackReasons.push('big-blocks');
             if (bal !== 'false') fallbackReasons.push('BAL');
             const driver = fallbackReasons.length ? 'reth-bench' : 'txgen';
             const nodeBin = bigBlocks === 'true' ? 'reth-bb' : 'reth';
@@ -496,7 +495,7 @@ jobs:
             const baselineArgsNote = baselineArgsVal ? `, baseline-args: \`${baselineArgsVal}\`` : '';
             const featureArgsVal = '${{ steps.args.outputs.feature-args }}';
             const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
-            const driver = '${{ steps.args.outputs.driver }}' || (bigBlocks ? 'reth-bench' : 'txgen');
+            const driver = '${{ steps.args.outputs.driver }}' || (bal !== 'false' ? 'reth-bench' : 'txgen');
             const driverReason = '${{ steps.args.outputs.driver-reason }}';
             const driverNote = driverReason ? `, driver: \`${driver}\` (fallback: \`${driverReason}\`)` : `, driver: \`${driver}\``;
             const blocksDesc = bigBlocks ? 'blocks: `big`' : `${blocks} blocks, ${warmup} warmup blocks`;
@@ -543,7 +542,7 @@ jobs:
             const baselineArgsNote = baselineArgsVal ? `, baseline-args: \`${baselineArgsVal}\`` : '';
             const featureArgsVal = '${{ steps.args.outputs.feature-args }}';
             const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
-            const driver = '${{ steps.args.outputs.driver }}' || (bigBlocks ? 'reth-bench' : 'txgen');
+            const driver = '${{ steps.args.outputs.driver }}' || (bal !== 'false' ? 'reth-bench' : 'txgen');
             const driverReason = '${{ steps.args.outputs.driver-reason }}';
             const driverNote = driverReason ? `, driver: \`${driver}\` (fallback: \`${driverReason}\`)` : `, driver: \`${driver}\``;
             const blocksDesc = bigBlocks ? 'blocks: `big`' : `${blocks} blocks, ${warmup} warmup blocks`;
@@ -632,7 +631,7 @@ jobs:
       BENCH_DRIVER_REASON: ${{ needs.reth-bench-ack.outputs.driver-reason }}
       BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
       BENCH_METRICS_ADDR: "127.0.0.1:9001"
-      TXGEN_REV: 5b04a80d557cc6658573db6ccf49ce04cbf07ea3
+      TXGEN_REV: 64826ac816380586e4856e2d1d2d20f4d4e66198
       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:
@@ -702,7 +701,7 @@ 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 driver = process.env.BENCH_DRIVER || (bal !== 'false' ? 'reth-bench' : 'txgen');
             const driverReason = process.env.BENCH_DRIVER_REASON || '';
             const driverNote = driverReason ? `, driver: \`${driver}\` (fallback: \`${driverReason}\`)` : `, driver: \`${driver}\``;
             const blocksDesc = bigBlocks ? 'blocks: `big`' : `${blocks} blocks, ${warmup} warmup blocks`;

From 596323794e32798451f53b567be990e918edec82 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 12 May 2026 11:04:05 +0200
Subject: [PATCH 098/335] fix(net): validate downloaded block access list
 hashes (#24113)

---
 Cargo.lock                       |   1 -
 crates/net/p2p/Cargo.toml        |   2 -
 crates/net/p2p/src/full_block.rs | 392 ++++++++++++++++++++++++-------
 3 files changed, 309 insertions(+), 86 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 79506998d4c..1f4a4b5bdf7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9082,7 +9082,6 @@ name = "reth-network-p2p"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eip7928",
  "alloy-eips 2.0.4",
  "alloy-primitives",
  "auto_impl",
diff --git a/crates/net/p2p/Cargo.toml b/crates/net/p2p/Cargo.toml
index 7098642e27c..d6a5978932e 100644
--- a/crates/net/p2p/Cargo.toml
+++ b/crates/net/p2p/Cargo.toml
@@ -23,7 +23,6 @@ reth-storage-errors.workspace = true
 
 # ethereum
 alloy-consensus.workspace = true
-alloy-eip7928.workspace = true
 alloy-eips.workspace = true
 alloy-primitives = { workspace = true, features = ["rand"] }
 
@@ -56,7 +55,6 @@ test-utils = [
 std = [
     "reth-consensus/std",
     "reth-ethereum-primitives/std",
-    "alloy-eip7928/std",
     "alloy-eips/std",
     "alloy-primitives/std",
     "reth-primitives-traits/std",
diff --git a/crates/net/p2p/src/full_block.rs b/crates/net/p2p/src/full_block.rs
index 0feadb984f6..d1692373592 100644
--- a/crates/net/p2p/src/full_block.rs
+++ b/crates/net/p2p/src/full_block.rs
@@ -9,8 +9,7 @@ use crate::{
     BlockClient,
 };
 use alloy_consensus::BlockHeader;
-use alloy_eip7928::bal::Bal;
-use alloy_primitives::{Sealable, B256};
+use alloy_primitives::{keccak256, Bytes, Sealable, Sealed, B256};
 use core::marker::PhantomData;
 use futures::FutureExt;
 use reth_consensus::Consensus;
@@ -29,15 +28,24 @@ use std::{
     sync::Arc,
     task::{ready, Context, Poll},
 };
-use tracing::debug;
+use tracing::{debug, trace};
+
+/// RLP encoding for an empty list.
+const EMPTY_LIST_CODE: u8 = 0xc0;
 
 /// A sealed block with associated data.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SealedBlockWith<B: Block, T = Option<Bal>> {
+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 {
@@ -60,14 +68,19 @@ impl<B: Block, T> SealedBlockWith<B, T> {
     }
 }
 
-impl<B: Block> SealedBlockWith<B, Option<BlockAccessLists>> {
+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.
-    pub const fn access_lists(&self) -> Option<&BlockAccessLists> {
+    /// 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()
     }
 }
@@ -153,7 +166,7 @@ impl<Client> FullBlockClient<Client>
 where
     Client: BlockClient + BlockAccessListsClient,
 {
-    /// Returns a future that fetches the [`SealedBlock`] and optionally its [`BlockAccessLists`]
+    /// Returns a future that fetches the [`SealedBlock`] and optionally its block access list
     /// for the given hash.
     ///
     /// Note: this future is cancel safe
@@ -167,7 +180,7 @@ where
         self.get_full_block_with_access_lists_with_requirement(hash, BalRequirement::default())
     }
 
-    /// Returns a future that fetches the [`SealedBlock`] and optionally its [`BlockAccessLists`]
+    /// 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
@@ -189,7 +202,7 @@ where
         }
     }
 
-    /// Returns a future that fetches [`SealedBlock`]s and optionally their [`BlockAccessLists`] for
+    /// 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
@@ -207,7 +220,7 @@ where
         )
     }
 
-    /// Returns a future that fetches [`SealedBlock`]s and optionally their [`BlockAccessLists`] for
+    /// 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
@@ -434,7 +447,11 @@ where
                 let (peer, access_lists) = bal.split();
                 match access_lists.0.len() {
                     0 => self.bal_request_state = BalRequestState::Ready(None),
-                    1 => self.bal_request_state = BalRequestState::Ready(Some(access_lists)),
+                    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",
@@ -467,12 +484,19 @@ where
     /// 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<SealedBlockWith<Client::Block, Option<BlockAccessLists>>> {
-        let BalRequestState::Ready(access_lists) = &mut self.bal_request_state else { return None };
+    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()?;
-        Some(SealedBlockWith::new(block, access_lists.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))
     }
 }
 
@@ -480,7 +504,7 @@ impl<Client> Future for FetchFullBlockWithBalFuture<Client>
 where
     Client: BlockClient<Header: BlockHeader + Sealable> + BlockAccessListsClient + 'static,
 {
-    type Output = SealedBlockWith<Client::Block, Option<BlockAccessLists>>;
+    type Output = SealedBlockWithAccessList<Client::Block>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
@@ -517,7 +541,7 @@ where
 /// Tracks the BAL request and its completed result.
 enum BalRequestState<Req> {
     Pending(Req),
-    Ready(Option<BlockAccessLists>),
+    Ready(Option<WithPeerId<Bytes>>),
 }
 
 impl<Req> BalRequestState<Req> {
@@ -565,30 +589,6 @@ where
         );
     }
 
-    fn on_access_lists_response(&mut self, response: WithPeerId<BlockAccessLists>) {
-        let (peer, access_lists) = response.split();
-        let expected =
-            self.block_result.as_ref().expect("blocks should be ready before BAL response").len();
-        let received = access_lists.0.len();
-
-        if received > expected {
-            debug!(
-                target: "downloaders",
-                start_hash = ?self.blocks.start_hash(),
-                expected,
-                received,
-                "Received wrong access list range response",
-            );
-            self.client.report_bad_message(peer);
-            self.access_lists = OptionalBlockAccessListsState::Ready(None);
-            return
-        }
-
-        // Short BAL responses are allowed by the wire protocol. Preserve the returned prefix and
-        // let callers decide whether they need to fetch the remaining entries.
-        self.access_lists = OptionalBlockAccessListsState::Ready(Some(access_lists));
-    }
-
     /// 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();
@@ -601,7 +601,9 @@ where
 
         match poll {
             Poll::Pending => {}
-            Poll::Ready(Ok(access_lists)) => self.on_access_lists_response(access_lists),
+            Poll::Ready(Ok(access_lists)) => {
+                self.access_lists = OptionalBlockAccessListsState::Ready(Some(access_lists));
+            }
             Poll::Ready(Err(err)) => {
                 debug!(
                     target: "downloaders",
@@ -618,29 +620,14 @@ where
     }
 
     /// Returns the block range once blocks and the optional BAL lookup are both complete.
-    fn take_response(
-        &mut self,
-    ) -> Option<Vec<SealedBlockWith<Client::Block, Option<BlockAccessLists>>>> {
+    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()?;
-        let mut access_lists = access_lists.take().map(|access_lists| access_lists.0.into_iter());
-
-        Some(
-            blocks
-                .into_iter()
-                .map(|block| {
-                    let access_lists = access_lists
-                        .as_mut()
-                        .and_then(|access_lists| access_lists.next())
-                        .map(|access_list| BlockAccessLists(vec![access_list]));
 
-                    SealedBlockWith::new(block, access_lists)
-                })
-                .collect(),
-        )
+        Some(seal_blocks_with_access_lists(&self.client, blocks, access_lists.take()))
     }
 }
 
@@ -650,7 +637,7 @@ where
         + BlockAccessListsClient
         + 'static,
 {
-    type Output = Vec<SealedBlockWith<Client::Block, Option<BlockAccessLists>>>;
+    type Output = Vec<SealedBlockWithAccessList<Client::Block>>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
@@ -682,7 +669,7 @@ enum OptionalBlockAccessListsState<Req> {
     /// A `GetBlockAccessLists` request is in flight.
     Pending(Req),
     /// `None` means the block range is available but optional BAL data is not.
-    Ready(Option<BlockAccessLists>),
+    Ready(Option<WithPeerId<BlockAccessLists>>),
 }
 
 impl<Client> Debug for FetchFullBlockFuture<Client>
@@ -1175,13 +1162,106 @@ 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 the RLP empty-list unavailable marker, and `Err(peer)` for a non-empty 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<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 computed = keccak256(access_list.as_ref());
+    if computed == expected {
+        return Ok(Some(Sealed::new_unchecked(access_list, expected)))
+    }
+
+    // A mismatched RLP empty list means the peer returned the "unavailable" BAL entry.
+    if access_list.as_ref() == [EMPTY_LIST_CODE] {
+        return Ok(None)
+    }
+
+    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, Bytes};
     use parking_lot::Mutex;
     use std::{
         collections::HashMap,
@@ -1193,13 +1273,23 @@ mod tests {
     };
     use tokio::time::{timeout, Duration};
 
-    // RLP encoding for an empty list.
-    const EMPTY_LIST_CODE: u8 = 0xc0;
+    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: &[SealedBlockWith<B, Option<BlockAccessLists>>],
-    ) -> Vec<Option<BlockAccessLists>> {
-        blocks.iter().map(|block| block.access_lists().cloned()).collect()
+        blocks: &[SealedBlockWithAccessList<B>],
+    ) -> Vec<Option<Sealed<Bytes>>> {
+        blocks.iter().map(|block| block.access_list().cloned()).collect()
     }
 
     #[tokio::test]
@@ -1230,27 +1320,28 @@ 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 = 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(), Some(&BlockAccessLists(vec![access_list])));
+        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_uses_requested_requirement() {
         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 requirement = Arc::clone(&client.last_access_list_requirement);
@@ -1263,8 +1354,9 @@ mod tests {
             )
             .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(), Some(&BlockAccessLists(vec![access_list])));
+        assert_eq!(received.access_list(), Some(&expected_access_list));
         assert_eq!(*requirement.lock(), Some(BalRequirement::Mandatory));
     }
 
@@ -1273,9 +1365,9 @@ mod tests {
         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);
@@ -1286,19 +1378,64 @@ mod tests {
                 .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_lists(), Some(&BlockAccessLists(vec![access_list])));
+        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 =
+            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_treats_empty_entry_as_unavailable() {
+        let client = FullBlockWithAccessListsClient::default();
+        let body = BlockBody::default();
+        let expected_access_list = Bytes::from_static(&[0xc1, 0x01]);
+        let unavailable_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(), unavailable_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), 0);
+    }
+
     #[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 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);
@@ -1311,7 +1448,7 @@ mod tests {
                 .expect("block request should complete without access lists");
 
         assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
-        assert!(received.access_lists().is_none());
+        assert!(received.access_list().is_none());
         assert_eq!(request_count.load(Ordering::SeqCst), 1);
         assert_eq!(bad_messages.load(Ordering::SeqCst), 0);
     }
@@ -1321,9 +1458,9 @@ mod tests {
         let client = FullBlockWithAccessListsClient::default();
         client.set_access_lists_unsupported(true);
 
-        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);
 
         let request_count = Arc::clone(&client.access_list_requests);
@@ -1336,7 +1473,7 @@ mod tests {
                 .expect("block request should complete without access lists");
 
         assert_eq!(received.block(), &SealedBlock::from_sealed_parts(header, body));
-        assert!(received.access_lists().is_none());
+        assert!(received.access_list().is_none());
         assert_eq!(request_count.load(Ordering::SeqCst), 1);
         assert_eq!(
             *requirement.lock(),
@@ -1431,9 +1568,10 @@ mod tests {
             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);
-            let access_list = Bytes::from(vec![EMPTY_LIST_CODE, block_idx as u8]);
 
             client.insert(sealed_header.clone(), body.clone(), access_list);
         }
@@ -1700,7 +1838,7 @@ mod tests {
                         .get(&block.block().hash())
                         .cloned()
                         .expect("access list exists");
-                    Some(BlockAccessLists(vec![access_list]))
+                    Some(sealed_access_list(access_list))
                 })
                 .collect::<Vec<_>>()
         };
@@ -1786,7 +1924,7 @@ mod tests {
                         .get(&block.block().hash())
                         .cloned()
                         .expect("access list exists");
-                    Some(BlockAccessLists(vec![access_list]))
+                    Some(sealed_access_list(access_list))
                 })
                 .collect::<Vec<_>>()
         };
@@ -1794,6 +1932,45 @@ mod tests {
         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().insert(header.hash(), Bytes::from_static(&[EMPTY_LIST_CODE]));
+
+        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();
@@ -1816,7 +1993,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn download_full_block_range_with_access_lists_rejects_long_response() {
+    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);
@@ -1835,6 +2012,55 @@ mod tests {
         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);
     }
 

From 4941d4ed2f5c31bade61b19c52c22facb62d1512 Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Tue, 12 May 2026 11:47:12 +0200
Subject: [PATCH 099/335] fix(bench): sync big-block weekly snapshots (#24072)

Co-authored-by: Brian Picciano <933154+mediocregopher@users.noreply.github.com>
Co-authored-by: Amp <amp@ampcode.com>
Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/scripts/bench-reth-snapshot.sh | 63 +++++++++++++++-----------
 .github/workflows/bench.yml            | 27 -----------
 2 files changed, 37 insertions(+), 53 deletions(-)

diff --git a/.github/scripts/bench-reth-snapshot.sh b/.github/scripts/bench-reth-snapshot.sh
index ca29801e1a9..fa118cfa17c 100755
--- a/.github/scripts/bench-reth-snapshot.sh
+++ b/.github/scripts/bench-reth-snapshot.sh
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 #
-# Ensures the benchmark snapshot in the schelk volume matches the configured
+# 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.
@@ -10,11 +10,14 @@
 #
 # Required env:
 #   SCHELK_MOUNT       - schelk mount point (e.g. /reth-bench)
-#   BENCH_SNAPSHOT_MANIFEST_URL - exact manifest URL to sync from
 #   BENCH_RETH_BINARY  - path to the reth-compatible binary (required to refresh)
 #
 # Optional env:
 #   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
 
@@ -37,6 +40,36 @@ 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
     printf '%s' "${BENCH_SNAPSHOT_NAME}"
@@ -52,28 +85,6 @@ EXPECTED_SNAPSHOT="$(describe_snapshot)"
 sudo schelk recover -y --kill || sudo schelk full-recover -y || true
 sudo schelk mount -y
 
-if [ "${BENCH_BIG_BLOCKS:-false}" = "true" ]; then
-  if [ -d "$DATADIR/db" ] && [ -d "$DATADIR/static_files" ]; then
-    echo "Found local ${EXPECTED_SNAPSHOT} at ${DATADIR}; skipping manifest sync for big-block benchmarks"
-    exit 0
-  fi
-
-  echo "::error::Missing local ${EXPECTED_SNAPSHOT} at ${DATADIR}. Big-block benchmarks require a pre-populated schelk data volume."
-  ls -la "$SCHELK_MOUNT" || true
-  ls -la "$DATADIR" || true
-
-  if [ "$CHECK_ONLY" = true ]; then
-    exit 10
-  fi
-
-  exit 1
-fi
-
-: "${BENCH_SNAPSHOT_MANIFEST_URL:?BENCH_SNAPSHOT_MANIFEST_URL must be set}"
-
-MANIFEST_URL="$BENCH_SNAPSHOT_MANIFEST_URL"
-MANIFEST_BASE_URL="${MANIFEST_URL%/*}"
-
 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")"
@@ -92,10 +103,10 @@ sha256_file() {
   fi
 }
 
-echo "Using snapshot manifest from BENCH_SNAPSHOT_MANIFEST_URL"
+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 BENCH_SNAPSHOT_MANIFEST_URL"
+  echo "::error::Failed to fetch snapshot manifest from ${MANIFEST_URL}"
   exit 2
 fi
 
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 40ecae43f4c..579bb971dd3 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -846,29 +846,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"
-          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
-
-          echo "Big-blocks base snapshot: $BASE_SNAPSHOT"
-          echo "BENCH_SNAPSHOT_NAME=${BASE_SNAPSHOT}" >> "$GITHUB_ENV"
-
       - name: Prepare source dirs
         run: |
           prepare_source_dir() {
@@ -1447,9 +1424,7 @@ jobs:
           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 }}']] : []),
               ['building binaries', '${{ steps.build.outcome }}'],
               ['syncing snapshot', '${{ steps.snapshot-check.outcome }}'],
               ['running feature benchmark (1/2)', '${{ steps.run-feature-1.outcome }}'],
@@ -1485,9 +1460,7 @@ jobs:
         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 }}']] : []),
               ['building binaries', '${{ steps.build.outcome }}'],
               ['syncing snapshot', '${{ steps.snapshot-check.outcome }}'],
               ['running feature benchmark (1/2)', '${{ steps.run-feature-1.outcome }}'],

From b5886caf30270bc24cf618f865115f46fdb0a767 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 12 May 2026 03:01:17 -0700
Subject: [PATCH 100/335] feat(otlp): make service.version configurable
 (#24142)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 crates/node/core/src/args/trace.rs | 25 ++++++++++++++++++--
 crates/tracing-otlp/src/lib.rs     | 37 +++++++++++++++++++++++++-----
 2 files changed, 54 insertions(+), 8 deletions(-)

diff --git a/crates/node/core/src/args/trace.rs b/crates/node/core/src/args/trace.rs
index 58371940359..d6eaeedfe2e 100644
--- a/crates/node/core/src/args/trace.rs
+++ b/crates/node/core/src/args/trace.rs
@@ -115,6 +115,20 @@ pub struct TraceArgs {
     )]
     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
@@ -143,6 +157,7 @@ impl Default for TraceArgs {
             logs_otlp_filter: EnvFilter::try_new("info").expect("valid filter"),
             sample_ratio: None,
             service_name: "reth".to_string(),
+            service_version: None,
         }
     }
 }
@@ -168,12 +183,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 +219,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/tracing-otlp/src/lib.rs b/crates/tracing-otlp/src/lib.rs
index bd0549b4a34..f4c24adb1ee 100644
--- a/crates/tracing-otlp/src/lib.rs
+++ b/crates/tracing-otlp/src/lib.rs
@@ -38,7 +38,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 +86,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 +113,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 +139,19 @@ impl OtlpConfig {
             );
         }
 
-        Ok(Self { service_name: service_name.into(), endpoint, protocol, sample_ratio })
+        Ok(Self {
+            service_name: service_name.into(),
+            service_version: None,
+            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 +180,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 +195,13 @@ impl OtlpLogsConfig {
         endpoint: Url,
         protocol: OtlpProtocol,
     ) -> eyre::Result<Self> {
-        Ok(Self { service_name: service_name.into(), endpoint, protocol })
+        Ok(Self { service_name: service_name.into(), service_version: None, 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,10 +221,11 @@ 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()
 }
 

From f1279719df7cc1d7bf0c87a92f466f7f2e64a9c7 Mon Sep 17 00:00:00 2001
From: Karl Yu <43113774+0xKarl98@users.noreply.github.com>
Date: Tue, 12 May 2026 18:50:59 +0800
Subject: [PATCH 101/335] feat(engine): return BAL in payload bodies by hash v2
 (#24128)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/rpc/rpc-engine-api/src/engine_api.rs | 119 +++++++++++++++++---
 1 file changed, 105 insertions(+), 14 deletions(-)

diff --git a/crates/rpc/rpc-engine-api/src/engine_api.rs b/crates/rpc/rpc-engine-api/src/engine_api.rs
index e376c509a00..de865cbbe7a 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, B128, B256, U64};
 use alloy_rpc_types_engine::{
     CancunPayloadFields, ClientVersionV1, ExecutionData, ExecutionPayloadBodiesV1,
     ExecutionPayloadBodiesV2, ExecutionPayloadBodyV1, ExecutionPayloadBodyV2,
@@ -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>,
@@ -294,7 +294,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>,
@@ -759,6 +759,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 +813,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 +1102,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>,
@@ -1498,8 +1533,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 +1548,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 +1605,62 @@ 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());
+    }
+
     struct EngineApiTestHandle {
         #[allow(dead_code)]
         chain_spec: Arc<ChainSpec>,

From 8d21649eb8ca7ab32258c680e26cac66cbedda02 Mon Sep 17 00:00:00 2001
From: 0xsensei <prblmslvr.aditya@gmail.com>
Date: Tue, 12 May 2026 16:26:38 +0530
Subject: [PATCH 102/335] test(engine): add coverage for BAL executor error
 paths and gas tracker (#24137)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 .../src/tree/payload_processor/bal/execute.rs | 200 ++++++++++++++++++
 1 file changed, 200 insertions(+)

diff --git a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
index 00754c1ec81..d26a73b4ea4 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
@@ -1016,4 +1016,204 @@ mod tests {
 
         assert_shadow_equal(evm_config, db, empty_amsterdam_block(B256::ZERO), vec![tx]);
     }
+
+    #[test]
+    fn rejects_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, so the final hash check
+        // must fail.
+        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(
+            &Runtime::test(),
+            evm_config,
+            db_factory(system_contracts_db()),
+            received,
+            &block,
+            Vec::<Recovered<TransactionSigned>>::new(),
+        );
+
+        match result {
+            Err(BalExecutionError::Reject(RejectReason::FinalHashMismatch {
+                rebuilt,
+                expected,
+            })) => {
+                assert_ne!(rebuilt, expected, "rebuilt and expected hashes must differ");
+            }
+            Err(e) => panic!("expected FinalHashMismatch, got {e:?}"),
+            Ok(_) => panic!("expected FinalHashMismatch, got Ok"),
+        }
+    }
+
+    #[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_evm_error() {
+        // A tx recovery failure fed into the worker channel must surface as
+        // BalExecutionError::Evm. 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 result = execute_block(
+            &Runtime::test(),
+            &evm_config,
+            &db_factory(system_contracts_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::Evm(_))),
+            "expected Evm 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);
+        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);
+        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,
+        };
+        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);
+        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);
+        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",
+        );
+    }
 }

From aa6e5ff7b2523b1cb8b5d4ac95948c77379c75d1 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 12 May 2026 04:03:29 -0700
Subject: [PATCH 103/335] bench: set OTLP service.version to baseline/feature
 label (#24143)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/scripts/bench-reth-run.sh  | 2 +-
 .github/scripts/bench-txgen-run.sh | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/scripts/bench-reth-run.sh b/.github/scripts/bench-reth-run.sh
index 96b999d97c7..c74bacbe0b0 100755
--- a/.github/scripts/bench-reth-run.sh
+++ b/.github/scripts/bench-reth-run.sh
@@ -157,7 +157,7 @@ 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)
+    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)
diff --git a/.github/scripts/bench-txgen-run.sh b/.github/scripts/bench-txgen-run.sh
index 3600a70e952..ca1b96eccd2 100755
--- a/.github/scripts/bench-txgen-run.sh
+++ b/.github/scripts/bench-txgen-run.sh
@@ -137,7 +137,7 @@ 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)
+    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)

From e8374ae8b5b4ba7f504604f30e3373f4e80f4aa9 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 12 May 2026 04:20:33 -0700
Subject: [PATCH 104/335] ci(bench): bump BENCH_RUNNERS from 2 to 4 (#24146)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/workflows/bench.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 579bb971dd3..6da15e3326b 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -95,7 +95,7 @@ on:
 env:
   CARGO_TERM_COLOR: always
   RUSTC_WRAPPER: "sccache"
-  BENCH_RUNNERS: 2
+  BENCH_RUNNERS: 4
 
 name: bench
 

From 8248a24288af0550137bc79b958cddd598c315b8 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 12 May 2026 04:22:05 -0700
Subject: [PATCH 105/335] feat(otlp): add DefaultTraceValues for overridable
 service identity (#24145)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 crates/node/core/src/args/mod.rs   |  2 +-
 crates/node/core/src/args/trace.rs | 51 ++++++++++++++++++++++++++++--
 2 files changed, 49 insertions(+), 4 deletions(-)

diff --git a/crates/node/core/src/args/mod.rs b/crates/node/core/src/args/mod.rs
index f885111cb42..28a55b24099 100644
--- a/crates/node/core/src/args/mod.rs
+++ b/crates/node/core/src/args/mod.rs
@@ -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;
diff --git a/crates/node/core/src/args/trace.rs b/crates/node/core/src/args/trace.rs
index d6eaeedfe2e..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,7 +153,7 @@ 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"
     )]
@@ -149,6 +193,7 @@ pub struct TraceArgs {
 
 impl Default for TraceArgs {
     fn default() -> Self {
+        let defaults = DefaultTraceValues::get_global();
         Self {
             otlp: None,
             logs_otlp: None,
@@ -156,8 +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_version: None,
+            service_name: defaults.service_name.clone(),
+            service_version: defaults.service_version.clone(),
         }
     }
 }

From 157b1fc70db9a9dfa165316bf2bab5c3fb71c89c Mon Sep 17 00:00:00 2001
From: Karl Yu <43113774+0xKarl98@users.noreply.github.com>
Date: Tue, 12 May 2026 19:56:08 +0800
Subject: [PATCH 106/335] feat(debug-client): support block access list payload
 conversion (#23989)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
Co-authored-by: Arsenii Kulikov <klkvrr@gmail.com>
---
 Cargo.lock                                    |  1 +
 bin/reth-bb/src/main.rs                       |  2 +
 crates/consensus/debug-client/Cargo.toml      |  1 +
 .../debug-client/src/providers/rpc.rs         | 59 +++++++++++++++++--
 crates/engine/util/src/reorg.rs               |  2 +-
 crates/ethereum/engine-primitives/src/lib.rs  | 12 +++-
 crates/ethereum/node/src/node.rs              |  8 +--
 crates/node/builder/src/launch/debug.rs       | 30 +++++++---
 crates/payload/primitives/src/lib.rs          |  1 +
 .../rpc/rpc-engine-api/src/reth_engine_api.rs |  2 +-
 examples/bsc-p2p/src/block_import/service.rs  |  2 +-
 examples/custom-engine-types/src/main.rs      |  3 +-
 12 files changed, 96 insertions(+), 27 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1f4a4b5bdf7..2ca0f654d6a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7893,6 +7893,7 @@ dependencies = [
 name = "reth-consensus-debug-client"
 version = "2.2.0"
 dependencies = [
+ "alloy-consensus",
  "alloy-eips 2.0.4",
  "alloy-json-rpc",
  "alloy-primitives",
diff --git a/bin/reth-bb/src/main.rs b/bin/reth-bb/src/main.rs
index e03c6cab3eb..3e02da66d0a 100644
--- a/bin/reth-bb/src/main.rs
+++ b/bin/reth-bb/src/main.rs
@@ -33,6 +33,7 @@ use reth_node_ethereum::{
 };
 use reth_primitives_traits::SealedBlock;
 use reth_provider::EthStorage;
+use revm_primitives::Bytes;
 use tracing::info;
 
 #[derive(Debug, Clone, Default)]
@@ -47,6 +48,7 @@ impl PayloadTypes for BbPayloadTypes {
         _block: SealedBlock<
                 <<Self::BuiltPayload as reth_node_api::BuiltPayload>::Primitives as reth_node_api::NodePrimitives>::Block,
             >,
+        _bal: Option<Bytes>,
     ) -> Self::ExecutionData {
         unreachable!()
     }
diff --git a/crates/consensus/debug-client/Cargo.toml b/crates/consensus/debug-client/Cargo.toml
index 64ed9f7ebf9..2fdb84a46e9 100644
--- a/crates/consensus/debug-client/Cargo.toml
+++ b/crates/consensus/debug-client/Cargo.toml
@@ -16,6 +16,7 @@ reth-node-api.workspace = true
 reth-tracing.workspace = true
 
 # ethereum
+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/providers/rpc.rs b/crates/consensus/debug-client/src/providers/rpc.rs
index 03680d3efa2..76f7aaa63fa 100644
--- a/crates/consensus/debug-client/src/providers/rpc.rs
+++ b/crates/consensus/debug-client/src/providers/rpc.rs
@@ -1,5 +1,11 @@
 use crate::PayloadProvider;
-use alloy_provider::{ConnectionConfig, Network, Provider, ProviderBuilder, WebSocketConfig};
+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::ExecutionPayload;
@@ -14,15 +20,16 @@ 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) -> ExecutionData + Send + Sync>,
+    convert: Arc<dyn Fn(N::BlockResponse, PayloadExtras) -> ExecutionData + Send + Sync>,
 }
 
 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) -> ExecutionData + 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, ExecutionData> RpcBlockProvider<N, ExecutionData> {
                     .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,6 +78,39 @@ impl<N: Network, ExecutionData> RpcBlockProvider<N, ExecutionData> {
             }
         }
     }
+
+    /// 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, ExecutionData> PayloadProvider for RpcBlockProvider<N, ExecutionData>
@@ -94,7 +141,8 @@ where
             while let Some(res) = stream.next().await {
                 match res {
                     Ok(block) => {
-                        let payload = (self.convert)(block);
+                        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;
@@ -126,6 +174,7 @@ where
             .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/engine/util/src/reorg.rs b/crates/engine/util/src/reorg.rs
index 13390cef433..32a3f992cbc 100644
--- a/crates/engine/util/src/reorg.rs
+++ b/crates/engine/util/src/reorg.rs
@@ -194,7 +194,7 @@ where
                         BeaconEngineMessage::NewPayload { payload, tx },
                         // Reorg payload
                         BeaconEngineMessage::NewPayload {
-                            payload: T::block_to_payload(reorg_block),
+                            payload: T::block_to_payload(reorg_block, None),
                             tx: reorg_payload_tx,
                         },
                         // Reorg forkchoice state
diff --git a/crates/ethereum/engine-primitives/src/lib.rs b/crates/ethereum/engine-primitives/src/lib.rs
index e08dbc22b42..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;
@@ -52,8 +53,9 @@ where
         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)
     }
 }
 
@@ -91,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/node/src/node.rs b/crates/ethereum/node/src/node.rs
index be1219982e2..eca9d36fbdc 100644
--- a/crates/ethereum/node/src/node.rs
+++ b/crates/ethereum/node/src/node.rs
@@ -452,12 +452,8 @@ where
 impl<N: FullNodeComponents<Types = Self>> DebugNode<N> for EthereumNode {
     type RpcBlock = alloy_rpc_types_eth::Block;
 
-    fn rpc_to_execution_data(rpc_block: Self::RpcBlock) -> ExecutionData {
-        let (block, hash) = rpc_block.into_consensus_sealed().into_parts();
-        ExecutionData::from_block_unchecked(
-            hash,
-            &block.convert_transactions::<TransactionSigned>(),
-        )
+    fn rpc_to_primitive_block(rpc_block: Self::RpcBlock) -> reth_ethereum_primitives::Block {
+        rpc_block.into_consensus().convert_transactions()
     }
 
     fn local_payload_attributes_builder(
diff --git a/crates/node/builder/src/launch/debug.rs b/crates/node/builder/src/launch/debug.rs
index c8e1207fafe..0f870f51ac9 100644
--- a/crates/node/builder/src/launch/debug.rs
+++ b/crates/node/builder/src/launch/debug.rs
@@ -9,9 +9,10 @@ use reth_consensus_debug_client::{
 };
 use reth_engine_local::{LocalMiner, MiningMode};
 use reth_node_api::{
-    FullNodeComponents, FullNodeTypes, HeaderTy, NodeTypes, PayloadAttrTy,
+    BlockTy, FullNodeComponents, FullNodeTypes, HeaderTy, NodeTypes, PayloadAttrTy,
     PayloadAttributesBuilder, PayloadTypes,
 };
+use reth_primitives_traits::SealedBlock;
 use std::{
     future::{Future, IntoFuture},
     pin::Pin,
@@ -51,6 +52,7 @@ pub(crate) type PayloadDataTy<N> = <<N as NodeTypes>::Payload as PayloadTypes>::
 ///
 ///     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.
 ///     }
@@ -61,16 +63,16 @@ pub trait DebugNode<N: FullNodeComponents>: Node<N> {
     /// endpoint.
     type RpcBlock: Serialize + DeserializeOwned + 'static;
 
-    /// Converts an RPC block to execution payload data.
+    /// Converts an RPC block to a primitive block.
     ///
-    /// This method handles the conversion between the RPC block format and the internal Engine API
-    /// payload data used by the node's consensus engine.
+    /// This method handles the conversion between the RPC block format and the internal primitive
+    /// block format used by the node's consensus engine.
     ///
     /// # Example
     ///
     /// For Ethereum nodes, this typically converts from `alloy_rpc_types_eth::Block`
-    /// to the node's internal execution payload data representation.
-    fn rpc_to_execution_data(rpc_block: Self::RpcBlock) -> PayloadDataTy<Self>;
+    /// to the node's internal block representation.
+    fn rpc_to_primitive_block(rpc_block: Self::RpcBlock) -> BlockTy<Self>;
 
     /// Creates a payload attributes builder for local mining in dev mode.
     ///
@@ -238,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_execution_data(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?;
 
@@ -274,7 +280,13 @@ where
                     )
                 })?,
                 chain.id(),
-                N::Types::rpc_to_execution_data,
+                |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(),
diff --git a/crates/payload/primitives/src/lib.rs b/crates/payload/primitives/src/lib.rs
index f2db62acfd1..946284961b2 100644
--- a/crates/payload/primitives/src/lib.rs
+++ b/crates/payload/primitives/src/lib.rs
@@ -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/rpc/rpc-engine-api/src/reth_engine_api.rs b/crates/rpc/rpc-engine-api/src/reth_engine_api.rs
index 7230552a399..93bcc423850 100644
--- a/crates/rpc/rpc-engine-api/src/reth_engine_api.rs
+++ b/crates/rpc/rpc-engine-api/src/reth_engine_api.rs
@@ -43,7 +43,7 @@ impl<Payload: PayloadTypes> RethEngineApiServer<Payload::ExecutionData> for Reth
             RethNewPayloadInput::BlockRlp(rlp) => {
                 let block = Decodable::decode(&mut 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), None)
             }
         };
 
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-engine-types/src/main.rs b/examples/custom-engine-types/src/main.rs
index 1d94be5b059..2ed864757b1 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,
@@ -118,6 +118,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());

From b43e6b08b6c864bf8b7f3e3c8aa69d6a5e8af360 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 12 May 2026 05:48:32 -0700
Subject: [PATCH 107/335] feat(engine): support BAL in create_reorg_head
 (#24147)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 Cargo.lock                      |  2 ++
 crates/engine/util/Cargo.toml   |  2 ++
 crates/engine/util/src/reorg.rs | 17 ++++++++++++-----
 3 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2ca0f654d6a..c37f85f85fb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8348,6 +8348,8 @@ name = "reth-engine-util"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
+ "alloy-primitives",
+ "alloy-rlp",
  "alloy-rpc-types-engine",
  "eyre",
  "futures",
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 32a3f992cbc..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, None),
+                            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))
 }

From 303357582a4315e4f5c9c2acfc8f566072b4836d Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Tue, 12 May 2026 15:14:57 +0200
Subject: [PATCH 108/335] ci(bench): use online CPUs for reth affinity (#24148)

Co-authored-by: Brian Picciano <933154+mediocregopher@users.noreply.github.com>
Co-authored-by: Amp <amp@ampcode.com>
---
 .github/scripts/bench-reth-run.sh  | 2 +-
 .github/scripts/bench-txgen-run.sh | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/scripts/bench-reth-run.sh b/.github/scripts/bench-reth-run.sh
index c74bacbe0b0..3e077d21d18 100755
--- a/.github/scripts/bench-reth-run.sh
+++ b/.github/scripts/bench-reth-run.sh
@@ -107,7 +107,7 @@ 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)
+ONLINE=$(getconf _NPROCESSORS_ONLN)
 MAX_RETH=$(( ONLINE - 1 ))
 if [ "${BENCH_CORES:-0}" -gt 0 ] && [ "$BENCH_CORES" -lt "$MAX_RETH" ]; then
   MAX_RETH=$BENCH_CORES
diff --git a/.github/scripts/bench-txgen-run.sh b/.github/scripts/bench-txgen-run.sh
index ca1b96eccd2..8f776f10c38 100755
--- a/.github/scripts/bench-txgen-run.sh
+++ b/.github/scripts/bench-txgen-run.sh
@@ -94,7 +94,7 @@ echo "=== Cache state after drop ==="
 free -h
 grep Cached /proc/meminfo
 
-ONLINE=$(nproc --all)
+ONLINE=$(getconf _NPROCESSORS_ONLN)
 MAX_RETH=$(( ONLINE - 1 ))
 if [ "${BENCH_CORES:-0}" -gt 0 ] && [ "$BENCH_CORES" -lt "$MAX_RETH" ]; then
   MAX_RETH=$BENCH_CORES

From 3eb7e62bad55527788744296e6353643be267dc1 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 12 May 2026 06:15:39 -0700
Subject: [PATCH 109/335] bench: extract txgen payloads once and reuse across
 runs (#24144)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/scripts/bench-txgen-extract.sh | 154 +++++++++++++++++++++++++
 .github/scripts/bench-txgen-run.sh     |  97 +++++++++-------
 .github/workflows/bench-scheduled.yml  |  11 ++
 .github/workflows/bench.yml            |  11 ++
 4 files changed, 232 insertions(+), 41 deletions(-)
 create mode 100755 .github/scripts/bench-txgen-extract.sh

diff --git a/.github/scripts/bench-txgen-extract.sh b/.github/scripts/bench-txgen-extract.sh
new file mode 100755
index 00000000000..571e6946afd
--- /dev/null
+++ b/.github/scripts/bench-txgen-extract.sh
@@ -0,0 +1,154 @@
+#!/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
+set -euxo pipefail
+
+BINARY="$1"
+OUTPUT_DIR="$2"
+
+BIG_BLOCKS="${BENCH_BIG_BLOCKS:-false}"
+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 ))
+if [ "$BIG_BLOCKS" = "true" ]; then
+  echo "Extracting ${TOTAL} big blocks from ${EXTRACT_FROM} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured)"
+  "$TXGEN_ETHEREUM" extract-big-blocks \
+    --rpc "$BENCH_RPC_URL" \
+    --from "$EXTRACT_FROM" \
+    --count "$TOTAL" \
+    --target-gas "${BENCH_BIG_BLOCKS_TARGET_GAS:-1G}" \
+    -o "$ALL_BLOCKS"
+else
+  EXTRACT_TO=$(( HEAD_DEC + TOTAL ))
+  echo "Extracting blocks ${EXTRACT_FROM}..${EXTRACT_TO} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured)"
+  "$TXGEN_ETHEREUM" extract \
+    --rpc "$BENCH_RPC_URL" \
+    --from "$EXTRACT_FROM" \
+    --to "$EXTRACT_TO" \
+    -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"
+
+echo "Extraction complete: $(wc -l < "$ALL_BLOCKS") payloads in ${OUTPUT_DIR}"
diff --git a/.github/scripts/bench-txgen-run.sh b/.github/scripts/bench-txgen-run.sh
index 8f776f10c38..119a259aaf4 100755
--- a/.github/scripts/bench-txgen-run.sh
+++ b/.github/scripts/bench-txgen-run.sh
@@ -11,7 +11,8 @@
 #               BENCH_WORK_DIR, BENCH_WAIT_TIME, BENCH_BASELINE_ARGS,
 #               BENCH_FEATURE_ARGS, BENCH_OTLP_TRACES_ENDPOINT,
 #               BENCH_OTLP_LOGS_ENDPOINT, BENCH_OTLP_DISABLED,
-#               BENCH_TRACY, BENCH_TRACY_FILTER, BENCH_TRACY_SAMPLING_HZ
+#               BENCH_TRACY, BENCH_TRACY_FILTER, BENCH_TRACY_SAMPLING_HZ,
+#               TXGEN_PAYLOADS_DIR (pre-extracted payloads; skips extraction)
 set -euxo pipefail
 
 LABEL="$1"
@@ -220,7 +221,6 @@ 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)"
 TXGEN_SEND_ARGS=()
@@ -228,12 +228,6 @@ if [ -n "${BENCH_WAIT_TIME:-}" ]; then
   TXGEN_SEND_ARGS+=(--wait-time "$BENCH_WAIT_TIME")
 fi
 
-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 ))
@@ -244,43 +238,64 @@ 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"
-if [ "$BIG_BLOCKS" = "true" ]; then
-  ALL_BIG_BLOCKS="$TXGEN_DIR/all-big-blocks.ndjson"
-  WARMUP_BIG_BLOCKS="$TXGEN_DIR/warmup-big-blocks.ndjson"
-  MEASURED_BIG_BLOCKS="$TXGEN_DIR/measured-big-blocks.ndjson"
-  ALL_BLOCKS="$ALL_BIG_BLOCKS"
-  WARMUP_BLOCKS="$WARMUP_BIG_BLOCKS"
-  BENCHMARK_BLOCKS="$MEASURED_BIG_BLOCKS"
-fi
 
-EXTRACT_FROM=$(( HEAD_DEC + 1 ))
-if [ "$BIG_BLOCKS" = "true" ]; then
-  echo "Extracting ${TOTAL} big blocks from ${EXTRACT_FROM} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured)"
-  "$TXGEN_ETHEREUM" extract-big-blocks \
-    --rpc "$BENCH_RPC_URL" \
-    --from "$EXTRACT_FROM" \
-    --count "$TOTAL" \
-    --target-gas "${BENCH_BIG_BLOCKS_TARGET_GAS:-1G}" \
-    -o "$ALL_BIG_BLOCKS"
+# 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 [ ! -f "$BENCHMARK_BLOCKS" ]; then
+    echo "::error::Pre-extracted payloads missing: ${BENCHMARK_BLOCKS}"
+    exit 1
+  fi
 else
-  EXTRACT_TO=$(( HEAD_DEC + TOTAL ))
-  echo "Extracting blocks ${EXTRACT_FROM}..${EXTRACT_TO} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured)"
-  "$TXGEN_ETHEREUM" extract \
-    --rpc "$BENCH_RPC_URL" \
-    --from "$EXTRACT_FROM" \
-    --to "$EXTRACT_TO" \
-    -o "$ALL_BLOCKS"
-fi
+  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}))
 
-if [ "$WARMUP" -gt 0 ] 2>/dev/null; then
-  head -n "$WARMUP" "$ALL_BLOCKS" > "$WARMUP_BLOCKS"
-else
-  : > "$WARMUP_BLOCKS"
+  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 ))
+  if [ "$BIG_BLOCKS" = "true" ]; then
+    echo "Extracting ${TOTAL} big blocks from ${EXTRACT_FROM} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured)"
+    "$TXGEN_ETHEREUM" extract-big-blocks \
+      --rpc "$BENCH_RPC_URL" \
+      --from "$EXTRACT_FROM" \
+      --count "$TOTAL" \
+      --target-gas "${BENCH_BIG_BLOCKS_TARGET_GAS:-1G}" \
+      -o "$ALL_BLOCKS"
+  else
+    EXTRACT_TO=$(( HEAD_DEC + TOTAL ))
+    echo "Extracting blocks ${EXTRACT_FROM}..${EXTRACT_TO} for txgen benchmark (${WARMUP} warmup, ${BLOCKS} measured)"
+    "$TXGEN_ETHEREUM" extract \
+      --rpc "$BENCH_RPC_URL" \
+      --from "$EXTRACT_FROM" \
+      --to "$EXTRACT_TO" \
+      -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
-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)..."
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 43dd2ee4346..997c6c75a6d 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -556,6 +556,17 @@ jobs:
           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 four times.
+      - name: Extract txgen payloads
+        if: env.BENCH_DRIVER == 'txgen'
+        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)"
         id: run-baseline-1
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 6da15e3326b..749c97b1f29 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -1015,6 +1015,17 @@ jobs:
             const s = require('./.github/scripts/bench-update-status.js');
             await s({github, context, status: 'Running benchmarks...'});
 
+      # Extract txgen payloads once so they are reused across all benchmark
+      # runs instead of re-fetching from the remote RPC four times.
+      - name: Extract txgen payloads
+        if: env.BENCH_DRIVER == 'txgen'
+        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 (F-B-B-F) to reduce systematic bias from
       # thermal drift and cache warming.
       - name: "Run benchmark: feature (1/2)"

From e8a5a3cbfb34aea3d31b7a4302791185fa016472 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 12 May 2026 15:29:17 +0200
Subject: [PATCH 110/335] feat(rpc): support BAL with block RLP payloads
 (#24153)

---
 bin/reth-bench/src/valid_payload.rs           |  3 +-
 crates/rpc/rpc-api/src/reth_engine.rs         | 96 ++++++++++++++++++-
 .../rpc/rpc-engine-api/src/reth_engine_api.rs |  6 +-
 3 files changed, 96 insertions(+), 9 deletions(-)

diff --git a/bin/reth-bench/src/valid_payload.rs b/bin/reth-bench/src/valid_payload.rs
index 70cc239bd57..bfc79c695bf 100644
--- a/bin/reth-bench/src/valid_payload.rs
+++ b/bin/reth-bench/src/valid_payload.rs
@@ -225,10 +225,11 @@ pub(crate) fn block_to_new_payload(
     let wait_for_persistence = wait_for_persistence.rpc_value(block_number);
 
     if let Some(rlp) = rlp {
+        let bal = bal.map(|bal| alloy_rlp::encode(bal).into());
         return Ok((
             None,
             serde_json::to_value((
-                RethNewPayloadInput::<ExecutionData>::BlockRlp(rlp),
+                RethNewPayloadInput::<ExecutionData>::BlockRlp { block: rlp, bal },
                 wait_for_persistence,
                 no_wait_for_caches.then_some(false),
             ))?,
diff --git a/crates/rpc/rpc-api/src/reth_engine.rs b/crates/rpc/rpc-api/src/reth_engine.rs
index b67f140c6a2..ae641057659 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::{Deserialize, Deserializer, Serialize};
 
 /// Reth-specific payload status that includes server-measured execution latency.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -30,14 +30,48 @@ pub struct RethPayloadStatus {
 }
 
 /// Input for `reth_newPayload` that accepts either `ExecutionData` directly or an RLP-encoded
-/// block.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+/// block with optional side data.
+#[derive(Debug, Clone, Serialize)]
 #[serde(untagged)]
 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.
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        bal: Option<Bytes>,
+    },
+}
+
+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 +109,55 @@ 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_value(input).unwrap(), json!({ "block": "0x01", "bal": "0x02" }));
+    }
+
+    #[test]
+    fn block_rlp_deserializes_without_bal() {
+        let input = serde_json::from_value::<RethNewPayloadInput<TestExecutionData>>(json!({
+            "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-engine-api/src/reth_engine_api.rs b/crates/rpc/rpc-engine-api/src/reth_engine_api.rs
index 93bcc423850..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), None)
+                Payload::block_to_payload(SealedBlock::new_unhashed(block), bal)
             }
         };
 

From 1b5696e8ad40e9470c121f61d3d0a9fac729bf34 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 12 May 2026 06:45:10 -0700
Subject: [PATCH 111/335] ci(bench): update Grafana datasource (#24150)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/scripts/bench-reth-local.sh   | 2 +-
 .github/workflows/bench-scheduled.yml | 2 +-
 .github/workflows/bench.yml           | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/scripts/bench-reth-local.sh b/.github/scripts/bench-reth-local.sh
index 6e2ccda383f..5d15da5e4bb 100755
--- a/.github/scripts/bench-reth-local.sh
+++ b/.github/scripts/bench-reth-local.sh
@@ -459,7 +459,7 @@ 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"
+GRAFANA_DATASOURCE="efk1hcn87dnnkd"
 LAST_RUN_DURATION=$(( $(date +%s) - LAST_RUN_START ))
 FROM_MS=$(( BENCH_REFERENCE_EPOCH * 1000 ))
 TO_MS=$(( (BENCH_REFERENCE_EPOCH + LAST_RUN_DURATION) * 1000 ))
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 997c6c75a6d..c88d90c60ef 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -627,7 +627,7 @@ jobs:
           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"
+          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=reth-bench&var-benchmark_id=${BENCH_ID}&var-benchmark_run=\$__all"
           echo "grafana-url=${GRAFANA_URL}" >> "$GITHUB_OUTPUT"
           echo "Grafana URL: ${GRAFANA_URL}"
 
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 749c97b1f29..8bb715a2506 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -1107,7 +1107,7 @@ jobs:
           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"
+          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=reth-bench&var-benchmark_id=${BENCH_ID}&var-benchmark_run=\$__all"
           echo "grafana-url=${GRAFANA_URL}" >> "$GITHUB_OUTPUT"
           echo "Grafana URL: ${GRAFANA_URL}"
 

From 0b9b729690445bd08822b3ac15621d25db867bda Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 12 May 2026 16:22:09 +0200
Subject: [PATCH 112/335] docs(engine): update getPayloadV6 handler docs
 (#24156)

---
 crates/rpc/rpc-engine-api/src/engine_api.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/rpc/rpc-engine-api/src/engine_api.rs b/crates/rpc/rpc-engine-api/src/engine_api.rs
index de865cbbe7a..bd1b65ac1fd 100644
--- a/crates/rpc/rpc-engine-api/src/engine_api.rs
+++ b/crates/rpc/rpc-engine-api/src/engine_api.rs
@@ -1343,7 +1343,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(

From 15c07737e449cb28a93a0a35a051eb459940f50b Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 12 May 2026 07:52:45 -0700
Subject: [PATCH 113/335] bench: show per-phase status in PR comment during
 benchmark runs (#24158)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/scripts/bench-update-status.sh | 31 ++++++++++++++++++++++++++
 .github/workflows/bench.yml            | 17 +++++++-------
 2 files changed, 39 insertions(+), 9 deletions(-)
 create mode 100755 .github/scripts/bench-update-status.sh

diff --git a/.github/scripts/bench-update-status.sh b/.github/scripts/bench-update-status.sh
new file mode 100755
index 00000000000..4c04943d19b
--- /dev/null
+++ b/.github/scripts/bench-update-status.sh
@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# Updates the reth-bench 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/workflows/bench.yml b/.github/workflows/bench.yml
index 8bb715a2506..5a78ca2bf91 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -1006,15 +1006,6 @@ jobs:
           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...'});
-
       # Extract txgen payloads once so they are reused across all benchmark
       # runs instead of re-fetching from the remote RPC four times.
       - name: Extract txgen payloads
@@ -1033,7 +1024,9 @@ jobs:
         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 }}"
+          BENCH_GH_TOKEN: ${{ secrets.DEREK_PAT }}
         run: |
+          .github/scripts/bench-update-status.sh "Running benchmark: feature (1/2)..."
           LAST_RUN_START=$(date +%s)
           echo "BENCH_LAST_RUN_START=${LAST_RUN_START}" >> "$GITHUB_ENV"
           cat > "$BENCH_LABELS_FILE" <<LABELS
@@ -1050,7 +1043,9 @@ jobs:
         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 }}"
+          BENCH_GH_TOKEN: ${{ secrets.DEREK_PAT }}
         run: |
+          .github/scripts/bench-update-status.sh "Running benchmark: baseline (1/2)..."
           LAST_RUN_START=$(date +%s)
           echo "BENCH_LAST_RUN_START=${LAST_RUN_START}" >> "$GITHUB_ENV"
           cat > "$BENCH_LABELS_FILE" <<LABELS
@@ -1068,7 +1063,9 @@ jobs:
         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 }}"
+          BENCH_GH_TOKEN: ${{ secrets.DEREK_PAT }}
         run: |
+          .github/scripts/bench-update-status.sh "Running benchmark: baseline (2/2)..."
           LAST_RUN_START=$(date +%s)
           echo "BENCH_LAST_RUN_START=${LAST_RUN_START}" >> "$GITHUB_ENV"
           cat > "$BENCH_LABELS_FILE" <<LABELS
@@ -1086,7 +1083,9 @@ jobs:
         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 }}"
+          BENCH_GH_TOKEN: ${{ secrets.DEREK_PAT }}
         run: |
+          .github/scripts/bench-update-status.sh "Running benchmark: feature (2/2)..."
           LAST_RUN_START=$(date +%s)
           echo "BENCH_LAST_RUN_START=${LAST_RUN_START}" >> "$GITHUB_ENV"
           cat > "$BENCH_LABELS_FILE" <<LABELS

From abcbab871ddbc154c5eda4863bc6ba44170544fe Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 12 May 2026 19:45:20 +0200
Subject: [PATCH 114/335] fix(net): model unavailable BALs explicitly (#24157)

---
 .../eth-wire-types/src/block_access_lists.rs  | 99 ++++++++++++++-----
 crates/net/eth-wire-types/src/snap.rs         |  4 +-
 crates/net/eth-wire/src/eth_snap_stream.rs    |  6 +-
 crates/net/network/src/eth_requests.rs        | 24 +----
 crates/net/network/tests/it/requests.rs       | 71 ++++++++++---
 crates/net/p2p/src/full_block.rs              | 58 ++++++-----
 crates/storage/provider/src/bal.rs            | 12 +--
 crates/storage/storage-api/src/bal.rs         | 28 +++---
 8 files changed, 189 insertions(+), 113 deletions(-)

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..0e27ab7833e 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))
@@ -92,7 +111,7 @@ mod tests {
         AccountChanges, BalanceChange, 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![
@@ -140,19 +159,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 +202,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 +227,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 +238,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 +256,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/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/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/network/src/eth_requests.rs b/crates/net/network/src/eth_requests.rs
index 81b5bacd2ce..e7bc32fbd75 100644
--- a/crates/net/network/src/eth_requests.rs
+++ b/crates/net/network/src/eth_requests.rs
@@ -6,7 +6,6 @@ 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::{
@@ -343,31 +342,12 @@ where
         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!`.
diff --git a/crates/net/network/tests/it/requests.rs b/crates/net/network/tests/it/requests.rs
index 19cd8c354c1..85a59a13d76 100644
--- a/crates/net/network/tests/it/requests.rs
+++ b/crates/net/network/tests/it/requests.rs
@@ -3,7 +3,7 @@
 
 use alloy_consensus::Header;
 use alloy_eips::NumHash;
-use alloy_primitives::{keccak256, Bytes, Sealed, B256};
+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;
@@ -19,7 +19,10 @@ use reth_network_p2p::{
     headers::client::{HeadersClient, HeadersRequest},
     BlockAccessListsClient,
 };
-use reth_provider::{test_utils::MockEthProvider, BalStoreHandle, InMemoryBalStore, SealedBal};
+use reth_provider::{
+    test_utils::MockEthProvider, BalNotificationStream, BalStore, BalStoreHandle, InMemoryBalStore,
+    ProviderError, ProviderResult, SealedBal,
+};
 use reth_transaction_pool::test_utils::{TestPool, TransactionGenerator};
 use std::sync::Arc;
 use tokio::sync::oneshot;
@@ -549,10 +552,7 @@ async fn test_eth71_get_block_access_lists() {
     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.
@@ -575,7 +575,7 @@ async fn test_eth71_get_block_access_lists_respects_response_soft_limit() {
 
     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.
@@ -594,7 +594,7 @@ async fn test_eth71_get_block_access_lists_returns_single_oversized_bal() {
 
     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.
@@ -643,10 +643,23 @@ async fn test_eth71_fetch_client_get_block_access_lists() {
     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 store errors produce a valid empty BAL response instead of synthesizing unavailable
+// entries.
+#[tokio::test(flavor = "multi_thread")]
+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.
@@ -668,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);
 
@@ -689,6 +709,31 @@ 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 get_by_range(&self, _start: BlockNumber, _count: u64) -> ProviderResult<Vec<Bytes>> {
+        Ok(Vec::new())
+    }
+
+    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];
diff --git a/crates/net/p2p/src/full_block.rs b/crates/net/p2p/src/full_block.rs
index d1692373592..1b4c5828843 100644
--- a/crates/net/p2p/src/full_block.rs
+++ b/crates/net/p2p/src/full_block.rs
@@ -30,9 +30,6 @@ use std::{
 };
 use tracing::{debug, trace};
 
-/// RLP encoding for an empty list.
-const EMPTY_LIST_CODE: u8 = 0xc0;
-
 /// A sealed block with associated data.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SealedBlockWith<B: Block, T = Option<Sealed<Bytes>>> {
@@ -541,7 +538,7 @@ where
 /// Tracks the BAL request and its completed result.
 enum BalRequestState<Req> {
     Pending(Req),
-    Ready(Option<WithPeerId<Bytes>>),
+    Ready(Option<WithPeerId<Option<Bytes>>>),
 }
 
 impl<Req> BalRequestState<Req> {
@@ -1165,25 +1162,21 @@ 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 the RLP empty-list unavailable marker, and `Err(peer)` for a non-empty hash
-/// mismatch that should be reported as a bad message.
+/// 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<Bytes>,
+    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)))
     }
 
-    // A mismatched RLP empty list means the peer returned the "unavailable" BAL entry.
-    if access_list.as_ref() == [EMPTY_LIST_CODE] {
-        return Ok(None)
-    }
-
     debug!(
         target: "downloaders",
         block_hash = ?block.hash(),
@@ -1271,6 +1264,8 @@ mod tests {
             Arc,
         },
     };
+
+    const EMPTY_LIST_CODE: u8 = 0xc0;
     use tokio::time::{timeout, Duration};
 
     fn sealed_access_list(access_list: Bytes) -> Sealed<Bytes> {
@@ -1407,13 +1402,12 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn download_single_full_block_with_access_lists_treats_empty_entry_as_unavailable() {
+    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 unavailable_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(), unavailable_access_list);
+        client.inner.insert(header.clone(), body.clone());
 
         let bad_messages = Arc::clone(&client.bad_messages);
         let client = FullBlockClient::test_client(client);
@@ -1428,6 +1422,28 @@ mod tests {
         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();
@@ -1672,16 +1688,10 @@ mod tests {
             let mut access_lists: Vec<_> = hashes
                 .into_iter()
                 .take(self.access_list_soft_limit.load(Ordering::SeqCst))
-                .map(|hash| {
-                    self.access_lists
-                        .lock()
-                        .get(&hash)
-                        .cloned()
-                        .unwrap_or_else(|| Bytes::from_static(&[EMPTY_LIST_CODE]))
-                })
+                .map(|hash| self.access_lists.lock().get(&hash).cloned())
                 .collect();
             for _ in 0..self.extra_access_list_entries.load(Ordering::SeqCst) {
-                access_lists.push(Bytes::from_static(&[EMPTY_LIST_CODE]));
+                access_lists.push(None);
             }
 
             MaybePendingAccessLists::new(
@@ -1936,7 +1946,7 @@ mod tests {
     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().insert(header.hash(), Bytes::from_static(&[EMPTY_LIST_CODE]));
+        client.access_lists.lock().remove(&header.hash());
 
         let access_lists = Arc::clone(&client.access_lists);
         let bad_messages = Arc::clone(&client.bad_messages);
diff --git a/crates/storage/provider/src/bal.rs b/crates/storage/provider/src/bal.rs
index 07f355c2773..95ed4c1ea73 100644
--- a/crates/storage/provider/src/bal.rs
+++ b/crates/storage/provider/src/bal.rs
@@ -184,18 +184,14 @@ impl BalStore for InMemoryBalStore {
         &self,
         block_hashes: &[BlockHash],
         limit: GetBlockAccessListLimit,
-        out: &mut Vec<Bytes>,
+        out: &mut Vec<Option<Bytes>>,
     ) -> ProviderResult<()> {
         let inner = self.inner.read();
         let mut size = 0;
 
         for hash in block_hashes {
-            let bal = inner
-                .entries
-                .get(hash)
-                .map(|entry| entry.bal.clone())
-                .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) {
@@ -293,7 +289,7 @@ mod tests {
             )
             .unwrap();
 
-        assert_eq!(limited, vec![bal0, bal1]);
+        assert_eq!(limited, vec![Some(bal0), Some(bal1)]);
     }
 
     #[test]
diff --git a/crates/storage/storage-api/src/bal.rs b/crates/storage/storage-api/src/bal.rs
index 44d8d9f3fce..46ab33c9d0b 100644
--- a/crates/storage/storage-api/src/bal.rs
+++ b/crates/storage/storage-api/src/bal.rs
@@ -105,13 +105,13 @@ pub trait BalStore: Send + Sync + 'static {
     /// 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();
@@ -125,12 +125,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) {
@@ -248,7 +247,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)
     }
 
@@ -258,7 +257,7 @@ 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)
     }
@@ -321,13 +320,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
@@ -353,6 +351,8 @@ mod tests {
     #[cfg(feature = "std")]
     use tokio_stream::StreamExt;
 
+    const EMPTY_LIST_CODE: u8 = 0xc0;
+
     #[test]
     fn noop_store_returns_empty_results() {
         let store = BalStoreHandle::default();
@@ -384,7 +384,7 @@ mod tests {
     #[test]
     fn decoded_lookup_decodes_raw_bal() {
         let hash = B256::random();
-        let raw_bal = Bytes::from_static(&[0xc0]);
+        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()));
@@ -408,7 +408,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]

From 2c1cb29da7111e1dd8d77abe9bb2e23a75b2da7c Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Tue, 12 May 2026 22:43:41 +0400
Subject: [PATCH 115/335] refactor: spawn full block validation (#24160)

---
 .../engine/tree/src/tree/payload_validator.rs | 256 +++++++-----------
 1 file changed, 103 insertions(+), 153 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 09ae6767f6f..a0351eb88de 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -39,7 +39,7 @@
 //! [`SealedBlock`]: reth_primitives_traits::SealedBlock
 
 use crate::tree::{
-    error::{InsertBlockError, InsertBlockErrorKind},
+    error::{InsertBlockError, InsertBlockErrorKind, InsertPayloadError},
     instrumented_state::{InstrumentedStateProvider, StateProviderStats},
     multiproof::{StateRootComputeOutcome, StateRootHandle},
     payload_processor::PayloadProcessor,
@@ -53,6 +53,7 @@ use alloy_eip7928::bal::DecodedBal;
 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;
 
@@ -107,6 +108,11 @@ pub use crate::tree::types::ValidationOutcome;
 /// Handle to a [`HashedPostState`] computed on a background thread.
 type LazyHashedPostState = reth_tasks::LazyHandle<Arc<HashedPostState>>;
 
+/// 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;
+
 type ReceiptRootSender<N> =
     crossbeam_channel::Sender<IndexedReceipt<<N as NodePrimitives>::Receipt>>;
 type ReceiptRootReceiver = tokio::sync::oneshot::Receiver<(B256, alloy_primitives::Bloom)>;
@@ -332,48 +338,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:
@@ -399,40 +363,28 @@ where
         V: PayloadValidator<T, Block = N::Block> + Clone,
         Evm: ConfigureEngineEvm<T::ExecutionData, Primitives = N>,
     {
-        // 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 = input.is_payload();
-        let convert_to_block = 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)
-                    },
-                );
-                Either::Left(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(_) => Either::Right(()),
         };
 
-        // Returns the sealed block, either by awaiting the background conversion task (for
-        // payloads) or by extracting the already-converted block directly.
-        let convert_to_block =
-            move |input: BlockOrPayload<T>| -> Result<SealedBlock<N::Block>, NewPayloadError> {
-                match convert_to_block {
-                    Either::Left(handle) => handle.try_into_inner().expect("sole handle"),
-                    Either::Right(()) => {
-                        let BlockOrPayload::Block(block) = input else { unreachable!() };
-                        Ok(block)
-                    }
-                }
-            };
+        // 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
@@ -441,7 +393,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())
                     }
                 }
@@ -462,7 +414,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 =
@@ -472,7 +434,7 @@ 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())
@@ -480,17 +442,6 @@ where
         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)?;
@@ -581,15 +532,15 @@ where
         let (output, senders, receipt_root_rx) = if bal_eligible {
             let provider_builder =
                 bal_provider_builder.expect("eligibility implies builder was cloned");
-            match self.execute_block_bal(state_provider, env, &input, &handle, provider_builder) {
-                Ok(output) => output,
-                Err(err) => return self.handle_execution_error(input, err, &parent_block),
-            }
+            ensure_ok!(self.execute_block_bal(
+                state_provider,
+                env,
+                &input,
+                &handle,
+                provider_builder
+            ))
         } else {
-            match self.execute_block(state_provider, env, &input, &mut handle) {
-                Ok(output) => output,
-                Err(err) => return self.handle_execution_error(input, err, &parent_block),
-            }
+            ensure_ok!(self.execute_block(state_provider, env, &input, &mut handle))
         };
         let block_access_list_hash = decoded_bal.as_ref().map(|decoded_bal| decoded_bal.hash());
         let execution_duration = execute_block_start.elapsed();
@@ -621,18 +572,7 @@ where
                 Arc::new(hashed_state_provider.hashed_post_state(&hashed_state_output.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.
@@ -653,12 +593,6 @@ 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!(
             self.validate_post_execution(
@@ -666,7 +600,6 @@ where
                 &parent_block,
                 &output,
                 &mut ctx,
-                transaction_root,
                 receipt_root_bloom,
                 hashed_state,
                 block_access_list_hash
@@ -879,6 +812,61 @@ where
         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)
+        })
+    }
+
     /// Return sealed block header from database or in-memory state by hash.
     fn sealed_header_by_hash(
         &self,
@@ -895,29 +883,6 @@ 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>,
-    ) -> 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(())
-    }
-
     /// Executes a block with the given state provider.
     ///
     /// This method orchestrates block execution:
@@ -1529,7 +1494,6 @@ where
         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,
         block_access_list_hash: Option<B256>,
@@ -1540,20 +1504,6 @@ where
         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 =

From f10844da81af9b7da8ca125c0761e7683c15de8c Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 12 May 2026 20:50:14 +0200
Subject: [PATCH 116/335] refactor(tasks): use parking_lot mutex in lazy handle
 (#24161)

---
 crates/tasks/Cargo.toml  |  4 ++--
 crates/tasks/src/lazy.rs | 12 ++++--------
 2 files changed, 6 insertions(+), 10 deletions(-)

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

From c71343b84f95be89b2b0dae851586c3c6319e5ef Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 12 May 2026 22:09:03 +0200
Subject: [PATCH 117/335] docs: update security contact (#24165)

---
 SECURITY.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

From a638890c387582c44f87f1f8da081f664beaac07 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 12 May 2026 22:34:49 +0200
Subject: [PATCH 118/335] refactor(rpc): simplify blob bundle validation
 (#24169)

---
 crates/rpc/rpc/src/validation.rs | 38 +++++++++-----------------------
 1 file changed, 11 insertions(+), 27 deletions(-)

diff --git a/crates/rpc/rpc/src/validation.rs b/crates/rpc/rpc/src/validation.rs
index b5ab60a1c7f..88e96deef07 100644
--- a/crates/rpc/rpc/src/validation.rs
+++ b/crates/rpc/rpc/src/validation.rs
@@ -1,7 +1,7 @@
 use alloy_consensus::{
     BlobTransactionValidationError, BlockHeader, EnvKzgSettings, Transaction, TxReceipt,
 };
-use alloy_eips::{eip4844::kzg_to_versioned_hash, eip7685::RequestsOrHash};
+use alloy_eips::eip7685::RequestsOrHash;
 use alloy_primitives::map::AddressSet;
 use alloy_rpc_types_beacon::relay::{
     BidTrace, BuilderBlockValidationRequest, BuilderBlockValidationRequestV2,
@@ -347,42 +347,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)
     }
 

From bedf3346b33705d2ddddb9d87219b735fab53591 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 12 May 2026 23:51:42 +0200
Subject: [PATCH 119/335] perf(reth-bench): buffer recent block hash requests
 (#24176)

---
 bin/reth-bench/src/bench/context.rs | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/bin/reth-bench/src/bench/context.rs b/bin/reth-bench/src/bench/context.rs
index d87d2db3d31..1a1f97bbce1 100644
--- a/bin/reth-bench/src/bench/context.rs
+++ b/bin/reth-bench/src/bench/context.rs
@@ -11,6 +11,7 @@ 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 futures::{stream, StreamExt, TryStreamExt};
 use reqwest::Url;
 use reth_node_core::args::{BenchmarkArgs, WaitForPersistence};
 use tracing::info;
@@ -244,15 +245,20 @@ async fn fetch_recent_block_hashes(
     latest_regular_block: u64,
 ) -> eyre::Result<Vec<(u64, B256)>> {
     const BLOCKHASH_HISTORY: u64 = 256;
+    const MAX_CONCURRENT_BLOCK_HASH_REQUESTS: usize = 5;
 
     let start = latest_regular_block.saturating_sub(BLOCKHASH_HISTORY - 1);
-    let mut hashes = Vec::with_capacity((latest_regular_block - start + 1) as usize);
-    for block_number in start..=latest_regular_block {
-        let Some(block) = provider.get_block_by_number(block_number.into()).await? else {
-            continue;
-        };
-        hashes.push((block_number, block.header.hash));
-    }
+    let hashes = stream::iter(start..=latest_regular_block)
+        .map(|block_number| async move {
+            provider
+                .get_block_by_number(block_number.into())
+                .await
+                .map(|block| block.map(|block| (block_number, block.header.hash)))
+        })
+        .buffered(MAX_CONCURRENT_BLOCK_HASH_REQUESTS)
+        .try_filter_map(|block_hash| async move { Ok(block_hash) })
+        .try_collect()
+        .await?;
 
     Ok(hashes)
 }

From 06b2d3730ddee66ab45161f3c1cac8857cf218e3 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 13 May 2026 11:43:32 +0200
Subject: [PATCH 120/335] fix(net): bind discovery to net-if address (#24178)

---
 crates/ethereum/node/tests/e2e/p2p.rs        | 79 +++++++++++++++++++-
 crates/node/core/src/args/network.rs         | 75 +++++++++++++++++--
 docs/vocs/docs/pages/cli/reth/node.mdx       |  6 +-
 docs/vocs/docs/pages/cli/reth/p2p/body.mdx   |  6 +-
 docs/vocs/docs/pages/cli/reth/p2p/header.mdx |  6 +-
 docs/vocs/docs/pages/cli/reth/stage/run.mdx  |  6 +-
 6 files changed, 164 insertions(+), 14 deletions(-)

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/node/core/src/args/network.rs b/crates/node/core/src/args/network.rs
index b682633805e..d25921ed30b 100644
--- a/crates/node/core/src/args/network.rs
+++ b/crates/node/core/src/args/network.rs
@@ -375,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>,
 
@@ -441,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 };
@@ -462,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| {
@@ -532,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));
@@ -569,11 +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, self.port))
-            .discovery_addr(SocketAddr::new(self.discovery.addr, 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))
@@ -907,6 +936,9 @@ pub struct DiscoveryArgs {
     pub disable_nat: bool,
 
     /// 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.
     #[arg(id = "discovery.addr", long = "discovery.addr", value_name = "DISCOVERY_ADDR", default_value_t = DefaultDiscoveryArgs::get_global().addr)]
     pub addr: IpAddr,
 
@@ -1313,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/docs/vocs/docs/pages/cli/reth/node.mdx b/docs/vocs/docs/pages/cli/reth/node.mdx
index 9255cb8998c..b9bb3c46db7 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]
 
@@ -264,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
diff --git a/docs/vocs/docs/pages/cli/reth/p2p/body.mdx b/docs/vocs/docs/pages/cli/reth/p2p/body.mdx
index f55534e616a..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]
 
@@ -204,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 33f17e8e80a..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]
 
@@ -204,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/stage/run.mdx b/docs/vocs/docs/pages/cli/reth/stage/run.mdx
index 87dd3230b35..33bec937dab 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/run.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/run.mdx
@@ -190,7 +190,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]
 
@@ -360,7 +362,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

From d4151617a2d2e573a9e828f0bd56787b210e7098 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 13 May 2026 11:52:40 +0200
Subject: [PATCH 121/335] fix(engine): return BALs in payload range v2 (#24177)

---
 crates/rpc/rpc-engine-api/src/engine_api.rs | 94 +++++++++++++++++++--
 crates/storage/provider/src/bal.rs          | 78 ++++++++++++++++-
 2 files changed, 163 insertions(+), 9 deletions(-)

diff --git a/crates/rpc/rpc-engine-api/src/engine_api.rs b/crates/rpc/rpc-engine-api/src/engine_api.rs
index bd1b65ac1fd..0638fda44ea 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, Bytes, 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,
@@ -701,12 +701,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`
@@ -1661,6 +1689,58 @@ mod tests {
         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>,
diff --git a/crates/storage/provider/src/bal.rs b/crates/storage/provider/src/bal.rs
index 95ed4c1ea73..11084f9801f 100644
--- a/crates/storage/provider/src/bal.rs
+++ b/crates/storage/provider/src/bal.rs
@@ -202,8 +202,22 @@ impl BalStore for InMemoryBalStore {
         Ok(())
     }
 
-    fn get_by_range(&self, _start: BlockNumber, _count: u64) -> ProviderResult<Vec<Bytes>> {
-        Ok(Vec::new())
+    fn get_by_range(&self, start: BlockNumber, count: u64) -> ProviderResult<Vec<Bytes>> {
+        let inner = self.inner.read();
+        let mut result = Vec::new();
+
+        for offset in 0..count {
+            let Some(block_number) = start.checked_add(offset) else { break };
+            let Some(block_hash) =
+                inner.hashes_by_number.get(&block_number).and_then(|hashes| hashes.first())
+            else {
+                break
+            };
+            let Some(entry) = inner.entries.get(block_hash) else { break };
+            result.push(entry.bal.clone());
+        }
+
+        Ok(result)
     }
 
     fn bal_stream(&self) -> BalNotificationStream {
@@ -261,6 +275,66 @@ mod tests {
         assert!(store.get_by_range(1, 10).unwrap().is_empty());
     }
 
+    #[test]
+    fn range_lookup_returns_ordered_bals() {
+        let store = InMemoryBalStore::default();
+        let bal1 = Bytes::from_static(b"bal1");
+        let bal2 = Bytes::from_static(b"bal2");
+        let bal3 = Bytes::from_static(b"bal3");
+
+        store.insert(NumHash::new(2, B256::random()), sealed_bal(bal2.clone())).unwrap();
+        store.insert(NumHash::new(1, B256::random()), sealed_bal(bal1.clone())).unwrap();
+        store.insert(NumHash::new(3, B256::random()), sealed_bal(bal3.clone())).unwrap();
+
+        assert_eq!(store.get_by_range(1, 3).unwrap(), vec![bal1, bal2, bal3]);
+    }
+
+    #[test]
+    fn range_lookup_stops_at_first_missing_block_number() {
+        let store = InMemoryBalStore::default();
+        let bal1 = Bytes::from_static(b"bal1");
+        let bal2 = Bytes::from_static(b"bal2");
+
+        store.insert(NumHash::new(1, B256::random()), sealed_bal(bal1.clone())).unwrap();
+        store.insert(NumHash::new(2, B256::random()), sealed_bal(bal2.clone())).unwrap();
+        store
+            .insert(NumHash::new(4, B256::random()), sealed_bal(Bytes::from_static(b"bal4")))
+            .unwrap();
+
+        assert_eq!(store.get_by_range(1, 4).unwrap(), vec![bal1, bal2]);
+    }
+
+    #[test]
+    fn range_lookup_handles_count_zero_and_start() {
+        let store = InMemoryBalStore::default();
+        let bal2 = Bytes::from_static(b"bal2");
+        let bal3 = Bytes::from_static(b"bal3");
+
+        store
+            .insert(NumHash::new(1, B256::random()), sealed_bal(Bytes::from_static(b"bal1")))
+            .unwrap();
+        store.insert(NumHash::new(2, B256::random()), sealed_bal(bal2.clone())).unwrap();
+        store.insert(NumHash::new(3, B256::random()), sealed_bal(bal3.clone())).unwrap();
+
+        assert!(store.get_by_range(2, 0).unwrap().is_empty());
+        assert_eq!(store.get_by_range(2, 2).unwrap(), vec![bal2, bal3]);
+    }
+
+    #[test]
+    fn range_lookup_uses_first_hash_for_same_number() {
+        let store = InMemoryBalStore::default();
+        let bal1a = Bytes::from_static(b"bal1a");
+        let bal2 = Bytes::from_static(b"bal2");
+
+        store.insert(NumHash::new(1, B256::random()), sealed_bal(bal1a.clone())).unwrap();
+        store
+            .insert(NumHash::new(1, B256::random()), sealed_bal(Bytes::from_static(b"bal1b")))
+            .unwrap();
+        store.insert(NumHash::new(2, B256::random()), sealed_bal(bal2.clone())).unwrap();
+
+        assert_eq!(store.get_by_range(1, 2).unwrap(), vec![bal1a, bal2]);
+    }
+
     #[test]
     fn flush_is_noop() {
         let store = InMemoryBalStore::default();

From 1a0b5a5c465a24b5a230582267be5c463362aa18 Mon Sep 17 00:00:00 2001
From: tempoxyz-bot <github-svc@tempo.xyz>
Date: Wed, 13 May 2026 13:00:30 +0200
Subject: [PATCH 122/335] perf: preallocate receipt root encode buffer (#24173)

Co-authored-by: autoopt[bot] <autoopt@tempo.xyz>
Co-authored-by: Amp <amp@ampcode.com>
---
 .../tree/src/tree/payload_processor/receipt_root_task.rs      | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

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..68de84811bd 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
@@ -14,6 +14,8 @@ 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> {
@@ -75,7 +77,7 @@ impl<R: Receipt> ReceiptRootTaskHandle<R> {
 
         let mut builder = OrderedTrieRootEncodedBuilder::new(receipts_len);
         let mut aggregated_bloom = Bloom::ZERO;
-        let mut encode_buf = Vec::new();
+        let mut encode_buf = Vec::with_capacity(RECEIPT_ENCODE_BUF_INITIAL_CAPACITY);
         let mut received_count = 0usize;
 
         for indexed_receipt in self.receipt_rx {

From 60da991966bf05f17c34f2432313624838fa2500 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Wed, 13 May 2026 04:25:21 -0700
Subject: [PATCH 123/335] bench: reduce false positives with between-pairing CI
 and unified bootstrap (#24179)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/scripts/bench-reth-summary.py | 279 +++++++++++++++++++-------
 1 file changed, 208 insertions(+), 71 deletions(-)

diff --git a/.github/scripts/bench-reth-summary.py b/.github/scripts/bench-reth-summary.py
index 9871409178e..0d5197e394d 100755
--- a/.github/scripts/bench-reth-summary.py
+++ b/.github/scripts/bench-reth-summary.py
@@ -24,8 +24,10 @@
 import sys
 
 GIGAGAS = 1_000_000_000
-T_CRITICAL = 1.96  # two-tailed 95% confidence
 BOOTSTRAP_ITERATIONS = 10_000
+# t-critical for between-pairing CI (df=3, 4 cross-pairings).
+# Set conservatively to reduce false positives from run-level bias.
+T_BETWEEN_PAIRINGS = 4.5
 
 
 def _opt_int(row: dict, key: str) -> int | None:
@@ -196,91 +198,215 @@ def _paired_data(
     return pairs, lat_diffs_ms, mgas_diffs, total_lat_diffs_ms, persist_diffs_ms
 
 
+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 _between_pairing_ci(pairing_means: list[float]) -> float:
+    """Compute CI half-width from the variance between pairing means.
+
+    This captures run-level bias (thermal drift, background load) that
+    per-block pooling cannot detect. Uses T_BETWEEN_PAIRINGS as the
+    t-critical value (conservative for df=3).
+    """
+    n = len(pairing_means)
+    if n < 2:
+        return 0.0
+    mean = sum(pairing_means) / n
+    sd = math.sqrt(sum((x - mean) ** 2 for x in pairing_means) / (n - 1))
+    se = sd / math.sqrt(n)
+    return T_BETWEEN_PAIRINGS * se
+
+
+def _cross_pair_directions(
+    baseline_runs: list[list[dict]],
+    feature_runs: list[list[dict]],
+) -> dict[str, bool]:
+    """Check if the direction of change agrees across all cross-pairings.
+
+    With ABBA runs [B1, B2] and [F1, F2], generates all 4 pairings:
+    (B1,F1), (B2,F2), (B1,F2), (B2,F1). For each metric, returns True
+    only if the mean diff has the same sign across all pairings.
+
+    With a single run pair, always returns True (no cross-check possible).
+    """
+    if len(baseline_runs) < 2 or len(feature_runs) < 2:
+        return {
+            "lat": True, "mgas": True, "total_lat": True, "persist": True,
+        }
+
+    cross_pairs = []
+    for b in baseline_runs:
+        for f in feature_runs:
+            cross_pairs.append(_paired_data(b, f))
+
+    def _signs_agree(diffs_per_pair: list[list[float]]) -> bool:
+        means = []
+        for diffs in diffs_per_pair:
+            if diffs:
+                means.append(sum(diffs) / len(diffs))
+        if len(means) < 2:
+            return True
+        return all(m > 0 for m in means) or all(m < 0 for m in means) or all(m == 0 for m in means)
+
+    return {
+        "lat": _signs_agree([cp[1] for cp in cross_pairs]),
+        "mgas": _signs_agree([cp[2] for cp in cross_pairs]),
+        "total_lat": _signs_agree([cp[3] for cp in cross_pairs]),
+        "persist": _signs_agree([cp[4] for cp in cross_pairs]),
+    }
+
+
 def compute_paired_stats(
     baseline_runs: list[list[dict]],
     feature_runs: list[list[dict]],
 ) -> dict:
     """Compute paired statistics between baseline and feature runs.
 
-    Each pair (baseline_runs[i], feature_runs[i]) produces per-block diffs.
-    All diffs are pooled for the final CI.
+    Uses all cross-pairings (B1-F1, B2-F2, B1-F2, B2-F1) for pooled
+    diffs and CIs. The final CI for each metric is the max of:
+    - Within-block bootstrap CI (captures per-block variance)
+    - Between-pairing CI (captures run-level bias)
+
+    Also checks that the direction of change agrees across all pairings.
     """
+    # Generate all cross-pairings for pooled stats
     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))
+    # Per-pairing means for between-pairing CI
+    per_pairing_lat_means = []
+    per_pairing_mgas_means = []
+    per_pairing_total_lat_means = []
+    per_pairing_persist_means = []
+    for baseline in baseline_runs:
+        for feature in 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 lat_diffs:
+                per_pairing_lat_means.append(sum(lat_diffs) / len(lat_diffs))
+            if mgas_diffs:
+                per_pairing_mgas_means.append(sum(mgas_diffs) / len(mgas_diffs))
+            if total_lat_diffs:
+                per_pairing_total_lat_means.append(sum(total_lat_diffs) / len(total_lat_diffs))
+            if persist_diffs:
+                per_pairing_persist_means.append(sum(persist_diffs) / len(persist_diffs))
 
     if not all_lat_diffs:
         return {}
 
     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
 
-    # Bootstrap CI on difference-of-percentiles (resample paired blocks)
+    rng = random.Random(42)
+
+    # Within-block bootstrap CI
+    ci_within = _bootstrap_ci(rng, all_lat_diffs)
+    mgas_ci_within = _bootstrap_ci(rng, all_mgas_diffs) if all_mgas_diffs else 0.0
+    wall_ci_within = _bootstrap_ci(rng, all_total_lat_diffs) if all_total_lat_diffs else 0.0
+    persist_ci_within = _bootstrap_ci(rng, all_persist_diffs) if all_persist_diffs else 0.0
+
+    # Between-pairing CI (run-level variance floor)
+    ci_between = _between_pairing_ci(per_pairing_lat_means)
+    mgas_ci_between = _between_pairing_ci(per_pairing_mgas_means)
+    wall_ci_between = _between_pairing_ci(per_pairing_total_lat_means)
+    persist_ci_between = _between_pairing_ci(per_pairing_persist_means)
+
+    # Final CI = max(within, between)
+    ci = max(ci_within, ci_between)
+    mgas_ci = max(mgas_ci_within, mgas_ci_between)
+    wall_clock_ci_ms = max(wall_ci_within, wall_ci_between)
+    persist_ci_ms = max(persist_ci_within, persist_ci_between)
+
+    # Bootstrap CI for percentile diffs
     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)
 
-    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)
+    p50_ci_within = _bootstrap_percentile_ci(rng, all_pairs, 50)
+    p90_ci_within = _bootstrap_percentile_ci(rng, all_pairs, 90)
+    p99_ci_within = _bootstrap_percentile_ci(rng, all_pairs, 99)
+
+    # Between-pairing CI for percentile diffs
+    per_pairing_p50_diffs = []
+    per_pairing_p90_diffs = []
+    per_pairing_p99_diffs = []
+    for baseline in baseline_runs:
+        for feature in feature_runs:
+            pairs_i, _, _, _, _ = _paired_data(baseline, feature)
+            if pairs_i:
+                b_sorted = sorted(p[0] for p in pairs_i)
+                f_sorted = sorted(p[1] for p in pairs_i)
+                per_pairing_p50_diffs.append(percentile(f_sorted, 50) - percentile(b_sorted, 50))
+                per_pairing_p90_diffs.append(percentile(f_sorted, 90) - percentile(b_sorted, 90))
+                per_pairing_p99_diffs.append(percentile(f_sorted, 99) - percentile(b_sorted, 99))
+
+    p50_ci = max(p50_ci_within, _between_pairing_ci(per_pairing_p50_diffs))
+    p90_ci = max(p90_ci_within, _between_pairing_ci(per_pairing_p90_diffs))
+    p99_ci = max(p99_ci_within, _between_pairing_ci(per_pairing_p99_diffs))
 
     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
+    # Cross-pair direction agreement
+    directions = _cross_pair_directions(baseline_runs, feature_runs)
 
     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,
+        "p50_ci_ms": p50_ci,
         "p90_diff_ms": p90_diff,
-        "p90_ci_ms": (p90_boot[hi] - p90_boot[lo]) / 2,
+        "p90_ci_ms": p90_ci,
         "p99_diff_ms": p99_diff,
-        "p99_ci_ms": (p99_boot[hi] - p99_boot[lo]) / 2,
+        "p99_ci_ms": p99_ci,
         "mean_mgas_diff": mean_mgas_diff,
         "mgas_ci": mgas_ci,
         "wall_clock_ci_ms": wall_clock_ci_ms,
         "persist_ci_ms": persist_ci_ms,
         "blocks": max(blocks_per_pair),
+        "directions_agree": directions,
     }
 
 
@@ -320,9 +446,14 @@ 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
+def significance(pct: float, ci_pct: float, lower_is_better: bool, directions_agree: bool = True) -> str:
+    """Return significance label: 'good', 'bad', or 'neutral'.
+
+    A result is only significant if:
+    1. The CI doesn't cross zero (|pct| > ci_pct), AND
+    2. All cross-pairings agree on direction (directions_agree=True).
+    """
+    significant = abs(pct) > ci_pct and directions_agree
     if not significant:
         return "neutral"
     elif (pct < 0) == lower_is_better:
@@ -331,14 +462,16 @@ def significance(pct: float, ci_pct: float, lower_is_better: bool) -> str:
         return "bad"
 
 
-def change_str(pct: float, ci_pct: float, lower_is_better: bool) -> str:
+def change_str(pct: float, ci_pct: float, lower_is_better: bool, directions_agree: bool = True) -> str:
     """Format change% with paired CI significance.
 
-    Significant if the CI doesn't cross zero (i.e. |pct| > ci_pct).
+    Significant if the CI doesn't cross zero (i.e. |pct| > ci_pct)
+    AND all cross-pairings agree on direction.
     """
-    sig = significance(pct, ci_pct, lower_is_better)
+    sig = significance(pct, ci_pct, lower_is_better, directions_agree)
     emoji = {"good": "✅", "bad": "❌", "neutral": "⚪"}[sig]
-    return f"{pct:+.2f}% {emoji} (±{ci_pct:.2f}%)"
+    qualifier = "" if directions_agree else " ↕"
+    return f"{pct:+.2f}% {emoji}{qualifier} (±{ci_pct:.2f}%)"
 
 
 def compute_changes(
@@ -351,23 +484,25 @@ def pct(base: float, feat: float) -> float:
     def ci_pct(ci_ms: float, base_ms: float) -> float:
         return ci_ms / base_ms * 100.0 if base_ms > 0 else 0.0
 
+    dirs = paired_stats.get("directions_agree", {})
+
     metrics = [
-        ("mean", "mean_ms", "ci_ms", "mean_ms", True),
-        ("p50", "p50_ms", "p50_ci_ms", "p50_ms", True),
-        ("p90", "p90_ms", "p90_ci_ms", "p90_ms", True),
-        ("p99", "p99_ms", "p99_ci_ms", "p99_ms", True),
-        ("mgas_s", "mean_mgas_s", "mgas_ci", "mean_mgas_s", False),
-        ("wall_clock", "wall_clock_s", "wall_clock_ci_ms", "mean_total_lat_ms", True),
-        ("persist_wait", "mean_persist_ms", "persist_ci_ms", "mean_persist_ms", True),
+        ("p50", "p50_ms", "p50_ci_ms", "p50_ms", True, dirs.get("lat", True)),
+        ("p90", "p90_ms", "p90_ci_ms", "p90_ms", True, dirs.get("lat", True)),
+        ("p99", "p99_ms", "p99_ci_ms", "p99_ms", True, dirs.get("lat", True)),
+        ("mgas_s", "mean_mgas_s", "mgas_ci", "mean_mgas_s", False, dirs.get("mgas", True)),
+        ("wall_clock", "wall_clock_s", "wall_clock_ci_ms", "mean_total_lat_ms", True, dirs.get("total_lat", True)),
+        ("persist_wait", "mean_persist_ms", "persist_ci_ms", "mean_persist_ms", True, dirs.get("persist", True)),
     ]
     changes = {}
-    for name, stat_key, ci_key, base_key, lower_is_better in metrics:
+    for name, stat_key, ci_key, base_key, lower_is_better, dir_agree in metrics:
         p = pct(baseline_stats[stat_key], feature_stats[stat_key])
         c = ci_pct(paired_stats[ci_key], baseline_stats[base_key])
         changes[name] = {
             "pct": round(p, 4),
             "ci_pct": round(c, 4),
-            "sig": significance(p, c, lower_is_better),
+            "sig": significance(p, c, lower_is_better, dir_agree),
+            "directions_agree": dir_agree,
         }
     return changes
 
@@ -394,7 +529,6 @@ def generate_comparison_table(
     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"])
 
@@ -409,12 +543,17 @@ def pct(base: float, feat: float) -> float:
     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
+    # CI as a percentage of baseline
     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
 
+    dirs = paired.get("directions_agree", {})
+    lat_agree = dirs.get("lat", True)
+    mgas_agree = dirs.get("mgas", True)
+    total_agree = dirs.get("total_lat", True)
+    persist_agree = dirs.get("persist", True)
+
     base_url = f"https://github.com/{repo}/commit"
     baseline_label = f"[`{baseline_name}`]({base_url}/{baseline_ref})"
     feature_label = f"[`{feature_name}`]({base_url}/{feature_sha})"
@@ -422,14 +561,12 @@ 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"| P50 | {fmt_ms(run1['p50_ms'])} | {fmt_ms(run2['p50_ms'])} | {change_str(p50_pct, p50_ci_pct, lower_is_better=True, directions_agree=lat_agree)} |",
+        f"| P90 | {fmt_ms(run1['p90_ms'])} | {fmt_ms(run2['p90_ms'])} | {change_str(p90_pct, p90_ci_pct, lower_is_better=True, directions_agree=lat_agree)} |",
+        f"| P99 | {fmt_ms(run1['p99_ms'])} | {fmt_ms(run2['p99_ms'])} | {change_str(p99_pct, p99_ci_pct, lower_is_better=True, directions_agree=lat_agree)} |",
+        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, directions_agree=mgas_agree)} |",
+        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, directions_agree=total_agree)} |",
+        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, directions_agree=persist_agree)} |",
         "",
     ]
     meta_parts = [f"{n} {'big blocks' if big_blocks else 'blocks'}"]

From e2dc712cfae154be8e6a41f1b44c8e86188c3992 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Wed, 13 May 2026 15:26:14 +0400
Subject: [PATCH 124/335] feat: retain announced port (#24182)

---
 crates/net/network/src/session/handle.rs | 25 +++++++++++++++++++++++-
 crates/net/network/src/session/mod.rs    |  6 ++++++
 2 files changed, 30 insertions(+), 1 deletion(-)

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

From 89b39c1c0f31e99dfcc2c072b38701930704218e Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 13 May 2026 13:44:23 +0200
Subject: [PATCH 125/335] refactor(storage): remove BAL range lookup (#24180)

---
 crates/engine/tree/src/persistence.rs     |  4 --
 crates/net/network/tests/it/requests.rs   |  4 --
 crates/rpc/rpc-eth-types/src/cache/mod.rs |  4 --
 crates/storage/provider/src/bal.rs        | 85 -----------------------
 crates/storage/storage-api/src/bal.rs     | 21 ------
 5 files changed, 118 deletions(-)

diff --git a/crates/engine/tree/src/persistence.rs b/crates/engine/tree/src/persistence.rs
index e9b1c0fb1e0..1087a3e8291 100644
--- a/crates/engine/tree/src/persistence.rs
+++ b/crates/engine/tree/src/persistence.rs
@@ -490,10 +490,6 @@ mod tests {
             Ok(vec![None; block_hashes.len()])
         }
 
-        fn get_by_range(&self, _start: BlockNumber, _count: u64) -> ProviderResult<Vec<Bytes>> {
-            Ok(Vec::new())
-        }
-
         fn bal_stream(&self) -> BalNotificationStream {
             BalStoreHandle::noop().bal_stream()
         }
diff --git a/crates/net/network/tests/it/requests.rs b/crates/net/network/tests/it/requests.rs
index 85a59a13d76..2b9323f70cb 100644
--- a/crates/net/network/tests/it/requests.rs
+++ b/crates/net/network/tests/it/requests.rs
@@ -725,10 +725,6 @@ impl BalStore for FailingLookupBalStore {
         Err(ProviderError::other(std::io::Error::other("BAL lookup failed")))
     }
 
-    fn get_by_range(&self, _start: BlockNumber, _count: u64) -> ProviderResult<Vec<Bytes>> {
-        Ok(Vec::new())
-    }
-
     fn bal_stream(&self) -> BalNotificationStream {
         BalStoreHandle::noop().bal_stream()
     }
diff --git a/crates/rpc/rpc-eth-types/src/cache/mod.rs b/crates/rpc/rpc-eth-types/src/cache/mod.rs
index 9fd8c63cf99..bfb82373d0e 100644
--- a/crates/rpc/rpc-eth-types/src/cache/mod.rs
+++ b/crates/rpc/rpc-eth-types/src/cache/mod.rs
@@ -1233,10 +1233,6 @@ mod tests {
             Ok(Some(test_decoded_revm_bal()))
         }
 
-        fn get_by_range(&self, _start: BlockNumber, _count: u64) -> ProviderResult<Vec<Bytes>> {
-            Ok(Vec::new())
-        }
-
         fn bal_stream(&self) -> reth_storage_api::BalNotificationStream {
             reth_storage_api::NoopBalStore.bal_stream()
         }
diff --git a/crates/storage/provider/src/bal.rs b/crates/storage/provider/src/bal.rs
index 11084f9801f..184a8207596 100644
--- a/crates/storage/provider/src/bal.rs
+++ b/crates/storage/provider/src/bal.rs
@@ -202,24 +202,6 @@ impl BalStore for InMemoryBalStore {
         Ok(())
     }
 
-    fn get_by_range(&self, start: BlockNumber, count: u64) -> ProviderResult<Vec<Bytes>> {
-        let inner = self.inner.read();
-        let mut result = Vec::new();
-
-        for offset in 0..count {
-            let Some(block_number) = start.checked_add(offset) else { break };
-            let Some(block_hash) =
-                inner.hashes_by_number.get(&block_number).and_then(|hashes| hashes.first())
-            else {
-                break
-            };
-            let Some(entry) = inner.entries.get(block_hash) else { break };
-            result.push(entry.bal.clone());
-        }
-
-        Ok(result)
-    }
-
     fn bal_stream(&self) -> BalNotificationStream {
         self.notifications.new_listener()
     }
@@ -268,73 +250,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn range_lookup_is_empty() {
-        let store = InMemoryBalStore::default();
-
-        assert!(store.get_by_range(1, 10).unwrap().is_empty());
-    }
-
-    #[test]
-    fn range_lookup_returns_ordered_bals() {
-        let store = InMemoryBalStore::default();
-        let bal1 = Bytes::from_static(b"bal1");
-        let bal2 = Bytes::from_static(b"bal2");
-        let bal3 = Bytes::from_static(b"bal3");
-
-        store.insert(NumHash::new(2, B256::random()), sealed_bal(bal2.clone())).unwrap();
-        store.insert(NumHash::new(1, B256::random()), sealed_bal(bal1.clone())).unwrap();
-        store.insert(NumHash::new(3, B256::random()), sealed_bal(bal3.clone())).unwrap();
-
-        assert_eq!(store.get_by_range(1, 3).unwrap(), vec![bal1, bal2, bal3]);
-    }
-
-    #[test]
-    fn range_lookup_stops_at_first_missing_block_number() {
-        let store = InMemoryBalStore::default();
-        let bal1 = Bytes::from_static(b"bal1");
-        let bal2 = Bytes::from_static(b"bal2");
-
-        store.insert(NumHash::new(1, B256::random()), sealed_bal(bal1.clone())).unwrap();
-        store.insert(NumHash::new(2, B256::random()), sealed_bal(bal2.clone())).unwrap();
-        store
-            .insert(NumHash::new(4, B256::random()), sealed_bal(Bytes::from_static(b"bal4")))
-            .unwrap();
-
-        assert_eq!(store.get_by_range(1, 4).unwrap(), vec![bal1, bal2]);
-    }
-
-    #[test]
-    fn range_lookup_handles_count_zero_and_start() {
-        let store = InMemoryBalStore::default();
-        let bal2 = Bytes::from_static(b"bal2");
-        let bal3 = Bytes::from_static(b"bal3");
-
-        store
-            .insert(NumHash::new(1, B256::random()), sealed_bal(Bytes::from_static(b"bal1")))
-            .unwrap();
-        store.insert(NumHash::new(2, B256::random()), sealed_bal(bal2.clone())).unwrap();
-        store.insert(NumHash::new(3, B256::random()), sealed_bal(bal3.clone())).unwrap();
-
-        assert!(store.get_by_range(2, 0).unwrap().is_empty());
-        assert_eq!(store.get_by_range(2, 2).unwrap(), vec![bal2, bal3]);
-    }
-
-    #[test]
-    fn range_lookup_uses_first_hash_for_same_number() {
-        let store = InMemoryBalStore::default();
-        let bal1a = Bytes::from_static(b"bal1a");
-        let bal2 = Bytes::from_static(b"bal2");
-
-        store.insert(NumHash::new(1, B256::random()), sealed_bal(bal1a.clone())).unwrap();
-        store
-            .insert(NumHash::new(1, B256::random()), sealed_bal(Bytes::from_static(b"bal1b")))
-            .unwrap();
-        store.insert(NumHash::new(2, B256::random()), sealed_bal(bal2.clone())).unwrap();
-
-        assert_eq!(store.get_by_range(1, 2).unwrap(), vec![bal1a, bal2]);
-    }
-
     #[test]
     fn flush_is_noop() {
         let store = InMemoryBalStore::default();
diff --git a/crates/storage/storage-api/src/bal.rs b/crates/storage/storage-api/src/bal.rs
index 46ab33c9d0b..dcb4da59ab5 100644
--- a/crates/storage/storage-api/src/bal.rs
+++ b/crates/storage/storage-api/src/bal.rs
@@ -139,11 +139,6 @@ pub trait BalStore: Send + Sync + 'static {
         Ok(())
     }
 
-    /// Fetch BALs for the requested range.
-    ///
-    /// Implementations may stop at the first gap and return the contiguous prefix.
-    fn get_by_range(&self, start: BlockNumber, count: u64) -> ProviderResult<Vec<Bytes>>;
-
     /// Returns a stream of BAL insert notifications.
     ///
     /// Notifications are emitted only after a BAL has been successfully inserted into the store.
@@ -262,12 +257,6 @@ impl BalStoreHandle {
         self.inner.append_by_hashes_with_limit(block_hashes, limit, out)
     }
 
-    /// Fetch BALs for the requested range.
-    #[inline]
-    pub fn get_by_range(&self, start: BlockNumber, count: u64) -> ProviderResult<Vec<Bytes>> {
-        self.inner.get_by_range(start, count)
-    }
-
     /// Returns a stream of BAL insert notifications.
     #[cfg(feature = "std")]
     #[inline]
@@ -334,10 +323,6 @@ 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()
@@ -359,11 +344,9 @@ 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!(store.get_by_hash(B256::random()).unwrap().is_none());
-        assert!(by_range.is_empty());
         assert_eq!(store.prune(10).unwrap(), 0);
     }
 
@@ -453,10 +436,6 @@ mod tests {
                 .collect())
         }
 
-        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()

From 9b6a79ff9c72e467bebcde2369c574cb22927cc7 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 13 May 2026 14:49:15 +0200
Subject: [PATCH 126/335] fix(rpc): reuse cached block access lists (#24185)

Co-authored-by: 0xKarl98 <43113774+0xKarl98@users.noreply.github.com>
---
 crates/rpc/rpc-eth-api/src/helpers/bal.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/crates/rpc/rpc-eth-api/src/helpers/bal.rs b/crates/rpc/rpc-eth-api/src/helpers/bal.rs
index 608140afe17..aafc034749d 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/bal.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/bal.rs
@@ -12,11 +12,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 +28,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()

From 38a3334e77533167db4c7824fd1bb6601826351f Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Wed, 13 May 2026 08:17:17 -0700
Subject: [PATCH 127/335] ci(bench): use DEREK_BENCH_ACK_TOKEN for org
 membership check (#24191)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/workflows/bench.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 5a78ca2bf91..065624ef324 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -142,7 +142,7 @@ jobs:
         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 org = 'paradigmxyz';
             const checkMembership = async (username) => {

From 968e50b35ad74d570f5e7f7c29bdb06777e6158d Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Wed, 13 May 2026 09:01:24 -0700
Subject: [PATCH 128/335] ci(bench): add git-sha, git-ref, platform, scenario
 metadata to txgen bench (#24190)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/scripts/bench-txgen-run.sh    | 34 ++++++++++++++++++++++++++-
 .github/workflows/bench-scheduled.yml |  3 +++
 2 files changed, 36 insertions(+), 1 deletion(-)

diff --git a/.github/scripts/bench-txgen-run.sh b/.github/scripts/bench-txgen-run.sh
index 119a259aaf4..f35c4811a6c 100755
--- a/.github/scripts/bench-txgen-run.sh
+++ b/.github/scripts/bench-txgen-run.sh
@@ -18,6 +18,28 @@ 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
@@ -318,6 +340,11 @@ if [ "${BENCH_TRACY:-off}" != "off" ]; then
 fi
 
 # TODO(txgen): expose microsecond client-side FCU latency to avoid ms rounding.
+CLICKHOUSE_REPORT=()
+if [ -n "${CLICKHOUSE_URL:-}" ]; then
+  CLICKHOUSE_REPORT=(--report "clickhouse:$CLICKHOUSE_URL")
+fi
+
 echo "Running txgen measured benchmark (${BLOCKS} blocks)..."
 $BENCH_NICE "$TXGEN_BENCH" send-blocks \
   --engine http://127.0.0.1:8551 \
@@ -325,6 +352,11 @@ $BENCH_NICE "$TXGEN_BENCH" send-blocks \
   --input "$BENCHMARK_BLOCKS" \
   "${TXGEN_SEND_ARGS[@]}" \
   --wait-for-persistence never \
-  --report json:"$OUTPUT_DIR/report.json" 2>&1 | sed -u "s/^/[bench] /"
+  --report json:"$OUTPUT_DIR/report.json" \
+  "${CLICKHOUSE_REPORT[@]}" \
+  -m "git-sha=$GIT_SHA" \
+  -m "git-ref=$GIT_REF" \
+  -m "platform=ethereum" \
+  -m "scenario=replay" 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/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index c88d90c60ef..f7d13a06fb1 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -317,6 +317,9 @@ jobs:
       BENCH_OTLP_DISABLED: "true"
       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 }}
     steps:
       - name: Clean up previous bench-work
         run: sudo rm -rf "$BENCH_WORK_DIR" 2>/dev/null || true

From d2609bfb4ff69a0059882c02a5600e4466756659 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Wed, 13 May 2026 13:23:30 -0700
Subject: [PATCH 129/335] feat(examples): add custom state root example
 (#24135)

Co-authored-by: Centaur AI <ai@centaur.local>
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 Cargo.lock                             |  16 +++
 Cargo.toml                             |   1 +
 examples/custom-state-root/Cargo.toml  |  20 +++
 examples/custom-state-root/src/main.rs | 169 +++++++++++++++++++++++++
 4 files changed, 206 insertions(+)
 create mode 100644 examples/custom-state-root/Cargo.toml
 create mode 100644 examples/custom-state-root/src/main.rs

diff --git a/Cargo.lock b/Cargo.lock
index c37f85f85fb..641fa8541a1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3697,6 +3697,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"
diff --git a/Cargo.toml b/Cargo.toml
index 379d32c24bc..07d12c23ee4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -122,6 +122,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/",
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())
+}

From 4e515ac5fd06655300b3e3c820005170bce9418d Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Thu, 14 May 2026 13:52:59 +0400
Subject: [PATCH 130/335] fix: properly handle dummy blocks in migrate-v2
 (#24189)

---
 crates/cli/commands/src/db/migrate_v2.rs | 46 +++++++++++++++++++++---
 1 file changed, 42 insertions(+), 4 deletions(-)

diff --git a/crates/cli/commands/src/db/migrate_v2.rs b/crates/cli/commands/src/db/migrate_v2.rs
index 072fe0d419e..775e8e21713 100644
--- a/crates/cli/commands/src/db/migrate_v2.rs
+++ b/crates/cli/commands/src/db/migrate_v2.rs
@@ -21,15 +21,15 @@ 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,
+    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)]
@@ -326,6 +326,44 @@ impl Command {
             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, we initialize the stages that depend on block body indices data with
+            // 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),
+                )?;
+                provider_rw.save_stage_checkpoint(
+                    StageId::TransactionLookup,
+                    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 stages that depend on block body indices data with the first block that has a corresponding block body indices entry"
+                );
+            }
+        }
         provider_rw.commit()?;
 
         info!(target: "reth::cli", "Recomputable tables cleared");

From 94fa8ebe1b38c71ee2ef25b4c8950e09871e81c0 Mon Sep 17 00:00:00 2001
From: tempoxyz-bot <github-svc@tempo.xyz>
Date: Thu, 14 May 2026 12:20:32 +0200
Subject: [PATCH 131/335] perf(engine): reserve prewarm proof target sets
 (#24198)

Co-authored-by: autoopt[bot] <autoopt@tempo.xyz>
Co-authored-by: Amp <amp@ampcode.com>
---
 crates/engine/tree/src/tree/payload_processor/prewarm.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/engine/tree/src/tree/payload_processor/prewarm.rs b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
index afad0d9225d..3052a4ed078 100644
--- a/crates/engine/tree/src/tree/payload_processor/prewarm.rs
+++ b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
@@ -816,6 +816,8 @@ where
 /// 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

From 4b73a2417095416ce996f050ded39150ef244f87 Mon Sep 17 00:00:00 2001
From: Dan Cline <6798349+Rjected@users.noreply.github.com>
Date: Thu, 14 May 2026 07:00:09 -0400
Subject: [PATCH 132/335] ci(bench): add benchmarkoor replay workflow (#24172)

---
 .github/scripts/bench-benchmarkoor-run.sh     | 872 ++++++++++++++++++
 .../scripts/bench-benchmarkoor-snapshot.sh    | 289 ++++++
 .github/scripts/bench-benchmarkoor-summary.py | 313 +++++++
 .github/workflows/bench-benchmarkoor.yml      | 724 +++++++++++++++
 4 files changed, 2198 insertions(+)
 create mode 100755 .github/scripts/bench-benchmarkoor-run.sh
 create mode 100755 .github/scripts/bench-benchmarkoor-snapshot.sh
 create mode 100755 .github/scripts/bench-benchmarkoor-summary.py
 create mode 100644 .github/workflows/bench-benchmarkoor.yml

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/workflows/bench-benchmarkoor.yml b/.github/workflows/bench-benchmarkoor.yml
new file mode 100644
index 00000000000..3e74b938407
--- /dev/null
+++ b/.github/workflows/bench-benchmarkoor.yml
@@ -0,0 +1,724 @@
+# 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:
+  # Temporary test trigger for branch-only workflow validation.
+  # Remove before merging this workflow.
+  push:
+    branches:
+      - dan/create-benchmarkoor-replay-workflow
+  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-reth-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 }}" &
+          PID_FEATURE=$!
+          .github/scripts/bench-reth-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

From 420693521fccd1437071a15a4a54a3a98b5492cf Mon Sep 17 00:00:00 2001
From: Alexey Shekhirin <github@shekhirin.com>
Date: Thu, 14 May 2026 14:14:24 +0100
Subject: [PATCH 133/335] feat(cli): add `download --force` snapshot overwrite
 support (#24229)

---
 Cargo.lock                                 |  2 +
 bin/reth/Cargo.toml                        |  2 +
 bin/reth/tests/it/main.rs                  | 56 +++++++++++++++++++++-
 crates/cli/commands/src/download/mod.rs    | 53 ++++++++++++++++++--
 docs/vocs/docs/pages/cli/reth/download.mdx |  3 ++
 5 files changed, 110 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 641fa8541a1..b13abeac66e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7516,10 +7516,12 @@ dependencies = [
  "reth-tasks",
  "reth-transaction-pool",
  "serde_json",
+ "tar",
  "tempfile",
  "tokio",
  "toml",
  "tracing",
+ "zstd",
 ]
 
 [[package]]
diff --git a/bin/reth/Cargo.toml b/bin/reth/Cargo.toml
index 471bc8293ed..c4e9d7dcb2a 100644
--- a/bin/reth/Cargo.toml
+++ b/bin/reth/Cargo.toml
@@ -75,9 +75,11 @@ 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 = [
diff --git a/bin/reth/tests/it/main.rs b/bin/reth/tests/it/main.rs
index 8925168a1a9..3c311fcba66 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,43 @@ 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_overwrites_snapshot_data_but_preserves_identity_files() {
+    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("static_files")).expect("failed to create old static dir");
+    fs::write(datadir.join("db/old.mdbx"), b"old db").expect("failed to write old db file");
+    fs::write(datadir.join("static_files/old"), b"old static")
+        .expect("failed to write old static file");
+    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");
+    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("static_files/old").exists(), "old static 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"]"#
+    );
 }
 
 #[test]
diff --git a/crates/cli/commands/src/download/mod.rs b/crates/cli/commands/src/download/mod.rs
index 6884b4968bb..91fc472f210 100644
--- a/crates/cli/commands/src/download/mod.rs
+++ b/crates/cli/commands/src/download/mod.rs
@@ -114,6 +114,7 @@ use source::{
 use std::{
     borrow::Cow,
     collections::BTreeMap,
+    ffi::OsStr,
     path::{Path, PathBuf},
     sync::{Arc, OnceLock},
 };
@@ -124,6 +125,7 @@ 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_PRESERVED_DATADIR_FILES: &[&str] = &["discovery-secret", "known-peers.json"];
 
 /// Maximum number of simultaneous HTTP downloads across the entire snapshot job.
 const MAX_CONCURRENT_DOWNLOADS: usize = 8;
@@ -419,6 +421,10 @@ pub struct DownloadCommand<C: ChainSpecParser> {
     #[arg(long, short = 'y')]
     non_interactive: bool,
 
+    /// Overwrite existing snapshot data while preserving discovery-secret and known-peers.json.
+    #[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
@@ -448,11 +454,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 {
@@ -461,8 +462,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(),
@@ -493,6 +505,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,
@@ -847,6 +863,33 @@ fn selection_from_prune_mode(mode: Option<PruneMode>, snapshot_block: u64) -> Co
     }
 }
 
+/// Removes existing snapshot data while preserving files listed in
+/// [`FORCE_PRESERVED_DATADIR_FILES`].
+fn clear_existing_datadir(target_dir: &Path) -> Result<()> {
+    if !target_dir.try_exists()? {
+        return Ok(());
+    }
+
+    info!(target: "reth::cli", dir = ?target_dir, "Clearing existing data directory");
+    for entry in fs::read_dir(target_dir)? {
+        let entry = entry?;
+        let file_name = entry.file_name();
+        if FORCE_PRESERVED_DATADIR_FILES.iter().any(|preserved| file_name == OsStr::new(preserved))
+        {
+            continue;
+        }
+
+        let path = entry.path();
+        if entry.file_type()?.is_dir() {
+            fs::remove_dir_all(&path)?;
+        } else {
+            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(
diff --git a/docs/vocs/docs/pages/cli/reth/download.mdx b/docs/vocs/docs/pages/cli/reth/download.mdx
index 4f47697e9d4..57c368e6387 100644
--- a/docs/vocs/docs/pages/cli/reth/download.mdx
+++ b/docs/vocs/docs/pages/cli/reth/download.mdx
@@ -202,6 +202,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 while preserving discovery-secret and known-peers.json
+
       --resumable [<RESUMABLE>]
           Enable resumable two-phase downloads (download to disk first, then extract).
 

From fef3460212656ba22dc3982d48daf489cf712a69 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Thu, 14 May 2026 10:59:44 -0700
Subject: [PATCH 134/335] feat(reth-bb): enable otlp, otlp-logs, portable revm,
 and js-tracer by default (#24251)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 bin/reth-bb/Cargo.toml | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/bin/reth-bb/Cargo.toml b/bin/reth-bb/Cargo.toml
index eb3ab1d0ce1..41de839a59e 100644
--- a/bin/reth-bb/Cargo.toml
+++ b/bin/reth-bb/Cargo.toml
@@ -71,6 +71,23 @@ default = [
     "asm-keccak",
     "keccak-cache-global",
     "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 = [

From f511fee5689835c680260ea8ba3cc259db026b2c Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Fri, 15 May 2026 00:40:05 +0400
Subject: [PATCH 135/335] perf(bal): initialize state providers once per worker
 (#24254)

---
 .../src/tree/payload_processor/prewarm.rs     | 60 +++++++++----------
 1 file changed, 28 insertions(+), 32 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_processor/prewarm.rs b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
index 3052a4ed078..7c6ee4a9f3a 100644
--- a/crates/engine/tree/src/tree/payload_processor/prewarm.rs
+++ b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
@@ -28,8 +28,8 @@ 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, StateProvider, StateProviderBox,
+    StateProviderFactory, StateReader,
 };
 use reth_revm::{database::StateProviderDatabase, state::EvmState};
 use reth_tasks::{pool::WorkerPool, Runtime};
@@ -363,7 +363,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",
@@ -371,26 +371,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(());
@@ -407,24 +402,21 @@ where
                     "bal_prefetch_storage",
                     bal_accounts = prefetch_bal.as_bal().len(),
                 );
-                let provider_parent_span = branch_span.clone();
+                let 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);
-                    },
-                );
+                prefetch_bal.as_bal().par_iter().for_each(|account| {
+                    if ctx.should_stop() {
+                        return;
+                    }
+                    WorkerPool::with_worker_mut(|worker| {
+                        let provider = worker
+                            .get_or_init::<Option<CachedStateProvider<StateProviderBox, true>>>(
+                                || None,
+                            );
+                        ctx.prefetch_bal_storage(&parent_span, provider, account);
+                    });
+                });
 
                 let _ = prefetch_tx.send(());
             });
@@ -439,6 +431,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 });
     }
 

From ee4d1944d105a82977061ebcec711a8700bf8272 Mon Sep 17 00:00:00 2001
From: onbjerg <onbjerg@users.noreply.github.com>
Date: Fri, 15 May 2026 15:08:30 +0200
Subject: [PATCH 136/335] feat(bench): route BAL replays through txgen (#24261)

---
 .github/scripts/bench-txgen-build.sh   |  5 ---
 .github/scripts/bench-txgen-extract.sh | 25 +++++++++++--
 .github/scripts/bench-txgen-run.sh     | 52 +++++++++++++++++++++-----
 .github/workflows/bench.yml            |  8 ++--
 4 files changed, 68 insertions(+), 22 deletions(-)

diff --git a/.github/scripts/bench-txgen-build.sh b/.github/scripts/bench-txgen-build.sh
index 80329db9cd8..ad56ce8c52a 100755
--- a/.github/scripts/bench-txgen-build.sh
+++ b/.github/scripts/bench-txgen-build.sh
@@ -12,11 +12,6 @@ MODE="$1"
 SOURCE_DIR="$2"
 COMMIT="$3"
 
-if [ -n "${BENCH_BAL:-}" ] && [ "${BENCH_BAL}" != "false" ]; then
-  echo "::error::txgen path does not support BAL replay yet; use big-blocks with the reth-bench driver"
-  exit 1
-fi
-
 BIG_BLOCKS="${BENCH_BIG_BLOCKS:-false}"
 if [ "$BIG_BLOCKS" = "true" ]; then
   NODE_BIN="reth-bb"
diff --git a/.github/scripts/bench-txgen-extract.sh b/.github/scripts/bench-txgen-extract.sh
index 571e6946afd..39131424021 100755
--- a/.github/scripts/bench-txgen-extract.sh
+++ b/.github/scripts/bench-txgen-extract.sh
@@ -15,13 +15,19 @@
 #   <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
+# 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"
@@ -125,21 +131,27 @@ if [ "$BIG_BLOCKS" = "true" ]; then
 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)"
+  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)"
+  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
 
@@ -151,4 +163,11 @@ else
 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-run.sh b/.github/scripts/bench-txgen-run.sh
index f35c4811a6c..bc5364faafd 100755
--- a/.github/scripts/bench-txgen-run.sh
+++ b/.github/scripts/bench-txgen-run.sh
@@ -51,12 +51,29 @@ LOG="${OUTPUT_DIR}/node.log"
 
 RETH_SCOPE="${RETH_SCOPE:-reth-bench.scope}"
 
-# Unsupported txgen-path behavior is made explicit here. Keep this check near
-# the top so BAL support can be added when txgen supports it.
-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
+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
@@ -271,6 +288,15 @@ if [ -n "${TXGEN_PAYLOADS_DIR:-}" ] && [ -d "$TXGEN_PAYLOADS_DIR" ]; then
     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
@@ -293,21 +319,27 @@ else
   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)"
+    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)"
+    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
 
@@ -357,6 +389,8 @@ $BENCH_NICE "$TXGEN_BENCH" send-blocks \
   -m "git-sha=$GIT_SHA" \
   -m "git-ref=$GIT_REF" \
   -m "platform=ethereum" \
-  -m "scenario=replay" 2>&1 | sed -u "s/^/[bench] /"
+  -m "scenario=replay" \
+  -m "bal-mode=${BENCH_BAL:-false}" \
+  -m "bal-enabled=$USE_BAL" 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/workflows/bench.yml b/.github/workflows/bench.yml
index 065624ef324..afff127ad52 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -392,11 +392,9 @@ jobs:
               if (!featureName) featureName = '${{ github.ref_name }}';
             }
 
-            const fallbackReasons = [];
-            if (bal !== 'false') fallbackReasons.push('BAL');
-            const driver = fallbackReasons.length ? 'reth-bench' : 'txgen';
+            const driver = 'txgen';
             const nodeBin = bigBlocks === 'true' ? 'reth-bb' : 'reth';
-            const driverReason = fallbackReasons.join(',');
+            const driverReason = '';
 
             core.setOutput('pr', pr || '');
             core.setOutput('actor', actor);
@@ -631,7 +629,7 @@ jobs:
       BENCH_DRIVER_REASON: ${{ needs.reth-bench-ack.outputs.driver-reason }}
       BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
       BENCH_METRICS_ADDR: "127.0.0.1:9001"
-      TXGEN_REV: 64826ac816380586e4856e2d1d2d20f4d4e66198
+      TXGEN_REV: 51e7dd935728b5d77c10ddac59ba327418271aab
       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:

From 5b0d340b5f2a388a748b623604ca1f74c05b9785 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Fri, 15 May 2026 08:18:09 -0700
Subject: [PATCH 137/335] bench: remove wait time thread reply from Slack
 notifications (#24264)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/scripts/bench-slack-notify.js | 38 ++++-----------------------
 1 file changed, 5 insertions(+), 33 deletions(-)

diff --git a/.github/scripts/bench-slack-notify.js b/.github/scripts/bench-slack-notify.js
index c9c3ccc3333..a786870c63c 100644
--- a/.github/scripts/bench-slack-notify.js
+++ b/.github/scripts/bench-slack-notify.js
@@ -18,7 +18,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { fmtChange, fmtMs, verdict, loadSamplyUrls, blocksLabel, metricRows, waitTimeRows } = require('./bench-utils');
+const { fmtChange, fmtMs, verdict, loadSamplyUrls, blocksLabel, metricRows } = require('./bench-utils');
 
 const SLACK_API = 'https://slack.com/api/chat.postMessage';
 
@@ -157,26 +157,7 @@ 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 }) {
@@ -241,18 +222,9 @@ async function success({ core, context }) {
   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 });
   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
@@ -262,7 +234,7 @@ async function success({ core, context }) {
     const changes = summary.changes || {};
     const hasImprovement = Object.values(changes).some(c => c.sig === 'good');
     if (hasImprovement) {
-      await sendWithThread(channel);
+      await postToSlack(token, channel, blocks, text, core);
       postedToChannel = true;
     } else {
       core.info('No significant improvement, skipping public channel notification');
@@ -280,7 +252,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`);
     }

From 8f6b90ebed5137aec1130b39cfb99b9a9e2cd907 Mon Sep 17 00:00:00 2001
From: onbjerg <onbjerg@users.noreply.github.com>
Date: Fri, 15 May 2026 19:39:09 +0200
Subject: [PATCH 138/335] ci(bench): remove legacy reth-bench workflow path
 (#24262)

---
 .github/scripts/bench-job-summary.js          |   2 +-
 .github/scripts/bench-metrics-proxy.py        |   4 +-
 .github/scripts/bench-reth-build.sh           | 159 -----
 .github/scripts/bench-reth-charts.py          |   2 +-
 .github/scripts/bench-reth-local.sh           | 574 ------------------
 .github/scripts/bench-reth-run.sh             | 354 -----------
 .github/scripts/bench-reth-summary.py         |  17 +-
 .github/scripts/bench-slack-notify.js         |   2 +-
 .github/scripts/bench-txgen-build.sh          |   6 +-
 .github/scripts/bench-txgen-install.sh        |   4 +-
 .../scripts/bench-txgen-report-to-reth-csv.py |   8 +-
 .github/scripts/bench-txgen-run.sh            |   2 +-
 .github/scripts/bench-update-status.js        |   2 +-
 .github/scripts/bench-update-status.sh        |   2 +-
 .github/scripts/bench-utils.js                |   8 +-
 .github/workflows/bench-benchmarkoor.yml      |   6 +-
 .github/workflows/bench-scheduled.yml         |  41 +-
 .github/workflows/bench.yml                   | 129 ++--
 18 files changed, 70 insertions(+), 1252 deletions(-)
 delete mode 100755 .github/scripts/bench-reth-build.sh
 delete mode 100755 .github/scripts/bench-reth-local.sh
 delete mode 100755 .github/scripts/bench-reth-run.sh

diff --git a/.github/scripts/bench-job-summary.js b/.github/scripts/bench-job-summary.js
index 21caf88c7d0..096ef596afd 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
diff --git a/.github/scripts/bench-metrics-proxy.py b/.github/scripts/bench-metrics-proxy.py
index 5adfba751cc..e0ee724a3e6 100644
--- a/.github/scripts/bench-metrics-proxy.py
+++ b/.github/scripts/bench-metrics-proxy.py
@@ -3,8 +3,8 @@
 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.
+Reads labels from a JSON file updated between benchmark runs and injects them
+into every Prometheus metric line.
 
 Returns empty 200 when reth is not running (clean Grafana gaps).
 """
diff --git a/.github/scripts/bench-reth-build.sh b/.github/scripts/bench-reth-build.sh
deleted file mode 100755
index 13e5c171e42..00000000000
--- a/.github/scripts/bench-reth-build.sh
+++ /dev/null
@@ -1,159 +0,0 @@
-#!/usr/bin/env bash
-#
-# Builds (or fetches from cache) reth binaries for benchmarking.
-#
-# Usage: bench-reth-build.sh <baseline|feature> <source-dir> <commit> [cache-sha]
-#
-#   baseline — build/fetch the baseline binary at <commit> (merge-base)
-#              source-dir must be checked out at <commit>
-#   feature  — build/fetch the candidate binary + reth-bench at <commit>
-#              source-dir must be checked out at <commit>
-#              optional cache-sha is the PR head commit for cache key
-#
-# 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
-#   BENCH_BINARY_CACHE_ROOT       — MinIO cache root (default: minio/reth-binaries)
-set -euxo pipefail
-
-MC="${MC:-mc}"
-MODE="$1"
-SOURCE_DIR="$2"
-COMMIT="$3"
-CACHE_ROOT="${BENCH_BINARY_CACHE_ROOT:-minio/reth-binaries}"
-RETH_BENCH_BIN="${CARGO_HOME:-$HOME/.cargo}/bin/reth-bench"
-
-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
-
-hash_build_config() {
-  if command -v sha256sum &>/dev/null; then
-    sha256sum | cut -c1-12
-  else
-    shasum -a 256 | cut -c1-12
-  fi
-}
-
-# Cache suffix: hash of features+rustflags so different build configs get separate cache entries.
-if [ -n "$EXTRA_FEATURES" ] || [ -n "$EXTRA_RUSTFLAGS" ]; then
-  BUILD_SUFFIX="-$(printf '%s' "${EXTRA_FEATURES}${EXTRA_RUSTFLAGS}" | hash_build_config)"
-else
-  BUILD_SUFFIX=""
-fi
-
-# Verify a cached reth binary was built from the expected commit.
-# `reth --version` outputs "Commit SHA: <full-sha>" on its own line.
-verify_binary() {
-  local binary="$1" expected_commit="$2"
-  local version binary_sha
-  version=$("$binary" --version 2>/dev/null) || return 1
-  binary_sha=$(echo "$version" | sed -n 's/^Commit SHA: *//p')
-  if [ -z "$binary_sha" ]; then
-    echo "Warning: could not extract commit SHA from version output"
-    return 1
-  fi
-  if [ "$binary_sha" = "$expected_commit" ]; then
-    return 0
-  fi
-  echo "Cache mismatch: binary built from ${binary_sha} but expected ${expected_commit}"
-  return 1
-}
-
-upload_cache_artifact() {
-  local source="$1" destination="$2"
-  if ! $MC cp "$source" "$destination"; then
-    echo "::warning::Failed to upload binary cache artifact to ${destination}; continuing without remote cache write"
-  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)
-    BUCKET="${CACHE_ROOT}/${COMMIT}${BUILD_SUFFIX}"
-    mkdir -p "${SOURCE_DIR}/target/profiling"
-
-    CACHE_VALID=false
-    if $MC stat --no-list "${BUCKET}/${NODE_BIN}" &>/dev/null; then
-      echo "Cache hit for baseline (${COMMIT}), downloading ${NODE_BIN}..."
-      if $MC cp "${BUCKET}/${NODE_BIN}" "${SOURCE_DIR}/target/profiling/${NODE_BIN}" && \
-         chmod +x "${SOURCE_DIR}/target/profiling/${NODE_BIN}" && \
-         verify_binary "${SOURCE_DIR}/target/profiling/${NODE_BIN}" "${COMMIT}"; then
-        CACHE_VALID=true
-      else
-        echo "Cached baseline binary is stale or download failed, rebuilding..."
-      fi
-    fi
-    if [ "$CACHE_VALID" = false ]; then
-      echo "Building baseline ${NODE_BIN} (${COMMIT}) from source..."
-      build_node_binary
-      upload_cache_artifact "${SOURCE_DIR}/target/profiling/${NODE_BIN}" "${BUCKET}/${NODE_BIN}"
-    fi
-    ;;
-
-  feature|branch)
-    CACHE_SHA="${4:-$COMMIT}"
-    BUCKET="${CACHE_ROOT}/${CACHE_SHA}${BUILD_SUFFIX}"
-
-    CACHE_VALID=false
-    if $MC stat --no-list "${BUCKET}/${NODE_BIN}" &>/dev/null && $MC stat --no-list "${BUCKET}/reth-bench" &>/dev/null; then
-      echo "Cache hit for ${CACHE_SHA}, downloading binaries..."
-      mkdir -p "${SOURCE_DIR}/target/profiling" "$(dirname "$RETH_BENCH_BIN")"
-      if $MC cp "${BUCKET}/${NODE_BIN}" "${SOURCE_DIR}/target/profiling/${NODE_BIN}" && \
-         $MC cp "${BUCKET}/reth-bench" "$RETH_BENCH_BIN" && \
-         chmod +x "${SOURCE_DIR}/target/profiling/${NODE_BIN}" "$RETH_BENCH_BIN" && \
-         verify_binary "${SOURCE_DIR}/target/profiling/${NODE_BIN}" "${COMMIT}"; then
-        CACHE_VALID=true
-      else
-        echo "Cached feature binary is stale or download failed, rebuilding..."
-      fi
-    fi
-    if [ "$CACHE_VALID" = false ]; then
-      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
-      upload_cache_artifact "${SOURCE_DIR}/target/profiling/${NODE_BIN}" "${BUCKET}/${NODE_BIN}"
-      upload_cache_artifact "$RETH_BENCH_BIN" "${BUCKET}/reth-bench"
-    fi
-    ;;
-
-  *)
-    echo "Usage: $0 <baseline|feature> <source-dir> <commit> [cache-sha]"
-    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 5d15da5e4bb..00000000000
--- a/.github/scripts/bench-reth-local.sh
+++ /dev/null
@@ -1,574 +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) and
-# BENCH_SNAPSHOT_MANIFEST_URL pointing at the benchmark snapshot manifest.
-#
-# 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:9001"
-
-# ── 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: 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 4: Sync snapshot ────────────────────────────────────────────
-echo "▸ Syncing snapshot..."
-BENCH_RETH_BINARY="${FEATURE_SRC}/target/profiling/reth" "${SCRIPTS_DIR}/bench-reth-snapshot.sh"
-echo "  Snapshot is ready."
-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 \
-    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
-
-  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="$(mktemp "${TMPDIR:-/tmp}/bench-metrics-labels.XXXXXX")"
-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="efk1hcn87dnnkd"
-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 3e077d21d18..00000000000
--- a/.github/scripts/bench-reth-run.sh
+++ /dev/null
@@ -1,354 +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=$(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}"
-
-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
-)
-
-# Keep the engine in startup sync mode until the pipeline is idle. Older
-# baselines may not have this flag, so gate it on clap help output.
-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 --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
-
-# 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
-
-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: generate synthetic payloads in flight with new-payload-fcu.
-  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
-  if [ -n "${BENCH_BIG_BLOCKS_TARGET_GAS:-}" ]; then
-    BB_BENCH_ARGS+=(--big-blocks-target-gas "$BENCH_BIG_BLOCKS_TARGET_GAS")
-  fi
-  case "$BENCH_BAL_MODE" in
-    false)
-      ;;
-    true)
-      BB_BENCH_ARGS+=(--enable-bal)
-      ;;
-    baseline)
-      if [[ "$LABEL" == baseline* ]]; then
-        BB_BENCH_ARGS+=(--enable-bal)
-      fi
-      ;;
-    feature)
-      if [[ "$LABEL" == feature* ]]; then
-        BB_BENCH_ARGS+=(--enable-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" new-payload-fcu \
-      --rpc-url "$BENCH_RPC_URL" \
-      "${BB_BENCH_ARGS[@]}" \
-      --big-blocks "$WARMUP" \
-      --engine-rpc-url http://127.0.0.1:8551 \
-      --jwt-secret "$DATADIR/jwt.hex" 2>&1 | sed -u "s/^/[bench] /"
-  else
-    echo "Skipping big blocks warmup (0 payloads)..."
-  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
-
-  if [ "${BENCH_BLOCKS:-0}" -le 0 ] 2>/dev/null; then
-    echo "::error::BENCH_BLOCKS must be greater than 0 for big-block benchmarks"
-    exit 1
-  fi
-
-  echo "Running big blocks benchmark (new-payload-fcu, count=${BENCH_BLOCKS})..."
-  $BENCH_NICE "$RETH_BENCH" new-payload-fcu \
-    --rpc-url "$BENCH_RPC_URL" \
-    "${BB_BENCH_ARGS[@]}" \
-    --big-blocks "$BENCH_BLOCKS" \
-    --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-summary.py b/.github/scripts/bench-reth-summary.py
index 0d5197e394d..7d660872e1a 100755
--- a/.github/scripts/bench-reth-summary.py
+++ b/.github/scripts/bench-reth-summary.py
@@ -1,5 +1,5 @@
 #!/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> \
@@ -520,8 +520,6 @@ def generate_comparison_table(
     warmup_blocks: str | None = None,
     wait_time: str | None = None,
     bal_mode: str | None = None,
-    driver: str | None = None,
-    driver_reason: str | None = None,
 ) -> str:
     """Generate a markdown comparison table between baseline and feature."""
     n = paired["blocks"]
@@ -570,11 +568,6 @@ def pct(base: float, feat: float) -> float:
         "",
     ]
     meta_parts = [f"{n} {'big blocks' if big_blocks else 'blocks'}"]
-    if driver:
-        driver_label = driver
-        if driver_reason:
-            driver_label += f" (fallback: {driver_reason})"
-        meta_parts.append(f"driver: {driver_label}")
     if warmup_blocks:
         meta_parts.append(f"{warmup_blocks} warmup")
     if wait_time:
@@ -639,7 +632,7 @@ def generate_markdown(
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Parse reth-bench ABBA results")
+    parser = argparse.ArgumentParser(description="Parse benchmark ABBA results")
     parser.add_argument(
         "--baseline-csv", nargs="+", required=True,
         help="Baseline combined_latency.csv files (A1, A2)",
@@ -665,8 +658,6 @@ 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("--driver-reason", default=None, help="Why the benchmark fell back to this driver")
     parser.add_argument("--grafana-url", default=None, help="Grafana dashboard URL for this benchmark run")
     args = parser.parse_args()
 
@@ -721,8 +712,6 @@ def main():
         warmup_blocks=args.warmup_blocks,
         wait_time=args.wait_time,
         bal_mode=bal_mode,
-        driver=args.driver,
-        driver_reason=args.driver_reason,
     )
     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)")
@@ -753,8 +742,6 @@ def main():
 
     summary = {
         "blocks": paired_stats["blocks"],
-        "driver": args.driver,
-        "driver_reason": args.driver_reason,
         "big_blocks": args.big_blocks,
         "warmup_blocks": args.warmup_blocks,
         "wait_time": args.wait_time,
diff --git a/.github/scripts/bench-slack-notify.js b/.github/scripts/bench-slack-notify.js
index a786870c63c..db9ef6de158 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-...)
diff --git a/.github/scripts/bench-txgen-build.sh b/.github/scripts/bench-txgen-build.sh
index ad56ce8c52a..4c040558064 100755
--- a/.github/scripts/bench-txgen-build.sh
+++ b/.github/scripts/bench-txgen-build.sh
@@ -1,11 +1,11 @@
 #!/usr/bin/env bash
 #
-# Builds the node binary for the txgen-backed PR benchmark path.
+# Builds the node binary used by benchmark workflows.
 #
 # Usage: bench-txgen-build.sh <baseline|feature> <source-dir> <commit>
 #
-# This intentionally does not build or install reth-bench. Big-block benchmarks
-# build reth-bb because txgen replays reth-bb's extended payload format.
+# Big-block benchmarks build reth-bb because txgen replays reth-bb's extended
+# payload format.
 set -euxo pipefail
 
 MODE="$1"
diff --git a/.github/scripts/bench-txgen-install.sh b/.github/scripts/bench-txgen-install.sh
index e3334dc2a3b..384d0ed7c94 100755
--- a/.github/scripts/bench-txgen-install.sh
+++ b/.github/scripts/bench-txgen-install.sh
@@ -1,8 +1,6 @@
 #!/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.
+# Installs the txgen tools used by the benchmark workflows.
 #
 # Required env:
 #   TXGEN_REV   – pinned txgen git revision
diff --git a/.github/scripts/bench-txgen-report-to-reth-csv.py b/.github/scripts/bench-txgen-report-to-reth-csv.py
index 01620d94260..6501abe617a 100755
--- a/.github/scripts/bench-txgen-report-to-reth-csv.py
+++ b/.github/scripts/bench-txgen-report-to-reth-csv.py
@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
-"""Convert txgen `bench send-blocks` JSON into the legacy reth-bench CSVs.
+"""Convert txgen `bench send-blocks` JSON into legacy benchmark 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
+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.
 """
 
@@ -29,7 +29,7 @@ def block_latency_us(block: dict) -> tuple[int, int, int]:
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser(description="Convert txgen JSON report to reth-bench CSVs")
+    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()
diff --git a/.github/scripts/bench-txgen-run.sh b/.github/scripts/bench-txgen-run.sh
index bc5364faafd..65603ca957a 100755
--- a/.github/scripts/bench-txgen-run.sh
+++ b/.github/scripts/bench-txgen-run.sh
@@ -2,7 +2,7 @@
 #
 # 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.
+# convert txgen JSON report into legacy benchmark CSVs.
 #
 # Usage: bench-txgen-run.sh <label> <binary> <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
index 4c04943d19b..b26db9ae44a 100755
--- a/.github/scripts/bench-update-status.sh
+++ b/.github/scripts/bench-update-status.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Updates the reth-bench PR comment with current status via the GitHub API.
+# Updates the benchmark PR comment with current status via the GitHub API.
 #
 # Usage: bench-update-status.sh "Running benchmark: feature (1/2)..."
 #
diff --git a/.github/scripts/bench-utils.js b/.github/scripts/bench-utils.js
index 2889e706d85..8f5f52e6b55 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.
 
@@ -54,12 +54,6 @@ function balModeLabel(mode) {
 
 function blocksLabel(summary) {
   const parts = [];
-  const driver = summary.driver || process.env.BENCH_DRIVER || '';
-  const driverReason = summary.driver_reason || process.env.BENCH_DRIVER_REASON || '';
-  if (driver) {
-    const value = driverReason ? `${driver} (fallback: ${driverReason})` : driver;
-    parts.push({ key: 'Driver', value });
-  }
   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-benchmarkoor.yml b/.github/workflows/bench-benchmarkoor.yml
index 3e74b938407..02bbae4f53e 100644
--- a/.github/workflows/bench-benchmarkoor.yml
+++ b/.github/workflows/bench-benchmarkoor.yml
@@ -423,11 +423,11 @@ jobs:
           FEATURE_DIR="$(cd ../reth-feature && pwd)"
           DOWNLOAD_DIR="$(cd ../reth-download && pwd)"
 
-          .github/scripts/bench-reth-build.sh baseline "$BASELINE_DIR" "${{ steps.refs.outputs.baseline-ref }}" &
+          .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=$!
-          .github/scripts/bench-reth-build.sh baseline "$DOWNLOAD_DIR" "${{ steps.refs.outputs.download-ref }}" &
+          .github/scripts/bench-txgen-build.sh baseline "$DOWNLOAD_DIR" "${{ steps.refs.outputs.download-ref }}" &
           PID_DOWNLOAD=$!
 
           FAIL=0
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index f7d13a06fb1..1071eae40f0 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -308,9 +308,7 @@ jobs:
       BENCH_ABBA: "true"
       BENCH_COMMENT_ID: ""
       BENCH_SLACK: ${{ github.event_name == 'workflow_dispatch' && inputs.slack || 'always' }}
-      BENCH_DRIVER: txgen
       BENCH_NODE_BIN: reth
-      BENCH_DRIVER_REASON: ""
       BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
       BENCH_METRICS_ADDR: "127.0.0.1:9001"
       TXGEN_REV: 5b04a80d557cc6658573db6ccf49ce04cbf07ea3
@@ -457,12 +455,8 @@ jobs:
           BASELINE_DIR="$(cd ../reth-baseline && pwd)"
           FEATURE_DIR="$(cd ../reth-feature && pwd)"
 
-          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
+          .github/scripts/bench-txgen-install.sh
+          BUILD_SCRIPT=.github/scripts/bench-txgen-build.sh
 
           "$BUILD_SCRIPT" baseline "${BASELINE_DIR}" "$BASELINE_REF" &
           PID_BASELINE=$!
@@ -562,7 +556,6 @@ jobs:
       # Extract txgen payloads once so they are reused across all benchmark
       # runs instead of re-fetching from the remote RPC four times.
       - name: Extract txgen payloads
-        if: env.BENCH_DRIVER == 'txgen'
         run: |
           PAYLOADS_DIR="$BENCH_WORK_DIR/txgen-payloads"
           .github/scripts/bench-txgen-extract.sh \
@@ -577,11 +570,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
-          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"
+          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
@@ -589,11 +578,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
-          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"
+          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
@@ -601,11 +586,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
-          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"
+          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
@@ -615,11 +596,7 @@ 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
-          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"
+          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
         id: metrics
@@ -694,12 +671,6 @@ jobs:
           if [ -n "$GRAFANA_URL" ]; then
             SUMMARY_ARGS="$SUMMARY_ARGS --grafana-url $GRAFANA_URL"
           fi
-          if [ -n "${BENCH_DRIVER:-}" ]; then
-            SUMMARY_ARGS="$SUMMARY_ARGS --driver $BENCH_DRIVER"
-          fi
-          if [ -n "${BENCH_DRIVER_REASON:-}" ]; then
-            SUMMARY_ARGS="$SUMMARY_ARGS --driver-reason $BENCH_DRIVER_REASON"
-          fi
           # shellcheck disable=SC2086
           python3 .github/scripts/bench-reth-summary.py $SUMMARY_ARGS
 
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index afff127ad52..fe833febf01 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
@@ -102,11 +102,11 @@ 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
@@ -131,9 +131,7 @@ jobs:
       feature-args: ${{ steps.args.outputs.feature-args }}
       abba: ${{ steps.args.outputs.abba }}
       otlp: ${{ steps.args.outputs.otlp }}
-      driver: ${{ steps.args.outputs.driver }}
       node-bin: ${{ steps.args.outputs.node-bin }}
-      driver-reason: ${{ steps.args.outputs.driver-reason }}
       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 }}
@@ -392,9 +390,7 @@ jobs:
               if (!featureName) featureName = '${{ github.ref_name }}';
             }
 
-            const driver = 'txgen';
             const nodeBin = bigBlocks === 'true' ? 'reth-bb' : 'reth';
-            const driverReason = '';
 
             core.setOutput('pr', pr || '');
             core.setOutput('actor', actor);
@@ -415,9 +411,7 @@ jobs:
             core.setOutput('feature-args', featureNodeArgs);
             core.setOutput('abba', abba);
             core.setOutput('otlp', otlp);
-            core.setOutput('driver', driver);
             core.setOutput('node-bin', nodeBin);
-            core.setOutput('driver-reason', driverReason);
 
       - name: Acknowledge request
         id: ack
@@ -493,11 +487,8 @@ jobs:
             const baselineArgsNote = baselineArgsVal ? `, baseline-args: \`${baselineArgsVal}\`` : '';
             const featureArgsVal = '${{ steps.args.outputs.feature-args }}';
             const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
-            const driver = '${{ steps.args.outputs.driver }}' || (bal !== 'false' ? 'reth-bench' : 'txgen');
-            const driverReason = '${{ steps.args.outputs.driver-reason }}';
-            const driverNote = driverReason ? `, driver: \`${driver}\` (fallback: \`${driverReason}\`)` : `, driver: \`${driver}\``;
             const blocksDesc = bigBlocks ? 'blocks: `big`' : `${blocks} blocks, ${warmup} warmup blocks`;
-            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${driverNote}${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
+            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
 
             const { data: comment } = await github.rest.issues.createComment({
               owner: context.repo.owner,
@@ -540,11 +531,8 @@ jobs:
             const baselineArgsNote = baselineArgsVal ? `, baseline-args: \`${baselineArgsVal}\`` : '';
             const featureArgsVal = '${{ steps.args.outputs.feature-args }}';
             const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
-            const driver = '${{ steps.args.outputs.driver }}' || (bal !== 'false' ? 'reth-bench' : 'txgen');
-            const driverReason = '${{ steps.args.outputs.driver-reason }}';
-            const driverNote = driverReason ? `, driver: \`${driver}\` (fallback: \`${driverReason}\`)` : `, driver: \`${driver}\``;
             const blocksDesc = bigBlocks ? 'blocks: `big`' : `${blocks} blocks, ${warmup} warmup blocks`;
-            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${driverNote}${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
+            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${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;
@@ -593,9 +581,9 @@ jobs:
               }
             }
 
-  reth-bench:
-    needs: reth-bench-ack
-    name: bench-${{ needs.reth-bench-ack.outputs.driver }}
+  bench-txgen:
+    needs: bench-ack
+    name: bench-txgen
     runs-on: [self-hosted, Linux, X64, available]
     permissions:
       contents: read
@@ -606,32 +594,30 @@ jobs:
       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_PR_HEAD_SHA: ${{ needs.reth-bench-ack.outputs.pr-head-sha }}
-      BENCH_PR_HEAD_REF: ${{ needs.reth-bench-ack.outputs.pr-head-ref }}
-      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_BIG_BLOCKS_TARGET_GAS: ${{ needs.reth-bench-ack.outputs.big-blocks-target-gas }}
-      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_DRIVER: ${{ needs.reth-bench-ack.outputs.driver }}
-      BENCH_NODE_BIN: ${{ needs.reth-bench-ack.outputs.node-bin }}
-      BENCH_DRIVER_REASON: ${{ needs.reth-bench-ack.outputs.driver-reason }}
+      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_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_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_ABBA: ${{ needs.bench-ack.outputs.abba }}
+      BENCH_OTLP: ${{ needs.bench-ack.outputs.otlp }}
+      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"
       TXGEN_REV: 51e7dd935728b5d77c10ddac59ba327418271aab
-      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_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 || '' }}
     steps:
       - name: Clean up previous bench-work
         run: sudo rm -rf "$BENCH_WORK_DIR" 2>/dev/null || true
@@ -671,15 +657,15 @@ jobs:
               repo: context.repo.repo,
               run_id: context.runId,
             });
-            const expectedJobName = `bench-${process.env.BENCH_DRIVER || 'txgen'}`;
+            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 slack = process.env.BENCH_SLACK || 'always';
             const bigBlocks = process.env.BENCH_BIG_BLOCKS === 'true';
@@ -699,11 +685,8 @@ 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 || (bal !== 'false' ? 'reth-bench' : 'txgen');
-            const driverReason = process.env.BENCH_DRIVER_REASON || '';
-            const driverNote = driverReason ? `, driver: \`${driver}\` (fallback: \`${driverReason}\`)` : `, driver: \`${driver}\``;
             const blocksDesc = bigBlocks ? 'blocks: `big`' : `${blocks} blocks, ${warmup} warmup blocks`;
-            core.exportVariable('BENCH_CONFIG', `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${driverNote}${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`);
+            core.exportVariable('BENCH_CONFIG', `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${abbaNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`);
 
             const { buildBody } = require('./.github/scripts/bench-update-status.js');
             await github.rest.issues.updateComment({
@@ -804,8 +787,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;
 
@@ -881,16 +864,11 @@ jobs:
           BASELINE_DIR="$(cd ../reth-baseline && pwd)"
           FEATURE_DIR="$(cd ../reth-feature && pwd)"
 
-          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
+          .github/scripts/bench-txgen-install.sh
 
-          "$BUILD_SCRIPT" baseline "${BASELINE_DIR}" "${{ steps.refs.outputs.baseline-ref }}" &
+          .github/scripts/bench-txgen-build.sh baseline "${BASELINE_DIR}" "${{ steps.refs.outputs.baseline-ref }}" &
           PID_BASELINE=$!
-          "$BUILD_SCRIPT" 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
@@ -1007,7 +985,6 @@ jobs:
       # Extract txgen payloads once so they are reused across all benchmark
       # runs instead of re-fetching from the remote RPC four times.
       - name: Extract txgen payloads
-        if: env.BENCH_DRIVER == 'txgen'
         run: |
           PAYLOADS_DIR="$BENCH_WORK_DIR/txgen-payloads"
           .github/scripts/bench-txgen-extract.sh \
@@ -1030,11 +1007,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":"${LAST_RUN_START}","reference_epoch":"${BENCH_REFERENCE_EPOCH}"}
           LABELS
-          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"
+          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: baseline (1/2)"
         id: run-baseline-1
@@ -1049,11 +1022,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":"${LAST_RUN_START}","reference_epoch":"${BENCH_REFERENCE_EPOCH}"}
           LABELS
-          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"
+          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: baseline (2/2)"
         if: env.BENCH_ABBA != 'false'
@@ -1069,11 +1038,7 @@ 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
-          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"
+          taskset -c 0 .github/scripts/bench-txgen-run.sh baseline "../reth-baseline/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/baseline-2"
 
       - name: "Run benchmark: feature (2/2)"
         if: env.BENCH_ABBA != 'false'
@@ -1089,11 +1054,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":"${LAST_RUN_START}","reference_epoch":"${BENCH_REFERENCE_EPOCH}"}
           LABELS
-          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"
+          taskset -c 0 .github/scripts/bench-txgen-run.sh feature "../reth-feature/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/feature-2"
 
       - name: Stop metrics proxy & generate Grafana URL
         id: metrics
@@ -1232,12 +1193,6 @@ 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
-          if [ -n "${BENCH_DRIVER_REASON:-}" ]; then
-            SUMMARY_ARGS="$SUMMARY_ARGS --driver-reason $BENCH_DRIVER_REASON"
-          fi
           GRAFANA_URL='${{ steps.metrics.outputs.grafana-url }}'
           if [ -n "$GRAFANA_URL" ]; then
             SUMMARY_ARGS="$SUMMARY_ARGS --grafana-url $GRAFANA_URL"

From b61b5436be9f376e1e4cfba39e267154f50120e1 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Fri, 15 May 2026 22:11:12 +0400
Subject: [PATCH 139/335] feat(migrate-v2): migrate mdbx -> rocksdb (#24230)

---
 crates/cli/commands/src/db/migrate_v2.rs | 77 +++++++++++++++---------
 1 file changed, 47 insertions(+), 30 deletions(-)

diff --git a/crates/cli/commands/src/db/migrate_v2.rs b/crates/cli/commands/src/db/migrate_v2.rs
index 775e8e21713..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;
@@ -23,7 +19,8 @@ use reth_node_builder::NodeTypesWithDBAdapter;
 use reth_provider::{
     providers::ProviderNodeTypes, BlockNumReader, DBProvider, DatabaseProviderFactory,
     MetadataProvider, MetadataWriter, ProviderFactory, PruneCheckpointReader,
-    StageCheckpointWriter, StaticFileProviderFactory, StaticFileWriter, StorageSettings,
+    RocksDBProviderFactory, StageCheckpointWriter, StaticFileProviderFactory, StaticFileWriter,
+    StorageSettings,
 };
 use reth_prune_types::PruneSegment;
 use reth_stages_types::{StageCheckpoint, StageId};
@@ -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", "Clearing recomputable MDBX tables");
+        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 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,14 +342,7 @@ 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");
         }
@@ -339,17 +360,13 @@ impl Command {
             // was likely initialized with dummy blocks coming from a dummy chain generated by
             // `setup_without_evm`.
             //
-            // In that case, we initialize the stages that depend on block body indices data with
-            // the first block that has a corresponding block body indices entry.
+            // 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),
                 )?;
-                provider_rw.save_stage_checkpoint(
-                    StageId::TransactionLookup,
-                    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();
@@ -360,7 +377,7 @@ impl Command {
 
                 warn!(
                     target: "reth::cli",
-                    "Missing block body indices data for first {first_indices_entry} blocks, initializing stages that depend on block body indices data with the first block that has a corresponding block body indices entry"
+                    "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"
                 );
             }
         }

From 080df4503108b9d4cc6d0629f74427b4afa64321 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Fri, 15 May 2026 17:02:41 -0700
Subject: [PATCH 140/335] ci(bench): bump txgen to latest commit (#24266)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/workflows/bench.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index fe833febf01..955b6389e00 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -615,7 +615,7 @@ jobs:
       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"
-      TXGEN_REV: 51e7dd935728b5d77c10ddac59ba327418271aab
+      TXGEN_REV: f439eec4e0f6dbe0675dd3bac8192d9f0299d409
       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 || '' }}
     steps:

From 49fe11041a9d8f58ebb4087dd9569a2cdbe4d027 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Sun, 17 May 2026 00:23:11 -0700
Subject: [PATCH 141/335] feat(discv4): add enforce_eip868_neighbours config
 setting (#23503)

Co-authored-by: Matthias Seitz <19890894+mattsse@users.noreply.github.com>
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/discv4/src/config.rs | 18 ++++++++++++++++++
 crates/net/discv4/src/lib.rs    | 20 +++++++++++++++++---
 2 files changed, 35 insertions(+), 3 deletions(-)

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

From c4c690f703e3e5ca336c62bc28ea912d9e8e401c Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Sun, 17 May 2026 16:00:48 +0200
Subject: [PATCH 142/335] chore(deps): update alloy core to 1.6.0 (#24275)

---
 Cargo.lock | 163 ++++++++++++++++++++++++++++++++++++++---------------
 Cargo.toml |   6 +-
 2 files changed, 119 insertions(+), 50 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b13abeac66e..4ab9179a3f6 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",
 ]
 
@@ -187,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",
@@ -199,7 +199,7 @@ dependencies = [
  "itoa",
  "serde",
  "serde_json",
- "winnow 0.7.15",
+ "winnow 1.0.1",
 ]
 
 [[package]]
@@ -376,9 +376,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",
@@ -464,9 +464,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",
@@ -477,20 +477,21 @@ 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]]
@@ -836,9 +837,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",
@@ -850,9 +851,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",
@@ -861,16 +862,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",
@@ -884,19 +885,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",
@@ -995,7 +996,7 @@ dependencies = [
  "derive_more",
  "nybbles",
  "proptest",
- "proptest-derive",
+ "proptest-derive 0.7.0",
  "serde",
  "smallvec",
  "thiserror 2.0.18",
@@ -1754,6 +1755,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"
@@ -2232,7 +2242,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",
 ]
 
@@ -2410,7 +2420,7 @@ dependencies = [
  "ripemd",
  "serde",
  "sha2",
- "sha3",
+ "sha3 0.10.8",
  "thiserror 1.0.69",
 ]
 
@@ -2454,7 +2464,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
 dependencies = [
  "lazy_static",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2793,6 +2803,15 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "crypto-common"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77727bb15fa921304124b128af125e7e3b968275d1b108b379190264f4423710"
+dependencies = [
+ "hybrid-array",
+]
+
 [[package]]
 name = "csv"
 version = "1.4.0"
@@ -3120,12 +3139,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"
@@ -3391,7 +3420,7 @@ dependencies = [
  "rand 0.8.6",
  "secp256k1 0.30.0",
  "serde",
- "sha3",
+ "sha3 0.10.8",
  "zeroize",
 ]
 
@@ -4230,7 +4259,7 @@ dependencies = [
  "log",
  "rustversion",
  "windows-link 0.1.3",
- "windows-result 0.3.4",
+ "windows-result 0.4.1",
 ]
 
 [[package]]
@@ -4459,8 +4488,6 @@ dependencies = [
  "allocator-api2",
  "equivalent",
  "foldhash 0.2.0",
- "serde",
- "serde_core",
 ]
 
 [[package]]
@@ -4468,6 +4495,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"
@@ -4692,6 +4724,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"
@@ -4779,7 +4820,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.61.2",
+ "windows-core 0.62.2",
 ]
 
 [[package]]
@@ -5525,6 +5566,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"
@@ -5815,9 +5866,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",
@@ -6158,7 +6209,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.60.2",
 ]
 
 [[package]]
@@ -6957,6 +7008,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"
@@ -11110,7 +11172,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs 0.26.11",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -11534,7 +11596,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]]
@@ -11853,9 +11925,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",
@@ -12737,9 +12809,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"
@@ -12824,7 +12896,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",
 ]
 
@@ -13681,9 +13753,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 07d12c23ee4..f90bc78b8f1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -444,9 +444,9 @@ revm-database-interface = { version = "11.0.0", default-features = false }
 revm-inspectors = "0.39.0"
 
 # 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 }

From e9507f5907f5bab192a97d5adda7cfd8f041333a Mon Sep 17 00:00:00 2001
From: AKABABA-ETH <111528650+AKABABA-ETH@users.noreply.github.com>
Date: Mon, 18 May 2026 15:43:41 +0800
Subject: [PATCH 143/335] fix(rpc): reject trace_filter ranges in pruned
 history (#23600)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/rpc/rpc/src/trace.rs | 7 +++++++
 1 file changed, 7 insertions(+)

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

From 1e6f3576b053295ba8a21fde62a06dd805469adf Mon Sep 17 00:00:00 2001
From: Veronica Hayes <veronicahayesvero@gmail.com>
Date: Mon, 18 May 2026 09:51:51 +0200
Subject: [PATCH 144/335] fix(rpc): return cached raw block access lists
 (#24281)

---
 crates/rpc/rpc-eth-api/src/core.rs        |  4 +---
 crates/rpc/rpc-eth-api/src/helpers/bal.rs | 24 ++++++++++++++++++++++-
 2 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/crates/rpc/rpc-eth-api/src/core.rs b/crates/rpc/rpc-eth-api/src/core.rs
index 3467a9bea7e..bfc1418dab3 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};
@@ -974,7 +973,6 @@ where
     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 aafc034749d..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};
@@ -70,4 +71,25 @@ pub trait GetBlockAccessList: Trace + Call + LoadBlock + RpcNodeCoreExt {
             .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()))
+        }
+    }
 }

From 062dd7122636a17697fe7df3e336561d75b7f4aa Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 18 May 2026 11:34:29 +0200
Subject: [PATCH 145/335] chore: bump alloy to 2.0.5 (#24289)

---
 Cargo.lock          | 330 ++++++++++++++++++++++----------------------
 Cargo.toml          |  54 ++++----
 bin/reth/Cargo.toml |   2 +-
 3 files changed, 193 insertions(+), 193 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4ab9179a3f6..371bea30735 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -121,14 +121,14 @@ dependencies = [
 
 [[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 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "alloy-trie",
  "alloy-tx-macros",
  "arbitrary",
@@ -149,24 +149,24 @@ 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",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "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",
  "alloy-dyn-abi",
@@ -288,9 +288,9 @@ dependencies = [
 
 [[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",
@@ -298,7 +298,7 @@ dependencies = [
  "alloy-eip7928",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "arbitrary",
  "auto_impl",
  "borsh",
@@ -319,7 +319,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c1ceeea6dcbbcd4e546b27700763a6f6c3b3fee30054209884f521078b6fda4f"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-hardforks 0.4.7",
  "alloy-primitives",
  "alloy-rpc-types-engine",
@@ -334,13 +334,13 @@ dependencies = [
 
 [[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 2.0.5",
  "alloy-primitives",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "alloy-trie",
  "borsh",
  "serde",
@@ -388,9 +388,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",
@@ -403,19 +403,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",
  "alloy-consensus-any",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-json-rpc",
  "alloy-network-primitives",
  "alloy-primitives",
  "alloy-rpc-types-any",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "alloy-signer",
  "alloy-sol-types",
  "async-trait",
@@ -429,22 +429,22 @@ 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",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "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",
  "alloy-hardforks 0.2.13",
@@ -496,13 +496,13 @@ dependencies = [
 
 [[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",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-json-rpc",
  "alloy-network",
  "alloy-network-primitives",
@@ -541,9 +541,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",
@@ -585,9 +585,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",
@@ -611,22 +611,22 @@ 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 2.0.5",
  "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",
  "alloy-primitives",
@@ -636,38 +636,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 2.0.5",
  "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 2.0.5",
  "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 2.0.5",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "derive_more",
@@ -683,9 +683,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",
@@ -696,15 +696,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",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "arbitrary",
  "derive_more",
  "ethereum_ssz",
@@ -717,17 +717,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",
  "alloy-consensus-any",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-network-primitives",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "alloy-sol-types",
  "arbitrary",
  "itertools 0.14.0",
@@ -739,28 +739,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",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "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 2.0.5",
  "serde",
  "serde_json",
  "thiserror 2.0.18",
@@ -768,13 +768,13 @@ 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 2.0.5",
  "serde",
 ]
 
@@ -791,9 +791,9 @@ dependencies = [
 
 [[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",
@@ -803,9 +803,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",
@@ -818,9 +818,9 @@ 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",
  "alloy-network",
@@ -907,9 +907,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",
@@ -930,9 +930,9 @@ 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",
@@ -946,9 +946,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",
@@ -966,9 +966,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",
@@ -1005,9 +1005,9 @@ dependencies = [
 
 [[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",
@@ -1066,7 +1066,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]]
@@ -1077,7 +1077,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -2464,7 +2464,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
 dependencies = [
  "lazy_static",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -2874,7 +2874,7 @@ name = "custom-hardforks"
 version = "0.1.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-genesis",
  "alloy-primitives",
  "reth-chainspec",
@@ -3330,7 +3330,7 @@ name = "ef-tests"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
@@ -3477,7 +3477,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3536,7 +3536,7 @@ name = "example-beacon-api-sidecar-fetcher"
 version = "0.1.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rpc-types-beacon",
  "clap",
@@ -3615,7 +3615,7 @@ dependencies = [
 name = "example-custom-beacon-withdrawals"
 version = "0.0.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-evm",
  "alloy-sol-types",
  "eyre",
@@ -3670,7 +3670,7 @@ dependencies = [
 name = "example-custom-inspector"
 version = "0.0.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-evm",
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -3692,7 +3692,7 @@ dependencies = [
 name = "example-custom-payload-builder"
 version = "0.0.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "eyre",
  "futures-util",
  "reth-basic-payload-builder",
@@ -4258,7 +4258,7 @@ dependencies = [
  "libc",
  "log",
  "rustversion",
- "windows-link 0.1.3",
+ "windows-link 0.2.1",
  "windows-result 0.4.1",
 ]
 
@@ -5187,7 +5187,7 @@ checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
 dependencies = [
  "hermit-abi",
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -6209,7 +6209,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -7591,7 +7591,7 @@ name = "reth-basic-payload-builder"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "futures-core",
  "futures-util",
@@ -7617,7 +7617,7 @@ name = "reth-bb"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-evm",
  "alloy-hardforks 0.4.7",
  "alloy-primitives",
@@ -7666,7 +7666,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eip7928",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-json-rpc",
  "alloy-primitives",
  "alloy-provider",
@@ -7713,7 +7713,7 @@ name = "reth-chain-state"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-signer",
  "alloy-signer-local",
@@ -7746,7 +7746,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-evm",
  "alloy-genesis",
  "alloy-primitives",
@@ -7778,7 +7778,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
  "arbitrary",
@@ -7874,7 +7874,7 @@ dependencies = [
 name = "reth-cli-util"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "cfg-if",
  "eyre",
@@ -7899,7 +7899,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fce542a96bf888f31854803e80b3340bc233927743aa580838014e8a88fe0d66"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-trie",
@@ -7960,7 +7960,7 @@ name = "reth-consensus-common"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "rand 0.9.4",
  "reth-chainspec",
@@ -7974,7 +7974,7 @@ name = "reth-consensus-debug-client"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-json-rpc",
  "alloy-primitives",
  "alloy-provider",
@@ -8092,7 +8092,7 @@ dependencies = [
 name = "reth-db-models"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "arbitrary",
  "bytes",
@@ -8188,7 +8188,7 @@ name = "reth-downloaders"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
  "assert_matches",
@@ -8226,7 +8226,7 @@ name = "reth-e2e-test-utils"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-network",
  "alloy-primitives",
  "alloy-provider",
@@ -8331,7 +8331,7 @@ name = "reth-engine-primitives"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "auto_impl",
@@ -8356,7 +8356,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eip7928",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-evm",
  "alloy-primitives",
  "alloy-rlp",
@@ -8457,7 +8457,7 @@ name = "reth-era"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
  "ethereum_ssz",
@@ -8535,7 +8535,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
  "arbitrary",
@@ -8574,7 +8574,7 @@ dependencies = [
  "alloy-chains",
  "alloy-consensus",
  "alloy-eip7928",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-genesis",
  "alloy-hardforks 0.4.7",
  "alloy-primitives",
@@ -8661,7 +8661,7 @@ name = "reth-ethereum-consensus"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "reth-chainspec",
  "reth-consensus",
@@ -8676,7 +8676,7 @@ dependencies = [
 name = "reth-ethereum-engine-primitives"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "reth-engine-primitives",
@@ -8706,7 +8706,7 @@ name = "reth-ethereum-payload-builder"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-engine",
@@ -8735,7 +8735,7 @@ name = "reth-ethereum-primitives"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-eth",
@@ -8766,7 +8766,7 @@ name = "reth-evm"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-evm",
  "alloy-primitives",
  "auto_impl",
@@ -8790,7 +8790,7 @@ name = "reth-evm-ethereum"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-evm",
  "alloy-genesis",
  "alloy-primitives",
@@ -8842,7 +8842,7 @@ name = "reth-execution-types"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-evm",
  "alloy-primitives",
  "alloy-rlp",
@@ -8863,7 +8863,7 @@ name = "reth-exex"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-genesis",
  "alloy-primitives",
  "eyre",
@@ -8907,7 +8907,7 @@ dependencies = [
 name = "reth-exex-test-utils"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "eyre",
  "futures-util",
  "reth-chainspec",
@@ -8938,7 +8938,7 @@ dependencies = [
 name = "reth-exex-types"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "arbitrary",
  "bincode",
@@ -8965,7 +8965,7 @@ name = "reth-invalid-block-hooks"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-debug",
@@ -9079,7 +9079,7 @@ name = "reth-network"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
@@ -9165,7 +9165,7 @@ name = "reth-network-p2p"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "auto_impl",
  "derive_more",
@@ -9258,7 +9258,7 @@ name = "reth-node-builder"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-provider",
  "alloy-rpc-types",
@@ -9329,7 +9329,7 @@ name = "reth-node-core"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "clap",
@@ -9386,7 +9386,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-consensus",
  "alloy-contract",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-genesis",
  "alloy-network",
  "alloy-primitives",
@@ -9469,7 +9469,7 @@ name = "reth-node-events"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "derive_more",
@@ -9566,7 +9566,7 @@ name = "reth-payload-primitives"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-engine",
@@ -9610,7 +9610,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ee12e304adbacbb32248c9806ebafbe1e2811fbfefe53c5e5b710a8438b7ec0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
@@ -9642,7 +9642,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eip7928",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rpc-types-engine",
@@ -9695,7 +9695,7 @@ name = "reth-prune"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "assert_matches",
  "itertools 0.14.0",
@@ -9769,7 +9769,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-consensus",
  "alloy-dyn-abi",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-evm",
  "alloy-genesis",
  "alloy-network",
@@ -9785,7 +9785,7 @@ dependencies = [
  "alloy-rpc-types-mev",
  "alloy-rpc-types-trace",
  "alloy-rpc-types-txpool",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "alloy-signer",
  "alloy-signer-local",
  "async-trait",
@@ -9847,7 +9847,7 @@ dependencies = [
 name = "reth-rpc-api"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-genesis",
  "alloy-json-rpc",
  "alloy-primitives",
@@ -9861,7 +9861,7 @@ dependencies = [
  "alloy-rpc-types-mev",
  "alloy-rpc-types-trace",
  "alloy-rpc-types-txpool",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "jsonrpsee",
  "reth-chain-state",
  "reth-engine-primitives",
@@ -9877,7 +9877,7 @@ dependencies = [
 name = "reth-rpc-api-testing-util"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rpc-types-eth",
  "alloy-rpc-types-trace",
@@ -9896,7 +9896,7 @@ dependencies = [
 name = "reth-rpc-builder"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-network",
  "alloy-primitives",
  "alloy-provider",
@@ -9994,7 +9994,7 @@ dependencies = [
 name = "reth-rpc-engine-api"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-engine",
@@ -10033,7 +10033,7 @@ dependencies = [
  "alloy-consensus",
  "alloy-dyn-abi",
  "alloy-eip7928",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-evm",
  "alloy-json-rpc",
  "alloy-network",
@@ -10041,7 +10041,7 @@ dependencies = [
  "alloy-rlp",
  "alloy-rpc-types-eth",
  "alloy-rpc-types-mev",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "async-trait",
  "auto_impl",
  "dyn-clone",
@@ -10076,7 +10076,7 @@ name = "reth-rpc-eth-types"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-evm",
  "alloy-network",
  "alloy-primitives",
@@ -10141,7 +10141,7 @@ dependencies = [
 name = "reth-rpc-server-types"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "jsonrpsee-core",
@@ -10172,7 +10172,7 @@ name = "reth-stages"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
@@ -10233,7 +10233,7 @@ dependencies = [
 name = "reth-stages-api"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "aquamarine",
  "assert_matches",
@@ -10325,7 +10325,7 @@ name = "reth-storage-api"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "auto_impl",
@@ -10350,7 +10350,7 @@ dependencies = [
 name = "reth-storage-errors"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
  "derive_more",
@@ -10368,7 +10368,7 @@ name = "reth-storage-rpc-provider"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-network",
  "alloy-primitives",
  "alloy-provider",
@@ -10417,7 +10417,7 @@ name = "reth-testing-utils"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
@@ -10477,7 +10477,7 @@ name = "reth-transaction-pool"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
  "aquamarine",
@@ -10528,7 +10528,7 @@ name = "reth-trie"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.4",
+ "alloy-eips 2.0.5",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-trie",
@@ -10565,7 +10565,7 @@ dependencies = [
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.4",
+ "alloy-serde 2.0.5",
  "alloy-trie",
  "arbitrary",
  "arrayvec",
@@ -11113,7 +11113,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -11172,7 +11172,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs 0.26.11",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -11193,7 +11193,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs 1.0.7",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -11808,7 +11808,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]]
@@ -12029,7 +12029,7 @@ dependencies = [
  "getrandom 0.4.2",
  "once_cell",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -13298,7 +13298,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index f90bc78b8f1..a555859bdb9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -457,33 +457,33 @@ 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 }
diff --git a/bin/reth/Cargo.toml b/bin/reth/Cargo.toml
index c4e9d7dcb2a..c9b01c23ceb 100644
--- a/bin/reth/Cargo.toml
+++ b/bin/reth/Cargo.toml
@@ -70,7 +70,7 @@ aquamarine.workspace = true
 clap = { workspace = true, features = ["derive", "env"] }
 
 [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

From 781f82e6268565555ff97d3fc741da3413e50d0c Mon Sep 17 00:00:00 2001
From: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
Date: Mon, 18 May 2026 15:49:32 +0530
Subject: [PATCH 146/335] feat(rpc): add a ssz proxy layer for engine-api
 methods (#23936)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 Cargo.lock                                   |   6 +
 crates/ethereum/node/Cargo.toml              |  11 +-
 crates/ethereum/node/src/engine_ssz_proxy.rs | 329 +++++++++++++++++++
 crates/ethereum/node/src/lib.rs              |   2 +
 crates/ethereum/node/tests/e2e/eth.rs        | 117 ++++++-
 crates/rpc/rpc-builder/src/auth.rs           |   5 +
 6 files changed, 466 insertions(+), 4 deletions(-)
 create mode 100644 crates/ethereum/node/src/engine_ssz_proxy.rs

diff --git a/Cargo.lock b/Cargo.lock
index 371bea30735..956f8e1fc38 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9398,10 +9398,14 @@ dependencies = [
  "alloy-signer",
  "alloy-sol-types",
  "enr",
+ "ethereum_ssz",
  "eyre",
  "futures",
+ "http-body-util",
+ "jsonrpsee",
  "jsonrpsee-core",
  "rand 0.9.4",
+ "reqwest 0.13.2",
  "reth-chainspec",
  "reth-db",
  "reth-e2e-test-utils",
@@ -9427,6 +9431,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",
@@ -9439,6 +9444,7 @@ dependencies = [
  "similar-asserts",
  "tempfile",
  "tokio",
+ "tower",
 ]
 
 [[package]]
diff --git a/crates/ethereum/node/Cargo.toml b/crates/ethereum/node/Cargo.toml
index 6ec5804e844..c86f08976bc 100644
--- a/crates/ethereum/node/Cargo.toml
+++ b/crates/ethereum/node/Cargo.toml
@@ -39,12 +39,14 @@ reth-engine-primitives = { workspace = true, features = ["std"] }
 reth-payload-primitives.workspace = true
 # ethereum
 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 +54,9 @@ revm = { workspace = true, features = ["secp256k1", "blst", "c-kzg", "memory_lim
 
 # misc
 eyre.workspace = true
+ethereum_ssz.workspace = true
+http-body-util.workspace = true
+tower.workspace = true
 
 [dev-dependencies]
 reth-db.workspace = true
@@ -81,6 +86,8 @@ 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..eccc5b18986
--- /dev/null
+++ b/crates/ethereum/node/src/engine_ssz_proxy.rs
@@ -0,0 +1,329 @@
+//! HTTP SSZ transport proxy for the authenticated Engine API server.
+//!
+//! Implements the [EIP-8178] SSZ Engine API routes under `/engine`.
+//!
+//! [EIP-8178]: https://eips.ethereum.org/EIPS/eip-8178
+
+use alloy_eips::eip7685::{Requests, RequestsOrHash};
+use alloy_primitives::{Bytes, B256};
+use alloy_rpc_types_engine::{
+    CancunPayloadFields, ExecutionData, ExecutionPayload, ExecutionPayloadSidecar,
+    ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3, ExecutionPayloadV4,
+    ForkchoiceState, PayloadAttributes, PraguePayloadFields,
+};
+use http_body_util::BodyExt;
+use jsonrpsee::server::{HttpBody, HttpRequest, HttpResponse};
+use reth_engine_primitives::ConsensusEngineHandle;
+use reth_ethereum_engine_primitives::EthEngineTypes;
+use std::{
+    future::Future,
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
+use tokio::sync::RwLock;
+use tower::{BoxError, Layer, Service};
+
+const OCTET_STREAM: &str = "application/octet-stream";
+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_INTERNAL_SERVER_ERROR: u16 = 500;
+const STATUS_SERVICE_UNAVAILABLE: u16 = 503;
+
+/// Shared handle used by [`EngineSszProxyLayer`].
+#[derive(Clone, Debug, Default)]
+pub struct EngineSszProxyHandle {
+    engine: Arc<RwLock<Option<ConsensusEngineHandle<EthEngineTypes>>>>,
+}
+
+impl EngineSszProxyHandle {
+    /// 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()
+    }
+}
+
+/// A tower layer that intercepts SSZ Engine API routes under `/engine`.
+#[derive(Clone, Debug, Default)]
+pub struct EngineSszProxyLayer {
+    handle: EngineSszProxyHandle,
+}
+
+impl EngineSszProxyLayer {
+    /// Creates a new proxy layer and a handle for setting the engine after node launch.
+    pub fn new() -> (Self, EngineSszProxyHandle) {
+        let handle = EngineSszProxyHandle::default();
+        (Self { handle: handle.clone() }, handle)
+    }
+}
+
+impl<S> Layer<S> for EngineSszProxyLayer {
+    type Service = EngineSszProxyService<S>;
+
+    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> {
+    inner: S,
+    handle: EngineSszProxyHandle,
+}
+
+impl<S> Service<HttpRequest> for EngineSszProxyService<S>
+where
+    S: Service<HttpRequest, Response = HttpResponse, Error = BoxError> + Send + Clone,
+    S::Future: Send + '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(
+    handle: EngineSszProxyHandle,
+    request: HttpRequest,
+) -> HttpResponse {
+    if request.method().as_str() != "POST" {
+        return text_response(STATUS_METHOD_NOT_ALLOWED, "method not allowed")
+    }
+
+    let path = request.uri().path().to_owned();
+    let Some((version, resource)) = parse_engine_path(&path) else {
+        return text_response(STATUS_NOT_FOUND, "unknown engine ssz endpoint")
+    };
+
+    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")
+    };
+
+    match resource {
+        "payloads" => handle_new_payload(engine, version, &body).await,
+        "forkchoice" => handle_forkchoice_updated(engine, version, &body).await,
+        _ => text_response(STATUS_NOT_FOUND, "unknown engine ssz endpoint"),
+    }
+}
+
+fn parse_engine_path(path: &str) -> Option<(u8, &str)> {
+    let mut segments = path.trim_start_matches('/').split('/');
+    match (segments.next(), segments.next(), segments.next(), segments.next()) {
+        (Some("engine"), Some(version), Some(resource), None) => {
+            let version = version.strip_prefix('v')?.parse().ok()?;
+            Some((version, resource))
+        }
+        _ => None,
+    }
+}
+
+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()),
+    }
+}
+
+fn decode_new_payload_request(version: u8, body: &[u8]) -> Result<ExecutionData, &'static str> {
+    use ssz::Decode;
+
+    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, expected_blob_versioned_hashes, parent_beacon_block_root) =
+                <(ExecutionPayloadV3, Vec<B256>, B256)>::from_ssz_bytes(body)
+                    .map_err(|_| "invalid ssz")?;
+            let sidecar = ExecutionPayloadSidecar::v3(CancunPayloadFields {
+                parent_beacon_block_root,
+                versioned_hashes: expected_blob_versioned_hashes,
+            });
+            Ok(ExecutionData::new(execution_payload.into(), sidecar))
+        }
+        4 => {
+            let (
+                execution_payload,
+                expected_blob_versioned_hashes,
+                parent_beacon_block_root,
+                execution_requests,
+            ) = <(ExecutionPayloadV3, Vec<B256>, B256, Vec<Bytes>)>::from_ssz_bytes(body)
+                .map_err(|_| "invalid ssz")?;
+            let sidecar = ExecutionPayloadSidecar::v4(
+                CancunPayloadFields {
+                    parent_beacon_block_root,
+                    versioned_hashes: expected_blob_versioned_hashes,
+                },
+                PraguePayloadFields::new(RequestsOrHash::Requests(Requests::new(
+                    execution_requests,
+                ))),
+            );
+            Ok(ExecutionData::new(execution_payload.into(), sidecar))
+        }
+        5 => {
+            let (
+                execution_payload,
+                expected_blob_versioned_hashes,
+                parent_beacon_block_root,
+                execution_requests,
+            ) = <(ExecutionPayloadV4, Vec<B256>, B256, Vec<Bytes>)>::from_ssz_bytes(body)
+                .map_err(|_| "invalid ssz")?;
+            let sidecar = ExecutionPayloadSidecar::v4(
+                CancunPayloadFields {
+                    parent_beacon_block_root,
+                    versioned_hashes: expected_blob_versioned_hashes,
+                },
+                PraguePayloadFields::new(RequestsOrHash::Requests(Requests::new(
+                    execution_requests,
+                ))),
+            );
+            Ok(ExecutionData::new(ExecutionPayload::V4(execution_payload), sidecar))
+        }
+        _ => Err("unsupported payload endpoint version"),
+    }
+}
+
+fn decode_forkchoice_request(
+    version: u8,
+    body: &[u8],
+) -> Result<(ForkchoiceState, Option<PayloadAttributes>), &'static str> {
+    use ssz::Decode;
+
+    match version {
+        1..=4 => {
+            let (forkchoice_state, payload_attributes) =
+                <(ForkchoiceState, Vec<PayloadAttributes>)>::from_ssz_bytes(body)
+                    .map_err(|_| "invalid ssz")?;
+            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 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 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")
+}
diff --git a/crates/ethereum/node/src/lib.rs b/crates/ethereum/node/src/lib.rs
index 8b27be1bc78..1b4f5252a45 100644
--- a/crates/ethereum/node/src/lib.rs
+++ b/crates/ethereum/node/src/lib.rs
@@ -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/tests/e2e/eth.rs b/crates/ethereum/node/tests/e2e/eth.rs
index 197b5f89c1b..7b1cbda974f 100644
--- a/crates/ethereum/node/tests/e2e/eth.rs
+++ b/crates/ethereum/node/tests/e2e/eth.rs
@@ -2,7 +2,9 @@ use crate::utils::{advance_with_random_transactions, eth_payload_attributes};
 use alloy_eips::eip7685::RequestsOrHash;
 use alloy_genesis::Genesis;
 use alloy_primitives::{Address, B256};
-use alloy_rpc_types_engine::{PayloadAttributes, PayloadStatusEnum};
+use alloy_rpc_types_engine::{
+    ForkchoiceState, ForkchoiceUpdated, PayloadAttributes, PayloadStatus, PayloadStatusEnum,
+};
 use jsonrpsee_core::client::ClientT;
 use reth_chainspec::{ChainSpecBuilder, EthChainSpec, MAINNET};
 use reth_e2e_test_utils::{
@@ -11,12 +13,17 @@ 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_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_NEW_PAYLOAD_V4_ROUTE: &str = "/engine/v4/payloads";
+const ENGINE_FORKCHOICE_UPDATED_V3_ROUTE: &str = "/engine/v3/forkchoice";
+
 #[tokio::test]
 async fn can_run_eth_node() -> eyre::Result<()> {
     reth_tracing::init_test_tracing();
@@ -256,6 +263,112 @@ 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();
+    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;
+    let node = NodeTestContext::new(node, eth_payload_attributes).await?;
+
+    let wallet = Wallet::default();
+    let raw_tx = TransactionTestContext::transfer_tx_bytes(1, wallet.inner).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 new_payload_response = client
+        .post(format!("{auth_url}{ENGINE_NEW_PAYLOAD_V4_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, Vec::<B256>::new(), 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_FORKCHOICE_UPDATED_V3_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 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/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 {

From 04d67cb148cd691571517e85e15ce683447266fd Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 18 May 2026 12:21:51 +0200
Subject: [PATCH 147/335] feat(rpc): add builder submission v6 validation
 (#24170)

---
 crates/ethereum/node/tests/e2e/rpc.rs   | 93 ++++++++++++++++++++++++-
 crates/ethereum/node/tests/e2e/utils.rs | 17 +++++
 crates/rpc/rpc-api/src/validation.rs    |  9 ++-
 crates/rpc/rpc/src/validation.rs        | 73 ++++++++++++++++++-
 4 files changed, 186 insertions(+), 6 deletions(-)

diff --git a/crates/ethereum/node/tests/e2e/rpc.rs b/crates/ethereum/node/tests/e2e/rpc.rs
index 2fc1b670d01..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;
@@ -296,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();
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/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/src/validation.rs b/crates/rpc/rpc/src/validation.rs
index 88e96deef07..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::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)?;
 
@@ -387,6 +388,7 @@ where
             block,
             request.request.message,
             request.registered_gas_limit,
+            None,
         )
         .await
     }
@@ -415,6 +417,7 @@ where
             block,
             request.request.message,
             request.registered_gas_limit,
+            None,
         )
         .await
     }
@@ -455,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
     }
@@ -540,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> {
@@ -630,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)]
@@ -654,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 |

From 29d9241f678d4724ec83e9b02f60cd0f876c2d28 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 18 May 2026 12:29:48 +0200
Subject: [PATCH 148/335] fix(rpc): remove stale debug endpoints (#24284)

---
 Cargo.lock                       |   1 -
 crates/node/core/src/args/log.rs |   2 +-
 crates/rpc/rpc-api/src/debug.rs  | 104 -------------------------------
 crates/rpc/rpc-api/src/lib.rs    |   4 +-
 crates/rpc/rpc/Cargo.toml        |   1 -
 crates/rpc/rpc/src/debug.rs      |  72 ---------------------
 crates/tracing/src/lib.rs        |   4 +-
 7 files changed, 5 insertions(+), 183 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 956f8e1fc38..2d74a1be578 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9833,7 +9833,6 @@ dependencies = [
  "reth-storage-api",
  "reth-tasks",
  "reth-testing-utils",
- "reth-tracing",
  "reth-transaction-pool",
  "reth-trie-common",
  "revm",
diff --git a/crates/node/core/src/args/log.rs b/crates/node/core/src/args/log.rs
index 40162d50cb0..c4e1bf90f65 100644
--- a/crates/node/core/src/args/log.rs
+++ b/crates/node/core/src/args/log.rs
@@ -165,7 +165,7 @@ impl LogArgs {
     /// 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
diff --git a/crates/rpc/rpc-api/src/debug.rs b/crates/rpc/rpc-api/src/debug.rs
index a9d8b32009a..f7832e1b4ad 100644
--- a/crates/rpc/rpc-api/src/debug.rs
+++ b/crates/rpc/rpc-api/src/debug.rs
@@ -162,12 +162,6 @@ 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<()>;
-
     /// 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 +178,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 +200,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 +223,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 +258,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 +271,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 +283,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 +292,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 +315,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 +324,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 +346,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/lib.rs b/crates/rpc/rpc-api/src/lib.rs
index 43dfc065e28..8d09da22e12 100644
--- a/crates/rpc/rpc-api/src/lib.rs
+++ b/crates/rpc/rpc-api/src/lib.rs
@@ -41,7 +41,7 @@ pub use servers::*;
 pub mod servers {
     pub use crate::{
         admin::AdminApiServer,
-        debug::{DebugApiServer, DebugExecutionWitnessApiServer},
+        debug::DebugApiServer,
         engine::{EngineApiServer, EngineEthApiServer, IntoEngineApiRpcModule},
         mev::{MevFullApiServer, MevSimApiServer},
         miner::MinerApiServer,
@@ -72,7 +72,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/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/debug.rs b/crates/rpc/rpc/src/debug.rs
index f38efa79c75..d0e5b243989 100644
--- a/crates/rpc/rpc/src/debug.rs
+++ b/crates/rpc/rpc/src/debug.rs
@@ -831,10 +831,6 @@ 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(())
-    }
-
     async fn debug_account_range(
         &self,
         _block_number: BlockNumberOrTag,
@@ -847,10 +843,6 @@ where
         Ok(())
     }
 
-    async fn debug_block_profile(&self, _file: String, _seconds: u64) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_chaindb_compact(&self) -> RpcResult<()> {
         Ok(())
     }
@@ -871,10 +863,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(())
     }
@@ -925,10 +913,6 @@ where
         Ok(())
     }
 
-    async fn debug_freeze_client(&self, _node: String) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_gc_stats(&self) -> RpcResult<()> {
         Ok(())
     }
@@ -957,10 +941,6 @@ where
         Ok(())
     }
 
-    async fn debug_go_trace(&self, _file: String, _seconds: u64) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_intermediate_roots(
         &self,
         block_hash: B256,
@@ -974,10 +954,6 @@ where
         Ok(())
     }
 
-    async fn debug_mutex_profile(&self, _file: String, _nsec: u64) -> RpcResult<()> {
-        Ok(())
-    }
-
     async fn debug_preimage(&self, _hash: B256) -> RpcResult<()> {
         Ok(())
     }
@@ -990,10 +966,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(())
     }
@@ -1002,18 +974,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,
@@ -1030,14 +994,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,
@@ -1046,14 +1002,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,
@@ -1087,26 +1035,6 @@ where
         let opts = opts.map(|o| o.tracing_options).unwrap_or_default();
         self.trace_block(entry.block.clone(), 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(())
-    }
 }
 
 impl<Eth: RpcNodeCore> std::fmt::Debug for DebugApi<Eth> {
diff --git a/crates/tracing/src/lib.rs b/crates/tracing/src/lib.rs
index 22bc829616b..233ffbdb87a 100644
--- a/crates/tracing/src/lib.rs
+++ b/crates/tracing/src/lib.rs
@@ -87,7 +87,7 @@ pub struct RethTracer {
     #[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,
 }
 
@@ -149,7 +149,7 @@ 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

From 79dc30cb340405b3531d3143320e66aaba3d9107 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 18 May 2026 12:44:01 +0200
Subject: [PATCH 149/335] refactor(tx-pool): simplify blob cell lookup (#24290)

---
 crates/transaction-pool/src/blobstore/disk.rs | 51 +++++++++++--------
 crates/transaction-pool/src/blobstore/mem.rs  | 49 ++++++++++--------
 2 files changed, 56 insertions(+), 44 deletions(-)

diff --git a/crates/transaction-pool/src/blobstore/disk.rs b/crates/transaction-pool/src/blobstore/disk.rs
index d061f5de98d..ec7b2cd4528 100644
--- a/crates/transaction-pool/src/blobstore/disk.rs
+++ b/crates/transaction-pool/src/blobstore/disk.rs
@@ -392,28 +392,10 @@ impl BlobStore for DiskFileBlobStore {
             return Ok(None);
         };
 
-        let versioned_hashes = sidecar.versioned_hashes().collect::<Vec<_>>();
-
-        let matches =
-            self.get_by_versioned_hashes_cells_eip7594(&versioned_hashes, indices_bitarray)?;
-
-        let mut cells = Vec::new();
-
-        for matched in matches {
-            let Some(matched) = matched else {
-                return Ok(None);
-            };
-
-            for cell in matched.blob_cells {
-                let Some(cell) = cell else {
-                    return Ok(None);
-                };
-
-                cells.push(cell);
-            }
-        }
-
-        Ok(Some(cells))
+        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> {
@@ -1085,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 35642e363c5..dfaaec160fd 100644
--- a/crates/transaction-pool/src/blobstore/mem.rs
+++ b/crates/transaction-pool/src/blobstore/mem.rs
@@ -238,28 +238,10 @@ impl BlobStore for InMemoryBlobStore {
             return Ok(None);
         };
 
-        let versioned_hashes = sidecar.versioned_hashes().collect::<Vec<_>>();
-
-        let matches =
-            self.get_by_versioned_hashes_cells_eip7594(&versioned_hashes, indices_bitarray)?;
-
-        let mut cells = Vec::new();
-
-        for matched in matches {
-            let Some(matched) = matched else {
-                return Ok(None);
-            };
-
-            for cell in matched.blob_cells {
-                let Some(cell) = cell else {
-                    return Ok(None);
-                };
-
-                cells.push(cell);
-            }
-        }
-
-        Ok(Some(cells))
+        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> {
@@ -352,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));
+    }
 }

From b95b5441d00d642cebec4c4eace9450178fec78b Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 18 May 2026 15:09:10 +0400
Subject: [PATCH 150/335] perf: join account and storage reveals (#24265)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 Cargo.lock                      |   1 +
 crates/trie/sparse/Cargo.toml   |   2 +
 crates/trie/sparse/src/state.rs | 238 ++++++++++----------------------
 crates/trie/sparse/src/trie.rs  |  43 +++++-
 4 files changed, 117 insertions(+), 167 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2d74a1be578..92de64299a6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10667,6 +10667,7 @@ dependencies = [
  "alloy-trie",
  "arbitrary",
  "assert_matches",
+ "either",
  "itertools 0.14.0",
  "metrics",
  "pretty_assertions",
diff --git a/crates/trie/sparse/Cargo.toml b/crates/trie/sparse/Cargo.toml
index 035947987ca..18393802e88 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,7 @@ std = [
     "tracing/std",
     "serde?/std",
     "serde_json?/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/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> {

From 3116adf26c03450741a7973c23638964ab43913f Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 18 May 2026 13:40:19 +0200
Subject: [PATCH 151/335] fix(cli): reject zero db list len (#24283)

---
 crates/cli/commands/src/db/list.rs | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

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

From 97064bdc75a8b9bdc34680f533fc21d078c5a000 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Mon, 18 May 2026 06:47:44 -0700
Subject: [PATCH 152/335] ci(bench): allow BAL replay without big blocks
 (#24270)

Co-authored-by: Centaur AI <ai@centaur.local>
---
 .github/workflows/bench.yml | 19 +++----------------
 1 file changed, 3 insertions(+), 16 deletions(-)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 955b6389e00..61009ec24ee 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -360,19 +360,6 @@ jobs:
               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;
-            }
 
             // Resolve display names for baseline/feature
             let baselineName = baseline || 'main';
@@ -474,7 +461,7 @@ jobs:
             const bal = '${{ steps.args.outputs.bal }}' || 'false';
             const samplyNote = samply ? ', samply: `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';
@@ -518,7 +505,7 @@ jobs:
             const bal = '${{ steps.args.outputs.bal }}' || 'false';
             const samplyNote = samply ? ', samply: `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';
@@ -672,7 +659,7 @@ jobs:
             const bal = process.env.BENCH_BAL || 'false';
             const samplyNote = samply ? ', samply: `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';

From 4aa378175cc77308a4aa6e204df7075857b80e12 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 18 May 2026 16:01:41 +0200
Subject: [PATCH 153/335] feat(rpc): add eth_pendingTransactions (#24286)

---
 crates/rpc/rpc-eth-api/src/core.rs                | 10 ++++++++++
 crates/rpc/rpc-eth-api/src/helpers/transaction.rs | 10 ++++++++++
 2 files changed, 20 insertions(+)

diff --git a/crates/rpc/rpc-eth-api/src/core.rs b/crates/rpc/rpc-eth-api/src/core.rs
index bfc1418dab3..337ae2db01c 100644
--- a/crates/rpc/rpc-eth-api/src/core.rs
+++ b/crates/rpc/rpc-eth-api/src/core.rs
@@ -186,6 +186,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>>;
@@ -648,6 +652,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,
diff --git a/crates/rpc/rpc-eth-api/src/helpers/transaction.rs b/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
index d451cfece29..1905a33701a 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
@@ -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.

From 75c327ee5633e12d430ef04ae595d03e545d6472 Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Mon, 18 May 2026 16:18:44 +0200
Subject: [PATCH 154/335] perf(trie): skip db seek on exact overlay hits
 (#24294)

Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
---
 .../trie/trie/src/hashed_cursor/post_state.rs | 228 ++++++++++++++----
 crates/trie/trie/src/trie_cursor/in_memory.rs | 114 ++++++++-
 2 files changed, 297 insertions(+), 45 deletions(-)

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

From 8c3126691476ee9daee01962ecaddf6e29d56780 Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Mon, 18 May 2026 16:21:58 +0200
Subject: [PATCH 155/335] feat(bench): add configurable run-pair evaluation
 (#24238)

Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
---
 .github/scripts/bench-job-summary.js  |   2 +-
 .github/scripts/bench-reth-summary.py | 441 +++++++++++---------------
 .github/scripts/bench-slack-notify.js |  22 +-
 .github/scripts/bench-utils.js        |  23 +-
 .github/workflows/bench-scheduled.yml |   6 +-
 .github/workflows/bench.yml           | 282 ++++++++--------
 6 files changed, 380 insertions(+), 396 deletions(-)

diff --git a/.github/scripts/bench-job-summary.js b/.github/scripts/bench-job-summary.js
index 096ef596afd..8f621c155b6 100644
--- a/.github/scripts/bench-job-summary.js
+++ b/.github/scripts/bench-job-summary.js
@@ -7,7 +7,7 @@
 //   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_RUN_PAIRS      – Number of configured benchmark run pairs
 //
 // Usage from actions/github-script:
 //   const jobSummary = require('./.github/scripts/bench-job-summary.js');
diff --git a/.github/scripts/bench-reth-summary.py b/.github/scripts/bench-reth-summary.py
index 7d660872e1a..1f6e935e7aa 100755
--- a/.github/scripts/bench-reth-summary.py
+++ b/.github/scripts/bench-reth-summary.py
@@ -2,20 +2,23 @@
 """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
 import json
@@ -23,11 +26,16 @@
 import random
 import sys
 
-GIGAGAS = 1_000_000_000
 BOOTSTRAP_ITERATIONS = 10_000
-# t-critical for between-pairing CI (df=3, 4 cross-pairings).
-# Set conservatively to reduce false positives from run-level bias.
-T_BETWEEN_PAIRINGS = 4.5
+PRACTICAL_FLOOR_PCT = {
+    "mean": 0.70,
+    "p50": 0.70,
+    "p90": 1.35,
+    "p99": 5.0,
+    "mgas_s": 0.45,
+    "wall_clock": 0.70,
+    "persist_wait": 5.0,
+}
 
 
 def _opt_int(row: dict, key: str) -> int | None:
@@ -48,10 +56,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"),
@@ -61,22 +66,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
@@ -233,199 +222,129 @@ def _bootstrap_percentile_ci(
     return (boot_diffs[hi] - boot_diffs[lo]) / 2
 
 
-def _between_pairing_ci(pairing_means: list[float]) -> float:
-    """Compute CI half-width from the variance between pairing means.
-
-    This captures run-level bias (thermal drift, background load) that
-    per-block pooling cannot detect. Uses T_BETWEEN_PAIRINGS as the
-    t-critical value (conservative for df=3).
-    """
-    n = len(pairing_means)
-    if n < 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
-    mean = sum(pairing_means) / n
-    sd = math.sqrt(sum((x - mean) ** 2 for x in pairing_means) / (n - 1))
-    se = sd / math.sqrt(n)
-    return T_BETWEEN_PAIRINGS * se
-
-
-def _cross_pair_directions(
+    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[str, bool]:
-    """Check if the direction of change agrees across all cross-pairings.
-
-    With ABBA runs [B1, B2] and [F1, F2], generates all 4 pairings:
-    (B1,F1), (B2,F2), (B1,F2), (B2,F1). For each metric, returns True
-    only if the mean diff has the same sign across all pairings.
+    n_iter: int = BOOTSTRAP_ITERATIONS,
+) -> dict[str, float]:
+    """Compute run-cluster bootstrap CIs.
 
-    With a single run pair, always returns True (no cross-check possible).
+    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.
     """
+    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 {
-            "lat": True, "mgas": True, "total_lat": True, "persist": True,
-        }
+        return empty
 
-    cross_pairs = []
-    for b in baseline_runs:
-        for f in feature_runs:
-            cross_pairs.append(_paired_data(b, f))
+    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)
 
-    def _signs_agree(diffs_per_pair: list[list[float]]) -> bool:
-        means = []
-        for diffs in diffs_per_pair:
-            if diffs:
-                means.append(sum(diffs) / len(diffs))
-        if len(means) < 2:
-            return True
-        return all(m > 0 for m in means) or all(m < 0 for m in means) or all(m == 0 for m in means)
+    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))
 
-    return {
-        "lat": _signs_agree([cp[1] for cp in cross_pairs]),
-        "mgas": _signs_agree([cp[2] for cp in cross_pairs]),
-        "total_lat": _signs_agree([cp[3] for cp in cross_pairs]),
-        "persist": _signs_agree([cp[4] for cp in cross_pairs]),
-    }
+    return {metric: _ci_half_width(samples[metric]) for metric in metrics}
 
 
-def compute_paired_stats(
+def compute_ci_stats(
     baseline_runs: list[list[dict]],
     feature_runs: list[list[dict]],
 ) -> dict:
-    """Compute paired statistics between baseline and feature runs.
-
-    Uses all cross-pairings (B1-F1, B2-F2, B1-F2, B2-F1) for pooled
-    diffs and CIs. The final CI for each metric is the max of:
-    - Within-block bootstrap CI (captures per-block variance)
-    - Between-pairing CI (captures run-level bias)
+    """Compute confidence interval half-widths for displayed changes.
 
-    Also checks that the direction of change agrees across all pairings.
+    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.
     """
-    # Generate all cross-pairings for pooled stats
-    all_pairs = []
-    all_lat_diffs = []
-    all_mgas_diffs = []
-    all_total_lat_diffs = []
-    all_persist_diffs = []
-    blocks_per_pair = []
-    # Per-pairing means for between-pairing CI
-    per_pairing_lat_means = []
-    per_pairing_mgas_means = []
-    per_pairing_total_lat_means = []
-    per_pairing_persist_means = []
-    for baseline in baseline_runs:
-        for feature in 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 lat_diffs:
-                per_pairing_lat_means.append(sum(lat_diffs) / len(lat_diffs))
-            if mgas_diffs:
-                per_pairing_mgas_means.append(sum(mgas_diffs) / len(mgas_diffs))
-            if total_lat_diffs:
-                per_pairing_total_lat_means.append(sum(total_lat_diffs) / len(total_lat_diffs))
-            if persist_diffs:
-                per_pairing_persist_means.append(sum(persist_diffs) / len(persist_diffs))
-
-    if not all_lat_diffs:
+    if not baseline_runs or not feature_runs:
         return {}
 
-    n = len(all_lat_diffs)
-    mean_diff = sum(all_lat_diffs) / n
-
+    blocks = max(len(run) for run in baseline_runs + feature_runs)
     rng = random.Random(42)
 
-    # Within-block bootstrap CI
-    ci_within = _bootstrap_ci(rng, all_lat_diffs)
-    mgas_ci_within = _bootstrap_ci(rng, all_mgas_diffs) if all_mgas_diffs else 0.0
-    wall_ci_within = _bootstrap_ci(rng, all_total_lat_diffs) if all_total_lat_diffs else 0.0
-    persist_ci_within = _bootstrap_ci(rng, all_persist_diffs) if all_persist_diffs else 0.0
-
-    # Between-pairing CI (run-level variance floor)
-    ci_between = _between_pairing_ci(per_pairing_lat_means)
-    mgas_ci_between = _between_pairing_ci(per_pairing_mgas_means)
-    wall_ci_between = _between_pairing_ci(per_pairing_total_lat_means)
-    persist_ci_between = _between_pairing_ci(per_pairing_persist_means)
-
-    # Final CI = max(within, between)
-    ci = max(ci_within, ci_between)
-    mgas_ci = max(mgas_ci_within, mgas_ci_between)
-    wall_clock_ci_ms = max(wall_ci_within, wall_ci_between)
-    persist_ci_ms = max(persist_ci_within, persist_ci_between)
-
-    # Bootstrap CI for percentile diffs
-    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)
-
-    p50_ci_within = _bootstrap_percentile_ci(rng, all_pairs, 50)
-    p90_ci_within = _bootstrap_percentile_ci(rng, all_pairs, 90)
-    p99_ci_within = _bootstrap_percentile_ci(rng, all_pairs, 99)
-
-    # Between-pairing CI for percentile diffs
-    per_pairing_p50_diffs = []
-    per_pairing_p90_diffs = []
-    per_pairing_p99_diffs = []
-    for baseline in baseline_runs:
-        for feature in feature_runs:
-            pairs_i, _, _, _, _ = _paired_data(baseline, feature)
-            if pairs_i:
-                b_sorted = sorted(p[0] for p in pairs_i)
-                f_sorted = sorted(p[1] for p in pairs_i)
-                per_pairing_p50_diffs.append(percentile(f_sorted, 50) - percentile(b_sorted, 50))
-                per_pairing_p90_diffs.append(percentile(f_sorted, 90) - percentile(b_sorted, 90))
-                per_pairing_p99_diffs.append(percentile(f_sorted, 99) - percentile(b_sorted, 99))
-
-    p50_ci = max(p50_ci_within, _between_pairing_ci(per_pairing_p50_diffs))
-    p90_ci = max(p90_ci_within, _between_pairing_ci(per_pairing_p90_diffs))
-    p99_ci = max(p99_ci_within, _between_pairing_ci(per_pairing_p99_diffs))
-
-    mean_mgas_diff = sum(all_mgas_diffs) / len(all_mgas_diffs) if all_mgas_diffs else 0.0
-
-    # Cross-pair direction agreement
-    directions = _cross_pair_directions(baseline_runs, feature_runs)
+    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_ci,
-        "p90_diff_ms": p90_diff,
         "p90_ci_ms": p90_ci,
-        "p99_diff_ms": p99_diff,
         "p99_ci_ms": p99_ci,
-        "mean_mgas_diff": mean_mgas_diff,
         "mgas_ci": mgas_ci,
         "wall_clock_ci_ms": wall_clock_ci_ms,
         "persist_ci_ms": persist_ci_ms,
-        "blocks": max(blocks_per_pair),
-        "directions_agree": directions,
+        "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"
 
@@ -446,36 +365,38 @@ def display_bal_mode(bal_mode: str | None) -> str | None:
     return bal_mode
 
 
-def significance(pct: float, ci_pct: float, lower_is_better: bool, directions_agree: bool = True) -> str:
+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:
-    1. The CI doesn't cross zero (|pct| > ci_pct), AND
-    2. All cross-pairings agree on direction (directions_agree=True).
+    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.
     """
-    significant = abs(pct) > ci_pct and directions_agree
-    if not significant:
-        return "neutral"
-    elif (pct < 0) == lower_is_better:
+    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 change_str(pct: float, ci_pct: float, lower_is_better: bool, directions_agree: bool = True) -> str:
-    """Format change% with paired CI significance.
+def change_str(pct: float, ci_pct: float, floor_pct: float, lower_is_better: bool) -> str:
+    """Format change% with CI significance.
 
-    Significant if the CI doesn't cross zero (i.e. |pct| > ci_pct)
-    AND all cross-pairings agree on direction.
+    Significant if the confidence interval clears the practical floor.
     """
-    sig = significance(pct, ci_pct, lower_is_better, directions_agree)
+    sig = significance(pct, ci_pct, floor_pct, lower_is_better)
     emoji = {"good": "✅", "bad": "❌", "neutral": "⚪"}[sig]
-    qualifier = "" if directions_agree else " ↕"
-    return f"{pct:+.2f}% {emoji}{qualifier} (±{ci_pct:.2f}%)"
+    return f"{pct:+.2f}% {emoji} (±{ci_pct:.2f}%, floor {floor_pct:.2f}%)"
 
 
 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:
@@ -484,25 +405,25 @@ def pct(base: float, feat: float) -> float:
     def ci_pct(ci_ms: float, base_ms: float) -> float:
         return ci_ms / base_ms * 100.0 if base_ms > 0 else 0.0
 
-    dirs = paired_stats.get("directions_agree", {})
-
     metrics = [
-        ("p50", "p50_ms", "p50_ci_ms", "p50_ms", True, dirs.get("lat", True)),
-        ("p90", "p90_ms", "p90_ci_ms", "p90_ms", True, dirs.get("lat", True)),
-        ("p99", "p99_ms", "p99_ci_ms", "p99_ms", True, dirs.get("lat", True)),
-        ("mgas_s", "mean_mgas_s", "mgas_ci", "mean_mgas_s", False, dirs.get("mgas", True)),
-        ("wall_clock", "wall_clock_s", "wall_clock_ci_ms", "mean_total_lat_ms", True, dirs.get("total_lat", True)),
-        ("persist_wait", "mean_persist_ms", "persist_ci_ms", "mean_persist_ms", True, dirs.get("persist", True)),
+        ("mean", "mean_ms", "ci_ms", "mean_ms", True),
+        ("p50", "p50_ms", "p50_ci_ms", "p50_ms", True),
+        ("p90", "p90_ms", "p90_ci_ms", "p90_ms", True),
+        ("p99", "p99_ms", "p99_ci_ms", "p99_ms", True),
+        ("mgas_s", "mean_mgas_s", "mgas_ci", "mean_mgas_s", False),
+        ("wall_clock", "wall_clock_s", "wall_clock_ci_ms", "mean_total_lat_ms", True),
+        ("persist_wait", "mean_persist_ms", "persist_ci_ms", "mean_persist_ms", True),
     ]
     changes = {}
-    for name, stat_key, ci_key, base_key, lower_is_better, dir_agree in metrics:
+    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])
         changes[name] = {
             "pct": round(p, 4),
             "ci_pct": round(c, 4),
-            "sig": significance(p, c, lower_is_better, dir_agree),
-            "directions_agree": dir_agree,
+            "floor_pct": round(floor, 4),
+            "sig": significance(p, c, floor, lower_is_better),
         }
     return changes
 
@@ -510,7 +431,7 @@ def ci_pct(ci_ms: float, base_ms: float) -> float:
 def generate_comparison_table(
     run1: dict,
     run2: dict,
-    paired: dict,
+    ci_stats: dict,
     repo: str,
     baseline_ref: str,
     baseline_name: str,
@@ -520,9 +441,10 @@ 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
@@ -530,6 +452,7 @@ def pct(base: float, feat: float) -> float:
     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"])
@@ -537,20 +460,23 @@ 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
+    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 = 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
-
-    dirs = paired.get("directions_agree", {})
-    lat_agree = dirs.get("lat", True)
-    mgas_agree = dirs.get("mgas", True)
-    total_agree = dirs.get("total_lat", True)
-    persist_agree = dirs.get("persist", True)
+    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"])
 
     base_url = f"https://github.com/{repo}/commit"
     baseline_label = f"[`{baseline_name}`]({base_url}/{baseline_ref})"
@@ -559,17 +485,20 @@ def pct(base: float, feat: float) -> float:
     lines = [
         f"| Metric | {baseline_label} | {feature_label} | Change |",
         "|--------|------|--------|--------|",
-        f"| P50 | {fmt_ms(run1['p50_ms'])} | {fmt_ms(run2['p50_ms'])} | {change_str(p50_pct, p50_ci_pct, lower_is_better=True, directions_agree=lat_agree)} |",
-        f"| P90 | {fmt_ms(run1['p90_ms'])} | {fmt_ms(run2['p90_ms'])} | {change_str(p90_pct, p90_ci_pct, lower_is_better=True, directions_agree=lat_agree)} |",
-        f"| P99 | {fmt_ms(run1['p99_ms'])} | {fmt_ms(run2['p99_ms'])} | {change_str(p99_pct, p99_ci_pct, lower_is_better=True, directions_agree=lat_agree)} |",
-        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, directions_agree=mgas_agree)} |",
-        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, directions_agree=total_agree)} |",
-        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, directions_agree=persist_agree)} |",
+        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)} |",
+        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)} |",
         "",
     ]
     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)
@@ -632,16 +561,16 @@ def generate_markdown(
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Parse benchmark 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"
     )
@@ -659,10 +588,11 @@ def main():
     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("--grafana-url", default=None, help="Grafana dashboard URL for this benchmark run")
+    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 = []
@@ -680,17 +610,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)
+    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"
@@ -702,7 +630,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,
@@ -712,9 +640,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})"
@@ -741,9 +672,10 @@ def main():
             wait_time_tables.append(table)
 
     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": {
@@ -756,8 +688,7 @@ 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,
     }
     with open(args.output_summary, "w") as f:
diff --git a/.github/scripts/bench-slack-notify.js b/.github/scripts/bench-slack-notify.js
index db9ef6de158..ae71c439048 100644
--- a/.github/scripts/bench-slack-notify.js
+++ b/.github/scripts/bench-slack-notify.js
@@ -62,6 +62,16 @@ 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}>`;
+    });
+}
+
 // Slack shortcodes for verdict (Block Kit header doesn't support unicode emoji)
 const SLACK_VERDICT = {
   '⚠️': ':warning:',
@@ -87,16 +97,12 @@ function buildSuccessBlocks({ summary, prNumber, actor, actorSlackId, jobUrl, re
 
   // 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(' | ')}`;
 
   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 countsLine = blocksLabel(summary).map(p => `*${p.key}:* ${p.value}`).join(' | ');
 
diff --git a/.github/scripts/bench-utils.js b/.github/scripts/bench-utils.js
index 8f5f52e6b55..1b99adb1fb0 100644
--- a/.github/scripts/bench-utils.js
+++ b/.github/scripts/bench-utils.js
@@ -14,8 +14,11 @@ 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)}%`);
+  const detailStr = details.length ? ` (${details.join(', ')})` : '';
+  return `${pctStr}${detailStr} ${SIG_EMOJI[ch.sig]}`;
 }
 
 function verdict(changes) {
@@ -30,7 +33,15 @@ function verdict(changes) {
 
 function loadSamplyUrls(workDir) {
   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();
       if (url) urls[run] = url;
@@ -66,10 +77,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;
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 1071eae40f0..6872be9c1c2 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -305,7 +305,7 @@ jobs:
       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_NODE_BIN: reth
@@ -554,7 +554,7 @@ jobs:
           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 four times.
+      # runs instead of re-fetching from the remote RPC for every run.
       - name: Extract txgen payloads
         run: |
           PAYLOADS_DIR="$BENCH_WORK_DIR/txgen-payloads"
@@ -665,7 +665,7 @@ 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
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 61009ec24ee..57f91d9751e 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -12,9 +12,9 @@ on:
   workflow_dispatch:
     inputs:
       blocks:
-        description: "Number of blocks to benchmark"
+        description: "Number of blocks to benchmark (default: 500, big blocks: 65)"
         required: false
-        default: "500"
+        default: ""
         type: string
       big_blocks:
         description: "Use big blocks mode: false, true, or target gas like 100M/2G"
@@ -81,11 +81,11 @@ 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
@@ -129,7 +129,8 @@ jobs:
       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 }}
@@ -176,10 +177,12 @@ 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|100M|2G]] [bal=true|false|feature|baseline] [warmup=N] [baseline=REF] [feature=REF] [samply] [slack=always|on-win|on-error|never] [cores=N] [abba=true|false] [otlp=true|false] [wait-time=DURATION] [baseline-args="..."] [feature-args="..."]`';
+            const usage = '`@decofe bench [blocks=N] [big-blocks[=true|false|100M|2G]] [bal=true|false|feature|baseline] [warmup=N] [baseline=REF] [feature=REF] [samply] [slack=always|on-win|on-error|never] [cores=N] [run-pairs=N] [otlp=true|false] [wait-time=DURATION] [baseline-args="..."] [feature-args="..."]`';
             let pr, actor, blocks, warmup, baseline, feature, samply, cores, bigBlocks, bal;
             let bigBlocksTargetGas = '';
+            let explicitBlocks = false;
             let explicitWarmup = false;
+            let explicitRunPairs = false;
 
             const parseBigBlocks = (value) => {
               value = String(value || 'false');
@@ -188,11 +191,21 @@ jobs:
               if (/^\d+([kKmMgG])?$/.test(value)) return { enabled: 'true', targetGas: value };
               return null;
             };
+            const defaultBlocks = (isBigBlocks) => isBigBlocks ? '65' : '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';
+              blocks = '${{ github.event.inputs.blocks }}' || '';
+              explicitBlocks = blocks !== '';
               warmup = '${{ github.event.inputs.warmup }}' || '';
               explicitWarmup = warmup !== '';
               baseline = '${{ github.event.inputs.baseline }}';
@@ -208,7 +221,8 @@ jobs:
               bigBlocks = parsedBigBlocks.enabled;
               bigBlocksTargetGas = parsedBigBlocks.targetGas;
               bal = '${{ github.event.inputs.bal }}' || 'false';
-              var abba = '${{ github.event.inputs.abba }}' !== 'false' ? 'true' : 'false';
+              var runPairs = '${{ github.event.inputs.run_pairs }}' || '';
+              explicitRunPairs = runPairs !== '';
               var otlp = '${{ github.event.inputs.otlp }}' === 'true' ? 'true' : 'false';
               var waitTime = '${{ github.event.inputs.wait_time }}' || '';
               var baselineNodeArgs = '${{ github.event.inputs.baseline_args }}' || '';
@@ -232,14 +246,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']);
-              const boolDefaultTrue = new Set(['abba']);
+              const boolArgs = new Set(['samply', 'otlp']);
               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: '', baseline: '', feature: '', samply: 'false', slack: 'always', 'big-blocks': 'false', bal: 'false', cores: '0', abba: 'true', otlp: 'false', 'wait-time': '', 'baseline-args': '', 'feature-args': '' };
+              const defaults = { blocks: '', warmup: '', baseline: '', feature: '', samply: 'false', slack: 'always', 'big-blocks': 'false', bal: 'false', cores: '0', 'run-pairs': '', otlp: 'false', 'wait-time': '', 'baseline-args': '', 'feature-args': '' };
               const unknown = [];
               const invalid = [];
               const args = body.replace(/^(?:@decofe|derek) bench\s*/, '');
@@ -255,8 +268,6 @@ jobs:
                     defaults[part] = 'true';
                   } else if (boolArgs.has(part)) {
                     defaults[part] = 'true';
-                  } else if (boolDefaultTrue.has(part)) {
-                    defaults[part] = 'true';
                   } else {
                     unknown.push(part);
                   }
@@ -275,7 +286,7 @@ jobs:
                   } else {
                     invalid.push(`\`${key}=${value}\` (must be false, true, or a gas value like 100M or 2G)`);
                   }
-                } else if (boolArgs.has(key) || boolDefaultTrue.has(key)) {
+                } else if (boolArgs.has(key)) {
                   if (value === 'true' || value === 'false') {
                     defaults[key] = value;
                   } else {
@@ -298,7 +309,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) {
@@ -337,13 +350,20 @@ jobs:
               bigBlocks = parsedBigBlocks.enabled;
               bigBlocksTargetGas = parsedBigBlocks.targetGas;
               bal = defaults.bal;
-              var abba = defaults.abba;
+              var runPairs = defaults['run-pairs'];
               var otlp = defaults.otlp;
               var waitTime = defaults['wait-time'];
               var baselineNodeArgs = defaults['baseline-args'];
               var featureNodeArgs = defaults['feature-args'];
             }
 
+            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;
@@ -355,6 +375,11 @@ jobs:
             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}`);
@@ -396,7 +421,8 @@ jobs:
             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('node-bin', nodeBin);
 
@@ -464,8 +490,9 @@ jobs:
             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 }}';
@@ -474,8 +501,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}${slackNote}${balNote}${coresNote}${runPairsNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
 
             const { data: comment } = await github.rest.issues.createComment({
               owner: context.repo.owner,
@@ -508,8 +535,9 @@ jobs:
             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 }}';
@@ -518,8 +546,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}${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;
@@ -595,7 +623,8 @@ jobs:
       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_ABBA: ${{ needs.bench-ack.outputs.abba }}
+      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_COMMENT_ID: ${{ needs.bench-ack.outputs.comment-id }}
       BENCH_SLACK: ${{ needs.bench-ack.outputs.slack }}
@@ -662,8 +691,9 @@ jobs:
             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 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 || '';
@@ -672,8 +702,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}${slackNote}${balNote}${coresNote}${runPairsNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`);
 
             const { buildBody } = require('./.github/scripts/bench-update-status.js');
             await github.rest.issues.updateComment({
@@ -970,7 +1000,7 @@ jobs:
           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 four times.
+      # runs instead of re-fetching from the remote RPC for every run.
       - name: Extract txgen payloads
         run: |
           PAYLOADS_DIR="$BENCH_WORK_DIR/txgen-payloads"
@@ -979,69 +1009,73 @@ jobs:
             "$PAYLOADS_DIR"
           echo "TXGEN_PAYLOADS_DIR=${PAYLOADS_DIR}" >> "$GITHUB_ENV"
 
-      # 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
+      # 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 }}
           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 }}"
           BENCH_GH_TOKEN: ${{ secrets.DEREK_PAT }}
         run: |
-          .github/scripts/bench-update-status.sh "Running benchmark: feature (1/2)..."
-          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-txgen-run.sh feature "../reth-feature/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/feature-1"
+          set -euo pipefail
 
-      - name: "Run benchmark: baseline (1/2)"
-        id: run-baseline-1
-        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 }}"
-          BENCH_GH_TOKEN: ${{ secrets.DEREK_PAT }}
-        run: |
-          .github/scripts/bench-update-status.sh "Running benchmark: baseline (1/2)..."
-          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-txgen-run.sh baseline "../reth-baseline/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/baseline-1"
+          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: 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 }}"
-          BENCH_GH_TOKEN: ${{ secrets.DEREK_PAT }}
-        run: |
-          .github/scripts/bench-update-status.sh "Running benchmark: baseline (2/2)..."
-          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-txgen-run.sh baseline "../reth-baseline/target/profiling/${BENCH_NODE_BIN}" "$BENCH_WORK_DIR/baseline-2"
+          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
 
-      - 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 }}"
-          BENCH_GH_TOKEN: ${{ secrets.DEREK_PAT }}
-        run: |
-          .github/scripts/bench-update-status.sh "Running benchmark: feature (2/2)..."
-          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_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-txgen-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
         id: metrics
@@ -1049,7 +1083,7 @@ jobs:
         run: |
           kill "$BENCH_METRICS_PROXY_PID" 2>/dev/null || true
 
-          LAST_RUN_DURATION=$(( $(date +%s) - BENCH_LAST_RUN_START ))
+          LAST_RUN_DURATION=$(( $(date +%s) - ${BENCH_LAST_RUN_START:-$BENCH_REFERENCE_EPOCH} ))
           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=efk1hcn87dnnkd&var-job=reth-bench&var-benchmark_id=${BENCH_ID}&var-benchmark_run=\$__all"
@@ -1061,7 +1095,8 @@ jobs:
         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
 
@@ -1094,7 +1129,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
 
@@ -1133,6 +1169,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()
@@ -1156,15 +1199,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
@@ -1194,14 +1237,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
@@ -1299,16 +1342,11 @@ 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`;
@@ -1373,14 +1411,11 @@ jobs:
         with:
           github-token: ${{ secrets.DEREK_PAT }}
           script: |
-            const abba = (process.env.BENCH_ABBA || 'true') !== 'false';
             const steps_status = [
               ['building binaries', '${{ steps.build.outcome }}'],
               ['syncing snapshot', '${{ steps.snapshot-check.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 }}']] : []),
+              ['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';
@@ -1409,14 +1444,11 @@ jobs:
           SLACK_BENCH_CHANNEL: ${{ secrets.SLACK_BENCH_CHANNEL }}
         with:
           script: |
-            const abba = (process.env.BENCH_ABBA || 'true') !== 'false';
             const steps_status = [
               ['building binaries', '${{ steps.build.outcome }}'],
               ['syncing snapshot', '${{ steps.snapshot-check.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 }}']] : []),
+              ['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';

From 81272f7f5eb116312aab319c6867183b2d39818a Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Mon, 18 May 2026 16:26:16 +0200
Subject: [PATCH 156/335] refactor(chain-state): manage state trie overlays
 centrally (#24184)

Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
---
 Cargo.lock                                    |   1 +
 crates/chain-state/Cargo.toml                 |   4 +-
 crates/chain-state/src/deferred_trie.rs       | 842 ++----------------
 crates/chain-state/src/in_memory.rs           |  26 +-
 crates/chain-state/src/lazy_overlay.rs        | 327 -------
 crates/chain-state/src/lib.rs                 |   4 +-
 crates/chain-state/src/state_trie_overlay.rs  | 682 ++++++++++++++
 crates/engine/tree/src/tree/metrics.rs        |   4 -
 crates/engine/tree/src/tree/mod.rs            |  28 +-
 .../engine/tree/src/tree/payload_validator.rs | 109 +--
 crates/engine/tree/src/tree/state.rs          | 188 ++--
 crates/engine/tree/src/tree/tests.rs          |  17 +-
 .../rpc-eth-api/src/helpers/pending_block.rs  |   2 +-
 .../provider/src/providers/state/overlay.rs   | 230 +++--
 crates/tasks/src/runtime.rs                   |  41 +
 15 files changed, 1056 insertions(+), 1449 deletions(-)
 delete mode 100644 crates/chain-state/src/lazy_overlay.rs
 create mode 100644 crates/chain-state/src/state_trie_overlay.rs

diff --git a/Cargo.lock b/Cargo.lock
index 92de64299a6..48f26852d9f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7730,6 +7730,7 @@ dependencies = [
  "reth-metrics",
  "reth-primitives-traits",
  "reth-storage-api",
+ "reth-tasks",
  "reth-testing-utils",
  "reth-trie",
  "revm-database",
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 befb34cfd9c..ea71b92c15d 100644
--- a/crates/chain-state/src/deferred_trie.rs
+++ b/crates/chain-state/src/deferred_trie.rs
@@ -1,9 +1,8 @@
-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,
@@ -11,46 +10,26 @@ use std::{
 };
 use tracing::{debug_span, instrument};
 
-/// Shared handle to asynchronously populated trie data.
+/// Shared handle to asynchronously populated 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.
+/// If the background task has not completed by the time trie data is needed, the caller computes
+/// the sorted data synchronously from the retained unsorted inputs and caches the result.
 #[derive(Clone)]
 pub struct DeferredTrieData {
     /// Shared deferred state holding either raw inputs (pending) or computed result (ready).
-    state: Arc<Mutex<DeferredState>>,
+    state: Arc<Mutex<DeferredTrieDataInner>>,
 }
 
-/// 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.
+/// 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.
@@ -67,8 +46,9 @@ static DEFERRED_TRIE_METRICS: LazyLock<DeferredTrieMetrics> =
     LazyLock::new(DeferredTrieMetrics::default);
 
 /// Internal state for deferred trie data.
-enum DeferredState {
+enum DeferredTrieDataInner {
     /// 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.
@@ -82,20 +62,16 @@ 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(_) => {
+            DeferredTrieDataInner::Pending(_) => {
                 f.debug_struct("DeferredTrieData").field("state", &"pending").finish()
             }
-            DeferredState::Ready(_) => {
+            DeferredTrieDataInner::Ready(_) => {
                 f.debug_struct("DeferredTrieData").field("state", &"ready").finish()
             }
         }
@@ -104,64 +80,24 @@ impl fmt::Debug for DeferredTrieData {
 
 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
-    pub fn pending(
-        hashed_state: Arc<HashedPostState>,
-        trie_updates: Arc<TrieUpdates>,
-        anchor_hash: B256,
-        ancestors: Vec<Self>,
-    ) -> Self {
+    pub fn pending(hashed_state: Arc<HashedPostState>, trie_updates: Arc<TrieUpdates>) -> Self {
         Self {
-            state: Arc::new(Mutex::new(DeferredState::Pending(Some(PendingInputs {
+            state: Arc::new(Mutex::new(DeferredTrieDataInner::Pending(Some(PendingInputs {
                 hashed_state,
                 trie_updates,
-                anchor_hash,
-                ancestors,
             })))),
         }
     }
 
     /// 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 { state: Arc::new(Mutex::new(DeferredTrieDataInner::Ready(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,200 +125,24 @@ 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())
-    }
-
-    /// 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
+        ComputedTrieData::new(Arc::new(sorted_hashed_state), Arc::new(sorted_trie_updates))
     }
 
     /// 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.
     #[instrument(level = "debug", target = "engine::tree::deferred_trie", skip_all)]
     pub fn wait_cloned(&self) -> ComputedTrieData {
         let mut state = self.state.lock();
         match &mut *state {
-            // If the deferred trie data is ready, return the cached result.
-            DeferredState::Ready(bundle) => {
+            DeferredTrieDataInner::Ready(bundle) => {
                 DEFERRED_TRIE_METRICS.deferred_trie_async_ready.increment(1);
                 bundle.clone()
             }
-            // 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) => {
+            DeferredTrieDataInner::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);
+                let computed = Self::sort(inputs.hashed_state, inputs.trie_updates);
+                *state = DeferredTrieDataInner::Ready(computed.clone());
 
                 computed
             }
@@ -391,578 +151,102 @@ impl DeferredTrieData {
 }
 
 impl ComputedTrieData {
-    /// Construct a bundle that includes trie input anchored to a persisted ancestor.
-    pub const fn with_trie_input(
+    /// Construct sorted trie data for one block.
+    pub const fn new(
         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(
-        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 {
         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() {
+    fn pending_computes_and_caches_result() {
         let deferred = 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 first = deferred.wait_cloned();
-        // Second call should reuse the cached result (same Arc pointer)
         let second = deferred.wait_cloned();
 
         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() {
+    fn concurrent_waits_share_computed_result() {
         let deferred = empty_pending();
+        let deferred2 = deferred.clone();
 
-        // 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));
-        }
-    }
+        let handle = thread::spawn(move || deferred2.wait_cloned());
+        let result1 = deferred.wait_cloned();
+        let result2 = handle.join().unwrap();
 
-    /// 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)));
+        assert!(Arc::ptr_eq(&result1.hashed_state, &result2.hashed_state));
+        assert!(Arc::ptr_eq(&result1.trie_updates, &result2.trie_updates));
     }
 
-    /// 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)],
-        );
-
+    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 =
+            DeferredTrieData::pending(Arc::new(hashed_state), Arc::new(TrieUpdates::default()));
         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 };
-
-        // Create parent with anchored trie input
-        let parent = ready_block_with_state(anchor, vec![(key, Some(account))]);
-
-        // Create child - should reuse parent's overlay
-        let child = DeferredTrieData::pending(
-            Arc::new(HashedPostState::default()),
-            Arc::new(TrieUpdates::default()),
-            anchor,
-            vec![parent],
-        );
-
-        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);
-    }
-
-    /// 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);
-    }
-
-    /// 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);
+        assert_eq!(result.hashed_state.total_len(), 2);
+        assert_eq!(result.trie_updates.total_len(), 0);
     }
 
-    /// 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();
-
-        // 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);
-    }
-
-    /// 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),
-            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),
+        let deferred = DeferredTrieData::pending(
+            Arc::new(HashedPostState { accounts, storages: Default::default() }),
             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 _ = 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..60a85e44781 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,10 +803,9 @@ 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. 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.
@@ -878,20 +874,6 @@ impl<N: NodePrimitives> ExecutedBlock<N> {
         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/state_trie_overlay.rs b/crates/chain-state/src/state_trie_overlay.rs
new file mode 100644
index 00000000000..d7baef361fd
--- /dev/null
+++ b/crates/chain-state/src/state_trie_overlay.rs
@@ -0,0 +1,682 @@
+//! 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, 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, Arc<TrieInputSorted>>>,
+    #[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).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.get_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)))
+    }
+
+    #[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> {
+        let key = OverlayCacheKey { anchor_hash, tip_hash };
+        let span = tracing::Span::current();
+
+        if let Some(input) = self.overlays.get(&key).map(|entry| Arc::clone(entry.value())) {
+            self.metrics.overlay_cache_reuses.increment(1);
+            span.record("cache_reused", true);
+            return Ok(input)
+        }
+        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 })
+                        .map(|entry| Arc::clone(entry.value()))
+                })
+                .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),
+        };
+
+        // The vacant entry is the cache-fill gate: racing callers block instead of recomputing.
+        let input = match self.overlays.entry(key) {
+            Entry::Occupied(entry) => {
+                self.metrics.overlay_cache_reuses.increment(1);
+                span.record("cache_reused", true);
+                return Ok(Arc::clone(entry.get()))
+            }
+            Entry::Vacant(entry) => {
+                self.metrics.overlay_cache_fills.increment(1);
+                let input = {
+                    #[cfg(feature = "rayon")]
+                    {
+                        if let Some(worker_pool) = &self.worker_pool {
+                            let compute_span = span;
+                            let metrics = self.metrics.clone();
+                            Arc::new(worker_pool.install_fn(move || {
+                                let _guard = compute_span.enter();
+                                compute_overlay(compute_input, anchor_hash, &metrics)
+                            }))
+                        } else {
+                            Arc::new(compute_overlay(compute_input, anchor_hash, &self.metrics))
+                        }
+                    }
+
+                    #[cfg(not(feature = "rayon"))]
+                    {
+                        Arc::new(compute_overlay(compute_input, anchor_hash, &self.metrics))
+                    }
+                };
+
+                entry.insert(Arc::clone(&input));
+                input
+            }
+        };
+
+        Ok(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;
+        }
+    }
+}
+
+/// 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,
+}
+
+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};
+    use std::sync::Arc;
+    #[cfg(feature = "rayon")]
+    use std::{
+        thread,
+        time::{Duration, Instant},
+    };
+
+    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)
+        );
+    }
+
+    #[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/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 efdea2db935..e0bf3934b8c 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -14,7 +14,7 @@ use alloy_rpc_types_engine::{
 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,7 +36,7 @@ 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;
@@ -156,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(
@@ -163,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(),
         }
     }
@@ -445,6 +450,7 @@ where
             config.invalid_header_hit_eviction_threshold(),
             header.num_hash(),
             kind,
+            runtime.state_trie_overlay_worker_pool(),
         );
 
         let task = Self::new(
@@ -1505,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(())
@@ -2189,9 +2183,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,
diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index a0351eb88de..ed72938e2c6 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -59,7 +59,7 @@ 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::{
@@ -475,15 +475,14 @@ 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());
 
@@ -804,7 +803,6 @@ where
         let executed_block = self.spawn_deferred_trie_task(
             Arc::new(block),
             output,
-            ctx.state(),
             hashed_state,
             trie_output,
             changeset_provider,
@@ -1242,10 +1240,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()
     }
@@ -1683,47 +1680,14 @@ 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.
@@ -1731,10 +1695,7 @@ where
     /// This function creates a [`DeferredTrieData`] handle with fallback inputs and spawns a
     /// blocking task that calls `wait_cloned()` to:
     /// 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. Cache 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.
@@ -1746,22 +1707,10 @@ where
         &self,
         block: Arc<RecoveredBlock<N::Block>>,
         execution_outcome: Arc<BlockExecutionOutput<N::Receipt>>,
-        state: &EngineApiTreeState<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) = 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.
         // 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.
@@ -1769,8 +1718,7 @@ where
             Ok(state) => state,
             Err(handle) => handle.get().clone(),
         };
-        let deferred_trie_data =
-            DeferredTrieData::pending(hashed_state, trie_output, anchor_hash, ancestors);
+        let deferred_trie_data = DeferredTrieData::pending(hashed_state, trie_output);
         let deferred_handle_task = deferred_trie_data.clone();
         let block_validation_metrics = self.metrics.block_validation.clone();
 
@@ -1807,15 +1755,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.
@@ -2148,19 +2087,19 @@ where
             &block.execution_output.state,
         );
 
-        let (lazy_overlay, anchor_hash) =
-            Self::get_parent_lazy_overlay(block.recovered_block.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(
+                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,
-            state,
             LazyHashedPostState::ready(block.hashed_state),
             block.trie_updates,
             changeset_provider,
@@ -2177,11 +2116,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(
diff --git a/crates/engine/tree/src/tree/state.rs b/crates/engine/tree/src/tree/state.rs
index a5b3e40d0b0..b8a33adb8b0 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.
@@ -421,39 +390,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 +397,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 +424,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 +454,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 +498,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 +552,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 +606,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 193200f2a32..2af5f529e33 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();
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 643bc1ef13d..71d4f8a1a74 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
@@ -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()),
             ),
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/tasks/src/runtime.rs b/crates/tasks/src/runtime.rs
index 646da171165..af87b4eba24 100644
--- a/crates/tasks/src/runtime.rs
+++ b/crates/tasks/src/runtime.rs
@@ -41,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;
 
@@ -115,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")]
@@ -130,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,
         }
     }
 }
@@ -190,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
@@ -275,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,
@@ -365,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 ──────────────────────────────────────────────────────
@@ -400,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),
             },
         }
     }
@@ -823,6 +850,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);
@@ -867,6 +895,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,
@@ -875,6 +910,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"
             );
@@ -888,6 +924,7 @@ impl RuntimeBuilder {
                 proof_account_worker_pool,
                 prewarming_pool,
                 bal_streaming_pool,
+                state_trie_overlay_worker_pool,
             )
         };
 
@@ -922,6 +959,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)),
         };
@@ -1010,6 +1049,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);
@@ -1018,5 +1058,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);
     }
 }

From 273da2ff4aa3151f9f12e08fa99a76633ac1428d Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Mon, 18 May 2026 08:12:43 -0700
Subject: [PATCH 157/335] ci(bench): remote write txgen bench metrics (#24293)

Co-authored-by: Alexey Shekhirin <github@shekhirin.com>
---
 .github/scripts/bench-metrics-proxy.py | 276 -------------------------
 .github/scripts/bench-txgen-run.sh     |  30 ++-
 .github/workflows/bench-scheduled.yml  |  22 +-
 .github/workflows/bench.yml            |  22 +-
 4 files changed, 45 insertions(+), 305 deletions(-)
 delete mode 100644 .github/scripts/bench-metrics-proxy.py

diff --git a/.github/scripts/bench-metrics-proxy.py b/.github/scripts/bench-metrics-proxy.py
deleted file mode 100644
index e0ee724a3e6..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 between benchmark 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:9001/",
-                        help="Upstream reth metrics URL (default: http://127.0.0.1:9001/)")
-
-    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-txgen-run.sh b/.github/scripts/bench-txgen-run.sh
index 65603ca957a..f094cbaf2e0 100755
--- a/.github/scripts/bench-txgen-run.sh
+++ b/.github/scripts/bench-txgen-run.sh
@@ -377,20 +377,48 @@ if [ -n "${CLICKHOUSE_URL:-}" ]; then
   CLICKHOUSE_REPORT=(--report "clickhouse:$CLICKHOUSE_URL")
 fi
 
+METRICS_ARGS=()
+PROMETHEUS_REPORT=()
+PROMETHEUS_METADATA=()
+if [ -n "${BENCH_VICTORIAMETRICS_URL:-}" ]; then
+  if [ -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" 2>&1 | sed -u "s/^/[bench] /"
+  -m "bal-enabled=$USE_BAL" \
+  "${PROMETHEUS_METADATA[@]}" 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/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 6872be9c1c2..9b4e0428993 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -318,6 +318,7 @@ jobs:
       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
@@ -533,8 +534,12 @@ 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"
@@ -544,15 +549,6 @@ jobs:
           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
@@ -598,16 +594,14 @@ jobs:
           LABELS
           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=efk1hcn87dnnkd&var-job=reth-bench&var-benchmark_id=${BENCH_ID}&var-benchmark_run=\$__all"
+          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}"
 
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 57f91d9751e..3fa03905c46 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -634,6 +634,7 @@ jobs:
       TXGEN_REV: f439eec4e0f6dbe0675dd3bac8192d9f0299d409
       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: ${{ secrets.BENCH_VICTORIAMETRICS_URL }}
     steps:
       - name: Clean up previous bench-work
         run: sudo rm -rf "$BENCH_WORK_DIR" 2>/dev/null || true
@@ -979,8 +980,12 @@ 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="ci-${{ github.run_id }}"
           BENCH_REFERENCE_EPOCH=$(date +%s)
           echo "BENCH_ID=${BENCH_ID}" >> "$GITHUB_ENV"
@@ -990,15 +995,6 @@ jobs:
           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
@@ -1077,16 +1073,14 @@ jobs:
 
           .github/scripts/bench-update-status.sh "Finalizing results..."
 
-      - 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:-$BENCH_REFERENCE_EPOCH} ))
           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=efk1hcn87dnnkd&var-job=reth-bench&var-benchmark_id=${BENCH_ID}&var-benchmark_run=\$__all"
+          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}"
 

From 20f0fc46ab2a33fe0f0d5cabac33ab3c8081a12a Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Mon, 18 May 2026 17:30:21 +0200
Subject: [PATCH 158/335] perf(engine): create changeset provider in background
 (#24292)

Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
---
 .../engine/tree/src/tree/payload_validator.rs | 46 +++++++++++++++----
 1 file changed, 37 insertions(+), 9 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index ed72938e2c6..aff8c264d3f 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -80,7 +80,7 @@ use reth_primitives_traits::{
     RecoveredBlock, SealedBlock, SealedHeader, SignerRecoverable,
 };
 use reth_provider::{
-    providers::{OverlayBuilder, OverlayStateProviderFactory},
+    providers::{OverlayBuilder, OverlayStateProvider, OverlayStateProviderFactory},
     BlockExecutionOutput, BlockNumReader, BlockReader, ChangeSetReader, DatabaseProviderFactory,
     DatabaseProviderROFactory, HashedPostStateProvider, ProviderError, PruneCheckpointReader,
     StageCheckpointReader, StateProvider, StateProviderBox, StateProviderFactory, StateReader,
@@ -113,6 +113,9 @@ type LazyHashedPostState = reth_tasks::LazyHandle<Arc<HashedPostState>>;
 /// 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)>;
@@ -485,6 +488,7 @@ where
         );
         let overlay_factory =
             OverlayStateProviderFactory::new(provider_factory.clone(), overlay_builder.clone());
+        let changeset_provider = self.spawn_changeset_provider_task(overlay_factory.clone());
 
         // BAL execute path eligibility. Computed up front because the BAL arm needs a clone of
         // `provider_builder` (consumed by `spawn_payload_processor` below).
@@ -496,7 +500,7 @@ where
             env.clone(),
             txs,
             provider_builder.clone(),
-            overlay_factory.clone(),
+            overlay_factory,
             &strategy,
         ));
 
@@ -793,12 +797,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
+        );
 
         let executed_block = self.spawn_deferred_trie_task(
             Arc::new(block),
@@ -865,6 +870,29 @@ where
         })
     }
 
+    /// Spawns a background task that creates the changeset provider used by the deferred trie task.
+    ///
+    /// This is started before execution so overlay construction can run concurrently with payload
+    /// validation, then awaited before the deferred trie task 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.
     fn sealed_header_by_hash(
         &self,
@@ -1796,7 +1824,7 @@ 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(block, execution_outcome, deferred_trie_data)
     }

From 6cb04766eb89555a938fabe37719ddaf52cf7913 Mon Sep 17 00:00:00 2001
From: figtracer <me@figtracer.com>
Date: Mon, 18 May 2026 16:53:26 +0100
Subject: [PATCH 159/335] feat(init-state): support storage v2 imports (#24126)

---
 crates/storage/db-common/src/init.rs          | 444 ++++++++++++++++++
 .../src/providers/static_file/manager.rs      |   2 +
 .../src/providers/static_file/writer.rs       |  71 +++
 3 files changed, 517 insertions(+)

diff --git a/crates/storage/db-common/src/init.rs b/crates/storage/db-common/src/init.rs
index c2ea1e7f606..32924a67a1e 100644
--- a/crates/storage/db-common/src/init.rs
+++ b/crates/storage/db-common/src/init.rs
@@ -690,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;
@@ -750,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.
 ///
@@ -833,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>(
@@ -1062,6 +1349,163 @@ mod tests {
         );
     }
 
+    #[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 =
diff --git a/crates/storage/provider/src/providers/static_file/manager.rs b/crates/storage/provider/src/providers/static_file/manager.rs
index dc79d779097..57133bfc4fd 100644
--- a/crates/storage/provider/src/providers/static_file/manager.rs
+++ b/crates/storage/provider/src/providers/static_file/manager.rs
@@ -933,6 +933,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",
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.

From b310b03dba8edde650b2242ca5653fd76969a0c8 Mon Sep 17 00:00:00 2001
From: tempoxyz-bot <github-svc@tempo.xyz>
Date: Tue, 19 May 2026 07:49:34 +0200
Subject: [PATCH 160/335] perf: trust streamed receipt root indices (#24224)

Co-authored-by: autoopt[bot] <autoopt@tempo.xyz>
Co-authored-by: Amp <amp@ampcode.com>
---
 .../payload_processor/receipt_root_task.rs    | 21 +++++--------------
 1 file changed, 5 insertions(+), 16 deletions(-)

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 68de84811bd..c12bba4ad15 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
@@ -87,22 +87,11 @@ impl<R: Receipt> ReceiptRootTaskHandle<R> {
             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"
-                    );
-                }
-            }
+            // Receipt indices are produced by the block executor in transaction order and are
+            // bounded by `receipts_len`, so avoid re-validating every streamed receipt on the hot
+            // path. `finalize` below still catches aborted execution that sends too few receipts.
+            builder.push_unchecked(indexed_receipt.index, &encode_buf);
+            received_count += 1;
         }
 
         let Ok(root) = builder.finalize() else {

From 805f915e826e20686883ad8986079bd77fc4ba4e Mon Sep 17 00:00:00 2001
From: tempoxyz-bot <github-svc@tempo.xyz>
Date: Tue, 19 May 2026 07:50:23 +0200
Subject: [PATCH 161/335] perf: skip committed proof child churn (#24225)

Co-authored-by: autoopt[bot] <autoopt@tempo.xyz>
Co-authored-by: Amp <amp@ampcode.com>
---
 crates/trie/trie/src/proof_v2/mod.rs | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/crates/trie/trie/src/proof_v2/mod.rs b/crates/trie/trie/src/proof_v2/mod.rs
index db52a0e6bda..933e049c254 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) {

From d9c9ea0c1d5af2520db83ba771abb2969baa47c9 Mon Sep 17 00:00:00 2001
From: Mablr <59505383+mablr@users.noreply.github.com>
Date: Tue, 19 May 2026 08:23:37 +0200
Subject: [PATCH 162/335] feat(tracing): add `std` feature gate to
 `reth-tracing` for wasm compatibility (#23699)

---
 .github/scripts/check_wasm.sh  | 10 ++++++++++
 Cargo.lock                     | 11 +++++++++--
 Cargo.toml                     |  4 ++--
 crates/node/builder/Cargo.toml |  2 +-
 crates/node/core/Cargo.toml    |  2 +-
 crates/tracing/Cargo.toml      | 30 +++++++++++++++++++++---------
 crates/tracing/src/lib.rs      | 27 ++++++++++++++++++++++++++-
 crates/trie/sparse/Cargo.toml  |  1 +
 8 files changed, 71 insertions(+), 16 deletions(-)

diff --git a/.github/scripts/check_wasm.sh b/.github/scripts/check_wasm.sh
index fbc01acfa1a..c94e458677e 100755
--- a/.github/scripts/check_wasm.sh
+++ b/.github/scripts/check_wasm.sh
@@ -77,6 +77,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/Cargo.lock b/Cargo.lock
index 48f26852d9f..f24dd2d4de2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11908,6 +11908,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"
@@ -12558,11 +12564,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",
diff --git a/Cargo.toml b/Cargo.toml
index a555859bdb9..f013173ef48 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -423,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" }
@@ -539,7 +539,7 @@ 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"
+tracing-appender = "0.2.5"
 url = { version = "2.3", default-features = false }
 zstd = "0.13"
 byteorder = "1"
diff --git a/crates/node/builder/Cargo.toml b/crates/node/builder/Cargo.toml
index a2c75de8888..d489bf18cb6 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/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/tracing/Cargo.toml b/crates/tracing/Cargo.toml
index 58c18ff7ed4..d9fe85ff853 100644
--- a/crates/tracing/Cargo.toml
+++ b/crates/tracing/Cargo.toml
@@ -17,21 +17,33 @@ 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-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-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/lib.rs b/crates/tracing/src/lib.rs
index 233ffbdb87a..8e6cf748a6f 100644
--- a/crates/tracing/src/lib.rs
+++ b/crates/tracing/src/lib.rs
@@ -39,45 +39,62 @@
     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;
+#[cfg(feature = "std")]
 pub use layers::{FileInfo, FileWorkerGuard, Layers};
+#[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;
+#[cfg(feature = "std")]
 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,
@@ -91,6 +108,7 @@ pub struct RethTracer {
     enable_reload: bool,
 }
 
+#[cfg(feature = "std")]
 impl RethTracer {
     /// Constructs a new `Tracer` with default settings.
     ///
@@ -156,6 +174,7 @@ impl RethTracer {
     }
 }
 
+#[cfg(feature = "std")]
 impl Default for RethTracer {
     fn default() -> Self {
         Self::new()
@@ -166,6 +185,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 +194,7 @@ pub struct LayerInfo {
     color: Option<String>,
 }
 
+#[cfg(feature = "std")]
 impl LayerInfo {
     ///  Constructs a new `LayerInfo`.
     ///
@@ -195,6 +216,7 @@ impl LayerInfo {
     }
 }
 
+#[cfg(feature = "std")]
 impl Default for LayerInfo {
     ///  Provides default values for `LayerInfo`.
     ///
@@ -216,6 +238,7 @@ 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.
     ///
@@ -241,6 +264,7 @@ pub trait Tracer: Sized {
     fn init_with_layers(self, layers: Layers) -> eyre::Result<Option<WorkerGuard>>;
 }
 
+#[cfg(feature = "std")]
 impl Tracer for RethTracer {
     fn init_with_layers(self, mut layers: Layers) -> eyre::Result<Option<WorkerGuard>> {
         // Configure stdout layer - reloadable if requested for runtime log level changes
@@ -293,6 +317,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/trie/sparse/Cargo.toml b/crates/trie/sparse/Cargo.toml
index 18393802e88..8cb9e678440 100644
--- a/crates/trie/sparse/Cargo.toml
+++ b/crates/trie/sparse/Cargo.toml
@@ -69,6 +69,7 @@ std = [
     "tracing/std",
     "serde?/std",
     "serde_json?/std",
+    "reth-tracing/std",
     "either/std",
 ]
 metrics = ["dep:reth-metrics", "dep:metrics", "std"]

From ada255d9898cb0a587fe4a70b845f792cbd22f92 Mon Sep 17 00:00:00 2001
From: tempoxyz-bot <github-svc@tempo.xyz>
Date: Tue, 19 May 2026 08:24:50 +0200
Subject: [PATCH 163/335] perf: fast-path empty storage proof dispatch (#24301)

Co-authored-by: autoopt[bot] <autoopt@tempo.xyz>
Co-authored-by: Amp <amp@ampcode.com>
---
 crates/trie/parallel/src/proof_task.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

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

From a5ce4866f68329e04c41237e9689806e289025a8 Mon Sep 17 00:00:00 2001
From: tempoxyz-bot <github-svc@tempo.xyz>
Date: Tue, 19 May 2026 08:25:37 +0200
Subject: [PATCH 164/335] perf: keep small save block tx numbers inline
 (#24318)

Co-authored-by: autoopt[bot] <autoopt@tempo.xyz>
Co-authored-by: Amp <amp@ampcode.com>
---
 Cargo.lock                                                 | 1 +
 crates/storage/provider/Cargo.toml                         | 1 +
 crates/storage/provider/src/providers/database/provider.rs | 5 +++--
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f24dd2d4de2..94abe667406 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9690,6 +9690,7 @@ dependencies = [
  "revm-database-interface",
  "revm-state",
  "rocksdb",
+ "smallvec",
  "strum",
  "tempfile",
  "tokio",
diff --git a/crates/storage/provider/Cargo.toml b/crates/storage/provider/Cargo.toml
index 052ba6c3e9c..6558dff131e 100644
--- a/crates/storage/provider/Cargo.toml
+++ b/crates/storage/provider/Cargo.toml
@@ -55,6 +55,7 @@ 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
diff --git a/crates/storage/provider/src/providers/database/provider.rs b/crates/storage/provider/src/providers/database/provider.rs
index b95ce3cd221..c9807eaf8f2 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);

From f0bf0995555cbc35d2c55ceca36848fd46211011 Mon Sep 17 00:00:00 2001
From: Dan Cline <6798349+Rjected@users.noreply.github.com>
Date: Tue, 19 May 2026 02:29:08 -0400
Subject: [PATCH 165/335] ci: remove temporary branch trigger from benchmarkoor
 workflow (#24252)

---
 .github/workflows/bench-benchmarkoor.yml | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/.github/workflows/bench-benchmarkoor.yml b/.github/workflows/bench-benchmarkoor.yml
index 02bbae4f53e..a6e84cfabbb 100644
--- a/.github/workflows/bench-benchmarkoor.yml
+++ b/.github/workflows/bench-benchmarkoor.yml
@@ -6,11 +6,6 @@
 # page cache, and measures only the testing fixture replay.
 
 on:
-  # Temporary test trigger for branch-only workflow validation.
-  # Remove before merging this workflow.
-  push:
-    branches:
-      - dan/create-benchmarkoor-replay-workflow
   workflow_dispatch:
     inputs:
       pr:

From 833202dff443f86da5c23a2f736bfa14c13c8652 Mon Sep 17 00:00:00 2001
From: tempoxyz-bot <github-svc@tempo.xyz>
Date: Tue, 19 May 2026 08:50:12 +0200
Subject: [PATCH 166/335] perf(engine): avoid tiny multiproof chunks (#24236)

Co-authored-by: autoopt[bot] <autoopt@tempo.xyz>
Co-authored-by: Amp <amp@ampcode.com>
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/engine/tree/src/tree/payload_processor/multiproof.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_processor/multiproof.rs b/crates/engine/tree/src/tree/payload_processor/multiproof.rs
index b8f68ee5abf..0edd1933430 100644
--- a/crates/engine/tree/src/tree/payload_processor/multiproof.rs
+++ b/crates/engine/tree/src/tree/payload_processor/multiproof.rs
@@ -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) {

From f12b36aba9351aedf447176d7ab87eb775dfb182 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 19 May 2026 02:25:29 -0700
Subject: [PATCH 167/335] ci(bench): unpin txgen install rev (#24336)

---
 .github/scripts/bench-txgen-install.sh | 7 +------
 .github/workflows/bench-scheduled.yml  | 1 -
 .github/workflows/bench.yml            | 1 -
 3 files changed, 1 insertion(+), 8 deletions(-)

diff --git a/.github/scripts/bench-txgen-install.sh b/.github/scripts/bench-txgen-install.sh
index 384d0ed7c94..e3b2ced9180 100755
--- a/.github/scripts/bench-txgen-install.sh
+++ b/.github/scripts/bench-txgen-install.sh
@@ -2,14 +2,10 @@
 #
 # Installs the txgen tools used by the benchmark workflows.
 #
-# 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
@@ -31,5 +27,4 @@ elif [ -n "${TXGEN_TOKEN:-${GH_PROJECT_TOKEN:-${DEREK_PAT:-${DEREK_TOKEN:-}}}}"
 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
+cargo install --git "$TXGEN_REPO" --locked txgen-ethereum bench-cli
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 9b4e0428993..4c8dbc8f8b8 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -311,7 +311,6 @@ jobs:
       BENCH_NODE_BIN: reth
       BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
       BENCH_METRICS_ADDR: "127.0.0.1:9001"
-      TXGEN_REV: 5b04a80d557cc6658573db6ccf49ce04cbf07ea3
       BENCH_OTLP_DISABLED: "true"
       BASELINE_REF: ${{ needs.resolve-refs.outputs.baseline-ref }}
       FEATURE_REF: ${{ needs.resolve-refs.outputs.feature-ref }}
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 3fa03905c46..0426bcf3c81 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -631,7 +631,6 @@ jobs:
       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"
-      TXGEN_REV: f439eec4e0f6dbe0675dd3bac8192d9f0299d409
       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: ${{ secrets.BENCH_VICTORIAMETRICS_URL }}

From 08192b307ede19c473abc019215f7debbf2272a0 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 19 May 2026 03:09:09 -0700
Subject: [PATCH 168/335] fix(engine): correct backpressure default parsing
 (#24334)

Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
---
 crates/node/core/src/args/engine.rs    | 89 +++++++++++++++++++++++---
 docs/vocs/docs/pages/cli/reth/node.mdx |  4 +-
 2 files changed, 82 insertions(+), 11 deletions(-)

diff --git a/crates/node/core/src/args/engine.rs b/crates/node/core/src/args/engine.rs
index ab6536486b3..e1e08b28b32 100644
--- a/crates/node/core/src/args/engine.rs
+++ b/crates/node/core/src/args/engine.rs
@@ -295,6 +295,12 @@ impl Default for DefaultEngineValues {
     }
 }
 
+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 +316,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)]
@@ -544,7 +553,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,
@@ -577,7 +586,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,
@@ -621,12 +630,20 @@ 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!(
@@ -639,8 +656,8 @@ impl EngineArgs {
     /// 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)
@@ -696,6 +713,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]
@@ -703,7 +774,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,
@@ -795,7 +866,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()
         };
 
diff --git a/docs/vocs/docs/pages/cli/reth/node.mdx b/docs/vocs/docs/pages/cli/reth/node.mdx
index b9bb3c46db7..e688cd37c2d 100644
--- a/docs/vocs/docs/pages/cli/reth/node.mdx
+++ b/docs/vocs/docs/pages/cli/reth/node.mdx
@@ -971,9 +971,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

From 64ce7c12e7c451b1d302a961a7ef4711783a9d92 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 19 May 2026 12:29:15 +0200
Subject: [PATCH 169/335] chore(deps): bump the cargo-weekly group across 1
 directory with 13 updates (#24330)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 153 ++++++++++++++++++++++++++++++-----------------------
 Cargo.toml |  12 ++---
 2 files changed, 93 insertions(+), 72 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 94abe667406..1b72d8b4626 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -529,7 +529,7 @@ dependencies = [
  "lru",
  "parking_lot",
  "pin-project",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "serde",
  "serde_json",
  "thiserror 2.0.18",
@@ -598,7 +598,7 @@ dependencies = [
  "alloy-transport-ws",
  "futures",
  "pin-project",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "serde",
  "serde_json",
  "tokio",
@@ -937,7 +937,7 @@ dependencies = [
  "alloy-json-rpc",
  "alloy-transport",
  "itertools 0.14.0",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "serde_json",
  "tower",
  "tracing",
@@ -1443,9 +1443,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",
@@ -1734,9 +1734,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",
@@ -2147,9 +2147,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",
@@ -2504,9 +2504,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",
@@ -2518,9 +2518,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"
@@ -2970,9 +2970,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"
@@ -3531,6 +3531,17 @@ 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"
@@ -3542,7 +3553,7 @@ dependencies = [
  "clap",
  "eyre",
  "futures-util",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-ethereum",
  "serde",
  "serde_json",
@@ -3557,7 +3568,7 @@ dependencies = [
  "bytes",
  "clap",
  "futures-util",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-ethereum",
  "serde_json",
  "tokio",
@@ -4451,6 +4462,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"
@@ -5125,9 +5142,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",
@@ -5169,16 +5186,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "iri-string"
-version = "0.7.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25e659a4bb38e810ebc252e53b5814ff908a8c58c2a9ce2fae1bbec24cbf4e20"
-dependencies = [
- "memchr",
- "serde",
-]
-
 [[package]]
 name = "is-terminal"
 version = "0.4.17"
@@ -5633,11 +5640,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"
@@ -5934,12 +5952,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]]
@@ -5955,11 +5973,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",
@@ -5985,9 +6004,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",
@@ -5998,6 +6017,7 @@ dependencies = [
  "quanta",
  "rand 0.9.4",
  "rand_xoshiro",
+ "rapidhash",
  "sketches-ddsketch",
 ]
 
@@ -6695,18 +6715,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",
@@ -7490,9 +7510,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",
@@ -7685,7 +7705,7 @@ dependencies = [
  "eyre",
  "futures",
  "humantime",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-chainspec",
  "reth-cli",
  "reth-cli-runner",
@@ -7801,7 +7821,7 @@ dependencies = [
  "proptest-arbitrary-interop",
  "ratatui",
  "rayon",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-chainspec",
  "reth-cli",
  "reth-cli-runner",
@@ -7985,7 +8005,7 @@ dependencies = [
  "derive_more",
  "eyre",
  "futures",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-node-api",
  "reth-tracing",
  "ringbuffer",
@@ -8465,7 +8485,7 @@ dependencies = [
  "ethereum_ssz_derive",
  "eyre",
  "rand 0.9.4",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-era-downloader",
  "reth-ethereum-primitives",
  "sha2",
@@ -8485,7 +8505,7 @@ dependencies = [
  "eyre",
  "futures",
  "futures-util",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-era",
  "reth-fs-util",
  "sha2",
@@ -8503,7 +8523,7 @@ dependencies = [
  "bytes",
  "eyre",
  "futures-util",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-db-api",
  "reth-db-common",
  "reth-era",
@@ -9067,7 +9087,7 @@ version = "2.2.0"
 dependencies = [
  "futures-util",
  "if-addrs",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-tracing",
  "serde_with",
  "thiserror 2.0.18",
@@ -9406,7 +9426,7 @@ dependencies = [
  "jsonrpsee",
  "jsonrpsee-core",
  "rand 0.9.4",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-chainspec",
  "reth-db",
  "reth-e2e-test-utils",
@@ -9511,7 +9531,7 @@ dependencies = [
  "metrics-util",
  "pprof_util",
  "procfs",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-fs-util",
  "reth-metrics",
  "reth-tasks",
@@ -9916,7 +9936,7 @@ dependencies = [
  "jsonrpsee",
  "metrics",
  "pin-project",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-chain-state",
  "reth-chainspec",
  "reth-consensus",
@@ -10098,7 +10118,7 @@ dependencies = [
  "jsonrpsee-types",
  "metrics",
  "rand 0.9.4",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-chain-state",
  "reth-chainspec",
  "reth-db-models",
@@ -10137,7 +10157,7 @@ dependencies = [
  "jsonrpsee",
  "jsonrpsee-http-client",
  "pin-project",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "tokio",
  "tower",
  "tower-http",
@@ -10192,7 +10212,7 @@ dependencies = [
  "paste",
  "rand 0.9.4",
  "rayon",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "reth-chainspec",
  "reth-codecs",
  "reth-config",
@@ -11536,11 +11556,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",
@@ -11555,9 +11576,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",
@@ -12311,9 +12332,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",
@@ -12510,9 +12531,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",
@@ -12525,7 +12546,6 @@ dependencies = [
  "http-body-util",
  "http-range-header",
  "httpdate",
- "iri-string",
  "mime",
  "mime_guess",
  "percent-encoding",
@@ -12536,6 +12556,7 @@ dependencies = [
  "tower-layer",
  "tower-service",
  "tracing",
+ "url",
  "uuid",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index f013173ef48..f9294d17dc8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -552,16 +552,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"] }
@@ -575,7 +575,7 @@ 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"
+pin-project = "1.1.12"
 reqwest = { version = "0.13", default-features = false, features = ["rustls", "stream"] }
 tracing-futures = "0.2"
 tower = "0.5"
@@ -652,7 +652,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"
@@ -671,7 +671,7 @@ 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"

From 2b1eb37a5723df11c4ebaedc8f580b3ede784a83 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 19 May 2026 13:16:14 +0200
Subject: [PATCH 170/335] fix(rpc): suppress unstable engine capability
 warnings (#24338)

---
 crates/rpc/rpc-engine-api/src/capabilities.rs | 46 +++++++++++++++++--
 1 file changed, 42 insertions(+), 4 deletions(-)

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

From fc59451fc0d74339e195123c6dbd6bc138c295f3 Mon Sep 17 00:00:00 2001
From: Sebastian Stammler <seb@oplabs.co>
Date: Tue, 19 May 2026 13:18:43 +0200
Subject: [PATCH 171/335] fix(op): prioritize head over finalized as backfill
 target on OP Stack (#24159)

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/engine/tree/src/tree/mod.rs   | 164 +++++++++--------
 crates/engine/tree/src/tree/tests.rs | 255 +++++++++++++++++++++++++++
 2 files changed, 336 insertions(+), 83 deletions(-)

diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index e0bf3934b8c..cf0c814fbb5 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -1842,33 +1842,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
@@ -2524,85 +2524,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.
+    ///
+    /// 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) finalized block.
+    /// 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
diff --git a/crates/engine/tree/src/tree/tests.rs b/crates/engine/tree/src/tree/tests.rs
index 2af5f529e33..4d70ef50634 100644
--- a/crates/engine/tree/src/tree/tests.rs
+++ b/crates/engine/tree/src/tree/tests.rs
@@ -2325,3 +2325,258 @@ fn test_canonicalizing_downloaded_sync_target_head_updates_finalized() {
     );
     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;
+}

From fa88516558a7c41ceb19d4ecbece403153528706 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 19 May 2026 13:19:59 +0200
Subject: [PATCH 172/335] feat(rpc): add debug account state endpoints (#24296)

---
 crates/rpc/rpc-api/src/debug.rs          |  22 +++-
 crates/rpc/rpc-builder/tests/it/http.rs  |  16 +++
 crates/rpc/rpc/src/debug.rs              | 153 +++++++++++++++++++++--
 docs/vocs/docs/pages/jsonrpc/debug.mdx   |  16 +++
 docs/vocs/docs/pages/run/faq/pruning.mdx |   4 +
 5 files changed, 203 insertions(+), 8 deletions(-)

diff --git a/crates/rpc/rpc-api/src/debug.rs b/crates/rpc/rpc-api/src/debug.rs
index f7832e1b4ad..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,6 +162,26 @@ pub trait DebugApi<TxReq: RpcObject> {
         mode: Option<ExecutionWitnessMode>,
     ) -> RpcResult<ExecutionWitness>;
 
+    /// 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).
     ///
diff --git a/crates/rpc/rpc-builder/tests/it/http.rs b/crates/rpc/rpc-builder/tests/it/http.rs
index dc904bb98fa..9270b46717d 100644
--- a/crates/rpc/rpc-builder/tests/it/http.rs
+++ b/crates/rpc/rpc-builder/tests/it/http.rs
@@ -447,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/src/debug.rs b/crates/rpc/rpc/src/debug.rs
index d0e5b243989..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};
@@ -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(
@@ -831,6 +948,28 @@ where
         Self::debug_execution_witness_by_block_hash(self, hash, mode).await.map_err(Into::into)
     }
 
+    /// 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(
         &self,
         _block_number: BlockNumberOrTag,
diff --git a/docs/vocs/docs/pages/jsonrpc/debug.mdx b/docs/vocs/docs/pages/jsonrpc/debug.mdx
index a6541267e17..142fd622bc8 100644
--- a/docs/vocs/docs/pages/jsonrpc/debug.mdx
+++ b/docs/vocs/docs/pages/jsonrpc/debug.mdx
@@ -139,6 +139,22 @@ Similar to [`debug_executionWitness`](#debug_executionwitness), but accepts a bl
 | ------ | ---------------------------------------------------------------------- |
 | RPC    | `{"method": "debug_executionWitnessByBlockHash", "params": [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, without the storage root, after replaying a block through the transaction at the given index.
+
+| Client | Method invocation                                                       |
+| ------ | ----------------------------------------------------------------------- |
+| RPC    | `{"method": "debug_accountInfoAt", "params": [block_id, tx_index, address]}` |
+
 ## `debug_dbGet`
 
 Retrieves a raw value from the database.
diff --git a/docs/vocs/docs/pages/run/faq/pruning.mdx b/docs/vocs/docs/pages/run/faq/pruning.mdx
index 4aac4ff542e..dd3ec416500 100644
--- a/docs/vocs/docs/pages/run/faq/pruning.mdx
+++ b/docs/vocs/docs/pages/run/faq/pruning.mdx
@@ -146,6 +146,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`                       |                                                            |
@@ -257,6 +259,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`                       | ✅              | ✅                 | ✅       | ✅              | ✅              |

From 81c026181e96ef33a823f3ef4d2a28940e9fa4fe Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 19 May 2026 04:49:41 -0700
Subject: [PATCH 173/335] ci: enable bench OTLP exports by default (#24344)

---
 .github/scripts/bench-txgen-build.sh  | 9 ++++++++-
 .github/workflows/bench-scheduled.yml | 3 ++-
 .github/workflows/bench.yml           | 6 +++---
 3 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/.github/scripts/bench-txgen-build.sh b/.github/scripts/bench-txgen-build.sh
index 4c040558064..12f0443c160 100755
--- a/.github/scripts/bench-txgen-build.sh
+++ b/.github/scripts/bench-txgen-build.sh
@@ -23,8 +23,15 @@ fi
 
 EXTRA_FEATURES=""
 EXTRA_RUSTFLAGS=""
+if [ "${BENCH_OTLP_DISABLED:-false}" != "true" ]; then
+  EXTRA_FEATURES="otlp,otlp-logs"
+fi
 if [ "${BENCH_TRACY:-off}" != "off" ]; then
-  EXTRA_FEATURES="tracy,tracy-client/ondemand"
+  if [ -n "$EXTRA_FEATURES" ]; then
+    EXTRA_FEATURES="${EXTRA_FEATURES},tracy,tracy-client/ondemand"
+  else
+    EXTRA_FEATURES="tracy,tracy-client/ondemand"
+  fi
   EXTRA_RUSTFLAGS=" -C force-frame-pointers=yes"
 fi
 
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 4c8dbc8f8b8..77063ab72a0 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -311,7 +311,8 @@ jobs:
       BENCH_NODE_BIN: reth
       BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
       BENCH_METRICS_ADDR: "127.0.0.1:9001"
-      BENCH_OTLP_DISABLED: "true"
+      BENCH_OTLP_TRACES_ENDPOINT: ${{ secrets.BENCH_OTLP_TRACES_ENDPOINT }}
+      BENCH_OTLP_LOGS_ENDPOINT: ${{ 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 }}
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 0426bcf3c81..dfb11f87cce 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -89,7 +89,7 @@ on:
       otlp:
         description: "Export OTLP traces and logs"
         required: false
-        default: "false"
+        default: "true"
         type: boolean
 
 env:
@@ -223,7 +223,7 @@ jobs:
               bal = '${{ github.event.inputs.bal }}' || 'false';
               var runPairs = '${{ github.event.inputs.run_pairs }}' || '';
               explicitRunPairs = runPairs !== '';
-              var otlp = '${{ github.event.inputs.otlp }}' === 'true' ? 'true' : 'false';
+              var otlp = '${{ github.event.inputs.otlp }}' === 'false' ? 'false' : 'true';
               var waitTime = '${{ github.event.inputs.wait_time }}' || '';
               var baselineNodeArgs = '${{ github.event.inputs.baseline_args }}' || '';
               var featureNodeArgs = '${{ github.event.inputs.feature_args }}' || '';
@@ -252,7 +252,7 @@ jobs:
               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: '', warmup: '', baseline: '', feature: '', samply: 'false', slack: 'always', 'big-blocks': 'false', bal: 'false', cores: '0', 'run-pairs': '', otlp: 'false', 'wait-time': '', 'baseline-args': '', 'feature-args': '' };
+              const defaults = { blocks: '', warmup: '', baseline: '', feature: '', samply: 'false', slack: 'always', 'big-blocks': 'false', bal: 'false', cores: '0', 'run-pairs': '', otlp: 'true', 'wait-time': '', 'baseline-args': '', 'feature-args': '' };
               const unknown = [];
               const invalid = [];
               const args = body.replace(/^(?:@decofe|derek) bench\s*/, '');

From bd3544e61d2ec8feaf5823c6543fe4932c187b3c Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 19 May 2026 06:59:18 -0700
Subject: [PATCH 174/335] feat: derive OTLP auth from endpoint URL credentials
 (#24346)

---
 .github/workflows/bench.yml    |  21 +++++
 Cargo.lock                     |   1 +
 crates/tracing-otlp/Cargo.toml |   1 +
 crates/tracing-otlp/src/lib.rs | 135 ++++++++++++++++++++++++++++++++-
 4 files changed, 156 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index dfb11f87cce..48880e82382 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -718,6 +718,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 }}
diff --git a/Cargo.lock b/Cargo.lock
index 1b72d8b4626..b40835b16bd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10486,6 +10486,7 @@ dependencies = [
 name = "reth-tracing-otlp"
 version = "2.2.0"
 dependencies = [
+ "base64 0.22.1",
  "clap",
  "eyre",
  "opentelemetry",
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 f4c24adb1ee..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.
 ///
@@ -139,10 +143,11 @@ impl OtlpConfig {
             );
         }
 
+        set_otlp_auth_header_from_endpoint(&endpoint, OTEL_EXPORTER_OTLP_TRACES_HEADERS)?;
         Ok(Self {
             service_name: service_name.into(),
             service_version: None,
-            endpoint,
+            endpoint: endpoint_without_credentials(endpoint),
             protocol,
             sample_ratio,
         })
@@ -195,7 +200,13 @@ impl OtlpLogsConfig {
         endpoint: Url,
         protocol: OtlpProtocol,
     ) -> eyre::Result<Self> {
-        Ok(Self { service_name: service_name.into(), service_version: None, 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.
@@ -229,6 +240,55 @@ fn build_resource(service_name: impl Into<Value>, service_version: Option<&str>)
         .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 {
@@ -287,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());
+    }
+}

From f6f623c66b96d2c97b966e247bdda77990d10ec3 Mon Sep 17 00:00:00 2001
From: Emma Jamieson-Hoare <emmajam@users.noreply.github.com>
Date: Tue, 19 May 2026 17:24:36 +0100
Subject: [PATCH 175/335] docs: promote storage mode docs (#24351)

---
 docs/vocs/docs/pages/run/ethereum.mdx         |   2 +-
 .../docs/pages/run/ethereum/snapshots.mdx     |   1 -
 docs/vocs/docs/pages/run/faq.mdx              |   9 +-
 docs/vocs/docs/pages/run/faq/storage-v2.mdx   |  73 ---------
 docs/vocs/docs/pages/run/overview.mdx         |   5 +-
 docs/vocs/docs/pages/run/storage.mdx          |  96 +++++++++++
 docs/vocs/docs/pages/run/storage/minimal.mdx  |  64 ++++++++
 .../pages/run/{faq => storage}/pruning.mdx    | 150 +++++++-----------
 .../vocs/docs/pages/run/storage/snapshots.mdx |  69 ++++++++
 docs/vocs/redirects.config.ts                 |  10 +-
 docs/vocs/sidebar.ts                          |  37 +++--
 11 files changed, 328 insertions(+), 188 deletions(-)
 delete mode 100644 docs/vocs/docs/pages/run/ethereum/snapshots.mdx
 delete mode 100644 docs/vocs/docs/pages/run/faq/storage-v2.mdx
 create mode 100644 docs/vocs/docs/pages/run/storage.mdx
 create mode 100644 docs/vocs/docs/pages/run/storage/minimal.mdx
 rename docs/vocs/docs/pages/run/{faq => storage}/pruning.mdx (81%)
 create mode 100644 docs/vocs/docs/pages/run/storage/snapshots.mdx

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 81%
rename from docs/vocs/docs/pages/run/faq/pruning.mdx
rename to docs/vocs/docs/pages/run/storage/pruning.mdx
index dd3ec416500..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
 
@@ -156,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                             |
@@ -182,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`            |                                                            |
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/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/sidebar.ts b/docs/vocs/sidebar.ts
index a52bcebddbd..957582dabf5 100644
--- a/docs/vocs/sidebar.ts
+++ b/docs/vocs/sidebar.ts
@@ -73,12 +73,6 @@ export const sidebar: SidebarItem[] = [
                             {
                                 text: "Ethereum",
                                 link: "/run/ethereum",
-                                // items: [
-                                //     {
-                                //         text: "Snapshots",
-                                //         link: "/run/ethereum/snapshots"
-                                //     }
-                                // ]
                             },
                             {
                                 text: "Private testnets",
@@ -86,6 +80,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 +120,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 +255,4 @@ export const sidebar: SidebarItem[] = [
             rethCliSidebar
         ]
     },
-]
\ No newline at end of file
+]

From ee2a466031090c2a5db8e892d6cd60f46deb21e4 Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Tue, 19 May 2026 18:35:00 +0200
Subject: [PATCH 176/335] fix(bench): reduce noisy big-block verdicts (#24340)

Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
---
 .github/scripts/bench-reth-summary.py | 82 ++++++++++++++++++++++++---
 .github/scripts/bench-slack-notify.js |  2 +-
 .github/scripts/bench-utils.js        |  6 +-
 .github/workflows/bench.yml           |  4 +-
 4 files changed, 81 insertions(+), 13 deletions(-)

diff --git a/.github/scripts/bench-reth-summary.py b/.github/scripts/bench-reth-summary.py
index 1f6e935e7aa..95e44462ae8 100755
--- a/.github/scripts/bench-reth-summary.py
+++ b/.github/scripts/bench-reth-summary.py
@@ -27,6 +27,9 @@
 import sys
 
 BOOTSTRAP_ITERATIONS = 10_000
+P99_MIN_VERDICT_BLOCKS = 125
+PERSIST_WAIT_MIN_VERDICT_MS = 0.5
+PERSIST_WAIT_MIN_TOTAL_PCT = 0.1
 PRACTICAL_FLOOR_PCT = {
     "mean": 0.70,
     "p50": 0.70,
@@ -124,6 +127,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 = []
@@ -385,14 +406,51 @@ def significance(pct: float, ci_pct: float, floor_pct: float, lower_is_better: b
     return "neutral"
 
 
-def change_str(pct: float, ci_pct: float, floor_pct: float, lower_is_better: bool) -> str:
+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,
+    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, floor_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}%, floor {floor_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(
@@ -419,12 +477,18 @@ def ci_pct(ci_ms: float, base_ms: float) -> float:
         p = pct(baseline_stats[stat_key], feature_stats[stat_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),
             "floor_pct": round(floor, 4),
-            "sig": significance(p, c, floor, lower_is_better),
+            "sig": "neutral" if informational else sig,
         }
+        if informational:
+            changes[name]["informational"] = True
+            changes[name]["informational_reason"] = informational
+            changes[name]["raw_sig"] = sig
     return changes
 
 
@@ -477,6 +541,8 @@ def pct(base: float, feat: float) -> float:
     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})"
@@ -488,10 +554,10 @@ def pct(base: float, feat: float) -> float:
         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)} |",
+        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)} |",
+        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'}"]
@@ -613,8 +679,8 @@ def main():
     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)
+    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 ci_stats:
diff --git a/.github/scripts/bench-slack-notify.js b/.github/scripts/bench-slack-notify.js
index ae71c439048..6feb03ea399 100644
--- a/.github/scripts/bench-slack-notify.js
+++ b/.github/scripts/bench-slack-notify.js
@@ -238,7 +238,7 @@ async function success({ core, context }) {
   let postedToChannel = false;
   if (channel) {
     const changes = summary.changes || {};
-    const hasImprovement = Object.values(changes).some(c => c.sig === 'good');
+    const hasImprovement = Object.values(changes).some(c => !c.informational && c.sig === 'good');
     if (hasImprovement) {
       await postToSlack(token, channel, blocks, text, core);
       postedToChannel = true;
diff --git a/.github/scripts/bench-utils.js b/.github/scripts/bench-utils.js
index 1b99adb1fb0..5ae3412e264 100644
--- a/.github/scripts/bench-utils.js
+++ b/.github/scripts/bench-utils.js
@@ -17,12 +17,14 @@ function fmtChange(ch) {
   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.informational) details.push('informational');
   const detailStr = details.length ? ` (${details.join(', ')})` : '';
-  return `${pctStr}${detailStr} ${SIG_EMOJI[ch.sig]}`;
+  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' };
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 48880e82382..cf15de66ea5 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -12,7 +12,7 @@ on:
   workflow_dispatch:
     inputs:
       blocks:
-        description: "Number of blocks to benchmark (default: 500, big blocks: 65)"
+        description: "Number of blocks to benchmark (default: 500, big blocks: 30)"
         required: false
         default: ""
         type: string
@@ -191,7 +191,7 @@ jobs:
               if (/^\d+([kKmMgG])?$/.test(value)) return { enabled: 'true', targetGas: value };
               return null;
             };
-            const defaultBlocks = (isBigBlocks) => isBigBlocks ? '65' : '500';
+            const defaultBlocks = (isBigBlocks) => isBigBlocks ? '30' : '500';
             const defaultWarmup = (blockCount) => String(Math.floor(Number(blockCount) / 4));
             const defaultRunPairs = (isBigBlocks) => isBigBlocks ? '10' : '6';
             const benchRunOrder = (runPairs) => {

From d1ef639fbfffa02f117594eb5540834446c0dfe8 Mon Sep 17 00:00:00 2001
From: tempoxyz-bot <github-svc@tempo.xyz>
Date: Tue, 19 May 2026 21:04:53 +0200
Subject: [PATCH 177/335] perf: branch cached storage zero checks (#24341)

Co-authored-by: autoopt[bot] <autoopt@tempo.xyz>
Co-authored-by: Amp <amp@ampcode.com>
---
 crates/engine/execution-cache/src/cached_state.rs | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/crates/engine/execution-cache/src/cached_state.rs b/crates/engine/execution-cache/src/cached_state.rs
index ca7fba04934..4475d71849c 100644
--- a/crates/engine/execution-cache/src/cached_state.rs
+++ b/crates/engine/execution-cache/src/cached_state.rs
@@ -465,6 +465,15 @@ impl<S: AccountReader, const PREWARM: bool> AccountReader for CachedStateProvide
     }
 }
 
+#[inline]
+fn nonzero_storage_value(value: StorageValue) -> Option<StorageValue> {
+    if value.is_zero() {
+        None
+    } else {
+        Some(value)
+    }
+}
+
 impl<S: StateProvider, const PREWARM: bool> StateProvider for CachedStateProvider<S, PREWARM> {
     fn storage(
         &self,
@@ -480,13 +489,13 @@ impl<S: StateProvider, const PREWARM: bool> StateProvider for CachedStateProvide
                     if let Some(stats) = &self.cache_stats {
                         stats.record_storage_miss();
                     }
-                    Ok(Some(value).filter(|v| !v.is_zero()))
+                    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()))
+                    Ok(nonzero_storage_value(value))
                 }
             }
         } else if let Some(value) = self.caches.0.storage_cache.get(&(account, storage_key)) {
@@ -494,7 +503,7 @@ impl<S: StateProvider, const PREWARM: bool> StateProvider for CachedStateProvide
             if let Some(stats) = &self.cache_stats {
                 stats.record_storage_hit();
             }
-            Ok(Some(value).filter(|v| !v.is_zero()))
+            Ok(nonzero_storage_value(value))
         } else {
             self.metrics.storage_cache_misses.increment(1);
             if let Some(stats) = &self.cache_stats {

From cae229f0d5f6b67199af22a31e9fca193fb958da Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Wed, 20 May 2026 00:37:15 +0400
Subject: [PATCH 178/335] fix(bench): don't enable otlp features (#24356)

---
 .github/scripts/bench-txgen-build.sh | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/.github/scripts/bench-txgen-build.sh b/.github/scripts/bench-txgen-build.sh
index 12f0443c160..4c040558064 100755
--- a/.github/scripts/bench-txgen-build.sh
+++ b/.github/scripts/bench-txgen-build.sh
@@ -23,15 +23,8 @@ fi
 
 EXTRA_FEATURES=""
 EXTRA_RUSTFLAGS=""
-if [ "${BENCH_OTLP_DISABLED:-false}" != "true" ]; then
-  EXTRA_FEATURES="otlp,otlp-logs"
-fi
 if [ "${BENCH_TRACY:-off}" != "off" ]; then
-  if [ -n "$EXTRA_FEATURES" ]; then
-    EXTRA_FEATURES="${EXTRA_FEATURES},tracy,tracy-client/ondemand"
-  else
-    EXTRA_FEATURES="tracy,tracy-client/ondemand"
-  fi
+  EXTRA_FEATURES="tracy,tracy-client/ondemand"
   EXTRA_RUSTFLAGS=" -C force-frame-pointers=yes"
 fi
 

From 60b3f313800dca1af11bdad9681937cfa606939e Mon Sep 17 00:00:00 2001
From: DaniPopes <57450786+DaniPopes@users.noreply.github.com>
Date: Wed, 20 May 2026 01:16:56 +0200
Subject: [PATCH 179/335] fix(ci): correct bench Grafana range (#24358)

---
 .github/workflows/bench-scheduled.yml | 3 +--
 .github/workflows/bench.yml           | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 77063ab72a0..ca59845a513 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -598,9 +598,8 @@ jobs:
         id: metrics
         if: "!cancelled()"
         run: |
-          LAST_RUN_DURATION=$(( $(date +%s) - BENCH_LAST_RUN_START ))
           FROM_MS=$(( BENCH_REFERENCE_EPOCH * 1000 ))
-          TO_MS=$(( (BENCH_REFERENCE_EPOCH + LAST_RUN_DURATION) * 1000 ))
+          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}"
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index cf15de66ea5..253336b5ada 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -1097,9 +1097,8 @@ jobs:
         id: metrics
         if: "!cancelled()"
         run: |
-          LAST_RUN_DURATION=$(( $(date +%s) - ${BENCH_LAST_RUN_START:-$BENCH_REFERENCE_EPOCH} ))
           FROM_MS=$(( BENCH_REFERENCE_EPOCH * 1000 ))
-          TO_MS=$(( (BENCH_REFERENCE_EPOCH + LAST_RUN_DURATION) * 1000 ))
+          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}"

From 0cf3c7e9e433ae15e9b5fd0f0a40386aa555d5c9 Mon Sep 17 00:00:00 2001
From: tempoxyz-bot <github-svc@tempo.xyz>
Date: Wed, 20 May 2026 08:20:52 +0200
Subject: [PATCH 180/335] perf: gate per-transaction execution spans (#24311)

Co-authored-by: autoopt[bot] <autoopt@tempo.xyz>
Co-authored-by: Amp <amp@ampcode.com>
---
 .../engine/tree/src/tree/payload_validator.rs | 20 +++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index aff8c264d3f..19b6748bc00 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -101,7 +101,7 @@ 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};
 
 pub use crate::tree::types::ValidationOutcome;
 
@@ -1211,13 +1211,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::DEBUG).then(|| {
+                debug_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)?;

From 5363ac9786ecb8caaf8b8fd995066c6c1d5a48a6 Mon Sep 17 00:00:00 2001
From: Ivan Wang <wff19940326@gmail.com>
Date: Wed, 20 May 2026 14:44:15 +0800
Subject: [PATCH 181/335] fix(trie): accept B256::ZERO as non-existent account
 in from_eip1186_proof (#24359)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/trie/common/src/proofs.rs | 51 ++++++++++++++++++++++++++++++--
 1 file changed, 49 insertions(+), 2 deletions(-)

diff --git a/crates/trie/common/src/proofs.rs b/crates/trie/common/src/proofs.rs
index 6a8adbc621a..f6e54a56ab0 100644
--- a/crates/trie/common/src/proofs.rs
+++ b/crates/trie/common/src/proofs.rs
@@ -768,11 +768,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 +1215,47 @@ 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]
     fn test_multiproof_targets_chunking_length() {
         let mut targets = MultiProofTargets::default();

From 192c7824b6f375adc253df249128d04c63ad8576 Mon Sep 17 00:00:00 2001
From: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
Date: Wed, 20 May 2026 12:44:02 +0530
Subject: [PATCH 182/335] chore: added custody_columns to fcuv4 (#24245)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/rpc/rpc-api/src/engine.rs            | 10 ++++++++++
 crates/rpc/rpc-engine-api/src/engine_api.rs |  9 +++++++--
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/crates/rpc/rpc-api/src/engine.rs b/crates/rpc/rpc-api/src/engine.rs
index 3c3e46d66c5..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>
diff --git a/crates/rpc/rpc-engine-api/src/engine_api.rs b/crates/rpc/rpc-engine-api/src/engine_api.rs
index 0638fda44ea..e6a509ce7c3 100644
--- a/crates/rpc/rpc-engine-api/src/engine_api.rs
+++ b/crates/rpc/rpc-engine-api/src/engine_api.rs
@@ -385,6 +385,7 @@ where
         &self,
         state: ForkchoiceState,
         payload_attrs: Option<EngineT::PayloadAttributes>,
+        _custody_columns: Option<B128>,
     ) -> EngineApiResult<ForkchoiceUpdated> {
         self.validate_and_execute_forkchoice(EngineApiMessageVersion::V4, state, payload_attrs)
             .await
@@ -395,9 +396,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
     }
@@ -1277,9 +1279,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`

From cdb02a5bc708759058924942aece2d5a2c826129 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 20 May 2026 10:39:14 +0200
Subject: [PATCH 183/335] docs(net): clarify eth/72 cell mask (#24363)

---
 crates/net/eth-wire-types/src/broadcast.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/crates/net/eth-wire-types/src/broadcast.rs b/crates/net/eth-wire-types/src/broadcast.rs
index 07a3a3a97bc..a599a72a676 100644
--- a/crates/net/eth-wire-types/src/broadcast.rs
+++ b/crates/net/eth-wire-types/src/broadcast.rs
@@ -584,7 +584,8 @@ impl Decodable for NewPooledTransactionHashes68 {
     }
 }
 
-/// Same as [`NewPooledTransactionHashes68`] but adds cell mask of B128.
+/// 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 {
@@ -601,7 +602,12 @@ pub struct NewPooledTransactionHashes72 {
     pub sizes: Vec<usize>,
     /// Transaction hashes for new transactions that have appeared on the network.
     pub hashes: Vec<B256>,
-    /// Cell mask for new transactions that have appeared on the network.
+    /// 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>,
 }
 

From 1be17ebbb695f6e9d0b6bb2f59314a5ce039715f Mon Sep 17 00:00:00 2001
From: Alexey Shekhirin <github@shekhirin.com>
Date: Wed, 20 May 2026 11:36:12 +0100
Subject: [PATCH 184/335] feat(node): add pruning mode to startup log (#24367)

---
 crates/node/builder/src/launch/engine.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/crates/node/builder/src/launch/engine.rs b/crates/node/builder/src/launch/engine.rs
index 7e39de7f538..0dbd65017c2 100644
--- a/crates/node/builder/src/launch/engine.rs
+++ b/crates/node/builder/src/launch/engine.rs
@@ -25,6 +25,7 @@ use reth_node_api::{
     BuiltPayload, ConsensusEngineHandle, FullNodeTypes, NodeTypes, NodeTypesWithDBAdapter,
 };
 use reth_node_core::{
+    args::PruneConfigKind,
     dirs::{ChainPath, DataDirPath},
     exit::NodeExitFuture,
     primitives::Head,
@@ -115,7 +116,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

From d4ac2a5fb433a72a6124aefe2e97b9f8ed1d9d6f Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 20 May 2026 14:54:57 +0200
Subject: [PATCH 185/335] perf: use B256Map for hash-keyed maps (#24372)

---
 crates/engine/tree/src/tree/mod.rs           |  8 ++++----
 crates/transaction-pool/src/pool/listener.rs | 10 ++++++----
 crates/transaction-pool/src/traits.rs        | 10 ++++++----
 3 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index cf0c814fbb5..a42fc60523e 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -7,7 +7,7 @@ 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,
 };
@@ -40,7 +40,7 @@ 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::{
@@ -315,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,
@@ -409,7 +409,7 @@ where
             engine_kind,
             evm_config,
             changeset_cache,
-            execution_timing_stats: HashMap::new(),
+            execution_timing_stats: B256Map::default(),
             building_payload: false,
             runtime,
         }
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/traits.rs b/crates/transaction-pool/src/traits.rs
index 4547fb3e9d4..e684c3e79d5 100644
--- a/crates/transaction-pool/src/traits.rs
+++ b/crates/transaction-pool/src/traits.rs
@@ -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,
@@ -830,7 +832,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 +858,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()

From c52c4b0e5b549bf4cef1a7f64f3ff0610abf725b Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Wed, 20 May 2026 06:13:58 -0700
Subject: [PATCH 186/335] ci: show bench workflow config in Slack notifications
 (#24373)

---
 .github/scripts/bench-slack-notify.js | 36 ++++++++++++++++++++++++---
 1 file changed, 33 insertions(+), 3 deletions(-)

diff --git a/.github/scripts/bench-slack-notify.js b/.github/scripts/bench-slack-notify.js
index 6feb03ea399..f81835f8827 100644
--- a/.github/scripts/bench-slack-notify.js
+++ b/.github/scripts/bench-slack-notify.js
@@ -80,6 +80,32 @@ const SLACK_VERDICT = {
   '⚪': ':white_circle:',
 };
 
+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('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 }) {
   const { emoji, label } = verdict(summary.changes);
   const headerEmoji = SLACK_VERDICT[emoji] || emoji;
@@ -105,6 +131,7 @@ function buildSuccessBlocks({ summary, prNumber, actor, actorSlackId, jobUrl, re
   if (featureProfiles.length) featureLine += ` | ${featureProfiles.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 || '';
@@ -112,7 +139,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}`;
@@ -176,6 +205,7 @@ function buildFailureBlocks({ prNumber, actor, actorSlackId, jobUrl, repo, faile
     `by ${actorMention}`,
     `failed while *${failedStep}*`,
   ].filter(Boolean);
+  const configLine = benchConfigLine();
 
   const buttons = [
     {
@@ -193,7 +223,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',
@@ -296,4 +326,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 };

From 6c3fe54b2ab3ec099b81f2a38287969478c12830 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 20 May 2026 15:40:16 +0200
Subject: [PATCH 187/335] fix: enforce secp256k1 feature propagation (#24365)

---
 .config/zepter.yaml         | 2 +-
 crates/net/peers/Cargo.toml | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

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

From 98a7c2dd81a98721e6a0b600172c4d3195b58da7 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Wed, 20 May 2026 06:41:31 -0700
Subject: [PATCH 188/335] ci: checkout PR repo for bench comments (#24374)

---
 .github/workflows/bench.yml | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 253336b5ada..370e75ff785 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -136,6 +136,7 @@ jobs:
       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'
@@ -397,6 +398,7 @@ jobs:
               });
               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 }}';
@@ -612,6 +614,7 @@ jobs:
       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 }}
@@ -644,6 +647,7 @@ jobs:
         with:
           script: |
             if (!process.env.BENCH_PR) {
+              core.setOutput('repository', '${{ github.repository }}');
               core.setOutput('ref', '${{ github.ref }}');
               return;
             }
@@ -652,11 +656,14 @@ jobs:
               core.setFailed('BENCH_PR_HEAD_SHA is not set — ack job must pin the PR head SHA');
               return;
             }
-            core.info(`PR #${process.env.BENCH_PR}, using pinned head SHA ${sha}`);
+            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

From c4a54bbe48eb1907ecc874961096dc58b687931f Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Wed, 20 May 2026 06:44:40 -0700
Subject: [PATCH 189/335] ci: disable OTLP for release benches (#24369)

---
 .github/workflows/bench.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 370e75ff785..02e3e3985a3 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -387,6 +387,11 @@ jobs:
               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;

From 5568b76d59aa157c9dc90ca629d18275840a2881 Mon Sep 17 00:00:00 2001
From: onbjerg <onbjerg@users.noreply.github.com>
Date: Wed, 20 May 2026 15:52:00 +0200
Subject: [PATCH 190/335] chore(bench): remove reth-bench (#24288)

Co-authored-by: Derek <256792747+decofe@users.noreply.github.com>
---
 .github/CODEOWNERS                            |   1 -
 .github/scripts/check_wasm.sh                 |   1 -
 .github/workflows/e2e.yml                     |   1 -
 .github/workflows/integration.yml             |   2 +-
 .github/workflows/lint.yml                    |   2 +-
 .github/workflows/unit.yml                    |   2 +-
 Cargo.lock                                    | 113 ---
 Cargo.toml                                    |   2 -
 Makefile                                      |  12 -
 README.md                                     |   2 +-
 bin/reth-bb/README.md                         |  48 +-
 bin/reth-bench/Cargo.toml                     | 142 ----
 bin/reth-bench/README.md                      | 159 ----
 .../scripts/compare_newpayload_latency.py     | 384 ---------
 bin/reth-bench/src/authenticated_transport.rs | 257 ------
 bin/reth-bench/src/bench/context.rs           | 264 ------
 .../src/bench/generate_big_block.rs           | 782 ------------------
 bin/reth-bench/src/bench/helpers.rs           | 154 ----
 bin/reth-bench/src/bench/metrics_scraper.rs   | 156 ----
 bin/reth-bench/src/bench/mod.rs               | 112 ---
 bin/reth-bench/src/bench/new_payload_fcu.rs   | 776 -----------------
 bin/reth-bench/src/bench/new_payload_only.rs  | 238 ------
 bin/reth-bench/src/bench/output.rs            | 318 -------
 .../send_invalid_payload/invalidation.rs      | 250 ------
 .../src/bench/send_invalid_payload/mod.rs     | 401 ---------
 bin/reth-bench/src/bench/send_payload.rs      | 180 ----
 bin/reth-bench/src/bench_mode.rs              |  49 --
 bin/reth-bench/src/main.rs                    |  44 -
 bin/reth-bench/src/valid_payload.rs           | 495 -----------
 crates/e2e-test-utils/src/testsuite/README.md |   1 -
 crates/node/core/src/args/benchmark_args.rs   | 329 --------
 crates/node/core/src/args/mod.rs              |   4 -
 32 files changed, 33 insertions(+), 5648 deletions(-)
 delete mode 100644 bin/reth-bench/Cargo.toml
 delete mode 100644 bin/reth-bench/README.md
 delete mode 100755 bin/reth-bench/scripts/compare_newpayload_latency.py
 delete mode 100644 bin/reth-bench/src/authenticated_transport.rs
 delete mode 100644 bin/reth-bench/src/bench/context.rs
 delete mode 100644 bin/reth-bench/src/bench/generate_big_block.rs
 delete mode 100644 bin/reth-bench/src/bench/helpers.rs
 delete mode 100644 bin/reth-bench/src/bench/metrics_scraper.rs
 delete mode 100644 bin/reth-bench/src/bench/mod.rs
 delete mode 100644 bin/reth-bench/src/bench/new_payload_fcu.rs
 delete mode 100644 bin/reth-bench/src/bench/new_payload_only.rs
 delete mode 100644 bin/reth-bench/src/bench/output.rs
 delete mode 100644 bin/reth-bench/src/bench/send_invalid_payload/invalidation.rs
 delete mode 100644 bin/reth-bench/src/bench/send_invalid_payload/mod.rs
 delete mode 100644 bin/reth-bench/src/bench/send_payload.rs
 delete mode 100644 bin/reth-bench/src/bench_mode.rs
 delete mode 100644 bin/reth-bench/src/main.rs
 delete mode 100644 bin/reth-bench/src/valid_payload.rs
 delete mode 100644 crates/node/core/src/args/benchmark_args.rs

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/scripts/check_wasm.sh b/.github/scripts/check_wasm.sh
index c94e458677e..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
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/integration.yml b/.github/workflows/integration.yml
index f6303710c55..576d36dcf47 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)"
 
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 076a7a7fee9..87dcc085f89 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:
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/Cargo.lock b/Cargo.lock
index b40835b16bd..17e8bbe0b80 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -510,7 +510,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",
@@ -2424,33 +2423,6 @@ dependencies = [
  "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"
@@ -2812,27 +2784,6 @@ dependencies = [
  "hybrid-array",
 ]
 
-[[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"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "ctr"
 version = "0.9.2"
@@ -6532,12 +6483,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[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"
@@ -7680,54 +7625,6 @@ dependencies = [
  "tracing",
 ]
 
-[[package]]
-name = "reth-bench"
-version = "2.2.0"
-dependencies = [
- "alloy-consensus",
- "alloy-eip7928",
- "alloy-eips 2.0.5",
- "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.3",
- "reth-chainspec",
- "reth-cli",
- "reth-cli-runner",
- "reth-cli-util",
- "reth-engine-primitives",
- "reth-ethereum-cli",
- "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",
- "tokio-stream",
- "tower",
- "tracing",
- "url",
-]
-
 [[package]]
 name = "reth-chain-state"
 version = "2.2.0"
@@ -12619,16 +12516,6 @@ dependencies = [
  "valuable",
 ]
 
-[[package]]
-name = "tracing-error"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b1581020d7a273442f5b45074a6a57d5757ad0a47dac0e9f0bd57b81936f3db"
-dependencies = [
- "tracing",
- "tracing-subscriber 0.3.23",
-]
-
 [[package]]
 name = "tracing-futures"
 version = "0.2.5"
diff --git a/Cargo.toml b/Cargo.toml
index f9294d17dc8..9501a7b6efe 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,7 +10,6 @@ exclude = [".github/"]
 [workspace]
 members = [
     "bin/reth-bb/",
-    "bin/reth-bench/",
     "bin/reth/",
     "crates/storage/rpc-provider/",
     "crates/chain-state/",
@@ -320,7 +319,6 @@ 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" }
diff --git a/Makefile b/Makefile
index 65db2e6d8b3..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
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/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-bench/Cargo.toml b/bin/reth-bench/Cargo.toml
deleted file mode 100644
index 99a76e0a442..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-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"] }
-tokio-stream.workspace = true
-
-# 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 f44245e82b0..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-trace-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 1a1f97bbce1..00000000000
--- a/bin/reth-bench/src/bench/context.rs
+++ /dev/null
@@ -1,264 +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::generate_big_block::BigBlocksInitialState, bench_mode::BenchMode,
-};
-use alloy_eips::BlockNumberOrTag;
-use alloy_primitives::B256;
-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 futures::{stream, StreamExt, TryStreamExt};
-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,
-    /// Initial state for generated big blocks.
-    pub(crate) big_blocks_initial_state: Option<BigBlocksInitialState>,
-}
-
-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 mut big_blocks_initial_state = None;
-        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.big_blocks.is_some() && bench_args.from.is_none() {
-            let (from, initial_state) =
-                derive_big_blocks_initial_state(&auth_provider, &block_provider).await?;
-            big_blocks_initial_state = initial_state;
-
-            (Some(from), bench_args.to)
-        } 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,
-            big_blocks_initial_state,
-        })
-    }
-}
-
-/// Derives the initial state for big blocks benchmark from RPC of the local node.
-async fn derive_big_blocks_initial_state(
-    local_provider: &RootProvider<AnyNetwork>,
-    source_provider: &RootProvider<AnyNetwork>,
-) -> eyre::Result<(u64, Option<BigBlocksInitialState>)> {
-    let local_head = local_provider
-        .get_block_by_number(BlockNumberOrTag::Latest)
-        .full()
-        .await?
-        .ok_or_else(|| eyre::eyre!("Failed to fetch latest block from engine"))?;
-
-    let local_head_number = local_head.header.number;
-    let local_head_hash = local_head.header.hash;
-
-    let source_block_at_local_head = source_provider
-        .get_block_by_number(local_head_number.into())
-        .await?
-        .ok_or_else(|| eyre::eyre!("Failed to fetch block {local_head_number} from RPC"))?;
-
-    // Node's tip is not synthetic, no initial state needed
-    if source_block_at_local_head.header.number == local_head_number &&
-        source_block_at_local_head.header.hash == local_head_hash
-    {
-        return Ok((local_head_number, None));
-    }
-
-    // If the tip is synthetic, derive last regular block from the last transaction the node has.
-    let last_regular_block = if let Some(tx_hash) = local_head.transactions.hashes().last() {
-        let tx = source_provider
-            .get_transaction_by_hash(tx_hash)
-            .await?
-            .ok_or_else(|| eyre::eyre!("Failed to fetch transaction {tx_hash} from RPC"))?;
-        tx.block_number
-            .ok_or_else(|| eyre::eyre!("Transaction {tx_hash} from local head is pending on RPC"))?
-    } else {
-        return Err(eyre::eyre!(
-            "Synthetic local tip has no transactions, can't derive last regular block"
-        ));
-    };
-
-    let initial_state = BigBlocksInitialState {
-        prior_block_hashes: fetch_recent_block_hashes(source_provider, last_regular_block).await?,
-        next_synthetic_block_number: local_head_number + 1,
-    };
-
-    Ok((last_regular_block, Some(initial_state)))
-}
-
-async fn fetch_recent_block_hashes(
-    provider: &RootProvider<AnyNetwork>,
-    latest_regular_block: u64,
-) -> eyre::Result<Vec<(u64, B256)>> {
-    const BLOCKHASH_HISTORY: u64 = 256;
-    const MAX_CONCURRENT_BLOCK_HASH_REQUESTS: usize = 5;
-
-    let start = latest_regular_block.saturating_sub(BLOCKHASH_HISTORY - 1);
-    let hashes = stream::iter(start..=latest_regular_block)
-        .map(|block_number| async move {
-            provider
-                .get_block_by_number(block_number.into())
-                .await
-                .map(|block| block.map(|block| (block_number, block.header.hash)))
-        })
-        .buffered(MAX_CONCURRENT_BLOCK_HASH_REQUESTS)
-        .try_filter_map(|block_hash| async move { Ok(block_hash) })
-        .try_collect()
-        .await?;
-
-    Ok(hashes)
-}
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 148b3ae6a70..00000000000
--- a/bin/reth-bench/src/bench/generate_big_block.rs
+++ /dev/null
@@ -1,782 +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 [`BigBlockData`] JSON file containing the merged
-//! [`ExecutionData`] and environment switches at each block boundary.
-
-use alloy_consensus::TxEnvelope;
-use alloy_eips::{
-    eip7928::{AccountChanges, BlockAccessList, SlotChanges},
-    Typed2718,
-};
-use alloy_primitives::{Bytes, B256};
-use alloy_provider::{
-    network::{AnyNetwork, AnyRpcBlock},
-    Provider, RootProvider,
-};
-use alloy_rpc_client::ClientBuilder;
-use alloy_rpc_types_engine::{ExecutionData, ExecutionPayload};
-use clap::Parser;
-use eyre::Context;
-use futures::{stream, Stream, StreamExt};
-use reth_chainspec::EthChainSpec;
-use reth_cli::chainspec::ChainSpecParser;
-use reth_cli_runner::CliContext;
-use reth_engine_primitives::{BigBlockData, ExecutionPayload as _};
-use reth_ethereum_cli::chainspec::EthereumChainSpecParser;
-use std::{
-    collections::{HashMap, HashSet},
-    future::Future,
-};
-use tracing::{info, warn};
-
-/// A single transaction with its gas used and raw encoded bytes.
-#[derive(Debug, Clone)]
-pub struct RawTransaction {
-    /// The actual gas used by the transaction (from receipt).
-    pub gas_used: u64,
-    /// The transaction type (e.g., 3 for EIP-4844 blob txs).
-    pub tx_type: u8,
-    /// The raw RLP-encoded transaction bytes.
-    pub raw: Bytes,
-}
-
-/// Abstraction over sources of transactions for big block generation.
-///
-/// Implementors provide transactions from different sources (RPC, database, files, etc.)
-pub trait TransactionSource {
-    /// Fetch transactions from a specific block number.
-    ///
-    /// Returns `Ok(None)` if the block doesn't exist.
-    /// Returns `Ok(Some((transactions, gas_used)))` with the block's transactions and total gas.
-    fn fetch_block_transactions(
-        &self,
-        block_number: u64,
-    ) -> impl Future<Output = eyre::Result<Option<(Vec<RawTransaction>, u64)>>> + Send;
-}
-
-/// RPC-based transaction source that fetches from a remote node.
-#[derive(Debug)]
-pub struct RpcTransactionSource {
-    provider: RootProvider<AnyNetwork>,
-}
-
-impl RpcTransactionSource {
-    /// Create a new RPC transaction source.
-    pub const fn new(provider: RootProvider<AnyNetwork>) -> Self {
-        Self { provider }
-    }
-
-    /// Create from an RPC URL with retry backoff.
-    pub fn from_url(rpc_url: &str) -> eyre::Result<Self> {
-        let client = ClientBuilder::default()
-            .layer(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,
-}
-
-/// State used to continue generated big block replay from the benchmark node's current tip.
-#[derive(Debug, Clone, Default)]
-pub(crate) struct BigBlocksInitialState {
-    /// Real block hashes from previous big blocks, used for BLOCKHASH lookups.
-    pub prior_block_hashes: Vec<(u64, B256)>,
-    /// Block number to assign to the first generated synthetic block.
-    pub next_synthetic_block_number: u64,
-}
-
-/// `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,
-
-    /// Maximum number of in-flight RPC fetches to keep buffered ahead of the merger.
-    ///
-    /// Each entry is one full per-block fetch (block + receipts, plus BAL when `--bal` is
-    /// set). Larger values absorb RPC latency at the cost of more concurrent connections
-    /// and memory; the buffer persists across `--num-big-blocks` so prefetching continues
-    /// across big-block boundaries.
-    #[arg(long, value_name = "PREFETCH_BUFFER", default_value_t = 32)]
-    prefetch_buffer: usize,
-}
-
-impl Command {
-    /// 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);
-
-        // Persistent prefetch stream: keeps `prefetch_buffer` per-block fetches in flight
-        // ahead of the merger across all big blocks. Each item is a fully materialized
-        // `FetchedBlock` (or `None` once the chain tip is reached on this fetch).
-        let prefetch_buffer = self.prefetch_buffer.max(1);
-        let bal_enabled = self.bal;
-        let block_stream = stream::iter(self.from_block..)
-            .map(|block_number| {
-                let provider = provider.clone();
-                async move { fetch_one_block(provider, block_number, bal_enabled).await }
-            })
-            .buffered(prefetch_buffer);
-
-        let mut big_blocks_stream =
-            Box::pin(big_blocks_stream(self.num_big_blocks, self.target_gas, block_stream, None));
-
-        while let Some(big_block) = big_blocks_stream.next().await {
-            let big_block = big_block?;
-            // Save to disk
-            let range_start = big_block.env_switches[0].block_number();
-            let range_end = big_block.env_switches.last().unwrap().block_number();
-            let block_hash = big_block.block_hash();
-            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,
-                "Big block payload saved"
-            );
-        }
-
-        Ok(())
-    }
-}
-
-/// Produces a stream of big block payloads given a stream of regular blocks.
-pub(crate) fn big_blocks_stream(
-    num_big_blocks: u64,
-    target_gas: u64,
-    block_stream: impl Stream<Item = eyre::Result<Option<(AnyRpcBlock, Option<BlockAccessList>)>>>
-        + Unpin,
-    initial_state: Option<BigBlocksInitialState>,
-) -> impl Stream<Item = eyre::Result<BigBlockData<ExecutionData>>> {
-    futures::stream::try_unfold(
-        (
-            block_stream,
-            initial_state.as_ref().map(|s| s.prior_block_hashes.clone()).unwrap_or_default(),
-            0,
-            initial_state.as_ref().map(|s| s.next_synthetic_block_number),
-            false,
-            0,
-        ),
-        move |(
-            mut block_stream,
-            mut accumulated_block_hashes,
-            mut big_block_idx,
-            next_synthetic_block_number,
-            mut reached_chain_tip,
-            mut first_block,
-        )| async move {
-            if reached_chain_tip || num_big_blocks == big_block_idx {
-                warn!(
-                    target: "reth-bench",
-                    generated = big_block_idx + 1,
-                    requested = num_big_blocks,
-                    "Reached chain tip, stopping generation early"
-                );
-                return Ok(None);
-            }
-
-            // Drain the prefetch stream until the gas target is reached for this big block.
-            let mut blocks = Vec::new();
-            let mut block_access_lists: Vec<Option<BlockAccessList>> = Vec::new();
-            let mut accumulated_block_gas: u64 = 0;
-
-            while accumulated_block_gas < target_gas {
-                let (block, block_access_list) = match block_stream.next().await {
-                    Some(Ok(Some(fetched))) => fetched,
-                    Some(Ok(None)) => {
-                        warn!(
-                            target: "reth-bench",
-                            "Block not found — reached chain tip"
-                        );
-                        reached_chain_tip = true;
-                        break;
-                    }
-                    Some(Err(e)) => return Err(e),
-                    // The block-number stream is open-ended; this only fires if the
-                    // upstream `iter(from..)` is somehow exhausted.
-                    None => {
-                        reached_chain_tip = true;
-                        break;
-                    }
-                };
-
-                if first_block == 0 {
-                    first_block = block.header.number;
-                }
-
-                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 (payload, sidecar) = ExecutionPayload::from_block_slow(&block);
-                let execution_data = ExecutionData { payload, sidecar };
-
-                let block_gas = execution_data.payload.as_v1().gas_used;
-
-                accumulated_block_gas += block_gas;
-                blocks.push(execution_data);
-                block_access_lists.push(block_access_list);
-            }
-
-            // 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 = num_big_blocks,
-                    "No blocks available, stopping generation early"
-                );
-                return Ok(None);
-            }
-
-            let mut merged_block_access_list = None;
-            let mut cumulative_tx_count = 0;
-
-            for (block_idx, (block_data, block_access_list)) in
-                blocks.iter().zip(block_access_lists).enumerate()
-            {
-                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,
-                        block_idx as u64,
-                    );
-                }
-
-                cumulative_tx_count += block_data.transaction_count();
-            }
-
-            if let Some(block_access_list) = &mut merged_block_access_list {
-                block_access_list.sort_unstable_by_key(|account| account.address);
-                for account in block_access_list {
-                    account.sort();
-                }
-            }
-
-            let big_block = BigBlockData {
-                env_switches: blocks,
-                prior_block_hashes: accumulated_block_hashes.clone(),
-                block_number: next_synthetic_block_number.unwrap_or(first_block) + big_block_idx,
-                merged_block_access_list: merged_block_access_list
-                    .as_ref()
-                    .map(|list| alloy_rlp::encode(list).into()),
-            };
-
-            // 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.env_switches {
-                let block_number = switch_data.block_number();
-                let block_hash = switch_data.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);
-            }
-
-            info!(
-                target: "reth-bench",
-                block_hash = %big_block.block_hash(),
-                total_txs = %big_block.transaction_count(),
-                total_gas_used = %big_block.gas_used(),
-                env_switches = %big_block.env_switches.len(),
-                prior_block_hashes = %big_block.prior_block_hashes.len(),
-                bal_accounts = %merged_block_access_list.as_ref().map_or(0, Vec::len),
-                "Generated big block"
-            );
-
-            big_block_idx += 1;
-            Ok(Some((
-                big_block,
-                (
-                    block_stream,
-                    accumulated_block_hashes,
-                    big_block_idx,
-                    next_synthetic_block_number,
-                    reached_chain_tip,
-                    first_block,
-                ),
-            )))
-        },
-    )
-}
-
-/// Fetches one block + receipts (and optionally its BAL) from the RPC. Returns `Ok(None)`
-/// when the block doesn't exist yet (chain-tip reached).
-async fn fetch_one_block(
-    provider: RootProvider<AnyNetwork>,
-    block_number: u64,
-    bal_enabled: bool,
-) -> eyre::Result<Option<(AnyRpcBlock, Option<BlockAccessList>)>> {
-    let (rpc_block, block_access_list) =
-        tokio::try_join!(provider.get_block_by_number(block_number.into()).full(), async {
-            if bal_enabled {
-                provider.get_block_access_list_by_number(block_number.into()).await
-            } else {
-                Ok(None)
-            }
-        })?;
-    let Some(rpc_block) = rpc_block else {
-        return Ok(None);
-    };
-
-    Ok(Some((rpc_block, block_access_list)))
-}
-
-fn merge_block_access_list(
-    merged: &mut BlockAccessList,
-    incoming: BlockAccessList,
-    tx_index_offset: u64,
-    segment_idx: 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, segment_idx);
-
-        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,
-    segment_idx: u64,
-) {
-    // Per-block BALs use block_access_index = 0 for pre-execution writes
-    // (system contract calls before any tx), 1..tx_count for tx commits, and
-    // tx_count+1 for post-execution.
-    //
-    // Renumbering: each segment boundary reserves two distinct bal_indexes —
-    // one for the prior segment's `finish()` (post-execution withdrawals +
-    // EIP-7002/7251 system calls) and one for the new segment's
-    // `apply_pre_execution_changes()` (EIP-2935/EIP-4788). The renumbered
-    // bal_index for a block-local idx in segment `k` is
-    // `idx + tx_index_offset + 2*k`. This ensures BAL workers reading via
-    // `BalWrites::get` (strict less-than) see all prior segments' boundary
-    // writes.
-    let shift = tx_index_offset + 2 * segment_idx;
-    for slot_changes in &mut account_changes.storage_changes {
-        for change in &mut slot_changes.changes {
-            change.block_access_index += shift;
-        }
-    }
-    for change in &mut account_changes.balance_changes {
-        change.block_access_index += shift;
-    }
-    for change in &mut account_changes.nonce_changes {
-        change.block_access_index += shift;
-    }
-    for change in &mut account_changes.code_changes {
-        change.block_access_index += shift;
-    }
-}
-
-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, 0);
-
-        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 ffc567f2b3f..00000000000
--- a/bin/reth-bench/src/bench/mod.rs
+++ /dev/null
@@ -1,112 +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, RawTransaction, RpcTransactionSource, TransactionCollector,
-    TransactionSource,
-};
-pub(crate) mod metrics_scraper;
-mod new_payload_fcu;
-mod new_payload_only;
-mod output;
-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),
-
-    /// 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::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 66d3e876f41..00000000000
--- a/bin/reth-bench/src/bench/new_payload_fcu.rs
+++ /dev/null
@@ -1,776 +0,0 @@
-//! Runs the `reth bench` command, calling first newPayload for each block, then calling
-//! forkchoiceUpdated.
-
-use crate::{
-    bench::{
-        context::BenchContext,
-        generate_big_block::big_blocks_stream,
-        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_eip7928::BlockAccessList;
-use alloy_eips::Encodable2718;
-use alloy_primitives::{Bytes, 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, Stream, StreamExt, TryStreamExt};
-use reth_cli_runner::CliContext;
-use reth_engine_primitives::config::DEFAULT_PERSISTENCE_THRESHOLD;
-use reth_node_api::{BigBlockData, EngineApiMessageVersion, ExecutionPayload};
-use reth_node_core::args::{BenchmarkArgs, WaitForPersistence};
-use reth_rpc_api::{RethNewPayloadInput, TestingBuildBlockRequestV1};
-use std::{
-    pin::Pin,
-    time::{Duration, Instant},
-};
-use tokio::{runtime::Handle, sync::mpsc};
-use tokio_stream::wrappers::ReceiverStream;
-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,
-
-    /// The target gas for the big blocks.
-    #[arg(long, value_name = "TARGET_GAS", default_value = "1G", value_parser = super::helpers::parse_gas_limit)]
-    pub big_blocks_target_gas: u64,
-
-    #[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,
-            big_blocks_initial_state,
-        } = 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 provider = block_provider.clone();
-        let bench_mode = benchmark_mode.clone();
-        let mut blocks: Pin<Box<dyn Stream<Item = eyre::Result<Payload>> + Send>> = Box::pin(
-            stream::iter((next_block..)
-                .take_while(move |next_block| {
-                    bench_mode.contains(*next_block)
-                }))
-                .map(move |next_block| {
-                    let block_provider = 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 bal = if !rlp_blocks &&
-                            (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 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,
-                        };
-
-                        let forkchoice = ForkchoiceState {
-                            head_block_hash,
-                            safe_block_hash,
-                            finalized_block_hash,
-                        };
-
-                        Ok(Payload::Block(block, rlp, bal, forkchoice))
-                    }
-                })
-                .buffered(buffer_size),
-        );
-
-        // Big blocks: convert the stream of regular blocks into a stream of big blocks.
-        if let Some(num_big_blocks) = self.benchmark.big_blocks {
-            let block_stream = blocks.map(|res| {
-                res.map(|payload| {
-                    let Payload::Block(block, _, bal, _) = payload else {
-                        unreachable!();
-                    };
-                    Some((block, bal))
-                })
-            });
-            let mut big_blocks = Box::pin(big_blocks_stream(
-                num_big_blocks as u64,
-                self.big_blocks_target_gas,
-                block_stream,
-                big_blocks_initial_state,
-            ));
-            let (tx, rx) = mpsc::channel(buffer_size);
-            tokio::task::spawn_blocking(|| {
-                Handle::current().block_on(async move {
-                    while let Some(big_block) = big_blocks.next().await {
-                        tx.send(big_block.map(Payload::BigBlock)).await.unwrap();
-                    }
-                });
-            });
-
-            blocks = Box::pin(ReceiverStream::new(rx));
-        }
-
-        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(payload) = {
-            let wait_start = Instant::now();
-            let result = blocks.try_next().await?;
-            total_wait_time += wait_start.elapsed();
-            result
-        } {
-            let gas_used = payload.gas_used();
-            let gas_limit = payload.gas_limit();
-            let block_number = payload.block_number();
-            let canonical_parent_hash = payload.parent_hash();
-            let transaction_count = payload.transaction_count() as u64;
-            let deferred_branch_start_block = reorg_state
-                .as_ref()
-                .filter(|state| state.fork_length == 0 && queued_fork_block.is_none())
-                .map(|_| payload.block().cloned());
-
-            debug!(target: "reth-bench", ?block_number, "Sending payload");
-            let start = Instant::now();
-            let canonical_forkchoice_state = payload.forkchoice_state();
-            let (version, params) = payload.into_new_payload_params(
-                use_reth_namespace,
-                wait_for_persistence,
-                no_wait_for_caches,
-            )?;
-            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
-                                .as_ref()
-                                .ok_or_eyre("missing deferred fork block for reorg branch start")?,
-                            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)
-}
-
-/// Payload types used during benchmarking.
-#[expect(clippy::large_enum_variant)]
-enum Payload {
-    /// A regular block payload.
-    Block(AnyRpcBlock, Option<Bytes>, Option<BlockAccessList>, ForkchoiceState),
-    /// A big block payload.
-    BigBlock(BigBlockData<ExecutionData>),
-}
-
-impl Payload {
-    fn into_new_payload_params(
-        self,
-        use_reth_namespace: bool,
-        wait_for_persistence: WaitForPersistence,
-        no_wait_for_caches: bool,
-    ) -> eyre::Result<(Option<EngineApiMessageVersion>, serde_json::Value)> {
-        match self {
-            Self::Block(block, rlp, bal, _) => block_to_new_payload(
-                block,
-                rlp,
-                use_reth_namespace,
-                wait_for_persistence,
-                no_wait_for_caches,
-                bal,
-            ),
-            Self::BigBlock(big_block) => {
-                let wait_for_persistence = wait_for_persistence.rpc_value(big_block.block_number());
-                Ok((
-                    None,
-                    serde_json::to_value((
-                        RethNewPayloadInput::ExecutionData(big_block),
-                        wait_for_persistence,
-                        no_wait_for_caches.then_some(false),
-                    ))?,
-                ))
-            }
-        }
-    }
-
-    fn gas_used(&self) -> u64 {
-        match self {
-            Self::Block(block, _, _, _) => block.header.gas_used,
-            Self::BigBlock(big_block) => big_block.gas_used(),
-        }
-    }
-
-    fn gas_limit(&self) -> u64 {
-        match self {
-            Self::Block(block, _, _, _) => block.header.gas_limit,
-            Self::BigBlock(big_block) => big_block.gas_limit(),
-        }
-    }
-
-    fn block_number(&self) -> u64 {
-        match self {
-            Self::Block(block, _, _, _) => block.header.number,
-            Self::BigBlock(big_block) => big_block.block_number(),
-        }
-    }
-
-    fn parent_hash(&self) -> B256 {
-        match self {
-            Self::Block(block, _, _, _) => block.header.parent_hash,
-            Self::BigBlock(big_block) => big_block.parent_hash(),
-        }
-    }
-
-    fn transaction_count(&self) -> usize {
-        match self {
-            Self::Block(block, _, _, _) => block.transactions.len(),
-            Self::BigBlock(big_block) => big_block.transaction_count(),
-        }
-    }
-
-    const fn block(&self) -> Option<&AnyRpcBlock> {
-        match self {
-            Self::Block(block, _, _, _) => Some(block),
-            Self::BigBlock(_) => None,
-        }
-    }
-
-    fn forkchoice_state(&self) -> ForkchoiceState {
-        match self {
-            Self::Block(_, _, _, forkchoice) => *forkchoice,
-            Self::BigBlock(big_block) => ForkchoiceState {
-                head_block_hash: big_block.block_hash(),
-                safe_block_hash: big_block.block_hash(),
-                finalized_block_hash: big_block.block_hash(),
-            },
-        }
-    }
-}
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/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 ebf8c540a72..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, Clone)]
-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 bfc79c695bf..00000000000
--- a/bin/reth-bench/src/valid_payload.rs
+++ /dev/null
@@ -1,495 +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 {
-        let bal = bal.map(|bal| alloy_rlp::encode(bal).into());
-        return Ok((
-            None,
-            serde_json::to_value((
-                RethNewPayloadInput::<ExecutionData>::BlockRlp { block: rlp, bal },
-                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/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/node/core/src/args/benchmark_args.rs b/crates/node/core/src/args/benchmark_args.rs
deleted file mode 100644
index 9c2f671a9f6..00000000000
--- a/crates/node/core/src/args/benchmark_args.rs
+++ /dev/null
@@ -1,329 +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,
-
-    /// If provided, the benchmark will generate the specified number of big blocks and use them
-    /// instead of regular blocks.
-    #[arg(long, verbatim_doc_comment)]
-    pub big_blocks: Option<usize>,
-}
-
-/// 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/mod.rs b/crates/node/core/src/args/mod.rs
index 28a55b24099..68a0c9f8f8b 100644
--- a/crates/node/core/src/args/mod.rs
+++ b/crates/node/core/src/args/mod.rs
@@ -60,10 +60,6 @@ pub use pruning::{DefaultPruningValues, PruneConfigKind, PruningArgs};
 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};

From cf9abbbd782f4b0c45f0c28da41455d37ba9af0b Mon Sep 17 00:00:00 2001
From: Ivan Wang <wff19940326@gmail.com>
Date: Thu, 21 May 2026 00:24:30 +0800
Subject: [PATCH 191/335] feat(trie): geth-compatible zero hashes for
 non-existent accounts in eth_getProof (#24360)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/trie/common/src/proofs.rs | 80 ++++++++++++++++++++++++++++++--
 1 file changed, 77 insertions(+), 3 deletions(-)

diff --git a/crates/trie/common/src/proofs.rs b/crates/trie/common/src/proofs.rs
index f6e54a56ab0..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
@@ -1256,6 +1286,50 @@ mod tests {
         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();

From 27737df66d73a43a03e3ac3ebc91cd213fe295a2 Mon Sep 17 00:00:00 2001
From: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
Date: Thu, 21 May 2026 01:10:49 +0530
Subject: [PATCH 192/335] chore: add support for Eth capabilities (#24298)

Co-authored-by: Soubhik Singha Mahapatra <soubhiksmp2004@gmail.com>
Co-authored-by: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 Cargo.lock                                   |   2 +
 crates/rpc/rpc-eth-api/Cargo.toml            |   1 +
 crates/rpc/rpc-eth-api/src/core.rs           |  15 +-
 crates/rpc/rpc-eth-api/src/helpers/spec.rs   | 183 ++++++++++++++++++-
 crates/rpc/rpc-eth-api/src/node.rs           |   5 +-
 crates/rpc/rpc-eth-types/Cargo.toml          |   1 +
 crates/rpc/rpc-eth-types/src/capabilities.rs | 153 ++++++++++++++++
 crates/rpc/rpc-eth-types/src/lib.rs          |   2 +
 crates/rpc/rpc/src/eth/core.rs               |   3 +-
 crates/storage/provider/src/traits/full.rs   |   2 +
 10 files changed, 362 insertions(+), 5 deletions(-)
 create mode 100644 crates/rpc/rpc-eth-types/src/capabilities.rs

diff --git a/Cargo.lock b/Cargo.lock
index 17e8bbe0b80..8253d62cbac 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9980,6 +9980,7 @@ dependencies = [
  "reth-network-api",
  "reth-node-api",
  "reth-primitives-traits",
+ "reth-prune-types",
  "reth-revm",
  "reth-rpc-convert",
  "reth-rpc-eth-types",
@@ -10006,6 +10007,7 @@ dependencies = [
  "alloy-primitives",
  "alloy-rpc-client",
  "alloy-rpc-types-eth",
+ "alloy-serde 2.0.5",
  "alloy-sol-types",
  "alloy-transport",
  "derive_more",
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 337ae2db01c..03e63ea5d7e 100644
--- a/crates/rpc/rpc-eth-api/src/core.rs
+++ b/crates/rpc/rpc-eth-api/src/core.rs
@@ -18,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;
@@ -88,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>>;
@@ -485,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,
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/node.rs b/crates/rpc/rpc-eth-api/src/node.rs
index e4852e82990..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::{
-    BalProvider, BlockReader, BlockReaderIdExt, StageCheckpointReader, StateProviderFactory,
+    BalProvider, BlockReader, BlockReaderIdExt, PruneCheckpointReader, StageCheckpointReader,
+    StateProviderFactory,
 };
 use reth_transaction_pool::{PoolTransaction, TransactionPool};
 
@@ -37,6 +38,7 @@ pub trait RpcNodeCore: Clone + Send + Sync + Unpin + 'static {
         > + StateProviderFactory
         + CanonStateSubscriptions<Primitives = Self::Primitives>
         + StageCheckpointReader
+        + PruneCheckpointReader
         + BalProvider
         + Send
         + Sync
@@ -131,6 +133,7 @@ where
         > + StateProviderFactory
         + CanonStateSubscriptions<Primitives = Evm::Primitives>
         + StageCheckpointReader
+        + PruneCheckpointReader
         + BalProvider
         + Send
         + Sync
diff --git a/crates/rpc/rpc-eth-types/Cargo.toml b/crates/rpc/rpc-eth-types/Cargo.toml
index ab8782352b6..3e6153db921 100644
--- a/crates/rpc/rpc-eth-types/Cargo.toml
+++ b/crates/rpc/rpc-eth-types/Cargo.toml
@@ -38,6 +38,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
 
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/src/eth/core.rs b/crates/rpc/rpc/src/eth/core.rs
index 9747f4ef00d..a8f704243c1 100644
--- a/crates/rpc/rpc/src/eth/core.rs
+++ b/crates/rpc/rpc/src/eth/core.rs
@@ -576,7 +576,7 @@ 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::{BalProvider, BlockReader, BlockReaderIdExt, StateProviderFactory};
@@ -599,6 +599,7 @@ mod tests {
             + StateProviderFactory
             + CanonStateSubscriptions<Primitives = reth_ethereum_primitives::EthPrimitives>
             + StageCheckpointReader
+            + PruneCheckpointReader
             + BalProvider
             + Unpin
             + Clone
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

From 02a9ea19240171334d4518fa5feb50e0cffbfa7e Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Thu, 21 May 2026 12:57:15 +0530
Subject: [PATCH 193/335] feat: add shared cell-custody (#24364)

Co-authored-by: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/network-api/src/custody.rs         |  65 +++++++
 crates/net/network-api/src/lib.rs             |  11 ++
 crates/net/network-api/src/noop.rs            |   8 +-
 crates/net/network/src/network.rs             |   9 +-
 crates/rpc/rpc-engine-api/src/engine_api.rs   | 165 +++++++++++++++++-
 .../rpc/rpc/src/eth/helpers/sync_listener.rs  |   7 +-
 6 files changed, 258 insertions(+), 7 deletions(-)
 create mode 100644 crates/net/network-api/src/custody.rs

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/lib.rs b/crates/net/network-api/src/lib.rs
index 95030ad4ded..0a62bc4a146 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;
 
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/src/network.rs b/crates/net/network/src/network.rs
index e188ebd8369..9573edb6c45 100644
--- a/crates/net/network/src/network.rs
+++ b/crates/net/network/src/network.rs
@@ -16,7 +16,7 @@ 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,
 };
@@ -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,
@@ -427,6 +428,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 +507,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
diff --git a/crates/rpc/rpc-engine-api/src/engine_api.rs b/crates/rpc/rpc-engine-api/src/engine_api.rs
index e6a509ce7c3..6dd6105d29f 100644
--- a/crates/rpc/rpc-engine-api/src/engine_api.rs
+++ b/crates/rpc/rpc-engine-api/src/engine_api.rs
@@ -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,
@@ -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 }
@@ -385,8 +387,11 @@ where
         &self,
         state: ForkchoiceState,
         payload_attrs: Option<EngineT::PayloadAttributes>,
-        _custody_columns: Option<B128>,
+        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
     }
@@ -1279,11 +1284,11 @@ where
         &self,
         fork_choice_state: ForkchoiceState,
         payload_attributes: Option<EngineT::PayloadAttributes>,
-        _custody_columns: Option<B128>,
+        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, _custody_columns)
+            .fork_choice_updated_v4_metered(fork_choice_state, payload_attributes, custody_columns)
             .await?)
     }
 
@@ -1559,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>,
 }
@@ -1856,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
         }
@@ -1927,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/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)
         }

From 13d56d585dea5296ee27d0107c2865308639184a Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Thu, 21 May 2026 14:10:02 +0530
Subject: [PATCH 194/335] chore: handle GetCells request (#24129)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/network/src/builder.rs          |  17 +-
 crates/net/network/src/eth_requests.rs     | 186 ++++++++++++++++++++-
 crates/node/builder/src/builder/mod.rs     |   9 +-
 crates/node/builder/src/components/pool.rs |   4 +-
 crates/transaction-pool/src/lib.rs         |   8 +-
 crates/transaction-pool/src/noop.rs        |   6 +-
 crates/transaction-pool/src/traits.rs      |   5 +-
 7 files changed, 224 insertions(+), 11 deletions(-)

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/eth_requests.rs b/crates/net/network/src/eth_requests.rs
index e7bc32fbd75..ad67b85dbe7 100644
--- a/crates/net/network/src/eth_requests.rs
+++ b/crates/net/network/src/eth_requests.rs
@@ -18,6 +18,7 @@ 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,
@@ -50,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;
 
@@ -61,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)]
@@ -77,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>
@@ -317,10 +332,27 @@ where
     fn on_cells_request(
         &self,
         _peer_id: PeerId,
-        _request: GetCells,
+        request: GetCells,
         response: oneshot::Sender<RequestResult<Cells>>,
     ) {
-        let _ = response.send(Ok(Cells::default()));
+        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));
     }
 }
 
@@ -505,3 +537,153 @@ pub enum IncomingEthRequest<N: NetworkPrimitives = EthNetworkPrimitives> {
         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/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/pool.rs b/crates/node/builder/src/components/pool.rs
index eb9568f5fff..c09dd5444ff 100644
--- a/crates/node/builder/src/components/pool.rs
+++ b/crates/node/builder/src/components/pool.rs
@@ -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/transaction-pool/src/lib.rs b/crates/transaction-pool/src/lib.rs
index 3a20090724c..4e37ade0e75 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;
 
@@ -816,6 +816,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 +827,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;
 
diff --git a/crates/transaction-pool/src/noop.rs b/crates/transaction-pool/src/noop.rs
index 6e4b53757ac..e31534e175b 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},
@@ -388,6 +388,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/traits.rs b/crates/transaction-pool/src/traits.rs
index e684c3e79d5..15291706168 100644
--- a/crates/transaction-pool/src/traits.rs
+++ b/crates/transaction-pool/src/traits.rs
@@ -51,7 +51,7 @@
 //! - Conversion from consensus to pooled always fails
 
 use crate::{
-    blobstore::BlobStoreError,
+    blobstore::{BlobStore, BlobStoreError},
     error::{InvalidPoolTransactionError, PoolError, PoolResult},
     pool::{
         state::SubPool, BestTransactionFilter, NewTransactionEvent, TransactionEvents,
@@ -736,6 +736,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.

From 925cfaf9e2b6e354de196f1c82f6b963179aa683 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Thu, 21 May 2026 11:34:37 +0200
Subject: [PATCH 195/335] fix(import): skip invalid blocks during file decode
 instead of aborting (#24379)

---
 crates/cli/commands/src/import_core.rs    | 15 ++++-
 crates/net/downloaders/src/file_client.rs | 80 ++++++++++++++++++++---
 2 files changed, 83 insertions(+), 12 deletions(-)

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

From 559b0b9fa4938195b7c6ebfc11518755574dc1c5 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Thu, 21 May 2026 23:52:35 +0200
Subject: [PATCH 196/335] refactor(payload): store recovered block in built
 payload (#24403)

---
 .../ethereum/engine-primitives/src/payload.rs | 21 ++++++++++++-------
 crates/ethereum/payload/src/lib.rs            |  9 ++++----
 crates/payload/builder/src/lib.rs             |  5 +++--
 crates/payload/builder/src/test_utils.rs      |  4 ++--
 crates/rpc/rpc/src/testing.rs                 |  4 +---
 5 files changed, 23 insertions(+), 20 deletions(-)

diff --git a/crates/ethereum/engine-primitives/src/payload.rs b/crates/ethereum/engine-primitives/src/payload.rs
index 44c40d6160f..182bc8d4f11 100644
--- a/crates/ethereum/engine-primitives/src/payload.rs
+++ b/crates/ethereum/engine-primitives/src/payload.rs
@@ -16,7 +16,7 @@ use alloy_rpc_types_engine::{
 };
 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;
 
@@ -30,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
@@ -49,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>,
@@ -59,11 +59,16 @@ 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<SealedBlock<N::Block>> {
+    pub const fn block_arc(&self) -> &Arc<RecoveredBlock<N::Block>> {
         &self.block
     }
 
@@ -235,7 +240,7 @@ 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 {
@@ -412,7 +417,7 @@ impl From<alloc::vec::IntoIter<BlobTransactionSidecarEip7594>> for BlobSidecars
 mod tests {
     use super::*;
     use alloy_primitives::B256;
-    use reth_primitives_traits::Block as _;
+    use reth_primitives_traits::{Block as _, RecoveredBlock};
 
     #[test]
     fn into_execution_data_preserves_requests() {
@@ -424,7 +429,7 @@ mod tests {
         block.header.requests_hash = Some(requests.requests_hash());
 
         let payload = EthBuiltPayload::new(
-            Arc::new(block.seal_slow()),
+            Arc::new(RecoveredBlock::new_sealed(block.seal_slow(), vec![])),
             U256::ZERO,
             Some(requests.clone()),
             None,
@@ -448,7 +453,7 @@ mod tests {
         block.header.block_access_list_hash = Some(B256::ZERO);
 
         let payload = EthBuiltPayload::new(
-            Arc::new(block.seal_slow()),
+            Arc::new(RecoveredBlock::new_sealed(block.seal_slow(), vec![])),
             U256::ZERO,
             None,
             Some(block_access_list.clone()),
diff --git a/crates/ethereum/payload/src/lib.rs b/crates/ethereum/payload/src/lib.rs
index 257ca2da5d5..2cf090e7ac5 100644
--- a/crates/ethereum/payload/src/lib.rs
+++ b/crates/ethereum/payload/src/lib.rs
@@ -478,19 +478,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 block_access_list: Option<Bytes> =
         block_access_list.map(|block_access_list| alloy_rlp::encode(&block_access_list).into());
-    let payload = EthBuiltPayload::new(sealed_block, total_fees, requests, block_access_list)
+    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/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/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/rpc/rpc/src/testing.rs b/crates/rpc/rpc/src/testing.rs
index e7d2e45826c..8d44c94a950 100644
--- a/crates/rpc/rpc/src/testing.rs
+++ b/crates/rpc/rpc/src/testing.rs
@@ -209,11 +209,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)

From 79b93b8910d75b67c941ad20f24bbe7286e929b0 Mon Sep 17 00:00:00 2001
From: Rocker Zhang <zhang.rocker.liyuan@gmail.com>
Date: Fri, 22 May 2026 15:02:15 +0800
Subject: [PATCH 197/335] docs(txpool): fix grammar in TransactionPool::get_all
 doc (#24397)

---
 crates/transaction-pool/src/traits.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/transaction-pool/src/traits.rs b/crates/transaction-pool/src/traits.rs
index 15291706168..b0c4e2db1b5 100644
--- a/crates/transaction-pool/src/traits.rs
+++ b/crates/transaction-pool/src/traits.rs
@@ -566,9 +566,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.

From f5ce6407ad3addef38ed9259223cd107c0b27a56 Mon Sep 17 00:00:00 2001
From: Rocker Zhang <zhang.rocker.liyuan@gmail.com>
Date: Fri, 22 May 2026 15:02:56 +0800
Subject: [PATCH 198/335] docs(txpool): fix singular "transaction" in sub-pool
 limit docs (#24398)

---
 crates/node/builder/src/components/pool.rs | 6 +++---
 crates/node/core/src/args/txpool.rs        | 8 ++++----
 crates/transaction-pool/src/config.rs      | 6 +++---
 docs/vocs/docs/pages/cli/reth/node.mdx     | 8 ++++----
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/crates/node/builder/src/components/pool.rs b/crates/node/builder/src/components/pool.rs
index c09dd5444ff..d6f459c62f8 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>,
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/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/docs/vocs/docs/pages/cli/reth/node.mdx b/docs/vocs/docs/pages/cli/reth/node.mdx
index e688cd37c2d..e25376d38a5 100644
--- a/docs/vocs/docs/pages/cli/reth/node.mdx
+++ b/docs/vocs/docs/pages/cli/reth/node.mdx
@@ -574,7 +574,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]
 
@@ -584,7 +584,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]
 
@@ -594,7 +594,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]
 
@@ -604,7 +604,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]
 

From b05e68db85fb29c4eaa707728171acb0fd0cd23d Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Fri, 22 May 2026 09:56:32 +0200
Subject: [PATCH 199/335] fix(net): remove untrusted peers from resolver
 (#24406)

---
 crates/net/network/src/peers.rs                  | 2 ++
 crates/net/network/src/trusted_peers_resolver.rs | 5 +++++
 2 files changed, 7 insertions(+)

diff --git a/crates/net/network/src/peers.rs b/crates/net/network/src/peers.rs
index c2e371f8039..6926e3d295f 100644
--- a/crates/net/network/src/peers.rs
+++ b/crates/net/network/src/peers.rs
@@ -969,6 +969,8 @@ impl PeersManager {
 
     /// Removes the tracked node from the trusted set.
     pub(crate) fn remove_peer_from_trusted_set(&mut self, peer_id: PeerId) {
+        self.trusted_peers_resolver.remove(peer_id);
+
         let Entry::Occupied(mut entry) = self.peers.entry(peer_id) else { return };
         if !entry.get().is_trusted() {
             return
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`).

From 44e891fc43c6cd912ed246d4fe32e4f4ff954e08 Mon Sep 17 00:00:00 2001
From: shana <avalonche@protonmail.com>
Date: Fri, 22 May 2026 01:29:17 -0700
Subject: [PATCH 200/335] fix(engine): skip inserted-block cache update while
 in use (#24384)

---
 .../tree/src/tree/payload_processor/mod.rs    | 70 +++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/crates/engine/tree/src/tree/payload_processor/mod.rs b/crates/engine/tree/src/tree/payload_processor/mod.rs
index 174cf49b4f3..b926ad18a98 100644
--- a/crates/engine/tree/src/tree/payload_processor/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/mod.rs
@@ -728,6 +728,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(),
@@ -1010,6 +1020,7 @@ mod tests {
     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},
@@ -1169,6 +1180,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();

From eb70f82c37f46f6cadf8f07eb6e80cfa537ced3d Mon Sep 17 00:00:00 2001
From: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
Date: Fri, 22 May 2026 15:21:46 +0530
Subject: [PATCH 201/335] chore(net): add NewPooledTransactionHashes72 for
 eth/72

Follow-up cell availability tracking is covered by #24415.
---
 crates/net/eth-wire-types/src/broadcast.rs    | 110 ++++++++++++++++--
 crates/net/eth-wire-types/src/message.rs      |  20 +++-
 crates/net/eth-wire-types/src/version.rs      |  18 ++-
 crates/net/network/src/session/active.rs      |  35 +++++-
 .../net/network/src/transactions/fetcher.rs   |  30 ++++-
 crates/net/network/src/transactions/mod.rs    |  42 ++++---
 examples/manual-p2p/src/main.rs               |   3 +
 7 files changed, 223 insertions(+), 35 deletions(-)

diff --git a/crates/net/eth-wire-types/src/broadcast.rs b/crates/net/eth-wire-types/src/broadcast.rs
index a599a72a676..500e91147e1 100644
--- a/crates/net/eth-wire-types/src/broadcast.rs
+++ b/crates/net/eth-wire-types/src/broadcast.rs
@@ -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,
         }
     }
 
@@ -237,13 +245,12 @@ impl NewPooledTransactionHashes {
             Self::Eth68(_) => {
                 matches!(
                     version,
-                    EthVersion::Eth68 |
-                        EthVersion::Eth69 |
-                        EthVersion::Eth70 |
-                        EthVersion::Eth71 |
-                        EthVersion::Eth72
+                    EthVersion::Eth68 | EthVersion::Eth69 | EthVersion::Eth70 | EthVersion::Eth71
                 )
             }
+            Self::Eth72(_) => {
+                matches!(version, EthVersion::Eth72)
+            }
         }
     }
 
@@ -252,6 +259,7 @@ impl NewPooledTransactionHashes {
         match self {
             Self::Eth66(msg) => msg.iter(),
             Self::Eth68(msg) => msg.hashes.iter(),
+            Self::Eth72(msg) => msg.hashes.iter(),
         }
     }
 
@@ -260,6 +268,7 @@ impl NewPooledTransactionHashes {
         match self {
             Self::Eth66(msg) => &msg.0,
             Self::Eth68(msg) => &msg.hashes,
+            Self::Eth72(msg) => &msg.hashes,
         }
     }
 
@@ -268,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,
         }
     }
 
@@ -276,6 +286,7 @@ impl NewPooledTransactionHashes {
         match self {
             Self::Eth66(msg) => msg.0,
             Self::Eth68(msg) => msg.hashes,
+            Self::Eth72(msg) => msg.hashes,
         }
     }
 
@@ -284,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(),
         }
     }
 
@@ -297,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);
+            }
         }
     }
 
@@ -305,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(),
         }
     }
 
@@ -313,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),
         }
     }
@@ -327,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),
         }
     }
@@ -336,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)),
         }
     }
@@ -352,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,
         }
     }
 }
@@ -362,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),
         }
     }
 }
@@ -378,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(
@@ -795,7 +837,34 @@ 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 = HashMap::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)
     }
 }
 
@@ -922,6 +991,11 @@ impl<V> PartiallyValidData<V> {
         Self { data, version }
     }
 
+    /// Wraps raw data with version [`EthVersion::Eth72`].
+    pub const fn from_raw_data_eth72(data: HashMap<TxHash, 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 {
         Self::from_raw_data(data, Some(EthVersion::Eth68))
@@ -932,6 +1006,12 @@ impl<V> PartiallyValidData<V> {
         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(HashMap::default())
+    }
+
     /// Returns a new [`PartiallyValidData`] with empty data from an [`Eth68`](EthVersion::Eth68)
     /// announcement.
     pub fn empty_eth68() -> Self {
@@ -945,7 +1025,7 @@ impl<V> PartiallyValidData<V> {
     }
 
     /// 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
     }
@@ -1076,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>()
+            }
         }
     }
 }
diff --git a/crates/net/eth-wire-types/src/message.rs b/crates/net/eth-wire-types/src/message.rs
index 0dda77dc827..c6eb68f970b 100644
--- a/crates/net/eth-wire-types/src/message.rs
+++ b/crates/net/eth-wire-types/src/message.rs
@@ -14,7 +14,8 @@ use super::{
 };
 use crate::{
     status::StatusMessage, BlockRangeUpdate, Cells, EthNetworkPrimitives, EthVersion, GetCells,
-    NetworkPrimitives, RawCapabilityMessage, Receipts69, Receipts70, SharedTransactions,
+    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,
                     )?)
@@ -325,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>),
@@ -410,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,
@@ -501,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),
@@ -530,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(),
diff --git a/crates/net/eth-wire-types/src/version.rs b/crates/net/eth-wire-types/src/version.rs
index e23a98e1029..b5eecfa0081 100644
--- a/crates/net/eth-wire-types/src/version.rs
+++ b/crates/net/eth-wire-types/src/version.rs
@@ -57,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)
@@ -72,7 +77,7 @@ impl EthVersion {
         matches!(self, Self::Eth71)
     }
 
-    /// Returns true if the version is eth/71
+    /// Returns true if the version is eth/72
     pub const fn is_eth72(&self) -> bool {
         matches!(self, Self::Eth72)
     }
@@ -256,6 +261,17 @@ mod tests {
         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]
     fn test_eth_version_rlp_encode() {
         let versions = [
diff --git a/crates/net/network/src/session/active.rs b/crates/net/network/src/session/active.rs
index d5b8386459e..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)
             }
@@ -989,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 {
@@ -1023,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),
         }
     }
@@ -1085,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) {
@@ -1126,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;
@@ -1466,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/transactions/fetcher.rs b/crates/net/network/src/transactions/fetcher.rs
index dd7f46592b3..477a6c8d263 100644
--- a/crates/net/network/src/transactions/fetcher.rs
+++ b/crates/net/network/src/transactions/fetcher.rs
@@ -238,7 +238,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)
@@ -1288,7 +1288,7 @@ 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::HashMap, B256};
     use alloy_rlp::Decodable;
     use derive_more::IntoIterator;
     use reth_eth_wire_types::EthVersion;
@@ -1406,6 +1406,32 @@ mod test {
         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::<HashMap<_, _>>();
+        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();
diff --git a/crates/net/network/src/transactions/mod.rs b/crates/net/network/src/transactions/mod.rs
index 5fe91c7ab1d..6a9bd67f78c 100644
--- a/crates/net/network/src/transactions/mod.rs
+++ b/crates/net/network/src/transactions/mod.rs
@@ -43,8 +43,8 @@ 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;
@@ -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);
         }
 
@@ -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());
+            }
         }
     }
 
@@ -1974,11 +1987,10 @@ impl PooledTransactionsHashesBuilder {
     fn new(version: EthVersion) -> Self {
         match version {
             EthVersion::Eth66 | EthVersion::Eth67 => Self::Eth66(Default::default()),
-            EthVersion::Eth68 |
-            EthVersion::Eth69 |
-            EthVersion::Eth70 |
-            EthVersion::Eth71 |
-            EthVersion::Eth72 => Self::Eth68(Default::default()),
+            EthVersion::Eth68 | EthVersion::Eth69 | EthVersion::Eth70 | EthVersion::Eth71 => {
+                Self::Eth68(Default::default())
+            }
+            EthVersion::Eth72 => Self::Eth72(Default::default()),
         }
     }
 
@@ -1992,6 +2004,10 @@ impl PooledTransactionsHashesBuilder {
                 msg.shrink_to_fit();
                 msg.into()
             }
+            Self::Eth72(mut msg) => {
+                msg.shrink_to_fit();
+                msg.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);
             }

From bc2b1e081c9de34354b2cdff8723e9a924085d85 Mon Sep 17 00:00:00 2001
From: Rocker Zhang <zhang.rocker.liyuan@gmail.com>
Date: Fri, 22 May 2026 18:06:50 +0800
Subject: [PATCH 202/335] docs(txpool): fix grammar in
 EthPooledTransaction::new doc comment (#24407)

---
 crates/transaction-pool/src/traits.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/transaction-pool/src/traits.rs b/crates/transaction-pool/src/traits.rs
index b0c4e2db1b5..b32eaa44ac3 100644
--- a/crates/transaction-pool/src/traits.rs
+++ b/crates/transaction-pool/src/traits.rs
@@ -1452,7 +1452,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;

From 6da2096ad870cb0dea39ee78b76c8cd99b5d5889 Mon Sep 17 00:00:00 2001
From: Axiom <AxiomBot@proton.me>
Date: Fri, 22 May 2026 03:23:37 -0700
Subject: [PATCH 203/335] docs(rpc): document missing debug namespace methods
 (#24362)

Co-authored-by: Axiom Bot <0xAxiom@users.noreply.github.com>
---
 docs/vocs/docs/pages/jsonrpc/debug.mdx | 26 +++++++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/docs/vocs/docs/pages/jsonrpc/debug.mdx b/docs/vocs/docs/pages/jsonrpc/debug.mdx
index 142fd622bc8..4d65af843ab 100644
--- a/docs/vocs/docs/pages/jsonrpc/debug.mdx
+++ b/docs/vocs/docs/pages/jsonrpc/debug.mdx
@@ -139,6 +139,14 @@ 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.
@@ -149,7 +157,7 @@ Returns account information, including the storage root, after replaying a block
 
 ## `debug_accountInfoAt`
 
-Returns account information, without the storage root, after replaying a block through the transaction at the given index.
+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                                                       |
 | ------ | ----------------------------------------------------------------------- |
@@ -170,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]}` |

From b21ebeb67bed4e149af5a248d8df94f0240b98bb Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Fri, 22 May 2026 03:42:00 -0700
Subject: [PATCH 204/335] ci: disable OTLP for scheduled release benches
 (#24418)

---
 .github/workflows/bench-scheduled.yml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index ca59845a513..9100231abbb 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -311,8 +311,9 @@ jobs:
       BENCH_NODE_BIN: reth
       BENCH_SNAPSHOT_MANIFEST_URL: ${{ secrets.BENCH_SNAPSHOT_MANIFEST_URL }}
       BENCH_METRICS_ADDR: "127.0.0.1:9001"
-      BENCH_OTLP_TRACES_ENDPOINT: ${{ secrets.BENCH_OTLP_TRACES_ENDPOINT }}
-      BENCH_OTLP_LOGS_ENDPOINT: ${{ secrets.BENCH_OTLP_LOGS_ENDPOINT }}
+      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 }}

From e6a5337a15fe7653222245599bb8a08d827fbe19 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Fri, 22 May 2026 05:48:04 -0700
Subject: [PATCH 205/335] chore(payload): prefer named thread for payload
 builds (#24370)

Co-authored-by: Alexey Shekhirin <github@shekhirin.com>
---
 crates/node/builder/src/components/payload.rs |   6 +-
 crates/payload/basic/src/lib.rs               |  55 ++++++---
 crates/tasks/src/runtime.rs                   |  44 +++++++
 crates/tasks/src/worker_map.rs                | 114 ++++++++++++++++--
 4 files changed, 187 insertions(+), 32 deletions(-)

diff --git a/crates/node/builder/src/components/payload.rs b/crates/node/builder/src/components/payload.rs
index f5cf1dd02b0..d7b76b45230 100644
--- a/crates/node/builder/src/components/payload.rs
+++ b/crates/node/builder/src/components/payload.rs
@@ -111,7 +111,7 @@ where
             );
 
         ctx.task_executor().spawn_critical_os_thread(
-            "payload-builder",
+            "payload-service",
             "payload builder service",
             payload_service,
         );
@@ -141,8 +141,8 @@ where
         let (tx, mut rx) = mpsc::unbounded_channel();
 
         ctx.task_executor().spawn_critical_os_thread(
-            "payload-builder",
-            "payload builder",
+            "payload-service",
+            "payload builder service",
             async move {
                 #[expect(clippy::collection_is_never_read)]
                 let mut subscriptions = Vec::new();
diff --git a/crates/payload/basic/src/lib.rs b/crates/payload/basic/src/lib.rs
index 86a710837e3..197f2a56bc5 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;
 
@@ -240,6 +242,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`].
@@ -359,19 +366,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 +530,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 +544,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);
                 }
             };
diff --git a/crates/tasks/src/runtime.rs b/crates/tasks/src/runtime.rs
index af87b4eba24..52af910bda5 100644
--- a/crates/tasks/src/runtime.rs
+++ b/crates/tasks/src/runtime.rs
@@ -550,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.
     ///
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);
+    }
 }

From 803839df0f66f4068c8560c6ac0ffa7430c77198 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Fri, 22 May 2026 18:50:29 +0400
Subject: [PATCH 206/335] chore: bump revm 40 (#24395)

Co-authored-by: Derek <256792747+decofe@users.noreply.github.com>
---
 Cargo.lock                                    | 319 +++++++++---------
 Cargo.toml                                    |  30 +-
 bin/reth-bb/src/evm_config.rs                 |  12 +-
 .../src/tree/payload_processor/bal/execute.rs |   2 +-
 .../src/tree/payload_processor/bal/worker.rs  |   3 +-
 .../tree/src/tree/payload_processor/mod.rs    |  26 +-
 crates/errors/src/error.rs                    |   4 +-
 crates/ethereum/evm/src/lib.rs                |   6 +-
 crates/evm/evm/Cargo.toml                     |   2 +
 crates/evm/evm/src/either.rs                  |   2 +-
 crates/evm/evm/src/execute.rs                 | 114 +------
 .../eth-wire-types/src/block_access_lists.rs  |  35 +-
 crates/rpc/rpc-eth-types/Cargo.toml           |   1 +
 crates/rpc/rpc-eth-types/src/cache/mod.rs     |  16 +-
 crates/storage/storage-api/Cargo.toml         |   3 +
 crates/storage/storage-api/src/bal.rs         |   3 +-
 crates/transaction-pool/src/validate/eth.rs   |   5 +-
 examples/custom-evm/src/main.rs               |   3 +-
 examples/precompile-cache/src/main.rs         |   4 +-
 .../prestate/tx-selfdestruct-prestate.json    |   4 -
 20 files changed, 252 insertions(+), 342 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8253d62cbac..4d62695bd42 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -125,10 +125,10 @@ version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "83447eeb17816e172f1dfc0db1f9dc0b7c5d069bd1f7cecbecceb382bf931015"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "alloy-trie",
  "alloy-tx-macros",
  "arbitrary",
@@ -154,10 +154,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5406343e306856dc2be762700e98a16904de45dee14a07f233e742ce68daff2f"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "arbitrary",
  "serde",
 ]
@@ -264,26 +264,18 @@ dependencies = [
 ]
 
 [[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]]
@@ -295,10 +287,10 @@ dependencies = [
  "alloy-eip2124",
  "alloy-eip2930",
  "alloy-eip7702",
- "alloy-eip7928",
+ "alloy-eip7928 0.3.7",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "arbitrary",
  "auto_impl",
  "borsh",
@@ -314,12 +306,12 @@ dependencies = [
 
 [[package]]
 name = "alloy-evm"
-version = "0.34.0"
+version = "0.35.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1ceeea6dcbbcd4e546b27700763a6f6c3b3fee30054209884f521078b6fda4f"
+checksum = "3585808f81853af97c12b062496d6be382e902df0e4f4c508e1305355b9e4d49"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-hardforks 0.4.7",
  "alloy-primitives",
  "alloy-rpc-types-engine",
@@ -338,9 +330,9 @@ version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab0e0fe9e6d1120ad7bb9254c3fc2b9bc80a8df42a033fb626be6559c13d5153"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "alloy-trie",
  "borsh",
  "serde",
@@ -409,13 +401,13 @@ checksum = "a7db7b095b0b1db1d18ce7e91dcd2e82007f2d52bfb8125e6b64633a74a06bc3"
 dependencies = [
  "alloy-consensus",
  "alloy-consensus-any",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-json-rpc",
  "alloy-network-primitives",
  "alloy-primitives",
  "alloy-rpc-types-any",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "alloy-signer",
  "alloy-sol-types",
  "async-trait",
@@ -434,9 +426,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd28d9bfd11729037d194f2b1d43db8642eb3f342032691f4ca96bb745479c3c"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "serde",
 ]
 
@@ -502,7 +494,7 @@ checksum = "8955ab30418343de57b356de2ea60200f9fb8016a7ea3bc7f5c6176f01a8b1cf"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-json-rpc",
  "alloy-network",
  "alloy-network-primitives",
@@ -617,7 +609,7 @@ dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "serde",
 ]
 
@@ -641,7 +633,7 @@ checksum = "2ff111a54268dc0bbd3b17f98571a7e27cc661dc081ad2999d91888647eb2e11"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "serde",
 ]
 
@@ -655,7 +647,7 @@ dependencies = [
  "alloy-network-primitives",
  "alloy-primitives",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "serde",
  "serde_json",
 ]
@@ -666,7 +658,7 @@ version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a62f6ce2d95f59ed310bd90d5fd1566a29d1ec45cc219abbc5dcc807d31f136"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "derive_more",
@@ -700,10 +692,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7eba59e1c069f168a01982f42a57797736923b76aa854194df4930be17867e1c"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "arbitrary",
  "derive_more",
  "ethereum_ssz",
@@ -722,11 +714,11 @@ checksum = "175a2a5b6017d7f61b5e4b800d21215fe8e94fe729d00828e13bb6d93dcf3492"
 dependencies = [
  "alloy-consensus",
  "alloy-consensus-any",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-network-primitives",
  "alloy-primitives",
  "alloy-rlp",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "alloy-sol-types",
  "arbitrary",
  "itertools 0.14.0",
@@ -743,10 +735,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed1004c1d68bfaee001712f83356f88031ab74a727b8560fb7fc738d1281ebe5"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "serde",
  "serde_json",
 ]
@@ -759,7 +751,7 @@ checksum = "514b4b1ce3354f65067b4fc7eb75358e0f2ec8be3340c96dea65d6894f9ca435"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "serde",
  "serde_json",
  "thiserror 2.0.18",
@@ -773,19 +765,8 @@ checksum = "76e34a42ebb4a71ab0bfdebc6d2f3c7bf809f01edf154d08fed159d10d1ef1d4"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.5",
- "serde",
-]
-
-[[package]]
-name = "alloy-serde"
-version = "1.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11ece63b89294b8614ab3f483560c08d016930f842bf36da56bf0b764a15c11e"
-dependencies = [
- "alloy-primitives",
+ "alloy-serde",
  "serde",
- "serde_json",
 ]
 
 [[package]]
@@ -2825,7 +2806,7 @@ name = "custom-hardforks"
 version = "0.1.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-primitives",
  "reth-chainspec",
@@ -3281,7 +3262,7 @@ name = "ef-tests"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
@@ -3498,7 +3479,7 @@ name = "example-beacon-api-sidecar-fetcher"
 version = "0.1.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-beacon",
  "clap",
@@ -3577,7 +3558,7 @@ dependencies = [
 name = "example-custom-beacon-withdrawals"
 version = "0.0.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-evm",
  "alloy-sol-types",
  "eyre",
@@ -3632,7 +3613,7 @@ dependencies = [
 name = "example-custom-inspector"
 version = "0.0.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-evm",
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -3654,7 +3635,7 @@ dependencies = [
 name = "example-custom-payload-builder"
 version = "0.0.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "eyre",
  "futures-util",
  "reth-basic-payload-builder",
@@ -6138,6 +6119,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"
@@ -7556,7 +7546,7 @@ name = "reth-basic-payload-builder"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "futures-core",
  "futures-util",
@@ -7582,7 +7572,7 @@ name = "reth-bb"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-evm",
  "alloy-hardforks 0.4.7",
  "alloy-primitives",
@@ -7630,7 +7620,7 @@ name = "reth-chain-state"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-signer",
  "alloy-signer-local",
@@ -7664,7 +7654,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-evm",
  "alloy-genesis",
  "alloy-primitives",
@@ -7696,7 +7686,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "arbitrary",
@@ -7792,7 +7782,7 @@ dependencies = [
 name = "reth-cli-util"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "cfg-if",
  "eyre",
@@ -7812,12 +7802,12 @@ dependencies = [
 
 [[package]]
 name = "reth-codecs"
-version = "0.3.1"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fce542a96bf888f31854803e80b3340bc233927743aa580838014e8a88fe0d66"
+checksum = "0f54468f34d9ed03356dee71bb182a2815a490934f1a291f58158053eee946ba"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-trie",
@@ -7833,9 +7823,9 @@ dependencies = [
 
 [[package]]
 name = "reth-codecs-derive"
-version = "0.3.1"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "634c90f1cc0f9887680ca785b0b21aa961070b9465917bf65afaec56a6d005bb"
+checksum = "c80c0516faf1698c57f91f07c98ecd9f3a9d3f163f1ad4bb263d9c495b3928e0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -7865,7 +7855,7 @@ name = "reth-consensus"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eip7928",
+ "alloy-eip7928 0.4.1",
  "alloy-primitives",
  "auto_impl",
  "reth-execution-types",
@@ -7878,7 +7868,7 @@ name = "reth-consensus-common"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "rand 0.9.4",
  "reth-chainspec",
@@ -7892,7 +7882,7 @@ name = "reth-consensus-debug-client"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-json-rpc",
  "alloy-primitives",
  "alloy-provider",
@@ -8010,7 +8000,7 @@ dependencies = [
 name = "reth-db-models"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "arbitrary",
  "bytes",
@@ -8106,7 +8096,7 @@ name = "reth-downloaders"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "assert_matches",
@@ -8144,7 +8134,7 @@ name = "reth-e2e-test-utils"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-network",
  "alloy-primitives",
  "alloy-provider",
@@ -8249,7 +8239,7 @@ name = "reth-engine-primitives"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "auto_impl",
@@ -8273,8 +8263,8 @@ name = "reth-engine-tree"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eip7928",
- "alloy-eips 2.0.5",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-evm",
  "alloy-primitives",
  "alloy-rlp",
@@ -8375,7 +8365,7 @@ name = "reth-era"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "ethereum_ssz",
@@ -8453,7 +8443,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "arbitrary",
@@ -8491,8 +8481,8 @@ version = "2.2.0"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
- "alloy-eip7928",
- "alloy-eips 2.0.5",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-hardforks 0.4.7",
  "alloy-primitives",
@@ -8579,7 +8569,7 @@ name = "reth-ethereum-consensus"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "reth-chainspec",
  "reth-consensus",
@@ -8594,7 +8584,7 @@ dependencies = [
 name = "reth-ethereum-engine-primitives"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "reth-engine-primitives",
@@ -8624,7 +8614,7 @@ name = "reth-ethereum-payload-builder"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-engine",
@@ -8653,7 +8643,7 @@ name = "reth-ethereum-primitives"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-eth",
@@ -8684,7 +8674,8 @@ name = "reth-evm"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-evm",
  "alloy-primitives",
  "auto_impl",
@@ -8708,7 +8699,7 @@ name = "reth-evm-ethereum"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-evm",
  "alloy-genesis",
  "alloy-primitives",
@@ -8760,7 +8751,7 @@ name = "reth-execution-types"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-evm",
  "alloy-primitives",
  "alloy-rlp",
@@ -8781,7 +8772,7 @@ name = "reth-exex"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-primitives",
  "eyre",
@@ -8825,7 +8816,7 @@ dependencies = [
 name = "reth-exex-test-utils"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "eyre",
  "futures-util",
  "reth-chainspec",
@@ -8856,7 +8847,7 @@ dependencies = [
 name = "reth-exex-types"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "arbitrary",
  "bincode",
@@ -8883,7 +8874,7 @@ name = "reth-invalid-block-hooks"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-debug",
@@ -8997,7 +8988,7 @@ name = "reth-network"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
@@ -9083,7 +9074,7 @@ name = "reth-network-p2p"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "auto_impl",
  "derive_more",
@@ -9176,7 +9167,7 @@ name = "reth-node-builder"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-provider",
  "alloy-rpc-types",
@@ -9247,7 +9238,7 @@ name = "reth-node-core"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "clap",
@@ -9304,7 +9295,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-consensus",
  "alloy-contract",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-network",
  "alloy-primitives",
@@ -9393,7 +9384,7 @@ name = "reth-node-events"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "derive_more",
@@ -9490,7 +9481,7 @@ name = "reth-payload-primitives"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-engine",
@@ -9529,12 +9520,12 @@ dependencies = [
 
 [[package]]
 name = "reth-primitives-traits"
-version = "0.3.1"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ee12e304adbacbb32248c9806ebafbe1e2811fbfefe53c5e5b710a8438b7ec0"
+checksum = "2d1216ba179909d41d8d55c5eae6c1c33698bc7a3053c35fd425c7789a5de3c1"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
@@ -9565,8 +9556,8 @@ name = "reth-provider"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eip7928",
- "alloy-eips 2.0.5",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rpc-types-engine",
@@ -9620,7 +9611,7 @@ name = "reth-prune"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "assert_matches",
  "itertools 0.14.0",
@@ -9694,7 +9685,7 @@ version = "2.2.0"
 dependencies = [
  "alloy-consensus",
  "alloy-dyn-abi",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-evm",
  "alloy-genesis",
  "alloy-network",
@@ -9710,7 +9701,7 @@ dependencies = [
  "alloy-rpc-types-mev",
  "alloy-rpc-types-trace",
  "alloy-rpc-types-txpool",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "alloy-signer",
  "alloy-signer-local",
  "async-trait",
@@ -9771,7 +9762,7 @@ dependencies = [
 name = "reth-rpc-api"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-json-rpc",
  "alloy-primitives",
@@ -9785,7 +9776,7 @@ dependencies = [
  "alloy-rpc-types-mev",
  "alloy-rpc-types-trace",
  "alloy-rpc-types-txpool",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "jsonrpsee",
  "reth-chain-state",
  "reth-engine-primitives",
@@ -9801,7 +9792,7 @@ dependencies = [
 name = "reth-rpc-api-testing-util"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-eth",
  "alloy-rpc-types-trace",
@@ -9820,7 +9811,7 @@ dependencies = [
 name = "reth-rpc-builder"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-network",
  "alloy-primitives",
  "alloy-provider",
@@ -9918,7 +9909,7 @@ dependencies = [
 name = "reth-rpc-engine-api"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-engine",
@@ -9956,8 +9947,8 @@ version = "2.2.0"
 dependencies = [
  "alloy-consensus",
  "alloy-dyn-abi",
- "alloy-eip7928",
- "alloy-eips 2.0.5",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-evm",
  "alloy-json-rpc",
  "alloy-network",
@@ -9965,7 +9956,7 @@ dependencies = [
  "alloy-rlp",
  "alloy-rpc-types-eth",
  "alloy-rpc-types-mev",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "async-trait",
  "auto_impl",
  "dyn-clone",
@@ -10001,13 +9992,14 @@ name = "reth-rpc-eth-types"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-evm",
  "alloy-network",
  "alloy-primitives",
  "alloy-rpc-client",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "alloy-sol-types",
  "alloy-transport",
  "derive_more",
@@ -10067,7 +10059,7 @@ dependencies = [
 name = "reth-rpc-server-types"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "jsonrpsee-core",
@@ -10080,9 +10072,9 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-traits"
-version = "0.3.1"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "860fe223501a76ff14aa3bf164f739f31008c2a2905ac85708bfd88f042e6151"
+checksum = "75186b77fef29e0160f476c9a6bde3363e503f0f32ac4ef47726ef1e3da81118"
 dependencies = [
  "alloy-consensus",
  "alloy-network",
@@ -10098,7 +10090,7 @@ name = "reth-stages"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
@@ -10159,7 +10151,7 @@ dependencies = [
 name = "reth-stages-api"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "aquamarine",
  "assert_matches",
@@ -10251,7 +10243,8 @@ name = "reth-storage-api"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eip7928 0.4.1",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rpc-types-engine",
  "auto_impl",
@@ -10276,7 +10269,7 @@ dependencies = [
 name = "reth-storage-errors"
 version = "2.2.0"
 dependencies = [
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "derive_more",
@@ -10294,7 +10287,7 @@ name = "reth-storage-rpc-provider"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-network",
  "alloy-primitives",
  "alloy-provider",
@@ -10343,7 +10336,7 @@ name = "reth-testing-utils"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
@@ -10404,7 +10397,7 @@ name = "reth-transaction-pool"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "aquamarine",
@@ -10455,7 +10448,7 @@ name = "reth-trie"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips 2.0.5",
+ "alloy-eips",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-trie",
@@ -10492,7 +10485,7 @@ dependencies = [
  "alloy-primitives",
  "alloy-rlp",
  "alloy-rpc-types-eth",
- "alloy-serde 2.0.5",
+ "alloy-serde",
  "alloy-trie",
  "arbitrary",
  "arrayvec",
@@ -10550,7 +10543,7 @@ dependencies = [
 name = "reth-trie-parallel"
 version = "2.2.0"
 dependencies = [
- "alloy-eip7928",
+ "alloy-eip7928 0.4.1",
  "alloy-evm",
  "alloy-primitives",
  "alloy-rlp",
@@ -10616,18 +10609,18 @@ dependencies = [
 
 [[package]]
 name = "reth-zstd-compressors"
-version = "0.3.1"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c12fafa33d2f420a9d39249a3e0357b1928d09429f30758b85280409092873b2"
+checksum = "80dcfa0327b7642cc41c71d8cd3626a48ac76fb8304c28bcbdf416a45615d020"
 dependencies = [
  "zstd",
 ]
 
 [[package]]
 name = "revm"
-version = "38.0.0"
+version = "40.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91202d39dbe8e8d10e9e8f2b76c30da68ecd1d25be69ba6d853ad0d03a3a398a"
+checksum = "b2d649306477c7153d0f4568976385ccb1789608e9a5b956ec781514612ccbc3"
 dependencies = [
  "revm-bytecode",
  "revm-context",
@@ -10644,9 +10637,9 @@ dependencies = [
 
 [[package]]
 name = "revm-bytecode"
-version = "10.0.0"
+version = "11.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdbb3a3d735efa94c91f2ef6bf20a35f99a77bc78f3e25bd758336901bdf9661"
+checksum = "d0b0efe30093e26767c2eb4d86c369a9b3877cc034e843f074436111c4459832"
 dependencies = [
  "bitvec",
  "phf",
@@ -10656,9 +10649,9 @@ dependencies = [
 
 [[package]]
 name = "revm-context"
-version = "16.0.1"
+version = "18.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5f68d928d8b228e0faeb1c6ed75c4fde7d124f1ddf9119b67e7a0ad4041237d"
+checksum = "8f54b599f334f7cd32c5de193d586f50d7cc2bd5aa07f83dfeaf85a277ad5d9a"
 dependencies = [
  "bitvec",
  "cfg-if",
@@ -10673,9 +10666,9 @@ dependencies = [
 
 [[package]]
 name = "revm-context-interface"
-version = "17.0.1"
+version = "19.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3758e6167c4ba7a59a689c519a047edaefcd4c37d74f279b93ed87bc8aece4"
+checksum = "a96259bca5af514ea4b92037908b0232afbc167f1f8355604118ec599caeca8c"
 dependencies = [
  "alloy-eip2930",
  "alloy-eip7702",
@@ -10689,11 +10682,11 @@ dependencies = [
 
 [[package]]
 name = "revm-database"
-version = "13.0.1"
+version = "15.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c281a1f11d3bcb8c0bba1199ed6bcb001d1aeb3d4fb366819e14f88723989a4e"
+checksum = "e73c2151aded4387d96f90c958bb67f34968d40d11d1495fe41091fe220af115"
 dependencies = [
- "alloy-eips 1.8.3",
+ "alloy-eips",
  "revm-bytecode",
  "revm-database-interface",
  "revm-primitives",
@@ -10703,9 +10696,9 @@ dependencies = [
 
 [[package]]
 name = "revm-database-interface"
-version = "11.0.1"
+version = "12.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d89efb9832a4e3742bb4ded5f7fe5bf905e8860e69427d4dfec153484fc6d304"
+checksum = "75f753660705cf9e7b7e45fc5607d4cebf729094d5e96dc1d1cf98cf57b69507"
 dependencies = [
  "auto_impl",
  "either",
@@ -10717,9 +10710,9 @@ dependencies = [
 
 [[package]]
 name = "revm-handler"
-version = "18.1.0"
+version = "20.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "783e903d6922b7f5f9a940d1bb229530502d2924b1aed9d5ca5a94ebf065d460"
+checksum = "aa038202a389d72b5c1b4d6f6e8f921a93171bf02f7cfdb5308eeea5780869c1"
 dependencies = [
  "auto_impl",
  "derive-where",
@@ -10736,9 +10729,9 @@ dependencies = [
 
 [[package]]
 name = "revm-inspector"
-version = "19.0.0"
+version = "21.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8216ad58422090d0daa9eb430e0a081f7ad07e7fd30681dee71f8420c99624e0"
+checksum = "4375c14860fa31232673f8e963510ddaccd10d511353e35771a1d5015fed327a"
 dependencies = [
  "auto_impl",
  "either",
@@ -10754,9 +10747,9 @@ dependencies = [
 
 [[package]]
 name = "revm-inspectors"
-version = "0.39.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "731b682530a732ef9c189ef831589128e2ce34d4a306c956322ae2dffe009715"
+checksum = "2854f2c48cecac90e8ad48fe8d8842707f79df2b748913b67bd2439a9ea3b4ab"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -10774,9 +10767,9 @@ dependencies = [
 
 [[package]]
 name = "revm-interpreter"
-version = "35.0.1"
+version = "37.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ece9f41b69658c15d748288a4dbdfc06a63f3ce93d983af440de3f1631dce6a"
+checksum = "ecec5a33daed0d84e3e1529203451d33ca50d2a30c2e3d9959ce18ee0229a06a"
 dependencies = [
  "revm-bytecode",
  "revm-context-interface",
@@ -10787,9 +10780,9 @@ dependencies = [
 
 [[package]]
 name = "revm-precompile"
-version = "34.0.0"
+version = "36.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a346a8cc6c8c39bd65306641c692191299c0a7b63d38810e39e8fe9b92378660"
+checksum = "d5cc580444ccf766456f7586edaf1bff9f09b7101f3a9ac0979969168e5debc6"
 dependencies = [
  "ark-bls12-381",
  "ark-bn254",
@@ -10813,24 +10806,24 @@ dependencies = [
 
 [[package]]
 name = "revm-primitives"
-version = "23.0.0"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c99bda77d9661521ba0b4bc04558c6692074f01e65dd420fa3b893033d9b8a2"
+checksum = "5b4a4ed40c86155d1656e1744e90e23c96e1059f3cd146d70b6d4b2882708f1c"
 dependencies = [
  "alloy-primitives",
- "num_enum",
  "once_cell",
  "serde",
 ]
 
 [[package]]
 name = "revm-state"
-version = "11.0.1"
+version = "12.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c32490ed687dba31c3c882beb8c20408bdd30ef96690d8f145b0ee9a87040bfe"
+checksum = "fc740a183b0d4c0807f565df2420ccb6a662df1d878108faddb25560164a4022"
 dependencies = [
- "alloy-eip7928",
+ "alloy-eip7928 0.4.1",
  "bitflags 2.11.1",
+ "nonmax",
  "revm-bytecode",
  "revm-primitives",
  "serde",
diff --git a/Cargo.toml b/Cargo.toml
index 9501a7b6efe..0b31fac168a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -325,8 +325,8 @@ reth-cli = { path = "crates/cli/cli" }
 reth-cli-commands = { path = "crates/cli/commands" }
 reth-cli-runner = { path = "crates/cli/runner" }
 reth-cli-util = { path = "crates/cli/util" }
-reth-codecs = { version = "0.3.1", default-features = false }
-reth-codecs-derive = "0.3.1"
+reth-codecs = { version = "0.4.0", default-features = false }
+reth-codecs-derive = "0.4.0"
 reth-config = { path = "crates/config", default-features = false }
 reth-consensus = { path = "crates/consensus/consensus", default-features = false }
 reth-consensus-common = { path = "crates/consensus/common", default-features = false }
@@ -394,7 +394,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.0", default-features = false }
 reth-provider = { path = "crates/storage/provider" }
 reth-prune = { path = "crates/prune/prune" }
 reth-prune-types = { path = "crates/prune/types", default-features = false }
@@ -410,7 +410,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.0", default-features = false }
 reth-stages = { path = "crates/stages/stages" }
 reth-stages-api = { path = "crates/stages/api" }
 reth-stages-types = { path = "crates/stages/types", default-features = false }
@@ -429,17 +429,17 @@ 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.0", 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.2", 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.0"
 
 # eth
 alloy-dyn-abi = "1.6.0"
@@ -448,8 +448,8 @@ 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.7", default-features = false }
-alloy-evm = { version = "0.34.0", default-features = false }
+alloy-eip7928 = { version = "0.4.0", default-features = false, features = ["rlp"] }
+alloy-evm = { version = "0.35.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 }
 
diff --git a/bin/reth-bb/src/evm_config.rs b/bin/reth-bb/src/evm_config.rs
index 12935c70063..5370376eaab 100644
--- a/bin/reth-bb/src/evm_config.rs
+++ b/bin/reth-bb/src/evm_config.rs
@@ -29,7 +29,7 @@ use reth_evm::{
 };
 use reth_evm_ethereum::{EthEvmConfig, RethReceiptBuilder};
 use reth_primitives_traits::{SealedBlock, SealedHeader, SignedTransaction, TxTy};
-use revm::primitives::hardfork::SpecId;
+use revm::{primitives::hardfork::SpecId, state::bal::BlockAccessIndex};
 use std::sync::Arc;
 
 // ---------------------------------------------------------------------------
@@ -108,8 +108,8 @@ fn seed_state_block_hashes<DB>(state: &mut &mut revm::database::State<DB>, hashe
 /// Used as a [`BalIndexReader`] callback so the
 /// generic [`BbBlockExecutor`](crate::evm::BbBlockExecutor) can pick its
 /// starting segment without a trait bound on `DB`.
-fn read_bal_index<DB>(state: &&mut revm::database::State<DB>) -> u64 {
-    state.bal_state.bal_index()
+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>`.
@@ -119,7 +119,7 @@ fn read_bal_index<DB>(state: &&mut revm::database::State<DB>) -> u64 {
 /// `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`.
-fn bump_bal_index<DB: revm::Database>(state: &mut &mut revm::database::State<DB>) {
+const fn bump_bal_index<DB: revm::Database>(state: &mut &mut revm::database::State<DB>) {
     state.bump_bal_index();
 }
 
@@ -129,8 +129,8 @@ fn bump_bal_index<DB: revm::Database>(state: &mut &mut revm::database::State<DB>
 /// [`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).
-fn set_bal_index<DB: revm::Database>(state: &mut &mut revm::database::State<DB>, index: u64) {
-    state.set_bal_index(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));
 }
 
 // ---------------------------------------------------------------------------
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
index d26a73b4ea4..76078b4447b 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
@@ -287,7 +287,7 @@ impl BlockGasTracker {
         Ok(())
     }
 
-    fn record_result<H>(&mut self, result: &ResultAndState<H>) {
+    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 =
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/worker.rs b/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
index efd1262dff5..386d2c95189 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
@@ -1,5 +1,6 @@
 use super::BalExecutionError;
 use alloy_consensus::Transaction;
+use alloy_eip7928::BlockAccessIndex;
 use alloy_evm::{
     block::{BlockExecutionError, BlockExecutor, BlockExecutorFactory},
     Evm,
@@ -64,7 +65,7 @@ pub(super) fn spawn_worker<'scope, Evm, Tx, Err, DB, MakeDb>(
                 let signer = *tx.signer();
                 let tx_gas_limit = tx.tx().gas_limit();
 
-                executor.evm_mut().db_mut().set_bal_index(index as u64 + 1);
+                executor.evm_mut().db_mut().set_bal_index(BlockAccessIndex::new(index as u64 + 1));
                 let result = executor
                     .execute_transaction_without_commit(tx)
                     .map_err(BalExecutionError::Evm)?;
diff --git a/crates/engine/tree/src/tree/payload_processor/mod.rs b/crates/engine/tree/src/tree/payload_processor/mod.rs
index b926ad18a98..fd0eae81d9e 100644
--- a/crates/engine/tree/src/tree/payload_processor/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/mod.rs
@@ -1032,7 +1032,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 {
@@ -1260,25 +1260,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);
             }
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/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/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 ff64cf54c58..1c989ec98bc 100644
--- a/crates/evm/evm/src/either.rs
+++ b/crates/evm/evm/src/either.rs
@@ -80,7 +80,7 @@ where
         }
     }
 
-    fn take_bal(&mut self) -> Option<alloy_eips::eip7928::BlockAccessList> {
+    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 19c148c31f6..b89335f733a 100644
--- a/crates/evm/evm/src/execute.rs
+++ b/crates/evm/evm/src/execute.rs
@@ -3,10 +3,8 @@
 use crate::{ConfigureEvm, Database, OnStateHook, TxEnvFor};
 use alloc::{boxed::Box, sync::Arc, vec::Vec};
 use alloy_consensus::{BlockHeader, Header};
-use alloy_eips::{
-    eip2718::WithEncoded,
-    eip7928::{compute_block_access_list_hash, BlockAccessList},
-};
+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::{
     block::{CommitChanges, ExecutableTxParts},
@@ -506,7 +504,7 @@ where
 
         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));
+            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 {
@@ -700,16 +698,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;
@@ -768,101 +759,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/net/eth-wire-types/src/block_access_lists.rs b/crates/net/eth-wire-types/src/block_access_lists.rs
index 0e27ab7833e..a6c97fe20ec 100644
--- a/crates/net/eth-wire-types/src/block_access_lists.rs
+++ b/crates/net/eth-wire-types/src/block_access_lists.rs
@@ -108,7 +108,8 @@ 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, EMPTY_STRING_CODE};
@@ -120,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![
@@ -129,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]),
                 )],
             },
@@ -145,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]),
+                )],
             },
         ]
     }
diff --git a/crates/rpc/rpc-eth-types/Cargo.toml b/crates/rpc/rpc-eth-types/Cargo.toml
index 3e6153db921..28c405f002f 100644
--- a/crates/rpc/rpc-eth-types/Cargo.toml
+++ b/crates/rpc/rpc-eth-types/Cargo.toml
@@ -29,6 +29,7 @@ reth-transaction-pool.workspace = true
 reth-trie.workspace = true
 
 # ethereum
+alloy-eip7928.workspace = true
 alloy-eips.workspace = true
 alloy-evm = { workspace = true, features = ["overrides", "call-util"] }
 alloy-primitives.workspace = true
diff --git a/crates/rpc/rpc-eth-types/src/cache/mod.rs b/crates/rpc/rpc-eth-types/src/cache/mod.rs
index bfb82373d0e..4ef466e5310 100644
--- a/crates/rpc/rpc-eth-types/src/cache/mod.rs
+++ b/crates/rpc/rpc-eth-types/src/cache/mod.rs
@@ -3,7 +3,8 @@
 use super::{EthStateCacheConfig, MultiConsumerLruCache};
 use crate::block::CachedTransaction;
 use alloy_consensus::{transaction::TxHashRef, BlockHeader};
-use alloy_eips::{eip7928::bal::DecodedBal, BlockHashOrNumber};
+use alloy_eip7928::bal::DecodedBal;
+use alloy_eips::BlockHashOrNumber;
 use alloy_primitives::{Address, TxHash, B256};
 use futures::{stream::FuturesOrdered, Stream, StreamExt};
 use reth_chain_state::CanonStateNotification;
@@ -987,6 +988,7 @@ fn revm_code_write_heap_size((_, bytecode): &(B256, Bytecode)) -> usize {
 mod tests {
     use super::*;
     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};
@@ -1115,15 +1117,19 @@ mod tests {
     #[test]
     fn cached_revm_bal_size_accounts_for_nested_allocations() {
         let mut account = RevmAccountBal::default();
-        account.account_info.nonce.writes.push((1, 1));
-        account.account_info.balance.writes.push((2, StorageValue::from(1u64)));
+        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((
-            3,
+            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![(4, StorageValue::from(2u64))]),
+            RevmBalWrites::new(vec![(BlockAccessIndex::new(4), StorageValue::from(2u64))]),
         );
 
         let mut bal = RevmBal::default();
diff --git a/crates/storage/storage-api/Cargo.toml b/crates/storage/storage-api/Cargo.toml
index d00ad0e5dcd..eb75a1c014c 100644
--- a/crates/storage/storage-api/Cargo.toml
+++ b/crates/storage/storage-api/Cargo.toml
@@ -27,6 +27,7 @@ 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
@@ -59,6 +60,7 @@ std = [
     "reth-trie-common/std",
     "serde_json?/std",
     "dep:reth-tokio-util",
+    "alloy-eip7928/std",
 ]
 
 db-api = [
@@ -79,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 dcb4da59ab5..d280e0fceb7 100644
--- a/crates/storage/storage-api/src/bal.rs
+++ b/crates/storage/storage-api/src/bal.rs
@@ -1,5 +1,6 @@
 use alloc::{sync::Arc, vec::Vec};
-use alloy_eips::{eip7928::bal::DecodedBal, NumHash};
+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;
diff --git a/crates/transaction-pool/src/validate/eth.rs b/crates/transaction-pool/src/validate/eth.rs
index 6fa760a1db1..f420a2421ee 100644
--- a/crates/transaction-pool/src/validate/eth.rs
+++ b/crates/transaction-pool/src/validate/eth.rs
@@ -34,7 +34,7 @@ use reth_primitives_traits::{
 use reth_storage_api::{AccountInfoReader, BlockReaderIdExt, BytecodeReader, StateProviderFactory};
 use reth_tasks::Runtime;
 use revm::context_interface::Cfg;
-use revm_primitives::U256;
+use revm_primitives::{eip8037::CPSB_GLAMSTERDAM, U256};
 use std::{
     fmt,
     marker::PhantomData,
@@ -1424,10 +1424,11 @@ pub fn ensure_intrinsic_gas<T: EthPoolTransaction>(
             .map(|l| l.iter().map(|i| i.storage_keys.len()).sum::<usize>())
             .unwrap_or_default() as u64,
         transaction.authorization_list().map(|l| l.len()).unwrap_or_default() as u64,
+        CPSB_GLAMSTERDAM,
     );
 
     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/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/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/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

From 0456b4b9d9e496f735aaace18c60bf4cf4997033 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Fri, 22 May 2026 20:38:09 +0400
Subject: [PATCH 207/335] perf: don't send unchanged accounts to trie (#24432)

---
 crates/engine/tree/src/tree/payload_processor/prewarm.rs | 5 ++++-
 crates/trie/parallel/src/state_root_task.rs              | 6 ++++--
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_processor/prewarm.rs b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
index 7c6ee4a9f3a..318c817c249 100644
--- a/crates/engine/tree/src/tree/payload_processor/prewarm.rs
+++ b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
@@ -828,7 +828,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/trie/parallel/src/state_root_task.rs b/crates/trie/parallel/src/state_root_task.rs
index 24a1e3269d9..975d9506aaa 100644
--- a/crates/trie/parallel/src/state_root_task.rs
+++ b/crates/trie/parallel/src/state_root_task.rs
@@ -177,8 +177,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

From f6e3ebad9ff946b283bf3fb18c0230bd9f1e79e0 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Fri, 22 May 2026 22:13:01 +0400
Subject: [PATCH 208/335] perf: avoid hashing the state twice (#24354)

---
 .../tree/src/tree/payload_processor/mod.rs    | 15 ++++++++--
 .../src/tree/payload_processor/sparse_trie.rs | 30 ++++++++++++++++---
 .../engine/tree/src/tree/payload_validator.rs |  8 ++++-
 crates/trie/parallel/src/state_root_task.rs   | 19 +++++++++++-
 4 files changed, 64 insertions(+), 8 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_processor/mod.rs b/crates/engine/tree/src/tree/payload_processor/mod.rs
index fd0eae81d9e..ef9139f14b0 100644
--- a/crates/engine/tree/src/tree/payload_processor/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/mod.rs
@@ -26,7 +26,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,
@@ -381,16 +383,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
@@ -580,6 +584,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,
@@ -628,6 +633,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,
@@ -895,6 +901,11 @@ impl<Tx, Err, R: Send + Sync + 'static> PayloadHandle<Tx, Err, R> {
     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())
+    }
 }
 
 /// Access to the spawned [`PrewarmCacheTask`].
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..bae7f5082ae 100644
--- a/crates/engine/tree/src/tree/payload_processor/sparse_trie.rs
+++ b/crates/engine/tree/src/tree/payload_processor/sparse_trie.rs
@@ -45,6 +45,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 +108,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 +125,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 +151,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 +171,7 @@ where
             storage_cache_misses: 0,
             pending_targets: Default::default(),
             pending_updates: Default::default(),
+            final_hashed_state: Default::default(),
             metrics,
         }
     }
@@ -415,7 +427,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 +472,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 +504,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 +517,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 +1030,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 19b6748bc00..b012e78d9f4 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -565,6 +565,7 @@ where
         // (keccak256 hashing of all changed addresses and storage slots).
         let hashed_state_output = output.clone();
         let hashed_state_provider = self.provider.clone();
+        let mut hashed_state_rx = handle.take_hashed_state_rx();
         let hashed_state: LazyHashedPostState =
             self.payload_processor.executor().spawn_blocking_named("hash-post-state", move || {
                 let _span = debug_span!(
@@ -572,7 +573,12 @@ where
                     "hashed_post_state",
                 )
                 .entered();
-                Arc::new(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 = validated_block.try_into_inner().expect("sole handle")?;
diff --git a/crates/trie/parallel/src/state_root_task.rs b/crates/trie/parallel/src/state_root_task.rs
index 975d9506aaa..cd6783ad0d5 100644
--- a/crates/trie/parallel/src/state_root_task.rs
+++ b/crates/trie/parallel/src/state_root_task.rs
@@ -85,6 +85,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 +97,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.
@@ -143,6 +151,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.

From 89c930a006f08dfbc6b13aca303b99d889517488 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Sat, 23 May 2026 06:53:53 +0200
Subject: [PATCH 209/335] fix(rpc): support hostname resolution for trusted
 peers (#24427)

Co-authored-by: hfuss <hayden.fuss@kaleido.io>
---
 crates/net/network-api/src/lib.rs |  7 +++
 crates/net/network/src/manager.rs |  5 ++
 crates/net/network/src/network.rs |  8 ++-
 crates/net/network/src/peers.rs   | 94 ++++++++++++++++++++++++++++---
 crates/net/network/src/state.rs   |  5 ++
 crates/net/peers/src/lib.rs       | 47 +++++++++++++---
 crates/rpc/rpc/src/admin.rs       | 14 ++++-
 7 files changed, 159 insertions(+), 21 deletions(-)

diff --git a/crates/net/network-api/src/lib.rs b/crates/net/network-api/src/lib.rs
index 0a62bc4a146..16773b998f1 100644
--- a/crates/net/network-api/src/lib.rs
+++ b/crates/net/network-api/src/lib.rs
@@ -151,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/src/manager.rs b/crates/net/network/src/manager.rs
index 84913aca0d9..1afce957ac5 100644
--- a/crates/net/network/src/manager.rs
+++ b/crates/net/network/src/manager.rs
@@ -714,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/network.rs b/crates/net/network/src/network.rs
index 9573edb6c45..a02ad9a6361 100644
--- a/crates/net/network/src/network.rs
+++ b/crates/net/network/src/network.rs
@@ -21,7 +21,7 @@ use reth_network_api::{
     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;
@@ -321,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(
@@ -532,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 6926e3d295f..204cd3df46d 100644
--- a/crates/net/network/src/peers.rs
+++ b/crates/net/network/src/peers.rs
@@ -12,7 +12,7 @@ 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::{
@@ -819,6 +819,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.
@@ -971,7 +980,10 @@ impl PeersManager {
     pub(crate) fn remove_peer_from_trusted_set(&mut self, peer_id: PeerId) {
         self.trusted_peers_resolver.remove(peer_id);
 
-        let Entry::Occupied(mut entry) = self.peers.entry(peer_id) else { return };
+        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
         }
@@ -1063,17 +1075,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);
         }
     }
 
@@ -1349,7 +1369,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,
     };
@@ -3310,4 +3330,60 @@ 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));
+    }
 }
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/peers/src/lib.rs b/crates/net/peers/src/lib.rs
index fe02ffe59cc..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,6 +121,8 @@ 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 {
@@ -130,6 +132,7 @@ impl AnyNode {
         match self {
             Self::NodeRecord(record) => record.id,
             Self::PeerId(peer_id) => *peer_id,
+            Self::TrustedPeer(peer) => peer.id,
         }
     }
 
@@ -140,6 +143,7 @@ impl AnyNode {
             Self::NodeRecord(record) => record.id,
             Self::Enr(enr) => pk2id(&enr.public_key()),
             Self::PeerId(peer_id) => *peer_id,
+            Self::TrustedPeer(peer) => peer.id,
         }
     }
 
@@ -148,7 +152,7 @@ impl AnyNode {
     pub const fn node_record(&self) -> Option<NodeRecord> {
         match self {
             Self::NodeRecord(record) => Some(*record),
-            Self::PeerId(_) => None,
+            Self::PeerId(_) | Self::TrustedPeer(_) => None,
         }
     }
 
@@ -170,7 +174,15 @@ impl AnyNode {
                 .into_ipv4_mapped();
                 Some(node_record)
             }
-            Self::PeerId(_) => None,
+            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,
         }
     }
 }
@@ -196,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))
             }
@@ -219,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}"),
         }
     }
 }
@@ -342,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/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)
     }
 

From 788677a69e09a42e5d03c9bd3ee76d29633aa3d2 Mon Sep 17 00:00:00 2001
From: Veronica Hayes <veronicahayesvero@gmail.com>
Date: Sat, 23 May 2026 07:24:13 +0200
Subject: [PATCH 210/335] fix(engine): reject zero multiproof chunk size
 (#24390)

---
 crates/node/core/src/args/engine.rs | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/crates/node/core/src/args/engine.rs b/crates/node/core/src/args/engine.rs
index e1e08b28b32..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::{
@@ -383,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
@@ -875,6 +878,17 @@ 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 {

From 1914b26a48d35856dc193d722612177d58e62e22 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Sat, 23 May 2026 08:15:11 +0200
Subject: [PATCH 211/335] feat(evm): implement ExecutorTx for tx tuples
 (#24462)

---
 crates/evm/evm/src/execute.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/crates/evm/evm/src/execute.rs b/crates/evm/evm/src/execute.rs
index b89335f733a..658b1f5c5c8 100644
--- a/crates/evm/evm/src/execute.rs
+++ b/crates/evm/evm/src/execute.rs
@@ -436,6 +436,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

From ec9b772dca8fd1662bbd0baf7cec8db2ea416149 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Sat, 23 May 2026 16:59:55 +0200
Subject: [PATCH 212/335] fix(evm): use cached transaction hashes in chain
 (#24474)

---
 crates/evm/execution-types/src/chain.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/crates/evm/execution-types/src/chain.rs b/crates/evm/execution-types/src/chain.rs
index ec6b8b6eb54..ec93a8ef4e7 100644
--- a/crates/evm/execution-types/src/chain.rs
+++ b/crates/evm/execution-types/src/chain.rs
@@ -2,8 +2,11 @@
 
 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_consensus::{
+    transaction::{Recovered, TxHashRef},
+    BlockHeader, TxReceipt,
+};
+use alloy_eips::{eip1898::ForkBlock, BlockNumHash};
 use alloy_primitives::{Address, BlockHash, BlockNumber, Log, TxHash};
 use core::{fmt, ops::RangeInclusive};
 use reth_primitives_traits::{
@@ -291,10 +294,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 +305,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 +445,7 @@ 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()))
     }
 }
 

From 1a8f30e86da3f1d053046c43d06eec6196ab0507 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 25 May 2026 08:54:33 +0200
Subject: [PATCH 213/335] refactor(evm): add chain transaction hash iterator
 (#24493)

---
 crates/evm/execution-types/src/chain.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/crates/evm/execution-types/src/chain.rs b/crates/evm/execution-types/src/chain.rs
index ec93a8ef4e7..a5a1165e345 100644
--- a/crates/evm/execution-types/src/chain.rs
+++ b/crates/evm/execution-types/src/chain.rs
@@ -210,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,

From f68703f6505c42b46d1cecffc192c64318adaec5 Mon Sep 17 00:00:00 2001
From: Riyan Maulana <ridamichofi@gmail.com>
Date: Mon, 25 May 2026 10:54:53 +0400
Subject: [PATCH 214/335] docs(engine): fix is_opstack comment (#24498)

---
 crates/engine/tree/src/engine.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/engine/tree/src/engine.rs b/crates/engine/tree/src/engine.rs
index c15acfc227d..f7951426da1 100644
--- a/crates/engine/tree/src/engine.rs
+++ b/crates/engine/tree/src/engine.rs
@@ -232,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)
     }

From f148781d170502442a262747f34cd5052cef1b87 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 25 May 2026 09:04:59 +0200
Subject: [PATCH 215/335] perf(evm): preallocate chain transaction hashes
 (#24478)

---
 crates/evm/execution-types/src/chain.rs | 10 ++++++++++
 crates/transaction-pool/src/maintain.rs |  4 ++--
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/crates/evm/execution-types/src/chain.rs b/crates/evm/execution-types/src/chain.rs
index a5a1165e345..696e7570f17 100644
--- a/crates/evm/execution-types/src/chain.rs
+++ b/crates/evm/execution-types/src/chain.rs
@@ -452,6 +452,16 @@ impl<B: Block<Body: BlockBody<Transaction: SignedTransaction>>> ChainBlocks<'_,
             .values()
             .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
+    }
 }
 
 impl<B: Block> IntoIterator for ChainBlocks<'_, B> {
diff --git a/crates/transaction-pool/src/maintain.rs b/crates/transaction-pool/src/maintain.rs
index a0e632181c7..63ad765cbe5 100644
--- a/crates/transaction-pool/src/maintain.rs
+++ b/crates/transaction-pool/src/maintain.rs
@@ -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 {

From e85f1042a433540dec0a35d46e5bc17eba77883a Mon Sep 17 00:00:00 2001
From: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
Date: Mon, 25 May 2026 12:35:20 +0530
Subject: [PATCH 216/335] chore: use mainnet inplace of forks/osaka for hive
 (#24486)

---
 .github/scripts/hive/build_simulators.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/scripts/hive/build_simulators.sh b/.github/scripts/hive/build_simulators.sh
index 46f29bac05e..baad56dddaf 100755
--- a/.github/scripts/hive/build_simulators.sh
+++ b/.github/scripts/hive/build_simulators.sh
@@ -10,7 +10,7 @@ case "${fixture_variant}" in
         ;;
     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}"

From 578680aef612fc4f8eea215b3a3a264aef8ce366 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 25 May 2026 11:53:37 +0200
Subject: [PATCH 217/335] feat(txpool): add retain_contains helper (#24482)

---
 crates/transaction-pool/src/lib.rs      |  7 +++++++
 crates/transaction-pool/src/noop.rs     |  6 ++++++
 crates/transaction-pool/src/pool/mod.rs | 14 +++++++++++++-
 crates/transaction-pool/src/traits.rs   | 13 ++++++++++++-
 4 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/crates/transaction-pool/src/lib.rs b/crates/transaction-pool/src/lib.rs
index 4e37ade0e75..ad25bcf6232 100644
--- a/crates/transaction-pool/src/lib.rs
+++ b/crates/transaction-pool/src/lib.rs
@@ -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)
     }
diff --git a/crates/transaction-pool/src/noop.rs b/crates/transaction-pool/src/noop.rs
index e31534e175b..6f2c12af89e 100644
--- a/crates/transaction-pool/src/noop.rs
+++ b/crates/transaction-pool/src/noop.rs
@@ -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
     }
diff --git a/crates/transaction-pool/src/pool/mod.rs b/crates/transaction-pool/src/pool/mod.rs
index 2c6f3a68820..fadce19af1f 100644
--- a/crates/transaction-pool/src/pool/mod.rs
+++ b/crates/transaction-pool/src/pool/mod.rs
@@ -1113,7 +1113,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 +1125,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 b32eaa44ac3..c8b43ba5bb2 100644
--- a/crates/transaction-pool/src/traits.rs
+++ b/crates/transaction-pool/src/traits.rs
@@ -550,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()

From 00f9bd2a9cb277199f68f4d5fbfc71a3e382dd97 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 25 May 2026 11:52:49 +0200
Subject: [PATCH 218/335] fix: use tx_hash for transaction identity (#24494)

---
 Cargo.lock                                    |  1 -
 crates/chain-state/src/notifications.rs       |  7 +---
 crates/ethereum/node/tests/e2e/dev.rs         |  4 +-
 crates/net/eth-wire-types/src/transactions.rs |  8 ++--
 crates/prune/prune/Cargo.toml                 |  1 -
 crates/prune/prune/src/builder.rs             |  5 +--
 crates/prune/prune/src/segments/set.rs        |  3 +-
 .../src/segments/user/transaction_lookup.rs   | 15 ++++----
 crates/rpc/rpc-eth-types/src/logs_utils.rs    |  8 ++--
 crates/rpc/rpc-eth-types/src/transaction.rs   |  7 ++--
 crates/stages/stages/Cargo.toml               |  2 +-
 crates/stages/stages/src/stages/tx_lookup.rs  |  4 +-
 .../provider/src/providers/consistent.rs      | 12 +++---
 .../src/providers/rocksdb/invariants.rs       | 38 +++++++++----------
 .../provider/src/providers/static_file/jar.rs |  6 +--
 .../src/providers/static_file/manager.rs      | 33 +++++++---------
 .../transaction-pool/src/blobstore/tracker.rs |  5 +--
 17 files changed, 74 insertions(+), 85 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4d62695bd42..1603dc0d8de 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9611,7 +9611,6 @@ name = "reth-prune"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
- "alloy-eips",
  "alloy-primitives",
  "assert_matches",
  "itertools 0.14.0",
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/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/net/eth-wire-types/src/transactions.rs b/crates/net/eth-wire-types/src/transactions.rs
index f43e4e1d928..ebfe4f4e4ad 100644
--- a/crates/net/eth-wire-types/src/transactions.rs
+++ b/crates/net/eth-wire-types/src/transactions.rs
@@ -2,8 +2,8 @@
 
 use crate::broadcast::decode_list_with_memory_budget;
 use alloc::vec::Vec;
-use alloy_consensus::transaction::PooledTransaction;
-use alloy_eips::{eip2718::Encodable2718, eip7594::Cell};
+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};
@@ -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())
     }
 }
 
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/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/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/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/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/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/rocksdb/invariants.rs b/crates/storage/provider/src/providers/rocksdb/invariants.rs
index eb8e60e70b2..84291d29f44 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() {
@@ -632,7 +632,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 +759,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 +821,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 +972,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 +1010,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 +1045,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/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 57133bfc4fd..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;
@@ -2715,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,
@@ -2726,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,
@@ -2760,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())
@@ -2802,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)))
         })
     }
 
@@ -3004,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/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);

From e550355a95f3ec05043e4f33d0cca7eec1bc6ae3 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 25 May 2026 11:53:25 +0200
Subject: [PATCH 219/335] perf(txpool): add best transaction size hints
 (#24417)

---
 crates/transaction-pool/src/pool/best.rs | 108 +++++++++++++++++++++++
 1 file changed, 108 insertions(+)

diff --git a/crates/transaction-pool/src/pool/best.rs b/crates/transaction-pool/src/pool/best.rs
index 80d1e7d805d..9496b07e8b7 100644
--- a/crates/transaction-pool/src/pool/best.rs
+++ b/crates/transaction-pool/src/pool/best.rs
@@ -72,6 +72,11 @@ impl<T: TransactionOrdering> Iterator for BestTransactionsWithFees<T> {
             );
         }
     }
+
+    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*
@@ -287,6 +292,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
@@ -325,6 +334,11 @@ where
             );
         }
     }
+
+    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>
@@ -414,6 +428,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>
@@ -472,6 +496,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());

From b7a7a8a7295c4ea841d5960a7e39a473e7d7cebe Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 25 May 2026 11:56:02 +0200
Subject: [PATCH 220/335] fix(rpc): guard eth_callMany with blocking IO
 semaphore (#24499)

---
 crates/rpc/rpc-eth-api/src/helpers/call.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs
index 2ab5bf2d074..2a8d593bbe3 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/call.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/call.rs
@@ -316,6 +316,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();

From 6a5f3711609e88ec30e9dac5ef62e49dd45111dd Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 25 May 2026 11:59:39 +0200
Subject: [PATCH 221/335] fix(consensus): validate Amsterdam header fields
 (#24495)

---
 crates/consensus/consensus/src/lib.rs | 16 +++++
 crates/ethereum/consensus/src/lib.rs  | 97 +++++++++++++++++++++++++++
 2 files changed, 113 insertions(+)

diff --git a/crates/consensus/consensus/src/lib.rs b/crates/consensus/consensus/src/lib.rs
index 58070efad8b..25722c9ebc8 100644
--- a/crates/consensus/consensus/src/lib.rs
+++ b/crates/consensus/consensus/src/lib.rs
@@ -330,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,
@@ -338,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,
diff --git a/crates/ethereum/consensus/src/lib.rs b/crates/ethereum/consensus/src/lib.rs
index 316b2e43589..fb7749a9d09 100644
--- a/crates/ethereum/consensus/src/lib.rs
+++ b/crates/ethereum/consensus/src/lib.rs
@@ -235,6 +235,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() {
+                return Err(ConsensusError::BlockAccessListHashUnexpected)
+            }
+            if header.slot_number().is_some() {
+                return Err(ConsensusError::SlotNumberUnexpected)
+            }
+        }
+
         Ok(())
     }
 
@@ -270,6 +286,7 @@ 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;
@@ -283,6 +300,18 @@ 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()
+        }
+    }
+
     #[test]
     fn test_valid_gas_limit_increase() {
         let parent = header_with_gas_limit(GAS_LIMIT_BOUND_DIVISOR * 10);
@@ -365,4 +394,72 @@ 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_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 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());
+    }
 }

From 1ddac7135d4f782bf068ebdaf15c8bd040bd3579 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 25 May 2026 12:20:44 +0200
Subject: [PATCH 222/335] feat(evm): add WithTxEnv constructor (#24366)

---
 .../tree/src/tree/payload_processor/mod.rs      |  8 ++------
 crates/evm/evm/src/execute.rs                   | 17 ++++++++++++++++-
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_processor/mod.rs b/crates/engine/tree/src/tree/payload_processor/mod.rs
index ef9139f14b0..616ac20f3e6 100644
--- a/crates/engine/tree/src/tree/payload_processor/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/mod.rs
@@ -475,8 +475,7 @@ 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
                         });
@@ -779,10 +778,7 @@ 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()));
         }
diff --git a/crates/evm/evm/src/execute.rs b/crates/evm/evm/src/execute.rs
index 658b1f5c5c8..32b90d72e16 100644
--- a/crates/evm/evm/src/execute.rs
+++ b/crates/evm/evm/src/execute.rs
@@ -670,7 +670,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.
@@ -679,6 +682,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() }

From 37f700186bdf0d9c2586829d8c8e115d35ae4b86 Mon Sep 17 00:00:00 2001
From: tempoxyz-bot <github-svc@tempo.xyz>
Date: Mon, 25 May 2026 13:06:52 +0200
Subject: [PATCH 223/335] perf: reserve proof branch rlp nodes (#24469)

Co-authored-by: autoopt[bot] <autoopt@tempo.xyz>
Co-authored-by: Amp <amp@ampcode.com>
---
 crates/trie/trie/src/proof_v2/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/trie/trie/src/proof_v2/mod.rs b/crates/trie/trie/src/proof_v2/mod.rs
index 933e049c254..7a8cd904a89 100644
--- a/crates/trie/trie/src/proof_v2/mod.rs
+++ b/crates/trie/trie/src/proof_v2/mod.rs
@@ -535,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,
@@ -554,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"
         );
 

From f2d2bd23306801f7ba8f7380ab9740dead844c4a Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 25 May 2026 13:32:28 +0200
Subject: [PATCH 224/335] fix(rpc): guard eth_simulateV1 with blocking IO
 semaphore (#24503)

---
 crates/rpc/rpc-eth-api/src/helpers/call.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs
index 2a8d593bbe3..6ab40a768b7 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/call.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/call.rs
@@ -89,6 +89,8 @@ 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();

From 0720dcd379d3cd5a1eb8187389063c9351181bb6 Mon Sep 17 00:00:00 2001
From: tempoxyz-bot <github-svc@tempo.xyz>
Date: Mon, 25 May 2026 13:40:17 +0200
Subject: [PATCH 225/335] perf: fast-path forward cursor seeks (#24442)

Co-authored-by: autoopt[bot] <autoopt@tempo.xyz>
Co-authored-by: Amp <amp@ampcode.com>
---
 crates/trie/trie/src/forward_cursor.rs | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

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

From cb75145118a92f321c6f61fa8f807029e23ff6ea Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Mon, 25 May 2026 04:44:18 -0700
Subject: [PATCH 226/335] ci: suppress mixed bench on-win Slack notifications
 (#24504)

---
 .github/scripts/bench-slack-notify.js | 14 ++++++--------
 .github/scripts/bench-utils.js        |  6 ++++++
 .github/workflows/bench-scheduled.yml |  9 ++++-----
 3 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/.github/scripts/bench-slack-notify.js b/.github/scripts/bench-slack-notify.js
index f81835f8827..40726dddaf8 100644
--- a/.github/scripts/bench-slack-notify.js
+++ b/.github/scripts/bench-slack-notify.js
@@ -18,7 +18,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { fmtChange, fmtMs, verdict, loadSamplyUrls, blocksLabel, metricRows } = require('./bench-utils');
+const { fmtChange, fmtMs, verdict, isWin, loadSamplyUrls, blocksLabel, metricRows } = require('./bench-utils');
 
 const SLACK_API = 'https://slack.com/api/chat.postMessage';
 
@@ -263,24 +263,22 @@ async function success({ core, context }) {
 
   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.informational && c.sig === 'good');
-    if (hasImprovement) {
+    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;
   }
diff --git a/.github/scripts/bench-utils.js b/.github/scripts/bench-utils.js
index 5ae3412e264..3d9a782b34e 100644
--- a/.github/scripts/bench-utils.js
+++ b/.github/scripts/bench-utils.js
@@ -33,6 +33,11 @@ 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) {
   const urls = {};
   let runs = [];
@@ -122,6 +127,7 @@ module.exports = {
   fmtS,
   fmtChange,
   verdict,
+  isWin,
   loadSamplyUrls,
   blocksLabel,
   metricRows,
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 9100231abbb..066679e1e4d 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -832,7 +832,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;
@@ -854,11 +854,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;
             }
 

From dfd0148600a65b2e6b9d9e9b163fb90d813155c1 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 25 May 2026 13:51:16 +0200
Subject: [PATCH 227/335] fix(rpc): preserve legacy block rlp serialization
 (#24505)

---
 crates/rpc/rpc-api/src/reth_engine.rs | 56 +++++++++++++++++++++++----
 1 file changed, 48 insertions(+), 8 deletions(-)

diff --git a/crates/rpc/rpc-api/src/reth_engine.rs b/crates/rpc/rpc-api/src/reth_engine.rs
index ae641057659..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, Deserializer, Serialize};
+use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
 
 /// Reth-specific payload status that includes server-measured execution latency.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -31,8 +31,7 @@ pub struct RethPayloadStatus {
 
 /// Input for `reth_newPayload` that accepts either `ExecutionData` directly or an RLP-encoded
 /// block with optional side data.
-#[derive(Debug, Clone, Serialize)]
-#[serde(untagged)]
+#[derive(Debug, Clone)]
 pub enum RethNewPayloadInput<ExecutionData> {
     /// Standard execution data (payload + sidecar).
     ExecutionData(ExecutionData),
@@ -41,11 +40,31 @@ pub enum RethNewPayloadInput<ExecutionData> {
         /// RLP-encoded block bytes.
         block: Bytes,
         /// RLP-encoded block access list bytes.
-        #[serde(default, skip_serializing_if = "Option::is_none")]
         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>,
@@ -130,15 +149,36 @@ mod tests {
             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_value::<RethNewPayloadInput<TestExecutionData>>(json!({
-            "block": "0x01"
-        }))
-        .unwrap();
+        let input =
+            serde_json::from_str::<RethNewPayloadInput<TestExecutionData>>(r#"{"block":"0x01"}"#)
+                .unwrap();
 
         let RethNewPayloadInput::BlockRlp { block, bal } = input else {
             panic!("expected block rlp input")

From 4da25612f1438dd1a99efec974ef439ff14c7361 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 25 May 2026 14:02:19 +0200
Subject: [PATCH 228/335] feat(trie): add open-ended ordered root builder
 (#24419)

---
 Cargo.lock                                    |   1 +
 crates/trie/common/Cargo.toml                 |   5 +
 crates/trie/common/src/lib.rs                 |   3 +
 .../common/src/open_ended_ordered_root.rs     | 150 ++++++++++++++++++
 .../common/tests/open_ended_ordered_root.rs   | 142 +++++++++++++++++
 5 files changed, 301 insertions(+)
 create mode 100644 crates/trie/common/src/open_ended_ordered_root.rs
 create mode 100644 crates/trie/common/tests/open_ended_ordered_root.rs

diff --git a/Cargo.lock b/Cargo.lock
index 1603dc0d8de..e6feb5eb5cc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10480,6 +10480,7 @@ name = "reth-trie-common"
 version = "2.2.0"
 dependencies = [
  "alloy-consensus",
+ "alloy-eips",
  "alloy-genesis",
  "alloy-primitives",
  "alloy-rlp",
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/lib.rs b/crates/trie/common/src/lib.rs
index 1ac046d5e0d..d7e30b2bc4d 100644
--- a/crates/trie/common/src/lib.rs
+++ b/crates/trie/common/src/lib.rs
@@ -75,6 +75,9 @@ pub mod root;
 /// Incremental ordered trie root computation.
 pub mod ordered_root;
 
+/// Open-ended incremental ordered trie root computation.
+pub mod open_ended_ordered_root;
+
 /// Buffer for trie updates.
 pub mod updates;
 
diff --git a/crates/trie/common/src/open_ended_ordered_root.rs b/crates/trie/common/src/open_ended_ordered_root.rs
new file mode 100644
index 00000000000..1c0b6e3d8d9
--- /dev/null
+++ b/crates/trie/common/src/open_ended_ordered_root.rs
@@ -0,0 +1,150 @@
+//! Open-ended incremental ordered trie root computation.
+//!
+//! Ethereum block transaction and receipt roots are ordered trie roots keyed by the RLP encoding of
+//! each item index.
+//! [`OrderedTrieRootEncodedBuilder`](crate::ordered_root::OrderedTrieRootEncodedBuilder)
+//! requires the total number of items up front because it accepts out-of-order items and must know
+//! the final RLP key order before it can flush buffered leaves.
+//!
+//! [`OpenEndedOrderedTrieRootEncodedBuilder`](crate::open_ended_ordered_root::OpenEndedOrderedTrieRootEncodedBuilder)
+//! is for the append-only case where items are received in their final contiguous order, but the
+//! final item count is not known until the stream ends. This is useful while building a block: once
+//! a transaction is committed at the next block index, its encoded transaction and receipt can be
+//! consumed immediately without waiting to know how many transactions will eventually land in the
+//! block.
+//!
+//! # 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::open_ended_ordered_root::OpenEndedOrderedTrieRootEncodedBuilder;
+//!
+//! let mut builder = OpenEndedOrderedTrieRootEncodedBuilder::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;
+
+/// First index whose RLP-encoded key sorts after index 0.
+///
+/// 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.
+///
+/// Unlike [`OrderedTrieRootEncodedBuilder`](crate::ordered_root::OrderedTrieRootEncodedBuilder),
+/// this type does not require the total item count up front. It relies on a stricter input
+/// contract instead: every pushed item must be the next contiguous item in the final list.
+///
+/// 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 OpenEndedOrderedTrieRootEncodedBuilder {
+    /// Number of items pushed so far. This is also the next append-only index.
+    len: usize,
+    /// 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 OpenEndedOrderedTrieRootEncodedBuilder {
+    /// Creates an empty builder.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Pushes the next pre-encoded item.
+    ///
+    /// Items must be pushed in their final contiguous order.
+    #[inline]
+    pub fn push_next(&mut self, bytes: &[u8]) {
+        let index = self.len;
+        self.len += 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 the number of items pushed so far.
+    #[inline]
+    pub const fn pushed_count(&self) -> usize {
+        self.len
+    }
+
+    /// Returns `true` if no items have been pushed.
+    #[inline]
+    pub const fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    /// Finalizes the builder and returns the trie root.
+    ///
+    /// 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 EMPTY_ROOT_HASH;
+        }
+
+        self.flush_zero();
+        self.hb.root()
+    }
+
+    fn flush_zero(&mut self) {
+        if self.zero.is_none() {
+            return;
+        }
+
+        let zero = self.zero.take().expect("index 0 must be buffered before it is flushed");
+        self.add_leaf(0, &zero);
+    }
+
+    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);
+    }
+}
diff --git a/crates/trie/common/tests/open_ended_ordered_root.rs b/crates/trie/common/tests/open_ended_ordered_root.rs
new file mode 100644
index 00000000000..29f636ddea3
--- /dev/null
+++ b/crates/trie/common/tests/open_ended_ordered_root.rs
@@ -0,0 +1,142 @@
+//! Tests for open-ended ordered trie root computation.
+
+use alloy_primitives::B256;
+use alloy_trie::root::ordered_trie_root_encoded;
+use proptest::prelude::*;
+use reth_trie_common::{
+    open_ended_ordered_root::OpenEndedOrderedTrieRootEncodedBuilder, EMPTY_ROOT_HASH,
+};
+
+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 = OpenEndedOrderedTrieRootEncodedBuilder::new();
+    for item in items {
+        builder.push_next(item);
+    }
+    builder.finalize()
+}
+
+#[test]
+fn empty_builder_returns_empty_root() {
+    let builder = OpenEndedOrderedTrieRootEncodedBuilder::new();
+
+    assert!(builder.is_empty());
+    assert_eq!(builder.pushed_count(), 0);
+    assert_eq!(builder.finalize(), EMPTY_ROOT_HASH);
+}
+
+#[test]
+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 short_lists_flush_zero_on_finalize() {
+    for len in 1..=128 {
+        let items = items(len);
+        let expected = ordered_trie_root_encoded(&items);
+
+        let mut builder = OpenEndedOrderedTrieRootEncodedBuilder::new();
+        for item in &items {
+            builder.push_next(item);
+        }
+
+        assert_eq!(builder.pushed_count(), len);
+        assert_eq!(builder.finalize(), expected, "mismatch for short len={len}");
+    }
+}
+
+#[test]
+fn long_lists_flush_zero_when_index_128_arrives() {
+    let items = items(129);
+    let expected = ordered_trie_root_encoded(&items);
+
+    let mut builder = OpenEndedOrderedTrieRootEncodedBuilder::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);
+    }
+}
+
+#[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 = OpenEndedOrderedTrieRootEncodedBuilder::new();
+        let mut buf = Vec::new();
+
+        for item in items {
+            buf.clear();
+            item.encode_2718(&mut buf);
+            builder.push_next(&buf);
+        }
+
+        builder.finalize()
+    }
+
+    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);
+        }
+    }
+}

From 278c60216f1cd9a13c4159b5db54c43f54e8609a Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 May 2026 16:33:56 +0400
Subject: [PATCH 229/335] fix: recompute hashed state on state root task
 failures (#24506)

---
 .../engine/tree/src/tree/payload_validator.rs | 149 +++++++++++-------
 1 file changed, 90 insertions(+), 59 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index b012e78d9f4..1a224408db9 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -566,7 +566,7 @@ where
         let hashed_state_output = output.clone();
         let hashed_state_provider = self.provider.clone();
         let mut hashed_state_rx = handle.take_hashed_state_rx();
-        let hashed_state: LazyHashedPostState =
+        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",
@@ -603,19 +603,30 @@ where
                 .ok()
         };
 
-        let hashed_state = ensure_ok_post_block!(
+        ensure_ok_post_block!(
             self.validate_post_execution(
                 &block,
                 &parent_block,
                 &output,
                 &mut ctx,
                 receipt_root_bloom,
-                hashed_state,
                 block_access_list_hash
             ),
             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;
@@ -630,18 +641,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");
 
@@ -656,7 +670,7 @@ where
                                 provider_builder.clone(),
                                 provider_factory,
                                 overlay_builder,
-                                &hashed_state,
+                                &output,
                                 trie_updates.as_ref().clone(),
                             );
                             #[cfg(feature = "trie-debug")]
@@ -685,11 +699,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 => {
@@ -759,6 +790,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());
@@ -1320,16 +1357,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())))
             }
@@ -1341,13 +1380,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);
                 });
@@ -1362,7 +1404,7 @@ where
                                 source = "task",
                                 "State root timeout race won"
                             );
-                            return Ok(result);
+                            return Ok(result.map(|outcome| (outcome, None)));
                         }
                         Err(RecvTimeoutError::Disconnected) => {
                             debug!(
@@ -1374,13 +1416,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) => {}
                     }
@@ -1391,13 +1436,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),
+                        )));
                     }
                 }
             }
@@ -1415,15 +1463,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",
@@ -1522,7 +1570,6 @@ 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>,
@@ -1530,9 +1577,8 @@ where
         output: &BlockExecutionOutput<N::Receipt>,
         ctx: &mut TreeCtx<'_, N>,
         receipt_root_bloom: Option<ReceiptRootBloom>,
-        hashed_state: LazyHashedPostState,
         block_access_list_hash: Option<B256>,
-    ) -> Result<LazyHashedPostState, InsertBlockErrorKind>
+    ) -> Result<(), InsertBlockErrorKind>
     where
         V: PayloadValidator<T, Block = N::Block>,
     {
@@ -1556,28 +1602,13 @@ where
         }
         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 _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)
-        {
-            // call post-block hook
-            self.on_invalid_block(parent_block, block, output, None, ctx.state_mut());
-            return Err(err.into())
-        }
-
         // record post-execution validation duration
         self.metrics
             .block_validation
             .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.

From 52a259237e4866c1857b5a8ba9f153bfdb38df46 Mon Sep 17 00:00:00 2001
From: cui <cuiweixie@gmail.com>
Date: Mon, 25 May 2026 20:38:31 +0800
Subject: [PATCH 230/335] fix(stages): fix off-by-one bug (#24267)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/stages/stages/src/stages/merkle.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

From 99425616f06be6ae2affd448abe175f3fd3df9e6 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 May 2026 17:35:49 +0400
Subject: [PATCH 231/335] feat: support disabling pipeline stages (#24436)

---
 crates/node/builder/src/launch/common.rs | 52 +++++++++++++++---------
 crates/node/builder/src/launch/engine.rs | 37 +++++++++++------
 crates/node/builder/src/node.rs          |  5 +++
 crates/node/builder/src/setup.rs         |  8 +++-
 4 files changed, 68 insertions(+), 34 deletions(-)

diff --git a/crates/node/builder/src/launch/common.rs b/crates/node/builder/src/launch/common.rs
index c963618d25e..dca47987689 100644
--- a/crates/node/builder/src/launch/common.rs
+++ b/crates/node/builder/src/launch/common.rs
@@ -78,7 +78,7 @@ 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;
@@ -477,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>,
@@ -557,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()),
@@ -594,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),
@@ -937,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)
@@ -989,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/engine.rs b/crates/node/builder/src/launch/engine.rs
index 0dbd65017c2..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},
@@ -64,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>>
@@ -91,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
@@ -104,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");
             })
@@ -162,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.
@@ -282,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()
@@ -430,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/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);
 

From 0363b5cce6161e34b68fd72787c5b1647fe4d022 Mon Sep 17 00:00:00 2001
From: 0xsensei <prblmslvr.aditya@gmail.com>
Date: Mon, 25 May 2026 19:20:59 +0530
Subject: [PATCH 232/335] perf(network): use FbBuildHasher for transaction
 manager maps (#24497)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/network/src/cache.rs               | 35 +++++++++---
 .../network/src/test_utils/transactions.rs    |  2 +-
 .../net/network/src/transactions/fetcher.rs   | 53 +++++++++++++------
 crates/net/network/src/transactions/mod.rs    | 20 ++++---
 4 files changed, 80 insertions(+), 30 deletions(-)

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/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 477a6c8d263..d4931c9d42d 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,
@@ -551,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:#}"),
@@ -686,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 };
@@ -992,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(),
@@ -1010,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
@@ -1020,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
     }
 
diff --git a/crates/net/network/src/transactions/mod.rs b/crates/net/network/src/transactions/mod.rs
index 6a9bd67f78c..ca9fe755680 100644
--- a/crates/net/network/src/transactions/mod.rs
+++ b/crates/net/network/src/transactions/mod.rs
@@ -37,7 +37,10 @@ use crate::{
     transactions::config::{StrictEthAnnouncementFilter, TransactionPropagationKind},
     NetworkHandle, TxTypesCounter,
 };
-use alloy_primitives::{TxHash, B256};
+use alloy_primitives::{
+    map::{B256Map, 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::{
@@ -293,7 +296,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 +312,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 +405,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),
@@ -2035,7 +2038,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.
@@ -2056,7 +2059,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,
@@ -2070,7 +2076,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
     }
 

From 3f8762d923866d83f1d2fe5714abde1ae1a88605 Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Mon, 25 May 2026 15:58:01 +0200
Subject: [PATCH 233/335] chore(bench): raise significance floors (#24511)

Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
---
 .github/scripts/bench-reth-summary.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/scripts/bench-reth-summary.py b/.github/scripts/bench-reth-summary.py
index 95e44462ae8..cefa5a1c265 100755
--- a/.github/scripts/bench-reth-summary.py
+++ b/.github/scripts/bench-reth-summary.py
@@ -31,11 +31,11 @@
 PERSIST_WAIT_MIN_VERDICT_MS = 0.5
 PERSIST_WAIT_MIN_TOTAL_PCT = 0.1
 PRACTICAL_FLOOR_PCT = {
-    "mean": 0.70,
-    "p50": 0.70,
+    "mean": 1.20,
+    "p50": 1.20,
     "p90": 1.35,
     "p99": 5.0,
-    "mgas_s": 0.45,
+    "mgas_s": 1.20,
     "wall_clock": 0.70,
     "persist_wait": 5.0,
 }

From c179be80e06695704999be529010d5dd5a12b94e Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Mon, 25 May 2026 23:55:26 +0900
Subject: [PATCH 234/335] =?UTF-8?q?fix:=20=F0=9F=87=B5=F0=9F=87=B1=20polis?=
 =?UTF-8?q?h=20BAL=20error=20story=20(#24061)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 crates/consensus/consensus/src/lib.rs         |   7 +-
 crates/engine/tree/src/tree/error.rs          |  18 +--
 .../src/tree/payload_processor/bal/error.rs   |  41 ++---
 .../src/tree/payload_processor/bal/execute.rs | 151 ++++++++++--------
 .../src/tree/payload_processor/bal/mod.rs     |   3 +-
 .../payload_processor/bal/ordered_outputs.rs  | 104 +++++++-----
 .../src/tree/payload_processor/bal/worker.rs  |  33 +++-
 .../engine/tree/src/tree/payload_validator.rs |  66 ++++----
 8 files changed, 236 insertions(+), 187 deletions(-)

diff --git a/crates/consensus/consensus/src/lib.rs b/crates/consensus/consensus/src/lib.rs
index 25722c9ebc8..59ab0354b38 100644
--- a/crates/consensus/consensus/src/lib.rs
+++ b/crates/consensus/consensus/src/lib.rs
@@ -492,12 +492,15 @@ pub enum ConsensusError {
     /// EIP-7825: Transaction gas limit exceeds maximum allowed
     #[error(transparent)]
     TransactionGasLimitTooHigh(Box<TxGasLimitTooHighErr>),
-    /// Error when an unexpected block access list cost is encountered.
+    /// EIP-7928: Error when an unexpected block access list cost is encountered.
     #[error(transparent)]
     BlockAccessListCostMoreThanGasLimit(Box<BlockAccessListGasError>),
-    /// Error when the block access list hash doesn't match the expected value.
+    /// 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>),
diff --git a/crates/engine/tree/src/tree/error.rs b/crates/engine/tree/src/tree/error.rs
index 5110fa8b0d7..de04e4338a2 100644
--- a/crates/engine/tree/src/tree/error.rs
+++ b/crates/engine/tree/src/tree/error.rs
@@ -117,10 +117,6 @@ pub enum InsertBlockErrorKind {
     /// Provider error.
     #[error(transparent)]
     Provider(#[from] ProviderError),
-    /// BAL-driven block execution rejected the block. Covers structural BAL errors and the
-    /// final-hash mismatch.
-    #[error(transparent)]
-    InvalidBlockAccessList(BalExecutionError),
     /// Other errors.
     #[error(transparent)]
     Other(#[from] Box<dyn core::error::Error + Send + Sync + 'static>),
@@ -129,11 +125,10 @@ pub enum InsertBlockErrorKind {
 impl From<BalExecutionError> for InsertBlockErrorKind {
     fn from(e: BalExecutionError) -> Self {
         match e {
-            // Worker EVM errors flow through the standard execution-error path so existing
-            // metrics and routing apply.
-            BalExecutionError::Evm(inner) => Self::Execution(inner),
+            BalExecutionError::Consensus(inner) => Self::Consensus(inner),
+            BalExecutionError::Execution(inner) => Self::Execution(inner),
             BalExecutionError::Provider(inner) => Self::Provider(inner),
-            other => Self::InvalidBlockAccessList(other),
+            BalExecutionError::Other(inner) => Self::Other(inner),
         }
     }
 }
@@ -164,9 +159,6 @@ impl InsertBlockErrorKind {
                 }
             }
             Self::Provider(err) => Err(InsertBlockFatalError::Provider(err)),
-            Self::InvalidBlockAccessList(err) => {
-                Ok(InsertBlockValidationError::InvalidBlockAccessList(err))
-            }
             Self::Other(err) => Err(InternalBlockExecutionError::Other(err).into()),
         }
     }
@@ -192,10 +184,6 @@ pub enum InsertBlockValidationError {
     /// Validation error, transparently wrapping [`BlockValidationError`]
     #[error(transparent)]
     Validation(#[from] BlockValidationError),
-    /// BAL-driven block execution rejected the block. Covers structural BAL errors and the
-    /// final-hash mismatch.
-    #[error(transparent)]
-    InvalidBlockAccessList(BalExecutionError),
 }
 
 /// Errors that may occur when inserting a payload.
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/error.rs b/crates/engine/tree/src/tree/payload_processor/bal/error.rs
index 5c99954d87e..ffd3b7310eb 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/error.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/error.rs
@@ -1,43 +1,32 @@
 //! Errors for the BAL execution path.
 
 use alloy_evm::block::BlockExecutionError;
-use alloy_primitives::B256;
+use reth_consensus::ConsensusError;
 use reth_provider::ProviderError;
 
 /// Errors surfaced by `execute_block`.
 #[derive(Debug, thiserror::Error)]
 pub enum BalExecutionError {
-    /// BAL-specific rejection.
-    #[error("BAL rejection: {0:?}")]
-    Reject(RejectReason),
+    /// Block violated consensus rules while running the BAL path.
+    #[error(transparent)]
+    Consensus(#[from] ConsensusError),
     /// Worker or canonical EVM failure.
-    ///
-    /// This includes revm `BalError` for undeclared accesses. Revm does not yet report the
-    /// offending address or storage slot here.
     #[error("evm execution failed: {0}")]
-    Evm(#[from] BlockExecutionError),
+    Execution(#[from] BlockExecutionError),
     /// Provider setup failed before EVM execution could start.
     #[error("provider setup failed: {0}")]
     Provider(#[from] ProviderError),
-    /// The received BAL could not be converted from alloy-format to revm-format.
-    #[error("alloy→revm BAL conversion failed: {0}")]
-    BalConversion(String),
+    /// BAL execution failed before it reached EVM execution.
+    #[error(transparent)]
+    Other(#[from] Box<dyn core::error::Error + Send + Sync + 'static>),
 }
 
-impl From<RejectReason> for BalExecutionError {
-    fn from(r: RejectReason) -> Self {
-        Self::Reject(r)
+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())
     }
 }
-
-/// Reasons a block may be rejected on the BAL execution path.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum RejectReason {
-    /// The rebuilt BAL disagrees with the received BAL at end-of-block.
-    FinalHashMismatch {
-        /// Hash of the rebuilt BAL.
-        rebuilt: B256,
-        /// Hash of the received BAL.
-        expected: B256,
-    },
-}
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
index 76078b4447b..4dd1b79c7b3 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
@@ -10,14 +10,14 @@
 //! worker results in transaction order, tracks block gas admission, and builds the BAL that this
 //! execution actually produced.
 //!
-//! The final hash check compares that rebuilt BAL with the header commitment. The outer payload
-//! validator still handles consensus checks, receipt-root validation, state-root work, and block
-//! insertion.
+//! 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, RejectReason};
+use super::{ordered_outputs::ordered_worker_outputs, worker, BalExecutionError};
 use alloy_eip7928::{
     bal::{Bal as AlloyBal, DecodedBal},
-    compute_block_access_list_hash,
+    compute_block_access_list_hash, BlockAccessList,
 };
 use alloy_evm::{
     block::{BlockExecutionError, BlockExecutor, BlockValidationError, TxResult},
@@ -30,6 +30,7 @@ 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},
     primitives::{eip7825::TX_GAS_LIMIT_CAP, hardfork::SpecId},
@@ -51,7 +52,10 @@ pub fn execute_block<'a, Evm, Tx, Err, DB, MakeDb>(
     transaction_count: usize,
     txs: Receiver<(usize, Result<Tx, Err>)>,
     receipt_tx: Sender<IndexedReceipt<ReceiptTy<Evm::Primitives>>>,
-) -> Result<(BlockExecutionOutput<ReceiptTy<Evm::Primitives>>, Vec<Address>), BalExecutionError>
+) -> Result<
+    (BlockExecutionOutput<ReceiptTy<Evm::Primitives>>, Vec<Address>, BlockAccessList),
+    BalExecutionError,
+>
 where
     Evm: ConfigureEvm + 'static,
     Tx: ExecutableTxFor<Evm> + Send + 'a,
@@ -91,7 +95,10 @@ fn execute_block_inner<'scope, Evm, Tx, Err, DB, MakeDb>(
     txs: Receiver<(usize, Result<Tx, Err>)>,
     receipt_tx: Sender<IndexedReceipt<ReceiptTy<Evm::Primitives>>>,
     worker_count: usize,
-) -> Result<(BlockExecutionOutput<ReceiptTy<Evm::Primitives>>, Vec<Address>), BalExecutionError>
+) -> Result<
+    (BlockExecutionOutput<ReceiptTy<Evm::Primitives>>, Vec<Address>, BlockAccessList),
+    BalExecutionError,
+>
 where
     Evm: ConfigureEvm + 'scope,
     Tx: ExecutableTxFor<Evm> + Send + 'scope,
@@ -101,13 +108,8 @@ where
     ReceiptTy<Evm::Primitives>: Clone,
 {
     let bal = input_bal.as_bal();
-    let input_bal_revm: Arc<RevmBal> = Arc::new(
-        RevmBal::try_from(Vec::<_>::from(bal.clone()))
-            .map_err(|e| BalExecutionError::BalConversion(format!("{e:?}")))?,
-    );
+    let input_bal_revm = convert_alloy_to_revm_bal(bal)?;
 
-    // NOTE: technically Amsterdam implies BAL (the current path) we are on.
-    // TODO: should we do this
     let is_amsterdam = evm_env.cfg_env.spec.into().is_enabled_in(SpecId::AMSTERDAM);
     let block_gas_limit = evm_env.block_env.gas_limit();
     let mut canonical_state =
@@ -140,10 +142,6 @@ where
         canonical_executor.apply_pre_execution_changes()?;
         let mut senders = Vec::with_capacity(transaction_count);
         let mut last_sent_len = 0usize;
-        // `DecodedBal::hash` is lazy-cached. Compute the hash after workers are spawned and before
-        // waiting on ordered results, so the callsite can read the header commitment hash once
-        // execution finishes without adding serial work after the BAL equality check.
-        let _ = input_bal.hash();
         for output in ordered_worker_outputs(&result_rx, transaction_count) {
             let output = output?;
 
@@ -170,15 +168,39 @@ where
         (block_result, senders)
     };
 
-    validate_bal(&mut canonical_state, input_bal.as_ref())?;
+    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 load_bal_accounts<DB>(
     canonical_state: &mut State<DB>,
     bal: &AlloyBal,
@@ -196,49 +218,36 @@ where
     for account_changes in bal {
         canonical_state
             .load_cache_account(account_changes.address)
-            .map_err(|e| BalExecutionError::Evm(BlockExecutionError::other(e)))?;
+            .map_err(|e| BalExecutionError::Execution(BlockExecutionError::other(e)))?;
     }
 
     Ok(())
 }
 
-/// Validates that execution rebuilt the same BAL that was provided with the payload.
-///
-/// This consumes the BAL built by `canonical_state` and compares it against the decoded input
-/// BAL before post-execution validation relies on `DecodedBal::hash()` as the header commitment.
-pub(crate) fn validate_bal<DB>(
+fn take_built_bal_and_log_divergence<DB>(
     canonical_state: &mut State<DB>,
-    input_bal: &DecodedBal,
-) -> Result<(), BalExecutionError>
+    received_bal: &AlloyBal,
+) -> BlockAccessList
 where
     DB: Database,
 {
-    let composed_alloy = canonical_state.take_built_alloy_bal().expect("with_bal_builder set");
-    let input_bal_entries = input_bal.as_bal();
-    if composed_alloy == input_bal_entries.as_slice() {
-        return Ok(());
-    }
-    let rebuilt = compute_block_access_list_hash(&composed_alloy);
-    let expected_bal_hash = input_bal.hash();
-
-    if tracing::enabled!(
-        target: "engine::tree::payload_processor::bal",
-        tracing::Level::DEBUG
-    ) {
-        let div = input_bal_entries.diff(&composed_alloy);
+    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 = %expected_bal_hash,
+            %expected,
             %div,
             "first BAL divergence",
         );
     }
 
-    Err(BalExecutionError::Reject(RejectReason::FinalHashMismatch {
-        rebuilt,
-        expected: expected_bal_hash,
-    }))
+    built_bal
 }
 
 /// Closes the abort channel on drop, waking scoped workers before the scope exits.
@@ -298,7 +307,7 @@ impl BlockGasTracker {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy_consensus::{BlockHeader, EthereumReceipt, Header};
+    use alloy_consensus::{BlockHeader, Header};
     use alloy_eip7928::{bal::Bal as AlloyBal, BlockAccessList};
     use alloy_eips::{
         eip2935::{HISTORY_STORAGE_ADDRESS, HISTORY_STORAGE_CODE},
@@ -306,7 +315,7 @@ mod tests {
         eip7002::{WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_PREDEPLOY_CODE},
     };
     use alloy_primitives::{keccak256, B256, U256};
-    use reth_ethereum_primitives::{Block, BlockBody, TransactionSigned};
+    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;
@@ -473,7 +482,24 @@ mod tests {
         input_bal: Arc<DecodedBal>,
         block: &SealedBlock<Block>,
         txs: Vec<Tx>,
-    ) -> Result<BlockExecutionOutput<EthereumReceipt>, BalExecutionError>
+    ) -> 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,
@@ -494,7 +520,7 @@ mod tests {
             tx_stream(txs),
             receipt_tx,
         )
-        .map(|(output, _)| output)
+        .map(|(output, _, built_bal)| (output, built_bal))
     }
 
     /// Inserts `AccountInfo { nonce: 0, balance }` for `addr` into the canonical DB.
@@ -890,7 +916,7 @@ mod tests {
         );
 
         match result {
-            Err(BalExecutionError::Evm(err)) => assert!(matches!(
+            Err(BalExecutionError::Execution(err)) => assert!(matches!(
                 err.as_validation(),
                 Some(BlockValidationError::TransactionGasLimitMoreThanAvailableBlockGas { .. })
             )),
@@ -1018,10 +1044,10 @@ mod tests {
     }
 
     #[test]
-    fn rejects_final_hash_mismatch() {
+    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, so the final hash check
-        // must fail.
+        // 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();
@@ -1047,7 +1073,7 @@ mod tests {
             Arc::new(DecodedBal::new(tampered_bal, raw))
         };
 
-        let result = run_execute_block(
+        let result = run_execute_block_full(
             &Runtime::test(),
             evm_config,
             db_factory(system_contracts_db()),
@@ -1057,14 +1083,11 @@ mod tests {
         );
 
         match result {
-            Err(BalExecutionError::Reject(RejectReason::FinalHashMismatch {
-                rebuilt,
-                expected,
-            })) => {
-                assert_ne!(rebuilt, expected, "rebuilt and expected hashes must differ");
+            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 FinalHashMismatch, got {e:?}"),
-            Ok(_) => panic!("expected FinalHashMismatch, got Ok"),
+            Err(e) => panic!("expected success with rebuilt BAL, got {e:?}"),
         }
     }
 
@@ -1095,9 +1118,9 @@ mod tests {
     }
 
     #[test]
-    fn worker_tx_recovery_error_becomes_evm_error() {
+    fn worker_tx_recovery_error_becomes_other_error() {
         // A tx recovery failure fed into the worker channel must surface as
-        // BalExecutionError::Evm. Uses execute_block directly since tx_stream hardcodes
+        // 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);
@@ -1126,8 +1149,8 @@ mod tests {
         );
 
         assert!(
-            matches!(result, Err(BalExecutionError::Evm(_))),
-            "expected Evm error from tx recovery failure, got {result:?}",
+            matches!(result, Err(BalExecutionError::Other(_))),
+            "expected Other error from tx recovery failure, got {result:?}",
         );
     }
 
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/mod.rs b/crates/engine/tree/src/tree/payload_processor/bal/mod.rs
index 35aea31a60b..beef5832931 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/mod.rs
@@ -14,6 +14,5 @@ mod worker;
 pub mod error;
 pub mod execute;
 
-pub use error::{BalExecutionError, RejectReason};
+pub use error::BalExecutionError;
 pub use execute::execute_block;
-pub(crate) use execute::validate_bal;
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
index ab6fa364d48..bed19ef85f4 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/ordered_outputs.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/ordered_outputs.rs
@@ -1,33 +1,52 @@
 //! Ordering adapter for speculative BAL worker results.
 
-use super::{worker::BalWorkerOutput, BalExecutionError};
-use alloy_evm::block::BlockExecutionError;
+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.
 ///
-/// Contract for callers:
+/// Behavior:
 /// - each yielded `Ok` output has the next transaction index
 /// - worker errors are forwarded unchanged
-/// - closed channels before `total` outputs, out-of-bounds indices, and duplicate indices yield
-///   `Err`
+/// - 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
-///
-/// Callers that intentionally abort workers must stop polling this iterator after initiating
-/// abort. Before `total` outputs are yielded, channel closure is treated as an execution error.
 pub(super) fn ordered_worker_outputs<R>(
-    result_rx: &Receiver<Result<BalWorkerOutput<R>, BalExecutionError>>,
+    result_rx: &Receiver<Result<BalWorkerOutput<R>, BalWorkerError>>,
     total: usize,
-) -> impl Iterator<Item = Result<BalWorkerOutput<R>, BalExecutionError>> + '_ {
+) -> impl Iterator<Item = Result<BalWorkerOutput<R>, OrderedWorkerOutputError>> + '_ {
     OrderedWorkerOutputs::new(result_rx, total)
 }
 
 struct OrderedWorkerOutputs<'a, R> {
-    result_rx: &'a Receiver<Result<BalWorkerOutput<R>, BalExecutionError>>,
+    result_rx: &'a Receiver<Result<BalWorkerOutput<R>, BalWorkerError>>,
     pending: Vec<Option<BalWorkerOutput<R>>>,
     next: usize,
     total: usize,
@@ -36,7 +55,7 @@ struct OrderedWorkerOutputs<'a, R> {
 
 impl<'a, R> OrderedWorkerOutputs<'a, R> {
     fn new(
-        result_rx: &'a Receiver<Result<BalWorkerOutput<R>, BalExecutionError>>,
+        result_rx: &'a Receiver<Result<BalWorkerOutput<R>, BalWorkerError>>,
         total: usize,
     ) -> Self {
         Self {
@@ -50,7 +69,7 @@ impl<'a, R> OrderedWorkerOutputs<'a, R> {
 }
 
 impl<R> Iterator for OrderedWorkerOutputs<'_, R> {
-    type Item = Result<BalWorkerOutput<R>, BalExecutionError>;
+    type Item = Result<BalWorkerOutput<R>, OrderedWorkerOutputError>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.failed || self.next >= self.total {
@@ -67,30 +86,24 @@ impl<R> Iterator for OrderedWorkerOutputs<'_, R> {
                 Ok(Ok(output)) => output,
                 Ok(Err(err)) => {
                     self.failed = true;
-                    return Some(Err(err));
+                    return Some(Err(err.into()));
                 }
                 Err(_) => {
                     self.failed = true;
-                    return Some(Err(BalExecutionError::Evm(BlockExecutionError::msg(
-                        "BAL worker result channel closed while waiting for ordered outputs",
-                    ))));
+                    return Some(Err(OrderedWorkerOutputError::ResultChannelClosed));
                 }
             };
 
             let index = output.index;
-            if index >= self.total {
-                self.failed = true;
-                return Some(Err(BalExecutionError::Evm(BlockExecutionError::msg(
-                    "BAL worker returned out-of-bounds transaction index",
-                ))));
-            }
-
-            if index < self.next || self.pending[index].is_some() {
-                self.failed = true;
-                return Some(Err(BalExecutionError::Evm(BlockExecutionError::msg(
-                    "BAL worker returned duplicate transaction 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);
         }
@@ -100,13 +113,17 @@ impl<R> Iterator for OrderedWorkerOutputs<'_, R> {
 #[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>, BalExecutionError>, text: &str) {
+    fn expect_err_contains<R>(
+        result: Result<BalWorkerOutput<R>, OrderedWorkerOutputError>,
+        text: &str,
+    ) {
         let Err(err) = result else {
             panic!("expected ordered worker output error");
         };
@@ -131,7 +148,10 @@ mod tests {
     #[test]
     fn forwards_worker_errors_and_then_stops() {
         let (tx, rx) = crossbeam_channel::unbounded();
-        tx.send(Err(BalExecutionError::Evm(BlockExecutionError::msg("worker failed")))).unwrap();
+        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);
@@ -152,32 +172,31 @@ mod tests {
     }
 
     #[test]
-    fn rejects_out_of_bounds_index() {
+    #[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);
-
-        expect_err_contains(outputs.next().expect("first item"), "out-of-bounds");
-        assert!(outputs.next().is_none());
+        let _ = outputs.next();
     }
 
     #[test]
-    fn rejects_duplicate_pending_index() {
+    #[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);
-
-        expect_err_contains(outputs.next().expect("first item"), "duplicate");
-        assert!(outputs.next().is_none());
+        let _ = outputs.next();
     }
 
     #[test]
-    fn rejects_duplicate_already_yielded_index() {
+    #[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();
@@ -186,7 +205,6 @@ mod tests {
         let mut outputs = ordered_worker_outputs(&rx, 2);
 
         assert_eq!(outputs.next().expect("first item").expect("first output").result, 0);
-        expect_err_contains(outputs.next().expect("second item"), "duplicate");
-        assert!(outputs.next().is_none());
+        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
index 386d2c95189..63cfbd4eb0d 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
@@ -12,6 +12,29 @@ 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,
@@ -23,7 +46,7 @@ type WorkerExecutorResult<Cfg> =
     <<Cfg as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::TxExecutionResult;
 
 type WorkerResultSender<Cfg> =
-    Sender<Result<BalWorkerOutput<WorkerExecutorResult<Cfg>>, BalExecutionError>>;
+    Sender<Result<BalWorkerOutput<WorkerExecutorResult<Cfg>>, BalWorkerError>>;
 
 #[expect(clippy::too_many_arguments)]
 pub(super) fn spawn_worker<'scope, Evm, Tx, Err, DB, MakeDb>(
@@ -44,9 +67,9 @@ pub(super) fn spawn_worker<'scope, Evm, Tx, Err, DB, MakeDb>(
     MakeDb: Fn() -> Result<DB, BalExecutionError> + Sync + 'scope,
 {
     scope.spawn(move |_| {
-        let worker_result = (|| -> Result<(), BalExecutionError> {
+        let worker_result = (|| -> Result<(), BalWorkerError> {
             let mut worker_state = State::builder()
-                .with_database(make_db()?)
+                .with_database(make_db().map_err(BalWorkerError::Setup)?)
                 .with_bal(received_bal_revm)
                 .with_bundle_update()
                 .build();
@@ -61,14 +84,14 @@ pub(super) fn spawn_worker<'scope, Evm, Tx, Err, DB, MakeDb>(
                         Err(_) => break,
                     },
                 };
-                let tx = tx.map_err(|e| BalExecutionError::Evm(BlockExecutionError::other(e)))?;
+                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(BalExecutionError::Evm)?;
+                    .map_err(BalWorkerError::Execution)?;
 
                 if result_tx
                     .send(Ok(BalWorkerOutput { index, signer, tx_gas_limit, result }))
diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 1a224408db9..0f5a876fe5d 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -49,7 +49,7 @@ use crate::tree::{
     PayloadHandle, StateProviderBuilder, StateProviderDatabase, TreeConfig, WaitForCaches,
 };
 use alloy_consensus::transaction::{Either, TxHashRef};
-use alloy_eip7928::bal::DecodedBal;
+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};
@@ -452,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(),
@@ -531,8 +535,7 @@ where
         // The receipt root task is spawned before execution and receives receipts incrementally
         // as transactions complete, allowing parallel computation during execution.
         let execute_block_start = Instant::now();
-        let decoded_bal = env.decoded_bal.clone();
-        let (output, senders, receipt_root_rx) = if bal_eligible {
+        let (output, senders, receipt_root_rx, built_bal) = if bal_eligible {
             let provider_builder =
                 bal_provider_builder.expect("eligibility implies builder was cloned");
             ensure_ok!(self.execute_block_bal(
@@ -545,7 +548,6 @@ where
         } else {
             ensure_ok!(self.execute_block(state_provider, env, &input, &mut handle))
         };
-        let block_access_list_hash = decoded_bal.as_ref().map(|decoded_bal| decoded_bal.hash());
         let execution_duration = execute_block_start.elapsed();
 
         // After executing the block we can stop prewarming transactions
@@ -610,7 +612,7 @@ where
                 &output,
                 &mut ctx,
                 receipt_root_bloom,
-                block_access_list_hash
+                built_bal
             ),
             block
         );
@@ -952,6 +954,13 @@ where
         }
     }
 
+    fn validate_received_bal_gas(
+        decoded_bal: &DecodedBal,
+        gas_limit: u64,
+    ) -> Result<(), ConsensusError> {
+        decoded_bal.as_bal().validate_gas_limit(gas_limit).map_err(ConsensusError::from)
+    }
+
     /// Executes a block with the given state provider.
     ///
     /// This method orchestrates block execution:
@@ -968,7 +977,12 @@ where
         input: &BlockOrPayload<T>,
         handle: &mut PayloadHandle<impl ExecutableTxFor<Evm>, Err, N::Receipt>,
     ) -> Result<
-        (BlockExecutionOutput<N::Receipt>, Vec<Address>, ReceiptRootReceiver),
+        (
+            BlockExecutionOutput<N::Receipt>,
+            Vec<Address>,
+            ReceiptRootReceiver,
+            Option<BlockAccessList>,
+        ),
         InsertBlockErrorKind,
     >
     where
@@ -980,16 +994,6 @@ where
     {
         debug!(target: "engine::tree::payload_validator", "Executing block");
 
-        if let Some(decoded_bal) = &env.decoded_bal {
-            decoded_bal
-                .as_bal()
-                .validate_gas_limit(input.gas_limit())
-                .map_err(|e| {
-                    debug!(target: "engine::tree::payload_validator", "BAL is invalid since it contains more items than the gas limit allows");
-                    InsertBlockErrorKind::Consensus(ConsensusError::from(e))
-                })?
-        }
-
         let has_bal = env.decoded_bal.is_some();
         let mut db = debug_span!(target: "engine::tree", "build_state_db").in_scope(|| {
             State::builder()
@@ -1056,17 +1060,11 @@ where
             .map(|(evm, result)| (evm.into_db(), result))?;
         self.metrics.record_post_execution(post_exec_start.elapsed());
 
-        if let Some(decoded_bal) = &env.decoded_bal {
-            // Regular execution still handles BAL payloads when the parallel BAL path is
-            // disabled. Prove that execution rebuilt the payload-provided BAL before
-            // post-execution validation uses `decoded_bal.hash()` as the header commitment.
-            crate::tree::payload_processor::bal::validate_bal(&mut db, decoded_bal)?;
-        }
-
         // Merge transitions into bundle state
         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();
@@ -1074,7 +1072,7 @@ 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))
     }
 
     /// Returns true when the BAL execute path should be used for this block.
@@ -1108,7 +1106,7 @@ where
     /// 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. Adapts the BAL output to a [`BlockExecutionOutput`].
+    /// 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<S, Tx, Err, BalP, T>(
@@ -1119,7 +1117,12 @@ where
         handle: &PayloadHandle<Tx, Err, N::Receipt>,
         provider_builder: StateProviderBuilder<N, BalP>,
     ) -> Result<
-        (BlockExecutionOutput<N::Receipt>, Vec<Address>, ReceiptRootReceiver),
+        (
+            BlockExecutionOutput<N::Receipt>,
+            Vec<Address>,
+            ReceiptRootReceiver,
+            Option<BlockAccessList>,
+        ),
         InsertBlockErrorKind,
     >
     where
@@ -1157,7 +1160,7 @@ where
         let execution_start = Instant::now();
         let ctx =
             self.execution_ctx_for(input).map_err(|e| InsertBlockErrorKind::Other(Box::new(e)))?;
-        let (output, senders) = crate::tree::payload_processor::bal::execute_block(
+        let (output, senders, built_bal) = crate::tree::payload_processor::bal::execute_block(
             &self.runtime,
             &self.evm_config,
             &make_db,
@@ -1178,7 +1181,7 @@ where
             "Executed block via BAL path",
         );
 
-        Ok((output, senders, result_rx))
+        Ok((output, senders, result_rx, Some(built_bal)))
     }
 
     fn spawn_receipt_root_task(
@@ -1577,7 +1580,7 @@ where
         output: &BlockExecutionOutput<N::Receipt>,
         ctx: &mut TreeCtx<'_, N>,
         receipt_root_bloom: Option<ReceiptRootBloom>,
-        block_access_list_hash: Option<B256>,
+        built_bal: Option<BlockAccessList>,
     ) -> Result<(), InsertBlockErrorKind>
     where
         V: PayloadValidator<T, Block = N::Block>,
@@ -1590,6 +1593,9 @@ where
         let _enter =
             debug_span!(target: "engine::tree::payload_validator", "validate_block_post_execution")
                 .entered();
+        let block_access_list_hash =
+            built_bal.as_ref().map(|bal| compute_block_access_list_hash(bal));
+
         if let Err(err) = self.consensus.validate_block_post_execution(
             block,
             output,

From 5d63243741b07a74e8db4cda2a58c70ce2ec3d0e Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Tue, 26 May 2026 14:47:09 +0900
Subject: [PATCH 235/335] fix(engine): align BAL gas admission (#24107)

---
 .../src/tree/payload_processor/bal/execute.rs | 44 +++++++++++++------
 1 file changed, 30 insertions(+), 14 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
index 4dd1b79c7b3..3e70f8f115a 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
@@ -33,7 +33,6 @@ use revm::{
     bytecode::BytecodeDecodeError,
     context::{result::ResultAndState, Block},
     database::{states::bundle_state::BundleRetention, State},
-    primitives::{eip7825::TX_GAS_LIMIT_CAP, hardfork::SpecId},
 };
 use revm_state::bal::Bal as RevmBal;
 use std::sync::Arc;
@@ -110,8 +109,9 @@ where
     let bal = input_bal.as_bal();
     let input_bal_revm = convert_alloy_to_revm_bal(bal)?;
 
-    let is_amsterdam = evm_env.cfg_env.spec.into().is_enabled_in(SpecId::AMSTERDAM);
     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()?).with_bundle_update().with_bal_builder().build();
     load_bal_accounts(&mut canonical_state, bal)?;
@@ -135,7 +135,8 @@ where
         }
         drop(result_tx);
 
-        let mut gas_tracker = BlockGasTracker::new(block_gas_limit, is_amsterdam);
+        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());
 
@@ -266,24 +267,36 @@ impl AbortGuard {
 #[derive(Debug)]
 struct BlockGasTracker {
     block_gas_limit: u64,
-    is_amsterdam: bool,
+    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, is_amsterdam: bool) -> Self {
-        Self { block_gas_limit, is_amsterdam, cumulative_tx_gas_used: 0, block_regular_gas_used: 0 }
+    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.is_amsterdam {
+        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 = tx_gas_limit.min(TX_GAS_LIMIT_CAP);
+        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 {
@@ -1181,7 +1194,7 @@ mod tests {
             );
 
         // 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);
+        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(),
@@ -1189,7 +1202,7 @@ mod tests {
         );
 
         // Amsterdam: block_available_gas = 1_000_000 - 0 = 1_000_000 → accept 500_000.
-        let mut amsterdam = BlockGasTracker::new(block_gas_limit, true);
+        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(),
@@ -1201,8 +1214,11 @@ mod tests {
     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,
+        use revm::{
+            context::result::{
+                ExecResultAndState, ExecutionResult, Output, ResultGas, SuccessReason,
+            },
+            primitives::eip7825::TX_GAS_LIMIT_CAP,
         };
         use revm_state::EvmState;
 
@@ -1211,7 +1227,7 @@ mod tests {
 
         // 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);
+        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",
@@ -1232,7 +1248,7 @@ mod tests {
                 EvmState::default(),
             );
 
-        let mut tracker = BlockGasTracker::new(block_gas_limit, false);
+        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(),

From a2faa053ea64e3a0f7d29e626e9b0f8e6f50a2e2 Mon Sep 17 00:00:00 2001
From: Riyan Maulana <ridamichofi@gmail.com>
Date: Tue, 26 May 2026 10:08:43 +0400
Subject: [PATCH 236/335] fix(rpc): export Anvil and Hardhat server traits
 (#24537)

---
 crates/rpc/rpc-api/src/lib.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/rpc/rpc-api/src/lib.rs b/crates/rpc/rpc-api/src/lib.rs
index 8d09da22e12..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,
+        anvil::AnvilApiServer,
         debug::DebugApiServer,
         engine::{EngineApiServer, EngineEthApiServer, IntoEngineApiRpcModule},
+        hardhat::HardhatApiServer,
         mev::{MevFullApiServer, MevSimApiServer},
         miner::MinerApiServer,
         net::NetApiServer,

From c3ced87e19b099c7f0f73d9957bdaedcf430e89b Mon Sep 17 00:00:00 2001
From: cui <cuiweixie@gmail.com>
Date: Tue, 26 May 2026 15:32:18 +0800
Subject: [PATCH 237/335] fix(net): add eth_72 to supports_eth (#24536)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/eth-wire-types/src/capability.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/crates/net/eth-wire-types/src/capability.rs b/crates/net/eth-wire-types/src/capability.rs
index acac45e580c..4a94f4e3533 100644
--- a/crates/net/eth-wire-types/src/capability.rs
+++ b/crates/net/eth-wire-types/src/capability.rs
@@ -294,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.

From b848abb78bb53ac62de79248060b84f19a2357af Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 26 May 2026 02:52:32 -0700
Subject: [PATCH 238/335] ci(bench): show derek command in bench summary
 (#24550)

---
 .github/scripts/bench-reth-summary.py | 13 +++++++++-
 .github/workflows/bench.yml           | 35 +++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/.github/scripts/bench-reth-summary.py b/.github/scripts/bench-reth-summary.py
index cefa5a1c265..bcf9fa20856 100755
--- a/.github/scripts/bench-reth-summary.py
+++ b/.github/scripts/bench-reth-summary.py
@@ -23,6 +23,7 @@
 import csv
 import json
 import math
+import os
 import random
 import sys
 
@@ -601,9 +602,13 @@ def generate_markdown(
     wait_time_tables: list[str] | None = None,
     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}"
@@ -654,6 +659,11 @@ def main():
     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("--grafana-url", default=None, help="Grafana dashboard URL for this benchmark run")
+    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()
 
@@ -769,6 +779,7 @@ def main():
         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/workflows/bench.yml b/.github/workflows/bench.yml
index 02e3e3985a3..093eaec29ce 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -1018,6 +1018,41 @@ jobs:
             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"
+            slack="$BENCH_SLACK"
+          )
+          [ "$BENCH_SAMPLY" = "true" ] && derek_cmd+=(samply)
+          [ -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"

From e84f716b31d05706196f817077962850e4fd7c2b Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 26 May 2026 14:57:17 +0200
Subject: [PATCH 239/335] fix(rpc): default eth_simulateV1 fee fields to 0 per
 spec (#24386)

---
 crates/rpc/rpc-eth-types/src/simulate.rs | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/crates/rpc/rpc-eth-types/src/simulate.rs b/crates/rpc/rpc-eth-types/src/simulate.rs
index 79b4889780e..cfeeb0a22a0 100644
--- a/crates/rpc/rpc-eth-types/src/simulate.rs
+++ b/crates/rpc/rpc-eth-types/src/simulate.rs
@@ -256,22 +256,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);

From 5635fc28c8cda16f98540ceaa2b9b90d1d6c0261 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Tue, 26 May 2026 17:18:18 +0400
Subject: [PATCH 240/335] feat: unify ordered trie encoders (#24523)

Co-authored-by: Derek <256792747+decofe@users.noreply.github.com>
---
 .../payload_processor/receipt_root_task.rs    |  57 +-
 crates/trie/common/src/lib.rs                 |   3 -
 .../common/src/open_ended_ordered_root.rs     | 150 ------
 crates/trie/common/src/ordered_root.rs        | 497 ++++++++----------
 .../common/tests/open_ended_ordered_root.rs   | 142 -----
 5 files changed, 269 insertions(+), 580 deletions(-)
 delete mode 100644 crates/trie/common/src/open_ended_ordered_root.rs
 delete mode 100644 crates/trie/common/tests/open_ended_ordered_root.rs

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 c12bba4ad15..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,7 +7,7 @@
 //! 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;
@@ -67,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",
@@ -75,38 +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::with_capacity(RECEIPT_ENCODE_BUF_INITIAL_CAPACITY);
-        let mut received_count = 0usize;
+        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();
-            // Receipt indices are produced by the block executor in transaction order and are
-            // bounded by `receipts_len`, so avoid re-validating every streamed receipt on the hot
-            // path. `finalize` below still catches aborted execution that sends too few receipts.
-            builder.push_unchecked(indexed_receipt.index, &encode_buf);
-            received_count += 1;
+            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/trie/common/src/lib.rs b/crates/trie/common/src/lib.rs
index d7e30b2bc4d..1ac046d5e0d 100644
--- a/crates/trie/common/src/lib.rs
+++ b/crates/trie/common/src/lib.rs
@@ -75,9 +75,6 @@ pub mod root;
 /// Incremental ordered trie root computation.
 pub mod ordered_root;
 
-/// Open-ended incremental ordered trie root computation.
-pub mod open_ended_ordered_root;
-
 /// Buffer for trie updates.
 pub mod updates;
 
diff --git a/crates/trie/common/src/open_ended_ordered_root.rs b/crates/trie/common/src/open_ended_ordered_root.rs
deleted file mode 100644
index 1c0b6e3d8d9..00000000000
--- a/crates/trie/common/src/open_ended_ordered_root.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-//! Open-ended incremental ordered trie root computation.
-//!
-//! Ethereum block transaction and receipt roots are ordered trie roots keyed by the RLP encoding of
-//! each item index.
-//! [`OrderedTrieRootEncodedBuilder`](crate::ordered_root::OrderedTrieRootEncodedBuilder)
-//! requires the total number of items up front because it accepts out-of-order items and must know
-//! the final RLP key order before it can flush buffered leaves.
-//!
-//! [`OpenEndedOrderedTrieRootEncodedBuilder`](crate::open_ended_ordered_root::OpenEndedOrderedTrieRootEncodedBuilder)
-//! is for the append-only case where items are received in their final contiguous order, but the
-//! final item count is not known until the stream ends. This is useful while building a block: once
-//! a transaction is committed at the next block index, its encoded transaction and receipt can be
-//! consumed immediately without waiting to know how many transactions will eventually land in the
-//! block.
-//!
-//! # 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::open_ended_ordered_root::OpenEndedOrderedTrieRootEncodedBuilder;
-//!
-//! let mut builder = OpenEndedOrderedTrieRootEncodedBuilder::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;
-
-/// First index whose RLP-encoded key sorts after index 0.
-///
-/// 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.
-///
-/// Unlike [`OrderedTrieRootEncodedBuilder`](crate::ordered_root::OrderedTrieRootEncodedBuilder),
-/// this type does not require the total item count up front. It relies on a stricter input
-/// contract instead: every pushed item must be the next contiguous item in the final list.
-///
-/// 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 OpenEndedOrderedTrieRootEncodedBuilder {
-    /// Number of items pushed so far. This is also the next append-only index.
-    len: usize,
-    /// 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 OpenEndedOrderedTrieRootEncodedBuilder {
-    /// Creates an empty builder.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Pushes the next pre-encoded item.
-    ///
-    /// Items must be pushed in their final contiguous order.
-    #[inline]
-    pub fn push_next(&mut self, bytes: &[u8]) {
-        let index = self.len;
-        self.len += 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 the number of items pushed so far.
-    #[inline]
-    pub const fn pushed_count(&self) -> usize {
-        self.len
-    }
-
-    /// Returns `true` if no items have been pushed.
-    #[inline]
-    pub const fn is_empty(&self) -> bool {
-        self.len == 0
-    }
-
-    /// Finalizes the builder and returns the trie root.
-    ///
-    /// 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 EMPTY_ROOT_HASH;
-        }
-
-        self.flush_zero();
-        self.hb.root()
-    }
-
-    fn flush_zero(&mut self) {
-        if self.zero.is_none() {
-            return;
-        }
-
-        let zero = self.zero.take().expect("index 0 must be buffered before it is flushed");
-        self.add_leaf(0, &zero);
-    }
-
-    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);
-    }
-}
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/tests/open_ended_ordered_root.rs b/crates/trie/common/tests/open_ended_ordered_root.rs
deleted file mode 100644
index 29f636ddea3..00000000000
--- a/crates/trie/common/tests/open_ended_ordered_root.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-//! Tests for open-ended ordered trie root computation.
-
-use alloy_primitives::B256;
-use alloy_trie::root::ordered_trie_root_encoded;
-use proptest::prelude::*;
-use reth_trie_common::{
-    open_ended_ordered_root::OpenEndedOrderedTrieRootEncodedBuilder, EMPTY_ROOT_HASH,
-};
-
-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 = OpenEndedOrderedTrieRootEncodedBuilder::new();
-    for item in items {
-        builder.push_next(item);
-    }
-    builder.finalize()
-}
-
-#[test]
-fn empty_builder_returns_empty_root() {
-    let builder = OpenEndedOrderedTrieRootEncodedBuilder::new();
-
-    assert!(builder.is_empty());
-    assert_eq!(builder.pushed_count(), 0);
-    assert_eq!(builder.finalize(), EMPTY_ROOT_HASH);
-}
-
-#[test]
-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 short_lists_flush_zero_on_finalize() {
-    for len in 1..=128 {
-        let items = items(len);
-        let expected = ordered_trie_root_encoded(&items);
-
-        let mut builder = OpenEndedOrderedTrieRootEncodedBuilder::new();
-        for item in &items {
-            builder.push_next(item);
-        }
-
-        assert_eq!(builder.pushed_count(), len);
-        assert_eq!(builder.finalize(), expected, "mismatch for short len={len}");
-    }
-}
-
-#[test]
-fn long_lists_flush_zero_when_index_128_arrives() {
-    let items = items(129);
-    let expected = ordered_trie_root_encoded(&items);
-
-    let mut builder = OpenEndedOrderedTrieRootEncodedBuilder::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);
-    }
-}
-
-#[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 = OpenEndedOrderedTrieRootEncodedBuilder::new();
-        let mut buf = Vec::new();
-
-        for item in items {
-            buf.clear();
-            item.encode_2718(&mut buf);
-            builder.push_next(&buf);
-        }
-
-        builder.finalize()
-    }
-
-    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);
-        }
-    }
-}

From 493586eff89bfd71c32a72deb877b8da879eea11 Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Tue, 26 May 2026 22:49:30 +0900
Subject: [PATCH 241/335] fix(parbal): remove load_bal_accounts (#24559)

---
 .../src/tree/payload_processor/bal/execute.rs | 30 ++-----------------
 1 file changed, 2 insertions(+), 28 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
index 3e70f8f115a..699b5c3e58a 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
@@ -114,7 +114,6 @@ where
     let tx_gas_limit_cap = evm_env.cfg_env.tx_gas_limit_cap;
     let mut canonical_state =
         State::builder().with_database(make_db()?).with_bundle_update().with_bal_builder().build();
-    load_bal_accounts(&mut canonical_state, bal)?;
 
     let (block_result, senders) = {
         let (result_tx, result_rx) = crossbeam_channel::unbounded();
@@ -202,29 +201,6 @@ fn convert_alloy_to_revm_bal(bal: &AlloyBal) -> Result<Arc<RevmBal>, BalExecutio
     Ok(Arc::new(received_bal_revm))
 }
 
-fn load_bal_accounts<DB>(
-    canonical_state: &mut State<DB>,
-    bal: &AlloyBal,
-) -> Result<(), BalExecutionError>
-where
-    DB: Database,
-{
-    // Pre-load every BAL-declared address into canonical state's cache. `State::commit`
-    // (called by `commit_transaction`) panics at revm-database's
-    // `cache.rs:195` ("All accounts should be present inside cache") when it tries to
-    // apply a diff for an address not previously loaded. In the normal serial flow the
-    // EVM loads the account itself during execution, but here workers execute the tx EVM
-    // and the canonical loop only commits their outputs, so canonical may never have read
-    // those accounts itself.
-    for account_changes in bal {
-        canonical_state
-            .load_cache_account(account_changes.address)
-            .map_err(|e| BalExecutionError::Execution(BlockExecutionError::other(e)))?;
-    }
-
-    Ok(())
-}
-
 fn take_built_bal_and_log_divergence<DB>(
     canonical_state: &mut State<DB>,
     received_bal: &AlloyBal,
@@ -999,10 +975,8 @@ mod tests {
     #[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 — this is the first scenario that
-        // exercises a real storage diff, validating that our account-only pre-load path
-        // (`load_cache_account` in execute_block) is sufficient even when commits include
-        // storage writes.
+        // 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;

From aec6ba00c87ccfb240132bef13130e79fce6f4dc Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 26 May 2026 08:19:54 -0700
Subject: [PATCH 242/335] chore: bump revm to 40.0.3 (#24562)

---
 Cargo.lock                                  | 49 +++++++++++----------
 Cargo.toml                                  |  2 +-
 crates/transaction-pool/src/validate/eth.rs |  3 +-
 3 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e6feb5eb5cc..c38a00a0973 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10618,9 +10618,9 @@ dependencies = [
 
 [[package]]
 name = "revm"
-version = "40.0.2"
+version = "40.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2d649306477c7153d0f4568976385ccb1789608e9a5b956ec781514612ccbc3"
+checksum = "823da6e5509bb8e5dcd91295870e494917a030ad506fc83301f3f08ad8b15b17"
 dependencies = [
  "revm-bytecode",
  "revm-context",
@@ -10637,9 +10637,9 @@ dependencies = [
 
 [[package]]
 name = "revm-bytecode"
-version = "11.0.0"
+version = "11.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0b0efe30093e26767c2eb4d86c369a9b3877cc034e843f074436111c4459832"
+checksum = "d8b378c2653331fe60969d9745e802cd773d82a20d8aaced914dfcf26ab8f0d9"
 dependencies = [
  "bitvec",
  "phf",
@@ -10649,9 +10649,9 @@ dependencies = [
 
 [[package]]
 name = "revm-context"
-version = "18.0.2"
+version = "18.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f54b599f334f7cd32c5de193d586f50d7cc2bd5aa07f83dfeaf85a277ad5d9a"
+checksum = "bafa298114f3cab706945de14c04e73e6e6d7896302e4183dae273f968e52f80"
 dependencies = [
  "bitvec",
  "cfg-if",
@@ -10666,9 +10666,9 @@ dependencies = [
 
 [[package]]
 name = "revm-context-interface"
-version = "19.0.2"
+version = "19.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a96259bca5af514ea4b92037908b0232afbc167f1f8355604118ec599caeca8c"
+checksum = "db9c13f1dfc79425931fd184b6bd373dfac7baba50859b01107d5c0e20549cbb"
 dependencies = [
  "alloy-eip2930",
  "alloy-eip7702",
@@ -10682,11 +10682,12 @@ dependencies = [
 
 [[package]]
 name = "revm-database"
-version = "15.0.1"
+version = "15.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e73c2151aded4387d96f90c958bb67f34968d40d11d1495fe41091fe220af115"
+checksum = "a69c3ce73454a09ef89a66177239d7c4f5f697227ae27254c99451866603b19d"
 dependencies = [
  "alloy-eips",
+ "derive_more",
  "revm-bytecode",
  "revm-database-interface",
  "revm-primitives",
@@ -10696,9 +10697,9 @@ dependencies = [
 
 [[package]]
 name = "revm-database-interface"
-version = "12.1.0"
+version = "12.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75f753660705cf9e7b7e45fc5607d4cebf729094d5e96dc1d1cf98cf57b69507"
+checksum = "4a2656187f9f9c22ef9dd9300ed71aeaeca3506a6a0a229a07f264649b960d68"
 dependencies = [
  "auto_impl",
  "either",
@@ -10710,9 +10711,9 @@ dependencies = [
 
 [[package]]
 name = "revm-handler"
-version = "20.0.2"
+version = "20.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa038202a389d72b5c1b4d6f6e8f921a93171bf02f7cfdb5308eeea5780869c1"
+checksum = "3ce1d66037ca1394128313bb995fa9f50d834927a389386bb34f8f0ef914648f"
 dependencies = [
  "auto_impl",
  "derive-where",
@@ -10729,9 +10730,9 @@ dependencies = [
 
 [[package]]
 name = "revm-inspector"
-version = "21.0.2"
+version = "21.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4375c14860fa31232673f8e963510ddaccd10d511353e35771a1d5015fed327a"
+checksum = "9fe3635d3411e8318849546570ca0220e783443319e28f5397c9f80b05bf4344"
 dependencies = [
  "auto_impl",
  "either",
@@ -10767,9 +10768,9 @@ dependencies = [
 
 [[package]]
 name = "revm-interpreter"
-version = "37.0.2"
+version = "37.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecec5a33daed0d84e3e1529203451d33ca50d2a30c2e3d9959ce18ee0229a06a"
+checksum = "bae56c57ddca1f5c4abd443f826f1b3e49a86a528e7e1ea0fc207cdc4671a37e"
 dependencies = [
  "revm-bytecode",
  "revm-context-interface",
@@ -10780,9 +10781,9 @@ dependencies = [
 
 [[package]]
 name = "revm-precompile"
-version = "36.0.2"
+version = "36.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5cc580444ccf766456f7586edaf1bff9f09b7101f3a9ac0979969168e5debc6"
+checksum = "191db865091e07ecb80b12ce3048192c76071ca3d2b0a315b111b271cd4ced37"
 dependencies = [
  "ark-bls12-381",
  "ark-bn254",
@@ -10806,9 +10807,9 @@ dependencies = [
 
 [[package]]
 name = "revm-primitives"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b4a4ed40c86155d1656e1744e90e23c96e1059f3cd146d70b6d4b2882708f1c"
+checksum = "fe5102d804892908d4ebf68da29b8562895922dffa26c230ff2c4dadcf93916f"
 dependencies = [
  "alloy-primitives",
  "once_cell",
@@ -10817,9 +10818,9 @@ dependencies = [
 
 [[package]]
 name = "revm-state"
-version = "12.0.0"
+version = "12.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc740a183b0d4c0807f565df2420ccb6a662df1d878108faddb25560164a4022"
+checksum = "40eff6067185cf80932e06f6a9c8045b012ecb6f99a8d6edc618ec2792373e14"
 dependencies = [
  "alloy-eip7928 0.4.1",
  "bitflags 2.11.1",
diff --git a/Cargo.toml b/Cargo.toml
index 0b31fac168a..300a314c997 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -432,7 +432,7 @@ reth-trie-sparse = { path = "crates/trie/sparse", default-features = false }
 reth-zstd-compressors = { version = "0.4.0", default-features = false }
 
 # revm
-revm = { version = "40.0.2", default-features = false }
+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 }
diff --git a/crates/transaction-pool/src/validate/eth.rs b/crates/transaction-pool/src/validate/eth.rs
index f420a2421ee..ebffeab38d5 100644
--- a/crates/transaction-pool/src/validate/eth.rs
+++ b/crates/transaction-pool/src/validate/eth.rs
@@ -34,7 +34,7 @@ use reth_primitives_traits::{
 use reth_storage_api::{AccountInfoReader, BlockReaderIdExt, BytecodeReader, StateProviderFactory};
 use reth_tasks::Runtime;
 use revm::context_interface::Cfg;
-use revm_primitives::{eip8037::CPSB_GLAMSTERDAM, U256};
+use revm_primitives::U256;
 use std::{
     fmt,
     marker::PhantomData,
@@ -1424,7 +1424,6 @@ pub fn ensure_intrinsic_gas<T: EthPoolTransaction>(
             .map(|l| l.iter().map(|i| i.storage_keys.len()).sum::<usize>())
             .unwrap_or_default() as u64,
         transaction.authorization_list().map(|l| l.len()).unwrap_or_default() as u64,
-        CPSB_GLAMSTERDAM,
     );
 
     let gas_limit = transaction.gas_limit();

From 283cc32396784be892ee8343ccde80dc8716f126 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 26 May 2026 22:10:57 +0200
Subject: [PATCH 243/335] refactor(net): use B256 collections for tx hashes
 (#24565)

---
 crates/net/eth-wire-types/src/broadcast.rs    | 46 +++++++++----------
 .../net/network/src/transactions/fetcher.rs   | 30 ++++++------
 crates/net/network/src/transactions/mod.rs    | 22 ++++-----
 crates/net/p2p/src/full_block.rs              |  7 ++-
 4 files changed, 51 insertions(+), 54 deletions(-)

diff --git a/crates/net/eth-wire-types/src/broadcast.rs b/crates/net/eth-wire-types/src/broadcast.rs
index 500e91147e1..1ae9f211045 100644
--- a/crates/net/eth-wire-types/src/broadcast.rs
+++ b/crates/net/eth-wire-types/src/broadcast.rs
@@ -3,7 +3,7 @@
 use crate::{EthMessage, EthVersion, NetworkPrimitives};
 use alloc::{sync::Arc, vec::Vec};
 use alloy_primitives::{
-    map::{HashMap, HashSet},
+    map::{B256Map, B256Set},
     Bytes, TxHash, B128, B256, U128,
 };
 use alloy_rlp::{
@@ -856,7 +856,7 @@ impl DedupPayload for NewPooledTransactionHashes72 {
     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()) {
@@ -882,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()) {
@@ -908,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;
 
@@ -979,7 +979,7 @@ pub struct PartiallyValidData<V> {
     #[deref]
     #[deref_mut]
     #[into_iterator]
-    data: HashMap<TxHash, V>,
+    data: B256Map<V>,
     version: Option<EthVersion>,
 }
 
@@ -987,41 +987,41 @@ 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: HashMap<TxHash, V>) -> Self {
+    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(HashMap::default())
+        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
@@ -1031,7 +1031,7 @@ impl<V> PartiallyValidData<V> {
     }
 
     /// Destructs returning the validated data.
-    pub fn into_data(self) -> HashMap<TxHash, V> {
+    pub fn into_data(self) -> B256Map<V> {
         self.data
     }
 }
@@ -1043,7 +1043,7 @@ pub struct ValidAnnouncementData {
     #[deref]
     #[deref_mut]
     #[into_iterator]
-    data: HashMap<TxHash, Eth68TxMetadata>,
+    data: B256Map<Eth68TxMetadata>,
     version: EthVersion,
 }
 
@@ -1053,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)
     }
@@ -1070,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
     }
 }
@@ -1087,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.
@@ -1389,7 +1389,7 @@ mod tests {
                 b256!("0x0000000000000000000000000000000000000000000000000000000000000005"),
             ]
             .into_iter()
-            .collect::<HashSet<_>>(),
+            .collect::<B256Set>(),
         );
 
         let rest = hashes.retain_count(3);
@@ -1409,7 +1409,7 @@ mod tests {
                 b256!("0x0000000000000000000000000000000000000000000000000000000000000005"),
             ]
             .into_iter()
-            .collect::<HashSet<_>>(),
+            .collect::<B256Set>(),
         );
 
         let _ = hashes.retain_count(6);
@@ -1428,7 +1428,7 @@ mod tests {
                 b256!("0x0000000000000000000000000000000000000000000000000000000000000005"),
             ]
             .into_iter()
-            .collect::<HashSet<_>>(),
+            .collect::<B256Set>(),
         );
 
         let rest = hashes.retain_count(0);
diff --git a/crates/net/network/src/transactions/fetcher.rs b/crates/net/network/src/transactions/fetcher.rs
index d4931c9d42d..f3dda344ae4 100644
--- a/crates/net/network/src/transactions/fetcher.rs
+++ b/crates/net/network/src/transactions/fetcher.rs
@@ -1309,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, map::HashMap, 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)>)>);
@@ -1363,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);
 
@@ -1383,8 +1387,8 @@ 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);
@@ -1405,8 +1409,8 @@ mod test {
         ];
 
         let expected_request_hashes =
-            [eth68_hashes[0], eth68_hashes[2]].into_iter().collect::<HashSet<_>>();
-        let expected_surplus_hashes = std::iter::once(eth68_hashes[1]).collect::<HashSet<_>>();
+            [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(
@@ -1420,8 +1424,8 @@ 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);
@@ -1440,7 +1444,7 @@ mod test {
         let announcement_data = hashes
             .into_iter()
             .map(|hash| (hash, Some((0u8, announced_size))))
-            .collect::<HashMap<_, _>>();
+            .collect::<B256Map<_>>();
         let valid_announcement_data = ValidAnnouncementData::from_partially_valid_data(
             PartiallyValidData::from_raw_data_eth72(announcement_data),
         );
@@ -1533,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 ca9fe755680..85edcc82598 100644
--- a/crates/net/network/src/transactions/mod.rs
+++ b/crates/net/network/src/transactions/mod.rs
@@ -38,7 +38,7 @@ use crate::{
     NetworkHandle, TxTypesCounter,
 };
 use alloy_primitives::{
-    map::{B256Map, FbBuildHasher},
+    map::{B256Map, B256Set, FbBuildHasher},
     TxHash, B256,
 };
 use constants::SOFT_LIMIT_COUNT_HASHES_IN_NEW_POOLED_TRANSACTIONS_BROADCAST_MESSAGE;
@@ -187,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())
         }
@@ -197,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())
     }
@@ -1195,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);
                 }
@@ -2112,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,
@@ -2917,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
@@ -3197,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/p2p/src/full_block.rs b/crates/net/p2p/src/full_block.rs
index 1b4c5828843..3150cbdf068 100644
--- a/crates/net/p2p/src/full_block.rs
+++ b/crates/net/p2p/src/full_block.rs
@@ -1254,10 +1254,9 @@ mod tests {
     use super::*;
     use crate::{error::RequestError, test_utils::TestFullBlockClient};
     use alloy_consensus::Header;
-    use alloy_primitives::{keccak256, Bytes};
+    use alloy_primitives::{keccak256, map::B256Map, Bytes};
     use parking_lot::Mutex;
     use std::{
-        collections::HashMap,
         ops::Range,
         sync::{
             atomic::{AtomicBool, AtomicUsize, Ordering},
@@ -1522,7 +1521,7 @@ 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>,
@@ -1537,7 +1536,7 @@ 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)),

From a91b9e0df3ffb6a22419f6900c907bdbc40dae97 Mon Sep 17 00:00:00 2001
From: figtracer <me@figtracer.com>
Date: Tue, 26 May 2026 22:45:33 +0100
Subject: [PATCH 244/335] perf(txpool): preallocate propagation vectors
 (#24554)

Co-authored-by: DaniPopes <57450786+DaniPopes@users.noreply.github.com>
---
 crates/transaction-pool/src/pool/mod.rs | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/crates/transaction-pool/src/pool/mod.rs b/crates/transaction-pool/src/pool/mod.rs
index fadce19af1f..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.

From 980872d606b4f28a34eacc621bfd9a74c4f6f1aa Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 27 May 2026 01:08:31 +0200
Subject: [PATCH 245/335] feat(transaction-pool): add borrowed pool
 transactions iterator (#24556)

---
 crates/transaction-pool/src/traits.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/crates/transaction-pool/src/traits.rs b/crates/transaction-pool/src/traits.rs
index c8b43ba5bb2..4ee1d9d0e78 100644
--- a/crates/transaction-pool/src/traits.rs
+++ b/crates/transaction-pool/src/traits.rs
@@ -810,6 +810,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())

From fd96cb2bd65023a0b8cc1ee328f325e64f65ebb1 Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Wed, 27 May 2026 17:15:04 +0900
Subject: [PATCH 246/335] refactor(engine): split execution cache policy
 (#24568)

---
 .../execution-cache/src/cached_state.rs       | 217 +++++++++++-------
 .../src/tree/payload_processor/prewarm.rs     |  24 +-
 .../engine/tree/src/tree/payload_validator.rs |   6 +-
 crates/ethereum/payload/src/lib.rs            |   2 +-
 4 files changed, 138 insertions(+), 111 deletions(-)

diff --git a/crates/engine/execution-cache/src/cached_state.rs b/crates/engine/execution-cache/src/cached_state.rs
index 4475d71849c..a7ddc97cae2 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::with_cache_stats`].
 #[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,33 +114,113 @@ 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)
+    }
+
+    /// 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)
     }
-}
 
-impl<S> CachedStateProvider<S, true> {
-    /// Creates a new [`CachedStateProvider`] with prewarming enabled.
-    pub const fn new_prewarm(
+    /// Creates a cache-filling [`CachedStateProvider`] that also reports hit/miss metrics.
+    pub const fn new_cache_filling(
         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::FillOnMiss, metrics)
+    }
+
+    /// Creates a [`CachedStateProvider`] with an explicit cache fill mode.
+    pub const fn new_with_mode(
+        state_provider: S,
+        caches: ExecutionCache,
+        fill_mode: CacheFillMode,
+        metrics: Option<CachedStateMetrics>,
+    ) -> Self {
+        Self { state_provider, caches, metrics, fill_mode, cache_stats: None }
     }
-}
 
-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_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();
+        }
+    }
+
+    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.
@@ -429,37 +513,26 @@ 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)
         }
     }
@@ -474,85 +547,61 @@ fn nonzero_storage_value(value: StorageValue) -> Option<StorageValue> {
     }
 }
 
-impl<S: StateProvider, const PREWARM: bool> StateProvider for CachedStateProvider<S, PREWARM> {
+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();
-                    }
+                    self.record_storage_miss();
                     Ok(nonzero_storage_value(value))
                 }
                 CachedStatus::Cached(value) => {
-                    if let Some(stats) = &self.cache_stats {
-                        stats.record_storage_hit();
-                    }
+                    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();
-            }
+            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)
     }
@@ -576,9 +625,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,
@@ -606,9 +653,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,
@@ -636,7 +681,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)
     }
@@ -650,9 +695,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)
     }
@@ -1028,7 +1071,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);
@@ -1051,7 +1094,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/tree/src/tree/payload_processor/prewarm.rs b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
index 318c817c249..d97b94aa3c8 100644
--- a/crates/engine/tree/src/tree/payload_processor/prewarm.rs
+++ b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
@@ -411,9 +411,7 @@ where
                     }
                     WorkerPool::with_worker_mut(|worker| {
                         let provider = worker
-                            .get_or_init::<Option<CachedStateProvider<StateProviderBox, true>>>(
-                                || None,
-                            );
+                            .get_or_init::<Option<CachedStateProvider<StateProviderBox>>>(|| None);
                         ctx.prefetch_bal_storage(&parent_span, provider, account);
                     });
                 });
@@ -576,11 +574,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);
@@ -686,11 +680,7 @@ where
             {
                 (false, Some(saved)) => {
                     let caches = saved.cache().clone();
-                    Box::new(CachedStateProvider::new_prewarm(
-                        inner,
-                        caches,
-                        self.cache_metrics.clone().unwrap_or_default(),
-                    ))
+                    Box::new(CachedStateProvider::new_prewarm(inner, caches))
                 }
                 _ => Box::new(inner),
             };
@@ -754,7 +744,7 @@ where
     fn prefetch_bal_storage(
         &self,
         parent_span: &Span,
-        provider: &mut Option<CachedStateProvider<reth_provider::StateProviderBox, true>>,
+        provider: &mut Option<CachedStateProvider<reth_provider::StateProviderBox>>,
         account: &alloy_eip7928::AccountChanges,
     ) {
         if self.disable_bal_batch_io ||
@@ -787,11 +777,7 @@ where
                 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(),
-                ))
+                slot.insert(CachedStateProvider::new_prewarm(built, caches))
             }
         };
 
diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 0f5a876fe5d..2645404b696 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -514,9 +514,9 @@ where
 
         // 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()) {
+        if let Some(caches) = handle.caches() {
             state_provider = Box::new(
-                CachedStateProvider::new(state_provider, caches, cache_metrics)
+                CachedStateProvider::new(state_provider, caches, handle.cache_metrics())
                     .with_cache_stats(cache_stats.clone()),
             );
         };
@@ -1139,7 +1139,6 @@ where
         let cache = handle.caches().ok_or_else(|| {
             InsertBlockErrorKind::Other("BAL execute path: no execution cache available".into())
         })?;
-        let cache_metrics = handle.cache_metrics().unwrap_or_default();
         let saved_cache = SavedCache::new(env.parent_hash, cache);
 
         let (receipt_tx, result_rx) = self.spawn_receipt_root_task(env.transaction_count);
@@ -1154,7 +1153,6 @@ where
             Ok(StateProviderDatabase::new(CachedStateProvider::new_prewarm(
                 provider,
                 saved_cache.cache().clone(),
-                cache_metrics.clone(),
             )))
         };
         let execution_start = Instant::now();
diff --git a/crates/ethereum/payload/src/lib.rs b/crates/ethereum/payload/src/lib.rs
index 2cf090e7ac5..6605cd26c6a 100644
--- a/crates/ethereum/payload/src/lib.rs
+++ b/crates/ethereum/payload/src/lib.rs
@@ -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());

From 1cb8aa92112953f1c31272fc5941650117d0cf5c Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Wed, 27 May 2026 18:30:47 +0900
Subject: [PATCH 247/335] refactor(engine): flush state provider metrics
 explicitly (#24575)

---
 .../tree/src/tree/instrumented_state.rs       | 59 +++++++++++--------
 .../engine/tree/src/tree/payload_validator.rs | 48 ++++++++-------
 2 files changed, 63 insertions(+), 44 deletions(-)

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/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 2645404b696..5d7aec94539 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -40,7 +40,7 @@
 
 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},
@@ -521,34 +521,42 @@ where
             );
         };
 
-        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
-        };
+        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()));
+
+        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");
+            state_provider = Box::new(InstrumentedStateProvider::with_stats(
+                state_provider,
+                metrics.clone(),
+                Arc::clone(stats),
+            ));
+        }
 
         // Execute the block and handle any execution errors.
         // The receipt root task is spawned before execution and receives receipts incrementally
         // as transactions complete, allowing parallel computation during execution.
         let execute_block_start = Instant::now();
-        let (output, senders, receipt_root_rx, built_bal) = if bal_eligible {
+        let execution_result = if bal_eligible {
             let provider_builder =
                 bal_provider_builder.expect("eligibility implies builder was cloned");
-            ensure_ok!(self.execute_block_bal(
-                state_provider,
-                env,
-                &input,
-                &handle,
-                provider_builder
-            ))
+            self.execute_block_bal(state_provider, env, &input, &handle, provider_builder)
         } else {
-            ensure_ok!(self.execute_block(state_provider, env, &input, &mut handle))
+            self.execute_block(state_provider, env, &input, &mut handle)
         };
         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();
@@ -827,7 +835,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,

From 40692d91f6f8edf67ce69eb85e9d9ba8fa17a623 Mon Sep 17 00:00:00 2001
From: Emma Jamieson-Hoare <emmajam@users.noreply.github.com>
Date: Wed, 27 May 2026 13:13:45 +0100
Subject: [PATCH 248/335] chore(ci): increase stale workflow operation budget
 (#24583)

---
 .github/workflows/stale.yml | 1 +
 1 file changed, 1 insertion(+)

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

From f88acf7f5a3fd59d0afcb5aa8cb0856b948d38da Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Wed, 27 May 2026 05:31:33 -0700
Subject: [PATCH 249/335] refactor: split execution cache state metrics labels
 (#24585)

---
 .../execution-cache/src/cached_state.rs       | 36 ++++++++++---------
 crates/engine/tree/src/tree/mod.rs            |  4 +--
 .../tree/src/tree/payload_processor/mod.rs    | 14 +++++---
 .../src/tree/payload_processor/prewarm.rs     | 10 +++---
 4 files changed, 37 insertions(+), 27 deletions(-)

diff --git a/crates/engine/execution-cache/src/cached_state.rs b/crates/engine/execution-cache/src/cached_state.rs
index a7ddc97cae2..1344b787427 100644
--- a/crates/engine/execution-cache/src/cached_state.rs
+++ b/crates/engine/execution-cache/src/cached_state.rs
@@ -271,6 +271,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,
 
@@ -280,12 +297,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,
 
@@ -295,12 +306,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,
 
@@ -317,17 +322,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
@@ -968,7 +970,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);
@@ -1028,7 +1030,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);
         }
diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index a42fc60523e..ea25b585097 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -72,8 +72,8 @@ 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};
 
diff --git a/crates/engine/tree/src/tree/payload_processor/mod.rs b/crates/engine/tree/src/tree/payload_processor/mod.rs
index 616ac20f3e6..fd055788daa 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};
@@ -121,6 +122,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.
@@ -185,6 +188,8 @@ where
             disable_sparse_trie_cache_pruning: config.disable_sparse_trie_cache_pruning(),
             cache_metrics: (!config.disable_cache_metrics())
                 .then(|| CachedStateMetrics::zeroed(CachedStateMetricsSource::Engine)),
+            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(),
         }
@@ -527,6 +532,7 @@ where
             provider: provider_builder,
             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,
@@ -722,7 +728,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!(
@@ -756,7 +762,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);
diff --git a/crates/engine/tree/src/tree/payload_processor/prewarm.rs b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
index d97b94aa3c8..c44efbe9933 100644
--- a/crates/engine/tree/src/tree/payload_processor/prewarm.rs
+++ b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
@@ -14,8 +14,8 @@
 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;
@@ -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
@@ -528,6 +528,8 @@ where
     /// 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

From 808d6f01b36d271ae3ff8eaecf3dfa30551333fe Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Wed, 27 May 2026 22:10:38 +0900
Subject: [PATCH 250/335] fix: state provider creation (#24584)

---
 .../execution-cache/src/cached_state.rs       | 27 ++---
 .../src/tree/payload_processor/bal/execute.rs | 22 +++--
 .../src/tree/payload_processor/bal/worker.rs  |  7 +-
 .../engine/tree/src/tree/payload_validator.rs | 98 +++++++++----------
 4 files changed, 75 insertions(+), 79 deletions(-)

diff --git a/crates/engine/execution-cache/src/cached_state.rs b/crates/engine/execution-cache/src/cached_state.rs
index 1344b787427..411329c2ff9 100644
--- a/crates/engine/execution-cache/src/cached_state.rs
+++ b/crates/engine/execution-cache/src/cached_state.rs
@@ -92,7 +92,7 @@ type FixedCache<K, V, H = DefaultHashBuilder> = fixed_cache::Cache<K, V, H, Epoc
 /// 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::with_cache_stats`].
+/// [`CacheStats`] are controlled separately by [`Self::new_with_mode`].
 #[derive(Debug)]
 pub struct CachedStateProvider<S> {
     /// The state provider
@@ -120,39 +120,26 @@ impl<S> CachedStateProvider<S> {
         caches: ExecutionCache,
         metrics: Option<CachedStateMetrics>,
     ) -> Self {
-        Self::new_with_mode(state_provider, caches, CacheFillMode::LookupOnly, metrics)
+        Self::new_with_mode(state_provider, caches, CacheFillMode::LookupOnly, metrics, None)
     }
 
     /// 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)
+        Self::new_with_mode(state_provider, caches, CacheFillMode::FillOnMiss, None, None)
     }
 
-    /// Creates a cache-filling [`CachedStateProvider`] that also reports hit/miss metrics.
-    pub const fn new_cache_filling(
-        state_provider: S,
-        caches: ExecutionCache,
-        metrics: Option<CachedStateMetrics>,
-    ) -> Self {
-        Self::new_with_mode(state_provider, caches, CacheFillMode::FillOnMiss, metrics)
-    }
-
-    /// Creates a [`CachedStateProvider`] with an explicit cache fill mode.
+    /// 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,
         fill_mode: CacheFillMode,
         metrics: Option<CachedStateMetrics>,
+        cache_stats: Option<Arc<CacheStats>>,
     ) -> Self {
-        Self { state_provider, caches, metrics, fill_mode, cache_stats: None }
-    }
-
-    /// 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
+        Self { state_provider, caches, metrics, fill_mode, cache_stats }
     }
 
     fn record_account_hit(&self) {
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
index 699b5c3e58a..734cac8153c 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/execute.rs
@@ -2,9 +2,9 @@
 //!
 //! Read `execute_block` as two execution paths over the same parent state.
 //!
-//! Worker states run transactions speculatively. Each worker gets one fresh database from
-//! `make_db`, installs the received BAL, sets the transaction BAL index for each streamed
-//! transaction, and returns uncommitted transaction results.
+//! 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
@@ -60,7 +60,7 @@ where
     Tx: ExecutableTxFor<Evm> + Send + 'a,
     Err: core::error::Error + Send + Sync + 'static,
     DB: Database + Send + 'a,
-    MakeDb: Fn() -> Result<DB, BalExecutionError> + Sync + 'a,
+    MakeDb: Fn(bool) -> Result<DB, BalExecutionError> + Sync + 'a,
     ReceiptTy<Evm::Primitives>: Clone,
 {
     let worker_pool = runtime.bal_streaming_pool();
@@ -103,7 +103,7 @@ where
     Tx: ExecutableTxFor<Evm> + Send + 'scope,
     Err: core::error::Error + Send + Sync + 'static,
     DB: Database + Send + 'scope,
-    MakeDb: Fn() -> Result<DB, BalExecutionError> + Sync + 'scope,
+    MakeDb: Fn(bool) -> Result<DB, BalExecutionError> + Sync + 'scope,
     ReceiptTy<Evm::Primitives>: Clone,
 {
     let bal = input_bal.as_bal();
@@ -112,8 +112,11 @@ where
     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()?).with_bundle_update().with_bal_builder().build();
+    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();
@@ -498,6 +501,7 @@ mod tests {
         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,
@@ -1122,11 +1126,13 @@ mod tests {
         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,
-            &db_factory(system_contracts_db()),
+            &make_db,
             to_arc_decoded(BlockAccessList::default()),
             evm_env,
             execution_ctx,
diff --git a/crates/engine/tree/src/tree/payload_processor/bal/worker.rs b/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
index 63cfbd4eb0d..8801589a01d 100644
--- a/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
+++ b/crates/engine/tree/src/tree/payload_processor/bal/worker.rs
@@ -64,12 +64,15 @@ pub(super) fn spawn_worker<'scope, Evm, Tx, Err, DB, MakeDb>(
     Tx: ExecutableTxFor<Evm> + Send + 'scope,
     Err: core::error::Error + Send + Sync + 'static,
     DB: Database + Send + 'scope,
-    MakeDb: Fn() -> Result<DB, BalExecutionError> + Sync + '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(make_db().map_err(BalWorkerError::Setup)?)
+                .with_database(database)
                 .with_bal(received_bal_revm)
                 .with_bundle_update()
                 .build();
diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 5d7aec94539..fbdd818ea58 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -70,7 +70,7 @@ 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, BuiltPayloadExecutedBlock, InvalidPayloadAttributesError, NewPayloadError,
     PayloadTypes,
@@ -442,7 +442,6 @@ where
             )
             .into())
         };
-        let mut state_provider = ensure_ok!(provider_builder.build());
         drop(_enter);
 
         let evm_env = debug_span!(target: "engine::tree::payload_validator", "evm_env")
@@ -494,10 +493,7 @@ where
             OverlayStateProviderFactory::new(provider_factory.clone(), overlay_builder.clone());
         let changeset_provider = self.spawn_changeset_provider_task(overlay_factory.clone());
 
-        // BAL execute path eligibility. Computed up front because the BAL arm needs a clone of
-        // `provider_builder` (consumed by `spawn_payload_processor` below).
         let bal_eligible = ensure_ok!(self.bal_path_eligible(env.decoded_bal.as_deref()));
-        let bal_provider_builder = bal_eligible.then(|| provider_builder.clone());
 
         // Spawn the appropriate processor based on strategy
         let mut handle = ensure_ok!(self.spawn_payload_processor(
@@ -511,46 +507,61 @@ where
         // 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()));
-
-        // Use cached state provider before executing, used in execution after prewarming threads
-        // complete
-        if let Some(caches) = handle.caches() {
-            state_provider = Box::new(
-                CachedStateProvider::new(state_provider, caches, handle.cache_metrics())
-                    .with_cache_stats(cache_stats.clone()),
-            );
-        };
-
         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()));
 
-        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");
-            state_provider = Box::new(InstrumentedStateProvider::with_stats(
-                state_provider,
-                metrics.clone(),
-                Arc::clone(stats),
-            ));
-        }
+        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
+            };
+
+            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),
+                ));
+            }
+
+            Ok(provider)
+        };
 
         // Execute the block and handle any execution errors.
         // The receipt root task is spawned before execution and receives receipts incrementally
         // as transactions complete, allowing parallel computation during execution.
         let execute_block_start = Instant::now();
         let execution_result = if bal_eligible {
-            let provider_builder =
-                bal_provider_builder.expect("eligibility implies builder was cloned");
-            self.execute_block_bal(state_provider, env, &input, &handle, provider_builder)
+            self.execute_block_bal(env, &input, &handle, &make_state_provider)
         } else {
-            self.execute_block(state_provider, env, &input, &mut handle)
+            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()),
+            }
         };
         let execution_duration = execute_block_start.elapsed();
         if let (Some(metrics), Some(stats)) = (&state_provider_metrics, &state_provider_stats) {
@@ -1117,13 +1128,12 @@ where
     /// 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<S, Tx, Err, BalP, T>(
+    fn execute_block_bal<Tx, Err, MakeStateProvider, T>(
         &self,
-        _state_provider: S,
         env: ExecutionEnv<Evm>,
         input: &BlockOrPayload<T>,
         handle: &PayloadHandle<Tx, Err, N::Receipt>,
-        provider_builder: StateProviderBuilder<N, BalP>,
+        make_state_provider: &MakeStateProvider,
     ) -> Result<
         (
             BlockExecutionOutput<N::Receipt>,
@@ -1134,34 +1144,24 @@ where
         InsertBlockErrorKind,
     >
     where
-        S: StateProvider + Send,
         Tx: ExecutableTxFor<Evm> + Send,
         Err: core::error::Error + Send + Sync + 'static,
-        BalP: BlockReader + StateProviderFactory + StateReader + Clone + 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 cache = handle.caches().ok_or_else(|| {
-            InsertBlockErrorKind::Other("BAL execute path: no execution cache available".into())
-        })?;
-        let saved_cache = SavedCache::new(env.parent_hash, cache);
-
         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 = move || {
-            let provider = provider_builder
-                .build()
+        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(CachedStateProvider::new_prewarm(
-                provider,
-                saved_cache.cache().clone(),
-            )))
+            Ok(StateProviderDatabase::new(provider))
         };
         let execution_start = Instant::now();
         let ctx =

From 97efd06859265192543619b15339618564f9820c Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Wed, 27 May 2026 17:00:55 +0200
Subject: [PATCH 251/335] feat(bench): compare target metrics in benchmark
 summaries (#24392)

Co-authored-by: Brian Picciano <933154+mediocregopher@users.noreply.github.com>
Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
---
 .github/config/bench-metrics-targets.json     |   97 ++
 .github/scripts/bench-job-summary.js          |   33 +-
 .github/scripts/bench-reth-summary.py         | 1219 +++++++++++++++++
 .../bench-target-metric-sample-filter.py      |   63 +
 .github/scripts/bench-txgen-run.sh            |  117 +-
 .github/scripts/bench-utils.js                |    3 +
 .github/workflows/bench-scheduled.yml         |    5 +
 .github/workflows/bench.yml                   |    5 +
 8 files changed, 1539 insertions(+), 3 deletions(-)
 create mode 100644 .github/config/bench-metrics-targets.json
 create mode 100644 .github/scripts/bench-target-metric-sample-filter.py

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-job-summary.js b/.github/scripts/bench-job-summary.js
index 8f621c155b6..36d686472a0 100644
--- a/.github/scripts/bench-job-summary.js
+++ b/.github/scripts/bench-job-summary.js
@@ -14,7 +14,21 @@
 //   await jobSummary({ core, context, chartSha, grafanaUrl, runId });
 
 const fs = require('fs');
-const { verdict, loadSamplyUrls, blocksLabel, metricRows, waitTimeRows } = require('./bench-utils');
+const { verdict, loadSamplyUrls, blocksLabel, metricRows, waitTimeRows, fmtChange } = require('./bench-utils');
+
+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, runId }) {
   let summary;
@@ -67,6 +81,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';
diff --git a/.github/scripts/bench-reth-summary.py b/.github/scripts/bench-reth-summary.py
index bcf9fa20856..6145d217d3f 100755
--- a/.github/scripts/bench-reth-summary.py
+++ b/.github/scripts/bench-reth-summary.py
@@ -24,13 +24,22 @@
 import json
 import math
 import os
+from pathlib import Path
 import random
+import re
 import sys
 
 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,
@@ -84,6 +93,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)
@@ -379,6 +513,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
@@ -493,6 +644,1003 @@ def ci_pct(ci_ms: float, base_ms: float) -> float:
     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,
@@ -597,9 +1745,60 @@ 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 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,
@@ -625,6 +1824,9 @@ def generate_markdown(
                 lines.append(table)
                 lines.append("")
         lines.append("</details>")
+    if target_metric_table:
+        lines.append("")
+        lines.append(target_metric_table)
     if grafana_url:
         lines.append("")
         lines.append(f"**[Grafana Dashboard]({grafana_url})**")
@@ -659,6 +1861,7 @@ def main():
     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("--grafana-url", default=None, help="Grafana dashboard URL for this benchmark run")
+    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"),
@@ -747,6 +1950,19 @@ 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": ci_stats["blocks"],
         "big_blocks": args.big_blocks,
@@ -767,6 +1983,8 @@ def main():
         "changes": compute_changes(baseline_stats, feature_stats, ci_stats),
         "wait_times": wait_time_data,
     }
+    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}")
@@ -774,6 +1992,7 @@ 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,
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-run.sh b/.github/scripts/bench-txgen-run.sh
index f094cbaf2e0..9166cc945ee 100755
--- a/.github/scripts/bench-txgen-run.sh
+++ b/.github/scripts/bench-txgen-run.sh
@@ -12,7 +12,8 @@
 #               BENCH_FEATURE_ARGS, BENCH_OTLP_TRACES_ENDPOINT,
 #               BENCH_OTLP_LOGS_ENDPOINT, BENCH_OTLP_DISABLED,
 #               BENCH_TRACY, BENCH_TRACY_FILTER, BENCH_TRACY_SAMPLING_HZ,
-#               TXGEN_PAYLOADS_DIR (pre-extracted payloads; skips extraction)
+#               TXGEN_PAYLOADS_DIR (pre-extracted payloads; skips extraction),
+#               BENCH_TARGET_METRICS_SCRAPE_INTERVAL_MS (optional txgen override)
 set -euxo pipefail
 
 LABEL="$1"
@@ -48,8 +49,92 @@ 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
@@ -372,6 +457,7 @@ if [ "${BENCH_TRACY:-off}" != "off" ]; then
 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")
@@ -380,8 +466,26 @@ 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 [ -n "${BENCH_METRICS_ADDR:-}" ]; 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")
@@ -421,4 +525,13 @@ $BENCH_NICE "$TXGEN_BENCH" send-blocks \
   -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-utils.js b/.github/scripts/bench-utils.js
index 3d9a782b34e..9f440fa5843 100644
--- a/.github/scripts/bench-utils.js
+++ b/.github/scripts/bench-utils.js
@@ -17,6 +17,9 @@ function fmtChange(ch) {
   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;
diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 066679e1e4d..5a811d2f569 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -308,9 +308,11 @@ jobs:
       BENCH_RUN_PAIRS: "2"
       BENCH_COMMENT_ID: ""
       BENCH_SLACK: ${{ github.event_name == 'workflow_dispatch' && inputs.slack || 'always' }}
+      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 || '' }}
@@ -665,6 +667,9 @@ jobs:
           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
 
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 093eaec29ce..7640fd8e5b4 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -639,6 +639,8 @@ jobs:
       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: ${{ secrets.BENCH_VICTORIAMETRICS_URL }}
@@ -1287,6 +1289,9 @@ jobs:
           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
 

From 7c5168c17a966081fb2b4523dadabb76f5a3e6bb Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 27 May 2026 17:17:38 +0200
Subject: [PATCH 252/335] refactor(payload): use alloy gas limit helper
 (#24590)

---
 crates/ethereum/payload/src/config.rs | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/crates/ethereum/payload/src/config.rs b/crates/ethereum/payload/src/config.rs
index 6e429b61f0f..2b15939821f 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)]
@@ -68,12 +68,3 @@ impl EthereumBuilderConfig {
         calculate_block_gas_limit(parent_gas_limit, 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)
-}

From 41b20d0bf50189cd8dcbf18923c2b09d8fbf6fee Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Wed, 27 May 2026 21:11:05 +0530
Subject: [PATCH 253/335] fix(rpc): use builder gas limit for testing blocks
 (#24573)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/ethereum/node/src/node.rs        |  6 ++-
 crates/node/core/src/args/rpc_server.rs |  4 +-
 crates/rpc/rpc/src/testing.rs           | 64 ++++++++++++++++++-------
 3 files changed, 54 insertions(+), 20 deletions(-)

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/node/core/src/args/rpc_server.rs b/crates/node/core/src/args/rpc_server.rs
index 6c03333c2f1..b164980dab7 100644
--- a/crates/node/core/src/args/rpc_server.rs
+++ b/crates/node/core/src/args/rpc_server.rs
@@ -650,8 +650,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>,
diff --git a/crates/rpc/rpc/src/testing.rs b/crates/rpc/rpc/src/testing.rs
index 8d44c94a950..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,
@@ -225,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,

From 072277f8e27d2f5b0e55733024bfc00f694fb04b Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Thu, 28 May 2026 00:56:32 +0400
Subject: [PATCH 254/335] feat: expose a `EthBlockAssembler` method with
 optional precomputed values (#24598)

---
 crates/ethereum/evm/src/build.rs | 62 ++++++++++++++++++++++----------
 1 file changed, 43 insertions(+), 19 deletions(-)

diff --git a/crates/ethereum/evm/src/build.rs b/crates/ethereum/evm/src/build.rs
index 548f3ecbdf0..42b9df41553 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,
@@ -53,11 +56,13 @@ where
 
         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
@@ -123,3 +128,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)
+    }
+}

From 91f3802a4c62a2c7286a52411debe39410223272 Mon Sep 17 00:00:00 2001
From: figtracer <me@figtracer.com>
Date: Wed, 27 May 2026 22:31:24 +0100
Subject: [PATCH 255/335] perf(txpool): preallocate reorg mined hash set
 (#24555)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/evm/execution-types/src/chain.rs | 12 +++++++++++-
 crates/transaction-pool/src/maintain.rs |  2 +-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/crates/evm/execution-types/src/chain.rs b/crates/evm/execution-types/src/chain.rs
index 696e7570f17..bb561010812 100644
--- a/crates/evm/execution-types/src/chain.rs
+++ b/crates/evm/execution-types/src/chain.rs
@@ -7,7 +7,7 @@ use alloy_consensus::{
     BlockHeader, TxReceipt,
 };
 use alloy_eips::{eip1898::ForkBlock, BlockNumHash};
-use alloy_primitives::{Address, BlockHash, BlockNumber, Log, TxHash};
+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,
@@ -462,6 +462,16 @@ impl<B: Block<Body: BlockBody<Transaction: SignedTransaction>>> ChainBlocks<'_,
         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
+    }
 }
 
 impl<B: Block> IntoIterator for ChainBlocks<'_, B> {
diff --git a/crates/transaction-pool/src/maintain.rs b/crates/transaction-pool/src/maintain.rs
index 63ad765cbe5..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

From 183e358d2ae03464ea1275e49cc34b84545f22c7 Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Thu, 28 May 2026 15:04:23 +0900
Subject: [PATCH 256/335] chore: clarify the intent behind not fill-on-miss
 (#24612)

---
 .../engine/tree/src/tree/payload_validator.rs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index fbdd818ea58..228dce6983c 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -514,6 +514,25 @@ where
             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 {

From 3fd73f5a9ed34c565af9b6ba36f6f7b2466c1d59 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 28 May 2026 08:37:35 +0200
Subject: [PATCH 257/335] chore(deps): bump the cargo-weekly group with 5
 updates (#24608)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 20 ++++++++++----------
 Cargo.toml | 10 +++++-----
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c38a00a0973..32cc0c5b950 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2886,9 +2886,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",
@@ -3291,9 +3291,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",
 ]
@@ -3438,9 +3438,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",
@@ -3453,9 +3453,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",
@@ -11939,9 +11939,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",
diff --git a/Cargo.toml b/Cargo.toml
index 300a314c997..e9508d53d48 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -484,7 +484,7 @@ 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"
@@ -498,7 +498,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"
@@ -535,7 +535,7 @@ 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"
+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 }
@@ -634,8 +634,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 }

From 56de61169993305e717b77d874fd0c3586c7ca20 Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Thu, 28 May 2026 15:40:44 +0900
Subject: [PATCH 258/335] fix: don't gate BAL path on caches anymore (#24616)

---
 .../tree/src/tree/payload_processor/mod.rs      | 17 ++++++++---------
 .../engine/tree/src/tree/payload_validator.rs   | 13 +++++++------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_processor/mod.rs b/crates/engine/tree/src/tree/payload_processor/mod.rs
index fd055788daa..ec57b9ac67a 100644
--- a/crates/engine/tree/src/tree/payload_processor/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/mod.rs
@@ -276,6 +276,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,
@@ -298,17 +299,14 @@ where
             halve_workers,
             config,
         );
-        // BAL blocks only bypass the normal execution state hook when the parallel BAL executor
-        // consumes the BAL. If parallel BAL execution is disabled, or if state caching is
-        // disabled so the BAL executor cannot use a shared cache, treat the BAL as absent here so
-        // the block follows today's sequential execution and transaction-prewarm path.
+        // 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. `disable_bal_batch_io` controls the prefetch half inside
-        // prewarm, not this dispatch decision.
-        let parallel_bal_execution = !config.disable_state_cache() &&
-            !config.disable_bal_parallel_execution() &&
-            env.decoded_bal.is_some();
+        // 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,
@@ -1373,6 +1371,7 @@ mod tests {
                 OverlayBuilder::<EthPrimitives>::new(genesis_hash, ChangesetCache::new()),
             ),
             &TreeConfig::default(),
+            false,
         );
 
         let mut state_hook = handle.state_hook().expect("state hook is None");
diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 228dce6983c..16b2f11fd15 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -493,7 +493,7 @@ where
             OverlayStateProviderFactory::new(provider_factory.clone(), overlay_builder.clone());
         let changeset_provider = self.spawn_changeset_provider_task(overlay_factory.clone());
 
-        let bal_eligible = ensure_ok!(self.bal_path_eligible(env.decoded_bal.as_deref()));
+        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(
@@ -502,6 +502,7 @@ where
             provider_builder.clone(),
             overlay_factory,
             &strategy,
+            parallel_bal_execution,
         ));
 
         // Create optional cache stats for detailed block logging
@@ -573,7 +574,7 @@ where
         // The receipt root task is spawned before execution and receives receipts incrementally
         // as transactions complete, allowing parallel computation during execution.
         let execute_block_start = Instant::now();
-        let execution_result = if bal_eligible {
+        let execution_result = if parallel_bal_execution {
             self.execute_block_bal(env, &input, &handle, &make_state_provider)
         } else {
             let state_provider = make_state_provider(false);
@@ -1123,9 +1124,7 @@ where
     //     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_state_cache() &&
-            !self.config.disable_bal_parallel_execution();
+        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"
@@ -1661,7 +1660,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,
@@ -1670,6 +1669,7 @@ where
         provider_builder: StateProviderBuilder<N, P>,
         overlay_factory: OverlayStateProviderFactory<P, N>,
         strategy: &StateRootStrategy<N>,
+        parallel_bal_execution: bool,
     ) -> Result<
         PayloadHandle<
             impl ExecutableTxFor<Evm> + use<N, P, Evm, V, T>,
@@ -1689,6 +1689,7 @@ where
                     provider_builder,
                     overlay_factory,
                     &self.config,
+                    parallel_bal_execution,
                 );
 
                 // record prewarming initialization duration

From 6835254b289c48aa972651fafc26f8eb3b9b22f1 Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Thu, 28 May 2026 13:53:53 +0200
Subject: [PATCH 259/335] ci: expose bench observability links (#24625)

Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
---
 .github/scripts/bench-job-summary.js  |  16 ++-
 .github/scripts/bench-reth-summary.py | 154 +++++++++++++++++++++++++-
 .github/workflows/bench.yml           | 111 +++++++++++++++++--
 3 files changed, 263 insertions(+), 18 deletions(-)

diff --git a/.github/scripts/bench-job-summary.js b/.github/scripts/bench-job-summary.js
index 36d686472a0..e9eca59d86b 100644
--- a/.github/scripts/bench-job-summary.js
+++ b/.github/scripts/bench-job-summary.js
@@ -11,7 +11,7 @@
 //
 // 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, logsUrl, tracesUrl, runId });
 
 const fs = require('fs');
 const { verdict, loadSamplyUrls, blocksLabel, metricRows, waitTimeRows, fmtChange } = require('./bench-utils');
@@ -30,7 +30,7 @@ function fmtTargetMetricValue(metric, v) {
   return fmtMetricValue(v);
 }
 
-module.exports = async function ({ core, context, chartSha, grafanaUrl, runId }) {
+module.exports = async function ({ core, context, chartSha, logsUrl, tracesUrl, runId }) {
   let summary;
   try {
     summary = JSON.parse(fs.readFileSync(process.env.BENCH_WORK_DIR + '/summary.json', 'utf8'));
@@ -45,6 +45,9 @@ 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 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}`;
@@ -122,9 +125,12 @@ 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`;
+  // Observability
+  const observabilityLinks = [];
+  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-reth-summary.py b/.github/scripts/bench-reth-summary.py
index 6145d217d3f..f3083d5f2d0 100755
--- a/.github/scripts/bench-reth-summary.py
+++ b/.github/scripts/bench-reth-summary.py
@@ -21,6 +21,7 @@
 
 import argparse
 import csv
+from datetime import datetime, timezone
 import json
 import math
 import os
@@ -28,6 +29,8 @@
 import random
 import re
 import sys
+import time
+from urllib.parse import quote
 
 BOOTSTRAP_ITERATIONS = 10_000
 EPSILON = 1e-9
@@ -49,6 +52,9 @@
     "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:
@@ -1795,12 +1801,117 @@ def target_metric_change_str(change: dict) -> str:
     )
 
 
+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 = [
+        ("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."""
@@ -1827,9 +1938,7 @@ def generate_markdown(
     if target_metric_table:
         lines.append("")
         lines.append(target_metric_table)
-    if grafana_url:
-        lines.append("")
-        lines.append(f"**[Grafana Dashboard]({grafana_url})**")
+    lines.extend(generate_observability_section(summary))
     return "\n".join(lines)
 
 
@@ -1860,7 +1969,12 @@ 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",
@@ -1983,6 +2097,37 @@ def main():
         "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:
@@ -1997,7 +2142,6 @@ def main():
         repo=args.repo,
         baseline_ref=baseline_ref,
         baseline_name=baseline_name,
-        grafana_url=args.grafana_url,
         derek_command=args.derek_command,
     )
 
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 7640fd8e5b4..abf6003a00d 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -1142,15 +1142,98 @@ jobs:
 
           .github/scripts/bench-update-status.sh "Finalizing results..."
 
-      - name: Generate Grafana URL
+      - name: Generate observability URLs
         id: metrics
         if: "!cancelled()"
         run: |
           FROM_MS=$(( BENCH_REFERENCE_EPOCH * 1000 ))
           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()"
@@ -1285,10 +1368,27 @@ 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
             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
@@ -1418,12 +1518,6 @@ jobs:
               }
             }
 
-            // 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`;
-            }
-
             // Node errors (panics / ERROR logs)
             try {
               const errors = fs.readFileSync(process.env.BENCH_WORK_DIR + '/errors.md', 'utf8');
@@ -1455,7 +1549,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 }}',
             });
 

From 518858bf4758d7d9de399db45103ac0d4dce9fc5 Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Thu, 28 May 2026 20:44:31 +0530
Subject: [PATCH 260/335] fix(rpc): handle simulate precompile self moves
 (#24567)

---
 crates/rpc/rpc-eth-types/src/simulate.rs | 69 ++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/crates/rpc/rpc-eth-types/src/simulate.rs b/crates/rpc/rpc-eth-types/src/simulate.rs
index cfeeb0a22a0..41bde8edd04 100644
--- a/crates/rpc/rpc-eth-types/src/simulate.rs
+++ b/crates/rpc/rpc-eth-types/src/simulate.rs
@@ -103,6 +103,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 +123,7 @@ impl EthSimulateError {
             Self::SenderNotEOA => -38024,
             Self::MaxInitCodeSizeExceeded => -38025,
             Self::TooManyBlocks | Self::GasLimitReached => -38026,
+            Self::MovePrecompileToSelf(_) => -38022,
             Self::NotAPrecompile(_) => -32000,
         }
     }
@@ -147,6 +151,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)
@@ -369,3 +382,59 @@ where
     )?;
     Ok(SimulatedBlock { inner: block, calls })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{apply_precompile_overrides, EthSimulateError};
+    use alloy_evm::precompiles::PrecompilesMap;
+    use alloy_primitives::address;
+    use alloy_rpc_types_eth::state::{AccountOverride, StateOverride};
+    use revm::precompile::Precompiles;
+
+    #[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());
+    }
+}

From ed9b50589e8146a1a8badd84d3b77458fecb2a32 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Thu, 28 May 2026 19:13:26 +0200
Subject: [PATCH 261/335] fix(rpc): gap-fill empty blocks in eth_simulateV1
 (#24388)

---
 Cargo.lock                                 |   1 +
 crates/rpc/rpc-eth-api/src/helpers/call.rs |  53 ++---
 crates/rpc/rpc-eth-types/Cargo.toml        |   1 +
 crates/rpc/rpc-eth-types/src/simulate.rs   | 238 ++++++++++++++++++++-
 4 files changed, 252 insertions(+), 41 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 32cc0c5b950..ff6799d2cf3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9990,6 +9990,7 @@ dependencies = [
 name = "reth-rpc-eth-types"
 version = "2.2.0"
 dependencies = [
+ "alloy-chains",
  "alloy-consensus",
  "alloy-eip7928 0.4.1",
  "alloy-eips",
diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs
index 6ab40a768b7..58b7994c8fc 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};
 use reth_errors::{ProviderError, RethError};
 use reth_evm::{
     block::BlockExecutor, env::BlockEnvironment, execute::BlockBuilder, ConfigureEvm, Evm,
@@ -93,42 +94,29 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
 
             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, mut db| {
+                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,
+                )?;
+
                 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();
-
                 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 attributes = this.next_env_attributes(&parent)?;
 
                     let mut evm_env = this
@@ -175,7 +163,6 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                     }
 
                     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 =
@@ -268,10 +255,6 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
 
                     parent = result.block.clone_sealed_header();
 
-                    // Update tracking for next iteration's validation
-                    prev_block_number = parent.number();
-                    prev_timestamp = parent.timestamp();
-
                     let block = simulate::build_simulated_block::<Self::Error, _>(
                         result.block,
                         results,
diff --git a/crates/rpc/rpc-eth-types/Cargo.toml b/crates/rpc/rpc-eth-types/Cargo.toml
index 28c405f002f..3785c89b2bc 100644
--- a/crates/rpc/rpc-eth-types/Cargo.toml
+++ b/crates/rpc/rpc-eth-types/Cargo.toml
@@ -29,6 +29,7 @@ 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"] }
diff --git a/crates/rpc/rpc-eth-types/src/simulate.rs b/crates/rpc/rpc-eth-types/src/simulate.rs
index 41bde8edd04..1acdf128b42 100644
--- a/crates/rpc/rpc-eth-types/src/simulate.rs
+++ b/crates/rpc/rpc-eth-types/src/simulate.rs
@@ -4,21 +4,24 @@ 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;
@@ -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.
@@ -135,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
@@ -385,12 +493,34 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::{apply_precompile_overrides, EthSimulateError};
+    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;
-    use alloy_rpc_types_eth::state::{AccountOverride, StateOverride};
+    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");
@@ -437,4 +567,100 @@ mod tests {
         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(_)));
+    }
 }

From 8afd4817ba9a6ea9f3806f1850cdbbb0cae16813 Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Fri, 29 May 2026 02:55:13 +0530
Subject: [PATCH 262/335] fix(rpc): align simulate response fields (#24630)

---
 crates/rpc/rpc-eth-types/src/simulate.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/rpc/rpc-eth-types/src/simulate.rs b/crates/rpc/rpc-eth-types/src/simulate.rs
index 1acdf128b42..05efc45a58b 100644
--- a/crates/rpc/rpc-eth-types/src/simulate.rs
+++ b/crates/rpc/rpc-eth-types/src/simulate.rs
@@ -435,7 +435,7 @@ where
                         ..SimulateError::invalid_params()
                     }),
                     gas_used: gas.tx_gas_used(),
-                    max_used_gas: Some(gas.total_gas_spent()),
+                    max_used_gas: Some(gas.total_gas_spent().max(gas.floor_gas())),
                     logs: Vec::new(),
                     status: false,
                 }
@@ -443,14 +443,14 @@ where
             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_used_gas: Some(gas.total_gas_spent().max(gas.floor_gas())),
                     status: false,
                     logs: Vec::new(),
                 }
@@ -459,7 +459,7 @@ where
                 return_data: output.into_data(),
                 error: None,
                 gas_used: gas.tx_gas_used(),
-                max_used_gas: Some(gas.total_gas_spent()),
+                max_used_gas: Some(gas.total_gas_spent().max(gas.floor_gas())),
                 logs: logs
                     .into_iter()
                     .map(|log| {

From dc718cda993a18df6428b159d86c5ffb34ea7a1f Mon Sep 17 00:00:00 2001
From: JOJO <wataxiwajojo@protonmail.com>
Date: Fri, 29 May 2026 07:25:18 +0000
Subject: [PATCH 263/335] perf(rpc): derive evm env from header in sim_bundle
 (#23841)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/rpc/rpc-eth-api/src/helpers/state.rs | 46 +++++++++++++++++++--
 crates/rpc/rpc/src/eth/sim_bundle.rs        |  5 +--
 2 files changed, 45 insertions(+), 6 deletions(-)

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

From 2b9c61e000134af101f08230e93bf1e1113aaef4 Mon Sep 17 00:00:00 2001
From: RandoomWalks <125154949+RandoomWalks@users.noreply.github.com>
Date: Fri, 29 May 2026 00:41:44 -0700
Subject: [PATCH 264/335] fix(net): track block access list requests in eth
 request metrics (#23880)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/network/src/eth_requests.rs | 1 +
 crates/net/network/src/metrics.rs      | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/crates/net/network/src/eth_requests.rs b/crates/net/network/src/eth_requests.rs
index ad67b85dbe7..3282285d3e5 100644
--- a/crates/net/network/src/eth_requests.rs
+++ b/crates/net/network/src/eth_requests.rs
@@ -371,6 +371,7 @@ 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);
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,

From 76576db458ee186ad2d8ff9a884c7502df195d4b Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Fri, 29 May 2026 10:15:01 +0200
Subject: [PATCH 265/335] perf(tx-pool): use FxHashSet for invalid senders
 (#24647)

---
 crates/transaction-pool/src/pool/best.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/transaction-pool/src/pool/best.rs b/crates/transaction-pool/src/pool/best.rs
index 9496b07e8b7..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};
@@ -97,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
     ///

From 446350c2687e56f1eb73a1c0d377770f3ee16d79 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 29 May 2026 11:03:14 +0200
Subject: [PATCH 266/335] chore(deps): bump crate-ci/typos from 1.45.0 to
 1.46.2 (#24605)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 .github/workflows/lint.yml                 | 2 +-
 crates/node/builder/src/components/pool.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 87dcc085f89..14fe9c446b1 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -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/crates/node/builder/src/components/pool.rs b/crates/node/builder/src/components/pool.rs
index d6f459c62f8..8d1afcdb59c 100644
--- a/crates/node/builder/src/components/pool.rs
+++ b/crates/node/builder/src/components/pool.rs
@@ -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,

From 03d9691e7e8b26897bd4f32a053bab46ee84fd11 Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Fri, 29 May 2026 13:29:24 +0200
Subject: [PATCH 267/335] feat(consensus): add experimental BAL validation
 toggle (#24632)

Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
---
 crates/ethereum/consensus/src/lib.rs        | 84 ++++++++++++++++++++-
 crates/ethereum/consensus/src/validation.rs | 31 +++++++-
 2 files changed, 112 insertions(+), 3 deletions(-)

diff --git a/crates/ethereum/consensus/src/lib.rs b/crates/ethereum/consensus/src/lib.rs
index fb7749a9d09..8bc2c6badb1 100644
--- a/crates/ethereum/consensus/src/lib.rs
+++ b/crates/ethereum/consensus/src/lib.rs
@@ -50,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> {
@@ -61,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,
         }
     }
 
@@ -93,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
@@ -111,12 +120,13 @@ where
         receipt_root_bloom: Option<ReceiptRootBloom>,
         block_access_list_hash: Option<B256>,
     ) -> Result<(), ConsensusError> {
-        let res = validate_block_post_execution(
+        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 &&
@@ -243,7 +253,7 @@ where
                 return Err(ConsensusError::SlotNumberMissing)
             }
         } else {
-            if header.block_access_list_hash().is_some() {
+            if header.block_access_list_hash().is_some() && !self.allow_bal_hashes {
                 return Err(ConsensusError::BlockAccessListHashUnexpected)
             }
             if header.slot_number().is_some() {
@@ -290,6 +300,7 @@ mod tests {
     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,
@@ -312,6 +323,12 @@ mod tests {
         }
     }
 
+    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);
@@ -409,6 +426,18 @@ mod tests {
         ));
     }
 
+    #[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());
@@ -423,6 +452,57 @@ mod tests {
         ));
     }
 
+    #[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());
diff --git a/crates/ethereum/consensus/src/validation.rs b/crates/ethereum/consensus/src/validation.rs
index 4be126c1bf0..5acb8a02e29 100644
--- a/crates/ethereum/consensus/src/validation.rs
+++ b/crates/ethereum/consensus/src/validation.rs
@@ -24,6 +24,30 @@ pub fn validate_block_post_execution<B, R, ChainSpec>(
     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,
     R: Receipt,
@@ -82,7 +106,12 @@ where
     }
 
     // Validate that the header block access list hash matches the calculated block access list hash
-    if chain_spec.is_amsterdam_active_at_timestamp(block.header().timestamp()) &&
+    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();

From 3b963ff91441a4153c1f5da48cec22b1192134dd Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Fri, 29 May 2026 14:35:27 +0200
Subject: [PATCH 268/335] fix(ci): restore bench grafana observability link
 (#24648)

Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
---
 .github/scripts/bench-job-summary.js  | 6 ++++--
 .github/scripts/bench-reth-summary.py | 1 +
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/.github/scripts/bench-job-summary.js b/.github/scripts/bench-job-summary.js
index e9eca59d86b..0754145f638 100644
--- a/.github/scripts/bench-job-summary.js
+++ b/.github/scripts/bench-job-summary.js
@@ -11,7 +11,7 @@
 //
 // Usage from actions/github-script:
 //   const jobSummary = require('./.github/scripts/bench-job-summary.js');
-//   await jobSummary({ core, context, chartSha, logsUrl, tracesUrl, runId });
+//   await jobSummary({ core, context, chartSha, grafanaUrl, logsUrl, tracesUrl, runId });
 
 const fs = require('fs');
 const { verdict, loadSamplyUrls, blocksLabel, metricRows, waitTimeRows, fmtChange } = require('./bench-utils');
@@ -30,7 +30,7 @@ function fmtTargetMetricValue(metric, v) {
   return fmtMetricValue(v);
 }
 
-module.exports = async function ({ core, context, chartSha, logsUrl, tracesUrl, runId }) {
+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'));
@@ -46,6 +46,7 @@ module.exports = async function ({ core, context, chartSha, logsUrl, tracesUrl,
 
   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})`;
@@ -127,6 +128,7 @@ module.exports = async function ({ core, context, chartSha, logsUrl, tracesUrl,
 
   // 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) {
diff --git a/.github/scripts/bench-reth-summary.py b/.github/scripts/bench-reth-summary.py
index f3083d5f2d0..9b942a183af 100755
--- a/.github/scripts/bench-reth-summary.py
+++ b/.github/scripts/bench-reth-summary.py
@@ -1893,6 +1893,7 @@ def resolve_observability_range(
 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")),
     ]

From b8116b42b8dbe3045f1407e9d5fc26e48de38c88 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Fri, 29 May 2026 16:36:17 +0200
Subject: [PATCH 269/335] fix(rpc): default eth_simulateV1 per-call gas to
 remaining block gas (#24387)

---
 crates/ethereum/node/tests/e2e/simulate.rs | 133 ++++++++++++++++++++-
 crates/rpc/rpc-eth-api/src/helpers/call.rs |  39 +-----
 crates/rpc/rpc-eth-types/src/simulate.rs   |  66 +++++++++-
 3 files changed, 201 insertions(+), 37 deletions(-)

diff --git a/crates/ethereum/node/tests/e2e/simulate.rs b/crates/ethereum/node/tests/e2e/simulate.rs
index d30b58c7e4b..2130769648d 100644
--- a/crates/ethereum/node/tests/e2e/simulate.rs
+++ b/crates/ethereum/node/tests/e2e/simulate.rs
@@ -4,13 +4,144 @@ use alloy_provider::{network::EthereumWallet, Provider, ProviderBuilder};
 use alloy_rpc_types_eth::{
     simulate::{SimBlock, SimulatePayload, SimulatedBlock},
     state::StateOverridesBuilder,
-    BlockOverrides, TransactionRequest,
+    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_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.
diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs
index 58b7994c8fc..107669705c0 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/call.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/call.rs
@@ -116,6 +116,9 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                 let mut blocks: Vec<SimulatedBlock<RpcBlock<Self::NetworkTypes>>> =
                     Vec::with_capacity(block_state_calls.len());
 
+                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 {
                     let attributes = this.next_env_attributes(&parent)?;
 
@@ -162,37 +165,7 @@ 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 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 chain_id = evm_env.cfg_env.chain_id;
 
                     let ctx = this
                         .evm_config()
@@ -226,7 +199,7 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                         simulate::execute_transactions(
                             builder,
                             calls,
-                            default_gas_limit,
+                            &mut remaining_call_gas_limit,
                             chain_id,
                             this.converter(),
                         )
@@ -246,7 +219,7 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                         simulate::execute_transactions(
                             builder,
                             calls,
-                            default_gas_limit,
+                            &mut remaining_call_gas_limit,
                             chain_id,
                             this.converter(),
                         )
diff --git a/crates/rpc/rpc-eth-types/src/simulate.rs b/crates/rpc/rpc-eth-types/src/simulate.rs
index 05efc45a58b..f7171b18536 100644
--- a/crates/rpc/rpc-eth-types/src/simulate.rs
+++ b/crates/rpc/rpc-eth-types/src/simulate.rs
@@ -282,12 +282,17 @@ 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,
     calls: Vec<RpcTxReq<T::Network>>,
-    default_gas_limit: u64,
+    remaining_call_gas_limit: &mut Option<u64>,
     chain_id: u64,
     converter: &T,
 ) -> Result<
@@ -304,7 +309,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(
@@ -319,9 +365,23 @@ 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.

From fa7c66c14e48f65aa6f502d79696d0fdbf6e6218 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Fri, 29 May 2026 18:43:54 +0400
Subject: [PATCH 270/335] refactor: integrate state hook from `State<DB>`
 (#24654)

---
 Cargo.lock                                    |  4 +--
 Cargo.toml                                    |  2 +-
 bin/reth-bb/src/evm.rs                        | 33 +------------------
 .../tree/src/tree/payload_processor/mod.rs    |  5 ++-
 .../src/tree/payload_processor/multiproof.rs  |  4 +--
 .../src/tree/payload_processor/sparse_trie.rs |  2 +-
 .../engine/tree/src/tree/payload_validator.rs |  4 +--
 crates/ethereum/evm/tests/execute.rs          |  2 +-
 crates/ethereum/payload/src/lib.rs            |  6 ++--
 crates/evm/evm/src/execute.rs                 | 13 +++++---
 crates/trie/parallel/src/state_root_task.rs   | 31 ++---------------
 .../custom-beacon-withdrawals/src/main.rs     |  5 ---
 12 files changed, 26 insertions(+), 85 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ff6799d2cf3..db0212549d0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -306,9 +306,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-evm"
-version = "0.35.0"
+version = "0.36.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3585808f81853af97c12b062496d6be382e902df0e4f4c508e1305355b9e4d49"
+checksum = "a6e494529570a4d25eb4d1a7456d8f969c3202aceaf703e4006cec5f730aee96"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
diff --git a/Cargo.toml b/Cargo.toml
index e9508d53d48..f94a5f039a1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -449,7 +449,7 @@ 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.4.0", default-features = false, features = ["rlp"] }
-alloy-evm = { version = "0.35.0", default-features = false }
+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 }
 
diff --git a/bin/reth-bb/src/evm.rs b/bin/reth-bb/src/evm.rs
index 56be39d34dc..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};
 
 // ---------------------------------------------------------------------------
@@ -152,10 +151,6 @@ 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>>,
@@ -207,7 +202,6 @@ where
             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,
@@ -275,16 +269,6 @@ where
         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")
     }
@@ -384,12 +368,6 @@ where
         // 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
@@ -521,15 +499,6 @@ where
         Ok((evm, result))
     }
 
-    fn set_state_hook(&mut self, hook: Option<Box<dyn OnStateHook>>) {
-        // 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);
-    }
-
     fn evm_mut(&mut self) -> &mut Self::Evm {
         self.inner_mut().evm_mut()
     }
diff --git a/crates/engine/tree/src/tree/payload_processor/mod.rs b/crates/engine/tree/src/tree/payload_processor/mod.rs
index ec57b9ac67a..5949cbf0e4a 100644
--- a/crates/engine/tree/src/tree/payload_processor/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/mod.rs
@@ -1024,7 +1024,6 @@ 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;
@@ -1376,8 +1375,8 @@ mod tests {
 
         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 0edd1933430..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
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 bae7f5082ae..73e3fcd81f3 100644
--- a/crates/engine/tree/src/tree/payload_processor/sparse_trie.rs
+++ b/crates/engine/tree/src/tree/payload_processor/sparse_trie.rs
@@ -193,7 +193,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)
diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 16b2f11fd15..90200030a3d 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -1075,8 +1075,8 @@ where
         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();
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/payload/src/lib.rs b/crates/ethereum/payload/src/lib.rs
index 6605cd26c6a..0b05f2fb899 100644
--- a/crates/ethereum/payload/src/lib.rs
+++ b/crates/ethereum/payload/src/lib.rs
@@ -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;
@@ -221,7 +221,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| {
@@ -452,7 +452,7 @@ where
     {
         // 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.
diff --git a/crates/evm/evm/src/execute.rs b/crates/evm/evm/src/execute.rs
index 32b90d72e16..d641bbcffd2 100644
--- a/crates/evm/evm/src/execute.rs
+++ b/crates/evm/evm/src/execute.rs
@@ -633,16 +633,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> {
diff --git a/crates/trie/parallel/src/state_root_task.rs b/crates/trie/parallel/src/state_root_task.rs
index cd6783ad0d5..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.
@@ -123,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()));
         }
     }
 
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()
     }

From 57671f4fd63f62b4e6da3f6b5b8dc246193cbd2d Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Sat, 30 May 2026 10:18:23 +0200
Subject: [PATCH 271/335] chore(db): address static file cursor clippy lint
 (#24672)

---
 crates/storage/db/src/static_file/cursor.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

From 259b8dc3be74fd70e1a157a33a0a45785b8521c4 Mon Sep 17 00:00:00 2001
From: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
Date: Sat, 30 May 2026 15:54:53 +0530
Subject: [PATCH 272/335] chore: Override beacon block root for eth_simulate
 (#24652)

Co-authored-by: Soubhik Singha Mahapatra <soubhiksmp2004@gmail.com>
Co-authored-by: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/rpc/rpc-eth-api/src/helpers/call.rs    |  9 ++-
 .../rpc-eth-api/src/helpers/pending_block.rs  | 73 ++++++++++++++++---
 2 files changed, 67 insertions(+), 15 deletions(-)

diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs
index 107669705c0..c0b47b7aa77 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/call.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/call.rs
@@ -120,7 +120,12 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                 let mut remaining_call_gas_limit = (call_gas_limit > 0).then_some(call_gas_limit);
 
                 for block in block_state_calls {
-                    let attributes = this.next_env_attributes(&parent)?;
+                    let SimBlock { block_overrides, state_overrides, calls } = block;
+
+                    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()
@@ -139,8 +144,6 @@ 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.
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 71d4f8a1a74..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.
@@ -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));
     }

From 88ce2ac471f0e44fb65536268c93007ca3765851 Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Mon, 1 Jun 2026 19:46:05 +0530
Subject: [PATCH 273/335] chore(hive): update bal fixture and branch version to
 7 (#24734)

---
 .github/scripts/hive/build_simulators.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/scripts/hive/build_simulators.sh b/.github/scripts/hive/build_simulators.sh
index baad56dddaf..c87b3be58d9 100755
--- a/.github/scripts/hive/build_simulators.sh
+++ b/.github/scripts/hive/build_simulators.sh
@@ -5,8 +5,8 @@ fixture_variant="${1:-osaka}"
 
 case "${fixture_variant}" in
     amsterdam)
-        eels_fixtures="https://github.com/ethereum/execution-spec-tests/releases/download/bal@v5.6.1/fixtures_bal.tar.gz"
-        eels_branch="devnets/bal/3"
+        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"

From 8b07219eb87163b58763a712a422aa66c5a59486 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Mon, 1 Jun 2026 08:21:01 -0700
Subject: [PATCH 274/335] ci: update benchmark RPC endpoint (#24735)

---
 .github/workflows/bench-scheduled.yml | 2 +-
 .github/workflows/bench.yml           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/bench-scheduled.yml b/.github/workflows/bench-scheduled.yml
index 5a811d2f569..489a3c83a43 100644
--- a/.github/workflows/bench-scheduled.yml
+++ b/.github/workflows/bench-scheduled.yml
@@ -290,7 +290,7 @@ 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
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index abf6003a00d..c3b553df304 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -612,7 +612,7 @@ jobs:
       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

From 63598af37bac813a49709bfa54a5cc1516f61a51 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 2 Jun 2026 10:02:11 +0200
Subject: [PATCH 275/335] fix(provider): reject expired recovered blocks
 (#24760)

---
 crates/storage/provider/src/providers/database/provider.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/storage/provider/src/providers/database/provider.rs b/crates/storage/provider/src/providers/database/provider.rs
index c9807eaf8f2..58e24c38e88 100644
--- a/crates/storage/provider/src/providers/database/provider.rs
+++ b/crates/storage/provider/src/providers/database/provider.rs
@@ -1099,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

From 84fb8008a38f5e46f314f568656fec28f4b82d61 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 2 Jun 2026 01:54:11 -0700
Subject: [PATCH 276/335] chore(docs): bump Vocs to v2 (#24732)

---
 .github/workflows/book.yml              |    2 +-
 docs/cli/help.rs                        |    2 +-
 docs/vocs/bun.lock                      | 1336 +++++++++--------------
 docs/vocs/docs/pages/index.mdx          |   11 +-
 docs/vocs/package.json                  |    8 +-
 docs/vocs/scripts/fix-search-index.ts   |   27 +-
 docs/vocs/scripts/generate-redirects.ts |    7 +-
 docs/vocs/scripts/inject-cargo-docs.ts  |    9 +-
 docs/vocs/sidebar-cli-reth.ts           |    2 +-
 docs/vocs/sidebar.ts                    |    3 +-
 docs/vocs/types.ts                      |   12 +
 docs/vocs/vocs.config.ts                |   68 +-
 12 files changed, 574 insertions(+), 913 deletions(-)
 create mode 100644 docs/vocs/types.ts

diff --git a/.github/workflows/book.yml b/.github/workflows/book.yml
index 142e5111482..24a0a1270fb 100644
--- a/.github/workflows/book.yml
+++ b/.github/workflows/book.yml
@@ -53,7 +53,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/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..084f2288f10 100644
--- a/docs/vocs/bun.lock
+++ b/docs/vocs/bun.lock
@@ -7,23 +7,21 @@
       "dependencies": {
         "react": "^19.2.5",
         "react-dom": "^19.2.5",
-        "vocs": "~1.0.13",
+        "vocs": "^2.0.10",
+        "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 +38,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 +48,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 +56,191 @@
 
     "@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=="],
-
-    "@clack/core": ["@clack/core@0.3.5", "", { "dependencies": { "picocolors": "^1.0.0", "sisteransi": "^1.0.5" } }, "sha512-5cfhQNH+1VQ2xLQlmzXMqUoiaH0lRBq9/CLW9lTyMbuKLC3+xEK01tHVvyut++mLOn5urSHmkm6I0Lg9MaJSTQ=="],
+    "@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/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=="],
+    "@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=="],
 
-    "@emotion/hash": ["@emotion/hash@0.9.2", "", {}, "sha512-MyqliTZGuOm3+5ZRSaaBGP3USLw6+EGykkwZns2EPC5g8jJ4z9OrdZY9apkl3+UP9+sdz76YYkwCKP5gh8iY3g=="],
+    "@codemirror/autocomplete": ["@codemirror/autocomplete@6.20.2", "", { "dependencies": { "@codemirror/language": "^6.0.0", "@codemirror/state": "^6.0.0", "@codemirror/view": "^6.17.0", "@lezer/common": "^1.0.0" } }, "sha512-G5FPkgIiLjOgZMjqVjvuKQ1rGPtHogLldJr33eFJdVLtmwY+giGrlv/ewljLz6b9BSQLkjxuwBc6g6omDM+YxQ=="],
 
-    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.6", "", { "os": "aix", "cpu": "ppc64" }, "sha512-ShbM/3XxwuxjFiuVBHA+d3j5dyac0aEVVq1oluIDf71hUw0aRF59dV/efUsIwFnR6m8JNM2FjZOzmaZ8yG61kw=="],
+    "@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-arm": ["@esbuild/android-arm@0.25.6", "", { "os": "android", "cpu": "arm" }, "sha512-S8ToEOVfg++AU/bHwdksHNnyLyVM+eMVAOf6yRKFitnwnbwwPNqKr3srzFRe7nzV69RQKb5DgchIX5pt3L53xg=="],
+    "@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-arm64": ["@esbuild/android-arm64@0.25.6", "", { "os": "android", "cpu": "arm64" }, "sha512-hd5zdUarsK6strW+3Wxi5qWws+rJhCCbMiC9QZyzoxfk5uHRIE8T287giQxzVpEvCwuJ9Qjg6bEjcRJcgfLqoA=="],
+    "@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/android-x64": ["@esbuild/android-x64@0.25.6", "", { "os": "android", "cpu": "x64" }, "sha512-0Z7KpHSr3VBIO9A/1wcT3NTy7EB4oNC4upJ5ye3R7taCc2GUdeynSLArnon5G8scPwaU866d3H4BCrE5xLW25A=="],
+    "@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-arm64": ["@esbuild/darwin-arm64@0.25.6", "", { "os": "darwin", "cpu": "arm64" }, "sha512-FFCssz3XBavjxcFxKsGy2DYK5VSvJqa6y5HXljKzhRZ87LvEi13brPrf/wdyl/BbpbMKJNOr1Sd0jtW4Ge1pAA=="],
+    "@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/darwin-x64": ["@esbuild/darwin-x64@0.25.6", "", { "os": "darwin", "cpu": "x64" }, "sha512-GfXs5kry/TkGM2vKqK2oyiLFygJRqKVhawu3+DOCk7OxLy/6jYkWXhlHwOoTb0WqGnWGAS7sooxbZowy+pK9Yg=="],
+    "@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-arm64": ["@esbuild/freebsd-arm64@0.25.6", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-aoLF2c3OvDn2XDTRvn8hN6DRzVVpDlj2B/F66clWd/FHLiHaG3aVZjxQX2DYphA5y/evbdGvC6Us13tvyt4pWg=="],
+    "@codemirror/state": ["@codemirror/state@6.6.0", "", { "dependencies": { "@marijn/find-cluster-break": "^1.0.0" } }, "sha512-4nbvra5R5EtiCzr9BTHiTLc+MLXK2QGiAVYMyi8PkQd3SR+6ixar/Q/01Fa21TBIDOZXgeWV4WppsQolSreAPQ=="],
 
-    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.6", "", { "os": "freebsd", "cpu": "x64" }, "sha512-2SkqTjTSo2dYi/jzFbU9Plt1vk0+nNg8YC8rOXXea+iA3hfNJWebKYPs3xnOUf9+ZWhKAaxnQNUf2X9LOpeiMQ=="],
+    "@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-arm": ["@esbuild/linux-arm@0.25.6", "", { "os": "linux", "cpu": "arm" }, "sha512-SZHQlzvqv4Du5PrKE2faN0qlbsaW/3QQfUUc6yO2EjFcA83xnwm91UbEEVx4ApZ9Z5oG8Bxz4qPE+HFwtVcfyw=="],
+    "@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-arm64": ["@esbuild/linux-arm64@0.25.6", "", { "os": "linux", "cpu": "arm64" }, "sha512-b967hU0gqKd9Drsh/UuAm21Khpoh6mPBSgz8mKRq4P5mVK8bpA+hQzmm/ZwGVULSNBzKdZPQBRT3+WuVavcWsQ=="],
+    "@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-ia32": ["@esbuild/linux-ia32@0.25.6", "", { "os": "linux", "cpu": "ia32" }, "sha512-aHWdQ2AAltRkLPOsKdi3xv0mZ8fUGPdlKEjIEhxCPm5yKEThcUjHpWB1idN74lfXGnZ5SULQSgtr5Qos5B0bPw=="],
+    "@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-loong64": ["@esbuild/linux-loong64@0.25.6", "", { "os": "linux", "cpu": "none" }, "sha512-VgKCsHdXRSQ7E1+QXGdRPlQ/e08bN6WMQb27/TMfV+vPjjTImuT9PmLXupRlC90S1JeNNW5lzkAEO/McKeJ2yg=="],
+    "@emnapi/core": ["@emnapi/core@1.10.0", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.1", "tslib": "^2.4.0" } }, "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw=="],
 
-    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.6", "", { "os": "linux", "cpu": "none" }, "sha512-WViNlpivRKT9/py3kCmkHnn44GkGXVdXfdc4drNmRl15zVQ2+D2uFwdlGh6IuK5AAnGTo2qPB1Djppj+t78rzw=="],
+    "@emnapi/runtime": ["@emnapi/runtime@1.10.0", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA=="],
 
-    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.6", "", { "os": "linux", "cpu": "ppc64" }, "sha512-wyYKZ9NTdmAMb5730I38lBqVu6cKl4ZfYXIs31Baf8aoOtB4xSGi3THmDYt4BTFHk7/EcVixkOV2uZfwU3Q2Jw=="],
+    "@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.1", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w=="],
 
-    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.6", "", { "os": "linux", "cpu": "none" }, "sha512-KZh7bAGGcrinEj4qzilJ4hqTY3Dg2U82c8bv+e1xqNqZCrCyc+TL9AUEn5WGKDzm3CfC5RODE/qc96OcbIe33w=="],
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.28.0", "", { "os": "aix", "cpu": "ppc64" }, "sha512-lhRUCeuOyJQURhTxl4WkpFTjIsbDayJHih5kZC1giwE+MhIzAb7mEsQMqMf18rHLsrb5qI1tafG20mLxEWcWlA=="],
 
-    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.6", "", { "os": "linux", "cpu": "s390x" }, "sha512-9N1LsTwAuE9oj6lHMyyAM+ucxGiVnEqUdp4v7IaMmrwb06ZTEVCIs3oPPplVsnjPfyjmxwHxHMF8b6vzUVAUGw=="],
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.28.0", "", { "os": "android", "cpu": "arm" }, "sha512-wqh0ByljabXLKHeWXYLqoJ5jKC4XBaw6Hk08OfMrCRd2nP2ZQ5eleDZC41XHyCNgktBGYMbqnrJKq/K/lzPMSQ=="],
 
-    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.6", "", { "os": "linux", "cpu": "x64" }, "sha512-A6bJB41b4lKFWRKNrWoP2LHsjVzNiaurf7wyj/XtFNTsnPuxwEBWHLty+ZE0dWBKuSK1fvKgrKaNjBS7qbFKig=="],
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.28.0", "", { "os": "android", "cpu": "arm64" }, "sha512-+WzIXQOSaGs33tLEgYPYe/yQHf0WTU0X42Jca3y8NWMbUVhp7rUnw+vAsRC/QiDrdD31IszMrZy+qwPOPjd+rw=="],
 
-    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.6", "", { "os": "none", "cpu": "arm64" }, "sha512-IjA+DcwoVpjEvyxZddDqBY+uJ2Snc6duLpjmkXm/v4xuS3H+3FkLZlDm9ZsAbF9rsfP3zeA0/ArNDORZgrxR/Q=="],
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.28.0", "", { "os": "android", "cpu": "x64" }, "sha512-+VJggoaKhk2VNNqVL7f6S189UzShHC/mR9EE8rDdSkdpN0KflSwWY/gWjDrNxxisg8Fp1ZCD9jLMo4m0OUfeUA=="],
 
-    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.6", "", { "os": "none", "cpu": "x64" }, "sha512-dUXuZr5WenIDlMHdMkvDc1FAu4xdWixTCRgP7RQLBOkkGgwuuzaGSYcOpW4jFxzpzL1ejb8yF620UxAqnBrR9g=="],
-
-    "@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=="],
-
-    "@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/darwin-x64": ["@esbuild/darwin-x64@0.28.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-fyzLm/DLDl/84OCfp2f/XQ4flmORsjU7VKt8HLjvIXChJoFFOIL6pLJPH4Yhd1n1gGFF9mPwtlN5Wf82DZs+LQ=="],
 
-    "@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-arm64": ["@esbuild/freebsd-arm64@0.28.0", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-l9GeW5UZBT9k9brBYI+0WDffcRxgHQD8ShN2Ur4xWq/NFzUKm3k5lsH4PdaRgb2w7mI9u61nr2gI2mLI27Nh3Q=="],
 
-    "@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/freebsd-x64": ["@esbuild/freebsd-x64@0.28.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-BXoQai/A0wPO6Es3yFJ7APCiKGc1tdAEOgeTNy3SsB491S3aHn4S4r3e976eUnPdU+NbdtmBuLncYir2tMU9Nw=="],
 
-    "@mermaid-js/parser": ["@mermaid-js/parser@0.6.2", "", { "dependencies": { "langium": "3.3.1" } }, "sha512-+PO02uGF6L6Cs0Bw8RpGhikVvMWEysfAyl27qTlroUB8jSWr1lL0Sf6zi78ZxlSnmgSY2AMMKVgghnN9jTtwkQ=="],
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.28.0", "", { "os": "linux", "cpu": "arm" }, "sha512-CjaaREJagqJp7iTaNQjjidaNbCKYcd4IDkzbwwxtSvjI7NZm79qiHc8HqciMddQ6CKvJT6aBd8lO9kN/ZudLlw=="],
 
-    "@noble/hashes": ["@noble/hashes@1.8.0", "", {}, "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A=="],
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.28.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-RVyzfb3FWsGA55n6WY0MEIEPURL1FcbhFE6BffZEMEekfCzCIMtB5yyDcFnVbTnwk+CLAgTujmV/Lgvih56W+A=="],
 
-    "@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-ia32": ["@esbuild/linux-ia32@0.28.0", "", { "os": "linux", "cpu": "ia32" }, "sha512-KBnSTt1kxl9x70q+ydterVdl+Cn0H18ngRMRCEQfrbqdUuntQQ0LoMZv47uB97NljZFzY6HcfqEZ2SAyIUTQBQ=="],
 
-    "@nodelib/fs.stat": ["@nodelib/fs.stat@2.0.5", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="],
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.28.0", "", { "os": "linux", "cpu": "none" }, "sha512-zpSlUce1mnxzgBADvxKXX5sl8aYQHo2ezvMNI8I0lbblJtp8V4odlm3Yzlj7gPyt3T8ReksE6bK+pT3WD+aJRg=="],
 
-    "@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-mips64el": ["@esbuild/linux-mips64el@0.28.0", "", { "os": "linux", "cpu": "none" }, "sha512-2jIfP6mmjkdmeTlsX/9vmdmhBmKADrWqN7zcdtHIeNSCH1SqIoNI63cYsjQR8J+wGa4Y5izRcSHSm8K3QWmk3w=="],
 
-    "@radix-ui/colors": ["@radix-ui/colors@3.0.0", "", {}, "sha512-FUOsGBkHrYJwCSEtWRCIfQbZG7q1e6DgxCIOe1SUQzDe/7rXXeA47s8yCn6fuTNQAj1Zq4oTFi9Yjp3wzElcxg=="],
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.28.0", "", { "os": "linux", "cpu": "ppc64" }, "sha512-bc0FE9wWeC0WBm49IQMPSPILRocGTQt3j5KPCA8os6VprfuJ7KD+5PzESSrJ6GmPIPJK965ZJHTUlSA6GNYEhg=="],
 
-    "@radix-ui/number": ["@radix-ui/number@1.1.1", "", {}, "sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g=="],
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.28.0", "", { "os": "linux", "cpu": "none" }, "sha512-SQPZOwoTTT/HXFXQJG/vBX8sOFagGqvZyXcgLA3NhIqcBv1BJU1d46c0rGcrij2B56Z2rNiSLaZOYW5cUk7yLQ=="],
 
-    "@radix-ui/primitive": ["@radix-ui/primitive@1.1.2", "", {}, "sha512-XnbHrrprsNqZKQhStrSwgRUQzoCI1glLzdw79xiZPoofhGICeZRSQ3dIxAKH1gb3OHfNf4d6f+vAv3kil2eggA=="],
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.28.0", "", { "os": "linux", "cpu": "s390x" }, "sha512-SCfR0HN8CEEjnYnySJTd2cw0k9OHB/YFzt5zgJEwa+wL/T/raGWYMBqwDNAC6dqFKmJYZoQBRfHjgwLHGSrn3Q=="],
 
-    "@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/linux-x64": ["@esbuild/linux-x64@0.28.0", "", { "os": "linux", "cpu": "x64" }, "sha512-us0dSb9iFxIi8srnpl931Nvs65it/Jd2a2K3qs7fz2WfGPHqzfzZTfec7oxZJRNPXPnNYZtanmRc4AL/JwVzHQ=="],
 
-    "@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-arm64": ["@esbuild/netbsd-arm64@0.28.0", "", { "os": "none", "cpu": "arm64" }, "sha512-CR/RYotgtCKwtftMwJlUU7xCVNg3lMYZ0RzTmAHSfLCXw3NtZtNpswLEj/Kkf6kEL3Gw+BpOekRX0BYCtklhUw=="],
 
-    "@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/netbsd-x64": ["@esbuild/netbsd-x64@0.28.0", "", { "os": "none", "cpu": "x64" }, "sha512-nU1yhmYutL+fQ71Kxnhg8uEOdC0pwEW9entHykTgEbna2pw2dkbFSMeqjjyHZoCmt8SBkOSvV+yNmm94aUrrqw=="],
 
-    "@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-arm64": ["@esbuild/openbsd-arm64@0.28.0", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-cXb5vApOsRsxsEl4mcZ1XY3D4DzcoMxR/nnc4IyqYs0rTI8ZKmW6kyyg+11Z8yvgMfAEldKzP7AdP64HnSC/6g=="],
 
-    "@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/openbsd-x64": ["@esbuild/openbsd-x64@0.28.0", "", { "os": "openbsd", "cpu": "x64" }, "sha512-8wZM2qqtv9UP3mzy7HiGYNH/zjTA355mpeuA+859TyR+e+Tc08IHYpLJuMsfpDJwoLo1ikIJI8jC3GFjnRClzA=="],
 
-    "@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/openharmony-arm64": ["@esbuild/openharmony-arm64@0.28.0", "", { "os": "none", "cpu": "arm64" }, "sha512-FLGfyizszcef5C3YtoyQDACyg95+dndv79i2EekILBofh5wpCa1KuBqOWKrEHZg3zrL3t5ouE5jgr94vA+Wb2w=="],
 
-    "@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/sunos-x64": ["@esbuild/sunos-x64@0.28.0", "", { "os": "sunos", "cpu": "x64" }, "sha512-1ZgjUoEdHZZl/YlV76TSCz9Hqj9h9YmMGAgAPYd+q4SicWNX3G5GCyx9uhQWSLcbvPW8Ni7lj4gDa1T40akdlw=="],
 
-    "@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-arm64": ["@esbuild/win32-arm64@0.28.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-Q9StnDmQ/enxnpxCCLSg0oo4+34B9TdXpuyPeTedN/6+iXBJ4J+zwfQI28u/Jl40nOYAxGoNi7mFP40RUtkmUA=="],
 
-    "@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-ia32": ["@esbuild/win32-ia32@0.28.0", "", { "os": "win32", "cpu": "ia32" }, "sha512-zF3ag/gfiCe6U2iczcRzSYJKH1DCI+ByzSENHlM2FcDbEeo5Zd2C86Aq0tKUYAJJ1obRP84ymxIAksZUcdztHA=="],
 
-    "@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=="],
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.28.0", "", { "os": "win32", "cpu": "x64" }, "sha512-pEl1bO9mfAmIC+tW5btTmrKaujg3zGtUmWNdCw/xs70FBjwAL3o9OEKNHvNmnyylD6ubxUERiEhdsL0xBQ9efw=="],
 
-    "@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/core": ["@floating-ui/core@1.7.5", "", { "dependencies": { "@floating-ui/utils": "^0.2.11" } }, "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ=="],
 
-    "@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/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-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/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-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=="],
+    "@floating-ui/utils": ["@floating-ui/utils@0.2.11", "", {}, "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg=="],
 
-    "@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=="],
+    "@hono/node-server": ["@hono/node-server@2.0.4", "", { "peerDependencies": { "hono": "^4" } }, "sha512-Ut3y0dMMPWy6bZ2kVfx25EOVbZlm15dhF4mOsezMlhpNHy+4MkU1qN9Y6lnruYi4wPmFzimGX2X7LF/FwHli4A=="],
 
-    "@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/lucide": ["@iconify-json/lucide@1.2.111", "", { "dependencies": { "@iconify/types": "*" } }, "sha512-S6oXom2YOKuXFxWofhHa2oq++Z3WeZ78dRFDA7aEEJqyNCJlQd1UGAfN8u2gD2NzvYotmm+j5kH678viWfZbGQ=="],
 
-    "@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/simple-icons": ["@iconify-json/simple-icons@1.2.84", "", { "dependencies": { "@iconify/types": "*" } }, "sha512-v4JVu6xIewGoETD4mm2k6UAdFAbTlY1duw5ZNSxYORfs2yFsHDhoU9Omn/BgrV0nR/ptWkF3ZIr/ZHoYXI/6Jw=="],
 
-    "@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-json/vscode-icons": ["@iconify-json/vscode-icons@1.2.53", "", { "dependencies": { "@iconify/types": "*" } }, "sha512-l7EU0XxVXufefqYg8gaBgsmM0Bk6Sg5EbF6JTnJ15YkRbC9eiDn5dtyV41IRpV/dabveEAl0iD7dQjv+A7fNLA=="],
 
-    "@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/types": ["@iconify/types@2.0.0", "", {}, "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg=="],
 
-    "@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=="],
+    "@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-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=="],
+    "@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-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/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-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/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-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/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
 
-    "@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/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-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/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
 
-    "@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=="],
+    "@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-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/common": ["@lezer/common@1.5.2", "", {}, "sha512-sxQE460fPZyU3sdc8lafxiPwJHBzZRy/udNFynGQky1SePYBdhkBl1kOagA9uT3pxR8K09bOrmTUqA9wb/PjSQ=="],
 
-    "@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/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-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/highlight": ["@lezer/highlight@1.2.3", "", { "dependencies": { "@lezer/common": "^1.3.0" } }, "sha512-qXdH7UqTvGfdVBINrgKhDsVTJTxactNNxLk7+UMwZhU13lMHaOBlJe9Vqp907ya56Y3+ed2tlqzys7jDkTmW0g=="],
 
-    "@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/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-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/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-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=="],
+    "@lezer/lr": ["@lezer/lr@1.4.10", "", { "dependencies": { "@lezer/common": "^1.0.0" } }, "sha512-rnCpTIBafOx4mRp43xOxDJbFipJm/c0cia/V5TiGlhmMa+wsSdoGmUN3w5Bqrks/09Q/D4tNAmWaT8p6NRi77A=="],
 
-    "@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=="],
+    "@marijn/find-cluster-break": ["@marijn/find-cluster-break@1.0.2", "", {}, "sha512-l0h88YhZFyKdXIFNfSWpyjStDjGHwZ/U7iobcK1cQQD8sejsONdQtTVU+1wVN1PBw40PiiHB1vA5S7VTfQiP9g=="],
 
-    "@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/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-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/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-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=="],
+    "@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-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,127 +284,109 @@
 
     "@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=="],
-
-    "@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=="],
-
-    "@tailwindcss/oxide-android-arm64": ["@tailwindcss/oxide-android-arm64@4.0.7", "", { "os": "android", "cpu": "arm64" }, "sha512-5iQXXcAeOHBZy8ASfHFm1k0O/9wR2E3tKh6+P+ilZZbQiMgu+qrnfpBWYPc3FPuQdWiWb73069WT5D+CAfx/tg=="],
-
-    "@tailwindcss/oxide-darwin-arm64": ["@tailwindcss/oxide-darwin-arm64@4.0.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-7yGZtEc5IgVYylqK/2B0yVqoofk4UAbkn1ygNpIJZyrOhbymsfr8uUFCueTu2fUxmAYIfMZ8waWo2dLg/NgLgg=="],
-
-    "@tailwindcss/oxide-darwin-x64": ["@tailwindcss/oxide-darwin-x64@4.0.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-tPQDV20fBjb26yWbPqT1ZSoDChomMCiXTKn4jupMSoMCFyU7+OJvIY1ryjqBuY622dEBJ8LnCDDWsnj1lX9nNQ=="],
-
-    "@tailwindcss/oxide-freebsd-x64": ["@tailwindcss/oxide-freebsd-x64@4.0.7", "", { "os": "freebsd", "cpu": "x64" }, "sha512-sZqJpTyTZiknU9LLHuByg5GKTW+u3FqM7q7myequAXxKOpAFiOfXpY710FuMY+gjzSapyRbDXJlsTQtCyiTo5w=="],
-
-    "@tailwindcss/oxide-linux-arm-gnueabihf": ["@tailwindcss/oxide-linux-arm-gnueabihf@4.0.7", "", { "os": "linux", "cpu": "arm" }, "sha512-PBgvULgeSswjd8cbZ91gdIcIDMdc3TUHV5XemEpxlqt9M8KoydJzkuB/Dt910jYdofOIaTWRL6adG9nJICvU4A=="],
-
-    "@tailwindcss/oxide-linux-arm64-gnu": ["@tailwindcss/oxide-linux-arm64-gnu@4.0.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-By/a2yeh+e9b+C67F88ndSwVJl2A3tcUDb29FbedDi+DZ4Mr07Oqw9Y1DrDrtHIDhIZ3bmmiL1dkH2YxrtV+zw=="],
+    "@stitches/core": ["@stitches/core@1.2.8", "", {}, "sha512-Gfkvwk9o9kE9r9XNBmJRfV8zONvXThnm1tcuojL04Uy5uRyqg93DC83lDebl0rocZCfKSjUv+fWYtMQmEDJldg=="],
 
-    "@tailwindcss/oxide-linux-arm64-musl": ["@tailwindcss/oxide-linux-arm64-musl@4.0.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-WHYs3cpPEJb/ccyT20NOzopYQkl7JKncNBUbb77YFlwlXMVJLLV3nrXQKhr7DmZxz2ZXqjyUwsj2rdzd9stYdw=="],
+    "@svgr/babel-plugin-add-jsx-attribute": ["@svgr/babel-plugin-add-jsx-attribute@8.0.0", "", { "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-b9MIk7yhdS1pMCZM8VeNfUlSKVRhsHZNMl5O9SfaX0l0t5wjdgu4IDzGB8bpnGBBOjGST3rRFVsaaEtI4W6f7g=="],
 
-    "@tailwindcss/oxide-linux-x64-gnu": ["@tailwindcss/oxide-linux-x64-gnu@4.0.7", "", { "os": "linux", "cpu": "x64" }, "sha512-7bP1UyuX9kFxbOwkeIJhBZNevKYPXB6xZI37v09fqi6rqRJR8elybwjMUHm54GVP+UTtJ14ueB1K54Dy1tIO6w=="],
+    "@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=="],
 
-    "@tailwindcss/oxide-linux-x64-musl": ["@tailwindcss/oxide-linux-x64-musl@4.0.7", "", { "os": "linux", "cpu": "x64" }, "sha512-gBQIV8nL/LuhARNGeroqzXymMzzW5wQzqlteVqOVoqwEfpHOP3GMird5pGFbnpY+NP0fOlsZGrxxOPQ4W/84bQ=="],
+    "@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=="],
 
-    "@tailwindcss/oxide-win32-arm64-msvc": ["@tailwindcss/oxide-win32-arm64-msvc@4.0.7", "", { "os": "win32", "cpu": "arm64" }, "sha512-aH530NFfx0kpQpvYMfWoeG03zGnRCMVlQG8do/5XeahYydz+6SIBxA1tl/cyITSJyWZHyVt6GVNkXeAD30v0Xg=="],
+    "@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-win32-x64-msvc": ["@tailwindcss/oxide-win32-x64-msvc@4.0.7", "", { "os": "win32", "cpu": "x64" }, "sha512-8Cva6bbJN7ZJx320k7vxGGdU0ewmpfS5A4PudyzUuofdi8MgeINuiiWiPQ0VZCda/GX88K6qp+6UpDZNVr8HMQ=="],
+    "@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/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=="],
+    "@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=="],
 
-    "@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=="],
+    "@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=="],
 
-    "@types/babel__generator": ["@types/babel__generator@7.27.0", "", { "dependencies": { "@babel/types": "^7.0.0" } }, "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg=="],
+    "@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=="],
 
-    "@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=="],
+    "@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=="],
 
-    "@types/babel__traverse": ["@types/babel__traverse@7.20.7", "", { "dependencies": { "@babel/types": "^7.20.7" } }, "sha512-dkO5fhS7+/oos4ciWxyEyjWe48zmG6wbCheo/G2ZnHx4fs3EU6YC6UM8rk56gAjNJ9P3MTH2jo5jb92/K6wbng=="],
+    "@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=="],
 
-    "@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=="],
+    "@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=="],
 
-    "@types/d3-array": ["@types/d3-array@3.2.1", "", {}, "sha512-Y2Jn2idRrLzUfAKV2LyRImR+y4oa2AntrgID95SHJxuMUrkNXmanDSed71sRNZysveJVt1hLLemQZIady0FpEg=="],
+    "@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=="],
 
-    "@types/d3-axis": ["@types/d3-axis@3.0.6", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-pYeijfZuBd87T0hGn0FO1vQ/cgLk6E1ALJjfkC0oJ8cbwkZl3TpgS8bVBLZN+2jjGgg38epgxb2zmoGtSfvgMw=="],
+    "@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=="],
 
-    "@types/d3-brush": ["@types/d3-brush@3.0.6", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-nH60IZNNxEcrh6L1ZSMNA28rj27ut/2ZmI3r96Zd+1jrZD++zD3LsMIjWlvg4AYrHn/Pqz4CF3veCxGjtbqt7A=="],
+    "@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=="],
 
-    "@types/d3-chord": ["@types/d3-chord@3.0.6", "", {}, "sha512-LFYWWd8nwfwEmTZG9PfQxd17HbNPksHBiJHaKuY1XeqscXacsS2tyoo6OdRsjf+NQYeB6XrNL3a25E3gH69lcg=="],
+    "@tailwindcss/oxide-android-arm64": ["@tailwindcss/oxide-android-arm64@4.3.0", "", { "os": "android", "cpu": "arm64" }, "sha512-TJPiq67tKlLuObP6RkwvVGDoxCMBVtDgKkLfa/uyj7/FyxvQwHS+UOnVrXXgbEsfUaMgiVvC4KbJnRr26ho4Ng=="],
 
-    "@types/d3-color": ["@types/d3-color@3.1.3", "", {}, "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A=="],
+    "@tailwindcss/oxide-darwin-arm64": ["@tailwindcss/oxide-darwin-arm64@4.3.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-oMN/WZRb+SO37BmUElEgeEWuU8E/HXRkiODxJxLe1UTHVXLrdVSgfaJV7pSlhRGMSOiXLuxTIjfsF3wYvz8cgQ=="],
 
-    "@types/d3-contour": ["@types/d3-contour@3.0.6", "", { "dependencies": { "@types/d3-array": "*", "@types/geojson": "*" } }, "sha512-BjzLgXGnCWjUSYGfH1cpdo41/hgdWETu4YxpezoztawmqsvCeep+8QGfiY6YbDvfgHz/DkjeIkkZVJavB4a3rg=="],
+    "@tailwindcss/oxide-darwin-x64": ["@tailwindcss/oxide-darwin-x64@4.3.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-N6CUmu4a6bKVADfw77p+iw6Yd9Q3OBhe0veaDX+QazfuVYlQsHfDgxBrsjQ/IW+zywL8mTrNd0SdJT/zgtvMdA=="],
 
-    "@types/d3-delaunay": ["@types/d3-delaunay@6.0.4", "", {}, "sha512-ZMaSKu4THYCU6sV64Lhg6qjf1orxBthaC161plr5KuPHo3CNm8DTHiLw/5Eq2b6TsNP0W0iJrUOFscY6Q450Hw=="],
+    "@tailwindcss/oxide-freebsd-x64": ["@tailwindcss/oxide-freebsd-x64@4.3.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-zDL5hBkQdH5C6MpqbK3gQAgP80tsMwSI26vjOzjJtNCMUo0lFgOItzHKBIupOZNQxt3ouPH7RPhvNhiTfCe5CQ=="],
 
-    "@types/d3-dispatch": ["@types/d3-dispatch@3.0.6", "", {}, "sha512-4fvZhzMeeuBJYZXRXrRIQnvUYfyXwYmLsdiN7XXmVNQKKw1cM8a5WdID0g1hVFZDqT9ZqZEY5pD44p24VS7iZQ=="],
+    "@tailwindcss/oxide-linux-arm-gnueabihf": ["@tailwindcss/oxide-linux-arm-gnueabihf@4.3.0", "", { "os": "linux", "cpu": "arm" }, "sha512-R06HdNi7A7OEoMsf6d4tjZ71RCWnZQPHj2mnotSFURjNLdBC+cIgXQ7l81CqeoiQftjf6OOblxXMInMgN2VzMA=="],
 
-    "@types/d3-drag": ["@types/d3-drag@3.0.7", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ=="],
+    "@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/d3-dsv": ["@types/d3-dsv@3.0.7", "", {}, "sha512-n6QBF9/+XASqcKK6waudgL0pf/S5XHPPI8APyMLLUHd8NqouBGLsU8MgtO7NINGtPBtk9Kko/W4ea0oAspwh9g=="],
+    "@tailwindcss/oxide-linux-arm64-musl": ["@tailwindcss/oxide-linux-arm64-musl@4.3.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-Z6sukiQsngnWO+l39X4pPbiWT81IC+PLKF+PHxIlyZbGNb9MODfYlXEVlFvej5BOZInWX01kVyzeLvHsXhfczQ=="],
 
-    "@types/d3-ease": ["@types/d3-ease@3.0.2", "", {}, "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA=="],
+    "@tailwindcss/oxide-linux-x64-gnu": ["@tailwindcss/oxide-linux-x64-gnu@4.3.0", "", { "os": "linux", "cpu": "x64" }, "sha512-DRNdQRpSGzRGfARVuVkxvM8Q12nh19l4BF/G7zGA1oe+9wcC6saFBHTISrpIcKzhiXtSrlSrluCfvMuledoCTQ=="],
 
-    "@types/d3-fetch": ["@types/d3-fetch@3.0.7", "", { "dependencies": { "@types/d3-dsv": "*" } }, "sha512-fTAfNmxSb9SOWNB9IoG5c8Hg6R+AzUHDRlsXsDZsNp6sxAEOP0tkP3gKkNSO/qmHPoBFTxNrjDprVHDQDvo5aA=="],
+    "@tailwindcss/oxide-linux-x64-musl": ["@tailwindcss/oxide-linux-x64-musl@4.3.0", "", { "os": "linux", "cpu": "x64" }, "sha512-Z0IADbDo8bh6I7h2IQMx601AdXBLfFpEdUotft86evd/8ZPflZe9COPO8Q1vw+pfLWIUo9zN/JGZvwuAJqduqg=="],
 
-    "@types/d3-force": ["@types/d3-force@3.0.10", "", {}, "sha512-ZYeSaCF3p73RdOKcjj+swRlZfnYpK1EbaDiYICEEp5Q6sUiqFaFQ9qgoshp5CzIyyb/yD09kD9o2zEltCexlgw=="],
+    "@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=="],
 
-    "@types/d3-format": ["@types/d3-format@3.0.4", "", {}, "sha512-fALi2aI6shfg7vM5KiR1wNJnZ7r6UuggVqtDA+xiEdPZQwy/trcQaHnwShLuLdta2rTymCNpxYTiMZX/e09F4g=="],
+    "@tailwindcss/oxide-win32-arm64-msvc": ["@tailwindcss/oxide-win32-arm64-msvc@4.3.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-Pe+RPVTi1T+qymuuRpcdvwSVZjnll/f7n8gBxMMh3xLTctMDKqpdfGimbMyioqtLhUYZxdJ9wGNhV7MKHvgZsQ=="],
 
-    "@types/d3-geo": ["@types/d3-geo@3.1.0", "", { "dependencies": { "@types/geojson": "*" } }, "sha512-856sckF0oP/diXtS4jNsiQw/UuK5fQG8l/a9VVLeSouf1/PPbBE1i1W852zVwKwYCBkFJJB7nCFTbk6UMEXBOQ=="],
+    "@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=="],
 
-    "@types/d3-hierarchy": ["@types/d3-hierarchy@3.1.7", "", {}, "sha512-tJFtNoYBtRtkNysX1Xq4sxtjK8YgoWUNpIiUee0/jHGRwqvzYxkq0hGVbbOGSz+JgFxxRu4K8nb3YpG3CMARtg=="],
+    "@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=="],
 
-    "@types/d3-interpolate": ["@types/d3-interpolate@3.0.4", "", { "dependencies": { "@types/d3-color": "*" } }, "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA=="],
+    "@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=="],
 
-    "@types/d3-path": ["@types/d3-path@3.1.1", "", {}, "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg=="],
+    "@takumi-rs/core-darwin-arm64": ["@takumi-rs/core-darwin-arm64@0.62.8", "", { "os": "darwin", "cpu": "arm64" }, "sha512-TxVakpycL4g99i2mmLp7abKaQXMCirkrmIXOmQtOaezwsX+yKzDqfm8XH3fhhj5febqgtpHkNvKus8F5k81RHQ=="],
 
-    "@types/d3-polygon": ["@types/d3-polygon@3.0.2", "", {}, "sha512-ZuWOtMaHCkN9xoeEMr1ubW2nGWsp4nIql+OPQRstu4ypeZ+zk3YKqQT0CXVe/PYqrKpZAi+J9mTs05TKwjXSRA=="],
+    "@takumi-rs/core-darwin-x64": ["@takumi-rs/core-darwin-x64@0.62.8", "", { "os": "darwin", "cpu": "x64" }, "sha512-2a9TzXpPkpUUBc3dSU3BZAriBuLTPpVc0LzIvI72sp9qyYAVn5Itry+z1Xl+nt5As/xkFdOJccqQxe7tLLBtpQ=="],
 
-    "@types/d3-quadtree": ["@types/d3-quadtree@3.0.6", "", {}, "sha512-oUzyO1/Zm6rsxKRHA1vH0NEDG58HrT5icx/azi9MF1TWdtttWl0UIUsjEQBBh+SIkrpd21ZjEv7ptxWys1ncsg=="],
+    "@takumi-rs/core-linux-arm64-gnu": ["@takumi-rs/core-linux-arm64-gnu@0.62.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-e8Oe1aOFew+1rbu9y5JRaDvLqw4FqGJx1uPLo5mfdYQKWZ3ltdFseRUCCQI3rOXMXKz6uIWRuHd3Qw5sBp+wJg=="],
 
-    "@types/d3-random": ["@types/d3-random@3.0.3", "", {}, "sha512-Imagg1vJ3y76Y2ea0871wpabqp613+8/r0mCLEBfdtqC7xMSfj9idOnmBYyMoULfHePJyxMAw3nWhJxzc+LFwQ=="],
+    "@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=="],
 
-    "@types/d3-scale": ["@types/d3-scale@4.0.9", "", { "dependencies": { "@types/d3-time": "*" } }, "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw=="],
+    "@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=="],
 
-    "@types/d3-scale-chromatic": ["@types/d3-scale-chromatic@3.1.0", "", {}, "sha512-iWMJgwkK7yTRmWqRB5plb1kadXyQ5Sj8V/zYlFGMUBbIPKQScw+Dku9cAAMgJG+z5GYDoMjWGLVOvjghDEFnKQ=="],
+    "@takumi-rs/core-linux-x64-musl": ["@takumi-rs/core-linux-x64-musl@0.62.8", "", { "os": "linux", "cpu": "x64" }, "sha512-FIt0fpowyh9dse8F29cYBPVhrdc7Zzjz1pEyJunNzIzCIpC0yG3eUwFnK0wsoYoyzbgVZkbLRFRRAFmUORLvDg=="],
 
-    "@types/d3-selection": ["@types/d3-selection@3.0.11", "", {}, "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w=="],
+    "@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=="],
 
-    "@types/d3-shape": ["@types/d3-shape@3.1.7", "", { "dependencies": { "@types/d3-path": "*" } }, "sha512-VLvUQ33C+3J+8p+Daf+nYSOsjB4GXp19/S/aGo60m9h1v6XaxjiT82lKVWJCfzhtuZ3yD7i/TPeC/fuKLLOSmg=="],
+    "@takumi-rs/core-win32-x64-msvc": ["@takumi-rs/core-win32-x64-msvc@0.62.8", "", { "os": "win32", "cpu": "x64" }, "sha512-KxntZ5d7Cu87WQx0AUw0yzZ3AQuTjeTPZMe4MhYdQbgqw4y6hyOqUL3fz8z80/jh6XxLNHBgcBC0nn9FvJnvSw=="],
 
-    "@types/d3-time": ["@types/d3-time@3.0.4", "", {}, "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g=="],
+    "@takumi-rs/helpers": ["@takumi-rs/helpers@0.62.8", "", {}, "sha512-9qRFeuk0yTvAeVAaQoU2uW1XeigbTBta/fTReHxEsa0hYqyJe4gM4YicA0D29tfObhSRJUN/j2b2WmHuADAmcQ=="],
 
-    "@types/d3-time-format": ["@types/d3-time-format@4.0.3", "", {}, "sha512-5xg9rC+wWL8kdDj153qZcsJ0FWiFt0J5RB6LYUNZjwSnesfblqrI/bJ1wBdJ8OQfncgbJG5+2F+qfqnqyzYxyg=="],
+    "@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=="],
 
-    "@types/d3-timer": ["@types/d3-timer@3.0.2", "", {}, "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw=="],
+    "@takumi-rs/wasm": ["@takumi-rs/wasm@0.62.8", "", {}, "sha512-V3L4LMoa1hqUxYel+j2oaIYhx7TdfSI/5iStU+7sTDru3o0gwJxw923jG66/F+lLSPGeY4rmYejcJCJN5VfpBA=="],
 
-    "@types/d3-transition": ["@types/d3-transition@3.0.9", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg=="],
-
-    "@types/d3-zoom": ["@types/d3-zoom@3.0.8", "", { "dependencies": { "@types/d3-interpolate": "*", "@types/d3-selection": "*" } }, "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw=="],
+    "@tybys/wasm-util": ["@tybys/wasm-util@0.10.2", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg=="],
 
     "@types/debug": ["@types/debug@4.1.12", "", { "dependencies": { "@types/ms": "*" } }, "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ=="],
 
@@ -478,10 +394,10 @@
 
     "@types/estree-jsx": ["@types/estree-jsx@1.0.5", "", { "dependencies": { "@types/estree": "*" } }, "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg=="],
 
-    "@types/geojson": ["@types/geojson@7946.0.16", "", {}, "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg=="],
-
     "@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=="],
@@ -492,260 +408,232 @@
 
     "@types/react": ["@types/react@19.2.14", "", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w=="],
 
-    "@types/trusted-types": ["@types/trusted-types@2.0.7", "", {}, "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw=="],
-
     "@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=="],
-
-    "@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=="],
-
-    "@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-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/dynamic": ["@vanilla-extract/dynamic@2.1.5", "", { "dependencies": { "@vanilla-extract/private": "^1.0.9" } }, "sha512-QGIFGb1qyXQkbzx6X6i3+3LMc/iv/ZMBttMBL+Wm/DetQd36KsKsFg5CtH3qy+1hCA/5w93mEIIAiL4fkM8ycw=="],
+    "@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/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=="],
-
-    "@vanilla-extract/private": ["@vanilla-extract/private@1.0.9", "", {}, "sha512-gT2jbfZuaaCLrAxwXbRgIhGhcXbRZCG3v4TTUnjw0EJ7ArdBRxkq4msNJkbuRkCgfIK5ATmprB5t9ljvLeFDEA=="],
-
-    "@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=="],
-
-    "@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=="],
-
-    "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+    "@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=="],
 
-    "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="],
+    "@webassemblyjs/floating-point-hex-parser": ["@webassemblyjs/floating-point-hex-parser@1.13.2", "", {}, "sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA=="],
 
-    "ansi-regex": ["ansi-regex@6.1.0", "", {}, "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA=="],
+    "@webassemblyjs/helper-api-error": ["@webassemblyjs/helper-api-error@1.13.2", "", {}, "sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ=="],
 
-    "ansi-styles": ["ansi-styles@6.2.1", "", {}, "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug=="],
+    "@webassemblyjs/helper-buffer": ["@webassemblyjs/helper-buffer@1.14.1", "", {}, "sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA=="],
 
-    "aria-hidden": ["aria-hidden@1.2.6", "", { "dependencies": { "tslib": "^2.0.0" } }, "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA=="],
+    "@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=="],
 
-    "astring": ["astring@1.9.0", "", { "bin": { "astring": "bin/astring" } }, "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg=="],
+    "@webassemblyjs/helper-wasm-bytecode": ["@webassemblyjs/helper-wasm-bytecode@1.13.2", "", {}, "sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA=="],
 
-    "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=="],
+    "@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=="],
 
-    "bail": ["bail@2.0.2", "", {}, "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw=="],
+    "@webassemblyjs/ieee754": ["@webassemblyjs/ieee754@1.13.2", "", { "dependencies": { "@xtuc/ieee754": "^1.2.0" } }, "sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw=="],
 
-    "balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="],
+    "@webassemblyjs/leb128": ["@webassemblyjs/leb128@1.13.2", "", { "dependencies": { "@xtuc/long": "4.2.2" } }, "sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw=="],
 
-    "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="],
+    "@webassemblyjs/utf8": ["@webassemblyjs/utf8@1.13.2", "", {}, "sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ=="],
 
-    "bcp-47-match": ["bcp-47-match@2.0.3", "", {}, "sha512-JtTezzbAibu8G0R9op9zb3vcWZd9JF6M0xOYGPn0fNCd7wOpRB1mU2mH9T8gaBGbAAyIIVgB2G7xG0GP98zMAQ=="],
+    "@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=="],
 
-    "bl": ["bl@5.1.0", "", { "dependencies": { "buffer": "^6.0.3", "inherits": "^2.0.4", "readable-stream": "^3.4.0" } }, "sha512-tv1ZJHLfTDnXE6tMHv73YgSJaWR2AFuPwMntBe7XL/GBFHnT0CLnsHMogfk5+GzCDC5ZWarSCYaIGATZt9dNsQ=="],
+    "@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=="],
 
-    "boolbase": ["boolbase@1.0.0", "", {}, "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww=="],
+    "@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=="],
 
-    "brace-expansion": ["brace-expansion@5.0.5", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ=="],
+    "@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=="],
 
-    "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="],
+    "@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=="],
 
-    "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=="],
+    "@xtuc/ieee754": ["@xtuc/ieee754@1.2.0", "", {}, "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA=="],
 
-    "buffer": ["buffer@6.0.3", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.2.1" } }, "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA=="],
+    "@xtuc/long": ["@xtuc/long@4.2.2", "", {}, "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ=="],
 
-    "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],
+    "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="],
 
-    "cac": ["cac@6.7.14", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="],
-
-    "caniuse-lite": ["caniuse-lite@1.0.30001727", "", {}, "sha512-pB68nIHmbN6L/4C6MH1DokyR3bYqFwjaSs/sWDHGj4CTcFtQUQMuJftVwWkXq7mNWOybD3KhUv3oWHoGxgP14Q=="],
-
-    "ccount": ["ccount@2.0.1", "", {}, "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg=="],
-
-    "chalk": ["chalk@5.4.1", "", {}, "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w=="],
-
-    "character-entities": ["character-entities@2.0.2", "", {}, "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ=="],
-
-    "character-entities-html4": ["character-entities-html4@2.1.0", "", {}, "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA=="],
-
-    "character-entities-legacy": ["character-entities-legacy@3.0.0", "", {}, "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ=="],
-
-    "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=="],
-
-    "cli-cursor": ["cli-cursor@4.0.0", "", { "dependencies": { "restore-cursor": "^4.0.0" } }, "sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg=="],
+    "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
 
-    "cli-spinners": ["cli-spinners@2.9.2", "", {}, "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg=="],
+    "acorn-import-phases": ["acorn-import-phases@1.0.4", "", { "peerDependencies": { "acorn": "^8.14.0" } }, "sha512-wKmbr/DDiIXzEOiWrTTUcDm24kQ2vGfZQvM2fwg2vXqR5uW6aapr7ObPtj1th32b9u90/Pf4AItvdTh42fBmVQ=="],
 
-    "clsx": ["clsx@2.1.1", "", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="],
+    "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="],
 
-    "collapse-white-space": ["collapse-white-space@2.1.0", "", {}, "sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw=="],
+    "acorn-loose": ["acorn-loose@8.5.2", "", { "dependencies": { "acorn": "^8.15.0" } }, "sha512-PPvV6g8UGMGgjrMu+n/f9E/tCSkNQ2Y97eFvuVdJfG11+xdIeDcLyNdC8SHcrHbRqkfwLASdplyR6B6sKM1U4A=="],
 
-    "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
+    "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=="],
 
-    "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
+    "ajv-formats": ["ajv-formats@3.0.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ=="],
 
-    "comma-separated-tokens": ["comma-separated-tokens@2.0.3", "", {}, "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg=="],
+    "ajv-keywords": ["ajv-keywords@5.1.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3" }, "peerDependencies": { "ajv": "^8.8.2" } }, "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw=="],
 
-    "commander": ["commander@8.3.0", "", {}, "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww=="],
+    "anser": ["anser@2.3.5", "", {}, "sha512-vcZjxvvVoxTeR5XBNJB38oTu/7eDCZlwdz32N1eNgpyPF7j/Z7Idf+CUwQOkKKpJ7RJyjxgLHCM7vdIK0iCNMQ=="],
 
-    "compressible": ["compressible@2.0.18", "", { "dependencies": { "mime-db": ">= 1.43.0 < 2" } }, "sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg=="],
-
-    "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=="],
+    "ansi-regex": ["ansi-regex@6.1.0", "", {}, "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA=="],
 
-    "confbox": ["confbox@0.1.8", "", {}, "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w=="],
+    "ansi-styles": ["ansi-styles@6.2.1", "", {}, "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug=="],
 
-    "convert-source-map": ["convert-source-map@2.0.0", "", {}, "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="],
+    "any-promise": ["any-promise@1.3.0", "", {}, "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A=="],
 
-    "cookie": ["cookie@1.0.2", "", {}, "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA=="],
+    "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],
 
-    "cose-base": ["cose-base@1.0.3", "", { "dependencies": { "layout-base": "^1.0.0" } }, "sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg=="],
+    "astring": ["astring@1.9.0", "", { "bin": { "astring": "bin/astring" } }, "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg=="],
 
-    "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=="],
+    "bail": ["bail@2.0.2", "", {}, "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw=="],
 
-    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
+    "balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="],
 
-    "css-selector-parser": ["css-selector-parser@3.1.3", "", {}, "sha512-gJMigczVZqYAk0hPVzx/M4Hm1D9QOtqkdQk9005TNzDIUGzo5cnHEDiKUT7jGPximL/oYb+LIitcHFQ4aKupxg=="],
+    "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="],
 
-    "css-what": ["css-what@6.2.2", "", {}, "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA=="],
+    "baseline-browser-mapping": ["baseline-browser-mapping@2.10.33", "", { "bin": { "baseline-browser-mapping": "dist/cli.cjs" } }, "sha512-bA6+tcSLpz2tIEdDXZPpPTIuxBcC4+w6SieaYyfigIa4h8GlFxbA17v22Vx3JUtuZQj9SgOsnbK+aTBzyDyEuw=="],
 
-    "csstype": ["csstype@3.2.3", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="],
+    "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=="],
 
-    "cytoscape": ["cytoscape@3.32.1", "", {}, "sha512-dbeqFTLYEwlFg7UGtcZhCCG/2WayX72zK3Sq323CEX29CY81tYfVhw1MIdduCtpstB0cTOhJswWlM/OEB3Xp+Q=="],
+    "brace-expansion": ["brace-expansion@5.0.5", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ=="],
 
-    "cytoscape-cose-bilkent": ["cytoscape-cose-bilkent@4.1.0", "", { "dependencies": { "cose-base": "^1.0.0" }, "peerDependencies": { "cytoscape": "^3.2.0" } }, "sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ=="],
+    "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=="],
 
-    "cytoscape-fcose": ["cytoscape-fcose@2.2.0", "", { "dependencies": { "cose-base": "^2.2.0" }, "peerDependencies": { "cytoscape": "^3.2.0" } }, "sha512-ki1/VuRIHFCzxWNrsshHYPs6L7TvLu3DL+TyIGEsRcvVERmxokbf5Gdk7mFxZnTdiGtnA4cfSmjZJMviqSuZrQ=="],
+    "buffer": ["buffer@6.0.3", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.2.1" } }, "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA=="],
 
-    "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=="],
+    "buffer-from": ["buffer-from@1.1.2", "", {}, "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="],
 
-    "d3-array": ["d3-array@3.2.4", "", { "dependencies": { "internmap": "1 - 2" } }, "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg=="],
+    "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],
 
-    "d3-axis": ["d3-axis@3.0.0", "", {}, "sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw=="],
+    "cac": ["cac@6.7.14", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="],
 
-    "d3-brush": ["d3-brush@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-drag": "2 - 3", "d3-interpolate": "1 - 3", "d3-selection": "3", "d3-transition": "3" } }, "sha512-ALnjWlVYkXsVIGlOsuWH1+3udkYFI48Ljihfnh8FZPF2QS9o+PzGLBslO0PjzVoHLZ2KCVgAM8NVkXPJB2aNnQ=="],
+    "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=="],
 
-    "d3-chord": ["d3-chord@3.0.1", "", { "dependencies": { "d3-path": "1 - 3" } }, "sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g=="],
+    "call-bound": ["call-bound@1.0.4", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" } }, "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg=="],
 
-    "d3-color": ["d3-color@3.1.0", "", {}, "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA=="],
+    "callsites": ["callsites@3.1.0", "", {}, "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="],
 
-    "d3-contour": ["d3-contour@4.0.2", "", { "dependencies": { "d3-array": "^3.2.0" } }, "sha512-4EzFTRIikzs47RGmdxbeUvLWtGedDUNkTcmzoeyg4sP/dvCexO47AaQL7VKy/gul85TOxw+IBgA8US2xwbToNA=="],
+    "camelcase": ["camelcase@6.3.0", "", {}, "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA=="],
 
-    "d3-delaunay": ["d3-delaunay@6.0.4", "", { "dependencies": { "delaunator": "5" } }, "sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A=="],
+    "caniuse-lite": ["caniuse-lite@1.0.30001793", "", {}, "sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA=="],
 
-    "d3-dispatch": ["d3-dispatch@3.0.1", "", {}, "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg=="],
+    "ccount": ["ccount@2.0.1", "", {}, "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg=="],
 
-    "d3-drag": ["d3-drag@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-selection": "3" } }, "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg=="],
+    "character-entities": ["character-entities@2.0.2", "", {}, "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ=="],
 
-    "d3-dsv": ["d3-dsv@3.0.1", "", { "dependencies": { "commander": "7", "iconv-lite": "0.6", "rw": "1" }, "bin": { "csv2json": "bin/dsv2json.js", "csv2tsv": "bin/dsv2dsv.js", "dsv2dsv": "bin/dsv2dsv.js", "dsv2json": "bin/dsv2json.js", "json2csv": "bin/json2dsv.js", "json2dsv": "bin/json2dsv.js", "json2tsv": "bin/json2dsv.js", "tsv2csv": "bin/dsv2dsv.js", "tsv2json": "bin/dsv2json.js" } }, "sha512-UG6OvdI5afDIFP9w4G0mNq50dSOsXHJaRE8arAS5o9ApWnIElp8GZw1Dun8vP8OyHOZ/QJUKUJwxiiCCnUwm+Q=="],
+    "character-entities-html4": ["character-entities-html4@2.1.0", "", {}, "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA=="],
 
-    "d3-ease": ["d3-ease@3.0.1", "", {}, "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w=="],
+    "character-entities-legacy": ["character-entities-legacy@3.0.0", "", {}, "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ=="],
 
-    "d3-fetch": ["d3-fetch@3.0.1", "", { "dependencies": { "d3-dsv": "1 - 3" } }, "sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw=="],
+    "character-reference-invalid": ["character-reference-invalid@2.0.1", "", {}, "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw=="],
 
-    "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=="],
+    "chrome-trace-event": ["chrome-trace-event@1.0.4", "", {}, "sha512-rNjApaLzuwaOTjCiT8lSDdGN1APCiqkChLMJxJPWLunPAt5fy8xgU9/jNOchV84wfIxrA0lRQB7oCT8jrn/wrQ=="],
 
-    "d3-format": ["d3-format@3.1.0", "", {}, "sha512-YyUI6AEuY/Wpt8KWLgZHsIU86atmikuoOmCfommt0LYHiQSPjvX2AcFc38PX0CBpr2RCyZhjex+NS/LPOv6YqA=="],
+    "clean-set": ["clean-set@1.1.2", "", {}, "sha512-cA8uCj0qSoG9e0kevyOWXwPaELRPVg5Pxp6WskLMwerx257Zfnh8Nl0JBH59d7wQzij2CK7qEfJQK3RjuKKIug=="],
 
-    "d3-geo": ["d3-geo@3.1.1", "", { "dependencies": { "d3-array": "2.5.0 - 3" } }, "sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q=="],
+    "clsx": ["clsx@2.1.1", "", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="],
 
-    "d3-hierarchy": ["d3-hierarchy@3.1.2", "", {}, "sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA=="],
+    "collapse-white-space": ["collapse-white-space@2.1.0", "", {}, "sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw=="],
 
-    "d3-interpolate": ["d3-interpolate@3.0.1", "", { "dependencies": { "d3-color": "1 - 3" } }, "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g=="],
+    "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
 
-    "d3-path": ["d3-path@3.1.0", "", {}, "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ=="],
+    "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
 
-    "d3-polygon": ["d3-polygon@3.0.1", "", {}, "sha512-3vbA7vXYwfe1SYhED++fPUQlWSYTTGmFmQiany/gdbiWgU/iEyQzyymwL9SkJjFFuCS4902BSzewVGsHHmHtXg=="],
+    "comma-separated-tokens": ["comma-separated-tokens@2.0.3", "", {}, "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg=="],
 
-    "d3-quadtree": ["d3-quadtree@3.0.1", "", {}, "sha512-04xDrxQTDTCFwP5H6hRhsRcb9xxv2RzkcsygFzmkSIOJy3PeRJP7sNk3VRIbKXcog561P9oU0/rVH6vDROAgUw=="],
+    "commander": ["commander@4.1.1", "", {}, "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA=="],
 
-    "d3-random": ["d3-random@3.0.1", "", {}, "sha512-FXMe9GfxTxqd5D6jFsQ+DJ8BJS4E/fT5mqqdjovykEB2oFbTMDVdg1MGFxfQW+FBOGoB++k8swBrgwSHT1cUXQ=="],
+    "confbox": ["confbox@0.2.4", "", {}, "sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ=="],
 
-    "d3-sankey": ["d3-sankey@0.12.3", "", { "dependencies": { "d3-array": "1 - 2", "d3-shape": "^1.2.0" } }, "sha512-nQhsBRmM19Ax5xEIPLMY9ZmJ/cDvd1BG3UVvt5h3WRxKg5zGRbvnteTyWAbzeSvlh3tW7ZEmq4VwR5mB3tutmQ=="],
+    "content-disposition": ["content-disposition@1.1.0", "", {}, "sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g=="],
 
-    "d3-scale": ["d3-scale@4.0.2", "", { "dependencies": { "d3-array": "2.10.0 - 3", "d3-format": "1 - 3", "d3-interpolate": "1.2.0 - 3", "d3-time": "2.1.1 - 3", "d3-time-format": "2 - 4" } }, "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ=="],
+    "content-type": ["content-type@1.0.5", "", {}, "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA=="],
 
-    "d3-scale-chromatic": ["d3-scale-chromatic@3.1.0", "", { "dependencies": { "d3-color": "1 - 3", "d3-interpolate": "1 - 3" } }, "sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ=="],
+    "convert-source-map": ["convert-source-map@2.0.0", "", {}, "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="],
 
-    "d3-selection": ["d3-selection@3.0.0", "", {}, "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ=="],
+    "cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="],
 
-    "d3-shape": ["d3-shape@3.2.0", "", { "dependencies": { "d3-path": "^3.1.0" } }, "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA=="],
+    "cookie-signature": ["cookie-signature@1.2.2", "", {}, "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg=="],
 
-    "d3-time": ["d3-time@3.1.0", "", { "dependencies": { "d3-array": "2 - 3" } }, "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q=="],
+    "cors": ["cors@2.8.6", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw=="],
 
-    "d3-time-format": ["d3-time-format@4.1.0", "", { "dependencies": { "d3-time": "1 - 3" } }, "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg=="],
+    "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=="],
 
-    "d3-timer": ["d3-timer@3.0.1", "", {}, "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA=="],
+    "crelt": ["crelt@1.0.6", "", {}, "sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g=="],
 
-    "d3-transition": ["d3-transition@3.0.1", "", { "dependencies": { "d3-color": "1 - 3", "d3-dispatch": "1 - 3", "d3-ease": "1 - 3", "d3-interpolate": "1 - 3", "d3-timer": "1 - 3" }, "peerDependencies": { "d3-selection": "2 - 3" } }, "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w=="],
+    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
 
-    "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=="],
+    "csstype": ["csstype@3.2.3", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="],
 
-    "dagre-d3-es": ["dagre-d3-es@7.0.11", "", { "dependencies": { "d3": "^7.9.0", "lodash-es": "^4.17.21" } }, "sha512-tvlJLyQf834SylNKax8Wkzco/1ias1OPw8DcUMDE7oUIoSEW25riQVuiu/0OWEFqT0cxHT3Pa9/D82Jr47IONw=="],
+    "cva": ["class-variance-authority@0.7.1", "", { "dependencies": { "clsx": "^2.1.1" } }, "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg=="],
 
-    "dayjs": ["dayjs@1.11.13", "", {}, "sha512-oaMBel6gjolK862uaPQOVTA7q3TZhuSvuMQAAglQDOWYO9A91IrAOUJEyKVlqJlHE0vq5p5UXxzdPfMH/x6xNg=="],
+    "d": ["d@1.0.2", "", { "dependencies": { "es5-ext": "^0.10.64", "type": "^2.7.2" } }, "sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw=="],
 
-    "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=="],
+    "depd": ["depd@2.0.0", "", {}, "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="],
 
-    "deep-object-diff": ["deep-object-diff@1.1.9", "", {}, "sha512-Rn+RuwkmkDwCi2/oXOFS9Gsr5lJZu/yTGpK7wAaAIE75CC+LCGEZHpY6VQJa/RoJcrmaA/docWJZvYohlNkWPA=="],
+    "dequal": ["dequal@2.0.3", "", {}, "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA=="],
 
-    "deepmerge": ["deepmerge@4.3.1", "", {}, "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A=="],
+    "detect-libc": ["detect-libc@2.0.4", "", {}, "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA=="],
 
-    "delaunator": ["delaunator@5.0.1", "", { "dependencies": { "robust-predicates": "^3.0.2" } }, "sha512-8nvh+XBe96aCESrGOqMp/84b13H9cdKbG5P2ejQCh4d4sK9RL4371qou9drQjMhvnPmhWl5hnmqbEE0fXr9Xnw=="],
+    "devlop": ["devlop@1.1.0", "", { "dependencies": { "dequal": "^2.0.0" } }, "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA=="],
 
-    "depd": ["depd@2.0.0", "", {}, "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="],
+    "dot-case": ["dot-case@3.0.4", "", { "dependencies": { "no-case": "^3.0.4", "tslib": "^2.0.3" } }, "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w=="],
 
-    "dequal": ["dequal@2.0.3", "", {}, "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA=="],
+    "dotenv": ["dotenv@17.4.2", "", {}, "sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw=="],
 
-    "destroy": ["destroy@1.2.0", "", {}, "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg=="],
+    "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=="],
 
-    "detect-libc": ["detect-libc@2.0.4", "", {}, "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA=="],
+    "eastasianwidth": ["eastasianwidth@0.2.0", "", {}, "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA=="],
 
-    "detect-node-es": ["detect-node-es@1.1.0", "", {}, "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ=="],
+    "ee-first": ["ee-first@1.1.1", "", {}, "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="],
 
-    "detect-package-manager": ["detect-package-manager@3.0.2", "", { "dependencies": { "execa": "^5.1.1" } }, "sha512-8JFjJHutStYrfWwzfretQoyNGoZVW1Fsrp4JO9spa7h/fBfwgTMEIy4/LBzRDGsxwVPHU0q+T9YvwLDJoOApLQ=="],
+    "electron-to-chromium": ["electron-to-chromium@1.5.364", "", {}, "sha512-G/dYE3+AYhyHwzTwg8UbnXf7zqMERYh7l2jJ3QujhFsH8agSYwtnGAR2aZ7f0AakIKJXd5En/Hre4igIUrdlYw=="],
 
-    "devlop": ["devlop@1.1.0", "", { "dependencies": { "dequal": "^2.0.0" } }, "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA=="],
+    "emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
 
-    "direction": ["direction@2.0.1", "", { "bin": { "direction": "cli.js" } }, "sha512-9S6m9Sukh1cZNknO1CWAr2QAWsbKLafQiyM5gZ7VgXHeuaoUwffKN4q6NC4A/Mf9iiPlOXQEKW/Mv/mh9/3YFA=="],
+    "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="],
 
-    "dompurify": ["dompurify@3.2.6", "", { "optionalDependencies": { "@types/trusted-types": "^2.0.7" } }, "sha512-/2GogDQlohXPZe6D6NOgQvXLPSYBqIWMnZ8zzOhn09REE4eyAzb+Hed3jhoM9OkuaJ8P6ZGTTVWQKAi8ieIzfQ=="],
+    "enhanced-resolve": ["enhanced-resolve@5.22.1", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.3" } }, "sha512-6QEuw3zoX1SJQc7b87aBXke/no+mG2bTBgw29gWMQonLmpEkWoCAVkl+M49e48AZlWzxiDzDZzYdp6kobcyLww=="],
 
-    "eastasianwidth": ["eastasianwidth@0.2.0", "", {}, "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA=="],
+    "entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
 
-    "ee-first": ["ee-first@1.1.1", "", {}, "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="],
+    "error-ex": ["error-ex@1.3.4", "", { "dependencies": { "is-arrayish": "^0.2.1" } }, "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ=="],
 
-    "electron-to-chromium": ["electron-to-chromium@1.5.186", "", {}, "sha512-lur7L4BFklgepaJxj4DqPk7vKbTEl0pajNlg2QjE5shefmlmBLm2HvQ7PMf1R/GvlevT/581cop33/quQcfX3A=="],
+    "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="],
 
-    "emoji-regex": ["emoji-regex@10.4.0", "", {}, "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw=="],
+    "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="],
 
-    "emoji-regex-xs": ["emoji-regex-xs@1.0.0", "", {}, "sha512-LRlerrMYoIDrT6jgpeZ2YYl/L8EulRTt5hQcYjy5AInh7HWXKimpqx68aknBFpGL2+/IcogTcaydJEgaTmOpDg=="],
+    "es-module-lexer": ["es-module-lexer@2.1.0", "", {}, "sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ=="],
 
-    "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="],
+    "es-object-atoms": ["es-object-atoms@1.1.2", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw=="],
 
-    "enhanced-resolve": ["enhanced-resolve@5.20.1", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.0" } }, "sha512-Qohcme7V1inbAfvjItgw0EaxVX5q2rdVEZHRBrEQdRZTssLDGsL8Lwrznl8oQ/6kuTJONLaDcGjkNP247XEhcA=="],
+    "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=="],
 
-    "entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="],
+    "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=="],
 
-    "es-module-lexer": ["es-module-lexer@1.7.0", "", {}, "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA=="],
+    "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 +644,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 +652,72 @@
 
     "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=="],
+
+    "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=="],
 
-    "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-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.7", "", {}, "sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw=="],
+    "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=="],
-
-    "globals": ["globals@15.15.0", "", {}, "sha512-7ACyT3wmyp3I61S4fG682L0VA2RGD9otkqGJIwNUMF1SWUombIIk+af1unuDYgMm082aHYwD+mzJvv9Iu8dsgg=="],
+    "glob-to-regexp": ["glob-to-regexp@0.4.1", "", {}, "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw=="],
 
-    "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 +726,119 @@
 
     "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=="],
+    "iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
 
     "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=="],
+    "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=="],
 
-    "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=="],
+    "js-tokens": ["js-tokens@9.0.1", "", {}, "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ=="],
 
-    "jsonfile": ["jsonfile@6.1.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ=="],
+    "js-yaml": ["js-yaml@4.2.0", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw=="],
 
-    "katex": ["katex@0.16.22", "", { "dependencies": { "commander": "^8.3.0" }, "bin": { "katex": "cli.js" } }, "sha512-XCHRdUw4lf3SKBaJe4EvgqIuWwkPSo9XoeO8GjQW94Bp7TWv9hNhzZjZ+OH9yf1UmLygb7DIT5GSFQiyt16zYg=="],
-
-    "khroma": ["khroma@2.1.0", "", {}, "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw=="],
+    "jsesc": ["jsesc@3.1.0", "", { "bin": { "jsesc": "bin/jsesc" } }, "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA=="],
 
-    "kolorist": ["kolorist@1.8.0", "", {}, "sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ=="],
+    "json-parse-even-better-errors": ["json-parse-even-better-errors@2.3.1", "", {}, "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="],
 
-    "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=="],
+    "json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
 
-    "layout-base": ["layout-base@1.0.2", "", {}, "sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg=="],
+    "json-schema-typed": ["json-schema-typed@8.0.2", "", {}, "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA=="],
 
-    "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=="],
+    "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="],
 
-    "lightningcss-android-arm64": ["lightningcss-android-arm64@1.30.2", "", { "os": "android", "cpu": "arm64" }, "sha512-BH9sEdOCahSgmkVhBLeU7Hc9DWeZ1Eb6wNS6Da8igvUwAe0sqROHddIlvU06q3WyXVEOYDZ6ykBZQnjTbmo4+A=="],
+    "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-darwin-arm64": ["lightningcss-darwin-arm64@1.30.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-ylTcDJBN3Hp21TdhRT5zBOIi73P6/W0qwvlFEk22fkdXchtNTOU4Qc37SkzV+EKYxLouZ6M4LG9NfZ1qkhhBWA=="],
+    "lightningcss-android-arm64": ["lightningcss-android-arm64@1.32.0", "", { "os": "android", "cpu": "arm64" }, "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg=="],
 
-    "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.30.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-oBZgKchomuDYxr7ilwLcyms6BCyLn0z8J0+ZZmfpjwg9fRVZIR5/GMXd7r9RH94iDhld3UmSjBM6nXWM2TfZTQ=="],
+    "lightningcss-darwin-arm64": ["lightningcss-darwin-arm64@1.32.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ=="],
 
-    "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.30.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-c2bH6xTrf4BDpK8MoGG4Bd6zAMZDAXS569UxCAGcA7IKbHNMlhGQ89eRmvpIUGfKWNVdbhSbkQaWhEoMGmGslA=="],
+    "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.32.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w=="],
 
-    "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.30.2", "", { "os": "linux", "cpu": "arm" }, "sha512-eVdpxh4wYcm0PofJIZVuYuLiqBIakQ9uFZmipf6LF/HRj5Bgm0eb3qL/mr1smyXIS1twwOxNWndd8z0E374hiA=="],
+    "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.32.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig=="],
 
-    "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.30.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-UK65WJAbwIJbiBFXpxrbTNArtfuznvxAJw4Q2ZGlU8kPeDIWEX1dg3rn2veBVUylA2Ezg89ktszWbaQnxD/e3A=="],
+    "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.32.0", "", { "os": "linux", "cpu": "arm" }, "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw=="],
 
-    "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.30.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA=="],
+    "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.32.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ=="],
 
-    "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.30.2", "", { "os": "linux", "cpu": "x64" }, "sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w=="],
+    "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.32.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg=="],
 
-    "lightningcss-linux-x64-musl": ["lightningcss-linux-x64-musl@1.30.2", "", { "os": "linux", "cpu": "x64" }, "sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA=="],
+    "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.32.0", "", { "os": "linux", "cpu": "x64" }, "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA=="],
 
-    "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-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-x64-msvc": ["lightningcss-win32-x64-msvc@1.30.2", "", { "os": "win32", "cpu": "x64" }, "sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw=="],
+    "lightningcss-win32-arm64-msvc": ["lightningcss-win32-arm64-msvc@1.32.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw=="],
 
-    "local-pkg": ["local-pkg@1.1.1", "", { "dependencies": { "mlly": "^1.7.4", "pkg-types": "^2.0.1", "quansync": "^0.2.8" } }, "sha512-WunYko2W1NcdfAFpuLUoucsgULmgDBRkdxHxWQ7mK0cQqwPiy8E1enjuRBrhLtZkB5iScJ1XIPdhVEFK8aOLSg=="],
+    "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.32.0", "", { "os": "win32", "cpu": "x64" }, "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q=="],
 
-    "locate-path": ["locate-path@6.0.0", "", { "dependencies": { "p-locate": "^5.0.0" } }, "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="],
+    "lines-and-columns": ["lines-and-columns@1.2.4", "", {}, "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="],
 
-    "lodash-es": ["lodash-es@4.17.21", "", {}, "sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw=="],
+    "loader-runner": ["loader-runner@4.3.2", "", {}, "sha512-DFEqQ3ihfS9blba08cLfYf1NRAIEm+dDjic073DRDc3/JspI/8wYmtDsHwd3+4hwvdxSK7PGaElfTmm0awWJ4w=="],
 
-    "log-symbols": ["log-symbols@5.1.0", "", { "dependencies": { "chalk": "^5.0.0", "is-unicode-supported": "^1.1.0" } }, "sha512-l0x2DvrW294C9uDCoQe1VSU4gf529FkSZ6leBl4TiqZH/e+0R7hSfHQBNut2mNygDgHwvYHfFLn6Oxb3VWj2rA=="],
+    "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=="],
 
     "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=="],
+    "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 +870,23 @@
 
     "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=="],
-
-    "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="],
+    "media-typer": ["media-typer@1.1.0", "", {}, "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw=="],
 
-    "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-descriptors": ["merge-descriptors@2.0.0", "", {}, "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g=="],
 
-    "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=="],
+    "merge-stream": ["merge-stream@2.0.0", "", {}, "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w=="],
 
     "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 +956,109 @@
 
     "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.46", "", {}, "sha512-GYVXHE2KnrzAfsAjl4uP++evGFCrAU1jta4ubEjIG7YWt/64Gqv66a30yKwWczVjA6j3bM4nBwH7Pk1JmDHaxQ=="],
 
     "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=="],
-
-    "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=="],
-
-    "playwright": ["playwright@1.54.1", "", { "dependencies": { "playwright-core": "1.54.1" }, "optionalDependencies": { "fsevents": "2.3.2" }, "bin": { "playwright": "cli.js" } }, "sha512-peWpSwIBmSLi6aW2auvrUtf2DqY16YYcCMO8rTVx486jKmDTJg7UAhyrraP98GB8BoPURZP8+nxO7TSd4cPr5g=="],
+    "picomatch": ["picomatch@4.0.4", "", {}, "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A=="],
 
-    "playwright-core": ["playwright-core@1.54.1", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-Nbjs2zjj0htNhzgiy5wu+3w09YetDx5pkrpI/kZotDlDUaYk0HVA5xrBVPdow4SAUIlhgKcJeJg4GRKW6xHusA=="],
+    "pirates": ["pirates@4.0.7", "", {}, "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA=="],
 
-    "points-on-curve": ["points-on-curve@0.2.0", "", {}, "sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A=="],
+    "pkce-challenge": ["pkce-challenge@5.0.1", "", {}, "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ=="],
 
-    "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=="],
+    "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=="],
 
-    "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": ["postcss@8.5.15", "", { "dependencies": { "nanoid": "^3.3.12", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A=="],
 
-    "postcss-value-parser": ["postcss-value-parser@4.2.0", "", {}, "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ=="],
+    "property-information": ["property-information@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
 
-    "property-information": ["property-information@6.5.0", "", {}, "sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig=="],
+    "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=="],
 
-    "quansync": ["quansync@0.2.10", "", {}, "sha512-t41VRkMYbkHyCYmOvx/6URnN80H7k4X0lLdBMGsz+maAwrJQYB1djpV6vHrQIBE0WBSGqhtEHrK9U3DWWH8v7A=="],
+    "qs": ["qs@6.15.2", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw=="],
 
-    "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
-
-    "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.5", "", {}, "sha512-llUJLzz1zTUBrskt2pwZgLq59AemifIftw4aB7JxOqf1HY2FDaGDxgwpAPVzHU1kdWabH7FauP4i1oEeer2WCA=="],
 
-    "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.5", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.5" } }, "sha512-J5bAZz+DXMMwW/wV3xzKke59Af6CHY7G4uYLN1OvBcKEsWOs4pQExj86BBKamxl/Ik5bx9whOrvBlSDfWzgSag=="],
 
-    "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 +1068,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 +1098,31 @@
 
     "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=="],
 
-    "restore-cursor": ["restore-cursor@4.0.0", "", { "dependencies": { "onetime": "^5.1.0", "signal-exit": "^3.0.2" } }, "sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg=="],
+    "reselect": ["reselect@5.2.0", "", {}, "sha512-AgZ3UOZm3YndfrJ4OYjgrT7bmCm/1iqkjvEfH/oYjzh6PD2qw4QuT3jjnXIrpdt4MTpMXclMT3lXbmRY+XRakw=="],
 
-    "reusify": ["reusify@1.1.0", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="],
+    "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="],
 
-    "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=="],
-
-    "rw": ["rw@1.3.3", "", {}, "sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ=="],
+    "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=="],
 
-    "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
+    "rsc-html-stream": ["rsc-html-stream@0.0.7", "", {}, "sha512-v9+fuY7usTgvXdNl8JmfXCvSsQbq2YMd60kOeeMIqCJFZ69fViuIxztHei7v5mlMMa2h3SqS+v44Gu9i9xANZA=="],
 
     "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 +1132,77 @@
 
     "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=="],
+    "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=="],
 
-    "tabbable": ["tabbable@6.2.0", "", {}, "sha512-Cat63mxsVJlzYvN51JmVXIgNoUokrIaT2zLclCXjRd8boZ0004U4KCs/sToJ75C6sdlByWxpYnb5Boif1VSFew=="],
+    "supports-color": ["supports-color@8.1.1", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q=="],
 
-    "tailwindcss": ["tailwindcss@4.0.7", "", {}, "sha512-yH5bPPyapavo7L+547h3c4jcBXcrKwybQRjwdEIVAd9iXRvy/3T1CC6XSQEgZtRySjKfqvo3Cc0ZF1DTheuIdA=="],
+    "svg-parser": ["svg-parser@2.0.4", "", {}, "sha512-e4hG1hRwoOdRb37cIMSgzNsxyzKfayW6VOflrwvR+/bzrkyxY/31WkbgnQpgtrNp1SdpJvpUAGTa/ZoiPNDuRQ=="],
 
-    "tapable": ["tapable@2.3.2", "", {}, "sha512-1MOpMXuhGzGL5TTCZFItxCc0AARf1EZFQkGqMm7ERKj8+Hgr5oLvJOVFcC+lRmR8hCe2S3jC4T5D7Vg/d7/fhA=="],
+    "tailwindcss": ["tailwindcss@4.3.0", "", {}, "sha512-y6nxMGB1nMW9R6k96e5gdIFzcfL/gTJRNaqGes1YvkLnPVXzWgbqFF2yLC0T8G774n24cx3Pe8XrKoniCOAH+Q=="],
 
-    "tinyexec": ["tinyexec@1.0.1", "", {}, "sha512-5uC6DDlmeqiOwCPmK9jMSdOuZTh8bU39Ys6yidB+UTt5hfZUPGAypSgFRiEp+jbi9qH40BLDvy85jIU88wKSqw=="],
+    "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=="],
 
-    "tinyglobby": ["tinyglobby@0.2.14", "", { "dependencies": { "fdir": "^6.4.4", "picomatch": "^4.0.2" } }, "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ=="],
+    "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=="],
 
-    "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="],
+    "thenify": ["thenify@3.3.1", "", { "dependencies": { "any-promise": "^1.0.0" } }, "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw=="],
+
+    "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=="],
 
@@ -1336,28 +1212,30 @@
 
     "trough": ["trough@2.2.0", "", {}, "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw=="],
 
-    "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=="],
+
+    "twoslash-protocol": ["twoslash-protocol@0.3.8", "", {}, "sha512-HmvAHoiEviK8LqvAQyc9/irkdvwTUiR1fHmNwH/0gq8EHxyBt4PWVPixjEXg6wJu1u6yBrILEWXGK9Kw58/8yQ=="],
 
-    "ua-parser-js": ["ua-parser-js@1.0.40", "", { "bin": { "ua-parser-js": "script/cli.js" } }, "sha512-z6PJ8Lml+v3ichVojCiB8toQJBuwR42ySM4ezjXIqXK3M0HczmKQ3LF4rhU55PfD99KEEXQG6yb7iOMyvYuHew=="],
+    "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 +1244,51 @@
 
     "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=="],
-
-    "uuid": ["uuid@11.1.0", "", { "bin": { "uuid": "dist/esm/bin/uuid" } }, "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A=="],
+    "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=="],
 
     "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.10", "", { "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-EVJRXLBxV0/AODmRLZF+be6VTquUX5JeJXYWayer/6yS6UCrRsQSEurhRmSYMjlQhA/VyLVWdtegsZtJhimbAg=="],
 
-    "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.1", "", { "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-fsDHpz4K+h7K7Umyoweclrvxdk+jZD5lzg4dByuIh7sctiEe8YTu4DhRAxel+cRp9LvLRB8hcWgwkjCBLiqxVg=="],
 
-    "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,97 +1296,79 @@
 
     "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=="],
 
-    "zwitch": ["zwitch@2.0.4", "", {}, "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A=="],
+    "zod-to-json-schema": ["zod-to-json-schema@3.25.2", "", { "peerDependencies": { "zod": "^3.25.28 || ^4" } }, "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA=="],
 
-    "@babel/core/debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+    "zwitch": ["zwitch@2.0.4", "", {}, "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A=="],
 
-    "@babel/helper-compilation-targets/lru-cache": ["lru-cache@5.1.1", "", { "dependencies": { "yallist": "^3.0.2" } }, "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w=="],
+    "@babel/code-frame/js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="],
 
-    "@babel/traverse/debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+    "@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=="],
 
-    "@clack/prompts/is-unicode-supported": ["is-unicode-supported@1.3.0", "", { "bundled": true }, "sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ=="],
+    "@babel/helper-compilation-targets/lru-cache": ["lru-cache@5.1.1", "", { "dependencies": { "yallist": "^3.0.2" } }, "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w=="],
 
-    "@iconify/utils/debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
+    "@jridgewell/gen-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=="],
+    "@jridgewell/trace-mapping/@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.4", "", {}, "sha512-VT2+G1VQs/9oz078bLrYbecdZKs912zQlkelYpuf+SXF+QvZDYJlbx/LSx+meSAwdDFnF8FVXW92AVjjkVmgFw=="],
 
-    "@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=="],
-
-    "@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=="],
-
-    "@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=="],
-
-    "@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=="],
-
-    "@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=="],
-
-    "@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=="],
+    "@rollup/pluginutils/picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="],
 
-    "@typescript/vfs/debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
+    "@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=="],
 
-    "@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/@emnapi/core": ["@emnapi/core@1.10.0", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.1", "tslib": "^2.4.0" }, "bundled": true }, "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw=="],
 
-    "@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=="],
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/runtime": ["@emnapi/runtime@1.10.0", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA=="],
 
-    "@vanilla-extract/css/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.1", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w=="],
 
-    "@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=="],
+    "@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=="],
 
-    "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=="],
+    "@tailwindcss/oxide-wasm32-wasi/@tybys/wasm-util": ["@tybys/wasm-util@0.10.2", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg=="],
 
-    "cytoscape-fcose/cose-base": ["cose-base@2.2.0", "", { "dependencies": { "layout-base": "^2.0.0" } }, "sha512-AzlgcsCbUMymkADOJtQm3wO9S3ltPfYOFD5033keQn9NJzIbtnZj+UdBJe7DYml/8TdbtHJW3j58SOnKhWY/5g=="],
+    "@tailwindcss/oxide-wasm32-wasi/tslib": ["tslib@2.8.1", "", { "bundled": true }, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
 
-    "d3-dsv/commander": ["commander@7.2.0", "", {}, "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw=="],
+    "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=="],
 
-    "d3-sankey/d3-array": ["d3-array@2.12.1", "", { "dependencies": { "internmap": "^1.0.0" } }, "sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ=="],
+    "esrecurse/estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="],
 
-    "d3-sankey/d3-shape": ["d3-shape@1.3.7", "", { "dependencies": { "d3-path": "1" } }, "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw=="],
+    "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=="],
 
-    "eval/@types/node": ["@types/node@24.0.14", "", { "dependencies": { "undici-types": "~7.8.0" } }, "sha512-4zXMWD91vBLGRtHK3YbIoFMia+1nqEz72coM42C5ETjnNCa/heoj7NT1G67iAfOqMmcfhuCZ4uNpyz8EjlAejw=="],
-
-    "execa/signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
-
-    "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-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=="],
-
-    "hast-util-from-parse5/property-information": ["property-information@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
-
-    "hast-util-select/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-to-estree/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-html/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=="],
 
-    "hast-util-to-jsx-runtime/property-information": ["property-information@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
+    "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=="],
 
-    "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=="],
+    "react-router/cookie": ["cookie@1.0.2", "", {}, "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA=="],
 
-    "micromark/debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
+    "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=="],
 
-    "micromatch/picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="],
+    "remark-mdx-frontmatter/yaml": ["yaml@2.8.0", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-4lLa/EcQCB0cJkyts+FpIRx5G/llPxfP6VQU5KByHEhLxY3IJCH0f0Hy1MHI8sClTvsIb8qwRJ6R/ZdlDJ/leQ=="],
 
-    "p-locate/p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="],
+    "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=="],
 
-    "parse-entities/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+    "schema-utils/ajv-formats": ["ajv-formats@2.1.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA=="],
 
-    "restore-cursor/signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
+    "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=="],
 
-    "rollup/fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+    "send/statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
 
-    "send/encodeurl": ["encodeurl@1.0.2", "", {}, "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w=="],
+    "source-map-support/source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="],
 
-    "send/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+    "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 +1376,15 @@
 
     "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=="],
+    "sucrase/tinyglobby": ["tinyglobby@0.2.16", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.4" } }, "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg=="],
 
-    "vite-node/debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
+    "terser/acorn": ["acorn@8.16.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw=="],
 
-    "vocs/minimatch": ["minimatch@9.0.9", "", { "dependencies": { "brace-expansion": "^2.0.2" } }, "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg=="],
+    "terser/commander": ["commander@2.20.3", "", {}, "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="],
 
-    "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=="],
+    "type-is/content-type": ["content-type@2.0.0", "", {}, "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ=="],
+
+    "webpack/acorn": ["acorn@8.16.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw=="],
 
     "wrap-ansi-cjs/ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
 
@@ -1534,204 +1392,24 @@
 
     "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=="],
+    "@babel/helper-compilation-targets/browserslist/caniuse-lite": ["caniuse-lite@1.0.30001727", "", {}, "sha512-pB68nIHmbN6L/4C6MH1DokyR3bYqFwjaSs/sWDHGj4CTcFtQUQMuJftVwWkXq7mNWOybD3KhUv3oWHoGxgP14Q=="],
 
-    "@iconify/utils/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=="],
 
-    "@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
+    "@babel/helper-compilation-targets/browserslist/node-releases": ["node-releases@2.0.19", "", {}, "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw=="],
 
-    "@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=="],
+    "@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=="],
 
-    "@types/babel__core/@babel/types/@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.27.1", "", {}, "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="],
+    "body-parser/http-errors/statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
 
-    "@types/babel__generator/@babel/types/@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.27.1", "", {}, "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="],
+    "mlly/pkg-types/confbox": ["confbox@0.1.8", "", {}, "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w=="],
 
-    "@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=="],
-
-    "@typescript/vfs/debug/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
-
-    "@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=="],
-
-    "@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=="],
-
-    "@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=="],
-
-    "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=="],
-
-    "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=="],
-
-    "micromark/debug/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
-
-    "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/pages/index.mdx b/docs/vocs/docs/pages/index.mdx
index 8fcf352cf81..631ac7536cd 100644
--- a/docs/vocs/docs/pages/index.mdx
+++ b/docs/vocs/docs/pages/index.mdx
@@ -7,7 +7,7 @@ title: Reth
 description: Secure, performant and modular blockchain SDK and node.
 ---
 
-import { HomePage, Sponsors } from "vocs/components";
+import { HomePage } from "vocs";
 import { SdkShowcase } from "../components/SdkShowcase";
 import { TrustedBy } from "../components/TrustedBy";
 
@@ -158,5 +158,12 @@ Production chains and networks are powered by Reth's modular architecture. These
 
 ## Supporters
 
-<Sponsors />
+<div className="flex flex-wrap gap-4">
+  <a href="https://paradigm.xyz" className="flex h-[72px] w-[180px] items-center justify-center rounded-lg border border-black/10 p-4 dark:border-white/10" rel="noreferrer noopener" target="_blank">
+    <img src="https://raw.githubusercontent.com/wevm/.github/main/content/sponsors/paradigm-light.svg" alt="Paradigm" className="max-h-full max-w-full dark:invert" />
+  </a>
+  <a href="https://ithaca.xyz" className="flex h-[72px] w-[180px] items-center justify-center rounded-lg border border-black/10 p-4 dark:border-white/10" rel="noreferrer noopener" target="_blank">
+    <img src="https://raw.githubusercontent.com/wevm/.github/main/content/sponsors/ithaca-light.svg" alt="Ithaca" className="max-h-full max-w-full dark:invert" />
+  </a>
+</div>
 </article>
diff --git a/docs/vocs/package.json b/docs/vocs/package.json
index dbbc3858f4f..ed0e74a91a1 100644
--- a/docs/vocs/package.json
+++ b/docs/vocs/package.json
@@ -15,12 +15,14 @@
   "dependencies": {
     "react": "^19.2.5",
     "react-dom": "^19.2.5",
-    "vocs": "~1.0.13"
+    "vocs": "^2.0.10",
+    "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/scripts/fix-search-index.ts b/docs/vocs/scripts/fix-search-index.ts
index 99b53971f7b..6937e8043a9 100644
--- a/docs/vocs/scripts/fix-search-index.ts
+++ b/docs/vocs/scripts/fix-search-index.ts
@@ -3,12 +3,27 @@ import { readdir, copyFile, readFile, writeFile } from 'fs/promises';
 import { join } from 'path';
 
 async function fixSearchIndex() {
-  const distDir = 'docs/dist';
-  const vocsDir = join(distDir, '.vocs');
+  const distDir = 'docs/dist/public';
+  const legacyDistDir = 'docs/dist';
+  const vocsDir = join(legacyDistDir, '.vocs');
   
   try {
     // 1. Find the search index file
-    const files = await readdir(vocsDir);
+    let files: string[];
+    try {
+      files = await readdir(vocsDir);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        const assetsDir = join(distDir, 'assets');
+        const assets = await readdir(assetsDir);
+        const searchIndexFile = assets.find(f => f.startsWith('search-index-') && f.endsWith('.json'));
+        if (searchIndexFile) {
+          console.log(`✅ Vocs 2 search index found at ${join(assetsDir, searchIndexFile)}; no legacy fix needed.`);
+          return;
+        }
+      }
+      throw error;
+    }
     const searchIndexFile = files.find(f => f.startsWith('search-index-') && f.endsWith('.json'));
     
     if (!searchIndexFile) {
@@ -21,13 +36,13 @@ async function fixSearchIndex() {
     
     // 2. Copy search index to root of dist
     const sourcePath = join(vocsDir, searchIndexFile);
-    const destPath = join(distDir, searchIndexFile);
+    const destPath = join(legacyDistDir, 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');
+    const htmlFiles = await findFiles(legacyDistDir, '.html');
+    const jsFiles = await findFiles(legacyDistDir, '.js');
     console.log(`📝 Found ${htmlFiles.length} HTML files and ${jsFiles.length} JS files to update`);
     
     // 4. Replace references in all files
diff --git a/docs/vocs/scripts/generate-redirects.ts b/docs/vocs/scripts/generate-redirects.ts
index c56861a5a90..9040ca07add 100644
--- a/docs/vocs/scripts/generate-redirects.ts
+++ b/docs/vocs/scripts/generate-redirects.ts
@@ -3,6 +3,7 @@ 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..e767b1ee893 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_PUBLIC_PATH = './docs/dist/public';
+const VOCS_DIST_PATH = `${VOCS_PUBLIC_PATH}/docs`;
 const BASE_PATH = '/docs';
 
 async function injectCargoDocs() {
@@ -19,9 +20,9 @@ async function injectCargoDocs() {
 
   // Check if Vocs dist exists
   try {
-    await fs.access('./docs/dist');
+    await fs.access(VOCS_PUBLIC_PATH);
   } catch {
-    console.error('Error: Vocs dist not found. Please run: bun run build');
+    console.error('Error: Vocs public dist not found. Please run: bun run build');
     process.exit(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 957582dabf5..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",
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 e8ffec2b2a7..41f280a5944 100644
--- a/docs/vocs/vocs.config.ts
+++ b/docs/vocs/vocs.config.ts
@@ -1,14 +1,16 @@
-import React from 'react'
-import { defineConfig } from 'vocs'
+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.',
+  accentColor: 'light-dark(#1f1f1f, #ffffff)',
+  srcDir: 'docs',
   logoUrl: '/logo.png',
   iconUrl: '/logo.png',
   ogImageUrl: '/reth-prod.png',
+  outDir: 'docs/dist',
   sidebar,
   basePath,
   search: {
@@ -17,9 +19,7 @@ export default defineConfig({
   topNav: [
     { text: 'Run', link: '/run/ethereum' },
     { text: 'SDK', link: '/sdk' },
-    {
-      element: React.createElement('a', { href: '/docs', target: '_self' }, 'Rustdocs')
-    },
+    { text: 'Rustdocs', link: '/docs' },
     { text: 'GitHub', link: 'https://github.com/paradigmxyz/reth' },
     {
       text: 'v2.2.0',
@@ -45,63 +45,7 @@ export default defineConfig({
       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",
-  },
-  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
-          }
-        }
-      }
-    ]
+    link: "https://github.com/paradigmxyz/reth/edit/main/docs/vocs/docs/pages/:path",
   }
 })

From d80418f84e43ea46627d89a2c159fbd0dca49866 Mon Sep 17 00:00:00 2001
From: Emma Jamieson-Hoare <emmajam@users.noreply.github.com>
Date: Tue, 2 Jun 2026 12:52:43 +0200
Subject: [PATCH 277/335] fix(docs): deploy Vocs v2 output root (#24765)

---
 .github/workflows/book.yml              |  2 +-
 docs/vocs/scripts/build-cargo-docs.sh   |  5 +++--
 docs/vocs/scripts/fix-search-index.ts   | 11 +++++------
 docs/vocs/scripts/generate-redirects.ts |  2 +-
 docs/vocs/scripts/inject-cargo-docs.ts  |  8 ++++----
 5 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/book.yml b/.github/workflows/book.yml
index 24a0a1270fb..142e5111482 100644
--- a/.github/workflows/book.yml
+++ b/.github/workflows/book.yml
@@ -53,7 +53,7 @@ jobs:
       - name: Upload artifact
         uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0
         with:
-          path: "./docs/vocs/docs/dist/public"
+          path: "./docs/vocs/docs/dist"
 
   deploy:
     # Only deploy if a push to main
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 6937e8043a9..265440f2889 100644
--- a/docs/vocs/scripts/fix-search-index.ts
+++ b/docs/vocs/scripts/fix-search-index.ts
@@ -3,9 +3,8 @@ import { readdir, copyFile, readFile, writeFile } from 'fs/promises';
 import { join } from 'path';
 
 async function fixSearchIndex() {
-  const distDir = 'docs/dist/public';
-  const legacyDistDir = 'docs/dist';
-  const vocsDir = join(legacyDistDir, '.vocs');
+  const distDir = 'docs/dist';
+  const vocsDir = join(distDir, '.vocs');
   
   try {
     // 1. Find the search index file
@@ -36,13 +35,13 @@ async function fixSearchIndex() {
     
     // 2. Copy search index to root of dist
     const sourcePath = join(vocsDir, searchIndexFile);
-    const destPath = join(legacyDistDir, 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(legacyDistDir, '.html');
-    const jsFiles = await findFiles(legacyDistDir, '.js');
+    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
diff --git a/docs/vocs/scripts/generate-redirects.ts b/docs/vocs/scripts/generate-redirects.ts
index 9040ca07add..57188631f5c 100644
--- a/docs/vocs/scripts/generate-redirects.ts
+++ b/docs/vocs/scripts/generate-redirects.ts
@@ -3,7 +3,7 @@ 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'
+const DIST_DIR = './docs/dist'
 
 function generateRedirectHtml(targetPath: string): string {
   return `<!DOCTYPE html>
diff --git a/docs/vocs/scripts/inject-cargo-docs.ts b/docs/vocs/scripts/inject-cargo-docs.ts
index e767b1ee893..8ba1185880b 100644
--- a/docs/vocs/scripts/inject-cargo-docs.ts
+++ b/docs/vocs/scripts/inject-cargo-docs.ts
@@ -2,8 +2,8 @@ import { promises as fs } from 'fs';
 import { glob } from 'glob';
 
 const CARGO_DOCS_PATH = '../../target/doc';
-const VOCS_PUBLIC_PATH = './docs/dist/public';
-const VOCS_DIST_PATH = `${VOCS_PUBLIC_PATH}/docs`;
+const VOCS_DIST_ROOT = './docs/dist';
+const VOCS_DIST_PATH = `${VOCS_DIST_ROOT}/docs`;
 const BASE_PATH = '/docs';
 
 async function injectCargoDocs() {
@@ -20,9 +20,9 @@ async function injectCargoDocs() {
 
   // Check if Vocs dist exists
   try {
-    await fs.access(VOCS_PUBLIC_PATH);
+    await fs.access(VOCS_DIST_ROOT);
   } catch {
-    console.error('Error: Vocs public dist not found. Please run: bun run build');
+    console.error('Error: Vocs dist not found. Please run: bun run build');
     process.exit(1);
   }
 

From 95f584e0a4d89802ae2ab8717cb56fec5b35944d Mon Sep 17 00:00:00 2001
From: Emma Jamieson-Hoare <emmajam@users.noreply.github.com>
Date: Tue, 2 Jun 2026 14:00:51 +0200
Subject: [PATCH 278/335] fix(docs): handle Vocs search index fallback path
 (#24766)

---
 docs/vocs/scripts/fix-search-index.ts | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/docs/vocs/scripts/fix-search-index.ts b/docs/vocs/scripts/fix-search-index.ts
index 265440f2889..d8ded170e76 100644
--- a/docs/vocs/scripts/fix-search-index.ts
+++ b/docs/vocs/scripts/fix-search-index.ts
@@ -13,12 +13,19 @@ async function fixSearchIndex() {
       files = await readdir(vocsDir);
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        const assetsDir = join(distDir, 'assets');
-        const assets = await readdir(assetsDir);
-        const searchIndexFile = assets.find(f => f.startsWith('search-index-') && f.endsWith('.json'));
-        if (searchIndexFile) {
-          console.log(`✅ Vocs 2 search index found at ${join(assetsDir, searchIndexFile)}; no legacy fix needed.`);
-          return;
+        for (const assetsDir of [join(distDir, 'assets'), join(distDir, 'public', 'assets')]) {
+          try {
+            const assets = await readdir(assetsDir);
+            const searchIndexFile = assets.find(f => f.startsWith('search-index-') && f.endsWith('.json'));
+            if (searchIndexFile) {
+              console.log(`✅ Vocs 2 search index found at ${join(assetsDir, searchIndexFile)}; no legacy fix needed.`);
+              return;
+            }
+          } catch (assetsError) {
+            if ((assetsError as NodeJS.ErrnoException).code !== 'ENOENT') {
+              throw assetsError;
+            }
+          }
         }
       }
       throw error;

From 3392ec1a6437d8ce58aae1adb5f413bd8ce9bc42 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?L=C3=A9a=20Narzis?=
 <78718413+lean-apple@users.noreply.github.com>
Date: Tue, 2 Jun 2026 15:28:32 +0200
Subject: [PATCH 279/335] feat(era): add ere types (#24718)

---
 crates/era/Cargo.toml                 |   2 +-
 crates/era/src/common/compression.rs  |  76 +++
 crates/era/src/common/mod.rs          |   9 +
 crates/era/src/e2s/types.rs           |  22 +-
 crates/era/src/era/types/group.rs     |   6 +-
 crates/era/src/ere/mod.rs             |   5 +
 crates/era/src/ere/types/execution.rs | 908 ++++++++++++++++++++++++++
 crates/era/src/ere/types/mod.rs       |   5 +
 crates/era/src/lib.rs                 |   1 +
 9 files changed, 1023 insertions(+), 11 deletions(-)
 create mode 100644 crates/era/src/common/compression.rs
 create mode 100644 crates/era/src/ere/mod.rs
 create mode 100644 crates/era/src/ere/types/execution.rs
 create mode 100644 crates/era/src/ere/types/mod.rs

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/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/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/ere/mod.rs b/crates/era/src/ere/mod.rs
new file mode 100644
index 00000000000..f488d7e09aa
--- /dev/null
+++ b/crates/era/src/ere/mod.rs
@@ -0,0 +1,5 @@
+//! Core `ere` (era execution) primitives.
+//!
+//! See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md>
+
+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..c0f5a695cba
--- /dev/null
+++ b/crates/era/src/ere/types/execution.rs
@@ -0,0 +1,908 @@
+//! 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 block tuple in an `ERE` file, containing all components for a single block
+#[derive(Debug, Clone)]
+pub struct BlockTuple {
+    /// Compressed block header
+    pub header: CompressedHeader,
+
+    /// Compressed block body
+    pub body: CompressedBody,
+
+    /// Compressed receipts
+    pub receipts: CompressedSlimReceipts,
+
+    /// Total difficulty
+    pub total_difficulty: TotalDifficulty,
+}
+
+impl BlockTuple {
+    /// Create a new [`BlockTuple`]
+    pub const fn new(
+        header: CompressedHeader,
+        body: CompressedBody,
+        receipts: CompressedSlimReceipts,
+        total_difficulty: TotalDifficulty,
+    ) -> Self {
+        Self { header, body, receipts, total_difficulty }
+    }
+
+    /// 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`
+    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, compressed_receipts, 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_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/mod.rs b/crates/era/src/ere/types/mod.rs
new file mode 100644
index 00000000000..c16f0cfaa74
--- /dev/null
+++ b/crates/era/src/ere/types/mod.rs
@@ -0,0 +1,5 @@
+//! `ere` (era execution) types
+//!
+//! See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md>
+
+pub mod execution;
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;

From 4132f14817676990e3acc05c4aec89b428ca4e08 Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Tue, 2 Jun 2026 20:30:19 +0530
Subject: [PATCH 280/335] fix(rpc): expose simulated block hashes (#24705)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/ethereum/node/tests/e2e/simulate.rs | 59 +++++++++++++++++++++-
 crates/rpc/rpc-eth-api/src/helpers/call.rs |  8 ++-
 2 files changed, 64 insertions(+), 3 deletions(-)

diff --git a/crates/ethereum/node/tests/e2e/simulate.rs b/crates/ethereum/node/tests/e2e/simulate.rs
index 2130769648d..cd9d2b1de23 100644
--- a/crates/ethereum/node/tests/e2e/simulate.rs
+++ b/crates/ethereum/node/tests/e2e/simulate.rs
@@ -1,9 +1,9 @@
 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,
+    state::{AccountOverride, StateOverride, StateOverridesBuilder},
     BlockOverrides, TransactionRequest, TransactionTrait as _,
 };
 use reth_chainspec::{ChainSpecBuilder, MAINNET};
@@ -99,6 +99,61 @@ async fn test_simulate_v1_no_fields_call_defaults_to_remaining_block_gas() -> ey
     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();
diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs
index c0b47b7aa77..f10a158c62a 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/call.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/call.rs
@@ -45,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.
@@ -229,7 +230,12 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                         .map_err(map_err)?
                     };
 
-                    parent = result.block.clone_sealed_header();
+                    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,

From 4b9eb71c7470f00ef9a6a28e5b807497d4d4611c Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 2 Jun 2026 10:18:13 -0700
Subject: [PATCH 281/335] chore: bump fixed-cache to 0.1.10 (#24775)

---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index db0212549d0..7523c0a1ed5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3944,9 +3944,9 @@ checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
 [[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",
diff --git a/Cargo.toml b/Cargo.toml
index f94a5f039a1..d511c8c4f82 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -541,7 +541,7 @@ 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 }

From 955847f195cea63c2d141a192c9b7b97e7f84e92 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Tue, 2 Jun 2026 23:00:22 +0200
Subject: [PATCH 282/335] perf: remove updates count cap (#24777)

Co-authored-by: Derek <256792747+decofe@users.noreply.github.com>
---
 .../engine/tree/src/tree/payload_processor/sparse_trie.rs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

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 73e3fcd81f3..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.
@@ -356,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());

From 2e80931e22bee51c6d6fbc2df95386df2c046641 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 2 Jun 2026 15:27:44 -0700
Subject: [PATCH 283/335] chore(cli): log latest re-executed block (#24785)

---
 crates/cli/commands/src/re_execute.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/crates/cli/commands/src/re_execute.rs b/crates/cli/commands/src/re_execute.rs
index 04e2f6dfc25..6512ee02763 100644
--- a/crates/cli/commands/src/re_execute.rs
+++ b/crates/cli/commands/src/re_execute.rs
@@ -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()),

From ecd117e7918debd2ad431b7a8b2370bd31aec116 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Tue, 2 Jun 2026 21:49:46 -0700
Subject: [PATCH 284/335] fix(docs): publish Vocs v2 static output (#24789)

---
 .github/workflows/book.yml                  |   7 ++++++-
 docs/vocs/{docs => }/public/alchemy.png     | Bin
 docs/vocs/{docs => }/public/coinbase.png    | Bin
 docs/vocs/{docs => }/public/flashbots.png   | Bin
 docs/vocs/{docs => }/public/logo.png        | Bin
 docs/vocs/{docs => }/public/remote_exex.png | Bin
 docs/vocs/{docs => }/public/reth-prod.png   | Bin
 docs/vocs/{docs => }/public/succinct.png    | Bin
 docs/vocs/vocs.config.ts                    |   1 +
 9 files changed, 7 insertions(+), 1 deletion(-)
 rename docs/vocs/{docs => }/public/alchemy.png (100%)
 rename docs/vocs/{docs => }/public/coinbase.png (100%)
 rename docs/vocs/{docs => }/public/flashbots.png (100%)
 rename docs/vocs/{docs => }/public/logo.png (100%)
 rename docs/vocs/{docs => }/public/remote_exex.png (100%)
 rename docs/vocs/{docs => }/public/reth-prod.png (100%)
 rename docs/vocs/{docs => }/public/succinct.png (100%)

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/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/vocs.config.ts b/docs/vocs/vocs.config.ts
index 41f280a5944..712e91e03bb 100644
--- a/docs/vocs/vocs.config.ts
+++ b/docs/vocs/vocs.config.ts
@@ -11,6 +11,7 @@ export default defineConfig({
   iconUrl: '/logo.png',
   ogImageUrl: '/reth-prod.png',
   outDir: 'docs/dist',
+  renderStrategy: 'full-static',
   sidebar,
   basePath,
   search: {

From 3be7f289c2fbbaf9eb3c9f0dd2ad20e84f194a44 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Wed, 3 Jun 2026 01:19:16 -0700
Subject: [PATCH 285/335] fix(docs): improve reth vocs homepage buttons
 (#24800)

---
 docs/vocs/docs/pages/index.mdx | 59 ++++++++++------------------------
 1 file changed, 17 insertions(+), 42 deletions(-)

diff --git a/docs/vocs/docs/pages/index.mdx b/docs/vocs/docs/pages/index.mdx
index 631ac7536cd..24ebbd720a5 100644
--- a/docs/vocs/docs/pages/index.mdx
+++ b/docs/vocs/docs/pages/index.mdx
@@ -7,7 +7,6 @@ title: Reth
 description: Secure, performant and modular blockchain SDK and node.
 ---
 
-import { HomePage } from "vocs";
 import { SdkShowcase } from "../components/SdkShowcase";
 import { TrustedBy } from "../components/TrustedBy";
 
@@ -23,10 +22,10 @@ import { TrustedBy } from "../components/TrustedBy";
           />
           <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 className="flex justify-center gap-2 flex-wrap w-full max-md:justify-start" style={{ marginTop: 28, marginBottom: 16 }}>
+          <a href="/run/ethereum" className="vocs_Link vocs_Link_styleless" style={{ background: "light-dark(#1f1f1f, #ffffff)", borderRadius: 8, color: "light-dark(#ffffff, #000000)", fontSize: 16, fontWeight: 600, lineHeight: 1.2, minHeight: 44, padding: "13px 16px", textAlign: "center", whiteSpace: "nowrap" }}>Run a Node</a>
+          <a href="/sdk" className="vocs_Link vocs_Link_styleless" style={{ background: "light-dark(#1f1f1f, #ffffff)", borderRadius: 8, color: "light-dark(#ffffff, #000000)", fontSize: 16, fontWeight: 600, lineHeight: 1.2, minHeight: 44, padding: "13px 16px", textAlign: "center", whiteSpace: "nowrap" }}>Build a Node</a>
+          <a href="/introduction/why-reth" className="vocs_Link vocs_Link_styleless" style={{ border: "1px solid light-dark(rgb(0 0 0 / 0.12), rgb(255 255 255 / 0.16))", borderRadius: 8, color: "inherit", fontSize: 16, fontWeight: 600, lineHeight: 1.2, minHeight: 44, padding: "13px 16px", textAlign: "center", whiteSpace: "nowrap" }}>Why Reth?</a>
         </div>
       </div>
         <div className="flex flex-col justify-between space-y-4 w-full max-w-[500px]">
@@ -53,43 +52,19 @@ import { TrustedBy } from "../components/TrustedBy";
 
             :::
           </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>
-      </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>
-      <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 className="grid grid-cols-2 lg:grid-cols-3 gap-2">
+            <a href="https://github.com/paradigmxyz/reth/stargazers" className="vocs_Link vocs_Link_styleless" style={{ alignItems: "center", background: "light-dark(rgb(0 0 0 / 0.04), rgb(255 255 255 / 0.05))", border: "1px solid light-dark(rgb(0 0 0 / 0.1), rgb(255 255 255 / 0.16))", borderRadius: 8, color: "inherit", display: "flex", gap: 8, height: 36, justifyContent: "center", minWidth: 0, padding: "0 10px" }} rel="noreferrer noopener" target="_blank">
+              <span style={{ background: "light-dark(rgb(255 255 255 / 0.64), rgb(0 0 0 / 0.32))", borderRadius: 6, color: "light-dark(rgb(0 0 0 / 0.76), rgb(255 255 255 / 0.76))", fontSize: 14, fontWeight: 500, lineHeight: 1, overflow: "hidden", padding: "5px 8px", textOverflow: "ellipsis", whiteSpace: "nowrap" }}>stars</span>
+              <span style={{ color: "light-dark(#000, #fff)", fontSize: 14, fontWeight: 600, lineHeight: 1, whiteSpace: "nowrap" }}>4.7K</span>
+            </a>
+            <a href="https://github.com/paradigmxyz/reth/graphs/contributors" className="vocs_Link vocs_Link_styleless" style={{ alignItems: "center", background: "light-dark(rgb(0 0 0 / 0.04), rgb(255 255 255 / 0.05))", border: "1px solid rgb(74 222 128 / 0.5)", borderRadius: 8, color: "inherit", display: "flex", gap: 8, height: 36, justifyContent: "center", minWidth: 0, padding: "0 10px" }} rel="noreferrer noopener" target="_blank">
+              <span style={{ background: "light-dark(rgb(255 255 255 / 0.64), rgb(0 0 0 / 0.32))", borderRadius: 6, color: "light-dark(rgb(0 0 0 / 0.76), rgb(255 255 255 / 0.76))", fontSize: 14, fontWeight: 500, lineHeight: 1, overflow: "hidden", padding: "5px 8px", textOverflow: "ellipsis", whiteSpace: "nowrap" }}>contributors</span>
+              <span style={{ color: "#4ade80", fontSize: 14, fontWeight: 600, lineHeight: 1, whiteSpace: "nowrap" }}>580+</span>
+            </a>
+            <a href="https://github.com/paradigmxyz/reth/blob/main/LICENSE-MIT" className="vocs_Link vocs_Link_styleless" style={{ alignItems: "center", background: "light-dark(rgb(0 0 0 / 0.04), rgb(255 255 255 / 0.05))", border: "1px solid light-dark(rgb(0 0 0 / 0.1), rgb(255 255 255 / 0.16))", borderRadius: 8, color: "inherit", display: "flex", gap: 8, height: 36, justifyContent: "center", minWidth: 0, padding: "0 10px" }} rel="noreferrer noopener" target="_blank">
+              <span style={{ background: "light-dark(rgb(255 255 255 / 0.64), rgb(0 0 0 / 0.32))", borderRadius: 6, color: "light-dark(rgb(0 0 0 / 0.76), rgb(255 255 255 / 0.76))", fontSize: 14, fontWeight: 500, lineHeight: 1, overflow: "hidden", padding: "5px 8px", textOverflow: "ellipsis", whiteSpace: "nowrap" }}>license</span>
+              <span style={{ color: "light-dark(#000, #fff)", fontSize: 14, fontWeight: 600, lineHeight: 1, whiteSpace: "nowrap" }}>MIT</span>
+            </a>
           </div>
         </div>
 

From 0f12b16f4098ecfc472e51b40ab5b8dc31c25e61 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Wed, 3 Jun 2026 01:58:33 -0700
Subject: [PATCH 286/335] chore: downgrade tx execution span to trace (#24781)

---
 crates/engine/tree/src/tree/payload_validator.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 90200030a3d..30240b00d19 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -1281,8 +1281,8 @@ where
 
             senders.push(tx_signer);
 
-            let _enter = tracing::enabled!(target: "engine::tree", Level::DEBUG).then(|| {
-                debug_span!(
+            let _enter = tracing::enabled!(target: "engine::tree", Level::TRACE).then(|| {
+                tracing::trace_span!(
                     target: "engine::tree",
                     "execute tx",
                     tx_index = senders.len() - 1,

From d34892e35ea5c009389fad642537d7f1146ca7ce Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 3 Jun 2026 11:33:17 +0200
Subject: [PATCH 287/335] feat(payload): make state pre-cache optional (#24670)

---
 crates/node/builder/src/components/payload.rs | 33 ++++++++++++++++---
 crates/payload/basic/src/lib.rs               | 21 ++++++++++++
 2 files changed, 49 insertions(+), 5 deletions(-)

diff --git a/crates/node/builder/src/components/payload.rs b/crates/node/builder/src/components/payload.rs
index d7b76b45230..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(),
diff --git a/crates/payload/basic/src/lib.rs b/crates/payload/basic/src/lib.rs
index 197f2a56bc5..f99bbc0823a 100644
--- a/crates/payload/basic/src/lib.rs
+++ b/crates/payload/basic/src/lib.rs
@@ -125,6 +125,10 @@ 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())
     }
 }
@@ -193,6 +197,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
@@ -260,6 +269,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 ===
@@ -287,6 +298,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 {
@@ -296,6 +316,7 @@ impl Default for BasicPayloadJobGeneratorConfig {
             // 12s slot time
             deadline: SLOT_DURATION,
             max_payload_tasks: 3,
+            pre_cache_state: true,
         }
     }
 }

From f82fe9f22960ef51831c2ff3f865e06afd6cfbb0 Mon Sep 17 00:00:00 2001
From: Emma Jamieson-Hoare <emmajam@users.noreply.github.com>
Date: Wed, 3 Jun 2026 11:52:52 +0200
Subject: [PATCH 288/335] fix(docs): load homepage styles in Vocs v2 (#24804)

---
 docs/vocs/docs/pages/_root.css | 1 +
 docs/vocs/docs/styles.css      | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)
 create mode 100644 docs/vocs/docs/pages/_root.css

diff --git a/docs/vocs/docs/pages/_root.css b/docs/vocs/docs/pages/_root.css
new file mode 100644
index 00000000000..b27cc89c989
--- /dev/null
+++ b/docs/vocs/docs/pages/_root.css
@@ -0,0 +1 @@
+@import "../styles.css";
diff --git a/docs/vocs/docs/styles.css b/docs/vocs/docs/styles.css
index fcfc8cf2cd6..28af0cd0cd4 100644
--- a/docs/vocs/docs/styles.css
+++ b/docs/vocs/docs/styles.css
@@ -1,6 +1,6 @@
 @import "tailwindcss" important;
 
-@custom-variant dark (&:where(.dark, .dark *));
+@custom-variant dark (&:where(.dark, .dark *, [data-vocs-theme="dark"], [data-vocs-theme="dark"] *));
 
 [data-layout="landing"] .vocs_Button_button {
   border-radius: 4px !important;

From 80fcff9808a32162a006fce6e2c65a965cf26538 Mon Sep 17 00:00:00 2001
From: Emma Jamieson-Hoare <emmajam@users.noreply.github.com>
Date: Wed, 3 Jun 2026 12:34:54 +0200
Subject: [PATCH 289/335] fix(docs): simplify homepage hero layout (#24805)

---
 docs/vocs/docs/pages/index.mdx | 99 ++++++++++++++++------------------
 1 file changed, 46 insertions(+), 53 deletions(-)

diff --git a/docs/vocs/docs/pages/index.mdx b/docs/vocs/docs/pages/index.mdx
index 24ebbd720a5..6d20c183f42 100644
--- a/docs/vocs/docs/pages/index.mdx
+++ b/docs/vocs/docs/pages/index.mdx
@@ -12,64 +12,58 @@ 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 gap-2 flex-wrap w-full max-md:justify-start" style={{ marginTop: 28, marginBottom: 16 }}>
-          <a href="/run/ethereum" className="vocs_Link vocs_Link_styleless" style={{ background: "light-dark(#1f1f1f, #ffffff)", borderRadius: 8, color: "light-dark(#ffffff, #000000)", fontSize: 16, fontWeight: 600, lineHeight: 1.2, minHeight: 44, padding: "13px 16px", textAlign: "center", whiteSpace: "nowrap" }}>Run a Node</a>
-          <a href="/sdk" className="vocs_Link vocs_Link_styleless" style={{ background: "light-dark(#1f1f1f, #ffffff)", borderRadius: 8, color: "light-dark(#ffffff, #000000)", fontSize: 16, fontWeight: 600, lineHeight: 1.2, minHeight: 44, padding: "13px 16px", textAlign: "center", whiteSpace: "nowrap" }}>Build a Node</a>
-          <a href="/introduction/why-reth" className="vocs_Link vocs_Link_styleless" style={{ border: "1px solid light-dark(rgb(0 0 0 / 0.12), rgb(255 255 255 / 0.16))", borderRadius: 8, color: "inherit", fontSize: 16, fontWeight: 600, lineHeight: 1.2, minHeight: 44, padding: "13px 16px", textAlign: "center", whiteSpace: "nowrap" }}>Why Reth?</a>
-        </div>
+    <div className="max-sm:px-0 space-y-6">
+      <img
+        src="/reth-prod.png"
+        alt="Reth"
+        className="w-full h-auto rounded-xl"
+      />
+      <div className="font-regular max-w-[760px] 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 className="flex gap-2 flex-wrap max-md:justify-center">
+          <a href="https://github.com/paradigmxyz/reth/stargazers" aria-label="4.7K GitHub stars" title="4.7K stars" className="vocs_Link vocs_Link_styleless" style={{ alignItems: "center", background: "light-dark(rgb(0 0 0 / 0.04), rgb(255 255 255 / 0.05))", border: "1px solid light-dark(rgb(0 0 0 / 0.1), rgb(255 255 255 / 0.16))", borderRadius: 8, color: "inherit", display: "inline-flex", gap: 6, height: 36, justifyContent: "center", minWidth: 0, padding: "0 12px", whiteSpace: "nowrap" }} rel="noreferrer noopener" target="_blank">
+            <span style={{ color: "light-dark(#000, #fff)", fontSize: 14, fontWeight: 700, lineHeight: 1 }}>4.7K</span>
+            <span style={{ color: "light-dark(rgb(0 0 0 / 0.62), rgb(255 255 255 / 0.62))", fontSize: 13, fontWeight: 500, lineHeight: 1 }}>stars</span>
+          </a>
+          <a href="https://github.com/paradigmxyz/reth/graphs/contributors" aria-label="580+ GitHub contributors" title="580+ contributors" className="vocs_Link vocs_Link_styleless" style={{ alignItems: "center", background: "light-dark(rgb(0 0 0 / 0.04), rgb(255 255 255 / 0.05))", border: "1px solid rgb(74 222 128 / 0.5)", borderRadius: 8, color: "inherit", display: "inline-flex", gap: 6, height: 36, justifyContent: "center", minWidth: 0, padding: "0 12px", whiteSpace: "nowrap" }} rel="noreferrer noopener" target="_blank">
+            <span style={{ color: "#4ade80", fontSize: 14, fontWeight: 700, lineHeight: 1 }}>580+</span>
+            <span style={{ color: "light-dark(rgb(0 0 0 / 0.62), rgb(255 255 255 / 0.62))", fontSize: 13, fontWeight: 500, lineHeight: 1 }}>contributors</span>
+          </a>
+          <a href="https://github.com/paradigmxyz/reth/blob/main/LICENSE-MIT" aria-label="MIT license" title="MIT license" className="vocs_Link vocs_Link_styleless" style={{ alignItems: "center", background: "light-dark(rgb(0 0 0 / 0.04), rgb(255 255 255 / 0.05))", border: "1px solid light-dark(rgb(0 0 0 / 0.1), rgb(255 255 255 / 0.16))", borderRadius: 8, color: "inherit", display: "inline-flex", gap: 6, height: 36, justifyContent: "center", minWidth: 0, padding: "0 12px", whiteSpace: "nowrap" }} rel="noreferrer noopener" target="_blank">
+            <span style={{ color: "light-dark(#000, #fff)", fontSize: 14, fontWeight: 700, lineHeight: 1 }}>MIT</span>
+            <span style={{ color: "light-dark(rgb(0 0 0 / 0.62), rgb(255 255 255 / 0.62))", fontSize: 13, fontWeight: 500, lineHeight: 1 }}>license</span>
+          </a>
       </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
+      <div className="flex gap-x-5 gap-y-2 flex-wrap text-[15px] font-medium max-md:justify-center">
+        <a href="/run/ethereum" className="vocs_Link vocs_Link_styleless text-black dark:text-white hover:opacity-70">Run a Node</a>
+        <a href="/sdk" className="vocs_Link vocs_Link_styleless text-black dark:text-white hover:opacity-70">Build a Node</a>
+        <a href="/introduction/why-reth" className="vocs_Link vocs_Link_styleless text-black dark:text-white hover:opacity-70">Why Reth?</a>
+      </div>
+      <div id="home-install">
+        :::code-group
 
-            # Run the node with JSON-RPC enabled
-            reth node --http --http.api eth,trace
-            ```
+        ```bash [Run a Node]
+        # Install the binary
+        brew install paradigmxyz/brew/reth
 
-            ```rust [Build a Node]
-            // .. snip ..
-            let handle = node_builder
-              .with_types::<EthereumNode>()
-              .with_components(EthereumNode::components())
-              .with_add_ons(EthereumAddOns::default())
-              .launch()
-              .await?;
-            ```
+        # Run the node with JSON-RPC enabled
+        reth node --http --http.api eth,trace
+        ```
 
-            :::
-          </div>
-          <div className="grid grid-cols-2 lg:grid-cols-3 gap-2">
-            <a href="https://github.com/paradigmxyz/reth/stargazers" className="vocs_Link vocs_Link_styleless" style={{ alignItems: "center", background: "light-dark(rgb(0 0 0 / 0.04), rgb(255 255 255 / 0.05))", border: "1px solid light-dark(rgb(0 0 0 / 0.1), rgb(255 255 255 / 0.16))", borderRadius: 8, color: "inherit", display: "flex", gap: 8, height: 36, justifyContent: "center", minWidth: 0, padding: "0 10px" }} rel="noreferrer noopener" target="_blank">
-              <span style={{ background: "light-dark(rgb(255 255 255 / 0.64), rgb(0 0 0 / 0.32))", borderRadius: 6, color: "light-dark(rgb(0 0 0 / 0.76), rgb(255 255 255 / 0.76))", fontSize: 14, fontWeight: 500, lineHeight: 1, overflow: "hidden", padding: "5px 8px", textOverflow: "ellipsis", whiteSpace: "nowrap" }}>stars</span>
-              <span style={{ color: "light-dark(#000, #fff)", fontSize: 14, fontWeight: 600, lineHeight: 1, whiteSpace: "nowrap" }}>4.7K</span>
-            </a>
-            <a href="https://github.com/paradigmxyz/reth/graphs/contributors" className="vocs_Link vocs_Link_styleless" style={{ alignItems: "center", background: "light-dark(rgb(0 0 0 / 0.04), rgb(255 255 255 / 0.05))", border: "1px solid rgb(74 222 128 / 0.5)", borderRadius: 8, color: "inherit", display: "flex", gap: 8, height: 36, justifyContent: "center", minWidth: 0, padding: "0 10px" }} rel="noreferrer noopener" target="_blank">
-              <span style={{ background: "light-dark(rgb(255 255 255 / 0.64), rgb(0 0 0 / 0.32))", borderRadius: 6, color: "light-dark(rgb(0 0 0 / 0.76), rgb(255 255 255 / 0.76))", fontSize: 14, fontWeight: 500, lineHeight: 1, overflow: "hidden", padding: "5px 8px", textOverflow: "ellipsis", whiteSpace: "nowrap" }}>contributors</span>
-              <span style={{ color: "#4ade80", fontSize: 14, fontWeight: 600, lineHeight: 1, whiteSpace: "nowrap" }}>580+</span>
-            </a>
-            <a href="https://github.com/paradigmxyz/reth/blob/main/LICENSE-MIT" className="vocs_Link vocs_Link_styleless" style={{ alignItems: "center", background: "light-dark(rgb(0 0 0 / 0.04), rgb(255 255 255 / 0.05))", border: "1px solid light-dark(rgb(0 0 0 / 0.1), rgb(255 255 255 / 0.16))", borderRadius: 8, color: "inherit", display: "flex", gap: 8, height: 36, justifyContent: "center", minWidth: 0, padding: "0 10px" }} rel="noreferrer noopener" target="_blank">
-              <span style={{ background: "light-dark(rgb(255 255 255 / 0.64), rgb(0 0 0 / 0.32))", borderRadius: 6, color: "light-dark(rgb(0 0 0 / 0.76), rgb(255 255 255 / 0.76))", fontSize: 14, fontWeight: 500, lineHeight: 1, overflow: "hidden", padding: "5px 8px", textOverflow: "ellipsis", whiteSpace: "nowrap" }}>license</span>
-              <span style={{ color: "light-dark(#000, #fff)", fontSize: 14, fontWeight: 600, lineHeight: 1, whiteSpace: "nowrap" }}>MIT</span>
-            </a>
-          </div>
-        </div>
+        ```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>
   </div>
-  <div className="flex justify-between flex-wrap mt-10 lg:mt-30">
+  <div className="flex justify-between flex-wrap mt-10 lg:mt-16">
       <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">
@@ -111,7 +105,6 @@ import { TrustedBy } from "../components/TrustedBy";
         </div>
       </div>
     </div>
-    </div>
 </div>
 <article className="vocs_Content max-w-5xl mx-auto">
 

From 4a36609e6e405c63149f13c2587b44a45c3281f2 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 3 Jun 2026 12:45:53 +0200
Subject: [PATCH 290/335] feat(rpc): allow disabling rpc metrics (#24803)

---
 crates/node/core/src/args/rpc_server.rs | 25 ++++++++++++
 crates/rpc/ipc/src/server/mod.rs        | 11 +++--
 crates/rpc/rpc-builder/src/config.rs    | 20 ++++++++-
 crates/rpc/rpc-builder/src/lib.rs       | 54 +++++++++++++++++++------
 docs/vocs/docs/pages/cli/reth/node.mdx  |  3 ++
 5 files changed, 96 insertions(+), 17 deletions(-)

diff --git a/crates/node/core/src/args/rpc_server.rs b/crates/node/core/src/args/rpc_server.rs
index b164980dab7..03aa15670fd 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,
@@ -231,6 +232,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;
@@ -382,6 +389,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(),
@@ -511,6 +519,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,
@@ -828,6 +840,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,
@@ -872,6 +885,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,
@@ -981,6 +995,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 +1062,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(),
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-builder/src/config.rs b/crates/rpc/rpc-builder/src/config.rs
index 5576a4cc9db..c11135683ba 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>;
 
@@ -185,7 +188,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!(
@@ -227,6 +232,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);
 
@@ -370,6 +379,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/docs/vocs/docs/pages/cli/reth/node.mdx b/docs/vocs/docs/pages/cli/reth/node.mdx
index e25376d38a5..297b492f103 100644
--- a/docs/vocs/docs/pages/cli/reth/node.mdx
+++ b/docs/vocs/docs/pages/cli/reth/node.mdx
@@ -409,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
 

From 01755533e2c522211eefa06459d417bd86b236e9 Mon Sep 17 00:00:00 2001
From: Emma Jamieson-Hoare <emmajam@users.noreply.github.com>
Date: Wed, 3 Jun 2026 13:38:07 +0200
Subject: [PATCH 291/335] fix(docs): polish homepage layout (#24810)

---
 docs/vocs/docs/components/SdkShowcase.tsx | 16 ++++-----
 docs/vocs/docs/pages/index.mdx            | 42 +++++++++++------------
 docs/vocs/docs/styles.css                 | 26 ++++++++++++++
 3 files changed, 55 insertions(+), 29 deletions(-)

diff --git a/docs/vocs/docs/components/SdkShowcase.tsx b/docs/vocs/docs/components/SdkShowcase.tsx
index 442d6676f4f..f67d9fcfa77 100644
--- a/docs/vocs/docs/components/SdkShowcase.tsx
+++ b/docs/vocs/docs/components/SdkShowcase.tsx
@@ -40,29 +40,29 @@ const projects: SdkProject[] = [
 
 export function SdkShowcase() {
   return (
-    <div className="grid grid-cols-1 md:grid-cols-2 gap-6">
+    <div className="grid max-w-full grid-cols-1 gap-5 overflow-hidden xl:grid-cols-2">
       {projects.map((project) => (
         <div
           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="group relative min-w-0 overflow-hidden rounded-lg border border-black/10 bg-white/5 p-6 transition-colors hover:bg-black/5 dark:border-white/10 dark:bg-white/5 dark:hover:bg-white/10"
         >
           {/* 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="absolute right-5 top-5 rounded-full bg-black/10 px-3 py-1 text-sm font-medium text-black dark:bg-white/10 dark:text-white">
             {project.loc} LoC
           </div>
 
           {/* Content */}
           <div className="space-y-3">
-            <div>
-              <h3 className="text-xl font-semibold text-black dark:text-white mb-1">
+            <div className="min-w-0 pr-24">
+              <h3 className="mb-1 break-words text-xl font-semibold leading-tight text-black dark:text-white">
                 {project.name}
               </h3>
-              <p className="text-sm text-gray-600 dark:text-gray-400">
+              <p className="break-words text-sm text-gray-600 dark:text-gray-400">
                 {project.company}
               </p>
             </div>
 
-            <p className="text-gray-700 dark:text-gray-300 text-sm leading-relaxed">
+            <p className="break-words text-sm leading-relaxed text-gray-700 dark:text-gray-300">
               {project.description}
             </p>
 
@@ -71,7 +71,7 @@ export function SdkShowcase() {
               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"
+              className="inline-flex items-center gap-2 whitespace-nowrap text-sm font-medium text-black transition-colors hover:text-gray-700 dark:text-white dark:hover:text-gray-300"
             >
               <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"/>
diff --git a/docs/vocs/docs/pages/index.mdx b/docs/vocs/docs/pages/index.mdx
index 6d20c183f42..79df4677e3f 100644
--- a/docs/vocs/docs/pages/index.mdx
+++ b/docs/vocs/docs/pages/index.mdx
@@ -33,11 +33,6 @@ import { TrustedBy } from "../components/TrustedBy";
             <span style={{ color: "light-dark(rgb(0 0 0 / 0.62), rgb(255 255 255 / 0.62))", fontSize: 13, fontWeight: 500, lineHeight: 1 }}>license</span>
           </a>
       </div>
-      <div className="flex gap-x-5 gap-y-2 flex-wrap text-[15px] font-medium max-md:justify-center">
-        <a href="/run/ethereum" className="vocs_Link vocs_Link_styleless text-black dark:text-white hover:opacity-70">Run a Node</a>
-        <a href="/sdk" className="vocs_Link vocs_Link_styleless text-black dark:text-white hover:opacity-70">Build a Node</a>
-        <a href="/introduction/why-reth" className="vocs_Link vocs_Link_styleless text-black dark:text-white hover:opacity-70">Why Reth?</a>
-      </div>
       <div id="home-install">
         :::code-group
 
@@ -61,44 +56,49 @@ import { TrustedBy } from "../components/TrustedBy";
 
         :::
       </div>
+      <div className="flex gap-x-5 gap-y-2 flex-wrap text-[15px] font-medium max-md:justify-center">
+        <a href="/run/ethereum" className="vocs_Link vocs_Link_styleless text-black dark:text-white hover:opacity-70">Run a Node</a>
+        <a href="/sdk" className="vocs_Link vocs_Link_styleless text-black dark:text-white hover:opacity-70">Build a Node</a>
+        <a href="/introduction/why-reth" className="vocs_Link vocs_Link_styleless text-black dark:text-white hover:opacity-70">Why Reth?</a>
+      </div>
     </div>
   </div>
   <div className="flex justify-between flex-wrap mt-10 lg:mt-16">
       <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>
+        <div className="relative w-full min-h-[220px] 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 min-h-[220px] px-5 py-6 relative z-10 flex flex-col gap-4 w-full vocs_Link vocs_Link_styleless">
+            <div className="text-lg leading-tight font-medium text-black dark:text-white">Institutional Security</div>
+            <div className="text-[15px] leading-6 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>
+        <div className="relative w-full min-h-[220px] overflow-hidden">
+          <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 min-h-[220px] px-5 py-6 relative z-10 flex flex-col gap-4 w-full vocs_Link vocs_Link_styleless">
+            <div className="text-lg leading-tight font-medium text-black dark:text-white">Performant</div>
+            <div className="text-[15px] leading-6 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>
+        <div className="relative w-full min-h-[220px] overflow-hidden">
+          <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 min-h-[220px] px-5 py-6 relative z-10 flex flex-col gap-4 w-full vocs_Link vocs_Link_styleless">
+            <div className="text-lg leading-tight font-medium text-black dark:text-white">Customizable</div>
+            <div className="text-[15px] leading-6 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>
+        <div className="relative w-full min-h-[220px] overflow-hidden">
+          <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 min-h-[220px] px-5 py-6 relative z-10 flex flex-col gap-4 w-full vocs_Link vocs_Link_styleless">
+            <div className="text-lg leading-tight font-medium text-black dark:text-white">Extensible</div>
+            <div className="text-[15px] leading-6 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" />
diff --git a/docs/vocs/docs/styles.css b/docs/vocs/docs/styles.css
index 28af0cd0cd4..2ea55064738 100644
--- a/docs/vocs/docs/styles.css
+++ b/docs/vocs/docs/styles.css
@@ -9,9 +9,35 @@
 }
 
 [data-layout="landing"] .vocs_Content {
+  overflow-x: clip;
+  padding-left: 24px;
+  padding-right: 24px;
   position: inherit;
 }
 
+@media (min-width: 768px) {
+  [data-layout="landing"] .vocs_Content {
+    padding-left: 0;
+    padding-right: 0;
+  }
+}
+
+[data-layout="landing"] .vocs_Content > h2 {
+  font-size: 32px;
+  letter-spacing: 0;
+  line-height: 1.15;
+  margin-bottom: 8px;
+  margin-top: 64px;
+}
+
+[data-layout="landing"] .vocs_Content > p {
+  font-size: 18px;
+  line-height: 1.55;
+  margin-bottom: 24px;
+  margin-top: 0;
+  max-width: 820px;
+}
+
 #home-install .vocs_CodeGroup {
   display: flex;
   height: 100%;

From d36006a4de29df459862a84590b47bf33bc5057b Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 3 Jun 2026 14:33:21 +0200
Subject: [PATCH 292/335] feat(db): allow disabling database metrics (#24806)

---
 crates/cli/commands/src/node.rs                |  3 ++-
 crates/node/core/src/args/database.rs          | 18 ++++++++++++++++++
 .../storage/db/src/implementation/mdbx/mod.rs  |  9 +++++++++
 docs/vocs/docs/pages/cli/reth/db.mdx           |  3 +++
 docs/vocs/docs/pages/cli/reth/db/diff.mdx      |  3 +++
 docs/vocs/docs/pages/cli/reth/download.mdx     |  3 +++
 docs/vocs/docs/pages/cli/reth/export-era.mdx   |  3 +++
 docs/vocs/docs/pages/cli/reth/import-era.mdx   |  3 +++
 docs/vocs/docs/pages/cli/reth/import.mdx       |  3 +++
 docs/vocs/docs/pages/cli/reth/init-state.mdx   |  3 +++
 docs/vocs/docs/pages/cli/reth/init.mdx         |  3 +++
 docs/vocs/docs/pages/cli/reth/node.mdx         |  3 +++
 docs/vocs/docs/pages/cli/reth/prune.mdx        |  3 +++
 docs/vocs/docs/pages/cli/reth/re-execute.mdx   |  3 +++
 docs/vocs/docs/pages/cli/reth/stage/drop.mdx   |  3 +++
 docs/vocs/docs/pages/cli/reth/stage/dump.mdx   |  3 +++
 docs/vocs/docs/pages/cli/reth/stage/run.mdx    |  3 +++
 docs/vocs/docs/pages/cli/reth/stage/unwind.mdx |  3 +++
 18 files changed, 74 insertions(+), 1 deletion(-)

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/node/core/src/args/database.rs b/crates/node/core/src/args/database.rs
index ce0cfe7ca8c..abe7d17cd9a 100644
--- a/crates/node/core/src/args/database.rs
+++ b/crates/node/core/src/args/database.rs
@@ -70,6 +70,9 @@ pub struct DatabaseArgs {
     /// 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 {
@@ -100,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`].
@@ -233,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([
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/docs/vocs/docs/pages/cli/reth/db.mdx b/docs/vocs/docs/pages/cli/reth/db.mdx
index b4cd2cfb1ca..0f589c0af89 100644
--- a/docs/vocs/docs/pages/cli/reth/db.mdx
+++ b/docs/vocs/docs/pages/cli/reth/db.mdx
@@ -121,6 +121,9 @@ Database:
       --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 d4a4dc3abfa..868ebac93cd 100644
--- a/docs/vocs/docs/pages/cli/reth/db/diff.mdx
+++ b/docs/vocs/docs/pages/cli/reth/db/diff.mdx
@@ -70,6 +70,9 @@ Database:
       --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 57c368e6387..7b1c6aaa479 100644
--- a/docs/vocs/docs/pages/cli/reth/download.mdx
+++ b/docs/vocs/docs/pages/cli/reth/download.mdx
@@ -100,6 +100,9 @@ Database:
       --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/export-era.mdx b/docs/vocs/docs/pages/cli/reth/export-era.mdx
index 84232b6e0c3..c7477ff7a69 100644
--- a/docs/vocs/docs/pages/cli/reth/export-era.mdx
+++ b/docs/vocs/docs/pages/cli/reth/export-era.mdx
@@ -100,6 +100,9 @@ Database:
       --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 e4bcc450965..20299d61886 100644
--- a/docs/vocs/docs/pages/cli/reth/import-era.mdx
+++ b/docs/vocs/docs/pages/cli/reth/import-era.mdx
@@ -100,6 +100,9 @@ Database:
       --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 26952df89f7..c6b66c57cf1 100644
--- a/docs/vocs/docs/pages/cli/reth/import.mdx
+++ b/docs/vocs/docs/pages/cli/reth/import.mdx
@@ -100,6 +100,9 @@ Database:
       --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 1350b48b0dc..fb369df3f95 100644
--- a/docs/vocs/docs/pages/cli/reth/init-state.mdx
+++ b/docs/vocs/docs/pages/cli/reth/init-state.mdx
@@ -100,6 +100,9 @@ Database:
       --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 cdca695d468..2803a1f5c24 100644
--- a/docs/vocs/docs/pages/cli/reth/init.mdx
+++ b/docs/vocs/docs/pages/cli/reth/init.mdx
@@ -100,6 +100,9 @@ Database:
       --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 297b492f103..599d5d57348 100644
--- a/docs/vocs/docs/pages/cli/reth/node.mdx
+++ b/docs/vocs/docs/pages/cli/reth/node.mdx
@@ -854,6 +854,9 @@ Database:
       --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
diff --git a/docs/vocs/docs/pages/cli/reth/prune.mdx b/docs/vocs/docs/pages/cli/reth/prune.mdx
index 5a729e2bf6a..75be037c504 100644
--- a/docs/vocs/docs/pages/cli/reth/prune.mdx
+++ b/docs/vocs/docs/pages/cli/reth/prune.mdx
@@ -100,6 +100,9 @@ Database:
       --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 f1126ad1045..0fecdb8eb40 100644
--- a/docs/vocs/docs/pages/cli/reth/re-execute.mdx
+++ b/docs/vocs/docs/pages/cli/reth/re-execute.mdx
@@ -100,6 +100,9 @@ Database:
       --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 715ee03a6b0..8ba0951fb90 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/drop.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/drop.mdx
@@ -100,6 +100,9 @@ Database:
       --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 3b95b4eb440..653d6d53ab2 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/dump.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/dump.mdx
@@ -107,6 +107,9 @@ Database:
       --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 33bec937dab..5997110158d 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/run.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/run.mdx
@@ -100,6 +100,9 @@ Database:
       --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/unwind.mdx b/docs/vocs/docs/pages/cli/reth/stage/unwind.mdx
index 75130dbd604..8b16062a733 100644
--- a/docs/vocs/docs/pages/cli/reth/stage/unwind.mdx
+++ b/docs/vocs/docs/pages/cli/reth/stage/unwind.mdx
@@ -105,6 +105,9 @@ Database:
       --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

From 71e434bbd925faf588e5d5f410bdfb6d4e8f7c57 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?L=C3=A9a=20Narzis?=
 <78718413+lean-apple@users.noreply.github.com>
Date: Wed, 3 Jun 2026 15:18:04 +0200
Subject: [PATCH 293/335] feat(era): add `ere` group and `DynamicBlockIndex`
 (#24791)

---
 crates/era/src/common/file_ops.rs     |  97 +++-
 crates/era/src/ere/types/execution.rs |  86 +++-
 crates/era/src/ere/types/group.rs     | 627 ++++++++++++++++++++++++++
 crates/era/src/ere/types/mod.rs       |   1 +
 4 files changed, 774 insertions(+), 37 deletions(-)
 create mode 100644 crates/era/src/ere/types/group.rs

diff --git a/crates/era/src/common/file_ops.rs b/crates/era/src/common/file_ops.rs
index 3938f9ebe89..a460a203d25 100644
--- a/crates/era/src/common/file_ops.rs
+++ b/crates/era/src/common/file_ops.rs
@@ -172,26 +172,28 @@ 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 {
+    /// 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 file extension for this type, dot included
     pub const fn extension(&self) -> &'static str {
         match self {
             Self::Era => ".era",
             Self::Era1 => ".era1",
+            Self::Ere => ".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| filename.ends_with(ty.extension()))
     }
 
     /// Generate era file name.
@@ -210,24 +212,20 @@ 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 {
@@ -243,3 +241,58 @@ 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);
+    }
+
+    #[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)
+        );
+        // 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.txt"), None);
+    }
+}
diff --git a/crates/era/src/ere/types/execution.rs b/crates/era/src/ere/types/execution.rs
index c0f5a695cba..8fb11fdff7e 100644
--- a/crates/era/src/ere/types/execution.rs
+++ b/crates/era/src/ere/types/execution.rs
@@ -524,7 +524,14 @@ pub struct HeaderRecord {
     pub total_difficulty: U256,
 }
 
-/// A block tuple in an `ERE` file, containing all components for a single block
+/// 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
@@ -533,22 +540,50 @@ pub struct BlockTuple {
     /// Compressed block body
     pub body: CompressedBody,
 
-    /// Compressed receipts
-    pub receipts: CompressedSlimReceipts,
+    /// 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>,
 
-    /// Total difficulty
-    pub total_difficulty: TotalDifficulty,
+    /// Proof of block validity, omitted by the `noproofs` profile
+    pub proof: Option<Proof>,
 }
 
 impl BlockTuple {
-    /// Create a new [`BlockTuple`]
-    pub const fn new(
-        header: CompressedHeader,
-        body: CompressedBody,
-        receipts: CompressedSlimReceipts,
-        total_difficulty: TotalDifficulty,
-    ) -> Self {
-        Self { header, body, receipts, total_difficulty }
+    /// 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`
@@ -559,7 +594,7 @@ impl BlockTuple {
         Ok(Block::new(header, body))
     }
 
-    /// Create from an `alloy_consensus::Block`
+    /// 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,
@@ -572,7 +607,9 @@ impl BlockTuple {
 
         let difficulty = TotalDifficulty::new(total_difficulty);
 
-        Ok(Self::new(header, body, compressed_receipts, difficulty))
+        Ok(Self::new(header, body)
+            .with_receipts(compressed_receipts)
+            .with_total_difficulty(difficulty))
     }
 }
 
@@ -691,6 +728,25 @@ mod tests {
         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);
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
index c16f0cfaa74..c61a22d390a 100644
--- a/crates/era/src/ere/types/mod.rs
+++ b/crates/era/src/ere/types/mod.rs
@@ -3,3 +3,4 @@
 //! See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md>
 
 pub mod execution;
+pub mod group;

From cf794dfa04781a2c46f0acae1239e3a0cf5d6ad8 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Wed, 3 Jun 2026 15:32:33 +0200
Subject: [PATCH 294/335] feat(payload): wire target gas limit attributes
 (#24502)

---
 crates/ethereum/payload/src/config.rs    | 42 +++++++++++++++++++++++-
 crates/ethereum/payload/src/lib.rs       |  3 +-
 crates/payload/primitives/src/payload.rs |  8 +++++
 crates/payload/primitives/src/traits.rs  | 12 +++++++
 examples/custom-engine-types/src/main.rs |  4 +++
 5 files changed, 67 insertions(+), 2 deletions(-)

diff --git a/crates/ethereum/payload/src/config.rs b/crates/ethereum/payload/src/config.rs
index 2b15939821f..0af9d9f19c9 100644
--- a/crates/ethereum/payload/src/config.rs
+++ b/crates/ethereum/payload/src/config.rs
@@ -65,6 +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),
+        )
+    }
+}
+
+#[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 0b05f2fb899..dc5b387f103 100644
--- a/crates/ethereum/payload/src/lib.rs
+++ b/crates/ethereum/payload/src/lib.rs
@@ -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,
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 4345cefea99..9b9ca191048 100644
--- a/crates/payload/primitives/src/traits.rs
+++ b/crates/payload/primitives/src/traits.rs
@@ -91,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 {
@@ -113,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/examples/custom-engine-types/src/main.rs b/examples/custom-engine-types/src/main.rs
index 2ed864757b1..bc1414693fb 100644
--- a/examples/custom-engine-types/src/main.rs
+++ b/examples/custom-engine-types/src/main.rs
@@ -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

From fcfbd805b2aa4884631a7f5b5765b8bf00ed136c Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Wed, 3 Jun 2026 19:07:21 +0530
Subject: [PATCH 295/335] fix(rpc): align eth_simulate fork handling (#24724)

---
 crates/ethereum/evm/src/build.rs           | 9 +++++++--
 crates/rpc/rpc-eth-api/src/helpers/call.rs | 9 ++++++++-
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/crates/ethereum/evm/src/build.rs b/crates/ethereum/evm/src/build.rs
index 42b9df41553..263cf4e0b35 100644
--- a/crates/ethereum/evm/src/build.rs
+++ b/crates/ethereum/evm/src/build.rs
@@ -75,6 +75,11 @@ impl<ChainSpec: EthChainSpec + EthereumHardforks> EthBlockAssembler<ChainSpec> {
             .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;
@@ -108,8 +113,8 @@ impl<ChainSpec: EthChainSpec + EthereumHardforks> EthBlockAssembler<ChainSpec> {
             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,
diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs
index f10a158c62a..0ac0a2d1df5 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/call.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/call.rs
@@ -18,7 +18,7 @@ use alloy_rpc_types_eth::{
     BlockId, Bundle, EthCallResponse, StateContext, TransactionInfo,
 };
 use futures::Future;
-use reth_chainspec::{ChainSpecProvider, EthChainSpec};
+use reth_chainspec::{ChainSpecProvider, EthChainSpec, EthereumHardforks};
 use reth_errors::{ProviderError, RethError};
 use reth_evm::{
     block::BlockExecutor, env::BlockEnvironment, execute::BlockBuilder, ConfigureEvm, Evm,
@@ -149,6 +149,13 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                     // 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

From e92347d244e550131d69a765f9ee646d68b9d037 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Wed, 3 Jun 2026 18:05:28 +0200
Subject: [PATCH 296/335] ci(bench): allow rkrasiuk to trigger PR benches
 (#24819)

---
 .github/workflows/bench.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index c3b553df304..03fd7e991ab 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -145,7 +145,9 @@ jobs:
           github-token: ${{ secrets.DEREK_BENCH_ACK_TOKEN }}
           script: |
             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;

From 6f3efa3b407294b93a814bd5802f050b6f1cefde Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Thu, 4 Jun 2026 13:22:05 +0530
Subject: [PATCH 297/335] fix(engine): update ssz proxy endpoint paths (#24844)

---
 crates/ethereum/node/src/engine_ssz_proxy.rs | 94 +++++++++++++++++---
 crates/ethereum/node/tests/e2e/eth.rs        |  8 +-
 2 files changed, 87 insertions(+), 15 deletions(-)

diff --git a/crates/ethereum/node/src/engine_ssz_proxy.rs b/crates/ethereum/node/src/engine_ssz_proxy.rs
index eccc5b18986..bfab692303f 100644
--- a/crates/ethereum/node/src/engine_ssz_proxy.rs
+++ b/crates/ethereum/node/src/engine_ssz_proxy.rs
@@ -1,6 +1,6 @@
 //! HTTP SSZ transport proxy for the authenticated Engine API server.
 //!
-//! Implements the [EIP-8178] SSZ Engine API routes under `/engine`.
+//! Implements the [EIP-8178] SSZ Engine API routes under `/engine/v2`.
 //!
 //! [EIP-8178]: https://eips.ethereum.org/EIPS/eip-8178
 
@@ -52,7 +52,7 @@ impl EngineSszProxyHandle {
     }
 }
 
-/// A tower layer that intercepts SSZ Engine API routes under `/engine`.
+/// A tower layer that intercepts SSZ Engine API routes under `/engine/v2`.
 #[derive(Clone, Debug, Default)]
 pub struct EngineSszProxyLayer {
     handle: EngineSszProxyHandle,
@@ -95,7 +95,7 @@ where
     }
 
     fn call(&mut self, request: HttpRequest) -> Self::Future {
-        if !request.uri().path().starts_with("/engine/") {
+        if !request.uri().path().starts_with("/engine/v2/") {
             let fut = self.inner.call(request);
             return Box::pin(fut)
         }
@@ -114,7 +114,7 @@ async fn handle_engine_ssz_request(
     }
 
     let path = request.uri().path().to_owned();
-    let Some((version, resource)) = parse_engine_path(&path) else {
+    let Some((fork, resource)) = parse_engine_path(&path) else {
         return text_response(STATUS_NOT_FOUND, "unknown engine ssz endpoint")
     };
 
@@ -127,23 +127,69 @@ async fn handle_engine_ssz_request(
     };
 
     match resource {
-        "payloads" => handle_new_payload(engine, version, &body).await,
-        "forkchoice" => handle_forkchoice_updated(engine, version, &body).await,
+        "payloads" => handle_new_payload(engine, fork.payloads_version(), &body).await,
+        "forkchoice" => handle_forkchoice_updated(engine, fork.forkchoice_version(), &body).await,
         _ => text_response(STATUS_NOT_FOUND, "unknown engine ssz endpoint"),
     }
 }
 
-fn parse_engine_path(path: &str) -> Option<(u8, &str)> {
+fn parse_engine_path(path: &str) -> Option<(EngineSszFork, &str)> {
     let mut segments = path.trim_start_matches('/').split('/');
-    match (segments.next(), segments.next(), segments.next(), segments.next()) {
-        (Some("engine"), Some(version), Some(resource), None) => {
-            let version = version.strip_prefix('v')?.parse().ok()?;
-            Some((version, resource))
+    match (segments.next(), segments.next(), segments.next(), segments.next(), segments.next()) {
+        (Some("engine"), Some("v2"), Some(fork), Some(resource), None) => {
+            Some((fork.parse().ok()?, resource))
         }
         _ => None,
     }
 }
 
+#[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(()),
+        }
+    }
+}
+
 async fn handle_new_payload(
     engine: ConsensusEngineHandle<EthEngineTypes>,
     version: u8,
@@ -327,3 +373,29 @@ fn text_response(status: u16, body: impl Into<String>) -> HttpResponse {
         .body(HttpBody::from(body.into()))
         .expect("valid response")
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_fork_scoped_payload_endpoint() {
+        let (fork, resource) = parse_engine_path("/engine/v2/prague/payloads").unwrap();
+        assert_eq!(fork, EngineSszFork::Prague);
+        assert_eq!(resource, "payloads");
+        assert_eq!(fork.payloads_version(), 4);
+    }
+
+    #[test]
+    fn parses_fork_scoped_forkchoice_endpoint() {
+        let (fork, resource) = parse_engine_path("/engine/v2/amsterdam/forkchoice").unwrap();
+        assert_eq!(fork, EngineSszFork::Amsterdam);
+        assert_eq!(resource, "forkchoice");
+        assert_eq!(fork.forkchoice_version(), 4);
+    }
+
+    #[test]
+    fn rejects_legacy_version_scoped_endpoint() {
+        assert!(parse_engine_path("/engine/v4/payloads").is_none());
+    }
+}
diff --git a/crates/ethereum/node/tests/e2e/eth.rs b/crates/ethereum/node/tests/e2e/eth.rs
index 7b1cbda974f..07e3ef4a154 100644
--- a/crates/ethereum/node/tests/e2e/eth.rs
+++ b/crates/ethereum/node/tests/e2e/eth.rs
@@ -21,8 +21,8 @@ use reth_tasks::Runtime;
 use ssz::{Decode, Encode};
 use std::sync::Arc;
 
-const ENGINE_NEW_PAYLOAD_V4_ROUTE: &str = "/engine/v4/payloads";
-const ENGINE_FORKCHOICE_UPDATED_V3_ROUTE: &str = "/engine/v3/forkchoice";
+const ENGINE_PRAGUE_PAYLOADS_ROUTE: &str = "/engine/v2/prague/payloads";
+const ENGINE_PRAGUE_FORKCHOICE_ROUTE: &str = "/engine/v2/prague/forkchoice";
 
 #[tokio::test]
 async fn can_run_eth_node() -> eyre::Result<()> {
@@ -326,7 +326,7 @@ async fn test_engine_ssz_proxy_can_mine_block() -> eyre::Result<()> {
     let auth_header = secret_to_bearer_header(auth_server.jwt_secret());
 
     let new_payload_response = client
-        .post(format!("{auth_url}{ENGINE_NEW_PAYLOAD_V4_ROUTE}"))
+        .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")
@@ -342,7 +342,7 @@ async fn test_engine_ssz_proxy_can_mine_block() -> eyre::Result<()> {
     assert_eq!(status.status, PayloadStatusEnum::Valid);
 
     let fcu_response = client
-        .post(format!("{auth_url}{ENGINE_FORKCHOICE_UPDATED_V3_ROUTE}"))
+        .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")

From 7ab758fff89b0db2c1148d84ee540c9f3418b32d Mon Sep 17 00:00:00 2001
From: Emma Jamieson-Hoare <emmajam@users.noreply.github.com>
Date: Thu, 4 Jun 2026 12:21:13 +0200
Subject: [PATCH 298/335] chore(docs): upgrade Vocs to v2 (#24849)

---
 .gitignore                                |   3 +
 docs/vocs/bun.lock                        |  55 ++-
 docs/vocs/docs/components/SdkShowcase.tsx |  52 +--
 docs/vocs/docs/components/TrustedBy.tsx   |  44 +-
 docs/vocs/docs/pages/_root.css            | 525 +++++++++++++++++++++-
 docs/vocs/docs/pages/index.mdx            | 202 ++++-----
 docs/vocs/docs/styles.css                 |  57 ---
 docs/vocs/package.json                    |   9 +-
 docs/vocs/scripts/fix-search-index.ts     | 148 +++---
 docs/vocs/scripts/generate-redirects.ts   |   4 +-
 docs/vocs/scripts/inject-cargo-docs.ts    |   4 +-
 docs/vocs/vocs.config.ts                  |  30 ++
 12 files changed, 823 insertions(+), 310 deletions(-)
 delete mode 100644 docs/vocs/docs/styles.css

diff --git a/.gitignore b/.gitignore
index cf5014a4810..0011ac50601 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/docs/vocs/bun.lock b/docs/vocs/bun.lock
index 084f2288f10..199457a3262 100644
--- a/docs/vocs/bun.lock
+++ b/docs/vocs/bun.lock
@@ -5,10 +5,11 @@
     "": {
       "name": "vocs",
       "dependencies": {
-        "react": "^19.2.5",
-        "react-dom": "^19.2.5",
-        "vocs": "^2.0.10",
-        "waku": "^1.0.0-beta.0",
+        "react": "19.2.4",
+        "react-dom": "19.2.4",
+        "react-server-dom-webpack": "19.2.4",
+        "vocs": "^2.0.11",
+        "waku": "1.0.0-beta.0",
       },
       "devDependencies": {
         "@types/node": "^24.12.2",
@@ -60,7 +61,7 @@
 
     "@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=="],
 
-    "@codemirror/autocomplete": ["@codemirror/autocomplete@6.20.2", "", { "dependencies": { "@codemirror/language": "^6.0.0", "@codemirror/state": "^6.0.0", "@codemirror/view": "^6.17.0", "@lezer/common": "^1.0.0" } }, "sha512-G5FPkgIiLjOgZMjqVjvuKQ1rGPtHogLldJr33eFJdVLtmwY+giGrlv/ewljLz6b9BSQLkjxuwBc6g6omDM+YxQ=="],
+    "@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=="],
 
     "@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=="],
 
@@ -154,9 +155,9 @@
 
     "@iconify-json/lucide": ["@iconify-json/lucide@1.2.111", "", { "dependencies": { "@iconify/types": "*" } }, "sha512-S6oXom2YOKuXFxWofhHa2oq++Z3WeZ78dRFDA7aEEJqyNCJlQd1UGAfN8u2gD2NzvYotmm+j5kH678viWfZbGQ=="],
 
-    "@iconify-json/simple-icons": ["@iconify-json/simple-icons@1.2.84", "", { "dependencies": { "@iconify/types": "*" } }, "sha512-v4JVu6xIewGoETD4mm2k6UAdFAbTlY1duw5ZNSxYORfs2yFsHDhoU9Omn/BgrV0nR/ptWkF3ZIr/ZHoYXI/6Jw=="],
+    "@iconify-json/simple-icons": ["@iconify-json/simple-icons@1.2.85", "", { "dependencies": { "@iconify/types": "*" } }, "sha512-Hp5LXvd3LRk+e+1558wtonA7c1Z0/Phmi7xCqpgtb8bs8cuyGnP34GDbt5uhhUXxKlzacnnhAcXgcDxe9bUa1w=="],
 
-    "@iconify-json/vscode-icons": ["@iconify-json/vscode-icons@1.2.53", "", { "dependencies": { "@iconify/types": "*" } }, "sha512-l7EU0XxVXufefqYg8gaBgsmM0Bk6Sg5EbF6JTnJ15YkRbC9eiDn5dtyV41IRpV/dabveEAl0iD7dQjv+A7fNLA=="],
+    "@iconify-json/vscode-icons": ["@iconify-json/vscode-icons@1.2.54", "", { "dependencies": { "@iconify/types": "*" } }, "sha512-WxGA+FE5AP7mbKuy7lMClIKc/iY9hCKgafZsrCeQjyO2G3MvP/2cZev1W1QPn3tAbXDmVak5K3HB3rxvi+066g=="],
 
     "@iconify/types": ["@iconify/types@2.0.0", "", {}, "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg=="],
 
@@ -454,7 +455,7 @@
 
     "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="],
 
-    "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+    "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=="],
 
@@ -536,7 +537,7 @@
 
     "comma-separated-tokens": ["comma-separated-tokens@2.0.3", "", {}, "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg=="],
 
-    "commander": ["commander@4.1.1", "", {}, "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA=="],
+    "commander": ["commander@2.20.3", "", {}, "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="],
 
     "confbox": ["confbox@0.2.4", "", {}, "sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ=="],
 
@@ -586,13 +587,13 @@
 
     "ee-first": ["ee-first@1.1.1", "", {}, "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="],
 
-    "electron-to-chromium": ["electron-to-chromium@1.5.364", "", {}, "sha512-G/dYE3+AYhyHwzTwg8UbnXf7zqMERYh7l2jJ3QujhFsH8agSYwtnGAR2aZ7f0AakIKJXd5En/Hre4igIUrdlYw=="],
+    "electron-to-chromium": ["electron-to-chromium@1.5.367", "", {}, "sha512-4Mk/mrynCNQ+atY40D3UpmhLWB6AHMbYMlIrPhHcMF6x0L7O0b052FCAsxw1LlaR++UFuNg3D/A6XCuGDa0guQ=="],
 
     "emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
 
     "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="],
 
-    "enhanced-resolve": ["enhanced-resolve@5.22.1", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.3" } }, "sha512-6QEuw3zoX1SJQc7b87aBXke/no+mG2bTBgw29gWMQonLmpEkWoCAVkl+M49e48AZlWzxiDzDZzYdp6kobcyLww=="],
+    "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=="],
 
@@ -982,7 +983,7 @@
 
     "no-case": ["no-case@3.0.4", "", { "dependencies": { "lower-case": "^2.0.2", "tslib": "^2.0.3" } }, "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg=="],
 
-    "node-releases": ["node-releases@2.0.46", "", {}, "sha512-GYVXHE2KnrzAfsAjl4uP++evGFCrAU1jta4ubEjIG7YWt/64Gqv66a30yKwWczVjA6j3bM4nBwH7Pk1JmDHaxQ=="],
+    "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=="],
 
@@ -1046,11 +1047,11 @@
 
     "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": ["react@19.2.5", "", {}, "sha512-llUJLzz1zTUBrskt2pwZgLq59AemifIftw4aB7JxOqf1HY2FDaGDxgwpAPVzHU1kdWabH7FauP4i1oEeer2WCA=="],
+    "react": ["react@19.2.4", "", {}, "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ=="],
 
     "react-devtools-inline": ["react-devtools-inline@4.4.0", "", { "dependencies": { "es6-symbol": "^3" } }, "sha512-ES0GolSrKO8wsKbsEkVeiR/ZAaHQTY4zDh1UW8DImVmm8oaGLl3ijJDvSGe+qDRKPZdPRnDtWWnSvvrgxXdThQ=="],
 
-    "react-dom": ["react-dom@19.2.5", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.5" } }, "sha512-J5bAZz+DXMMwW/wV3xzKke59Af6CHY7G4uYLN1OvBcKEsWOs4pQExj86BBKamxl/Ik5bx9whOrvBlSDfWzgSag=="],
+    "react-dom": ["react-dom@19.2.4", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.4" } }, "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ=="],
 
     "react-error-boundary": ["react-error-boundary@6.1.2", "", { "peerDependencies": { "react": "^18.0.0 || ^19.0.0" } }, "sha512-3DpCr5HVdZ0caUjYE/kIHBEJN0mNP3ZCgf16c48uJ5TbWjorKVp+YG8W3XqlJ7vJAVNw6wNIImyPXmFydwmyng=="],
 
@@ -1058,7 +1059,7 @@
 
     "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-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=="],
+    "react-server-dom-webpack": ["react-server-dom-webpack@19.2.4", "", { "dependencies": { "acorn-loose": "^8.3.0", "neo-async": "^2.6.1", "webpack-sources": "^3.2.0" }, "peerDependencies": { "react": "^19.2.4", "react-dom": "^19.2.4", "webpack": "^5.59.0" } }, "sha512-zEhkWv6RhXDctC2N7yEUHg3751nvFg81ydHj8LTTZuukF/IF1gcOKqqAL6Ds+kS5HtDVACYPik0IvzkgYXPhlQ=="],
 
     "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=="],
 
@@ -1276,11 +1277,11 @@
 
     "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=="],
 
-    "vocs": ["vocs@2.0.10", "", { "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-EVJRXLBxV0/AODmRLZF+be6VTquUX5JeJXYWayer/6yS6UCrRsQSEurhRmSYMjlQhA/VyLVWdtegsZtJhimbAg=="],
+    "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=="],
 
     "w3c-keyname": ["w3c-keyname@2.2.8", "", {}, "sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ=="],
 
-    "waku": ["waku@1.0.0-beta.1", "", { "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-fsDHpz4K+h7K7Umyoweclrvxdk+jZD5lzg4dByuIh7sctiEe8YTu4DhRAxel+cRp9LvLRB8hcWgwkjCBLiqxVg=="],
+    "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=="],
 
     "watchpack": ["watchpack@2.5.1", "", { "dependencies": { "glob-to-regexp": "^0.4.1", "graceful-fs": "^4.1.2" } }, "sha512-Zn5uXdcFNIA1+1Ei5McRd+iRzfhENPCe7LeABkJtNulSxjma+l7ltNx55BWZkRlwRnpOgHqxnjyaDgJnNXnqzg=="],
 
@@ -1318,6 +1319,8 @@
 
     "@jridgewell/trace-mapping/@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.4", "", {}, "sha512-VT2+G1VQs/9oz078bLrYbecdZKs912zQlkelYpuf+SXF+QvZDYJlbx/LSx+meSAwdDFnF8FVXW92AVjjkVmgFw=="],
 
+    "@mdx-js/mdx/acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+
     "@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=="],
@@ -1338,14 +1341,24 @@
 
     "@tailwindcss/oxide-wasm32-wasi/tslib": ["tslib@2.8.1", "", { "bundled": true }, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
 
+    "acorn-loose/acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+
     "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=="],
 
+    "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=="],
 
+    "finalhandler/statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
+
     "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=="],
 
     "micromark/debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
 
+    "micromark-extension-mdxjs/acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+
+    "mlly/acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+
     "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=="],
 
     "parse-entities/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
@@ -1376,15 +1389,11 @@
 
     "strip-ansi-cjs/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
 
-    "sucrase/tinyglobby": ["tinyglobby@0.2.16", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.4" } }, "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg=="],
-
-    "terser/acorn": ["acorn@8.16.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw=="],
-
-    "terser/commander": ["commander@2.20.3", "", {}, "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="],
+    "sucrase/commander": ["commander@4.1.1", "", {}, "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA=="],
 
     "type-is/content-type": ["content-type@2.0.0", "", {}, "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ=="],
 
-    "webpack/acorn": ["acorn@8.16.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw=="],
+    "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=="],
 
diff --git a/docs/vocs/docs/components/SdkShowcase.tsx b/docs/vocs/docs/components/SdkShowcase.tsx
index f67d9fcfa77..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 max-w-full grid-cols-1 gap-5 overflow-hidden xl:grid-cols-2">
+    <div className="reth-sdk-grid">
       {projects.map((project) => (
-        <div
+        <article
           key={project.name}
-          className="group relative min-w-0 overflow-hidden rounded-lg border border-black/10 bg-white/5 p-6 transition-colors hover:bg-black/5 dark:border-white/10 dark:bg-white/5 dark:hover:bg-white/10"
+          className="reth-sdk-card"
         >
-          {/* LoC Badge */}
-          <div className="absolute right-5 top-5 rounded-full bg-black/10 px-3 py-1 text-sm font-medium text-black dark:bg-white/10 dark:text-white">
+          <div className="reth-sdk-badge">
             {project.loc} LoC
           </div>
 
-          {/* Content */}
-          <div className="space-y-3">
-            <div className="min-w-0 pr-24">
-              <h3 className="mb-1 break-words text-xl font-semibold leading-tight text-black dark:text-white">
-                {project.name}
-              </h3>
-              <p className="break-words 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="break-words text-sm leading-relaxed text-gray-700 dark:text-gray-300">
-              {project.description}
-            </p>
-
-            {/* GitHub Link */}
-            <a
-              href={project.githubUrl}
-              target="_blank"
-              rel="noopener noreferrer"
-              className="inline-flex items-center gap-2 whitespace-nowrap text-sm font-medium text-black transition-colors hover:text-gray-700 dark:text-white dark:hover:text-gray-300"
-            >
-              <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
index b27cc89c989..d029a3f79c0 100644
--- a/docs/vocs/docs/pages/_root.css
+++ b/docs/vocs/docs/pages/_root.css
@@ -1 +1,524 @@
-@import "../styles.css";
+@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/index.mdx b/docs/vocs/docs/pages/index.mdx
index 79df4677e3f..bcab93f5b7b 100644
--- a/docs/vocs/docs/pages/index.mdx
+++ b/docs/vocs/docs/pages/index.mdx
@@ -1,137 +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 { 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-y-6">
-      <img
-        src="/reth-prod.png"
-        alt="Reth"
-        className="w-full h-auto rounded-xl"
-      />
-      <div className="font-regular max-w-[760px] 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 className="flex gap-2 flex-wrap max-md:justify-center">
-          <a href="https://github.com/paradigmxyz/reth/stargazers" aria-label="4.7K GitHub stars" title="4.7K stars" className="vocs_Link vocs_Link_styleless" style={{ alignItems: "center", background: "light-dark(rgb(0 0 0 / 0.04), rgb(255 255 255 / 0.05))", border: "1px solid light-dark(rgb(0 0 0 / 0.1), rgb(255 255 255 / 0.16))", borderRadius: 8, color: "inherit", display: "inline-flex", gap: 6, height: 36, justifyContent: "center", minWidth: 0, padding: "0 12px", whiteSpace: "nowrap" }} rel="noreferrer noopener" target="_blank">
-            <span style={{ color: "light-dark(#000, #fff)", fontSize: 14, fontWeight: 700, lineHeight: 1 }}>4.7K</span>
-            <span style={{ color: "light-dark(rgb(0 0 0 / 0.62), rgb(255 255 255 / 0.62))", fontSize: 13, fontWeight: 500, lineHeight: 1 }}>stars</span>
-          </a>
-          <a href="https://github.com/paradigmxyz/reth/graphs/contributors" aria-label="580+ GitHub contributors" title="580+ contributors" className="vocs_Link vocs_Link_styleless" style={{ alignItems: "center", background: "light-dark(rgb(0 0 0 / 0.04), rgb(255 255 255 / 0.05))", border: "1px solid rgb(74 222 128 / 0.5)", borderRadius: 8, color: "inherit", display: "inline-flex", gap: 6, height: 36, justifyContent: "center", minWidth: 0, padding: "0 12px", whiteSpace: "nowrap" }} rel="noreferrer noopener" target="_blank">
-            <span style={{ color: "#4ade80", fontSize: 14, fontWeight: 700, lineHeight: 1 }}>580+</span>
-            <span style={{ color: "light-dark(rgb(0 0 0 / 0.62), rgb(255 255 255 / 0.62))", fontSize: 13, fontWeight: 500, lineHeight: 1 }}>contributors</span>
-          </a>
-          <a href="https://github.com/paradigmxyz/reth/blob/main/LICENSE-MIT" aria-label="MIT license" title="MIT license" className="vocs_Link vocs_Link_styleless" style={{ alignItems: "center", background: "light-dark(rgb(0 0 0 / 0.04), rgb(255 255 255 / 0.05))", border: "1px solid light-dark(rgb(0 0 0 / 0.1), rgb(255 255 255 / 0.16))", borderRadius: 8, color: "inherit", display: "inline-flex", gap: 6, height: 36, justifyContent: "center", minWidth: 0, padding: "0 12px", whiteSpace: "nowrap" }} rel="noreferrer noopener" target="_blank">
-            <span style={{ color: "light-dark(#000, #fff)", fontSize: 14, fontWeight: 700, lineHeight: 1 }}>MIT</span>
-            <span style={{ color: "light-dark(rgb(0 0 0 / 0.62), rgb(255 255 255 / 0.62))", fontSize: 13, fontWeight: 500, lineHeight: 1 }}>license</span>
-          </a>
-      </div>
-      <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 gap-x-5 gap-y-2 flex-wrap text-[15px] font-medium max-md:justify-center">
-        <a href="/run/ethereum" className="vocs_Link vocs_Link_styleless text-black dark:text-white hover:opacity-70">Run a Node</a>
-        <a href="/sdk" className="vocs_Link vocs_Link_styleless text-black dark:text-white hover:opacity-70">Build a Node</a>
-        <a href="/introduction/why-reth" className="vocs_Link vocs_Link_styleless text-black dark:text-white hover:opacity-70">Why Reth?</a>
-      </div>
-    </div>
-  </div>
-  <div className="flex justify-between flex-wrap mt-10 lg:mt-16">
-      <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 min-h-[220px] 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 min-h-[220px] px-5 py-6 relative z-10 flex flex-col gap-4 w-full vocs_Link vocs_Link_styleless">
-            <div className="text-lg leading-tight font-medium text-black dark:text-white">Institutional Security</div>
-            <div className="text-[15px] leading-6 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 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="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 min-h-[220px] overflow-hidden">
-          <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 min-h-[220px] px-5 py-6 relative z-10 flex flex-col gap-4 w-full vocs_Link vocs_Link_styleless">
-            <div className="text-lg leading-tight font-medium text-black dark:text-white">Performant</div>
-            <div className="text-[15px] leading-6 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 min-h-[220px] overflow-hidden">
-          <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 min-h-[220px] px-5 py-6 relative z-10 flex flex-col gap-4 w-full vocs_Link vocs_Link_styleless">
-            <div className="text-lg leading-tight font-medium text-black dark:text-white">Customizable</div>
-            <div className="text-[15px] leading-6 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 min-h-[220px] overflow-hidden">
-          <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 min-h-[220px] px-5 py-6 relative z-10 flex flex-col gap-4 w-full vocs_Link vocs_Link_styleless">
-            <div className="text-lg leading-tight font-medium text-black dark:text-white">Extensible</div>
-            <div className="text-[15px] leading-6 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 className="reth-home-hero-media">
+        <img src="/reth-prod.png" alt="Reth chip on a dark circuit grid" />
       </div>
     </div>
-</div>
-<article className="vocs_Content max-w-5xl mx-auto">
+    <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>
 
-## Trusted by the Best
+  <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>
 
-Leading infra companies use Reth for MEV applications, staking, RPC services and generating zero-knowledge proofs.
+  <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 id="home-install" className="reth-home-code">
+      :::code-group
 
-<div className="mb-12">
-    <TrustedBy />
-</div>
+      ```bash [Run a Node]
+      # Install the binary
+      brew install paradigmxyz/brew/reth
 
-## Built with Reth SDK
+      # Run the node with JSON-RPC enabled
+      reth node --http --http.api eth,trace
+      ```
 
-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.
+      ```rust [Build a Node]
+      // .. snip ..
+      let handle = node_builder
+        .with_types::<EthereumNode>()
+        .with_components(EthereumNode::components())
+        .with_add_ons(EthereumAddOns::default())
+        .launch()
+        .await?;
+      ```
 
-<div className="mb-12">
-    <SdkShowcase />
-</div>
+      :::
+    </div>
+  </section>
 
-## Supporters
+  <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="flex flex-wrap gap-4">
-  <a href="https://paradigm.xyz" className="flex h-[72px] w-[180px] items-center justify-center rounded-lg border border-black/10 p-4 dark:border-white/10" rel="noreferrer noopener" target="_blank">
-    <img src="https://raw.githubusercontent.com/wevm/.github/main/content/sponsors/paradigm-light.svg" alt="Paradigm" className="max-h-full max-w-full dark:invert" />
-  </a>
-  <a href="https://ithaca.xyz" className="flex h-[72px] w-[180px] items-center justify-center rounded-lg border border-black/10 p-4 dark:border-white/10" rel="noreferrer noopener" target="_blank">
-    <img src="https://raw.githubusercontent.com/wevm/.github/main/content/sponsors/ithaca-light.svg" alt="Ithaca" className="max-h-full max-w-full dark:invert" />
-  </a>
+  <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>
+
+  <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>
+
+  <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>
-</article>
diff --git a/docs/vocs/docs/styles.css b/docs/vocs/docs/styles.css
deleted file mode 100644
index 2ea55064738..00000000000
--- a/docs/vocs/docs/styles.css
+++ /dev/null
@@ -1,57 +0,0 @@
-@import "tailwindcss" important;
-
-@custom-variant dark (&:where(.dark, .dark *, [data-vocs-theme="dark"], [data-vocs-theme="dark"] *));
-
-[data-layout="landing"] .vocs_Button_button {
-  border-radius: 4px !important;
-  height: 36px !important;
-  padding: 0 16px !important;
-}
-
-[data-layout="landing"] .vocs_Content {
-  overflow-x: clip;
-  padding-left: 24px;
-  padding-right: 24px;
-  position: inherit;
-}
-
-@media (min-width: 768px) {
-  [data-layout="landing"] .vocs_Content {
-    padding-left: 0;
-    padding-right: 0;
-  }
-}
-
-[data-layout="landing"] .vocs_Content > h2 {
-  font-size: 32px;
-  letter-spacing: 0;
-  line-height: 1.15;
-  margin-bottom: 8px;
-  margin-top: 64px;
-}
-
-[data-layout="landing"] .vocs_Content > p {
-  font-size: 18px;
-  line-height: 1.55;
-  margin-bottom: 24px;
-  margin-top: 0;
-  max-width: 820px;
-}
-
-#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 ed0e74a91a1..3575eb2ba30 100644
--- a/docs/vocs/package.json
+++ b/docs/vocs/package.json
@@ -13,10 +13,11 @@
     "inject-cargo-docs": "bun scripts/inject-cargo-docs.ts"
   },
   "dependencies": {
-    "react": "^19.2.5",
-    "react-dom": "^19.2.5",
-    "vocs": "^2.0.10",
-    "waku": "^1.0.0-beta.0"
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "react-server-dom-webpack": "19.2.4",
+    "vocs": "^2.0.11",
+    "waku": "1.0.0-beta.0"
   },
   "devDependencies": {
     "@types/node": "^24.12.2",
diff --git a/docs/vocs/scripts/fix-search-index.ts b/docs/vocs/scripts/fix-search-index.ts
index d8ded170e76..f3f61f45c74 100644
--- a/docs/vocs/scripts/fix-search-index.ts
+++ b/docs/vocs/scripts/fix-search-index.ts
@@ -1,81 +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
-    let files: string[];
-    try {
-      files = await readdir(vocsDir);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        for (const assetsDir of [join(distDir, 'assets'), join(distDir, 'public', 'assets')]) {
-          try {
-            const assets = await readdir(assetsDir);
-            const searchIndexFile = assets.find(f => f.startsWith('search-index-') && f.endsWith('.json'));
-            if (searchIndexFile) {
-              console.log(`✅ Vocs 2 search index found at ${join(assetsDir, searchIndexFile)}; no legacy fix needed.`);
-              return;
-            }
-          } catch (assetsError) {
-            if ((assetsError as NodeJS.ErrnoException).code !== 'ENOENT') {
-              throw assetsError;
-            }
-          }
-        }
-      }
-      throw error;
-    }
-    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 });
@@ -83,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 57188631f5c..5738e633569 100644
--- a/docs/vocs/scripts/generate-redirects.ts
+++ b/docs/vocs/scripts/generate-redirects.ts
@@ -2,8 +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'
+
+const DIST_DIR = './docs/dist/public'
 
 function generateRedirectHtml(targetPath: string): string {
   return `<!DOCTYPE html>
diff --git a/docs/vocs/scripts/inject-cargo-docs.ts b/docs/vocs/scripts/inject-cargo-docs.ts
index 8ba1185880b..5a9d28b3195 100644
--- a/docs/vocs/scripts/inject-cargo-docs.ts
+++ b/docs/vocs/scripts/inject-cargo-docs.ts
@@ -2,7 +2,7 @@ import { promises as fs } from 'fs';
 import { glob } from 'glob';
 
 const CARGO_DOCS_PATH = '../../target/doc';
-const VOCS_DIST_ROOT = './docs/dist';
+const VOCS_DIST_ROOT = './docs/dist/public';
 const VOCS_DIST_PATH = `${VOCS_DIST_ROOT}/docs`;
 const BASE_PATH = '/docs';
 
@@ -44,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];
     
diff --git a/docs/vocs/vocs.config.ts b/docs/vocs/vocs.config.ts
index 712e91e03bb..7183f5c3f25 100644
--- a/docs/vocs/vocs.config.ts
+++ b/docs/vocs/vocs.config.ts
@@ -48,5 +48,35 @@ export default defineConfig({
   ],
   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
+          }
+        }
+      }
+    ]
   }
 })

From 71d3d87b63959b0d5bd376b72941048046566803 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?L=C3=A9a=20Narzis?=
 <78718413+lean-apple@users.noreply.github.com>
Date: Thu, 4 Jun 2026 13:36:00 +0200
Subject: [PATCH 299/335] chore(era): remove per-reader `FileReader` impls
 (#24854)

---
 crates/era/src/common/file_ops.rs | 2 ++
 crates/era/src/era/file.rs        | 9 ++-------
 crates/era/src/era1/file.rs       | 7 ++-----
 3 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/crates/era/src/common/file_ops.rs b/crates/era/src/common/file_ops.rs
index a460a203d25..98d82347c8f 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
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/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;

From 7479155709795fbcc625bf1fc166c945d24986d6 Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Thu, 4 Jun 2026 18:49:10 +0530
Subject: [PATCH 300/335] fix(engine): derive SSZ newPayload versioned hashes
 (#24850)

---
 crates/ethereum/node/Cargo.toml              |  2 +-
 crates/ethereum/node/src/engine_ssz_proxy.rs | 70 +++++++++++---------
 crates/ethereum/node/tests/e2e/eth.rs        |  5 +-
 3 files changed, 41 insertions(+), 36 deletions(-)

diff --git a/crates/ethereum/node/Cargo.toml b/crates/ethereum/node/Cargo.toml
index c86f08976bc..c910ed6455a 100644
--- a/crates/ethereum/node/Cargo.toml
+++ b/crates/ethereum/node/Cargo.toml
@@ -38,6 +38,7 @@ 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
@@ -76,7 +77,6 @@ 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
diff --git a/crates/ethereum/node/src/engine_ssz_proxy.rs b/crates/ethereum/node/src/engine_ssz_proxy.rs
index bfab692303f..c8f0c29fa6c 100644
--- a/crates/ethereum/node/src/engine_ssz_proxy.rs
+++ b/crates/ethereum/node/src/engine_ssz_proxy.rs
@@ -4,7 +4,11 @@
 //!
 //! [EIP-8178]: https://eips.ethereum.org/EIPS/eip-8178
 
-use alloy_eips::eip7685::{Requests, RequestsOrHash};
+use alloy_consensus::{Transaction, TxEnvelope};
+use alloy_eips::{
+    eip2718::Decodable2718,
+    eip7685::{Requests, RequestsOrHash},
+};
 use alloy_primitives::{Bytes, B256};
 use alloy_rpc_types_engine::{
     CancunPayloadFields, ExecutionData, ExecutionPayload, ExecutionPayloadSidecar,
@@ -15,6 +19,7 @@ use http_body_util::BodyExt;
 use jsonrpsee::server::{HttpBody, HttpRequest, HttpResponse};
 use reth_engine_primitives::ConsensusEngineHandle;
 use reth_ethereum_engine_primitives::EthEngineTypes;
+use ssz::Decode;
 use std::{
     future::Future,
     pin::Pin,
@@ -223,8 +228,6 @@ async fn handle_forkchoice_updated(
 }
 
 fn decode_new_payload_request(version: u8, body: &[u8]) -> Result<ExecutionData, &'static str> {
-    use ssz::Decode;
-
     match version {
         1 => {
             let execution_payload =
@@ -237,28 +240,26 @@ fn decode_new_payload_request(version: u8, body: &[u8]) -> Result<ExecutionData,
             Ok(ExecutionData::new(execution_payload.into(), ExecutionPayloadSidecar::none()))
         }
         3 => {
-            let (execution_payload, expected_blob_versioned_hashes, parent_beacon_block_root) =
-                <(ExecutionPayloadV3, Vec<B256>, B256)>::from_ssz_bytes(body)
-                    .map_err(|_| "invalid ssz")?;
+            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: expected_blob_versioned_hashes,
+                versioned_hashes,
             });
             Ok(ExecutionData::new(execution_payload.into(), sidecar))
         }
         4 => {
-            let (
-                execution_payload,
-                expected_blob_versioned_hashes,
-                parent_beacon_block_root,
-                execution_requests,
-            ) = <(ExecutionPayloadV3, Vec<B256>, B256, Vec<Bytes>)>::from_ssz_bytes(body)
-                .map_err(|_| "invalid ssz")?;
+            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: expected_blob_versioned_hashes,
-                },
+                CancunPayloadFields { parent_beacon_block_root, versioned_hashes },
                 PraguePayloadFields::new(RequestsOrHash::Requests(Requests::new(
                     execution_requests,
                 ))),
@@ -266,18 +267,14 @@ fn decode_new_payload_request(version: u8, body: &[u8]) -> Result<ExecutionData,
             Ok(ExecutionData::new(execution_payload.into(), sidecar))
         }
         5 => {
-            let (
-                execution_payload,
-                expected_blob_versioned_hashes,
-                parent_beacon_block_root,
-                execution_requests,
-            ) = <(ExecutionPayloadV4, Vec<B256>, B256, Vec<Bytes>)>::from_ssz_bytes(body)
-                .map_err(|_| "invalid ssz")?;
+            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: expected_blob_versioned_hashes,
-                },
+                CancunPayloadFields { parent_beacon_block_root, versioned_hashes },
                 PraguePayloadFields::new(RequestsOrHash::Requests(Requests::new(
                     execution_requests,
                 ))),
@@ -288,12 +285,23 @@ fn decode_new_payload_request(version: u8, body: &[u8]) -> Result<ExecutionData,
     }
 }
 
+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> {
-    use ssz::Decode;
-
     match version {
         1..=4 => {
             let (forkchoice_state, payload_attributes) =
diff --git a/crates/ethereum/node/tests/e2e/eth.rs b/crates/ethereum/node/tests/e2e/eth.rs
index 07e3ef4a154..617889350ba 100644
--- a/crates/ethereum/node/tests/e2e/eth.rs
+++ b/crates/ethereum/node/tests/e2e/eth.rs
@@ -330,10 +330,7 @@ async fn test_engine_ssz_proxy_can_mine_block() -> eyre::Result<()> {
         .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, Vec::<B256>::new(), B256::ZERO, envelope.execution_requests.take())
-                .as_ssz_bytes(),
-        )
+        .body((payload, B256::ZERO, envelope.execution_requests.take()).as_ssz_bytes())
         .send()
         .await?;
     assert_eq!(new_payload_response.status(), reqwest::StatusCode::OK);

From 9468154552cdd135b73bbf3afa2ee53a8b8df364 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?L=C3=A9a=20Narzis?=
 <78718413+lean-apple@users.noreply.github.com>
Date: Thu, 4 Jun 2026 16:03:58 +0200
Subject: [PATCH 301/335] feat(era): add ere file writer and reader (#24856)

---
 crates/era/src/ere/file.rs | 760 +++++++++++++++++++++++++++++++++++++
 crates/era/src/ere/mod.rs  |   1 +
 2 files changed, 761 insertions(+)
 create mode 100644 crates/era/src/ere/file.rs

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
index f488d7e09aa..2337ef29572 100644
--- a/crates/era/src/ere/mod.rs
+++ b/crates/era/src/ere/mod.rs
@@ -2,4 +2,5 @@
 //!
 //! See also <https://github.com/eth-clients/e2store-format-specs/blob/main/formats/ere.md>
 
+pub mod file;
 pub mod types;

From e9e8043fb8893563ecaa1ef1bf6b570daf927bce Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Fri, 5 Jun 2026 14:18:29 +0530
Subject: [PATCH 302/335] feat(engine-ssz): add supports for
 `engine_getBlobsVX` methods in ssz proxy (#24887)

---
 crates/ethereum/node/src/engine_ssz_proxy.rs | 266 ++++++++++++++++---
 crates/ethereum/node/tests/e2e/eth.rs        |  30 ++-
 2 files changed, 253 insertions(+), 43 deletions(-)

diff --git a/crates/ethereum/node/src/engine_ssz_proxy.rs b/crates/ethereum/node/src/engine_ssz_proxy.rs
index c8f0c29fa6c..53982ccab94 100644
--- a/crates/ethereum/node/src/engine_ssz_proxy.rs
+++ b/crates/ethereum/node/src/engine_ssz_proxy.rs
@@ -9,7 +9,7 @@ use alloy_eips::{
     eip2718::Decodable2718,
     eip7685::{Requests, RequestsOrHash},
 };
-use alloy_primitives::{Bytes, B256};
+use alloy_primitives::{Bytes, B128, B256};
 use alloy_rpc_types_engine::{
     CancunPayloadFields, ExecutionData, ExecutionPayload, ExecutionPayloadSidecar,
     ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3, ExecutionPayloadV4,
@@ -17,14 +17,18 @@ use alloy_rpc_types_engine::{
 };
 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_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};
@@ -37,16 +41,40 @@ 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;
+
 /// Shared handle used by [`EngineSszProxyLayer`].
-#[derive(Clone, Debug, Default)]
-pub struct EngineSszProxyHandle {
+pub struct EngineSszProxyHandle<ChainSpec> {
     engine: Arc<RwLock<Option<ConsensusEngineHandle<EthEngineTypes>>>>,
+    blob_store: Arc<RwLock<Option<Arc<dyn BlobStore>>>>,
+    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(),
+            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 EngineSszProxyHandle {
+impl<ChainSpec> EngineSszProxyHandle<ChainSpec> {
+    fn new(chain_spec: Arc<ChainSpec>) -> Self {
+        Self { engine: Default::default(), blob_store: Default::default(), 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);
@@ -55,24 +83,37 @@ impl EngineSszProxyHandle {
     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()
+    }
+
+    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, Default)]
-pub struct EngineSszProxyLayer {
-    handle: EngineSszProxyHandle,
+#[derive(Clone, Debug)]
+pub struct EngineSszProxyLayer<ChainSpec> {
+    handle: EngineSszProxyHandle<ChainSpec>,
 }
 
-impl EngineSszProxyLayer {
+impl<ChainSpec> EngineSszProxyLayer<ChainSpec> {
     /// Creates a new proxy layer and a handle for setting the engine after node launch.
-    pub fn new() -> (Self, EngineSszProxyHandle) {
-        let handle = EngineSszProxyHandle::default();
+    pub fn new(chain_spec: Arc<ChainSpec>) -> (Self, EngineSszProxyHandle<ChainSpec>) {
+        let handle = EngineSszProxyHandle::new(chain_spec);
         (Self { handle: handle.clone() }, handle)
     }
 }
 
-impl<S> Layer<S> for EngineSszProxyLayer {
-    type Service = EngineSszProxyService<S>;
+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() }
@@ -81,15 +122,16 @@ impl<S> Layer<S> for EngineSszProxyLayer {
 
 /// The service produced by [`EngineSszProxyLayer`].
 #[derive(Clone, Debug)]
-pub struct EngineSszProxyService<S> {
+pub struct EngineSszProxyService<S, ChainSpec> {
     inner: S,
-    handle: EngineSszProxyHandle,
+    handle: EngineSszProxyHandle<ChainSpec>,
 }
 
-impl<S> Service<HttpRequest> for EngineSszProxyService<S>
+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;
@@ -100,7 +142,7 @@ where
     }
 
     fn call(&mut self, request: HttpRequest) -> Self::Future {
-        if !request.uri().path().starts_with("/engine/v2/") {
+        if !request.uri().path().starts_with("/engine/") {
             let fut = self.inner.call(request);
             return Box::pin(fut)
         }
@@ -110,16 +152,19 @@ where
     }
 }
 
-async fn handle_engine_ssz_request(
-    handle: EngineSszProxyHandle,
+async fn handle_engine_ssz_request<ChainSpec>(
+    handle: EngineSszProxyHandle<ChainSpec>,
     request: HttpRequest,
-) -> HttpResponse {
+) -> HttpResponse
+where
+    ChainSpec: EthereumHardforks + Send + Sync + 'static,
+{
     if request.method().as_str() != "POST" {
         return text_response(STATUS_METHOD_NOT_ALLOWED, "method not allowed")
     }
 
     let path = request.uri().path().to_owned();
-    let Some((fork, resource)) = parse_engine_path(&path) else {
+    let Some(endpoint) = parse_engine_path(&path) else {
         return text_response(STATUS_NOT_FOUND, "unknown engine ssz endpoint")
     };
 
@@ -127,27 +172,46 @@ async fn handle_engine_ssz_request(
         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")
-    };
-
-    match resource {
-        "payloads" => handle_new_payload(engine, fork.payloads_version(), &body).await,
-        "forkchoice" => handle_forkchoice_updated(engine, fork.forkchoice_version(), &body).await,
-        _ => text_response(STATUS_NOT_FOUND, "unknown engine ssz endpoint"),
+    match endpoint {
+        EngineSszEndpoint::Payloads(fork) => {
+            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) => {
+            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) => handle_get_blobs(handle, version, &body).await,
     }
 }
 
-fn parse_engine_path(path: &str) -> Option<(EngineSszFork, &str)> {
+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(fork), Some(resource), None) => {
-            Some((fork.parse().ok()?, resource))
+        (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 {
+    Payloads(EngineSszFork),
+    Forkchoice(EngineSszFork),
+    Blobs(u8),
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum EngineSszFork {
     Paris,
@@ -195,6 +259,10 @@ impl std::str::FromStr for EngineSszFork {
     }
 }
 
+fn parse_method_version(version: &str) -> Option<u8> {
+    version.strip_prefix('v')?.parse().ok().filter(|version| (1..=4).contains(version))
+}
+
 async fn handle_new_payload(
     engine: ConsensusEngineHandle<EthEngineTypes>,
     version: u8,
@@ -227,6 +295,118 @@ async fn handle_forkchoice_updated(
     }
 }
 
+/// 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 => {
@@ -374,6 +554,10 @@ fn ssz_response<T: ssz::Encode>(value: T) -> HttpResponse {
         .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)
@@ -385,25 +569,29 @@ fn text_response(status: u16, body: impl Into<String>) -> HttpResponse {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use ssz::Encode;
 
     #[test]
     fn parses_fork_scoped_payload_endpoint() {
-        let (fork, resource) = parse_engine_path("/engine/v2/prague/payloads").unwrap();
-        assert_eq!(fork, EngineSszFork::Prague);
-        assert_eq!(resource, "payloads");
-        assert_eq!(fork.payloads_version(), 4);
+        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 (fork, resource) = parse_engine_path("/engine/v2/amsterdam/forkchoice").unwrap();
-        assert_eq!(fork, EngineSszFork::Amsterdam);
-        assert_eq!(resource, "forkchoice");
-        assert_eq!(fork.forkchoice_version(), 4);
+        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);
+    }
 }
diff --git a/crates/ethereum/node/tests/e2e/eth.rs b/crates/ethereum/node/tests/e2e/eth.rs
index 617889350ba..f784e98146f 100644
--- a/crates/ethereum/node/tests/e2e/eth.rs
+++ b/crates/ethereum/node/tests/e2e/eth.rs
@@ -1,5 +1,5 @@
 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::{
@@ -23,6 +23,7 @@ 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";
 
 #[tokio::test]
 async fn can_run_eth_node() -> eyre::Result<()> {
@@ -285,7 +286,7 @@ async fn test_engine_ssz_proxy_can_mine_block() -> eyre::Result<()> {
                 .with_http_api(reth_rpc_server_types::RpcModuleSelection::All),
         );
 
-    let (ssz_layer, ssz_handle) = EngineSszProxyLayer::new();
+    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>()
@@ -295,10 +296,11 @@ async fn test_engine_ssz_proxy_can_mine_block() -> eyre::Result<()> {
         .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 wallet = Wallet::default();
-    let raw_tx = TransactionTestContext::transfer_tx_bytes(1, wallet.inner).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,
@@ -358,6 +360,26 @@ async fn test_engine_ssz_proxy_can_mine_block() -> eyre::Result<()> {
         .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);
 

From 251930e17a8fe6bc8c66eb93a6b0123639006853 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Fri, 5 Jun 2026 11:03:16 +0200
Subject: [PATCH 303/335] fix: docs Mermaid rendering (#24892)

---
 docs/vocs/bun.lock     | 213 ++++++++++++++++++++++++++++++++++++++++-
 docs/vocs/package.json |   1 +
 2 files changed, 213 insertions(+), 1 deletion(-)

diff --git a/docs/vocs/bun.lock b/docs/vocs/bun.lock
index 199457a3262..9119416209d 100644
--- a/docs/vocs/bun.lock
+++ b/docs/vocs/bun.lock
@@ -5,6 +5,7 @@
     "": {
       "name": "vocs",
       "dependencies": {
+        "mermaid": "^11",
         "react": "19.2.4",
         "react-dom": "19.2.4",
         "react-server-dom-webpack": "19.2.4",
@@ -61,6 +62,10 @@
 
     "@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=="],
 
+    "@braintree/sanitize-url": ["@braintree/sanitize-url@7.1.2", "", {}, "sha512-jigsZK+sMF/cuiB7sERuo9V7N9jx+dhmHHnQyDSVdpZwVutaBu7WvNYqMDLSgFgfB30n452TP3vjDAvFC973mA=="],
+
+    "@chevrotain/types": ["@chevrotain/types@11.1.2", "", {}, "sha512-U+HFai5+zmJCkK86QsaJtoITlboZHBqrVketcO2ROv865xfCMSFpELQoz1GkX5GzME8pTa+3kbKrZHQtI0gdbw=="],
+
     "@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=="],
 
     "@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=="],
@@ -197,6 +202,8 @@
 
     "@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=="],
 
+    "@mermaid-js/parser": ["@mermaid-js/parser@1.1.1", "", { "dependencies": { "@chevrotain/types": "~11.1.1" } }, "sha512-VuHdsYMK1bT6X2JbcAaWAhugTRvRBRyuZgd+c22swUeI9g/ntaxF7CY7dYarhZovofCbUNO0G7JesfmNtjYOCw=="],
+
     "@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=="],
 
     "@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=="],
@@ -389,12 +396,76 @@
 
     "@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.2", "", {}, "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw=="],
+
+    "@types/d3-axis": ["@types/d3-axis@3.0.6", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-pYeijfZuBd87T0hGn0FO1vQ/cgLk6E1ALJjfkC0oJ8cbwkZl3TpgS8bVBLZN+2jjGgg38epgxb2zmoGtSfvgMw=="],
+
+    "@types/d3-brush": ["@types/d3-brush@3.0.6", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-nH60IZNNxEcrh6L1ZSMNA28rj27ut/2ZmI3r96Zd+1jrZD++zD3LsMIjWlvg4AYrHn/Pqz4CF3veCxGjtbqt7A=="],
+
+    "@types/d3-chord": ["@types/d3-chord@3.0.6", "", {}, "sha512-LFYWWd8nwfwEmTZG9PfQxd17HbNPksHBiJHaKuY1XeqscXacsS2tyoo6OdRsjf+NQYeB6XrNL3a25E3gH69lcg=="],
+
+    "@types/d3-color": ["@types/d3-color@3.1.3", "", {}, "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A=="],
+
+    "@types/d3-contour": ["@types/d3-contour@3.0.6", "", { "dependencies": { "@types/d3-array": "*", "@types/geojson": "*" } }, "sha512-BjzLgXGnCWjUSYGfH1cpdo41/hgdWETu4YxpezoztawmqsvCeep+8QGfiY6YbDvfgHz/DkjeIkkZVJavB4a3rg=="],
+
+    "@types/d3-delaunay": ["@types/d3-delaunay@6.0.4", "", {}, "sha512-ZMaSKu4THYCU6sV64Lhg6qjf1orxBthaC161plr5KuPHo3CNm8DTHiLw/5Eq2b6TsNP0W0iJrUOFscY6Q450Hw=="],
+
+    "@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=="],
+
+    "@types/d3-dsv": ["@types/d3-dsv@3.0.7", "", {}, "sha512-n6QBF9/+XASqcKK6waudgL0pf/S5XHPPI8APyMLLUHd8NqouBGLsU8MgtO7NINGtPBtk9Kko/W4ea0oAspwh9g=="],
+
+    "@types/d3-ease": ["@types/d3-ease@3.0.2", "", {}, "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA=="],
+
+    "@types/d3-fetch": ["@types/d3-fetch@3.0.7", "", { "dependencies": { "@types/d3-dsv": "*" } }, "sha512-fTAfNmxSb9SOWNB9IoG5c8Hg6R+AzUHDRlsXsDZsNp6sxAEOP0tkP3gKkNSO/qmHPoBFTxNrjDprVHDQDvo5aA=="],
+
+    "@types/d3-force": ["@types/d3-force@3.0.10", "", {}, "sha512-ZYeSaCF3p73RdOKcjj+swRlZfnYpK1EbaDiYICEEp5Q6sUiqFaFQ9qgoshp5CzIyyb/yD09kD9o2zEltCexlgw=="],
+
+    "@types/d3-format": ["@types/d3-format@3.0.4", "", {}, "sha512-fALi2aI6shfg7vM5KiR1wNJnZ7r6UuggVqtDA+xiEdPZQwy/trcQaHnwShLuLdta2rTymCNpxYTiMZX/e09F4g=="],
+
+    "@types/d3-geo": ["@types/d3-geo@3.1.0", "", { "dependencies": { "@types/geojson": "*" } }, "sha512-856sckF0oP/diXtS4jNsiQw/UuK5fQG8l/a9VVLeSouf1/PPbBE1i1W852zVwKwYCBkFJJB7nCFTbk6UMEXBOQ=="],
+
+    "@types/d3-hierarchy": ["@types/d3-hierarchy@3.1.7", "", {}, "sha512-tJFtNoYBtRtkNysX1Xq4sxtjK8YgoWUNpIiUee0/jHGRwqvzYxkq0hGVbbOGSz+JgFxxRu4K8nb3YpG3CMARtg=="],
+
+    "@types/d3-interpolate": ["@types/d3-interpolate@3.0.4", "", { "dependencies": { "@types/d3-color": "*" } }, "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA=="],
+
+    "@types/d3-path": ["@types/d3-path@3.1.1", "", {}, "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg=="],
+
+    "@types/d3-polygon": ["@types/d3-polygon@3.0.2", "", {}, "sha512-ZuWOtMaHCkN9xoeEMr1ubW2nGWsp4nIql+OPQRstu4ypeZ+zk3YKqQT0CXVe/PYqrKpZAi+J9mTs05TKwjXSRA=="],
+
+    "@types/d3-quadtree": ["@types/d3-quadtree@3.0.6", "", {}, "sha512-oUzyO1/Zm6rsxKRHA1vH0NEDG58HrT5icx/azi9MF1TWdtttWl0UIUsjEQBBh+SIkrpd21ZjEv7ptxWys1ncsg=="],
+
+    "@types/d3-random": ["@types/d3-random@3.0.3", "", {}, "sha512-Imagg1vJ3y76Y2ea0871wpabqp613+8/r0mCLEBfdtqC7xMSfj9idOnmBYyMoULfHePJyxMAw3nWhJxzc+LFwQ=="],
+
+    "@types/d3-scale": ["@types/d3-scale@4.0.9", "", { "dependencies": { "@types/d3-time": "*" } }, "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw=="],
+
+    "@types/d3-scale-chromatic": ["@types/d3-scale-chromatic@3.1.0", "", {}, "sha512-iWMJgwkK7yTRmWqRB5plb1kadXyQ5Sj8V/zYlFGMUBbIPKQScw+Dku9cAAMgJG+z5GYDoMjWGLVOvjghDEFnKQ=="],
+
+    "@types/d3-selection": ["@types/d3-selection@3.0.11", "", {}, "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w=="],
+
+    "@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=="],
+
+    "@types/d3-time-format": ["@types/d3-time-format@4.0.3", "", {}, "sha512-5xg9rC+wWL8kdDj153qZcsJ0FWiFt0J5RB6LYUNZjwSnesfblqrI/bJ1wBdJ8OQfncgbJG5+2F+qfqnqyzYxyg=="],
+
+    "@types/d3-timer": ["@types/d3-timer@3.0.2", "", {}, "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw=="],
+
+    "@types/d3-transition": ["@types/d3-transition@3.0.9", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg=="],
+
+    "@types/d3-zoom": ["@types/d3-zoom@3.0.8", "", { "dependencies": { "@types/d3-interpolate": "*", "@types/d3-selection": "*" } }, "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw=="],
+
     "@types/debug": ["@types/debug@4.1.12", "", { "dependencies": { "@types/ms": "*" } }, "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ=="],
 
     "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="],
 
     "@types/estree-jsx": ["@types/estree-jsx@1.0.5", "", { "dependencies": { "@types/estree": "*" } }, "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg=="],
 
+    "@types/geojson": ["@types/geojson@7946.0.16", "", {}, "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg=="],
+
     "@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=="],
@@ -409,12 +480,16 @@
 
     "@types/react": ["@types/react@19.2.14", "", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w=="],
 
+    "@types/trusted-types": ["@types/trusted-types@2.0.7", "", {}, "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw=="],
+
     "@types/unist": ["@types/unist@3.0.3", "", {}, "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q=="],
 
     "@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=="],
 
+    "@upsetjs/venn.js": ["@upsetjs/venn.js@2.0.0", "", { "optionalDependencies": { "d3-selection": "^3.0.0", "d3-transition": "^3.0.1" } }, "sha512-WbBhLrooyePuQ1VZxrJjtLvTc4NVfpOyKx0sKqioq9bX1C1m7Jgykkn8gLrtwumBioXIqam8DLxp88Adbue6Hw=="],
+
     "@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=="],
 
     "@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=="],
@@ -553,6 +628,8 @@
 
     "cors": ["cors@2.8.6", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw=="],
 
+    "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=="],
 
     "crelt": ["crelt@1.0.6", "", {}, "sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g=="],
@@ -563,12 +640,88 @@
 
     "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=="],
+
+    "d3-axis": ["d3-axis@3.0.0", "", {}, "sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw=="],
+
+    "d3-brush": ["d3-brush@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-drag": "2 - 3", "d3-interpolate": "1 - 3", "d3-selection": "3", "d3-transition": "3" } }, "sha512-ALnjWlVYkXsVIGlOsuWH1+3udkYFI48Ljihfnh8FZPF2QS9o+PzGLBslO0PjzVoHLZ2KCVgAM8NVkXPJB2aNnQ=="],
+
+    "d3-chord": ["d3-chord@3.0.1", "", { "dependencies": { "d3-path": "1 - 3" } }, "sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g=="],
+
+    "d3-color": ["d3-color@3.1.0", "", {}, "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA=="],
+
+    "d3-contour": ["d3-contour@4.0.2", "", { "dependencies": { "d3-array": "^3.2.0" } }, "sha512-4EzFTRIikzs47RGmdxbeUvLWtGedDUNkTcmzoeyg4sP/dvCexO47AaQL7VKy/gul85TOxw+IBgA8US2xwbToNA=="],
+
+    "d3-delaunay": ["d3-delaunay@6.0.4", "", { "dependencies": { "delaunator": "5" } }, "sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A=="],
+
+    "d3-dispatch": ["d3-dispatch@3.0.1", "", {}, "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg=="],
+
+    "d3-drag": ["d3-drag@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-selection": "3" } }, "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg=="],
+
+    "d3-dsv": ["d3-dsv@3.0.1", "", { "dependencies": { "commander": "7", "iconv-lite": "0.6", "rw": "1" }, "bin": { "csv2json": "bin/dsv2json.js", "csv2tsv": "bin/dsv2dsv.js", "dsv2dsv": "bin/dsv2dsv.js", "dsv2json": "bin/dsv2json.js", "json2csv": "bin/json2dsv.js", "json2dsv": "bin/json2dsv.js", "json2tsv": "bin/json2dsv.js", "tsv2csv": "bin/dsv2dsv.js", "tsv2json": "bin/dsv2json.js" } }, "sha512-UG6OvdI5afDIFP9w4G0mNq50dSOsXHJaRE8arAS5o9ApWnIElp8GZw1Dun8vP8OyHOZ/QJUKUJwxiiCCnUwm+Q=="],
+
+    "d3-ease": ["d3-ease@3.0.1", "", {}, "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w=="],
+
+    "d3-fetch": ["d3-fetch@3.0.1", "", { "dependencies": { "d3-dsv": "1 - 3" } }, "sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw=="],
+
+    "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.2", "", {}, "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg=="],
+
+    "d3-geo": ["d3-geo@3.1.1", "", { "dependencies": { "d3-array": "2.5.0 - 3" } }, "sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q=="],
+
+    "d3-hierarchy": ["d3-hierarchy@3.1.2", "", {}, "sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA=="],
+
+    "d3-interpolate": ["d3-interpolate@3.0.1", "", { "dependencies": { "d3-color": "1 - 3" } }, "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g=="],
+
+    "d3-path": ["d3-path@3.1.0", "", {}, "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ=="],
+
+    "d3-polygon": ["d3-polygon@3.0.1", "", {}, "sha512-3vbA7vXYwfe1SYhED++fPUQlWSYTTGmFmQiany/gdbiWgU/iEyQzyymwL9SkJjFFuCS4902BSzewVGsHHmHtXg=="],
+
+    "d3-quadtree": ["d3-quadtree@3.0.1", "", {}, "sha512-04xDrxQTDTCFwP5H6hRhsRcb9xxv2RzkcsygFzmkSIOJy3PeRJP7sNk3VRIbKXcog561P9oU0/rVH6vDROAgUw=="],
+
+    "d3-random": ["d3-random@3.0.1", "", {}, "sha512-FXMe9GfxTxqd5D6jFsQ+DJ8BJS4E/fT5mqqdjovykEB2oFbTMDVdg1MGFxfQW+FBOGoB++k8swBrgwSHT1cUXQ=="],
+
+    "d3-sankey": ["d3-sankey@0.12.3", "", { "dependencies": { "d3-array": "1 - 2", "d3-shape": "^1.2.0" } }, "sha512-nQhsBRmM19Ax5xEIPLMY9ZmJ/cDvd1BG3UVvt5h3WRxKg5zGRbvnteTyWAbzeSvlh3tW7ZEmq4VwR5mB3tutmQ=="],
+
+    "d3-scale": ["d3-scale@4.0.2", "", { "dependencies": { "d3-array": "2.10.0 - 3", "d3-format": "1 - 3", "d3-interpolate": "1.2.0 - 3", "d3-time": "2.1.1 - 3", "d3-time-format": "2 - 4" } }, "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ=="],
+
+    "d3-scale-chromatic": ["d3-scale-chromatic@3.1.0", "", { "dependencies": { "d3-color": "1 - 3", "d3-interpolate": "1 - 3" } }, "sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ=="],
+
+    "d3-selection": ["d3-selection@3.0.0", "", {}, "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ=="],
+
+    "d3-shape": ["d3-shape@3.2.0", "", { "dependencies": { "d3-path": "^3.1.0" } }, "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA=="],
+
+    "d3-time": ["d3-time@3.1.0", "", { "dependencies": { "d3-array": "2 - 3" } }, "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q=="],
+
+    "d3-time-format": ["d3-time-format@4.1.0", "", { "dependencies": { "d3-time": "1 - 3" } }, "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg=="],
+
+    "d3-timer": ["d3-timer@3.0.1", "", {}, "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA=="],
+
+    "d3-transition": ["d3-transition@3.0.1", "", { "dependencies": { "d3-color": "1 - 3", "d3-dispatch": "1 - 3", "d3-ease": "1 - 3", "d3-interpolate": "1 - 3", "d3-timer": "1 - 3" }, "peerDependencies": { "d3-selection": "2 - 3" } }, "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w=="],
+
+    "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.14", "", { "dependencies": { "d3": "^7.9.0", "lodash-es": "^4.17.21" } }, "sha512-P4rFMVq9ESWqmOgK+dlXvOtLwYg0i7u0HBGJER0LZDJT2VHIPAMZ/riPxqJceWMStH5+E61QxFra9kIS3AqdMg=="],
+
+    "dayjs": ["dayjs@1.11.21", "", {}, "sha512-98IT+HOahAisibz/yjKbzuOBwYcjJ7BCLPzARyHiyEBmRz4fatF+KPJszEHXsGYjUG234aH/cOjW1wwTbKUZlA=="],
+
     "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=="],
 
+    "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=="],
@@ -577,6 +730,8 @@
 
     "devlop": ["devlop@1.1.0", "", { "dependencies": { "dequal": "^2.0.0" } }, "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA=="],
 
+    "dompurify": ["dompurify@3.4.8", "", { "optionalDependencies": { "@types/trusted-types": "^2.0.7" } }, "sha512-yb1cEmaOum7wFvOCSQxyfgVlv5D47Rc30iZWoMpbDIWTnJ6grDDQyu2KFJzB2k7u0pMuJcQ1zphH//fFnw2tjQ=="],
+
     "dot-case": ["dot-case@3.0.4", "", { "dependencies": { "no-case": "^3.0.4", "tslib": "^2.0.3" } }, "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w=="],
 
     "dotenv": ["dotenv@17.4.2", "", {}, "sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw=="],
@@ -607,6 +762,8 @@
 
     "es-object-atoms": ["es-object-atoms@1.1.2", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw=="],
 
+    "es-toolkit": ["es-toolkit@1.47.0", "", {}, "sha512-n1GuoD0WEQZMBk5tttoZSqwgyLx01oqa5XsBmCHwPyNe1S9jPBEmtR2pSgp2kJuWE3ciFZ6yRHmY4pM4C3OOkw=="],
+
     "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=="],
@@ -709,6 +866,8 @@
 
     "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=="],
+
     "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
 
     "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
@@ -735,7 +894,7 @@
 
     "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=="],
 
-    "iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
+    "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=="],
 
@@ -749,6 +908,8 @@
 
     "inline-style-parser": ["inline-style-parser@0.2.4", "", {}, "sha512-0aO8FkhNZlj/ZIbNi7Lxxr12obT7cL1moPfE4tg1LkX7LlLfC6DeX4l2ZEud1ukP9jNQyNnfzQVqwbwmAATY4Q=="],
 
+    "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=="],
@@ -795,6 +956,12 @@
 
     "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="],
 
+    "katex": ["katex@0.16.47", "", { "dependencies": { "commander": "^8.3.0" }, "bin": { "katex": "cli.js" } }, "sha512-Eeo8Ys1doU1z+x8AZsPpQu+p/QcZBI5PeOo7QGQdy2x2m0MU/hYagBbGOmXwr5KVbEfVuWv9LpnQWeehogurjg=="],
+
+    "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.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.32.0", "", { "os": "android", "cpu": "arm64" }, "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg=="],
@@ -825,6 +992,8 @@
 
     "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=="],
 
+    "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=="],
@@ -839,6 +1008,8 @@
 
     "markdown-table": ["markdown-table@3.0.4", "", {}, "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw=="],
 
+    "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=="],
@@ -883,6 +1054,8 @@
 
     "merge-stream": ["merge-stream@2.0.0", "", {}, "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w=="],
 
+    "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=="],
@@ -1013,6 +1186,8 @@
 
     "parseurl": ["parseurl@1.3.3", "", {}, "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="],
 
+    "path-data-parser": ["path-data-parser@0.1.0", "", {}, "sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+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=="],
@@ -1033,6 +1208,10 @@
 
     "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.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@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
@@ -1105,14 +1284,20 @@
 
     "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="],
 
+    "robust-predicates": ["robust-predicates@3.0.3", "", {}, "sha512-NS3levdsRIUOmiJ8FZWCP7LG3QpJyrs/TE0Zpf1yvZu8cAJJ6QMW92H1c7kWpdIHo8RvmLxN/o2JXTKHp74lUA=="],
+
     "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=="],
+
     "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=="],
 
     "rsc-html-stream": ["rsc-html-stream@0.0.7", "", {}, "sha512-v9+fuY7usTgvXdNl8JmfXCvSsQbq2YMd60kOeeMIqCJFZ69fViuIxztHei7v5mlMMa2h3SqS+v44Gu9i9xANZA=="],
 
+    "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=="],
@@ -1181,6 +1366,8 @@
 
     "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.4.0", "", {}, "sha512-5Z9ZpRzfuH6l/UAvCPAPUo3665Nk2wLaZU3x+TLHKVzIz33+sbJqbtrYoC3KD4/uVOr2Zp+L0LySezP9OHV9yA=="],
+
     "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=="],
 
     "supports-color": ["supports-color@8.1.1", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q=="],
@@ -1213,6 +1400,8 @@
 
     "trough": ["trough@2.2.0", "", {}, "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw=="],
 
+    "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=="],
@@ -1263,6 +1452,8 @@
 
     "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@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=="],
@@ -1345,6 +1536,16 @@
 
     "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=="],
 
+    "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=="],
+
+    "d3-dsv/commander": ["commander@7.2.0", "", {}, "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw=="],
+
+    "d3-sankey/d3-array": ["d3-array@2.12.1", "", { "dependencies": { "internmap": "^1.0.0" } }, "sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ=="],
+
+    "d3-sankey/d3-shape": ["d3-shape@1.3.7", "", { "dependencies": { "d3-path": "1" } }, "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw=="],
+
     "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=="],
@@ -1353,6 +1554,8 @@
 
     "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=="],
 
+    "katex/commander": ["commander@8.3.0", "", {}, "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww=="],
+
     "micromark/debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
 
     "micromark-extension-mdxjs/acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
@@ -1365,6 +1568,8 @@
 
     "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=="],
 
+    "raw-body/iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
+
     "react-router/cookie": ["cookie@1.0.2", "", {}, "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA=="],
 
     "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=="],
@@ -1411,6 +1616,12 @@
 
     "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-array/internmap": ["internmap@1.0.1", "", {}, "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw=="],
+
+    "d3-sankey/d3-shape/d3-path": ["d3-path@1.0.9", "", {}, "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg=="],
+
     "mlly/pkg-types/confbox": ["confbox@0.1.8", "", {}, "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w=="],
 
     "raw-body/http-errors/statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
diff --git a/docs/vocs/package.json b/docs/vocs/package.json
index 3575eb2ba30..ba604455cb4 100644
--- a/docs/vocs/package.json
+++ b/docs/vocs/package.json
@@ -13,6 +13,7 @@
     "inject-cargo-docs": "bun scripts/inject-cargo-docs.ts"
   },
   "dependencies": {
+    "mermaid": "^11",
     "react": "19.2.4",
     "react-dom": "19.2.4",
     "react-server-dom-webpack": "19.2.4",

From 6ca276af5b99f0baf063568a24c07dbbfb366904 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?L=C3=A9a=20Narzis?=
 <78718413+lean-apple@users.noreply.github.com>
Date: Fri, 5 Jun 2026 14:23:34 +0200
Subject: [PATCH 304/335] chore(era): reorg tests files folders (#24898)

---
 crates/era-downloader/tests/it/main.rs         | 18 +++++++++---------
 .../files}/mainnet-00000-4b363db9.era          |  0
 .../files}/mainnet-00001-40cf2f3c.era          |  0
 .../res/{era-nimbus.html => era/nimbus.html}   |  0
 .../tests/res/{ => era1}/checksums.txt         |  0
 .../tests/res/{ => era1}/ethportal.html        |  0
 .../files}/mainnet-00000-5ec1ffb8.era1         |  0
 .../files}/mainnet-00001-a5364e9a.era1         |  0
 .../res/{era1-ithaca.html => era1/ithaca.html} |  0
 .../res/{era1-nimbus.html => era1/nimbus.html} |  0
 10 files changed, 9 insertions(+), 9 deletions(-)
 rename crates/era-downloader/tests/res/{era-files => era/files}/mainnet-00000-4b363db9.era (100%)
 rename crates/era-downloader/tests/res/{era-files => era/files}/mainnet-00001-40cf2f3c.era (100%)
 rename crates/era-downloader/tests/res/{era-nimbus.html => era/nimbus.html} (100%)
 rename crates/era-downloader/tests/res/{ => era1}/checksums.txt (100%)
 rename crates/era-downloader/tests/res/{ => era1}/ethportal.html (100%)
 rename crates/era-downloader/tests/res/{era1-files => era1/files}/mainnet-00000-5ec1ffb8.era1 (100%)
 rename crates/era-downloader/tests/res/{era1-files => era1/files}/mainnet-00001-a5364e9a.era1 (100%)
 rename crates/era-downloader/tests/res/{era1-ithaca.html => era1/ithaca.html} (100%)
 rename crates/era-downloader/tests/res/{era1-nimbus.html => era1/nimbus.html} (100%)

diff --git a/crates/era-downloader/tests/it/main.rs b/crates/era-downloader/tests/it/main.rs
index fb5f33ab711..39ff987bfb3 100644
--- a/crates/era-downloader/tests/it/main.rs
+++ b/crates/era-downloader/tests/it/main.rs
@@ -13,20 +13,20 @@ 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");
 
 /// An HTTP client pre-programmed with canned answers to received calls.
 /// Panics if it receives an unknown call.
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

From 87fc4cf4355ddbc59220f691a46d9f9d354adfa0 Mon Sep 17 00:00:00 2001
From: DaniPopes <57450786+DaniPopes@users.noreply.github.com>
Date: Fri, 5 Jun 2026 14:33:46 +0200
Subject: [PATCH 305/335] feat(bench): add chrome trace profiles (#24879)

Co-authored-by: Derek <256792747+decofe@users.noreply.github.com>
---
 .github/scripts/bench-job-summary.js  |  18 +++-
 .github/scripts/bench-slack-notify.js |  50 ++++++++++-
 .github/scripts/bench-txgen-run.sh    |  17 +++-
 .github/scripts/bench-utils.js        |  11 ++-
 .github/workflows/bench.yml           | 125 ++++++++++++++++++++------
 Cargo.lock                            |  12 +++
 Cargo.toml                            |   1 +
 crates/ethereum/cli/src/app.rs        |   6 +-
 crates/ethereum/cli/src/interface.rs  |  11 ++-
 crates/node/core/src/args/log.rs      |  60 +++++++++++--
 crates/tracing/Cargo.toml             |   2 +
 crates/tracing/src/layers.rs          |  46 ++++++++++
 crates/tracing/src/lib.rs             |  34 ++++---
 crates/tracing/src/test_tracer.rs     |   7 +-
 14 files changed, 335 insertions(+), 65 deletions(-)

diff --git a/.github/scripts/bench-job-summary.js b/.github/scripts/bench-job-summary.js
index 0754145f638..6187aad008f 100644
--- a/.github/scripts/bench-job-summary.js
+++ b/.github/scripts/bench-job-summary.js
@@ -7,6 +7,7 @@
 //   BENCH_CORES          – CPU core limit (0 = all)
 //   BENCH_WARMUP_BLOCKS  – Number of warmup blocks
 //   BENCH_SAMPLY         – 'true' if samply profiling was enabled
+//   BENCH_TRACING_CHROME – 'true' if Chrome trace recording was enabled
 //   BENCH_RUN_PAIRS      – Number of configured benchmark run pairs
 //
 // Usage from actions/github-script:
@@ -14,7 +15,15 @@
 //   await jobSummary({ core, context, chartSha, grafanaUrl, logsUrl, tracesUrl, runId });
 
 const fs = require('fs');
-const { verdict, loadSamplyUrls, blocksLabel, metricRows, waitTimeRows, fmtChange } = require('./bench-utils');
+const {
+  verdict,
+  loadSamplyUrls,
+  loadTracingChromeUrls,
+  blocksLabel,
+  metricRows,
+  waitTimeRows,
+  fmtChange,
+} = require('./bench-utils');
 
 function fmtMetricValue(v) {
   if (v === null || v === undefined || !Number.isFinite(v)) return 'n/a';
@@ -126,6 +135,13 @@ module.exports = async function ({ core, context, chartSha, grafanaUrl, logsUrl,
     md += `### Samply Profiles\n\n${samplyLinks.join('\n')}\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})`);
diff --git a/.github/scripts/bench-slack-notify.js b/.github/scripts/bench-slack-notify.js
index 40726dddaf8..e71a9b8aa68 100644
--- a/.github/scripts/bench-slack-notify.js
+++ b/.github/scripts/bench-slack-notify.js
@@ -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, isWin, loadSamplyUrls, blocksLabel, metricRows } = require('./bench-utils');
+const {
+  fmtChange,
+  fmtMs,
+  verdict,
+  isWin,
+  loadSamplyUrls,
+  loadTracingChromeUrls,
+  blocksLabel,
+  metricRows,
+} = require('./bench-utils');
 
 const SLACK_API = 'https://slack.com/api/chat.postMessage';
 
@@ -72,6 +82,16 @@ function profileLinks(samplyUrls, prefix) {
     });
 }
 
+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:',
@@ -94,6 +114,7 @@ function benchConfigLine() {
   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);
@@ -106,7 +127,16 @@ function benchConfigLine() {
   return parts.length ? `*Workflow:* ${parts.join(' ')}` : '';
 }
 
-function buildSuccessBlocks({ summary, prNumber, actor, actorSlackId, jobUrl, repo, samplyUrls }) {
+function buildSuccessBlocks({
+  summary,
+  prNumber,
+  actor,
+  actorSlackId,
+  jobUrl,
+  repo,
+  samplyUrls,
+  tracingChromeUrls,
+}) {
   const { emoji, label } = verdict(summary.changes);
   const headerEmoji = SLACK_VERDICT[emoji] || emoji;
 
@@ -125,10 +155,14 @@ function buildSuccessBlocks({ summary, prNumber, actor, actorSlackId, jobUrl, re
   let baselineLine = `*Baseline:* ${baselineLink}`;
   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 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();
@@ -254,11 +288,21 @@ 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 = 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}`;
 
   const slackMode = process.env.BENCH_SLACK || 'always';
diff --git a/.github/scripts/bench-txgen-run.sh b/.github/scripts/bench-txgen-run.sh
index 9166cc945ee..66877b319b0 100755
--- a/.github/scripts/bench-txgen-run.sh
+++ b/.github/scripts/bench-txgen-run.sh
@@ -11,7 +11,8 @@
 #               BENCH_WORK_DIR, BENCH_WAIT_TIME, BENCH_BASELINE_ARGS,
 #               BENCH_FEATURE_ARGS, BENCH_OTLP_TRACES_ENDPOINT,
 #               BENCH_OTLP_LOGS_ENDPOINT, BENCH_OTLP_DISABLED,
-#               BENCH_TRACY, BENCH_TRACY_FILTER, BENCH_TRACY_SAMPLING_HZ,
+#               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
@@ -290,6 +291,20 @@ echo "Memory limit: $(( MEM_LIMIT / 1024 / 1024 ))MB (95% of $(( TOTAL_MEM_KB /
 
 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" \
diff --git a/.github/scripts/bench-utils.js b/.github/scripts/bench-utils.js
index 9f440fa5843..dc98bfb20be 100644
--- a/.github/scripts/bench-utils.js
+++ b/.github/scripts/bench-utils.js
@@ -42,6 +42,14 @@ function isWin(changes) {
 }
 
 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 = {};
   let runs = [];
   try {
@@ -53,7 +61,7 @@ function loadSamplyUrls(workDir) {
   }
   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 {}
   }
@@ -132,6 +140,7 @@ module.exports = {
   verdict,
   isWin,
   loadSamplyUrls,
+  loadTracingChromeUrls,
   blocksLabel,
   metricRows,
   waitTimeRows,
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 03fd7e991ab..1c25f2e7d10 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -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
@@ -121,6 +126,7 @@ 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 }}
       cores: ${{ steps.args.outputs.cores }}
       big-blocks: ${{ steps.args.outputs.big-blocks }}
@@ -180,8 +186,8 @@ 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|100M|2G]] [bal=true|false|feature|baseline] [warmup=N] [baseline=REF] [feature=REF] [samply] [slack=always|on-win|on-error|never] [cores=N] [run-pairs=N] [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] [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;
@@ -214,6 +220,7 @@ jobs:
               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';
               const parsedBigBlocks = parseBigBlocks('${{ github.event.inputs.big_blocks }}');
@@ -251,11 +258,11 @@ jobs:
               const body = context.payload.comment.body.trim();
               const intArgs = new Set(['warmup', 'cores', 'blocks', 'run-pairs']);
               const refArgs = new Set(['baseline', 'feature']);
-              const boolArgs = new Set(['samply', 'otlp']);
+              const boolArgs = new Set(['samply', 'tracing-chrome', 'otlp']);
               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: '', warmup: '', baseline: '', feature: '', samply: 'false', slack: 'always', 'big-blocks': 'false', bal: 'false', cores: '0', 'run-pairs': '', 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', 'wait-time': '', 'baseline-args': '', 'feature-args': '' };
               const unknown = [];
               const invalid = [];
               const args = body.replace(/^(?:@decofe|derek) bench\s*/, '');
@@ -347,6 +354,7 @@ jobs:
               baseline = defaults.baseline;
               feature = defaults.feature;
               samply = defaults.samply;
+              tracingChrome = defaults['tracing-chrome'];
               var slack = defaults.slack;
               cores = defaults.cores;
               const parsedBigBlocks = parseBigBlocks(defaults['big-blocks']);
@@ -422,6 +430,7 @@ 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);
@@ -491,10 +500,12 @@ 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 = bal !== 'false' ? `, BAL: \`${bal}\`` : '';
             const cores = '${{ steps.args.outputs.cores }}';
@@ -511,7 +522,7 @@ jobs:
             const featureArgsVal = '${{ steps.args.outputs.feature-args }}';
             const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
             const blocksDesc = bigBlocks ? `${blocks} big blocks, ${warmup} warmup blocks` : `${blocks} blocks, ${warmup} warmup blocks`;
-            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${runPairsNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
+            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,
@@ -536,10 +547,12 @@ 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 = bal !== 'false' ? `, BAL: \`${bal}\`` : '';
             const cores = '${{ steps.args.outputs.cores }}';
@@ -556,7 +569,7 @@ jobs:
             const featureArgsVal = '${{ steps.args.outputs.feature-args }}';
             const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
             const blocksDesc = bigBlocks ? `${blocks} big blocks, ${warmup} warmup blocks` : `${blocks} blocks, ${warmup} warmup blocks`;
-            const config = `**Config:** ${blocksDesc}, baseline: \`${baseline}\`, feature: \`${feature}\`${samplyNote}${slackNote}${balNote}${coresNote}${runPairsNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`;
+            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;
@@ -626,6 +639,7 @@ jobs:
       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 }}
@@ -699,10 +713,12 @@ jobs:
             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 = bal !== 'false' ? `, BAL: \`${bal}\`` : '';
             const cores = process.env.BENCH_CORES || '0';
@@ -719,7 +735,7 @@ jobs:
             const featureArgsVal = process.env.BENCH_FEATURE_ARGS || '';
             const featureArgsNote = featureArgsVal ? `, feature-args: \`${featureArgsVal}\`` : '';
             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}${slackNote}${balNote}${coresNote}${runPairsNote}${otlpNote}${waitTimeNote}${baselineArgsNote}${featureArgsNote}`);
+            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({
@@ -1045,6 +1061,7 @@ jobs:
             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")
@@ -1424,7 +1441,7 @@ jobs:
           name: bench-results
           path: ${{ env.BENCH_WORK_DIR }}
 
-      - name: Push charts
+      - name: Push benchmark artifacts
         id: push-charts
         if: success()
         env:
@@ -1436,7 +1453,8 @@ 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}"
@@ -1446,30 +1464,69 @@ jobs:
 
           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}" 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
 
-          echo "sha=$(git -C "${TMP_DIR}" rev-parse HEAD)" >> "$GITHUB_OUTPUT"
+              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=${PUSH_SHA}" >> "$GITHUB_OUTPUT"
           rm -rf "${TMP_DIR}"
 
       - name: Compare & comment
@@ -1520,6 +1577,18 @@ jobs:
               }
             }
 
+            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)
             try {
               const errors = fs.readFileSync(process.env.BENCH_WORK_DIR + '/errors.md', 'utf8');
diff --git a/Cargo.lock b/Cargo.lock
index 7523c0a1ed5..ca165d6a27c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10366,6 +10366,7 @@ dependencies = [
  "rolling-file",
  "tracing",
  "tracing-appender",
+ "tracing-chrome",
  "tracing-journald",
  "tracing-logfmt",
  "tracing-samply",
@@ -12503,6 +12504,17 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "tracing-chrome"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf0a738ed5d6450a9fb96e86a23ad808de2b727fd1394585da5cdd6788ffe724"
+dependencies = [
+ "serde_json",
+ "tracing-core",
+ "tracing-subscriber 0.3.23",
+]
+
 [[package]]
 name = "tracing-core"
 version = "0.1.36"
diff --git a/Cargo.toml b/Cargo.toml
index d511c8c4f82..daeda81a6df 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -688,6 +688,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"
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/node/core/src/args/log.rs b/crates/node/core/src/args/log.rs
index c4e1bf90f65..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,8 +181,8 @@ 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)
     }
 
@@ -171,12 +195,12 @@ impl LogArgs {
     /// * `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/tracing/Cargo.toml b/crates/tracing/Cargo.toml
index d9fe85ff853..ca141c22cc3 100644
--- a/crates/tracing/Cargo.toml
+++ b/crates/tracing/Cargo.toml
@@ -19,6 +19,7 @@ reth-tracing-otlp = { workspace = true, optional = true }
 tracing.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 }
@@ -35,6 +36,7 @@ default = ["std", "otlp"]
 std = [
     "tracing-subscriber",
     "tracing-appender",
+    "tracing-chrome",
     "tracing-journald",
     "tracing-logfmt",
     "tracing-samply",
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 8e6cf748a6f..e2b2620340e 100644
--- a/crates/tracing/src/lib.rs
+++ b/crates/tracing/src/lib.rs
@@ -57,7 +57,7 @@ tracy_client::register_demangler!();
 #[cfg(feature = "std")]
 pub use formatter::LogFormat;
 #[cfg(feature = "std")]
-pub use layers::{FileInfo, FileWorkerGuard, Layers};
+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,
@@ -86,8 +86,6 @@ mod throttle;
 #[cfg(feature = "std")]
 use tracing::level_filters::LevelFilter;
 #[cfg(feature = "std")]
-use tracing_appender::non_blocking::WorkerGuard;
-#[cfg(feature = "std")]
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
 ///  Tracer for application logging.
@@ -101,6 +99,7 @@ pub struct RethTracer {
     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
@@ -120,6 +119,7 @@ impl RethTracer {
             journald: None,
             file: None,
             samply: None,
+            chrome: None,
             #[cfg(feature = "tracy")]
             tracy: None,
             enable_reload: false,
@@ -160,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 {
@@ -245,9 +251,9 @@ pub trait Tracer: Sized {
     /// 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())
     }
 
@@ -259,14 +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,
@@ -297,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)?;
@@ -306,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))
     }
 }
 
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())
     }
 }

From 83df05e2ab41c64c0a44f8452a096848e67f0fed Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Sat, 6 Jun 2026 15:04:39 +0530
Subject: [PATCH 306/335] fix(engine-ssz): accept ssz fcu v4 custody columns
 (#24907)

---
 crates/ethereum/node/src/engine_ssz_proxy.rs | 51 +++++++++++++++++++-
 1 file changed, 50 insertions(+), 1 deletion(-)

diff --git a/crates/ethereum/node/src/engine_ssz_proxy.rs b/crates/ethereum/node/src/engine_ssz_proxy.rs
index 53982ccab94..d652568660d 100644
--- a/crates/ethereum/node/src/engine_ssz_proxy.rs
+++ b/crates/ethereum/node/src/engine_ssz_proxy.rs
@@ -483,12 +483,19 @@ fn decode_forkchoice_request(
     body: &[u8],
 ) -> Result<(ForkchoiceState, Option<PayloadAttributes>), &'static str> {
     match version {
-        1..=4 => {
+        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"),
     }
 }
@@ -511,6 +518,14 @@ fn payload_attrs(
     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,
@@ -594,4 +609,38 @@ mod tests {
         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");
+    }
 }

From f7eada52036747bfeed5ab17d9a272588c154525 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Sat, 6 Jun 2026 11:34:56 +0200
Subject: [PATCH 307/335] chore(deps): bump reth-core crates to 0.4.1 (#24897)

---
 Cargo.lock                            | 20 ++++++++++----------
 Cargo.toml                            | 10 +++++-----
 crates/ethereum/primitives/Cargo.toml |  1 +
 3 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ca165d6a27c..14f288f13ed 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7802,9 +7802,9 @@ dependencies = [
 
 [[package]]
 name = "reth-codecs"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f54468f34d9ed03356dee71bb182a2815a490934f1a291f58158053eee946ba"
+checksum = "98afe24504bdbdf20f746794e1708886c21cb4a59826652c9047cba7dfc716d4"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -7823,9 +7823,9 @@ dependencies = [
 
 [[package]]
 name = "reth-codecs-derive"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c80c0516faf1698c57f91f07c98ecd9f3a9d3f163f1ad4bb263d9c495b3928e0"
+checksum = "aeb02fa6170f3d13e621f1c05d0c6baa867e0b8ba9f841455114443bd2411a4e"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -9520,9 +9520,9 @@ dependencies = [
 
 [[package]]
 name = "reth-primitives-traits"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d1216ba179909d41d8d55c5eae6c1c33698bc7a3053c35fd425c7789a5de3c1"
+checksum = "8c2ce8506295bfbc570855a035fe11d6beec1db922ee4d5d1a44f568e6c8b6f1"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -10072,9 +10072,9 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-traits"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75186b77fef29e0160f476c9a6bde3363e503f0f32ac4ef47726ef1e3da81118"
+checksum = "947a4e5cec5166505ea078c9164f06bf691fd83d3850e72851b58a9f1900cb6d"
 dependencies = [
  "alloy-consensus",
  "alloy-network",
@@ -10611,9 +10611,9 @@ dependencies = [
 
 [[package]]
 name = "reth-zstd-compressors"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80dcfa0327b7642cc41c71d8cd3626a48ac76fb8304c28bcbdf416a45615d020"
+checksum = "395b92a7cf863f70bd109e35f70a2fe36033187de06f6840e0ccf61c8008375d"
 dependencies = [
  "zstd",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index daeda81a6df..c7ddeecb36b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -325,8 +325,8 @@ reth-cli = { path = "crates/cli/cli" }
 reth-cli-commands = { path = "crates/cli/commands" }
 reth-cli-runner = { path = "crates/cli/runner" }
 reth-cli-util = { path = "crates/cli/util" }
-reth-codecs = { version = "0.4.0", default-features = false }
-reth-codecs-derive = "0.4.0"
+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 }
@@ -394,7 +394,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.4.0", 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 }
@@ -410,7 +410,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.4.0", 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 }
@@ -429,7 +429,7 @@ reth-trie-common = { path = "crates/trie/common", default-features = false }
 reth-trie-db = { path = "crates/trie/db" }
 reth-trie-parallel = { path = "crates/trie/parallel" }
 reth-trie-sparse = { path = "crates/trie/sparse", default-features = false }
-reth-zstd-compressors = { version = "0.4.0", default-features = false }
+reth-zstd-compressors = { version = "0.4.1", default-features = false }
 
 # revm
 revm = { version = "40.0.3", default-features = false }
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",

From b99a3d6ec5d2280da134f84d1226ae9fb2cfbdf0 Mon Sep 17 00:00:00 2001
From: Soubhik Singha Mahapatra <160333583+Soubhik-10@users.noreply.github.com>
Date: Sat, 6 Jun 2026 16:29:59 +0530
Subject: [PATCH 308/335] feat(engine-ssz): add engine capabilities and
 identity methods (#24906)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/ethereum/node/Cargo.toml              |   3 +
 crates/ethereum/node/src/engine_ssz_proxy.rs | 127 +++++++++++++++++--
 crates/ethereum/node/tests/e2e/eth.rs        |  70 +++++++++-
 3 files changed, 187 insertions(+), 13 deletions(-)

diff --git a/crates/ethereum/node/Cargo.toml b/crates/ethereum/node/Cargo.toml
index c910ed6455a..d29cfafff8c 100644
--- a/crates/ethereum/node/Cargo.toml
+++ b/crates/ethereum/node/Cargo.toml
@@ -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
@@ -57,6 +58,8 @@ revm = { workspace = true, features = ["secp256k1", "blst", "c-kzg", "memory_lim
 eyre.workspace = true
 ethereum_ssz.workspace = true
 http-body-util.workspace = true
+serde.workspace = true
+serde_json.workspace = true
 tower.workspace = true
 
 [dev-dependencies]
diff --git a/crates/ethereum/node/src/engine_ssz_proxy.rs b/crates/ethereum/node/src/engine_ssz_proxy.rs
index d652568660d..44984d296a1 100644
--- a/crates/ethereum/node/src/engine_ssz_proxy.rs
+++ b/crates/ethereum/node/src/engine_ssz_proxy.rs
@@ -11,7 +11,7 @@ use alloy_eips::{
 };
 use alloy_primitives::{Bytes, B128, B256};
 use alloy_rpc_types_engine::{
-    CancunPayloadFields, ExecutionData, ExecutionPayload, ExecutionPayloadSidecar,
+    CancunPayloadFields, ClientVersionV1, ExecutionData, ExecutionPayload, ExecutionPayloadSidecar,
     ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3, ExecutionPayloadV4,
     ForkchoiceState, PayloadAttributes, PraguePayloadFields,
 };
@@ -20,6 +20,7 @@ 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;
@@ -34,6 +35,7 @@ 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";
 
@@ -46,11 +48,13 @@ 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>,
 }
 
@@ -59,6 +63,7 @@ impl<C> Clone for EngineSszProxyHandle<C> {
         Self {
             engine: self.engine.clone(),
             blob_store: self.blob_store.clone(),
+            client_version: self.client_version.clone(),
             chain_spec: self.chain_spec.clone(),
         }
     }
@@ -72,7 +77,12 @@ impl<C> std::fmt::Debug for EngineSszProxyHandle<C> {
 
 impl<ChainSpec> EngineSszProxyHandle<ChainSpec> {
     fn new(chain_spec: Arc<ChainSpec>) -> Self {
-        Self { engine: Default::default(), blob_store: Default::default(), chain_spec }
+        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.
@@ -93,6 +103,15 @@ impl<ChainSpec> EngineSszProxyHandle<ChainSpec> {
         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()
     }
@@ -159,39 +178,70 @@ async fn handle_engine_ssz_request<ChainSpec>(
 where
     ChainSpec: EthereumHardforks + Send + Sync + 'static,
 {
-    if request.method().as_str() != "POST" {
-        return text_response(STATUS_METHOD_NOT_ALLOWED, "method not allowed")
-    }
-
+    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")
     };
 
-    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")
-    };
-
     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) => handle_get_blobs(handle, 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()?))
         }
@@ -207,6 +257,8 @@ fn parse_engine_path(path: &str) -> Option<EngineSszEndpoint> {
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum EngineSszEndpoint {
+    Capabilities,
+    Identity,
     Payloads(EngineSszFork),
     Forkchoice(EngineSszFork),
     Blobs(u8),
@@ -263,6 +315,35 @@ 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,
@@ -569,6 +650,18 @@ fn ssz_response<T: ssz::Encode>(value: T) -> HttpResponse {
         .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")
 }
@@ -586,6 +679,18 @@ 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();
diff --git a/crates/ethereum/node/tests/e2e/eth.rs b/crates/ethereum/node/tests/e2e/eth.rs
index f784e98146f..5d0f604f638 100644
--- a/crates/ethereum/node/tests/e2e/eth.rs
+++ b/crates/ethereum/node/tests/e2e/eth.rs
@@ -3,7 +3,8 @@ use alloy_eips::{eip4844::BlobAndProofV1, eip7685::RequestsOrHash};
 use alloy_genesis::Genesis;
 use alloy_primitives::{Address, B256};
 use alloy_rpc_types_engine::{
-    ForkchoiceState, ForkchoiceUpdated, PayloadAttributes, PayloadStatus, PayloadStatusEnum,
+    ClientVersionV1, ForkchoiceState, ForkchoiceUpdated, PayloadAttributes, PayloadStatus,
+    PayloadStatusEnum,
 };
 use jsonrpsee_core::client::ClientT;
 use reth_chainspec::{ChainSpecBuilder, EthChainSpec, MAINNET};
@@ -12,7 +13,11 @@ 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_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;
@@ -24,6 +29,8 @@ 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<()> {
@@ -327,6 +334,65 @@ async fn test_engine_ssz_proxy_can_mine_block() -> eyre::Result<()> {
     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()?)

From e5f654ae9582c2fd3ce5992d4e88f774a94c1fc3 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Sun, 7 Jun 2026 11:09:37 +0200
Subject: [PATCH 309/335] feat(engine): add into_block_arc to built payload
 (#24960)

---
 crates/ethereum/engine-primitives/src/payload.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/crates/ethereum/engine-primitives/src/payload.rs b/crates/ethereum/engine-primitives/src/payload.rs
index 182bc8d4f11..602dcc9f355 100644
--- a/crates/ethereum/engine-primitives/src/payload.rs
+++ b/crates/ethereum/engine-primitives/src/payload.rs
@@ -72,6 +72,11 @@ impl<N: NodePrimitives> EthBuiltPayload<N> {
         &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

From e24169a3880f867ced0e7bff3f54dee19ece29eb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?L=C3=A9a=20Narzis?=
 <78718413+lean-apple@users.noreply.github.com>
Date: Sun, 7 Jun 2026 15:45:00 +0200
Subject: [PATCH 310/335] feat: extend era-downloader to ere files (#24899)

---
 crates/era-downloader/src/client.rs           |    59 +-
 crates/era-downloader/tests/it/download.rs    |    41 +-
 crates/era-downloader/tests/it/list.rs        |    18 +-
 crates/era-downloader/tests/it/main.rs        |    21 +
 crates/era-downloader/tests/it/stream.rs      |    24 +-
 .../tests/res/ere/checksums.txt               |     2 +
 .../tests/res/ere/ethpandaops.html            | 12074 ++++++++++++++++
 .../res/ere/files/mainnet-00000-a6860fef.erae |     1 +
 .../res/ere/files/mainnet-00001-05c64fc4.erae |     1 +
 crates/era/src/common/file_ops.rs             |    41 +-
 10 files changed, 12262 insertions(+), 20 deletions(-)
 create mode 100644 crates/era-downloader/tests/res/ere/checksums.txt
 create mode 100644 crates/era-downloader/tests/res/ere/ethpandaops.html
 create mode 100644 crates/era-downloader/tests/res/ere/files/mainnet-00000-a6860fef.erae
 create mode 100644 crates/era-downloader/tests/res/ere/files/mainnet-00001-05c64fc4.erae

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 39ff987bfb3..3934bd6c238 100644
--- a/crates/era-downloader/tests/it/main.rs
+++ b/crates/era-downloader/tests/it/main.rs
@@ -28,6 +28,16 @@ pub(crate) const ERA_MAINNET_0: &[u8] =
 pub(crate) const ERA_MAINNET_1: &[u8] =
     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.
 #[derive(Debug, Clone)]
@@ -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/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/src/common/file_ops.rs b/crates/era/src/common/file_ops.rs
index 98d82347c8f..081ace4b6a5 100644
--- a/crates/era/src/common/file_ops.rs
+++ b/crates/era/src/common/file_ops.rs
@@ -184,7 +184,10 @@ impl EraFileType {
     /// order-independent.
     const ALL: [Self; 3] = [Self::Era, Self::Era1, Self::Ere];
 
-    /// Get the file extension for this type, dot included
+    /// 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",
@@ -193,9 +196,28 @@ impl EraFileType {
         }
     }
 
+    /// 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> {
-        Self::ALL.into_iter().find(|ty| filename.ends_with(ty.extension()))
+        Self::ALL.into_iter().find(|ty| ty.extensions().iter().any(|ext| filename.ends_with(ext)))
     }
 
     /// Generate era file name.
@@ -230,6 +252,8 @@ impl EraFileType {
         }
         if url.contains("era1") {
             Self::Era1
+        } else if url.contains("erae") {
+            Self::Ere
         } else {
             Self::Era
         }
@@ -274,6 +298,10 @@ mod tests {
         // 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]
@@ -290,11 +318,20 @@ mod tests {
             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);
     }
 }

From 8b902fe0b3af1bde8efc25dca12b4baee8ed2175 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Sun, 7 Jun 2026 16:42:39 +0200
Subject: [PATCH 311/335] fix(payload): defer resolved job drop until after
 send (#24967)

---
 crates/payload/builder/src/service.rs | 31 +++++++++++++++++----------
 1 file changed, 20 insertions(+), 11 deletions(-)

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

From 9ebf589229a3710f87b1bcca7b87dcf4fc8d4c6f Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Mon, 8 Jun 2026 11:21:48 +0200
Subject: [PATCH 312/335] ci: add metrics option to Derek bench workflow
 (#24990)

---
 .github/workflows/bench.yml | 21 ++++++++++++++++-----
 deny.toml                   |  2 ++
 2 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 1c25f2e7d10..9be06605c4b 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -96,6 +96,11 @@ on:
         required: false
         default: "true"
         type: boolean
+      metrics:
+        description: "Upload txgen metrics to VictoriaMetrics"
+        required: false
+        default: "false"
+        type: boolean
 
 env:
   CARGO_TERM_COLOR: always
@@ -128,6 +133,7 @@ jobs:
       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 }}
@@ -186,7 +192,7 @@ 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|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] [wait-time=DURATION] [baseline-args="..."] [feature-args="..."]`';
+            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;
@@ -234,6 +240,7 @@ jobs:
               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 }}' || '';
@@ -258,11 +265,11 @@ jobs:
               const body = context.payload.comment.body.trim();
               const intArgs = new Set(['warmup', 'cores', 'blocks', 'run-pairs']);
               const refArgs = new Set(['baseline', 'feature']);
-              const boolArgs = new Set(['samply', 'tracing-chrome', '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: '', warmup: '', baseline: '', feature: '', samply: 'false', 'tracing-chrome': 'false', slack: 'always', 'big-blocks': 'false', bal: 'false', cores: '0', 'run-pairs': '', 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*/, '');
@@ -363,6 +370,7 @@ jobs:
               bal = defaults.bal;
               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'];
@@ -442,6 +450,7 @@ jobs:
             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
@@ -650,6 +659,7 @@ jobs:
       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 }}
@@ -659,7 +669,7 @@ jobs:
       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: ${{ secrets.BENCH_VICTORIAMETRICS_URL }}
+      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
@@ -1058,6 +1068,7 @@ jobs:
             cores="$BENCH_CORES"
             run-pairs="$BENCH_RUN_PAIRS"
             otlp="$BENCH_OTLP"
+            metrics="$BENCH_METRICS"
             slack="$BENCH_SLACK"
           )
           [ "$BENCH_SAMPLY" = "true" ] && derek_cmd+=(samply)
@@ -1391,7 +1402,7 @@ jobs:
             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 }}'
diff --git a/deny.toml b/deny.toml
index f4888f42900..32d7a639d95 100644
--- a/deny.toml
+++ b/deny.toml
@@ -16,6 +16,8 @@ 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

From f93b41249a05a27527cc2ce2da9259d49fe90e91 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 8 Jun 2026 11:32:50 +0200
Subject: [PATCH 313/335] ci: ignore proc-macro-error2 advisory (#24994)

---
 deny.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/deny.toml b/deny.toml
index 32d7a639d95..0d2486046ba 100644
--- a/deny.toml
+++ b/deny.toml
@@ -22,6 +22,9 @@ ignore = [
     # 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`.

From 5fab66d57bd1cf468fc0c3c5c8813fc3da645697 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?L=C3=A9a=20Narzis?=
 <78718413+lean-apple@users.noreply.github.com>
Date: Mon, 8 Jun 2026 11:53:48 +0200
Subject: [PATCH 314/335] refactor(era-utils): generalize `import` over
 `EraBlockReader` (#24977)

---
 Cargo.lock                            |   1 +
 crates/cli/commands/src/import_era.rs |  12 +-
 crates/era-utils/Cargo.toml           |   1 +
 crates/era-utils/src/history.rs       | 220 ++++++++++++++------------
 crates/era-utils/src/lib.rs           |  11 +-
 crates/era-utils/tests/it/history.rs  |   8 +-
 6 files changed, 142 insertions(+), 111 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 14f288f13ed..c5fe9d4a195 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8415,6 +8415,7 @@ dependencies = [
  "reth-db-common",
  "reth-era",
  "reth-era-downloader",
+ "reth-ethereum-primitives",
  "reth-etl",
  "reth-fs-util",
  "reth-primitives-traits",
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/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;

From 6b1ad1f4ca1e2bd8c7bc2be2f70562afea13fb33 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?L=C3=A9a=20Narzis?=
 <78718413+lean-apple@users.noreply.github.com>
Date: Mon, 8 Jun 2026 12:14:44 +0200
Subject: [PATCH 315/335] test: add roundtrip tests for er(a)e files (#24905)

---
 .github/workflows/integration.yml    |   4 +-
 crates/era/tests/it/ere/mod.rs       |   1 +
 crates/era/tests/it/ere/roundtrip.rs | 221 +++++++++++++++++++++++++++
 crates/era/tests/it/main.rs          |  26 ++++
 4 files changed, 250 insertions(+), 2 deletions(-)
 create mode 100644 crates/era/tests/it/ere/mod.rs
 create mode 100644 crates/era/tests/it/ere/roundtrip.rs

diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index 576d36dcf47..6c370b2ae24 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -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/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}"))
+    }
 }

From 101385a666e7390c10acc0f6915db7804484f702 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Mon, 8 Jun 2026 14:47:17 +0200
Subject: [PATCH 316/335] ci: summarize hive failure logs (#25001)

---
 .github/scripts/hive/print_client_logs.sh | 29 +++++++++++++++++++++++
 .github/workflows/hive.yml                |  6 ++---
 2 files changed, 31 insertions(+), 4 deletions(-)
 create mode 100755 .github/scripts/hive/print_client_logs.sh

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/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

From 581ee5c431caa420facbc0419f81a634ae2dcf3e Mon Sep 17 00:00:00 2001
From: Ishika Choudhury <117741714+Rimeeeeee@users.noreply.github.com>
Date: Mon, 8 Jun 2026 18:24:44 +0530
Subject: [PATCH 317/335] feat(rpc): add eth simulate state root flag (#24564)

Co-authored-by: Derek <256792747+decofe@users.noreply.github.com>
Co-authored-by: Arsenii Kulikov <klkvrr@gmail.com>
---
 crates/node/builder/src/rpc.rs                |  1 +
 crates/node/core/src/args/rpc_server.rs       | 19 +++++++++++++++++
 crates/rpc/rpc-builder/src/config.rs          |  1 +
 crates/rpc/rpc-eth-api/src/helpers/call.rs    | 14 ++++++++++++-
 .../rpc/rpc-eth-types/src/builder/config.rs   |  9 ++++++++
 crates/rpc/rpc-eth-types/src/simulate.rs      | 11 +++++++---
 crates/rpc/rpc/src/eth/builder.rs             | 21 +++++++++++++++++++
 crates/rpc/rpc/src/eth/core.rs                | 10 +++++++++
 crates/rpc/rpc/src/eth/helpers/call.rs        |  5 +++++
 docs/vocs/docs/pages/cli/reth/node.mdx        |  5 +++++
 10 files changed, 92 insertions(+), 4 deletions(-)

diff --git a/crates/node/builder/src/rpc.rs b/crates/node/builder/src/rpc.rs
index a10c40841f7..1194ca42414 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/core/src/args/rpc_server.rs b/crates/node/core/src/args/rpc_server.rs
index 03aa15670fd..5a55aeb1c4b 100644
--- a/crates/node/core/src/args/rpc_server.rs
+++ b/crates/node/core/src/args/rpc_server.rs
@@ -85,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,
@@ -316,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;
@@ -403,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,
@@ -606,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`).
@@ -854,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,
@@ -899,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,
@@ -1076,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,
diff --git a/crates/rpc/rpc-builder/src/config.rs b/crates/rpc/rpc-builder/src/config.rs
index c11135683ba..6518ba6deac 100644
--- a/crates/rpc/rpc-builder/src/config.rs
+++ b/crates/rpc/rpc-builder/src/config.rs
@@ -104,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)
diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs
index 0ac0a2d1df5..07ca27cdf82 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/call.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/call.rs
@@ -98,7 +98,12 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
             let parent = base_block.sealed_header().clone();
             let max_simulate_blocks = self.max_simulate_blocks();
 
-            self.spawn_with_state_at_block(block, move |this, mut db| {
+            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();
@@ -209,9 +214,11 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
 
                         simulate::execute_transactions(
                             builder,
+                            &state_provider,
                             calls,
                             &mut remaining_call_gas_limit,
                             chain_id,
+                            this.compute_state_root_for_eth_simulate(),
                             this.converter(),
                         )
                         .map_err(map_err)?
@@ -229,9 +236,11 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
 
                         simulate::execute_transactions(
                             builder,
+                            &state_provider,
                             calls,
                             &mut remaining_call_gas_limit,
                             chain_id,
+                            this.compute_state_root_for_eth_simulate(),
                             this.converter(),
                         )
                         .map_err(map_err)?
@@ -530,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-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/simulate.rs b/crates/rpc/rpc-eth-types/src/simulate.rs
index f7171b18536..a484e979035 100644
--- a/crates/rpc/rpc-eth-types/src/simulate.rs
+++ b/crates/rpc/rpc-eth-types/src/simulate.rs
@@ -24,7 +24,7 @@ use reth_primitives_traits::{
 };
 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,
@@ -291,9 +291,11 @@ pub fn apply_precompile_overrides(
 #[expect(clippy::type_complexity)]
 pub fn execute_transactions<S, T>(
     mut builder: S,
+    state_provider: impl StateProvider,
     calls: Vec<RpcTxReq<T::Network>>,
     remaining_call_gas_limit: &mut Option<u64>,
     chain_id: u64,
+    compute_state_root: bool,
     converter: &T,
 ) -> Result<
     (
@@ -384,8 +386,11 @@ where
         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))
 }
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 a8f704243c1..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> {
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/docs/vocs/docs/pages/cli/reth/node.mdx b/docs/vocs/docs/pages/cli/reth/node.mdx
index 599d5d57348..0b2057cf142 100644
--- a/docs/vocs/docs/pages/cli/reth/node.mdx
+++ b/docs/vocs/docs/pages/cli/reth/node.mdx
@@ -482,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`)
 

From b969584e080078660d69318a5bdcd9c4d48fbc41 Mon Sep 17 00:00:00 2001
From: Sergei Shulepov <s.pepyakin@gmail.com>
Date: Tue, 9 Jun 2026 00:57:49 +0900
Subject: [PATCH 318/335] perf(parbal): BAL prewarming pool (#25003)

Co-authored-by: DaniPopes <57450786+DaniPopes@users.noreply.github.com>
---
 .../payload_processor/bal_prewarm_pool.rs     | 159 ++++++++++++++++++
 .../tree/src/tree/payload_processor/mod.rs    |  18 +-
 .../src/tree/payload_processor/prewarm.rs     | 126 +++++---------
 3 files changed, 214 insertions(+), 89 deletions(-)
 create mode 100644 crates/engine/tree/src/tree/payload_processor/bal_prewarm_pool.rs

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 5949cbf0e4a..911d754c305 100644
--- a/crates/engine/tree/src/tree/payload_processor/mod.rs
+++ b/crates/engine/tree/src/tree/payload_processor/mod.rs
@@ -42,12 +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;
@@ -153,6 +154,9 @@ where
     disable_bal_parallel_state_root: bool,
     /// 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>
@@ -192,8 +196,19 @@ where
                 .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>
@@ -528,6 +543,7 @@ where
             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(),
diff --git a/crates/engine/tree/src/tree/payload_processor/prewarm.rs b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
index c44efbe9933..7c80afc6fd2 100644
--- a/crates/engine/tree/src/tree/payload_processor/prewarm.rs
+++ b/crates/engine/tree/src/tree/payload_processor/prewarm.rs
@@ -11,6 +11,7 @@
 //! 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},
@@ -20,7 +21,7 @@ use crate::tree::{
 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, StateProviderBox,
-    StateProviderFactory, StateReader,
+    AccountReader, BlockExecutionOutput, BlockReader, StateProviderFactory, StateReader,
 };
 use reth_revm::{database::StateProviderDatabase, state::EvmState};
 use reth_tasks::{pool::WorkerPool, Runtime};
@@ -355,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);
@@ -394,30 +393,38 @@ where
             let _ = stream_tx.send(());
         }
 
-        if ctx.saved_cache.is_some() && !ctx.disable_bal_batch_io {
-            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 parent_span = branch_span.clone();
-                let _span = branch_span.entered();
-
-                prefetch_bal.as_bal().par_iter().for_each(|account| {
-                    if ctx.should_stop() {
-                        return;
-                    }
-                    WorkerPool::with_worker_mut(|worker| {
-                        let provider = worker
-                            .get_or_init::<Option<CachedStateProvider<StateProviderBox>>>(|| None);
-                        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(());
         }
@@ -523,6 +530,9 @@ 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.
@@ -734,66 +744,6 @@ 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>>,
-        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))
-            }
-        };
-
-        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

From c8d9e0484c84b1b4a44be6a9053c8d02b1bf522e Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 8 Jun 2026 19:09:52 +0200
Subject: [PATCH 319/335] fix: avoid clearing rocksdb unnecesarily (#24903)

Co-authored-by: Derek <256792747+decofe@users.noreply.github.com>
---
 .../src/providers/rocksdb/invariants.rs       | 86 +++++++++----------
 1 file changed, 41 insertions(+), 45 deletions(-)

diff --git a/crates/storage/provider/src/providers/rocksdb/invariants.rs b/crates/storage/provider/src/providers/rocksdb/invariants.rs
index 84291d29f44..232c629afe1 100644
--- a/crates/storage/provider/src/providers/rocksdb/invariants.rs
+++ b/crates/storage/provider/src/providers/rocksdb/invariants.rs
@@ -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]

From c6379a923915055f25f9eec3452acb490b71c5b4 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Mon, 8 Jun 2026 19:47:19 +0200
Subject: [PATCH 320/335] feat(payload): cache parent block info for payload
 jobs (#24671)

---
 crates/ethereum/payload/src/lib.rs       |  2 +-
 crates/payload/basic/src/lib.rs          | 56 ++++++++++++++++++++++--
 crates/payload/basic/src/stack.rs        | 46 +++++++++++++++----
 examples/custom-engine-types/src/main.rs | 12 +++--
 4 files changed, 99 insertions(+), 17 deletions(-)

diff --git a/crates/ethereum/payload/src/lib.rs b/crates/ethereum/payload/src/lib.rs
index dc5b387f103..34428e71b2b 100644
--- a/crates/ethereum/payload/src/lib.rs
+++ b/crates/ethereum/payload/src/lib.rs
@@ -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 {
diff --git a/crates/payload/basic/src/lib.rs b/crates/payload/basic/src/lib.rs
index f99bbc0823a..5e95081d736 100644
--- a/crates/payload/basic/src/lib.rs
+++ b/crates/payload/basic/src/lib.rs
@@ -69,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 ===
@@ -89,6 +91,7 @@ impl<Client, Builder> BasicPayloadJobGenerator<Client, Builder> {
             config,
             builder,
             pre_cached: None,
+            pre_cached_parent_block_info: None,
         }
     }
 
@@ -131,6 +134,14 @@ impl<Client, Builder> BasicPayloadJobGenerator<Client, Builder> {
 
         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 ===
@@ -167,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));
@@ -217,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 });
     }
 }
 
@@ -232,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>);
@@ -724,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,
@@ -740,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 9f390dd4d9a..faf61450e11 100644
--- a/crates/payload/basic/src/stack.rs
+++ b/crates/payload/basic/src/stack.rs
@@ -175,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) => {
@@ -183,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 {
@@ -200,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 {
@@ -220,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/examples/custom-engine-types/src/main.rs b/examples/custom-engine-types/src/main.rs
index bc1414693fb..1d8ca06d744 100644
--- a/examples/custom-engine-types/src/main.rs
+++ b/examples/custom-engine-types/src/main.rs
@@ -343,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
@@ -351,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,
         })
@@ -361,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,
         })

From 44b904acb61a24e4923bdddf6c0f18627055e7b8 Mon Sep 17 00:00:00 2001
From: Julio <30329843+julio4@users.noreply.github.com>
Date: Tue, 9 Jun 2026 05:12:30 +0900
Subject: [PATCH 321/335] feat(txpool): add ValidatingPool trait for validator
 access (#24848)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/transaction-pool/src/lib.rs    | 14 ++++++++++++++
 crates/transaction-pool/src/traits.rs | 26 +++++++++++++++++++++++++-
 2 files changed, 39 insertions(+), 1 deletion(-)

diff --git a/crates/transaction-pool/src/lib.rs b/crates/transaction-pool/src/lib.rs
index ad25bcf6232..525ebe01554 100644
--- a/crates/transaction-pool/src/lib.rs
+++ b/crates/transaction-pool/src/lib.rs
@@ -865,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/traits.rs b/crates/transaction-pool/src/traits.rs
index 4ee1d9d0e78..9974bb569ae 100644
--- a/crates/transaction-pool/src/traits.rs
+++ b/crates/transaction-pool/src/traits.rs
@@ -57,7 +57,7 @@ use crate::{
         state::SubPool, BestTransactionFilter, NewTransactionEvent, TransactionEvents,
         TransactionListenerKind,
     },
-    validate::ValidPoolTransaction,
+    validate::{TransactionValidationOutcome, TransactionValidator, ValidPoolTransaction},
     AddedTransactionOutcome, AllTransactionsEvents,
 };
 use alloy_consensus::{error::ValueError, transaction::TxHashRef, BlockHeader, Signed, Typed2718};
@@ -791,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> {

From 72fafb577ce102c2408b75516907aa4438cf3d06 Mon Sep 17 00:00:00 2001
From: Derek Cofausper <256792747+decofe@users.noreply.github.com>
Date: Mon, 8 Jun 2026 23:47:28 +0200
Subject: [PATCH 322/335] fix: remove precompile cache initial capacity
 (#25013)

---
 crates/engine/tree/src/tree/precompile_cache.rs | 1 -
 1 file changed, 1 deletion(-)

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

From 949834ad1cdc658dd85631857bb3b5ca16f12a82 Mon Sep 17 00:00:00 2001
From: Alexey Shekhirin <github@shekhirin.com>
Date: Tue, 9 Jun 2026 10:35:02 +0200
Subject: [PATCH 323/335] fix(cli): target `reth download --force` cleanup
 (#25015)

---
 bin/reth/tests/it/main.rs                  | 16 ++++++++++++++-
 crates/cli/commands/src/download/mod.rs    | 24 +++++++++-------------
 docs/vocs/docs/pages/cli/reth/download.mdx |  2 +-
 3 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/bin/reth/tests/it/main.rs b/bin/reth/tests/it/main.rs
index 3c311fcba66..d71390501d6 100644
--- a/bin/reth/tests/it/main.rs
+++ b/bin/reth/tests/it/main.rs
@@ -186,19 +186,26 @@ fn download_help() {
 }
 
 #[test]
-fn download_force_overwrites_snapshot_data_but_preserves_identity_files() {
+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");
@@ -210,7 +217,9 @@ fn download_force_overwrites_snapshot_data_but_preserves_identity_files() {
         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"
@@ -219,6 +228,11 @@ fn download_force_overwrites_snapshot_data_but_preserves_identity_files() {
         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/cli/commands/src/download/mod.rs b/crates/cli/commands/src/download/mod.rs
index 91fc472f210..5cedbe4ad7e 100644
--- a/crates/cli/commands/src/download/mod.rs
+++ b/crates/cli/commands/src/download/mod.rs
@@ -114,7 +114,6 @@ use source::{
 use std::{
     borrow::Cow,
     collections::BTreeMap,
-    ffi::OsStr,
     path::{Path, PathBuf},
     sync::{Arc, OnceLock},
 };
@@ -125,7 +124,7 @@ 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_PRESERVED_DATADIR_FILES: &[&str] = &["discovery-secret", "known-peers.json"];
+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;
@@ -421,7 +420,7 @@ pub struct DownloadCommand<C: ChainSpecParser> {
     #[arg(long, short = 'y')]
     non_interactive: bool,
 
-    /// Overwrite existing snapshot data while preserving discovery-secret and known-peers.json.
+    /// Overwrite existing snapshot data by removing db, rocksdb, static_files, and reth.toml.
     #[arg(long, conflicts_with = "list")]
     force: bool,
 
@@ -863,26 +862,23 @@ fn selection_from_prune_mode(mode: Option<PruneMode>, snapshot_block: u64) -> Co
     }
 }
 
-/// Removes existing snapshot data while preserving files listed in
-/// [`FORCE_PRESERVED_DATADIR_FILES`].
+/// 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 data directory");
-    for entry in fs::read_dir(target_dir)? {
-        let entry = entry?;
-        let file_name = entry.file_name();
-        if FORCE_PRESERVED_DATADIR_FILES.iter().any(|preserved| file_name == OsStr::new(preserved))
-        {
+    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 path = entry.path();
-        if entry.file_type()?.is_dir() {
+        let metadata = fs::metadata(&path)?;
+        if metadata.is_dir() {
             fs::remove_dir_all(&path)?;
-        } else {
+        } else if metadata.is_file() {
             fs::remove_file(&path)?;
         }
     }
diff --git a/docs/vocs/docs/pages/cli/reth/download.mdx b/docs/vocs/docs/pages/cli/reth/download.mdx
index 7b1c6aaa479..d1e9ebfa7ae 100644
--- a/docs/vocs/docs/pages/cli/reth/download.mdx
+++ b/docs/vocs/docs/pages/cli/reth/download.mdx
@@ -206,7 +206,7 @@ Storage:
           Skip interactive component selection. Downloads the minimal set (state + headers + transactions + changesets) unless explicit --with-* flags narrow it
 
       --force
-          Overwrite existing snapshot data while preserving discovery-secret and known-peers.json
+          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).

From a3482dfa68b3875b41d4029edeca54bd2ab459ac Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Tue, 9 Jun 2026 11:46:45 +0200
Subject: [PATCH 324/335] fix(chain-state): publish deferred trie data from
 task (#24995)

Co-authored-by: Brian <brian@Host-007.homenet.telecomitalia.it>
Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
Co-authored-by: Derek <256792747+decofe@users.noreply.github.com>
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/chain-state/src/deferred_trie.rs       | 152 +++++++++++-------
 crates/chain-state/src/in_memory.rs           |  19 ++-
 .../engine/tree/src/tree/payload_validator.rs |  34 ++--
 3 files changed, 120 insertions(+), 85 deletions(-)

diff --git a/crates/chain-state/src/deferred_trie.rs b/crates/chain-state/src/deferred_trie.rs
index ea71b92c15d..4c45e205434 100644
--- a/crates/chain-state/src/deferred_trie.rs
+++ b/crates/chain-state/src/deferred_trie.rs
@@ -1,4 +1,3 @@
-use parking_lot::Mutex;
 use reth_metrics::{metrics::Counter, Metrics};
 use reth_trie::{
     updates::{TrieUpdates, TrieUpdatesSorted},
@@ -6,18 +5,47 @@ use reth_trie::{
 };
 use std::{
     fmt,
-    sync::{Arc, LazyLock},
+    sync::{Arc, LazyLock, OnceLock},
 };
 use tracing::{debug_span, instrument};
 
-/// Shared handle to asynchronously populated per-block trie data.
+/// Shared handle to asynchronously populated sorted per-block trie data.
 ///
-/// If the background task has not completed by the time trie data is needed, the caller computes
-/// the sorted data synchronously from the retained unsorted inputs and caches the result.
+/// 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<DeferredTrieDataInner>>,
+    /// Shared deferred result populated by the corresponding [`DeferredTrieDataProducer`].
+    value: Arc<OnceLock<ComputedTrieData>>,
+}
+
+/// 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.
@@ -38,23 +66,13 @@ pub struct ComputedTrieData {
 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 DeferredTrieDataInner {
-    /// 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 {
@@ -66,32 +84,31 @@ struct PendingInputs {
 
 impl fmt::Debug for DeferredTrieData {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let state = self.state.lock();
-        match &*state {
-            DeferredTrieDataInner::Pending(_) => {
-                f.debug_struct("DeferredTrieData").field("state", &"pending").finish()
-            }
-            DeferredTrieDataInner::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.
-    pub fn pending(hashed_state: Arc<HashedPostState>, trie_updates: Arc<TrieUpdates>) -> Self {
-        Self {
-            state: Arc::new(Mutex::new(DeferredTrieDataInner::Pending(Some(PendingInputs {
-                hashed_state,
-                trie_updates,
-            })))),
-        }
+    /// 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>,
+    ) -> (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`].
     pub fn ready(bundle: ComputedTrieData) -> Self {
-        Self { state: Arc::new(Mutex::new(DeferredTrieDataInner::Ready(bundle))) }
+        Self { value: Arc::new(OnceLock::from(bundle)) }
     }
 
     /// Sorts block execution outputs.
@@ -128,25 +145,21 @@ impl DeferredTrieData {
         ComputedTrieData::new(Arc::new(sorted_hashed_state), Arc::new(sorted_trie_updates))
     }
 
-    /// Returns trie data, computing synchronously if the async task hasn't completed.
+    /// 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 {
-        let mut state = self.state.lock();
-        match &mut *state {
-            DeferredTrieDataInner::Ready(bundle) => {
+        let bundle = match self.value.get() {
+            Some(bundle) => {
                 DEFERRED_TRIE_METRICS.deferred_trie_async_ready.increment(1);
-                bundle.clone()
+                bundle
             }
-            DeferredTrieDataInner::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(inputs.hashed_state, inputs.trie_updates);
-                *state = DeferredTrieDataInner::Ready(computed.clone());
-
-                computed
+            None => {
+                DEFERRED_TRIE_METRICS.deferred_trie_task_wait.increment(1);
+                self.value.wait()
             }
-        }
+        };
+
+        bundle.clone()
     }
 }
 
@@ -171,7 +184,7 @@ mod tests {
         time::{Duration, Instant},
     };
 
-    fn empty_pending() -> DeferredTrieData {
+    fn empty_pending() -> (DeferredTrieData, DeferredTrieDataProducer) {
         DeferredTrieData::pending(
             Arc::new(HashedPostState::default()),
             Arc::new(TrieUpdates::default()),
@@ -190,25 +203,46 @@ mod tests {
     }
 
     #[test]
-    fn pending_computes_and_caches_result() {
-        let deferred = empty_pending();
+    fn pending_waits_for_task_and_caches_result() {
+        let (deferred, task) = empty_pending();
 
+        let published = task.compute_and_publish();
         let first = deferred.wait_cloned();
         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));
     }
 
     #[test]
-    fn concurrent_waits_share_computed_result() {
-        let deferred = empty_pending();
+    fn pending_wait_blocks_until_task_publishes() {
+        let (deferred, task) = empty_pending();
+
+        let handle = thread::spawn(move || deferred.wait_cloned());
+        thread::sleep(Duration::from_millis(20));
+        assert!(!handle.is_finished());
+
+        let published = task.compute_and_publish();
+        let result = handle.join().unwrap();
+
+        assert!(Arc::ptr_eq(&published.hashed_state, &result.hashed_state));
+        assert!(Arc::ptr_eq(&published.trie_updates, &result.trie_updates));
+    }
+
+    #[test]
+    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));
     }
@@ -224,8 +258,9 @@ mod tests {
                 HashedStorage::from_iter(false, [(hashed_slot, U256::from(1))]),
             )]);
 
-        let deferred =
+        let (deferred, task) =
             DeferredTrieData::pending(Arc::new(hashed_state), Arc::new(TrieUpdates::default()));
+        let _ = task.compute_and_publish();
         let result = deferred.wait_cloned();
 
         assert_eq!(result.hashed_state.total_len(), 2);
@@ -238,11 +273,12 @@ mod tests {
         for i in 0..100 {
             accounts.insert(B256::with_last_byte(i), Some(Account::default()));
         }
-        let deferred = DeferredTrieData::pending(
+        let (deferred, task) = DeferredTrieData::pending(
             Arc::new(HashedPostState { accounts, storages: Default::default() }),
             Arc::new(TrieUpdates::default()),
         );
 
+        let _ = task.compute_and_publish();
         let _ = deferred.wait_cloned();
         let start = Instant::now();
         let _ = deferred.wait_cloned();
diff --git a/crates/chain-state/src/in_memory.rs b/crates/chain-state/src/in_memory.rs
index 60a85e44781..c62b7d6e69f 100644
--- a/crates/chain-state/src/in_memory.rs
+++ b/crates/chain-state/src/in_memory.rs
@@ -804,11 +804,11 @@ impl<N: NodePrimitives> ExecutedBlock<N> {
     /// after the block was validated.
     ///
     /// The [`DeferredTrieData`] handle allows expensive trie operations (sorting hashed state and
-    /// trie updates) to be performed outside the critical validation path. This can improve latency
-    /// for time-sensitive operations like block validation.
+    /// 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(
@@ -837,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 {
@@ -851,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()
@@ -860,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
@@ -868,7 +867,7 @@ 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
diff --git a/crates/engine/tree/src/tree/payload_validator.rs b/crates/engine/tree/src/tree/payload_validator.rs
index 30240b00d19..a59fdd17a7c 100644
--- a/crates/engine/tree/src/tree/payload_validator.rs
+++ b/crates/engine/tree/src/tree/payload_validator.rs
@@ -954,10 +954,11 @@ where
         })
     }
 
-    /// Spawns a background task that creates the changeset provider used by the deferred trie task.
+    /// 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 task is spawned.
+    /// validation, then awaited before the deferred trie producer is spawned.
     fn spawn_changeset_provider_task(
         &self,
         overlay_factory: OverlayStateProviderFactory<P, N>,
@@ -1793,17 +1794,16 @@ where
 
     /// 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. 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: Arc<RecoveredBlock<N::Block>>,
@@ -1812,15 +1812,15 @@ where
         trie_output: Arc<TrieUpdates>,
         changeset_provider: impl TrieCursorFactory + Send + 'static,
     ) -> ExecutedBlock<N> {
-        // 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) => state,
             Err(handle) => handle.get().clone(),
         };
-        let deferred_trie_data = DeferredTrieData::pending(hashed_state, trie_output);
-        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
@@ -1832,8 +1832,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",
@@ -1844,7 +1844,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());
@@ -1880,7 +1880,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"
                         );
                     }
                 }
@@ -1889,7 +1889,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"
                 );
             }
         };

From 84d8e471ea51896eb4c83e4f0b2ec95cefb1f30d Mon Sep 17 00:00:00 2001
From: Brian Picciano <me@mediocregopher.com>
Date: Tue, 9 Jun 2026 12:28:12 +0200
Subject: [PATCH 325/335] fix(chain-state): avoid state overlay cache deadlock
 (#24875)

Co-authored-by: Brian <brian@Brians-MacBook-Pro.local>
Co-authored-by: Brian <brian@Host-007.homenet.telecomitalia.it>
---
 crates/chain-state/src/state_trie_overlay.rs | 252 ++++++++++++++++---
 1 file changed, 211 insertions(+), 41 deletions(-)

diff --git a/crates/chain-state/src/state_trie_overlay.rs b/crates/chain-state/src/state_trie_overlay.rs
index d7baef361fd..00d6b75e3d0 100644
--- a/crates/chain-state/src/state_trie_overlay.rs
+++ b/crates/chain-state/src/state_trie_overlay.rs
@@ -17,7 +17,11 @@ use reth_primitives_traits::{
 #[cfg(feature = "rayon")]
 use reth_tasks::WorkerPool;
 use reth_trie::{updates::TrieUpdatesSorted, HashedPostStateSorted, TrieInputSorted};
-use std::{fmt, sync::Arc, time::Instant};
+use std::{
+    fmt,
+    sync::{Arc, OnceLock},
+    time::Instant,
+};
 use tracing::{debug, trace};
 
 /// Manages flattened state trie overlays for in-memory blocks.
@@ -27,7 +31,7 @@ use tracing::{debug, trace};
 #[derive(Clone)]
 pub struct StateTrieOverlayManager<N: NodePrimitives = EthPrimitives> {
     blocks: Arc<DashMap<B256, ExecutedBlock<N>>>,
-    overlays: Arc<DashMap<OverlayCacheKey, Arc<TrieInputSorted>>>,
+    overlays: Arc<DashMap<OverlayCacheKey, OverlayCacheEntry>>,
     #[cfg(feature = "rayon")]
     worker_pool: Option<Arc<WorkerPool>>,
     metrics: StateTrieOverlayMetrics,
@@ -118,7 +122,7 @@ impl<N: NodePrimitives> StateTrieOverlayManager<N> {
             .iter()
             .filter_map(|entry| {
                 let key = *entry.key();
-                (key.tip_hash == parent_hash).then_some(key.anchor_hash)
+                (key.tip_hash == parent_hash && entry.value().is_ready()).then_some(key.anchor_hash)
             })
             .collect::<Vec<_>>();
 
@@ -155,7 +159,7 @@ impl<N: NodePrimitives> StateTrieOverlayManager<N> {
                         anchor_hash = %anchor_hash,
                     )
                     .entered();
-                    let _ = manager.get_overlay(hash, anchor_hash);
+                    let _ = manager.precompute_overlay(hash, anchor_hash);
                 });
             }
         }
@@ -229,6 +233,16 @@ impl<N: NodePrimitives> StateTrieOverlayManager<N> {
         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",
@@ -246,13 +260,36 @@ impl<N: NodePrimitives> StateTrieOverlayManager<N> {
         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(input) = self.overlays.get(&key).map(|entry| Arc::clone(entry.value())) {
-            self.metrics.overlay_cache_reuses.increment(1);
-            span.record("cache_reused", true);
-            return Ok(input)
+        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);
 
@@ -277,7 +314,7 @@ impl<N: NodePrimitives> StateTrieOverlayManager<N> {
                 .then(|| {
                     self.overlays
                         .get(&OverlayCacheKey { anchor_hash, tip_hash: parent_hash })
-                        .map(|entry| Arc::clone(entry.value()))
+                        .and_then(|entry| entry.value().ready())
                 })
                 .flatten()
         });
@@ -289,42 +326,61 @@ impl<N: NodePrimitives> StateTrieOverlayManager<N> {
             None => ComputeOverlayInput::MergeBlocks(blocks),
         };
 
-        // The vacant entry is the cache-fill gate: racing callers block instead of recomputing.
-        let input = match self.overlays.entry(key) {
-            Entry::Occupied(entry) => {
-                self.metrics.overlay_cache_reuses.increment(1);
-                span.record("cache_reused", true);
-                return Ok(Arc::clone(entry.get()))
-            }
+        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 input = {
-                    #[cfg(feature = "rayon")]
-                    {
-                        if let Some(worker_pool) = &self.worker_pool {
-                            let compute_span = span;
-                            let metrics = self.metrics.clone();
-                            Arc::new(worker_pool.install_fn(move || {
-                                let _guard = compute_span.enter();
-                                compute_overlay(compute_input, anchor_hash, &metrics)
-                            }))
-                        } else {
-                            Arc::new(compute_overlay(compute_input, anchor_hash, &self.metrics))
-                        }
-                    }
+                let waiter = Arc::new(OverlayWaiter::new());
+                entry.insert(OverlayCacheEntry::Computing(Arc::clone(&waiter)));
+                CacheAction::Compute(waiter)
+            }
+        };
 
-                    #[cfg(not(feature = "rayon"))]
-                    {
-                        Arc::new(compute_overlay(compute_input, anchor_hash, &self.metrics))
+        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)));
                     }
-                };
+                }
 
-                entry.insert(Arc::clone(&input));
-                input
+                Ok(Some(input))
             }
-        };
-
-        Ok(input)
+        }
     }
 
     /// Returns `preferred_anchor` if it is on the parent chain, otherwise the first missing parent.
@@ -357,6 +413,27 @@ impl<N: NodePrimitives> StateTrieOverlayManager<N> {
             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.
@@ -386,6 +463,49 @@ struct OverlayCacheKey {
     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>>),
@@ -516,11 +636,12 @@ mod tests {
     use alloy_primitives::U256;
     use reth_primitives_traits::Account;
     use reth_trie::{updates::TrieUpdatesSorted, HashedPostState, HashedStorage};
-    use std::sync::Arc;
     #[cfg(feature = "rayon")]
+    use std::time::Instant;
     use std::{
+        sync::{mpsc, Arc},
         thread,
-        time::{Duration, Instant},
+        time::Duration,
     };
 
     fn with_unique_state(
@@ -625,6 +746,55 @@ mod tests {
         );
     }
 
+    #[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() {

From 3a220374fdfc13e3ecf3c5cf25aa97f51aa702a1 Mon Sep 17 00:00:00 2001
From: Julian Meyer <julian.meyer@coinbase.com>
Date: Tue, 9 Jun 2026 04:07:06 -0700
Subject: [PATCH 326/335] feat(net): add outbound peer rotation to prevent slot
 saturation (#24776)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 crates/net/network-types/src/peers/config.rs |  22 ++
 crates/net/network-types/src/peers/mod.rs    |  20 ++
 crates/net/network/src/peers.rs              | 355 ++++++++++++++++++-
 3 files changed, 394 insertions(+), 3 deletions(-)

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/peers.rs b/crates/net/network/src/peers.rs
index 204cd3df46d..aecdb16b944 100644
--- a/crates/net/network/src/peers.rs
+++ b/crates/net/network/src/peers.rs
@@ -8,6 +8,7 @@ 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;
@@ -16,7 +17,7 @@ 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() &&
@@ -1041,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.
     ///
@@ -1173,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
             }
@@ -1215,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
@@ -1359,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;
@@ -1412,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();
@@ -3386,4 +3496,243 @@ mod tests {
         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!(),
+        }
+    }
 }

From e5fd7621b80f7452a8b2ca5d6e6afa969ab82bdd Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 9 Jun 2026 16:33:27 +0200
Subject: [PATCH 327/335] perf(transaction-pool): specialize same-origin batch
 insertion (#25037)

---
 crates/transaction-pool/src/batcher.rs | 45 ++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

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

From 01cbe9bdada95a3267a6b75bd54b27b6452ab97a Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 9 Jun 2026 20:35:54 +0200
Subject: [PATCH 328/335] fix(rlpx): bound mux outbound buffer fairly (#25031)

---
 crates/net/eth-wire/src/multiplex.rs | 313 +++++++++++++++++++++++----
 1 file changed, 267 insertions(+), 46 deletions(-)

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

From 8919e677f6bc180dcd887a901e500265a6613bba Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 9 Jun 2026 22:32:48 +0200
Subject: [PATCH 329/335] chore(deps): bump revm-inspectors to 0.40.1 (#25047)

---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c5fe9d4a195..5a2938dd134 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10751,9 +10751,9 @@ dependencies = [
 
 [[package]]
 name = "revm-inspectors"
-version = "0.40.0"
+version = "0.40.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2854f2c48cecac90e8ad48fe8d8842707f79df2b748913b67bd2439a9ea3b4ab"
+checksum = "15e0cdc845c8dbf41255c9add80923b45df7bf1dd0473e41483ac398005dba12"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
diff --git a/Cargo.toml b/Cargo.toml
index c7ddeecb36b..9db7b987ea5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -439,7 +439,7 @@ 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.0"
+revm-inspectors = "0.40.1"
 
 # eth
 alloy-dyn-abi = "1.6.0"

From 9f2837e1794baf7492b16d115f6c0ee7c6103d89 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Tue, 9 Jun 2026 22:33:21 +0200
Subject: [PATCH 330/335] feat(revm): add CachedReads account capacity
 constructor (#25048)

---
 crates/revm/src/cached.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

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

From f1b8443d6842eff51b5b41c3284d7b0038bccc1e Mon Sep 17 00:00:00 2001
From: Matthieu Vachon <matt@streamingfast.io>
Date: Tue, 9 Jun 2026 16:53:06 -0400
Subject: [PATCH 331/335] feat(engine): expose pub state_trie_overlays()
 accessor on TreeState

OpFirehoseEngineValidator (reth-optimism-firehose) is an external
re-implementation of BasicEngineValidator that lives outside this crate
and therefore cannot read pub(crate) fields. This one-line accessor
exposes the existing state_trie_overlays field so external validators
can call .with_state_trie_overlay_manager(...) on OverlayBuilder without
rebuilding the manager from scratch on every request.
---
 crates/engine/tree/src/tree/state.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/crates/engine/tree/src/tree/state.rs b/crates/engine/tree/src/tree/state.rs
index b8a33adb8b0..a1b8d13d0ad 100644
--- a/crates/engine/tree/src/tree/state.rs
+++ b/crates/engine/tree/src/tree/state.rs
@@ -344,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)]

From 9384bc53d8c0c77e59cac83fdaaf3b372c6d2216 Mon Sep 17 00:00:00 2001
From: Emma Jamieson-Hoare <emmajam@users.noreply.github.com>
Date: Wed, 10 Jun 2026 10:55:23 +0100
Subject: [PATCH 332/335] chore(release): bump version to 2.3.0 (#25071)

---
 Cargo.lock               | 230 +++++++++++++++++++--------------------
 Cargo.toml               |   2 +-
 docs/vocs/vocs.config.ts |   2 +-
 3 files changed, 117 insertions(+), 117 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5a2938dd134..cc4ad641ed0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3251,7 +3251,7 @@ dependencies = [
 
 [[package]]
 name = "ef-test-runner"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "clap",
  "ef-tests",
@@ -3259,7 +3259,7 @@ dependencies = [
 
 [[package]]
 name = "ef-tests"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -3708,7 +3708,7 @@ dependencies = [
 
 [[package]]
 name = "example-full-contract-state"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "eyre",
@@ -3841,7 +3841,7 @@ dependencies = [
 
 [[package]]
 name = "exex-subscription"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "clap",
@@ -7493,7 +7493,7 @@ checksum = "1e061d1b48cb8d38042de4ae0a7a6401009d6143dc80d2e2d6f31f0bdd6470c7"
 
 [[package]]
 name = "reth"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-node-bindings",
  "alloy-primitives",
@@ -7543,7 +7543,7 @@ dependencies = [
 
 [[package]]
 name = "reth-basic-payload-builder"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -7569,7 +7569,7 @@ dependencies = [
 
 [[package]]
 name = "reth-bb"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -7617,7 +7617,7 @@ dependencies = [
 
 [[package]]
 name = "reth-chain-state"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -7650,7 +7650,7 @@ dependencies = [
 
 [[package]]
 name = "reth-chainspec"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
@@ -7670,7 +7670,7 @@ dependencies = [
 
 [[package]]
 name = "reth-cli"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-genesis",
  "clap",
@@ -7682,7 +7682,7 @@ dependencies = [
 
 [[package]]
 name = "reth-cli-commands"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
@@ -7771,7 +7771,7 @@ dependencies = [
 
 [[package]]
 name = "reth-cli-runner"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "reth-tasks",
  "tokio",
@@ -7780,7 +7780,7 @@ dependencies = [
 
 [[package]]
 name = "reth-cli-util"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eips",
  "alloy-primitives",
@@ -7834,7 +7834,7 @@ dependencies = [
 
 [[package]]
 name = "reth-config"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "eyre",
@@ -7852,7 +7852,7 @@ dependencies = [
 
 [[package]]
 name = "reth-consensus"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eip7928 0.4.1",
@@ -7865,7 +7865,7 @@ dependencies = [
 
 [[package]]
 name = "reth-consensus-common"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -7879,7 +7879,7 @@ dependencies = [
 
 [[package]]
 name = "reth-consensus-debug-client"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -7903,7 +7903,7 @@ dependencies = [
 
 [[package]]
 name = "reth-db"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-primitives",
@@ -7939,7 +7939,7 @@ dependencies = [
 
 [[package]]
 name = "reth-db-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-primitives",
@@ -7967,7 +7967,7 @@ dependencies = [
 
 [[package]]
 name = "reth-db-common"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-genesis",
@@ -7998,7 +7998,7 @@ dependencies = [
 
 [[package]]
 name = "reth-db-models"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eips",
  "alloy-primitives",
@@ -8014,7 +8014,7 @@ dependencies = [
 
 [[package]]
 name = "reth-discv4"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
@@ -8040,7 +8040,7 @@ dependencies = [
 
 [[package]]
 name = "reth-discv5"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
@@ -8065,7 +8065,7 @@ dependencies = [
 
 [[package]]
 name = "reth-dns-discovery"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-chains",
  "alloy-primitives",
@@ -8093,7 +8093,7 @@ dependencies = [
 
 [[package]]
 name = "reth-downloaders"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -8131,7 +8131,7 @@ dependencies = [
 
 [[package]]
 name = "reth-e2e-test-utils"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -8187,7 +8187,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ecies"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "aes",
  "alloy-primitives",
@@ -8214,7 +8214,7 @@ dependencies = [
 
 [[package]]
 name = "reth-engine-local"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-primitives",
@@ -8236,7 +8236,7 @@ dependencies = [
 
 [[package]]
 name = "reth-engine-primitives"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -8260,7 +8260,7 @@ dependencies = [
 
 [[package]]
 name = "reth-engine-tree"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eip7928 0.4.1",
@@ -8333,7 +8333,7 @@ dependencies = [
 
 [[package]]
 name = "reth-engine-util"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-primitives",
@@ -8362,7 +8362,7 @@ dependencies = [
 
 [[package]]
 name = "reth-era"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -8385,7 +8385,7 @@ dependencies = [
 
 [[package]]
 name = "reth-era-downloader"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "bytes",
@@ -8403,7 +8403,7 @@ dependencies = [
 
 [[package]]
 name = "reth-era-utils"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-primitives",
@@ -8430,7 +8430,7 @@ dependencies = [
 
 [[package]]
 name = "reth-errors"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "reth-consensus",
  "reth-execution-errors",
@@ -8440,7 +8440,7 @@ dependencies = [
 
 [[package]]
 name = "reth-eth-wire"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
@@ -8478,7 +8478,7 @@ dependencies = [
 
 [[package]]
 name = "reth-eth-wire-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
@@ -8504,7 +8504,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-rpc-types-engine",
  "alloy-rpc-types-eth",
@@ -8544,7 +8544,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum-cli"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "clap",
  "eyre",
@@ -8567,7 +8567,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum-consensus"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -8583,7 +8583,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum-engine-primitives"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eips",
  "alloy-primitives",
@@ -8599,7 +8599,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum-forks"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eip2124",
  "alloy-hardforks 0.4.7",
@@ -8612,7 +8612,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum-payload-builder"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -8641,7 +8641,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ethereum-primitives"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -8662,7 +8662,7 @@ dependencies = [
 
 [[package]]
 name = "reth-etl"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "rayon",
@@ -8672,7 +8672,7 @@ dependencies = [
 
 [[package]]
 name = "reth-evm"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eip7928 0.4.1",
@@ -8697,7 +8697,7 @@ dependencies = [
 
 [[package]]
 name = "reth-evm-ethereum"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -8719,7 +8719,7 @@ dependencies = [
 
 [[package]]
 name = "reth-execution-cache"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "fixed-cache",
@@ -8737,7 +8737,7 @@ dependencies = [
 
 [[package]]
 name = "reth-execution-errors"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-evm",
  "alloy-primitives",
@@ -8749,7 +8749,7 @@ dependencies = [
 
 [[package]]
 name = "reth-execution-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -8770,7 +8770,7 @@ dependencies = [
 
 [[package]]
 name = "reth-exex"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -8815,7 +8815,7 @@ dependencies = [
 
 [[package]]
 name = "reth-exex-test-utils"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eips",
  "eyre",
@@ -8846,7 +8846,7 @@ dependencies = [
 
 [[package]]
 name = "reth-exex-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eips",
  "alloy-primitives",
@@ -8863,7 +8863,7 @@ dependencies = [
 
 [[package]]
 name = "reth-fs-util"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -8872,7 +8872,7 @@ dependencies = [
 
 [[package]]
 name = "reth-invalid-block-hooks"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -8905,7 +8905,7 @@ dependencies = [
 
 [[package]]
 name = "reth-ipc"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "bytes",
  "futures",
@@ -8927,7 +8927,7 @@ dependencies = [
 
 [[package]]
 name = "reth-libmdbx"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "bitflags 2.11.1",
  "byteorder",
@@ -8944,7 +8944,7 @@ dependencies = [
 
 [[package]]
 name = "reth-mdbx-sys"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "bindgen",
  "cc",
@@ -8952,7 +8952,7 @@ dependencies = [
 
 [[package]]
 name = "reth-metrics"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "futures",
  "metrics",
@@ -8964,7 +8964,7 @@ dependencies = [
 
 [[package]]
 name = "reth-net-banlist"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "ipnet",
@@ -8972,7 +8972,7 @@ dependencies = [
 
 [[package]]
 name = "reth-net-nat"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "futures-util",
  "if-addrs",
@@ -8986,7 +8986,7 @@ dependencies = [
 
 [[package]]
 name = "reth-network"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -9048,7 +9048,7 @@ dependencies = [
 
 [[package]]
 name = "reth-network-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-primitives",
@@ -9072,7 +9072,7 @@ dependencies = [
 
 [[package]]
 name = "reth-network-p2p"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -9094,7 +9094,7 @@ dependencies = [
 
 [[package]]
 name = "reth-network-peers"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
@@ -9111,7 +9111,7 @@ dependencies = [
 
 [[package]]
 name = "reth-network-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eip2124",
  "humantime-serde",
@@ -9124,7 +9124,7 @@ dependencies = [
 
 [[package]]
 name = "reth-nippy-jar"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "anyhow",
  "bincode",
@@ -9142,7 +9142,7 @@ dependencies = [
 
 [[package]]
 name = "reth-node-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-rpc-types-engine",
  "eyre",
@@ -9165,7 +9165,7 @@ dependencies = [
 
 [[package]]
 name = "reth-node-builder"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -9236,7 +9236,7 @@ dependencies = [
 
 [[package]]
 name = "reth-node-core"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -9292,7 +9292,7 @@ dependencies = [
 
 [[package]]
 name = "reth-node-ethereum"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-contract",
@@ -9359,7 +9359,7 @@ dependencies = [
 
 [[package]]
 name = "reth-node-ethstats"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-primitives",
@@ -9382,7 +9382,7 @@ dependencies = [
 
 [[package]]
 name = "reth-node-events"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -9405,7 +9405,7 @@ dependencies = [
 
 [[package]]
 name = "reth-node-metrics"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "bytes",
  "eyre",
@@ -9434,7 +9434,7 @@ dependencies = [
 
 [[package]]
 name = "reth-node-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "reth-chainspec",
  "reth-db-api",
@@ -9445,7 +9445,7 @@ dependencies = [
 
 [[package]]
 name = "reth-payload-builder"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-primitives",
@@ -9468,7 +9468,7 @@ dependencies = [
 
 [[package]]
 name = "reth-payload-builder-primitives"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "pin-project",
  "reth-payload-primitives",
@@ -9479,7 +9479,7 @@ dependencies = [
 
 [[package]]
 name = "reth-payload-primitives"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -9503,7 +9503,7 @@ dependencies = [
 
 [[package]]
 name = "reth-payload-util"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-primitives",
@@ -9512,7 +9512,7 @@ dependencies = [
 
 [[package]]
 name = "reth-payload-validator"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-rpc-types-engine",
@@ -9554,7 +9554,7 @@ dependencies = [
 
 [[package]]
 name = "reth-provider"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eip7928 0.4.1",
@@ -9609,7 +9609,7 @@ dependencies = [
 
 [[package]]
 name = "reth-prune"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-primitives",
@@ -9641,11 +9641,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",
@@ -9665,7 +9665,7 @@ dependencies = [
 
 [[package]]
 name = "reth-revm"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-primitives",
@@ -9681,7 +9681,7 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-dyn-abi",
@@ -9760,7 +9760,7 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eips",
  "alloy-genesis",
@@ -9790,7 +9790,7 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-api-testing-util"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eips",
  "alloy-primitives",
@@ -9809,7 +9809,7 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-builder"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eips",
  "alloy-network",
@@ -9867,7 +9867,7 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-convert"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-evm",
@@ -9887,7 +9887,7 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-e2e-tests"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-genesis",
  "alloy-rpc-types-engine",
@@ -9907,7 +9907,7 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-engine-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eips",
  "alloy-primitives",
@@ -9943,7 +9943,7 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-eth-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-dyn-abi",
@@ -9989,7 +9989,7 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-eth-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
@@ -10041,7 +10041,7 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-layer"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-rpc-types-engine",
  "http",
@@ -10058,7 +10058,7 @@ dependencies = [
 
 [[package]]
 name = "reth-rpc-server-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eips",
  "alloy-primitives",
@@ -10088,7 +10088,7 @@ dependencies = [
 
 [[package]]
 name = "reth-stages"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -10150,7 +10150,7 @@ dependencies = [
 
 [[package]]
 name = "reth-stages-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eips",
  "alloy-primitives",
@@ -10184,7 +10184,7 @@ dependencies = [
 
 [[package]]
 name = "reth-stages-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "arbitrary",
@@ -10200,7 +10200,7 @@ dependencies = [
 
 [[package]]
 name = "reth-static-file"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "assert_matches",
@@ -10223,7 +10223,7 @@ dependencies = [
 
 [[package]]
 name = "reth-static-file-types"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "clap",
@@ -10241,7 +10241,7 @@ dependencies = [
 
 [[package]]
 name = "reth-storage-api"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eip7928 0.4.1",
@@ -10268,7 +10268,7 @@ dependencies = [
 
 [[package]]
 name = "reth-storage-errors"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eips",
  "alloy-primitives",
@@ -10285,7 +10285,7 @@ dependencies = [
 
 [[package]]
 name = "reth-storage-rpc-provider"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -10314,7 +10314,7 @@ dependencies = [
 
 [[package]]
 name = "reth-tasks"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "crossbeam-utils",
  "dashmap",
@@ -10334,7 +10334,7 @@ dependencies = [
 
 [[package]]
 name = "reth-testing-utils"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -10350,7 +10350,7 @@ dependencies = [
 
 [[package]]
 name = "reth-tokio-util"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "tokio",
  "tokio-stream",
@@ -10359,7 +10359,7 @@ dependencies = [
 
 [[package]]
 name = "reth-tracing"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "clap",
  "eyre",
@@ -10378,7 +10378,7 @@ dependencies = [
 
 [[package]]
 name = "reth-tracing-otlp"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "base64 0.22.1",
  "clap",
@@ -10396,7 +10396,7 @@ dependencies = [
 
 [[package]]
 name = "reth-transaction-pool"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -10447,7 +10447,7 @@ dependencies = [
 
 [[package]]
 name = "reth-trie"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -10480,7 +10480,7 @@ dependencies = [
 
 [[package]]
 name = "reth-trie-common"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -10513,7 +10513,7 @@ dependencies = [
 
 [[package]]
 name = "reth-trie-db"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-consensus",
  "alloy-primitives",
@@ -10544,7 +10544,7 @@ dependencies = [
 
 [[package]]
 name = "reth-trie-parallel"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-eip7928 0.4.1",
  "alloy-evm",
@@ -10578,7 +10578,7 @@ dependencies = [
 
 [[package]]
 name = "reth-trie-sparse"
-version = "2.2.0"
+version = "2.3.0"
 dependencies = [
  "alloy-primitives",
  "alloy-rlp",
diff --git a/Cargo.toml b/Cargo.toml
index 9db7b987ea5..7179547de35 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"
diff --git a/docs/vocs/vocs.config.ts b/docs/vocs/vocs.config.ts
index 7183f5c3f25..0c905d62d3d 100644
--- a/docs/vocs/vocs.config.ts
+++ b/docs/vocs/vocs.config.ts
@@ -23,7 +23,7 @@ export default defineConfig({
     { text: 'Rustdocs', link: '/docs' },
     { text: 'GitHub', link: 'https://github.com/paradigmxyz/reth' },
     {
-      text: 'v2.2.0',
+      text: 'v2.3.0',
       items: [
         {
           text: 'Releases',

From 83c45def807874e13703316d72c33450a0ea8d59 Mon Sep 17 00:00:00 2001
From: Matthieu Vachon <matt@streamingfast.io>
Date: Tue, 9 Jun 2026 15:30:03 -0400
Subject: [PATCH 333/335] fix(firehose): auto-trace in
 FirehoseBlockExecutor::execute when tracer is initialized
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Executor trait's provided execute() calls execute_one() unconditionally,
which skips inspector attachment and emits no FIRE BLOCK output for any
call site that doesn't know to call execute_and_trace_one() explicitly.

Override execute() on FirehoseBlockExecutor to check is_tracer_initialized()
and dispatch to execute_and_trace_one() when true. Any caller of execute()
on a FirehoseBlockExecutor — including the pipeline batch executor path —
now automatically emits Firehose traces without needing to be modified.
---
 crates/firehose/src/executor.rs | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/crates/firehose/src/executor.rs b/crates/firehose/src/executor.rs
index b0398ba44b7..9f5af0abb64 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::{
@@ -630,6 +630,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>,

From 9b821d9dae3414f6992bf2cd32d2577efb526773 Mon Sep 17 00:00:00 2001
From: Matthieu Vachon <matt@streamingfast.io>
Date: Wed, 10 Jun 2026 15:43:19 -0400
Subject: [PATCH 334/335] fix(engine): connect buffered blocks when backfill
 makes no progress
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When the backfill pipeline finishes with zero blocks synced (ctrl.block_number()
= None) — which is the normal outcome for OP Stack nodes that have no P2P peers
because all blocks arrive exclusively via engine_newPayload — the engine returned
early from on_backfill_sync_finished without calling try_connect_buffered_blocks.

This left every block received via newPayload during the backfill window stuck in
the block buffer indefinitely.  The engine then triggered backfill again on the
next FCU, downloaded zero blocks again, and repeated the loop forever.  Only
blocks that arrived during a brief idle window (between the failed backfill and
the next FCU) could be executed — which is why only a handful of live blocks near
the chain tip emitted FIRE BLOCK output while all historical blocks were silent.

Fix: when backfill makes no progress, call try_connect_buffered_blocks with the
current canonical head before returning.  This flushes any buffered blocks whose
parent state is already available (always true for the genesis → block 1 link on
a fresh node) through validate_block_with_state, which emits Firehose FIRE BLOCK
traces for each block.  Blocks whose parent state is not yet available are simply
re-buffered, so the change is safe for non-OP-Stack chains as well.
---
 crates/engine/tree/src/tree/mod.rs | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index cf0c814fbb5..223ca6e04db 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -1794,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

From ad1018372b6de96c34db4255fedc1f5aef6776b0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ste=CC=81phane=20Duchesneau?=
 <stephane.duchesneau@streamingfast.io>
Date: Mon, 15 Jun 2026 14:08:31 -0400
Subject: [PATCH 335/335] bump docs dependencies to address detected vulns in
 github PR

---
 docs/vocs/bun.lock     | 13 ++++++-------
 docs/vocs/package.json |  6 +++---
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/docs/vocs/bun.lock b/docs/vocs/bun.lock
index 9119416209d..9567e477fc0 100644
--- a/docs/vocs/bun.lock
+++ b/docs/vocs/bun.lock
@@ -1,14 +1,13 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "vocs",
       "dependencies": {
         "mermaid": "^11",
-        "react": "19.2.4",
-        "react-dom": "19.2.4",
-        "react-server-dom-webpack": "19.2.4",
+        "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",
       },
@@ -1226,11 +1225,11 @@
 
     "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": ["react@19.2.4", "", {}, "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ=="],
+    "react": ["react@19.2.6", "", {}, "sha512-sfWGGfavi0xr8Pg0sVsyHMAOziVYKgPLNrS7ig+ivMNb3wbCBw3KxtflsGBAwD3gYQlE/AEZsTLgToRrSCjb0Q=="],
 
     "react-devtools-inline": ["react-devtools-inline@4.4.0", "", { "dependencies": { "es6-symbol": "^3" } }, "sha512-ES0GolSrKO8wsKbsEkVeiR/ZAaHQTY4zDh1UW8DImVmm8oaGLl3ijJDvSGe+qDRKPZdPRnDtWWnSvvrgxXdThQ=="],
 
-    "react-dom": ["react-dom@19.2.4", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.4" } }, "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ=="],
+    "react-dom": ["react-dom@19.2.6", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.6" } }, "sha512-0prMI+hvBbPjsWnxDLxlCGyM8PN6UuWjEUCYmZhO67xIV9Xasa/r/vDnq+Xyq4Lo27g8QSbO5YzARu0D1Sps3g=="],
 
     "react-error-boundary": ["react-error-boundary@6.1.2", "", { "peerDependencies": { "react": "^18.0.0 || ^19.0.0" } }, "sha512-3DpCr5HVdZ0caUjYE/kIHBEJN0mNP3ZCgf16c48uJ5TbWjorKVp+YG8W3XqlJ7vJAVNw6wNIImyPXmFydwmyng=="],
 
@@ -1238,7 +1237,7 @@
 
     "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-server-dom-webpack": ["react-server-dom-webpack@19.2.4", "", { "dependencies": { "acorn-loose": "^8.3.0", "neo-async": "^2.6.1", "webpack-sources": "^3.2.0" }, "peerDependencies": { "react": "^19.2.4", "react-dom": "^19.2.4", "webpack": "^5.59.0" } }, "sha512-zEhkWv6RhXDctC2N7yEUHg3751nvFg81ydHj8LTTZuukF/IF1gcOKqqAL6Ds+kS5HtDVACYPik0IvzkgYXPhlQ=="],
+    "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=="],
 
diff --git a/docs/vocs/package.json b/docs/vocs/package.json
index ba604455cb4..5c989c5dc0e 100644
--- a/docs/vocs/package.json
+++ b/docs/vocs/package.json
@@ -14,9 +14,9 @@
   },
   "dependencies": {
     "mermaid": "^11",
-    "react": "19.2.4",
-    "react-dom": "19.2.4",
-    "react-server-dom-webpack": "19.2.4",
+    "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"
   },