github/reth
1
1
Fork 0
mirror of https://github.com/paradigmxyz/reth.git synced 2026-04-30 03:01:58 -04:00
Code Issues Packages Projects Releases Wiki Activity

refactor: BlindedPovider rename (#17208)

Browse Source 
Signed-off-by: Aliaksei Misiukevich <taberlick@gmail.com>
Co-authored-by: Alexey Shekhirin <5773434+shekhirin@users.noreply.github.com>
This commit is contained in:
Aliaksei Misiukevich
2025-07-15 14:40:52 +02:00
committed by GitHub
parent fb9f3cce92
commit fe1d2d2425
17 changed files with 230 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -3,7 +3,7 @@
use alloy_primitives::B256;
use reth_trie::{Nibbles, TrieNode};
use reth_trie_sparse::{
blinded::BlindedProvider, errors::SparseTrieResult, LeafLookup, LeafLookupError,
errors::SparseTrieResult, provider::TrieNodeProvider, LeafLookup, LeafLookupError,
SerialSparseTrie, SparseTrieInterface, SparseTrieUpdates, TrieMasks,
};
use reth_trie_sparse_parallel::ParallelSparseTrie;
@@ -77,7 +77,7 @@ impl SparseTrieInterface for ConfiguredSparseTrie {
}
}
fn update_leaf<P: BlindedProvider>(
fn update_leaf<P: TrieNodeProvider>(
&mut self,
full_path: Nibbles,
value: Vec<u8>,
@@ -89,7 +89,7 @@ impl SparseTrieInterface for ConfiguredSparseTrie {
}
}
fn remove_leaf<P: BlindedProvider>(
fn remove_leaf<P: TrieNodeProvider>(
&mut self,
full_path: &Nibbles,
provider: P,

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

@@ -29,7 +29,7 @@ use reth_trie_parallel::{
root::ParallelStateRootError,
};
use reth_trie_sparse::{
blinded::{BlindedProvider, BlindedProviderFactory},
provider::{TrieNodeProvider, TrieNodeProviderFactory},
SerialSparseTrie, SparseTrie, SparseTrieInterface,
};
use reth_trie_sparse_parallel::ParallelSparseTrie;
@@ -329,9 +329,9 @@ where
state_root_tx: mpsc::Sender<Result<StateRootComputeOutcome, ParallelStateRootError>>,
sparse_trie: Option<SparseTrie<A>>,
) where
BPF: BlindedProviderFactory + Clone + Send + Sync + 'static,
BPF::AccountNodeProvider: BlindedProvider + Send + Sync,
BPF::StorageNodeProvider: BlindedProvider + Send + Sync,
BPF: TrieNodeProviderFactory + Clone + Send + Sync + 'static,
BPF::AccountNodeProvider: TrieNodeProvider + Send + Sync,
BPF::StorageNodeProvider: TrieNodeProvider + Send + Sync,
A: SparseTrieInterface + Send + Sync + Default + 'static,
ConfiguredSparseTrie: From<A>,
{
@@ -371,9 +371,9 @@ where
state_root_tx: mpsc::Sender<Result<StateRootComputeOutcome, ParallelStateRootError>>,
is_revealed: bool,
) where
BPF: BlindedProviderFactory + Clone + Send + Sync + 'static,
BPF::AccountNodeProvider: BlindedProvider + Send + Sync,
BPF::StorageNodeProvider: BlindedProvider + Send + Sync,
BPF: TrieNodeProviderFactory + Clone + Send + Sync + 'static,
BPF::AccountNodeProvider: TrieNodeProvider + Send + Sync,
BPF::StorageNodeProvider: TrieNodeProvider + Send + Sync,
{
match configured_trie {
ConfiguredSparseTrie::Serial(boxed_serial) => {
@@ -407,9 +407,9 @@ where
stored_accounts_trie: Option<SparseTrie<ConfiguredSparseTrie>>,
use_parallel_for_new: bool,
) where
BPF: BlindedProviderFactory + Clone + Send + Sync + 'static,
BPF::AccountNodeProvider: BlindedProvider + Send + Sync,
BPF::StorageNodeProvider: BlindedProvider + Send + Sync,
BPF: TrieNodeProviderFactory + Clone + Send + Sync + 'static,
BPF::AccountNodeProvider: TrieNodeProvider + Send + Sync,
BPF::StorageNodeProvider: TrieNodeProvider + Send + Sync,
{
let is_revealed = stored_accounts_trie.as_ref().is_some_and(|trie| trie.is_revealed());
match stored_accounts_trie {

22
crates/engine/tree/src/tree/payload_processor/sparse_trie.rs
View File

@@ -9,8 +9,8 @@ use rayon::iter::{ParallelBridge, ParallelIterator};
use reth_trie::{updates::TrieUpdates, Nibbles};
use reth_trie_parallel::root::ParallelStateRootError;
use reth_trie_sparse::{
blinded::{BlindedProvider, BlindedProviderFactory},
errors::{SparseStateTrieResult, SparseTrieErrorKind},
provider::{TrieNodeProvider, TrieNodeProviderFactory},
SerialSparseTrie, SparseStateTrie, SparseTrie, SparseTrieInterface,
};
use std::{
@@ -22,9 +22,9 @@ use tracing::{debug, trace, trace_span};
/// A task responsible for populating the sparse trie.
pub(super) struct SparseTrieTask<BPF, A = SerialSparseTrie, S = SerialSparseTrie>
where
BPF: BlindedProviderFactory + Send + Sync,
BPF::AccountNodeProvider: BlindedProvider + Send + Sync,
BPF::StorageNodeProvider: BlindedProvider + Send + Sync,
BPF: TrieNodeProviderFactory + Send + Sync,
BPF::AccountNodeProvider: TrieNodeProvider + Send + Sync,
BPF::StorageNodeProvider: TrieNodeProvider + Send + Sync,
{
/// Executor used to spawn subtasks.
#[expect(unused)] // TODO use this for spawning trie tasks
@@ -36,15 +36,15 @@ where
/// It's kept as a field on the struct to prevent blocking on de-allocation in [`Self::run`].
pub(super) trie: SparseStateTrie<A, S>,
pub(super) metrics: MultiProofTaskMetrics,
/// Blinded node provider factory.
/// Trie node provider factory.
blinded_provider_factory: BPF,
}
impl<BPF, A, S> SparseTrieTask<BPF, A, S>
where
BPF: BlindedProviderFactory + Send + Sync + Clone,
BPF::AccountNodeProvider: BlindedProvider + Send + Sync,
BPF::StorageNodeProvider: BlindedProvider + Send + Sync,
BPF: TrieNodeProviderFactory + Send + Sync + Clone,
BPF::AccountNodeProvider: TrieNodeProvider + Send + Sync,
BPF::StorageNodeProvider: TrieNodeProvider + Send + Sync,
A: SparseTrieInterface + Send + Sync + Default,
S: SparseTrieInterface + Send + Sync + Default,
{
@@ -191,9 +191,9 @@ pub(crate) fn update_sparse_trie<BPF, A, S>(
blinded_provider_factory: &BPF,
) -> SparseStateTrieResult<Duration>
where
BPF: BlindedProviderFactory + Send + Sync,
BPF::AccountNodeProvider: BlindedProvider + Send + Sync,
BPF::StorageNodeProvider: BlindedProvider + Send + Sync,
BPF: TrieNodeProviderFactory + Send + Sync,
BPF::AccountNodeProvider: TrieNodeProvider + Send + Sync,
BPF::StorageNodeProvider: TrieNodeProvider + Send + Sync,
A: SparseTrieInterface + Send + Sync + Default,
S: SparseTrieInterface + Send + Sync + Default,
{

8
crates/stateless/src/trie.rs
View File

@@ -9,8 +9,8 @@ use reth_errors::ProviderError;
use reth_revm::state::Bytecode;
use reth_trie_common::{HashedPostState, Nibbles, TRIE_ACCOUNT_RLP_MAX_SIZE};
use reth_trie_sparse::{
blinded::{DefaultBlindedProvider, DefaultBlindedProviderFactory},
errors::SparseStateTrieResult,
provider::{DefaultTrieNodeProvider, DefaultTrieNodeProviderFactory},
SparseStateTrie, SparseTrie, SparseTrieInterface,
};
@@ -175,7 +175,7 @@ fn verify_execution_witness(
witness: &ExecutionWitness,
pre_state_root: B256,
) -> Result<(SparseStateTrie, B256Map<Bytecode>), StatelessValidationError> {
let provider_factory = DefaultBlindedProviderFactory;
let provider_factory = DefaultTrieNodeProviderFactory;
let mut trie = SparseStateTrie::new();
let mut state_witness = B256Map::default();
let mut bytecode = B256Map::default();
@@ -239,8 +239,8 @@ fn calculate_state_root(
// In `verify_execution_witness` a `DefaultBlindedProviderFactory` is used, so we use the same
// again in here.
let provider_factory = DefaultBlindedProviderFactory;
let storage_provider = DefaultBlindedProvider;
let provider_factory = DefaultTrieNodeProviderFactory;
let storage_provider = DefaultTrieNodeProvider;
for (address, storage) in state.storages.into_iter().sorted_unstable_by_key(|(addr, _)| *addr) {
// Take the existing storage trie (or create an empty, “revealed” one)

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

@@ -19,14 +19,14 @@ use reth_provider::{
use reth_trie::{
hashed_cursor::HashedPostStateCursorFactory,
prefix_set::TriePrefixSetsMut,
proof::{ProofBlindedProviderFactory, StorageProof},
proof::{ProofTrieNodeProviderFactory, StorageProof},
trie_cursor::InMemoryTrieCursorFactory,
updates::TrieUpdatesSorted,
DecodedStorageMultiProof, HashedPostStateSorted, Nibbles,
};
use reth_trie_common::prefix_set::{PrefixSet, PrefixSetMut};
use reth_trie_db::{DatabaseHashedCursorFactory, DatabaseTrieCursorFactory};
use reth_trie_sparse::blinded::{BlindedProvider, BlindedProviderFactory, RevealedNode};
use reth_trie_sparse::provider::{RevealedNode, TrieNodeProvider, TrieNodeProviderFactory};
use std::{
collections::VecDeque,
sync::{
@@ -40,7 +40,7 @@ use tokio::runtime::Handle;
use tracing::debug;
type StorageProofResult = Result<DecodedStorageMultiProof, ParallelStateRootError>;
type BlindedNodeResult = Result<Option<RevealedNode>, SparseTrieError>;
type TrieNodeProviderResult = Result<Option<RevealedNode>, SparseTrieError>;
/// A task that manages sending multiproof requests to a number of tasks that have longer-running
/// database transactions
@@ -291,7 +291,7 @@ where
fn blinded_account_node(
self,
path: Nibbles,
result_sender: Sender<BlindedNodeResult>,
result_sender: Sender<TrieNodeProviderResult>,
tx_sender: Sender<ProofTaskMessage<Tx>>,
) {
debug!(
@@ -302,14 +302,14 @@ where
let (trie_cursor_factory, hashed_cursor_factory) = self.create_factories();
let blinded_provider_factory = ProofBlindedProviderFactory::new(
let blinded_provider_factory = ProofTrieNodeProviderFactory::new(
trie_cursor_factory,
hashed_cursor_factory,
self.task_ctx.prefix_sets.clone(),
);
let start = Instant::now();
let result = blinded_provider_factory.account_node_provider().blinded_node(&path);
let result = blinded_provider_factory.account_node_provider().trie_node(&path);
debug!(
target: "trie::proof_task",
?path,
@@ -335,7 +335,7 @@ where
self,
account: B256,
path: Nibbles,
result_sender: Sender<BlindedNodeResult>,
result_sender: Sender<TrieNodeProviderResult>,
tx_sender: Sender<ProofTaskMessage<Tx>>,
) {
debug!(
@@ -347,14 +347,14 @@ where
let (trie_cursor_factory, hashed_cursor_factory) = self.create_factories();
let blinded_provider_factory = ProofBlindedProviderFactory::new(
let blinded_provider_factory = ProofTrieNodeProviderFactory::new(
trie_cursor_factory,
hashed_cursor_factory,
self.task_ctx.prefix_sets.clone(),
);
let start = Instant::now();
let result = blinded_provider_factory.storage_node_provider(account).blinded_node(&path);
let result = blinded_provider_factory.storage_node_provider(account).trie_node(&path);
debug!(
target: "trie::proof_task",
?account,
@@ -449,9 +449,9 @@ pub enum ProofTaskKind {
/// A storage proof request.
StorageProof(StorageProofInput, Sender<StorageProofResult>),
/// A blinded account node request.
BlindedAccountNode(Nibbles, Sender<BlindedNodeResult>),
BlindedAccountNode(Nibbles, Sender<TrieNodeProviderResult>),
/// A blinded storage node request.
BlindedStorageNode(B256, Nibbles, Sender<BlindedNodeResult>),
BlindedStorageNode(B256, Nibbles, Sender<TrieNodeProviderResult>),
}
/// A handle that wraps a single proof task sender that sends a terminate message on `Drop` if the
@@ -498,22 +498,22 @@ impl<Tx> Drop for ProofTaskManagerHandle<Tx> {
}
}
impl<Tx: DbTx> BlindedProviderFactory for ProofTaskManagerHandle<Tx> {
type AccountNodeProvider = ProofTaskBlindedNodeProvider<Tx>;
type StorageNodeProvider = ProofTaskBlindedNodeProvider<Tx>;
impl<Tx: DbTx> TrieNodeProviderFactory for ProofTaskManagerHandle<Tx> {
type AccountNodeProvider = ProofTaskTrieNodeProvider<Tx>;
type StorageNodeProvider = ProofTaskTrieNodeProvider<Tx>;
fn account_node_provider(&self) -> Self::AccountNodeProvider {
ProofTaskBlindedNodeProvider::AccountNode { sender: self.sender.clone() }
ProofTaskTrieNodeProvider::AccountNode { sender: self.sender.clone() }
}
fn storage_node_provider(&self, account: B256) -> Self::StorageNodeProvider {
ProofTaskBlindedNodeProvider::StorageNode { account, sender: self.sender.clone() }
ProofTaskTrieNodeProvider::StorageNode { account, sender: self.sender.clone() }
}
}
/// Blinded node provider for retrieving trie nodes by path.
/// Trie node provider for retrieving trie nodes by path.
#[derive(Debug)]
pub enum ProofTaskBlindedNodeProvider<Tx> {
pub enum ProofTaskTrieNodeProvider<Tx> {
/// Blinded account trie node provider.
AccountNode {
/// Sender to the proof task.
@@ -528,8 +528,8 @@ pub enum ProofTaskBlindedNodeProvider<Tx> {
},
}
impl<Tx: DbTx> BlindedProvider for ProofTaskBlindedNodeProvider<Tx> {
fn blinded_node(&self, path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError> {
impl<Tx: DbTx> TrieNodeProvider for ProofTaskTrieNodeProvider<Tx> {
fn trie_node(&self, path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError> {
let (tx, rx) = channel();
match self {
Self::AccountNode { sender } => {

136
crates/trie/sparse-parallel/src/trie.rs
View File

@@ -12,7 +12,7 @@ use reth_trie_common::{
BranchNodeRef, ExtensionNodeRef, LeafNodeRef, Nibbles, RlpNode, TrieNode, CHILD_INDEX_RANGE,
};
use reth_trie_sparse::{
blinded::{BlindedProvider, RevealedNode},
provider::{RevealedNode, TrieNodeProvider},
LeafLookup, LeafLookupError, RlpNodeStackItem, SparseNode, SparseNodeType, SparseTrieInterface,
SparseTrieUpdates, TrieMasks,
};
@@ -153,7 +153,7 @@ impl SparseTrieInterface for ParallelSparseTrie {
Ok(())
}
fn update_leaf<P: BlindedProvider>(
fn update_leaf<P: TrieNodeProvider>(
&mut self,
full_path: Nibbles,
value: Vec<u8>,
@@ -199,7 +199,7 @@ impl SparseTrieInterface for ParallelSparseTrie {
let subtrie = self.subtrie_for_path_mut(&reveal_path);
if subtrie.nodes.get(&reveal_path).expect("node must exist").is_hash() {
if let Some(RevealedNode { node, tree_mask, hash_mask }) =
provider.blinded_node(&reveal_path)?
provider.trie_node(&reveal_path)?
{
let decoded = TrieNode::decode(&mut &node[..])?;
trace!(
@@ -300,7 +300,7 @@ impl SparseTrieInterface for ParallelSparseTrie {
Ok(())
}
fn remove_leaf<P: BlindedProvider>(
fn remove_leaf<P: TrieNodeProvider>(
&mut self,
full_path: &Nibbles,
provider: P,
@@ -482,7 +482,7 @@ impl SparseTrieInterface for ParallelSparseTrie {
"Retrieving remaining blinded branch child",
);
if let Some(RevealedNode { node, tree_mask, hash_mask }) =
provider.blinded_node(&remaining_child_path)?
provider.trie_node(&remaining_child_path)?
{
let decoded = TrieNode::decode(&mut &node[..])?;
trace!(
@@ -1299,7 +1299,7 @@ impl SparseSubtrie {
&mut self,
full_path: Nibbles,
value: Vec<u8>,
provider: impl BlindedProvider,
provider: impl TrieNodeProvider,
retain_updates: bool,
) -> SparseTrieResult<()> {
debug_assert!(full_path.starts_with(&self.path));
@@ -1320,7 +1320,7 @@ impl SparseSubtrie {
if let Some(reveal_path) = reveal_path {
if self.nodes.get(&reveal_path).expect("node must exist").is_hash() {
if let Some(RevealedNode { node, tree_mask, hash_mask }) =
provider.blinded_node(&reveal_path)?
provider.trie_node(&reveal_path)?
{
let decoded = TrieNode::decode(&mut &node[..])?;
trace!(
@@ -2271,7 +2271,7 @@ mod tests {
};
use reth_trie_db::DatabaseTrieCursorFactory;
use reth_trie_sparse::{
blinded::{BlindedProvider, DefaultBlindedProvider, RevealedNode},
provider::{DefaultTrieNodeProvider, RevealedNode, TrieNodeProvider},
LeafLookup, LeafLookupError, SerialSparseTrie, SparseNode, SparseTrieInterface,
SparseTrieUpdates, TrieMasks,
};
@@ -2286,17 +2286,17 @@ mod tests {
nibbles
}
/// Mock blinded provider for testing that allows pre-setting nodes at specific paths.
/// Mock trie node provider for testing that allows pre-setting nodes at specific paths.
///
/// This provider can be used in tests to simulate blinded nodes that need to be revealed
/// This provider can be used in tests to simulate trie nodes that need to be revealed
/// during trie operations, particularly when collapsing branch nodes during leaf removal.
#[derive(Debug, Clone)]
struct MockBlindedProvider {
struct MockTrieNodeProvider {
/// Mapping from path to revealed node data
nodes: HashMap<Nibbles, RevealedNode, DefaultHashBuilder>,
}
impl MockBlindedProvider {
impl MockTrieNodeProvider {
/// Creates a new empty mock provider
fn new() -> Self {
Self { nodes: HashMap::with_hasher(RandomState::default()) }
@@ -2308,8 +2308,8 @@ mod tests {
}
}
impl BlindedProvider for MockBlindedProvider {
fn blinded_node(&self, path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError> {
impl TrieNodeProvider for MockTrieNodeProvider {
fn trie_node(&self, path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError> {
Ok(self.nodes.get(path).cloned())
}
}
@@ -2395,7 +2395,7 @@ mod tests {
leaves: impl IntoIterator<Item = (Nibbles, Vec<u8>)>,
) {
for (path, value) in leaves {
trie.update_leaf(path, value, DefaultBlindedProvider).unwrap();
trie.update_leaf(path, value, DefaultTrieNodeProvider).unwrap();
}
}
@@ -3270,7 +3270,7 @@ mod tests {
.into_iter(),
);
let provider = MockBlindedProvider::new();
let provider = MockTrieNodeProvider::new();
// Remove the leaf with a full path of 0x537
let leaf_full_path = Nibbles::from_nibbles([0x5, 0x3, 0x7]);
@@ -3330,7 +3330,7 @@ mod tests {
.insert(Nibbles::default(), BranchNodeCompact::new(0b11, 0, 0, vec![], None));
}
let provider = MockBlindedProvider::new();
let provider = MockTrieNodeProvider::new();
// Remove the leaf with a full path of 0x012
let leaf_full_path = Nibbles::from_nibbles([0x0, 0x1, 0x2]);
@@ -3389,7 +3389,7 @@ mod tests {
.into_iter(),
);
let provider = MockBlindedProvider::new();
let provider = MockTrieNodeProvider::new();
// Remove the leaf with a full path of 0x5012
let leaf_full_path = Nibbles::from_nibbles([0x5, 0x0, 0x1, 0x2]);
@@ -3449,7 +3449,7 @@ mod tests {
.into_iter(),
);
let provider = MockBlindedProvider::new();
let provider = MockTrieNodeProvider::new();
// Remove the leaf with a full path of 0x2034
let leaf_full_path = Nibbles::from_nibbles([0x2, 0x0, 0x3, 0x4]);
@@ -3528,7 +3528,7 @@ mod tests {
.into_iter(),
);
let provider = MockBlindedProvider::new();
let provider = MockTrieNodeProvider::new();
// Verify initial state - the lower subtrie's path should be 0x123
let lower_subtrie_root_path = Nibbles::from_nibbles([0x1, 0x2, 0x3]);
@@ -3586,7 +3586,7 @@ mod tests {
);
// Create a mock provider that will reveal the blinded leaf
let mut provider = MockBlindedProvider::new();
let mut provider = MockTrieNodeProvider::new();
let revealed_leaf = create_leaf_node([0x3, 0x4], 42);
let mut encoded = Vec::new();
revealed_leaf.encode(&mut encoded);
@@ -3627,7 +3627,7 @@ mod tests {
SparseNode::new_leaf(Nibbles::from_nibbles([0x1, 0x2, 0x3])),
)));
let provider = MockBlindedProvider::new();
let provider = MockTrieNodeProvider::new();
// Remove the leaf with a full key of 0x123
let leaf_full_path = Nibbles::from_nibbles([0x1, 0x2, 0x3]);
@@ -3716,7 +3716,7 @@ mod tests {
.into_iter(),
);
let provider = MockBlindedProvider::new();
let provider = MockTrieNodeProvider::new();
// Remove a leaf which does not exist; this should have no effect.
trie.remove_leaf(&Nibbles::from_nibbles([0x0, 0x1, 0x2, 0x3, 0x4, 0xF]), &provider)
@@ -3942,7 +3942,7 @@ mod tests {
paths.clone(),
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::default().with_updates(true);
for path in &paths {
sparse.update_leaf(*path, value_encoded(), &provider).unwrap();
@@ -4057,7 +4057,7 @@ mod tests {
#[test]
fn sparse_trie_remove_leaf() {
let ctx = ParallelSparseTrieTestContext;
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::default();
let value = alloy_rlp::encode_fixed_size(&U256::ZERO).to_vec();
@@ -4325,7 +4325,7 @@ mod tests {
TrieMask::new(0b11),
));
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::from_root(
branch.clone(),
TrieMasks { hash_mask: Some(TrieMask::new(0b01)), tree_mask: None },
@@ -4370,7 +4370,7 @@ mod tests {
TrieMask::new(0b11),
));
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::from_root(
branch.clone(),
TrieMasks { hash_mask: Some(TrieMask::new(0b01)), tree_mask: None },
@@ -4410,7 +4410,7 @@ mod tests {
fn test(updates: Vec<(BTreeMap<Nibbles, Account>, BTreeSet<Nibbles>)>) {
{
let mut state = BTreeMap::default();
let default_provider = DefaultBlindedProvider;
let default_provider = DefaultTrieNodeProvider;
let provider_factory = create_test_provider_factory();
let mut sparse = ParallelSparseTrie::default().with_updates(true);
@@ -4553,7 +4553,7 @@ mod tests {
const KEY_NIBBLES_LEN: usize = 3;
fn test(updates: Vec<(BTreeMap<Nibbles, Account>, BTreeSet<Nibbles>)>) {
let default_provider = DefaultBlindedProvider;
let default_provider = DefaultTrieNodeProvider;
let mut serial = SerialSparseTrie::default().with_updates(true);
let mut parallel = ParallelSparseTrie::default().with_updates(true);
@@ -4649,7 +4649,7 @@ mod tests {
#[test]
fn sparse_trie_two_leaves_at_lower_roots() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut trie = ParallelSparseTrie::default().with_updates(true);
let key_50 = Nibbles::unpack(hex!(
"0x5000000000000000000000000000000000000000000000000000000000000000"
@@ -4708,7 +4708,7 @@ mod tests {
[Nibbles::default()],
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::from_root(
TrieNode::decode(&mut &hash_builder_proof_nodes.nodes_sorted()[0].1[..]).unwrap(),
TrieMasks {
@@ -4818,7 +4818,7 @@ mod tests {
[Nibbles::default()],
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::from_root(
TrieNode::decode(&mut &hash_builder_proof_nodes.nodes_sorted()[0].1[..]).unwrap(),
TrieMasks {
@@ -4921,7 +4921,7 @@ mod tests {
[Nibbles::default()],
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::from_root(
TrieNode::decode(&mut &hash_builder_proof_nodes.nodes_sorted()[0].1[..]).unwrap(),
TrieMasks {
@@ -5002,7 +5002,7 @@ mod tests {
// First add leaf 0x1345 - this should create a leaf in upper trie at 0x
let (leaf1_path, value1) = ctx.create_test_leaf([0x1, 0x3, 0x4, 0x5], 1);
trie.update_leaf(leaf1_path, value1.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf1_path, value1.clone(), DefaultTrieNodeProvider).unwrap();
// Verify upper trie has a leaf at the root with key 1345
ctx.assert_upper_subtrie(&trie)
@@ -5011,7 +5011,7 @@ mod tests {
// Add leaf 0x1234 - this should go first in the upper subtrie
let (leaf2_path, value2) = ctx.create_test_leaf([0x1, 0x2, 0x3, 0x4], 2);
trie.update_leaf(leaf2_path, value2.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf2_path, value2.clone(), DefaultTrieNodeProvider).unwrap();
// Upper trie should now have a branch at 0x1
ctx.assert_upper_subtrie(&trie)
@@ -5021,7 +5021,7 @@ mod tests {
// Add leaf 0x1245 - this should cause a branch and create the 0x12 subtrie
let (leaf3_path, value3) = ctx.create_test_leaf([0x1, 0x2, 0x4, 0x5], 3);
trie.update_leaf(leaf3_path, value3.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf3_path, value3.clone(), DefaultTrieNodeProvider).unwrap();
// Verify lower subtrie at 0x12 exists with correct structure
ctx.assert_subtrie(&trie, Nibbles::from_nibbles([0x1, 0x2]))
@@ -5033,7 +5033,7 @@ mod tests {
// Add leaf 0x1334 - this should create another lower subtrie
let (leaf4_path, value4) = ctx.create_test_leaf([0x1, 0x3, 0x3, 0x4], 4);
trie.update_leaf(leaf4_path, value4.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf4_path, value4.clone(), DefaultTrieNodeProvider).unwrap();
// Verify lower subtrie at 0x13 exists with correct values
ctx.assert_subtrie(&trie, Nibbles::from_nibbles([0x1, 0x3]))
@@ -5077,7 +5077,7 @@ mod tests {
// First insert a leaf that ends exactly at the boundary (2 nibbles)
let (first_leaf_path, first_value) = ctx.create_test_leaf([0x1, 0x2, 0x2, 0x4], 1);
trie.update_leaf(first_leaf_path, first_value.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(first_leaf_path, first_value.clone(), DefaultTrieNodeProvider).unwrap();
// In an empty trie, the first leaf becomes the root, regardless of path length
ctx.assert_upper_subtrie(&trie)
@@ -5087,7 +5087,7 @@ mod tests {
// Now insert another leaf that shares the same 2-nibble prefix
let (second_leaf_path, second_value) = ctx.create_test_leaf([0x1, 0x2, 0x3, 0x4], 2);
trie.update_leaf(second_leaf_path, second_value.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(second_leaf_path, second_value.clone(), DefaultTrieNodeProvider).unwrap();
// Now both leaves should be in a lower subtrie at index [0x1, 0x2]
ctx.assert_subtrie(&trie, Nibbles::from_nibbles([0x1, 0x2]))
@@ -5150,7 +5150,7 @@ mod tests {
let updated_path = Nibbles::from_nibbles([0x1, 0x2, 0x3, 0x4]);
let (_, updated_value) = ctx.create_test_leaf([0x1, 0x2, 0x3, 0x4], 100);
trie.update_leaf(updated_path, updated_value.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(updated_path, updated_value.clone(), DefaultTrieNodeProvider).unwrap();
// Verify the subtrie structure is maintained and value is updated
// The branch structure should remain the same and all values should be present
@@ -5164,7 +5164,7 @@ mod tests {
// Add a new leaf that extends an existing branch
let (new_leaf_path, new_leaf_value) = ctx.create_test_leaf([0x1, 0x2, 0x3, 0x6], 200);
trie.update_leaf(new_leaf_path, new_leaf_value.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(new_leaf_path, new_leaf_value.clone(), DefaultTrieNodeProvider).unwrap();
// Verify the branch at [0x1, 0x2, 0x3] now has an additional child
ctx.assert_subtrie(&trie, Nibbles::from_nibbles([0x1, 0x2]))
@@ -5507,7 +5507,7 @@ mod tests {
// └── 0xAB2: Hash
// Create a mock provider that will provide the hash node
let mut provider = MockBlindedProvider::new();
let mut provider = MockTrieNodeProvider::new();
// Create revealed branch which will get revealed and add it to the mock provider
let child_hashes = [
@@ -5568,8 +5568,8 @@ mod tests {
let (leaf1_path, value1) = ctx.create_test_leaf([0xA, 0xB, 0xC, 0xD, 0xE, 0xF], 1);
let (leaf2_path, value2) = ctx.create_test_leaf([0xA, 0xB, 0xD, 0xE, 0xF, 0x0], 2);
trie.update_leaf(leaf1_path, value1.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf2_path, value2.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf1_path, value1.clone(), DefaultTrieNodeProvider).unwrap();
trie.update_leaf(leaf2_path, value2.clone(), DefaultTrieNodeProvider).unwrap();
// Verify upper trie structure
ctx.assert_upper_subtrie(&trie)
@@ -5625,9 +5625,9 @@ mod tests {
let (leaf2_path, value2) = ctx.create_test_leaf([0x2, 0x3, 0x4, 0x5], 2);
let (leaf3_path, value3) = ctx.create_test_leaf([0x2, 0x3, 0x5, 0x6], 3);
trie.update_leaf(leaf1_path, value1, DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf2_path, value2, DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf3_path, value3, DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf1_path, value1, DefaultTrieNodeProvider).unwrap();
trie.update_leaf(leaf2_path, value2, DefaultTrieNodeProvider).unwrap();
trie.update_leaf(leaf3_path, value3, DefaultTrieNodeProvider).unwrap();
// Verify initial structure has branch at root
ctx.assert_upper_subtrie(&trie).has_branch(&Nibbles::default(), &[0x1, 0x2]);
@@ -5641,9 +5641,9 @@ mod tests {
// Clear and add new leaves
let mut trie =
ParallelSparseTrie::from_root(TrieNode::EmptyRoot, TrieMasks::none(), true).unwrap();
trie.update_leaf(new_leaf1_path, new_value1.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(new_leaf2_path, new_value2.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(new_leaf3_path, new_value3.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(new_leaf1_path, new_value1.clone(), DefaultTrieNodeProvider).unwrap();
trie.update_leaf(new_leaf2_path, new_value2.clone(), DefaultTrieNodeProvider).unwrap();
trie.update_leaf(new_leaf3_path, new_value3.clone(), DefaultTrieNodeProvider).unwrap();
// Verify new structure has extension
ctx.assert_upper_subtrie(&trie)
@@ -5688,9 +5688,9 @@ mod tests {
let (leaf2_path, value2) = ctx.create_test_leaf([0x2, 0x3, 0x4, 0x5], 2);
let (leaf3_path, value3) = ctx.create_test_leaf([0x2, 0x3, 0x5, 0x6], 3);
trie.update_leaf(leaf1_path, value1, DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf2_path, value2.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf3_path, value3.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf1_path, value1, DefaultTrieNodeProvider).unwrap();
trie.update_leaf(leaf2_path, value2.clone(), DefaultTrieNodeProvider).unwrap();
trie.update_leaf(leaf3_path, value3.clone(), DefaultTrieNodeProvider).unwrap();
// Verify upper trie structure
ctx.assert_upper_subtrie(&trie)
@@ -5749,7 +5749,7 @@ mod tests {
// Step 1: Add first leaf - initially stored as leaf in upper trie
let (leaf1_path, value1) = ctx.create_test_leaf([0x1, 0x2, 0x3, 0x4, 0x5], 1);
trie.update_leaf(leaf1_path, value1.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf1_path, value1.clone(), DefaultTrieNodeProvider).unwrap();
// Verify leaf node in upper trie (optimized single-leaf case)
ctx.assert_upper_subtrie(&trie)
@@ -5758,7 +5758,7 @@ mod tests {
// Step 2: Add leaf at 0x12346 - creates branch at 0x1234
let (leaf2_path, value2) = ctx.create_test_leaf([0x1, 0x2, 0x3, 0x4, 0x6], 2);
trie.update_leaf(leaf2_path, value2.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf2_path, value2.clone(), DefaultTrieNodeProvider).unwrap();
// Verify extension now goes to 0x1234
ctx.assert_upper_subtrie(&trie)
@@ -5776,7 +5776,7 @@ mod tests {
// Step 3: Add leaf at 0x1235 - creates branch at 0x123
let (leaf3_path, value3) = ctx.create_test_leaf([0x1, 0x2, 0x3, 0x5], 3);
trie.update_leaf(leaf3_path, value3.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf3_path, value3.clone(), DefaultTrieNodeProvider).unwrap();
// Verify extension now goes to 0x123
ctx.assert_upper_subtrie(&trie)
@@ -5795,7 +5795,7 @@ mod tests {
// Step 4: Add leaf at 0x124 - creates branch at 0x12 (subtrie root)
let (leaf4_path, value4) = ctx.create_test_leaf([0x1, 0x2, 0x4], 4);
trie.update_leaf(leaf4_path, value4.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf4_path, value4.clone(), DefaultTrieNodeProvider).unwrap();
// Verify extension now goes to 0x12
ctx.assert_upper_subtrie(&trie)
@@ -5841,8 +5841,8 @@ mod tests {
let (leaf1_path, value1) = ctx.create_test_leaf(&path1_nibbles, 1);
let (leaf2_path, value2) = ctx.create_test_leaf(&path2_nibbles, 2);
trie.update_leaf(leaf1_path, value1.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf2_path, value2.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf1_path, value1.clone(), DefaultTrieNodeProvider).unwrap();
trie.update_leaf(leaf2_path, value2.clone(), DefaultTrieNodeProvider).unwrap();
// The common prefix of 63 F's will create a very long extension
let extension_key = vec![0xF; 63];
@@ -5965,7 +5965,7 @@ mod tests {
218, 223, 145, 158, 225, 240, 227, 203, 155, 98, 211, 244, 176, 44,
];
trie.update_leaf(leaf_full_path, leaf_new_value.clone(), DefaultBlindedProvider).unwrap();
trie.update_leaf(leaf_full_path, leaf_new_value.clone(), DefaultTrieNodeProvider).unwrap();
// Sanity checks before calculating the root
assert_eq!(
@@ -5983,7 +5983,7 @@ mod tests {
#[test]
fn find_leaf_existing_leaf() {
// Create a simple trie with one leaf
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::default();
let path = Nibbles::from_nibbles([0x1, 0x2, 0x3]);
let value = b"test_value".to_vec();
@@ -6002,7 +6002,7 @@ mod tests {
#[test]
fn find_leaf_value_mismatch() {
// Create a simple trie with one leaf
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::default();
let path = Nibbles::from_nibbles([0x1, 0x2, 0x3]);
let value = b"test_value".to_vec();
@@ -6040,7 +6040,7 @@ mod tests {
#[test]
fn find_leaf_exists_no_value_check() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::default();
let path = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]);
sparse.update_leaf(path, encode_account_value(0), &provider).unwrap();
@@ -6051,7 +6051,7 @@ mod tests {
#[test]
fn find_leaf_exists_with_value_check_ok() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::default();
let path = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]);
let value = encode_account_value(0);
@@ -6063,7 +6063,7 @@ mod tests {
#[test]
fn find_leaf_exclusion_branch_divergence() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::default();
let path1 = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]); // Creates branch at 0x12
let path2 = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x5, 0x6]); // Belongs to same branch
@@ -6078,7 +6078,7 @@ mod tests {
#[test]
fn find_leaf_exclusion_extension_divergence() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::default();
// This will create an extension node at root with key 0x12
let path1 = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4, 0x5, 0x6]);
@@ -6093,7 +6093,7 @@ mod tests {
#[test]
fn find_leaf_exclusion_leaf_divergence() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::default();
let existing_leaf_path = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]);
let search_path = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4, 0x5, 0x6]);
@@ -6106,7 +6106,7 @@ mod tests {
#[test]
fn find_leaf_exclusion_path_ends_at_branch() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = ParallelSparseTrie::default();
let path1 = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]); // Creates branch at 0x12
let path2 = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x5, 0x6]);

4
crates/trie/sparse/benches/rlp_node.rs
View File

@@ -7,7 +7,7 @@ use proptest::{prelude::*, test_runner::TestRunner};
use rand::{seq::IteratorRandom, Rng};
use reth_testing_utils::generators;
use reth_trie::Nibbles;
use reth_trie_sparse::{blinded::DefaultBlindedProvider, SerialSparseTrie, SparseTrieInterface};
use reth_trie_sparse::{provider::DefaultTrieNodeProvider, SerialSparseTrie, SparseTrieInterface};
fn update_rlp_node_level(c: &mut Criterion) {
let mut rng = generators::rng();
@@ -22,7 +22,7 @@ fn update_rlp_node_level(c: &mut Criterion) {
.current();
// Create a sparse trie with `size` leaves
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
for (key, value) in &state {
sparse

6
crates/trie/sparse/benches/root.rs
View File

@@ -13,7 +13,7 @@ use reth_trie::{
HashedStorage,
};
use reth_trie_common::{HashBuilder, Nibbles};
use reth_trie_sparse::{blinded::DefaultBlindedProvider, SerialSparseTrie, SparseTrie};
use reth_trie_sparse::{provider::DefaultTrieNodeProvider, SerialSparseTrie, SparseTrie};
fn calculate_root_from_leaves(c: &mut Criterion) {
let mut group = c.benchmark_group("calculate root from leaves");
@@ -40,7 +40,7 @@ fn calculate_root_from_leaves(c: &mut Criterion) {
});
// sparse trie
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
group.bench_function(BenchmarkId::new("sparse trie", size), |b| {
b.iter_with_setup(SparseTrie::<SerialSparseTrie>::revealed_empty, |mut sparse| {
for (key, value) in &state {
@@ -179,7 +179,7 @@ fn calculate_root_from_leaves_repeated(c: &mut Criterion) {
});
// sparse trie
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let benchmark_id = BenchmarkId::new(
"sparse trie",
format!(

6
crates/trie/sparse/benches/update.rs
View File

@@ -5,7 +5,7 @@ use criterion::{criterion_group, criterion_main, BatchSize, BenchmarkId, Criteri
use proptest::{prelude::*, strategy::ValueTree};
use rand::seq::IteratorRandom;
use reth_trie_common::Nibbles;
use reth_trie_sparse::{blinded::DefaultBlindedProvider, SerialSparseTrie, SparseTrie};
use reth_trie_sparse::{provider::DefaultTrieNodeProvider, SerialSparseTrie, SparseTrie};
const LEAF_COUNTS: [usize; 2] = [1_000, 5_000];
@@ -16,7 +16,7 @@ fn update_leaf(c: &mut Criterion) {
group.bench_function(BenchmarkId::from_parameter(leaf_count), |b| {
let leaves = generate_leaves(leaf_count);
// Start with an empty trie
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
b.iter_batched(
|| {
@@ -60,7 +60,7 @@ fn remove_leaf(c: &mut Criterion) {
group.bench_function(BenchmarkId::from_parameter(leaf_count), |b| {
let leaves = generate_leaves(leaf_count);
// Start with an empty trie
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
b.iter_batched(
|| {

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

@@ -14,7 +14,7 @@ pub use trie::*;
mod traits;
pub use traits::*;
pub mod blinded;
pub mod provider;
#[cfg(feature = "metrics")]
mod metrics;

38
crates/trie/sparse/src/blinded.rs → crates/trie/sparse/src/provider.rs
View File

@@ -4,13 +4,13 @@ use alloy_primitives::{Bytes, B256};
use reth_execution_errors::SparseTrieError;
use reth_trie_common::{Nibbles, TrieMask};
/// Factory for instantiating blinded node providers.
/// Factory for instantiating trie node providers.
#[auto_impl::auto_impl(&)]
pub trait BlindedProviderFactory {
pub trait TrieNodeProviderFactory {
/// Type capable of fetching blinded account nodes.
type AccountNodeProvider: BlindedProvider;
type AccountNodeProvider: TrieNodeProvider;
/// Type capable of fetching blinded storage nodes.
type StorageNodeProvider: BlindedProvider;
type StorageNodeProvider: TrieNodeProvider;
/// Returns blinded account node provider.
fn account_node_provider(&self) -> Self::AccountNodeProvider;
@@ -30,36 +30,36 @@ pub struct RevealedNode {
pub hash_mask: Option<TrieMask>,
}
/// Trie node provider for retrieving blinded nodes.
/// Trie node provider for retrieving trie nodes.
#[auto_impl::auto_impl(&)]
pub trait BlindedProvider {
/// Retrieve blinded node by path.
fn blinded_node(&self, path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError>;
pub trait TrieNodeProvider {
/// Retrieve trie node by path.
fn trie_node(&self, path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError>;
}
/// Default blinded node provider factory that creates [`DefaultBlindedProvider`].
/// Default trie node provider factory that creates [`DefaultTrieNodeProviderFactory`].
#[derive(PartialEq, Eq, Clone, Default, Debug)]
pub struct DefaultBlindedProviderFactory;
pub struct DefaultTrieNodeProviderFactory;
impl BlindedProviderFactory for DefaultBlindedProviderFactory {
type AccountNodeProvider = DefaultBlindedProvider;
type StorageNodeProvider = DefaultBlindedProvider;
impl TrieNodeProviderFactory for DefaultTrieNodeProviderFactory {
type AccountNodeProvider = DefaultTrieNodeProvider;
type StorageNodeProvider = DefaultTrieNodeProvider;
fn account_node_provider(&self) -> Self::AccountNodeProvider {
DefaultBlindedProvider
DefaultTrieNodeProvider
}
fn storage_node_provider(&self, _account: B256) -> Self::StorageNodeProvider {
DefaultBlindedProvider
DefaultTrieNodeProvider
}
}
/// Default blinded node provider that always returns `Ok(None)`.
/// Default trie node provider that always returns `Ok(None)`.
#[derive(PartialEq, Eq, Clone, Default, Debug)]
pub struct DefaultBlindedProvider;
pub struct DefaultTrieNodeProvider;
impl BlindedProvider for DefaultBlindedProvider {
fn blinded_node(&self, _path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError> {
impl TrieNodeProvider for DefaultTrieNodeProvider {
fn trie_node(&self, _path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError> {
Ok(None)
}
}

32
crates/trie/sparse/src/state.rs
View File

@@ -1,5 +1,5 @@
use crate::{
blinded::{BlindedProvider, BlindedProviderFactory},
provider::{TrieNodeProvider, TrieNodeProviderFactory},
traits::SparseTrieInterface,
SerialSparseTrie, SparseTrie, TrieMasks,
};
@@ -605,16 +605,16 @@ where
/// Returns mutable reference to the revealed account sparse trie.
///
/// If the trie is not revealed yet, its root will be revealed using the blinded node provider.
/// If the trie is not revealed yet, its root will be revealed using the trie node provider.
fn revealed_trie_mut(
&mut self,
provider_factory: impl BlindedProviderFactory,
provider_factory: impl TrieNodeProviderFactory,
) -> SparseStateTrieResult<&mut A> {
match self.state {
SparseTrie::Blind(_) => {
let (root_node, hash_mask, tree_mask) = provider_factory
.account_node_provider()
.blinded_node(&Nibbles::default())?
.trie_node(&Nibbles::default())?
.map(|node| {
TrieNode::decode(&mut &node.node[..])
.map(|decoded| (decoded, node.hash_mask, node.tree_mask))
@@ -634,7 +634,7 @@ where
/// If the trie has not been revealed, this function reveals the root node and returns its hash.
pub fn root(
&mut self,
provider_factory: impl BlindedProviderFactory,
provider_factory: impl TrieNodeProviderFactory,
) -> SparseStateTrieResult<B256> {
// record revealed node metrics
#[cfg(feature = "metrics")]
@@ -646,7 +646,7 @@ where
/// Returns sparse trie root and trie updates if the trie has been revealed.
pub fn root_with_updates(
&mut self,
provider_factory: impl BlindedProviderFactory,
provider_factory: impl TrieNodeProviderFactory,
) -> SparseStateTrieResult<(B256, TrieUpdates)> {
// record revealed node metrics
#[cfg(feature = "metrics")]
@@ -704,7 +704,7 @@ where
&mut self,
path: Nibbles,
value: Vec<u8>,
provider_factory: impl BlindedProviderFactory,
provider_factory: impl TrieNodeProviderFactory,
) -> SparseStateTrieResult<()> {
if !self.revealed_account_paths.contains(&path) {
self.revealed_account_paths.insert(path);
@@ -721,7 +721,7 @@ where
address: B256,
slot: Nibbles,
value: Vec<u8>,
provider_factory: impl BlindedProviderFactory,
provider_factory: impl TrieNodeProviderFactory,
) -> SparseStateTrieResult<()> {
if !self.revealed_storage_paths.get(&address).is_some_and(|slots| slots.contains(&slot)) {
self.revealed_storage_paths.entry(address).or_default().insert(slot);
@@ -742,7 +742,7 @@ where
&mut self,
address: B256,
account: Account,
provider_factory: impl BlindedProviderFactory,
provider_factory: impl TrieNodeProviderFactory,
) -> SparseStateTrieResult<()> {
let nibbles = Nibbles::unpack(address);
@@ -783,7 +783,7 @@ where
pub fn update_account_storage_root(
&mut self,
address: B256,
provider_factory: impl BlindedProviderFactory,
provider_factory: impl TrieNodeProviderFactory,
) -> SparseStateTrieResult<()> {
if !self.is_account_revealed(address) {
return Err(SparseTrieErrorKind::Blind.into())
@@ -831,7 +831,7 @@ where
pub fn remove_account_leaf(
&mut self,
path: &Nibbles,
provider_factory: impl BlindedProviderFactory,
provider_factory: impl TrieNodeProviderFactory,
) -> SparseStateTrieResult<()> {
let provider = provider_factory.account_node_provider();
self.state.remove_leaf(path, provider)?;
@@ -843,7 +843,7 @@ where
&mut self,
address: B256,
slot: &Nibbles,
provider_factory: impl BlindedProviderFactory,
provider_factory: impl TrieNodeProviderFactory,
) -> SparseStateTrieResult<()> {
let storage_trie = self.storages.get_mut(&address).ok_or(SparseTrieErrorKind::Blind)?;
@@ -905,7 +905,7 @@ fn filter_revealed_nodes(
#[cfg(test)]
mod tests {
use super::*;
use crate::blinded::DefaultBlindedProviderFactory;
use crate::provider::DefaultTrieNodeProviderFactory;
use alloy_primitives::{
b256,
map::{HashMap, HashSet},
@@ -982,7 +982,7 @@ mod tests {
#[test]
fn reveal_account_path_twice() {
let provider_factory = DefaultBlindedProviderFactory;
let provider_factory = DefaultTrieNodeProviderFactory;
let mut sparse = SparseStateTrie::<SerialSparseTrie>::default();
let leaf_value = alloy_rlp::encode(TrieAccount::default());
@@ -1054,7 +1054,7 @@ mod tests {
#[test]
fn reveal_storage_path_twice() {
let provider_factory = DefaultBlindedProviderFactory;
let provider_factory = DefaultTrieNodeProviderFactory;
let mut sparse = SparseStateTrie::<SerialSparseTrie>::default();
let leaf_value = alloy_rlp::encode(TrieAccount::default());
@@ -1186,7 +1186,7 @@ mod tests {
let root = hash_builder.root();
let proof_nodes = hash_builder.take_proof_nodes();
let provider_factory = DefaultBlindedProviderFactory;
let provider_factory = DefaultTrieNodeProviderFactory;
let mut sparse = SparseStateTrie::<SerialSparseTrie>::default().with_updates(true);
sparse
.reveal_decoded_multiproof(

10
crates/trie/sparse/src/traits.rs
View File

@@ -11,7 +11,7 @@ use alloy_trie::{BranchNodeCompact, TrieMask};
use reth_execution_errors::SparseTrieResult;
use reth_trie_common::{Nibbles, TrieNode};
use crate::blinded::BlindedProvider;
use crate::provider::TrieNodeProvider;
/// Trait defining common operations for revealed sparse trie implementations.
///
@@ -94,12 +94,12 @@ pub trait SparseTrieInterface: Sized + Debug + Send + Sync {
///
/// * `full_path` - The full path to the leaf
/// * `value` - The new value for the leaf
/// * `provider` - The blinded provider for resolving missing nodes
/// * `provider` - The trie provider for resolving missing nodes
///
/// # Returns
///
/// `Ok(())` if successful, or an error if the update failed.
fn update_leaf<P: BlindedProvider>(
fn update_leaf<P: TrieNodeProvider>(
&mut self,
full_path: Nibbles,
value: Vec<u8>,
@@ -114,12 +114,12 @@ pub trait SparseTrieInterface: Sized + Debug + Send + Sync {
/// # Arguments
///
/// * `full_path` - The full path to the leaf to remove
/// * `provider` - The blinded provider for resolving missing nodes
/// * `provider` - The trie node provider for resolving missing nodes
///
/// # Returns
///
/// `Ok(())` if successful, or an error if the removal failed.
fn remove_leaf<P: BlindedProvider>(
fn remove_leaf<P: TrieNodeProvider>(
&mut self,
full_path: &Nibbles,
provider: P,

78
crates/trie/sparse/src/trie.rs
View File

@@ -1,5 +1,5 @@
use crate::{
blinded::{BlindedProvider, RevealedNode},
provider::{RevealedNode, TrieNodeProvider},
LeafLookup, LeafLookupError, SparseTrieInterface, SparseTrieUpdates, TrieMasks,
};
use alloc::{
@@ -71,7 +71,7 @@ impl<T: SparseTrieInterface + Default> SparseTrie<T> {
/// # Examples
///
/// ```
/// use reth_trie_sparse::{blinded::DefaultBlindedProvider, SerialSparseTrie, SparseTrie};
/// use reth_trie_sparse::{provider::DefaultTrieNodeProvider, SerialSparseTrie, SparseTrie};
///
/// let trie = SparseTrie::<SerialSparseTrie>::revealed_empty();
/// assert!(!trie.is_blind());
@@ -120,7 +120,7 @@ impl<T: SparseTrieInterface> SparseTrie<T> {
/// # Examples
///
/// ```
/// use reth_trie_sparse::{blinded::DefaultBlindedProvider, SerialSparseTrie, SparseTrie};
/// use reth_trie_sparse::{provider::DefaultTrieNodeProvider, SerialSparseTrie, SparseTrie};
///
/// let trie = SparseTrie::<SerialSparseTrie>::blind();
/// assert!(trie.is_blind());
@@ -226,7 +226,7 @@ impl<T: SparseTrieInterface> SparseTrie<T> {
&mut self,
path: Nibbles,
value: Vec<u8>,
provider: impl BlindedProvider,
provider: impl TrieNodeProvider,
) -> SparseTrieResult<()> {
let revealed = self.as_revealed_mut().ok_or(SparseTrieErrorKind::Blind)?;
revealed.update_leaf(path, value, provider)?;
@@ -241,7 +241,7 @@ impl<T: SparseTrieInterface> SparseTrie<T> {
pub fn remove_leaf(
&mut self,
path: &Nibbles,
provider: impl BlindedProvider,
provider: impl TrieNodeProvider,
) -> SparseTrieResult<()> {
let revealed = self.as_revealed_mut().ok_or(SparseTrieErrorKind::Blind)?;
revealed.remove_leaf(path, provider)?;
@@ -556,7 +556,7 @@ impl SparseTrieInterface for SerialSparseTrie {
Ok(())
}
fn update_leaf<P: BlindedProvider>(
fn update_leaf<P: TrieNodeProvider>(
&mut self,
full_path: Nibbles,
value: Vec<u8>,
@@ -629,7 +629,7 @@ impl SparseTrieInterface for SerialSparseTrie {
// Check if the extension node child is a hash that needs to be revealed
if self.nodes.get(&current).unwrap().is_hash() {
if let Some(RevealedNode { node, tree_mask, hash_mask }) =
provider.blinded_node(&current)?
provider.trie_node(&current)?
{
let decoded = TrieNode::decode(&mut &node[..])?;
trace!(
@@ -687,7 +687,7 @@ impl SparseTrieInterface for SerialSparseTrie {
Ok(())
}
fn remove_leaf<P: BlindedProvider>(
fn remove_leaf<P: TrieNodeProvider>(
&mut self,
full_path: &Nibbles,
provider: P,
@@ -797,7 +797,7 @@ impl SparseTrieInterface for SerialSparseTrie {
if self.nodes.get(&child_path).unwrap().is_hash() {
trace!(target: "trie::sparse", ?child_path, "Retrieving remaining blinded branch child");
if let Some(RevealedNode { node, tree_mask, hash_mask }) =
provider.blinded_node(&child_path)?
provider.trie_node(&child_path)?
{
let decoded = TrieNode::decode(&mut &node[..])?;
trace!(
@@ -1912,7 +1912,7 @@ impl SparseTrieUpdates {
#[cfg(test)]
mod find_leaf_tests {
use super::*;
use crate::blinded::DefaultBlindedProvider;
use crate::provider::DefaultTrieNodeProvider;
use alloy_primitives::map::foldhash::fast::RandomState;
// Assuming this exists
use alloy_rlp::Encodable;
@@ -1935,7 +1935,7 @@ mod find_leaf_tests {
#[test]
fn find_leaf_existing_leaf() {
// Create a simple trie with one leaf
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
let path = Nibbles::from_nibbles([0x1, 0x2, 0x3]);
let value = b"test_value".to_vec();
@@ -1954,7 +1954,7 @@ mod find_leaf_tests {
#[test]
fn find_leaf_value_mismatch() {
// Create a simple trie with one leaf
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
let path = Nibbles::from_nibbles([0x1, 0x2, 0x3]);
let value = b"test_value".to_vec();
@@ -1992,7 +1992,7 @@ mod find_leaf_tests {
#[test]
fn find_leaf_exists_no_value_check() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
let path = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]);
sparse.update_leaf(path, VALUE_A(), &provider).unwrap();
@@ -2003,7 +2003,7 @@ mod find_leaf_tests {
#[test]
fn find_leaf_exists_with_value_check_ok() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
let path = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]);
let value = VALUE_A();
@@ -2015,7 +2015,7 @@ mod find_leaf_tests {
#[test]
fn find_leaf_exclusion_branch_divergence() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
let path1 = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]); // Creates branch at 0x12
let path2 = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x5, 0x6]); // Belongs to same branch
@@ -2030,7 +2030,7 @@ mod find_leaf_tests {
#[test]
fn find_leaf_exclusion_extension_divergence() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
// This will create an extension node at root with key 0x12
let path1 = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4, 0x5, 0x6]);
@@ -2045,7 +2045,7 @@ mod find_leaf_tests {
#[test]
fn find_leaf_exclusion_leaf_divergence() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
let existing_leaf_path = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]);
let search_path = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4, 0x5, 0x6]);
@@ -2058,7 +2058,7 @@ mod find_leaf_tests {
#[test]
fn find_leaf_exclusion_path_ends_at_branch() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
let path1 = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]); // Creates branch at 0x12
let path2 = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x5, 0x6]);
@@ -2072,7 +2072,7 @@ mod find_leaf_tests {
}
#[test]
fn find_leaf_error_blinded_node_at_leaf_path() {
fn find_leaf_error_trie_node_at_leaf_path() {
// Scenario: The node *at* the leaf path is blinded.
let blinded_hash = B256::repeat_byte(0xBB);
let leaf_path = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]);
@@ -2113,7 +2113,7 @@ mod find_leaf_tests {
}
#[test]
fn find_leaf_error_blinded_node() {
fn find_leaf_error_trie_node() {
let blinded_hash = B256::repeat_byte(0xAA);
let path_to_blind = Nibbles::from_nibbles_unchecked([0x1]);
let search_path = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]);
@@ -2155,7 +2155,7 @@ mod find_leaf_tests {
}
#[test]
fn find_leaf_error_blinded_node_via_reveal() {
fn find_leaf_error_trie_node_via_reveal() {
let blinded_hash = B256::repeat_byte(0xAA);
let path_to_blind = Nibbles::from_nibbles_unchecked([0x1]); // Path of the blinded node itself
let search_path = Nibbles::from_nibbles_unchecked([0x1, 0x2, 0x3, 0x4]); // Path we will search for
@@ -2216,7 +2216,7 @@ mod find_leaf_tests {
#[cfg(test)]
mod tests {
use super::*;
use crate::blinded::DefaultBlindedProvider;
use crate::provider::DefaultTrieNodeProvider;
use alloy_primitives::{map::B256Set, U256};
use alloy_rlp::Encodable;
use assert_matches::assert_matches;
@@ -2398,7 +2398,7 @@ mod tests {
[key],
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default().with_updates(true);
sparse.update_leaf(key, value_encoded(), &provider).unwrap();
let sparse_root = sparse.root();
@@ -2429,7 +2429,7 @@ mod tests {
paths.clone(),
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default().with_updates(true);
for path in &paths {
sparse.update_leaf(*path, value_encoded(), &provider).unwrap();
@@ -2460,7 +2460,7 @@ mod tests {
paths.clone(),
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default().with_updates(true);
for path in &paths {
sparse.update_leaf(*path, value_encoded(), &provider).unwrap();
@@ -2499,7 +2499,7 @@ mod tests {
paths.clone(),
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default().with_updates(true);
for path in &paths {
sparse.update_leaf(*path, value_encoded(), &provider).unwrap();
@@ -2539,7 +2539,7 @@ mod tests {
paths.clone(),
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default().with_updates(true);
for path in &paths {
sparse.update_leaf(*path, old_value_encoded.clone(), &provider).unwrap();
@@ -2574,7 +2574,7 @@ mod tests {
fn sparse_trie_remove_leaf() {
reth_tracing::init_test_tracing();
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
let value = alloy_rlp::encode_fixed_size(&U256::ZERO).to_vec();
@@ -2828,7 +2828,7 @@ mod tests {
TrieMask::new(0b11),
));
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::from_root(
branch.clone(),
TrieMasks { hash_mask: Some(TrieMask::new(0b01)), tree_mask: None },
@@ -2873,7 +2873,7 @@ mod tests {
TrieMask::new(0b11),
));
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::from_root(
branch.clone(),
TrieMasks { hash_mask: Some(TrieMask::new(0b01)), tree_mask: None },
@@ -2913,7 +2913,7 @@ mod tests {
fn test(updates: Vec<(BTreeMap<Nibbles, Account>, BTreeSet<Nibbles>)>) {
{
let mut state = BTreeMap::default();
let default_provider = DefaultBlindedProvider;
let default_provider = DefaultTrieNodeProvider;
let provider_factory = create_test_provider_factory();
let mut sparse = SerialSparseTrie::default().with_updates(true);
@@ -3074,7 +3074,7 @@ mod tests {
[Nibbles::default()],
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::from_root(
TrieNode::decode(&mut &hash_builder_proof_nodes.nodes_sorted()[0].1[..]).unwrap(),
TrieMasks {
@@ -3184,7 +3184,7 @@ mod tests {
[Nibbles::default()],
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::from_root(
TrieNode::decode(&mut &hash_builder_proof_nodes.nodes_sorted()[0].1[..]).unwrap(),
TrieMasks {
@@ -3287,7 +3287,7 @@ mod tests {
[Nibbles::default()],
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::from_root(
TrieNode::decode(&mut &hash_builder_proof_nodes.nodes_sorted()[0].1[..]).unwrap(),
TrieMasks {
@@ -3342,7 +3342,7 @@ mod tests {
#[test]
fn sparse_trie_get_changed_nodes_at_depth() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
let value = alloy_rlp::encode_fixed_size(&U256::ZERO).to_vec();
@@ -3457,7 +3457,7 @@ mod tests {
[Nibbles::default()],
);
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
sparse.update_leaf(key1(), value_encoded(), &provider).unwrap();
sparse.update_leaf(key2(), value_encoded(), &provider).unwrap();
@@ -3470,7 +3470,7 @@ mod tests {
#[test]
fn sparse_trie_wipe() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default().with_updates(true);
let value = alloy_rlp::encode_fixed_size(&U256::ZERO).to_vec();
@@ -3520,7 +3520,7 @@ mod tests {
fn sparse_trie_clear() {
// tests that if we fill a sparse trie with some nodes and then clear it, it has the same
// contents as an empty sparse trie
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
let value = alloy_rlp::encode_fixed_size(&U256::ZERO).to_vec();
sparse
@@ -3544,7 +3544,7 @@ mod tests {
#[test]
fn sparse_trie_display() {
let provider = DefaultBlindedProvider;
let provider = DefaultTrieNodeProvider;
let mut sparse = SerialSparseTrie::default();
let value = alloy_rlp::encode_fixed_size(&U256::ZERO).to_vec();

4
crates/trie/trie/src/proof/mod.rs
View File

@@ -17,8 +17,8 @@ use reth_trie_common::{
proof::ProofRetainer, AccountProof, MultiProof, MultiProofTargets, StorageMultiProof,
};
mod blinded;
pub use blinded::*;
mod trie_node;
pub use trie_node::*;
/// A struct for generating merkle proofs.
///

18
crates/trie/trie/src/proof/blinded.rs → crates/trie/trie/src/proof/trie_node.rs
View File

@@ -3,15 +3,15 @@ use crate::{hashed_cursor::HashedCursorFactory, trie_cursor::TrieCursorFactory};
use alloy_primitives::{map::HashSet, B256};
use reth_execution_errors::{SparseTrieError, SparseTrieErrorKind};
use reth_trie_common::{prefix_set::TriePrefixSetsMut, MultiProofTargets, Nibbles};
use reth_trie_sparse::blinded::{
pad_path_to_key, BlindedProvider, BlindedProviderFactory, RevealedNode,
use reth_trie_sparse::provider::{
pad_path_to_key, RevealedNode, TrieNodeProvider, TrieNodeProviderFactory,
};
use std::{sync::Arc, time::Instant};
use tracing::{enabled, trace, Level};
/// Factory for instantiating providers capable of retrieving blinded trie nodes via proofs.
#[derive(Debug, Clone)]
pub struct ProofBlindedProviderFactory<T, H> {
pub struct ProofTrieNodeProviderFactory<T, H> {
/// The cursor factory for traversing trie nodes.
trie_cursor_factory: T,
/// The factory for hashed cursors.
@@ -20,7 +20,7 @@ pub struct ProofBlindedProviderFactory<T, H> {
prefix_sets: Arc<TriePrefixSetsMut>,
}
impl<T, H> ProofBlindedProviderFactory<T, H> {
impl<T, H> ProofTrieNodeProviderFactory<T, H> {
/// Create new proof-based blinded provider factory.
pub const fn new(
trie_cursor_factory: T,
@@ -31,7 +31,7 @@ impl<T, H> ProofBlindedProviderFactory<T, H> {
}
}
impl<T, H> BlindedProviderFactory for ProofBlindedProviderFactory<T, H>
impl<T, H> TrieNodeProviderFactory for ProofTrieNodeProviderFactory<T, H>
where
T: TrieCursorFactory + Clone + Send + Sync,
H: HashedCursorFactory + Clone + Send + Sync,
@@ -79,12 +79,12 @@ impl<T, H> ProofBlindedAccountProvider<T, H> {
}
}
impl<T, H> BlindedProvider for ProofBlindedAccountProvider<T, H>
impl<T, H> TrieNodeProvider for ProofBlindedAccountProvider<T, H>
where
T: TrieCursorFactory + Clone + Send + Sync,
H: HashedCursorFactory + Clone + Send + Sync,
{
fn blinded_node(&self, path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError> {
fn trie_node(&self, path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError> {
let start = enabled!(target: "trie::proof::blinded", Level::TRACE).then(Instant::now);
let targets = MultiProofTargets::from_iter([(pad_path_to_key(path), HashSet::default())]);
@@ -136,12 +136,12 @@ impl<T, H> ProofBlindedStorageProvider<T, H> {
}
}
impl<T, H> BlindedProvider for ProofBlindedStorageProvider<T, H>
impl<T, H> TrieNodeProvider for ProofBlindedStorageProvider<T, H>
where
T: TrieCursorFactory + Clone + Send + Sync,
H: HashedCursorFactory + Clone + Send + Sync,
{
fn blinded_node(&self, path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError> {
fn trie_node(&self, path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError> {
let start = enabled!(target: "trie::proof::blinded", Level::TRACE).then(Instant::now);
let targets = HashSet::from_iter([pad_path_to_key(path)]);

30
crates/trie/trie/src/witness.rs
View File

@@ -1,7 +1,7 @@
use crate::{
hashed_cursor::{HashedCursor, HashedCursorFactory},
prefix_set::TriePrefixSetsMut,
proof::{Proof, ProofBlindedProviderFactory},
proof::{Proof, ProofTrieNodeProviderFactory},
trie_cursor::TrieCursorFactory,
};
use alloy_rlp::EMPTY_STRING_CODE;
@@ -21,7 +21,7 @@ use reth_execution_errors::{
};
use reth_trie_common::{MultiProofTargets, Nibbles};
use reth_trie_sparse::{
blinded::{BlindedProvider, BlindedProviderFactory, RevealedNode},
provider::{RevealedNode, TrieNodeProvider, TrieNodeProviderFactory},
SerialSparseTrie, SparseStateTrie,
};
use std::sync::{mpsc, Arc};
@@ -146,8 +146,8 @@ where
}
let (tx, rx) = mpsc::channel();
let blinded_provider_factory = WitnessBlindedProviderFactory::new(
ProofBlindedProviderFactory::new(
let blinded_provider_factory = WitnessTrieNodeProviderFactory::new(
ProofTrieNodeProviderFactory::new(
self.trie_cursor_factory,
self.hashed_cursor_factory,
Arc::new(self.prefix_sets),
@@ -237,24 +237,24 @@ where
}
#[derive(Debug, Clone)]
struct WitnessBlindedProviderFactory<F> {
/// Blinded node provider factory.
struct WitnessTrieNodeProviderFactory<F> {
/// Trie node provider factory.
provider_factory: F,
/// Sender for forwarding fetched blinded node.
/// Sender for forwarding fetched trie node.
tx: mpsc::Sender<Bytes>,
}
impl<F> WitnessBlindedProviderFactory<F> {
impl<F> WitnessTrieNodeProviderFactory<F> {
const fn new(provider_factory: F, tx: mpsc::Sender<Bytes>) -> Self {
Self { provider_factory, tx }
}
}
impl<F> BlindedProviderFactory for WitnessBlindedProviderFactory<F>
impl<F> TrieNodeProviderFactory for WitnessTrieNodeProviderFactory<F>
where
F: BlindedProviderFactory,
F::AccountNodeProvider: BlindedProvider,
F::StorageNodeProvider: BlindedProvider,
F: TrieNodeProviderFactory,
F::AccountNodeProvider: TrieNodeProvider,
F::StorageNodeProvider: TrieNodeProvider,
{
type AccountNodeProvider = WitnessBlindedProvider<F::AccountNodeProvider>;
type StorageNodeProvider = WitnessBlindedProvider<F::StorageNodeProvider>;
@@ -284,9 +284,9 @@ impl<P> WitnessBlindedProvider<P> {
}
}
impl<P: BlindedProvider> BlindedProvider for WitnessBlindedProvider<P> {
fn blinded_node(&self, path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError> {
let maybe_node = self.provider.blinded_node(path)?;
impl<P: TrieNodeProvider> TrieNodeProvider for WitnessBlindedProvider<P> {
fn trie_node(&self, path: &Nibbles) -> Result<Option<RevealedNode>, SparseTrieError> {
let maybe_node = self.provider.trie_node(path)?;
if let Some(node) = &maybe_node {
self.tx
.send(node.node.clone())