Struct ZkStdLib 

pub struct ZkStdLib { /* private fields */ }

The ZkStdLib exposes all tools that are used in circuit generation.

Implementations

impl ZkStdLib

pub fn new(config: &ZkStdLibConfig, max_bit_len: usize) -> Self

Creates a new ZkStdLib given its config.

pub fn configure( meta: &mut ConstraintSystem<Fq>, (arch, max_bit_len): (ZkStdLibArch, u8), ) -> ZkStdLibConfig

Configure ZkStdLib from scratch.

impl ZkStdLib

pub fn jubjub(&self) -> &EccChip<JubjubExtended>

Native EccChip.

pub fn biguint( &self, ) -> &BigUintGadget<Fq, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>>

Gadget for performing in-circuit big-unsigned integer operations.

pub fn map_gadget( &self, ) -> &MapGadget<Fq, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>, PoseidonChip<Fq>>

Gadget for performing map and non-map checks

pub fn secp256k1( &self, ) -> &ForeignWeierstrassEccChip<Fq, K256, MultiEmulationParams, FieldChip<Fq, Fq, MultiEmulationParams, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>>, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>>

Chip for performing in-circuit operations over the Secp256k1 curve, its scalar field or its base field.

pub fn p256( &self, ) -> &ForeignWeierstrassEccChip<Fq, P256, MultiEmulationParams, FieldChip<Fq, Fq, MultiEmulationParams, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>>, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>>

Chip for performing in-circuit operations over the P256 curve, its scalar field or its base field.

pub fn bls12_381( &self, ) -> &ForeignWeierstrassEccChip<Fq, G1Projective, G1Projective, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>>

Chip for performing in-circuit operations over the BLS12-381 curve, its scalar field or its base field.

pub fn curve25519( &self, ) -> &ForeignEdwardsEccChip<Fq, Curve25519, MultiEmulationParams, FieldChip<Fq, Scalar, MultiEmulationParams, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>>, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>>

Chip for performing in-circuit operations over Curve25519.

pub fn base64(&self) -> &Base64Chip<Fq>

Chip for performing in-circuit base64 decoding.

pub fn parser( &self, ) -> &ParserGadget<Fq, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>>

Gadget for column-free parsing helpers (fetch_bytes, date_to_int, etc.). Always available (no arch flag needed).

pub fn scanner(&self) -> &ScannerChip<Fq>

Chip for various scanning functions based on lookups. This includes automaton-based parsing (ScannerChip::parse) and substring checks (ScannerChip::check_subsequence, ScannerChip::check_bytes).

Returns the scanner chip for automaton-based parsing and substring checks. The static automaton table is loaded automatically when parse is called with a Static(..) variant.

pub fn verifier(&self) -> &VerifierGadget<BlstrsEmulation>

Chip for performing in-circuit verification of proofs (generated with Poseidon as the Fiat-Shamir transcript hash).

pub fn assert_true( &self, layouter: &mut impl Layouter<Fq>, input: &AssignedBit<Fq>, ) -> Result<(), Error>

Assert that a given assigned bit is true.

let input: AssignedBit<F> = chip.assign_fixed(layouter, true)?;
chip.assert_true(layouter, &input)?;

pub fn assert_false( &self, layouter: &mut impl Layouter<Fq>, input: &AssignedBit<Fq>, ) -> Result<(), Error>

Assert that a given assigned bit is false

pub fn lower_than( &self, layouter: &mut impl Layouter<Fq>, x: &AssignedNative<Fq>, y: &AssignedNative<Fq>, n: u32, ) -> Result<AssignedBit<Fq>, Error>

Returns 1 iff x < y.

let x: AssignedNative<F> = chip.assign_fixed(layouter, F::from(127))?;
let y: AssignedNative<F> = chip.assign_fixed(layouter, F::from(212))?;
let condition = chip.lower_than(layouter, &x, &y, 8)?;

chip.assert_true(layouter, &condition)?;

Unsatisfiable Circuit

If x or y are not in the range [0, 2^n).

let x: AssignedNative<F> = chip.assign_fixed(layouter, F::from(127))?;
let y: AssignedNative<F> = chip.assign_fixed(layouter, F::from(212))?;
let _condition = chip.lower_than(layouter, &x, &y, 7)?;

Setting n > (F::NUM_BITS - 1) / 2 will result in a compile-time error.

pub fn poseidon( &self, layouter: &mut impl Layouter<Fq>, input: &[AssignedNative<Fq>], ) -> Result<AssignedNative<Fq>, Error>

Poseidon hash from a slice of native values into a native value.

let x: AssignedNative<F> = chip.assign_fixed(layouter, F::from(127))?;
let y: AssignedNative<F> = chip.assign_fixed(layouter, F::from(212))?;

let _hash = chip.poseidon(layouter, &[x, y])?;

pub fn poseidon_varlen<const M: usize>( &self, layouter: &mut impl Layouter<Fq>, input: &AssignedVector<Fq, AssignedNative<Fq>, M, RATE>, ) -> Result<AssignedNative<Fq>, Error>

Poseidon hash over a payload whose element count can vary between proofs.

Unlike poseidon, which takes a plain slice whose length is structurally fixed in the circuit (the same for every proof), this variant takes an AssignedVector: a specialized structure for carrying data of varying length, up to a maximum capacity of M elements.

M must be a multiple of 2 (the Poseidon absorption rate).

pub fn hash_to_curve( &self, layouter: &mut impl Layouter<Fq>, inputs: &[AssignedNative<Fq>], ) -> Result<AssignedNativePoint<JubjubExtended>, Error>

Hashes a slice of assigned values into (x, y) coordinates which are guaranteed to be in the curve C. For usage, see HashToCurveGadget.

pub fn sha2_256( &self, layouter: &mut impl Layouter<Fq>, input: &[AssignedByte<Fq>], ) -> Result<[AssignedByte<Fq>; 32], Error>

SHA2-256. Takes as input a slice of assigned bytes and returns the assigned input/output in bytes. We assume the field uses little endian encoding.

let input = chip.assign_many(
    layouter,
    &[
        Value::known(13),
        Value::known(226),
        Value::known(119),
        Value::known(5),
    ],
)?;

let _hash = chip.sha2_256(layouter, &input)?;

pub fn sha2_256_varlen<const M: usize>( &self, layouter: &mut impl Layouter<Fq>, input: &AssignedVector<Fq, AssignedByte<Fq>, M, 64>, ) -> Result<[AssignedByte<Fq>; 32], Error>

SHA-256 hash over a payload whose byte count can vary between proofs.

Unlike sha2_256, which takes a plain slice whose length is structurally fixed in the circuit (the same for every proof), this variant takes an AssignedVector: a specialized structure for carrying data of varying length, up to a maximum capacity of M bytes.

M must be a multiple of 64 (the SHA-256 block size).

pub fn sha2_512( &self, layouter: &mut impl Layouter<Fq>, input: &[AssignedByte<Fq>], ) -> Result<[AssignedByte<Fq>; 64], Error>

SHA2-512 hash.

pub fn sha3_256( &self, layouter: &mut impl Layouter<Fq>, input: &[AssignedByte<Fq>], ) -> Result<[AssignedByte<Fq>; 32], Error>

SHA3-256 hash (third-party implementation).

pub fn keccak_256( &self, layouter: &mut impl Layouter<Fq>, input: &[AssignedByte<Fq>], ) -> Result<[AssignedByte<Fq>; 32], Error>

Keccak-256 hash (third-party implementation).

pub fn blake2b_256( &self, layouter: &mut impl Layouter<Fq>, input: &[AssignedByte<Fq>], ) -> Result<[AssignedByte<Fq>; 32], Error>

Blake2b hash with a 256-bit output, unkeyed (third-party implementation).

pub fn blake2b_512( &self, layouter: &mut impl Layouter<Fq>, input: &[AssignedByte<Fq>], ) -> Result<[AssignedByte<Fq>; 64], Error>

Blake2b hash with a 512-bit output, unkeyed (third-party implementation).

Trait Implementations

impl ArithInstructions<Fq, AssignedCell<Fq, Fq>> for ZkStdLib

fn linear_combination( &self, layouter: &mut impl Layouter<Fq>, terms: &[(Fq, AssignedNative<Fq>)], constant: Fq, ) -> Result<AssignedNative<Fq>, Error>

Addition of many elements, given a slice of terms of the form (coeff_i, x_i) and a constant k, returns k + (sum_i coeff_i * x_i).

fn mul( &self, layouter: &mut impl Layouter<Fq>, x: &AssignedNative<Fq>, y: &AssignedNative<Fq>, multiplying_constant: Option<Fq>, ) -> Result<AssignedNative<Fq>, Error>

Multiplication, possibly with an additional multiplying constant.

fn div( &self, layouter: &mut impl Layouter<Fq>, x: &AssignedNative<Fq>, y: &AssignedNative<Fq>, ) -> Result<AssignedNative<Fq>, Error>

Division. Division of x by y will make the circuit unsatisfiable if y = 0.

fn inv( &self, layouter: &mut impl Layouter<Fq>, x: &AssignedNative<Fq>, ) -> Result<AssignedNative<Fq>, Error>

Inversion (multiplicative inverse). The circuit will become unsatisfiable if x = 0.

fn inv0( &self, layouter: &mut impl Layouter<Fq>, x: &AssignedNative<Fq>, ) -> Result<AssignedNative<Fq>, Error>

Inversion (multiplicative inverse). If x = 0, this function returns 0.

fn add( &self, layouter: &mut impl Layouter<F>, x: &Assigned, y: &Assigned, ) -> Result<Assigned, Error>

Addition.

fn sub( &self, layouter: &mut impl Layouter<F>, x: &Assigned, y: &Assigned, ) -> Result<Assigned, Error>

Subtraction.

fn neg( &self, layouter: &mut impl Layouter<F>, x: &Assigned, ) -> Result<Assigned, Error>

Negation (additive inverse).

fn add_constant( &self, layouter: &mut impl Layouter<F>, x: &Assigned, constant: <Assigned as InnerValue>::Element, ) -> Result<Assigned, Error>

Addition of a constant.

fn add_constants( &self, layouter: &mut impl Layouter<F>, xs: &[Assigned], constants: &[<Assigned as InnerValue>::Element], ) -> Result<Vec<Assigned>, Error>

Pair-wise addition of a constant slice to a slice of assigned values.

fn mul_by_constant( &self, layouter: &mut impl Layouter<F>, x: &Assigned, constant: <Assigned as InnerValue>::Element, ) -> Result<Assigned, Error>

Multiplication by a constant. This function is potentially more efficient than composing assigned_fixed and mul.

fn square( &self, layouter: &mut impl Layouter<F>, x: &Assigned, ) -> Result<Assigned, Error>

Multiplication of an element by itself.

fn pow( &self, layouter: &mut impl Layouter<F>, x: &Assigned, n: u64, ) -> Result<Assigned, Error>

Exponentiate the given assigned element to the given (constant) n. pow(zero, 0) is one by definition.

fn add_and_mul( &self, layouter: &mut impl Layouter<F>, _: (<Assigned as InnerValue>::Element, &Assigned), _: (<Assigned as InnerValue>::Element, &Assigned), _: (<Assigned as InnerValue>::Element, &Assigned), k: <Assigned as InnerValue>::Element, m: <Assigned as InnerValue>::Element, ) -> Result<Assigned, Error>

Computes a*x + b*y + c*z + k + m*x*y.

impl<T> AssertionInstructions<Fq, T> for ZkStdLib

where T: InnerValue, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>: AssertionInstructions<Fq, T>,

fn assert_equal( &self, layouter: &mut impl Layouter<Fq>, x: &T, y: &T, ) -> Result<(), Error>

Ensures that the given assigned elements are the same.

fn assert_not_equal( &self, layouter: &mut impl Layouter<Fq>, x: &T, y: &T, ) -> Result<(), Error>

Ensures that the given assigned elements are different.

fn assert_equal_to_fixed( &self, layouter: &mut impl Layouter<Fq>, x: &T, constant: T::Element, ) -> Result<(), Error>

Ensures that the given assigned element is equal to the given constant.

fn assert_not_equal_to_fixed( &self, layouter: &mut impl Layouter<Fq>, x: &T, constant: T::Element, ) -> Result<(), Error>

Ensures that the given assigned element is different from the given constant.

impl<T> AssignmentInstructions<Fq, T> for ZkStdLib

where T: InnerValue, T::Element: Clone, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>: AssignmentInstructions<Fq, T>,

fn assign( &self, layouter: &mut impl Layouter<Fq>, value: Value<T::Element>, ) -> Result<T, Error>

Assigns an element as a private input to the circuit.

fn assign_fixed( &self, layouter: &mut impl Layouter<Fq>, constant: T::Element, ) -> Result<T, Error>

Assigns a fixed (constant) element.

fn assign_many( &self, layouter: &mut impl Layouter<Fq>, values: &[Value<T::Element>], ) -> Result<Vec<T>, Error>

Assigns several elements as private inputs to the circuit.

fn assign_many_fixed( &self, layouter: &mut impl Layouter<F>, values: &[<Assigned as InnerValue>::Element], ) -> Result<Vec<Assigned>, Error>

Assigns several elements fixed values to the circuit.

impl BinaryInstructions<Fq> for ZkStdLib

fn and( &self, layouter: &mut impl Layouter<Fq>, bits: &[AssignedBit<Fq>], ) -> Result<AssignedBit<Fq>, Error>

Conjunction of the given assigned bits.

fn or( &self, layouter: &mut impl Layouter<Fq>, bits: &[AssignedBit<Fq>], ) -> Result<AssignedBit<Fq>, Error>

Disjunction of the given assigned bits.

fn xor( &self, layouter: &mut impl Layouter<Fq>, bits: &[AssignedBit<Fq>], ) -> Result<AssignedBit<Fq>, Error>

Exclusive-OR of all the given assigned bits.

fn not( &self, layouter: &mut impl Layouter<Fq>, bit: &AssignedBit<Fq>, ) -> Result<AssignedBit<Fq>, Error>

Negation of the given assigned bit.

impl BitwiseInstructions<Fq, AssignedCell<Fq, Fq>> for ZkStdLib

fn band( &self, layouter: &mut impl Layouter<F>, x: &Assigned, y: &Assigned, n: usize, ) -> Result<Assigned, Error>

Bitwise conjunction of the given assigned elements, interpreted as binary bit-strings of length n.

fn bor( &self, layouter: &mut impl Layouter<F>, x: &Assigned, y: &Assigned, n: usize, ) -> Result<Assigned, Error>

Bitwise disjunction of the given assigned elements, interpreted as binary bit-strings of length n.

fn bxor( &self, layouter: &mut impl Layouter<F>, x: &Assigned, y: &Assigned, n: usize, ) -> Result<Assigned, Error>

Bitwise exclusive-or of the given assigned elements, interpreted as binary bit-strings of length n.

fn bnot( &self, layouter: &mut impl Layouter<F>, x: &Assigned, n: usize, ) -> Result<Assigned, Error>

Bitwise negation of the given assigned element, interpreted as a binary bit-string of length n.

impl CanonicityInstructions<Fq, AssignedCell<Fq, Fq>> for ZkStdLib

fn le_bits_lower_than( &self, layouter: &mut impl Layouter<Fq>, bits: &[AssignedBit<Fq>], bound: BigUint, ) -> Result<AssignedBit<Fq>, Error>

Returns true iff the integer represented by the given sequence of assigned bits, interpreted in little-endian, is strictly lower than the given bound.

fn le_bits_geq_than( &self, layouter: &mut impl Layouter<Fq>, bits: &[AssignedBit<Fq>], bound: BigUint, ) -> Result<AssignedBit<Fq>, Error>

Returns true iff the integer represented by the given sequence of assigned bits, interpreted in little-endian, is greater than or equal to the given bound.

fn is_canonical( &self, layouter: &mut impl Layouter<F>, bits: &[AssignedBit<F>], ) -> Result<AssignedBit<F>, Error>

Returns true iff the given sequence of bits is canonical in the underlying field Assigned::Element. Namely, iff |bits| <= Assigned::Element::NUM_BITS and the integer represented by the given sequence of assigned bits, interpreted in little-endian, is strictly lower than the order of Assigned::Element.

impl Clone for ZkStdLib

fn clone(&self) -> ZkStdLib

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> CommittedInstanceInstructions<Fq, T> for ZkStdLib

where Fq: PrimeField, T: Instantiable<Fq>, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>: CommittedInstanceInstructions<Fq, T>,

fn constrain_as_committed_public_input( &self, layouter: &mut impl Layouter<Fq>, assigned: &T, ) -> Result<(), Error>

Constrains the given assigned value as a public input that will be provided in committed form.

impl<Assigned> ControlFlowInstructions<Fq, Assigned> for ZkStdLib

where Assigned: InnerValue, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>: ControlFlowInstructions<Fq, Assigned>,

fn select( &self, layouter: &mut impl Layouter<Fq>, cond: &AssignedBit<Fq>, x: &Assigned, y: &Assigned, ) -> Result<Assigned, Error>

Returns x if cond = true and y otherwise.

fn cond_swap( &self, layouter: &mut impl Layouter<Fq>, cond: &AssignedBit<Fq>, x: &Assigned, y: &Assigned, ) -> Result<(Assigned, Assigned), Error>

Swaps two elements x and y only if cond is set to 1.

fn cond_assert_equal( &self, layouter: &mut impl Layouter<F>, cond: &AssignedBit<F>, x: &Assigned, y: &Assigned, ) -> Result<(), Error>

Equality assertion only if cond is set to 1.

impl<T1, T2> ConversionInstructions<Fq, T1, T2> for ZkStdLib

where T1: InnerValue, T2: InnerValue, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>: ConversionInstructions<Fq, T1, T2>,

fn convert_value(&self, x: &T1::Element) -> Option<T2::Element>

Converts an AssignedSource::Element into an AssignedTarget::Element, returns None if the conversion failed.

fn convert(&self, layouter: &mut impl Layouter<Fq>, x: &T1) -> Result<T2, Error>

Converts an AssignedSource into an AssignedTarget.

impl Debug for ZkStdLib

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

Formats the value using the given formatter.

impl DecompositionInstructions<Fq, AssignedCell<Fq, Fq>> for ZkStdLib

fn assigned_to_le_bits( &self, layouter: &mut impl Layouter<Fq>, x: &AssignedNative<Fq>, nb_bits: Option<usize>, enforce_canonical: bool, ) -> Result<Vec<AssignedBit<Fq>>, Error>

Returns a vector of assigned bits representing the given assigned element in little-endian.

fn assigned_to_le_bytes( &self, layouter: &mut impl Layouter<Fq>, x: &AssignedNative<Fq>, nb_bytes: Option<usize>, ) -> Result<Vec<AssignedByte<Fq>>, Error>

Returns a vector of assigned bytes representing the given element in little-endian.

fn assigned_to_le_chunks( &self, layouter: &mut impl Layouter<Fq>, x: &AssignedNative<Fq>, nb_bits_per_chunk: usize, nb_chunks: Option<usize>, ) -> Result<Vec<AssignedNative<Fq>>, Error>

Returns a vector of AssignedNative values representing the given element in little-endian. The output length may be specified, in which case this function will be imposing an upper bound on the value of x.

fn sgn0( &self, layouter: &mut impl Layouter<Fq>, x: &AssignedNative<Fq>, ) -> Result<AssignedBit<Fq>, Error>

Sign function as described in RFC 9380. sgn0(x) := x mod 2.

fn assigned_to_be_bits( &self, layouter: &mut impl Layouter<F>, x: &Assigned, nb_bits: Option<usize>, enforce_canonical: bool, ) -> Result<Vec<AssignedBit<F>>, Error>

Same as assigned_to_le_bits but the output bits are given in big-endian.

fn assigned_to_be_bytes( &self, layouter: &mut impl Layouter<F>, x: &Assigned, nb_bytes: Option<usize>, ) -> Result<Vec<AssignedByte<F>>, Error>

Same as assigned_to_le_bytes but the output bytes are given in big-endian.

fn assigned_from_le_bits( &self, layouter: &mut impl Layouter<F>, bits: &[AssignedBit<F>], ) -> Result<Assigned, Error>

Returns the element represented by the given vector of assigned bits, by interpreting it as a little-endian bit encoding.

fn assigned_from_be_bits( &self, layouter: &mut impl Layouter<F>, bits: &[AssignedBit<F>], ) -> Result<Assigned, Error>

Same as assigned_from_le_bits but the output bits are given in big-endian.

fn assigned_from_le_bytes( &self, layouter: &mut impl Layouter<F>, bytes: &[AssignedByte<F>], ) -> Result<Assigned, Error>

Returns the element represented by the given vector of assigned bytes, by interpreting it in little-endian.

fn assigned_from_be_bytes( &self, layouter: &mut impl Layouter<F>, bytes: &[AssignedByte<F>], ) -> Result<Assigned, Error>

Same as assigned_from_le_bytes but the output bytes are given in big-endian.

impl DivisionInstructions<Fq, AssignedCell<Fq, Fq>> for ZkStdLib

fn div_rem( &self, layouter: &mut impl Layouter<F>, dividend: &Assigned, divisor: BigUint, dividend_bound: Option<BigUint>, ) -> Result<(Assigned, Assigned), Error>

Integer division by a constant.

fn rem( &self, layouter: &mut impl Layouter<F>, input: &Assigned, modulus: BigUint, input_bound: Option<BigUint>, ) -> Result<Assigned, Error>

Integer modulo operation.

impl<T> EqualityInstructions<Fq, T> for ZkStdLib

where T: InnerValue, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>: EqualityInstructions<Fq, T>,

fn is_equal( &self, layouter: &mut impl Layouter<Fq>, x: &T, y: &T, ) -> Result<AssignedBit<Fq>, Error>

Returns 1 if the elements are equal, returns 0 otherwise.

fn is_not_equal( &self, layouter: &mut impl Layouter<Fq>, x: &T, y: &T, ) -> Result<AssignedBit<Fq>, Error>

Returns 0 if the elements are equal, returns 1 otherwise.

fn is_equal_to_fixed( &self, layouter: &mut impl Layouter<Fq>, x: &T, constant: T::Element, ) -> Result<AssignedBit<Fq>, Error>

Returns 1 iff the given element equals the given constant.

fn is_not_equal_to_fixed( &self, layouter: &mut impl Layouter<Fq>, x: &T, constant: T::Element, ) -> Result<AssignedBit<Fq>, Error>

Returns 1 iff the given element is not equal to the given constant.

impl FieldInstructions<Fq, AssignedCell<Fq, Fq>> for ZkStdLib

fn order(&self) -> BigUint

The field order.

fn assert_qr( &self, layouter: &mut impl Layouter<F>, x: &Assigned, ) -> Result<(), Error>

Assert that the given input is a quadratic residue of the field. This is done by exhibiting a square root.

fn is_square( &self, layouter: &mut impl Layouter<F>, x: &Assigned, ) -> Result<AssignedBit<F>, Error>

Returns 1 if the given input is a quadratic residue and 0 otherwise.

impl<T> PublicInputInstructions<Fq, T> for ZkStdLib

where T: Instantiable<Fq>, T::Element: Clone, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>: PublicInputInstructions<Fq, T>,

fn as_public_input( &self, layouter: &mut impl Layouter<Fq>, assigned: &T, ) -> Result<Vec<AssignedNative<Fq>>, Error>

Returns the cells associated with the given assigned value with the same format as a public input. This function is the in-circuit analog of Instantiable::as_public_input.

fn constrain_as_public_input( &self, layouter: &mut impl Layouter<Fq>, assigned: &T, ) -> Result<(), Error>

Constrains the given assigned value as a public input to the circuit.

fn assign_as_public_input( &self, layouter: &mut impl Layouter<Fq>, value: Value<T::Element>, ) -> Result<T, Error>

Same as assign, but it immediately constrains the assigned value as a public input. This allows the implementer of this function to skip some in-circuit checks on the structure of the assigned value, which will be guaranteed to hold through the public input bind.

impl RangeCheckInstructions<Fq, AssignedCell<Fq, Fq>> for ZkStdLib

fn assign_lower_than_fixed( &self, layouter: &mut impl Layouter<Fq>, value: Value<Fq>, bound: &BigUint, ) -> Result<AssignedNative<Fq>, Error>

Assigns an element that is immediately range-checked to be strictly lower than the given bound. This is potentially more efficient than composing [self.assign] with [self.assert_lower_than_fixed].

fn assert_lower_than_fixed( &self, layouter: &mut impl Layouter<Fq>, x: &AssignedNative<Fq>, bound: &BigUint, ) -> Result<(), Error>

Asserts that the given assigned element is in the range [0, bound).

impl<const M: usize, const A: usize, T> VectorInstructions<Fq, T, M, A> for ZkStdLib

where T: Vectorizable, T::Element: Copy, NativeGadget<Fq, P2RDecompositionChip<Fq>, NativeChip<Fq>>: AssignmentInstructions<Fq, T> + ControlFlowInstructions<Fq, T>,

fn trim_beginning( &self, layouter: &mut impl Layouter<Fq>, input: &AssignedVector<Fq, T, M, A>, n_elems: usize, ) -> Result<AssignedVector<Fq, T, M, A>, Error>

Trims n_elems elements from the beginning of the vector. The trimmed elements will not be changed by filler elements, they will remain in the buffer but not as part of the effective payload.

fn padding_flag( &self, layouter: &mut impl Layouter<Fq>, input: &AssignedVector<Fq, T, M, A>, ) -> Result<(Box<[AssignedBit<Fq>; M]>, VectorBounds<Fq>), Error>

Returns a vector of AssignedBits signaling the cells that represent padding with a 1, and the ones that represent payload data with a 0. Also returns the (start, end) limits of the data in the buffer, since they are computed internally.

fn get_limits( &self, layouter: &mut impl Layouter<Fq>, input: &AssignedVector<Fq, T, M, A>, ) -> Result<VectorBounds<Fq>, Error>

Returns the first and last positions of data in the buffer.

fn resize<const L: usize>( &self, layouter: &mut impl Layouter<Fq>, input: AssignedVector<Fq, T, M, A>, ) -> Result<AssignedVector<Fq, T, L, A>, Error>

Changes the size of an AssignedVector from M to L.

fn assign_with_filler( &self, layouter: &mut impl Layouter<Fq>, value: Value<Vec<T::Element>>, filler: Option<T::Element>, ) -> Result<AssignedVector<Fq, T, M, A>, Error>

Assigns vector with a chosen filler value.

impl ZeroInstructions<Fq, AssignedCell<Fq, Fq>> for ZkStdLib

fn assert_zero( &self, layouter: &mut impl Layouter<F>, x: &Assigned, ) -> Result<(), Error>

Enforces that the given assigned element is zero.

fn assert_non_zero( &self, layouter: &mut impl Layouter<F>, x: &Assigned, ) -> Result<(), Error>

Asserts that the given element is non-zero.

fn is_zero( &self, layouter: &mut impl Layouter<F>, x: &Assigned, ) -> Result<AssignedBit<F>, Error>

Returns 1 iff the given element equals zero (the additive identity).