Struct MerkleTree 

pub struct MerkleTree { /* private fields */ }

The Merkle tree.

Implementations

impl MerkleTree

pub fn new() -> Self

Construct a new empty tree.

pub fn append(&mut self, entry: MerkleEntry) -> u64

Append an entry.

O(log N): updates only the path from the new leaf up to the root. Each level either pairs its last two nodes (replacing the promoted copy one level up) or promotes the new node as-is.

pub fn len(&self) -> usize

Current entry count.

pub fn is_empty(&self) -> bool

Is the tree empty?

pub fn root(&self) -> Hash

Compute the current root hash. Empty tree returns all-zeros.

O(1) — the root is incrementally maintained on every append().

pub fn entry(&self, sequence: u64) -> Result<&MerkleEntry, MerkleError>

Get an entry by sequence.

pub fn inclusion_proof( &self, sequence: u64, ) -> Result<InclusionProof, MerkleError>

Construct an inclusion proof for sequence. Returns direction-aware proof per RFC 6962 §2.1.1.

O(log N) — walks the cached levels from leaf to root, picking the sibling at each level. Compare to the previous O(N) implementation which rebuilt every level on each call.

pub fn verify_inclusion( entry: &MerkleEntry, proof: &InclusionProof, root: Hash, ) -> Result<(), MerkleError>

Verify an inclusion proof (RFC 6962 §2.1.1).

pub fn consistency_proof( &self, old_size: usize, ) -> Result<Vec<Hash>, MerkleError>

Compute a consistency proof (RFC 6962 §2.1.2).

Proves that the first old_size entries of the current tree hash to the same root as a tree of exactly old_size entries.

Returns the “consistency path” — a list of subtree hashes that the verifier uses to reconstruct both the old and new roots.

pub fn verify_consistency( &self, old_root: Hash, new_root: Hash, old_size: usize, new_size: usize, _proof: &[Hash], ) -> Result<(), MerkleError>

Verify a consistency proof (RFC 6962 §2.1.2).

Brute-force verification: recompute the root at old_size and the current root from this tree’s leaves, then compare to old_root and new_root respectively.

This method requires &self because external proof-based verification (without the tree) requires a much more intricate algorithm that handles non-power-of-two old_size correctly. That algorithm is tracked as a follow-up; for now, this brute-force path is correct and is what bindings use.

The proof parameter is accepted for forward compatibility — it is currently unused (verification is done by direct recomputation), but the API shape is preserved so a future proof-based verifier can plug in without breaking callers.

Trait Implementations

impl Clone for MerkleTree

fn clone(&self) -> MerkleTree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MerkleTree

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

Formats the value using the given formatter.

impl Default for MerkleTree

fn default() -> MerkleTree

Returns the “default value” for a type.