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.

Fields

leaf_count: u32

The total number of leaves in the tree.

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.

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.

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>