Re-organize FFI to aggregator and zkevm.

ffi/src/aggregator.rs

@@ -0,0 +1,81 @@
+use crate::utils::{c_char_to_str, c_char_to_vec, vec_to_c_char, OUTPUT_DIR};
+use libc::c_char;
+use prover::{
+    aggregator::{ChunkHash, Prover, Verifier},
+    config::{AGG_DEGREES, LAYER4_DEGREE},
+    utils::init_env_and_log,
+    Proof,
+};
+use std::{cell::OnceCell, fs::File, io::Read};
+
+static mut AGG_PROVER: OnceCell<Prover> = OnceCell::new();
+static mut AGG_VERIFIER: Option<&Verifier> = None;
+
+/// # 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 = Prover::from_params_dir(params_dir, &AGG_DEGREES);
+    AGG_PROVER.set(prover).unwrap();
+}
+
+/// # 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(Verifier::from_params_dir(
+        params_dir,
+        *LAYER4_DEGREE,
+        Some(vk),
+    ));
+
+    AGG_VERIFIER = Some(Box::leak(verifier));
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn create_agg_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<Proof>>(&chunk_proofs).unwrap();
+    assert_eq!(chunk_hashes.len(), chunk_proofs.len());
+
+    let chunks = chunk_hashes
+        .into_iter()
+        .zip(chunk_proofs.into_iter())
+        .collect();
+
+    let proof = AGG_PROVER
+        .get_mut()
+        .unwrap()
+        .gen_agg_proof(chunks, 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_agg_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 = AGG_VERIFIER.unwrap().verify_agg_proof(proof).is_ok();
+    verified as c_char
+}

ffi/src/lib.rs

@@ -1,25 +1,5 @@
 #![feature(once_cell)]
 
-pub mod prove;
-pub mod verify;
-
-pub(crate) mod utils {
-    use std::{
-        ffi::{CStr, CString},
-        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 aggregator;
+mod utils;
+mod zkevm;

ffi/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()
+}

ffi/src/zkevm.rs

@@ -0,0 +1,80 @@
+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::{Prover, Verifier},
+    Proof,
+};
+use std::{cell::OnceCell, fs::File, io::Read};
+use types::eth::BlockTrace;
+
+static mut ZKEVM_PROVER: OnceCell<Prover> = OnceCell::new();
+static mut ZKEVM_VERIFIER: Option<&Verifier> = None;
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_zkevm_prover(params_dir: *const c_char) {
+    init_env_and_log("ffi_zkevm_prove");
+
+    let params_dir = c_char_to_str(params_dir);
+    let prover = Prover::from_params_dir(params_dir);
+    ZKEVM_PROVER.set(prover).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_zkevm_verifier(params_dir: *const c_char, vk_path: *const c_char) {
+    init_env_and_log("ffi_zkevm_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(Verifier::from_params_dir(params_dir, Some(vk)));
+
+    ZKEVM_VERIFIER = Some(Box::leak(verifier));
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn create_block_proof(block_trace: *const c_char) -> *const c_char {
+    let block_trace = c_char_to_vec(block_trace);
+    let block_trace = serde_json::from_slice::<BlockTrace>(&block_trace).unwrap();
+
+    let proof = ZKEVM_PROVER
+        .get_mut()
+        .unwrap()
+        .gen_chunk_proof(&[block_trace])
+        .unwrap();
+
+    let proof_bytes = serde_json::to_vec(&proof).unwrap();
+    vec_to_c_char(proof_bytes)
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn create_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 = ZKEVM_PROVER
+        .get_mut()
+        .unwrap()
+        .gen_chunk_proof(block_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 verify_chunk_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 = ZKEVM_VERIFIER.unwrap().verify_chunk_proof(proof).is_ok();
+    verified as c_char
+}