batch proof load/save

Author: lispc

Diff for: Cargo.lock

@@ -87,19 +87,28 @@ impl Prover {
             .or_else(|| self.raw_vk_bundle.clone())
     }
 
-    // Return the EVM proof for verification.
+    // Return the batch proof for a BatchProvingTask.
+    // TODO: should we rename the method name to `load_or_gen_batch_proof`?
     pub fn gen_batch_proof(
         &mut self,
         batch: BatchProvingTask,
         name: Option<&str>,
         output_dir: Option<&str>,
     ) -> Result<BatchProof> {
         let name = name.map_or_else(|| batch.identifier(), |name| name.to_string());
+        log::info!("gen_batch_proof with identifier {name}");
+
+        if let Some(output_dir) = output_dir {
+            if let Ok(batch_proof) = BatchProof::from_json_file(output_dir, &name) {
+                log::info!("batch proof loaded from {output_dir}");
+                return Ok(batch_proof);
+            }
+        }
 
         let (layer3_snark, batch_hash) =
             self.load_or_gen_last_agg_snark::<MAX_AGG_SNARKS>(&name, batch, output_dir)?;
 
-        // Load or generate final compression thin EVM proof (layer-4).
+        // Load or generate batch compression thin proof (layer-4).
         let layer4_snark = self.prover_impl.load_or_gen_comp_snark(
             &name,
             LayerId::Layer4.id(),
@@ -108,14 +117,16 @@ impl Prover {
             layer3_snark,
             output_dir,
         )?;
-        log::info!("Got final compression thin EVM proof (layer-4): {name}");
+        log::info!("Got batch compression thin proof (layer-4): {name}");
 
         self.check_batch_vk();
 
         let pk = self.prover_impl.pk(LayerId::Layer4.id());
         let batch_proof = BatchProof::new(layer4_snark, pk, batch_hash)?;
         if let Some(output_dir) = output_dir {
-            batch_proof.dump(output_dir, "agg")?;
+            batch_proof.dump_vk(output_dir, "agg")?;
+            batch_proof.dump(output_dir, &name)?;
+            log::debug!("batch proof dumped to {output_dir}");
         }
 
         Ok(batch_proof)

Diff for: prover/src/aggregator/prover.rs

@@ -33,7 +33,7 @@ impl<C: CircuitExt<Fr>> Verifier<C> {
     }
 
     pub fn from_params_dir(params_dir: &str, degree: u32, vk: &[u8]) -> Self {
-        let params = load_params(params_dir, degree, None).unwrap();
+        let params = load_params(params_dir, degree, None).expect("load params failed");
 
         Self::from_params(params, vk)
     }

Diff for: prover/src/common/verifier.rs

@@ -102,7 +102,7 @@ pub fn serialize_vk(vk: &VerifyingKey<G1Affine>) -> Vec<u8> {
 
 pub fn deserialize_vk<C: Circuit<Fr>>(raw_vk: &[u8]) -> VerifyingKey<G1Affine> {
     VerifyingKey::<G1Affine>::read::<_, C>(&mut Cursor::new(raw_vk), SerdeFormat::Processed)
-        .unwrap()
+        .unwrap_or_else(|_| panic!("failed to deserialize vk with len {}", raw_vk.len()))
 }
 
 pub fn write_snark(file_path: &str, snark: &Snark) {

Diff for: prover/src/io.rs

@@ -45,11 +45,18 @@ impl BatchProof {
         from_json_file(dir, &dump_filename(name))
     }
 
-    pub fn dump(&self, dir: &str, name: &str) -> Result<()> {
+    pub fn dump_vk(&self, dir: &str, name: &str) -> Result<()> {
         let filename = dump_filename(name);
+        if self.proof.vk.is_empty() {
+            log::warn!("batch proof vk is empty, skip dumping");
+        } else {
+            dump_vk(dir, &filename, &self.proof.vk)
+        }
+        Ok(())
+    }
 
-        dump_vk(dir, &filename, &self.proof.vk);
-
+    pub fn dump(&self, dir: &str, name: &str) -> Result<()> {
+        let filename = dump_filename(name);
         dump_as_json(dir, &filename, &self)
     }
 }