Merge branch 'develop' into pi-aggregation-circuit

Author: zhenfeizhang

Cargo.lock

@@ -44,3 +44,5 @@ rand = "0.8"
 default = ["test"]
 test = ["mock", "rand"]
 scroll = ["eth-types/scroll"]
+# Enable shanghai feature of mock only if mock is enabled (by test).
+shanghai = ["eth-types/shanghai", "mock?/shanghai"]

bus-mapping/Cargo.toml

@@ -15,7 +15,7 @@ pub use self::block::BlockHead;
 use crate::{
     error::Error,
     evm::opcodes::{gen_associated_ops, gen_begin_tx_ops, gen_end_tx_ops},
-    operation::{CallContextField, Operation, RWCounter, StartOp, RW},
+    operation::{self, CallContextField, Operation, RWCounter, StartOp, StorageOp, RW},
     rpc::GethClient,
     state_db::{self, CodeDB, StateDB},
 };
@@ -48,7 +48,7 @@ use std::{
     collections::{BTreeMap, HashMap},
     iter,
 };
-pub use transaction::{Transaction, TransactionContext};
+pub use transaction::{Transaction, TransactionContext, TxL1Fee, TX_L1_FEE_PRECISION};
 
 /// Circuit Setup Parameters
 #[derive(Debug, Clone, Copy)]
@@ -243,23 +243,28 @@ impl<'a> CircuitInputBuilder {
         check_last_tx: bool,
     ) -> Result<(), Error> {
         // accumulates gas across all txs in the block
-        log::info!("handling block {:?}", eth_block.number);
+        log::info!(
+            "handling block {:?}, tx num {}",
+            eth_block.number,
+            eth_block.transactions.len()
+        );
         for (tx_index, tx) in eth_block.transactions.iter().enumerate() {
+            let batch_tx_idx = self.block.txs.len();
             if self.block.txs.len() >= self.block.circuits_params.max_txs {
                 log::warn!(
-                    "skip tx outside MAX_TX limit {}, {}th(inner idx: {}) tx {:?}",
+                    "skip tx outside MAX_TX limit {}, {}th tx(inner idx: {}) {:?}",
                     self.block.circuits_params.max_txs,
+                    batch_tx_idx,
                     tx.transaction_index.unwrap_or_default(),
-                    self.block.txs.len(),
                     tx.hash
                 );
                 continue;
             }
             let geth_trace = &geth_traces[tx_index];
             log::info!(
-                "handling {}th(inner idx: {}) tx: {:?} rwc {:?}, to: {:?}, input_len {:?}",
+                "handling {}th tx(inner idx: {}): {:?} rwc {:?}, to: {:?}, input_len {:?}",
+                batch_tx_idx,
                 tx.transaction_index.unwrap_or_default(),
-                self.block.txs.len(),
                 tx.hash,
                 self.block_ctx.rwc,
                 tx.to,
@@ -273,6 +278,12 @@ impl<'a> CircuitInputBuilder {
                 geth_trace,
                 check_last_tx && tx_index + 1 == eth_block.transactions.len(),
             )?;
+            log::debug!(
+                "after handle {}th tx: rwc {:?}, block total gas {:?}",
+                batch_tx_idx,
+                self.block_ctx.rwc,
+                self.block_ctx.cumulative_gas_used
+            );
         }
         if handle_rwc_reversion {
             self.set_value_ops_call_context_rwc_eor();
@@ -285,8 +296,81 @@ impl<'a> CircuitInputBuilder {
         Ok(())
     }
 
+    fn print_rw_usage(&self) {
+        // opcode -> (count, mem_rw_len, stack_rw_len)
+        let mut opcode_info_map = BTreeMap::new();
+        for t in &self.block.txs {
+            for step in t.steps() {
+                if let ExecState::Op(op) = step.exec_state {
+                    opcode_info_map.entry(op).or_insert((0, 0, 0));
+                    let mut values = opcode_info_map[&op];
+                    values.0 += 1;
+                    values.1 += step
+                        .bus_mapping_instance
+                        .iter()
+                        .filter(|rw| rw.0 == operation::Target::Memory)
+                        .count();
+                    values.2 += step
+                        .bus_mapping_instance
+                        .iter()
+                        .filter(|rw| rw.0 == operation::Target::Stack)
+                        .count();
+                    opcode_info_map.insert(op, values);
+                }
+            }
+        }
+        for (op, (count, mem, stack)) in opcode_info_map
+            .iter()
+            .sorted_by_key(|(_, (_, m, _))| m)
+            .rev()
+        {
+            log::debug!(
+                "op {:?}, count {}, mem rw {}(avg {:.2}), stack rw {}(avg {:.2})",
+                op,
+                count,
+                mem,
+                *mem as f32 / *count as f32,
+                stack,
+                *stack as f32 / *count as f32
+            );
+        }
+        log::debug!("memory num: {}", self.block.container.memory.len());
+        log::debug!("stack num: {}", self.block.container.stack.len());
+        log::debug!("storage num: {}", self.block.container.storage.len());
+        log::debug!(
+            "tx_access_list_account num: {}",
+            self.block.container.tx_access_list_account.len()
+        );
+        log::debug!(
+            "tx_access_list_account_storage num: {}",
+            self.block.container.tx_access_list_account_storage.len()
+        );
+        log::debug!("tx_refund num: {}", self.block.container.tx_refund.len());
+        log::debug!("account num: {}", self.block.container.account.len());
+        log::debug!(
+            "call_context num: {}",
+            self.block.container.call_context.len()
+        );
+        log::debug!("tx_receipt num: {}", self.block.container.tx_receipt.len());
+        log::debug!("tx_log num: {}", self.block.container.tx_log.len());
+        log::debug!("start num: {}", self.block.container.start.len());
+    }
+
     /// ..
     pub fn set_end_block(&mut self) -> Result<(), Error> {
+        use crate::l2_predeployed::message_queue::{
+            ADDRESS as MESSAGE_QUEUE, WITHDRAW_TRIE_ROOT_SLOT,
+        };
+
+        let withdraw_root = *self
+            .sdb
+            .get_storage(&MESSAGE_QUEUE, &WITHDRAW_TRIE_ROOT_SLOT)
+            .1;
+        let withdraw_root_before = *self
+            .sdb
+            .get_committed_storage(&MESSAGE_QUEUE, &WITHDRAW_TRIE_ROOT_SLOT)
+            .1;
+
         let max_rws = self.block.circuits_params.max_rws;
         let mut end_block_not_last = self.block.block_steps.end_block_not_last.clone();
         let mut end_block_last = self.block.block_steps.end_block_last.clone();
@@ -297,15 +381,30 @@ impl<'a> CircuitInputBuilder {
         let mut dummy_tx_ctx = TransactionContext::default();
         let mut state = self.state_ref(&mut dummy_tx, &mut dummy_tx_ctx);
 
+        let dummy_tx_id = state.block.txs.len();
         if let Some(call_id) = state.block.txs.last().map(|tx| tx.calls[0].call_id) {
             state.call_context_read(
                 &mut end_block_last,
                 call_id,
                 CallContextField::TxId,
-                Word::from(state.block.txs.len() as u64),
+                Word::from(dummy_tx_id as u64),
             );
         }
 
+        // increase the total rwc by 1
+        state.push_op(
+            &mut end_block_last,
+            RW::READ,
+            StorageOp::new(
+                *MESSAGE_QUEUE,
+                *WITHDRAW_TRIE_ROOT_SLOT,
+                withdraw_root,
+                withdraw_root,
+                dummy_tx_id,
+                withdraw_root_before,
+            ),
+        );
+
         let mut push_op = |step: &mut ExecStep, rwc: RWCounter, rw: RW, op: StartOp| {
             let op_ref = state.block.container.insert(Operation::new(rwc, rw, op));
             step.bus_mapping_instance.push(op_ref);
@@ -333,6 +432,8 @@ impl<'a> CircuitInputBuilder {
             StartOp {},
         );
 
+        self.block.withdraw_root = withdraw_root;
+        self.block.prev_withdraw_root = withdraw_root_before;
         self.block.block_steps.end_block_not_last = end_block_not_last;
         self.block.block_steps.end_block_last = end_block_last;
         Ok(())
@@ -350,6 +451,17 @@ impl<'a> CircuitInputBuilder {
         is_last_tx: bool,
     ) -> Result<(), Error> {
         let mut tx = self.new_tx(eth_tx, !geth_trace.failed)?;
+
+        // Sanity check for transaction L1 fee.
+        let tx_l1_fee = tx.l1_fee();
+        if tx_l1_fee != geth_trace.l1_fee {
+            log::error!(
+                "Mismatch tx_l1_fee: calculated = {}, real = {}",
+                tx_l1_fee,
+                geth_trace.l1_fee
+            );
+        }
+
         let mut tx_ctx = TransactionContext::new(eth_tx, geth_trace, is_last_tx)?;
         let mut debug_tx = tx.clone();
         debug_tx.input.clear();
@@ -370,19 +482,22 @@ impl<'a> CircuitInputBuilder {
         gen_begin_tx_ops(&mut self.state_ref(&mut tx, &mut tx_ctx), geth_trace)?;
 
         for (index, geth_step) in geth_trace.struct_logs.iter().enumerate() {
+            let tx_gas = tx.gas;
             let mut state_ref = self.state_ref(&mut tx, &mut tx_ctx);
             log::trace!(
-                "handle {}th tx depth {} {}th opcode {:?} pc: {} gas_left: {} rwc: {} call_id: {} msize: {} args: {}",
+                "handle {}th tx depth {} {}th/{} opcode {:?} pc: {} gas_left: {} gas_used: {} rwc: {} call_id: {} msize: {} args: {}",
                 eth_tx.transaction_index.unwrap_or_default(),
                 geth_step.depth,
                 index,
+                geth_trace.struct_logs.len(),
                 geth_step.op,
                 geth_step.pc.0,
                 geth_step.gas.0,
+                tx_gas - geth_step.gas.0,
                 state_ref.block_ctx.rwc.0,
                 state_ref.call().map(|c| c.call_id).unwrap_or(0),
                 state_ref.call_ctx()?.memory.len(),
-                if geth_step.op.is_push() {
+                if geth_step.op.is_push_with_data() {
                     format!("{:?}", geth_trace.struct_logs[index + 1].stack.last())
                 } else if geth_step.op.is_call_without_value() {
                     format!(
@@ -478,6 +593,7 @@ pub fn keccak_inputs(block: &Block, code_db: &CodeDB) -> Result<Vec<Vec<u8>>, Er
     keccak_inputs.push(keccak_inputs_pi_circuit(
         block.chain_id().as_u64(),
         block.prev_state_root,
+        block.withdraw_root,
         &block.headers,
         block.txs(),
         block.circuits_params.max_txs,
@@ -564,13 +680,12 @@ pub fn get_dummy_tx_hash(chain_id: u64) -> H256 {
 fn keccak_inputs_pi_circuit(
     chain_id: u64,
     prev_state_root: Word,
+    withdraw_trie_root: Word,
     block_headers: &BTreeMap<u64, BlockHead>,
     transactions: &[Transaction],
     max_txs: usize,
 ) -> Vec<u8> {
     let dummy_tx_hash = get_dummy_tx_hash(chain_id);
-    // TODO: use real-world withdraw trie root
-    let withdraw_trie_root = Word::zero(); // zero for now
 
     let result = iter::empty()
         // state roots

bus-mapping/src/circuit_input_builder.rs

@@ -139,6 +139,10 @@ pub struct Block {
     pub headers: BTreeMap<u64, BlockHead>,
     /// State root of the previous block
     pub prev_state_root: Word,
+    /// Withdraw root
+    pub withdraw_root: Word,
+    /// Withdraw roof of the previous block
+    pub prev_withdraw_root: Word,
     /// Container of operations done in this block.
     pub container: OperationContainer,
     /// Transactions contained in the block

bus-mapping/src/circuit_input_builder/block.rs

@@ -359,7 +359,10 @@ impl<'a> CircuitInputStateRef<'a> {
         if matches!(rw, RW::WRITE) {
             match op.field {
                 AccountField::Nonce => account.nonce = op.value,
-                AccountField::Balance => account.balance = op.value,
+                AccountField::Balance => {
+                    log::trace!("update balance of {:?} to {:?}", &op.address, op.value);
+                    account.balance = op.value;
+                }
                 AccountField::KeccakCodeHash => {
                     account.keccak_code_hash = H256::from(op.value.to_be_bytes())
                 }