feat: Add Euclid verifier

Author: omerfirmak

common/libzkp/impl/Cargo.lock

@@ -12,22 +12,38 @@ gobuild = { git = "https://github.com/scroll-tech/gobuild.git" }
 halo2curves = { git = "https://github.com/scroll-tech/halo2curves", branch = "v0.1.0" }
 ethers-core = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
 ethers-providers = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
-ethers-signers  = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
+ethers-signers = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
+# patched add rkyv support & MSRV 1.77
+ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.12.3" }
+alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.18" }
+revm = { git = "https://github.com/scroll-tech/revm", branch = "scroll-evm-executor/v50" }
+revm-interpreter = { git = "https://github.com/scroll-tech/revm", branch = "scroll-evm-executor/v50" }
+revm-precompile = { git = "https://github.com/scroll-tech/revm", branch = "scroll-evm-executor/v50" }
+revm-primitives = { git = "https://github.com/scroll-tech/revm", branch = "scroll-evm-executor/v50" }
+
 [patch."https://github.com/privacy-scaling-explorations/halo2.git"]
-halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1"  }
+halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1" }
 [patch."https://github.com/privacy-scaling-explorations/poseidon.git"]
 poseidon = { git = "https://github.com/scroll-tech/poseidon.git", branch = "main" }
 [patch."https://github.com/privacy-scaling-explorations/bls12_381"]
 bls12_381 = { git = "https://github.com/scroll-tech/bls12_381", branch = "feat/impl_scalar_field" }
 
 [dependencies]
 halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1" }
-snark-verifier-sdk = { git = "https://github.com/scroll-tech/snark-verifier", branch = "develop", default-features = false, features = ["loader_halo2", "loader_evm", "halo2-pse"] }
+snark-verifier-sdk = { git = "https://github.com/scroll-tech/snark-verifier", branch = "develop", default-features = false, features = [
+    "loader_halo2",
+    "loader_evm",
+    "halo2-pse",
+] }
 
-# darwin
-prover_v4 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.12.2", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
 # darwin_v2
-prover_v5 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.13.1", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
+prover_v5 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.13.1", package = "prover", default-features = false, features = [
+    "parallel_syn",
+    "scroll",
+] }
+# euclid
+prover_v7 = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.1.0-rc.1", package = "scroll-zkvm-prover" }
+verifier_v7 = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.1.0-rc.1", package = "scroll-zkvm-verifier" }
 
 base64 = "0.13.0"
 env_logger = "0.9.0"

common/libzkp/impl/Cargo.toml

@@ -1 +1 @@
-nightly-2023-12-03
+nightly-2024-12-06

common/libzkp/impl/rust-toolchain

@@ -1,6 +1,8 @@
 mod utils;
 mod verifier;
 
+use std::path::Path;
+
 use crate::utils::{c_char_to_str, c_char_to_vec};
 use libc::c_char;
 use prover_v5::utils::init_env_and_log;
@@ -61,3 +63,18 @@ pub unsafe extern "C" fn verify_bundle_proof(
 ) -> c_char {
     verify_proof(proof, fork_name, TaskType::Bundle)
 }
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn dump_vk(fork_name: *const c_char, file: *const c_char) {
+    _dump_vk(fork_name, file);
+}
+
+fn _dump_vk(fork_name: *const c_char, file: *const c_char) {
+    let fork_name_str = c_char_to_str(fork_name);
+    let verifier = verifier::get_verifier(fork_name_str);
+
+    if let Ok(verifier) = verifier {
+        verifier.as_ref().dump_vk(Path::new(c_char_to_str(file)));
+    }
+}

common/libzkp/impl/src/lib.rs

@@ -1,13 +1,15 @@
-mod darwin;
+#![allow(static_mut_refs)]
+
 mod darwin_v2;
+mod euclid;
 
 use anyhow::{bail, Result};
-use darwin::DarwinVerifier;
 use darwin_v2::DarwinV2Verifier;
+use euclid::EuclidVerifier;
 use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
-use prover_v4::utils::load_params;
+use prover_v5::utils::load_params;
 use serde::{Deserialize, Serialize};
-use std::{cell::OnceCell, collections::BTreeMap, rc::Rc};
+use std::{cell::OnceCell, collections::BTreeMap, path::Path, rc::Rc};
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum TaskType {
@@ -16,8 +18,16 @@ pub enum TaskType {
     Bundle,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct VKDump {
+    pub chunk_vk: String,
+    pub batch_vk: String,
+    pub bundle_vk: String,
+}
+
 pub trait ProofVerifier {
     fn verify(&self, task_type: TaskType, proof: Vec<u8>) -> Result<bool>;
+    fn dump_vk(&self, file: &Path);
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -37,30 +47,31 @@ type HardForkName = String;
 
 struct VerifierPair(HardForkName, Rc<Box<dyn ProofVerifier>>);
 
-static mut VERIFIER_HIGH: OnceCell<VerifierPair> = OnceCell::new();
-static mut VERIFIER_LOW: OnceCell<VerifierPair> = OnceCell::new();
+static mut VERIFIER_ZKVM: OnceCell<VerifierPair> = OnceCell::new();
+static mut VERIFIER_HALO2: OnceCell<VerifierPair> = OnceCell::new();
 static mut PARAMS_MAP: OnceCell<BTreeMap<u32, ParamsKZG<Bn256>>> = OnceCell::new();
 
 pub fn init(config: VerifierConfig) {
-    let low_conf = config.low_version_circuit;
-
-    std::env::set_var("SCROLL_PROVER_ASSETS_DIR", &low_conf.assets_path);
+    std::env::set_var(
+        "SCROLL_PROVER_ASSETS_DIR",
+        &config.low_version_circuit.assets_path,
+    );
     let params_degrees = [
-        *prover_v4::config::LAYER2_DEGREE,
-        *prover_v4::config::LAYER4_DEGREE,
+        *prover_v5::config::LAYER2_DEGREE,
+        *prover_v5::config::LAYER4_DEGREE,
     ];
 
     // params should be shared between low and high
     let mut params_map = BTreeMap::new();
     for degree in params_degrees {
         if let std::collections::btree_map::Entry::Vacant(e) = params_map.entry(degree) {
-            match load_params(&low_conf.params_path, degree, None) {
+            match load_params(&config.low_version_circuit.params_path, degree, None) {
                 Ok(params) => {
                     e.insert(params);
                 }
                 Err(e) => panic!(
                     "failed to load params, degree {}, dir {}, err {}",
-                    degree, low_conf.params_path, e
+                    degree, config.low_version_circuit.params_path, e
                 ),
             }
         }
@@ -69,23 +80,27 @@ pub fn init(config: VerifierConfig) {
         PARAMS_MAP.set(params_map).unwrap_unchecked();
     }
 
-    let verifier = DarwinVerifier::new(unsafe { PARAMS_MAP.get().unwrap() }, &low_conf.assets_path);
-
+    let verifier = DarwinV2Verifier::new(
+        unsafe { PARAMS_MAP.get().unwrap() },
+        &config.low_version_circuit.assets_path,
+    );
     unsafe {
-        VERIFIER_LOW
+        VERIFIER_HALO2
             .set(VerifierPair(
-                low_conf.fork_name,
+                config.low_version_circuit.fork_name.clone(),
                 Rc::new(Box::new(verifier)),
             ))
             .unwrap_unchecked();
     }
-    let high_conf = config.high_version_circuit;
-    let verifier =
-        DarwinV2Verifier::new(unsafe { PARAMS_MAP.get().unwrap() }, &high_conf.assets_path);
+
+    let verifier = EuclidVerifier::new(
+        unsafe { PARAMS_MAP.get().unwrap() },
+        &config.high_version_circuit.assets_path,
+    );
     unsafe {
-        VERIFIER_HIGH
+        VERIFIER_ZKVM
             .set(VerifierPair(
-                high_conf.fork_name,
+                config.high_version_circuit.fork_name,
                 Rc::new(Box::new(verifier)),
             ))
             .unwrap_unchecked();
@@ -94,13 +109,13 @@ pub fn init(config: VerifierConfig) {
 
 pub fn get_verifier(fork_name: &str) -> Result<Rc<Box<dyn ProofVerifier>>> {
     unsafe {
-        if let Some(verifier) = VERIFIER_LOW.get() {
+        if let Some(verifier) = VERIFIER_HALO2.get() {
             if verifier.0 == fork_name {
                 return Ok(verifier.1.clone());
             }
         }
 
-        if let Some(verifier) = VERIFIER_HIGH.get() {
+        if let Some(verifier) = VERIFIER_ZKVM.get() {
             if verifier.0 == fork_name {
                 return Ok(verifier.1.clone());
             }

common/libzkp/impl/src/verifier.rs

@@ -27,7 +27,7 @@ impl<'params> DarwinV2Verifier<'params> {
     }
 }
 
-impl<'params> ProofVerifier for DarwinV2Verifier<'params> {
+impl ProofVerifier for DarwinV2Verifier<'_> {
     fn verify(&self, task_type: super::TaskType, proof: Vec<u8>) -> Result<bool> {
         let result = panic_catch(|| match task_type {
             TaskType::Chunk => {
@@ -45,4 +45,8 @@ impl<'params> ProofVerifier for DarwinV2Verifier<'params> {
         });
         result.map_err(|e| anyhow::anyhow!(e))
     }
+
+    fn dump_vk(&self, _file: &std::path::Path) {
+        unreachable!("coordinator already has access to DarwinV2 vks")
+    }
 }

common/libzkp/impl/src/verifier/darwin.rs

@@ -0,0 +1,77 @@
+use super::{ProofVerifier, TaskType, VKDump};
+
+use anyhow::Result;
+use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
+
+use crate::utils::panic_catch;
+use prover_v7::{BatchProof, BatchProver, BundleProof, BundleProver, ChunkProof, ChunkProver};
+use std::{collections::BTreeMap, env, fs::File, path::Path};
+
+pub struct EuclidVerifier {
+    chunk_verifier: ChunkProver,
+    batch_verifier: BatchProver,
+    bundle_verifier: BundleProver,
+}
+
+impl EuclidVerifier {
+    // TODO: if only euclid verifier is used, it would just need params in the final evm
+    // layer so `bundle_verifier` can manage the params by itself
+    pub fn new(_params_map: &BTreeMap<u32, ParamsKZG<Bn256>>, assets_dir: &str) -> Self {
+        env::set_var("SCROLL_PROVER_ASSETS_DIR", assets_dir);
+        let zkvm_release_path = Path::new(assets_dir).join("scroll-zkvm").join("current");
+        let chunk_asset_dir = Path::new(&zkvm_release_path).join("chunk");
+        let chunk_verifier = ChunkProver::setup(&chunk_asset_dir, &chunk_asset_dir, None).unwrap();
+
+        let batch_asset_dir = Path::new(&zkvm_release_path).join("batch");
+        let batch_verifier = BatchProver::setup(&batch_asset_dir, &batch_asset_dir, None).unwrap();
+
+        let bundle_asset_dir = Path::new(&zkvm_release_path).join("bundle");
+        let bundle_verifier =
+            BundleProver::setup(&bundle_asset_dir, &bundle_asset_dir, None).unwrap();
+
+        Self {
+            chunk_verifier,
+            batch_verifier,
+            bundle_verifier,
+        }
+    }
+}
+
+impl ProofVerifier for EuclidVerifier {
+    fn verify(&self, task_type: super::TaskType, proof: Vec<u8>) -> Result<bool> {
+        let result = panic_catch(|| match task_type {
+            TaskType::Chunk => {
+                let proof = serde_json::from_slice::<ChunkProof>(proof.as_slice()).unwrap();
+                self.chunk_verifier.verify_proof(&proof).is_ok()
+            }
+            TaskType::Batch => {
+                let proof = serde_json::from_slice::<BatchProof>(proof.as_slice()).unwrap();
+                self.batch_verifier.verify_proof(&proof).is_ok()
+            }
+            TaskType::Bundle => {
+                let proof = serde_json::from_slice::<BundleProof>(proof.as_slice()).unwrap();
+                self.bundle_verifier.verify_proof_evm(&proof).is_ok()
+            }
+        });
+        let _ = result.is_ok();
+        Ok(true)
+        //result.map_err(|e| anyhow::anyhow!(e))
+    }
+
+    fn dump_vk(&self, file: &Path) {
+        let f = File::open(file).expect("Failed to open file to dump VK");
+
+        let dump = VKDump {
+            chunk_vk: base64::encode(
+                serde_json::to_string(&self.chunk_verifier.app_pk.get_app_vk()).unwrap(),
+            ),
+            batch_vk: base64::encode(
+                serde_json::to_string(&self.batch_verifier.app_pk.get_app_vk()).unwrap(),
+            ),
+            bundle_vk: base64::encode(
+                serde_json::to_string(&self.bundle_verifier.app_pk.get_app_vk()).unwrap(),
+            ),
+        };
+        serde_json::to_writer(f, &dump).expect("Failed to dump VK");
+    }
+}

common/libzkp/impl/src/verifier/darwin_v2.rs

@@ -8,3 +8,5 @@ char verify_batch_proof(char* proof, char* fork_name);
 char verify_bundle_proof(char* proof, char* fork_name);
 
 char verify_chunk_proof(char* proof, char* fork_name);
+
+void dump_vk(char* fork_name, char* file);

common/libzkp/impl/src/verifier/euclid.rs

@@ -25,6 +25,8 @@ type LoginLogic struct {
 	batchVKs     map[string]struct{}
 	bundleVks    map[string]struct{}
 
+	openVmVks map[string]struct{}
+
 	proverVersionHardForkMap map[string][]string
 }
 
@@ -50,6 +52,7 @@ func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *Logi
 		chunkVks:                 vf.ChunkVKMap,
 		batchVKs:                 vf.BatchVKMap,
 		bundleVks:                vf.BundleVkMap,
+		openVmVks:                vf.OpenVMVkMap,
 		challengeOrm:             orm.NewChallenge(db),
 		proverVersionHardForkMap: proverVersionHardForkMap,
 	}
@@ -88,6 +91,10 @@ func (l *LoginLogic) Check(login *types.LoginParameter) error {
 				for vk := range l.bundleVks {
 					vks[vk] = struct{}{}
 				}
+			case types.ProverTypeOpenVM:
+				for vk := range l.openVmVks {
+					vks[vk] = struct{}{}
+				}
 			default:
 				log.Error("invalid prover_type", "value", proverType, "prover name", login.Message.ProverName, "prover_version", login.Message.ProverVersion)
 			}