Struct Proof 

pub struct Proof<D: Digest> {
    pub size: u64,
    pub digests: Vec<D>,
}

Contains the information necessary for proving the inclusion of an element, or some range of elements, in the MMR from its root digest.

The digests vector contains:

1: the digests of each peak corresponding to a mountain containing no elements from the element range being proven in decreasing order of height, followed by:

2: the nodes in the remaining mountains necessary for reconstructing their peak digests from the elements within the range, ordered by the position of their parent.

Fields

size: u64

The total number of nodes in the MMR.

digests: Vec<D>

The digests necessary for proving the inclusion of an element, or range of elements, in the MMR.

Implementations

impl<D: Digest> Proof<D>

pub fn verify_element_inclusion<I, H>( &self, hasher: &mut H, element: &[u8], element_pos: u64, root: &D, ) -> bool

where I: CHasher<Digest = D>, H: Hasher<I>,

Return true if proof proves that element appears at position element_pos within the MMR with root digest root.

pub fn verify_range_inclusion<I, H, E>( &self, hasher: &mut H, elements: &[E], start_element_pos: u64, root: &D, ) -> bool

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

Return true if proof proves that the elements appear consecutively starting at position start_element_pos within the MMR with root digest root.

pub fn verify_range_inclusion_and_extract_digests<I, H, E>( &self, hasher: &mut H, elements: &[E], start_element_pos: u64, root: &D, ) -> Result<Vec<(u64, D)>, Error>

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

Reconstructs the root digest of the MMR 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 a Error::InvalidProof if the input data is invalid and Error::RootMismatch if the root does not match the computed root.

pub fn nodes_to_pin(start_pos: u64) -> impl Iterator<Item = u64>

Return the list of pruned (pos < start_pos) node positions that are still required for proving any retained node.

This set consists of every pruned node that is either (1) a peak, or (2) has no descendent in the retained section, but its immediate parent does. (A node meeting condition (2) can be shown to always be the left-child of its parent.)

This set of nodes does not change with the MMR’s size, only the pruning boundary. For a given pruning boundary that happens to be a valid MMR size, one can prove that this set is exactly the set of peaks for an MMR whose size equals the pruning boundary. If the pruning boundary is not a valid MMR size, then the set corresponds to the peaks of the largest MMR whose size is less than the pruning boundary.

pub fn nodes_required_for_range_proof( size: u64, start_element_pos: u64, end_element_pos: u64, ) -> Vec<u64>

Return the list of node positions required by the range proof for the specified range of elements, inclusive of both endpoints.

pub async fn range_proof<S: Storage<D>>( mmr: &S, start_element_pos: u64, end_element_pos: u64, ) -> Result<Proof<D>, Error>

Return an inclusion proof for the specified range of elements, inclusive of both endpoints. Returns ElementPruned error if some element needed to generate the proof has been pruned.

pub async fn historical_range_proof<S: Storage<D>>( mmr: &S, size: u64, start_element_pos: u64, end_element_pos: u64, ) -> Result<Proof<D>, Error>

Analogous to range_proof but for a previous database state. Specifically, the state when the MMR had size elements.

pub async fn multi_proof<S: Storage<D>>( mmr: &S, positions: &[u64], ) -> Result<Proof<D>, Error>

Return an inclusion proof for the specified positions. This is analogous to range_proof but supports non-contiguous positions.

The order of positions does not affect the output (sorted internally).

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

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

Return true if proof proves that the elements at the specified positions are included in the MMR with the root digest root.

The order of the elements does not affect the output.

pub fn extract_pinned_nodes( &self, start_element_pos: u64, end_element_pos: u64, ) -> Result<Vec<D>, Error>

Extract the hashes of all nodes that should be pinned at the given pruning boundary from a proof that proves a range starting at that boundary.

Arguments

• start_element_pos - Start of the proven range (must equal pruning_boundary)
• end_element_pos - End of the proven range

Returns

A Vec of digest values for all nodes in nodes_to_pin(pruning_boundary), in the same order as returned by nodes_to_pin (decreasing height order)

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

Create an empty proof. The empty proof will verify only against the root digest of an empty (size == 0) MMR.

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

fn encode_size(&self) -> usize

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

impl<D: Digest> PartialEq for Proof<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<D: Digest> Read for Proof<D>

type Cfg = usize

The maximum number of digests in the proof.

fn read_cfg(buf: &mut impl Buf, max_len: &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, buf: &mut impl BufMut)

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

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