Struct BinaryMerkleTreeProver 

pub struct BinaryMerkleTreeProver<T, H: ParallelHashSuite, A: Allocator = GlobalAllocator> { /* 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: ParallelHashSuite, A: Allocator> BinaryMerkleTreeProver<T, H, A>

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

impl<T, H: ParallelHashSuite> BinaryMerkleTreeProver<T, H, GlobalAllocator>

pub fn new() -> Self

Commits trees on the global heap.

impl<T, H: ParallelHashSuite, A: Allocator> BinaryMerkleTreeProver<T, H, A>

pub fn with_allocator(alloc: A) -> Self

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: ParallelHashSuite> Default for BinaryMerkleTreeProver<T, H, GlobalAllocator>

fn default() -> Self

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) -> &Self::Scheme

Returns the Merkle tree scheme used by the prover.

fn layer<'a>( &self, committed: &'a Self::Committed, depth: usize, ) -> &'a [Output<H::LeafHash>]

Returns the internal digest layer at the given depth.

fn prove_opening<B: BufMut>( &self, committed: &Self::Committed, layer_depth: usize, index: usize, proof: &mut TranscriptWriter<'_, B>, )

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<ProverDigest<F, Self>>, Self::Committed)

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

Commit interleaved elements from iterator by val

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

where T: Clone + Sync,

Commit a vector of values.

fn commit_field_buffer<P>( &self, buffer: FieldSlice<'_, P>, log_leaf_len: usize, ) -> (Commitment<ProverDigest<T, Self>>, Self::Committed)

where P: PackedField<Scalar = T>,

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