Struct smtree::proof::RandomSamplingProof

pub struct RandomSamplingProof<V: Clone + Default + Mergeable + ProofExtractable + Paddable + PaddingProvable> where
    V::ProofNode: Default + Eq + Clone + Mergeable + Serializable,
    V::PaddingProof: Default + Eq + Clone + Serializable,  { /* fields omitted */ }

A random sampling proof proves that the result of random sampling is valid.

It consists of the tree index of the proved node, and the proofs of certain padding nodes, and a standard Merkle proof.

If the sampled index exists as a real leaf node (non-padding) in the tree, no padding nodes will be proved but just a standard Merkle proof for the sampled index.

If the sampled index doesn’t exist as a real leaf node (non-padding) in the tree, proofs of necessary padding nodes between the two closest neighbours of the sampled index are included in the proof, and the Merkle proof proves inclusion of the closest neighbours.

Implementations

impl<V: Clone + Default + Mergeable + Paddable + PaddingProvable + ProofExtractable> RandomSamplingProof<V> where
    V::ProofNode: Default + Eq + Clone + Mergeable + Serializable,
    V::PaddingProof: Default + Eq + Clone + Serializable, 

pub fn new(
    index: TreeIndex,
    padding_proofs: Vec<V::PaddingProof>,
    merkle_proof: MerkleProof<V>,
    leaves: Vec<V::ProofNode>
) -> RandomSamplingProof<V>

The constructor.

pub fn get_merkle_proof(&self) -> &MerkleProof<V>

Returns the Merkle proof.

pub fn get_index(&self) -> &TreeIndex

Returns the index of the proof.

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

Returns the leaf nodes.

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

Set the leaf node in the proof of a single node.

pub fn set_leaves(&mut self, value: &[V::ProofNode])

Set the leaf nodes in a batched proof.

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

Add a leaf node in a batched proof.

pub fn add_padding_proof(&mut self, proof: V::PaddingProof)

Adds the proof of a new padding node.

pub fn set_padding_proofs(&mut self, proofs: Vec<V::PaddingProof>)

Set the padding proofs as the input.

Trait Implementations

impl<V: Default + Clone + Mergeable + ProofExtractable + Paddable + PaddingProvable> Default for RandomSamplingProof<V> where
    V::ProofNode: Default + Eq + Clone + Mergeable + Serializable,
    V::PaddingProof: Default + Eq + Clone + Serializable,
    V::ProofNode: Default, 

fn default() -> RandomSamplingProof<V>

Returns the “default value” for a type.

impl<V: Clone + Default + Mergeable + Paddable + PaddingProvable + ProofExtractable> RandomSampleable for RandomSamplingProof<V> where
    V::ProofNode: Default + Eq + Clone + Mergeable + Serializable,
    V::PaddingProof: Default + Eq + Clone + Serializable, 

fn verify_random_sampling_proof(&self, root: &Self::ProofNodeType) -> bool

Verify the padding node proofs with the supporting Merkle proof for random sampling. For usage, before calling this method, the input Merkle proof needs to be verified.

type ProofNodeType = V::ProofNode

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

type TreeStruct = SparseMerkleTree<V>

The data type of the Merkle tree.

fn random_sampling(
    tree: &Self::TreeStruct,
    idx: &TreeIndex,
    secret: &Secret
) -> Self

Random sampling. Returns the random sampling proof of the input index.

impl<V: Clone + Default + Mergeable + Paddable + PaddingProvable + ProofExtractable> Serializable for RandomSamplingProof<V> where
    V::ProofNode: Default + Eq + Clone + Mergeable + Serializable,
    V::PaddingProof: Default + Eq + Clone + Serializable, 

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

Encode a proof in the format: tree_index || padding_num || padding_proofs || merkle_proof || leaves.

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

Decode input bytes (tree_index || padding_num || padding_proofs || merkle_proof || leaves) as a Padding proof.

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

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