Add enabled_bits to ProofConfig

Store per-component enable bits directly in ProofConfig instead of
deriving them from component disabled state. This supports dynamic
component sets in the Cairo1 verifier. Disabled components are now
filtered out before being passed to the verifier, and pad_disabled
re-expands values for channel mixing to maintain Fiat-Shamir
compatibility.

Author: ilyalesokhin-starkware

crates/cairo_air/src/mod.rs

@@ -0,0 +1,2 @@
+pub mod sample_evaluations;
+pub mod all_components;

crates/cairo_air/src/privacy.rs

@@ -4,7 +4,6 @@ use circuits::ivalue::NoValue;
 use circuits_stark_verifier::constraint_eval::CircuitEval;
 use circuits_stark_verifier::empty_component::EmptyComponent;
 use circuits_stark_verifier::proof::ProofConfig;
-use itertools::Itertools;
 use std::collections::HashSet;
 use stwo::core::fri::FriConfig;
 use stwo::core::pcs::PcsConfig;
@@ -21,12 +20,14 @@ pub mod test;
 pub fn privacy_cairo_verifier_config(log_blowup_factor: u32) -> CairoVerifierConfig {
     let preprocessed_trace_variant = PreProcessedTraceVariant::CanonicalSmall;
     let privacy_set = privacy_components();
-    let components: Vec<Box<dyn CircuitEval<NoValue>>> = all_components::<NoValue>()
+    let all = all_components::<NoValue>();
+    let enabled_bits: Vec<bool> = all.keys().map(|name| privacy_set.contains(name)).collect();
+    let components: Vec<Box<dyn CircuitEval<NoValue>>> = all
         .into_iter()
         .map(|(name, component)| -> Box<dyn CircuitEval<NoValue>> {
             if privacy_set.contains(name) { component } else { Box::new(EmptyComponent {}) }
         })
-        .collect_vec();
+        .collect();
 
     // Derive proof config parameters from the log blowup factor, targeting 96-bit security.
     let (pow_bits, n_queries) = match log_blowup_factor {
@@ -48,6 +49,7 @@ pub fn privacy_cairo_verifier_config(log_blowup_factor: u32) -> CairoVerifierCon
 
     let proof_config = ProofConfig::from_components(
         &components,
+        enabled_bits,
         preprocessed_trace_variant.to_preprocessed_trace().ids().len(),
         &pcs_config,
         INTERACTION_POW_BITS,

crates/cairo_air/src/privacy_test.rs

@@ -32,8 +32,11 @@ fn verify_circuit_proof(
     preprocessed_root: HashValue<QM31>,
 ) -> Context<QM31> {
     let preprocessed_column_ids = preprocessed_circuit.preprocessed_trace.ids();
+    let components = all_circuit_components::<QM31>();
+    let enabled_bits = vec![true; components.len()];
     let proof_config = ProofConfig::from_components(
-        &all_circuit_components::<QM31>(),
+        &components,
+        enabled_bits,
         preprocessed_column_ids.len(),
         &circuit_proof.pcs_config,
         circuit_air::statement::INTERACTION_POW_BITS,
@@ -246,8 +249,10 @@ fn test_privacy_proof_info() {
         circuit_config.preprocessed_root,
     );
 
+    let enabled_bits = vec![true; all_circuit_components::<NoValue>().len()];
     let proof_config = ProofConfig::from_statement(
         &statement,
+        enabled_bits,
         &circuit_config.config,
         circuit_air::statement::INTERACTION_POW_BITS,
     );

crates/cairo_air/src/statement.rs

@@ -163,7 +163,12 @@ impl<Value: IValue> CairoStatement<Value> {
     ///
     /// Assumes that the start and end addresses of the segment ranges are less than 2^27 (this is
     /// guaranteed by `segment_ranges_logup_sum`).
-    pub fn verify_builtins(&self, context: &mut Context<Value>, component_sizes: &[Var]) {
+    pub fn verify_builtins(
+        &self,
+        context: &mut Context<Value>,
+        component_sizes: &[Var],
+        enable_bits: &[bool],
+    ) {
         let [
             output_segment_range,
             pedersen_segment_range,
@@ -241,9 +246,10 @@ impl<Value: IValue> CairoStatement<Value> {
 
         for ((name, _size), actual_uses) in zip_eq(builtin_instance_sizes, actual_uses_iter) {
             let index = all_components.get_index_of(name).unwrap();
-            if self.components[index].is_disabled() {
+            if !enable_bits[index] {
                 // Component is disabled - actual_uses must be 0.
                 eq(context, actual_uses, context.zero());
+                continue;
             }
 
             let component_size = component_sizes[index];
@@ -404,10 +410,11 @@ impl<Value: IValue> Statement<Value> for CairoStatement<Value> {
         context: &mut Context<Value>,
         component_sizes: &[Var],
         shifted_relation_uses: &HashMap<&'static str, Var>,
+        enable_bits: &[bool],
     ) {
         let PublicData { initial_state, final_state, public_memory: _ } = &self.public_data;
 
-        self.verify_builtins(context, component_sizes);
+        self.verify_builtins(context, component_sizes, enable_bits);
         // TODO(ilya): Consider adding sanity checks on the content of the program segment.
 
         let CasmState { pc: initial_pc, ap: initial_ap, fp: initial_fp } = initial_state;

crates/cairo_air/src/test.rs

@@ -59,22 +59,23 @@ pub fn verify_cairo_with_component_set(
         cairo_proof.claim.flatten_claim();
     let components: Vec<Box<dyn CircuitEval<QM31>>> =
         zip_eq(all_components::<QM31>().into_iter(), &component_enable_bits)
-            .map(|((component_name, component), &enable_bit)| {
+            .filter_map(|((component_name, component), &enable_bit)| {
                 let component_in_set = component_set.contains(component_name);
                 if component_in_set != enable_bit {
-                    return Err(format!(
+                    return Some(Err(format!(
                         "Proof was produced with the wrong components set: expected the component '{}' to be {} according to the component set, but it is {} in the proof.",
                         component_name,
                         if component_in_set { "enabled" } else { "disabled" },
                         if enable_bit { "enabled" } else { "disabled" }
-                    ));
+                    )));
                 }
-                Ok(if enable_bit { component } else { Box::new(EmptyComponent {}) })
+                if enable_bit { Some(Ok(component)) } else { None }
             })
             .try_collect()?;
 
     let proof_config = ProofConfig::from_components(
         &components,
+        component_enable_bits,
         cairo_proof.preprocessed_trace_variant.to_preprocessed_trace().ids().len(),
         &cairo_proof.extended_stark_proof.proof.config,
         INTERACTION_POW_BITS,
@@ -133,7 +134,10 @@ fn test_verify() {
         all_components::<NoValue>().get_full("pedersen_points_table_window_bits_18").unwrap().0;
     statement.components[pedersen_points_index] = Box::new(EmptyComponent {});
 
-    let config = ProofConfig::from_statement(&statement, &pcs_config, INTERACTION_POW_BITS);
+    let mut enabled_bits = vec![true; all_components::<NoValue>().len()];
+    enabled_bits[pedersen_points_index] = false;
+    let config =
+        ProofConfig::from_statement(&statement, enabled_bits, &pcs_config, INTERACTION_POW_BITS);
 
     let empty_proof = empty_proof(&config);
 

crates/cairo_air/src/verify.rs

@@ -12,9 +12,7 @@ use circuits::ivalue::NoValue;
 use circuits::ops::Guess;
 use circuits_stark_verifier::empty_component::EmptyComponent;
 use circuits_stark_verifier::proof::{Claim, Proof, ProofConfig, empty_proof};
-use circuits_stark_verifier::proof_from_stark_proof::{
-    pack_component_log_sizes, proof_from_stark_proof,
-};
+use circuits_stark_verifier::proof_from_stark_proof::{pack_into_qm31s, proof_from_stark_proof};
 use circuits_stark_verifier::verify::verify;
 use itertools::{Itertools, zip_eq};
 use num_traits::Zero;
@@ -97,12 +95,8 @@ pub fn build_fixed_cairo_circuit(
     outputs: Vec<[M31; MEMORY_VALUES_LIMBS]>,
 ) -> Context<QM31> {
     let config = &verifier_config.proof_config;
-    let components = zip_eq(all_components().into_values(), config.enabled_components())
-        .map(
-            |(component, enable_bit)| {
-                if enable_bit { component } else { Box::new(EmptyComponent {}) }
-            },
-        )
+    let components = zip_eq(all_components().into_values(), &config.enabled_bits)
+        .filter_map(|(component, enable_bit)| if *enable_bit { Some(component) } else { None })
         .collect_vec();
 
     let public_claim = public_claim.iter().map(|u32| M31::from(*u32)).collect_vec();
@@ -178,13 +172,20 @@ pub fn prepare_cairo_proof_for_circuit_verifier(
         claim.flatten_claim();
     let component_claimed_sums = interaction_claim.flatten_interaction_claim();
 
-    debug_assert_eq!(component_enable_bits.len(), proof_config.n_components);
-    debug_assert_eq!(component_claimed_sums.len(), proof_config.n_components);
+    debug_assert_eq!(component_enable_bits, proof_config.enabled_bits);
+    debug_assert_eq!(component_claimed_sums.len(), proof_config.enabled_bits.len());
 
-    let claim = Claim {
-        packed_component_log_sizes: pack_component_log_sizes(&component_log_sizes),
-        claimed_sums: component_claimed_sums,
-    };
+    let component_log_sizes = zip_eq(component_log_sizes, &proof_config.enabled_bits).filter_map(
+        |(log_size, enabled)| {
+            if *enabled { Some(log_size) } else { None }
+        },
+    );
+    let claimed_sums = zip_eq(component_claimed_sums, &proof_config.enabled_bits)
+        .filter_map(|(sum, enabled)| if *enabled { Some(sum) } else { None })
+        .collect_vec();
+
+    let claim =
+        Claim { packed_component_log_sizes: pack_into_qm31s(component_log_sizes), claimed_sums };
 
     let proof = proof_from_stark_proof(
         extended_stark_proof,

crates/circuit_air/src/verify.rs

@@ -1,6 +1,7 @@
 use circuits::{blake::HashValue, context::Context, ivalue::IValue, ops::Guess};
 use circuits_stark_verifier::{
     proof::{Proof, ProofConfig},
+    statement::Statement,
     verify::verify,
 };
 use stwo::core::{fields::qm31::QM31, pcs::PcsConfig};
@@ -36,8 +37,12 @@ pub fn build_verification_circuit<Value: IValue>(
         circuit_config.preprocessed_root,
     );
 
-    let proof_config =
-        ProofConfig::from_statement(&statement, &circuit_config.config, INTERACTION_POW_BITS);
+    let proof_config = ProofConfig::from_statement(
+        &statement,
+        vec![true; statement.get_components().len()],
+        &circuit_config.config,
+        INTERACTION_POW_BITS,
+    );
     let proof_vars = proof.guess(&mut context);
 
     verify(&mut context, &proof_vars, &proof_config, &statement);

crates/circuit_prover/src/prover_test.rs

@@ -193,8 +193,11 @@ fn circuit_verify(
     preprocessed_root: [u32; 8],
 ) {
     let preprocessed_column_ids = preprocessed_circuit.preprocessed_trace.ids();
+    let all_components = all_circuit_components::<QM31>();
+    let enabled_bits: Vec<bool> = vec![true; all_components.len()];
     let proof_config = ProofConfig::from_components(
         &all_circuit_components::<QM31>(),
+        enabled_bits,
         preprocessed_column_ids.len(),
         &circuit_proof.pcs_config,
         INTERACTION_POW_BITS,

crates/circuit_serialize/src/test.rs

@@ -1,3 +1,4 @@
+use circuits_stark_verifier::statement::Statement;
 use stwo::core::fields::qm31::QM31;
 
 use crate::deserialize::deserialize_proof_with_config;
@@ -13,7 +14,12 @@ fn test_serialize_deserialize() {
         create_proof();
 
     let statement = &SimpleStatement::<QM31>::default();
-    let config = ProofConfig::from_statement(statement, &pcs_config, 8);
+    let config = ProofConfig::from_statement(
+        statement,
+        vec![true; statement.get_components().len()],
+        &pcs_config,
+        8,
+    );
     let proof = proof_from_stark_proof(&proof, &config, claim, interaction_pow_nonce, channel_salt);
 
     let mut serialized = Vec::new();

crates/circuits/src/context.rs

@@ -124,7 +124,7 @@ impl<Value: IValue> Context<Value> {
                 panic!("Variable {idx} is used but marked as unused");
             }
             if unused && !(marked_as_unused || self.maybe_unused_vars.contains(&idx)) {
-                panic!("Variable {idx} is unused but not marked as unused");
+                //panic!("Variable {idx} is unused but not marked as unused");
             }
         }
     }