Struct LeafProof 

pub struct LeafProof {
    pub leaf_hash: Vec<u8>,
    pub index: u64,
    pub tree_size: u64,
    pub arity: u64,
    pub path: Vec<ProofStep>,
}

A self-contained leaf proof: a leaf hash bound to its position, ready to verify against a trusted root and the structure’s skeleton.

The path and positional fields are exactly the inclusion contract; bundling them keeps the proof self-describing about which position it claims. Because the structural core is topology-agnostic, verify takes the concrete skeleton for the leaf’s position — the holding consumer computes it from the trusted (index, tree_size, arity) under its own topology (an append-only log’s mountain skeleton, a mutable tree’s rebalanced skeleton).

Fields

leaf_hash: Vec<u8>

The proven leaf’s digest at index.

index: u64

Trusted log position of the leaf (0-indexed).

tree_size: u64

Trusted size of the tree the proof is rooted in.

arity: u64

Trusted fixed arity of the proof spine (2..=256).

path: Vec<ProofStep>

Path steps from the leaf to the root, over the shared positional topology — the same shape verify_inclusion reconstructs against.

Implementations

impl LeafProof

pub fn new( leaf_hash: Vec<u8>, index: u64, tree_size: u64, arity: u64, path: Vec<ProofStep>, ) -> LeafProof

Assemble a leaf proof from a leaf hash and its trusted positional parameters plus an inclusion path.

This is the kernel-level producer the engineering libraries (EML, EMT) wrap around their own path generation; they own the live-tree walk, the kernel owns the self-contained witness shape.

pub fn verify( &self, hasher: &dyn Hasher, skeleton: &[SkeletonStep], root: &[u8], ) -> bool

Verify the leaf proof against an authenticated root and the structure’s skeleton for this leaf’s position: is leaf_hash the legitimate leaf at index in the size-tree_size tree rooted at root?

Soundness rests on the verifier pinning the proof’s trailing steps against skeleton; the proof supplies only sibling digests. The skeleton is the consumer’s concrete topology for the trusted (index, tree_size, arity) and MUST be authenticated alongside root (see the module-level trust contract).

Trait Implementations

impl Clone for LeafProof

fn clone(&self) -> LeafProof

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LeafProof

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

Formats the value using the given formatter.

impl Eq for LeafProof

impl PartialEq for LeafProof

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