feat: BeginTx and EndTx support taiko's 1559

.gitignore

@@ -4,3 +4,8 @@
 .vscode
 .idea
 /generated
+*.srs
+*.log
+*.json
+*.yul
+*.sol

Cargo.toml

@@ -10,7 +10,8 @@ members = [
     "eth-types",
     "external-tracer",
     "mock",
-    "testool"
+    "mock-taiko",
+    "testool",
 ]
 
 [patch.crates-io]

bus-mapping/src/circuit_input_builder.rs

@@ -6,6 +6,7 @@ mod block;
 mod call;
 mod execution;
 mod input_state_ref;
+mod protocol_instance;
 #[cfg(test)]
 mod tracer_tests;
 mod transaction;
@@ -34,6 +35,7 @@ pub use execution::{
 pub use input_state_ref::CircuitInputStateRef;
 use itertools::Itertools;
 use log::warn;
+pub use protocol_instance::{left_shift, MetaHash, ProtocolInstance, ANCHOR_TX_METHOD_SIGNATURE};
 use std::collections::HashMap;
 pub use transaction::{Transaction, TransactionContext};
 
@@ -409,6 +411,7 @@ pub struct BuilderClient<P: JsonRpcClient> {
     cli: GethClient<P>,
     chain_id: Word,
     circuits_params: CircuitsParams,
+    protocol_instance: ProtocolInstance,
 }
 
 /// Get State Accesses from TxExecTraces
@@ -468,13 +471,15 @@ impl<P: JsonRpcClient> BuilderClient<P> {
     pub async fn new(
         client: GethClient<P>,
         circuits_params: CircuitsParams,
+        protocol_instance: ProtocolInstance,
     ) -> Result<Self, Error> {
         let chain_id = client.get_chain_id().await?;
 
         Ok(Self {
             cli: client,
             chain_id: chain_id.into(),
             circuits_params,
+            protocol_instance,
         })
     }
 
@@ -615,6 +620,7 @@ impl<P: JsonRpcClient> BuilderClient<P> {
             prev_state_root,
             eth_block,
             self.circuits_params,
+            self.protocol_instance.clone(),
         )?;
         let mut builder = CircuitInputBuilder::new(sdb, code_db, block);
         builder.handle_block_with_anchor(eth_block, geth_traces, has_anchor_tx)?;

bus-mapping/src/circuit_input_builder/block.rs

@@ -2,6 +2,7 @@
 
 use super::{
     execution::ExecState, transaction::Transaction, CircuitsParams, CopyEvent, ExecStep, ExpEvent,
+    ProtocolInstance,
 };
 use crate::{
     operation::{OperationContainer, RWCounter},
@@ -90,6 +91,8 @@ pub struct Block {
     pub circuits_params: CircuitsParams,
     /// Original block from geth
     pub eth_block: eth_types::Block<eth_types::Transaction>,
+    /// Protocol instance from protocol
+    pub protocol_instance: ProtocolInstance,
 }
 
 impl Block {
@@ -100,6 +103,7 @@ impl Block {
         prev_state_root: Word,
         eth_block: &eth_types::Block<eth_types::Transaction>,
         circuits_params: CircuitsParams,
+        protocol_instance: ProtocolInstance,
     ) -> Result<Self, Error> {
         if eth_block.base_fee_per_gas.is_none() {
             // FIXME: resolve this once we have proper EIP-1559 support
@@ -141,6 +145,7 @@ impl Block {
             sha3_inputs: Vec::new(),
             circuits_params,
             eth_block: eth_block.clone(),
+            protocol_instance,
         })
     }
 

zkevm-circuits/src/witness/protocol_instance.rs → bus-mapping/src/circuit_input_builder/protocol_instance.rs

@@ -2,13 +2,11 @@
 
 use std::iter;
 
-use crate::{table::PiFieldTag, util::rlc_be_bytes};
-use eth_types::{Address, Bytes, Field, Hash, ToBigEndian, ToWord, Word, H256};
-use halo2_proofs::circuit::Value;
+use eth_types::{Address, Bytes, Hash, ToBigEndian, ToWord, Word, H256};
 use keccak256::plain::Keccak;
 
-// hash(anchor)
-const ANCHOR_TX_METHOD_SIGNATURE: u32 = 0xda69d3db;
+/// hash(anchor)
+pub const ANCHOR_TX_METHOD_SIGNATURE: u32 = 0xda69d3db;
 
 /// Taiko witness
 #[derive(Debug, Default, Clone)]
@@ -129,42 +127,6 @@ impl ProtocolInstance {
         result.extend_from_slice(&(self.parent_gas_used as u64).to_word().to_be_bytes());
         result.into()
     }
-
-    /// Assignments for pi table
-    pub fn table_assignments<F: Field>(&self, randomness: Value<F>) -> [[Value<F>; 2]; 6] {
-        [
-            [
-                Value::known(F::from(PiFieldTag::Null as u64)),
-                Value::known(F::ZERO),
-            ],
-            [
-                Value::known(F::from(PiFieldTag::MethodSign as u64)),
-                Value::known(F::from(ANCHOR_TX_METHOD_SIGNATURE as u64)),
-            ],
-            [
-                Value::known(F::from(PiFieldTag::L1Hash as u64)),
-                rlc_be_bytes(&self.meta_hash.l1_hash.to_fixed_bytes(), randomness),
-            ],
-            [
-                Value::known(F::from(PiFieldTag::L1SignalRoot as u64)),
-                rlc_be_bytes(&self.signal_root.to_fixed_bytes(), randomness),
-            ],
-            [
-                Value::known(F::from(PiFieldTag::L1Height as u64)),
-                rlc_be_bytes(
-                    &self.meta_hash.l1_height.to_word().to_be_bytes(),
-                    randomness,
-                ),
-            ],
-            [
-                Value::known(F::from(PiFieldTag::ParentGasUsed as u64)),
-                rlc_be_bytes(
-                    &(self.parent_gas_used as u64).to_word().to_be_bytes(),
-                    randomness,
-                ),
-            ],
-        ]
-    }
 }
 
 #[cfg(test)]

bus-mapping/src/evm/opcodes/begin_end_tx.rs

@@ -281,6 +281,25 @@ fn gen_end_tx_steps(state: &mut CircuitInputStateRef) -> Result<ExecStep, Error>
         coinbase_balance_prev,
     )?;
 
+    // add treasury account
+    let (found, treasury_account) = state
+        .sdb
+        .get_account(&state.block.protocol_instance.meta_hash.treasury);
+    if !found {
+        return Err(Error::AccountNotFound(
+            state.block.protocol_instance.meta_hash.treasury,
+        ));
+    }
+    let treasury_balance_prev = treasury_account.balance;
+    let treasury_balance =
+        treasury_balance_prev + state.block.base_fee * (state.tx.gas() - exec_step.gas_left.0);
+    state.account_write(
+        &mut exec_step,
+        state.block.coinbase,
+        AccountField::Balance,
+        treasury_balance,
+        treasury_balance_prev,
+    )?;
     // handle tx receipt tag
     state.tx_receipt_write(
         &mut exec_step,

bus-mapping/src/mock.rs

@@ -40,6 +40,7 @@ impl BlockData {
                 Word::default(),
                 &self.eth_block,
                 self.circuits_params,
+                Default::default(),
             )
             .unwrap(),
         )

integration-tests/src/integration_test_circuits.rs

@@ -334,7 +334,9 @@ async fn gen_inputs(
     eth_types::Block<eth_types::Transaction>,
 ) {
     let cli = get_client();
-    let cli = BuilderClient::new(cli, CIRCUITS_PARAMS).await.unwrap();
+    let cli = BuilderClient::new(cli, CIRCUITS_PARAMS, Default::default())
+        .await
+        .unwrap();
 
     cli.gen_inputs(block_num).await.unwrap()
 }

integration-tests/src/lib.rs

@@ -163,6 +163,7 @@ pub async fn build_circuit_input_builder_block(block_num: u64) {
             max_exp_steps: 1000,
             max_keccak_rows: 0,
         },
+        Default::default(),
     )
     .await
     .unwrap();

mock-taiko/.gitignore

@@ -0,0 +1 @@
+/target

mock-taiko/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "mock-taiko"
+version = "0.1.0"
+edition = "2021"
+authors = ["The appliedzkp team"]
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+halo2_proofs = { git = "https://github.com/privacy-scaling-explorations/halo2.git", features = [
+  "circuit-params",
+], tag = "v2023_04_20" }
+eth-types = { path = "../eth-types" }
+external-tracer = { path = "../external-tracer" }
+lazy_static = "1.4"
+itertools = "0.10.3"
+ethers-signers = "=2.0.0"
+ethers-core = "=2.0.0"
+rand_chacha = "0.3"
+rand = "0.8"
+sha3 = "0.10"
+num-bigint = { version = "0.4" }
+num = "0.4"
+libsecp256k1 = "0.7"
+once_cell = "1.17.1"

mock-taiko/src/account.rs

@@ -0,0 +1,84 @@
+//! Mock Account definition and builder related methods.
+
+use eth_types::{geth_types::Account, Address, Bytes, Word};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Default)]
+/// Mock structure which represents an Account and can be used for tests.
+/// It contains all the builder-pattern methods required to be able to specify
+/// any of its details.
+pub struct MockAccount {
+    /// Address
+    pub address: Address,
+    /// nonce
+    pub nonce: u64,
+    /// Balance
+    pub balance: Word,
+    /// EVM Code
+    pub code: Bytes,
+    /// Storage
+    pub storage: HashMap<Word, Word>,
+}
+
+impl From<MockAccount> for Account {
+    fn from(mock: MockAccount) -> Self {
+        Account {
+            address: mock.address,
+            nonce: mock.nonce.into(),
+            balance: mock.balance,
+            code: mock.code,
+            storage: mock.storage,
+        }
+    }
+}
+
+impl MockAccount {
+    /// Set address field for the MockAccount.
+    pub fn address(&mut self, address: Address) -> &mut Self {
+        self.address = address;
+        self
+    }
+
+    /// Set nonce field for the MockAccount.
+    pub fn nonce(&mut self, nonce: u64) -> &mut Self {
+        self.nonce = nonce;
+        self
+    }
+
+    /// Set balance field for the MockAccount.
+    pub fn balance(&mut self, balance: Word) -> &mut Self {
+        self.balance = balance;
+        self
+    }
+
+    /// Set code field for the MockAccount.
+    pub fn code<T: Into<Bytes>>(&mut self, code: T) -> &mut Self {
+        self.code = code.into();
+        self
+    }
+
+    /// Add storage field for the MockAccount by passing an iterator over the
+    /// key-value tuples of type [(`Word`, `Word`)].
+    pub fn storage<I: Iterator<Item = (Word, Word)>>(&mut self, storage: I) -> &mut Self {
+        storage.for_each(|pair| {
+            assert!(self.storage.insert(pair.0, pair.1).is_none());
+        });
+        self
+    }
+
+    /// Set all fields for the MockAccount based on their values in `account`.
+    pub fn account(&mut self, account: &Account) -> &mut Self {
+        self.address(account.address);
+        self.nonce(account.nonce.as_u64());
+        self.balance(account.balance);
+        self.code(account.code.clone());
+        self.storage(account.storage.iter().map(|(k, v)| (*k, *v)));
+        self
+    }
+
+    /// Finalizes the current MockAccount under construction returning a new
+    /// instance to it.
+    pub fn build(&mut self) -> Self {
+        self.to_owned()
+    }
+}