Struct ReplayChannel 

pub struct ReplayChannel<F: Field> { /* private fields */ }

A channel that replays recorded interaction values through a WitnessGenerator, filling both inout and private wires in the outer witness.

This mirrors IronSpartanBuilderChannel but uses concrete evaluation instead of symbolic constraint building. Each operation consumes the next value and writes it to the corresponding inout wire in the WitnessGenerator. When the verifier’s arithmetic runs on the returned CircuitElem values, the WitnessGenerator fills private wires.

Implementations

impl<F: Field> ReplayChannel<F>

pub fn new(layout: Arc<WitnessLayout<F>>, keys: Vec<F>, events: Vec<F>) -> Self

Creates a new replay channel.

TODO: Document args. Keys are the symmetric OTP keys for the received values.

Takes a shared Arc<WitnessLayout<F>>, not a borrow. The backing WitnessGenerator must be 'static: its CircuitElems outlive this call. The Arc is a bumped reference count on the layout the config already owns, not a clone.

pub fn finish(self) -> Result<Witness<F>, WitnessError>

Consumes the channel and builds the outer witness.

Trait Implementations

impl<F: Field> IOPVerifierChannel<F> for ReplayChannel<F>

type Oracle = ()

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: Field> IPVerifierChannel<F> for ReplayChannel<F>

type Elem = CircuitElem<F, WitnessGenerator<F>>

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_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 assert_zero(&mut self, val: Self::Elem) -> Result<(), Error>

Asserts that a value is zero.

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 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.

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

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

impl<F: BinaryField> WordIPVerifierChannel<F> for ReplayChannel<F>

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: &[Self::Elem], word: &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: &Word) -> Self::Elem

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<Self::Elem>

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