Struct ProverMerkleTranscriptChannel 

pub struct ProverMerkleTranscriptChannel<T, Challenger_, F, H: ParallelHashSuite, A: Allocator = GlobalAllocator> { /* private fields */ }

A MerkleIPProverChannel over a ProverTranscript, committing with a BinaryMerkleTreeProver.

The transcript is held through a BorrowMut bound, so the channel can own the transcript or mutably borrow one.

Implementations

impl<T, Challenger_, F, H: ParallelHashSuite> ProverMerkleTranscriptChannel<T, Challenger_, F, H>

pub fn new(transcript: T) -> Self

Constructs a channel over the transcript with a default Merkle tree prover.

impl<T, Challenger_, F, H: ParallelHashSuite, A: Allocator> ProverMerkleTranscriptChannel<T, Challenger_, F, H, A>

pub const fn with_merkle_prover( transcript: T, merkle_prover: BinaryMerkleTreeProver<F, H, A>, ) -> Self

Constructs a channel over the transcript with the given Merkle tree prover.

The prover carries the allocator every committed tree draws its nodes from.

pub fn into_transcript(self) -> T

Returns the wrapped transcript.

Trait Implementations

impl<T, Challenger_, F, H: ParallelHashSuite, A: Allocator> GrindingProverChannel for ProverMerkleTranscriptChannel<T, Challenger_, F, H, A>

where T: BorrowMut<ProverTranscript<Challenger_>>, Challenger_: Challenger + Clone,

fn grind(&mut self, bits: usize) -> u64

Searches for a nonce meeting bits of difficulty and writes it, returning the nonce.

impl<F, T, Challenger_, H, A> IPProverChannel<F> for ProverMerkleTranscriptChannel<T, Challenger_, F, H, A>

where F: Field, T: BorrowMut<ProverTranscript<Challenger_>>, Challenger_: Challenger, H: ParallelHashSuite, A: Allocator,

fn send_one(&mut self, elem: F)

Sends a single field element to the verifier.

fn send_many(&mut self, elems: &[F])

Sends multiple field elements to the verifier.

fn observe_one(&mut self, val: F)

Observes a single field element, feeding it into the Fiat-Shamir state.

fn observe_many(&mut self, vals: &[F])

Observes multiple field elements, feeding them into the Fiat-Shamir state.

fn sample(&mut self) -> F

Samples a random challenge.

fn send_public_claim(&mut self, elem: F)

Sends a value the verifier could compute for itself, as advice.

fn sample_many(&mut self, n: usize) -> Vec<F>

Samples n random challenges.

fn sample_array<const N: usize>(&mut self) -> [F; N]

Samples a fixed-size array of random challenges.

impl<F, T, Challenger_, H, A> MerkleIPProverChannel<F> for ProverMerkleTranscriptChannel<T, Challenger_, F, H, A>

where F: Field, T: BorrowMut<ProverTranscript<Challenger_>>, Challenger_: Challenger, H: ParallelHashSuite, A: Allocator, Output<H::LeafHash>: SerializeBytes,

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

A Merkle commitment, carrying the data required to open it later.

fn send_merkle_commitment<P: PackedField<Scalar = F>>( &mut self, data: FieldSlice<'_, P>, leaf_size: usize, ) -> Self::Commitment

Commits data as a Merkle tree with leaves of exactly leaf_size scalars each and sends the commitment.

fn send_openings<P: PackedField<Scalar = F>>( &mut self, commitment: &Self::Commitment, data: FieldSlice<'_, P>, indices: &[Word], )

Sends a multi-opening of committed leaves, bound by a Merkle commitment.

fn send_committed_vector<P: PackedField<Scalar = F>>( &mut self, commitment: &Self::Commitment, data: FieldSlice<'_, P>, )

Sends the full committed vector, bound by a Merkle commitment.

impl<F, T, Challenger_, H, A> WordIPProverChannel<F> for ProverMerkleTranscriptChannel<T, Challenger_, F, H, A>

where F: Field, T: BorrowMut<ProverTranscript<Challenger_>>, Challenger_: Challenger, H: ParallelHashSuite, A: Allocator,

type Word = Word

The word type this channel carries.

fn observe_words(&mut self, words: &[Word])

Feeds words into the Fiat-Shamir state, each as eight little-endian bytes.

fn sample_bits(&mut self, bits: usize) -> Word

Samples a uniform word of the given bit width, matching what the verifier samples.