Enum SparseNode 

pub enum SparseNode {
    Empty,
    Hash(B256),
    Leaf {
        key: Nibbles,
        hash: Option<B256>,
    },
    Extension {
        key: Nibbles,
        hash: Option<B256>,
        store_in_db_trie: Option<bool>,
    },
    Branch {
        state_mask: TrieMask,
        hash: Option<B256>,
        store_in_db_trie: Option<bool>,
    },
}

Enum representing trie nodes in sparse trie.

Variants

Empty

Empty trie node.

Hash(B256)

The hash of the node that was not revealed.

Leaf

Sparse leaf node with remaining key suffix.

Fields

key: Nibbles

Remaining key suffix for the leaf node.

hash: Option<B256>

Pre-computed hash of the sparse node. Can be reused unless this trie path has been updated.

Extension

Sparse extension node with key.

Fields

key: Nibbles

The key slice stored by this extension node.

hash: Option<B256>

Pre-computed hash of the sparse node. Can be reused unless this trie path has been updated.

If None, then the value is not known and should be calculated from scratch.

store_in_db_trie: Option<bool>

Pre-computed flag indicating whether the trie node should be stored in the database. Can be reused unless this trie path has been updated.

If None, then the value is not known and should be calculated from scratch.

Branch

Sparse branch node with state mask.

Fields

state_mask: TrieMask

The bitmask representing children present in the branch node.

hash: Option<B256>

Pre-computed hash of the sparse node. Can be reused unless this trie path has been updated.

If None, then the value is not known and should be calculated from scratch.

store_in_db_trie: Option<bool>

Pre-computed flag indicating whether the trie node should be stored in the database. Can be reused unless this trie path has been updated.

If None, then the value is not known and should be calculated from scratch.

Implementations

impl SparseNode

pub fn from_node(node: TrieNode) -> Self

Create new sparse node from [TrieNode].

pub const fn new_branch(state_mask: TrieMask) -> Self

Create new SparseNode::Branch from state mask.

pub const fn new_split_branch(bit_a: u8, bit_b: u8) -> Self

Create new SparseNode::Branch with two bits set.

pub const fn new_ext(key: Nibbles) -> Self

Create new SparseNode::Extension from the key slice.

pub const fn new_leaf(key: Nibbles) -> Self

Create new SparseNode::Leaf from leaf key and value.

pub const fn is_hash(&self) -> bool

Returns true if the node is a hash node.

pub const fn hash(&self) -> Option<B256>

Returns the hash of the node if it exists.

pub const fn set_hash(&mut self, new_hash: Option<B256>)

Sets the hash of the node for testing purposes.

For SparseNode::Empty and SparseNode::Hash nodes, this method does nothing.

Trait Implementations

impl Clone for SparseNode

fn clone(&self) -> SparseNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SparseNode

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

Formats the value using the given formatter.

impl PartialEq for SparseNode

fn eq(&self, other: &SparseNode) -> 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 Eq for SparseNode

impl StructuralPartialEq for SparseNode

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

Size for each variant:

• Empty: 0 bytes
• Hash: 32 bytes
• Leaf: 79 bytes
• Extension: 79 bytes
• Branch: 37 bytes