Struct RangeProof 

pub struct RangeProof<F: Family, D: Digest> {
    pub proof: Proof<F, D>,
    pub pre_prefix_acc: Option<D>,
    pub unfolded_prefix_peaks: Vec<D>,
    pub partial_chunk_digest: Option<D>,
    pub ops_root: D,
}

A proof that a range of operations exist in the database.

Fields

proof: Proof<F, D>

The Merkle digest material required to verify the proof.

pre_prefix_acc: Option<D>

The single folded accumulator of all aligned prefix peaks that do not require unfolding.

unfolded_prefix_peaks: Vec<D>

Individual fold-prefix peak digests, in peak order, when the generic proof’s single folded prefix accumulator would otherwise hide multi-peak chunk structure needed for grafted-root reconstruction.

partial_chunk_digest: Option<D>

The partial chunk digest from the status bitmap at the time of proof generation, if any.

ops_root: D

The ops-tree root at the time of proof generation. Needed by the verifier to reconstruct the canonical root.

Implementations

impl<F: Graftable, D: Digest> RangeProof<F, D>

pub async fn new<H: CHasher<Digest = D>, S: Storage<F, Digest = D>, const N: usize>( hasher: &mut H, status: &impl BitmapReadable<N>, storage: &S, range: Range<Location<F>>, ops_root: D, ) -> Result<Self, Error<F>>

Create a new range proof for the provided range of operations.

pub async fn new_with_ops<H: CHasher<Digest = D>, C: Contiguous, S: Storage<F, Digest = D>, const N: usize>( hasher: &mut H, status: &impl BitmapReadable<N>, storage: &S, log: &C, start_loc: Location<F>, max_ops: NonZeroU64, ops_root: D, ) -> Result<(Self, Vec<C::Item>, Vec<[u8; N]>), Error<F>>

Returns a proof that the specified range of operations are part of the database, along with the operations from the range and their activity status chunks. A truncated range (from hitting the max) can be detected by looking at the length of the returned operations vector.

Errors

Returns Error::OperationPruned if start_loc falls in a pruned bitmap chunk. Returns merkle::Error::LocationOverflow if start_loc > merkle::Family::MAX_LEAVES. Returns merkle::Error::RangeOutOfBounds if start_loc >= number of leaves in the MMR.

impl<F: Graftable, D: Digest> RangeProof<F, D>

pub fn verify<H: CHasher<Digest = D>, O: Codec, const N: usize>( &self, hasher: &mut H, start_loc: Location<F>, ops: &[O], chunks: &[[u8; N]], root: &H::Digest, ) -> bool

Return true if the given sequence of ops were applied starting at location start_loc in the db with the provided root, and having the activity status described by chunks.

Trait Implementations

impl<F: Clone + Family, D: Clone + Digest> Clone for RangeProof<F, D>

fn clone(&self) -> RangeProof<F, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Family, D: Debug + Digest> Debug for RangeProof<F, D>

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

Formats the value using the given formatter.

impl<F: PartialEq + Family, D: PartialEq + Digest> PartialEq for RangeProof<F, D>

fn eq(&self, other: &RangeProof<F, D>) -> 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<F: Eq + Family, D: Eq + Digest> Eq for RangeProof<F, D>

impl<F: Family, D: Digest> StructuralPartialEq for RangeProof<F, D>