From 56b63adeccacf67a254a1cbc8eadf009673de99c Mon Sep 17 00:00:00 2001 From: Roman Krasiuk Date: Thu, 21 Mar 2024 17:08:49 +0100 Subject: [PATCH] perf(tree): integrate parallel state root (#7161) --- Cargo.lock | 1 + crates/blockchain-tree/Cargo.toml | 1 + crates/blockchain-tree/src/blockchain_tree.rs | 6 +- crates/blockchain-tree/src/chain.rs | 36 ++++++++--- crates/blockchain-tree/src/shareable.rs | 32 +++++++--- crates/interfaces/src/provider.rs | 14 +++-- .../src/providers/bundle_state_provider.rs | 6 +- .../provider/src/providers/consistent_view.rs | 31 +++++---- .../provider/src/providers/database/mod.rs | 63 ++----------------- .../src/providers/database/provider.rs | 49 ++++++++++++++- crates/storage/provider/src/traits/mod.rs | 5 +- crates/storage/provider/src/traits/state.rs | 24 +------ crates/storage/provider/src/traits/trie.rs | 25 ++++++++ crates/trie-parallel/Cargo.toml | 2 +- crates/trie-parallel/benches/root.rs | 2 +- crates/trie-parallel/src/async_root.rs | 10 +-- crates/trie-parallel/src/parallel_root.rs | 21 ++++--- 17 files changed, 184 insertions(+), 144 deletions(-) create mode 100644 crates/storage/provider/src/traits/trie.rs diff --git a/Cargo.lock b/Cargo.lock index 5650c585b..6da61cf63 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5588,6 +5588,7 @@ dependencies = [ "reth-revm", "reth-stages", "reth-trie", + "reth-trie-parallel", "tokio", "tracing", ] diff --git a/crates/blockchain-tree/Cargo.toml b/crates/blockchain-tree/Cargo.toml index 9914bc85b..81bf9ea05 100644 --- a/crates/blockchain-tree/Cargo.toml +++ b/crates/blockchain-tree/Cargo.toml @@ -18,6 +18,7 @@ reth-db.workspace = true reth-provider.workspace = true reth-stages.workspace = true reth-trie = { workspace = true, features = ["metrics"] } +reth-trie-parallel = { workspace = true, features = ["parallel"] } # common parking_lot.workspace = true diff --git a/crates/blockchain-tree/src/blockchain_tree.rs b/crates/blockchain-tree/src/blockchain_tree.rs index 096df336b..983a2d958 100644 --- a/crates/blockchain-tree/src/blockchain_tree.rs +++ b/crates/blockchain-tree/src/blockchain_tree.rs @@ -76,7 +76,11 @@ pub struct BlockchainTree { prune_modes: Option, } -impl BlockchainTree { +impl BlockchainTree +where + DB: Database + Clone, + EVM: ExecutorFactory, +{ /// Create a new blockchain tree. pub fn new( externals: TreeExternals, diff --git a/crates/blockchain-tree/src/chain.rs b/crates/blockchain-tree/src/chain.rs index 6aa35b3a4..861c3eea7 100644 --- a/crates/blockchain-tree/src/chain.rs +++ b/crates/blockchain-tree/src/chain.rs @@ -18,10 +18,12 @@ use reth_primitives::{ BlockHash, BlockNumber, ForkBlock, GotExpected, SealedBlockWithSenders, SealedHeader, U256, }; use reth_provider::{ - providers::BundleStateProvider, BundleStateDataProvider, BundleStateWithReceipts, Chain, - ExecutorFactory, StateRootProvider, + providers::{BundleStateProvider, ConsistentDbView}, + BundleStateDataProvider, BundleStateWithReceipts, Chain, ExecutorFactory, ProviderError, + StateRootProvider, }; use reth_trie::updates::TrieUpdates; +use reth_trie_parallel::parallel_root::ParallelStateRoot; use std::{ collections::BTreeMap, ops::{Deref, DerefMut}, @@ -74,7 +76,7 @@ impl AppendableChain { block_validation_kind: BlockValidationKind, ) -> Result where - DB: Database, + DB: Database + Clone, EF: ExecutorFactory, { let state = BundleStateWithReceipts::default(); @@ -112,7 +114,7 @@ impl AppendableChain { block_validation_kind: BlockValidationKind, ) -> Result where - DB: Database, + DB: Database + Clone, EF: ExecutorFactory, { let parent_number = block.number - 1; @@ -174,7 +176,7 @@ impl AppendableChain { ) -> RethResult<(BundleStateWithReceipts, Option)> where BSDP: BundleStateDataProvider, - DB: Database, + DB: Database + Clone, EVM: ExecutorFactory, { // some checks are done before blocks comes here. @@ -182,8 +184,18 @@ impl AppendableChain { // get the state provider. let canonical_fork = bundle_state_data_provider.canonical_fork(); + + // SAFETY: For block execution and parallel state root computation below we open multiple + // independent database transactions. Upon opening the database transaction the consistent + // view will check a current tip in the database and throw an error if it doesn't match + // the one recorded during initialization. + // It is safe to use consistent view without any special error handling as long as + // we guarantee that plain state cannot change during processing of new payload. + // The usage has to be re-evaluated if that was ever to change. + let consistent_view = + ConsistentDbView::new_with_latest_tip(externals.provider_factory.clone())?; let state_provider = - externals.provider_factory.history_by_block_number(canonical_fork.number)?; + consistent_view.provider_ro()?.state_provider_by_block_number(canonical_fork.number)?; let provider = BundleStateProvider::new(state_provider, bundle_state_data_provider); @@ -199,9 +211,13 @@ impl AppendableChain { // calculate and check state root let start = Instant::now(); let (state_root, trie_updates) = if block_attachment.is_canonical() { - provider - .state_root_with_updates(bundle_state.state()) - .map(|(root, updates)| (root, Some(updates)))? + let mut state = provider.bundle_state_data_provider.state().clone(); + state.extend(bundle_state.clone()); + let hashed_state = state.hash_state_slow(); + ParallelStateRoot::new(consistent_view, hashed_state) + .incremental_root_with_updates() + .map(|(root, updates)| (root, Some(updates))) + .map_err(ProviderError::from)? } else { (provider.state_root(bundle_state.state())?, None) }; @@ -250,7 +266,7 @@ impl AppendableChain { block_validation_kind: BlockValidationKind, ) -> Result<(), InsertBlockErrorKind> where - DB: Database, + DB: Database + Clone, EF: ExecutorFactory, { let parent_block = self.chain.tip(); diff --git a/crates/blockchain-tree/src/shareable.rs b/crates/blockchain-tree/src/shareable.rs index e3229eac3..251ff5bb0 100644 --- a/crates/blockchain-tree/src/shareable.rs +++ b/crates/blockchain-tree/src/shareable.rs @@ -27,19 +27,27 @@ use tracing::trace; /// Shareable blockchain tree that is behind tokio::RwLock #[derive(Clone, Debug)] -pub struct ShareableBlockchainTree { +pub struct ShareableBlockchainTree { /// BlockchainTree pub tree: Arc>>, } -impl ShareableBlockchainTree { +impl ShareableBlockchainTree +where + DB: Database + Clone, + EF: ExecutorFactory, +{ /// Create a new shareable database. pub fn new(tree: BlockchainTree) -> Self { Self { tree: Arc::new(RwLock::new(tree)) } } } -impl BlockchainTreeEngine for ShareableBlockchainTree { +impl BlockchainTreeEngine for ShareableBlockchainTree +where + DB: Database + Clone, + EF: ExecutorFactory, +{ fn buffer_block(&self, block: SealedBlockWithSenders) -> Result<(), InsertBlockError> { let mut tree = self.tree.write(); // Blockchain tree metrics shouldn't be updated here, see @@ -103,7 +111,11 @@ impl BlockchainTreeEngine for ShareableBlockc } } -impl BlockchainTreeViewer for ShareableBlockchainTree { +impl BlockchainTreeViewer for ShareableBlockchainTree +where + DB: Database + Clone, + EF: ExecutorFactory, +{ fn blocks(&self) -> BTreeMap> { trace!(target: "blockchain_tree", "Returning all blocks in blockchain tree"); self.tree.read().block_indices().block_number_to_block_hashes().clone() @@ -196,8 +208,10 @@ impl BlockchainTreeViewer for ShareableBlockc } } -impl BlockchainTreePendingStateProvider - for ShareableBlockchainTree +impl BlockchainTreePendingStateProvider for ShareableBlockchainTree +where + DB: Database + Clone, + EF: ExecutorFactory, { fn find_pending_state_provider( &self, @@ -209,8 +223,10 @@ impl BlockchainTreePendingStateProvider } } -impl CanonStateSubscriptions - for ShareableBlockchainTree +impl CanonStateSubscriptions for ShareableBlockchainTree +where + DB: Database + Clone, + EF: ExecutorFactory, { fn subscribe_to_canonical_state(&self) -> reth_provider::CanonStateNotifications { trace!(target: "blockchain_tree", "Registered subscriber for canonical state"); diff --git a/crates/interfaces/src/provider.rs b/crates/interfaces/src/provider.rs index dd59bd120..c7b5f6258 100644 --- a/crates/interfaces/src/provider.rs +++ b/crates/interfaces/src/provider.rs @@ -131,6 +131,9 @@ pub enum ProviderError { /// Error encountered when the block number conversion from U256 to u64 causes an overflow. #[error("failed to convert block number U256 to u64: {0}")] BlockNumberOverflow(U256), + /// Consistent view error. + #[error("failed to initialize consistent view: {0}")] + ConsistentView(Box), } impl From for ProviderError { @@ -152,7 +155,7 @@ pub struct RootMismatch { } /// Consistent database view error. -#[derive(Error, Debug)] +#[derive(Clone, Debug, Error, PartialEq, Eq)] pub enum ConsistentViewError { /// Error thrown on attempt to initialize provider while node is still syncing. #[error("node is syncing. best block: {0}")] @@ -163,7 +166,10 @@ pub enum ConsistentViewError { /// The tip diff. tip: GotExpected>, }, - /// Underlying provider error. - #[error(transparent)] - Provider(#[from] ProviderError), +} + +impl From for ProviderError { + fn from(value: ConsistentViewError) -> Self { + Self::ConsistentView(Box::new(value)) + } } diff --git a/crates/storage/provider/src/providers/bundle_state_provider.rs b/crates/storage/provider/src/providers/bundle_state_provider.rs index 17bbac259..e3364cadb 100644 --- a/crates/storage/provider/src/providers/bundle_state_provider.rs +++ b/crates/storage/provider/src/providers/bundle_state_provider.rs @@ -11,9 +11,9 @@ use revm::db::BundleState; #[derive(Debug)] pub struct BundleStateProvider { /// The inner state provider. - pub(crate) state_provider: SP, - /// Bundle state data, - pub(crate) bundle_state_data_provider: BSDP, + pub state_provider: SP, + /// Bundle state data. + pub bundle_state_data_provider: BSDP, } impl BundleStateProvider { diff --git a/crates/storage/provider/src/providers/consistent_view.rs b/crates/storage/provider/src/providers/consistent_view.rs index 452fa05a1..3cad431b9 100644 --- a/crates/storage/provider/src/providers/consistent_view.rs +++ b/crates/storage/provider/src/providers/consistent_view.rs @@ -34,26 +34,22 @@ where Provider: DatabaseProviderFactory, { /// Creates new consistent database view. - pub fn new(provider: Provider) -> Self { - Self { database: PhantomData, provider, tip: None } + pub fn new(provider: Provider, tip: Option) -> Self { + Self { database: PhantomData, provider, tip } } - /// Initializes the view with provided tip. - pub fn with_tip(mut self, tip: B256) -> Self { - self.tip = Some(tip); - self - } - - /// Initializes the view with latest tip. - pub fn with_latest_tip(mut self) -> ProviderResult { - let provider = self.provider.database_provider_ro()?; - let tip = provider.tx_ref().cursor_read::()?.last()?; - self.tip = tip.map(|(_, hash)| hash); - Ok(self) + /// Creates new consistent database view with latest tip. + pub fn new_with_latest_tip(provider: Provider) -> ProviderResult { + let tip = provider + .database_provider_ro()? + .tx_ref() + .cursor_read::()? + .last()?; + Ok(Self::new(provider, tip.map(|(_, hash)| hash))) } /// Creates new read-only provider and performs consistency checks on the current tip. - pub fn provider_ro(&self) -> Result, ConsistentViewError> { + pub fn provider_ro(&self) -> ProviderResult> { let provider_ro = self.provider.database_provider_ro()?; let last_entry = provider_ro .tx_ref() @@ -65,12 +61,13 @@ where if self.tip != tip { return Err(ConsistentViewError::Inconsistent { tip: GotExpected { got: tip, expected: self.tip }, - }) + } + .into()) } let best_block_number = provider_ro.best_block_number()?; if last_entry.map(|(number, _)| number).unwrap_or_default() != best_block_number { - return Err(ConsistentViewError::Syncing(best_block_number)) + return Err(ConsistentViewError::Syncing(best_block_number).into()) } Ok(provider_ro) diff --git a/crates/storage/provider/src/providers/database/mod.rs b/crates/storage/provider/src/providers/database/mod.rs index 20b152e32..b6ea00cd4 100644 --- a/crates/storage/provider/src/providers/database/mod.rs +++ b/crates/storage/provider/src/providers/database/mod.rs @@ -1,8 +1,5 @@ use crate::{ - providers::{ - state::{historical::HistoricalStateProvider, latest::LatestStateProvider}, - StaticFileProvider, - }, + providers::{state::latest::LatestStateProvider, StaticFileProvider}, to_range, traits::{BlockSource, ReceiptProvider}, BlockHashReader, BlockNumReader, BlockReader, ChainSpecProvider, DatabaseProviderFactory, @@ -127,69 +124,19 @@ impl ProviderFactory { ))) } - /// Storage provider for latest block + /// State provider for latest block #[track_caller] pub fn latest(&self) -> ProviderResult { trace!(target: "providers::db", "Returning latest state provider"); Ok(Box::new(LatestStateProvider::new(self.db.tx()?, self.static_file_provider()))) } - /// Storage provider for state at that given block - fn state_provider_by_block_number( - &self, - provider: DatabaseProviderRO, - mut block_number: BlockNumber, - ) -> ProviderResult { - if block_number == provider.best_block_number().unwrap_or_default() && - block_number == provider.last_block_number().unwrap_or_default() - { - return Ok(Box::new(LatestStateProvider::new( - provider.into_tx(), - self.static_file_provider(), - ))) - } - - // +1 as the changeset that we want is the one that was applied after this block. - block_number += 1; - - let account_history_prune_checkpoint = - provider.get_prune_checkpoint(PruneSegment::AccountHistory)?; - let storage_history_prune_checkpoint = - provider.get_prune_checkpoint(PruneSegment::StorageHistory)?; - - let mut state_provider = HistoricalStateProvider::new( - provider.into_tx(), - block_number, - self.static_file_provider(), - ); - - // If we pruned account or storage history, we can't return state on every historical block. - // Instead, we should cap it at the latest prune checkpoint for corresponding prune segment. - if let Some(prune_checkpoint_block_number) = - account_history_prune_checkpoint.and_then(|checkpoint| checkpoint.block_number) - { - state_provider = state_provider.with_lowest_available_account_history_block_number( - prune_checkpoint_block_number + 1, - ); - } - if let Some(prune_checkpoint_block_number) = - storage_history_prune_checkpoint.and_then(|checkpoint| checkpoint.block_number) - { - state_provider = state_provider.with_lowest_available_storage_history_block_number( - prune_checkpoint_block_number + 1, - ); - } - - Ok(Box::new(state_provider)) - } - /// Storage provider for state at that given block pub fn history_by_block_number( &self, block_number: BlockNumber, ) -> ProviderResult { - let provider = self.provider()?; - let state_provider = self.state_provider_by_block_number(provider, block_number)?; + let state_provider = self.provider()?.state_provider_by_block_number(block_number)?; trace!(target: "providers::db", ?block_number, "Returning historical state provider for block number"); Ok(state_provider) } @@ -202,8 +149,8 @@ impl ProviderFactory { .block_number(block_hash)? .ok_or(ProviderError::BlockHashNotFound(block_hash))?; - let state_provider = self.state_provider_by_block_number(provider, block_number)?; - trace!(target: "providers::db", ?block_number, "Returning historical state provider for block hash"); + let state_provider = self.provider()?.state_provider_by_block_number(block_number)?; + trace!(target: "providers::db", ?block_number, %block_hash, "Returning historical state provider for block hash"); Ok(state_provider) } } diff --git a/crates/storage/provider/src/providers/database/provider.rs b/crates/storage/provider/src/providers/database/provider.rs index 67126de87..21aba9fb8 100644 --- a/crates/storage/provider/src/providers/database/provider.rs +++ b/crates/storage/provider/src/providers/database/provider.rs @@ -7,8 +7,9 @@ use crate::{ }, AccountReader, BlockExecutionWriter, BlockHashReader, BlockNumReader, BlockReader, BlockWriter, Chain, EvmEnvProvider, HashingWriter, HeaderProvider, HeaderSyncGap, HeaderSyncGapProvider, - HeaderSyncMode, HistoryWriter, OriginalValuesKnown, ProviderError, PruneCheckpointReader, - PruneCheckpointWriter, StageCheckpointReader, StatsReader, StorageReader, TransactionVariant, + HeaderSyncMode, HistoricalStateProvider, HistoryWriter, LatestStateProvider, + OriginalValuesKnown, ProviderError, PruneCheckpointReader, PruneCheckpointWriter, + StageCheckpointReader, StateProviderBox, StatsReader, StorageReader, TransactionVariant, TransactionsProvider, TransactionsProviderExt, WithdrawalsProvider, }; use itertools::{izip, Itertools}; @@ -164,6 +165,50 @@ impl DatabaseProvider { } } +impl DatabaseProvider { + /// Storage provider for state at that given block + pub fn state_provider_by_block_number( + self, + mut block_number: BlockNumber, + ) -> ProviderResult { + if block_number == self.best_block_number().unwrap_or_default() && + block_number == self.last_block_number().unwrap_or_default() + { + return Ok(Box::new(LatestStateProvider::new(self.tx, self.static_file_provider))) + } + + // +1 as the changeset that we want is the one that was applied after this block. + block_number += 1; + + let account_history_prune_checkpoint = + self.get_prune_checkpoint(PruneSegment::AccountHistory)?; + let storage_history_prune_checkpoint = + self.get_prune_checkpoint(PruneSegment::StorageHistory)?; + + let mut state_provider = + HistoricalStateProvider::new(self.tx, block_number, self.static_file_provider); + + // If we pruned account or storage history, we can't return state on every historical block. + // Instead, we should cap it at the latest prune checkpoint for corresponding prune segment. + if let Some(prune_checkpoint_block_number) = + account_history_prune_checkpoint.and_then(|checkpoint| checkpoint.block_number) + { + state_provider = state_provider.with_lowest_available_account_history_block_number( + prune_checkpoint_block_number + 1, + ); + } + if let Some(prune_checkpoint_block_number) = + storage_history_prune_checkpoint.and_then(|checkpoint| checkpoint.block_number) + { + state_provider = state_provider.with_lowest_available_storage_history_block_number( + prune_checkpoint_block_number + 1, + ); + } + + Ok(Box::new(state_provider)) + } +} + impl DatabaseProvider { #[cfg(any(test, feature = "test-utils"))] /// Inserts an historical block. Used for setting up test environments diff --git a/crates/storage/provider/src/traits/mod.rs b/crates/storage/provider/src/traits/mod.rs index 360fe97c0..1d841b025 100644 --- a/crates/storage/provider/src/traits/mod.rs +++ b/crates/storage/provider/src/traits/mod.rs @@ -36,9 +36,12 @@ pub use receipts::{ReceiptProvider, ReceiptProviderIdExt}; mod state; pub use state::{ BlockchainTreePendingStateProvider, BundleStateDataProvider, StateProvider, StateProviderBox, - StateProviderFactory, StateRootProvider, + StateProviderFactory, }; +mod trie; +pub use trie::StateRootProvider; + mod transactions; pub use transactions::{TransactionsProvider, TransactionsProviderExt}; diff --git a/crates/storage/provider/src/traits/state.rs b/crates/storage/provider/src/traits/state.rs index 5ca51bf8f..3cef4c7bc 100644 --- a/crates/storage/provider/src/traits/state.rs +++ b/crates/storage/provider/src/traits/state.rs @@ -1,13 +1,11 @@ use super::AccountReader; -use crate::{BlockHashReader, BlockIdReader, BundleStateWithReceipts}; +use crate::{BlockHashReader, BlockIdReader, BundleStateWithReceipts, StateRootProvider}; use auto_impl::auto_impl; use reth_interfaces::provider::{ProviderError, ProviderResult}; use reth_primitives::{ trie::AccountProof, Address, BlockHash, BlockId, BlockNumHash, BlockNumber, BlockNumberOrTag, Bytecode, StorageKey, StorageValue, B256, KECCAK_EMPTY, U256, }; -use reth_trie::updates::TrieUpdates; -use revm::db::BundleState; /// Type alias of boxed [StateProvider]. pub type StateProviderBox = Box; @@ -216,7 +214,7 @@ pub trait BlockchainTreePendingStateProvider: Send + Sync { /// * [`BundleStateWithReceipts`] contains all changed of accounts and storage of pending chain /// * block hashes of pending chain and canonical blocks. /// * canonical fork, the block on what pending chain was forked from. -#[auto_impl[Box,&]] +#[auto_impl(&, Box)] pub trait BundleStateDataProvider: Send + Sync { /// Return post state fn state(&self) -> &BundleStateWithReceipts; @@ -227,21 +225,3 @@ pub trait BundleStateDataProvider: Send + Sync { /// Needed to create state provider. fn canonical_fork(&self) -> BlockNumHash; } - -/// A type that can compute the state root of a given post state. -#[auto_impl[Box,&, Arc]] -pub trait StateRootProvider: Send + Sync { - /// Returns the state root of the `BundleState` on top of the current state. - /// - /// NOTE: 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; - - /// 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)>; -} diff --git a/crates/storage/provider/src/traits/trie.rs b/crates/storage/provider/src/traits/trie.rs new file mode 100644 index 000000000..1fa5d780b --- /dev/null +++ b/crates/storage/provider/src/traits/trie.rs @@ -0,0 +1,25 @@ +use auto_impl::auto_impl; +use reth_interfaces::provider::ProviderResult; +use reth_primitives::B256; +use reth_trie::updates::TrieUpdates; +use revm::db::BundleState; + +/// A type that can compute the state root of a given post state. +#[auto_impl(&, Box, Arc)] +pub trait StateRootProvider: Send + Sync { + /// Returns the state root of the `BundleState` on top of the current state. + /// + /// # Note + /// + /// 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; + + /// 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)>; +} diff --git a/crates/trie-parallel/Cargo.toml b/crates/trie-parallel/Cargo.toml index 312a21120..649e08973 100644 --- a/crates/trie-parallel/Cargo.toml +++ b/crates/trie-parallel/Cargo.toml @@ -55,7 +55,7 @@ criterion = { workspace = true, features = ["async_tokio"] } proptest.workspace = true [features] -default = ["metrics"] +default = ["metrics", "async", "parallel"] metrics = ["reth-metrics", "dep:metrics", "reth-trie/metrics"] async = ["reth-tasks/rayon", "tokio/sync", "itertools"] parallel = ["rayon"] diff --git a/crates/trie-parallel/benches/root.rs b/crates/trie-parallel/benches/root.rs index ca03ed758..eba1cdd3d 100644 --- a/crates/trie-parallel/benches/root.rs +++ b/crates/trie-parallel/benches/root.rs @@ -33,7 +33,7 @@ pub fn calculate_state_root(c: &mut Criterion) { provider_rw.commit().unwrap(); } - let view = ConsistentDbView::new(provider_factory.clone()); + let view = ConsistentDbView::new(provider_factory.clone(), None); // state root group.bench_function(BenchmarkId::new("sync root", size), |b| { diff --git a/crates/trie-parallel/src/async_root.rs b/crates/trie-parallel/src/async_root.rs index 450a0c120..68595ed95 100644 --- a/crates/trie-parallel/src/async_root.rs +++ b/crates/trie-parallel/src/async_root.rs @@ -7,10 +7,7 @@ use reth_primitives::{ trie::{HashBuilder, Nibbles, TrieAccount}, B256, }; -use reth_provider::{ - providers::{ConsistentDbView, ConsistentViewError}, - DatabaseProviderFactory, ProviderError, -}; +use reth_provider::{providers::ConsistentDbView, DatabaseProviderFactory, ProviderError}; use reth_tasks::pool::BlockingTaskPool; use reth_trie::{ hashed_cursor::HashedPostStateCursorFactory, @@ -219,9 +216,6 @@ pub enum AsyncStateRootError { /// The hashed address for which channel was closed. hashed_address: B256, }, - /// Consistency error on attempt to create new database provider. - #[error(transparent)] - ConsistentView(#[from] ConsistentViewError), /// Error while calculating storage root. #[error(transparent)] StorageRoot(#[from] StorageRootError), @@ -244,7 +238,7 @@ mod tests { let blocking_pool = BlockingTaskPool::new(ThreadPoolBuilder::default().build().unwrap()); let factory = create_test_provider_factory(); - let consistent_view = ConsistentDbView::new(factory.clone()); + let consistent_view = ConsistentDbView::new(factory.clone(), None); let mut rng = rand::thread_rng(); let mut state = (0..100) diff --git a/crates/trie-parallel/src/parallel_root.rs b/crates/trie-parallel/src/parallel_root.rs index 8c42133c8..9abb8ac2c 100644 --- a/crates/trie-parallel/src/parallel_root.rs +++ b/crates/trie-parallel/src/parallel_root.rs @@ -7,10 +7,7 @@ use reth_primitives::{ trie::{HashBuilder, Nibbles, TrieAccount}, B256, }; -use reth_provider::{ - providers::{ConsistentDbView, ConsistentViewError}, - DatabaseProviderFactory, ProviderError, -}; +use reth_provider::{providers::ConsistentDbView, DatabaseProviderFactory, ProviderError}; use reth_trie::{ hashed_cursor::{HashedCursorFactory, HashedPostStateCursorFactory}, node_iter::{AccountNode, AccountNodeIter}, @@ -195,9 +192,6 @@ where /// Error during parallel state root calculation. #[derive(Error, Debug)] pub enum ParallelStateRootError { - /// Consistency error on attempt to create new database provider. - #[error(transparent)] - ConsistentView(#[from] ConsistentViewError), /// Error while calculating storage root. #[error(transparent)] StorageRoot(#[from] StorageRootError), @@ -206,6 +200,17 @@ pub enum ParallelStateRootError { Provider(#[from] ProviderError), } +impl From for ProviderError { + fn from(error: ParallelStateRootError) -> Self { + match error { + ParallelStateRootError::Provider(error) => error, + ParallelStateRootError::StorageRoot(StorageRootError::DB(error)) => { + ProviderError::Database(error) + } + } + } +} + #[cfg(test)] mod tests { use super::*; @@ -217,7 +222,7 @@ mod tests { #[tokio::test] async fn random_parallel_root() { let factory = create_test_provider_factory(); - let consistent_view = ConsistentDbView::new(factory.clone()); + let consistent_view = ConsistentDbView::new(factory.clone(), None); let mut rng = rand::thread_rng(); let mut state = (0..100)