Struct NaiveVerifierChannel 

pub struct NaiveVerifierChannel<'a, F, Challenger_>
where
    F: Field,
    Challenger_: Challenger,
{ /* private fields */ }

A naive verifier channel that reads full polynomial data from the transcript.

This channel wraps a VerifierTranscript and provides oracle operations by reading the entire polynomial coefficients from the transcript. This is useful for testing protocols without the complexity of FRI/BaseFold.

Type Parameters

• F: The field type
• Challenger_: The Fiat-Shamir challenger

Implementations

impl<'a, F, Challenger_> NaiveVerifierChannel<'a, F, Challenger_>

where F: Field, Challenger_: Challenger,

pub const fn new( transcript: &'a mut VerifierTranscript<Challenger_>, oracle_specs: &'a [OracleSpec], ) -> Self

Creates a new naive verifier channel.

Arguments

• transcript - The verifier transcript for Fiat-Shamir (borrowed mutably)
• oracle_specs - Specifications for each oracle to be received (borrowed)

pub const fn transcript(&self) -> &VerifierTranscript<Challenger_>

Returns a reference to the underlying transcript.

pub fn finish(self)

Consumes the channel, asserting all oracle specs have been consumed.

Trait Implementations

impl<F, Challenger_> IOPVerifierChannel<F> for NaiveVerifierChannel<'_, F, Challenger_>

where F: Field, Challenger_: Challenger,

type Oracle = NaiveOracle

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<F>, claim: F, ) -> Result<(), Error>

Queues one oracle linear relation to be opened.

impl<F, Challenger_> IPVerifierChannel<F> for NaiveVerifierChannel<'_, F, Challenger_>

where F: Field, Challenger_: Challenger,

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.