move all the transfer rws handling to transfer gadget

Author: ChihChengLiang

zkevm-circuits/src/evm_circuit/execution/begin_tx.rs

@@ -466,21 +466,13 @@ impl<F: Field> ExecutionGadget<F> for BeginTxGadget<F> {
         }
         let callee_exists =
             is_precompiled(&tx.to_or_contract_addr()) || !callee_code_hash.is_zero();
-        let caller_balance_sub_fee_pair = rws.next().account_balance_pair();
-
-        let caller_balance_sub_value_pair = if !tx.value.is_zero() {
-            rws.next().account_balance_pair()
-        } else {
-            (zero, zero)
-        };
-        if !callee_exists && (!tx.value.is_zero() || tx.is_create()) {
-            callee_code_hash = rws.next().account_codehash_pair().1;
-        }
-        let callee_balance_pair = if !tx.value.is_zero() {
-            rws.next().account_balance_pair()
-        } else {
-            (zero, zero)
-        };
+        self.transfer_with_gas_fee.assign(
+            region,
+            offset,
+            &mut rws,
+            (callee_exists, tx.value, tx.is_create()),
+            Some(gas_fee),
+        )?;
         self.begin_tx.assign(region, offset, tx)?;
         self.tx.assign(region, offset, tx)?;
 
@@ -504,18 +496,6 @@ impl<F: Field> ExecutionGadget<F> for BeginTxGadget<F> {
         )?;
         self.sufficient_gas_left
             .assign(region, offset, F::from(tx.gas() - step.gas_cost))?;
-        self.transfer_with_gas_fee.assign(
-            region,
-            offset,
-            (
-                Some(caller_balance_sub_fee_pair.0),
-                Some(caller_balance_sub_fee_pair.1),
-            ),
-            caller_balance_sub_value_pair,
-            callee_balance_pair,
-            tx.value,
-            Some(gas_fee),
-        )?;
         self.code_hash
             .assign_u256(region, offset, callee_code_hash)?;
         self.is_empty_code_hash.assign_u256(

zkevm-circuits/src/evm_circuit/execution/callop.rs

@@ -867,20 +867,12 @@ impl<F: Field> ExecutionGadget<F> for CallOpGadget<F> {
             depth.low_u64() < 1025 && (!(is_call || is_callcode) || caller_balance >= value);
 
         // conditionally assign
-        if is_call && is_precheck_ok && !value.is_zero() {
-            if !callee_exists {
-                rws.next().account_codehash_pair(); // callee hash
-            }
-
-            let caller_balance_pair = rws.next().account_balance_pair();
-            let callee_balance_pair = rws.next().account_balance_pair();
+        if is_call && is_precheck_ok {
             self.transfer.assign(
                 region,
                 offset,
-                (None, None),
-                caller_balance_pair,
-                callee_balance_pair,
-                value,
+                &mut rws,
+                (callee_exists, value, false),
                 None,
             )?;
         }

zkevm-circuits/src/evm_circuit/execution/create.rs

@@ -639,22 +639,11 @@ impl<F: Field, const IS_CREATE2: bool, const S: ExecutionState> ExecutionGadget<
 
         let code_hash = if is_precheck_ok {
             if !is_address_collision {
-                // transfer
-                if callee_prev_code_hash.is_zero() {
-                    rws.next(); // codehash update
-                }
-                let [caller_balance_pair, callee_balance_pair] = if !value.is_zero() {
-                    [(); 2].map(|_| rws.next().account_balance_pair())
-                } else {
-                    [(0.into(), 0.into()), (0.into(), 0.into())]
-                };
                 self.transfer.assign(
                     region,
                     offset,
-                    (None, None),
-                    caller_balance_pair,
-                    callee_balance_pair,
-                    value,
+                    &mut rws,
+                    (!callee_prev_code_hash.is_zero(), value, true),
                     None,
                 )?;
             }

zkevm-circuits/src/evm_circuit/execution/end_tx.rs

@@ -11,7 +11,7 @@ use crate::{
                 MulWordByU64Gadget,
             },
             tx::EndTxHelperGadget,
-            CachedRegion, Cell,
+            CachedRegion, Cell, StepRws,
         },
         witness::{Block, Call, ExecStep, Transaction},
     },
@@ -150,9 +150,11 @@ impl<F: Field> ExecutionGadget<F> for EndTxGadget<F> {
         step: &ExecStep,
     ) -> Result<(), Error> {
         let gas_used = tx.gas() - step.gas_left;
-        let (refund, _) = block.get_rws(step, 2).tx_refund_value_pair();
-        let (caller_balance, caller_balance_prev) = block.get_rws(step, 3).account_balance_pair();
-        let (coinbase_code_hash_prev, _) = block.get_rws(step, 4).account_codehash_pair();
+        let mut rws = StepRws::new(block, step);
+        rws.offset_add(2);
+        let (refund, _) = rws.next().tx_refund_value_pair();
+        let (caller_balance, caller_balance_prev) = rws.next().account_balance_pair();
+        let (coinbase_code_hash_prev, _) = rws.next().account_codehash_pair();
 
         self.tx_id
             .assign(region, offset, Value::known(F::from(tx.id)))?;
@@ -206,24 +208,12 @@ impl<F: Field> ExecutionGadget<F> for EndTxGadget<F> {
             .assign_u256(region, offset, coinbase_code_hash_prev)?;
         self.coinbase_code_hash_is_zero
             .assign_u256(region, offset, coinbase_code_hash_prev)?;
-        if !coinbase_reward.is_zero() {
-            let coinbase_balance_pair = block
-                .get_rws(
-                    step,
-                    if coinbase_code_hash_prev.is_zero() {
-                        6
-                    } else {
-                        5
-                    },
-                )
-                .account_balance_pair();
-            self.coinbase_reward.assign(
-                region,
-                offset,
-                coinbase_balance_pair,
-                effective_tip * gas_used,
-            )?;
-        }
+        self.coinbase_reward.assign(
+            region,
+            offset,
+            &mut rws,
+            (!coinbase_code_hash_prev.is_zero(), coinbase_reward, false),
+        )?;
         self.is_persistent.assign(
             region,
             offset,

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

@@ -3,7 +3,7 @@ use super::{
     from_bytes,
     math_gadget::{IsEqualWordGadget, IsZeroGadget, IsZeroWordGadget, LtGadget},
     memory_gadget::{CommonMemoryAddressGadget, MemoryExpansionGadget},
-    AccountAddress, CachedRegion,
+    AccountAddress, CachedRegion, StepRws,
 };
 use crate::{
     evm_circuit::{
@@ -419,15 +419,24 @@ impl<F: Field> TransferToGadget<F> {
         &self,
         region: &mut CachedRegion<'_, '_, F>,
         offset: usize,
-        (receiver_balance, prev_receiver_balance): (U256, U256),
-        value: U256,
+        rws: &mut StepRws,
+        (receiver_exists, value, opcode_is_create): (bool, U256, bool),
     ) -> Result<(), Error> {
+        if !receiver_exists && (!value.is_zero() || opcode_is_create) {
+            let _receiver_code_hash = rws.next().account_codehash_pair();
+        }
+
+        let receiver_balance_pair = if !value.is_zero() {
+            rws.next().account_balance_pair()
+        } else {
+            (0.into(), 0.into())
+        };
         self.receiver.assign(
             region,
             offset,
-            prev_receiver_balance,
+            receiver_balance_pair.1,
             vec![value],
-            receiver_balance,
+            receiver_balance_pair.0,
         )?;
         self.value_is_zero
             .assign_value(region, offset, Value::known(WordLoHi::from(value)))?;
@@ -521,33 +530,37 @@ impl<F: Field, const WITH_FEE: bool> TransferGadget<F, WITH_FEE> {
         &self,
         region: &mut CachedRegion<'_, '_, F>,
         offset: usize,
-        (sender_balance_sub_fee, prev_sender_balance_sub_fee): (Option<U256>, Option<U256>),
-        (sender_balance_sub_value, prev_sender_balance_sub_value): (U256, U256),
-        (receiver_balance, prev_receiver_balance): (U256, U256),
-        value: U256,
+        rws: &mut StepRws,
+        (receiver_exists, value, opcode_is_create): (bool, U256, bool),
         gas_fee: Option<U256>,
     ) -> Result<(), Error> {
         if WITH_FEE {
+            let sender_balance_sub_fee = rws.next().account_balance_pair();
             self.sender_sub_fee.as_ref().expect("Exists").assign(
                 region,
                 offset,
-                prev_sender_balance_sub_fee.expect("exists"),
+                sender_balance_sub_fee.1,
                 vec![gas_fee.expect("exists")],
-                sender_balance_sub_fee.expect("exists"),
+                sender_balance_sub_fee.0,
             )?;
         }
+        let sender_balance_sub_value = if !value.is_zero() {
+            rws.next().account_balance_pair()
+        } else {
+            (0.into(), 0.into())
+        };
         self.sender_sub_value.assign(
             region,
             offset,
-            prev_sender_balance_sub_value,
+            sender_balance_sub_value.1,
             vec![value],
-            sender_balance_sub_value,
+            sender_balance_sub_value.0,
         )?;
         self.receiver.assign(
             region,
             offset,
-            (receiver_balance, prev_receiver_balance),
-            value,
+            rws,
+            (receiver_exists, value, opcode_is_create),
         )?;
         self.value_is_zero
             .assign_value(region, offset, Value::known(WordLoHi::from(value)))?;