jleony/nanoreth
1
0
Fork 0
mirror of https://github.com/hl-archive-node/nanoreth.git synced 2025-12-06 10:59:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore(trie): clean up state root methods (#10598)

Browse Source
This commit is contained in:
Roman Krasiuk
2024-08-28 07:41:29 -07:00
committed by GitHub
parent 3be92d5049
commit 6f086d1060
25 changed files with 119 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Cargo.lock generated
View File

@ -6204,6 +6204,7 @@ dependencies = [
"reth-stages-api",
"reth-tokio-util",
"reth-transaction-pool",
"reth-trie",
"tokio",
"tokio-stream",
"tracing",
@ -6984,6 +6985,7 @@ dependencies = [
"reth-revm",
"reth-rpc-types",
"reth-rpc-types-compat",
"reth-trie",
"revm-primitives",
"serde",
"serde_json",
@ -7132,6 +7134,7 @@ dependencies = [
"reth-provider",
"reth-revm",
"reth-transaction-pool",
"reth-trie",
"revm",
"tracing",
]
@ -8358,6 +8361,7 @@ dependencies = [
"reth-rpc-types-compat",
"reth-tasks",
"reth-transaction-pool",
"reth-trie",
"revm",
"revm-inspectors",
"revm-primitives",
@ -8605,7 +8609,6 @@ dependencies = [
"reth-stages-types",
"reth-storage-errors",
"reth-trie",
"revm",
]
[[package]]

7
crates/blockchain-tree/src/chain.rs
View File

@ -22,7 +22,7 @@ use reth_provider::{
FullExecutionDataProvider, ProviderError, StateRootProvider,
};
use reth_revm::database::StateProviderDatabase;
use reth_trie::updates::TrieUpdates;
use reth_trie::{updates::TrieUpdates, HashedPostState};
use reth_trie_parallel::parallel_root::ParallelStateRoot;
use std::{
collections::BTreeMap,
@ -232,7 +232,10 @@ impl AppendableChain {
.map(|(root, updates)| (root, Some(updates)))
.map_err(ProviderError::from)?
} else {
(provider.state_root(initial_execution_outcome.state())?, None)
let hashed_state =
HashedPostState::from_bundle_state(&initial_execution_outcome.state().state);
let state_root = provider.state_root(hashed_state)?;
(state_root, None)
};
if block.state_root != state_root {
return Err(ConsensusError::BodyStateRootDiff(

10
crates/chain-state/src/in_memory.rs
View File

@ -886,11 +886,11 @@ mod tests {
}
impl StateRootProvider for MockStateProvider {
fn hashed_state_root(&self, _hashed_state: HashedPostState) -> ProviderResult<B256> {
fn state_root(&self, _hashed_state: HashedPostState) -> ProviderResult<B256> {
Ok(B256::random())
}
fn hashed_state_root_from_nodes(
fn state_root_from_nodes(
&self,
_nodes: TrieUpdates,
_post_state: HashedPostState,
@ -899,14 +899,14 @@ mod tests {
Ok(B256::random())
}
fn hashed_state_root_with_updates(
fn state_root_with_updates(
&self,
_hashed_state: HashedPostState,
) -> ProviderResult<(B256, TrieUpdates)> {
Ok((B256::random(), TrieUpdates::default()))
}
fn hashed_state_root_from_nodes_with_updates(
fn state_root_from_nodes_with_updates(
&self,
_nodes: TrieUpdates,
_post_state: HashedPostState,
@ -917,7 +917,7 @@ mod tests {
}
impl StorageRootProvider for MockStateProvider {
fn hashed_storage_root(
fn storage_root(
&self,
_address: Address,
_hashed_storage: HashedStorage,

32
crates/chain-state/src/memory_overlay.rs
View File

@ -102,12 +102,12 @@ impl AccountReader for MemoryOverlayStateProvider {
}
impl StateRootProvider for MemoryOverlayStateProvider {
fn hashed_state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
let prefix_sets = hashed_state.construct_prefix_sets();
self.hashed_state_root_from_nodes(TrieUpdates::default(), hashed_state, prefix_sets)
self.state_root_from_nodes(TrieUpdates::default(), hashed_state, prefix_sets)
}
fn hashed_state_root_from_nodes(
fn state_root_from_nodes(
&self,
nodes: TrieUpdates,
state: HashedPostState,
@ -116,22 +116,18 @@ impl StateRootProvider for MemoryOverlayStateProvider {
let MemoryOverlayTrieState { mut trie_nodes, mut hashed_state } = self.trie_state().clone();
trie_nodes.extend(nodes);
hashed_state.extend(state);
self.historical.hashed_state_root_from_nodes(trie_nodes, hashed_state, prefix_sets)
self.historical.state_root_from_nodes(trie_nodes, hashed_state, prefix_sets)
}
fn hashed_state_root_with_updates(
fn state_root_with_updates(
&self,
hashed_state: HashedPostState,
) -> ProviderResult<(B256, TrieUpdates)> {
let prefix_sets = hashed_state.construct_prefix_sets();
self.hashed_state_root_from_nodes_with_updates(
TrieUpdates::default(),
hashed_state,
prefix_sets,
)
self.state_root_from_nodes_with_updates(TrieUpdates::default(), hashed_state, prefix_sets)
}
fn hashed_state_root_from_nodes_with_updates(
fn state_root_from_nodes_with_updates(
&self,
nodes: TrieUpdates,
state: HashedPostState,
@ -140,21 +136,13 @@ impl StateRootProvider for MemoryOverlayStateProvider {
let MemoryOverlayTrieState { mut trie_nodes, mut hashed_state } = self.trie_state().clone();
trie_nodes.extend(nodes);
hashed_state.extend(state);
self.historical.hashed_state_root_from_nodes_with_updates(
trie_nodes,
hashed_state,
prefix_sets,
)
self.historical.state_root_from_nodes_with_updates(trie_nodes, hashed_state, prefix_sets)
}
}
impl StorageRootProvider for MemoryOverlayStateProvider {
// TODO: Currently this does not reuse available in-memory trie nodes.
fn hashed_storage_root(
&self,
address: Address,
storage: HashedStorage,
) -> ProviderResult<B256> {
fn storage_root(&self, address: Address, storage: HashedStorage) -> ProviderResult<B256> {
let mut hashed_storage = self
.trie_state()
.hashed_state
@ -163,7 +151,7 @@ impl StorageRootProvider for MemoryOverlayStateProvider {
.cloned()
.unwrap_or_default();
hashed_storage.extend(&storage);
self.historical.hashed_storage_root(address, hashed_storage)
self.historical.storage_root(address, hashed_storage)
}
}

1
crates/consensus/auto-seal/Cargo.toml
View File

@ -29,6 +29,7 @@ reth-consensus.workspace = true
reth-rpc-types.workspace = true
reth-network-peers.workspace = true
reth-tokio-util.workspace = true
reth-trie.workspace = true
# async
futures-util.workspace = true

4
crates/consensus/auto-seal/src/lib.rs
View File

@ -31,6 +31,7 @@ use reth_primitives::{
use reth_provider::{BlockReaderIdExt, StateProviderFactory, StateRootProvider};
use reth_revm::database::StateProviderDatabase;
use reth_transaction_pool::TransactionPool;
use reth_trie::HashedPostState;
use std::{
collections::HashMap,
sync::Arc,
@ -378,6 +379,7 @@ impl StorageInner {
executor.executor(&mut db).execute((&block, U256::ZERO).into())?;
let gas_used = block_execution_output.gas_used;
let execution_outcome = ExecutionOutcome::from((block_execution_output, block.number));
let hashed_state = HashedPostState::from_bundle_state(&execution_outcome.state().state);
// todo(onbjerg): we should not pass requests around as this is building a block, which
// means we need to extract the requests from the execution output and compute the requests
@ -389,7 +391,7 @@ impl StorageInner {
trace!(target: "consensus::auto", ?execution_outcome, ?header, ?body, "executed block, calculating state root and completing header");
// now we need to update certain header fields with the results of the execution
header.state_root = db.state_root(execution_outcome.state())?;
header.state_root = db.state_root(hashed_state)?;
header.gas_used = gas_used;
let receipts = execution_outcome.receipts_by_block(header.number);

2
crates/engine/tree/src/tree/mod.rs
View File

@ -1776,7 +1776,7 @@ where
let root_time = Instant::now();
let (state_root, trie_output) =
state_provider.hashed_state_root_with_updates(hashed_state.clone())?;
state_provider.state_root_with_updates(hashed_state.clone())?;
if state_root != block.state_root {
return Err(ConsensusError::BodyStateRootDiff(
GotExpected { got: state_root, expected: block.state_root }.into(),

1
crates/engine/util/Cargo.toml
View File

@ -25,6 +25,7 @@ reth-revm.workspace = true
reth-provider.workspace = true
reth-ethereum-forks.workspace = true
revm-primitives.workspace = true
reth-trie.workspace = true
# async
tokio = { workspace = true, default-features = false }

4
crates/engine/util/src/reorg.rs
View File

@ -23,6 +23,7 @@ use reth_rpc_types::{
ExecutionPayload,
};
use reth_rpc_types_compat::engine::payload::block_to_payload;
use reth_trie::HashedPostState;
use revm_primitives::{BlockEnv, CfgEnvWithHandlerCfg, EVMError, EnvWithHandlerCfg};
use std::{
collections::VecDeque,
@ -367,6 +368,7 @@ where
reorg_target.number,
Default::default(),
);
let hashed_state = HashedPostState::from_bundle_state(&outcome.state().state);
let (blob_gas_used, excess_blob_gas) =
if chain_spec.is_cancun_active_at_timestamp(reorg_target.timestamp) {
@ -406,7 +408,7 @@ where
gas_used: cumulative_gas_used,
blob_gas_used,
excess_blob_gas,
state_root: state_provider.state_root(outcome.state())?,
state_root: state_provider.state_root(hashed_state)?,
},
body: transactions,
ommers: reorg_target.ommers,

1
crates/ethereum/payload/Cargo.toml
View File

@ -23,6 +23,7 @@ reth-basic-payload-builder.workspace = true
reth-evm.workspace = true
reth-evm-ethereum.workspace = true
reth-errors.workspace = true
reth-trie.workspace = true
# ethereum
revm.workspace = true

24
crates/ethereum/payload/src/lib.rs
View File

@ -39,6 +39,7 @@ use reth_primitives::{
use reth_provider::StateProviderFactory;
use reth_revm::database::StateProviderDatabase;
use reth_transaction_pool::{BestTransactionsAttributes, TransactionPool};
use reth_trie::HashedPostState;
use revm::{
db::states::bundle_state::BundleRetention,
primitives::{EVMError, EnvWithHandlerCfg, InvalidTransaction, ResultAndState},
@ -170,14 +171,17 @@ where
// calculate the state root
let bundle_state = db.take_bundle();
let state_root = db.database.state_root(&bundle_state).map_err(|err| {
warn!(target: "payload_builder",
parent_hash=%parent_block.hash(),
%err,
"failed to calculate state root for empty payload"
);
err
})?;
let state_root = db
.database
.state_root(HashedPostState::from_bundle_state(&bundle_state.state))
.map_err(|err| {
warn!(target: "payload_builder",
parent_hash=%parent_block.hash(),
%err,
"failed to calculate state root for empty payload"
);
err
})?;
let mut excess_blob_gas = None;
let mut blob_gas_used = None;
@ -497,7 +501,9 @@ where
// calculate the state root
let state_root = {
let state_provider = db.database.0.inner.borrow_mut();
state_provider.db.state_root(execution_outcome.state())?
state_provider
.db
.state_root(HashedPostState::from_bundle_state(&execution_outcome.state().state))?
};
// create the block header

19
crates/optimism/payload/src/builder.rs
View File

@ -155,7 +155,8 @@ where
// calculate the state root
let bundle_state = db.take_bundle();
let state_root = db.database.state_root(&bundle_state).map_err(|err| {
let hashed_state = HashedPostState::from_bundle_state(&bundle_state.state);
let state_root = db.database.state_root(hashed_state).map_err(|err| {
warn!(target: "payload_builder",
parent_hash=%parent_block.hash(),
%err,
@ -529,15 +530,13 @@ where
let hashed_state = HashedPostState::from_bundle_state(&execution_outcome.state().state);
let (state_root, trie_output) = {
let state_provider = db.database.0.inner.borrow_mut();
state_provider.db.hashed_state_root_with_updates(hashed_state.clone()).inspect_err(
|err| {
warn!(target: "payload_builder",
parent_hash=%parent_block.hash(),
%err,
"failed to calculate state root for empty payload"
);
},
)?
state_provider.db.state_root_with_updates(hashed_state.clone()).inspect_err(|err| {
warn!(target: "payload_builder",
parent_hash=%parent_block.hash(),
%err,
"failed to calculate state root for empty payload"
);
})?
};
// create the block header

10
crates/revm/src/test_utils.rs
View File

@ -72,11 +72,11 @@ impl BlockHashReader for StateProviderTest {
}
impl StateRootProvider for StateProviderTest {
fn hashed_state_root(&self, _hashed_state: HashedPostState) -> ProviderResult<B256> {
fn state_root(&self, _hashed_state: HashedPostState) -> ProviderResult<B256> {
unimplemented!("state root computation is not supported")
}
fn hashed_state_root_from_nodes(
fn state_root_from_nodes(
&self,
_nodes: TrieUpdates,
_hashed_state: HashedPostState,
@ -85,14 +85,14 @@ impl StateRootProvider for StateProviderTest {
unimplemented!("state root computation is not supported")
}
fn hashed_state_root_with_updates(
fn state_root_with_updates(
&self,
_hashed_state: HashedPostState,
) -> ProviderResult<(B256, TrieUpdates)> {
unimplemented!("state root computation is not supported")
}
fn hashed_state_root_from_nodes_with_updates(
fn state_root_from_nodes_with_updates(
&self,
_nodes: TrieUpdates,
_hashed_state: HashedPostState,
@ -103,7 +103,7 @@ impl StateRootProvider for StateProviderTest {
}
impl StorageRootProvider for StateProviderTest {
fn hashed_storage_root(
fn storage_root(
&self,
_address: Address,
_hashed_storage: HashedStorage,

1
crates/rpc/rpc-eth-api/Cargo.toml
View File

@ -30,6 +30,7 @@ reth-execution-types.workspace = true
reth-rpc-eth-types.workspace = true
reth-rpc-server-types.workspace = true
reth-network-api.workspace = true
reth-trie.workspace = true
# ethereum
alloy-dyn-abi = { workspace = true, features = ["eip712"] }

7
crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
View File

@ -31,6 +31,7 @@ use reth_revm::{
};
use reth_rpc_eth_types::{EthApiError, PendingBlock, PendingBlockEnv, PendingBlockEnvOrigin};
use reth_transaction_pool::{BestTransactionsAttributes, TransactionPool};
use reth_trie::HashedPostState;
use revm::{db::states::bundle_state::BundleRetention, DatabaseCommit, State};
use tokio::sync::Mutex;
use tracing::debug;
@ -402,6 +403,7 @@ pub trait LoadPendingBlock: EthApiTypes {
block_number,
Vec::new(),
);
let hashed_state = HashedPostState::from_bundle_state(&execution_outcome.state().state);
let receipts_root = self.receipts_root(&block_env, &execution_outcome, block_number);
@ -410,9 +412,8 @@ pub trait LoadPendingBlock: EthApiTypes {
// calculate the state root
let state_provider = &db.database;
let state_root = state_provider
.state_root(execution_outcome.state())
.map_err(Self::Error::from_eth_err)?;
let state_root =
state_provider.state_root(hashed_state).map_err(Self::Error::from_eth_err)?;
// create the block header
let transactions_root = calculate_transaction_root(&executed_txs);

2
crates/rpc/rpc-eth-api/src/helpers/state.rs
View File

@ -147,7 +147,7 @@ pub trait EthState: LoadState + SpawnBlocking {
// Provide a default `HashedStorage` value in order to
// get the storage root hash of the current state.
let storage_root = state
.hashed_storage_root(address, Default::default())
.storage_root(address, Default::default())
.map_err(Self::Error::from_eth_err)?;
Ok(Some(Account { balance, nonce, code_hash, storage_root }))

20
crates/rpc/rpc-eth-types/src/cache/db.rs vendored
View File

@ -18,46 +18,46 @@ pub type StateCacheDb<'a> = CacheDB<StateProviderDatabase<StateProviderTraitObjW
pub struct StateProviderTraitObjWrapper<'a>(pub &'a dyn StateProvider);
impl<'a> reth_storage_api::StateRootProvider for StateProviderTraitObjWrapper<'a> {
fn hashed_state_root(
fn state_root(
&self,
hashed_state: reth_trie::HashedPostState,
) -> reth_errors::ProviderResult<B256> {
self.0.hashed_state_root(hashed_state)
self.0.state_root(hashed_state)
}
fn hashed_state_root_from_nodes(
fn state_root_from_nodes(
&self,
nodes: reth_trie::updates::TrieUpdates,
hashed_state: reth_trie::HashedPostState,
prefix_sets: reth_trie::prefix_set::TriePrefixSetsMut,
) -> reth_errors::ProviderResult<B256> {
self.0.hashed_state_root_from_nodes(nodes, hashed_state, prefix_sets)
self.0.state_root_from_nodes(nodes, hashed_state, prefix_sets)
}
fn hashed_state_root_with_updates(
fn state_root_with_updates(
&self,
hashed_state: reth_trie::HashedPostState,
) -> reth_errors::ProviderResult<(B256, reth_trie::updates::TrieUpdates)> {
self.0.hashed_state_root_with_updates(hashed_state)
self.0.state_root_with_updates(hashed_state)
}
fn hashed_state_root_from_nodes_with_updates(
fn state_root_from_nodes_with_updates(
&self,
nodes: reth_trie::updates::TrieUpdates,
hashed_state: reth_trie::HashedPostState,
prefix_sets: reth_trie::prefix_set::TriePrefixSetsMut,
) -> reth_errors::ProviderResult<(B256, reth_trie::updates::TrieUpdates)> {
self.0.hashed_state_root_from_nodes_with_updates(nodes, hashed_state, prefix_sets)
self.0.state_root_from_nodes_with_updates(nodes, hashed_state, prefix_sets)
}
}
impl<'a> reth_storage_api::StorageRootProvider for StateProviderTraitObjWrapper<'a> {
fn hashed_storage_root(
fn storage_root(
&self,
address: Address,
hashed_storage: HashedStorage,
) -> ProviderResult<B256> {
self.0.hashed_storage_root(address, hashed_storage)
self.0.storage_root(address, hashed_storage)
}
}

36
crates/storage/provider/src/providers/bundle_state_provider.rs
View File

@ -8,7 +8,6 @@ use reth_trie::{
prefix_set::TriePrefixSetsMut, updates::TrieUpdates, AccountProof, HashedPostState,
HashedStorage,
};
use revm::db::BundleState;
use std::collections::HashMap;
/// A state provider that resolves to data from either a wrapped [`crate::ExecutionOutcome`]
@ -69,20 +68,14 @@ impl<SP: StateProvider, EDP: ExecutionDataProvider> AccountReader for BundleStat
impl<SP: StateProvider, EDP: ExecutionDataProvider> StateRootProvider
for BundleStateProvider<SP, EDP>
{
fn state_root(&self, bundle_state: &BundleState) -> ProviderResult<B256> {
let mut state = self.block_execution_data_provider.execution_outcome().state().clone();
state.extend(bundle_state.clone());
self.state_provider.state_root(&state)
}
fn hashed_state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
let bundle_state = self.block_execution_data_provider.execution_outcome().state();
let mut state = HashedPostState::from_bundle_state(&bundle_state.state);
state.extend(hashed_state);
self.state_provider.hashed_state_root(state)
self.state_provider.state_root(state)
}
fn hashed_state_root_from_nodes(
fn state_root_from_nodes(
&self,
_nodes: TrieUpdates,
_hashed_state: HashedPostState,
@ -92,25 +85,16 @@ impl<SP: StateProvider, EDP: ExecutionDataProvider> StateRootProvider
}
fn state_root_with_updates(
&self,
bundle_state: &BundleState,
) -> ProviderResult<(B256, TrieUpdates)> {
let mut state = self.block_execution_data_provider.execution_outcome().state().clone();
state.extend(bundle_state.clone());
self.state_provider.state_root_with_updates(&state)
}
fn hashed_state_root_with_updates(
&self,
hashed_state: HashedPostState,
) -> ProviderResult<(B256, TrieUpdates)> {
let bundle_state = self.block_execution_data_provider.execution_outcome().state();
let mut state = HashedPostState::from_bundle_state(&bundle_state.state);
state.extend(hashed_state);
self.state_provider.hashed_state_root_with_updates(state)
self.state_provider.state_root_with_updates(state)
}
fn hashed_state_root_from_nodes_with_updates(
fn state_root_from_nodes_with_updates(
&self,
nodes: TrieUpdates,
hashed_state: HashedPostState,
@ -121,18 +105,14 @@ impl<SP: StateProvider, EDP: ExecutionDataProvider> StateRootProvider
let mut state_prefix_sets = state.construct_prefix_sets();
state.extend(hashed_state);
state_prefix_sets.extend(prefix_sets);
self.state_provider.hashed_state_root_from_nodes_with_updates(
nodes,
state,
state_prefix_sets,
)
self.state_provider.state_root_from_nodes_with_updates(nodes, state, state_prefix_sets)
}
}
impl<SP: StateProvider, EDP: ExecutionDataProvider> StorageRootProvider
for BundleStateProvider<SP, EDP>
{
fn hashed_storage_root(
fn storage_root(
&self,
address: Address,
hashed_storage: HashedStorage,
@ -148,7 +128,7 @@ impl<SP: StateProvider, EDP: ExecutionDataProvider> StorageRootProvider
})
.unwrap_or_else(|| HashedStorage::new(false));
storage.extend(&hashed_storage);
self.state_provider.hashed_storage_root(address, storage)
self.state_provider.storage_root(address, storage)
}
}

10
crates/storage/provider/src/providers/state/historical.rs
View File

@ -285,14 +285,14 @@ impl<'b, TX: DbTx> BlockHashReader for HistoricalStateProviderRef<'b, TX> {
}
impl<'b, TX: DbTx> StateRootProvider for HistoricalStateProviderRef<'b, TX> {
fn hashed_state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
let mut revert_state = self.revert_state()?;
revert_state.extend(hashed_state);
StateRoot::overlay_root(self.tx, revert_state)
.map_err(|err| ProviderError::Database(err.into()))
}
fn hashed_state_root_from_nodes(
fn state_root_from_nodes(
&self,
nodes: TrieUpdates,
hashed_state: HashedPostState,
@ -306,7 +306,7 @@ impl<'b, TX: DbTx> StateRootProvider for HistoricalStateProviderRef<'b, TX> {
.map_err(|err| ProviderError::Database(err.into()))
}
fn hashed_state_root_with_updates(
fn state_root_with_updates(
&self,
hashed_state: HashedPostState,
) -> ProviderResult<(B256, TrieUpdates)> {
@ -316,7 +316,7 @@ impl<'b, TX: DbTx> StateRootProvider for HistoricalStateProviderRef<'b, TX> {
.map_err(|err| ProviderError::Database(err.into()))
}
fn hashed_state_root_from_nodes_with_updates(
fn state_root_from_nodes_with_updates(
&self,
nodes: TrieUpdates,
hashed_state: HashedPostState,
@ -337,7 +337,7 @@ impl<'b, TX: DbTx> StateRootProvider for HistoricalStateProviderRef<'b, TX> {
}
impl<'b, TX: DbTx> StorageRootProvider for HistoricalStateProviderRef<'b, TX> {
fn hashed_storage_root(
fn storage_root(
&self,
address: Address,
hashed_storage: HashedStorage,

10
crates/storage/provider/src/providers/state/latest.rs
View File

@ -81,12 +81,12 @@ impl<'b, TX: DbTx> BlockHashReader for LatestStateProviderRef<'b, TX> {
}
impl<'b, TX: DbTx> StateRootProvider for LatestStateProviderRef<'b, TX> {
fn hashed_state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
StateRoot::overlay_root(self.tx, hashed_state)
.map_err(|err| ProviderError::Database(err.into()))
}
fn hashed_state_root_from_nodes(
fn state_root_from_nodes(
&self,
nodes: TrieUpdates,
hashed_state: HashedPostState,
@ -96,7 +96,7 @@ impl<'b, TX: DbTx> StateRootProvider for LatestStateProviderRef<'b, TX> {
.map_err(|err| ProviderError::Database(err.into()))
}
fn hashed_state_root_with_updates(
fn state_root_with_updates(
&self,
hashed_state: HashedPostState,
) -> ProviderResult<(B256, TrieUpdates)> {
@ -104,7 +104,7 @@ impl<'b, TX: DbTx> StateRootProvider for LatestStateProviderRef<'b, TX> {
.map_err(|err| ProviderError::Database(err.into()))
}
fn hashed_state_root_from_nodes_with_updates(
fn state_root_from_nodes_with_updates(
&self,
nodes: TrieUpdates,
hashed_state: HashedPostState,
@ -116,7 +116,7 @@ impl<'b, TX: DbTx> StateRootProvider for LatestStateProviderRef<'b, TX> {
}
impl<'b, TX: DbTx> StorageRootProvider for LatestStateProviderRef<'b, TX> {
fn hashed_storage_root(
fn storage_root(
&self,
address: Address,
hashed_storage: HashedStorage,

12
crates/storage/provider/src/providers/state/macros.rs
View File

@ -42,15 +42,13 @@ macro_rules! delegate_provider_impls {
fn bytecode_by_hash(&self, code_hash: reth_primitives::B256) -> reth_storage_errors::provider::ProviderResult<Option<reth_primitives::Bytecode>>;
}
StateRootProvider $(where [$($generics)*])? {
fn state_root(&self, state: &revm::db::BundleState) -> reth_storage_errors::provider::ProviderResult<reth_primitives::B256>;
fn hashed_state_root(&self, state: reth_trie::HashedPostState) -> reth_storage_errors::provider::ProviderResult<reth_primitives::B256>;
fn hashed_state_root_from_nodes(&self, nodes: reth_trie::updates::TrieUpdates, state: reth_trie::HashedPostState, prefix_sets: reth_trie::prefix_set::TriePrefixSetsMut) -> reth_storage_errors::provider::ProviderResult<reth_primitives::B256>;
fn state_root_with_updates(&self, state: &revm::db::BundleState) -> reth_storage_errors::provider::ProviderResult<(reth_primitives::B256, reth_trie::updates::TrieUpdates)>;
fn hashed_state_root_with_updates(&self, state: reth_trie::HashedPostState) -> reth_storage_errors::provider::ProviderResult<(reth_primitives::B256, reth_trie::updates::TrieUpdates)>;
fn hashed_state_root_from_nodes_with_updates(&self, nodes: reth_trie::updates::TrieUpdates, state: reth_trie::HashedPostState, prefix_sets: reth_trie::prefix_set::TriePrefixSetsMut) -> reth_storage_errors::provider::ProviderResult<(reth_primitives::B256, reth_trie::updates::TrieUpdates)>;
fn state_root(&self, state: reth_trie::HashedPostState) -> reth_storage_errors::provider::ProviderResult<reth_primitives::B256>;
fn state_root_from_nodes(&self, nodes: reth_trie::updates::TrieUpdates, state: reth_trie::HashedPostState, prefix_sets: reth_trie::prefix_set::TriePrefixSetsMut) -> reth_storage_errors::provider::ProviderResult<reth_primitives::B256>;
fn state_root_with_updates(&self, state: reth_trie::HashedPostState) -> reth_storage_errors::provider::ProviderResult<(reth_primitives::B256, reth_trie::updates::TrieUpdates)>;
fn state_root_from_nodes_with_updates(&self, nodes: reth_trie::updates::TrieUpdates, state: reth_trie::HashedPostState, prefix_sets: reth_trie::prefix_set::TriePrefixSetsMut) -> reth_storage_errors::provider::ProviderResult<(reth_primitives::B256, reth_trie::updates::TrieUpdates)>;
}
StorageRootProvider $(where [$($generics)*])? {
fn hashed_storage_root(&self, address: reth_primitives::Address, storage: reth_trie::HashedStorage) -> reth_storage_errors::provider::ProviderResult<reth_primitives::B256>;
fn storage_root(&self, address: reth_primitives::Address, storage: reth_trie::HashedStorage) -> reth_storage_errors::provider::ProviderResult<reth_primitives::B256>;
}
StateProofProvider $(where [$($generics)*])? {
fn proof(&self, state: reth_trie::HashedPostState, address: reth_primitives::Address, slots: &[reth_primitives::B256]) -> reth_storage_errors::provider::ProviderResult<reth_trie::AccountProof>;

10
crates/storage/provider/src/test_utils/mock.rs
View File

@ -568,11 +568,11 @@ impl StageCheckpointReader for MockEthProvider {
}
impl StateRootProvider for MockEthProvider {
fn hashed_state_root(&self, _state: HashedPostState) -> ProviderResult<B256> {
fn state_root(&self, _state: HashedPostState) -> ProviderResult<B256> {
Ok(self.state_roots.lock().pop().unwrap_or_default())
}
fn hashed_state_root_from_nodes(
fn state_root_from_nodes(
&self,
_nodes: TrieUpdates,
_hashed_state: HashedPostState,
@ -581,7 +581,7 @@ impl StateRootProvider for MockEthProvider {
Ok(self.state_roots.lock().pop().unwrap_or_default())
}
fn hashed_state_root_with_updates(
fn state_root_with_updates(
&self,
_state: HashedPostState,
) -> ProviderResult<(B256, TrieUpdates)> {
@ -589,7 +589,7 @@ impl StateRootProvider for MockEthProvider {
Ok((state_root, Default::default()))
}
fn hashed_state_root_from_nodes_with_updates(
fn state_root_from_nodes_with_updates(
&self,
_nodes: TrieUpdates,
_hashed_state: HashedPostState,
@ -601,7 +601,7 @@ impl StateRootProvider for MockEthProvider {
}
impl StorageRootProvider for MockEthProvider {
fn hashed_storage_root(
fn storage_root(
&self,
_address: Address,
_hashed_storage: HashedStorage,

10
crates/storage/provider/src/test_utils/noop.rs
View File

@ -322,11 +322,11 @@ impl ChangeSetReader for NoopProvider {
}
impl StateRootProvider for NoopProvider {
fn hashed_state_root(&self, _state: HashedPostState) -> ProviderResult<B256> {
fn state_root(&self, _state: HashedPostState) -> ProviderResult<B256> {
Ok(B256::default())
}
fn hashed_state_root_from_nodes(
fn state_root_from_nodes(
&self,
_nodes: TrieUpdates,
_hashed_state: HashedPostState,
@ -335,14 +335,14 @@ impl StateRootProvider for NoopProvider {
Ok(B256::default())
}
fn hashed_state_root_with_updates(
fn state_root_with_updates(
&self,
_state: HashedPostState,
) -> ProviderResult<(B256, TrieUpdates)> {
Ok((B256::default(), TrieUpdates::default()))
}
fn hashed_state_root_from_nodes_with_updates(
fn state_root_from_nodes_with_updates(
&self,
_nodes: TrieUpdates,
_hashed_state: HashedPostState,
@ -353,7 +353,7 @@ impl StateRootProvider for NoopProvider {
}
impl StorageRootProvider for NoopProvider {
fn hashed_storage_root(
fn storage_root(
&self,
_address: Address,
_hashed_storage: HashedStorage,

2
crates/storage/storage-api/Cargo.toml
View File

@ -22,6 +22,4 @@ reth-stages-types.workspace = true
reth-storage-errors.workspace = true
reth-trie.workspace = true
revm.workspace = true
auto_impl.workspace = true

32
crates/storage/storage-api/src/trie.rs
View File

@ -4,7 +4,6 @@ use reth_trie::{
prefix_set::TriePrefixSetsMut, updates::TrieUpdates, AccountProof, HashedPostState,
HashedStorage,
};
use revm::db::BundleState;
use std::collections::HashMap;
/// A type that can compute the state root of a given post state.
@ -17,42 +16,28 @@ pub trait StateRootProvider: Send + Sync {
/// It is recommended to provide a different implementation from
/// `state_root_with_updates` since it affects the memory usage during state root
/// computation.
fn state_root(&self, bundle_state: &BundleState) -> ProviderResult<B256> {
self.hashed_state_root(HashedPostState::from_bundle_state(&bundle_state.state))
}
/// Returns the state root of the `HashedPostState` on top of the current state.
fn hashed_state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256>;
fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256>;
/// Returns the state root of the `HashedPostState` on top of the current state but re-uses the
/// intermediate nodes to speed up the computation. It's up to the caller to construct the
/// prefix sets and inform the provider of the trie paths that have changes.
fn hashed_state_root_from_nodes(
fn state_root_from_nodes(
&self,
nodes: TrieUpdates,
hashed_state: HashedPostState,
prefix_sets: TriePrefixSetsMut,
) -> ProviderResult<B256>;
/// Returns the state root of the BundleState on top of the current state with trie
/// updates to be committed to the database.
fn state_root_with_updates(
&self,
bundle_state: &BundleState,
) -> ProviderResult<(B256, TrieUpdates)> {
self.hashed_state_root_with_updates(HashedPostState::from_bundle_state(&bundle_state.state))
}
/// Returns the state root of the `HashedPostState` on top of the current state with trie
/// updates to be committed to the database.
fn hashed_state_root_with_updates(
fn state_root_with_updates(
&self,
hashed_state: HashedPostState,
) -> ProviderResult<(B256, TrieUpdates)>;
/// Returns state root and trie updates.
/// See [`StateRootProvider::hashed_state_root_from_nodes`] for more info.
fn hashed_state_root_from_nodes_with_updates(
/// See [`StateRootProvider::state_root_from_nodes`] for more info.
fn state_root_from_nodes_with_updates(
&self,
nodes: TrieUpdates,
hashed_state: HashedPostState,
@ -65,11 +50,8 @@ pub trait StateRootProvider: Send + Sync {
pub trait StorageRootProvider: Send + Sync {
/// Returns the storage root of the `HashedStorage` for target address on top of the current
/// state.
fn hashed_storage_root(
&self,
address: Address,
hashed_storage: HashedStorage,
) -> ProviderResult<B256>;
fn storage_root(&self, address: Address, hashed_storage: HashedStorage)
-> ProviderResult<B256>;
}
/// A type that can generate state proof on top of a given post state.