Inserted extension node

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,6 +19,8 @@ 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 = []

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,126 @@
+//! 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,
+            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);
+    }
+}

gadgets/src/util.rs

@@ -138,6 +138,63 @@ pub mod select {
     }
 }
 
+/// Returns the power of number using straigtforward multiplications
+pub mod pow {
+    use crate::util::Expr;
+    use eth_types::Field;
+    use halo2_proofs::plonk::Expression;
+
+    use super::Scalar;
+
+    /// Returns the `when_true` expression when the selector is true, else
+    /// returns the `when_false` expression.
+    pub fn expr<F: Field>(value: Expression<F>, exponent: usize) -> Expression<F> {
+        let mut result = 1.expr();
+        for _ in 0..exponent {
+            result = result * value.expr();
+        }
+        result
+    }
+
+    /// Returns the `when_true` value when the selector is true, else returns
+    /// the `when_false` value.
+    pub fn value<F: Field>(value: F, exponent: usize) -> F {
+        let mut result = 1.scalar();
+        for _ in 0..exponent {
+            result *= value;
+        }
+        result
+    }
+}
+
+/// Trait that implements functionality to get a scalar from
+/// commonly used types.
+pub trait Scalar<F: Field> {
+    /// Returns a scalar for the type.
+    fn scalar(&self) -> F;
+}
+
+/// Implementation trait `Scalar` for type able to be casted to u64
+#[macro_export]
+macro_rules! impl_scalar {
+    ($type:ty) => {
+        impl<F: eth_types::Field> $crate::util::Scalar<F> for $type {
+            #[inline]
+            fn scalar(&self) -> F {
+                F::from(*self as u64)
+            }
+        }
+    };
+    ($type:ty, $method:path) => {
+        impl<F: eth_types::Field> $crate::util::Scalar<F> for $type {
+            #[inline]
+            fn scalar(&self) -> F {
+                F::from($method(self) as u64)
+            }
+        }
+    };
+}
+
 /// Trait that implements functionality to get a constant expression from
 /// commonly used types.
 pub trait Expr<F: Field> {
@@ -149,6 +206,7 @@ pub trait Expr<F: Field> {
 #[macro_export]
 macro_rules! impl_expr {
     ($type:ty) => {
+        $crate::impl_scalar!($type);
         impl<F: eth_types::Field> $crate::util::Expr<F> for $type {
             #[inline]
             fn expr(&self) -> Expression<F> {
@@ -157,6 +215,7 @@ macro_rules! impl_expr {
         }
     };
     ($type:ty, $method:path) => {
+        $crate::impl_scalar!($type, $method);
         impl<F: eth_types::Field> $crate::util::Expr<F> for $type {
             #[inline]
             fn expr(&self) -> Expression<F> {
@@ -170,28 +229,41 @@ impl_expr!(bool);
 impl_expr!(u8);
 impl_expr!(u64);
 impl_expr!(usize);
+impl_expr!(isize);
 impl_expr!(OpcodeId, OpcodeId::as_u8);
 
-impl<F: Field> Expr<F> for Expression<F> {
+impl<F: Field> Scalar<F> for i32 {
+    #[inline]
+    fn scalar(&self) -> F {
+        F::from(self.unsigned_abs() as u64) * if self.is_negative() { -F::ONE } else { F::ONE }
+    }
+}
+
+impl<F: Field> Scalar<F> for &F {
+    #[inline]
+    fn scalar(&self) -> F {
+        *(*self)
+    }
+}
+
+impl<F: Field> Expr<F> for i32 {
     #[inline]
     fn expr(&self) -> Expression<F> {
-        self.clone()
+        Expression::Constant(self.scalar())
     }
 }
 
-impl<F: Field> Expr<F> for &Expression<F> {
+impl<F: Field> Expr<F> for Expression<F> {
     #[inline]
     fn expr(&self) -> Expression<F> {
-        (*self).clone()
+        self.clone()
     }
 }
 
-impl<F: Field> Expr<F> for i32 {
+impl<F: Field> Expr<F> for &Expression<F> {
     #[inline]
     fn expr(&self) -> Expression<F> {
-        Expression::Constant(
-            F::from(self.unsigned_abs() as u64) * if self.is_negative() { -F::ONE } else { F::ONE },
-        )
+        (*self).clone()
     }
 }
 

zkevm-circuits/Cargo.toml

@@ -35,6 +35,9 @@ num-bigint = { version = "0.4" }
 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"] }
@@ -44,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/bytecode_circuit/dev.rs

@@ -51,6 +51,7 @@ impl<F: Field> Circuit<F> for BytecodeCircuit<F> {
             &mut layouter,
             self.bytecodes.iter().map(|b| &b.bytes),
             &challenges,
+            true,
         )?;
         self.synthesize_sub(&config, &challenges, &mut layouter)?;
         Ok(())

zkevm-circuits/src/circuit_tools.rs

@@ -0,0 +1,8 @@
+//! Circuit utilities
+#![allow(missing_docs)]
+#[macro_use]
+pub mod constraint_builder;
+pub mod cached_region;
+pub mod cell_manager;
+pub mod gadgets;
+pub mod memory;