Struct BinaryMerkleTreeProver 

pub struct BinaryMerkleTreeProver<T, H, A = GlobalAllocator>
where
    H: ParallelHashSuite,
    A: Allocator,
{ /* private fields */ }

Builds Merkle trees over an allocator, which every tree it commits draws its nodes from.

The allocator is state rather than a per-call argument because MerkleTreeProver::Committed names the tree, and an associated type cannot depend on a method’s generic parameter.

Implementations

impl<T, H, A> BinaryMerkleTreeProver<T, H, A>

where H: ParallelHashSuite, A: Allocator,

pub fn scheme(&self) -> &BinaryMerkleTreeScheme<T, H>

impl<T, H> BinaryMerkleTreeProver<T, H>

where H: ParallelHashSuite,

pub fn new() -> BinaryMerkleTreeProver<T, H>

Commits trees on the global heap.

impl<T, H, A> BinaryMerkleTreeProver<T, H, A>

where H: ParallelHashSuite, A: Allocator,

pub fn with_allocator(alloc: A) -> BinaryMerkleTreeProver<T, H, A>

Commits trees whose nodes are drawn from alloc.

Pass &BufferPool to recycle node buffers across the proofs one prover runs.

Trait Implementations

impl<T, H> Default for BinaryMerkleTreeProver<T, H>

where H: ParallelHashSuite,

fn default() -> BinaryMerkleTreeProver<T, H>

Returns the “default value” for a type.

impl<F, H, A> MerkleTreeProver<F> for BinaryMerkleTreeProver<F, H, A>

where F: Field, H: ParallelHashSuite, A: Allocator,

type Scheme = BinaryMerkleTreeScheme<F, H>

type Committed = BinaryMerkleTree<Array<u8, <<H as HashSuite>::LeafHash as OutputSizeUser>::OutputSize>, A>

Data generated during commitment required to generate opening proofs.

fn scheme( &self, ) -> &<BinaryMerkleTreeProver<F, H, A> as MerkleTreeProver<F>>::Scheme

Returns the Merkle tree scheme used by the prover.

fn layer<'a>( &self, committed: &'a <BinaryMerkleTreeProver<F, H, A> as MerkleTreeProver<F>>::Committed, depth: usize, ) -> &'a [Array<u8, <<H as HashSuite>::LeafHash as OutputSizeUser>::OutputSize>]

Returns the internal digest layer at the given depth.

fn prove_opening<B>( &self, committed: &<BinaryMerkleTreeProver<F, H, A> as MerkleTreeProver<F>>::Committed, layer_depth: usize, index: usize, proof: &mut TranscriptWriter<'_, B>, )

where B: BufMut,

Generate an opening proof for an entry in a committed vector at the given index.

fn commit_iterated<ParIter>( &self, leaves: ParIter, n_items_per_input: usize, ) -> (Commitment<<<BinaryMerkleTreeProver<F, H, A> as MerkleTreeProver<F>>::Scheme as MerkleTreeScheme<F>>::Digest>, <BinaryMerkleTreeProver<F, H, A> as MerkleTreeProver<F>>::Committed)

where ParIter: IndexedParallelIterator, <ParIter as ParallelIterator>::Item: IntoIterator<Item = F>, <<ParIter as ParallelIterator>::Item as IntoIterator>::IntoIter: Send,

Commit interleaved elements from iterator by val

fn commit( &self, data: &[T], batch_size: usize, ) -> (Commitment<<Self::Scheme as MerkleTreeScheme<T>>::Digest>, Self::Committed)

where T: Clone + Sync,

Commit a vector of values.

fn commit_field_buffer<P>( &self, buffer: FieldBuffer<P, FieldSliceData<'_, P>>, log_leaf_len: usize, ) -> (Commitment<<Self::Scheme as MerkleTreeScheme<T>>::Digest>, Self::Committed)

where P: PackedField<Scalar = T>,

Commits a field buffer, packing 2^log_leaf_len scalars into each leaf.