Struct Proof 

pub struct Proof<F: Family, D: Digest> {
    pub leaves: Location<F>,
    pub inactive_peaks: usize,
    pub digests: Vec<D>,
}

Contains the information necessary for proving the inclusion of an element, or some range of elements, in a Merkle-family data structure from its root digest.

For range proofs, the digests vector uses a fold-based layout:

1. If there are folded peaks entirely before the proven range, the first digest is a single accumulator produced by folding those peaks: fold(fold(..., peak0), peak1). If there are no such peaks, this entry is absent.

2. The digests of any non-folded peaks entirely before the proven range, in peak iteration order.

3. For ForwardFold, the digests of peaks entirely after the proven range, in peak iteration order. For BackwardFold, inactive after-peaks are still listed individually, while active after-peaks are collapsed into one optional suffix accumulator.

4. The sibling digests needed to reconstruct each range-peak digest from the proven elements, in depth-first (forward consumption) order for each range peak.

Multi-proofs use a different, position-keyed layout: digests contains the sorted set of node digests required by the requested inactive_peaks and bagging policy. For BackwardFold, this may include active suffix peaks that a single range proof could collapse into a synthetic suffix accumulator.

Fields

leaves: Location<F>

The total number of leaves in the data structure. For MMR proofs, this is the number of leaves in the MMR, though other authenticated data structures may override the meaning of this field. For example, the authenticated crate::AuthenticatedBitMap stores the number of bits in the bitmap within this field.

inactive_peaks: usize

The number of inactive peaks in the structure when this proof was generated.

digests: Vec<D>

The digests necessary for proving inclusion.

Implementations

impl<F: Family, D: Digest> Proof<F, D>

pub fn verify_element_inclusion<H>( &self, hasher: &H, element: &[u8], loc: Location<F>, root: &D, ) -> bool

where H: Hasher<F, Digest = D>,

Return true if this proof proves that element appears at location loc within the structure with root digest root, using the bagging carried by hasher.

pub fn verify_range_inclusion<H, E>( &self, hasher: &H, elements: &[E], start_loc: Location<F>, root: &D, ) -> bool

where H: Hasher<F, Digest = D>, E: AsRef<[u8]>,

Return true if this proof verifies against the supplied root, using the bagging carried by hasher.

pub fn matches_canonical_inactive_peaks( &self, size: Position<F>, inactivity_floor: Location<F>, ) -> bool

Returns true if this proof’s inactive_peaks field matches the canonical value derived from size and inactivity_floor.

pub fn verify_multi_inclusion<H, E>( &self, hasher: &H, elements: &[(E, Location<F>)], root: &D, ) -> bool

where H: Hasher<F, Digest = D>, E: AsRef<[u8]>,

Verify a position-keyed multi-proof using the bagging carried by hasher.

Multi-proofs keep every witness tied to a concrete node position, so this path may include extra backward-bagged suffix peaks that range proofs can collapse into a suffix accumulator.

pub fn reconstruct_root<H, E>( &self, hasher: &H, elements: &[E], start_loc: Location<F>, ) -> Result<D, ReconstructionError>

where H: Hasher<F, Digest = D>, E: AsRef<[u8]>,

Reconstruct the root digest from this proof and the given consecutive elements using the bagging carried by hasher, or return a ReconstructionError if the input data is invalid.

pub fn verify_range_inclusion_and_extract_digests<H, E>( &self, hasher: &H, elements: &[E], start_loc: Location<F>, root: &D, ) -> Result<Vec<(Position<F>, D)>, Error<F>>

where H: Hasher<F, Digest = D>, E: AsRef<[u8]>,

Verify this proof against root and extract all authenticated digests.

Reconstructs the root from the proof and provided elements and returns every (position, digest) pair required by that reconstruction, including the proof’s own digests. Returns Error::InvalidProof if the input data is malformed and Error::RootMismatch if the reconstructed root does not match root.

pub fn verify_proof_and_pinned_nodes<H, E>( &self, hasher: &H, elements: &[E], start_loc: Location<F>, pinned_nodes: &[D], root: &D, ) -> bool

where H: Hasher<F, Digest = D>, E: AsRef<[u8]>,

Verify this proof and the pinned nodes against root.

The proof’s inactive_peaks field commits to the split boundary; peak bagging is selected by hasher.

The pinned_nodes are the peak digests of the sub-structure at start_loc, in the order returned by Family::nodes_to_pin. The proof authenticates the prefix [0, start_loc) via:

• fold-prefix peaks of the larger tree, and
• sibling subtrees inside the first range peak that lie wholly before start_loc.

When the larger tree has merged smaller subtrees into a bigger parent, the pins sit below these authenticated subtrees. The verifier hashes pairs of pins up to each authenticated subtree’s root and compares against the proof.

For example, in MMB at leaves=5, start_loc=4, the proof describes [0, 4) as one height-2 subtree p7, while the pins cover the same leaves as two height-1 subtrees p2, p5:

    proof authenticates:         pins contain:

            p7
          /    \
         p2    p5                p2         p5
        / \    / \              / \        / \
       L0 L1  L2 L3            L0 L1      L2 L3

The verifier walks down from p7 via F::children, pulls the pins for p2 and p5, and hashes them back up (node_digest(p7, pin[p2], pin[p5])) to compare against the p7 digest the proof authenticates.

Returns true only if the proof reconstructs to root and every pinned node digest is accounted for. When start_loc is 0, pinned_nodes must be empty.

Trait Implementations

impl<F: Clone + Family, D: Clone + Digest> Clone for Proof<F, D>

fn clone(&self) -> Proof<F, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Family, D: Debug + Digest> Debug for Proof<F, D>

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

Formats the value using the given formatter.

impl<F: Family, D: Digest> Default for Proof<F, D>

fn default() -> Self

Create an empty proof. The empty proof will verify only against the root digest of an empty (leaves == 0) data structure.

impl<F: Family, D: Digest> EncodeSize for Proof<F, D>

fn encode_size(&self) -> usize

Returns the encoded size of this value (in bytes).

fn encode_inline_size(&self) -> usize

Returns the encoded size excluding bytes passed to BufsMut::push during Write::write_bufs. Used to size the working buffer for inline writes. Override alongside Write::write_bufs for types where large Bytes fields go via push; failing to do so will over-allocate.

impl<F: Eq + Family, D: Eq + Digest> Eq for Proof<F, D>

impl<F: Family, D: Digest> PartialEq for Proof<F, D>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<F: Family, D: Digest> Read for Proof<F, D>

type Cfg = usize

The maximum number of digests in the proof.

fn read_cfg(buf: &mut impl Buf, max_digests: &Self::Cfg) -> Result<Self, Error>

Reads a value from the buffer using the provided configuration cfg.

impl<F: Family, D: Digest> Write for Proof<F, D>

fn write(&self, buf: &mut impl BufMut)

Writes the binary representation of self to the provided buffer buf.

fn write_bufs(&self, buf: &mut impl BufsMut)

Writes to a BufsMut, allowing existing Bytes chunks to be appended via BufsMut::push instead of written inline. Must encode to the same format as Write::write. Defaults to Write::write.