Struct celestia_types::nmt::NamespaceProof

pub struct NamespaceProof(/* private fields */);

Merkle proof of inclusion or absence of some data in the Nmt.

Example

use nmt_rs::NamespaceMerkleHasher;
use celestia_types::nmt::{Namespace, Nmt, NamespacedSha2Hasher, EMPTY_LEAVES};

let ns1 = Namespace::new_v0(&[1]).unwrap();
let ns2 = Namespace::new_v0(&[2]).unwrap();
let ns3 = Namespace::new_v0(&[3]).unwrap();
let ns4 = Namespace::new_v0(&[4]).unwrap();

let leaves = [
    (ns1, b"leaf0"),
    (ns2, b"leaf1"),
    (ns2, b"leaf2"),
    (ns4, b"leaf3"),
];

// create the nmt and feed it with data
let mut nmt = Nmt::with_hasher(NamespacedSha2Hasher::with_ignore_max_ns(true));

for (namespace, data) in leaves {
    nmt.push_leaf(data, *namespace);
}

// create and verify the proof of inclusion of namespace 2 data
let root = nmt.root();
let proof = nmt.get_namespace_proof(*ns2);
assert!(proof.is_of_presence());
assert!(
    proof.verify_complete_namespace(&root, &["leaf1", "leaf2"], *ns2).is_ok()
);

// create and verify the proof of absence of namespace 3 data
let proof = nmt.get_namespace_proof(*ns3);
assert!(proof.is_of_absence());
assert!(
    proof.verify_complete_namespace(&root, EMPTY_LEAVES, *ns3).is_ok()
);

Implementations

impl NamespaceProof

pub fn into_inner(self) -> NamespaceProof<NamespacedSha2Hasher, NS_SIZE>

Convert the proof to the underlying nmt_rs equivalent.

pub fn leaf(&self) -> Option<&NamespacedHash>

Get the hash of the leaf following the Namespace which absence is being proven.

If the tree had contained the proven namespace, it should be in the tree right before the leaf returned by this function.

This function returns None if the proof isn’t an AbsenceProof or the proven Namespace is not in the range of the tree root NamespacedHash.

pub fn max_ns_ignored(&self) -> bool

Returns true if the proof ignores all the leaves inserted with Namespace::PARITY_SHARE.

Methods from Deref<Target = NamespaceProof<NamespacedSha2Hasher, NS_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 Clone for NamespaceProof

fn clone(&self) -> NamespaceProof

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NamespaceProof

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

Formats the value using the given formatter.

impl Deref for NamespaceProof

type Target = NamespaceProof<NamespacedSha2Hasher<NS_SIZE>, NS_SIZE>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for NamespaceProof

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for NamespaceProof

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<NamespaceProof<NamespacedSha2Hasher<NS_SIZE>, NS_SIZE>> for NamespaceProof

fn from(value: NamespaceProof<NamespacedSha2Hasher, NS_SIZE>) -> NamespaceProof

Converts to this type from the input type.

impl From<NamespaceProof> for NamespaceProof<NamespacedSha2Hasher, NS_SIZE>

fn from(value: NamespaceProof) -> NamespaceProof<NamespacedSha2Hasher, NS_SIZE>

Converts to this type from the input type.

impl From<NamespaceProof> for Proof

fn from(value: NamespaceProof) -> Self

Converts to this type from the input type.

impl PartialEq for NamespaceProof

fn eq(&self, other: &NamespaceProof) -> 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 Protobuf<Proof> for NamespaceProof

fn encode<B>(&self, buf: &mut B) -> Result<(), Error>

where B: BufMut,

Encode into a buffer in Protobuf format.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), Error>

where B: BufMut,

Encode with a length-delimiter to a buffer in Protobuf format.

fn decode<B>(buf: B) -> Result<Self, Error>

where B: Buf,

Constructor that attempts to decode an instance from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, Error>

where B: Buf,

Constructor that attempts to decode a length-delimited instance from the buffer.

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn encode_vec(&self) -> Result<Vec<u8>, Infallible>

Encodes into a Protobuf-encoded Vec<u8>.

fn decode_vec(v: &[u8]) -> Result<Self, Error>

Constructor that attempts to decode a Protobuf-encoded instance from a Vec<u8> (or equivalent).

fn encode_length_delimited_vec(&self) -> Result<Vec<u8>, Infallible>

Encode with a length-delimiter to a Vec<u8> Protobuf-encoded message.

fn decode_length_delimited_vec(v: &[u8]) -> Result<Self, Error>

Constructor that attempts to decode a Protobuf-encoded instance with a length-delimiter from a Vec<u8> or equivalent.

impl Serialize for NamespaceProof

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Proof> for NamespaceProof

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: RawProof) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for NamespaceProof