Struct BatchMerkleProof 

pub struct BatchMerkleProof<H: Hasher> {
    pub nodes: Vec<Vec<H::Digest>>,
    pub depth: u8,
}

Multiple Merkle proofs aggregated into a single proof.

The aggregation is done in a way which removes all duplicate internal nodes, and thus, it is possible to achieve non-negligible compression as compared to naively concatenating individual Merkle proofs. The algorithm is for aggregation is a variation of Octopus.

Fields

nodes: Vec<Vec<H::Digest>>

Hashes of Merkle Tree proof values above the leaf layer

depth: u8

Depth of the leaves

Implementations

impl<H: Hasher> BatchMerkleProof<H>

pub fn from_single_proofs( proofs: &[(<H as Hasher>::Digest, Vec<<H as Hasher>::Digest>)], indexes: &[usize], ) -> BatchMerkleProof<H>

Constructs a batch Merkle proof from collection of single Merkle proofs.

Panics

Panics if:

• No proofs have been provided (i.e., proofs is an empty slice).
• Number of proofs is not equal to the number of indexes.
• Not all proofs have the same length.

pub fn get_root( &self, indexes: &[usize], leaves: &[H::Digest], ) -> Result<H::Digest, MerkleTreeError>

Computes a node to which all Merkle proofs aggregated in this proof resolve.

Errors

Returns an error if:

• No indexes were provided (i.e., indexes is an empty slice).
• Any of the specified indexes is greater than or equal to the number of leaves in the tree for which this batch proof was generated.
• List of indexes contains duplicates.
• The proof does not resolve to a single root.

pub fn into_openings( self, leaves: &[H::Digest], indexes: &[usize], ) -> Result<Vec<(<H as Hasher>::Digest, Vec<<H as Hasher>::Digest>)>, MerkleTreeError>

Computes the uncompressed individual Merkle proofs which aggregate to this batch proof.

Errors

Returns an error if:

• No indexes were provided (i.e., indexes is an empty slice).
• Number of provided indexes does not match the number of leaf nodes in the proof.

Trait Implementations

impl<H: Clone + Hasher> Clone for BatchMerkleProof<H>

where H::Digest: Clone,

fn clone(&self) -> BatchMerkleProof<H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H: Debug + Hasher> Debug for BatchMerkleProof<H>

where H::Digest: Debug,

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

Formats the value using the given formatter.

impl<H: Hasher> Deserializable for BatchMerkleProof<H>

fn read_from<R: ByteReader>( source: &mut R, ) -> Result<Self, DeserializationError>

Parses internal nodes from the provided source, and constructs a batch Merkle proof from these nodes.

Errors

Returns an error if:

• source could not be deserialized into a valid set of internal nodes.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

impl<H: PartialEq + Hasher> PartialEq for BatchMerkleProof<H>

where H::Digest: PartialEq,

fn eq(&self, other: &BatchMerkleProof<H>) -> 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<H: Hasher> Serializable for BatchMerkleProof<H>

fn write_into<W: ByteWriter>(&self, target: &mut W)

Writes all internal proof nodes into the provided target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl<H: Eq + Hasher> Eq for BatchMerkleProof<H>

where H::Digest: Eq,

impl<H: Hasher> StructuralPartialEq for BatchMerkleProof<H>