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

@@ -8,7 +8,7 @@
     poly::commitment::ParamsProver,
     transcript::{TranscriptReadBuffer, TranscriptWriterBuffer},
 };
 use log;
 use std::env::var;
 use zkevm_circuits::pi_circuit2::{PiCircuit, PiTestCircuit, PublicData};
 use zkevm_circuits::util::SubCircuit;
@@ -289,10 +289,10 @@
     let proof = PlonkVerifier::read_proof(&vk, &protocol, &instances, &mut transcript).unwrap();
     PlonkVerifier::verify(&vk, &protocol, &instances, &proof).unwrap();
 
     let file_path = &yul_file_name.unwrap_or(String::from("./PlonkEvmVerifier.sol"));
     File::create(file_path)
         .expect(file_path)
         .write_all(&loader.yul_code().as_bytes())
         .expect(file_path);
 
     evm::compile_yul(&loader.yul_code())
@@ -370,7 +370,7 @@
 
 pub fn write_pk(pk_file_path: &Path, pk: &ProvingKey<G1Affine>) -> Result<(), std::io::Error> {
     let dir = pk_file_path.parent().unwrap();
     fs::create_dir_all(dir).expect(format!("create {:?}", dir).as_str());
     let mut file = fs::File::create(&pk_file_path)?;
     pk.write(&mut file)
 }
@@ -561,6 +561,7 @@
                         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

@@ -1,32 +1,32 @@
 //! PI circuit benchmarks
 use ark_std::{end_timer, start_timer};
 use eth_types::geth_types::GethData;
 use eth_types::{address, bytecode, Word, U256};
 use ethers_signers::LocalWallet;
 use ethers_signers::Signer;
 use halo2_proofs::arithmetic::Field;
 use halo2_proofs::plonk::{create_proof, keygen_pk, keygen_vk, verify_proof};
 use halo2_proofs::poly::kzg::commitment::{KZGCommitmentScheme, ParamsKZG, ParamsVerifierKZG};
 use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     halo2curves::bn256::{Bn256, Fr, G1Affine},
     poly::commitment::ParamsProver,
     transcript::{
         Blake2bRead, Blake2bWrite, Challenge255, TranscriptReadBuffer, TranscriptWriterBuffer,
     },
 };
 use mock::{TestContext, MOCK_CHAIN_ID};
 use rand::SeedableRng;
 use rand_chacha::{ChaCha20Rng, ChaChaRng};
 use rand_xorshift::XorShiftRng;
 use std::collections::HashMap;
 use std::env::var;
 use std::io::Read;
 use zkevm_circuits::pi_circuit::{PiCircuit, PiTestCircuit, PublicData};
 use zkevm_circuits::super_circuit::SuperCircuit;
 use zkevm_circuits::test_util::rand_tx;
 use zkevm_circuits::util::SubCircuit;
 
 #[test]
 fn bench_super_circuit_prover() {
@@ -70,7 +70,7 @@
 
     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();
 
@@ -160,7 +160,7 @@
     verifier::{self, SnarkVerifier},
 };
 use std::fs::{self, File};
 use std::{io::Cursor, io::Write, rc::Rc, time::Instant};
 
 type PlonkVerifier = verifier::plonk::PlonkVerifier<KzgAs<Bn256, Gwc19>>;
 
@@ -234,13 +234,13 @@
 
     File::create("./PlonkEvmVerifier-super.sol")
         .expect("PlonkEvmVerifier-super.sol")
         .write_all(&loader.yul_code().as_bytes())
         .expect("PlonkEvmVerifier-super.sol");
 
     evm::compile_yul(&loader.yul_code())
 }
 
 fn evm_verify(deployment_code: Vec<u8>, instances: Vec<Vec<Fr>>, proof: Vec<u8>) {
     let calldata = encode_calldata(&instances, &proof);
 
     let success = {
@@ -262,7 +262,7 @@
     assert!(success);
 }
 
 fn gen_proof<C: Circuit<Fr>>(
     params: &ParamsKZG<Bn256>,
     pk: &ProvingKey<G1Affine>,
     circuit: C,
@@ -312,7 +312,7 @@
 
 fn write_pk(pk_file_path: &Path, pk: &ProvingKey<G1Affine>) -> Result<(), std::io::Error> {
     let dir = pk_file_path.parent().unwrap();
     fs::create_dir_all(dir).expect(format!("create {:?}", dir).as_str());
     let mut file = fs::File::create(&pk_file_path)?;
     pk.write(&mut file)
 }
@@ -352,11 +352,11 @@
 use bus_mapping::Error;
 use clap::Parser;
 use ethers_providers::Http;
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 use zkevm_circuits::evm_circuit::witness::block_convert;
 use zkevm_circuits::super_circuit::MOCK_RANDOMNESS;
 use zkevm_circuits::tx_circuit::PrimeField;
 
 #[derive(Parser, Debug)]
 #[clap(version, about)]
@@ -386,14 +386,14 @@
     };
 
     let builder = BuilderClient::new(geth_client, circuit_params.clone()).await?;
     let (builder, eth_block) = builder.gen_inputs(config.block_num).await?;
     let mut block = block_convert(&builder.block, &builder.code_db).unwrap();
     block.randomness = Fr::from(MOCK_RANDOMNESS);
     // let circuit = PiTestCircuit::<Fr, MAX_TXS,
     // MAX_CALLDATA>(PiCircuit::new_from_block(&block));
     assert!(block.txs.len() <= MAX_TXS);
 
     let (min_k, circuit, instance) =
         SuperCircuit::<_, MAX_TXS, MAX_CALLDATA, MAX_RWS>::build_from_circuit_input_builder(
             &builder,
         )
@@ -413,7 +413,7 @@
         load_circuit_pk(&key_file_name, &params, &circuit).unwrap()
     };
 
     let deployment_code = gen_evm_verifier(
         &params,
         pk.get_vk(),
         SuperCircuit::<_, MAX_TXS, MAX_CALLDATA, MAX_RWS>::num_instance(),

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));
     }