Struct IronSpartanBuilderChannel 

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

A channel that symbolically executes a verifier, building up an IronSpartan constraint system.

Instead of performing actual verification, this channel records all operations as constraints in a ConstraintBuilder. The typical usage pattern is:

1. Construct a fresh IronSpartanBuilderChannel via Self::new
2. Run the verifier on the channel (e.g., verify_iop)
3. The channel’s finish() method returns the ConstraintBuilder with all recorded constraints

Implementations

impl<F: Field> IronSpartanBuilderChannel<F>

pub fn new() -> Self

Creates a new builder channel backed by a fresh ConstraintBuilder.

pub fn finish(self) -> ConstraintBuilder<F>

Consumes the channel and returns the underlying ConstraintBuilder.

This must be called after all CircuitElem values derived from this channel have been dropped, as it requires sole ownership of the builder via Rc::try_unwrap.

Trait Implementations

impl<F: Field> Default for IronSpartanBuilderChannel<F>

fn default() -> Self

Returns the “default value” for a type.

impl<F: Field> IOPVerifierChannel<F> for IronSpartanBuilderChannel<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 IronSpartanBuilderChannel<F>

type Elem = CircuitElem<F, ConstraintBuilder<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 IronSpartanBuilderChannel<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.