adapt for "upgrade 5 refactor" (#351)

* running

* add the output dir

* done

* chore: bump serde (unit structs supported in flatten)

* bump prover

* bump prover

* bump prover

* fix some env var

* clean

---------

Co-authored-by: Rohit Narurkar <[email protected]>

bin/src/chain_prover.rs

@@ -10,10 +10,8 @@ use integration::{
     l2geth,
 };
 use prover::{
-    aggregator,
-    utils::init_env_and_log,
-    zkevm::{circuit::block_traces_to_witness_block, CircuitCapacityChecker, RowUsage},
-    BatchData, BlockTrace, ChunkInfo, ChunkProof, MAX_AGG_SNARKS,
+    eth_types::l2_types::BlockTrace, init_env_and_log, BatchData, ChunkInfo, ChunkProofV2,
+    CircuitCapacityChecker, RowUsage, MAX_AGG_SNARKS,
 };
 use std::env;
 
@@ -81,7 +79,7 @@ impl BatchBuilder {
         }
 
         let batch_bytes = self.batch_data.get_batch_data_bytes();
-        let blob_bytes = aggregator::eip4844::get_blob_bytes(&batch_bytes);
+        let blob_bytes = prover::get_blob_bytes(&batch_bytes);
         let compressed_da_size = blob_bytes.len();
         let uncompressed_da_size = self
             .batch_data
@@ -194,15 +192,15 @@ async fn prove_by_block(l2geth: &l2geth::Client, begin_block: i64, end_block: i6
                 unimplemented!("uncomment below");
                 //ChunkInfo::from_block_traces(&chunk)
             } else {
-                let witness_block = block_traces_to_witness_block(chunk).unwrap();
+                let witness_block = prover::chunk_trace_to_witness_block(chunk).unwrap();
                 ChunkInfo::from_witness_block(&witness_block, false)
             };
             if let Some(batch) = batch_builder.add(chunk_info) {
                 let mut padded_batch = batch.clone();
                 padding_chunk(&mut padded_batch);
                 let batch_data = BatchData::<{ MAX_AGG_SNARKS }>::new(batch.len(), &padded_batch);
                 let compressed_da_size =
-                    aggregator::eip4844::get_blob_bytes(&batch_data.get_batch_data_bytes()).len();
+                    prover::get_blob_bytes(&batch_data.get_batch_data_bytes()).len();
                 log::info!(
                     "batch built: blob usage {:.3}, chunk num {}, block num {}, block range {} to {}",
                     compressed_da_size as f32 / constants::N_BLOB_BYTES as f32,
@@ -234,7 +232,11 @@ fn padding_chunk(chunks: &mut Vec<ChunkInfo>) {
     }
 }
 
-fn prove_chunk(batch_id: u64, chunk_id: u64, block_traces: Vec<BlockTrace>) -> Option<ChunkProof> {
+fn prove_chunk(
+    batch_id: u64,
+    chunk_id: u64,
+    block_traces: Vec<BlockTrace>,
+) -> Option<ChunkProofV2> {
     let total_gas: u64 = block_traces
         .iter()
         .map(|b| b.header.gas_used.as_u64())

bin/src/prove_utils.rs

@@ -1,4 +1,4 @@
-use prover::{BlockTrace, ChunkProof};
+use prover::{eth_types::l2_types::BlockTrace, ChunkProofV2};
 use std::panic::{catch_unwind, AssertUnwindSafe};
 
 #[cfg(feature = "batch-prove")]
@@ -7,7 +7,7 @@ use prover::{BatchHeader, MAX_AGG_SNARKS};
 #[cfg(feature = "batch-prove")]
 pub fn prove_batch(
     id: &str,
-    chunk_proofs: Vec<ChunkProof>,
+    chunk_proofs: Vec<ChunkProofV2>,
     batch_header: BatchHeader<MAX_AGG_SNARKS>,
 ) {
     use integration::prove::get_blob_from_chunks;
@@ -16,15 +16,15 @@ pub fn prove_batch(
 
     let chunk_infos = chunk_proofs
         .iter()
-        .map(|p| p.chunk_info.clone())
+        .map(|p| p.inner.chunk_info().clone())
         .collect_vec();
     let blob_bytes = get_blob_from_chunks(&chunk_infos);
     let batch = BatchProvingTask {
         chunk_proofs,
         batch_header,
         blob_bytes,
     };
-    let result = catch_unwind(AssertUnwindSafe(|| prover::test::batch_prove(id, batch)));
+    let result = catch_unwind(AssertUnwindSafe(|| prover::batch_prove(id, batch)));
 
     match result {
         Ok(_) => log::info!("{id}: succeeded to prove batch"),
@@ -41,21 +41,15 @@ pub fn prove_batch(
     }
 }
 
-pub fn prove_chunk(id: &str, traces: Vec<BlockTrace>) -> Option<ChunkProof> {
+pub fn prove_chunk(id: &str, traces: Vec<BlockTrace>) -> Option<ChunkProofV2> {
     let result = catch_unwind(AssertUnwindSafe(|| {
         #[cfg(not(feature = "chunk-prove"))]
-        let proof = None::<ChunkProof>;
+        let proof = None::<ChunkProofV2>;
 
-        #[cfg(feature = "inner-prove")]
-        {
-            let witness_block =
-                prover::zkevm::circuit::block_traces_to_witness_block(traces.clone()).unwrap();
-            prover::test::inner_prove(id, &witness_block);
-        }
         #[cfg(feature = "chunk-prove")]
-        let proof = Some(prover::test::chunk_prove(
+        let proof = Some(prover::chunk_prove(
             id,
-            prover::ChunkProvingTask::from(traces),
+            prover::ChunkProvingTask::new(traces),
         ));
         #[cfg(not(any(feature = "inner-prove", feature = "chunk-prove")))]
         mock_prove(id, traces);
@@ -84,12 +78,10 @@ pub fn prove_chunk(id: &str, traces: Vec<BlockTrace>) -> Option<ChunkProof> {
 }
 
 #[cfg(not(any(feature = "inner-prove", feature = "chunk-prove")))]
-fn mock_prove(id: &str, traces: Vec<BlockTrace>) {
-    use prover::{inner::Prover, zkevm::circuit::SuperCircuit};
-
+fn mock_prove(id: &str, traces: Vec<prover::eth_types::l2_types::BlockTrace>) {
     log::info!("{id}: mock-prove BEGIN");
 
-    Prover::<SuperCircuit>::mock_prove_target_circuit_chunk(traces)
+    integration::mock::mock_prove_target_circuit_chunk(traces)
         .unwrap_or_else(|err| panic!("{id}: failed to mock-prove: {err}"));
 
     log::info!("{id}: mock-prove END");

bin/src/trace_prover.rs

@@ -1,6 +1,6 @@
 use clap::Parser;
 use integration::{prove::prove_and_verify_chunk, test_util::load_chunk};
-use prover::{utils::init_env_and_log, ChunkProvingTask};
+use prover::{init_env_and_log, ChunkProvingTask};
 use std::env;
 
 #[derive(Parser, Debug)]
@@ -31,15 +31,9 @@ fn main() {
 
     let traces = load_chunk(&args.trace_path).1;
     prover::eth_types::constants::set_scroll_block_constants_with_trace(&traces[0]);
-    let chunk = ChunkProvingTask::from(traces);
-    let params_map = prover::common::Prover::load_params_map(
-        &args.params_path,
-        &[
-            *prover::config::INNER_DEGREE,
-            *prover::config::LAYER1_DEGREE,
-            *prover::config::LAYER2_DEGREE,
-        ],
-    );
+    let chunk = ChunkProvingTask::new(traces);
+    let params_map =
+        prover::Prover::load_params_map(&args.params_path, &prover::CHUNK_PROVER_DEGREES);
     prove_and_verify_chunk(
         chunk,
         Some("0"), // same with `make test-chunk-prove`, to load vk

integration/Cargo.toml

@@ -26,3 +26,4 @@ prover.workspace = true
 [features]
 default = ["prove_verify"]
 prove_verify = []
+fix_later = [] # commented codes

integration/configs/layer3.config

@@ -2,7 +2,7 @@
   "strategy": "Simple",
   "degree": 21,
   "num_advice": [
-    63
+    85
   ],
   "num_lookup_advice": [
     8

integration/src/capacity_checker.rs

@@ -1,11 +1,8 @@
 use itertools::Itertools;
 use prover::{
-    zkevm::{
-        circuit::{block_traces_to_witness_block, calculate_row_usage_of_witness_block},
-        CircuitCapacityChecker, RowUsage, SubCircuitRowUsage,
-    },
-    zkevm_circuits::evm_circuit::ExecutionState,
-    BlockTrace,
+    calculate_row_usage_of_witness_block, chunk_trace_to_witness_block,
+    eth_types::l2_types::BlockTrace, zkevm_circuits::evm_circuit::ExecutionState,
+    CircuitCapacityChecker, RowUsage, SubCircuitRowUsage,
 };
 use std::time::Duration;
 
@@ -262,7 +259,7 @@ pub fn ccc_by_chunk(
     log::info!("ccc_by_chunk: run ccc for batch-{batch_id} chunk-{chunk_id}");
 
     let start_time = std::time::Instant::now();
-    let witness_block = block_traces_to_witness_block(Vec::from(block_traces)).unwrap();
+    let witness_block = chunk_trace_to_witness_block(Vec::from(block_traces)).unwrap();
     let rows = calculate_row_usage_of_witness_block(&witness_block).unwrap();
     let row_usage = RowUsage::from_row_usage_details(rows);
     pretty_print_row_usage(&row_usage, block_traces, chunk_id, "chunk-opt");

integration/src/l2geth.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use ethers_providers::{Http, Middleware, Provider};
-use prover::BlockTrace;
+use prover::eth_types::l2_types::BlockTrace;
 use serde::Serialize;
 
 pub struct Client {

integration/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod capacity_checker;
 pub mod l2geth;
+pub mod mock;
 pub mod prove;
 pub mod test_util;
 mod verifier;

integration/src/mock.rs

@@ -0,0 +1,35 @@
+use anyhow::bail;
+use halo2_proofs::{dev::MockProver, halo2curves::bn256::Fr};
+use prover::{
+    eth_types::l2_types::BlockTrace,
+    zkevm_circuits::{super_circuit::params::ScrollSuperCircuit, util::SubCircuit, witness::Block},
+};
+use snark_verifier_sdk::CircuitExt;
+
+use prover::{chunk_trace_to_witness_block, metric_of_witness_block, INNER_DEGREE};
+
+pub fn mock_prove_target_circuit_chunk(block_traces: Vec<BlockTrace>) -> anyhow::Result<()> {
+    let witness_block = chunk_trace_to_witness_block(block_traces)?;
+    mock_prove_witness_block(&witness_block)
+}
+
+pub fn mock_prove_witness_block(witness_block: &Block) -> anyhow::Result<()> {
+    log::info!(
+        "mock proving chunk, chunk metric {:?}",
+        metric_of_witness_block(witness_block)
+    );
+    let circuit = ScrollSuperCircuit::new_from_block(witness_block);
+    let prover = MockProver::<Fr>::run(*INNER_DEGREE, &circuit, circuit.instances())?;
+    if let Err(errs) = prover.verify_par() {
+        log::error!("err num: {}", errs.len());
+        for err in &errs {
+            log::error!("{}", err);
+        }
+        bail!("{:#?}", errs);
+    }
+    log::info!(
+        "mock prove done. chunk metric: {:?}",
+        metric_of_witness_block(witness_block),
+    );
+    Ok(())
+}