Enum ConfigurableSparseTrie 

pub enum ConfigurableSparseTrie {
    Arena(ArenaParallelSparseTrie),
    HashMap(ParallelSparseTrie),
}

An enum wrapping two different SparseTrie implementations, forwarding all calls to the underlying trie.

Variants

Arena(ArenaParallelSparseTrie)

The arena-based parallel sparse trie implementation.

HashMap(ParallelSparseTrie)

The hash-map-based parallel sparse trie implementation.

Trait Implementations

impl Clone for ConfigurableSparseTrie

fn clone(&self) -> ConfigurableSparseTrie

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ConfigurableSparseTrie

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ConfigurableSparseTrie

fn default() -> Self

Returns the “default value” for a type.

impl SparseTrie for ConfigurableSparseTrie

fn set_root( &mut self, root: TrieNodeV2, masks: Option<BranchNodeMasks>, retain_updates: bool, ) -> SparseTrieResult<()>

Configures the trie to have the given root node revealed.

fn set_updates(&mut self, retain_updates: bool)

Configures the trie to retain information about updates.

fn reserve_nodes(&mut self, additional: usize)

Reserves capacity for additional trie nodes.

fn reveal_nodes( &mut self, nodes: &mut [ProofTrieNodeV2], ) -> SparseTrieResult<()>

Reveals one or more trie nodes if they have not been revealed before.

fn update_leaf<P: TrieNodeProvider>( &mut self, full_path: Nibbles, value: Vec<u8>, provider: P, ) -> SparseTrieResult<()>

Updates the value of a leaf node at the specified path.

fn remove_leaf<P: TrieNodeProvider>( &mut self, full_path: &Nibbles, provider: P, ) -> SparseTrieResult<()>

Removes a leaf node at the specified path.

fn root(&mut self) -> B256

Calculates and returns the root hash of the trie.

fn is_root_cached(&self) -> bool

Returns true if the root node is cached and does not need any recomputation.

fn update_subtrie_hashes(&mut self)

Recalculates and updates the RLP hashes of subtries deeper than a certain level. The level is defined in the implementation.

fn get_leaf_value(&self, full_path: &Nibbles) -> Option<&Vec<u8>>

Retrieves a reference to the leaf value at the specified path.

fn find_leaf( &self, full_path: &Nibbles, expected_value: Option<&Vec<u8>>, ) -> Result<LeafLookup, LeafLookupError>

Attempts to find a leaf node at the specified path.

fn updates_ref(&self) -> Cow<'_, SparseTrieUpdates>

Returns a reference to the current sparse trie updates.

fn take_updates(&mut self) -> SparseTrieUpdates

Consumes and returns the currently accumulated trie updates.

fn wipe(&mut self)

Removes all nodes and values from the trie, resetting it to a blank state with only an empty root node. This is used when a storage root is deleted.

fn clear(&mut self)

This clears all data structures in the sparse trie, keeping the backing data structures allocated. A crate::SparseNode::Empty is inserted at the root.

fn shrink_nodes_to(&mut self, size: usize)

Shrink the capacity of the sparse trie’s node storage to the given size. This will reduce memory usage if the current capacity is higher than the given size.

fn shrink_values_to(&mut self, size: usize)

Shrink the capacity of the sparse trie’s value storage to the given size. This will reduce memory usage if the current capacity is higher than the given size.

fn size_hint(&self) -> usize

Returns a cheap O(1) size hint for the trie representing the count of revealed (non-Hash) nodes.

fn memory_size(&self) -> usize

Returns a heuristic for the in-memory size of this trie in bytes.

fn prune(&mut self, retained_leaves: &[Nibbles]) -> usize

Prunes all subtrees that do not contain retained leaves.

fn take_debug_recorder(&mut self) -> TrieDebugRecorder

Takes the debug recorder out of this trie, replacing it with an empty one.

fn update_leaves( &mut self, updates: &mut B256Map<LeafUpdate>, proof_required_fn: impl FnMut(B256, u8), ) -> SparseTrieResult<()>

Applies leaf updates to the sparse trie.

fn commit_updates( &mut self, updated: &HashMap<Nibbles, BranchNodeCompact>, removed: &HashSet<Nibbles>, )

Commits the updated nodes to internal trie state.

fn with_root( self, root: TrieNodeV2, masks: Option<BranchNodeMasks>, retain_updates: bool, ) -> SparseTrieResult<Self>

Configures the trie to have the given root node revealed.

fn with_updates(self, retain_updates: bool) -> Self

Configures the trie to retain information about updates.

fn reveal_node( &mut self, path: Nibbles, node: TrieNodeV2, masks: Option<BranchNodeMasks>, ) -> SparseTrieResult<()>

The single-node version of reveal_nodes.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 352 bytes

Size for each variant:

• Arena: 352 bytes
• HashMap: 296 bytes