feat: reduce upstream diff (#152)

Signed-off-by: Gregory Edison <[email protected]>

bin/reth/Cargo.toml

@@ -52,6 +52,8 @@ reth-payload-primitives.workspace = true
 reth-payload-validator.workspace = true
 reth-basic-payload-builder.workspace = true
 reth-static-file.workspace = true
+reth-trie = { workspace = true, features = ["metrics"] }
+reth-trie-db = { workspace = true, features = ["metrics"] }
 reth-node-api.workspace = true
 reth-node-core.workspace = true
 reth-ethereum-payload-builder.workspace = true

bin/reth/src/commands/debug_cmd/build_block.rs

@@ -254,7 +254,7 @@ impl<C: ChainSpecParser<ChainSpec = ChainSpec>> Command<C> {
 
                 let hashed_post_state = state_provider.hashed_post_state(execution_outcome.state());
                 let (state_root, trie_updates) =
-                    state_provider.state_root_from_state_with_updates(hashed_post_state.clone())?;
+                    state_provider.state_root_with_updates(hashed_post_state.clone())?;
 
                 if state_root != block_with_senders.state_root() {
                     eyre::bail!(

bin/reth/src/commands/debug_cmd/in_memory_merkle.rs

@@ -26,12 +26,13 @@ use reth_primitives::{EthPrimitives, SealedBlock};
 use reth_provider::{
     providers::ProviderNodeTypes, AccountExtReader, ChainSpecProvider, DatabaseProviderFactory,
     HashedPostStateProvider, HashingWriter, LatestStateProviderRef, OriginalValuesKnown,
-    ProviderFactory, StageCheckpointReader, StateRootProvider, StateRootProviderExt, StateWriter,
-    StorageLocation, StorageReader,
+    ProviderFactory, StageCheckpointReader, StateWriter, StorageLocation, StorageReader,
 };
 use reth_revm::database::StateProviderDatabase;
 use reth_stages::StageId;
 use reth_tasks::TaskExecutor;
+use reth_trie::StateRoot;
+use reth_trie_db::DatabaseStateRoot;
 use std::{path::PathBuf, sync::Arc};
 use tracing::*;
 
@@ -151,10 +152,10 @@ impl<C: ChainSpecParser<ChainSpec = ChainSpec>> Command<C> {
         let execution_outcome = ExecutionOutcome::from((block_execution_output, block.number()));
 
         // Unpacked `BundleState::state_root_slow` function
-        let (in_memory_state_root, in_memory_updates) = state_provider
-            .state_root_from_state_with_updates(
-                state_provider.hashed_post_state(execution_outcome.state()),
-            )?;
+        let (in_memory_state_root, in_memory_updates) = StateRoot::overlay_root_with_updates(
+            provider.tx_ref(),
+            state_provider.hashed_post_state(execution_outcome.state()),
+        )?;
 
         if in_memory_state_root == block.state_root() {
             info!(target: "reth::cli", state_root = ?in_memory_state_root, "Computed in-memory state root matches");
@@ -181,8 +182,10 @@ impl<C: ChainSpecParser<ChainSpec = ChainSpec>> Command<C> {
         let accounts = provider_rw.basic_accounts(account_lists)?;
         provider_rw.insert_account_for_hashing(accounts)?;
 
-        let (state_root, incremental_trie_updates) =
-            state_provider.incremental_state_root_with_updates(block.number()..=block.number())?;
+        let (state_root, incremental_trie_updates) = StateRoot::incremental_root_with_updates(
+            provider_rw.tx_ref(),
+            block.number..=block.number(),
+        )?;
         if state_root != block.state_root() {
             eyre::bail!(
                 "Computed incremental state root mismatch. Expected: {:?}. Got: {:?}",

crates/chain-state/src/in_memory.rs

@@ -951,15 +951,13 @@ mod tests {
     use reth_errors::ProviderResult;
     use reth_primitives::{Account, Bytecode, EthPrimitives, Receipt};
     use reth_storage_api::{
-        AccountReader, BlockHashReader, HashedPostStateProvider, HashedStorageProvider,
-        KeyHasherProvider, StateProofProvider, StateProvider, StateRootProvider,
-        StorageRootProvider,
+        AccountReader, BlockHashReader, HashedPostStateProvider, StateProofProvider, StateProvider,
+        StateRootProvider, StorageRootProvider,
     };
     use reth_trie::{
-        AccountProof, HashedStorage, KeccakKeyHasher, KeyHasher, MultiProof, MultiProofTargets,
-        StorageMultiProof, StorageProof, TrieInput,
+        AccountProof, HashedStorage, MultiProof, MultiProofTargets, StorageMultiProof,
+        StorageProof, TrieInput,
     };
-    use revm::db::BundleAccount;
 
     fn create_mock_state(
         test_block_builder: &mut TestBlockBuilder<EthPrimitives>,
@@ -1029,15 +1027,15 @@ mod tests {
     }
 
     impl StateRootProvider for MockStateProvider {
-        fn state_root_from_state(&self, _hashed_state: HashedPostState) -> ProviderResult<B256> {
+        fn state_root(&self, _hashed_state: HashedPostState) -> ProviderResult<B256> {
             Ok(B256::random())
         }
 
         fn state_root_from_nodes(&self, _input: TrieInput) -> ProviderResult<B256> {
             Ok(B256::random())
         }
 
-        fn state_root_from_state_with_updates(
+        fn state_root_with_updates(
             &self,
             _hashed_state: HashedPostState,
         ) -> ProviderResult<(B256, TrieUpdates)> {
@@ -1058,18 +1056,6 @@ mod tests {
         }
     }
 
-    impl HashedStorageProvider for MockStateProvider {
-        fn hashed_storage(&self, _account: &BundleAccount) -> HashedStorage {
-            HashedStorage::default()
-        }
-    }
-
-    impl KeyHasherProvider for MockStateProvider {
-        fn hash_key(&self, bytes: &[u8]) -> B256 {
-            KeccakKeyHasher::hash_key(bytes)
-        }
-    }
-
     impl StorageRootProvider for MockStateProvider {
         fn storage_root(
             &self,

crates/chain-state/src/memory_overlay.rs

@@ -6,14 +6,14 @@ use alloy_primitives::{
 use reth_errors::ProviderResult;
 use reth_primitives::{Account, Bytecode, NodePrimitives};
 use reth_storage_api::{
-    AccountReader, BlockHashReader, HashedPostStateProvider, HashedStorageProvider,
-    KeyHasherProvider, StateProofProvider, StateProvider, StateRootProvider, StorageRootProvider,
+    AccountReader, BlockHashReader, HashedPostStateProvider, StateProofProvider, StateProvider,
+    StateRootProvider, StorageRootProvider,
 };
 use reth_trie::{
     updates::TrieUpdates, AccountProof, HashedPostState, HashedStorage, MultiProof,
     MultiProofTargets, StorageMultiProof, TrieInput,
 };
-use revm::db::{BundleAccount, BundleState};
+use revm::db::BundleState;
 use std::sync::OnceLock;
 
 /// A state provider that stores references to in-memory blocks along with their state as well as a
@@ -111,7 +111,7 @@ impl<N: NodePrimitives> AccountReader for MemoryOverlayStateProviderRef<'_, N> {
 }
 
 impl<N: NodePrimitives> StateRootProvider for MemoryOverlayStateProviderRef<'_, N> {
-    fn state_root_from_state(&self, state: HashedPostState) -> ProviderResult<B256> {
+    fn state_root(&self, state: HashedPostState) -> ProviderResult<B256> {
         self.state_root_from_nodes(TrieInput::from_state(state))
     }
 
@@ -121,7 +121,7 @@ impl<N: NodePrimitives> StateRootProvider for MemoryOverlayStateProviderRef<'_,
         self.historical.state_root_from_nodes(input)
     }
 
-    fn state_root_from_state_with_updates(
+    fn state_root_with_updates(
         &self,
         state: HashedPostState,
     ) -> ProviderResult<(B256, TrieUpdates)> {
@@ -216,18 +216,6 @@ impl<N: NodePrimitives> HashedPostStateProvider for MemoryOverlayStateProviderRe
     }
 }
 
-impl<N: NodePrimitives> HashedStorageProvider for MemoryOverlayStateProviderRef<'_, N> {
-    fn hashed_storage(&self, account: &BundleAccount) -> HashedStorage {
-        self.historical.hashed_storage(account)
-    }
-}
-
-impl<N: NodePrimitives> KeyHasherProvider for MemoryOverlayStateProviderRef<'_, N> {
-    fn hash_key(&self, bytes: &[u8]) -> B256 {
-        self.historical.hash_key(bytes)
-    }
-}
-
 impl<N: NodePrimitives> StateProvider for MemoryOverlayStateProviderRef<'_, N> {
     fn storage(
         &self,

crates/cli/commands/Cargo.toml

@@ -45,7 +45,8 @@ reth-stages.workspace = true
 reth-stages-types = { workspace = true, optional = true }
 reth-static-file-types = { workspace = true, features = ["clap"] }
 reth-static-file.workspace = true
-reth-trie = { workspace = true, optional = true }
+reth-trie = { workspace = true, features = ["metrics"] }
+reth-trie-db = { workspace = true, features = ["metrics"] }
 reth-trie-common = { workspace = true, optional = true }
 reth-primitives-traits.workspace = true
 
@@ -107,7 +108,6 @@ arbitrary = [
     "reth-codecs/arbitrary",
     "reth-prune-types?/arbitrary",
     "reth-stages-types?/arbitrary",
-    "reth-trie",
     "reth-trie-common?/arbitrary",
     "alloy-consensus/arbitrary",
     "reth-primitives-traits/arbitrary",

crates/cli/commands/src/recover/storage_tries.rs

@@ -9,10 +9,9 @@ use reth_db_api::{
     cursor::{DbCursorRO, DbDupCursorRW},
     transaction::DbTx,
 };
-use reth_provider::{
-    BlockNumReader, HeaderProvider, LatestStateProviderRef, ProviderError, StateRootProviderExt,
-};
-
+use reth_provider::{BlockNumReader, HeaderProvider, ProviderError};
+use reth_trie::StateRoot;
+use reth_trie_db::DatabaseStateRoot;
 use tracing::*;
 
 /// `reth recover storage-tries` command
@@ -52,7 +51,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> Command<C>
             entry = storage_trie_cursor.next()?;
         }
 
-        let state_root = LatestStateProviderRef::new(&provider.0).state_root()?;
+        let state_root = StateRoot::from_tx(tx_mut).root()?;
         if state_root != best_header.state_root() {
             eyre::bail!(
                 "Recovery failed. Incorrect state root. Expected: {:?}. Received: {:?}",

crates/engine/invalid-block-hooks/src/witness.rs

@@ -1,5 +1,5 @@
 use alloy_consensus::BlockHeader;
-use alloy_primitives::B256;
+use alloy_primitives::{keccak256, B256};
 use alloy_rpc_types_debug::ExecutionWitness;
 use pretty_assertions::Comparison;
 use reth_chainspec::{EthChainSpec, EthereumHardforks};
@@ -67,9 +67,10 @@ where
         // TODO(alexey): unify with `DebugApi::debug_execution_witness`
 
         // Setup database.
-        let provider = self.provider.state_by_block_hash(parent_header.hash())?;
         let mut db = StateBuilder::new()
-            .with_database(StateProviderDatabase::new(&provider))
+            .with_database(StateProviderDatabase::new(
+                self.provider.state_by_block_hash(parent_header.hash())?,
+            ))
             .with_bundle_update()
             .build();
 
@@ -115,7 +116,7 @@ where
         // referenced accounts + storage slots.
         let mut hashed_state = db.database.hashed_post_state(&bundle_state);
         for (address, account) in db.cache.accounts {
-            let hashed_address = provider.hash_key(address.as_ref());
+            let hashed_address = keccak256(address);
             hashed_state
                 .accounts
                 .insert(hashed_address, account.account.as_ref().map(|a| a.info.clone().into()));
@@ -130,7 +131,7 @@ where
 
                 for (slot, value) in account.storage {
                     let slot = B256::from(slot);
-                    let hashed_slot = provider.hash_key(slot.as_ref());
+                    let hashed_slot = keccak256(slot);
                     storage.storage.insert(hashed_slot, value);
 
                     state_preimages.insert(hashed_slot, alloy_rlp::encode(slot).into());
@@ -220,7 +221,7 @@ where
         // Calculate the state root and trie updates after re-execution. They should match
         // the original ones.
         let (re_executed_root, trie_output) =
-            state_provider.state_root_from_state_with_updates(hashed_state)?;
+            state_provider.state_root_with_updates(hashed_state)?;
         if let Some((original_updates, original_root)) = trie_updates {
             if re_executed_root != original_root {
                 let filename = format!("{}_{}.state_root.diff", block.number(), block.hash());

crates/engine/tree/src/tree/cached_state.rs

@@ -6,10 +6,9 @@ use reth_errors::ProviderResult;
 use reth_metrics::Metrics;
 use reth_primitives_traits::{Account, Bytecode};
 use reth_provider::{
-    AccountReader, BlockHashReader, HashedPostStateProvider, HashedStorageProvider,
-    KeyHasherProvider, StateProofProvider, StateProvider, StateRootProvider, StorageRootProvider,
+    AccountReader, BlockHashReader, HashedPostStateProvider, StateProofProvider, StateProvider,
+    StateRootProvider, StorageRootProvider,
 };
-use reth_revm::db::BundleAccount;
 use reth_trie::{
     updates::TrieUpdates, AccountProof, HashedPostState, HashedStorage, MultiProof,
     MultiProofTargets, StorageMultiProof, StorageProof, TrieInput,
@@ -140,19 +139,19 @@ impl<S: StateProvider> StateProvider for CachedStateProvider<S> {
 }
 
 impl<S: StateRootProvider> StateRootProvider for CachedStateProvider<S> {
-    fn state_root_from_state(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
-        self.state_provider.state_root_from_state(hashed_state)
+    fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
+        self.state_provider.state_root(hashed_state)
     }
 
     fn state_root_from_nodes(&self, input: TrieInput) -> ProviderResult<B256> {
         self.state_provider.state_root_from_nodes(input)
     }
 
-    fn state_root_from_state_with_updates(
+    fn state_root_with_updates(
         &self,
         hashed_state: HashedPostState,
     ) -> ProviderResult<(B256, TrieUpdates)> {
-        self.state_provider.state_root_from_state_with_updates(hashed_state)
+        self.state_provider.state_root_with_updates(hashed_state)
     }
 
     fn state_root_from_nodes_with_updates(
@@ -190,18 +189,6 @@ impl<S: StateProofProvider> StateProofProvider for CachedStateProvider<S> {
     }
 }
 
-impl<S: StateProvider> HashedStorageProvider for CachedStateProvider<S> {
-    fn hashed_storage(&self, account: &BundleAccount) -> HashedStorage {
-        self.state_provider.hashed_storage(account)
-    }
-}
-
-impl<S: StateProvider> KeyHasherProvider for CachedStateProvider<S> {
-    fn hash_key(&self, bytes: &[u8]) -> B256 {
-        self.state_provider.hash_key(bytes)
-    }
-}
-
 impl<S: StorageRootProvider> StorageRootProvider for CachedStateProvider<S> {
     fn storage_root(
         &self,

crates/engine/tree/src/tree/mod.rs

@@ -2461,17 +2461,16 @@ where
                     }
                     Err(ParallelStateRootError::Provider(ProviderError::ConsistentView(error))) => {
                         debug!(target: "engine", %error, "Parallel state root computation failed consistency check, falling back");
-                        let (root, updates) = state_provider
-                            .state_root_from_state_with_updates(hashed_state.clone())?;
+                        let (root, updates) =
+                            state_provider.state_root_with_updates(hashed_state.clone())?;
                         (root, updates, root_time.elapsed())
                     }
                     Err(error) => return Err(InsertBlockErrorKind::Other(Box::new(error))),
                 }
             }
         } else {
             debug!(target: "engine::tree", block=?block_num_hash, ?is_descendant_of_persisting_blocks, "Failed to compute state root in parallel");
-            let (root, updates) =
-                state_provider.state_root_from_state_with_updates(hashed_state.clone())?;
+            let (root, updates) = state_provider.state_root_with_updates(hashed_state.clone())?;
             (root, updates, root_time.elapsed())
         };
 
@@ -2648,7 +2647,7 @@ where
                     }
 
                     let (regular_root, regular_updates) =
-                        state_provider.state_root_from_state_with_updates(hashed_state.clone())?;
+                        state_provider.state_root_with_updates(hashed_state.clone())?;
 
                     if regular_root == sealed_block.header().state_root() {
                         let provider_ro = state_root_task_config.consistent_view.provider_ro()?;
@@ -2673,7 +2672,7 @@ where
                 info!(target: "engine::tree", ?error, "Failed to wait for state root task result");
                 // Fall back to sequential calculation
                 let (root, updates) =
-                    state_provider.state_root_from_state_with_updates(hashed_state.clone())?;
+                    state_provider.state_root_with_updates(hashed_state.clone())?;
                 Ok((root, updates, root_time.elapsed()))
             }
         }

crates/engine/util/src/reorg.rs

@@ -408,7 +408,7 @@ where
             gas_used: cumulative_gas_used,
             blob_gas_used,
             excess_blob_gas,
-            state_root: state_provider.state_root_from_state(hashed_state)?,
+            state_root: state_provider.state_root(hashed_state)?,
             requests_hash: None, // TODO(prague)
         },
         body: BlockBody {

crates/ethereum/payload/src/lib.rs

@@ -391,7 +391,7 @@ where
     // calculate the state root
     let hashed_state = db.database.db.hashed_post_state(execution_outcome.state());
     let (state_root, _) = {
-        db.database.inner().state_root_from_state_with_updates(hashed_state).inspect_err(|err| {
+        db.database.inner().state_root_with_updates(hashed_state).inspect_err(|err| {
             warn!(target: "payload_builder",
                 parent_hash=%parent_header.hash(),
                 %err,