Struct VerifierMerkleTranscriptChannel 

pub struct VerifierMerkleTranscriptChannel<T, Challenger_, F, H: HashSuite> { /* private fields */ }

A MerkleIPVerifierChannel over a VerifierTranscript, verifying openings with a BinaryMerkleTreeScheme.

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: HashSuite> VerifierMerkleTranscriptChannel<T, Challenger_, F, H>

pub fn new(transcript: T) -> Self

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

pub const fn with_scheme( transcript: T, scheme: BinaryMerkleTreeScheme<F, H>, ) -> Self

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

pub fn into_transcript(self) -> T

Returns the wrapped transcript.

Trait Implementations

impl<T, Challenger_, F, H: HashSuite> GrindingVerifierChannel for VerifierMerkleTranscriptChannel<T, Challenger_, F, H>

where T: BorrowMut<VerifierTranscript<Challenger_>>, Challenger_: Challenger,

fn verify_grind(&mut self, bits: usize) -> Result<(), Error>

Checks the proof of work of bits difficulty standing at this point in the transcript.

impl<F, T, Challenger_, H> IPVerifierChannel<F> for VerifierMerkleTranscriptChannel<T, Challenger_, F, H>

where F: Field, T: BorrowMut<VerifierTranscript<Challenger_>>, Challenger_: Challenger, H: HashSuite,

type Elem = F

The element type returned by receive and sample methods.

fn recv_one(&mut self) -> Result<F, Error>

Receives a single field element from the prover.

fn recv_many(&mut self, n: usize) -> Result<Vec<F>, Error>

Receives n field elements from the prover.

fn recv_array<const N: usize>(&mut self) -> Result<[F; N], Error>

Receives a fixed-size array of field elements from the prover.

fn sample(&mut self) -> F

Samples a random challenge.

fn observe_one(&mut self, val: F) -> F

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

fn observe_many(&mut self, vals: &[F]) -> Vec<F>

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

fn assert_zero(&mut self, val: F) -> Result<(), Error>

Asserts that a value is zero.

fn recv_public_claim(&mut self) -> Result<Self::Elem, Error>

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

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

Samples n random challenges.

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

Samples a fixed-size array of random challenges.

impl<F, T, Challenger_, H> MerkleIPVerifierChannel<F> for VerifierMerkleTranscriptChannel<T, Challenger_, F, H>

where F: BinaryField + FixedSizeSerializeBytes, T: BorrowMut<VerifierTranscript<Challenger_>>, Challenger_: Challenger, H: HashSuite, Output<H::LeafHash>: DeserializeBytes,

type Commitment = TranscriptMerkleCommitment<Array<u8, <<H as HashSuite>::LeafHash as OutputSizeUser>::OutputSize>>

A Merkle commitment.

fn recv_merkle_commitment( &mut self, leaf_size: usize, depth: usize, ) -> Result<Self::Commitment, Error>

Receives a Merkle commitment for a tree with the given depth and leaf size.

fn recv_openings( &mut self, commitment: &Self::Commitment, indices: &[Word], ) -> Result<Vec<F>, Error>

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

fn recv_committed_vector( &mut self, commitment: &Self::Commitment, ) -> Result<Vec<F>, Error>

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

impl<F, T, Challenger_, H> WordIPVerifierChannel<F> for VerifierMerkleTranscriptChannel<T, Challenger_, F, H>

where F: BinaryField, T: BorrowMut<VerifierTranscript<Challenger_>>, Challenger_: Challenger, H: HashSuite,

type Word = Word

The word type this channel carries.

fn observe_words(&mut self, words: &[Word]) -> Vec<Word>

Feeds words into the Fiat-Shamir state, each as eight little-endian bytes, and returns them as this channel’s word type.

fn subset_sum(&mut self, elems: &[F], word: &Word) -> F

Returns the sum of the elems selected by the low bits of word, low bit first.

fn select(&mut self, elems: &[F], word: &Word) -> F

Returns the element of elems at the index in the low bits of word.

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

Samples a uniform word of the given bit width.

fn pack_words(&mut self, words: &[Word]) -> Vec<F>

Packs words into field elements, as many words to an element as one holds.