github/reth
1
1
Fork 0
mirror of https://github.com/paradigmxyz/reth.git synced 2026-01-09 07:17:56 -05:00
Code Issues Packages Projects Releases Wiki Activity

refactor: remove StateCommitment trait (#17812)

Browse Source
This commit is contained in:
robinsdan
2025-08-18 21:53:53 +08:00
committed by GitHub
parent e617dd30c9
commit 29e4b20588
36 changed files with 111 additions and 345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Cargo.lock generated
View File

@@ -3356,7 +3356,6 @@ dependencies = [
"reth-ethereum-payload-builder",
"reth-payload-builder",
"reth-tracing",
"reth-trie-db",
"serde",
"thiserror 2.0.15",
"tokio",
@@ -8518,7 +8517,6 @@ dependencies = [
"reth-provider",
"reth-tasks",
"reth-transaction-pool",
"reth-trie-db",
"tempfile",
"thiserror 2.0.15",
"tokio",
@@ -9008,7 +9006,6 @@ dependencies = [
"reth-tasks",
"reth-tracing",
"reth-transaction-pool",
"reth-trie-db",
"revm",
"serde_json",
"tokio",
@@ -9091,7 +9088,6 @@ dependencies = [
"reth-engine-primitives",
"reth-payload-primitives",
"reth-primitives-traits",
"reth-trie-db",
]
[[package]]
@@ -9333,7 +9329,6 @@ dependencies = [
"reth-tracing",
"reth-transaction-pool",
"reth-trie-common",
"reth-trie-db",
"revm",
"serde",
"serde_json",
@@ -10378,7 +10373,6 @@ dependencies = [
"reth-stages-types",
"reth-storage-errors",
"reth-trie-common",
"reth-trie-db",
"revm-database",
]

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

@@ -31,13 +31,13 @@ use reth_payload_primitives::{
use reth_primitives_traits::{Block, NodePrimitives, RecoveredBlock, SealedBlock, SealedHeader};
use reth_provider::{
providers::ConsistentDbView, BlockNumReader, BlockReader, DBProvider, DatabaseProviderFactory,
HashedPostStateProvider, ProviderError, StateCommitmentProvider, StateProviderBox,
StateProviderFactory, StateReader, StateRootProvider, TransactionVariant,
HashedPostStateProvider, ProviderError, StateProviderBox, StateProviderFactory, StateReader,
StateRootProvider, TransactionVariant,
};
use reth_revm::database::StateProviderDatabase;
use reth_stages_api::ControlFlow;
use reth_trie::{HashedPostState, TrieInput};
use reth_trie_db::{DatabaseHashedPostState, StateCommitment};
use reth_trie_db::DatabaseHashedPostState;
use state::TreeState;
use std::{
fmt::Debug,
@@ -76,6 +76,7 @@ pub use payload_processor::*;
pub use payload_validator::{BasicEngineValidator, EngineValidator};
pub use persistence_state::PersistenceState;
pub use reth_engine_primitives::TreeConfig;
use reth_trie::KeccakKeyHasher;
pub mod state;
@@ -115,7 +116,7 @@ impl<N: NodePrimitives, P> StateProviderBuilder<N, P> {
impl<N: NodePrimitives, P> StateProviderBuilder<N, P>
where
P: BlockReader + StateProviderFactory + StateReader + StateCommitmentProvider + Clone,
P: BlockReader + StateProviderFactory + StateReader + Clone,
{
/// Creates a new state provider from this builder.
pub fn build(&self) -> ProviderResult<StateProviderBox> {
@@ -292,7 +293,6 @@ where
+ BlockReader<Block = N::Block, Header = N::BlockHeader>
+ StateProviderFactory
+ StateReader<Receipt = N::Receipt>
+ StateCommitmentProvider
+ HashedPostStateProvider
+ Clone
+ 'static,
@@ -2243,9 +2243,10 @@ where
debug!(target: "engine::tree", block_number, best_block_number, "Empty revert state");
HashedPostState::default()
} else {
let revert_state = HashedPostState::from_reverts::<
<P::StateCommitment as StateCommitment>::KeyHasher,
>(provider.tx_ref(), block_number + 1)
let revert_state = HashedPostState::from_reverts::<KeccakKeyHasher>(
provider.tx_ref(),
block_number + 1,
)
.map_err(ProviderError::from)?;
debug!(
target: "engine::tree",
@@ -2547,7 +2548,7 @@ where
hash: B256,
) -> ProviderResult<Option<StateProviderBuilder<N, P>>>
where
P: BlockReader + StateProviderFactory + StateReader + StateCommitmentProvider + Clone,
P: BlockReader + StateProviderFactory + StateReader + Clone,
{
if let Some((historical, blocks)) = self.state.tree_state.blocks_by_hash(hash) {
debug!(target: "engine::tree", %hash, %historical, "found canonical state for block in memory, creating provider builder");

19
crates/engine/tree/src/tree/payload_processor/mod.rs
View File

@@ -22,8 +22,8 @@ use reth_evm::{
};
use reth_primitives_traits::NodePrimitives;
use reth_provider::{
providers::ConsistentDbView, BlockReader, DatabaseProviderFactory, StateCommitmentProvider,
StateProviderFactory, StateReader,
providers::ConsistentDbView, BlockReader, DatabaseProviderFactory, StateProviderFactory,
StateReader,
};
use reth_revm::{db::BundleState, state::EvmState};
use reth_trie::TrieInput;
@@ -163,7 +163,6 @@ where
+ BlockReader
+ StateProviderFactory
+ StateReader
+ StateCommitmentProvider
+ Clone
+ 'static,
{
@@ -247,12 +246,7 @@ where
provider_builder: StateProviderBuilder<N, P>,
) -> PayloadHandle<WithTxEnv<TxEnvFor<Evm>, I::Tx>, I::Error>
where
P: BlockReader
+ StateProviderFactory
+ StateReader
+ StateCommitmentProvider
+ Clone
+ 'static,
P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
{
let (prewarm_rx, execution_rx) = self.spawn_tx_iterator(transactions);
let prewarm_handle = self.spawn_caching_with(env, prewarm_rx, provider_builder, None);
@@ -298,12 +292,7 @@ where
to_multi_proof: Option<Sender<MultiProofMessage>>,
) -> CacheTaskHandle
where
P: BlockReader
+ StateProviderFactory
+ StateReader
+ StateCommitmentProvider
+ Clone
+ 'static,
P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
{
if self.disable_transaction_prewarming {
// if no transactions should be executed we clear them but still spawn the task for

21
crates/engine/tree/src/tree/payload_processor/multiproof.rs
View File

@@ -11,10 +11,7 @@ use derive_more::derive::Deref;
use metrics::Histogram;
use reth_errors::ProviderError;
use reth_metrics::Metrics;
use reth_provider::{
providers::ConsistentDbView, BlockReader, DatabaseProviderFactory, FactoryTx,
StateCommitmentProvider,
};
use reth_provider::{providers::ConsistentDbView, BlockReader, DatabaseProviderFactory, FactoryTx};
use reth_revm::state::EvmState;
use reth_trie::{
prefix_set::TriePrefixSetsMut, updates::TrieUpdatesSorted, DecodedMultiProof, HashedPostState,
@@ -359,8 +356,7 @@ pub struct MultiproofManager<Factory: DatabaseProviderFactory> {
impl<Factory> MultiproofManager<Factory>
where
Factory:
DatabaseProviderFactory<Provider: BlockReader> + StateCommitmentProvider + Clone + 'static,
Factory: DatabaseProviderFactory<Provider: BlockReader> + Clone + 'static,
{
/// Creates a new [`MultiproofManager`].
fn new(
@@ -642,8 +638,7 @@ pub(super) struct MultiProofTask<Factory: DatabaseProviderFactory> {
impl<Factory> MultiProofTask<Factory>
where
Factory:
DatabaseProviderFactory<Provider: BlockReader> + StateCommitmentProvider + Clone + 'static,
Factory: DatabaseProviderFactory<Provider: BlockReader> + Clone + 'static,
{
/// Creates a new multi proof task with the unified message channel
pub(super) fn new(
@@ -1131,10 +1126,7 @@ mod tests {
fn create_state_root_config<F>(factory: F, input: TrieInput) -> MultiProofConfig<F>
where
F: DatabaseProviderFactory<Provider: BlockReader>
+ StateCommitmentProvider
+ Clone
+ 'static,
F: DatabaseProviderFactory<Provider: BlockReader> + Clone + 'static,
{
let consistent_view = ConsistentDbView::new(factory, None);
let nodes_sorted = Arc::new(input.nodes.clone().into_sorted());
@@ -1146,10 +1138,7 @@ mod tests {
fn create_test_state_root_task<F>(factory: F) -> MultiProofTask<F>
where
F: DatabaseProviderFactory<Provider: BlockReader>
+ StateCommitmentProvider
+ Clone
+ 'static,
F: DatabaseProviderFactory<Provider: BlockReader> + Clone + 'static,
{
let executor = WorkloadExecutor::default();
let config = create_state_root_config(factory, TrieInput::default());

6
crates/engine/tree/src/tree/payload_processor/prewarm.rs
View File

@@ -14,7 +14,7 @@ use metrics::{Gauge, Histogram};
use reth_evm::{execute::ExecutableTxFor, ConfigureEvm, Evm, EvmFor, SpecFor};
use reth_metrics::Metrics;
use reth_primitives_traits::{NodePrimitives, SignedTransaction};
use reth_provider::{BlockReader, StateCommitmentProvider, StateProviderFactory, StateReader};
use reth_provider::{BlockReader, StateProviderFactory, StateReader};
use reth_revm::{database::StateProviderDatabase, db::BundleState, state::EvmState};
use reth_trie::MultiProofTargets;
use std::{
@@ -53,7 +53,7 @@ where
impl<N, P, Evm> PrewarmCacheTask<N, P, Evm>
where
N: NodePrimitives,
P: BlockReader + StateProviderFactory + StateReader + StateCommitmentProvider + Clone + 'static,
P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
Evm: ConfigureEvm<Primitives = N> + 'static,
{
/// Initializes the task with the given transactions pending execution
@@ -226,7 +226,7 @@ where
impl<N, P, Evm> PrewarmContext<N, P, Evm>
where
N: NodePrimitives,
P: BlockReader + StateProviderFactory + StateReader + StateCommitmentProvider + Clone + 'static,
P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
Evm: ConfigureEvm<Primitives = N> + 'static,
{
/// Splits this context into an evm, an evm config, metrics, and the atomic bool for terminating

17
crates/engine/tree/src/tree/payload_validator.rs
View File

@@ -36,12 +36,12 @@ use reth_primitives_traits::{
};
use reth_provider::{
BlockExecutionOutput, BlockNumReader, BlockReader, DBProvider, DatabaseProviderFactory,
ExecutionOutcome, HashedPostStateProvider, ProviderError, StateCommitmentProvider,
StateProvider, StateProviderFactory, StateReader, StateRootProvider,
ExecutionOutcome, HashedPostStateProvider, ProviderError, StateProvider, StateProviderFactory,
StateReader, StateRootProvider,
};
use reth_revm::db::State;
use reth_trie::{updates::TrieUpdates, HashedPostState, TrieInput};
use reth_trie_db::{DatabaseHashedPostState, StateCommitment};
use reth_trie::{updates::TrieUpdates, HashedPostState, KeccakKeyHasher, TrieInput};
use reth_trie_db::DatabaseHashedPostState;
use reth_trie_parallel::root::{ParallelStateRoot, ParallelStateRootError};
use std::{collections::HashMap, sync::Arc, time::Instant};
use tracing::{debug, error, info, trace, warn};
@@ -178,7 +178,6 @@ where
+ BlockReader<Header = N::BlockHeader>
+ StateProviderFactory
+ StateReader
+ StateCommitmentProvider
+ HashedPostStateProvider
+ Clone
+ 'static,
@@ -874,9 +873,10 @@ where
debug!(target: "engine::tree", block_number, best_block_number, "Empty revert state");
HashedPostState::default()
} else {
let revert_state = HashedPostState::from_reverts::<
<P::StateCommitment as StateCommitment>::KeyHasher,
>(provider.tx_ref(), block_number + 1)
let revert_state = HashedPostState::from_reverts::<KeccakKeyHasher>(
provider.tx_ref(),
block_number + 1,
)
.map_err(ProviderError::from)?;
debug!(
target: "engine::tree",
@@ -960,7 +960,6 @@ where
+ BlockReader<Header = N::BlockHeader>
+ StateProviderFactory
+ StateReader
+ StateCommitmentProvider
+ HashedPostStateProvider
+ Clone
+ 'static,

2
crates/ethereum/node/Cargo.toml
View File

@@ -33,7 +33,6 @@ reth-rpc-server-types.workspace = true
reth-node-api.workspace = true
reth-chainspec.workspace = true
reth-revm = { workspace = true, features = ["std"] }
reth-trie-db.workspace = true
reth-rpc-eth-types.workspace = true
reth-engine-local.workspace = true
reth-engine-primitives.workspace = true
@@ -93,7 +92,6 @@ test-utils = [
"reth-db/test-utils",
"reth-provider/test-utils",
"reth-transaction-pool/test-utils",
"reth-trie-db/test-utils",
"reth-evm/test-utils",
"reth-primitives-traits/test-utils",
"reth-evm-ethereum/test-utils",

2
crates/ethereum/node/src/node.rs
View File

@@ -53,7 +53,6 @@ use reth_transaction_pool::{
blobstore::DiskFileBlobStore, EthTransactionPool, PoolPooledTx, PoolTransaction,
TransactionPool, TransactionValidationTaskExecutor,
};
use reth_trie_db::MerklePatriciaTrie;
use revm::context::TxEnv;
use std::{default::Default, marker::PhantomData, sync::Arc, time::SystemTime};
@@ -133,7 +132,6 @@ impl EthereumNode {
impl NodeTypes for EthereumNode {
type Primitives = EthPrimitives;
type ChainSpec = ChainSpec;
type StateCommitment = MerklePatriciaTrie;
type Storage = EthStorage;
type Payload = EthEngineTypes;
}

1
crates/exex/test-utils/Cargo.toml
View File

@@ -31,7 +31,6 @@ reth-ethereum-primitives.workspace = true
reth-provider = { workspace = true, features = ["test-utils"] }
reth-tasks.workspace = true
reth-transaction-pool = { workspace = true, features = ["test-utils"] }
reth-trie-db.workspace = true
## alloy
alloy-eips.workspace = true

1
crates/exex/test-utils/src/lib.rs
View File

@@ -116,7 +116,6 @@ pub struct TestNode;
impl NodeTypes for TestNode {
type Primitives = EthPrimitives;
type ChainSpec = ChainSpec;
type StateCommitment = reth_trie_db::MerklePatriciaTrie;
type Storage = EthStorage;
type Payload = EthEngineTypes;
}

2
crates/node/builder/src/node.rs
View File

@@ -73,8 +73,6 @@ where
type ChainSpec = <N::Types as NodeTypes>::ChainSpec;
type StateCommitment = <N::Types as NodeTypes>::StateCommitment;
type Storage = <N::Types as NodeTypes>::Storage;
type Payload = <N::Types as NodeTypes>::Payload;

1
crates/node/types/Cargo.toml
View File

@@ -16,7 +16,6 @@ reth-chainspec.workspace = true
reth-db-api.workspace = true
reth-engine-primitives.workspace = true
reth-primitives-traits.workspace = true
reth-trie-db.workspace = true
reth-payload-primitives.workspace = true
[features]

56
crates/node/types/src/lib.rs
View File

@@ -18,7 +18,6 @@ use reth_chainspec::EthChainSpec;
use reth_db_api::{database_metrics::DatabaseMetrics, Database};
use reth_engine_primitives::EngineTypes;
use reth_payload_primitives::{BuiltPayload, PayloadTypes};
use reth_trie_db::StateCommitment;
/// The type that configures the essential types of an Ethereum-like node.
///
@@ -30,8 +29,6 @@ pub trait NodeTypes: Clone + Debug + Send + Sync + Unpin + 'static {
type Primitives: NodePrimitives;
/// The type used for configuration of the EVM.
type ChainSpec: EthChainSpec<Header = <Self::Primitives as NodePrimitives>::BlockHeader>;
/// The type used to perform state commitment operations.
type StateCommitment: StateCommitment;
/// The type responsible for writing chain primitives to storage.
type Storage: Default + Send + Sync + Unpin + Debug + 'static;
/// The node's engine types, defining the interaction with the consensus engine.
@@ -68,7 +65,6 @@ where
{
type Primitives = Types::Primitives;
type ChainSpec = Types::ChainSpec;
type StateCommitment = Types::StateCommitment;
type Storage = Types::Storage;
type Payload = Types::Payload;
}
@@ -83,119 +79,104 @@ where
/// A [`NodeTypes`] type builder.
#[derive(Clone, Debug, Default)]
pub struct AnyNodeTypes<P = (), C = (), SC = (), S = (), PL = ()>(
pub struct AnyNodeTypes<P = (), C = (), S = (), PL = ()>(
PhantomData<P>,
PhantomData<C>,
PhantomData<SC>,
PhantomData<S>,
PhantomData<PL>,
);
impl<P, C, SC, S, PL> AnyNodeTypes<P, C, SC, S, PL> {
impl<P, C, S, PL> AnyNodeTypes<P, C, S, PL> {
/// Creates a new instance of [`AnyNodeTypes`].
pub const fn new() -> Self {
Self(PhantomData, PhantomData, PhantomData, PhantomData, PhantomData)
Self(PhantomData, PhantomData, PhantomData, PhantomData)
}
/// Sets the `Primitives` associated type.
pub const fn primitives<T>(self) -> AnyNodeTypes<T, C, SC, S, PL> {
pub const fn primitives<T>(self) -> AnyNodeTypes<T, C, S, PL> {
AnyNodeTypes::new()
}
/// Sets the `ChainSpec` associated type.
pub const fn chain_spec<T>(self) -> AnyNodeTypes<P, T, SC, S, PL> {
AnyNodeTypes::new()
}
/// Sets the `StateCommitment` associated type.
pub const fn state_commitment<T>(self) -> AnyNodeTypes<P, C, T, S, PL> {
pub const fn chain_spec<T>(self) -> AnyNodeTypes<P, T, S, PL> {
AnyNodeTypes::new()
}
/// Sets the `Storage` associated type.
pub const fn storage<T>(self) -> AnyNodeTypes<P, C, SC, T, PL> {
pub const fn storage<T>(self) -> AnyNodeTypes<P, C, T, PL> {
AnyNodeTypes::new()
}
/// Sets the `Payload` associated type.
pub const fn payload<T>(self) -> AnyNodeTypes<P, C, SC, S, T> {
pub const fn payload<T>(self) -> AnyNodeTypes<P, C, S, T> {
AnyNodeTypes::new()
}
}
impl<P, C, SC, S, PL> NodeTypes for AnyNodeTypes<P, C, SC, S, PL>
impl<P, C, S, PL> NodeTypes for AnyNodeTypes<P, C, S, PL>
where
P: NodePrimitives + Send + Sync + Unpin + 'static,
C: EthChainSpec<Header = P::BlockHeader> + Clone + 'static,
SC: StateCommitment,
S: Default + Clone + Send + Sync + Unpin + Debug + 'static,
PL: PayloadTypes<BuiltPayload: BuiltPayload<Primitives = P>> + Send + Sync + Unpin + 'static,
{
type Primitives = P;
type ChainSpec = C;
type StateCommitment = SC;
type Storage = S;
type Payload = PL;
}
/// A [`NodeTypes`] type builder.
#[derive(Clone, Debug, Default)]
pub struct AnyNodeTypesWithEngine<P = (), E = (), C = (), SC = (), S = (), PL = ()> {
pub struct AnyNodeTypesWithEngine<P = (), E = (), C = (), S = (), PL = ()> {
/// Embedding the basic node types.
_base: AnyNodeTypes<P, C, SC, S, PL>,
_base: AnyNodeTypes<P, C, S, PL>,
/// Phantom data for the engine.
_engine: PhantomData<E>,
}
impl<P, E, C, SC, S, PL> AnyNodeTypesWithEngine<P, E, C, SC, S, PL> {
impl<P, E, C, S, PL> AnyNodeTypesWithEngine<P, E, C, S, PL> {
/// Creates a new instance of [`AnyNodeTypesWithEngine`].
pub const fn new() -> Self {
Self { _base: AnyNodeTypes::new(), _engine: PhantomData }
}
/// Sets the `Primitives` associated type.
pub const fn primitives<T>(self) -> AnyNodeTypesWithEngine<T, E, C, SC, S, PL> {
pub const fn primitives<T>(self) -> AnyNodeTypesWithEngine<T, E, C, S, PL> {
AnyNodeTypesWithEngine::new()
}
/// Sets the `Engine` associated type.
pub const fn engine<T>(self) -> AnyNodeTypesWithEngine<P, T, C, SC, S, PL> {
pub const fn engine<T>(self) -> AnyNodeTypesWithEngine<P, T, C, S, PL> {
AnyNodeTypesWithEngine::new()
}
/// Sets the `ChainSpec` associated type.
pub const fn chain_spec<T>(self) -> AnyNodeTypesWithEngine<P, E, T, SC, S, PL> {
AnyNodeTypesWithEngine::new()
}
/// Sets the `StateCommitment` associated type.
pub const fn state_commitment<T>(self) -> AnyNodeTypesWithEngine<P, E, C, T, S, PL> {
pub const fn chain_spec<T>(self) -> AnyNodeTypesWithEngine<P, E, T, S, PL> {
AnyNodeTypesWithEngine::new()
}
/// Sets the `Storage` associated type.
pub const fn storage<T>(self) -> AnyNodeTypesWithEngine<P, E, C, SC, T, PL> {
pub const fn storage<T>(self) -> AnyNodeTypesWithEngine<P, E, C, T, PL> {
AnyNodeTypesWithEngine::new()
}
/// Sets the `Payload` associated type.
pub const fn payload<T>(self) -> AnyNodeTypesWithEngine<P, E, C, SC, S, T> {
pub const fn payload<T>(self) -> AnyNodeTypesWithEngine<P, E, C, S, T> {
AnyNodeTypesWithEngine::new()
}
}
impl<P, E, C, SC, S, PL> NodeTypes for AnyNodeTypesWithEngine<P, E, C, SC, S, PL>
impl<P, E, C, S, PL> NodeTypes for AnyNodeTypesWithEngine<P, E, C, S, PL>
where
P: NodePrimitives + Send + Sync + Unpin + 'static,
E: EngineTypes + Send + Sync + Unpin,
C: EthChainSpec<Header = P::BlockHeader> + Clone + 'static,
SC: StateCommitment,
S: Default + Clone + Send + Sync + Unpin + Debug + 'static,
PL: PayloadTypes<BuiltPayload: BuiltPayload<Primitives = P>> + Send + Sync + Unpin + 'static,
{
type Primitives = P;
type ChainSpec = C;
type StateCommitment = SC;
type Storage = S;
type Payload = PL;
}
@@ -218,8 +199,5 @@ pub type ReceiptTy<N> = <PrimitivesTy<N> as NodePrimitives>::Receipt;
/// Helper type for getting the `Primitives` associated type from a [`NodeTypes`].
pub type PrimitivesTy<N> = <N as NodeTypes>::Primitives;
/// Helper type for getting the `Primitives` associated type from a [`NodeTypes`].
pub type KeyHasherTy<N> = <<N as NodeTypes>::StateCommitment as StateCommitment>::KeyHasher;
/// Helper adapter type for accessing [`PayloadTypes::PayloadAttributes`] on [`NodeTypes`].
pub type PayloadAttrTy<N> = <<N as NodeTypes>::Payload as PayloadTypes>::PayloadAttributes;

2
crates/optimism/node/Cargo.toml
View File

@@ -24,7 +24,6 @@ reth-provider.workspace = true
reth-transaction-pool.workspace = true
reth-network.workspace = true
reth-evm.workspace = true
reth-trie-db.workspace = true
reth-rpc-server-types.workspace = true
reth-tasks = { workspace = true, optional = true }
reth-trie-common.workspace = true
@@ -112,7 +111,6 @@ test-utils = [
"reth-db/test-utils",
"reth-provider/test-utils",
"reth-transaction-pool/test-utils",
"reth-trie-db/test-utils",
"reth-optimism-node/test-utils",
"reth-optimism-primitives/arbitrary",
"reth-primitives-traits/test-utils",

9
crates/optimism/node/src/node.rs
View File

@@ -16,8 +16,8 @@ use reth_network::{
PeersInfo,
};
use reth_node_api::{
AddOnsContext, BuildNextEnv, EngineTypes, FullNodeComponents, HeaderTy, KeyHasherTy,
NodeAddOns, NodePrimitives, PayloadAttributesBuilder, PayloadTypes, PrimitivesTy, TxTy,
AddOnsContext, BuildNextEnv, EngineTypes, FullNodeComponents, HeaderTy, NodeAddOns,
NodePrimitives, PayloadAttributesBuilder, PayloadTypes, PrimitivesTy, TxTy,
};
use reth_node_builder::{
components::{
@@ -63,7 +63,7 @@ use reth_transaction_pool::{
blobstore::DiskFileBlobStore, EthPoolTransaction, PoolPooledTx, PoolTransaction,
TransactionPool, TransactionValidationTaskExecutor,
};
use reth_trie_db::MerklePatriciaTrie;
use reth_trie_common::KeccakKeyHasher;
use serde::de::DeserializeOwned;
use std::{marker::PhantomData, sync::Arc};
@@ -262,7 +262,6 @@ where
impl NodeTypes for OpNode {
type Primitives = OpPrimitives;
type ChainSpec = OpChainSpec;
type StateCommitment = MerklePatriciaTrie;
type Storage = OpStorage;
type Payload = OpEngineTypes;
}
@@ -1195,7 +1194,7 @@ where
>;
async fn build(self, ctx: &AddOnsContext<'_, Node>) -> eyre::Result<Self::Validator> {
Ok(OpEngineValidator::new::<KeyHasherTy<Node::Types>>(
Ok(OpEngineValidator::new::<KeccakKeyHasher>(
ctx.config.chain.clone(),
ctx.node.provider().clone(),
))

7
crates/stages/stages/src/stages/execution.rs
View File

@@ -12,8 +12,8 @@ use reth_primitives_traits::{format_gas_throughput, Block, BlockBody, NodePrimit
use reth_provider::{
providers::{StaticFileProvider, StaticFileWriter},
BlockHashReader, BlockReader, DBProvider, ExecutionOutcome, HeaderProvider,
LatestStateProviderRef, OriginalValuesKnown, ProviderError, StateCommitmentProvider,
StateWriter, StaticFileProviderFactory, StatsReader, StorageLocation, TransactionVariant,
LatestStateProviderRef, OriginalValuesKnown, ProviderError, StateWriter,
StaticFileProviderFactory, StatsReader, StorageLocation, TransactionVariant,
};
use reth_revm::database::StateProviderDatabase;
use reth_stages_api::{
@@ -260,8 +260,7 @@ where
Primitives: NodePrimitives<BlockHeader: reth_db_api::table::Value>,
> + StatsReader
+ BlockHashReader
+ StateWriter<Receipt = <E::Primitives as NodePrimitives>::Receipt>
+ StateCommitmentProvider,
+ StateWriter<Receipt = <E::Primitives as NodePrimitives>::Receipt>,
{
/// Return the id of the stage
fn id(&self) -> StageId {

14
crates/storage/provider/src/providers/blockchain_provider.rs
View File

@@ -36,12 +36,10 @@ use reth_primitives_traits::{
use reth_prune_types::{PruneCheckpoint, PruneSegment};
use reth_stages_types::{StageCheckpoint, StageId};
use reth_storage_api::{
BlockBodyIndicesProvider, DBProvider, NodePrimitivesProvider, StateCommitmentProvider,
StorageChangeSetReader,
BlockBodyIndicesProvider, DBProvider, NodePrimitivesProvider, StorageChangeSetReader,
};
use reth_storage_errors::provider::ProviderResult;
use reth_trie::HashedPostState;
use reth_trie_db::StateCommitment;
use reth_trie::{HashedPostState, KeccakKeyHasher};
use revm_database::BundleState;
use std::{
ops::{Add, RangeBounds, RangeInclusive, Sub},
@@ -175,10 +173,6 @@ impl<N: ProviderNodeTypes> DatabaseProviderFactory for BlockchainProvider<N> {
}
}
impl<N: ProviderNodeTypes> StateCommitmentProvider for BlockchainProvider<N> {
type StateCommitment = N::StateCommitment;
}
impl<N: ProviderNodeTypes> StaticFileProviderFactory for BlockchainProvider<N> {
fn static_file_provider(&self) -> StaticFileProvider<Self::Primitives> {
self.database.static_file_provider()
@@ -611,9 +605,7 @@ impl<N: ProviderNodeTypes> StateProviderFactory for BlockchainProvider<N> {
impl<N: NodeTypesWithDB> HashedPostStateProvider for BlockchainProvider<N> {
fn hashed_post_state(&self, bundle_state: &BundleState) -> HashedPostState {
HashedPostState::from_bundle_state::<<N::StateCommitment as StateCommitment>::KeyHasher>(
bundle_state.state(),
)
HashedPostState::from_bundle_state::<KeccakKeyHasher>(bundle_state.state())
}
}

4
crates/storage/provider/src/providers/consistent_view.rs
View File

@@ -1,6 +1,5 @@
use crate::{BlockNumReader, DatabaseProviderFactory, HeaderProvider};
use alloy_primitives::B256;
use reth_storage_api::StateCommitmentProvider;
pub use reth_storage_errors::provider::ConsistentViewError;
use reth_storage_errors::provider::ProviderResult;
@@ -27,8 +26,7 @@ pub struct ConsistentDbView<Factory> {
impl<Factory> ConsistentDbView<Factory>
where
Factory: DatabaseProviderFactory<Provider: BlockNumReader + HeaderProvider>
+ StateCommitmentProvider,
Factory: DatabaseProviderFactory<Provider: BlockNumReader + HeaderProvider>,
{
/// Creates new consistent database view.
pub const fn new(factory: Factory, tip: Option<(B256, u64)>) -> Self {

13
crates/storage/provider/src/providers/database/mod.rs
View File

@@ -23,12 +23,10 @@ use reth_prune_types::{PruneCheckpoint, PruneModes, PruneSegment};
use reth_stages_types::{StageCheckpoint, StageId};
use reth_static_file_types::StaticFileSegment;
use reth_storage_api::{
BlockBodyIndicesProvider, NodePrimitivesProvider, StateCommitmentProvider,
TryIntoHistoricalStateProvider,
BlockBodyIndicesProvider, NodePrimitivesProvider, TryIntoHistoricalStateProvider,
};
use reth_storage_errors::provider::ProviderResult;
use reth_trie::HashedPostState;
use reth_trie_db::StateCommitment;
use revm_database::BundleState;
use std::{
ops::{RangeBounds, RangeInclusive},
@@ -42,6 +40,7 @@ mod provider;
pub use provider::{DatabaseProvider, DatabaseProviderRO, DatabaseProviderRW};
use super::ProviderNodeTypes;
use reth_trie::KeccakKeyHasher;
mod builder;
pub use builder::{ProviderFactoryBuilder, ReadOnlyConfig};
@@ -215,10 +214,6 @@ impl<N: ProviderNodeTypes> DatabaseProviderFactory for ProviderFactory<N> {
}
}
impl<N: NodeTypesWithDB> StateCommitmentProvider for ProviderFactory<N> {
type StateCommitment = N::StateCommitment;
}
impl<N: NodeTypesWithDB> StaticFileProviderFactory for ProviderFactory<N> {
/// Returns static file provider
fn static_file_provider(&self) -> StaticFileProvider<Self::Primitives> {
@@ -587,9 +582,7 @@ impl<N: ProviderNodeTypes> PruneCheckpointReader for ProviderFactory<N> {
impl<N: ProviderNodeTypes> HashedPostStateProvider for ProviderFactory<N> {
fn hashed_post_state(&self, bundle_state: &BundleState) -> HashedPostState {
HashedPostState::from_bundle_state::<<N::StateCommitment as StateCommitment>::KeyHasher>(
bundle_state.state(),
)
HashedPostState::from_bundle_state::<KeccakKeyHasher>(bundle_state.state())
}
}

10
crates/storage/provider/src/providers/database/provider.rs
View File

@@ -14,9 +14,9 @@ use crate::{
DBProvider, HashingWriter, HeaderProvider, HeaderSyncGapProvider, HistoricalStateProvider,
HistoricalStateProviderRef, HistoryWriter, LatestStateProvider, LatestStateProviderRef,
OriginalValuesKnown, ProviderError, PruneCheckpointReader, PruneCheckpointWriter, RevertsInit,
StageCheckpointReader, StateCommitmentProvider, StateProviderBox, StateWriter,
StaticFileProviderFactory, StatsReader, StorageLocation, StorageReader, StorageTrieWriter,
TransactionVariant, TransactionsProvider, TransactionsProviderExt, TrieWriter,
StageCheckpointReader, StateProviderBox, StateWriter, StaticFileProviderFactory, StatsReader,
StorageLocation, StorageReader, StorageTrieWriter, TransactionVariant, TransactionsProvider,
TransactionsProviderExt, TrieWriter,
};
use alloy_consensus::{
transaction::{SignerRecoverable, TransactionMeta},
@@ -410,10 +410,6 @@ impl<TX: DbTx + 'static, N: NodeTypes> TryIntoHistoricalStateProvider for Databa
}
}
impl<TX: DbTx + 'static, N: NodeTypes> StateCommitmentProvider for DatabaseProvider<TX, N> {
type StateCommitment = N::StateCommitment;
}
impl<
Tx: DbTx + DbTxMut + 'static,
N: NodeTypesForProvider<Primitives: NodePrimitives<BlockHeader = Header>>,

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

@@ -14,21 +14,21 @@ use reth_db_api::{
};
use reth_primitives_traits::{Account, Bytecode};
use reth_storage_api::{
BlockNumReader, BytecodeReader, DBProvider, StateCommitmentProvider, StateProofProvider,
StorageRootProvider,
BlockNumReader, BytecodeReader, DBProvider, StateProofProvider, StorageRootProvider,
};
use reth_storage_errors::provider::ProviderResult;
use reth_trie::{
proof::{Proof, StorageProof},
updates::TrieUpdates,
witness::TrieWitness,
AccountProof, HashedPostState, HashedStorage, MultiProof, MultiProofTargets, StateRoot,
StorageMultiProof, StorageRoot, TrieInput,
AccountProof, HashedPostState, HashedStorage, KeccakKeyHasher, MultiProof, MultiProofTargets,
StateRoot, StorageMultiProof, StorageRoot, TrieInput,
};
use reth_trie_db::{
DatabaseHashedPostState, DatabaseHashedStorage, DatabaseProof, DatabaseStateRoot,
DatabaseStorageProof, DatabaseStorageRoot, DatabaseTrieWitness, StateCommitment,
DatabaseStorageProof, DatabaseStorageRoot, DatabaseTrieWitness,
};
use std::fmt::Debug;
/// State provider for a given block number which takes a tx reference.
@@ -60,9 +60,7 @@ pub enum HistoryInfo {
MaybeInPlainState,
}
impl<'b, Provider: DBProvider + BlockNumReader + StateCommitmentProvider>
HistoricalStateProviderRef<'b, Provider>
{
impl<'b, Provider: DBProvider + BlockNumReader> HistoricalStateProviderRef<'b, Provider> {
/// Create new `StateProvider` for historical block number
pub fn new(provider: &'b Provider, block_number: BlockNumber) -> Self {
Self { provider, block_number, lowest_available_blocks: Default::default() }
@@ -135,9 +133,7 @@ impl<'b, Provider: DBProvider + BlockNumReader + StateCommitmentProvider>
);
}
Ok(HashedPostState::from_reverts::<
<Provider::StateCommitment as StateCommitment>::KeyHasher,
>(self.tx(), self.block_number)?)
Ok(HashedPostState::from_reverts::<KeccakKeyHasher>(self.tx(), self.block_number)?)
}
/// Retrieve revert hashed storage for this history provider and target address.
@@ -245,7 +241,7 @@ impl<Provider: DBProvider + BlockNumReader> HistoricalStateProviderRef<'_, Provi
}
}
impl<Provider: DBProvider + BlockNumReader + StateCommitmentProvider> AccountReader
impl<Provider: DBProvider + BlockNumReader> AccountReader
for HistoricalStateProviderRef<'_, Provider>
{
/// Get basic account information.
@@ -286,7 +282,7 @@ impl<Provider: DBProvider + BlockNumReader + BlockHashReader> BlockHashReader
}
}
impl<Provider: DBProvider + BlockNumReader + StateCommitmentProvider> StateRootProvider
impl<Provider: DBProvider + BlockNumReader> StateRootProvider
for HistoricalStateProviderRef<'_, Provider>
{
fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
@@ -322,7 +318,7 @@ impl<Provider: DBProvider + BlockNumReader + StateCommitmentProvider> StateRootP
}
}
impl<Provider: DBProvider + BlockNumReader + StateCommitmentProvider> StorageRootProvider
impl<Provider: DBProvider + BlockNumReader> StorageRootProvider
for HistoricalStateProviderRef<'_, Provider>
{
fn storage_root(
@@ -361,7 +357,7 @@ impl<Provider: DBProvider + BlockNumReader + StateCommitmentProvider> StorageRoo
}
}
impl<Provider: DBProvider + BlockNumReader + StateCommitmentProvider> StateProofProvider
impl<Provider: DBProvider + BlockNumReader> StateProofProvider
for HistoricalStateProviderRef<'_, Provider>
{
/// Get account and storage proofs.
@@ -392,18 +388,14 @@ impl<Provider: DBProvider + BlockNumReader + StateCommitmentProvider> StateProof
}
}
impl<Provider: StateCommitmentProvider> HashedPostStateProvider
for HistoricalStateProviderRef<'_, Provider>
{
impl<Provider: Sync> HashedPostStateProvider for HistoricalStateProviderRef<'_, Provider> {
fn hashed_post_state(&self, bundle_state: &revm_database::BundleState) -> HashedPostState {
HashedPostState::from_bundle_state::<
<Provider::StateCommitment as StateCommitment>::KeyHasher,
>(bundle_state.state())
HashedPostState::from_bundle_state::<KeccakKeyHasher>(bundle_state.state())
}
}
impl<Provider: DBProvider + BlockNumReader + BlockHashReader + StateCommitmentProvider>
StateProvider for HistoricalStateProviderRef<'_, Provider>
impl<Provider: DBProvider + BlockNumReader + BlockHashReader> StateProvider
for HistoricalStateProviderRef<'_, Provider>
{
/// Get storage.
fn storage(
@@ -436,7 +428,7 @@ impl<Provider: DBProvider + BlockNumReader + BlockHashReader + StateCommitmentPr
}
}
impl<Provider: DBProvider + BlockNumReader + StateCommitmentProvider> BytecodeReader
impl<Provider: DBProvider + BlockNumReader> BytecodeReader
for HistoricalStateProviderRef<'_, Provider>
{
/// Get account code by its hash
@@ -445,12 +437,6 @@ impl<Provider: DBProvider + BlockNumReader + StateCommitmentProvider> BytecodeRe
}
}
impl<Provider: StateCommitmentProvider> StateCommitmentProvider
for HistoricalStateProviderRef<'_, Provider>
{
type StateCommitment = Provider::StateCommitment;
}
/// State provider for a given block number.
/// For more detailed description, see [`HistoricalStateProviderRef`].
#[derive(Debug)]
@@ -463,9 +449,7 @@ pub struct HistoricalStateProvider<Provider> {
lowest_available_blocks: LowestAvailableBlocks,
}
impl<Provider: DBProvider + BlockNumReader + StateCommitmentProvider>
HistoricalStateProvider<Provider>
{
impl<Provider: DBProvider + BlockNumReader> HistoricalStateProvider<Provider> {
/// Create new `StateProvider` for historical block number
pub fn new(provider: Provider, block_number: BlockNumber) -> Self {
Self { provider, block_number, lowest_available_blocks: Default::default() }
@@ -500,14 +484,8 @@ impl<Provider: DBProvider + BlockNumReader + StateCommitmentProvider>
}
}
impl<Provider: StateCommitmentProvider> StateCommitmentProvider
for HistoricalStateProvider<Provider>
{
type StateCommitment = Provider::StateCommitment;
}
// Delegates all provider impls to [HistoricalStateProviderRef]
delegate_provider_impls!(HistoricalStateProvider<Provider> where [Provider: DBProvider + BlockNumReader + BlockHashReader + StateCommitmentProvider]);
delegate_provider_impls!(HistoricalStateProvider<Provider> where [Provider: DBProvider + BlockNumReader + BlockHashReader ]);
/// Lowest blocks at which different parts of the state are available.
/// They may be [Some] if pruning is enabled.
@@ -552,10 +530,7 @@ mod tests {
BlockNumberList,
};
use reth_primitives_traits::{Account, StorageEntry};
use reth_storage_api::{
BlockHashReader, BlockNumReader, DBProvider, DatabaseProviderFactory,
StateCommitmentProvider,
};
use reth_storage_api::{BlockHashReader, BlockNumReader, DBProvider, DatabaseProviderFactory};
use reth_storage_errors::provider::ProviderError;
const ADDRESS: Address = address!("0x0000000000000000000000000000000000000001");
@@ -565,9 +540,7 @@ mod tests {
const fn assert_state_provider<T: StateProvider>() {}
#[expect(dead_code)]
const fn assert_historical_state_provider<
T: DBProvider + BlockNumReader + BlockHashReader + StateCommitmentProvider,
>() {
const fn assert_historical_state_provider<T: DBProvider + BlockNumReader + BlockHashReader>() {
assert_state_provider::<HistoricalStateProvider<T>>();
}

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

@@ -5,20 +5,18 @@ use crate::{
use alloy_primitives::{Address, BlockNumber, Bytes, StorageKey, StorageValue, B256};
use reth_db_api::{cursor::DbDupCursorRO, tables, transaction::DbTx};
use reth_primitives_traits::{Account, Bytecode};
use reth_storage_api::{
BytecodeReader, DBProvider, StateCommitmentProvider, StateProofProvider, StorageRootProvider,
};
use reth_storage_api::{BytecodeReader, DBProvider, StateProofProvider, StorageRootProvider};
use reth_storage_errors::provider::{ProviderError, ProviderResult};
use reth_trie::{
proof::{Proof, StorageProof},
updates::TrieUpdates,
witness::TrieWitness,
AccountProof, HashedPostState, HashedStorage, MultiProof, MultiProofTargets, StateRoot,
StorageMultiProof, StorageRoot, TrieInput,
AccountProof, HashedPostState, HashedStorage, KeccakKeyHasher, MultiProof, MultiProofTargets,
StateRoot, StorageMultiProof, StorageRoot, TrieInput,
};
use reth_trie_db::{
DatabaseProof, DatabaseStateRoot, DatabaseStorageProof, DatabaseStorageRoot,
DatabaseTrieWitness, StateCommitment,
DatabaseTrieWitness,
};
/// State provider over latest state that takes tx reference.
@@ -60,9 +58,7 @@ impl<Provider: BlockHashReader> BlockHashReader for LatestStateProviderRef<'_, P
}
}
impl<Provider: DBProvider + StateCommitmentProvider> StateRootProvider
for LatestStateProviderRef<'_, Provider>
{
impl<Provider: DBProvider + Sync> StateRootProvider for LatestStateProviderRef<'_, Provider> {
fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
StateRoot::overlay_root(self.tx(), hashed_state)
.map_err(|err| ProviderError::Database(err.into()))
@@ -90,9 +86,7 @@ impl<Provider: DBProvider + StateCommitmentProvider> StateRootProvider
}
}
impl<Provider: DBProvider + StateCommitmentProvider> StorageRootProvider
for LatestStateProviderRef<'_, Provider>
{
impl<Provider: DBProvider + Sync> StorageRootProvider for LatestStateProviderRef<'_, Provider> {
fn storage_root(
&self,
address: Address,
@@ -123,9 +117,7 @@ impl<Provider: DBProvider + StateCommitmentProvider> StorageRootProvider
}
}
impl<Provider: DBProvider + StateCommitmentProvider> StateProofProvider
for LatestStateProviderRef<'_, Provider>
{
impl<Provider: DBProvider + Sync> StateProofProvider for LatestStateProviderRef<'_, Provider> {
fn proof(
&self,
input: TrieInput,
@@ -150,17 +142,13 @@ impl<Provider: DBProvider + StateCommitmentProvider> StateProofProvider
}
}
impl<Provider: DBProvider + StateCommitmentProvider> HashedPostStateProvider
for LatestStateProviderRef<'_, Provider>
{
impl<Provider: DBProvider + Sync> HashedPostStateProvider for LatestStateProviderRef<'_, Provider> {
fn hashed_post_state(&self, bundle_state: &revm_database::BundleState) -> HashedPostState {
HashedPostState::from_bundle_state::<
<Provider::StateCommitment as StateCommitment>::KeyHasher,
>(bundle_state.state())
HashedPostState::from_bundle_state::<KeccakKeyHasher>(bundle_state.state())
}
}
impl<Provider: DBProvider + BlockHashReader + StateCommitmentProvider> StateProvider
impl<Provider: DBProvider + BlockHashReader> StateProvider
for LatestStateProviderRef<'_, Provider>
{
/// Get storage.
@@ -179,7 +167,7 @@ impl<Provider: DBProvider + BlockHashReader + StateCommitmentProvider> StateProv
}
}
impl<Provider: DBProvider + BlockHashReader + StateCommitmentProvider> BytecodeReader
impl<Provider: DBProvider + BlockHashReader> BytecodeReader
for LatestStateProviderRef<'_, Provider>
{
/// Get account code by its hash
@@ -188,17 +176,11 @@ impl<Provider: DBProvider + BlockHashReader + StateCommitmentProvider> BytecodeR
}
}
impl<Provider: StateCommitmentProvider> StateCommitmentProvider
for LatestStateProviderRef<'_, Provider>
{
type StateCommitment = Provider::StateCommitment;
}
/// State provider for the latest state.
#[derive(Debug)]
pub struct LatestStateProvider<Provider>(Provider);
impl<Provider: DBProvider + StateCommitmentProvider> LatestStateProvider<Provider> {
impl<Provider: DBProvider> LatestStateProvider<Provider> {
/// Create new state provider
pub const fn new(db: Provider) -> Self {
Self(db)
@@ -211,12 +193,8 @@ impl<Provider: DBProvider + StateCommitmentProvider> LatestStateProvider<Provide
}
}
impl<Provider: StateCommitmentProvider> StateCommitmentProvider for LatestStateProvider<Provider> {
type StateCommitment = Provider::StateCommitment;
}
// Delegates all provider impls to [LatestStateProviderRef]
delegate_provider_impls!(LatestStateProvider<Provider> where [Provider: DBProvider + BlockHashReader + StateCommitmentProvider]);
delegate_provider_impls!(LatestStateProvider<Provider> where [Provider: DBProvider + BlockHashReader ]);
#[cfg(test)]
mod tests {
@@ -224,9 +202,7 @@ mod tests {
const fn assert_state_provider<T: StateProvider>() {}
#[expect(dead_code)]
const fn assert_latest_state_provider<
T: DBProvider + BlockHashReader + StateCommitmentProvider,
>() {
const fn assert_latest_state_provider<T: DBProvider + BlockHashReader>() {
assert_state_provider::<LatestStateProvider<T>>();
}
}

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

@@ -1,9 +1,9 @@
use crate::{
traits::{BlockSource, ReceiptProvider},
AccountReader, BlockHashReader, BlockIdReader, BlockNumReader, BlockReader, BlockReaderIdExt,
ChainSpecProvider, ChangeSetReader, EthStorage, HeaderProvider, ReceiptProviderIdExt,
StateProvider, StateProviderBox, StateProviderFactory, StateReader, StateRootProvider,
TransactionVariant, TransactionsProvider,
ChainSpecProvider, ChangeSetReader, HeaderProvider, ReceiptProviderIdExt, StateProvider,
StateProviderBox, StateProviderFactory, StateReader, StateRootProvider, TransactionVariant,
TransactionsProvider,
};
use alloy_consensus::{constants::EMPTY_ROOT_HASH, transaction::TransactionMeta, BlockHeader};
use alloy_eips::{BlockHashOrNumber, BlockId, BlockNumberOrTag};
@@ -18,10 +18,8 @@ use reth_db_api::{
mock::{DatabaseMock, TxMock},
models::{AccountBeforeTx, StoredBlockBodyIndices},
};
use reth_ethereum_engine_primitives::EthEngineTypes;
use reth_ethereum_primitives::EthPrimitives;
use reth_execution_types::ExecutionOutcome;
use reth_node_types::NodeTypes;
use reth_primitives_traits::{
Account, Block, BlockBody, Bytecode, GotExpected, NodePrimitives, RecoveredBlock, SealedHeader,
SignedTransaction, SignerRecoverable,
@@ -30,15 +28,14 @@ use reth_prune_types::PruneModes;
use reth_stages_types::{StageCheckpoint, StageId};
use reth_storage_api::{
BlockBodyIndicesProvider, BytecodeReader, DBProvider, DatabaseProviderFactory,
HashedPostStateProvider, NodePrimitivesProvider, StageCheckpointReader,
StateCommitmentProvider, StateProofProvider, StorageRootProvider,
HashedPostStateProvider, NodePrimitivesProvider, StageCheckpointReader, StateProofProvider,
StorageRootProvider,
};
use reth_storage_errors::provider::{ConsistentViewError, ProviderError, ProviderResult};
use reth_trie::{
updates::TrieUpdates, AccountProof, HashedPostState, HashedStorage, MultiProof,
MultiProofTargets, StorageMultiProof, StorageProof, TrieInput,
};
use reth_trie_db::MerklePatriciaTrie;
use std::{
collections::BTreeMap,
fmt::Debug,
@@ -232,26 +229,6 @@ impl ExtendedAccount {
}
}
/// Mock node.
#[derive(Clone, Debug)]
pub struct MockNode;
impl NodeTypes for MockNode {
type Primitives = EthPrimitives;
type ChainSpec = reth_chainspec::ChainSpec;
type StateCommitment = MerklePatriciaTrie;
type Storage = EthStorage;
type Payload = EthEngineTypes;
}
impl<T, ChainSpec> StateCommitmentProvider for MockEthProvider<T, ChainSpec>
where
T: NodePrimitives,
ChainSpec: EthChainSpec + Send + Sync + 'static,
{
type StateCommitment = <MockNode as NodeTypes>::StateCommitment;
}
impl<T: NodePrimitives, ChainSpec: EthChainSpec + Clone + 'static> DatabaseProviderFactory
for MockEthProvider<T, ChainSpec>
{

1
crates/storage/provider/src/test_utils/mod.rs
View File

@@ -29,7 +29,6 @@ pub type MockNodeTypes = reth_node_types::AnyNodeTypesWithEngine<
reth_ethereum_primitives::EthPrimitives,
reth_ethereum_engine_primitives::EthEngineTypes,
reth_chainspec::ChainSpec,
reth_trie_db::MerklePatriciaTrie,
crate::EthStorage,
EthEngineTypes,
>;

6
crates/storage/provider/src/traits/full.rs
View File

@@ -2,8 +2,8 @@
use crate::{
AccountReader, BlockReader, BlockReaderIdExt, ChainSpecProvider, ChangeSetReader,
DatabaseProviderFactory, HashedPostStateProvider, StageCheckpointReader,
StateCommitmentProvider, StateProviderFactory, StateReader, StaticFileProviderFactory,
DatabaseProviderFactory, HashedPostStateProvider, StageCheckpointReader, StateProviderFactory,
StateReader, StaticFileProviderFactory,
};
use reth_chain_state::{CanonStateSubscriptions, ForkChoiceSubscriptions};
use reth_node_types::{BlockTy, HeaderTy, NodeTypesWithDB, ReceiptTy, TxTy};
@@ -23,7 +23,6 @@ pub trait FullProvider<N: NodeTypesWithDB>:
> + AccountReader
+ StateProviderFactory
+ StateReader
+ StateCommitmentProvider
+ HashedPostStateProvider
+ ChainSpecProvider<ChainSpec = N::ChainSpec>
+ ChangeSetReader
@@ -49,7 +48,6 @@ impl<T, N: NodeTypesWithDB> FullProvider<N> for T where
> + AccountReader
+ StateProviderFactory
+ StateReader
+ StateCommitmentProvider
+ HashedPostStateProvider
+ ChainSpecProvider<ChainSpec = N::ChainSpec>
+ ChangeSetReader

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

@@ -22,7 +22,6 @@ reth-prune-types.workspace = true
reth-stages-types.workspace = true
reth-storage-errors.workspace = true
reth-trie-common.workspace = true
reth-trie-db = { workspace = true, optional = true }
revm-database.workspace = true
reth-ethereum-primitives.workspace = true
@@ -55,7 +54,6 @@ std = [
db-api = [
"dep:reth-db-api",
"dep:reth-trie-db",
]
serde = [
@@ -66,7 +64,6 @@ serde = [
"reth-prune-types/serde",
"reth-stages-types/serde",
"reth-trie-common/serde",
"reth-trie-db?/serde",
"revm-database/serde",
"reth-ethereum-primitives/serde",
"alloy-eips/serde",

11
crates/storage/storage-api/src/noop.rs
View File

@@ -10,7 +10,7 @@ use crate::{
};
#[cfg(feature = "db-api")]
use crate::{DBProvider, DatabaseProviderFactory, StateCommitmentProvider};
use crate::{DBProvider, DatabaseProviderFactory};
use alloc::{boxed::Box, string::String, sync::Arc, vec::Vec};
use alloy_consensus::transaction::TransactionMeta;
use alloy_eips::{BlockHashOrNumber, BlockId, BlockNumberOrTag};
@@ -38,8 +38,6 @@ use reth_trie_common::{
updates::TrieUpdates, AccountProof, HashedPostState, HashedStorage, MultiProof,
MultiProofTargets, StorageMultiProof, StorageProof, TrieInput,
};
#[cfg(feature = "db-api")]
use reth_trie_db::MerklePatriciaTrie;
/// Supports various api interfaces for testing purposes.
#[derive(Debug)]
@@ -626,13 +624,6 @@ impl<ChainSpec: Send + Sync, N: NodePrimitives> DBProvider for NoopProvider<Chai
}
}
#[cfg(feature = "db-api")]
impl<ChainSpec: Send + Sync, N: NodePrimitives> StateCommitmentProvider
for NoopProvider<ChainSpec, N>
{
type StateCommitment = MerklePatriciaTrie;
}
#[cfg(feature = "db-api")]
impl<ChainSpec: Send + Sync, N: NodePrimitives> DatabaseProviderFactory
for NoopProvider<ChainSpec, N>

9
crates/storage/storage-api/src/state.rs
View File

@@ -96,15 +96,6 @@ pub trait StateProvider:
pub trait AccountInfoReader: AccountReader + BytecodeReader {}
impl<T: AccountReader + BytecodeReader> AccountInfoReader for T {}
/// Trait implemented for database providers that can provide the [`reth_trie_db::StateCommitment`]
/// type.
#[cfg(feature = "db-api")]
pub trait StateCommitmentProvider: Send + Sync {
/// The [`reth_trie_db::StateCommitment`] type that can be used to perform state commitment
/// operations.
type StateCommitment: reth_trie_db::StateCommitment;
}
/// Trait that provides the hashed state from various sources.
#[auto_impl(&, Arc, Box)]
pub trait HashedPostStateProvider: Send + Sync {

39
crates/trie/db/src/commitment.rs
View File

@@ -1,39 +0,0 @@
use crate::{
DatabaseHashedCursorFactory, DatabaseProof, DatabaseStateRoot, DatabaseStorageRoot,
DatabaseTrieCursorFactory, DatabaseTrieWitness,
};
use reth_db_api::transaction::DbTx;
use reth_trie::{
proof::Proof, witness::TrieWitness, KeccakKeyHasher, KeyHasher, StateRoot, StorageRoot,
};
/// The `StateCommitment` trait provides associated types for state commitment operations.
pub trait StateCommitment: std::fmt::Debug + Clone + Send + Sync + Unpin + 'static {
/// The state root type.
type StateRoot<'a, TX: DbTx + 'a>: DatabaseStateRoot<'a, TX>;
/// The storage root type.
type StorageRoot<'a, TX: DbTx + 'a>: DatabaseStorageRoot<'a, TX>;
/// The state proof type.
type StateProof<'a, TX: DbTx + 'a>: DatabaseProof<'a, TX>;
/// The state witness type.
type StateWitness<'a, TX: DbTx + 'a>: DatabaseTrieWitness<'a, TX>;
/// The key hasher type.
type KeyHasher: KeyHasher;
}
/// The state commitment type for Ethereum's Merkle Patricia Trie.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct MerklePatriciaTrie;
impl StateCommitment for MerklePatriciaTrie {
type StateRoot<'a, TX: DbTx + 'a> =
StateRoot<DatabaseTrieCursorFactory<'a, TX>, DatabaseHashedCursorFactory<'a, TX>>;
type StorageRoot<'a, TX: DbTx + 'a> =
StorageRoot<DatabaseTrieCursorFactory<'a, TX>, DatabaseHashedCursorFactory<'a, TX>>;
type StateProof<'a, TX: DbTx + 'a> =
Proof<DatabaseTrieCursorFactory<'a, TX>, DatabaseHashedCursorFactory<'a, TX>>;
type StateWitness<'a, TX: DbTx + 'a> =
TrieWitness<DatabaseTrieCursorFactory<'a, TX>, DatabaseHashedCursorFactory<'a, TX>>;
type KeyHasher = KeccakKeyHasher;
}

2
crates/trie/db/src/lib.rs
View File

@@ -2,7 +2,6 @@
#![cfg_attr(not(test), warn(unused_crate_dependencies))]
mod commitment;
mod hashed_cursor;
mod prefix_set;
mod proof;
@@ -11,7 +10,6 @@ mod storage;
mod trie_cursor;
mod witness;
pub use commitment::{MerklePatriciaTrie, StateCommitment};
pub use hashed_cursor::{
DatabaseHashedAccountCursor, DatabaseHashedCursorFactory, DatabaseHashedStorageCursor,
};

5
crates/trie/parallel/src/proof.rs
View File

@@ -14,7 +14,7 @@ use itertools::Itertools;
use reth_execution_errors::StorageRootError;
use reth_provider::{
providers::ConsistentDbView, BlockReader, DBProvider, DatabaseProviderFactory, FactoryTx,
ProviderError, StateCommitmentProvider,
ProviderError,
};
use reth_storage_errors::db::DatabaseError;
use reth_trie::{
@@ -88,8 +88,7 @@ impl<Factory: DatabaseProviderFactory> ParallelProof<Factory> {
impl<Factory> ParallelProof<Factory>
where
Factory:
DatabaseProviderFactory<Provider: BlockReader> + StateCommitmentProvider + Clone + 'static,
Factory: DatabaseProviderFactory<Provider: BlockReader> + Clone + 'static,
{
/// Spawns a storage proof on the storage proof task and returns a receiver for the result.
fn spawn_storage_proof(

4
crates/trie/parallel/src/proof_task.rs
View File

@@ -14,7 +14,7 @@ use reth_db_api::transaction::DbTx;
use reth_execution_errors::SparseTrieError;
use reth_provider::{
providers::ConsistentDbView, BlockReader, DBProvider, DatabaseProviderFactory, FactoryTx,
ProviderResult, StateCommitmentProvider,
ProviderResult,
};
use reth_trie::{
hashed_cursor::HashedPostStateCursorFactory,
@@ -114,7 +114,7 @@ impl<Factory: DatabaseProviderFactory> ProofTaskManager<Factory> {
impl<Factory> ProofTaskManager<Factory>
where
Factory: DatabaseProviderFactory<Provider: BlockReader> + StateCommitmentProvider + 'static,
Factory: DatabaseProviderFactory<Provider: BlockReader> + 'static,
{
/// Inserts the task into the pending tasks queue.
pub fn queue_proof_task(&mut self, task: ProofTaskKind) {

8
crates/trie/parallel/src/root.rs
View File

@@ -7,7 +7,6 @@ use itertools::Itertools;
use reth_execution_errors::StorageRootError;
use reth_provider::{
providers::ConsistentDbView, BlockReader, DBProvider, DatabaseProviderFactory, ProviderError,
StateCommitmentProvider,
};
use reth_storage_errors::db::DatabaseError;
use reth_trie::{
@@ -59,12 +58,7 @@ impl<Factory> ParallelStateRoot<Factory> {
impl<Factory> ParallelStateRoot<Factory>
where
Factory: DatabaseProviderFactory<Provider: BlockReader>
+ StateCommitmentProvider
+ Clone
+ Send
+ Sync
+ 'static,
Factory: DatabaseProviderFactory<Provider: BlockReader> + Clone + Send + Sync + 'static,
{
/// Calculate incremental state root in parallel.
pub fn incremental_root(self) -> Result<B256, ParallelStateRootError> {

1
examples/custom-engine-types/Cargo.toml
View File

@@ -11,7 +11,6 @@ reth-basic-payload-builder.workspace = true
reth-ethereum-payload-builder.workspace = true
reth-ethereum = { workspace = true, features = ["test-utils", "node", "node-api", "pool"] }
reth-tracing.workspace = true
reth-trie-db.workspace = true
alloy-genesis.workspace = true
alloy-rpc-types = { workspace = true, features = ["engine"] }
alloy-primitives.workspace = true

2
examples/custom-engine-types/src/main.rs
View File

@@ -60,7 +60,6 @@ use reth_ethereum::{
use reth_ethereum_payload_builder::{EthereumBuilderConfig, EthereumExecutionPayloadValidator};
use reth_payload_builder::{EthBuiltPayload, EthPayloadBuilderAttributes, PayloadBuilderError};
use reth_tracing::{RethTracer, Tracer};
use reth_trie_db::MerklePatriciaTrie;
use serde::{Deserialize, Serialize};
use std::{convert::Infallible, sync::Arc};
use thiserror::Error;
@@ -269,7 +268,6 @@ struct MyCustomNode;
impl NodeTypes for MyCustomNode {
type Primitives = EthPrimitives;
type ChainSpec = ChainSpec;
type StateCommitment = MerklePatriciaTrie;
type Storage = EthStorage;
type Payload = CustomEngineTypes;
}

1
examples/custom-node/src/lib.rs
View File

@@ -46,7 +46,6 @@ pub struct CustomNode {
impl NodeTypes for CustomNode {
type Primitives = CustomNodePrimitives;
type ChainSpec = CustomChainSpec;
type StateCommitment = <OpNode as NodeTypes>::StateCommitment;
type Storage = <OpNode as NodeTypes>::Storage;
type Payload = CustomPayloadTypes;
}