Update callcode test (#3214)

* Update callcode test with clearer results

* lint

* Address feedback

* evm: squash call(code) test

---------

Co-authored-by: Jochem Brouwer <[email protected]>

Author: acolytec3

packages/evm/test/runCall.spec.ts

@@ -2,14 +2,14 @@ import { Chain, Common, Hardfork } from '@ethereumjs/common'
 import {
   Account,
   Address,
-  BIGINT_100,
   MAX_UINT64,
   bytesToBigInt,
   bytesToHex,
   concatBytes,
   hexToBytes,
   padToEven,
   unpadBytes,
+  zeros,
 } from '@ethereumjs/util'
 import { keccak256 } from 'ethereum-cryptography/keccak.js'
 import { assert, describe, it } from 'vitest'
@@ -724,38 +724,68 @@ describe('RunCall tests', () => {
     const evm = new EVM({
       common,
     })
-    for (const opcode of ['f1', 'f2']) {
-      // Code to either CALL or CALLCODE into the own address, with value 1
-      // JUMPDEST added at the start to track how much CALL(CODE)s are made
-      const contractCode = hexToBytes(`0x5B6000808080600130611a90${opcode}`)
-      const contractAddress = Address.fromString('0x000000000000000000000000636F6E7472616374')
-      await evm.stateManager.putContractCode(contractAddress, contractCode)
 
-      const account = await evm.stateManager.getAccount(contractAddress)
-      account!.balance = BIGINT_100
-
-      await evm.stateManager.putAccount(contractAddress, account)
+    for (const [opcode, gas, expectedOutput] of [
+      ['f1', 36600, '0x'], // 36600 is CALL fee
+      ['f2', 11600, '0x'], // 11600 is CALLCODE fee
+      ['f1', 36600 + 7 * 3, '0x01'], // 36600 is CALL fee + 7 * 3 gas for 7 PUSH opcodes
+      ['f2', 11600 + 7 * 3, '0x01'], // 11600 is CALLCODE fee + 7 * 3 gas for 7 PUSH opcodes
+    ]) {
+      // Code to either CALL or CALLCODE into AACC empty contract, with value 1
+      // If enough gas is provided, then since nonzero value is sent, the gas limit
+      // in the call(coded) contract will get the "bonus gas" stipend of 2300
+      // Previously, we added this gas stipend to the current gas available (which is wrong)
+
+      /***
+       * Bytecode for AAAA contract (used to check CALL/CALLCODE execution when gas is less than required)
+       * PUSH1 0x00
+       * PUSH1 0x00
+       * PUSH1 0x00
+       * PUSH1 0x00
+       * PUSH1 0x01
+       * PUSH2 0xAACC
+       * PUSH2 0x1a90 // Note: this is the gas available in the new call(code) frame, this value does not matter
+       * CALLCODE/CALL
+       */
+      const callCodeAddress = Address.fromString('0x000000000000000000000000000000000000aaaa')
+      const callCode = hexToBytes(`0x6000600060006000600161AACC611a90${opcode}`)
+
+      const gasLimit = gas.toString(16).padStart(4, '0')
+
+      /***
+       * Bytecode for AAAB contract (used to call contract AAAA and stores result of call execution)
+       * PUSH1 0x00
+       * DUP1
+       * DUP1
+       * DUP1
+       * DUP1
+       * PUSH2 0xAAAA
+       * PUSH2 0x{gas}  <- This is the gas limit set for the CALL/CODE execution
+       * CALL
+       * PUSH1 0x00
+       * SSTORE
+       */
+      const callerAddress = Address.fromString('0x000000000000000000000000000000000000aaab')
+      const callerCode = hexToBytes(`0x60008080808061AAAA61${gasLimit}f1600055`)
+
+      await evm.stateManager.putAccount(callCodeAddress, new Account())
+      await evm.stateManager.putContractCode(callCodeAddress, callCode)
+
+      await evm.stateManager.putAccount(callerAddress, new Account(undefined, BigInt(1)))
+      await evm.stateManager.putContractCode(callerAddress, callerCode)
 
       const runCallArgs = {
-        gasLimit: BigInt(50000 - 21000),
-        to: contractAddress,
+        to: callerAddress,
+        gasLimit: 0xfffffffn,
       }
-
-      let jumpdestCalls = 0
-
-      evm.events.on('step', (e) => {
-        if (e.opcode.name === 'JUMPDEST') {
-          jumpdestCalls++
-        }
-      })
-
       await evm.runCall(runCallArgs)
-      // JUMPDEST should be called twice:
-      // 1: call into the contract (externally, via tx)
-      // 2: call(code) into the contract (internally)
-      // If jumpdest would run >=3 times, it means the (2) has enough gas to pay for CALL(CODE)
-      // This is not correct
-      assert.ok(jumpdestCalls === 2, 'called JUMPDEST twice')
+
+      const callResult = bytesToHex(
+        await evm.stateManager.getContractStorage(callerAddress, zeros(32))
+      )
+      // Expect slot to have value of either: 0 since CALLCODE and CODE did not have enough gas to execute
+      // Or 1, if CALL(CODE) has enough gas to enter the new call frame
+      assert.equal(callResult, expectedOutput, `should have result ${expectedOutput}`)
     }
   })
 })