Move verify_openvm_stark into a new crate & refactor helper functions for verify_openvm_stark

Author: nyunyunyunyu

Cargo.lock

@@ -66,6 +66,8 @@ members = [
     "extensions/pairing/transpiler",
     "extensions/pairing/guest",
     "extensions/pairing/tests",
+    "guest-libs/verify_stark/guest",
+    "guest-libs/verify_stark/tests",
 ]
 exclude = ["crates/sdk/example"]
 resolver = "2"
@@ -162,6 +164,7 @@ openvm-ecc-sw-macros = { path = "extensions/ecc/sw-macros", default-features = f
 openvm-pairing-circuit = { path = "extensions/pairing/circuit", default-features = false }
 openvm-pairing-transpiler = { path = "extensions/pairing/transpiler", default-features = false }
 openvm-pairing-guest = { path = "extensions/pairing/guest", default-features = false }
+openvm-verify-stark = { path = "guest-libs/verify_stark/guest", default-features = false }
 
 # Benchmarking
 openvm-benchmarks-utils = { path = "benchmarks/utils", default-features = false }

Cargo.toml

@@ -1,13 +1,11 @@
 use std::{borrow::Borrow, path::PathBuf, sync::Arc};
 
 use eyre::Result;
-use openvm::host::{compute_hint_key_for_verify_openvm_stark, encode_rv32_public_values};
 use openvm_build::GuestOptions;
 use openvm_circuit::{
     arch::{
         hasher::poseidon2::vm_poseidon2_hasher, ContinuationVmProof, ExecutionError,
         GenerationError, SingleSegmentVmExecutor, SystemConfig, VmConfig, VmExecutor,
-        DEFAULT_MAX_NUM_PUBLIC_VALUES,
     },
     system::{memory::tree::public_values::UserPublicValuesProof, program::trace::VmCommittedExe},
 };
@@ -29,19 +27,17 @@ 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},
-    keygen::{AggStarkProvingKey, AppProvingKey},
+    keygen::AppProvingKey,
     types::{EvmHalo2Verifier, EvmProof},
     DefaultStaticVerifierPvHandler, Sdk, StdIn,
 };
@@ -578,90 +574,3 @@ fn test_segmentation_retry() {
         .sum();
     assert!(new_total_height < total_height);
 }
-#[test]
-fn test_verify_openvm_stark_e2e() -> Result<()> {
-    const ASM_FILENAME: &str = "root_verifier.asm";
-    let sdk = Sdk::new();
-    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())?
-    };
-
-    // app_exe publishes 7th and 8th fibonacci numbers.
-    let pvs = [13u32, 21, 0, 0, 0, 0, 0, 0];
-    let pvs_u32 = encode_rv32_public_values(&pvs);
-
-    let mut stdin = StdIn::default();
-    let key = compute_hint_key_for_verify_openvm_stark(
-        ASM_FILENAME,
-        &commits.exe_commit,
-        &commits.vm_commit,
-        &pvs_u32,
-    );
-    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);
-
-    stdin.write(&commits.exe_commit);
-    stdin.write(&commits.vm_commit);
-    stdin.write(&pvs_u32);
-
-    sdk.execute(verify_exe, vm_config, stdin)?;
-
-    Ok(())
-}

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

@@ -98,33 +98,6 @@ pub fn read_u32() -> u32 {
     u32::from_le_bytes(bytes.try_into().unwrap())
 }
 
-/// Compute the hint key for `verify_openvm_stark` function, which reads a stark proof from stream
-/// `kv_store`.
-pub fn compute_hint_key_for_verify_openvm_stark(
-    asm_filename: &str,
-    exe_commit_u32: &[u32; 8],
-    vm_commit_u32: &[u32; 8],
-    pvs_u32: &[u32],
-) -> Vec<u8> {
-    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()
-}
-
-/// Encode the public values in guest program(revealed by `reveal_u32`) into the format in proofs.
-pub fn encode_rv32_public_values(logic_pvs: &[u32]) -> Vec<u32> {
-    logic_pvs
-        .iter()
-        .flat_map(|x| x.to_le_bytes())
-        .map(|x| x as u32)
-        .collect()
-}
-
 #[cfg(all(feature = "std", test, not(target_os = "zkvm")))]
 mod tests {
     use alloc::vec;

crates/sdk/tests/integration_test.rs

@@ -29,8 +29,6 @@ pub mod utils;
 
 #[cfg(not(target_os = "zkvm"))]
 pub mod host;
-#[cfg(target_os = "zkvm")]
-pub mod verify_stark;
 
 #[cfg(target_os = "zkvm")]
 core::arch::global_asm!(include_str!("memset.s"));

crates/toolchain/openvm/src/host.rs

@@ -0,0 +1,16 @@
+[package]
+name = "openvm-verify-stark"
+description = "OpenVM guest library for verifying STARKs"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+homepage.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[target.'cfg(not(target_os = "zkvm"))'.dependencies]
+openvm-native-recursion.workspace = true
+openvm-rv32im-guest.workspace = true
+openvm-sdk = { workspace = true }
+openvm-stark-sdk = { workspace = true }

crates/toolchain/openvm/src/lib.rs

@@ -0,0 +1,28 @@
+use openvm_native_recursion::hints::Hintable;
+use openvm_rv32im_guest::hint_load_by_key_encode;
+use openvm_sdk::SC;
+use openvm_stark_sdk::{openvm_stark_backend::proof::Proof, p3_baby_bear::BabyBear};
+
+/// Compute the hint key for `verify_openvm_stark` function, which reads a stark proof from stream
+/// `kv_store`.
+pub fn compute_hint_key_for_verify_openvm_stark(
+    asm_filename: &str,
+    exe_commit_u32: &[u32; 8],
+    vm_commit_u32: &[u32; 8],
+    pvs: &[u8],
+) -> Vec<u8> {
+    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.iter().cloned())
+        .collect()
+}
+
+/// Encode a proof into a KV store value so `verify_openvm_stark` can hint it.
+pub fn encode_proof_to_kv_store_value(proof: &Proof<SC>) -> Vec<u8> {
+    let to_encode: Vec<Vec<BabyBear>> = proof.write();
+    hint_load_by_key_encode(&to_encode)
+}

guest-libs/verify_stark/guest/Cargo.toml

@@ -1,22 +1,24 @@
+#[cfg(not(target_os = "zkvm"))]
+pub mod host;
+
 /// Define a function that verifies an OpenVM Stark proof.
 /// To define this function, users need to specify the function name and an ASM file containing the
 /// assembly code for the verification(this ASM file can be generated by
 /// `Sdk.generate_root_verifier_asm` function). To specify the ASM file, users need to provide the
 /// parent folder and filename of the ASM file.
 /// To call this function:
 /// 1. users need to provide `app_exe_commit`/`app_vm_commit`/`user_pvs`(user public values) as the
-/// arguments. CAREFUL: `app_exe_commit`/`app_vm_commit`/`user_pvs` are in u32 and are interpreted
-/// as native fields. `user_pvs` are the exact public values of that proof. Which means, if a guest
-/// program calls `reveal_u32` to publish an u32(e.g. `258`) in the proof, that u32 is decomposed
-/// into 4 field elements in byte. In `user_pvs`, it should be an u32 array, `[2, 1, 0, 0]`.
+///    arguments. CAREFUL: `app_exe_commit`/`app_vm_commit` are in u32 and are interpreted as native
+///    fields. `user_pvs` are the exact public values of that proof. Here we assume all the public
+///    values are `u8`s.
 /// 2. Provide the corresponding stark proof in the key-value store in OpenVM streams. The key
-/// should be the concatenation of the filename, `app_exe_commit`, `app_vm_commit`, and `user_pvs`
-/// in little-endian bytes. Users can use `openvm::host::compute_hint_key_for_verify_openvm_stark`
-/// to compute the hint key.
+///    should be the concatenation of the filename, `app_exe_commit`, `app_vm_commit`, and
+///    `user_pvs` in little-endian bytes. Users can use
+///    `openvm::host::compute_hint_key_for_verify_openvm_stark` to compute the hint key.
 #[macro_export]
 macro_rules! define_verify_openvm_stark {
     ($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]) {
+        pub fn $fn_name(app_exe_commit: &[u32; 8], app_vm_commit: &[u32; 8], user_pvs: &[u8]) {
             // The memory location for the start of the heap.
             const HEAP_START_ADDRESS: u32 = 1 << 24;
             const FIELDS_PER_U32: u32 = 4;
@@ -28,7 +30,7 @@ macro_rules! define_verify_openvm_stark {
                 .cloned()
                 .chain(app_exe_commit.iter().flat_map(|x| x.to_le_bytes()))
                 .chain(app_vm_commit.iter().flat_map(|x| x.to_le_bytes()))
-                .chain(user_pvs.iter().flat_map(|x| x.to_le_bytes()))
+                .chain(user_pvs.iter().cloned())
                 .collect();
             openvm::io::hint_load_by_key(&hint_key);
             // Store the expected public values into the beginning of the native heap.
@@ -42,7 +44,7 @@ macro_rules! define_verify_openvm_stark {
                 native_addr += FIELDS_PER_U32;
             }
             for &x in user_pvs {
-                openvm::io::store_u32_to_native(native_addr, x);
+                openvm::io::store_u32_to_native(native_addr, x as u32);
                 native_addr += FIELDS_PER_U32;
             }
             // Assumption: the asm file should be generated by SDK. The code block should:

guest-libs/verify_stark/guest/src/host.rs

@@ -0,0 +1,22 @@
+[package]
+name = "openvm-verify-stark-integration-tests"
+description = "Integration tests for OpenVM verify-stark"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+homepage.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[dev-dependencies]
+openvm-sdk = { workspace = true }
+openvm-circuit.workspace = true
+openvm-stark-sdk = { workspace = true }
+openvm-build.workspace = true
+openvm-native-compiler.workspace = true
+openvm-verify-stark.workspace = true
+eyre.workspace = true
+
+[features]
+default = ["openvm-circuit/parallel"]

crates/toolchain/openvm/src/verify_stark.rs renamed to guest-libs/verify_stark/guest/src/lib.rs

@@ -5,9 +5,8 @@ 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"] }
+openvm = { path = "../../../../../crates/toolchain/openvm", features = ["std"] }
+openvm-verify-stark = { path = "../../../guest" }
 
 [features]
 default = []

guest-libs/verify_stark/tests/Cargo.toml

@@ -0,0 +1,18 @@
+extern crate alloc;
+use alloc::vec::Vec;
+
+use openvm::io::read;
+use openvm_verify_stark::define_verify_openvm_stark;
+
+define_verify_openvm_stark!(
+    verify_openvm_stark,
+    env!("CARGO_MANIFEST_DIR"),
+    "root_verifier.asm"
+);
+
+pub fn main() {
+    let app_exe_commit: [u32; 8] = read();
+    let app_vm_commit: [u32; 8] = read();
+    let pvs: Vec<u8> = read();
+    verify_openvm_stark(&app_exe_commit, &app_vm_commit, &pvs);
+}