Struct BatchMerkleProof 

pub struct BatchMerkleProof<H>
where
    H: Hasher,
{
    pub nodes: Vec<Vec<<H as Hasher>::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 as Hasher>::Digest>>

Hashes of Merkle Tree proof values above the leaf layer

depth: u8

Depth of the leaves

Implementations

impl<H> BatchMerkleProof<H>

where H: Hasher,

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 as Hasher>::Digest], ) -> Result<<H as Hasher>::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 as Hasher>::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 for BatchMerkleProof<H>

where H: Clone + Hasher, <H as Hasher>::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 for BatchMerkleProof<H>

where H: Debug + Hasher, <H as Hasher>::Digest: Debug,

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

Formats the value using the given formatter.

impl<H> Deserializable for BatchMerkleProof<H>

where H: Hasher,

fn read_from<R>( source: &mut R, ) -> Result<BatchMerkleProof<H>, DeserializationError>

where R: ByteReader,

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> Eq for BatchMerkleProof<H>

where H: Eq + Hasher, <H as Hasher>::Digest: Eq,

impl<H> PartialEq for BatchMerkleProof<H>

where H: PartialEq + Hasher, <H as Hasher>::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> Serializable for BatchMerkleProof<H>

where H: Hasher,

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

where W: ByteWriter,

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> StructuralPartialEq for BatchMerkleProof<H>

where H: Hasher,