Struct Verifier 

pub struct Verifier<'a, F: Graftable, H: Hasher> { /* private fields */ }

A merkle::hasher::Hasher implementation used for verifying proofs over grafted storage.

The ops structure uses family F, so this implements merkle::hasher::Hasher for that family to match the proof. Proof verification walks the tree from leaves to root, recomputing digests at each node. Since a proof path crosses the grafting boundary (from ops leaves up through grafted peaks), two different hashing behaviors are needed depending on the node’s height relative to the grafting height:

• Below or above: standard hash using ops-space positions (F).
• At: the children form an ops subtree root, which is combined with a bitmap chunk element to reconstruct the grafted leaf digest.

Implementations

impl<'a, F: Graftable, H: Hasher> Verifier<'a, F, H>

pub const fn new( grafting_height: u32, start_chunk_index: u64, chunks: Vec<&'a [u8]>, graftable_chunks: u64, ) -> Self

Create a new verifier using QMDB’s fixed Merkle hasher configuration.

start_chunk_index is the chunk index corresponding to chunks[0]. graftable_chunks is the number of chunks committed by the grafted tree; any chunk index in chunks at or beyond this boundary is treated as pending and not combined with the ops subtree root at the grafting height.

Trait Implementations

impl<'a, F: Clone + Graftable, H: Clone + Hasher> Clone for Verifier<'a, F, H>

fn clone(&self) -> Verifier<'a, F, H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Graftable, H: Hasher> Hasher<F> for Verifier<'_, F, H>

type Digest = <H as Hasher>::Digest

fn hash<'a>(&self, parts: impl IntoIterator<Item = &'a [u8]>) -> H::Digest

Hash an arbitrary sequence of byte slices into a single digest.

fn root_bagging(&self) -> Bagging

The bagging policy applied when this hasher folds peaks into a root. Only affects root peak aggregation; hash, leaf_digest, and node_digest are unaffected.

fn node_digest( &self, pos: Position<F>, left_digest: &H::Digest, right_digest: &H::Digest, ) -> H::Digest

Computes the digest for a node given its position and the digests of its children.

fn leaf_digest(&self, pos: Position<F>, element: &[u8]) -> Self::Digest

Computes the digest for a leaf given its position and the element it represents.

fn digest(&self, data: &[u8]) -> Self::Digest

Compute the digest of a byte slice.

fn fold(&self, acc: &Self::Digest, peak: &Self::Digest) -> Self::Digest

Folds a peak digest into a running accumulator: Hash(acc || peak).

fn root<'a, I>( &self, leaves: Location<F>, inactive_peaks: usize, peak_digests: I, ) -> Result<Self::Digest, Error<F>>

where I: IntoIterator<Item = &'a Self::Digest>, I::IntoIter: ExactSizeIterator,

Computes a root using inactive_peaks and the bagging policy carried by self.

fn root_with_folded_peaks<'a>( &self, leaves: Location<F>, inactive_peaks_to_fold: usize, committed_inactive_peaks: usize, peak_digests: impl IntoIterator<Item = &'a Self::Digest>, ) -> Option<Self::Digest>

Computes a root from a peak list that may already contain a forward-folded prefix accumulator. The bagging policy is read from self.root_bagging().