From 8def28f4c9bc8e052437483d1a6f7d7d167965d8 Mon Sep 17 00:00:00 2001
From: Steven Gu <asongala@163.com>
Date: Thu, 21 Sep 2023 15:15:22 +0800
Subject: [PATCH 1/2] Return `ChunkProof` from `chunk_prove` test.

---
 prover/src/test/chunk.rs | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/prover/src/test/chunk.rs b/prover/src/test/chunk.rs
index e8fee500a6..e9b2cf18ba 100644
--- a/prover/src/test/chunk.rs
+++ b/prover/src/test/chunk.rs
@@ -2,7 +2,7 @@ use crate::{
     common::{Prover, Verifier},
     config::{LayerId, ZKEVM_DEGREES},
     utils::read_env_var,
-    CompressionCircuit, WitnessBlock,
+    ChunkHash, ChunkProof, CompressionCircuit, WitnessBlock,
 };
 use once_cell::sync::Lazy;
 use std::env;
@@ -32,7 +32,7 @@ static mut CHUNK_VERIFIER: Lazy<Verifier<CompressionCircuit>> = Lazy::new(|| {
     verifier
 });
 
-pub fn chunk_prove(test: &str, witness_block: &WitnessBlock) {
+pub fn chunk_prove(test: &str, witness_block: &WitnessBlock) -> ChunkProof {
     log::info!("{test}: chunk-prove BEGIN");
 
     let prover = unsafe { &mut CHUNK_PROVER };
@@ -60,8 +60,15 @@ pub fn chunk_prove(test: &str, witness_block: &WitnessBlock) {
         verifier.set_vk(vk);
     }
 
-    let verified = verifier.verify_snark(snark);
+    let verified = verifier.verify_snark(snark.clone());
     assert!(verified, "{test}: failed to verify chunk snark");
 
     log::info!("{test}: chunk-prove END");
+
+    ChunkProof::new(
+        snark,
+        prover.pk(LayerId::Layer2.id()),
+        Some(ChunkHash::from_witness_block(witness_block, false)),
+    )
+    .unwrap_or_else(|err| panic!("{test}: failed to crate chunk proof: {err}"))
 }

From 07a77dcc69d129b0d6849ba901eae1c7669e6e81 Mon Sep 17 00:00:00 2001
From: Steven Gu <asongala@163.com>
Date: Thu, 21 Sep 2023 16:36:26 +0800
Subject: [PATCH 2/2] Add `batch_prove` test.

---
 prover/src/test.rs       |  2 ++
 prover/src/test/batch.rs | 55 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+)
 create mode 100644 prover/src/test/batch.rs

diff --git a/prover/src/test.rs b/prover/src/test.rs
index bef6b18532..3946970294 100644
--- a/prover/src/test.rs
+++ b/prover/src/test.rs
@@ -1,5 +1,7 @@
+mod batch;
 mod chunk;
 mod inner;
 
+pub use batch::batch_prove;
 pub use chunk::chunk_prove;
 pub use inner::inner_prove;
diff --git a/prover/src/test/batch.rs b/prover/src/test/batch.rs
new file mode 100644
index 0000000000..82f5aef45a
--- /dev/null
+++ b/prover/src/test/batch.rs
@@ -0,0 +1,55 @@
+use crate::{
+    aggregator::{Prover, Verifier},
+    config::LayerId,
+    consts::DEPLOYMENT_CODE_FILENAME,
+    io::force_to_read,
+    utils::read_env_var,
+    ChunkHash, ChunkProof,
+};
+use once_cell::sync::Lazy;
+
+static mut BATCH_PROVER: Lazy<Prover> = Lazy::new(|| {
+    let assets_dir = read_env_var("SCROLL_PROVER_ASSETS_DIR", "./test_assets".to_string());
+    let params_dir = read_env_var("SCROLL_PROVER_PARAMS_DIR", "./test_params".to_string());
+
+    let prover = Prover::from_dirs(&params_dir, &assets_dir);
+    log::info!("Constructed batch-prover");
+
+    prover
+});
+
+static mut BATCH_VERIFIER: Lazy<Verifier> = Lazy::new(|| {
+    let assets_dir = read_env_var("SCROLL_PROVER_ASSETS_DIR", "./test_assets".to_string());
+
+    let prover = unsafe { &mut BATCH_PROVER };
+    let params = prover.inner.params(LayerId::Layer4.degree()).clone();
+
+    let pk = prover
+        .inner
+        .pk(LayerId::Layer4.id())
+        .expect("Failed to get batch-prove PK");
+    let vk = pk.get_vk().clone();
+
+    let deployment_code = force_to_read(&assets_dir, &DEPLOYMENT_CODE_FILENAME);
+
+    let verifier = Verifier::new(params, vk, deployment_code);
+    log::info!("Constructed batch-verifier");
+
+    verifier
+});
+
+pub fn batch_prove(test: &str, chunk_hashes_proofs: Vec<(ChunkHash, ChunkProof)>) {
+    log::info!("{test}: batch-prove BEGIN");
+
+    let prover = unsafe { &mut BATCH_PROVER };
+    let proof = prover
+        .gen_agg_evm_proof(chunk_hashes_proofs, None, None)
+        .unwrap_or_else(|err| panic!("{test}: failed to generate batch proof: {err}"));
+    log::info!("{test}: generated batch proof");
+
+    let verifier = unsafe { &mut BATCH_VERIFIER };
+    let verified = verifier.verify_agg_evm_proof(proof);
+    assert!(verified, "{test}: failed to verify batch proof");
+
+    log::info!("{test}: batch-prove END");
+}