Struct OperationProof 

pub struct OperationProof<F: Family, D: Digest, const N: usize> {
    pub loc: Location<F>,
    pub chunk: [u8; N],
    pub range_proof: RangeProof<F, D>,
}

A proof that a specific operation is currently active in the database.

Fields

loc: Location<F>

The location of the operation in the db.

chunk: [u8; N]

The status bitmap chunk that contains the bit corresponding the operation’s location.

range_proof: RangeProof<F, D>

The range proof that incorporates activity status for the operation designated by loc.

Implementations

impl<F: Graftable, D: Digest, const N: usize> OperationProof<F, D, N>

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

Return an inclusion proof that incorporates activity status for the operation designated by loc.

Errors

Returns Error::OperationPruned if loc falls in a pruned bitmap chunk.

impl<F: Graftable, D: Digest, const N: usize> OperationProof<F, D, N>

pub fn verify<H: CHasher<Digest = D>, O: Codec>( &self, hasher: &mut H, operation: O, root: &D, ) -> bool

Verify that the proof proves that operation is active in the database with the given root.

Trait Implementations

impl<F: Clone + Family, D: Clone + Digest, const N: usize> Clone for OperationProof<F, D, N>

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

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, const N: usize> Debug for OperationProof<F, D, N>

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

Formats the value using the given formatter.

impl<F: PartialEq + Family, D: PartialEq + Digest, const N: usize> PartialEq for OperationProof<F, D, N>

fn eq(&self, other: &OperationProof<F, D, N>) -> 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, const N: usize> Eq for OperationProof<F, D, N>

impl<F: Family, D: Digest, const N: usize> StructuralPartialEq for OperationProof<F, D, N>