Struct BaseFoldProverChannel 

pub struct BaseFoldProverChannel<'a, F, P, NTT, Channel, A>
where
    F: BinaryField,
    P: PackedField<Scalar = F>,
    NTT: AdditiveNTT<Field = F> + Sync,
    Channel: MerkleIPProverChannel<F>,
    A: Allocator,
{ /* private fields */ }

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

This channel owns an [StdRng] and generates random masks internally during send_oracle. The caller provides only the raw witness buffer (not doubled). The channel handles:

• Generating a random mask of equal length
• Interleaving witness and mask for FRI commitment
• Running ZK BaseFold proofs in Self::finish

Type Parameters

• F: The binary field type
• P: The packed field type with Scalar = F
• NTT: The additive NTT for Reed-Solomon encoding
• Channel: The Merkle channel carrying all prover interaction
• A: The allocator the queued messages are drawn from, and the one Self::finish runs the opening with

Implementations

impl<'a, F, P, NTT, Channel, A> BaseFoldProverChannel<'a, F, P, NTT, Channel, A>

where F: BinaryField, P: PackedField<Scalar = F>, NTT: AdditiveNTT<Field = F> + Sync, Channel: MerkleIPProverChannel<F>, A: Allocator,

pub fn new( channel: Channel, ntt: &'a NTT, oracle_specs: Vec<OracleSpec>, fri_params: FRIParams<F>, rng: impl CryptoRng, alloc: A, ) -> Self

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

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

The RNG seeds the channel’s own generator, whose only output is the ZK masks. A mask is what hides a committed witness at the positions the verifier opens. Hiding is therefore only as strong as this RNG, so it must be a cryptographic one.

pub fn finish(self)

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

All oracle relations queued by prove_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). Mirrors BaseFoldVerifierChannel::finish.

Trait Implementations

impl<'a, F, P, NTT, Channel, A> IOPProverChannel<P, A> for BaseFoldProverChannel<'a, F, P, NTT, Channel, A>

where F: BinaryField, P: PackedField<Scalar = F>, NTT: AdditiveNTT<Field = F> + Sync, Channel: MerkleIPProverChannel<F>, A: Allocator,

type Oracle = BaseFoldOracle

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

Returns the specifications for the remaining oracles to be committed.

fn send_oracle(&mut self, buffer: FieldSlice<'_, P>) -> Self::Oracle

Commits an oracle to the verifier.

fn prove_oracle_relation( &mut self, oracle: Self::Oracle, transparent: StructuredBuffer<P, A::Vec<P>>, claim: P::Scalar, )

Generates an opening proof for one oracle linear relation.

fn finalize_oracle(&mut self, oracle: Self::Oracle, buffer: FieldVec<P, A>)

Gives ownership of the oracle buffer to the channel.

impl<'a, F, P, NTT, Channel, A> IPProverChannel<F> for BaseFoldProverChannel<'a, F, P, NTT, Channel, A>

where F: BinaryField, P: PackedField<Scalar = F>, NTT: AdditiveNTT<Field = F> + Sync, Channel: MerkleIPProverChannel<F>, 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 send_public_claim(&mut self, elem: F)

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

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 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, P, NTT, Channel, A> WordIPProverChannel<F> for BaseFoldProverChannel<'_, F, P, NTT, Channel, A>

where F: BinaryField, P: PackedField<Scalar = F>, NTT: AdditiveNTT<Field = F> + Sync, Channel: MerkleIPProverChannel<F>, A: Allocator,

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

The word type this channel carries.

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

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

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

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