chunk prover error and refactor

Author: roynalnaruto

Cargo.lock

@@ -34,6 +34,7 @@ serde.workspace = true
 serde_derive = "1.0"
 serde_json = { workspace = true, features = ["unbounded_depth"] }
 serde_stacker.workspace = true
+thiserror = "1.0"
 sha2 ="0.10.2"
 revm = { version = "3.5.0", default-features = false, features = ["std"] }
 

prover/Cargo.toml

@@ -345,7 +345,11 @@ pub fn check_chunk_hashes(
 ) -> Result<()> {
     for (idx, (in_arg, chunk_proof)) in chunk_hashes_proofs.iter().enumerate() {
         let in_proof = &chunk_proof.chunk_info;
-        crate::proof::compare_chunk_info(&format!("{name} chunk num {idx}"), in_arg, in_proof)?;
+        if let Err(e) =
+            crate::proof::compare_chunk_info(&format!("{name} chunk num {idx}"), in_arg, in_proof)
+        {
+            bail!(e);
+        }
     }
     Ok(())
 }

prover/src/aggregator/prover.rs

@@ -2,8 +2,8 @@ use crate::{
     common,
     config::INNER_DEGREE,
     io::serialize_vk,
-    utils::{chunk_trace_to_witness_block, gen_rng},
-    zkevm::circuit::TargetCircuit,
+    utils::gen_rng,
+    zkevm::circuit::{chunk_trace_to_witness_block, TargetCircuit},
     Proof,
 };
 use anyhow::Result;

prover/src/inner/prover.rs

@@ -1,7 +1,6 @@
 use super::{dump_as_json, dump_data, dump_vk, from_json_file, Proof};
 use crate::{types::base64, zkevm::SubCircuitRowUsage};
 use aggregator::ChunkInfo;
-use anyhow::{bail, Result};
 use halo2_proofs::{halo2curves::bn256::G1Affine, plonk::ProvingKey};
 use serde_derive::{Deserialize, Serialize};
 use snark_verifier::Protocol;
@@ -37,33 +36,34 @@ pub struct ChunkProof {
 macro_rules! compare_field {
     ($desc:expr, $field:ident, $lhs:ident, $rhs:ident) => {
         if $lhs.$field != $rhs.$field {
-            bail!(
+            return Err(format!(
                 "{} chunk different {}: {} != {}",
                 $desc,
                 stringify!($field),
                 $lhs.$field,
                 $rhs.$field
-            );
+            ));
         }
     };
 }
 
 /// Check chunk info is consistent with chunk info embedded inside proof
-pub fn compare_chunk_info(name: &str, lhs: &ChunkInfo, rhs: &ChunkInfo) -> Result<()> {
+pub fn compare_chunk_info(name: &str, lhs: &ChunkInfo, rhs: &ChunkInfo) -> Result<(), String> {
     compare_field!(name, chain_id, lhs, rhs);
     compare_field!(name, prev_state_root, lhs, rhs);
     compare_field!(name, post_state_root, lhs, rhs);
     compare_field!(name, withdraw_root, lhs, rhs);
     compare_field!(name, data_hash, lhs, rhs);
     if lhs.tx_bytes != rhs.tx_bytes {
-        bail!(
+        return Err(format!(
             "{} chunk different {}: {} != {}",
             name,
             "tx_bytes",
             hex::encode(&lhs.tx_bytes),
             hex::encode(&rhs.tx_bytes)
-        );
+        ));
     }
+
     Ok(())
 }
 
@@ -74,7 +74,7 @@ impl ChunkProof {
         chunk_info: ChunkInfo,
         chunk_kind: ChunkKind,
         row_usages: Vec<SubCircuitRowUsage>,
-    ) -> Result<Self> {
+    ) -> anyhow::Result<Self> {
         let protocol = serde_json::to_vec(&snark.protocol)?;
         let proof = Proof::new(snark.proof, &snark.instances, pk);
 
@@ -87,11 +87,11 @@ impl ChunkProof {
         })
     }
 
-    pub fn from_json_file(dir: &str, name: &str) -> Result<Self> {
+    pub fn from_json_file(dir: &str, name: &str) -> anyhow::Result<Self> {
         from_json_file(dir, &dump_filename(name))
     }
 
-    pub fn dump(&self, dir: &str, name: &str) -> Result<()> {
+    pub fn dump(&self, dir: &str, name: &str) -> anyhow::Result<()> {
         let filename = dump_filename(name);
 
         // Dump vk and protocol.

prover/src/proof/chunk.rs

@@ -1,8 +1,5 @@
 #![allow(deprecated)]
-use crate::{
-    types::BlockTraceJsonRpcResult,
-    zkevm::circuit::{block_traces_to_witness_block, print_chunk_stats},
-};
+use crate::types::BlockTraceJsonRpcResult;
 use anyhow::{bail, Result};
 use chrono::Utc;
 use eth_types::l2_types::BlockTrace;
@@ -127,14 +124,6 @@ pub fn metric_of_witness_block(block: &Block) -> ChunkMetric {
     }
 }
 
-pub fn chunk_trace_to_witness_block(chunk_trace: Vec<BlockTrace>) -> Result<Block> {
-    if chunk_trace.is_empty() {
-        bail!("Empty chunk trace");
-    }
-    print_chunk_stats(&chunk_trace);
-    block_traces_to_witness_block(chunk_trace)
-}
-
 // Return the output dir.
 pub fn init_env_and_log(id: &str) -> String {
     dotenvy::dotenv().ok();

prover/src/utils.rs

@@ -1,12 +1,14 @@
 #[cfg(feature = "scroll")]
 mod capacity_checker;
 pub mod circuit;
+mod error;
 mod prover;
 mod verifier;
 
 pub use self::prover::Prover;
 #[cfg(feature = "scroll")]
 pub use capacity_checker::{CircuitCapacityChecker, RowUsage};
+pub use error::ChunkProverError;
 use serde::{Deserialize, Serialize};
 pub use verifier::Verifier;
 

prover/src/zkevm.rs

@@ -137,10 +137,7 @@ impl CircuitCapacityChecker {
             self.acc_row_usage.clone()
         }
     }
-    pub fn estimate_circuit_capacity(
-        &mut self,
-        trace: BlockTrace,
-    ) -> Result<RowUsage, anyhow::Error> {
+    pub fn estimate_circuit_capacity(&mut self, trace: BlockTrace) -> anyhow::Result<RowUsage> {
         let (mut estimate_builder, codedb_prev) =
             if let Some((code_db, sdb, mpt_state)) = self.builder_ctx.take() {
                 // here we create a new builder for another (sealed) witness block

prover/src/zkevm/capacity_checker.rs

@@ -1,12 +1,11 @@
-use builder::dummy_witness_block;
 use halo2_proofs::halo2curves::bn256::Fr;
 use snark_verifier_sdk::CircuitExt;
 use zkevm_circuits::{super_circuit::params::ScrollSuperCircuit, util::SubCircuit, witness};
 
 mod builder;
 pub use self::builder::{
-    block_traces_to_witness_block, calculate_row_usage_of_witness_block, finalize_builder,
-    print_chunk_stats,
+    block_traces_to_witness_block, calculate_row_usage_of_witness_block,
+    chunk_trace_to_witness_block, finalize_builder,
 };
 
 pub use zkevm_circuits::super_circuit::params::{MAX_CALLDATA, MAX_INNER_BLOCKS, MAX_TXS};
@@ -23,7 +22,7 @@ pub trait TargetCircuit {
     where
         Self: Sized,
     {
-        let witness_block = dummy_witness_block()?;
+        let witness_block = builder::dummy_witness_block()?;
         let circuit = Self::from_witness_block(&witness_block)?;
         Ok(circuit)
     }

prover/src/zkevm/circuit.rs

@@ -1,6 +1,5 @@
-use crate::zkevm::SubCircuitRowUsage;
-use anyhow::{bail, Result};
-use bus_mapping::circuit_input_builder::CircuitInputBuilder;
+use crate::zkevm::{ChunkProverError, SubCircuitRowUsage};
+use bus_mapping::{circuit_input_builder::CircuitInputBuilder, Error as CircuitBuilderError};
 use eth_types::{l2_types::BlockTrace, ToWord};
 use itertools::Itertools;
 use mpt_zktrie::state::ZkTrieHash;
@@ -12,12 +11,14 @@ use zkevm_circuits::{
 
 pub fn calculate_row_usage_of_witness_block(
     witness_block: &Block,
-) -> Result<Vec<SubCircuitRowUsage>> {
+) -> Result<Vec<SubCircuitRowUsage>, ChunkProverError> {
     let rows = ScrollSuperCircuit::min_num_rows_block_subcircuits(witness_block);
 
     // Check whether we need to "estimate" poseidon sub circuit row usage
     if witness_block.mpt_updates.smt_traces.is_empty() {
-        bail!("light mode no longer supported");
+        return Err(ChunkProverError::Custom(
+            "light mode no longer supported".to_string(),
+        ));
     }
 
     let first_block_num = witness_block.first_block_number();
@@ -34,58 +35,44 @@ pub fn calculate_row_usage_of_witness_block(
             .sum::<usize>(),
         rows,
     );
-    let row_usage_details: Vec<SubCircuitRowUsage> = rows
+
+    Ok(rows
         .into_iter()
         .map(|x| SubCircuitRowUsage {
             name: x.name,
             row_number: x.row_num_real,
         })
-        .collect_vec();
-    Ok(row_usage_details)
-}
-
-pub fn print_chunk_stats(block_traces: &[BlockTrace]) {
-    let num_blocks = block_traces.len();
-    let num_txs = block_traces
-        .iter()
-        .map(|b| b.transactions.len())
-        .sum::<usize>();
-    let total_tx_len = block_traces
-        .iter()
-        .flat_map(|b| b.transactions.iter().map(|t| t.data.len()))
-        .sum::<usize>();
-    log::info!(
-        "check capacity of block traces, num_block {}, num_tx {}, tx total len {}",
-        num_blocks,
-        num_txs,
-        total_tx_len
-    );
+        .collect_vec())
 }
 
-pub fn dummy_witness_block() -> Result<Block> {
+pub fn dummy_witness_block() -> anyhow::Result<Block> {
     log::debug!("generate dummy witness block");
     let dummy_chain_id = 0;
     let witness_block = zkevm_circuits::witness::dummy_witness_block(dummy_chain_id);
     log::debug!("generate dummy witness block done");
     Ok(witness_block)
 }
 
-pub fn block_traces_to_witness_block(block_traces: Vec<BlockTrace>) -> Result<Block> {
+pub fn block_traces_to_witness_block(
+    block_traces: Vec<BlockTrace>,
+) -> Result<Block, ChunkProverError> {
     if block_traces.is_empty() {
-        bail!("use dummy_witness_block instead");
+        return Err(ChunkProverError::Custom(
+            "empty block traces! hint: use dummy_witness_block instead".to_string(),
+        ));
     }
     let block_num = block_traces.len();
     let total_tx_num = block_traces
         .iter()
         .map(|b| b.transactions.len())
         .sum::<usize>();
     if total_tx_num > MAX_TXS {
-        bail!(
+        return Err(ChunkProverError::Custom(format!(
             "tx num overflow {}, block range {} to {}",
             total_tx_num,
             block_traces[0].header.number.unwrap(),
             block_traces[block_num - 1].header.number.unwrap()
-        );
+        )));
     }
     log::info!(
         "block_traces_to_witness_block, block num {}, tx num {}",
@@ -116,8 +103,18 @@ pub fn block_traces_to_witness_block(block_traces: Vec<BlockTrace>) -> Result<Bl
     Ok(witness_block)
 }
 
+pub fn chunk_trace_to_witness_block(
+    chunk_trace: Vec<BlockTrace>,
+) -> Result<Block, ChunkProverError> {
+    if chunk_trace.is_empty() {
+        return Err(ChunkProverError::Custom("Empty chunk trace".to_string()));
+    }
+    print_chunk_stats(&chunk_trace);
+    block_traces_to_witness_block(chunk_trace)
+}
+
 /// Finalize building and return witness block
-pub fn finalize_builder(builder: &mut CircuitInputBuilder) -> Result<Block> {
+pub fn finalize_builder(builder: &mut CircuitInputBuilder) -> Result<Block, CircuitBuilderError> {
     builder.finalize_building()?;
 
     log::debug!("converting builder.block to witness block");
@@ -152,3 +149,21 @@ pub fn finalize_builder(builder: &mut CircuitInputBuilder) -> Result<Block> {
 
     Ok(witness_block)
 }
+
+fn print_chunk_stats(block_traces: &[BlockTrace]) {
+    let num_blocks = block_traces.len();
+    let num_txs = block_traces
+        .iter()
+        .map(|b| b.transactions.len())
+        .sum::<usize>();
+    let total_tx_len = block_traces
+        .iter()
+        .flat_map(|b| b.transactions.iter().map(|t| t.data.len()))
+        .sum::<usize>();
+    log::info!(
+        "check capacity of block traces, num_block {}, num_tx {}, tx total len {}",
+        num_blocks,
+        num_txs,
+        total_tx_len
+    );
+}