Circuit tools tests

Makefile

@@ -45,6 +45,9 @@ evm_bench: ## Run Evm Circuit benchmarks
 state_bench: ## Run State Circuit benchmarks
 	@cargo test --profile bench bench_state_circuit_prover -p circuit-benchmarks --features benches  -- --nocapture
 
+mpt_bench: ## Run MPT Circuit benchmarks
+	@cargo test --profile bench bench_mpt_circuit_prover -p circuit-benchmarks --features benches  -- --nocapture
+
 packed_multi_keccak_bench: ## Run Packed Multi Keccak Circuit benchmarks
 	@cargo test --profile bench bench_packed_multi_keccak_circuit_prover -p circuit-benchmarks --features benches  -- --nocapture
 

README.md

@@ -17,6 +17,7 @@ to use for your circuit in the bench process.
 -   Keccak Circuit prover benches. -> `DEGREE=16 make packed_multi_keccak_bench`
 -   EVM Circuit prover benches. -> `DEGREE=18 make evm_bench`.
 -   State Circuit prover benches. -> `DEGREE=18 make state_bench`
+-   MPT Circuit prover benches. -> `DEGREE=14 make mpt_bench`
 
 You can also run all benchmarks by running: `make circuit_benches DEGREE=18`.
 

circuit-benchmarks/Cargo.toml

@@ -19,7 +19,9 @@ env_logger = "0.9"
 ethers-signers = "0.17.0"
 mock = { path="../mock" }
 rand_chacha = "0.3"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 
 [features]
-default = []
+default = ["benches"]
 benches = []

circuit-benchmarks/src/lib.rs

@@ -35,3 +35,7 @@ pub mod exp_circuit;
 #[cfg(test)]
 #[cfg(feature = "benches")]
 pub mod constants;
+
+#[cfg(test)]
+#[cfg(feature = "benches")]
+pub mod mpt_circuit;

circuit-benchmarks/src/mpt_circuit.rs

@@ -0,0 +1,127 @@
+//! MPT circuit benchmarks
+
+#[cfg(test)]
+mod tests {
+    use ark_std::{end_timer, start_timer};
+    use halo2_proofs::{
+        halo2curves::bn256::{Bn256, Fr, G1Affine},
+        plonk::{create_proof, keygen_pk, keygen_vk, verify_proof},
+        poly::{
+            commitment::ParamsProver,
+            kzg::{
+                commitment::{KZGCommitmentScheme, ParamsKZG, ParamsVerifierKZG},
+                multiopen::{ProverSHPLONK, VerifierSHPLONK},
+                strategy::SingleStrategy,
+            },
+        },
+        transcript::{
+            Blake2bRead, Blake2bWrite, Challenge255, TranscriptReadBuffer, TranscriptWriterBuffer,
+        },
+    };
+    use rand::SeedableRng;
+    use rand_xorshift::XorShiftRng;
+    use std::env::var;
+    use zkevm_circuits::mpt_circuit::{witness_row::Node, MPTCircuit};
+
+    #[cfg_attr(not(feature = "benches"), ignore)]
+    #[test]
+    fn bench_mpt_circuit_prover() {
+        let setup_prfx = crate::constants::SETUP_PREFIX;
+        let proof_gen_prfx = crate::constants::PROOFGEN_PREFIX;
+        let proof_ver_prfx = crate::constants::PROOFVER_PREFIX;
+        // Unique string used by bench results module for parsing the result
+        const BENCHMARK_ID: &str = "MPT Circuit";
+
+        let degree: u32 = var("DEGREE")
+            .expect("No DEGREE env var was provided")
+            .parse()
+            .expect("Cannot parse DEGREE env var as u32");
+
+        let path = "../zkevm-circuits/src/mpt_circuit/tests/UpdateOneLevel.json";
+        let file = std::fs::File::open(path);
+        let reader = std::io::BufReader::new(file.unwrap());
+
+        let randomness = Fr::from(123456u64);
+        let nodes: Vec<Node> = serde_json::from_reader(reader).unwrap();
+
+        let mut keccak_data = vec![];
+        for node in nodes.iter() {
+            for k in node.keccak_data.iter() {
+                keccak_data.push(k.clone());
+            }
+        }
+
+        let circuit = MPTCircuit::<Fr> {
+            nodes,
+            keccak_data,
+            degree: degree as usize,
+            randomness,
+        };
+
+        // Initialize the polynomial commitment parameters
+        let mut rng = XorShiftRng::from_seed([
+            0x59, 0x62, 0xbe, 0x5d, 0x76, 0x3d, 0x31, 0x8d, 0x17, 0xdb, 0x37, 0x32, 0x54, 0x06,
+            0xbc, 0xe5,
+        ]);
+
+        // Bench setup generation
+        let setup_message = format!("{} {} with degree = {}", BENCHMARK_ID, setup_prfx, degree);
+        let start1 = start_timer!(|| setup_message);
+        let general_params = ParamsKZG::<Bn256>::setup(degree, &mut rng);
+        let verifier_params: ParamsVerifierKZG<Bn256> = general_params.verifier_params().clone();
+        end_timer!(start1);
+
+        // Initialize the proving key
+        let vk = keygen_vk(&general_params, &circuit).expect("keygen_vk should not fail");
+        let pk = keygen_pk(&general_params, vk, &circuit).expect("keygen_pk should not fail");
+        // Create a proof
+        let mut transcript = Blake2bWrite::<_, G1Affine, Challenge255<_>>::init(vec![]);
+
+        // Bench proof generation time
+        let proof_message = format!(
+            "{} {} with degree = {}",
+            BENCHMARK_ID, proof_gen_prfx, degree
+        );
+        let start2 = start_timer!(|| proof_message);
+
+        create_proof::<
+            KZGCommitmentScheme<Bn256>,
+            ProverSHPLONK<'_, Bn256>,
+            Challenge255<G1Affine>,
+            XorShiftRng,
+            Blake2bWrite<Vec<u8>, G1Affine, Challenge255<G1Affine>>,
+            MPTCircuit<Fr>,
+        >(
+            &general_params,
+            &pk,
+            &[circuit],
+            &[&[]],
+            rng,
+            &mut transcript,
+        )
+        .expect("proof generation should not fail");
+        let proof = transcript.finalize();
+        end_timer!(start2);
+
+        // Bench verification time
+        let start3 = start_timer!(|| format!("{} {}", BENCHMARK_ID, proof_ver_prfx));
+        let mut verifier_transcript = Blake2bRead::<_, G1Affine, Challenge255<_>>::init(&proof[..]);
+        let strategy = SingleStrategy::new(&general_params);
+
+        verify_proof::<
+            KZGCommitmentScheme<Bn256>,
+            VerifierSHPLONK<'_, Bn256>,
+            Challenge255<G1Affine>,
+            Blake2bRead<&[u8], G1Affine, Challenge255<G1Affine>>,
+            SingleStrategy<'_, Bn256>,
+        >(
+            &verifier_params,
+            pk.get_vk(),
+            strategy,
+            &[&[]],
+            &mut verifier_transcript,
+        )
+        .expect("failed to verify bench circuit");
+        end_timer!(start3);
+    }
+}

zkevm-circuits/Cargo.toml

@@ -36,6 +36,8 @@ rand_chacha = "0.3"
 snark-verifier = { git = "https://github.com/privacy-scaling-explorations/snark-verifier", tag = "v2023_04_20", default-features = false, features = ["loader_halo2", "system_halo2"] }
 cli-table = { version = "0.4", optional = true }
 num_enum = "0.5.7"
+serde = { version = "1.0.130", features = ["derive"] }
+serde_json = "1.0.78"
 
 [dev-dependencies]
 bus-mapping = { path = "../bus-mapping", features = ["test"] }
@@ -45,8 +47,6 @@ hex = "0.4.3"
 itertools = "0.10.1"
 mock = { path = "../mock" }
 pretty_assertions = "1.0.0"
-serde = { version = "1.0.130", features = ["derive"] }
-serde_json = "1.0.78"
 
 [features]
 default = []

zkevm-circuits/src/circuit_tools.rs

@@ -6,3 +6,4 @@ pub mod cached_region;
 pub mod cell_manager;
 pub mod gadgets;
 pub mod memory;
+mod test;

zkevm-circuits/src/circuit_tools/cached_region.rs

@@ -22,28 +22,26 @@ impl<F: Field, V: AsRef<[Value<F>]>> ChallengeSet<F> for V {
     }
 }
 
-pub struct CachedRegion<'r, 'b, F: Field, S: ChallengeSet<F>> {
+pub struct CachedRegion<'r, 'b, F: Field> {
     region: &'r mut Region<'b, F>,
     pub advice: HashMap<(usize, usize), F>,
     pub fixed: HashMap<(usize, usize), F>,
-    challenges: &'r S,
     disable_description: bool,
     regions: Vec<(usize, usize)>,
-    pub le_r: F,
-    pub be_r: F,
+    pub r: F,
+    pub keccak_r: F,
 }
 
-impl<'r, 'b, F: Field, S: ChallengeSet<F>> CachedRegion<'r, 'b, F, S> {
-    pub(crate) fn new(region: &'r mut Region<'b, F>, challenges: &'r S, le_r: F, be_r: F) -> Self {
+impl<'r, 'b, F: Field> CachedRegion<'r, 'b, F> {
+    pub(crate) fn new(region: &'r mut Region<'b, F>, r: F, keccak_r: F) -> Self {
         Self {
             region,
             advice: HashMap::new(),
             fixed: HashMap::new(),
-            challenges,
             disable_description: false,
             regions: Vec::new(),
-            le_r,
-            be_r,
+            r,
+            keccak_r,
         }
     }
 
@@ -59,14 +57,19 @@ impl<'r, 'b, F: Field, S: ChallengeSet<F>> CachedRegion<'r, 'b, F, S> {
         // Nothing to do
     }
 
-    pub(crate) fn assign_stored_expressions<C: CellType>(
+    pub(crate) fn lookup_challenge(&self) -> F {
+        self.r.clone()
+    }
+
+    pub(crate) fn assign_stored_expressions<C: CellType, S: ChallengeSet<F>>(
         &mut self,
         cb: &ConstraintBuilder<F, C>,
+        challenges: &S,
     ) -> Result<(), Error> {
         for (offset, region_id) in self.regions.clone() {
             for stored_expression in cb.get_stored_expressions(region_id).iter() {
                 // println!("stored expression: {}", stored_expression.name);
-                stored_expression.assign(self, offset)?;
+                stored_expression.assign(self, challenges, offset)?;
             }
         }
         Ok(())
@@ -127,7 +130,12 @@ impl<'r, 'b, F: Field, S: ChallengeSet<F>> CachedRegion<'r, 'b, F, S> {
         A: Fn() -> AR,
         AR: Into<String>,
     {
+        // Actually set the value
         let res = self.region.assign_fixed(annotation, column, offset, &to);
+        // Cache the value
+        // Note that the `value_field` in `AssignedCell` might be `Value::unkonwn` if
+        // the column has different phase than current one, so we call to `to`
+        // again here to cache the value.
         if res.is_ok() {
             to().map(|f: VR| {
                 let existing = self
@@ -156,10 +164,6 @@ impl<'r, 'b, F: Field, S: ChallengeSet<F>> CachedRegion<'r, 'b, F, S> {
             .unwrap_or(&zero)
     }
 
-    pub fn challenges(&self) -> &S {
-        self.challenges
-    }
-
     /// Constrains a cell to have a constant value.
     ///
     /// Returns an error if the cell is in a column where equality has not been
@@ -195,7 +199,8 @@ impl<F, C: CellType> Hash for StoredExpression<F, C> {
 impl<F: Field, C: CellType> StoredExpression<F, C> {
     pub fn assign<S: ChallengeSet<F>>(
         &self,
-        region: &mut CachedRegion<'_, '_, F, S>,
+        region: &mut CachedRegion<'_, '_, F>,
+        challenges: &S,
         offset: usize,
     ) -> Result<Value<F>, Error> {
         let value = self.expr.evaluate(
@@ -216,7 +221,7 @@ impl<F: Field, C: CellType> StoredExpression<F, C> {
                 ))
             },
             &|_| unimplemented!("instance column"),
-            &|challenge| *region.challenges().indexed()[challenge.index()],
+            &|challenge| *challenges.indexed()[challenge.index()],
             &|a| -a,
             &|a, b| a + b,
             &|a, b| a * b,