Add integration test

Author: nyunyunyunyu

Cargo.lock

@@ -15,7 +15,7 @@ use openvm_stark_sdk::{
     },
 };
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
-use static_assertions::assert_impl_all;
+use static_assertions::{assert_impl_all, const_assert_eq};
 
 use crate::{verifier::common::types::VmVerifierPvs, SC};
 

crates/continuations/src/verifier/internal/types.rs

@@ -58,6 +58,12 @@ hex.workspace = true
 forge-fmt = { workspace = true, optional = true }
 rrs-lib = { workspace = true }
 
+[dev-dependencies]
+cargo-openvm.workspace = true
+hex-literal = { version = "0.4.1", default-features = false }
+openvm-rv32im-guest.workspace = true
+
+
 [features]
 default = ["parallel", "jemalloc", "evm-verify"]
 evm-prove = ["openvm-native-recursion/evm-prove"]

crates/sdk/Cargo.toml

@@ -46,7 +46,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     /// use std::path::PathBuf;
     ///
     /// let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).to_path_buf();
-    /// path.push("guest");
+    /// path.push("guest/fib");
     /// let target_path = path.to_str().unwrap();
     /// ```
     // ANCHOR: build

crates/sdk/examples/sdk_app.rs

@@ -46,7 +46,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     /// use std::path::PathBuf;
     ///
     /// let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).to_path_buf();
-    /// path.push("guest");
+    /// path.push("guest/fib");
     /// let target_path = path.to_str().unwrap();
     /// ```
     // ANCHOR: build

crates/sdk/examples/sdk_evm.rs

@@ -5,4 +5,4 @@ version = "0.0.0"
 edition = "2021"
 
 [dependencies]
-openvm = { path = "../../toolchain/openvm" }
+openvm = { path = "../../../toolchain/openvm" }

crates/sdk/guest/Cargo.toml renamed to crates/sdk/guest/fib/Cargo.toml

@@ -0,0 +1,4 @@
+*.asm
+Cargo.lock
+target/
+openvm/

crates/sdk/guest/src/main.rs renamed to crates/sdk/guest/fib/src/main.rs

@@ -0,0 +1,18 @@
+[workspace]
+[package]
+name = "openvm-verify-stark-program"
+version = "0.0.0"
+edition = "2021"
+
+[dependencies]
+openvm = { path = "../../../toolchain/openvm", features = ["std"] }
+hex-literal = { version = "0.4.1", default-features = false }
+bytemuck = { version = "1.20.0", features = ["extern_crate_alloc"] }
+
+[features]
+default = []
+
+[profile.profiling]
+inherits = "release"
+debug = 2
+strip = false

crates/sdk/guest/verify_openvm_stark/.gitignore

@@ -0,0 +1,24 @@
+extern crate alloc;
+use alloc::vec::Vec;
+
+use openvm::{define_verify_openvm_stark, io::read};
+
+define_verify_openvm_stark!(
+    verify_openvm_stark,
+    env!("CARGO_MANIFEST_DIR"),
+    "root_verifier.asm"
+);
+
+// const APP_EXE_COMMIT: [u32; 8] = [
+//     343014587, 230645511, 1447462186, 773379336, 1182270030, 1497892484, 461820702, 353704350,
+// ];
+// const APP_VM_COMMIT: [u32; 8] = [
+//     445134834, 1133596793, 530952192, 425228715, 1806903712, 1362083369, 295028151, 482389308,
+// ];
+
+pub fn main() {
+    let app_exe_commit: [u32; 8] = read();
+    let app_vm_commit: [u32; 8] = read();
+    let pvs: Vec<u32> = read();
+    verify_openvm_stark(&app_exe_commit, &app_vm_commit, &pvs);
+}

crates/sdk/guest/verify_openvm_stark/Cargo.toml

@@ -1,4 +1,7 @@
-use std::collections::VecDeque;
+use std::{
+    collections::{HashMap, VecDeque},
+    sync::Arc,
+};
 
 use openvm_circuit::arch::Streams;
 use openvm_stark_backend::p3_field::FieldAlgebra;
@@ -9,6 +12,7 @@ use crate::F;
 #[derive(Clone, Default, Serialize, Deserialize)]
 pub struct StdIn {
     pub buffer: VecDeque<Vec<F>>,
+    pub kv_store: HashMap<Vec<u8>, Vec<u8>>,
 }
 
 impl StdIn {
@@ -36,6 +40,9 @@ impl StdIn {
     pub fn write_field(&mut self, data: &[F]) {
         self.buffer.push_back(data.to_vec());
     }
+    pub fn add_key_value(&mut self, key: Vec<u8>, value: Vec<u8>) {
+        self.kv_store.insert(key, value);
+    }
 }
 
 impl From<StdIn> for Streams<F> {
@@ -44,7 +51,9 @@ impl From<StdIn> for Streams<F> {
         while let Some(input) = std_in.read() {
             data.push(input);
         }
-        Streams::new(data)
+        let mut ret = Streams::new(data);
+        ret.kv_store = Arc::new(std_in.kv_store);
+        ret
     }
 }
 

crates/sdk/guest/verify_openvm_stark/src/main.rs

@@ -1,10 +1,14 @@
-use std::{borrow::Borrow, path::PathBuf, sync::Arc};
+use std::{array, borrow::Borrow, path::PathBuf, sync::Arc};
 
+use alloy_sol_types::private::U256;
+use cargo_openvm::util::read_config_toml_or_default;
 use eyre::Result;
+use itertools::Itertools;
 use openvm_build::GuestOptions;
 use openvm_circuit::{
     arch::{
-        hasher::poseidon2::vm_poseidon2_hasher, ContinuationVmProof, ExecutionError,
+        hasher::poseidon2::vm_poseidon2_hasher,
+        instructions::program::DEFAULT_MAX_NUM_PUBLIC_VALUES, ContinuationVmProof, ExecutionError,
         GenerationError, SingleSegmentVmExecutor, SystemConfig, VmConfig, VmExecutor,
     },
     system::{memory::tree::public_values::UserPublicValuesProof, program::trace::VmCommittedExe},
@@ -13,6 +17,7 @@ use openvm_continuations::{
     static_verifier::StaticVerifierPvHandler,
     verifier::{
         common::types::{SpecialAirIds, VmVerifierPvs},
+        internal::types::E2eStarkProof,
         leaf::types::{LeafVmVerifierInput, UserPublicValuesRootProof},
         root::types::RootVmVerifierPvs,
         utils::compress_babybear_var_to_bn254,
@@ -27,21 +32,28 @@ use openvm_native_recursion::{
         wrapper::Halo2WrapperProvingKey,
         RawEvmProof,
     },
+    hints::Hintable,
     types::InnerConfig,
     vars::StarkProofVariable,
 };
+use openvm_rv32im_guest::hint_load_by_key_encode;
 use openvm_rv32im_transpiler::{
     Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension,
 };
 use openvm_sdk::{
     codec::{Decode, Encode},
     commit::AppExecutionCommit,
     config::{AggConfig, AggStarkConfig, AppConfig, Halo2Config, SdkSystemConfig, SdkVmConfig},
+    fs::{decode_from_file, read_exe_from_file},
     keygen::{AggStarkProvingKey, AppProvingKey},
     types::{EvmHalo2Verifier, EvmProof},
     DefaultStaticVerifierPvHandler, Sdk, StdIn,
 };
-use openvm_stark_backend::{keygen::types::LinearConstraint, p3_matrix::Matrix};
+use openvm_stark_backend::{
+    keygen::types::LinearConstraint,
+    p3_field::{PrimeField32, PrimeField64},
+    p3_matrix::Matrix,
+};
 use openvm_stark_sdk::{
     config::{
         baby_bear_poseidon2::{BabyBearPoseidon2Config, BabyBearPoseidon2Engine},
@@ -399,7 +411,7 @@ fn test_static_verifier_custom_pv_handler() {
 #[test]
 fn test_e2e_proof_generation_and_verification_with_pvs() {
     let mut pkg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).to_path_buf();
-    pkg_dir.push("guest");
+    pkg_dir.push("guest/fib");
 
     let vm_config = SdkVmConfig::builder()
         .system(SdkSystemConfig {
@@ -469,7 +481,7 @@ fn test_sdk_guest_build_and_transpile() {
         // .with_options(vec!["--release"]);
         ;
     let mut pkg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).to_path_buf();
-    pkg_dir.push("guest");
+    pkg_dir.push("guest/fib");
     let one = sdk
         .build(guest_opts.clone(), &pkg_dir, &Default::default())
         .unwrap();
@@ -490,7 +502,7 @@ fn test_inner_proof_codec_roundtrip() -> eyre::Result<()> {
     // generate a proof
     let sdk = Sdk::new();
     let mut pkg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).to_path_buf();
-    pkg_dir.push("guest");
+    pkg_dir.push("guest/fib");
     let elf = sdk.build(Default::default(), pkg_dir, &Default::default())?;
 
     let vm_config = SdkVmConfig::builder()
@@ -580,11 +592,109 @@ fn test_segmentation_retry() {
         .sum();
     assert!(new_total_height < total_height);
 }
-
 #[test]
-fn test_root_verifier_asm_generate() {
-    let agg_stark_config = agg_stark_config_for_test();
-    let agg_pk = AggStarkProvingKey::keygen(agg_stark_config);
+fn test_verify_openvm_stark_e2e() -> Result<()> {
+    const ASM_FILENAME: &str = "root_verifier.asm";
     let sdk = Sdk::new();
-    sdk.generate_root_verifier_asm(&agg_pk);
+    let guest_opts = GuestOptions::default();
+    let mut pkg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).to_path_buf();
+    pkg_dir.push("guest/fib");
+    let elf = sdk.build(guest_opts.clone(), &pkg_dir, &Default::default())?;
+
+    let vm_config = SdkVmConfig::builder()
+        .system(SdkSystemConfig {
+            config: SystemConfig::default().with_continuations(),
+        })
+        .rv32i(Default::default())
+        .rv32m(Default::default())
+        .io(Default::default())
+        .native(Default::default())
+        .build();
+    assert!(vm_config.system.config.continuation_enabled);
+
+    let app_exe = sdk.transpile(elf, vm_config.transpiler())?;
+    let fri_params = FriParameters::new_for_testing(LEAF_LOG_BLOWUP);
+    let app_config = AppConfig::new_with_leaf_fri_params(fri_params, vm_config.clone(), fri_params);
+
+    let app_pk = sdk.app_keygen(app_config.clone())?;
+    let committed_app_exe = sdk.commit_app_exe(fri_params, app_exe.clone())?;
+
+    let commits =
+        AppExecutionCommit::compute(&vm_config, &committed_app_exe, &app_pk.leaf_committed_exe);
+
+    let agg_pk = AggStarkProvingKey::keygen(AggStarkConfig {
+        max_num_user_public_values: DEFAULT_MAX_NUM_PUBLIC_VALUES,
+        leaf_fri_params: FriParameters::new_for_testing(LEAF_LOG_BLOWUP),
+        internal_fri_params: FriParameters::new_for_testing(INTERNAL_LOG_BLOWUP),
+        root_fri_params: FriParameters::new_for_testing(ROOT_LOG_BLOWUP),
+        profiling: false,
+        compiler_options: CompilerOptions {
+            enable_cycle_tracker: true,
+            ..Default::default()
+        },
+        root_max_constraint_degree: (1 << ROOT_LOG_BLOWUP) + 1,
+    });
+    let asm = sdk.generate_root_verifier_asm(&agg_pk);
+    let asm_path = format!(
+        "{}/guest/verify_openvm_stark/{}",
+        env!("CARGO_MANIFEST_DIR"),
+        ASM_FILENAME
+    );
+    std::fs::write(asm_path, asm)?;
+
+    let e2e_stark_proof = sdk.generate_e2e_stark_proof(
+        Arc::new(app_pk),
+        committed_app_exe,
+        agg_pk,
+        StdIn::default(),
+    )?;
+
+    let verify_exe = {
+        let mut pkg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).to_path_buf();
+        pkg_dir.push("guest/verify_openvm_stark");
+        let elf = sdk.build(guest_opts.clone(), &pkg_dir, &Default::default())?;
+        sdk.transpile(elf, vm_config.transpiler())?
+    };
+
+    let pvs = vec![13u32, 21, 0, 0, 0, 0, 0, 0];
+
+    let exe_commit_u32: Vec<_> = commits
+        .exe_commit
+        .iter()
+        .map(|x| x.as_canonical_u32())
+        .collect();
+    let vm_commit_u32: Vec<_> = commits
+        .leaf_vm_verifier_commit
+        .iter()
+        .map(|x| x.as_canonical_u32())
+        .collect();
+    let pvs_u32: Vec<_> = pvs
+        .iter()
+        .flat_map(|x| x.to_le_bytes())
+        .map(|x| x as u32)
+        .collect();
+
+    let key = ASM_FILENAME
+        .as_bytes()
+        .iter()
+        .cloned()
+        .chain(exe_commit_u32.iter().flat_map(|x| x.to_le_bytes()))
+        .chain(vm_commit_u32.iter().flat_map(|x| x.to_le_bytes()))
+        .chain(pvs_u32.iter().flat_map(|x| x.to_le_bytes()))
+        .collect();
+    let mut stdin = StdIn::default();
+    let to_encode: Vec<Vec<F>> = e2e_stark_proof.proof.write();
+    let value = hint_load_by_key_encode(&to_encode);
+    stdin.add_key_value(key, value);
+
+    let exe_commit_u32_8: [u32; 8] = exe_commit_u32.try_into().unwrap();
+    let vm_commit_u32_8: [u32; 8] = vm_commit_u32.try_into().unwrap();
+
+    stdin.write(&exe_commit_u32_8);
+    stdin.write(&vm_commit_u32_8);
+    stdin.write(&pvs_u32);
+
+    sdk.execute(verify_exe, vm_config, stdin)?;
+
+    Ok(())
 }

crates/sdk/src/stdin.rs

@@ -15,7 +15,7 @@
 /// little-endian bytes.
 #[macro_export]
 macro_rules! define_verify_openvm_stark {
-    ($fn_name: ident, $asm_folder: literal, $asm_filename: literal) => {
+    ($fn_name: ident, $asm_folder: expr, $asm_filename: literal) => {
         pub fn $fn_name(app_exe_commit: &[u32; 8], app_vm_commit: &[u32; 8], user_pvs: &[u32]) {
             // The memory location for the start of the heap.
             const HEAP_START_ADDRESS: u32 = 1 << 24;