Struct Proof 

pub struct Proof<D: Digest> {
    pub size: Position,
    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: Position

The total number of nodes in the MMR for MMR proofs, though other authenticated data structures may override the meaning of this field. For example, the authenticated crate::mmr::bitmap::BitMap stores the number of bits in the bitmap within this field.

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], loc: Location, root: &D, ) -> bool

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

Return true if this proof proves that element appears at location loc within the MMR with root digest root.

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

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

Return true if this proof proves that the elements appear consecutively starting at position start_loc within the MMR with root digest root. A malformed proof will return false.

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

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

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

The order of the elements does not affect the output.

pub fn verify_range_inclusion_and_extract_digests<I, H, E>( &self, hasher: &mut H, elements: &[E], start_loc: Location, root: &I::Digest, ) -> Result<Vec<(Position, 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 reconstruct_root<I, H, E>( &self, hasher: &mut H, elements: &[E], start_loc: Location, ) -> Result<I::Digest, ReconstructionError>

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, or returns a ReconstructionError if the input data is invalid.

pub fn reconstruct_peak_digests<I, H, E>( &self, hasher: &mut H, elements: &[E], start_loc: Location, collected_digests: Option<&mut Vec<(Position, I::Digest)>>, ) -> Result<Vec<D>, ReconstructionError>

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

Reconstruct the peak digests of the MMR that produced this proof, returning ReconstructionError if the input data is invalid. If collected_digests is Some, then all node digests used in the process will be added to the wrapped vector.

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>