Merge branch 'main' into feat/use-steprws

bus-mapping/src/circuit_input_builder/block.rs

@@ -84,7 +84,8 @@ pub struct Block {
     pub block_steps: BlockSteps,
     /// Copy events in this block.
     pub copy_events: Vec<CopyEvent>,
-    /// Inputs to the SHA3 opcode
+    /// Inputs to the SHA3 opcode as well as data hashed during the EVM execution like init code
+    /// and address creation inputs.
     pub sha3_inputs: Vec<Vec<u8>>,
     /// Exponentiation events in the block.
     pub exp_events: Vec<ExpEvent>,

bus-mapping/src/circuit_input_builder/input_state_ref.rs

@@ -559,13 +559,13 @@ impl<'a> CircuitInputStateRef<'a> {
     /// balance by `value`. If `fee` is existing (not None), also need to push 1
     /// non-reversible [`AccountOp`] to update `sender` balance by `fee`.
     #[allow(clippy::too_many_arguments)]
-    pub fn transfer_with_fee(
+    pub fn transfer(
         &mut self,
         step: &mut ExecStep,
         sender: Address,
         receiver: Address,
         receiver_exists: bool,
-        must_create: bool,
+        is_create: bool,
         value: Word,
         fee: Option<Word>,
     ) -> Result<(), Error> {
@@ -608,82 +608,35 @@ impl<'a> CircuitInputStateRef<'a> {
             sender_balance_prev,
             sender_balance
         );
-        // If receiver doesn't exist, create it
-        if !receiver_exists && (!value.is_zero() || must_create) {
+
+        if !value.is_zero() {
             self.push_op_reversible(
                 step,
                 AccountOp {
-                    address: receiver,
-                    field: AccountField::CodeHash,
-                    value: CodeDB::empty_code_hash().to_word(),
-                    value_prev: Word::zero(),
+                    address: sender,
+                    field: AccountField::Balance,
+                    value: sender_balance,
+                    value_prev: sender_balance_prev,
                 },
             )?;
         }
-        if value.is_zero() {
-            // Skip transfer if value == 0
-            return Ok(());
-        }
 
-        self.push_op_reversible(
-            step,
-            AccountOp {
-                address: sender,
-                field: AccountField::Balance,
-                value: sender_balance,
-                value_prev: sender_balance_prev,
-            },
-        )?;
-
-        let (_found, receiver_account) = self.sdb.get_account(&receiver);
-        let receiver_balance_prev = receiver_account.balance;
-        let receiver_balance = receiver_account.balance + value;
-        self.push_op_reversible(
-            step,
-            AccountOp {
-                address: receiver,
-                field: AccountField::Balance,
-                value: receiver_balance,
-                value_prev: receiver_balance_prev,
-            },
-        )?;
+        self.transfer_to(step, receiver, receiver_exists, is_create, value, true)?;
 
         Ok(())
     }
 
-    /// Same functionality with `transfer_with_fee` but with `fee` set zero.
-    pub fn transfer(
-        &mut self,
-        step: &mut ExecStep,
-        sender: Address,
-        receiver: Address,
-        receiver_exists: bool,
-        must_create: bool,
-        value: Word,
-    ) -> Result<(), Error> {
-        self.transfer_with_fee(
-            step,
-            sender,
-            receiver,
-            receiver_exists,
-            must_create,
-            value,
-            None,
-        )
-    }
-
     /// Transfer to an address. Create an account if it is not existed before.
     pub fn transfer_to(
         &mut self,
         step: &mut ExecStep,
         receiver: Address,
         receiver_exists: bool,
-        must_create: bool,
+        is_create: bool,
         value: Word,
         reversible: bool,
     ) -> Result<(), Error> {
-        // If receiver doesn't exist, create it
-        if (!receiver_exists && !value.is_zero()) || must_create {
+        if !receiver_exists && (!value.is_zero() || is_create) {
             self.account_write(
                 step,
                 receiver,

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

@@ -1,6 +1,8 @@
 use super::TxExecSteps;
 use crate::{
-    circuit_input_builder::{Call, CircuitInputStateRef, ExecState, ExecStep},
+    circuit_input_builder::{
+        Call, CircuitInputStateRef, CopyDataType, CopyEvent, ExecState, ExecStep, NumberOrHash,
+    },
     operation::{AccountField, AccountOp, CallContextField, TxReceiptField, TxRefundOp, RW},
     state_db::CodeDB,
     Error,
@@ -122,7 +124,7 @@ fn gen_begin_tx_steps(state: &mut CircuitInputStateRef) -> Result<ExecStep, Erro
     }
 
     // Transfer with fee
-    state.transfer_with_fee(
+    state.transfer(
         &mut exec_step,
         call.caller_address,
         call.address,
@@ -148,6 +150,28 @@ fn gen_begin_tx_steps(state: &mut CircuitInputStateRef) -> Result<ExecStep, Erro
             stream.append(&nonce_prev);
             stream.out().to_vec()
         });
+        // We also hash the call_data as it will be used as init code, and the
+        // call_context.code_hash needs to be checked against the hash of this call_data.
+        state.block.sha3_inputs.push(state.tx.call_data.to_vec());
+
+        // Append the copy for the CopyCircuit to calculate RLC(call_data) for the keccack lookup
+        if state.tx.call_data.len() > 0 {
+            state.push_copy(
+                &mut exec_step,
+                CopyEvent {
+                    src_addr: 0,
+                    src_addr_end: state.tx.call_data.len() as u64,
+                    src_type: CopyDataType::TxCalldata,
+                    src_id: NumberOrHash::Number(state.tx.id as usize),
+                    dst_addr: 0,
+                    dst_type: CopyDataType::RlcAcc,
+                    dst_id: NumberOrHash::Number(0),
+                    log_id: None,
+                    rw_counter_start: state.block_ctx.rwc,
+                    bytes: state.tx.call_data.iter().map(|b| (*b, false)).collect(),
+                },
+            );
+        }
     }
 
     // There are 4 branches from here.

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

@@ -195,6 +195,7 @@ impl<const N_ARGS: usize> Opcode for CallOpcode<N_ARGS> {
                 callee_exists,
                 false,
                 call.value,
+                None,
             )?;
         }
 

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

@@ -217,8 +217,9 @@ impl<const IS_CREATE2: bool> Opcode for Create<IS_CREATE2> {
                 caller.address,
                 callee.address,
                 callee_exists,
-                !callee_exists,
+                true,
                 callee.value,
+                None,
             )?;
 
             // EIP 161, increase callee's nonce