[don't-merge] test vk deserialization

Cargo.toml

@@ -7,7 +7,7 @@ members = [
 ]
 
 [patch."https://github.com/privacy-scaling-explorations/halo2.git"]
-halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "develop"  }
+halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "feat/disable_selector_compression"  }
 [patch."https://github.com/privacy-scaling-explorations/poseidon.git"]
 poseidon = { git = "https://github.com/scroll-tech/poseidon.git", branch = "scroll-dev-0220" }
 [patch."https://github.com/privacy-scaling-explorations/halo2wrong.git"]

README.md

@@ -26,7 +26,7 @@ make download-setup -e degree=DEGREE params_dir=PARAMS_DIR
 
 ### Testing
 
-`make test-chunk-prove` is the main testing entry point for the multi-level circuit constraint system of scroll-zkevm. Developers could understand how the system works by reading the codes of this test.
+`make test-chunk-prove` and `make test-agg-prove` are the main testing entries for multi-level circuit constraint system of scroll-prover. Developers could understand how the system works by reading the codes of these tests.
 
 Besides it, `make test-inner-prove` could be used to test the first-level circuit, and `make-comp-prove` could be used to test two-layers compression circuits.
 

ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ffi"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

ffi/src/prove.rs

@@ -1,27 +1,44 @@
 use crate::utils::{c_char_to_str, c_char_to_vec, vec_to_c_char};
 use libc::c_char;
-use prover::{utils::init_env_and_log, zkevm};
+use prover::{aggregator, config::ALL_AGG_DEGREES, utils::init_env_and_log, zkevm};
 use std::cell::OnceCell;
 use types::eth::BlockTrace;
 
-static mut PROVER: OnceCell<zkevm::Prover> = OnceCell::new();
+static mut CHUNK_PROVER: OnceCell<zkevm::Prover> = OnceCell::new();
+static mut AGG_PROVER: OnceCell<aggregator::Prover> = OnceCell::new();
+static mut AGG_CHUNK_TRACES: OnceCell<Vec<Vec<BlockTrace>>> = OnceCell::new();
 
 /// # Safety
 #[no_mangle]
-pub unsafe extern "C" fn init_prover(params_path: *const c_char, _seed_path: *const c_char) {
-    init_env_and_log("ffi_prove");
+pub unsafe extern "C" fn init_chunk_prover(params_dir: *const c_char) {
+    init_env_and_log("ffi_chunk_prove");
 
-    let params_path = c_char_to_str(params_path);
-    let p = zkevm::Prover::from_params_dir(params_path);
-    PROVER.set(p).unwrap();
+    let params_dir = c_char_to_str(params_dir);
+    let prover = zkevm::Prover::from_params_dir(params_dir);
+    CHUNK_PROVER.set(prover).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_agg_prover(params_dir: *const c_char) {
+    init_env_and_log("ffi_agg_prove");
+
+    let params_dir = c_char_to_str(params_dir);
+
+    let prover = aggregator::Prover::from_params_dir(params_dir, &ALL_AGG_DEGREES);
+    AGG_PROVER.set(prover).unwrap();
 }
 
 /// # Safety
 #[no_mangle]
 pub unsafe extern "C" fn create_block_proof(trace_char: *const c_char) -> *const c_char {
     let trace_vec = c_char_to_vec(trace_char);
     let trace = serde_json::from_slice::<BlockTrace>(&trace_vec).unwrap();
-    let proof = PROVER.get_mut().unwrap().gen_chunk_proof(&[trace]).unwrap();
+    let proof = CHUNK_PROVER
+        .get_mut()
+        .unwrap()
+        .gen_chunk_proof(&[trace])
+        .unwrap();
     let proof_bytes = serde_json::to_vec(&proof).unwrap();
     vec_to_c_char(proof_bytes)
 }
@@ -31,11 +48,51 @@ pub unsafe extern "C" fn create_block_proof(trace_char: *const c_char) -> *const
 pub unsafe extern "C" fn create_chunk_proof(trace_char: *const c_char) -> *const c_char {
     let trace_vec = c_char_to_vec(trace_char);
     let traces = serde_json::from_slice::<Vec<BlockTrace>>(&trace_vec).unwrap();
-    let proof = PROVER
+    let proof = CHUNK_PROVER
         .get_mut()
         .unwrap()
         .gen_chunk_proof(traces.as_slice())
         .unwrap();
     let proof_bytes = serde_json::to_vec(&proof).unwrap();
     vec_to_c_char(proof_bytes)
 }
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn add_agg_chunk_trace(trace_char: *const c_char) {
+    let trace_vec = c_char_to_vec(trace_char);
+    let trace = serde_json::from_slice::<Vec<_>>(&trace_vec).unwrap();
+
+    AGG_CHUNK_TRACES
+        .get_mut()
+        .or_else(|| {
+            AGG_CHUNK_TRACES.set(vec![]).unwrap();
+            AGG_CHUNK_TRACES.get_mut()
+        })
+        .unwrap()
+        .push(trace);
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn clear_agg_chunk_traces() {
+    if let Some(chunk_traces) = AGG_CHUNK_TRACES.get_mut() {
+        chunk_traces.clear();
+    }
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn create_agg_proof() -> *const c_char {
+    // Consume the chunk traces (take and clear).
+    let chunk_traces = AGG_CHUNK_TRACES.take().unwrap();
+
+    let proof = AGG_PROVER
+        .get_mut()
+        .unwrap()
+        .gen_agg_proof(chunk_traces)
+        .unwrap();
+
+    let proof_bytes = serde_json::to_vec(&proof).unwrap();
+    vec_to_c_char(proof_bytes)
+}

ffi/src/verify.rs

@@ -1,30 +1,64 @@
 use crate::utils::{c_char_to_str, c_char_to_vec};
 use libc::c_char;
-use prover::{utils::init_env_and_log, zkevm, Proof};
+use prover::{aggregator, config::AGG_LAYER4_DEGREE, utils::init_env_and_log, zkevm, Proof};
 use std::{fs::File, io::Read};
 
-static mut VERIFIER: Option<&zkevm::Verifier> = None;
+static mut CHUNK_VERIFIER: Option<&zkevm::Verifier> = None;
+static mut AGG_VERIFIER: Option<&aggregator::Verifier> = None;
 
 /// # Safety
 #[no_mangle]
-pub unsafe extern "C" fn init_verifier(params_path: *const c_char, agg_vk_path: *const c_char) {
-    init_env_and_log("ffi_verify");
+pub unsafe extern "C" fn init_chunk_verifier(params_dir: *const c_char, vk_path: *const c_char) {
+    init_env_and_log("ffi_chunk_verify");
 
-    let params_path = c_char_to_str(params_path);
-    let agg_vk_path = c_char_to_str(agg_vk_path);
-    let mut f = File::open(agg_vk_path).unwrap();
-    let mut agg_vk = vec![];
-    f.read_to_end(&mut agg_vk).unwrap();
+    let vk_path = c_char_to_str(vk_path);
+    let mut f = File::open(vk_path).unwrap();
+    let mut vk = vec![];
+    f.read_to_end(&mut vk).unwrap();
 
-    let v = Box::new(zkevm::Verifier::from_params_dir(params_path, Some(agg_vk)));
-    VERIFIER = Some(Box::leak(v))
+    let params_dir = c_char_to_str(params_dir);
+    let verifier = Box::new(zkevm::Verifier::from_params_dir(params_dir, Some(vk)));
+
+    CHUNK_VERIFIER = Some(Box::leak(verifier));
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_agg_verifier(params_dir: *const c_char, vk_path: *const c_char) {
+    init_env_and_log("ffi_agg_verify");
+
+    let vk_path = c_char_to_str(vk_path);
+    let mut f = File::open(vk_path).unwrap();
+    let mut vk = vec![];
+    f.read_to_end(&mut vk).unwrap();
+
+    let params_dir = c_char_to_str(params_dir);
+    let verifier = Box::new(aggregator::Verifier::from_params_dir(
+        params_dir,
+        *AGG_LAYER4_DEGREE,
+        Some(vk),
+    ));
+
+    AGG_VERIFIER = Some(Box::leak(verifier));
 }
 
 /// # Safety
 #[no_mangle]
 pub unsafe extern "C" fn verify_chunk_proof(proof: *const c_char) -> c_char {
     let proof_vec = c_char_to_vec(proof);
-    let chunk_proof = serde_json::from_slice::<Proof>(proof_vec.as_slice()).unwrap();
-    let verified = VERIFIER.unwrap().verify_chunk_proof(chunk_proof).is_ok();
+    let proof = serde_json::from_slice::<Proof>(proof_vec.as_slice()).unwrap();
+    let verified = CHUNK_VERIFIER.unwrap().verify_chunk_proof(proof).is_ok();
+
+    verified as c_char
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_agg_proof(proof: *const c_char) -> c_char {
+    let proof_vec = c_char_to_vec(proof);
+    let proof = serde_json::from_slice::<Proof>(proof_vec.as_slice()).unwrap();
+
+    let verified = AGG_VERIFIER.unwrap().verify_agg_proof(proof).is_ok();
+
     verified as c_char
 }

prover/Cargo.toml

@@ -8,12 +8,12 @@ edition = "2021"
 [dependencies]
 halo2_proofs = { git = "https://github.com/privacy-scaling-explorations/halo2.git", tag = "v2023_02_02" }
 
-aggregator = { git = "https://github.com/scroll-tech/zkevm-circuits.git", branch = "develop" }
-bus-mapping = { git = "https://github.com/scroll-tech/zkevm-circuits.git", branch = "develop" }
-eth-types = { git = "https://github.com/scroll-tech/zkevm-circuits.git", branch = "develop" }
-zkevm-circuits = { git = "https://github.com/scroll-tech/zkevm-circuits.git", branch = "develop", default-features = false, features = ["test","scroll","scroll-trace","shanghai"] }
-mpt-zktrie = { git = "https://github.com/scroll-tech/zkevm-circuits.git", branch = "develop" }
-mock = { git = "https://github.com/scroll-tech/zkevm-circuits", branch = "develop" }
+aggregator = { git = "https://github.com/scroll-tech/zkevm-circuits.git", branch = "integrate-dynamic-proof-agg" }
+bus-mapping = { git = "https://github.com/scroll-tech/zkevm-circuits.git", branch = "integrate-dynamic-proof-agg" }
+eth-types = { git = "https://github.com/scroll-tech/zkevm-circuits.git", branch = "integrate-dynamic-proof-agg" }
+zkevm-circuits = { git = "https://github.com/scroll-tech/zkevm-circuits.git", branch = "integrate-dynamic-proof-agg", default-features = false, features = ["test","scroll","scroll-trace","shanghai"] }
+mpt-zktrie = { git = "https://github.com/scroll-tech/zkevm-circuits.git", branch = "integrate-dynamic-proof-agg" }
+mock = { git = "https://github.com/scroll-tech/zkevm-circuits", branch = "integrate-dynamic-proof-agg" }
 
 snark-verifier = { git = "https://github.com/scroll-tech/snark-verifier", branch = "develop" }
 snark-verifier-sdk = { git = "https://github.com/scroll-tech/snark-verifier", branch = "develop" }