stash

common/libzkp/impl/src/batch_prover.rs

@@ -8,7 +8,7 @@ use prover::{
 use std::{cell::OnceCell, panic, ptr::null};
 use types::eth::BlockTrace;
 
-static mut PROVER: OnceCell<Prover> = OnceCell::new();
+static mut BATCH_PROVER: OnceCell<Prover> = OnceCell::new();
 static mut VERIFIER: OnceCell<Verifier> = OnceCell::new();
 
 /// # Safety
@@ -19,7 +19,7 @@ pub unsafe extern "C" fn init_batch_prover(params_dir: *const c_char) {
     let params_dir = c_char_to_str(params_dir);
     let prover = Prover::from_params_dir(params_dir);
 
-    PROVER.set(prover).unwrap();
+    BATCH_PROVER.set(prover).unwrap();
 }
 
 /// # Safety
@@ -54,7 +54,7 @@ pub unsafe extern "C" fn gen_batch_proof(
         .collect();
 
     let proof_result = panic::catch_unwind(|| {
-        let proof = PROVER
+        let proof = BATCH_PROVER
             .get_mut()
             .unwrap()
             .gen_agg_evm_proof(chunk_hashes_proofs, None, OUTPUT_DIR.as_deref())

common/libzkp/impl/src/batch_verifier.rs

@@ -0,0 +1,90 @@
+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},
+    utils::{chunk_trace_to_witness_block, init_env_and_log},
+    BatchProof, ChunkHash, ChunkProof,
+};
+use std::{cell::OnceCell, panic, ptr::null};
+use types::eth::BlockTrace;
+
+static mut BATCH_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);
+
+    BATCH_PROVER.set(prover).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_batch_verifier(params_dir: *const c_char, assets_dir: *const c_char) {
+    init_env_and_log("ffi_batch_verify");
+
+    let params_dir = c_char_to_str(params_dir);
+    let assets_dir = c_char_to_str(assets_dir);
+
+    let verifier = Verifier::from_dirs(params_dir, assets_dir);
+
+    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_result = panic::catch_unwind(|| {
+        let proof = BATCH_PROVER
+            .get_mut()
+            .unwrap()
+            .gen_agg_evm_proof(chunk_hashes_proofs, None, OUTPUT_DIR.as_deref())
+            .unwrap();
+
+        serde_json::to_vec(&proof).unwrap()
+    });
+    proof_result.map_or(null(), vec_to_c_char)
+}
+
+/// # 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::<BatchProof>(proof.as_slice()).unwrap();
+
+    let verified = panic::catch_unwind(|| VERIFIER.get().unwrap().verify_agg_evm_proof(proof));
+    verified.unwrap_or(false) 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_info(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_info = ChunkHash::from_witness_block(&witness_block, false);
+
+    let chunk_info_bytes = serde_json::to_vec(&chunk_info).unwrap();
+    vec_to_c_char(chunk_info_bytes)
+}

common/libzkp/impl/src/chunk_prover.rs

@@ -8,7 +8,7 @@ use prover::{
 use std::{cell::OnceCell, panic, ptr::null};
 use types::eth::BlockTrace;
 
-static mut PROVER: OnceCell<Prover> = OnceCell::new();
+static mut CHUNK_PROVER: OnceCell<Prover> = OnceCell::new();
 static mut VERIFIER: OnceCell<Verifier> = OnceCell::new();
 
 /// # Safety
@@ -19,7 +19,7 @@ pub unsafe extern "C" fn init_chunk_prover(params_dir: *const c_char) {
     let params_dir = c_char_to_str(params_dir);
     let prover = Prover::from_params_dir(params_dir);
 
-    PROVER.set(prover).unwrap();
+    CHUNK_PROVER.set(prover).unwrap();
 }
 
 /// # Safety
@@ -42,7 +42,7 @@ pub unsafe extern "C" fn gen_chunk_proof(block_traces: *const c_char) -> *const
     let block_traces = serde_json::from_slice::<Vec<BlockTrace>>(&block_traces).unwrap();
 
     let proof_result = panic::catch_unwind(|| {
-        let proof = PROVER
+        let proof = CHUNK_PROVER
             .get_mut()
             .unwrap()
             .gen_chunk_proof(block_traces, None, OUTPUT_DIR.as_deref())

common/libzkp/impl/src/chunk_verifier.rs

@@ -0,0 +1,65 @@
+use crate::utils::{c_char_to_str, c_char_to_vec, vec_to_c_char, OUTPUT_DIR};
+use libc::c_char;
+use prover::{
+    utils::init_env_and_log,
+    zkevm::{Prover, Verifier},
+    ChunkProof,
+};
+use std::{cell::OnceCell, panic, ptr::null};
+use types::eth::BlockTrace;
+
+static mut CHUNK_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);
+
+    CHUNK_PROVER.set(prover).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_chunk_verifier(params_dir: *const c_char, assets_dir: *const c_char) {
+    init_env_and_log("ffi_chunk_verify");
+
+    let params_dir = c_char_to_str(params_dir);
+    let assets_dir = c_char_to_str(assets_dir);
+
+    let verifier = Verifier::from_dirs(params_dir, assets_dir);
+
+    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_result = panic::catch_unwind(|| {
+        let proof = CHUNK_PROVER
+            .get_mut()
+            .unwrap()
+            .gen_chunk_proof(block_traces, None, OUTPUT_DIR.as_deref())
+            .unwrap();
+
+        serde_json::to_vec(&proof).unwrap()
+    });
+
+    proof_result.map_or(null(), vec_to_c_char)
+}
+
+/// # 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 = panic::catch_unwind(|| VERIFIER.get().unwrap().verify_chunk_proof(proof));
+    verified.unwrap_or(false) as c_char
+}

common/libzkp/impl/src/lib.rs

@@ -1,5 +1,5 @@
 #![feature(once_cell)]
 
-mod batch;
-mod chunk;
+mod prove_batch;
+mod prove_chunk;
 mod utils;