Enum SparseNode

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

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.

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.

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.

Trait Implementations

impl Clone for SparseNode

fn clone(&self) -> SparseNode

Returns a copy 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: 112 bytes

Size for each variant:

• Empty: 0 bytes
• Hash: 32 bytes
• Leaf: 111 bytes
• Extension: 111 bytes
• Branch: 35 bytes