feat: add batch and chunk provers and verifiers

common/libzkp/impl/Cargo.toml

@@ -7,18 +7,20 @@ edition = "2021"
 [lib]
 crate-type = ["cdylib"]
 
-# `//` is used to skip https://github.com/rust-lang/cargo/issues/5478#issuecomment-522719793.
-[patch."https://github.com/privacy-scaling-explorations/halo2curves.git"]
-halo2curves = { git = 'https://github.com/privacy-scaling-explorations//halo2curves.git', rev = "9b67e19" }
 [patch."https://github.com/privacy-scaling-explorations/halo2.git"]
-halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "scroll-dev-0220"  }
+halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "develop" }
 [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"]
+halo2wrong = { git = "https://github.com/scroll-tech/halo2wrong.git", branch = "halo2-ecc-snark-verifier-0323" }
+maingate = { git = "https://github.com/scroll-tech/halo2wrong", branch = "halo2-ecc-snark-verifier-0323" }
+[patch."https://github.com/privacy-scaling-explorations/halo2curves.git"]
+halo2curves = { git = "https://github.com/scroll-tech/halo2curves.git", branch = "0.3.1-derive-serde" }
 
 [dependencies]
-zkevm = { git = "https://github.com/scroll-tech/scroll-prover", rev="78ab7a7" }
-types = { git = "https://github.com/scroll-tech/scroll-prover", rev="78ab7a7" }
-halo2_proofs = { git = "https://github.com/privacy-scaling-explorations/halo2.git", tag = "v2022_09_10" }
+prover = { git = "https://github.com/scroll-tech/scroll-prover", rev="260607c" }
+types = { git = "https://github.com/scroll-tech/scroll-prover", rev="260607c" }
+halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "develop" }
 
 log = "0.4"
 env_logger = "0.9.0"

common/libzkp/impl/rustfmt.toml

@@ -0,0 +1,9 @@
+edition = "2021"
+
+comment_width = 100
+imports_granularity = "Crate"
+max_width = 100
+newline_style = "Unix"
+# normalize_comments = true
+reorder_imports = true
+wrap_comments = true

common/libzkp/impl/src/batch.rs

@@ -0,0 +1,88 @@
+use crate::utils::{c_char_to_str, c_char_to_vec, vec_to_c_char, OUTPUT_DIR};
+use libc::c_char;
+use prover::{
+    aggregator::{Prover, Verifier},
+    io::read_all,
+    utils::{chunk_trace_to_witness_block, init_env_and_log},
+    ChunkHash, ChunkProof, Proof,
+};
+use std::cell::OnceCell;
+use types::eth::BlockTrace;
+
+static mut PROVER: OnceCell<Prover> = OnceCell::new();
+static mut VERIFIER: OnceCell<Verifier> = OnceCell::new();
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_batch_prover(params_dir: *const c_char) {
+    init_env_and_log("ffi_batch_prove");
+
+    let params_dir = c_char_to_str(params_dir);
+    let prover = Prover::from_params_dir(params_dir);
+
+    PROVER.set(prover).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_batch_verifier(params_dir: *const c_char, vk_path: *const c_char) {
+    init_env_and_log("ffi_batch_verify");
+
+    let params_dir = c_char_to_str(params_dir);
+    let raw_vk = read_all(c_char_to_str(vk_path));
+    let verifier = Verifier::from_params_dir(params_dir, &raw_vk);
+
+    VERIFIER.set(verifier).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn gen_batch_proof(
+    chunk_hashes: *const c_char,
+    chunk_proofs: *const c_char,
+) -> *const c_char {
+    let chunk_hashes = c_char_to_vec(chunk_hashes);
+    let chunk_proofs = c_char_to_vec(chunk_proofs);
+
+    let chunk_hashes = serde_json::from_slice::<Vec<ChunkHash>>(&chunk_hashes).unwrap();
+    let chunk_proofs = serde_json::from_slice::<Vec<ChunkProof>>(&chunk_proofs).unwrap();
+    assert_eq!(chunk_hashes.len(), chunk_proofs.len());
+
+    let chunk_hashes_proofs = chunk_hashes
+        .into_iter()
+        .zip(chunk_proofs.into_iter())
+        .collect();
+
+    let proof = PROVER
+        .get_mut()
+        .unwrap()
+        .gen_agg_proof(chunk_hashes_proofs, None, OUTPUT_DIR.as_deref())
+        .unwrap();
+
+    let proof_bytes = serde_json::to_vec(&proof).unwrap();
+    vec_to_c_char(proof_bytes)
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_batch_proof(proof: *const c_char) -> c_char {
+    let proof = c_char_to_vec(proof);
+    let proof = serde_json::from_slice::<Proof>(proof.as_slice()).unwrap();
+
+    let verified = VERIFIER.get().unwrap().verify_agg_proof(proof);
+    verified as c_char
+}
+
+// This function is only used for debugging on Go side.
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn block_traces_to_chunk_hash(block_traces: *const c_char) -> *const c_char {
+    let block_traces = c_char_to_vec(block_traces);
+    let block_traces = serde_json::from_slice::<Vec<BlockTrace>>(&block_traces).unwrap();
+
+    let witness_block = chunk_trace_to_witness_block(block_traces).unwrap();
+    let chunk_hash = ChunkHash::from_witness_block(&witness_block, false);
+
+    let chunk_hash_bytes = serde_json::to_vec(&chunk_hash).unwrap();
+    vec_to_c_char(chunk_hash_bytes)
+}

common/libzkp/impl/src/chunk.rs

@@ -0,0 +1,62 @@
+use crate::utils::{c_char_to_str, c_char_to_vec, vec_to_c_char, OUTPUT_DIR};
+use libc::c_char;
+use prover::{
+    io::read_all,
+    utils::init_env_and_log,
+    zkevm::{Prover, Verifier},
+    ChunkProof,
+};
+use std::cell::OnceCell;
+use types::eth::BlockTrace;
+
+static mut PROVER: OnceCell<Prover> = OnceCell::new();
+static mut VERIFIER: OnceCell<Verifier> = OnceCell::new();
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_chunk_prover(params_dir: *const c_char) {
+    init_env_and_log("ffi_chunk_prove");
+
+    let params_dir = c_char_to_str(params_dir);
+    let prover = Prover::from_params_dir(params_dir);
+
+    PROVER.set(prover).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+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_dir = c_char_to_str(params_dir);
+    let raw_vk = read_all(c_char_to_str(vk_path));
+    let verifier = Verifier::from_params_dir(params_dir, &raw_vk);
+
+    VERIFIER.set(verifier).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn gen_chunk_proof(block_traces: *const c_char) -> *const c_char {
+    let block_traces = c_char_to_vec(block_traces);
+    let block_traces = serde_json::from_slice::<Vec<BlockTrace>>(&block_traces).unwrap();
+
+    let proof = PROVER
+        .get_mut()
+        .unwrap()
+        .gen_chunk_proof(block_traces, None, OUTPUT_DIR.as_deref())
+        .unwrap();
+
+    let proof_bytes = serde_json::to_vec(&proof).unwrap();
+    vec_to_c_char(proof_bytes)
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_chunk_proof(proof: *const c_char) -> c_char {
+    let proof = c_char_to_vec(proof);
+    let proof = serde_json::from_slice::<ChunkProof>(proof.as_slice()).unwrap();
+
+    let verified = VERIFIER.get().unwrap().verify_chunk_proof(proof);
+    verified as c_char
+}

common/libzkp/impl/src/lib.rs

@@ -1,23 +1,5 @@
 #![feature(once_cell)]
 
-pub mod prove;
-pub mod verify;
-
-pub(crate) mod utils {
-    use std::ffi::{CStr, CString};
-    use std::os::raw::c_char;
-
-    pub(crate) fn c_char_to_str(c: *const c_char) -> &'static str {
-        let cstr = unsafe { CStr::from_ptr(c) };
-        cstr.to_str().unwrap()
-    }
-
-    pub(crate) fn c_char_to_vec(c: *const c_char) -> Vec<u8> {
-        let cstr = unsafe { CStr::from_ptr(c) };
-        cstr.to_bytes().to_vec()
-    }
-
-    pub(crate) fn vec_to_c_char(bytes: Vec<u8>) -> *const c_char {
-        CString::new(bytes).unwrap().into_raw()
-    }
-}
+mod batch;
+mod chunk;
+mod utils;

common/libzkp/impl/src/utils.rs

@@ -0,0 +1,24 @@
+use once_cell::sync::Lazy;
+use std::{
+    env,
+    ffi::{CStr, CString},
+    os::raw::c_char,
+};
+
+// Only used for debugging.
+pub(crate) static OUTPUT_DIR: Lazy<Option<String>> =
+    Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
+
+pub(crate) fn c_char_to_str(c: *const c_char) -> &'static str {
+    let cstr = unsafe { CStr::from_ptr(c) };
+    cstr.to_str().unwrap()
+}
+
+pub(crate) fn c_char_to_vec(c: *const c_char) -> Vec<u8> {
+    let cstr = unsafe { CStr::from_ptr(c) };
+    cstr.to_bytes().to_vec()
+}
+
+pub(crate) fn vec_to_c_char(bytes: Vec<u8>) -> *const c_char {
+    CString::new(bytes).unwrap().into_raw()
+}

common/libzkp/interface/libzkp.h

@@ -1,5 +1,9 @@
-void init_prover(char *params_path, char *seed_path);
-char* create_agg_proof(char *trace);
-char* create_agg_proof_multi(char *trace);
-void init_verifier(char *params_path, char *agg_vk_path);
-char verify_agg_proof(char *proof);
+void init_batch_prover(char* params_dir);
+void init_batch_verifier(char* params_dir, char* vk_path);
+char* gen_batch_proof(char* chunk_hashes, char* chunk_proofs);
+char verify_batch_proof(char* proof);
+
+void init_chunk_prover(char* params_dir);
+void init_chunk_verifier(char* params_dir, char* vk_path);
+char* gen_chunk_proof(char* block_traces);
+char verify_chunk_proof(char* proof);

coordinator/.gitignore

@@ -1,3 +1,3 @@
 /build/bin
 .idea
-verifier/lib
+internal/logic/verifier/lib