Enum monotree::node::Node

pub enum Node<'a> {
    Soft(Cell<'a>),
    Hard(Cell<'a>, Cell<'a>),
}

The only component of monotree. In a big picture, monotree simply consists of structured Nodes.

Schematic

There are two types of Node – Soft node and Hard node.

• Hard: a node that has two real cells as components. two links to child nodes.
• Soft: a node that has only one real cell and it has only one link going out to child node.

//              Root
//             /    \
//          NodeA   NodeB
//         /     \      \
//      NodeC   LeafB  LeafC
//       /
//     LeafA

where NodeA is a Hard node, NodeB and NodeC are Soft nodes.

Byte-Serialized View

Numbers in parentheses refer to byte length. By default HashLen = 32, BitsLen = 2.

SoftNode = Cell + 0x00(1), where
Cell = hash(HASH_LEN) + path(< HASH_LEN) + range_start(BitsLen) + range_end(BitsLen).
0x00 is an indicator for soft node.

HardNode = Cell_L + Cell_R + 0x01(1), where
Cell_L = hash_L(HASH_LEN) + path_L(< HASH_LEN) + range_L_start(BitsLen) + range_L_end(BitsLen)
Cell_R = path_R(< HASH_LEN) _ range_R_start(BitsLen) + range_R_end(BitsLen) + hash_R(HASH_LEN).
0x01 is an indicator for hard node.

To make Merkle proof easier, we purposely placed the hashes on outskirts of the serialized form. With only 1-bit information of left or right, provers can easily guess which side the hash he holds should be appended for the next step. Refer to verify_proof() implementation regarding on this discussion.

Variants

Soft(Cell<'a>)

Hard(Cell<'a>, Cell<'a>)

Implementations

impl<'a> Node<'a>

pub fn new(lc: Cell<'a>, rc: Cell<'a>) -> Self

pub fn cells_from_bytes( bytes: &'a [u8], right: bool ) -> Result<(Cell<'a>, Cell<'a>)>

Construct Cells by deserializing bytes slice.

pub fn from_bytes(bytes: &'a [u8]) -> Result<Self>

Construct Node by deserializing bytes slice.

pub fn to_bytes(&self) -> Result<Vec<u8>>

Serialize Node into bytes.

Trait Implementations

impl<'a> Clone for Node<'a>

fn clone(&self) -> Node<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Node<'a>

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

Formats the value using the given formatter.