Sync Prover mainnet fix (#821)

Co-authored-by: chengwenxi <22697326+chengwenxi@users.noreply.github.com>

Author: anylots

prover/.gitignore

@@ -24,4 +24,6 @@ shadow-proving
 contracts/cache
 contracts
 out
-lib
+lib
+
+proof

prover/Cargo.lock

@@ -86,7 +86,7 @@ impl ExternalSign {
         let req_data = self.craft_req_data(data, tx_info)?;
 
         let rt = self.do_request(&self.url, &req_data).await?;
-        log::debug!("ext_sign response: {:?}", rt);
+        log::info!("ext_sign rt: {:?}", rt);
 
         let response: Response = serde_json::from_str(&rt)?;
         if response.result.sign_datas.is_empty() {
@@ -97,6 +97,7 @@ impl ExternalSign {
             return Err("ext_sign response sign data invalid".into());
         }
 
+
         let sig = hex::decode(&response.result.sign_datas[0].sign[2..])?;
         let signed_tx: Bytes = tx.rlp_signed(&Signature::try_from(sig.as_slice())?);
         Ok(signed_tx)
@@ -139,8 +140,13 @@ impl ExternalSign {
     async fn do_request(&self, url: &str, payload: &ReqData) -> Result<String, Box<dyn Error>> {
         log::debug!("===payload: {:?}", serde_json::to_string(payload).unwrap());
         let response: reqwest::Response = self.client.post(url).json(&payload).send().await?;
-        if !response.status().is_success() {
-            return Err(format!("ext_sign response status not ok: {:?}", response.status()).into());
+        log::info!("===do_request response: {:?}", response);
+        
+        let status = response.status();
+        if !status.is_success() {
+            let text = response.text().await?;
+            log::info!("===do_request response text: {:?}", &text);
+            return Err(format!("ext_sign response status not ok: {:?}", status).into());
         }
         Ok(response.text().await?)
     }

prover/bin/challenge/src/external_sign.rs

@@ -12,7 +12,6 @@ use eyre::anyhow;
 use serde::{Deserialize, Serialize};
 use std::env::var;
 use std::error::Error;
-use std::ops::Mul;
 use std::str::FromStr;
 use std::sync::Arc;
 use std::time::Duration;
@@ -175,6 +174,7 @@ impl ChallengeHandler {
                 if !batch_proof.proof_data.is_empty() {
                     log::info!("query proof and prove state: {:#?}", batch_index);
                     let batch_header = batch_info.fill_ext(batch_proof.batch_header.clone()).encode();
+                    sleep(Duration::from_secs(600)).await;
                     self.prove_state(batch_index, batch_header, batch_proof, l1_rollup).await;
                     continue;
                 }
@@ -462,6 +462,8 @@ async fn batch_inspect(l1_rollup: &RollupType, l1_provider: &Provider<Http>, bat
     let withdrawal_root: [u8; 32] = param.batch_data_input.withdrawal_root;
     let last_block_number: u64 = param.batch_data_input.last_block_number;
     let num_l1_messages = param.batch_data_input.num_l1_messages;
+    log::info!("======> batch inspect: decode tx.input, version =  {:#?}", version);
+    log::info!("======> batch inspect: decode tx.input, param =  {:#?}", param);
 
     let mut batch_info = BatchInfo {
         version,
@@ -574,4 +576,4 @@ pub fn contract_error<M: Middleware>(e: ContractError<M>) -> String {
         format!("error: {:?}", e)
     };
     error_msg
-}
+}

prover/bin/challenge/src/handler.rs

@@ -34,7 +34,7 @@ pub fn prove(
 
     // Prepare input.
     // Convert the traces' format to reduce conversion costs in the client.
-    blocks.iter_mut().for_each(|blobk| blobk.flatten());
+    blocks.iter_mut().for_each(|block| block.flatten());
     let client_input =
         ClientInput { l2_traces: blocks.clone(), blob_info: get_blob_info(blocks).unwrap() };
 

prover/bin/host/build.rs

@@ -86,7 +86,10 @@ impl Prover {
             if read_env_var("SAVE_TRACE", false) {
                 save_trace(batch_index, block_traces);
             }
-            save_batch_header(block_traces, batch_index);
+            if !save_batch_header(block_traces, batch_index) {
+                save_trace(batch_index, block_traces);
+                continue;
+            }
 
             // Step3. Generate evm proof
             log::info!("Generate evm proof");
@@ -113,24 +116,40 @@ impl Prover {
     }
 }
 
-fn save_batch_header(blocks: &mut Vec<BlockTrace>, batch_index: u64) {
-    blocks.iter_mut().for_each(|blobk| blobk.flatten());
-    let batch_info = EVMVerifier::verify(blocks).unwrap();
-    let blob_info = morph_executor_host::get_blob_info(blocks).unwrap();
-    let (versioned_hash, _) = BlobVerifier::verify(&blob_info, blocks.len()).unwrap();
-
-    // Save batch_header
-    // | batch_data_hash | versioned_hash | sequencer_root |
-    // |-----------------|----------------|----------------|
-    // |     bytes32     |     bytes32    |     bytes32    |
-    let mut batch_header: Vec<u8> = Vec::with_capacity(96);
-    batch_header.extend_from_slice(&batch_info.data_hash().0);
-    batch_header.extend_from_slice(&versioned_hash.0);
-    batch_header.extend_from_slice(&batch_info.sequencer_root().0);
+fn save_batch_header(blocks: &mut Vec<BlockTrace>, batch_index: u64) -> bool {
     let proof_dir = PROVER_PROOF_DIR.to_string() + format!("/batch_{}", batch_index).as_str();
     std::fs::create_dir_all(&proof_dir).expect("failed to create proof path");
-    let mut batch_file = File::create(format!("{}/batch_header.data", proof_dir)).unwrap();
-    batch_file.write_all(&batch_header[..]).expect("failed to batch_header");
+    blocks.iter_mut().for_each(|block| block.flatten());
+    let verify_result = EVMVerifier::verify(blocks);
+
+    if let Ok(batch_info) = verify_result {
+        let blob_info = morph_executor_host::get_blob_info(blocks).unwrap();
+        let (versioned_hash, _) = BlobVerifier::verify(&blob_info, blocks.len()).unwrap();
+
+        // Save batch_header
+        // | batch_data_hash | versioned_hash | sequencer_root |
+        // |-----------------|----------------|----------------|
+        // |     bytes32     |     bytes32    |     bytes32    |
+        let mut batch_header: Vec<u8> = Vec::with_capacity(96);
+        batch_header.extend_from_slice(&batch_info.data_hash().0);
+        batch_header.extend_from_slice(&versioned_hash.0);
+        batch_header.extend_from_slice(&batch_info.sequencer_root().0);
+        let mut batch_file = File::create(format!("{}/batch_header.data", proof_dir)).unwrap();
+        batch_file.write_all(&batch_header[..]).expect("failed to batch_header");
+        true
+    } else {
+        let e = verify_result.unwrap_err();
+        let error_data = serde_json::json!({
+            "error_code": "EVM_EXECUTE_NOT_EXPECTED",
+            "error_msg": e.to_string()
+        });
+        let mut batch_file = File::create(format!("{}/execute_result.json", proof_dir)).unwrap();
+        batch_file
+            .write_all(serde_json::to_string_pretty(&error_data).unwrap().as_bytes())
+            .expect("failed to write error");
+        log::error!("EVM verification failed for batch {}: {}", batch_index, e);
+        false
+    }
 }
 
 fn save_proof(batch_index: u64, proof: EvmProofFixture) {
@@ -191,3 +210,19 @@ fn save_trace(batch_index: u64, chunk_traces: &Vec<BlockTrace>) {
     serde_json::to_writer_pretty(writer, &chunk_traces).unwrap();
     log::info!("chunk_traces of batch_index = {:#?} saved", batch_index);
 }
+
+#[test]
+fn test_save_execute() {
+    let batch_index = 102u64;
+
+    let mut blocks = load_trace("../../testdata/viridian/eip7702_traces.json");
+    println!("blocks.len(): {:?}", blocks.len());
+    let traces = blocks.first_mut().unwrap();
+
+    if !save_batch_header(traces, batch_index) {
+        save_trace(batch_index, traces);
+        println!("save_batch_header error");
+    } else {
+        println!("save_batch_header success");
+    }
+}

prover/bin/host/src/lib.rs

@@ -224,6 +224,31 @@ async fn query_proof(batch_index: String) -> ProveResult {
             .unwrap_or("nothing")
             .ends_with(format!("batch_{}", batch_index.trim()).as_str())
         {
+            // execute_result
+            let prove_result_path = path.join("execute_result.json");
+            if prove_result_path.exists() {
+                match fs::File::open(prove_result_path) {
+                    Ok(file) => {
+                        let reader = BufReader::new(file);
+                        let prove_result: serde_json::Value =
+                            serde_json::from_reader(reader).unwrap_or_default();
+                        if let Some(error_code) = prove_result.get("error_code") {
+                            result.error_code = error_code.as_str().unwrap_or("").to_string();
+                        }
+                        if let Some(error_msg) = prove_result.get("error_msg") {
+                            result.error_msg = error_msg.as_str().unwrap_or("").to_string();
+                        }
+                    }
+                    Err(e) => {
+                        log::error!("Failed to load prove_result: {:#?}", e);
+                        result.error_msg = String::from("Failed to load prove_result");
+                    }
+                }
+            }
+            if !result.error_code.is_empty() {
+                return result;
+            }
+
             //pi_batch_agg.data
             let proof_path = path.join("plonk_proof.json");
             if !proof_path.exists() {
@@ -261,7 +286,7 @@ async fn query_proof(batch_index: String) -> ProveResult {
             break;
         }
     }
-    if result.proof_data.is_empty() {
+    if result.proof_data.is_empty() && result.error_msg.is_empty() {
         result.error_msg = String::from("No proof was found");
     }
     result

prover/bin/server/src/queue.rs

@@ -72,7 +72,7 @@ async fn main() {
     );
 
     loop {
-        sleep(Duration::from_secs(12)).await;
+        sleep(Duration::from_secs(30)).await;
         // Sync & Prove
         let result = match batch_syncer.sync_batch().await {
             Ok(Some(batch)) => shadow_prover.prove(batch).await,

prover/bin/server/src/server.rs

@@ -110,6 +110,10 @@ async fn handle_with_prover<T, P, N>(
 
         // Query existing proof
         if let Some(prove_result) = query_proof(batch_index).await {
+            if !prove_result.error_code.is_empty() {
+                log::error!("query proof and prove state error, batch_index: {:?}, prove_result.error_code: {:?}, prove_result.error_msg: {:?}", batch_index, prove_result.error_code, prove_result.error_msg);
+                break;
+            }
             if !prove_result.proof_data.is_empty() {
                 log::info!("query proof and prove state: {:?}", batch_index);
                 prove_state(batch_index, l1_shadow_rollup).await;
@@ -160,6 +164,10 @@ async fn handle_with_prover<T, P, N>(
             max_waiting_time -= 300; // Query results every 5 minutes.
             match query_proof(batch_index).await {
                 Some(prove_result) => {
+                    if !prove_result.error_code.is_empty() {
+                        log::error!("query proof and prove state error, batch_index: {:?}, prove_result.error_code: {:?}, prove_result.error_msg: {:?}", batch_index, prove_result.error_code, prove_result.error_msg);
+                        return;
+                    }
                     log::debug!("query proof and prove state: {:#?}", batch_index);
                     if !prove_result.proof_data.is_empty() {
                         prove_state(batch_index, l1_shadow_rollup).await;