Struct InstanceGenerator 

pub struct InstanceGenerator<F: Field, LayoutRef = Arc<WitnessLayout<F>>> { /* private fields */ }

Reconstructs the public input vector [constants | inout | derived] on the verifier side by re-running the circuit function.

Implements CircuitBuilder with PublicWire as the wire type, structurally mirroring WitnessGenerator, but it only computes the public segment. The verifier lacks the secret (precommit) values, so private wires carry no value; by the soundness invariant a derived wire never reads a secret, so every derived value is computable from the real public inputs alone. Derived wires are allocated in the same order as ConstraintBuilder, keeping their ids aligned so WitnessLayout::get resolves each to the correct public slot.

LayoutRef is any pointer to a WitnessLayout, chosen by the caller:

• &WitnessLayout<F> — a zero-cost borrow, tied to the borrow’s lifetime.
• Arc<WitnessLayout<F>> — shared and 'static (the default).

A 'static generator is what lets a wrapper channel hand its transparent closures to an opener. Sharing an Arc gives that without cloning the layout, so the wrapper channel uses it.

Implementations

impl<F: Field, LayoutRef: Deref<Target = WitnessLayout<F>>> InstanceGenerator<F, LayoutRef>

pub fn new(layout: LayoutRef) -> Self

pub fn write_inout(&mut self, wire: ConstraintWire, value: F) -> PublicWire<F>

Writes a real inout value into its public slot.

pub fn placeholder_precommit(&mut self, wire: ConstraintWire) -> PublicWire<F>

Records a precommit wire as private (value unknown to the verifier). Per the soundness invariant a secret never feeds a derived value, so the missing value is inert.

pub fn public(&self) -> &[F]

The reconstructed public vector [constants | inout | derived] so far, of length 1 << layout.log_public(). Once every inout and alive-derived wire has been written, this is the final public vector; reading it by reference (rather than consuming via Self::build) lets callers keep the generator alive for wires that still reference it.

pub fn build(self) -> Vec<F>

Returns the reconstructed public vector [constants | inout | derived], of length 1 << layout.log_public(), ready to pass to Verifier::verify.

Trait Implementations

impl<F: Field, LayoutRef: Deref<Target = WitnessLayout<F>>> CircuitBuilder for InstanceGenerator<F, LayoutRef>

type Wire = PublicWire<F>

type Field = F

fn assert_zero(&mut self, _wire: Self::Wire)

fn assert_eq(&mut self, _lhs: Self::Wire, _rhs: Self::Wire)

fn constant(&mut self, val: F) -> Self::Wire

fn add(&mut self, lhs: Self::Wire, rhs: Self::Wire) -> Self::Wire

fn mul(&mut self, lhs: Self::Wire, rhs: Self::Wire) -> Self::Wire

fn hint<H: Fn([F; IN]) -> [F; OUT], const IN: usize, const OUT: usize>( &mut self, inputs: [Self::Wire; IN], f: H, ) -> [Self::Wire; OUT]

fn hint_varsize<H: FnOnce(&[F]) -> Vec<F>>( &mut self, inputs: &[Self::Wire], out_len: usize, f: H, ) -> Vec<Self::Wire>

Runtime-arity variant of hint: takes a slice of input wires and an out_len, with a closure mapping the input values to out_len output values. Emits no constraints; the outputs are public-derivable (allocated in the derived segment) iff every input is, matching hint. The closure is invoked at most once — value-generating builders run it, the symbolic builder skips it.

fn sub(&mut self, lhs: Self::Wire, rhs: Self::Wire) -> Self::Wire

impl<F: Debug + Field, LayoutRef: Debug> Debug for InstanceGenerator<F, LayoutRef>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.