From e04d895b7fbc2a3ac1672a38db9ea963469a11b5 Mon Sep 17 00:00:00 2001 From: Brian Picciano Date: Thu, 17 Sep 2026 12:58:50 +0000 Subject: [PATCH 01/10] perf(trie): skip historical trie changesets with complete overlays (#27129) (cherry picked from commit 835e42864d2f5cf375ebeacca3d279c3838971dd) --- .../src/providers/blockchain_provider.rs | 153 +++++++++++++ .../provider/src/providers/state/latest.rs | 25 ++- crates/storage/provider/src/writer/mod.rs | 12 +- crates/storage/storage-overlay/src/builder.rs | 136 +++++++++--- .../storage-overlay/src/changeset_cache.rs | 4 +- crates/storage/storage-overlay/src/manager.rs | 6 +- .../storage/storage-overlay/src/provider.rs | 208 ++++++++++-------- crates/trie/common/src/input.rs | 7 + crates/trie/db/src/proof.rs | 22 +- crates/trie/db/src/storage.rs | 27 ++- 10 files changed, 440 insertions(+), 160 deletions(-) diff --git a/crates/storage/provider/src/providers/blockchain_provider.rs b/crates/storage/provider/src/providers/blockchain_provider.rs index ac11538c2fd..318a374421a 100644 --- a/crates/storage/provider/src/providers/blockchain_provider.rs +++ b/crates/storage/provider/src/providers/blockchain_provider.rs @@ -1080,6 +1080,159 @@ mod tests { sync::Arc, }; + #[test] + fn historical_proofs_complete_masked_trie_rows() -> eyre::Result<()> { + use crate::{StaticFileProviderFactory, StaticFileSegment, StaticFileWriter}; + use reth_storage_api::{StorageSettings, StorageSettingsCache, TrieWriter}; + use reth_trie::{test_utils::TrieTestHarness, MultiProofTargetsV2}; + use revm::state::AccountInfo; + + let address = Address::with_last_byte(1); + let other_address = Address::with_last_byte(2); + let hashed_address = keccak256(address); + let account = Account { balance: U256::from(1), ..Default::default() }; + // Branches 00, 01 and 02 share the cached row at 0. The first two change + // in different blocks; the third keeps proof-v2's branch-collapse path inactive. + let slots: Vec = (0..=2u8) + .flat_map(|prefix| { + (0..u64::MAX) + .map(|slot| B256::from(U256::from(slot))) + .filter(move |slot| keccak256(slot)[0] == prefix) + .take(2) + }) + .collect(); + let mut storage: BTreeMap<_, _> = slots.iter().map(|&slot| (slot, U256::from(1))).collect(); + let mut trie = TrieTestHarness::new( + storage.iter().map(|(slot, value)| (keccak256(slot), *value)).collect(), + ); + let mut blocks = Vec::::new(); + let mut storage_roots = Vec::new(); + for number in 0..=2 { + let mut output = (*ExecutedBlock::::default() + .execution_output) + .clone(); + let (state, storage_updates) = if number == 0 { + ( + HashedPostState::default() + .with_accounts([ + (hashed_address, Some(account)), + (keccak256(other_address), Some(account)), + ]) + .with_storages([( + hashed_address, + HashedStorage::from_iter(trie.storage().iter().map(|(k, v)| (*k, *v))), + )]), + trie.storage_trie_updates().clone(), + ) + } else { + let slot = slots[(number as usize - 1) * 2]; + let value = U256::from(number + 1); + let changes = BTreeMap::from([(keccak256(slot), value)]); + let (_, updates) = trie.get_root_with_updates(&changes); + trie.apply_changeset(changes); + storage.insert(slot, value); + let info = AccountInfo::from_balance(account.balance); + output.state = BundleState::builder(number..=number) + .state_original_account_info(address, info.clone()) + .state_present_account_info(address, info) + .state_storage( + address, + std::iter::once((U256::from_be_bytes(slot.0), (U256::from(1), value))) + .collect(), + ) + .revert_storage( + number, + address, + vec![(U256::from_be_bytes(slot.0), U256::from(1))], + ) + .build(); + ( + HashedPostState::from_hashed_storage( + hashed_address, + HashedStorage::from_iter([(keccak256(slot), value)]), + ), + updates, + ) + }; + let mut updates = TrieUpdates::default(); + updates.storage_tries.insert(hashed_address, storage_updates); + let state_root = reth_trie::test_utils::state_root([ + (address, (account, storage.clone())), + (other_address, (account, BTreeMap::new())), + ]); + storage_roots.push(reth_trie::test_utils::storage_root(storage.clone())); + let block = Block { + header: alloy_consensus::Header { + number, + parent_hash: blocks + .last() + .map(|b| b.recovered_block().hash()) + .unwrap_or_default(), + state_root, + ..Default::default() + }, + ..Default::default() + }; + blocks.push(ExecutedBlock::new( + Arc::new(RecoveredBlock::new_unhashed(block, vec![])), + Arc::new(output), + ComputedTrieData::new( + Arc::new(state.into_sorted()), + Arc::new(updates.into_sorted()), + ), + )); + } + + let factory = create_test_provider_factory(); + factory.set_storage_settings_cache(StorageSettings::v2()); + let writer = factory.provider_rw()?; + writer.insert_block(blocks[0].recovered_block())?; + writer.write_hashed_state(blocks[0].hashed_state_ref())?; + writer.write_trie_updates_sorted(blocks[0].trie_updates_ref())?; + writer.commit()?; + let static_files = factory.static_file_provider(); + static_files.get_writer(0, StaticFileSegment::Receipts)?.increment_block(0)?; + static_files + .get_writer(0, StaticFileSegment::AccountChangeSets)? + .append_account_changeset(vec![], 0)?; + static_files + .get_writer(0, StaticFileSegment::StorageChangeSets)? + .append_storage_changeset(vec![], 0)?; + static_files.commit()?; + let writer = factory.provider_rw()?; + writer.save_blocks(&SaveBlocksInput::new(blocks[1..].to_vec(), 0, 0, 2, 1))?; + writer.commit()?; + factory.overlay_manager().insert_block(blocks[2].clone()); + let provider = BlockchainProvider::new(factory)?; + + for number in [1, 2] { + let state = provider.history_by_block_hash(blocks[number].recovered_block().hash())?; + let root = blocks[number].recovered_block().state_root; + state + .multiproof_v2( + Default::default(), + MultiProofTargetsV2 { + account_targets: vec![keccak256(other_address).into()], + ..Default::default() + }, + )? + .account_proof(other_address, &[])? + .verify(root)?; + assert_eq!(state.state_root(HashedPostState::default())?, root); + assert_eq!( + state.storage_root(address, HashedStorage::default())?, + storage_roots[number] + ); + state + .storage_proof(address, slots[2], HashedStorage::default())? + .verify(storage_roots[number])?; + let proof = state.storage_multiproof(address, &[slots[2]], HashedStorage::default())?; + assert_eq!(proof.root, storage_roots[number]); + proof.storage_proof(slots[2])?.verify(storage_roots[number])?; + } + Ok(()) + } + const TEST_BLOCKS_COUNT: usize = 5; const TEST_TRANSACTIONS_COUNT: u8 = 4; diff --git a/crates/storage/provider/src/providers/state/latest.rs b/crates/storage/provider/src/providers/state/latest.rs index f85b371ea72..788c60e9bd8 100644 --- a/crates/storage/provider/src/providers/state/latest.rs +++ b/crates/storage/provider/src/providers/state/latest.rs @@ -153,7 +153,14 @@ impl StorageRootProvider hashed_storage: HashedStorage, ) -> ProviderResult { reth_trie_db::with_adapter!(self.0, |A| { - >::overlay_root(self.tx(), address, hashed_storage) + let input = TrieInputSorted::from_state( + HashedPostState::from_hashed_storage( + alloy_primitives::keccak256(address), + hashed_storage, + ) + .into_sorted(), + ); + >::overlay_root(self.tx(), address, input) .map_err(|err| ProviderError::Database(err.into())) }) } @@ -182,13 +189,15 @@ impl StorageRootProvider hashed_storage: HashedStorage, ) -> ProviderResult { reth_trie_db::with_adapter!(self.0, |A| { - >::overlay_storage_multiproof( - self.tx(), - address, - slots, - hashed_storage, - ) - .map_err(ProviderError::from) + let input = TrieInputSorted::from_state( + HashedPostState::from_hashed_storage( + alloy_primitives::keccak256(address), + hashed_storage, + ) + .into_sorted(), + ); + >::overlay_storage_multiproof(self.tx(), address, slots, input) + .map_err(ProviderError::from) }) } } diff --git a/crates/storage/provider/src/writer/mod.rs b/crates/storage/provider/src/writer/mod.rs index ef8fb25013b..b5a313c4448 100644 --- a/crates/storage/provider/src/writer/mod.rs +++ b/crates/storage/provider/src/writer/mod.rs @@ -20,6 +20,7 @@ mod tests { use reth_trie::{ test_utils::{state_root, storage_root_prehashed}, HashedPostState, HashedStorage, StateRoot, StorageRoot, StorageRootProgress, + TrieInputSorted, }; use reth_trie_db::{DatabaseStateRoot, DatabaseStorageRoot, LegacyKeyAdapter, PackedKeyAdapter}; use revm::database::{ @@ -1186,18 +1187,25 @@ mod tests { reth_trie_db::DatabaseHashedCursorFactory<&'a TX>, >; let is_v2 = provider_rw.cached_storage_settings().is_v2(); + let input = TrieInputSorted::from_state(HashedPostState::from_hashed_storage( + hashed_address, + updated_storage.clone(), + ).into_sorted()); let storage_root = if is_v2 { TestStorageRoot::<_, _, PackedKeyAdapter>::overlay_root( tx, address, - updated_storage.clone(), + input, ) .unwrap() } else { TestStorageRoot::<_, _, LegacyKeyAdapter>::overlay_root( tx, address, - updated_storage.clone(), + TrieInputSorted::from_state(HashedPostState::from_hashed_storage( + hashed_address, + updated_storage.clone(), + ).into_sorted()), ) .unwrap() }; diff --git a/crates/storage/storage-overlay/src/builder.rs b/crates/storage/storage-overlay/src/builder.rs index d56fc0b4d7f..b78df88c9d3 100644 --- a/crates/storage/storage-overlay/src/builder.rs +++ b/crates/storage/storage-overlay/src/builder.rs @@ -1,4 +1,7 @@ -use crate::{manager::OverlayCacheConfig, OverlayManager}; +use crate::{ + manager::{OverlayCacheConfig, StateTrieOverlayError}, + OverlayManager, +}; use alloy_eips::BlockNumHash; use alloy_primitives::{ map::{AddressMap, AddressSet, B256Map, U256Map}, @@ -16,7 +19,7 @@ use reth_storage_api::{ BlockNumReader, ChangeSetReader, DBProvider, PruneCheckpointReader, StageCheckpointReader, StorageChangeSetReader, StorageSettingsCache, }; -use reth_trie::{updates::TrieUpdatesSorted, HashedPostStateSorted}; +use reth_trie::{updates::TrieUpdatesSorted, HashedPostStateSorted, TrieInputSorted}; use reth_trie_db::DatabaseHashedPostState; use revm::{bytecode::Bytecode, database::BundleState, state::AccountInfo}; use std::{ @@ -29,28 +32,23 @@ use tracing::{debug, debug_span, instrument}; /// Contains the trie and hashed-state data required to initialize an overlay state provider. #[derive(Debug, Clone)] pub struct StateTrieOverlay { - /// Trie updates overlay. - pub trie_updates: Arc, - /// Hashed state overlay. - pub hashed_post_state: Arc, + input: TrieInputSorted, /// Whether construction was skipped because a reused sparse trie covers this range. skipped_for_reused_sparse_trie: bool, } impl StateTrieOverlay { - pub(crate) const fn new( - trie_updates: Arc, - hashed_post_state: Arc, - ) -> Self { - Self { trie_updates, hashed_post_state, skipped_for_reused_sparse_trie: false } + pub(crate) const fn new(input: TrieInputSorted) -> Self { + Self { input, skipped_for_reused_sparse_trie: false } } fn empty() -> Self { - Self { - trie_updates: Arc::new(TrieUpdatesSorted::default()), - hashed_post_state: Arc::new(HashedPostStateSorted::default()), - skipped_for_reused_sparse_trie: true, - } + Self { input: TrieInputSorted::default(), skipped_for_reused_sparse_trie: true } + } + + /// Returns the trie input represented by this overlay. + pub const fn input(&self) -> &TrieInputSorted { + &self.input } pub(crate) const fn skipped_for_reused_sparse_trie(&self) -> bool { @@ -393,11 +391,17 @@ impl OverlayBuilder { } /// Builds the effective state trie overlay for the given provider. + /// + /// Set `trie_changesets` only for consumers that produce [`TrieUpdates`], such as + /// [`StateRootProvider::state_root_with_updates`]. Other consumers, including roots, proofs, + /// multiproofs, and witnesses, should leave it false: complete the cached trie at Finish and + /// invalidate hashed-state revert prefixes instead of querying trie changesets. #[cfg(test)] #[instrument(level = "debug", target = "storage::overlay", skip_all)] fn build_state_trie_overlay( &self, provider: &Provider, + trie_changesets: bool, ) -> ProviderResult where Provider: StageCheckpointReader @@ -409,7 +413,12 @@ impl OverlayBuilder { + StorageSettingsCache, { let (state_trie_tip_block, finish_tip_block) = database_state_frontiers(provider)?; - self.build_state_trie_overlay_at_frontiers(provider, state_trie_tip_block, finish_tip_block) + self.build_state_trie_overlay_at_frontiers( + provider, + state_trie_tip_block, + finish_tip_block, + trie_changesets, + ) } /// Builds the effective state trie overlay using frontiers already read from the provider. @@ -426,6 +435,7 @@ impl OverlayBuilder { provider: &Provider, state_trie_tip_block: BlockNumHash, finish_tip_block: BlockNumHash, + trie_changesets: bool, ) -> ProviderResult where Provider: ChangeSetReader @@ -445,7 +455,7 @@ impl OverlayBuilder { self.anchor_at_parent_with_frontiers(provider, state_trie_tip_block, finish_tip_block)?; // Collect any reverts which are required to bring the DB view back to the anchor hash. - let (trie_updates, hashed_post_state) = match &anchor_for_parent { + let (trie_updates, hashed_post_state, prefix_sets) = match &anchor_for_parent { AnchorForParent::RevertsRequired { anchor, .. } => { let revert_blocks = self.revert_blocks(&anchor_for_parent)?.expect("reverts are required"); @@ -457,7 +467,7 @@ impl OverlayBuilder { "Collecting trie reverts for overlay state provider" ); - let trie_reverts = { + let trie_reverts = if trie_changesets { let _guard = debug_span!(target: "storage::overlay", "retrieving_trie_reverts") .entered(); let start = Instant::now(); @@ -470,6 +480,32 @@ impl OverlayBuilder { )?; retrieve_trie_reverts_duration = start.elapsed(); accumulated_reverts + } else if state_trie_tip_block == finish_tip_block { + retrieve_trie_reverts_duration = Duration::ZERO; + Arc::default() + } else { + // Revert prefixes describe changes since the anchor, not stale hashes in + // masked DB rows. Complete the trie at Finish before applying those prefixes. + let start = Instant::now(); + let finish_state = self + .overlay_manager + .block_state(finish_tip_block.hash) + .ok_or_else(|| { + ProviderError::other(StateTrieOverlayError { + tip_hash: finish_tip_block.hash, + anchor_hash: state_trie_tip_block.hash, + }) + })?; + let (nodes, _) = self + .overlay_manager + .overlay_for_parent( + &finish_state, + state_trie_tip_block.hash, + OverlayCacheConfig::default(), + ) + .map_err(ProviderError::other)?; + retrieve_trie_reverts_duration = start.elapsed(); + nodes }; let mut hashed_state_reverts = { @@ -482,6 +518,12 @@ impl OverlayBuilder { res }; + let prefix_sets = if trie_changesets { + Default::default() + } else { + hashed_state_reverts.construct_prefix_sets() + }; + // Resolve overlays and extend reverts with them. If reverts are empty, use overlays // directly to avoid cloning. let (overlay_trie, overlay_state) = @@ -517,7 +559,7 @@ impl OverlayBuilder { "Reverted to anchor block", ); - (trie_updates, hashed_state_updates) + (trie_updates, hashed_state_updates, prefix_sets) } AnchorForParent::NoReverts { anchor } => { // If no reverts are needed, use the manager overlay directly unless the reused @@ -548,7 +590,7 @@ impl OverlayBuilder { "Built overlay directly from durable frontier" ); - (trie_updates, hashed_post_state) + (trie_updates, hashed_post_state, Default::default()) } }; @@ -561,7 +603,11 @@ impl OverlayBuilder { self.metrics.trie_updates_size.record(trie_updates_total_len as f64); self.metrics.hashed_state_size.record(hashed_state_updates_total_len as f64); - Ok(StateTrieOverlay::new(trie_updates, hashed_post_state)) + Ok(StateTrieOverlay::new(TrieInputSorted::new( + trie_updates, + hashed_post_state, + prefix_sets, + ))) } /// Returns the in-memory execution overlay and the block for historical fallback reads. @@ -892,11 +938,11 @@ mod tests { } fn account_keys(overlay: &StateTrieOverlay) -> Vec { - overlay.hashed_post_state.accounts.iter().map(|(key, _)| *key).collect() + overlay.input().state.accounts.iter().map(|(key, _)| *key).collect() } fn account_node_paths(overlay: &StateTrieOverlay) -> Vec { - overlay.trie_updates.account_nodes_ref().iter().map(|(path, _)| *path).collect() + overlay.input().nodes.account_nodes_ref().iter().map(|(path, _)| *path).collect() } #[test] @@ -1013,7 +1059,7 @@ mod tests { for (parent_index, expected_ids) in [(3, vec![3, 4]), (4, vec![3, 4, 5])] { let overlay = manager .overlay_builder(blocks[parent_index].recovered_block().hash()) - .build_state_trie_overlay(&provider) + .build_state_trie_overlay(&provider, true) .unwrap(); assert_eq!( @@ -1041,11 +1087,11 @@ mod tests { let overlay = manager .overlay_builder(blocks[4].recovered_block().hash()) .with_skip_overlay_for_reused_sparse_trie(blocks[3].recovered_block().hash()) - .build_state_trie_overlay(&provider) + .build_state_trie_overlay(&provider, true) .unwrap(); - assert!(overlay.hashed_post_state.is_empty()); - assert!(overlay.trie_updates.is_empty()); + assert!(overlay.input().state.is_empty()); + assert!(overlay.input().nodes.is_empty()); } #[test] @@ -1056,7 +1102,7 @@ mod tests { let builder = OverlayManager::::default() .overlay_builder(blocks[1].recovered_block().hash()) .with_no_reverts(); - let error = builder.build_state_trie_overlay(&provider).unwrap_err(); + let error = builder.build_state_trie_overlay(&provider, true).unwrap_err(); assert!(error.to_string().contains("reverts are disabled")); } @@ -1077,11 +1123,37 @@ mod tests { Err(ProviderError::BlockHashNotFound(hash)) if hash == parent_hash )); assert!(matches!( - builder.build_state_trie_overlay(&provider), + builder.build_state_trie_overlay(&provider, true), Err(ProviderError::BlockHashNotFound(hash)) if hash == parent_hash )); } + #[test] + fn state_trie_overlay_uses_revert_prefix_sets_without_trie_changesets() { + let (factory, blocks) = setup_frontiers(3, 3); + let provider_rw = factory.provider_rw().unwrap(); + provider_rw + .tx_ref() + .put::( + 3, + AccountBeforeTx { + address: Address::with_last_byte(1), + info: Some(Account::default()), + }, + ) + .unwrap(); + provider_rw.commit().unwrap(); + + let provider = factory.provider().unwrap(); + let overlay = OverlayManager::::default() + .overlay_builder(blocks[1].recovered_block().hash()) + .build_state_trie_overlay(&provider, false) + .unwrap(); + + assert!(overlay.input().nodes.is_empty()); + assert!(!overlay.input().prefix_sets.is_empty()); + } + #[test] fn execution_overlay_marks_historical_fallback() { let (factory, blocks) = setup_frontiers(1, 3); @@ -1276,7 +1348,7 @@ mod tests { let provider = factory.provider().unwrap(); let error = OverlayManager::::default() .overlay_builder(blocks[3].recovered_block().hash()) - .build_state_trie_overlay(&provider) + .build_state_trie_overlay(&provider, true) .unwrap_err(); assert!( @@ -1292,7 +1364,7 @@ mod tests { let parent_hash = blocks[3].recovered_block().hash(); let error = OverlayManager::::default() .overlay_builder(parent_hash) - .build_state_trie_overlay(&provider) + .build_state_trie_overlay(&provider, true) .unwrap_err(); assert!(error.to_string().contains("is after partial state trie frontier")); diff --git a/crates/storage/storage-overlay/src/changeset_cache.rs b/crates/storage/storage-overlay/src/changeset_cache.rs index c2e070fd4b1..69191d65ae9 100644 --- a/crates/storage/storage-overlay/src/changeset_cache.rs +++ b/crates/storage/storage-overlay/src/changeset_cache.rs @@ -403,7 +403,7 @@ impl ChangesetCache { let overlay = overlay_manager .overlay_builder(finish.hash) .with_no_reverts() - .build_state_trie_overlay_at_frontiers(provider, partial_state_trie, finish)?; + .build_state_trie_overlay_at_frontiers(provider, partial_state_trie, finish, true)?; let state_trie_provider = OverlayStateProvider::<&P, N>::new_with_state_trie( provider, overlay, @@ -644,7 +644,7 @@ mod tests { } fn empty_overlay() -> StateTrieOverlay { - StateTrieOverlay::new(Arc::default(), Arc::default()) + StateTrieOverlay::new(TrieInputSorted::default()) } fn insert_test_changesets( diff --git a/crates/storage/storage-overlay/src/manager.rs b/crates/storage/storage-overlay/src/manager.rs index 0e942dacdf7..8eb63374718 100644 --- a/crates/storage/storage-overlay/src/manager.rs +++ b/crates/storage/storage-overlay/src/manager.rs @@ -99,7 +99,7 @@ impl OverlayManager { OverlayBuilder::new(parent_hash, self.block_state(parent_hash), self.clone()) } - fn block_state(&self, parent_hash: B256) -> Option> { + pub(crate) fn block_state(&self, parent_hash: B256) -> Option> { let mut blocks = self.parent_chain(parent_hash).collect::>(); blocks.pop().map(|oldest| { blocks.into_iter().rev().fold(BlockState::new(oldest), |parent, block| { @@ -685,9 +685,9 @@ impl Default for OverlayCacheConfig { #[derive(Debug)] pub(crate) struct StateTrieOverlayError { /// Requested in-memory tip hash. - tip_hash: B256, + pub(crate) tip_hash: B256, /// Requested anchor hash. - anchor_hash: B256, + pub(crate) anchor_hash: B256, } impl fmt::Display for StateTrieOverlayError { diff --git a/crates/storage/storage-overlay/src/provider.rs b/crates/storage/storage-overlay/src/provider.rs index 578e4453560..cf2614c56a7 100644 --- a/crates/storage/storage-overlay/src/provider.rs +++ b/crates/storage/storage-overlay/src/provider.rs @@ -52,7 +52,7 @@ pub struct OverlayStateProviderFactory { factory: F, /// Overlay builder containing the configuration and overlay calculation logic. overlay_builder: OverlayBuilder, - /// A cache mapping `(state_trie_tip, finish_tip)` to [`StateTrieOverlay`]. + /// A cache mapping `(state_trie_tip, finish_tip, trie_changesets)` to [`StateTrieOverlay`]. /// /// Under partial persistence the overlay depends on both durable frontiers, so both hashes are /// part of the cache key. @@ -129,6 +129,7 @@ pub struct OverlayStateProvider { state_trie_overlay_cache: StateTrieOverlayCache, metrics: OverlayStateProviderFactoryMetrics, state_trie_overlay: OnceCell, + state_trie_overlay_with_trie_changesets: OnceCell, execution_overlay: OnceCell, is_v2: bool, } @@ -162,6 +163,7 @@ impl OverlayStateProvider, state_trie_overlay_cache, metrics, state_trie_overlay: OnceCell::new(), + state_trie_overlay_with_trie_changesets: OnceCell::new(), execution_overlay: OnceCell::new(), is_v2, } @@ -179,6 +181,7 @@ impl OverlayStateProvider, state_trie_overlay_cache: Default::default(), metrics: Default::default(), state_trie_overlay: OnceCell::new(), + state_trie_overlay_with_trie_changesets: OnceCell::new(), execution_overlay: OnceCell::from(CachedExecutionOverlay { overlay: execution_overlay, historical_fallback: None, @@ -201,6 +204,7 @@ impl<'a, Provider, N: NodePrimitives> OverlayStateProvider<&'a Provider, N> { state_trie_overlay_cache: Default::default(), metrics: Default::default(), state_trie_overlay: OnceCell::new(), + state_trie_overlay_with_trie_changesets: OnceCell::new(), execution_overlay: OnceCell::new(), is_v2, } @@ -216,7 +220,8 @@ impl<'a, Provider, N: NodePrimitives> OverlayStateProvider<&'a Provider, N> { overlay_builder: None, state_trie_overlay_cache: Default::default(), metrics: Default::default(), - state_trie_overlay: OnceCell::from(state_trie_overlay), + state_trie_overlay: OnceCell::from(state_trie_overlay.clone()), + state_trie_overlay_with_trie_changesets: OnceCell::from(state_trie_overlay), execution_overlay: OnceCell::new(), is_v2, } @@ -232,7 +237,7 @@ where &self.provider } - fn state_trie_overlay(&self) -> ProviderResult<&StateTrieOverlay> + fn state_trie_overlay(&self, trie_changesets: bool) -> ProviderResult<&StateTrieOverlay> where Provider::Target: StageCheckpointReader + PruneCheckpointReader @@ -242,15 +247,17 @@ where + BlockNumReader + StorageSettingsCache, { - if let Some(overlay) = self.state_trie_overlay.get() { + let state_trie_overlay = self.state_trie_overlay_mut(trie_changesets); + if let Some(overlay) = state_trie_overlay.get() { return Ok(overlay) } let (state_trie_tip_block, finish_tip_block) = database_state_frontiers(self.provider())?; - let overlay = match self - .state_trie_overlay_cache - .entry((state_trie_tip_block.hash, finish_tip_block.hash)) - { + let overlay = match self.state_trie_overlay_cache.entry(( + state_trie_tip_block.hash, + finish_tip_block.hash, + trie_changesets, + )) { dashmap::Entry::Occupied(entry) => entry.get().clone(), dashmap::Entry::Vacant(entry) => { self.metrics.state_trie_overlay_cache_misses.increment(1); @@ -262,6 +269,7 @@ where self.provider(), state_trie_tip_block, finish_tip_block, + trie_changesets, )?; if !overlay.skipped_for_reused_sparse_trie() { entry.insert(overlay.clone()); @@ -269,11 +277,23 @@ where overlay } }; - let _ = self.state_trie_overlay.set(overlay); - Ok(self.state_trie_overlay.get().expect("state trie overlay was just initialized")) + let _ = state_trie_overlay.set(overlay); + Ok(state_trie_overlay.get().expect("state trie overlay was just initialized")) + } + + const fn state_trie_overlay_mut(&self, trie_changesets: bool) -> &OnceCell { + if trie_changesets { + &self.state_trie_overlay_with_trie_changesets + } else { + &self.state_trie_overlay + } } - fn build_overlay(&self, input: TrieInputSorted) -> ProviderResult + fn build_overlay( + &self, + input: TrieInputSorted, + trie_changesets: bool, + ) -> ProviderResult where Provider::Target: StageCheckpointReader + PruneCheckpointReader @@ -283,13 +303,14 @@ where + BlockNumReader + StorageSettingsCache, { - let overlay = self.state_trie_overlay()?; + let overlay = self.state_trie_overlay(trie_changesets)?; if overlay.skipped_for_reused_sparse_trie() { return Err(ProviderError::UnsupportedProvider) } - let TrieInputSorted { nodes: input_nodes, state: input_state, prefix_sets } = input; - let mut nodes = Arc::clone(&overlay.trie_updates); - let mut state = Arc::clone(&overlay.hashed_post_state); + let TrieInputSorted { nodes: input_nodes, state: input_state, mut prefix_sets } = input; + let overlay_input = overlay.input(); + let mut nodes = Arc::clone(&overlay_input.nodes); + let mut state = Arc::clone(&overlay_input.state); if !input_nodes.is_empty() { Arc::make_mut(&mut nodes).extend_ref_and_sort(&input_nodes); @@ -298,6 +319,7 @@ where Arc::make_mut(&mut state).extend_ref_and_sort(&input_state); } + prefix_sets.extend_ref(&overlay_input.prefix_sets); Ok(TrieInputSorted::new(nodes, state, prefix_sets)) } @@ -511,16 +533,15 @@ where { fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted( - TrieInput::from_state(hashed_state), - ))?; + let input = + self.build_overlay(TrieInputSorted::from_state(hashed_state.into_sorted()), false)?; Ok(>::overlay_root_from_nodes(self.provider().tx(), input)?) }) } fn state_root_from_nodes(&self, input: TrieInput) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted(input))?; + let input = self.build_overlay(TrieInputSorted::from_unsorted(input), false)?; Ok( as DatabaseStateRoot<_>>::overlay_root_from_nodes( self.provider().tx(), input, @@ -533,9 +554,8 @@ where hashed_state: HashedPostState, ) -> ProviderResult<(B256, TrieUpdates)> { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted( - TrieInput::from_state(hashed_state), - ))?; + let input = + self.build_overlay(TrieInputSorted::from_state(hashed_state.into_sorted()), true)?; Ok(>::overlay_root_from_nodes_with_updates( self.provider().tx(), input, @@ -548,7 +568,7 @@ where input: TrieInput, ) -> ProviderResult<(B256, TrieUpdates)> { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted(input))?; + let input = self.build_overlay(TrieInputSorted::from_unsorted(input), true)?; Ok( as DatabaseStateRoot<_>>::overlay_root_from_nodes_with_updates( self.provider().tx(), @@ -576,20 +596,15 @@ where hashed_storage: HashedStorage, ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted( - TrieInput::from_state(HashedPostState::from_hashed_storage( - alloy_primitives::keccak256(address), - hashed_storage, - )), - ))?; - let hashed_storage = input - .state - .account_storages() - .get(&alloy_primitives::keccak256(address)) - .cloned() - .unwrap_or_default() - .into(); - >::overlay_root(self.provider().tx(), address, hashed_storage) + let hashed_address = alloy_primitives::keccak256(address); + let input = self.build_overlay( + TrieInputSorted::from_state( + HashedPostState::from_hashed_storage(hashed_address, hashed_storage) + .into_sorted(), + ), + false, + )?; + >::overlay_root(self.provider().tx(), address, input) .map_err(|err| ProviderError::Database(err.into())) }) } @@ -600,28 +615,9 @@ where slot: B256, hashed_storage: HashedStorage, ) -> ProviderResult { - reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted( - TrieInput::from_state(HashedPostState::from_hashed_storage( - alloy_primitives::keccak256(address), - hashed_storage, - )), - ))?; - let hashed_storage = input - .state - .account_storages() - .get(&alloy_primitives::keccak256(address)) - .cloned() - .unwrap_or_default() - .into(); - >::overlay_storage_proof( - self.provider().tx(), - address, - slot, - hashed_storage, - ) + self.storage_multiproof(address, &[slot], hashed_storage)? + .storage_proof(slot) .map_err(ProviderError::from) - }) } fn storage_multiproof( @@ -631,24 +627,19 @@ where hashed_storage: HashedStorage, ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted( - TrieInput::from_state(HashedPostState::from_hashed_storage( - alloy_primitives::keccak256(address), - hashed_storage, - )), - ))?; - let hashed_storage = input - .state - .account_storages() - .get(&alloy_primitives::keccak256(address)) - .cloned() - .unwrap_or_default() - .into(); + let hashed_address = alloy_primitives::keccak256(address); + let input = self.build_overlay( + TrieInputSorted::from_state( + HashedPostState::from_hashed_storage(hashed_address, hashed_storage) + .into_sorted(), + ), + false, + )?; >::overlay_storage_multiproof( self.provider().tx(), address, slots, - hashed_storage, + input, ) .map_err(ProviderError::from) }) @@ -674,7 +665,7 @@ where ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { let TrieInputSorted { nodes, state, prefix_sets } = - self.build_overlay(TrieInputSorted::from_unsorted(input))?; + self.build_overlay(TrieInputSorted::from_unsorted(input), false)?; let input = TrieInput::new( Arc::unwrap_or_clone(nodes).into(), Arc::unwrap_or_clone(state).into(), @@ -692,7 +683,7 @@ where ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { let TrieInputSorted { nodes, state, prefix_sets } = - self.build_overlay(TrieInputSorted::from_unsorted(input))?; + self.build_overlay(TrieInputSorted::from_unsorted(input), false)?; let input = TrieInput::new( Arc::unwrap_or_clone(nodes).into(), Arc::unwrap_or_clone(state).into(), @@ -710,7 +701,7 @@ where ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { let TrieInputSorted { nodes, state, prefix_sets } = - self.build_overlay(TrieInputSorted::from_unsorted(input))?; + self.build_overlay(TrieInputSorted::from_unsorted(input), false)?; let input = TrieInput::new( Arc::unwrap_or_clone(nodes).into(), Arc::unwrap_or_clone(state).into(), @@ -729,7 +720,7 @@ where ) -> ProviderResult> { reth_trie_db::with_adapter!(self.provider(), |A| { let TrieInputSorted { nodes, state, prefix_sets } = - self.build_overlay(TrieInputSorted::from_unsorted(input))?; + self.build_overlay(TrieInputSorted::from_unsorted(input), false)?; let witness = TrieWitness::new( InMemoryTrieCursorFactory::new( DatabaseTrieCursorFactory::<_, A>::new(self.provider().tx()), @@ -778,7 +769,7 @@ where return Ok(hashed_state) } - let overlay_state = self.build_overlay(TrieInputSorted::default())?.state; + let overlay_state = self.build_overlay(TrieInputSorted::default(), false)?.state; zero_destroyed_account_storage( &HashedPostStateCursorFactory::new( DatabaseHashedCursorFactory::new(self.provider().tx()), @@ -893,7 +884,7 @@ where Self: 'a; fn account_trie_cursor(&self) -> Result, DatabaseError> { - let overlay = self.state_trie_overlay().map_err(into_database_error)?; + let overlay = self.state_trie_overlay(true).map_err(into_database_error)?; let cursor: Box = if self.is_v2 { Box::new(DatabaseAccountTrieCursor::<_, PackedKeyAdapter>::new( self.provider().tx().cursor_read::()?, @@ -903,14 +894,14 @@ where self.provider().tx().cursor_read::()?, )) }; - Ok(InMemoryTrieCursor::new_account(cursor, &overlay.trie_updates)) + Ok(InMemoryTrieCursor::new_account(cursor, &overlay.input().nodes)) } fn storage_trie_cursor( &self, hashed_address: B256, ) -> Result, DatabaseError> { - let overlay = self.state_trie_overlay().map_err(into_database_error)?; + let overlay = self.state_trie_overlay(true).map_err(into_database_error)?; let cursor: Box = if self.is_v2 { Box::new(DatabaseStorageTrieCursor::<_, PackedKeyAdapter>::new( self.provider().tx().cursor_dup_read::()?, @@ -922,7 +913,7 @@ where hashed_address, )) }; - Ok(InMemoryTrieCursor::new_storage(cursor, &overlay.trie_updates, hashed_address)) + Ok(InMemoryTrieCursor::new_storage(cursor, &overlay.input().nodes, hashed_address)) } } @@ -954,10 +945,10 @@ where Self: 'a; fn hashed_account_cursor(&self) -> Result, DatabaseError> { - let overlay = self.state_trie_overlay().map_err(into_database_error)?; + let overlay = self.state_trie_overlay(true).map_err(into_database_error)?; HashedPostStateCursorFactory::new( DatabaseHashedCursorFactory::new(self.provider().tx()), - &overlay.hashed_post_state, + &overlay.input().state, ) .hashed_account_cursor() } @@ -966,10 +957,10 @@ where &self, hashed_address: B256, ) -> Result, DatabaseError> { - let overlay = self.state_trie_overlay().map_err(into_database_error)?; + let overlay = self.state_trie_overlay(true).map_err(into_database_error)?; HashedPostStateCursorFactory::new( DatabaseHashedCursorFactory::new(self.provider().tx()), - &overlay.hashed_post_state, + &overlay.input().state, ) .hashed_storage_cursor(hashed_address) } @@ -987,7 +978,7 @@ pub(crate) struct OverlayStateProviderFactoryMetrics { state_trie_overlay_cache_misses: Counter, } -type StateTrieOverlayCache = Arc>; +type StateTrieOverlayCache = Arc>; #[derive(Clone, Debug)] struct CachedExecutionOverlay { @@ -1122,11 +1113,11 @@ mod tests { } fn account_keys(overlay: &StateTrieOverlay) -> Vec { - overlay.hashed_post_state.accounts.iter().map(|(key, _)| *key).collect() + overlay.input().state.accounts.iter().map(|(key, _)| *key).collect() } fn account_node_paths(overlay: &StateTrieOverlay) -> Vec { - overlay.trie_updates.account_nodes_ref().iter().map(|(path, _)| *path).collect() + overlay.input().nodes.account_nodes_ref().iter().map(|(path, _)| *path).collect() } #[test] @@ -1142,7 +1133,7 @@ mod tests { ); let provider = state_provider_factory.database_provider_ro().unwrap(); - let first = provider.state_trie_overlay().unwrap().clone(); + let first = provider.state_trie_overlay(false).unwrap().clone(); assert_eq!(account_keys(&first), vec![B256::with_last_byte(3), B256::with_last_byte(4)]); drop(provider); @@ -1158,7 +1149,7 @@ mod tests { provider_rw.commit().unwrap(); let provider = state_provider_factory.database_provider_ro().unwrap(); - let second = provider.state_trie_overlay().unwrap().clone(); + let second = provider.state_trie_overlay(false).unwrap().clone(); assert_eq!(account_keys(&second), vec![B256::with_last_byte(4)]); assert_eq!(account_node_paths(&second), vec![Nibbles::from_nibbles([4])]); assert_eq!(state_provider_factory.state_trie_overlay_cache.len(), 2); @@ -1191,6 +1182,39 @@ mod tests { assert_eq!(state_provider_factory.state_trie_overlay_cache.len(), 1); } + #[test] + fn state_trie_overlay_cache_is_keyed_by_trie_changesets() { + let (factory, blocks) = setup_frontiers(1, 3); + let manager = OverlayManager::default(); + for block in &blocks[2..=3] { + manager.insert_block(block.clone()); + } + let state_provider_factory = OverlayStateProviderFactory::new( + factory, + manager.overlay_builder(blocks[3].recovered_block().hash()), + ); + let provider = state_provider_factory.database_provider_ro().unwrap(); + + provider.state_trie_overlay(false).unwrap(); + provider.state_trie_overlay(true).unwrap(); + + assert_eq!(state_provider_factory.state_trie_overlay_cache.len(), 2); + } + + #[test] + fn supplied_state_trie_overlay_is_available_in_both_modes() { + let (factory, _) = setup_frontiers(1, 1); + let provider = factory.provider().unwrap(); + let provider = OverlayStateProvider::<&_, EthPrimitives>::new_with_state_trie( + &provider, + StateTrieOverlay::new(TrieInputSorted::default()), + false, + ); + + assert!(provider.state_trie_overlay(false).is_ok()); + assert!(provider.state_trie_overlay(true).is_ok()); + } + #[test] fn lazy_overlays_survive_manager_block_removal() { let (factory, blocks) = setup_frontiers(1, 1); @@ -1212,7 +1236,7 @@ mod tests { [blocks[2].recovered_block().num_hash(), blocks[3].recovered_block().num_hash()] ); assert_eq!( - account_keys(provider.state_trie_overlay().unwrap()), + account_keys(provider.state_trie_overlay(false).unwrap()), vec![B256::with_last_byte(3), B256::with_last_byte(4)] ); } @@ -1230,7 +1254,7 @@ mod tests { ); let provider = state_provider_factory.database_provider_ro().unwrap(); - assert!(provider.state_trie_overlay().unwrap().skipped_for_reused_sparse_trie()); + assert!(provider.state_trie_overlay(false).unwrap().skipped_for_reused_sparse_trie()); assert!(state_provider_factory.state_trie_overlay_cache.is_empty()); assert!(matches!( provider.state_root(HashedPostState::default()), diff --git a/crates/trie/common/src/input.rs b/crates/trie/common/src/input.rs index 3d3bc2349d3..d9f8f41f46b 100644 --- a/crates/trie/common/src/input.rs +++ b/crates/trie/common/src/input.rs @@ -160,6 +160,13 @@ impl TrieInputSorted { Self { nodes, state, prefix_sets } } + /// Create new sorted trie input from sorted in-memory state. The prefix sets will be + /// constructed and set automatically. + pub fn from_state(state: HashedPostStateSorted) -> Self { + let prefix_sets = state.construct_prefix_sets(); + Self { nodes: Default::default(), state: Arc::new(state), prefix_sets } + } + /// Create from unsorted [`TrieInput`] by sorting. pub fn from_unsorted(input: TrieInput) -> Self { Self { diff --git a/crates/trie/db/src/proof.rs b/crates/trie/db/src/proof.rs index f362692963d..934c3fecd4e 100644 --- a/crates/trie/db/src/proof.rs +++ b/crates/trie/db/src/proof.rs @@ -7,7 +7,7 @@ use reth_trie::{ proof::{Proof, StorageProof}, trie_cursor::InMemoryTrieCursorFactory, AccountProof, DecodedMultiProofV2, HashedPostStateSorted, HashedStorage, MultiProof, - MultiProofTargets, MultiProofTargetsV2, StorageMultiProof, TrieInput, + MultiProofTargets, MultiProofTargetsV2, StorageMultiProof, TrieInput, TrieInputSorted, }; /// Extends [`Proof`] with operations specific for working with a database transaction. @@ -114,7 +114,7 @@ pub trait DatabaseStorageProof<'a, TX> { tx: &'a TX, address: Address, slots: &[B256], - storage: HashedStorage, + input: TrieInputSorted, ) -> Result; } @@ -158,21 +158,21 @@ impl<'a, TX: DbTx, A: TrieTableAdapter> DatabaseStorageProof<'a, TX> tx: &'a TX, address: Address, slots: &[B256], - storage: HashedStorage, + mut input: TrieInputSorted, ) -> Result { let hashed_address = keccak256(address); let targets = slots.iter().map(keccak256).collect(); - let prefix_set = storage.construct_prefix_set(); - let state_sorted = HashedPostStateSorted::new( - Default::default(), - HashMap::from_iter([(hashed_address, storage.into_sorted())]), - ); StorageProof::new( - DatabaseTrieCursorFactory::<_, A>::new(tx), - HashedPostStateCursorFactory::new(DatabaseHashedCursorFactory::new(tx), &state_sorted), + InMemoryTrieCursorFactory::new( + DatabaseTrieCursorFactory::<_, A>::new(tx), + &input.nodes, + ), + HashedPostStateCursorFactory::new(DatabaseHashedCursorFactory::new(tx), &input.state), address, ) - .with_prefix_set_mut(prefix_set) + .with_prefix_set_mut( + input.prefix_sets.storage_prefix_sets.remove(&hashed_address).unwrap_or_default(), + ) .storage_multiproof(targets) } } diff --git a/crates/trie/db/src/storage.rs b/crates/trie/db/src/storage.rs index 884d6f15565..e634723f1b2 100644 --- a/crates/trie/db/src/storage.rs +++ b/crates/trie/db/src/storage.rs @@ -5,7 +5,8 @@ use reth_execution_errors::StorageRootError; use reth_storage_api::{BlockNumReader, StorageChangeSetReader}; use reth_storage_errors::provider::ProviderResult; use reth_trie::{ - hashed_cursor::HashedPostStateCursorFactory, HashedPostState, HashedStorage, StorageRoot, + hashed_cursor::HashedPostStateCursorFactory, trie_cursor::InMemoryTrieCursorFactory, + HashedStorage, StorageRoot, TrieInputSorted, }; #[cfg(feature = "metrics")] @@ -19,11 +20,11 @@ pub trait DatabaseStorageRoot<'a, TX> { /// Create a new storage root calculator from database transaction and hashed address. fn from_tx_hashed(tx: &'a TX, hashed_address: B256) -> Self; - /// Calculates the storage root for this [`HashedStorage`] and returns it. + /// Calculates the storage root with the given trie input. fn overlay_root( tx: &'a TX, address: Address, - hashed_storage: HashedStorage, + input: TrieInputSorted, ) -> Result; } @@ -85,16 +86,22 @@ impl<'a, TX: DbTx, A: TrieTableAdapter> DatabaseStorageRoot<'a, TX> fn overlay_root( tx: &'a TX, address: Address, - hashed_storage: HashedStorage, + mut input: TrieInputSorted, ) -> Result { - let prefix_set = hashed_storage.construct_prefix_set().freeze(); - let state_sorted = - HashedPostState::from_hashed_storage(keccak256(address), hashed_storage).into_sorted(); + let hashed_address = keccak256(address); StorageRoot::new( - DatabaseTrieCursorFactory::<_, A>::new(tx), - HashedPostStateCursorFactory::new(DatabaseHashedCursorFactory::new(tx), &state_sorted), + InMemoryTrieCursorFactory::new( + DatabaseTrieCursorFactory::<_, A>::new(tx), + &input.nodes, + ), + HashedPostStateCursorFactory::new(DatabaseHashedCursorFactory::new(tx), &input.state), address, - prefix_set, + input + .prefix_sets + .storage_prefix_sets + .remove(&hashed_address) + .unwrap_or_default() + .freeze(), #[cfg(feature = "metrics")] TrieRootMetrics::new(reth_trie::TrieType::Storage), ) From d70cc04dab7d337f96080fad1923ec355750c391 Mon Sep 17 00:00:00 2001 From: Sebastian Stammler Date: Thu, 1 Oct 2026 10:42:37 +0200 Subject: [PATCH 02/10] test(storage-overlay): cover storage roots over a masked state trie Pin that `OverlayStateProvider::storage_root` reads trie nodes through the overlay when partial persistence leaves database storage-trie nodes older than the persisted hashed storage. OP Stack consensus depends on this: the Isthmus withdrawals root is the L2ToL1MessagePasser storage root, computed through `storage_root` when building and validating blocks. Co-Authored-By: Claude Opus 5.5 (1M context) --- .../storage/storage-overlay/src/provider.rs | 180 ++++++++++++++++++ 1 file changed, 180 insertions(+) diff --git a/crates/storage/storage-overlay/src/provider.rs b/crates/storage/storage-overlay/src/provider.rs index cf2614c56a7..af04e75adb4 100644 --- a/crates/storage/storage-overlay/src/provider.rs +++ b/crates/storage/storage-overlay/src/provider.rs @@ -1361,4 +1361,184 @@ mod tests { assert_eq!(provider.basic_account(&address).unwrap(), Some(account)); assert_eq!(provider.storage(address, storage_key).unwrap(), Some(storage)); } + + /// Hashed slot with the given first two bytes, so that the storage trie has stored branch + /// nodes at depth one that cache the hashes of their children. + fn hashed_slot(first: u8, second: u8) -> B256 { + let mut slot = alloy_primitives::keccak256([first, second]); + slot.0[0] = first; + slot.0[1] = second; + slot + } + + /// Writes hashed state and trie updates like `save_blocks` does under partial persistence. + fn write_state_trie( + provider: &(impl reth_storage_api::StateWriter + reth_storage_api::TrieWriter), + batch: &[ExecutedBlock], + mask: &[ExecutedBlock], + ) { + provider + .write_hashed_state(&HashedPostStateSorted::disjointed_merge_batch( + &ExecutedBlock::hashed_state_refs(batch), + &ExecutedBlock::hashed_state_refs(mask), + )) + .unwrap(); + provider + .write_trie_updates_sorted(&TrieUpdatesSorted::disjointed_merge_batch( + &ExecutedBlock::trie_updates_refs(batch), + &ExecutedBlock::trie_updates_refs(mask), + )) + .unwrap(); + } + + /// Storage roots over a partially persisted state trie must use the overlay trie nodes: the + /// database trie tables omit nodes overwritten by the masking suffix, so their cached child + /// hashes can be older than the persisted hashed state. + #[test] + fn storage_root_over_masked_state_trie() { + for settings in [reth_provider::StorageSettings::v1(), reth_provider::StorageSettings::v2()] + { + let address = Address::with_last_byte(0x16); + let hashed_address = alloy_primitives::keccak256(address); + + let base = (0..=u8::MAX) + .flat_map(|first| { + [0x00, 0x80].map(|second| (hashed_slot(first, second), U256::from(1))) + }) + .collect::>(); + let changes: [Vec<(B256, U256)>; 8] = [ + vec![], + base, + vec![ + (hashed_slot(0x10, 0x00), U256::from(2)), + (hashed_slot(0x11, 0x42), U256::from(2)), + (hashed_slot(0x20, 0x00), U256::ZERO), + ], + vec![(hashed_slot(0x30, 0x00), U256::from(3))], + vec![(hashed_slot(0x40, 0x80), U256::from(4))], + vec![ + (hashed_slot(0x30, 0x00), U256::from(5)), + (hashed_slot(0x31, 0x00), U256::from(5)), + (hashed_slot(0x50, 0x00), U256::from(5)), + (hashed_slot(0x60, 0x80), U256::ZERO), + ], + vec![ + (hashed_slot(0x1f, 0x80), U256::ZERO), + (hashed_slot(0x50, 0x00), U256::from(6)), + (hashed_slot(0x70, 0x00), U256::from(6)), + ], + vec![ + (hashed_slot(0x50, 0x00), U256::from(7)), + (hashed_slot(0x80, 0x00), U256::ZERO), + ], + ]; + let block_updates = [ + (hashed_slot(0x90, 0x42), U256::from(1)), + (hashed_slot(0xa0, 0x00), U256::from(8)), + (hashed_slot(0xb0, 0x80), U256::ZERO), + ]; + + // Like the engine's, each block's storage trie updates only contain modified nodes. + let reference = create_test_provider_factory(); + reference.set_storage_settings_cache(settings); + let mut storage_nodes = std::collections::BTreeMap::new(); + let blocks = TestBlockBuilder::eth() + .get_executed_blocks(0..changes.len() as u64) + .zip(&changes) + .map(|(block, changes)| { + let mut hashed_state = HashedPostState::default().with_storages([( + hashed_address, + HashedStorage::from_iter(changes.iter().copied()), + )]); + if block.recovered_block().number == 1 { + hashed_state = hashed_state + .with_accounts([(hashed_address, Some(Account::default()))]); + } + let provider = reference.provider().unwrap(); + let (_, trie_updates) = reth_provider::LatestStateProviderRef::new(&provider) + .state_root_with_updates(hashed_state.clone()) + .unwrap(); + drop(provider); + let hashed_state = hashed_state.into_sorted(); + let trie_updates = trie_updates.into_sorted(); + let provider_rw = reference.provider_rw().unwrap(); + reth_storage_api::StateWriter::write_hashed_state(&*provider_rw, &hashed_state) + .unwrap(); + reth_storage_api::TrieWriter::write_trie_updates_sorted( + &*provider_rw, + &trie_updates, + ) + .unwrap(); + provider_rw.commit().unwrap(); + + let modified_storage_nodes = trie_updates + .storage_tries_ref() + .get(&hashed_address) + .map(|storage_trie| storage_trie.storage_nodes_ref()) + .unwrap_or_default() + .iter() + .filter(|(path, node)| match node { + Some(node) => { + storage_nodes.insert(*path, node.clone()).as_ref() != Some(node) + } + None => storage_nodes.remove(path).is_some(), + }) + .cloned() + .collect(); + let trie_updates = TrieUpdatesSorted::new( + trie_updates.account_nodes_ref().to_vec(), + alloy_primitives::map::B256Map::from_iter([( + hashed_address, + reth_trie::updates::StorageTrieUpdatesSorted { + storage_nodes: modified_storage_nodes, + }, + )]), + ); + ExecutedBlock::new( + Arc::clone(&block.recovered_block), + Arc::clone(&block.execution_output), + ComputedTrieData::new(Arc::new(hashed_state), Arc::new(trie_updates)), + ) + }) + .collect::>(); + + let factory = create_test_provider_factory(); + factory.set_storage_settings_cache(settings); + let provider_rw = factory.provider_rw().unwrap(); + for block in &blocks[..=6] { + provider_rw.insert_block(block.recovered_block()).unwrap(); + } + write_state_trie(&*provider_rw, &blocks[1..=1], &[]); + write_state_trie(&*provider_rw, &blocks[2..=4], &blocks[5..=6]); + provider_rw + .save_stage_checkpoint( + StageId::Finish, + StageCheckpoint::new(6).with_finish_stage_checkpoint(FinishCheckpoint { + partial_state_trie: Some(4), + }), + ) + .unwrap(); + provider_rw.commit().unwrap(); + + let manager = OverlayManager::default(); + for block in &blocks[5..=7] { + manager.insert_block(block.clone()); + } + let state_provider_factory = OverlayStateProviderFactory::new( + factory, + manager.overlay_builder(blocks[7].recovered_block().hash()), + ); + let provider = state_provider_factory.database_provider_ro().unwrap(); + + let mut expected = std::collections::BTreeMap::new(); + for (slot, value) in changes.iter().flatten().chain(&block_updates) { + expected.insert(*slot, *value); + } + expected.retain(|_, value| !value.is_zero()); + + let storage_root = + provider.storage_root(address, HashedStorage::from_iter(block_updates)).unwrap(); + assert_eq!(storage_root, reth_trie::test_utils::storage_root_prehashed(expected)); + } + } } From 0232cc15fef36c2a362e0cfdaf1b7b72cd27f723 Mon Sep 17 00:00:00 2001 From: Matthias Seitz Date: Thu, 24 Sep 2026 13:53:27 +0000 Subject: [PATCH 03/10] fix(engine): validate forkchoice state before applying updates (#27247) Co-authored-by: Matthias Seitz <19890894+mattsse@users.noreply.github.com> (cherry picked from commit a120f00d47e43427816e2fe7e38229fabbb2db87) --- crates/chain-state/src/in_memory.rs | 16 +- crates/engine/tree/src/tree/mod.rs | 73 +++++++++ crates/engine/tree/src/tree/tests.rs | 36 +++++ crates/ethereum/node/tests/e2e/forkchoice.rs | 161 +++++++++++++++++++ crates/ethereum/node/tests/e2e/main.rs | 1 + 5 files changed, 284 insertions(+), 3 deletions(-) create mode 100644 crates/ethereum/node/tests/e2e/forkchoice.rs diff --git a/crates/chain-state/src/in_memory.rs b/crates/chain-state/src/in_memory.rs index ef0fa4fabb3..adf6790bf0f 100644 --- a/crates/chain-state/src/in_memory.rs +++ b/crates/chain-state/src/in_memory.rs @@ -1001,12 +1001,22 @@ impl> NewCanonicalChain { /// Returns the new tip for [`Self::Reorg`] and [`Self::Commit`] variants which commit at least /// 1 new block. pub fn tip(&self) -> &RecoveredBlock { + self.new_blocks().last().expect("non empty blocks").recovered_block() + } + + /// Returns the blocks added to the canonical chain by this update. + pub fn new_blocks(&self) -> &[ExecutedBlock] { match self { - Self::Commit { new } | Self::Reorg { new, .. } => { - new.last().expect("non empty blocks").recovered_block() - } + Self::Commit { new } | Self::Reorg { new, .. } => new, } } + + /// Returns whether the newly canonicalized blocks contain the given hash. + /// + /// This does not include the unchanged canonical prefix before the first new block. + pub fn contains(&self, hash: B256) -> bool { + self.new_blocks().iter().any(|block| block.recovered_block().hash() == hash) + } } #[cfg(test)] diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs index d45cfcab271..b91e86a65ea 100644 --- a/crates/engine/tree/src/tree/mod.rs +++ b/crates/engine/tree/src/tree/mod.rs @@ -1252,6 +1252,10 @@ where trace!(target: "engine::tree", "fcu head hash is already canonical"); + if !self.is_consistent_forkchoice_state(state, None)? { + return Ok(Some(TreeOutcome::new(OnForkChoiceUpdated::invalid_state()))); + } + // Update the safe and finalized blocks and ensure their values are valid if let Err(outcome) = self.ensure_consistent_forkchoice_state(state) { // safe or finalized hashes are invalid @@ -1320,6 +1324,10 @@ where return Ok(Some(TreeOutcome::new(OnForkChoiceUpdated::too_deep_reorg()))); } + if !self.is_consistent_forkchoice_state(state, None)? { + return Ok(Some(TreeOutcome::new(OnForkChoiceUpdated::invalid_state()))); + } + // We need to effectively unwind the _canonical_ chain to the FCU's head, which is // part of the canonical chain. We need to update the latest block state to reflect // the canonical ancestor. This ensures that state providers and the transaction @@ -1348,6 +1356,10 @@ where // Ensure we can apply a new chain update for the head block if let Some(chain_update) = self.on_new_head(state.head_block_hash)? { + if !self.is_consistent_forkchoice_state(state, Some(&chain_update))? { + return Ok(Some(TreeOutcome::new(OnForkChoiceUpdated::invalid_state()))); + } + let tip = chain_update.tip().clone_sealed_header(); self.on_canonical_chain_update(chain_update); @@ -3373,6 +3385,67 @@ where Ok(canonical) } + /// Checks that nonzero safe and finalized hashes belong to the chain defined by the FCU head. + /// + /// The [Engine API forkchoiceUpdated specification] requires `-38002` when a `VALID` head's + /// safe or finalized hash is outside that chain, and requires all forkchoice state updates to + /// be atomic. In direct FCU processing, this check must therefore run before canonicalizing + /// the head or updating either marker; checking only after canonicalization would leave an + /// invalid reorg applied. + /// + /// `chain_update` describes a proposed commit or reorg that has not yet been applied. Its new + /// blocks and the canonical prefix below its first block form the proposed chain. Without a + /// chain update, the proposed head is already canonical, so only canonical blocks through its + /// height are eligible. For a canonical-prefix hash, the current in-memory or persisted + /// canonical hash must match too: a stale persisted header may still be found by hash while + /// disk reorg cleanup is pending. A zero safe or finalized hash leaves that marker unchanged. + /// Returns `Ok(false)` for an unknown or off-chain hash and propagates provider errors. + /// + /// [Engine API forkchoiceUpdated specification]: https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#specification-1 + fn is_consistent_forkchoice_state( + &self, + state: ForkchoiceState, + chain_update: Option<&NewCanonicalChain>, + ) -> ProviderResult { + let canonical_head_number = match chain_update { + Some(chain_update) => { + let new = chain_update.new_blocks(); + // Only the canonical prefix below the new branch remains on the proposed chain. + new.first().expect("non empty chain").block_number() - 1 + } + None => { + let Some(head) = self.find_canonical_header(state.head_block_hash)? else { + return Ok(false) + }; + head.number() + } + }; + + for hash in [state.finalized_block_hash, state.safe_block_hash] { + if hash.is_zero() || chain_update.is_some_and(|update| update.contains(hash)) { + continue + } + let Some(header) = self.find_canonical_header(hash)? else { return Ok(false) }; + if header.number() > canonical_head_number { + return Ok(false) + } + + // A persisted header can still be found by hash while its disk reorg is pending. + // Prefer the in-memory canonical hash at this height over the persisted one. + let canonical_hash = if let Some(hash) = + self.canonical_in_memory_state.hash_by_number(header.number()) + { + Some(hash) + } else { + self.provider.block_hash(header.number())? + }; + if canonical_hash != Some(hash) { + return Ok(false) + } + } + Ok(true) + } + /// Updates the tracked finalized block if we have it. fn update_finalized_block( &self, diff --git a/crates/engine/tree/src/tree/tests.rs b/crates/engine/tree/src/tree/tests.rs index 6830500088a..d78cfe77030 100644 --- a/crates/engine/tree/src/tree/tests.rs +++ b/crates/engine/tree/src/tree/tests.rs @@ -3350,3 +3350,39 @@ async fn test_on_backfill_sync_finished_opstack_retriggers_backfill_to_buffered_ async fn test_on_backfill_sync_finished_eth_retriggers_backfill_to_buffered_finalized() { assert_post_backfill_recheck_retriggers_to_buffered_target(EngineApiKind::Ethereum).await; } + +/// A stale persisted hash must not count as an ancestor after an in-memory reorg. +#[test] +fn test_forkchoice_rejects_stale_persisted_prefix_hash() { + let mut test_harness = TestHarness::new(MAINNET.clone()); + let old: Vec<_> = test_harness.block_builder.get_executed_blocks(0..3).collect(); + test_harness = test_harness.with_blocks(old.clone()); + + let new: Vec<_> = test_harness + .block_builder + .create_fork(old[0].recovered_block(), 2) + .into_iter() + .map(|block| { + ExecutedBlock::new( + Arc::new(block), + Arc::new(BlockExecutionOutput::default()), + ComputedTrieData::default(), + ) + }) + .collect(); + test_harness.tree.canonical_in_memory_state.update_chain(NewCanonicalChain::Reorg { + new: vec![new[0].clone()], + old: old[1..].to_vec(), + }); + + let state = ForkchoiceState { + head_block_hash: new[1].recovered_block().hash(), + safe_block_hash: old[1].recovered_block().hash(), + finalized_block_hash: old[0].recovered_block().hash(), + }; + let update = NewCanonicalChain::Commit { new: vec![new[1].clone()] }; + assert!(!test_harness.tree.is_consistent_forkchoice_state(state, Some(&update)).unwrap()); + + let state = ForkchoiceState { safe_block_hash: new[0].recovered_block().hash(), ..state }; + assert!(test_harness.tree.is_consistent_forkchoice_state(state, Some(&update)).unwrap()); +} diff --git a/crates/ethereum/node/tests/e2e/forkchoice.rs b/crates/ethereum/node/tests/e2e/forkchoice.rs new file mode 100644 index 00000000000..e9ff2ef457f --- /dev/null +++ b/crates/ethereum/node/tests/e2e/forkchoice.rs @@ -0,0 +1,161 @@ +//! Tests for atomic forkchoice state updates via the Engine API. + +use crate::utils::eth_payload_attributes; +use alloy_eips::BlockNumberOrTag; +use alloy_primitives::B256; +use alloy_provider::{Provider, ProviderBuilder}; +use alloy_rpc_types_engine::{ForkchoiceState, PayloadStatusEnum}; +use jsonrpsee_core::client::Error; +use reth_chainspec::{ChainSpecBuilder, MAINNET}; +use reth_e2e_test_utils::E2ETestSetupBuilder; +use reth_node_ethereum::{EthEngineTypes, EthereumNode}; +use reth_rpc_api::{EngineApiClient, TestingBuildBlockRequestV1}; +use reth_rpc_server_types::{RethRpcModule, RpcModuleSelection}; +use std::sync::Arc; + +#[tokio::test] +async fn invalid_forkchoice_preserves_canonical_state() -> 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, _) = + E2ETestSetupBuilder::::new(2, chain_spec, eth_payload_attributes) + .with_connect_nodes(false) + .with_node_config_modifier(|mut config| { + config.rpc.http_api = + Some(RpcModuleSelection::from([RethRpcModule::Eth, RethRpcModule::Testing])); + config + }) + .build() + .await?; + let node = nodes.pop().unwrap(); + let producer = nodes.pop().unwrap(); + let genesis = node.block_hash(0); + let engine = node.auth_server_handle().http_client(); + let producer_engine = producer.auth_server_handle().http_client(); + let rpc = ProviderBuilder::new().connect_http(node.rpc_url()); + + // Build a1 <- a2 <- a3 and b1 <- b2, both rooted at genesis. Only chain A is canonical. + let mut chains = [vec![genesis], vec![genesis]]; + for (branch, length) in [3, 2].into_iter().enumerate() { + for number in 1..=length { + let envelope = producer + .testing_build_block_v1(TestingBuildBlockRequestV1 { + parent_block_hash: *chains[branch].last().unwrap(), + payload_attributes: eth_payload_attributes(number + branch as u64 * 10), + transactions: vec![], + extra_data: None, + }) + .await?; + let payload = envelope.execution_payload; + let hash = payload.payload_inner.payload_inner.block_hash; + for client in [&producer_engine, &engine] { + let status = EngineApiClient::::new_payload_v3( + client, + payload.clone(), + vec![], + B256::ZERO, + ) + .await?; + assert_eq!(status.status, PayloadStatusEnum::Valid); + } + producer.update_forkchoice(genesis, hash).await?; + chains[branch].push(hash); + } + if branch == 0 { + let status = EngineApiClient::::fork_choice_updated_v3( + &engine, + ForkchoiceState { + head_block_hash: chains[0][3], + safe_block_hash: genesis, + finalized_block_hash: genesis, + }, + None, + ) + .await?; + assert_eq!(status.payload_status.status, PayloadStatusEnum::Valid); + } + } + let [a, b] = chains; + + for (head, safe, finalized) in [ + (b[2], a[2], a[1]), + (b[2], a[2], b[1]), + (b[2], b[1], a[1]), + (b[2], B256::repeat_byte(0xff), b[1]), + (a[3], b[1], a[1]), + (a[2], a[3], genesis), + ] { + let state = ForkchoiceState { + head_block_hash: head, + safe_block_hash: safe, + finalized_block_hash: finalized, + }; + let err = EngineApiClient::::fork_choice_updated_v3(&engine, state, None) + .await + .unwrap_err(); + let Error::Call(err) = err else { panic!("Expected an RPC error, got {err:?}") }; + assert_eq!(err.code(), -38002, "{state:?}"); + + for (tag, hash) in [ + (BlockNumberOrTag::Latest, a[3]), + (BlockNumberOrTag::Safe, genesis), + (BlockNumberOrTag::Finalized, genesis), + (BlockNumberOrTag::Number(1), a[1]), + (BlockNumberOrTag::Number(2), a[2]), + (BlockNumberOrTag::Number(3), a[3]), + ] { + assert_eq!( + rpc.get_block_by_number(tag).await?.unwrap().header.hash, + hash, + "{tag:?} changed after rejecting {state:?}" + ); + } + } + + // Safe/finalized hashes on the proposed branch must be accepted before it is canonical. + let status = EngineApiClient::::fork_choice_updated_v3( + &engine, + ForkchoiceState { + head_block_hash: b[2], + safe_block_hash: b[2], + finalized_block_hash: b[1], + }, + None, + ) + .await?; + assert_eq!(status.payload_status.status, PayloadStatusEnum::Valid); + for (tag, hash) in [ + (BlockNumberOrTag::Latest, b[2]), + (BlockNumberOrTag::Safe, b[2]), + (BlockNumberOrTag::Finalized, b[1]), + (BlockNumberOrTag::Number(1), b[1]), + (BlockNumberOrTag::Number(2), b[2]), + ] { + assert_eq!(rpc.get_block_by_number(tag).await?.unwrap().header.hash, hash); + } + assert!(rpc.get_block_by_number(BlockNumberOrTag::Number(3)).await?.is_none()); + + // Invalid payload attributes must not roll back an otherwise valid forkchoice update. + let err = EngineApiClient::::fork_choice_updated_v3( + &engine, + ForkchoiceState::same_hash(b[2]), + Some(eth_payload_attributes(1)), + ) + .await + .unwrap_err(); + let Error::Call(err) = err else { panic!("Expected an RPC error, got {err:?}") }; + assert_eq!(err.code(), -38003); + assert_eq!( + rpc.get_block_by_number(BlockNumberOrTag::Finalized).await?.unwrap().header.hash, + b[2] + ); + + Ok(()) +} diff --git a/crates/ethereum/node/tests/e2e/main.rs b/crates/ethereum/node/tests/e2e/main.rs index 045998ffedc..7272b4fade8 100644 --- a/crates/ethereum/node/tests/e2e/main.rs +++ b/crates/ethereum/node/tests/e2e/main.rs @@ -5,6 +5,7 @@ mod custom_genesis; mod dev; mod eip6780; mod eth; +mod forkchoice; mod invalid_payload; mod p2p; mod pool; From 1320f9251ab1f029901461ae09b446d08389feae Mon Sep 17 00:00:00 2001 From: banteg <4562643+banteg@users.noreply.github.com> Date: Fri, 25 Sep 2026 09:27:42 +0000 Subject: [PATCH 04/10] fix(engine): don't treat stale persisted fcu head as canonical (#27429) Co-authored-by: Matthias Seitz <19890894+mattsse@users.noreply.github.com> (cherry picked from commit 444e867155c2a7a4c028e479ca7201b0b6871579) --- crates/engine/tree/src/tree/mod.rs | 43 +++--- crates/engine/tree/src/tree/tests.rs | 61 ++++++++- crates/ethereum/node/tests/e2e/forkchoice.rs | 133 ++++++++++++++++++- 3 files changed, 213 insertions(+), 24 deletions(-) diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs index b91e86a65ea..9e16234ec2e 100644 --- a/crates/engine/tree/src/tree/mod.rs +++ b/crates/engine/tree/src/tree/mod.rs @@ -3372,17 +3372,33 @@ where } /// Attempts to find the header for the given block hash if it is canonical. + /// + /// A persisted header can still be found by hash while its disk reorg is pending, so it is + /// only canonical if it is not above the canonical head and matches the canonical hash at its + /// height. The in-memory canonical hash is preferred over the persisted one. pub fn find_canonical_header( &self, hash: B256, ) -> Result>, ProviderError> { - let mut canonical = self.canonical_in_memory_state.header_by_hash(hash); + if let Some(header) = self.canonical_in_memory_state.header_by_hash(hash) { + return Ok(Some(header)) + } - if canonical.is_none() { - canonical = self.provider.header(hash)?.map(|header| SealedHeader::new(header, hash)); + let Some(header) = self.provider.sealed_header_by_hash(hash)? else { return Ok(None) }; + // Reorged-out headers remain on disk until persistence catches up, so reject old tips above + // the in-memory head and use in-memory hashes to reject old blocks at shared heights. + let number = header.number(); + if number > self.canonical_in_memory_state.get_canonical_block_number() { + return Ok(None) } + let canonical_hash = + if let Some(hash) = self.canonical_in_memory_state.hash_by_number(number) { + Some(hash) + } else { + self.provider.block_hash(number)? + }; - Ok(canonical) + Ok((canonical_hash == Some(hash)).then_some(header)) } /// Checks that nonzero safe and finalized hashes belong to the chain defined by the FCU head. @@ -3396,9 +3412,9 @@ where /// `chain_update` describes a proposed commit or reorg that has not yet been applied. Its new /// blocks and the canonical prefix below its first block form the proposed chain. Without a /// chain update, the proposed head is already canonical, so only canonical blocks through its - /// height are eligible. For a canonical-prefix hash, the current in-memory or persisted - /// canonical hash must match too: a stale persisted header may still be found by hash while - /// disk reorg cleanup is pending. A zero safe or finalized hash leaves that marker unchanged. + /// height are eligible. Canonical-prefix hashes are resolved via + /// [`Self::find_canonical_header`], which rejects stale persisted headers whose disk reorg + /// cleanup is pending. A zero safe or finalized hash leaves that marker unchanged. /// Returns `Ok(false)` for an unknown or off-chain hash and propagates provider errors. /// /// [Engine API forkchoiceUpdated specification]: https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#specification-1 @@ -3429,19 +3445,6 @@ where if header.number() > canonical_head_number { return Ok(false) } - - // A persisted header can still be found by hash while its disk reorg is pending. - // Prefer the in-memory canonical hash at this height over the persisted one. - let canonical_hash = if let Some(hash) = - self.canonical_in_memory_state.hash_by_number(header.number()) - { - Some(hash) - } else { - self.provider.block_hash(header.number())? - }; - if canonical_hash != Some(hash) { - return Ok(false) - } } Ok(true) } diff --git a/crates/engine/tree/src/tree/tests.rs b/crates/engine/tree/src/tree/tests.rs index d78cfe77030..e4b88ebc1aa 100644 --- a/crates/engine/tree/src/tree/tests.rs +++ b/crates/engine/tree/src/tree/tests.rs @@ -30,7 +30,9 @@ use reth_ethereum_primitives::{Block, EthPrimitives}; use reth_evm_ethereum::MockEvmConfig; use reth_payload_builder::PayloadServiceCommand; use reth_primitives_traits::Block as _; -use reth_provider::{test_utils::MockEthProvider, BalStoreHandle, InMemoryBalStore, RawBal}; +use reth_provider::{ + test_utils::MockEthProvider, BalStoreHandle, HeaderProvider, InMemoryBalStore, RawBal, +}; use reth_tasks::spawn_os_thread; use reth_trie_common::ComputedTrieData; use std::{ @@ -3386,3 +3388,60 @@ fn test_forkchoice_rejects_stale_persisted_prefix_hash() { let state = ForkchoiceState { safe_block_hash: new[0].recovered_block().hash(), ..state }; assert!(test_harness.tree.is_consistent_forkchoice_state(state, Some(&update)).unwrap()); } + +/// Reorgs from a persisted chain to a sibling branch of `sibling_len` blocks without advancing +/// persistence, then asserts that an FCU back to the reorged-out tip makes it canonical again. +async fn assert_fcu_back_to_reorged_out_head_with_pending_disk_reorg(sibling_len: u64) { + reth_tracing::init_test_tracing(); + let mut test_harness = TestHarness::new(MAINNET.clone()); + let old: Vec<_> = test_harness.block_builder.get_executed_blocks(0..4).collect(); + test_harness = test_harness.with_blocks(old.clone()); + let old_tip = old[3].recovered_block().hash(); + + let new: Vec<_> = test_harness + .block_builder + .create_fork(old[0].recovered_block(), sibling_len) + .into_iter() + .map(|block| { + ExecutedBlock::new( + Arc::new(block), + Arc::new(BlockExecutionOutput::default()), + ComputedTrieData::default(), + ) + }) + .collect(); + for block in &new { + test_harness.tree.state.tree_state.insert_executed(block.clone()); + } + let new_tip = new.last().unwrap().recovered_block().hash(); + + let fcu = |head_block_hash| ForkchoiceState { + head_block_hash, + safe_block_hash: B256::ZERO, + finalized_block_hash: B256::ZERO, + }; + + let outcome = test_harness.tree.on_forkchoice_updated(fcu(new_tip), None).unwrap(); + assert_eq!(outcome.outcome.forkchoice_status(), ForkchoiceStatus::Valid); + assert_eq!(test_harness.tree.canonical_in_memory_state.get_canonical_head().hash(), new_tip); + + // Persistence is not advanced, so the reorged-out blocks are still found on disk. + assert!(test_harness.provider.header(old_tip).unwrap().is_some()); + + let outcome = test_harness.tree.on_forkchoice_updated(fcu(old_tip), None).unwrap(); + assert_eq!(outcome.outcome.forkchoice_status(), ForkchoiceStatus::Valid); + assert_eq!(test_harness.tree.state.tree_state.canonical_block_hash(), old_tip); + assert_eq!(test_harness.tree.canonical_in_memory_state.get_canonical_head().hash(), old_tip); +} + +/// A reorged-out head must become canonical again while its disk reorg is still pending. +#[tokio::test] +async fn test_fcu_back_to_reorged_out_head_with_pending_disk_reorg() { + assert_fcu_back_to_reorged_out_head_with_pending_disk_reorg(3).await; +} + +/// Same as above, but the reorged-out head is above the tip of the shorter sibling branch. +#[tokio::test] +async fn test_fcu_back_to_reorged_out_head_above_shorter_branch_with_pending_disk_reorg() { + assert_fcu_back_to_reorged_out_head_with_pending_disk_reorg(1).await; +} diff --git a/crates/ethereum/node/tests/e2e/forkchoice.rs b/crates/ethereum/node/tests/e2e/forkchoice.rs index e9ff2ef457f..6e0e5806922 100644 --- a/crates/ethereum/node/tests/e2e/forkchoice.rs +++ b/crates/ethereum/node/tests/e2e/forkchoice.rs @@ -1,4 +1,4 @@ -//! Tests for atomic forkchoice state updates via the Engine API. +//! Tests for canonical chain and atomic forkchoice state updates via the Engine API. use crate::utils::eth_payload_attributes; use alloy_eips::BlockNumberOrTag; @@ -7,11 +7,12 @@ use alloy_provider::{Provider, ProviderBuilder}; use alloy_rpc_types_engine::{ForkchoiceState, PayloadStatusEnum}; use jsonrpsee_core::client::Error; use reth_chainspec::{ChainSpecBuilder, MAINNET}; -use reth_e2e_test_utils::E2ETestSetupBuilder; +use reth_e2e_test_utils::{trie::wait_for_persisted_block, E2ETestSetupBuilder}; use reth_node_ethereum::{EthEngineTypes, EthereumNode}; +use reth_provider::{DatabaseProviderFactory, HeaderProvider}; use reth_rpc_api::{EngineApiClient, TestingBuildBlockRequestV1}; use reth_rpc_server_types::{RethRpcModule, RpcModuleSelection}; -use std::sync::Arc; +use std::{sync::Arc, time::Duration}; #[tokio::test] async fn invalid_forkchoice_preserves_canonical_state() -> eyre::Result<()> { @@ -159,3 +160,129 @@ async fn invalid_forkchoice_preserves_canonical_state() -> eyre::Result<()> { Ok(()) } + +/// Restoring a persisted head must update canonical state before disk reorg cleanup completes. +#[tokio::test] +async fn fcu_restores_reorged_out_persisted_head() -> eyre::Result<()> { + assert_fcu_restores_reorged_out_persisted_head(3).await +} + +/// A stale persisted head above a shorter sibling branch must also become canonical again. +#[tokio::test] +async fn fcu_restores_reorged_out_persisted_head_above_shorter_branch() -> eyre::Result<()> { + assert_fcu_restores_reorged_out_persisted_head(1).await +} + +/// Holds the database writer lock across both FCUs so disk cleanup cannot win the race. +async fn assert_fcu_restores_reorged_out_persisted_head(sibling_len: u64) -> 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, _) = + E2ETestSetupBuilder::::new(2, chain_spec, eth_payload_attributes) + .with_connect_nodes(false) + .with_tree_config_modifier(|config| { + config + .with_num_state_masking_blocks(0) + .with_persistence_threshold(0) + .with_memory_block_buffer_target(0) + }) + .with_node_config_modifier(|mut config| { + config.rpc.http_api = + Some(RpcModuleSelection::from([RethRpcModule::Eth, RethRpcModule::Testing])); + config + }) + .build() + .await?; + let node = nodes.pop().unwrap(); + let producer = nodes.pop().unwrap(); + let genesis = node.block_hash(0); + let engine = node.auth_server_handle().http_client(); + let producer_engine = producer.auth_server_handle().http_client(); + let rpc = ProviderBuilder::new().connect_http(node.rpc_url()); + + // Persist A through block 3, then import a sibling branch without canonicalizing it. + let mut chains = [vec![genesis], vec![genesis]]; + for (branch, length) in [3, sibling_len].into_iter().enumerate() { + for number in 1..=length { + let envelope = producer + .testing_build_block_v1(TestingBuildBlockRequestV1 { + parent_block_hash: *chains[branch].last().unwrap(), + payload_attributes: eth_payload_attributes(number + branch as u64 * 10), + transactions: vec![], + extra_data: None, + }) + .await?; + let payload = envelope.execution_payload; + let hash = payload.payload_inner.payload_inner.block_hash; + for client in [&producer_engine, &engine] { + let status = EngineApiClient::::new_payload_v3( + client, + payload.clone(), + vec![], + B256::ZERO, + ) + .await?; + assert_eq!(status.status, PayloadStatusEnum::Valid); + } + producer.update_forkchoice(genesis, hash).await?; + chains[branch].push(hash); + } + if branch == 0 { + node.update_forkchoice(genesis, chains[0][3]).await?; + wait_for_persisted_block(&node.inner.provider, 3, Duration::from_secs(30)).await?; + } + } + let [a, b] = chains; + + // MDBX allows only one writer. Acquire it off the executor and keep it alive while the + // persistence task attempts to remove A, leaving the old headers visible on disk. + let provider = node.inner.provider.clone(); + let disk_reorg_guard = + tokio::task::spawn_blocking(move || provider.database_provider_rw()).await??; + for head in [*b.last().unwrap(), a[3]] { + let status = tokio::time::timeout( + Duration::from_secs(10), + EngineApiClient::::fork_choice_updated_v3( + &engine, + ForkchoiceState { + head_block_hash: head, + safe_block_hash: B256::ZERO, + finalized_block_hash: B256::ZERO, + }, + None, + ), + ) + .await??; + assert_eq!(status.payload_status.status, PayloadStatusEnum::Valid); + assert_eq!( + node.inner.provider.database_provider_ro()?.sealed_header(3)?.unwrap().hash(), + a[3], + "The old tip must remain on disk throughout both FCUs" + ); + assert_eq!( + rpc.get_block_by_number(BlockNumberOrTag::Latest).await?.unwrap().header.hash, + head, + "A VALID FCU must make the requested sibling tip canonical" + ); + } + for (number, hash) in a.into_iter().enumerate() { + assert_eq!( + rpc.get_block_by_number(BlockNumberOrTag::Number(number as u64)) + .await? + .unwrap() + .header + .hash, + hash + ); + } + drop(disk_reorg_guard); + + Ok(()) +} From 68594096cc4b8a53bce48485c56994d59b21642a Mon Sep 17 00:00:00 2001 From: Derek Cofausper <256792747+decofe@users.noreply.github.com> Date: Thu, 1 Oct 2026 15:44:08 +0000 Subject: [PATCH 05/10] fix(storage): use trie changesets for all overlays (#27634) Co-authored-by: Brian Picciano <933154+mediocregopher@users.noreply.github.com> (cherry picked from commit 078d026239a1977f5d79eeb67fa44d2087ebf7e5) --- crates/storage/storage-overlay/src/provider.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/crates/storage/storage-overlay/src/provider.rs b/crates/storage/storage-overlay/src/provider.rs index af04e75adb4..a856f956b92 100644 --- a/crates/storage/storage-overlay/src/provider.rs +++ b/crates/storage/storage-overlay/src/provider.rs @@ -534,14 +534,14 @@ where fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { let input = - self.build_overlay(TrieInputSorted::from_state(hashed_state.into_sorted()), false)?; + self.build_overlay(TrieInputSorted::from_state(hashed_state.into_sorted()), true)?; Ok(>::overlay_root_from_nodes(self.provider().tx(), input)?) }) } fn state_root_from_nodes(&self, input: TrieInput) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted(input), false)?; + let input = self.build_overlay(TrieInputSorted::from_unsorted(input), true)?; Ok( as DatabaseStateRoot<_>>::overlay_root_from_nodes( self.provider().tx(), input, @@ -602,7 +602,7 @@ where HashedPostState::from_hashed_storage(hashed_address, hashed_storage) .into_sorted(), ), - false, + true, )?; >::overlay_root(self.provider().tx(), address, input) .map_err(|err| ProviderError::Database(err.into())) @@ -633,7 +633,7 @@ where HashedPostState::from_hashed_storage(hashed_address, hashed_storage) .into_sorted(), ), - false, + true, )?; >::overlay_storage_multiproof( self.provider().tx(), @@ -665,7 +665,7 @@ where ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { let TrieInputSorted { nodes, state, prefix_sets } = - self.build_overlay(TrieInputSorted::from_unsorted(input), false)?; + self.build_overlay(TrieInputSorted::from_unsorted(input), true)?; let input = TrieInput::new( Arc::unwrap_or_clone(nodes).into(), Arc::unwrap_or_clone(state).into(), @@ -683,7 +683,7 @@ where ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { let TrieInputSorted { nodes, state, prefix_sets } = - self.build_overlay(TrieInputSorted::from_unsorted(input), false)?; + self.build_overlay(TrieInputSorted::from_unsorted(input), true)?; let input = TrieInput::new( Arc::unwrap_or_clone(nodes).into(), Arc::unwrap_or_clone(state).into(), @@ -701,7 +701,7 @@ where ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { let TrieInputSorted { nodes, state, prefix_sets } = - self.build_overlay(TrieInputSorted::from_unsorted(input), false)?; + self.build_overlay(TrieInputSorted::from_unsorted(input), true)?; let input = TrieInput::new( Arc::unwrap_or_clone(nodes).into(), Arc::unwrap_or_clone(state).into(), @@ -720,7 +720,7 @@ where ) -> ProviderResult> { reth_trie_db::with_adapter!(self.provider(), |A| { let TrieInputSorted { nodes, state, prefix_sets } = - self.build_overlay(TrieInputSorted::from_unsorted(input), false)?; + self.build_overlay(TrieInputSorted::from_unsorted(input), true)?; let witness = TrieWitness::new( InMemoryTrieCursorFactory::new( DatabaseTrieCursorFactory::<_, A>::new(self.provider().tx()), @@ -769,7 +769,7 @@ where return Ok(hashed_state) } - let overlay_state = self.build_overlay(TrieInputSorted::default(), false)?.state; + let overlay_state = self.build_overlay(TrieInputSorted::default(), true)?.state; zero_destroyed_account_storage( &HashedPostStateCursorFactory::new( DatabaseHashedCursorFactory::new(self.provider().tx()), From 0b1f6f3949290490a5620d217052929c445dbe14 Mon Sep 17 00:00:00 2001 From: Christopher Campbell Date: Wed, 23 Sep 2026 09:49:23 +0000 Subject: [PATCH 06/10] fix(trie): state root task persists EIP-161-empty accounts into HashedAccounts (#27252) Co-authored-by: Claude Co-authored-by: Brian Picciano (cherry picked from commit 695b4f174b495e5a2bbc8779165422a678858bd7) --- crates/trie/parallel/src/state_root_task.rs | 200 +++++++++++++++++++- 1 file changed, 196 insertions(+), 4 deletions(-) diff --git a/crates/trie/parallel/src/state_root_task.rs b/crates/trie/parallel/src/state_root_task.rs index 5eb920317a9..382124aa63a 100644 --- a/crates/trie/parallel/src/state_root_task.rs +++ b/crates/trie/parallel/src/state_root_task.rs @@ -497,9 +497,19 @@ 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(); - if account.info != account.original_info() { - let info = if destroyed { None } else { Some(account.info.into()) }; - hashed_state.accounts.insert(hashed_address, info); + // EIP-161: a touched account that ends up empty is deleted, so it must be emitted + // as a removal rather than as an all-zero account. This mirrors what revm does in + // the bundle path (`CacheAccount::touch_empty_eip161`) and what the sibling + // producer for this consumer already does in `send_bal_hashed_state`. + // An address that never existed and still does not exist is not a deletion: revm + // emits no transition for `LoadedNotExisting`. Skipping it matches the bundle + // producer; every `None` here becomes a storage-trie cursor walk in `StateRoot`. + let deleted = destroyed || (account.is_empty() && !account.is_loaded_as_not_existing()); + if deleted { + hashed_state.accounts.insert(hashed_address, None); + } else if account.info != account.original_info() { + // A touched but unchanged account produces no bundle transition either. + hashed_state.accounts.insert(hashed_address, Some(account.info.into())); } let mut changed_storage_iter = account @@ -533,7 +543,7 @@ mod tests { #[test] fn created_selfdestruct_does_not_emit_storage() { let address = Address::repeat_byte(0x01); - let mut account = Account::default(); + let mut account = Account::new_not_existing(TransactionId::ZERO); account.mark_touch(); assert!(account.mark_created_locally()); assert!(account.mark_selfdestructed_locally()); @@ -573,6 +583,188 @@ mod tests { assert!(!hashed_state.storages.contains_key(&hashed_address)); } + /// An account drained to zero balance, with nonce 0 and no code, is EIP-161-empty and + /// canonical execution deletes it. Asserts the converter reports the deletion as `None`, + /// matching `HashedPostState::from_bundle_state`, so `write_hashed_state` removes the + /// `HashedAccounts` row instead of upserting an all-zero one. + #[test] + fn emptied_account_is_deleted() { + let address = Address::repeat_byte(0x05); + let mut account = Account::default(); + // Pre-state: the account exists and holds a balance. + account.info.balance = U256::from(1); + account.set_current_info_as_original(); + // This block drains it. Not selfdestructed: an ordinary value transfer out. + account.mark_touch(); + account.info.balance = U256::ZERO; + assert!(account.is_empty(), "the drained account must be EIP-161-empty"); + assert!(!account.is_selfdestructed()); + + let hashed_state = + evm_state_to_hashed_post_state(EvmState::from_iter([(address, account)])); + + assert_eq!(hashed_state.accounts.get(&keccak256(address)), Some(&None)); + } + + /// A pre-existing EIP-161-empty account that is merely touched must be deleted. revm marks it + /// for removal (`touch_empty_eip161`) and the `BundleState` path reports `None`. Asserts the + /// converter emits the deletion even though `info == original_info()`, so an existing all-zero + /// `HashedAccounts` row can be cleared by a touch. + #[test] + fn touched_preexisting_empty_account_is_deleted() { + let address = Address::repeat_byte(0x06); + // Empty in the pre-state too: nonce 0, balance 0, no code. + let mut account = Account::default(); + account.set_current_info_as_original(); + account.mark_touch(); + assert!(account.is_empty()); + + let hashed_state = + evm_state_to_hashed_post_state(EvmState::from_iter([(address, account)])); + + assert_eq!(hashed_state.accounts.get(&keccak256(address)), Some(&None)); + } + + /// The two `HashedPostState` producers that feed the same consumer must agree. + /// + /// `evm_state_to_hashed_post_state` converts the raw `EvmState` handed to the state hook; + /// `HashedPostState::from_bundle_state` converts the `BundleState` revm produces from the + /// same execution. Since "perf: avoid hashing the state twice" the engine persists whichever + /// one it gets, so a disagreement between them is a disagreement about durable state. + /// + /// Asserts both producers agree for a touched account drained to EIP-161-empty, which revm + /// marks for removal in the bundle path (`CacheAccount::touch_empty_eip161`). + #[test] + fn matches_bundle_state_for_emptied_account() { + use revm::{ + database::{states::bundle_state::BundleRetention, State}, + state::AccountInfo, + DatabaseCommit, + }; + + let address = Address::repeat_byte(0x07); + let pre = AccountInfo { balance: U256::from(1), ..Default::default() }; + + // The EvmState the state hook observes: a funded account drained to empty. + let mut account = Account::from(pre.clone()); + account.mark_touch(); + account.info.balance = U256::ZERO; + let evm_state = EvmState::from_iter([(address, account)]); + + // Same execution, through revm's own bundle machinery. + let mut db = State::builder().with_bundle_update().build(); + db.insert_account(address, pre); + db.commit(evm_state.clone()); + db.merge_transitions(BundleRetention::PlainState); + let bundle = db.take_bundle(); + + let from_bundle = + HashedPostState::from_bundle_state::(bundle.state.iter()); + let from_hook = evm_state_to_hashed_post_state(evm_state); + + assert_eq!( + from_hook.accounts, from_bundle.accounts, + "state-hook and bundle producers disagree about durable account state" + ); + } + + /// An account created during the block whose final info is empty. EIP-161 deletes it, so + /// the bundle producer reports a removal. + #[test] + fn created_empty_account_matches_bundle_state() { + use revm::{ + database::{states::bundle_state::BundleRetention, State}, + DatabaseCommit, + }; + + let address = Address::repeat_byte(0x08); + let mut account = Account::default(); + account.mark_touch(); + assert!(account.mark_created_locally()); + assert!(account.is_empty()); + let evm_state = EvmState::from_iter([(address, account)]); + + let mut db = State::builder().with_bundle_update().build(); + db.commit(evm_state.clone()); + db.merge_transitions(BundleRetention::PlainState); + let bundle = db.take_bundle(); + + let from_bundle = + HashedPostState::from_bundle_state::(bundle.state.iter()); + let from_hook = evm_state_to_hashed_post_state(evm_state); + + assert_eq!( + from_hook.accounts.get(&keccak256(address)).copied().flatten(), + from_bundle.accounts.get(&keccak256(address)).copied().flatten(), + "state-hook and bundle producers disagree about a created-empty account" + ); + } + + /// A zero-value call to an address that never existed leaves it non-existent. revm's bundle + /// path emits no transition for it (`CacheAccount::touch_empty_eip161` returns `None` for + /// `LoadedNotExisting`). Asserts the converter also emits nothing, rather than a deletion + /// that would queue a `HashedAccounts` delete and a storage-trie wipe for an unused address. + #[test] + fn touched_never_existing_account_matches_bundle_state() { + use revm::{ + database::{states::bundle_state::BundleRetention, State}, + DatabaseCommit, + }; + + let address = Address::repeat_byte(0x09); + let mut account = Account::new_not_existing(TransactionId::default()); + account.mark_touch(); + let evm_state = EvmState::from_iter([(address, account)]); + + let mut db = State::builder().with_bundle_update().build(); + db.commit(evm_state.clone()); + db.merge_transitions(BundleRetention::PlainState); + let bundle = db.take_bundle(); + + let from_bundle = + HashedPostState::from_bundle_state::(bundle.state.iter()); + let from_hook = evm_state_to_hashed_post_state(evm_state); + + assert_eq!( + from_hook.accounts, from_bundle.accounts, + "state-hook and bundle producers disagree about a never-existing touched account" + ); + } + + /// An account touched without being changed. revm's bundle producer reports nothing for it. + /// Asserts the converter agrees, so a block full of zero-value calls does not rewrite + /// unchanged `HashedAccounts` rows. + #[test] + fn touched_unchanged_account_matches_bundle_state() { + use revm::{ + database::{states::bundle_state::BundleRetention, State}, + state::AccountInfo, + DatabaseCommit, + }; + + let address = Address::repeat_byte(0x0a); + let pre = AccountInfo { balance: U256::from(7), nonce: 1, ..Default::default() }; + let mut account = Account::from(pre.clone()); + account.mark_touch(); + assert!(!account.is_empty()); + let evm_state = EvmState::from_iter([(address, account)]); + + let mut db = State::builder().with_bundle_update().build(); + db.insert_account(address, pre); + db.commit(evm_state.clone()); + db.merge_transitions(BundleRetention::PlainState); + let bundle = db.take_bundle(); + + let from_bundle = + HashedPostState::from_bundle_state::(bundle.state.iter()); + let from_hook = evm_state_to_hashed_post_state(evm_state); + + assert_eq!( + from_hook.accounts, from_bundle.accounts, + "state-hook and bundle producers disagree about a touched but unchanged account" + ); + } + #[derive(Default)] struct CountingSink { access_hints: AtomicUsize, From 56c3d375fbbb4543ff1eb702138ad01d672bd0e9 Mon Sep 17 00:00:00 2001 From: Brian Picciano Date: Wed, 7 Oct 2026 23:17:37 +0000 Subject: [PATCH 07/10] fix(trie): rewind backward overlay seeks (#27782) (cherry picked from commit 5868ee478841e1eaffc2fae740b60b7d5a920896) --- crates/trie/trie/src/hashed_cursor/post_state.rs | 4 ++++ crates/trie/trie/src/trie_cursor/in_memory.rs | 8 ++++++++ 2 files changed, 12 insertions(+) diff --git a/crates/trie/trie/src/hashed_cursor/post_state.rs b/crates/trie/trie/src/hashed_cursor/post_state.rs index a5e6e593347..d6d6c2fe906 100644 --- a/crates/trie/trie/src/hashed_cursor/post_state.rs +++ b/crates/trie/trie/src/hashed_cursor/post_state.rs @@ -299,6 +299,10 @@ 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, DatabaseError> { + // Forward scans can reuse cursor positions; backward seeks and exhausted cursors cannot. + if self.last_key.is_none_or(|last| key < last) { + self.reset(); + } let post_state_entry = self.post_state_cursor.seek(&key).copied().map(|(k, v)| (k, v.into_option())); diff --git a/crates/trie/trie/src/trie_cursor/in_memory.rs b/crates/trie/trie/src/trie_cursor/in_memory.rs index 1d704cc4abf..8db7853e804 100644 --- a/crates/trie/trie/src/trie_cursor/in_memory.rs +++ b/crates/trie/trie/src/trie_cursor/in_memory.rs @@ -238,6 +238,10 @@ impl TrieCursor for InMemoryTrieCursor<'_, C> { &mut self, key: Nibbles, ) -> Result, DatabaseError> { + // Forward scans can reuse cursor positions; backward seeks and exhausted cursors cannot. + if self.last_key.is_none_or(|last| key < last) { + self.reset(); + } let mem_entry = self.in_memory_cursor.seek(&key); if let Some((mem_key, entry_inner)) = mem_entry && @@ -281,6 +285,10 @@ impl TrieCursor for InMemoryTrieCursor<'_, C> { &mut self, key: Nibbles, ) -> Result, DatabaseError> { + // Forward scans can reuse cursor positions; backward seeks and exhausted cursors cannot. + if self.last_key.is_none_or(|last| key < last) { + self.reset(); + } let mem_entry = self.in_memory_cursor.seek(&key); if let Some((mem_key, Some(node))) = mem_entry && From 5f793856dd20b855973d8cdfa593d774e7534338 Mon Sep 17 00:00:00 2001 From: Derek Cofausper <256792747+decofe@users.noreply.github.com> Date: Fri, 9 Oct 2026 00:39:09 +0000 Subject: [PATCH 08/10] fix(trie): remove orphaned branches (#27832) Co-authored-by: Brian Picciano <933154+mediocregopher@users.noreply.github.com> Co-authored-by: Brian Picciano (cherry picked from commit 5e309af68bb064eb594807bf8d2b2e6638b91c27) --- crates/trie/trie/src/trie.rs | 6 + crates/trie/trie/src/walker.rs | 239 ++++++++++++++++++++++++++++++--- 2 files changed, 230 insertions(+), 15 deletions(-) diff --git a/crates/trie/trie/src/trie.rs b/crates/trie/trie/src/trie.rs index bf3144046de..9ff833dc9ce 100644 --- a/crates/trie/trie/src/trie.rs +++ b/crates/trie/trie/src/trie.rs @@ -73,6 +73,9 @@ impl StateRoot { } /// Configures the state root walker to visit all children of changed branch paths. + /// + /// When updates are retained, also removes stored descendants hidden by a changed branch's + /// tree mask. Regenerated branch updates take precedence over these deletions. pub const fn with_walk_all_changed_branch_children(mut self, enabled: bool) -> Self { self.walk_all_changed_branch_children = enabled; self @@ -586,6 +589,9 @@ impl StorageRoot { } /// Configures the storage root walker to visit all children of changed branch paths. + /// + /// When updates are retained, also removes stored descendants hidden by a changed branch's + /// tree mask. Regenerated branch updates take precedence over these deletions. pub const fn with_walk_all_changed_branch_children(mut self, enabled: bool) -> Self { self.walk_all_changed_branch_children = enabled; self diff --git a/crates/trie/trie/src/walker.rs b/crates/trie/trie/src/walker.rs index a8442578575..4702d86b3a0 100644 --- a/crates/trie/trie/src/walker.rs +++ b/crates/trie/trie/src/walker.rs @@ -4,22 +4,10 @@ use crate::{ BranchNodeCompact, Nibbles, }; use alloy_primitives::{map::HashSet, B256}; -use alloy_trie::proof::AddedRemovedKeys; +use alloy_trie::{proof::AddedRemovedKeys, TrieMask}; use reth_storage_errors::db::DatabaseError; use tracing::{instrument, trace}; -#[cfg(test)] -use crate::trie_cursor::{mock::MockTrieCursorFactory, TrieCursorFactory}; - -#[cfg(test)] -use alloy_primitives::map::B256Map; - -#[cfg(test)] -use alloy_trie::TrieMask; - -#[cfg(test)] -use std::collections::BTreeMap; - #[cfg(feature = "metrics")] use crate::metrics::WalkerMetrics; @@ -126,6 +114,10 @@ impl> TrieWalker { } /// Configures the walker to treat every child of a matching branch path as unskippable. + /// + /// When deletions are retained, also collects stored descendants hidden by a matching + /// branch's tree mask. These keys appear in the deletion set even if traversal never visits + /// them. Root calculations can replace these deletions with regenerated branch updates. pub const fn with_walk_all_changed_branch_children(mut self, enabled: bool) -> Self { self.walk_all_changed_branch_children = enabled; self @@ -354,6 +346,8 @@ impl> TrieWalker { return Ok(()) } + self.remove_orphaned_descendants(key, node.tree_mask)?; + // Create a new CursorSubNode and push it to the stack. let subnode = CursorSubNode::new(key, Some(node)); let position = subnode.position(); @@ -415,13 +409,62 @@ impl> TrieWalker { Ok(()) } + + /// Removes cached descendants hidden by a changed branch's tree mask during recovery. + /// + /// For example, a change under `0x3a` can leave stored `0x3c` and `0x3c4...` entries while + /// parent `0x3` has tree-mask bit `c` clear. The walker skips those entries and therefore never + /// records their keys for deletion. + /// + /// Collect the hidden cache keys without using their hashes; regenerated branch updates take + /// precedence over these deletions. The cursor must be positioned on this parent; restore that + /// position afterwards so traversal continues unchanged. + fn remove_orphaned_descendants( + &mut self, + key: Nibbles, + tree_mask: TrieMask, + ) -> Result<(), DatabaseError> { + let missing_children = !tree_mask; + if self.walk_all_changed_branch_children && + !missing_children.is_empty() && + let Some(removed_keys) = &mut self.removed_keys && + self.changes.contains(&key) + { + for nibble in missing_children.iter() { + let mut prefix = key; + prefix.push(nibble); + let mut entry = self.cursor.seek(prefix)?; + #[cfg(feature = "metrics")] + self.metrics.inc_branch_nodes_seeked(); + while let Some((path, _)) = entry && + path.starts_with(&prefix) + { + removed_keys.insert(path); + entry = self.cursor.next()?; + } + } + self.cursor.seek_exact(key)?; + #[cfg(feature = "metrics")] + self.metrics.inc_branch_nodes_seeked(); + } + Ok(()) + } } #[cfg(test)] mod tests { use super::*; - use crate::prefix_set::PrefixSetMut; - use alloy_primitives::B256; + use crate::{ + mock::KeyVisitType, + prefix_set::PrefixSetMut, + progress::StorageRootProgress, + test_utils::{storage_root_prehashed, TrieTestHarness}, + trie_cursor::{mock::MockTrieCursorFactory, TrieCursorFactory}, + updates::StorageTrieUpdates, + StorageRoot, + }; + use alloy_primitives::{map::B256Map, B256, U256}; + use std::collections::BTreeMap; fn branch_node(state_mask: u16, tree_mask: u16, hash_mask: u16) -> BranchNodeCompact { let hash_count = hash_mask.count_ones() as usize; @@ -495,4 +538,170 @@ mod tests { assert_eq!(walker.key().copied(), Some(Nibbles::from_nibbles([0x2, 0x4]))); assert!(!walker.can_skip_current_node); } + + #[test] + fn changed_branch_children_remove_orphans() { + for regenerate_branch in [false, true] { + let mut storage = BTreeMap::from([ + (B256::right_padding_from(&[0x3a]), U256::ONE), + (B256::right_padding_from(&[0x3a, 0x01]), U256::from(10)), + (B256::right_padding_from(&[0x3a, 0x10]), U256::from(7)), + (B256::right_padding_from(&[0x3b]), U256::from(2)), + (B256::right_padding_from(&[0x3c, 0x47]), U256::from(3)), + (B256::right_padding_from(&[0x80]), U256::from(4)), + (B256::right_padding_from(&[0x81]), U256::from(5)), + (B256::right_padding_from(&[0x80, 0x10]), U256::from(8)), + ]); + if regenerate_branch { + storage.insert(B256::right_padding_from(&[0x3c, 0x48]), U256::from(6)); + storage.insert(B256::right_padding_from(&[0x3c, 0x47, 0x10]), U256::from(9)); + } + let mut harness = TrieTestHarness::new(storage.clone()); + let expected_nodes = harness + .storage_trie_updates() + .storage_nodes + .iter() + .map(|(key, node)| (*key, node.clone())) + .collect::>(); + let mut stored_nodes = expected_nodes.clone(); + let parent = Nibbles::from_nibbles([0x3]); + stored_nodes.get_mut(&parent).unwrap().tree_mask &= + !TrieMask::new((1 << 0xa) | (1 << 0xc)); + + // The cached branch at 0x3c and its descendants are unreachable through 0x3's mask. + // Include a descendant which should be regenerated and one which should disappear. + let orphan_paths = [ + Nibbles::from_nibbles([0x3, 0xc]), + Nibbles::from_nibbles([0x3, 0xc, 0x4]), + Nibbles::from_nibbles([0x3, 0xc, 0x4, 0xf]), + Nibbles::from_nibbles([0x3, 0xf, 0x1]), + Nibbles::from_nibbles([0x3, 0x1, 0x4]), + ]; + // The valid branch under 0x3a is also hidden by the mask. Its regenerated update can + // be split off before the walker finishes 0x3, so resumption must not delete it again. + assert!(expected_nodes.contains_key(&Nibbles::from_nibbles([0x3, 0xa]))); + for path in orphan_paths { + let mut stale_node = branch_node(0b11, 0, 0b11); + stale_node.hashes = vec![B256::repeat_byte(0xee); 2].into(); + stored_nodes.insert(path, stale_node); + } + harness.set_trie_nodes(stored_nodes.clone()); + + // A change under sibling 0x3a must also clean up 0x3c and state-mask gaps. + let prefix_set = + PrefixSetMut::from([Nibbles::unpack(B256::right_padding_from(&[0x3a]))]).freeze(); + for (enabled, threshold) in [(false, u64::MAX), (true, u64::MAX), (true, 1)] { + // Also rebuild the neighboring branch in checkpointed runs. Resuming a skipped + // branch after a leaf checkpoint currently fails even without orphan cleanup. + let changes = if threshold == 1 { + PrefixSetMut::from([ + Nibbles::unpack(B256::right_padding_from(&[0x3a])), + Nibbles::unpack(B256::right_padding_from(&[0x80])), + ]) + .freeze() + } else { + prefix_set.clone() + }; + let (root, updates) = + storage_root_with_progress(&harness, changes, enabled, threshold); + + let mut resulting_nodes = stored_nodes.clone(); + for (path, node) in updates.into_sorted().storage_nodes { + if let Some(node) = node { + resulting_nodes.insert(path, node); + } else { + resulting_nodes.remove(&path); + } + } + assert_eq!(root, storage_root_prehashed(storage.clone())); + if enabled { + assert_eq!(resulting_nodes, expected_nodes); + } else { + // Normal traversal ignores hidden descendants, but leaves them in the cache. + assert_ne!(resulting_nodes, expected_nodes); + } + } + } + } + + fn storage_root_with_progress( + harness: &TrieTestHarness, + changes: PrefixSet, + enabled: bool, + threshold: u64, + ) -> (B256, StorageTrieUpdates) { + let mut previous_state = None; + let mut updates = StorageTrieUpdates::default(); + let mut checkpoints = 0; + loop { + let progress = StorageRoot::new_hashed( + harness.trie_cursor_factory(), + harness.hashed_cursor_factory(), + harness.hashed_address(), + changes.clone(), + #[cfg(feature = "metrics")] + crate::metrics::TrieRootMetrics::new(crate::TrieType::Storage), + ) + .with_walk_all_changed_branch_children(enabled) + .with_threshold(threshold) + .with_intermediate_state(previous_state) + .root_with_progress() + .unwrap(); + match progress { + StorageRootProgress::Progress(state, _, new_updates) => { + updates.extend(new_updates); + previous_state = Some(*state); + checkpoints += 1; + } + StorageRootProgress::Complete(root, _, new_updates) => { + updates.extend(new_updates); + if threshold == 1 { + assert!(checkpoints > 1); + } + return (root, updates) + } + } + } + } + + #[test] + fn orphan_cleanup_skips_live_subtrees() { + let parent = Nibbles::from_nibbles([0x3]); + let tree_mask = TrieMask::from_nibble(0xa); + let orphans = [ + Nibbles::from_nibbles([0x3, 0xb]), + Nibbles::from_nibbles([0x3, 0xb, 0x5]), + Nibbles::from_nibbles([0x3, 0xb, 0x5, 0xf]), + ]; + let mut nodes = BTreeMap::from([ + (parent, branch_node((1 << 0xa) | (1 << 0xb), tree_mask.get(), 0)), + (Nibbles::from_nibbles([0x3, 0xa]), branch_node(0b11, 0, 0)), + (Nibbles::from_nibbles([0x4]), branch_node(0b11, 0, 0)), + ]); + for index in 0..128 { + nodes.insert( + Nibbles::from_nibbles([0x3, 0xa, index / 16, index % 16]), + branch_node(0b11, 0, 0), + ); + } + nodes.extend(orphans.into_iter().map(|path| (path, branch_node(0b11, 0, 0)))); + let factory = MockTrieCursorFactory::new(nodes, B256Map::default()); + let changes = PrefixSetMut::from([Nibbles::from_nibbles([0x3, 0xa])]).freeze(); + let mut walker = + TrieWalker::<_>::state_trie(factory.account_trie_cursor().unwrap(), changes) + .with_walk_all_changed_branch_children(true) + .with_deletions_retained(true); + walker.cursor.seek_exact(parent).unwrap(); + factory.visited_account_keys().clear(); + walker.remove_orphaned_descendants(parent, tree_mask).unwrap(); + + assert_eq!(walker.take_removed_keys(), HashSet::from_iter(orphans)); + assert_eq!(walker.cursor.current().unwrap(), Some(parent)); + let next_count = factory + .visited_account_keys() + .iter() + .filter(|visit| matches!(visit.visit_type, KeyVisitType::Next)) + .count(); + assert!(next_count <= 4, "cleanup walked {next_count} entries for 3 orphan nodes"); + } } From cd6b0c3cf71a8b6342efbeaa3acf0b338cb971df Mon Sep 17 00:00:00 2001 From: Derek Cofausper <256792747+decofe@users.noreply.github.com> Date: Thu, 17 Sep 2026 16:54:06 +0000 Subject: [PATCH 09/10] chore(deps): update imbl and remove bitmaps exception (#27286) Co-authored-by: Sergei Shulepov <2205845+pepyakin@users.noreply.github.com> (cherry picked from commit 25993190fae484f6d93a247a935d25db30b3d6fc) --- Cargo.lock | 18 ++++-------------- deny.toml | 2 -- 2 files changed, 4 insertions(+), 16 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9a19ff74073..3c61ed85363 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1756,12 +1756,6 @@ dependencies = [ "serde_core", ] -[[package]] -name = "bitmaps" -version = "3.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1d084b0137aaa901caf9f1e8b21daa6aa24d41cd806e111335541eff9683bd6" - [[package]] name = "bitvec" version = "1.0.1" @@ -5014,13 +5008,12 @@ dependencies = [ [[package]] name = "imbl" -version = "7.0.1" +version = "7.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43ea8d4c37ee560727e824d62804183624d371e632019b0e9e3532bce64a33e5" +checksum = "46bad832b9b463ed9398b8506488cc2e3b897a9d44f13af115f382aac71f4fec" dependencies = [ "arbitrary", "archery", - "bitmaps", "equivalent", "imbl-sized-chunks", "rand_core 0.9.5", @@ -5032,12 +5025,9 @@ dependencies = [ [[package]] name = "imbl-sized-chunks" -version = "0.1.3" +version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f4241005618a62f8d57b2febd02510fb96e0137304728543dfc5fd6f052c22d" -dependencies = [ - "bitmaps", -] +checksum = "2a0813be332553f857953298749fa19549e8b61b80589757c29b4e2a804fa9c6" [[package]] name = "impl-codec" diff --git a/deny.toml b/deny.toml index 133b02e82a1..be45b22db44 100644 --- a/deny.toml +++ b/deny.toml @@ -12,8 +12,6 @@ ignore = [ "RUSTSEC-2023-0089", # https://rustsec.org/advisories/RUSTSEC-2026-0173 proc-macro-error2 is unmaintained "RUSTSEC-2026-0173", - # https://rustsec.org/advisories/RUSTSEC-2026-0247 bitmaps is unmaintained, transitive dep via imbl - "RUSTSEC-2026-0247", ] # This section is considered when running `cargo deny check bans`. From 8d359d0142719d4042eaf09fcbb7e4a1f89c37ac Mon Sep 17 00:00:00 2001 From: Sebastian Stammler Date: Tue, 15 Sep 2026 15:59:19 +0200 Subject: [PATCH 10/10] ci: run fork validation through CircleCI act Squash the fork CI support from 04e73b7c2bdc8dcf3c1e8961c8d04b861bc15a8e and push-event support from b0d194cad81ddf9dcb954ecee95b22cc2d68b70b into one replayable maintenance commit. Preserve release action pins and advisory policy when resolving the replay. Select the book build job without entering Pages deployment. Refresh the standalone lockfile to patched h2 and rustls releases instead of suppressing RUSTSEC-2026-0258 and RUSTSEC-2026-0285; rustls requires the updated AWS-LC backend. Run cargo deny natively instead of through act (folded in from c279f31455e8b714c1123c19accb1a68bd566f7c): lint.yml's `deny` job calls tempoxyz/ci's reusable deny.yml, which starts with tempoxyz's secure-runner. That action requires a GitHub OIDC token unless the event is a fork pull request, and act never receives one, so the job failed on every push and same-repo PR. Run the same `cargo deny --all-features check all` in a CircleCI job with a digest-pinned Rust image and a checksum-pinned cargo-deny release, and drop `deny` from the act lint matrix. Co-authored-by: Josh Klopfenstein Co-authored-by: falcorocks <14293929+falcorocks@users.noreply.github.com> Co-Authored-By: Claude Opus 5.5 (1M context) Maintenance CI: Compare optimism push vectors against v2.6.0, retaining actual PR and merge-queue bases.: --- .circleci/config.yml | 243 ++++++++++++++++++++++++++++++ .circleci/prepare-act-event.sh | 102 +++++++++++++ .github/scripts/check_rv32imac.sh | 2 +- .github/scripts/check_wasm.sh | 2 +- .github/workflows/book.yml | 2 + .github/workflows/compact.yml | 10 +- .github/workflows/e2e.yml | 4 + .github/workflows/integration.yml | 4 + .github/workflows/lint.yml | 20 ++- .github/workflows/stage.yml | 2 + .github/workflows/unit.yml | 6 + 11 files changed, 391 insertions(+), 6 deletions(-) create mode 100644 .circleci/config.yml create mode 100755 .circleci/prepare-act-event.sh diff --git a/.circleci/config.yml b/.circleci/config.yml new file mode 100644 index 00000000000..4ed70d500ab --- /dev/null +++ b/.circleci/config.yml @@ -0,0 +1,243 @@ +version: 2.1 + +# Runs this fork's validation workflows through pinned act because GitHub Actions is disabled. +# Pull requests and branch pushes run the PR checks; merge queues add stage.yml. Event metadata is +# generated once per CircleCI revision and shared by all shards. +# +# The read-only GitHub token is exposed to PR code, so its CircleCI context must remain +# restricted to trusted contributors. Keep CircleCI auto-cancellation enabled. +# +# The act binary, checksum, and runner image are pinned. Compiler caches are no-ops because +# act's local cache is not reusable across these machines; Pages plumbing is skipped after the +# validation build. Lint and unit jobs are distributed; other workflows run up to four jobs. +# +# Excluded: pr-title.yml, label-pr.yml, and the privileged cyclops-audit.yml integration. + +jobs: + # Replaces lint.yml's `deny` job, which calls tempoxyz/ci's reusable deny.yml. That workflow starts + # with tempoxyz's secure-runner, which needs a GitHub OIDC token that act never receives, so the + # check itself runs natively here. Its policy comes from deny.toml in this repo. + # + # When re-applying this CI patch onto a new reth release, diff lint.yml's `deny:` job and the + # tempoxyz/ci deny.yml it calls against this job (toolchain, cargo-deny version, `check` + # arguments, deny flags), and update both pins here. + cargo-deny: + docker: + - image: rust:1.95-bookworm@sha256:6258907abe69656e41cd992e0b705cdcfabcbbe3db374f92ed2d47121282d4a1 + resource_class: medium + steps: + - checkout + - run: + name: Install pinned cargo-deny + command: | + set -euo pipefail + readonly DENY_VERSION="0.20.2" + readonly DENY_SHA256="9f12ed4c49936e09b48bf862b595cde2fe64fcbd9d74dfacac6131ca824c8d5f" + readonly DENY_ARCHIVE="cargo-deny-${DENY_VERSION}-x86_64-unknown-linux-musl.tar.gz" + curl --fail --silent --show-error --location \ + "https://github.com/EmbarkStudios/cargo-deny/releases/download/${DENY_VERSION}/${DENY_ARCHIVE}" \ + --output "/tmp/${DENY_ARCHIVE}" + echo "${DENY_SHA256} /tmp/${DENY_ARCHIVE}" | sha256sum --check + tar -xzf "/tmp/${DENY_ARCHIVE}" -C /usr/local/bin --strip-components=1 \ + "cargo-deny-${DENY_VERSION}-x86_64-unknown-linux-musl/cargo-deny" + test "$(cargo-deny --version)" = "cargo-deny ${DENY_VERSION}" + - run: + name: cargo deny check + command: cargo deny --log-level warn --all-features check all + + prepare-act-event: + machine: + image: ubuntu-2404:2025.09.1 + resource_class: medium + steps: + - checkout + - run: + name: Snapshot GitHub event + command: | + mkdir -p /tmp/act-event + if ! .circleci/prepare-act-event.sh; then + echo "GitHub event preparation failed; act shards will report the failure" | + tee /tmp/act-event/failed + fi + - persist_to_workspace: + root: /tmp/act-event + paths: + - . + + act: + parameters: + wf: + type: string + job: + type: string + default: "" + concurrent_jobs: + type: integer + default: 4 + machine: + image: ubuntu-2404:2025.09.1 + resource_class: xlarge + steps: + - checkout + - attach_workspace: + at: /tmp/act-event + - run: + name: Check event snapshot + command: | + if [ -f /tmp/act-event/failed ]; then + cat /tmp/act-event/failed >&2 + exit 1 + fi + - run: + name: Install pinned act + command: | + set -euo pipefail + readonly ACT_VERSION="0.2.89-action-cache-fix.1" + readonly ACT_RELEASE="v0.2.89-action-cache-fix.4" + readonly ACT_BINARY="act_Linux_x86_64" + readonly ACT_SHA256="28bfcf1502f59a834b14f2fb23c39e5b253c2234d875592b5aa0a175f9674dce" + curl --fail --silent --show-error --location \ + "https://github.com/ethereum-optimism/act/releases/download/${ACT_RELEASE}/${ACT_BINARY}" \ + --output "/tmp/${ACT_BINARY}" + echo "${ACT_SHA256} /tmp/${ACT_BINARY}" | sha256sum --check + sudo install -m 0755 "/tmp/${ACT_BINARY}" /usr/local/bin/act + test "$(act --version)" = "act version ${ACT_VERSION}" + - run: + name: Stub unsupported non-check actions + command: | + mkdir -p /tmp/noop-action + printf '%s\n' \ + 'name: noop' \ + 'description: disabled service plumbing under act' \ + 'inputs:' \ + ' cache-bin: {required: false}' \ + ' cache-on-failure: {required: false}' \ + ' cache-targets: {required: false}' \ + ' prefix-key: {required: false}' \ + 'runs:' \ + ' using: composite' \ + ' steps:' \ + ' - run: echo "Service plumbing disabled under act"' \ + ' shell: bash' \ + > /tmp/noop-action/action.yml + - run: + name: Run << parameters.wf >> via act + no_output_timeout: 45m + command: | + set -euo pipefail + event_path=/tmp/act-event/github-event.json + event_name="$(jq -er 'if .pull_request then "pull_request" elif .merge_group then "merge_group" elif .ref and .after then "push" else error("unsupported event") end' "$event_path")" + base_ref="$(jq -r '(.pull_request.base.ref // .merge_group.base_ref // "") | sub("^refs/heads/"; "")' "$event_path")" + target_job="<< parameters.job >>" + # Validate documentation without entering Pages deployment on branch pushes. + if [ "<< parameters.wf >>" = "book.yml" ]; then + target_job=build + fi + act_job=() + if [ -n "$target_job" ]; then + case "$target_job" in + crate-checks-*) + partition="${target_job#crate-checks-}" + if [[ ! "$partition" =~ ^[1-9][0-9]*$ ]]; then + echo "invalid crate-checks partition: $partition" >&2 + exit 1 + fi + act_job=(-j crate-checks --matrix "partition:${partition}") + ;; + *) + act_job=(-j "$target_job") + ;; + esac + fi + + act_env=(--env "RUSTC_WRAPPER=" --env "GITHUB_BASE_REF=${base_ref}") + if [ "<< parameters.wf >>" = "unit.yml" ] && [ "$target_job" = "state" ]; then + # EF tests use Rayon internally, so unrestricted nextest processes multiply + # runnable threads and starve valid_blocks past its upstream timeout. + act_env+=(--env "NEXTEST_TEST_THREADS=2") + fi + if [ "$event_name" != "pull_request" ]; then + act_env+=( + --env "GITHUB_REF=refs/heads/${CIRCLE_BRANCH}" + --env "GITHUB_SHA=${CIRCLE_SHA1}" + ) + fi + + act "$event_name" -W ".github/workflows/<< parameters.wf >>" \ + "${act_job[@]}" \ + --eventpath "$event_path" \ + -P "ubuntu-latest=catthehacker/ubuntu@sha256:b839c14c4410998529ec18f951262bdf87a2b23bc1467304d07b491b9455e074" \ + --concurrent-jobs << parameters.concurrent_jobs >> \ + "${act_env[@]}" \ + -s GITHUB_TOKEN="${MISE_GITHUB_TOKEN:?missing restricted read-only GitHub token}" \ + --local-repository "mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba=/tmp/noop-action" \ + --local-repository "Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6=/tmp/noop-action" \ + --local-repository "actions/configure-pages@45bfe0192ca1faeb007ade9deae92b16b8254a0d=/tmp/noop-action" \ + --local-repository "actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9=/tmp/noop-action" + +workflows: + reth-act: + jobs: + - prepare-act-event: + context: + - circleci-repo-readonly-authenticated-github-token + - act: + context: + - circleci-repo-readonly-authenticated-github-token + name: "act-<< matrix.wf >>" + requires: + - prepare-act-event + matrix: + parameters: + wf: + - book.yml + - compact.yml + - e2e.yml + - grafana.yml + - integration.yml + - lint-actions.yml + - stage.yml + - act: + wf: lint.yml + concurrent_jobs: 1 + context: + - circleci-repo-readonly-authenticated-github-token + name: "act-lint-<< matrix.job >>" + requires: + - prepare-act-event + matrix: + parameters: + job: + - clippy-binaries + - clippy + - wasm + - riscv + - crate-checks-1 + - crate-checks-2 + - crate-checks-3 + - msrv + - docs + - fmt + - udeps + - book + - typos + - check-toml + - grafana + - no-test-deps + - feature-propagation + - cargo-deny: + name: lint-deny + - act: + wf: unit.yml + concurrent_jobs: 1 + context: + - circleci-repo-readonly-authenticated-github-token + name: "act-unit-<< matrix.job >>" + requires: + - prepare-act-event + matrix: + parameters: + job: + - test + - state + - doc diff --git a/.circleci/prepare-act-event.sh b/.circleci/prepare-act-event.sh new file mode 100755 index 00000000000..99cccb27f3c --- /dev/null +++ b/.circleci/prepare-act-event.sh @@ -0,0 +1,102 @@ +#!/usr/bin/env bash +set -euo pipefail + +readonly OUTPUT_DIR="${ACT_EVENT_OUTPUT_DIR:-/tmp/act-event}" +readonly EVENT_PATH="${OUTPUT_DIR}/github-event.json" + +mkdir -p "$OUTPUT_DIR" +rm -f "$EVENT_PATH" + +: "${CIRCLE_SHA1:?missing CircleCI revision}" +: "${CIRCLE_PROJECT_USERNAME:?missing CircleCI project owner}" +: "${CIRCLE_PROJECT_REPONAME:?missing CircleCI project repository}" + +repository="${CIRCLE_PROJECT_USERNAME}/${CIRCLE_PROJECT_REPONAME}" + +if [[ "${CIRCLE_BRANCH:-}" == gh-readonly-queue/* ]]; then + event_name="merge_group" +elif [[ -n "${CIRCLE_PULL_REQUEST:-}" ]]; then + event_name="pull_request" +else + event_name="push" +fi + +case "$event_name" in + pull_request) + : "${CIRCLE_PULL_REQUEST:?pull-request trigger must provide CIRCLE_PULL_REQUEST}" + pr_number="${CIRCLE_PULL_REQUEST##*/}" + if [[ ! "$pr_number" =~ ^[1-9][0-9]*$ ]]; then + echo "invalid pull-request URL: ${CIRCLE_PULL_REQUEST}" >&2 + exit 1 + fi + + pull_request_path="${OUTPUT_DIR}/pull-request.json" + curl --fail --silent --show-error --location \ + -H "Accept: application/vnd.github+json" \ + -H "Authorization: Bearer ${MISE_GITHUB_TOKEN:?missing restricted read-only GitHub token}" \ + -H "X-GitHub-Api-Version: 2022-11-28" \ + "https://api.github.com/repos/${repository}/pulls/${pr_number}" > "$pull_request_path" + + event_head_sha="$(jq -er '.head.sha' "$pull_request_path")" + if [[ "$event_head_sha" != "$CIRCLE_SHA1" ]]; then + echo "PR head does not match CircleCI revision: ${CIRCLE_SHA1} != ${event_head_sha}" >&2 + exit 1 + fi + + jq '{ + action: "synchronize", + number: .number, + pull_request: ., + repository: .base.repo, + sender: .user + }' "$pull_request_path" > "$EVENT_PATH" + base_ref="$(jq -er '.base.ref | select(length > 0)' "$pull_request_path")" + head_ref="$(jq -er '.head.ref | select(length > 0)' "$pull_request_path")" + echo "act event: pull_request #${pr_number}, ${head_ref} -> ${base_ref}" + ;; + push) + : "${CIRCLE_BRANCH:?push trigger must provide CIRCLE_BRANCH}" + jq -n \ + --arg ref "refs/heads/${CIRCLE_BRANCH}" \ + --arg after "$CIRCLE_SHA1" \ + '{ref: $ref, after: $after}' > "$EVENT_PATH" + echo "act event: push ${CIRCLE_BRANCH} at ${CIRCLE_SHA1}" + ;; + merge_group) + : "${CIRCLE_BRANCH:?merge-queue trigger must provide CIRCLE_BRANCH}" + if [[ ! "$CIRCLE_BRANCH" =~ ^gh-readonly-queue/(.+)/pr-([1-9][0-9]*)-[^/]+$ ]]; then + echo "merge_group requires a gh-readonly-queue//pr-- branch, got: ${CIRCLE_BRANCH}" >&2 + exit 1 + fi + base_ref="${BASH_REMATCH[1]}" + + if ! base_sha="$(git rev-parse "${CIRCLE_SHA1}^1" 2>/dev/null)"; then + git fetch --no-tags --depth=2 origin "$CIRCLE_SHA1" + base_sha="$(git rev-parse "${CIRCLE_SHA1}^1")" + fi + + jq -n \ + --arg head_sha "$CIRCLE_SHA1" \ + --arg head_ref "refs/heads/${CIRCLE_BRANCH}" \ + --arg base_sha "$base_sha" \ + --arg base_ref "refs/heads/${base_ref}" \ + --arg repository "$repository" \ + --arg repository_name "$CIRCLE_PROJECT_REPONAME" \ + --arg repository_owner "$CIRCLE_PROJECT_USERNAME" \ + '{ + action: "checks_requested", + merge_group: { + head_sha: $head_sha, + head_ref: $head_ref, + base_sha: $base_sha, + base_ref: $base_ref + }, + repository: { + full_name: $repository, + name: $repository_name, + owner: {login: $repository_owner} + } + }' > "$EVENT_PATH" + echo "act event: merge_group ${CIRCLE_BRANCH} -> ${base_ref} at ${base_sha}" + ;; +esac diff --git a/.github/scripts/check_rv32imac.sh b/.github/scripts/check_rv32imac.sh index 4e477cdbed1..988a95a3309 100755 --- a/.github/scripts/check_rv32imac.sh +++ b/.github/scripts/check_rv32imac.sh @@ -32,7 +32,7 @@ trap 'rm -rf -- "$tmpdir"' EXIT INT TERM for crate in "${crates_to_check[@]}"; do outfile="$tmpdir/$crate.log" - if cargo +stable build -p "$crate" --target riscv32imac-unknown-none-elf --no-default-features --color never >"$outfile" 2>&1; then + if cargo build -p "$crate" --target riscv32imac-unknown-none-elf --no-default-features --color never >"$outfile" 2>&1; then echo "✅ $crate" else echo "❌ $crate" diff --git a/.github/scripts/check_wasm.sh b/.github/scripts/check_wasm.sh index 15a8b8122ff..e4d5a8037a8 100755 --- a/.github/scripts/check_wasm.sh +++ b/.github/scripts/check_wasm.sh @@ -110,7 +110,7 @@ for crate in "${crates[@]}"; do fi outfile="$tmpdir/$crate.log" - if cargo +stable build -p "$crate" --target wasm32-wasip1 --no-default-features --color never >"$outfile" 2>&1; then + if cargo build -p "$crate" --target wasm32-wasip1 --no-default-features --color never >"$outfile" 2>&1; then echo "✅ $crate" else echo "❌ $crate" diff --git a/.github/workflows/book.yml b/.github/workflows/book.yml index 07f26676b62..86a39c9945b 100644 --- a/.github/workflows/book.yml +++ b/.github/workflows/book.yml @@ -40,6 +40,8 @@ jobs: - name: Install Rust nightly uses: dtolnay/rust-toolchain@nightly + with: + toolchain: nightly-2026-07-14 - name: Build docs run: cd docs/vocs && bash scripts/build-cargo-docs.sh diff --git a/.github/workflows/compact.yml b/.github/workflows/compact.yml index 52ad1ff8374..ac60ce324b2 100644 --- a/.github/workflows/compact.yml +++ b/.github/workflows/compact.yml @@ -1,6 +1,6 @@ # Ensures that `Compact` codec changes are backwards compatible. # -# 1) checkout `main` +# 1) checkout the PR base, or the selected release for maintenance-branch pushes # 2) randomly generate and serialize to disk many different type vectors with `Compact` (eg. Header, Transaction, etc) # 3) checkout `pr` # 4) deserialize previously generated test vectors @@ -35,6 +35,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: @@ -42,9 +44,11 @@ jobs: - name: Checkout base uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: - ref: ${{ github.base_ref || 'main' }} + # Use v2.6.0's commit: the fork carries its history but does not mirror upstream tags. + # The maintenance branch must decode its release's data, not unreleased main formats. + ref: ${{ github.base_ref || (github.ref == 'refs/heads/optimism' && '73a3a00862a8f14f89e30da8de001456f18cfae0' || 'main') }} persist-credentials: false - # On `main` branch, generates test vectors and serializes them to disk using `Compact`. + # On the comparison base, generate test vectors and serialize them to disk using `Compact`. - name: Generate compact vectors run: | ${{ matrix.bin }} -- test-vectors compact --write diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml index 6031cd278a5..98f7d55e787 100644 --- a/.github/workflows/e2e.yml +++ b/.github/workflows/e2e.yml @@ -35,6 +35,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: @@ -71,6 +73,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml index 3d3ff5abf6d..45567fed0b0 100644 --- a/.github/workflows/integration.yml +++ b/.github/workflows/integration.yml @@ -42,6 +42,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - name: Install Geth run: .github/scripts/install_geth.sh - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 @@ -86,6 +88,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: tool: nextest diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index b52ca66799c..1368de51907 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -38,6 +38,7 @@ jobs: - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@clippy with: + toolchain: nightly-2026-07-14 components: clippy - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 @@ -62,6 +63,7 @@ jobs: - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@nightly with: + toolchain: nightly-2026-07-14 components: clippy - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 @@ -81,8 +83,10 @@ jobs: with: persist-credentials: false - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 + - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable with: + toolchain: "1.97.0" target: wasm32-wasip1 - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: @@ -94,7 +98,7 @@ jobs: - uses: dcarbone/install-jq-action@4fcb5062d7ce9bc4382d1a352d19ba3ba2c317c1 # v4.0.1 - name: Run Wasm checks run: | - sudo apt update && sudo apt install gcc-multilib + sudo apt update && sudo apt install --yes gcc-multilib .github/scripts/check_wasm.sh riscv: @@ -109,6 +113,7 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - uses: dtolnay/rust-toolchain@stable with: + toolchain: "1.97.0" target: riscv32imac-unknown-none-elf - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: @@ -138,6 +143,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: tool: cargo-hack @@ -183,6 +190,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@nightly + with: + toolchain: nightly-2026-07-14 - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: @@ -206,6 +215,7 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - uses: dtolnay/rust-toolchain@nightly with: + toolchain: nightly-2026-07-14 components: rustfmt - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - name: Run fmt @@ -224,6 +234,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@nightly + with: + toolchain: nightly-2026-07-14 - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: @@ -246,6 +258,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@nightly + with: + toolchain: nightly-2026-07-14 - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: @@ -308,6 +322,8 @@ jobs: persist-credentials: false - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - name: Ensure no arbitrary or proptest dependency on default build run: cargo tree --package reth -e=features,no-dev | grep -Eq "arbitrary|proptest" && exit 1 || exit 0 @@ -323,6 +339,8 @@ jobs: persist-credentials: false - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - uses: taiki-e/cache-cargo-install-action@9ee83daaa7b96a6fab930949ecf1122bba04a389 # v3.0.8 diff --git a/.github/workflows/stage.yml b/.github/workflows/stage.yml index bb5c2422482..a235be631cf 100644 --- a/.github/workflows/stage.yml +++ b/.github/workflows/stage.yml @@ -39,6 +39,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: diff --git a/.github/workflows/unit.yml b/.github/workflows/unit.yml index 9e59205b8d8..a42d46af854 100644 --- a/.github/workflows/unit.yml +++ b/.github/workflows/unit.yml @@ -42,6 +42,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: @@ -94,6 +96,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: tool: nextest @@ -118,6 +122,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: