Struct RangeProof 

pub struct RangeProof<F: Graftable, D: Digest> {
    pub proof: Proof<F, D>,
    pub pending_chunk_digest: F::PendingChunk<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.

pending_chunk_digest: F::PendingChunk<D>

The pending-chunk contribution, if any.

partial_chunk_digest: Option<D>

Digest of the bitmap’s trailing partial chunk, if any.

ops_root: D

The ops-tree root digest.

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: &StandardHasher<H>, status: &impl BitmapReadable<N>, storage: &S, inactivity_floor: Location<F>, 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: &StandardHasher<H>, status: &impl BitmapReadable<N>, storage: &S, log: &C, request: RangeProofSpec<F, 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 tree.

pub fn verify<H: CHasher<Digest = D>, O: Codec, const N: usize>( &self, root_hasher: &StandardHasher<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 + Graftable, D: Clone + Digest> Clone for RangeProof<F, D>

where F::PendingChunk<D>: Clone,

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 + Graftable, D: Debug + Digest> Debug for RangeProof<F, D>

where F::PendingChunk<D>: Debug,

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

Formats the value using the given formatter.

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

fn encode_size(&self) -> usize

Returns the encoded size of this value (in bytes).

fn encode_inline_size(&self) -> usize

Returns the encoded size excluding bytes passed to BufsMut::push during Write::write_bufs. Used to size the working buffer for inline writes. Override alongside Write::write_bufs for types where large Bytes fields go via push; failing to do so will over-allocate.

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

where F::PendingChunk<D>: PartialEq,

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: Graftable, D: Digest> Read for RangeProof<F, D>

type Cfg = usize

The maximum number of digests in the embedded Merkle proof.

fn read_cfg(buf: &mut impl Buf, max_digests: &Self::Cfg) -> Result<Self, Error>

Reads a value from the buffer using the provided configuration cfg.

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

fn write(&self, buf: &mut impl BufMut)

Writes the binary representation of self to the provided buffer buf.

fn write_bufs(&self, buf: &mut impl BufsMut)

Writes to a BufsMut, allowing existing Bytes chunks to be appended via BufsMut::push instead of written inline. Must encode to the same format as Write::write. Defaults to Write::write.

impl<F: Eq + Graftable, D: Eq + Digest> Eq for RangeProof<F, D>

where F::PendingChunk<D>: Eq,

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