Enum nmt_rs::nmt_proof::NamespaceProof

pub enum NamespaceProof<M: MerkleHash, const NS_ID_SIZE: usize> {
    AbsenceProof {
        proof: Proof<M>,
        ignore_max_ns: bool,
        leaf: Option<NamespacedHash<NS_ID_SIZE>>,
    },
    PresenceProof {
        proof: Proof<M>,
        ignore_max_ns: bool,
    },
}

A proof of some statement about a namespaced merkle tree.

This proof may prove the presence of some set of leaves, or the absence of a particular namespace

Variants

AbsenceProof

A proof that some item is absent from the tree

Fields

proof: Proof<M>

The range proof against the inner merkle tree

ignore_max_ns: bool

Whether to treat the maximum possible namespace as a special marker value and ignore it in computing namespace ranges

leaf: Option<NamespacedHash<NS_ID_SIZE>>

A leaf that is present in the tree, if the namespace being proven absent falls within the namespace range covered by the root.

PresenceProof

A proof that some item is included in the tree

Fields

proof: Proof<M>

The range proof against the inner merkle tree

ignore_max_ns: bool

Whether to treat the maximum possible namespace as a special marker value and ignore it in computing namespace ranges

Implementations

impl<M, const NS_ID_SIZE: usize> NamespaceProof<M, NS_ID_SIZE>

where M: NamespaceMerkleHasher<NS_ID_SIZE, Output = NamespacedHash<NS_ID_SIZE>>,

pub fn verify_complete_namespace( &self, root: &NamespacedHash<NS_ID_SIZE>, raw_leaves: &[impl AsRef<[u8]>], namespace: NamespaceId<NS_ID_SIZE>, ) -> Result<(), RangeProofError>

Verify that the provided raw leaves are a complete namespace. This may be a proof of presence or absence.

pub fn verify_range( &self, root: &NamespacedHash<NS_ID_SIZE>, raw_leaves: &[impl AsRef<[u8]>], leaf_namespace: NamespaceId<NS_ID_SIZE>, ) -> Result<(), RangeProofError>

Verify a that the provided raw leaves are a (1) present and (2) form a contiguous subset of some namespace

pub fn convert_to_absence_proof(&mut self, leaf: NamespacedHash<NS_ID_SIZE>)

Convert a proof of the presence of some leaf to the proof of the absence of another leaf

pub fn siblings(&self) -> &[NamespacedHash<NS_ID_SIZE>]

Returns the siblings provided as part of the proof

pub fn start_idx(&self) -> u32

Returns the index of the first leaf in the proof

pub fn end_idx(&self) -> u32

Returns the index after the last leaf in the proof

pub fn leftmost_right_sibling(&self) -> Option<&NamespacedHash<NS_ID_SIZE>>

Returns the leftmost node to the right of the proven range, if one exists

pub fn rightmost_left_sibling(&self) -> Option<&NamespacedHash<NS_ID_SIZE>>

Returns the rightmost node to the left of the proven range, if one exists

pub fn is_of_absence(&self) -> bool

Returns true if the proof is an absence proof

pub fn is_of_presence(&self) -> bool

Returns true if the proof is a presence proof

Trait Implementations

impl<M: Clone + MerkleHash, const NS_ID_SIZE: usize> Clone for NamespaceProof<M, NS_ID_SIZE>

fn clone(&self) -> NamespaceProof<M, NS_ID_SIZE>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: Debug + MerkleHash, const NS_ID_SIZE: usize> Debug for NamespaceProof<M, NS_ID_SIZE>

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

Formats the value using the given formatter.

impl<M: PartialEq + MerkleHash, const NS_ID_SIZE: usize> PartialEq for NamespaceProof<M, NS_ID_SIZE>

fn eq(&self, other: &NamespaceProof<M, NS_ID_SIZE>) -> 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<M: MerkleHash, const NS_ID_SIZE: usize> StructuralPartialEq for NamespaceProof<M, NS_ID_SIZE>