Struct ZKWrappedVerifierChannel 

pub struct ZKWrappedVerifierChannel<'a, F, Channel>
where
    F: BinaryField,
    Channel: MerkleIPVerifierChannel<F, Elem = F>,
{ /* private fields */ }

A verifier channel that wraps a BaseFoldVerifierChannel and an IOPVerifier.

Self::Elem = CircuitElem<F, InstanceGenerator>. F values received or sampled from the inner channel are written into the InstanceGenerator’s public segment as inout wires (in the same order the symbolic IronSpartanBuilderChannel allocates them); arithmetic over public values produces derived public values, and mixing with a precommit key (as recv_one arranges via inout - key) yields a value-less private result.

transparent closures supplied to IOPVerifierChannel::verify_oracle_relation must depend only on public inputs (constants and sampled challenges), never on private ones — that method panics otherwise.

Implementations

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

where F: BinaryField, Channel: MerkleIPVerifierChannel<F, Elem = F>,

pub fn new( inner_channel: BaseFoldVerifierChannel<'a, F, Channel>, outer_verifier: &'a IOPVerifier<F>, outer_layout: Arc<WitnessLayout<F>>, ) -> Result<Self, Error>

Creates a new ZK-wrapped verifier channel.

The outer verifier’s oracle specs are expected to straddle the inner channel specs: the outer precommit spec is at position 0 (committed before any inner interaction), and the remaining outer specs (private, mask) form a suffix that will be received after the inner verification completes. new receives the outer precommit oracle from the inner channel and stores the handle for use in Self::finish.

outer_layout is the witness layout of the outer constraint system (the same layout the prover used); it backs the InstanceGenerator that reconstructs the public-input vector. It is a shared Arc, not a borrow, so the generator is 'static. Its CircuitElems live in the transparent closures queued onto inner_channel. The Arc shares the layout the config owns rather than cloning it.

Panics

Panics if the channel’s oracle specs do not match the expected layout [outer_precommit, inner..., outer_private, outer_mask].

pub const fn public_value( &self, elem: &CircuitElem<F, InstanceGenerator<F>>, ) -> Option<F>

The value of an element, when the verifier holds it.

A constant, an inout wire, or anything derived from those alone has a value here; an element that reads a precommit wire has none. This is what lets a check over public values run outside the wrapper circuit — the verifier evaluates it directly instead of constraining it.

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

Consumes the channel and runs the outer verifier.

Reads the outer public-input vector [constants | inout | derived] from the InstanceGenerator and runs IOPVerifier::verify against the inner channel.

Trait Implementations

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

where F: BinaryField, Channel: MerkleIPVerifierChannel<F, Elem = F>,

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<'a, F, Channel> IPVerifierChannel<F> for ZKWrappedVerifierChannel<'a, F, Channel>

where F: BinaryField, Channel: MerkleIPVerifierChannel<F, Elem = F>,

type Elem = CircuitElem<F, InstanceGenerator<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, Channel> WordIPVerifierChannel<F> for ZKWrappedVerifierChannel<'_, F, Channel>

where F: BinaryField, Channel: MerkleIPVerifierChannel<F, Elem = F, Word = Word>,

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.