Struct Proof 

pub struct Proof<F: Family, D: Digest> {
    pub leaves: Location<F>,
    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.

The digests vector uses a fold-based layout:

1. If there are peaks entirely before the proven range (fold prefix), 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 peaks entirely after the proven range, in peak iteration order.

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

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.

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.

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 proves that the elements appear consecutively starting at start_loc within the structure with root digest root.

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]>,

Return true if this proof proves that the elements at the specified locations are included in the structure with root digest root. A malformed proof will return false.

The order of the elements does not affect the output.

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, 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]>,

Reconstructs the root digest from the digests in the proof and the provided range of elements, returning the (position,digest) of every node whose digest was required by the process (including those from the proof itself). Returns Error::InvalidProof if the input data is invalid and Error::RootMismatch if the root does not match the computed 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 that both the proof and the pinned nodes are valid with respect to root.

The pinned_nodes are the peak digests of the sub-structure at start_loc, in the order returned by Family::nodes_to_pin. Each pinned node is either:

• A peak that precedes the proven range (fold-prefix peak). These are verified by refolding them and comparing against the proof’s fold-prefix accumulator.
• A sibling node within a range peak’s reconstruction. These are verified against the digests extracted during proof verification.

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: Family, D: Digest> PartialEq for Proof<F, D>

fn eq(&self, other: &Self) -> 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<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.

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