Struct SerialSparseTrie 

pub struct SerialSparseTrie { /* private fields */ }

The representation of revealed sparse trie.

The revealed sparse trie contains the actual trie structure with nodes, values, and tracking for changes. It supports operations like inserting, updating, and removing nodes.

Invariants

• The root node is always present in nodes collection.
• Each leaf entry in nodes collection must have a corresponding entry in values collection. The opposite is also true.
• All keys in values collection are full leaf paths.

Implementations

impl SerialSparseTrie

pub fn from_root( root: TrieNode, masks: TrieMasks, retain_updates: bool, ) -> SparseTrieResult<Self>

Creates a new revealed sparse trie from the given root node.

This function initializes the internal structures and then reveals the root. It is a convenient method to create a trie when you already have the root node available.

Arguments

• root - The root node of the trie
• masks - Trie masks for root branch node
• retain_updates - Whether to track updates

Returns

Self if successful, or an error if revealing fails.

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

Returns a reference to the current sparse trie updates.

If no updates have been made/recorded, returns an empty update set.

pub const fn nodes_ref(&self) -> &HashMap<Nibbles, SparseNode>

Returns an immutable reference to all nodes in the sparse trie.

pub fn update_rlp_node_level(&mut self, depth: usize)

Recalculates and updates the RLP hashes of nodes deeper than or equal to the specified depth.

The root node is considered to be at level 0. This method is useful for optimizing hash recalculations after localized changes to the trie structure:

This function identifies all nodes that have changed (based on the prefix set) at the given depth and recalculates their RLP representation.

pub fn rlp_node_allocate(&mut self, prefix_set: &mut PrefixSet) -> RlpNode

Look up or calculate the RLP of the node at the root path.

Panics

If the node at provided path does not exist.

pub fn rlp_node( &mut self, prefix_set: &mut PrefixSet, buffers: &mut RlpNodeBuffers, rlp_buf: &mut Vec<u8>, ) -> RlpNode

Looks up or computes the RLP encoding of the node specified by the current path in the provided buffers.

The function uses a stack (RlpNodeBuffers::path_stack) to track the traversal and accumulate RLP encodings.

Parameters

• prefix_set: The set of trie paths that need their nodes updated.
• buffers: The reusable buffers for stack management and temporary RLP values.

Panics

If the node at provided path does not exist.

Trait Implementations

impl Clone for SerialSparseTrie

fn clone(&self) -> SerialSparseTrie

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SerialSparseTrie

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

Formats the value using the given formatter.

impl Default for SerialSparseTrie

fn default() -> Self

Returns the “default value” for a type.

impl Display for SerialSparseTrie

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

Formats the value using the given formatter.

impl PartialEq for SerialSparseTrie

fn eq(&self, other: &SerialSparseTrie) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SparseTrieInterface for SerialSparseTrie

fn with_root( self, root: TrieNode, masks: TrieMasks, 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 reserve_nodes(&mut self, additional: usize)

Reserves capacity for additional trie nodes.

fn reveal_node( &mut self, path: Nibbles, node: TrieNode, masks: TrieMasks, ) -> SparseTrieResult<()>

The single-node version of reveal_nodes.

fn reveal_nodes( &mut self, nodes: Vec<RevealedSparseNode>, ) -> 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 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 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 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 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.

impl Eq for SerialSparseTrie

impl StructuralPartialEq for SerialSparseTrie

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: 304 bytes