Struct Proof 

pub struct Proof<D: Digest> {
    pub leaf_count: u32,
    pub siblings: Vec<D>,
}

A Merkle proof for multiple non-contiguous leaves in a Binary Merkle Tree.

This proof type is more space-efficient than generating individual proofs for each leaf because sibling nodes that are shared between multiple paths are deduplicated.

The proof contains the leaf count and sibling digests required for verification. The leaf count is incorporated into the root hash during finalization, so modifying it will cause verification to fail (preventing malleability attacks).

Fields

leaf_count: u32

The number of leaves in the tree.

This value is incorporated into the root hash during finalization, so modifying it will cause verification to fail (prevents malleability).

siblings: Vec<D>

The deduplicated sibling digests required to verify all elements, ordered by their position in the tree (level-major, then index within level).

Implementations

impl<D: Digest> Proof<D>

pub fn max_encode_size(siblings: usize) -> usize

Returns an upper bound on the encoded size of a proof with at most siblings sibling digests.

pub fn verify_element_inclusion<H: Hasher<Digest = D>>( &self, leaf: &D, position: u32, root: &D, ) -> Result<(), Error>

Verifies that a given leaf at position is included in a Binary Merkle Tree with root.

The proof consists of sibling hashes stored from the leaf up to the root. At each level, if the current node is a left child (even index), the sibling is combined to the right; if it is a right child (odd index), the sibling is combined to the left.

The leaf_count stored in the proof is incorporated into the finalized root computation, so any modification to it will cause verification to fail.

pub fn verify_multi_inclusion<H: Hasher<Digest = D>>( &self, elements: &[(D, u32)], root: &D, ) -> Result<(), Error>

Verifies that the given elements at their respective positions are included in a Binary Merkle Tree with root.

Positions must be strictly ascending and in range. The error names the first position in input order that is out of range, repeats the previous one, or precedes it.

The leaf_count stored in the proof is incorporated into the finalized root computation, so any modification to it will cause verification to fail.

pub fn verify_range_inclusion<H: Hasher<Digest = D>>( &self, position: u32, leaves: &[D], root: &D, ) -> Result<(), Error>

Verifies that a contiguous range of leaves starting at position are included in a Binary Merkle Tree with root.

This is a convenience method for verifying range proofs. The leaves must be in order starting from position.

The leaf_count stored in the proof is incorporated into the finalized root computation, so any modification to it will cause verification to fail.

Trait Implementations

impl<D: Clone + Digest> Clone for Proof<D>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D: Debug + Digest> Debug for Proof<D>

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

Formats the value using the given formatter.

impl<D: Digest> Default for Proof<D>

fn default() -> Self

Returns the “default value” for a type.

impl<D: Digest> EncodeSize for Proof<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 fixed working buffer for inline writes, so it must not be less than the bytes written inline. Override alongside Write::write_bufs for types where large byte fields go via push, or the working buffer will over-allocate.

impl<D: Eq + Digest> Eq for Proof<D>

impl<D: PartialEq + Digest> PartialEq for Proof<D>

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

Equality operator ==.

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

Inequality operator !=.

impl<D: Digest> Read for Proof<D>

type Cfg = usize

The maximum number of items being proven.

The upper bound on sibling hashes is derived as max_items * MAX_LEVELS.

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

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

impl<D: PartialEq + Digest> StructuralPartialEq for Proof<D>

impl<D: Digest> Write for Proof<D>

fn write(&self, writer: &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 byte chunks to be appended via BufsMut::push instead of written inline. Must encode to the same format as Write::write. Defaults to Write::write.