Struct smtree::proof::MerkleProof

pub struct MerkleProof<V: Clone + Default + Mergeable + ProofExtractable> where
    <V as ProofExtractable>::ProofNode: Clone + Default + Eq + Mergeable + Serializable,  { /* fields omitted */ }

A proof depicts a Merkle path.

It consists of the tree index of the proved node, which indicates the path from the root to it, and the siblings of nodes along the path, excluding the root which doesn’t have a sibling.

Implementations

impl<V: Default + Clone + Mergeable + ProofExtractable> MerkleProof<V> where
    <V as ProofExtractable>::ProofNode: Clone + Default + Eq + Mergeable + Serializable, 

pub fn new(_idx: TreeIndex) -> MerkleProof<V>

The constructor for proof of a single node.

pub fn new_batch(idx: &[TreeIndex]) -> MerkleProof<V>

The constructor for a batched proof.

pub fn get_batch_num(&self) -> usize

Returns the number indexes in this proof.

pub fn get_indexes(&self) -> &[TreeIndex]

Returns the indexes of the proof.

pub fn get_path_siblings(&self) -> &[V::ProofNode]

Returns the siblings of nodes along the path.

pub fn get_siblings_num(&self) -> usize

Returns the number of siblings along the proof path.

pub fn get_sibling_at_idx(&self, idx: usize) -> &V::ProofNode

Returns the sibling of the node at input index.

For the single node proof, the sibling which is the child of the root has index 0, and the sibling of the proved node has the greatest index.

For a batched proof, the order of siblings follows the BFS order.

Panics if the input index is out of the range [0, siblings_num-1].

pub fn add_sibling(&mut self, value: V::ProofNode)

Add a sibling node at the end of the proof path.

pub fn set_siblings(&mut self, value: Vec<V::ProofNode>)

Set the sibling nodes.

pub fn verify(&self, leaf: &V::ProofNode, root: &V::ProofNode) -> bool

Verify a Merkle proof of a single node.

pub fn verify_batch(&self, leaves: &[V::ProofNode], root: &V::ProofNode) -> bool

Verify a batched Merkle proof.

Trait Implementations

impl<V: Clone + Default + Mergeable + ProofExtractable> Clone for MerkleProof<V> where
    <V as ProofExtractable>::ProofNode: Clone + Default + Eq + Mergeable + Serializable,
    V::ProofNode: Clone, 

fn clone(&self) -> MerkleProof<V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug + Clone + Default + Mergeable + ProofExtractable> Debug for MerkleProof<V> where
    <V as ProofExtractable>::ProofNode: Clone + Default + Eq + Mergeable + Serializable,
    V::ProofNode: Debug, 

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

Formats the value using the given formatter.

impl<V: Default + Clone + Mergeable + ProofExtractable> Default for MerkleProof<V> where
    <V as ProofExtractable>::ProofNode: Clone + Default + Eq + Mergeable + Serializable,
    V::ProofNode: Default, 

fn default() -> MerkleProof<V>

Returns the “default value” for a type.

impl<P: Clone + Default + Mergeable + Paddable + ProofExtractable> InclusionProvable for MerkleProof<P> where
    <P as ProofExtractable>::ProofNode: Clone + Default + Eq + Mergeable + Serializable, 

fn generate_inclusion_proof(
    tree: &Self::TreeStruct,
    list: &[TreeIndex]
) -> Option<Self>

Generate Merkle proof for a given list of nodes.

Return None if any of the input node doesn’t exist in the tree.

type ProofNodeType = <P as ProofExtractable>::ProofNode

The data type of a node with necessary information in Merkle proofs.

type TreeStruct = SparseMerkleTree<P>

The data type of the Merkle tree.

fn verify_inclusion_proof(
    &self,
    leaves: &[Self::ProofNodeType],
    root: &Self::ProofNodeType
) -> bool

Verify the inclusion proof according to the leave nodes and the root.

impl<V: Default + Clone + Mergeable + ProofExtractable> Serializable for MerkleProof<V> where
    <V as ProofExtractable>::ProofNode: Clone + Default + Eq + Mergeable + Serializable, 

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

Encode a proof in the format: batch_num || tree_indexes || sibling_num || siblings.

If the index list is empty, return empty vector.

fn deserialize_as_a_unit(
    bytes: &[u8],
    begin: &mut usize
) -> Result<MerkleProof<V>, DecodingError>

Decode input bytes (batch_num || tree_indexes || sibling_num || siblings) as a Merkle proof.

If there are bytes left, not used for decoding, or *begin != bytes.len() at the end of the execution, return DecodingError::TooManyEncodedBytes.

fn deserialize(bytes: &[u8]) -> Result<Self, DecodingError> where
    Self: Sized, 

Decode the input bytes as a Self object, using up all bytes.