dynamic handling of openvm1.3/1.4 (#219)

* fix

* update

* fix

Author: lispc

Cargo.lock

@@ -54,6 +54,7 @@ use openvm_sdk::{
     prover::AppProver,
 };
 use openvm_stark_sdk::p3_bn254_fr::Bn254Fr;
+use scroll_zkvm_types::zkvm::AGG_STARK_PROVING_KEY;
 use snark_verifier_sdk::snark_verifier::loader::evm::compile_solidity;
 
 mod verifier;
@@ -311,11 +312,8 @@ fn generate_evm_verifier(
     let path_root_agg_pk = verifier_output_dir.join("root_verifier_vk");
 
     if force_overwrite || !path_root_agg_pk.exists() {
-        openvm_sdk::fs::write_object_to_file(
-            &path_root_agg_pk,
-            openvm_sdk::Sdk::riscv32().agg_pk().get_agg_vk(),
-        )
-        .expect("fail to write");
+        openvm_sdk::fs::write_object_to_file(&path_root_agg_pk, AGG_STARK_PROVING_KEY.get_agg_vk())
+            .expect("fail to write");
     }
 
     // Check if files exist and skip if in auto mode

crates/build-guest/src/main.rs

@@ -48,14 +48,17 @@ pub fn generate_evm_verifier() -> Result<String> {
 }
 
 pub fn download_evm_verifier() -> Result<String> {
-    let verifier_url = "https://github.com/openvm-org/openvm-solidity-sdk/raw/refs/heads/main/src/v1.3/Halo2Verifier.sol";
+    let openvm_version = "v1.4";
+    let verifier_url = format!(
+        "https://github.com/openvm-org/openvm-solidity-sdk/raw/refs/heads/main/src/{openvm_version}/Halo2Verifier.sol"
+    );
     println!("{LOG_PREFIX} Downloading pre-built verifier from openvm-solidity-sdk...");
 
     let output = std::process::Command::new("wget")
         .arg("-q")
         .arg("-O")
         .arg("-")
-        .arg(verifier_url)
+        .arg(&verifier_url)
         .output()?;
 
     if !output.status.success() {

crates/build-guest/src/verifier.rs

@@ -180,6 +180,7 @@ pub trait ProverTester {
         let config = scroll_zkvm_prover::ProverConfig {
             path_app_exe,
             path_app_config,
+            is_openvm_v13: guest_version() == "0.5.2",
             ..Default::default()
         };
         let prover = scroll_zkvm_prover::Prover::setup(config, Some(Self::NAME))?;

crates/integration/src/lib.rs

@@ -11,7 +11,10 @@ use openvm_native_circuit::NativeGpuBuilder as NativeBuilder;
 use openvm_circuit::arch::instructions::exe::VmExe;
 use openvm_sdk::{DefaultStarkEngine, config::SdkVmBuilder};
 use openvm_sdk::{F, Sdk, StdIn, prover::StarkProver};
-use scroll_zkvm_types::{proof::OpenVmEvmProof, types_agg::ProgramCommitment, utils::serialize_vk};
+use scroll_zkvm_types::{
+    proof::OpenVmEvmProof, types_agg::ProgramCommitment, utils::serialize_vk,
+    zkvm::AGG_STARK_PROVING_KEY_V13,
+};
 use scroll_zkvm_verifier::verifier::{AGG_STARK_PROVING_KEY, UniversalVerifier};
 use tracing::instrument;
 
@@ -46,6 +49,8 @@ pub struct ProverConfig {
     pub path_app_config: PathBuf,
     /// The maximum length for a single OpenVM segment.
     pub segment_len: Option<usize>,
+    /// Use v1.3 openvm
+    pub is_openvm_v13: bool,
 }
 
 const DEFAULT_SEGMENT_SIZE: usize = (1 << 22) - 1000;
@@ -81,9 +86,22 @@ impl Prover {
             segmentation_limits.max_trace_height = segment_len as u32;
             segmentation_limits.max_cells = 1_200_000_000_usize; // For 24G vram
 
-            let sdk = Sdk::new(app_config).expect("sdk init failed");
+            let mut sdk = Sdk::new(app_config).expect("sdk init failed");
+
+            let verifier_k = if self.config.is_openvm_v13 { 24 } else { 23 };
+            tracing::info!(
+                "changing openvm_sdk.halo2_config.verifier_k from {} to {}",
+                sdk.halo2_config().verifier_k,
+                verifier_k
+            );
+            sdk.halo2_config_mut().verifier_k = verifier_k;
+
             // 45s for first time
-            let sdk = sdk.with_agg_pk(AGG_STARK_PROVING_KEY.clone());
+            let sdk = sdk.with_agg_pk(if self.config.is_openvm_v13 {
+                AGG_STARK_PROVING_KEY_V13.clone()
+            } else {
+                AGG_STARK_PROVING_KEY.clone()
+            });
             Ok(sdk)
         })
     }

crates/prover/src/prover/mod.rs

@@ -18,6 +18,7 @@ openvm-native-recursion.workspace = true
 openvm-stark-sdk = { workspace = true, default-features = false }
 
 alloy-primitives = { workspace = true, features = ["tiny-keccak"] }
+once_cell = "1.20"
 snark-verifier-sdk.workspace = true
 sbv-primitives.workspace = true
 serde.workspace = true

crates/types/Cargo.toml

@@ -25,3 +25,5 @@ pub mod task;
 pub use task::ProvingTask;
 
 pub mod utils;
+
+pub mod zkvm;

crates/types/src/lib.rs

@@ -0,0 +1,69 @@
+// This should be removed after we fully migrated to openvm 1.4 after protocol upgrade.
+use once_cell::sync::Lazy;
+use openvm_sdk::Sdk;
+use openvm_sdk::keygen::AggProvingKey;
+use std::sync::Arc;
+
+mod openvm_private_patch {
+    // copied from openvm/crates/sdk/src/keygen/perm.rs
+    use std::cmp::Reverse;
+
+    /// Permutation of the AIR IDs to order them by forced trace heights.
+    pub(crate) struct AirIdPermutation {
+        pub perm: Vec<usize>,
+    }
+
+    impl AirIdPermutation {
+        pub fn compute(heights: &[u32]) -> AirIdPermutation {
+            let mut height_with_air_id: Vec<_> = heights.iter().copied().enumerate().collect();
+            height_with_air_id.sort_by_key(|(_, h)| Reverse(*h));
+            AirIdPermutation {
+                perm: height_with_air_id
+                    .into_iter()
+                    .map(|(a_id, _)| a_id)
+                    .collect(),
+            }
+        }
+        /// arr[i] <- arr[perm[i]]
+        pub(crate) fn permute<T>(&self, arr: &mut [T]) {
+            debug_assert_eq!(arr.len(), self.perm.len());
+            let mut perm = self.perm.clone();
+            for i in 0..perm.len() {
+                if perm[i] != i {
+                    let mut curr = i;
+                    loop {
+                        let target = perm[curr];
+                        perm[curr] = curr;
+                        if perm[target] == target {
+                            break;
+                        }
+                        arr.swap(curr, target);
+                        curr = target;
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Proving key for STARK aggregation. Primarily used to aggregate
+/// [continuation proofs][openvm_sdk::prover::vm::ContinuationVmProof].
+pub static AGG_STARK_PROVING_KEY: Lazy<AggProvingKey> = Lazy::new(|| build_agg_pk(false));
+pub static AGG_STARK_PROVING_KEY_V13: Lazy<AggProvingKey> = Lazy::new(|| build_agg_pk(true));
+
+fn build_agg_pk(legacy_v13: bool) -> AggProvingKey {
+    let mut agg_pk = Sdk::riscv32().agg_pk().clone();
+    if !legacy_v13 {
+        // it is a bit confusing..
+        // we plan to enable `feature = "legacy-v1-3-evm-verifier"`,
+        // so here we need to mimic v14 behavior
+        let root_air_perm =
+            openvm_private_patch::AirIdPermutation::compute(&agg_pk.root_verifier_pk.air_heights);
+        let vm_pk = Arc::get_mut(&mut agg_pk.root_verifier_pk.vm_pk).unwrap();
+        for thc in &mut vm_pk.vm_pk.trace_height_constraints {
+            root_air_perm.permute(&mut thc.coefficients);
+        }
+    }
+
+    agg_pk
+}

crates/types/src/zkvm.rs

@@ -18,5 +18,6 @@ bincode_v1.workspace = true
 eyre.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+sha256 = "1"
 
 [dev-dependencies]

crates/verifier/Cargo.toml

@@ -1,19 +1,16 @@
-use once_cell::sync::Lazy;
 use openvm_sdk::commit::AppExecutionCommit;
-use openvm_sdk::keygen::{AggProvingKey, AggVerifyingKey};
+use openvm_sdk::keygen::AggVerifyingKey;
 use openvm_sdk::{Sdk, commit::CommitBytes};
 use scroll_zkvm_types::proof::OpenVmEvmProof;
 use scroll_zkvm_types::{proof::StarkProof, utils::serialize_vk};
 use std::path::Path;
 
-/// Proving key for STARK aggregation. Primarily used to aggregate
-/// [continuation proofs][openvm_sdk::prover::vm::ContinuationVmProof].
-pub static AGG_STARK_PROVING_KEY: Lazy<AggProvingKey> =
-    Lazy::new(|| Sdk::riscv32().agg_pk().clone());
+pub use scroll_zkvm_types::zkvm::{AGG_STARK_PROVING_KEY, AGG_STARK_PROVING_KEY_V13};
 
 pub struct UniversalVerifier {
     pub evm_verifier: Vec<u8>,
     pub loaded_agg_vk: AggVerifyingKey,
+    pub is_openvm_v13: bool,
 }
 
 impl UniversalVerifier {
@@ -51,16 +48,34 @@ impl UniversalVerifier {
         let path_verifier_code = path_verifier.as_ref().join("verifier.bin");
         let path_agg_vk = path_verifier.as_ref().join("root_verifier_vk");
         let evm_verifier = std::fs::read(path_verifier_code)?;
+
+        // TODO: clean this after we get rid of openvm v1.3.
+        let is_openvm_v13 = {
+            let hash = sha256::digest(&evm_verifier);
+            // from 0.5.2 release files
+            let is_openvm_v13 =
+                hash == ("4f1b70db9fade2ce7425924dc662d75c5a315f3a611ed8cadd68b516407a4cf1");
+            println!(
+                "is_openvm_v13: {}, verifier.bin sha256sum: {}",
+                is_openvm_v13, hash
+            );
+            is_openvm_v13
+        };
         let loaded_agg_vk = openvm_sdk::fs::read_object_from_file(path_agg_vk).unwrap_or_else(
             |_|{
                 tracing::warn!("root_Verifier_vk is not avaliable in disk, try to calculate it on-the-fly, which may be time consuming ...");
-                AGG_STARK_PROVING_KEY.get_agg_vk()
+                if is_openvm_v13 {
+                    AGG_STARK_PROVING_KEY_V13.get_agg_vk()
+                } else {
+                    AGG_STARK_PROVING_KEY.get_agg_vk()
+                }
             }
         );
 
         Ok(Self {
             evm_verifier,
             loaded_agg_vk,
+            is_openvm_v13,
         })
     }