Struct BaseFoldVerifierChannel 

pub struct BaseFoldVerifierChannel<'a, F, Channel>
where
    F: BinaryField,
    Channel: MerkleIPVerifierChannel<F, Elem: From<F> + 'static>,
{ /* private fields */ }

A verifier channel that uses ZK BaseFold for all oracle commitments and openings.

This channel always applies zero-knowledge blinding. The FRI parameters must be set up with log_batch_size = 1 and log_msg_len = witness_log_len + 1 to account for the mask.

Type Parameters

• 'a: Lifetime for borrowed references
• F: The binary field type
• Channel: The Merkle channel carrying all prover interaction

Implementations

impl<'a, F, Channel> BaseFoldVerifierChannel<'a, F, Channel>

where F: BinaryField, Channel: MerkleIPVerifierChannel<F, Elem: From<F> + 'static>,

pub const fn new( channel: Channel, oracle_specs: &'a [OracleSpec], fri_params: &'a FRIParams<F>, ) -> Self

Creates a new BaseFold ZK verifier channel over a Merkle channel from precomputed FRI parameters.

The FRI parameters should already account for ZK (log_batch_size = 1, doubled message length).

pub fn finish(self) -> Result<Channel, Error>

Consumes the channel and verifies the single combined opening over all committed oracles.

All oracle relations queued by verify_oracle_relation across every call are processed here in one batch: masking, one batched sumcheck reducing the masked claims to a shared point r, then one combined FRI opening over every committed oracle (in oracle-index order). Because the whole opening is deferred to this point, every oracle is committed and there is a single sumcheck point, so the precomputed combined FRIParams (optimal_for_batch over all oracle specs) serves the opening.

Returns the Merkle channel, so a caller can still reach what it accumulated.

Trait Implementations

impl<'a, F, Channel> IOPVerifierChannel<F> for BaseFoldVerifierChannel<'a, F, Channel>

where F: BinaryField, Channel: MerkleIPVerifierChannel<F, Elem: From<F> + 'static>,

type Oracle = BaseFoldOracle

fn remaining_oracle_specs(&self) -> &[OracleSpec]

Returns the specifications for the remaining oracles to be received.

fn recv_oracle( &mut self, _log_msg_len: usize, _is_witness_dependent: bool, ) -> Result<Self::Oracle, Error>

Receives an oracle commitment from the prover.

fn verify_oracle_relation( &mut self, oracle: Self::Oracle, transparent: TransparentEvalFn<Self::Elem>, claim: Self::Elem, ) -> Result<(), Error>

Queues one oracle linear relation to be opened.

impl<F, Channel> IPVerifierChannel<F> for BaseFoldVerifierChannel<'_, F, Channel>

where F: BinaryField, Channel: MerkleIPVerifierChannel<F, Elem: From<F> + 'static>,

type Elem = <Channel as IPVerifierChannel<F>>::Elem

The element type returned by receive and sample methods.

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

Receives a single field element from the prover.

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

Receives n field elements from the prover.

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

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

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

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

fn sample(&mut self) -> Self::Elem

Samples a random challenge.

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

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

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

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

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

Asserts that a value is zero.

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, Channel> WordIPVerifierChannel<F> for BaseFoldVerifierChannel<'_, F, Channel>

where F: BinaryField, Channel: MerkleIPVerifierChannel<F, Elem: From<F> + 'static>,

type Word = <Channel as WordIPVerifierChannel<F>>::Word

The word type this channel carries.

fn observe_words(&mut self, words: &[Word]) -> Vec<Self::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: &[Self::Elem], word: &Self::Word) -> Self::Elem

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

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

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

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

Samples a uniform word of the given bit width.

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

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