Struct FeatureFlags 

pub struct FeatureFlags {
    pub range_check0: bool,
    pub range_check1: bool,
    pub foreign_field_add: bool,
    pub foreign_field_mul: bool,
    pub xor: bool,
    pub rot: bool,
    pub lookup_features: LookupFeatures,
}

Flags indicating which optional gates are used in a circuit.

Kimchi circuits can use a variety of optional gates and lookup patterns. Rather than always including constraints for every possible gate type, these flags track which gates are actually present. This allows the prover and verifier to only compute and check relevant constraints.

Flags are typically computed automatically via Self::from_gates, which scans the circuit gates and enables the corresponding flags.

When a flag is disabled, the following optimizations apply:

• The gate’s selector polynomial is not computed
• The gate’s constraints are excluded from linearization
• Associated lookup tables are not included

Fields

range_check0: bool

Enables GateType::RangeCheck0, which partially constrains one 88-bit value. Can also perform a standalone 64-bit range check by constraining columns 1-2 to zero (removing the two highest 12-bit limbs: 88 - 24 = 64 bits). See crate::circuits::polynomials::range_check for details.

range_check1: bool

Enables GateType::RangeCheck1, which fully constrains the third value in the multi-range-check gadget and triggers deferred lookups. See crate::circuits::polynomials::range_check for details.

foreign_field_add: bool

Enables GateType::ForeignFieldAdd for addition over non-native fields.

foreign_field_mul: bool

Enables GateType::ForeignFieldMul for multiplication over non-native fields.

xor: bool

Enables GateType::Xor16 for 16-bit XOR operations.

rot: bool

Enables GateType::Rot64 for 64-bit rotation operations.

lookup_features: LookupFeatures

Lookup feature configuration. See LookupFeatures for details.

Implementations

impl FeatureFlags

pub fn from_gates_and_lookup_features<F: PrimeField>( gates: &[CircuitGate<F>], lookup_features: LookupFeatures, ) -> FeatureFlags

Creates feature flags by scanning gates, using pre-computed lookup features.

pub fn from_gates<F: PrimeField>( gates: &[CircuitGate<F>], uses_runtime_tables: bool, ) -> FeatureFlags

Creates feature flags by scanning gates for optional gate types.

This is the primary constructor. It detects both gate-level features and lookup features from the circuit gates.

Trait Implementations

impl Clone for FeatureFlags

fn clone(&self) -> FeatureFlags

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FeatureFlags

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

Formats the value using the given formatter.

impl Default for FeatureFlags

fn default() -> FeatureFlags

Returns an instance with all features disabled.

impl<'de> Deserialize<'de> for FeatureFlags

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<FeatureFlags> for JsValue

fn from(value: FeatureFlags) -> Self

Converts to this type from the input type.

impl<'from_value_lifetime> FromValue<'from_value_lifetime> for FeatureFlags

fn from_value(value: Value) -> Self

Convert from OCaml value

impl FromWasmAbi for FeatureFlags

type Abi = u32

The wasm ABI type that this converts from when coming back out from the ABI boundary.

unsafe fn from_abi(js: u32) -> Self

Recover a Self from Self::Abi.

impl IntoValue for FeatureFlags

fn into_value(self, gc: &Runtime) -> Value

Convert to OCaml value

impl IntoWasmAbi for FeatureFlags

type Abi = u32

The wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> u32

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl LongRefFromWasmAbi for FeatureFlags

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = Ref<'static, FeatureFlags>

Same as RefFromWasmAbi::Anchor

unsafe fn long_ref_from_abi(js: Self::Abi) -> Self::Anchor

Same as RefFromWasmAbi::ref_from_abi

impl OCamlBinding for FeatureFlags

fn ocaml_binding( env: &mut Env, rename: Option<&'static str>, new_type: bool, ) -> String

will generate the OCaml bindings for a type (called root type). It takes the current environment [Env], as well as an optional name (if you wish to rename the type in OCaml).

impl OCamlDesc for FeatureFlags

fn ocaml_desc(env: &Env, generics: &[&str]) -> String

describes the type in OCaml, given the current environment [Env] and the list of generic type parameters of the root type (the type that makes use of this type)

fn unique_id() -> u128

Returns a unique ID for the type. This ID will not change if concrete type parameters are used.

impl OptionFromWasmAbi for FeatureFlags

fn is_none(abi: &Self::Abi) -> bool

Tests whether the argument is a “none” instance. If so it will be deserialized as None, and otherwise it will be passed to FromWasmAbi.

impl OptionIntoWasmAbi for FeatureFlags

fn none() -> Self::Abi

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option.

impl RefFromWasmAbi for FeatureFlags

type Abi = u32

The wasm ABI type references to Self are recovered from.

type Anchor = Ref<'static, FeatureFlags>

The type that holds the reference to Self for the duration of the invocation of the function that has an &Self parameter. This is required to ensure that the lifetimes don’t persist beyond one function call, and so that they remain anonymous.

unsafe fn ref_from_abi(js: Self::Abi) -> Self::Anchor

Recover a Self::Anchor from Self::Abi.

impl RefMutFromWasmAbi for FeatureFlags

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = RefMut<'static, FeatureFlags>

Same as RefFromWasmAbi::Anchor

unsafe fn ref_mut_from_abi(js: Self::Abi) -> Self::Anchor

Same as RefFromWasmAbi::ref_from_abi

impl Serialize for FeatureFlags

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFromJsValue for FeatureFlags

type Error = JsValue

The type returned in the event of a conversion error.

fn try_from_js_value(value: JsValue) -> Result<Self, Self::Error>

Performs the conversion.

impl VectorFromWasmAbi for FeatureFlags

type Abi = <Box<[JsValue]> as FromWasmAbi>::Abi

unsafe fn vector_from_abi(js: Self::Abi) -> Box<[FeatureFlags]>

impl VectorIntoWasmAbi for FeatureFlags

type Abi = <Box<[JsValue]> as IntoWasmAbi>::Abi

fn vector_into_abi(vector: Box<[FeatureFlags]>) -> Self::Abi

impl WasmDescribe for FeatureFlags

fn describe()

impl WasmDescribeVector for FeatureFlags

fn describe_vector()

impl Copy for FeatureFlags