chore: fix tests + cargo fmt

Author: stephenh-axiom-xyz

Cargo.lock

@@ -0,0 +1,87 @@
+use std::{borrow::BorrowMut, sync::Arc};
+
+use eyre::Result;
+use openvm_stark_backend::{
+    keygen::types::{MultiStarkProvingKey, MultiStarkVerifyingKey},
+    proof::Proof,
+    prover::{AirProvingContext, DeviceDataTransporter, ProvingContext},
+    AirRef, PartitionedBaseAir, StarkEngine,
+};
+use openvm_stark_sdk::config::baby_bear_poseidon2::{
+    BabyBearPoseidon2CpuEngine, DuplexSponge, DIGEST_SIZE, F,
+};
+use p3_air::{Air, AirBuilder, AirBuilderWithPublicValues, BaseAir, BaseAirWithPublicValues};
+use p3_field::PrimeCharacteristicRing;
+use p3_matrix::{dense::RowMajorMatrix, Matrix};
+
+use crate::{circuit::deferral::DeferralCircuitPvs, SC};
+
+pub(in crate::tests) struct EmptyAirWithPvs(pub(in crate::tests) usize);
+
+impl<F> BaseAir<F> for EmptyAirWithPvs {
+    fn width(&self) -> usize {
+        1
+    }
+}
+impl<F> BaseAirWithPublicValues<F> for EmptyAirWithPvs {
+    fn num_public_values(&self) -> usize {
+        self.0
+    }
+}
+impl<F> PartitionedBaseAir<F> for EmptyAirWithPvs {}
+impl<AB: AirBuilder + AirBuilderWithPublicValues> Air<AB> for EmptyAirWithPvs {
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local = main.row_slice(0).unwrap();
+        builder.assert_zero(local[0].clone());
+
+        let pvs: Vec<AB::Expr> = builder
+            .public_values()
+            .iter()
+            .map(|pv| (*pv).into())
+            .collect();
+        for pv in pvs {
+            builder.assert_eq(pv.clone(), pv);
+        }
+    }
+}
+
+pub(in crate::tests) fn generate_dummy_def_proof(
+    engine: &BabyBearPoseidon2CpuEngine<DuplexSponge>,
+    pk: &MultiStarkProvingKey<SC>,
+    input_commit: [F; DIGEST_SIZE],
+    output_commit: [F; DIGEST_SIZE],
+) -> Proof<SC> {
+    let mut pvs = vec![F::ZERO; DeferralCircuitPvs::<u8>::width()];
+    let pvs_ref: &mut DeferralCircuitPvs<F> = pvs.as_mut_slice().borrow_mut();
+    pvs_ref.input_commit = input_commit;
+    pvs_ref.output_commit = output_commit;
+
+    let trace = RowMajorMatrix::new(vec![F::ZERO], 1);
+    let ctx = ProvingContext {
+        per_trace: vec![(
+            0,
+            AirProvingContext {
+                cached_mains: vec![],
+                common_main: trace,
+                public_values: pvs,
+            },
+        )],
+    };
+    let d_pk = engine.device().transport_pk_to_device(pk);
+    engine.prove(&d_pk, ctx).unwrap()
+}
+
+pub(in crate::tests) fn generate_single_dummy_def_proof(
+) -> Result<(Arc<MultiStarkVerifyingKey<SC>>, Proof<SC>)> {
+    let engine = BabyBearPoseidon2CpuEngine::<DuplexSponge>::new(super::app_system_params());
+    let (pk, vk) = engine
+        .keygen(&[Arc::new(EmptyAirWithPvs(DeferralCircuitPvs::<u8>::width())) as AirRef<SC>]);
+    let proof = generate_dummy_def_proof(
+        &engine,
+        &pk,
+        [F::ONE; DIGEST_SIZE],
+        [F::from_u8(2); DIGEST_SIZE],
+    );
+    Ok((Arc::new(vk), proof))
+}

crates/continuations/src/tests/dummy.rs

@@ -24,11 +24,7 @@ use openvm_rv32im_circuit::{Rv32I, Rv32Io, Rv32M};
 use openvm_rv32im_transpiler::{
     Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension,
 };
-use openvm_stark_backend::{
-    proof::Proof,
-    prover::{AirProvingContext, DeviceDataTransporter, ProvingContext},
-    AirRef, PartitionedBaseAir, StarkEngine,
-};
+use openvm_stark_backend::{proof::Proof, AirRef, StarkEngine};
 use openvm_stark_sdk::{
     config::{
         baby_bear_bn254_poseidon2::BabyBearBn254Poseidon2CpuEngine,
@@ -42,12 +38,14 @@ use openvm_transpiler::{
     elf::Elf, openvm_platform::memory::MEM_SIZE, transpiler::Transpiler, FromElf,
 };
 use openvm_verify_stark_host::pvs::{DeferralPvs, DEF_PVS_AIR_ID};
-use p3_air::{Air, AirBuilder, AirBuilderWithPublicValues, BaseAir, BaseAirWithPublicValues};
 use p3_field::{PrimeCharacteristicRing, PrimeField32};
-use p3_matrix::{dense::RowMajorMatrix, Matrix};
 use tracing::{warn, Level};
 
-use super::{app_system_params, internal_system_params, leaf_system_params, root_system_params};
+use super::{
+    app_system_params,
+    dummy::{generate_dummy_def_proof, EmptyAirWithPvs},
+    internal_system_params, leaf_system_params, root_system_params,
+};
 use crate::{
     circuit::{
         deferral::{verify::DeferralMerkleProofs, DeferralCircuitPvs, DEF_HOOK_PVS_AIR_ID},
@@ -76,36 +74,6 @@ const INPUT_RAW_0: [u8; 8] = [1, 2, 3, 4, 5, 6, 7, 8];
 const INPUT_RAW_1: [u8; 8] = [8, 7, 6, 5, 4, 3, 2, 1];
 const INPUT_RAW_2: [u8; 8] = [9, 9, 9, 9, 9, 9, 9, 9];
 
-struct EmptyAirWithPvs(usize);
-
-impl<F> BaseAir<F> for EmptyAirWithPvs {
-    fn width(&self) -> usize {
-        1
-    }
-}
-impl<F> BaseAirWithPublicValues<F> for EmptyAirWithPvs {
-    fn num_public_values(&self) -> usize {
-        self.0
-    }
-}
-impl<F> PartitionedBaseAir<F> for EmptyAirWithPvs {}
-impl<AB: AirBuilder + AirBuilderWithPublicValues> Air<AB> for EmptyAirWithPvs {
-    fn eval(&self, builder: &mut AB) {
-        let main = builder.main();
-        let local = main.row_slice(0).unwrap();
-        builder.assert_zero(local[0].clone());
-
-        let pvs: Vec<AB::Expr> = builder
-            .public_values()
-            .iter()
-            .map(|pv| (*pv).into())
-            .collect();
-        for pv in pvs {
-            builder.assert_eq(pv.clone(), pv);
-        }
-    }
-}
-
 fn make_deferral_extension() -> DeferralExtension {
     let fns: Vec<_> = (0..NUM_DEF_CIRCUITS)
         .map(|idx| {
@@ -224,34 +192,6 @@ fn generate_set_merkle_proof(
     proof
 }
 
-fn generate_dummy_def_proof(
-    engine: &AppEngine,
-    pk: &openvm_stark_backend::keygen::types::MultiStarkProvingKey<SC>,
-    input_commit: [F; DIGEST_SIZE],
-    output_commit: [F; DIGEST_SIZE],
-) -> Proof<SC> {
-    use std::borrow::BorrowMut;
-
-    let mut pvs = vec![F::ZERO; DeferralCircuitPvs::<u8>::width()];
-    let pvs_ref: &mut DeferralCircuitPvs<F> = pvs.as_mut_slice().borrow_mut();
-    pvs_ref.input_commit = input_commit;
-    pvs_ref.output_commit = output_commit;
-
-    let trace = RowMajorMatrix::new(vec![F::ZERO], 1);
-    let ctx = ProvingContext {
-        per_trace: vec![(
-            0,
-            AirProvingContext {
-                cached_mains: vec![],
-                common_main: trace,
-                public_values: pvs,
-            },
-        )],
-    };
-    let d_pk = engine.device().transport_pk_to_device(pk);
-    engine.prove(&d_pk, ctx).unwrap()
-}
-
 fn read_def_pvs(proof: &Proof<SC>) -> DeferralPvs<F> {
     *proof.public_values[DEF_PVS_AIR_ID].as_slice().borrow()
 }

crates/continuations/src/tests/e2e.rs

@@ -34,9 +34,9 @@ use tracing::Level;
 use crate::{prover::ChildVkKind, SC};
 
 #[cfg(feature = "cuda")]
-mod e2e;
+mod dummy;
 #[cfg(feature = "cuda")]
-mod verify;
+mod e2e;
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "cuda")] {
@@ -46,27 +46,24 @@ cfg_if::cfg_if! {
         use crate::prover::{
             DeferralInnerGpuProver as DeferralInnerProver,
             DeferralHookGpuProver as DeferralHookProver,
-            DeferralVerifyGpuProver as DeferredVerifyProver,
         };
         use crate::circuit::{
             deferral::{
-                verify::output::expected_output_commit,
                 DeferralAggregationPvs,
                 DeferralCircuitPvs,
                 DEF_AGG_PVS_AIR_ID,
             },
-            root::RootVerifierPvs,
         };
         use openvm_recursion_circuit::utils::poseidon2_hash_slice_with_states;
         use openvm_cuda_backend::{BabyBearPoseidon2GpuEngine, GpuBackend};
-        use openvm_stark_backend::{prover::CommittedTraceData, verifier::verify, TranscriptHistory};
+        use openvm_stark_backend::{prover::CommittedTraceData};
         use openvm_stark_sdk::config::{
-            baby_bear_poseidon2::{poseidon2_compress_with_capacity, default_duplex_sponge_recorder},
+            baby_bear_poseidon2::{poseidon2_compress_with_capacity},
             baby_bear_bn254_poseidon2::BabyBearBn254Poseidon2CpuEngine,
         };
         use openvm_verify_stark_host::pvs::{VERIFIER_PVS_AIR_ID, DeferralPvs, VerifierBasePvs};
         use crate::prover::DeferralChildVkKind;
-        use crate::utils::{poseidon2_input_to_digests, zero_hash};
+        use crate::utils::zero_hash;
         type RootEngine = BabyBearBn254Poseidon2CpuEngine;
         type Engine = BabyBearPoseidon2GpuEngine;
         type PB = GpuBackend;
@@ -365,26 +362,9 @@ fn test_root_prover_trace_heights() -> Result<()> {
 
 #[cfg(feature = "cuda")]
 fn generate_single_def_proof(
-    child_extra_recursive_layers: usize,
+    _child_extra_recursive_layers: usize,
 ) -> Result<(Arc<MultiStarkVerifyingKey<SC>>, Proof<SC>)> {
-    let (
-        internal_recursive_vk,
-        internal_recursive_pcs_data,
-        internal_recursive_proof,
-        user_pvs_proof,
-    ) = run_full_aggregation(10, child_extra_recursive_layers)?;
-    let system_config = test_rv32im_config().rv32i.system;
-    let deferred_verify_prover = DeferredVerifyProver::new::<Engine>(
-        internal_recursive_vk,
-        internal_recursive_pcs_data,
-        root_system_params(),
-        system_config.memory_config.memory_dimensions(),
-        system_config.num_public_values,
-        None,
-    );
-    let def_proof =
-        deferred_verify_prover.prove_no_def::<Engine>(internal_recursive_proof, &user_pvs_proof)?;
-    Ok((deferred_verify_prover.get_vk(), def_proof))
+    dummy::generate_single_dummy_def_proof()
 }
 
 #[cfg(feature = "cuda")]
@@ -525,85 +505,6 @@ fn expected_deferral_inner_merkle_commit_from_copies(
     commits[0]
 }
 
-#[cfg(feature = "cuda")]
-#[test_case(0 ; "internal_recursive_dag_commit not set")]
-#[test_case(1 ; "internal_recursive_dag_commit set")]
-fn test_deferral_verify_prover(child_extra_recursive_layers: usize) -> Result<()> {
-    setup_tracing_with_log_level(Level::INFO);
-    let (
-        internal_recursive_vk,
-        internal_recursive_pcs_data,
-        internal_recursive_proof,
-        user_pvs_proof,
-    ) = run_full_aggregation(10, child_extra_recursive_layers)?;
-
-    let system_config = test_rv32im_config().rv32i.system;
-
-    // Compute def_proof
-    let deferred_verify_prover = DeferredVerifyProver::new::<Engine>(
-        internal_recursive_vk.clone(),
-        internal_recursive_pcs_data.clone(),
-        root_system_params(),
-        system_config.memory_config.memory_dimensions(),
-        system_config.num_public_values,
-        None,
-    );
-    let def_proof = deferred_verify_prover
-        .prove_no_def::<Engine>(internal_recursive_proof.clone(), &user_pvs_proof)?;
-
-    // Verify that def_proof is valid
-    let vk = deferred_verify_prover.get_vk();
-    let engine = Engine::new(vk.inner.params.clone());
-    engine.verify(&vk, &def_proof)?;
-
-    // Get the final transcript state of internal_recursive_proof
-    let mut ts = default_duplex_sponge_recorder();
-    let config = SC::default_from_params(internal_recursive_vk.inner.params.clone());
-    verify(
-        &config,
-        internal_recursive_vk.as_ref(),
-        &internal_recursive_proof,
-        &mut ts,
-    )?;
-    let ts_log = ts.into_log();
-    let expected_final_ts_state = ts_log.perm_results().last().unwrap();
-
-    // Generate a root_proof to compare the pvs of def_proof against
-    let root_prover = RootProver::new::<RootEngine>(
-        internal_recursive_vk,
-        internal_recursive_pcs_data.commitment.into(),
-        root_system_params(),
-        system_config.memory_config.memory_dimensions(),
-        system_config.num_public_values,
-        None,
-        None,
-    );
-    let ctx = root_prover.generate_proving_ctx(internal_recursive_proof, &user_pvs_proof);
-    let root_proof = root_prover.root_prove_from_ctx::<RootEngine>(ctx.unwrap())?;
-
-    // Assert the correctness of the def_proof public values
-    let root_pvs: &RootVerifierPvs<F> = root_proof.public_values[VERIFIER_PVS_AIR_ID]
-        .as_slice()
-        .borrow();
-    // RootCircuit AIR layout is:
-    // 0: RootVerifierPvsAir, 1: UserPvsCommitAir, 2: UserPvsInMemoryAir, 3..: verifier subcircuit.
-    const ROOT_USER_PVS_COMMIT_AIR_ID: usize = 1;
-    let user_pvs = root_proof.public_values[ROOT_USER_PVS_COMMIT_AIR_ID].clone();
-
-    let (left, right) = poseidon2_input_to_digests(*expected_final_ts_state);
-    let expected_input_commit = poseidon2_compress_with_capacity(left, right).0;
-    let expected_output_commit =
-        expected_output_commit(root_pvs.app_exe_commit, root_pvs.app_vk_commit, user_pvs);
-
-    let def_pvs: &DeferralCircuitPvs<F> = def_proof.public_values[VERIFIER_PVS_AIR_ID]
-        .as_slice()
-        .borrow();
-    assert_eq!(expected_input_commit, def_pvs.input_commit);
-    assert_eq!(expected_output_commit, def_pvs.output_commit);
-
-    Ok(())
-}
-
 #[cfg(feature = "cuda")]
 #[test_case(0, 1 ; "internal_recursive_dag_commit not set + one child")]
 #[test_case(1, 1 ; "internal_recursive_dag_commit set + one child")]