chore: stark-backend v0.2.1 and replace AnyRap with AirRef

Cargo.toml

@@ -107,8 +107,8 @@ lto = "thin"
 
 [workspace.dependencies]
 # Stark Backend
-openvm-stark-backend = { git = "https://github.com/openvm-org/stark-backend.git", rev = "d2788c", default-features = false }
-openvm-stark-sdk = { git = "https://github.com/openvm-org/stark-backend.git", rev = "d2788c", default-features = false }
+openvm-stark-backend = { git = "https://github.com/openvm-org/stark-backend.git", tag = "v0.2.1-alpha", default-features = false }
+openvm-stark-sdk = { git = "https://github.com/openvm-org/stark-backend.git", tag = "v0.2.1-alpha", default-features = false }
 
 # OpenVM
 openvm-sdk = { path = "crates/sdk", default-features = false }

benchmarks/src/bin/verify_fibair.rs

@@ -12,6 +12,7 @@ use openvm_sdk::{
 };
 use openvm_stark_sdk::{
     bench::run_with_metric_collection,
+    collect_airs_and_inputs,
     config::{baby_bear_poseidon2::BabyBearPoseidon2Engine, FriParameters},
     dummy_airs::fib_air::chip::FibonacciChip,
     engine::StarkFriEngine,
@@ -35,9 +36,8 @@ fn main() -> Result<()> {
 
     run_with_metric_collection("OUTPUT_PATH", || -> Result<()> {
         // run_test tries to setup tracing, but it will be ignored since run_with_metric_collection already sets it.
-        let vdata = engine
-            .run_test(vec![fib_chip.generate_air_proof_input()])
-            .unwrap();
+        let (fib_air, fib_input) = collect_airs_and_inputs!(fib_chip);
+        let vdata = engine.run_test(fib_air, fib_input).unwrap();
         // Unlike other apps, this "app" does not have continuations enabled.
         let app_fri_params =
             FriParameters::standard_with_100_bits_conjectured_security(leaf_log_blowup);

crates/circuits/primitives/derive/src/lib.rs

@@ -107,7 +107,7 @@ pub fn chip_derive(input: TokenStream) -> TokenStream {
                 .push(syn::parse_quote! { #inner_ty: openvm_stark_backend::Chip<SC> });
             quote! {
                 impl #impl_generics openvm_stark_backend::Chip<SC> for #name #ty_generics #where_clause {
-                    fn air(&self) -> std::sync::Arc<dyn openvm_stark_backend::rap::AnyRap<SC>> {
+                    fn air(&self) -> openvm_stark_backend::AirRef<SC> {
                         self.0.air()
                     }
                     fn generate_air_proof_input(self) -> openvm_stark_backend::prover::types::AirProofInput<SC> {
@@ -195,7 +195,7 @@ pub fn chip_derive(input: TokenStream) -> TokenStream {
 
             quote! {
                 impl #impl_generics openvm_stark_backend::Chip<SC> for #name #ty_generics #where_clause {
-                    fn air(&self) -> std::sync::Arc<dyn openvm_stark_backend::rap::AnyRap<SC>> {
+                    fn air(&self) -> openvm_stark_backend::AirRef<SC> {
                         match self {
                             #(#air_arms,)*
                         }

crates/circuits/primitives/src/bitwise_op_lookup/mod.rs

@@ -16,8 +16,8 @@ use openvm_stark_backend::{
     p3_field::{Field, FieldAlgebra},
     p3_matrix::{dense::RowMajorMatrix, Matrix},
     prover::types::AirProofInput,
-    rap::{get_air_name, AnyRap, BaseAirWithPublicValues, PartitionedBaseAir},
-    Chip, ChipUsageGetter, Stateful,
+    rap::{get_air_name, BaseAirWithPublicValues, PartitionedBaseAir},
+    AirRef, Chip, ChipUsageGetter, Stateful,
 };
 
 mod bus;
@@ -210,20 +210,20 @@ impl<const NUM_BITS: usize> SharedBitwiseOperationLookupChip<NUM_BITS> {
 impl<SC: StarkGenericConfig, const NUM_BITS: usize> Chip<SC>
     for BitwiseOperationLookupChip<NUM_BITS>
 {
-    fn air(&self) -> Arc<dyn AnyRap<SC>> {
+    fn air(&self) -> AirRef<SC> {
         Arc::new(self.air)
     }
 
     fn generate_air_proof_input(self) -> AirProofInput<SC> {
         let trace = self.generate_trace::<Val<SC>>();
-        AirProofInput::simple_no_pis(Arc::new(self.air), trace)
+        AirProofInput::simple_no_pis(trace)
     }
 }
 
 impl<SC: StarkGenericConfig, const NUM_BITS: usize> Chip<SC>
     for SharedBitwiseOperationLookupChip<NUM_BITS>
 {
-    fn air(&self) -> Arc<dyn AnyRap<SC>> {
+    fn air(&self) -> AirRef<SC> {
         self.0.air()
     }
 

crates/circuits/primitives/src/bitwise_op_lookup/tests/mod.rs

@@ -5,9 +5,9 @@ use openvm_stark_backend::{
     p3_field::FieldAlgebra,
     p3_matrix::dense::RowMajorMatrix,
     p3_maybe_rayon::prelude::{IntoParallelRefIterator, ParallelIterator},
-    prover::USE_DEBUG_BUILDER,
-    rap::AnyRap,
+    utils::disable_debug_builder,
     verifier::VerificationError,
+    AirRef,
 };
 use openvm_stark_sdk::{
     any_rap_arc_vec, config::baby_bear_poseidon2::BabyBearPoseidon2Engine, engine::StarkFriEngine,
@@ -70,9 +70,9 @@ fn test_bitwise_operation_lookup() {
 
     let chips = dummies
         .into_iter()
-        .map(|list| Arc::new(list) as Arc<dyn AnyRap<_>>)
-        .chain(iter::once(Arc::new(lookup.air) as Arc<dyn AnyRap<_>>))
-        .collect::<Vec<Arc<dyn AnyRap<_>>>>();
+        .map(|list| Arc::new(list) as AirRef<_>)
+        .chain(iter::once(Arc::new(lookup.air) as AirRef<_>))
+        .collect::<Vec<AirRef<_>>>();
 
     let mut traces = lists
         .par_iter()
@@ -129,9 +129,7 @@ fn run_negative_test(bad_row: (u32, u32, u32, BitwiseOperation)) {
         lookup.generate_trace(),
     ];
 
-    USE_DEBUG_BUILDER.with(|debug| {
-        *debug.lock().unwrap() = false;
-    });
+    disable_debug_builder();
     assert_eq!(
         BabyBearPoseidon2Engine::run_simple_test_no_pis_fast(chips, traces).err(),
         Some(VerificationError::ChallengePhaseError),

crates/circuits/primitives/src/range/tests/mod.rs

@@ -1,9 +1,7 @@
 use std::{iter, sync::Arc};
 
 use list::ListChip;
-use openvm_stark_backend::{
-    p3_matrix::dense::RowMajorMatrix, p3_maybe_rayon::prelude::*, rap::AnyRap,
-};
+use openvm_stark_backend::{p3_matrix::dense::RowMajorMatrix, p3_maybe_rayon::prelude::*, AirRef};
 use openvm_stark_sdk::{
     config::baby_bear_blake3::BabyBearBlake3Engine, engine::StarkFriEngine, p3_baby_bear::BabyBear,
     utils::create_seeded_rng,
@@ -53,7 +51,7 @@ fn test_list_range_checker() {
 
     let range_trace = range_checker.generate_trace();
 
-    let mut all_chips: Vec<Arc<dyn AnyRap<_>>> = vec![];
+    let mut all_chips: Vec<AirRef<_>> = vec![];
     for list in lists {
         all_chips.push(Arc::new(list.air));
     }

crates/circuits/primitives/src/range_gate/tests.rs

@@ -2,7 +2,7 @@ use std::{iter, sync::Arc};
 
 use openvm_stark_backend::{
     p3_field::FieldAlgebra, p3_matrix::dense::RowMajorMatrix, p3_maybe_rayon::prelude::*,
-    rap::AnyRap, utils::disable_debug_builder, verifier::VerificationError,
+    utils::disable_debug_builder, verifier::VerificationError, AirRef,
 };
 use openvm_stark_sdk::{
     any_rap_arc_vec, config::baby_bear_blake3::BabyBearBlake3Engine,
@@ -61,7 +61,7 @@ fn test_range_gate_chip() {
 
     let mut all_chips = lists
         .into_iter()
-        .map(|list| Arc::new(list) as Arc<dyn AnyRap<_>>)
+        .map(|list| Arc::new(list) as AirRef<_>)
         .collect::<Vec<_>>();
     all_chips.push(Arc::new(range_checker.air));
 

crates/circuits/primitives/src/range_tuple/mod.rs

@@ -19,8 +19,8 @@ use openvm_stark_backend::{
     p3_field::{Field, PrimeField32},
     p3_matrix::{dense::RowMajorMatrix, Matrix},
     prover::types::AirProofInput,
-    rap::{get_air_name, AnyRap, BaseAirWithPublicValues, PartitionedBaseAir},
-    Chip, ChipUsageGetter, Stateful,
+    rap::{get_air_name, BaseAirWithPublicValues, PartitionedBaseAir},
+    AirRef, Chip, ChipUsageGetter, Stateful,
 };
 
 mod bus;
@@ -188,21 +188,21 @@ impl<SC: StarkGenericConfig, const N: usize> Chip<SC> for RangeTupleCheckerChip<
 where
     Val<SC>: PrimeField32,
 {
-    fn air(&self) -> Arc<dyn AnyRap<SC>> {
+    fn air(&self) -> AirRef<SC> {
         Arc::new(self.air)
     }
 
     fn generate_air_proof_input(self) -> AirProofInput<SC> {
         let trace = self.generate_trace::<Val<SC>>();
-        AirProofInput::simple_no_pis(Arc::new(self.air), trace)
+        AirProofInput::simple_no_pis(trace)
     }
 }
 
 impl<SC: StarkGenericConfig, const N: usize> Chip<SC> for SharedRangeTupleCheckerChip<N>
 where
     Val<SC>: PrimeField32,
 {
-    fn air(&self) -> Arc<dyn AnyRap<SC>> {
+    fn air(&self) -> AirRef<SC> {
         self.0.air()
     }
 

crates/circuits/primitives/src/range_tuple/tests.rs

@@ -1,8 +1,7 @@
 use std::{array, iter, sync::Arc};
 
 use openvm_stark_backend::{
-    p3_field::FieldAlgebra, p3_matrix::dense::RowMajorMatrix, p3_maybe_rayon::prelude::*,
-    rap::AnyRap,
+    p3_field::FieldAlgebra, p3_matrix::dense::RowMajorMatrix, p3_maybe_rayon::prelude::*, AirRef,
 };
 use openvm_stark_sdk::{
     config::baby_bear_blake3::BabyBearBlake3Engine,
@@ -46,7 +45,7 @@ fn test_range_tuple_chip() {
 
     let mut all_chips = lists_airs
         .into_iter()
-        .map(|list| Arc::new(list) as Arc<dyn AnyRap<_>>)
+        .map(|list| Arc::new(list) as AirRef<_>)
         .collect::<Vec<_>>();
     all_chips.push(Arc::new(range_checker.air));
 

crates/circuits/primitives/src/var_range/mod.rs

@@ -20,8 +20,8 @@ use openvm_stark_backend::{
     p3_field::{Field, PrimeField32},
     p3_matrix::{dense::RowMajorMatrix, Matrix},
     prover::types::AirProofInput,
-    rap::{get_air_name, AnyRap, BaseAirWithPublicValues, PartitionedBaseAir},
-    Chip, ChipUsageGetter, Stateful,
+    rap::{get_air_name, BaseAirWithPublicValues, PartitionedBaseAir},
+    AirRef, Chip, ChipUsageGetter, Stateful,
 };
 use tracing::instrument;
 
@@ -219,21 +219,21 @@ impl<SC: StarkGenericConfig> Chip<SC> for VariableRangeCheckerChip
 where
     Val<SC>: PrimeField32,
 {
-    fn air(&self) -> Arc<dyn AnyRap<SC>> {
+    fn air(&self) -> AirRef<SC> {
         Arc::new(self.air)
     }
 
     fn generate_air_proof_input(self) -> AirProofInput<SC> {
         let trace = self.generate_trace::<Val<SC>>();
-        AirProofInput::simple_no_pis(Arc::new(self.air), trace)
+        AirProofInput::simple_no_pis(trace)
     }
 }
 
 impl<SC: StarkGenericConfig> Chip<SC> for SharedVariableRangeCheckerChip
 where
     Val<SC>: PrimeField32,
 {
-    fn air(&self) -> Arc<dyn AnyRap<SC>> {
+    fn air(&self) -> AirRef<SC> {
         self.0.air()
     }
 

crates/circuits/primitives/src/var_range/tests/mod.rs

@@ -2,7 +2,7 @@ use std::{iter, sync::Arc};
 
 use openvm_stark_backend::{
     p3_field::FieldAlgebra, p3_matrix::dense::RowMajorMatrix, p3_maybe_rayon::prelude::*,
-    prover::USE_DEBUG_BUILDER, rap::AnyRap, verifier::VerificationError,
+    utils::disable_debug_builder, verifier::VerificationError, AirRef,
 };
 use openvm_stark_sdk::{
     any_rap_arc_vec, config::baby_bear_blake3::BabyBearBlake3Engine, engine::StarkFriEngine,
@@ -50,7 +50,7 @@ fn test_variable_range_checker_chip_send() {
 
     let mut all_chips = lists_airs
         .into_iter()
-        .map(|list| Arc::new(list) as Arc<dyn AnyRap<_>>)
+        .map(|list| Arc::new(list) as AirRef<_>)
         .collect::<Vec<_>>();
     all_chips.push(Arc::new(var_range_checker.air));
 
@@ -123,9 +123,7 @@ fn negative_test_variable_range_checker_chip_send() {
     let var_range_trace = var_range_checker.generate_trace();
     let all_traces = vec![list_trace, var_range_trace];
 
-    USE_DEBUG_BUILDER.with(|debug| {
-        *debug.lock().unwrap() = false;
-    });
+    disable_debug_builder();
     assert_eq!(
         BabyBearBlake3Engine::run_simple_test_no_pis_fast(all_chips, all_traces).err(),
         Some(VerificationError::ChallengePhaseError),
@@ -163,7 +161,7 @@ fn test_variable_range_checker_chip_range_check() {
 
     let mut all_chips = lists_airs
         .into_iter()
-        .map(|list| Arc::new(list) as Arc<dyn AnyRap<_>>)
+        .map(|list| Arc::new(list) as AirRef<_>)
         .collect::<Vec<_>>();
     all_chips.push(Arc::new(var_range_checker.air));
 
@@ -234,9 +232,7 @@ fn negative_test_variable_range_checker_chip_range_check() {
     let var_range_trace = var_range_checker.generate_trace();
     let all_traces = vec![list_trace, var_range_trace];
 
-    USE_DEBUG_BUILDER.with(|debug| {
-        *debug.lock().unwrap() = false;
-    });
+    disable_debug_builder();
     assert_eq!(
         BabyBearBlake3Engine::run_simple_test_no_pis_fast(all_chips, all_traces).err(),
         Some(VerificationError::ChallengePhaseError),

crates/circuits/primitives/src/xor/lookup/mod.rs

@@ -15,8 +15,8 @@ use openvm_stark_backend::{
     p3_field::Field,
     p3_matrix::{dense::RowMajorMatrix, Matrix},
     prover::types::AirProofInput,
-    rap::{get_air_name, AnyRap, BaseAirWithPublicValues, PartitionedBaseAir},
-    Chip, ChipUsageGetter,
+    rap::{get_air_name, BaseAirWithPublicValues, PartitionedBaseAir},
+    AirRef, Chip, ChipUsageGetter,
 };
 
 use super::bus::XorBus;
@@ -154,13 +154,13 @@ impl<const M: usize> XorLookupChip<M> {
 }
 
 impl<SC: StarkGenericConfig, const M: usize> Chip<SC> for XorLookupChip<M> {
-    fn air(&self) -> Arc<dyn AnyRap<SC>> {
+    fn air(&self) -> AirRef<SC> {
         Arc::new(self.air)
     }
 
     fn generate_air_proof_input(self) -> AirProofInput<SC> {
         let trace = self.generate_trace::<Val<SC>>();
-        AirProofInput::simple_no_pis(Arc::new(self.air), trace)
+        AirProofInput::simple_no_pis(trace)
     }
 }
 

crates/circuits/primitives/src/xor/lookup/tests.rs

@@ -2,7 +2,7 @@ use std::{iter, sync::Arc};
 
 use openvm_stark_backend::{
     p3_field::FieldAlgebra, p3_matrix::dense::RowMajorMatrix, p3_maybe_rayon::prelude::*,
-    rap::AnyRap, utils::disable_debug_builder, verifier::VerificationError,
+    utils::disable_debug_builder, verifier::VerificationError, AirRef,
 };
 use openvm_stark_sdk::{
     any_rap_arc_vec, config::baby_bear_blake3::BabyBearBlake3Engine,
@@ -68,7 +68,7 @@ fn test_xor_limbs_chip() {
 
     let xor_trace = xor_chip.generate_trace();
 
-    let mut all_chips: Vec<Arc<dyn AnyRap<_>>> = vec![];
+    let mut all_chips: Vec<AirRef<_>> = vec![];
     for requester in requesters {
         all_chips.push(Arc::new(requester));
     }

crates/circuits/sha256-air/src/tests.rs

@@ -13,8 +13,8 @@ use openvm_stark_backend::{
     p3_air::{Air, BaseAir},
     p3_field::{Field, PrimeField32},
     prover::types::AirProofInput,
-    rap::{get_air_name, AnyRap, BaseAirWithPublicValues, PartitionedBaseAir},
-    Chip, ChipUsageGetter,
+    rap::{get_air_name, BaseAirWithPublicValues, PartitionedBaseAir},
+    AirRef, Chip, ChipUsageGetter,
 };
 use openvm_stark_sdk::utils::create_seeded_rng;
 use rand::Rng;
@@ -54,18 +54,17 @@ impl<SC: StarkGenericConfig> Chip<SC> for Sha256TestChip
 where
     Val<SC>: PrimeField32,
 {
-    fn air(&self) -> Arc<dyn AnyRap<SC>> {
+    fn air(&self) -> AirRef<SC> {
         Arc::new(self.air.clone())
     }
 
     fn generate_air_proof_input(self) -> AirProofInput<SC> {
-        let air = self.air();
         let trace = crate::generate_trace::<Val<SC>>(
             &self.air.sub_air,
             self.bitwise_lookup_chip.clone(),
             self.records,
         );
-        AirProofInput::simple(air, trace, vec![])
+        AirProofInput::simple_no_pis(trace)
     }
 }
 

crates/prof/src/aggregate.rs

@@ -268,6 +268,7 @@ pub const VM_METRIC_NAMES: &[&str] = &[
     "main_trace_commit_time_ms",
     "generate_perm_trace_time_ms",
     "perm_trace_commit_time_ms",
+    "quotient_extended_view_time_ms",
     "quotient_poly_compute_time_ms",
     "quotient_poly_commit_time_ms",
     "pcs_opening_time_ms",

crates/sdk/src/commit.rs

@@ -55,13 +55,9 @@ impl AppExecutionCommit<F> {
         );
         let hasher = vm_poseidon2_hasher();
         let memory_dimensions = app_vm_config.system().memory_config.memory_dimensions();
-        let app_program_commit: [F; DIGEST_SIZE] =
-            app_exe.committed_program.prover_data.commit.into();
-        let leaf_verifier_program_commit: [F; DIGEST_SIZE] = leaf_vm_verifier_exe
-            .committed_program
-            .prover_data
-            .commit
-            .into();
+        let app_program_commit: [F; DIGEST_SIZE] = app_exe.committed_program.commitment.into();
+        let leaf_verifier_program_commit: [F; DIGEST_SIZE] =
+            leaf_vm_verifier_exe.committed_program.commitment.into();
 
         let mem_config = app_vm_config.system().memory_config;
         let init_memory_commit = MemoryNode::tree_from_memory(