fix some testcases in testool related to copy table (#653)

* should always expand

* fix calldatacopy_d0(cdc_0_1_2)_g0_v0

* Revert "should always expand"

This reverts commit 29f72ba.

* fix outbounds

* update test assertion

* pass empty slice

* fix

* fix

* fmt

* add testcase of call_precompile_with_value

* add testcase of test_oog_call_with_inner_sstore

* fix busmapping assert

* fix test_oog_call_with_inner_sstore

* Revert "fix test_oog_call_with_inner_sstore"

This reverts commit 63c26d1.

* revert reversible_write_counter constraint

* cleanup

* cleanup

Author: lightsing

bus-mapping/src/circuit_input_builder/input_state_ref.rs

@@ -1844,12 +1844,21 @@ impl<'a> CircuitInputStateRef<'a> {
             return Ok((vec![], vec![], vec![]));
         }
 
+        let caller_memory = self.caller_ctx()?.memory.clone();
+        let call_data_length = self.call()?.call_data_length;
+        let call_data_offset = self.call()?.call_data_offset;
+        let call_data = if call_data_length != 0 {
+            let ends = call_data_offset + call_data_length;
+            &caller_memory.0[..ends as usize]
+        } else {
+            &caller_memory.0[..call_data_offset as usize]
+        };
         let call_ctx = self.call_ctx_mut()?;
         let (src_range, dst_range, write_slot_bytes) = combine_copy_slot_bytes(
             src_addr.into().0,
             dst_addr.into().0,
             copy_length,
-            &call_ctx.call_data,
+            call_data,
             &mut call_ctx.memory,
         );
 
@@ -1897,12 +1906,20 @@ impl<'a> CircuitInputStateRef<'a> {
         }
 
         let last_callee_memory = self.call()?.last_callee_memory.clone();
+        let return_data_length = self.call()?.last_callee_return_data_length;
+        let return_data_offset = self.call()?.last_callee_return_data_offset;
+        let return_data: &[u8] = if return_data_length != 0 {
+            let ends = return_data_offset + return_data_length;
+            &last_callee_memory.0[..ends as usize]
+        } else {
+            &last_callee_memory.0[..return_data_offset as usize]
+        };
         let call_ctx = self.call_ctx_mut()?;
         let (src_range, dst_range, write_slot_bytes) = combine_copy_slot_bytes(
             src_addr.into().0,
             dst_addr.into().0,
             copy_length,
-            &last_callee_memory.0,
+            return_data,
             &mut call_ctx.memory,
         );
         let read_slot_bytes = self.call()?.last_callee_memory.read_chunk(src_range);

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

@@ -13,7 +13,7 @@ use crate::{
 use eth_types::{
     evm_types::{
         gas_utils::{eip150_gas, memory_expansion_gas_cost},
-        Gas, GasCost, OpcodeId,
+        Gas, GasCost, OpcodeId, GAS_STIPEND_CALL_WITH_VALUE,
     },
     GethExecStep, ToWord, Word,
 };
@@ -461,7 +461,15 @@ impl<const N_ARGS: usize> Opcode for CallOpcode<N_ARGS> {
                 state.handle_return(&mut precompile_step, geth_steps, true)?;
 
                 let real_cost = geth_steps[0].gas.0 - geth_steps[1].gas.0;
-                debug_assert_eq!(real_cost, gas_cost + contract_gas_cost);
+                debug_assert_eq!(
+                    real_cost
+                        + if has_value && !callee_exists {
+                            GAS_STIPEND_CALL_WITH_VALUE
+                        } else {
+                            0
+                        },
+                    gas_cost + contract_gas_cost
+                );
                 exec_step.gas_cost = GasCost(gas_cost + contract_gas_cost);
                 if real_cost != exec_step.gas_cost.0 {
                     log::warn!(

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

@@ -239,7 +239,7 @@ impl<F: Field> ExecutionGadget<F> for CallDataCopyGadget<F> {
 mod test {
     use crate::{evm_circuit::test::rand_bytes, test_util::CircuitTestBuilder};
     use bus_mapping::circuit_input_builder::CircuitsParams;
-    use eth_types::{bytecode, Word};
+    use eth_types::{bytecode, word, Word};
     use mock::{
         generate_mock_call_bytecode,
         test_ctx::{helpers::*, TestContext},
@@ -363,4 +363,22 @@ mod test {
         test_root_ok(0x40, 0, 0x40.into(), Word::MAX);
         test_internal_ok(0x40, 0x40, 0, 0x10.into(), Word::MAX);
     }
+
+    #[test]
+    fn calldatacopy_unaligned_data() {
+        // calldatacopy_d0(cdc_0_1_2)_g0_v0
+        test_internal_ok(0xf, 0x10, 2, 1.into(), 0x0.into());
+
+        // copy source out of bounds
+        test_internal_ok(0xf, 0x10, 0x9, 0x20.into(), 0x0.into());
+
+        // calldatacopy_d4(cdc_0_neg6_ff)_g0_v0
+        test_internal_ok(
+            0xf,
+            0x10,
+            0x09,
+            word!("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa"),
+            0x0.into(),
+        );
+    }
 }

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

@@ -447,7 +447,7 @@ impl<F: Field> ExecutionGadget<F> for CallOpGadget<F> {
                 // +15 call context lookups for precompile.
                 let rw_counter_delta = 33.expr()
                     + is_call.expr() * 1.expr()
-                    + transfer_rwc_delta
+                    + transfer_rwc_delta.expr()
                     + is_callcode.expr()
                     + is_delegatecall.expr() * 2.expr()
                     + precompile_input_rws.expr()
@@ -1581,6 +1581,46 @@ mod test {
             .run();
     }
 
+    // minimal testool case: returndatasize_bug_d0_g0_v0
+    #[test]
+    fn test_oog_call_with_inner_sstore() {
+        let (addr_a, addr_b, addr_c) = (
+            mock::MOCK_ACCOUNTS[0],
+            mock::MOCK_ACCOUNTS[1],
+            mock::MOCK_ACCOUNTS[2],
+        );
+        let code_a = bytecode! {
+            .op_call(1, addr_b, 50000, 0, 0, 0, 0)
+        };
+
+        let code_b = bytecode! {
+            .op_call(10, 1, 50000, 0, 0, 0, 0)
+            .op_sstore(0, 0)
+        };
+
+        let ctx = TestContext::<3, 1>::new(
+            None,
+            |accs| {
+                accs[0]
+                    .address(addr_a)
+                    .balance(word!("0x0de0b6b3a7640000"))
+                    .code(code_a);
+                accs[1].address(addr_b).code(code_b);
+                accs[2].address(addr_c).balance(word!("0x6400000000"));
+            },
+            |mut txs, accs| {
+                txs[0]
+                    .from(accs[2].address)
+                    .to(accs[0].address)
+                    .gas(word!("0x0a00000000"));
+            },
+            |block, _tx| block.number(0xcafeu64),
+        )
+        .unwrap();
+
+        CircuitTestBuilder::new_from_test_ctx(ctx).run()
+    }
+
     #[test]
     fn callop_error_depth() {
         let callee_code = bytecode! {
@@ -1632,6 +1672,30 @@ mod test_precompiles {
     };
     use paste::paste;
 
+    // FIXME: enable this test
+    #[ignore]
+    #[test]
+    fn call_precompile_with_value() {
+        let callee_code = bytecode! {
+            .op_call(0xc350, 0x4, 0x13, 0x0, 0x0, 0x0, 0x0)
+        };
+
+        let ctx = TestContext::<2, 1>::new(
+            None,
+            account_0_code_account_1_no_code(callee_code),
+            tx_from_1_to_0,
+            |block, _tx| block.number(0xcafeu64),
+        )
+        .unwrap();
+
+        CircuitTestBuilder::new_from_test_ctx(ctx)
+            .params(CircuitsParams {
+                max_rws: 500,
+                ..Default::default()
+            })
+            .run();
+    }
+
     fn test_precompile_inner(arg: PrecompileCallArgs, call_op: &OpcodeId) {
         let code = arg.with_call_op(*call_op);
         let ctx = TestContext::<2, 1>::new(