In-circuit blockhash calculation

Cargo.toml

@@ -16,6 +16,9 @@ members = [
 [patch."https://github.com/privacy-scaling-explorations/halo2.git"]
 halo2_proofs = { git = "https://github.com/smtmfft/halo2.git", rev = "50ee8ad785c53232824e60b4ff6df32b69970358" }
 
+[patch.crates-io]
+ethers-core = {git = "https://github.com/ggkitsas/ethers-rs/", rev = "6059806c17fa1a1d7534044bcdbecfef869392e1"}
+
 # Definition of benchmarks profile to use.
 [profile.bench]
 opt-level = 3

circuit-benchmarks/examples/pi_circuit_integration.rs

@@ -561,6 +561,7 @@ async fn main() -> Result<(), Error> {
                         CIRCUIT_CONFIG.max_txs,
                         CIRCUIT_CONFIG.max_calldata,
                         public_data,
+                        None,
                     ),
                 );
             assert!(block.txs.len() <= CIRCUIT_CONFIG.max_txs);

circuit-benchmarks/examples/super_circuit_integration.rs

@@ -70,7 +70,7 @@ fn bench_super_circuit_prover() {
 
     block.sign(&wallets);
 
-    type TestSuperCircuit = SuperCircuit::<Fr, 4, 32, 512>;
+    type TestSuperCircuit = SuperCircuit<Fr, 4, 32, 512>;
     let (_, circuit, instance, _) = TestSuperCircuit::build(block).unwrap();
     let instance_refs: Vec<&[Fr]> = instance.iter().map(|v| &v[..]).collect();
 

circuit-benchmarks/src/pi_circuit_with_verifier.rs

@@ -144,7 +144,7 @@ use snark_verifier::{
     verifier::{self, SnarkVerifier},
 };
 use std::fs::{self, File};
-use std::{io::Cursor, io::Write, rc::Rc, time::Instant};
+use std::{io::Write, rc::Rc};
 
 type PlonkVerifier = verifier::plonk::PlonkVerifier<KzgAs<Bn256, Gwc19>>;
 
@@ -184,14 +184,13 @@ fn new_pi_circuit<const MAX_TXS: usize, const MAX_CALLDATA: usize>(
     let randomness = Fr::random(&mut rng);
     let rand_rpi = Fr::random(&mut rng);
     let public_data = generate_publicdata::<MAX_TXS, MAX_CALLDATA>();
-    let circuit = PiTestCircuit::<Fr, MAX_TXS, MAX_CALLDATA>(PiCircuit::<Fr>::new(
+    PiTestCircuit::<Fr, MAX_TXS, MAX_CALLDATA>(PiCircuit::<Fr>::new(
         MAX_TXS,
         MAX_CALLDATA,
         randomness,
         rand_rpi,
         public_data,
-    ));
-    circuit
+    ))
 }
 
 trait InstancesExport {
@@ -235,7 +234,7 @@ fn gen_evm_verifier(
 
     File::create("./PlonkEvmVerifier.sol")
         .expect("PlonkEvmVerifier.sol")
-        .write_all(&loader.yul_code().as_bytes())
+        .write_all(loader.yul_code().as_bytes())
         .expect("PlonkEvmVerifier.sol");
 
     evm::compile_yul(&loader.yul_code())

mock/src/block.rs

@@ -1,7 +1,7 @@
 //! Mock Block definition and builder related methods.
 
 use crate::{MockTransaction, MOCK_BASEFEE, MOCK_CHAIN_ID, MOCK_DIFFICULTY, MOCK_GASLIMIT};
-use eth_types::{Address, Block, Bytes, Hash, Transaction, Word, H64, U64};
+use eth_types::{Address, Block, Bytes, Hash, Transaction, Word, H256, H64, U64};
 use ethers_core::types::Bloom;
 use ethers_core::types::OtherFields;
 
@@ -32,6 +32,7 @@ pub struct MockBlock {
     size: Word,
     mix_hash: Hash,
     nonce: H64,
+    withdrawals_root: H256,
     // This field is handled here as we assume that all block txs have the same ChainId.
     // Also, the field is stored in the block_table since we don't have a chain_config
     // structure/table.
@@ -64,6 +65,7 @@ impl Default for MockBlock {
             mix_hash: Hash::zero(),
             nonce: H64::zero(),
             chain_id: *MOCK_CHAIN_ID,
+            withdrawals_root: H256::zero(),
         }
     }
 }
@@ -97,6 +99,7 @@ impl From<MockBlock> for Block<Transaction> {
             mix_hash: Some(mock.mix_hash),
             nonce: Some(mock.nonce),
             base_fee_per_gas: Some(mock.base_fee_per_gas),
+            withdrawals_root: Some(mock.withdrawals_root),
             other: OtherFields::default(),
         }
     }
@@ -127,6 +130,7 @@ impl From<MockBlock> for Block<()> {
             mix_hash: Some(mock.mix_hash),
             nonce: Some(mock.nonce),
             base_fee_per_gas: Some(mock.base_fee_per_gas),
+            withdrawals_root: Some(mock.withdrawals_root),
             other: OtherFields::default(),
         }
     }

zkevm-circuits/src/evm_circuit/util/constraint_builder.rs

@@ -142,15 +142,15 @@ impl<F: Field> ReversionInfo<F> {
 pub struct BaseConstraintBuilder<F> {
     pub constraints: Vec<(&'static str, Expression<F>)>,
     pub max_degree: usize,
-    pub condition: Option<Expression<F>>,
+    pub conditions: Vec<Expression<F>>,
 }
 
 impl<F: Field> BaseConstraintBuilder<F> {
     pub(crate) fn new(max_degree: usize) -> Self {
         BaseConstraintBuilder {
             constraints: Vec::new(),
             max_degree,
-            condition: None,
+            conditions: Vec::new(),
         }
     }
 
@@ -189,27 +189,32 @@ impl<F: Field> BaseConstraintBuilder<F> {
         condition: Expression<F>,
         constraint: impl FnOnce(&mut Self) -> R,
     ) -> R {
-        debug_assert!(
-            self.condition.is_none(),
-            "Nested condition is not supported"
-        );
-        self.condition = Some(condition);
+        self.conditions.push(condition);
         let ret = constraint(self);
-        self.condition = None;
+        self.conditions.pop();
         ret
     }
 
+    pub(crate) fn get_condition(&self) -> Option<Expression<F>> {
+        if self.conditions.is_empty() {
+            None
+        } else {
+            Some(and::expr(self.conditions.iter()))
+        }
+    }
+
+    pub(crate) fn get_condition_expr(&self) -> Expression<F> {
+        self.get_condition().unwrap_or_else(|| 1.expr())
+    }
+
     pub(crate) fn add_constraints(&mut self, constraints: Vec<(&'static str, Expression<F>)>) {
         for (name, constraint) in constraints {
             self.add_constraint(name, constraint);
         }
     }
 
     pub(crate) fn add_constraint(&mut self, name: &'static str, constraint: Expression<F>) {
-        let constraint = match &self.condition {
-            Some(condition) => condition.clone() * constraint,
-            None => constraint,
-        };
+        let constraint = self.get_condition_expr() * constraint;
         self.validate_degree(constraint.degree(), name);
         self.constraints.push((name, constraint));
     }