feat(prover-sever): enhance error checking

bin/src/prove.rs

@@ -8,7 +8,7 @@ use std::io::Write;
 use std::path::PathBuf;
 use utils::Measurer;
 use zkevm::{
-    circuit::{EvmCircuit, StateCircuit, AGG_DEGREE, DEGREE},
+    circuit::{EvmCircuit, StateCircuit, AGG_DEGREE, DEGREE, MAX_TXS},
     io::write_file,
     prover::Prover,
     utils::{get_block_trace_from_file, load_or_create_params, load_or_create_seed},
@@ -78,6 +78,16 @@ fn main() {
     // Generating proofs for each trace
     let mut outer_timer = Measurer::new();
     for (trace_name, trace) in traces {
+        let tx_count = trace.transactions.len();
+        if tx_count > MAX_TXS {
+            panic!(
+                "{}",
+                format!(
+                    "too many transactions. MAX_TXS: {}, given transactions: {}",
+                    MAX_TXS, tx_count
+                )
+            );
+        }
         let mut out_dir = PathBuf::from(&trace_name);
         fs::create_dir_all(&out_dir).unwrap();
 

prover-server/src/mock_client.rs

@@ -50,8 +50,7 @@ async fn test_request_proof(cli: HttpClient, proof_type: ProofType) -> bool {
 async fn test_request_spec(cli: HttpClient) -> bool {
     kroma_info("Send 'spec' request to prover-server");
     let params = rpc_params![];
-    let response: String = cli.request("spec", params).await.unwrap();
-    let zk_spec: ZkSpec = serde_json::from_str(&response).unwrap();
+    let zk_spec: ZkSpec = cli.request("spec", params).await.unwrap();
 
     kroma_info(format!(
         "Got: \

prover-server/src/server_main.rs

@@ -7,12 +7,11 @@ use crate::spec::ProofType;
 use crate::utils::{kroma_err, kroma_info};
 use clap::Parser;
 use jsonrpc_derive::rpc;
-use jsonrpc_http_server::jsonrpc_core::{ErrorCode, Result};
+use jsonrpc_http_server::jsonrpc_core::Result;
 use jsonrpc_http_server::ServerBuilder;
 use spec::ZkSpec;
 use types::eth::BlockTrace;
-
-const KROMA_CHAIN_ID: u32 = 901;
+use zkevm::circuit::{CHAIN_ID, MAX_TXS};
 
 #[rpc]
 pub trait Rpc {
@@ -28,7 +27,7 @@ pub trait Rpc {
     /// 4. pub max_txs: u32,
     /// 5. pub max_call_data: u32,
     fn spec(&self) -> Result<ZkSpec> {
-        let spec = ZkSpec::new(KROMA_CHAIN_ID);
+        let spec = ZkSpec::new(*CHAIN_ID as u32);
         Ok(spec)
     }
 
@@ -48,21 +47,50 @@ impl Rpc for RpcImpl {
     ///
     /// # Returns
     /// ProofResult instance which includes proof and final pair.
-    fn prove(&self, trace: String, proof_type: i32) -> Result<ProofResult> {
+    fn prove(&self, trace: String, proof_type_val: i32) -> Result<ProofResult> {
+        // initiate ProofType
+        let proof_type = ProofType::from_value(proof_type_val);
+        if let ProofType::None = proof_type {
+            let msg = format!(
+                "invalid prove param: expected param from 1 to 4, but {:?}",
+                proof_type_val
+            );
+            kroma_err(&msg);
+            let err = jsonrpc_core::Error::invalid_params(msg);
+            return Err(err);
+        }
+
         // initiate BlockTrace
         let block_trace: BlockTrace = match serde_json::from_slice(trace.as_bytes()) {
             Ok(trace) => trace,
             Err(_) => {
                 kroma_err("invalid block trace.");
-                let err = jsonrpc_core::Error::new(ErrorCode::InvalidParams);
+                let err = jsonrpc_core::Error::invalid_params("invalid format trace");
                 return Err(err);
             }
         };
 
-        // initiate ProofType
-        let proof_type = ProofType::from_value(proof_type);
-        if let ProofType::None = proof_type {
-            let err = jsonrpc_core::Error::new(ErrorCode::InvalidParams);
+        // check number of txs in the trace
+        let tx_count = block_trace.transactions.len();
+        if tx_count > MAX_TXS {
+            let msg = format!(
+                "too many transactions. MAX_TXS: {}, given transactions: {}",
+                MAX_TXS, tx_count
+            );
+            kroma_err(&msg);
+            let err = jsonrpc_core::Error::invalid_params(msg);
+            return Err(err);
+        }
+
+        // check chain id
+        let trace_chain_id = block_trace.chain_id;
+        if *CHAIN_ID != trace_chain_id.as_u64() {
+            let msg = format!(
+                "not matched chain ids: expected({:?}), requested({:?})",
+                *CHAIN_ID, trace_chain_id
+            );
+            kroma_err(&msg);
+            let err = jsonrpc_core::Error::invalid_params(msg);
             return Err(err);
         }
 
@@ -103,6 +131,7 @@ fn main() {
     kroma_info(format!("Prover server starting on {endpoint}"));
     let server = ServerBuilder::new(io)
         .threads(3)
+        .max_request_body_size(32_000_000)
         .start_http(&endpoint.parse().unwrap())
         .unwrap();
 

zkevm/src/circuit.rs

@@ -36,13 +36,13 @@ const MAX_EXP_STEPS: usize = 10_000;
 */
 
 ////// params for degree = 20 ////////////
-pub static DEGREE: Lazy<usize> = Lazy::new(|| read_env_var("DEGREE", 20));
-pub const MAX_TXS: usize = 25;
+pub static DEGREE: Lazy<usize> = Lazy::new(|| read_env_var("DEGREE", 21));
+pub const MAX_TXS: usize = 100;
 const MAX_INNER_BLOCKS: usize = 1;
-pub const MAX_CALLDATA: usize = 400_000;
-const MAX_RWS: usize = 1_000_000;
-const MAX_KECCAK_ROWS: usize = 524_000;
-const MAX_EXP_STEPS: usize = 10_000;
+pub const MAX_CALLDATA: usize = 2_000_000;
+const MAX_RWS: usize = 2_000_000;
+const MAX_KECCAK_ROWS: usize = 1_000_000;
+const MAX_EXP_STEPS: usize = 100_000;
 
 pub static CHAIN_ID: Lazy<u64> = Lazy::new(|| read_env_var("CHAIN_ID", 2357));
 pub static AGG_DEGREE: Lazy<usize> = Lazy::new(|| read_env_var("AGG_DEGREE", 26));