Clean up code.

Makefile

@@ -39,7 +39,7 @@ test-inner-prove:
 	@cargo test --features prove_verify --release test_inner_prove_verify
 
 test-chunk-prove:
-	@cargo test --features prove_verify --release test_comp_prove_verify
+	@cargo test --features prove_verify --release test_chunk_prove_verify
 
 test-agg-prove:
 	@cargo test --features prove_verify --release test_agg_prove_verify

README.md

@@ -28,8 +28,6 @@ make download-setup -e degree=DEGREE params_dir=PARAMS_DIR
 
 `make test-chunk-prove` and `make test-agg-prove` are the main testing entries for multi-level circuit constraint system of scroll-prover. Developers could understand how the system works by reading the codes of these tests.
 
-Besides it, `make test-inner-prove` could be used to test the first-level circuit, and `make-comp-prove` could be used to test two-layers compression circuits.
-
 ### Binaries
 
 This repository is designed to be used as a Rust crate, rather than a standalone running process. However, you can still use the following command to run binaries locally.

bin/src/verify.rs

@@ -20,12 +20,12 @@ fn main() {
 
     let args = Args::parse();
     let chunk_vk = read_from_file(&args.vk_path);
-    let v = Verifier::from_params_dir(&args.params_path, Some(chunk_vk));
+    let v = Verifier::from_params_dir(&args.params_path, &chunk_vk);
 
     let proof_path = PathBuf::from("proof_data").join("chunk_full_proof.json");
     let proof_vec = read_from_file(&proof_path.to_string_lossy());
     let proof = serde_json::from_slice::<Proof>(proof_vec.as_slice()).unwrap();
-    let verified = v.verify_chunk_proof(proof).is_ok();
+    let verified = v.verify_chunk_proof(proof);
     info!("verify agg proof: {}", verified)
 }
 

ffi/src/aggregator.rs

@@ -1,9 +1,9 @@
 use crate::utils::{c_char_to_str, c_char_to_vec, vec_to_c_char, OUTPUT_DIR};
 use libc::c_char;
 use prover::{
-    aggregator::{ChunkHash, Prover, Verifier},
+    aggregator::{Prover, Verifier},
     utils::init_env_and_log,
-    Proof,
+    ChunkHash, Proof,
 };
 use std::{cell::OnceCell, fs::File, io::Read};
 
@@ -32,7 +32,7 @@ pub unsafe extern "C" fn init_agg_verifier(params_dir: *const c_char, vk_path: *
     f.read_to_end(&mut vk).unwrap();
 
     let params_dir = c_char_to_str(params_dir);
-    let verifier = Box::new(Verifier::from_params_dir(params_dir, Some(vk)));
+    let verifier = Box::new(Verifier::from_params_dir(params_dir, &vk));
 
     AGG_VERIFIER = Some(Box::leak(verifier));
 }
@@ -71,6 +71,6 @@ pub unsafe extern "C" fn verify_agg_proof(proof: *const c_char) -> c_char {
     let proof = c_char_to_vec(proof);
     let proof = serde_json::from_slice::<Proof>(proof.as_slice()).unwrap();
 
-    let verified = AGG_VERIFIER.unwrap().verify_agg_proof(proof).is_ok();
+    let verified = AGG_VERIFIER.unwrap().verify_agg_proof(proof);
     verified as c_char
 }

ffi/src/zkevm.rs

@@ -32,7 +32,7 @@ pub unsafe extern "C" fn init_zkevm_verifier(params_dir: *const c_char, vk_path:
     f.read_to_end(&mut vk).unwrap();
 
     let params_dir = c_char_to_str(params_dir);
-    let verifier = Box::new(Verifier::from_params_dir(params_dir, Some(vk)));
+    let verifier = Box::new(Verifier::from_params_dir(params_dir, &vk));
 
     ZKEVM_VERIFIER = Some(Box::leak(verifier));
 }
@@ -75,6 +75,6 @@ pub unsafe extern "C" fn verify_chunk_proof(proof: *const c_char) -> c_char {
     let proof = c_char_to_vec(proof);
     let proof = serde_json::from_slice::<Proof>(proof.as_slice()).unwrap();
 
-    let verified = ZKEVM_VERIFIER.unwrap().verify_chunk_proof(proof).is_ok();
+    let verified = ZKEVM_VERIFIER.unwrap().verify_chunk_proof(proof);
     verified as c_char
 }

prover/src/aggregator.rs

@@ -2,4 +2,3 @@ mod prover;
 mod verifier;
 
 pub use self::{prover::Prover, verifier::Verifier};
-pub use aggregator::ChunkHash;

prover/src/aggregator/verifier.rs

@@ -1,6 +1,5 @@
 use crate::{common, config::LAYER4_DEGREE, Proof};
 use aggregator::CompressionCircuit;
-use anyhow::Result;
 use halo2_proofs::{
     halo2curves::bn256::{Bn256, G1Affine},
     plonk::VerifyingKey,
@@ -19,19 +18,19 @@ impl From<common::Verifier> for Verifier {
 }
 
 impl Verifier {
-    pub fn new(params: ParamsKZG<Bn256>, vk: Option<VerifyingKey<G1Affine>>) -> Self {
+    pub fn new(params: ParamsKZG<Bn256>, vk: VerifyingKey<G1Affine>) -> Self {
         common::Verifier::new(params, vk).into()
     }
 
-    pub fn from_params(params: ParamsKZG<Bn256>, raw_vk: Option<Vec<u8>>) -> Self {
+    pub fn from_params(params: ParamsKZG<Bn256>, raw_vk: &[u8]) -> Self {
         common::Verifier::from_params(params, raw_vk).into()
     }
 
-    pub fn from_params_dir(params_dir: &str, vk: Option<Vec<u8>>) -> Self {
+    pub fn from_params_dir(params_dir: &str, vk: &[u8]) -> Self {
         common::Verifier::from_params_dir(params_dir, *LAYER4_DEGREE, vk).into()
     }
 
-    pub fn verify_agg_proof(&self, proof: Proof) -> Result<bool> {
+    pub fn verify_agg_proof(&self, proof: Proof) -> bool {
         self.inner.verify_proof::<CompressionCircuit>(proof)
     }
 }

prover/src/common/prover/evm.rs

@@ -2,7 +2,9 @@ use super::Prover;
 use crate::{utils::gen_rng, Proof};
 use aggregator::CompressionCircuit;
 use anyhow::{anyhow, Result};
-use snark_verifier_sdk::Snark;
+use halo2_proofs::halo2curves::bn256::Fr;
+use rand::Rng;
+use snark_verifier_sdk::{gen_evm_proof_shplonk, CircuitExt, Snark};
 use std::{env::set_var, path::PathBuf};
 
 impl Prover {
@@ -29,4 +31,20 @@ impl Prover {
 
         result
     }
+
+    fn gen_evm_proof<C: CircuitExt<Fr>>(
+        &mut self,
+        id: &str,
+        degree: u32,
+        rng: &mut (impl Rng + Send),
+        circuit: C,
+    ) -> Result<Proof> {
+        let (params, pk) = self.params_and_pk(id, &circuit, degree)?;
+
+        let instances = circuit.instances();
+        let num_instance = circuit.num_instance();
+        let proof = gen_evm_proof_shplonk(params, pk, circuit, instances.clone(), rng);
+
+        Proof::new(pk, proof, &instances, Some(num_instance))
+    }
 }

prover/src/common/prover/inner.rs

@@ -7,12 +7,14 @@ use crate::{
 };
 use anyhow::Result;
 use halo2_proofs::halo2curves::bn256::Fr;
+use rand::Rng;
 use snark_verifier_sdk::{gen_snark_shplonk, Snark};
 use zkevm_circuits::evm_circuit::witness::Block;
 
 impl Prover {
     pub fn gen_inner_snark<C: TargetCircuit>(
         &mut self,
+        mut rng: impl Rng + Send,
         witness_block: &Block<Fr>,
     ) -> Result<Snark> {
         log::info!(
@@ -23,7 +25,7 @@ impl Prover {
         let (circuit, _instance) = C::from_witness_block(witness_block)?;
         let (params, pk) =
             self.params_and_pk(&C::name(), &C::dummy_inner_circuit(), *INNER_DEGREE)?;
-        let snark = gen_snark_shplonk(params, pk, circuit, &mut gen_rng(), None::<String>);
+        let snark = gen_snark_shplonk(params, pk, circuit, &mut rng, None::<String>);
 
         Ok(snark)
     }
@@ -43,7 +45,8 @@ impl Prover {
         match output_dir.and_then(|_| load_snark(&file_path).ok().flatten()) {
             Some(snark) => Ok(snark),
             None => {
-                let result = self.gen_inner_snark::<SuperCircuit>(&witness_block);
+                let rng = gen_rng();
+                let result = self.gen_inner_snark::<SuperCircuit>(rng, &witness_block);
                 if let (Some(_), Ok(snark)) = (output_dir, &result) {
                     write_snark(&file_path, snark);
                 }

prover/src/common/prover/padding.rs

@@ -6,15 +6,20 @@ use crate::{
 };
 use aggregator::{ChunkHash, DummyChunkHashCircuit};
 use anyhow::Result;
+use rand::Rng;
 use snark_verifier_sdk::{gen_snark_shplonk, Snark};
 
 impl Prover {
-    pub fn gen_padding_snark(&mut self, last_real_chunk_hash: &ChunkHash) -> Result<Snark> {
+    pub fn gen_padding_snark(
+        &mut self,
+        mut rng: impl Rng + Send,
+        last_real_chunk_hash: &ChunkHash,
+    ) -> Result<Snark> {
         let chunk_hash = ChunkHash::dummy_chunk_hash(last_real_chunk_hash);
         let circuit = DummyChunkHashCircuit::new(chunk_hash);
 
         let (params, pk) = self.params_and_pk("padding", &circuit, *INNER_DEGREE)?;
-        let snark = gen_snark_shplonk(params, pk, circuit, &mut gen_rng(), None::<String>);
+        let snark = gen_snark_shplonk(params, pk, circuit, &mut rng, None::<String>);
 
         Ok(snark)
     }
@@ -34,7 +39,8 @@ impl Prover {
         match output_dir.and_then(|_| load_snark(&file_path).ok().flatten()) {
             Some(snark) => Ok(snark),
             None => {
-                let result = self.gen_padding_snark(last_real_chunk_hash);
+                let rng = gen_rng();
+                let result = self.gen_padding_snark(rng, last_real_chunk_hash);
                 if let (Some(_), Ok(snark)) = (output_dir, &result) {
                     write_snark(&file_path, snark);
                 }

prover/src/common/prover/utils.rs

@@ -1,13 +1,12 @@
 use super::Prover;
-use crate::Proof;
 use anyhow::Result;
 use halo2_proofs::{
     halo2curves::bn256::{Bn256, Fr, G1Affine},
     plonk::{keygen_pk2, Circuit, ProvingKey},
     poly::{commitment::Params, kzg::commitment::ParamsKZG},
 };
 use rand::Rng;
-use snark_verifier_sdk::{gen_evm_proof_shplonk, gen_snark_shplonk, CircuitExt, Snark};
+use snark_verifier_sdk::{gen_snark_shplonk, CircuitExt, Snark};
 
 impl Prover {
     pub fn gen_snark<C: CircuitExt<Fr>>(
@@ -22,22 +21,6 @@ impl Prover {
         Ok(gen_snark_shplonk(params, pk, circuit, rng, None::<String>))
     }
 
-    pub fn gen_evm_proof<C: CircuitExt<Fr>>(
-        &mut self,
-        id: &str,
-        degree: u32,
-        rng: &mut (impl Rng + Send),
-        circuit: C,
-    ) -> Result<Proof> {
-        let (params, pk) = self.params_and_pk(id, &circuit, degree)?;
-
-        let instances = circuit.instances();
-        let num_instance = circuit.num_instance();
-        let proof = gen_evm_proof_shplonk(params, pk, circuit, instances.clone(), rng);
-
-        Proof::new(pk, proof, &instances, Some(num_instance))
-    }
-
     pub fn params(&mut self, degree: u32) -> &ParamsKZG<Bn256> {
         if self.params_map.contains_key(&degree) {
             return &self.params_map[&degree];

prover/src/common/verifier.rs

@@ -1,6 +1,5 @@
 use crate::{utils::load_params, Proof};
 use aggregator::CompressionCircuit;
-use anyhow::Result;
 use halo2_proofs::{
     halo2curves::bn256::{Bn256, Fr, G1Affine},
     plonk::VerifyingKey,
@@ -16,42 +15,31 @@ mod utils;
 #[derive(Debug)]
 pub struct Verifier {
     params: ParamsKZG<Bn256>,
-    vk: Option<VerifyingKey<G1Affine>>,
+    vk: VerifyingKey<G1Affine>,
 }
 
 impl Verifier {
-    pub fn new(params: ParamsKZG<Bn256>, vk: Option<VerifyingKey<G1Affine>>) -> Self {
+    pub fn new(params: ParamsKZG<Bn256>, vk: VerifyingKey<G1Affine>) -> Self {
         Self { params, vk }
     }
 
-    pub fn from_params(params: ParamsKZG<Bn256>, raw_vk: Option<Vec<u8>>) -> Self {
-        let vk = raw_vk.as_ref().map(|k| {
-            VerifyingKey::<G1Affine>::read::<_, CompressionCircuit>(
-                &mut Cursor::new(&k),
-                SerdeFormat::Processed,
-            )
-            .unwrap()
-        });
+    pub fn from_params(params: ParamsKZG<Bn256>, raw_vk: &[u8]) -> Self {
+        let vk = VerifyingKey::<G1Affine>::read::<_, CompressionCircuit>(
+            &mut Cursor::new(raw_vk),
+            SerdeFormat::Processed,
+        )
+        .unwrap();
 
         Self { params, vk }
     }
 
-    pub fn from_params_dir(params_dir: &str, degree: u32, vk: Option<Vec<u8>>) -> Self {
+    pub fn from_params_dir(params_dir: &str, degree: u32, vk: &[u8]) -> Self {
         let params = load_params(params_dir, degree, None).unwrap();
 
         Self::from_params(params, vk)
     }
 
-    pub fn verify_proof<C: CircuitExt<Fr>>(&self, proof: Proof) -> Result<bool> {
-        let vk = match &self.vk {
-            Some(vk) => vk,
-            None => panic!("Verification key is missing"),
-        };
-
-        Ok(verify_snark_shplonk::<C>(
-            &self.params,
-            proof.to_snark(),
-            vk,
-        ))
+    pub fn verify_proof<C: CircuitExt<Fr>>(&self, proof: Proof) -> bool {
+        verify_snark_shplonk::<C>(&self.params, proof.to_snark(), &self.vk)
     }
 }

prover/src/common/verifier/evm.rs

@@ -12,11 +12,6 @@ use std::{path::PathBuf, str::FromStr};
 impl Verifier {
     // Should panic if failed to verify.
     pub fn evm_verify<C: CircuitExt<Fr>>(&self, proof: &Proof, output_dir: &str) {
-        let vk = match &self.vk {
-            Some(vk) => vk,
-            None => panic!("Verification key is missing"),
-        };
-
         let num_instance = proof.num_instance().expect("Not a EVM proof").clone();
 
         let mut yul_file_path = PathBuf::from_str(output_dir).unwrap();
@@ -25,7 +20,7 @@ impl Verifier {
         // Generate deployment code and dump YUL file.
         let deployment_code = gen_evm_verifier::<C, Kzg<Bn256, Bdfg21>>(
             &self.params,
-            vk,
+            &self.vk,
             num_instance,
             Some(yul_file_path.as_path()),
         );

prover/src/common/verifier/utils.rs

@@ -10,7 +10,7 @@ impl Verifier {
         &self.params
     }
 
-    pub fn vk(&self) -> Option<&VerifyingKey<G1Affine>> {
-        self.vk.as_ref()
+    pub fn vk(&self) -> &VerifyingKey<G1Affine> {
+        &self.vk
     }
 }

prover/src/config.rs

@@ -18,7 +18,7 @@ pub static ZKEVM_DEGREES: Lazy<Vec<u32>> = Lazy::new(|| {
 
 pub static AGG_DEGREES: Lazy<Vec<u32>> = Lazy::new(|| {
     Vec::from_iter(HashSet::from([
-        *LAYER2_DEGREE,
+        *LAYER2_DEGREE, // For padding
         *LAYER3_DEGREE,
         *LAYER4_DEGREE,
     ]))

prover/src/proof.rs

@@ -2,7 +2,7 @@ use crate::io::{deserialize_fr_matrix, serialize_fr_matrix, serialize_vk, write_
 use anyhow::Result;
 use halo2_proofs::{
     halo2curves::bn256::{Fr, G1Affine},
-    plonk::ProvingKey,
+    plonk::{Circuit, ProvingKey, VerifyingKey},
     SerdeFormat,
 };
 use serde_derive::{Deserialize, Serialize};
@@ -16,6 +16,7 @@ use snark_verifier::{
 use snark_verifier_sdk::Snark;
 use std::{
     fs::File,
+    io::Cursor,
     path::{Path, PathBuf},
 };
 use types::base64;
@@ -104,6 +105,11 @@ impl Proof {
         &self.proof
     }
 
+    pub fn vk<C: Circuit<Fr>>(&self) -> VerifyingKey<G1Affine> {
+        VerifyingKey::<G1Affine>::read::<_, C>(&mut Cursor::new(&self.vk), SerdeFormat::Processed)
+            .unwrap()
+    }
+
     pub fn instances(&self) -> Vec<Vec<Fr>> {
         let buf: Vec<Vec<Vec<_>>> = serde_json::from_reader(self.instances.as_slice()).unwrap();