Struct HashNodeSmt

pub struct HashNodeSmt<D> { /* private fields */ }

====================================================================================== A Hash SMT node for the top accumulator that carries just a hash value.

Implementations

impl<D> HashNodeSmt<D>

pub fn new(hash: Vec<u8>) -> HashNodeSmt<D>

Trait Implementations

impl<D: Clone> Clone for HashNodeSmt<D>

fn clone(&self) -> HashNodeSmt<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D: Debug> Debug for HashNodeSmt<D>

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

Formats the value using the given formatter.

impl<D: Default> Default for HashNodeSmt<D>

fn default() -> HashNodeSmt<D>

Returns the “default value” for a type.

impl<D: Digest> Mergeable for HashNodeSmt<D>

fn merge(lch: &HashNodeSmt<D>, rch: &HashNodeSmt<D>) -> HashNodeSmt<D>

A function to merge two child nodes as the parent node in the SMT.

impl<D: Digest> Paddable for HashNodeSmt<D>

fn padding(idx: &TreeIndex, secret: &Secret) -> HashNodeSmt<D>

When the tree node of the input index doesn’t exist, we need to construct a padding node at that position.

impl<D: Clone + Digest> PaddingProvable for HashNodeSmt<D>

type PaddingProof = HashNodeSmt<D>

The data type of the proof for a padding node.

fn prove_padding_node(&self, idx: &TreeIndex, secret: &Secret) -> HashNodeSmt<D>

Generate the proof for padding node at given tree index.

fn verify_padding_node( node: &<Self as ProofExtractable>::ProofNode, proof: &Self::PaddingProof, _idx: &TreeIndex, ) -> bool

Verify the proof for a padding node at given tree index with associated node data in the Merkle proof.

impl<D> PartialEq for HashNodeSmt<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: Clone> ProofExtractable for HashNodeSmt<D>

type ProofNode = HashNodeSmt<D>

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

fn get_proof_node(&self) -> Self::ProofNode

Extracting a proof node from a tree node.

impl<D: Digest> Rand for HashNodeSmt<D>

fn randomize(&mut self)

A function returning a random value of the corresponding type.

impl<D: Digest> Serializable for HashNodeSmt<D>

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

Encode the input object.

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

Decode some of the input bytes starting from the begin position as a Self object, possibly with some bytes at the end left.

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

where Self: Sized,

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

impl<D: TypeName> TypeName for HashNodeSmt<D>

fn get_name() -> String

A function returning the type name of tree nodes in the SMT for logging purpose.

impl<D> Eq for HashNodeSmt<D>