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 verify_element_inclusion<H: Hasher<Digest = D>>( &self, hasher: &mut H, leaf: &D, position: u32, root: &D, ) -> Result<(), Error>

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

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, hasher: &mut H, 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.

Elements can be provided in any order; positions are sorted internally. Duplicate positions will cause verification to fail.

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, hasher: &mut H, 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) -> Proof<D>

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).

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

fn eq(&self, other: &Proof<D>) -> 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<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: Digest> Write for Proof<D>

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

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

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

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