new(tests): Backfill tests for OOGing on constant gas

pdobacz · pdobacz · commit 613cffecf2c3 · 2025-10-20T17:33:23.000+02:00
diff --git a/tests/frontier/opcodes/test_all_opcodes.py b/tests/frontier/opcodes/test_all_opcodes.py
@@ -19,24 +19,20 @@
 )
 from ethereum_test_vm import Opcode, UndefinedOpcodes
 from ethereum_test_vm import Opcodes as Op
+from tests.unscheduled.eip7692_eof_v1.eip3540_eof_v1.opcodes import V1_EOF_ONLY_OPCODES
+from tests.unscheduled.eip7692_eof_v1.gas_test import gas_test
 
 REFERENCE_SPEC_GIT_PATH = "N/A"
 REFERENCE_SPEC_VERSION = "N/A"
 
 
 def prepare_stack(opcode: Opcode) -> Bytecode:
     """Prepare valid stack for opcode."""
-    if opcode == Op.CREATE:
-        return Op.MSTORE(0, 0x6001600155) + Op.PUSH1(5) + Op.PUSH1(27) + Op.PUSH1(5)
-    if opcode == Op.CREATE2:
-        return Op.MSTORE(0, 0x6001600155) + Op.PUSH1(1) + Op.PUSH1(5) + Op.PUSH1(27) + Op.PUSH1(5)
     if opcode == Op.JUMPI:
-        return Op.PUSH1(1) + Op.PUSH1(5)
+        return Op.PUSH1(1) + Op.PUSH1(3) + Op.PC + Op.ADD
     if opcode == Op.JUMP:
-        return Op.PUSH1(3)
-    if opcode == Op.RETURNDATACOPY:
-        return Op.PUSH1(0) * 3
-    return Op.PUSH1(0x01) * 32
+        return Op.PUSH1(3) + Op.PC + Op.ADD
+    return Op.PUSH1(0x00) * 32
 
 
 def prepare_suffix(opcode: Opcode) -> Bytecode:
@@ -122,3 +118,161 @@ def test_cover_revert(state_test: StateTestFiller, pre: Alloc) -> None:
     )
 
     state_test(env=Environment(), pre=pre, post={}, tx=tx)
+
+
+opcode_to_gas = {
+    Op.ADD: 3,
+    Op.MUL: 5,
+    Op.SUB: 3,
+    Op.DIV: 5,
+    Op.SDIV: 5,
+    Op.MOD: 5,
+    Op.SMOD: 5,
+    Op.ADDMOD: 8,
+    Op.MULMOD: 8,
+    Op.EXP: 10,
+    Op.SIGNEXTEND: 5,
+    Op.LT: 3,
+    Op.GT: 3,
+    Op.SLT: 3,
+    Op.SGT: 3,
+    Op.EQ: 3,
+    Op.ISZERO: 3,
+    Op.AND: 3,
+    Op.OR: 3,
+    Op.XOR: 3,
+    Op.NOT: 3,
+    Op.BYTE: 3,
+    Op.SHL: 3,
+    Op.SHR: 3,
+    Op.SAR: 3,
+    Op.CLZ: 5,
+    Op.SHA3: 30,
+    Op.ADDRESS: 2,
+    Op.BALANCE: 100,
+    Op.ORIGIN: 2,
+    Op.CALLER: 2,
+    Op.CALLVALUE: 2,
+    Op.CALLDATALOAD: 3,
+    Op.CALLDATASIZE: 2,
+    Op.CALLDATACOPY: 3,
+    Op.CODESIZE: 2,
+    Op.CODECOPY: 3,
+    Op.GASPRICE: 2,
+    Op.EXTCODESIZE: 100,
+    Op.EXTCODECOPY: 100,
+    Op.RETURNDATASIZE: 2,
+    Op.RETURNDATACOPY: 3,
+    Op.EXTCODEHASH: 100,
+    Op.BLOCKHASH: 20,
+    Op.COINBASE: 2,
+    Op.TIMESTAMP: 2,
+    Op.NUMBER: 2,
+    Op.PREVRANDAO: 2,
+    Op.GASLIMIT: 2,
+    Op.CHAINID: 2,
+    Op.SELFBALANCE: 5,
+    Op.BASEFEE: 2,
+    Op.BLOBHASH: 3,
+    Op.BLOBBASEFEE: 2,
+    Op.POP: 2,
+    Op.MLOAD: 3,
+    Op.MSTORE: 3,
+    Op.MSTORE8: 3,
+    Op.SLOAD: 100,
+    Op.JUMP: 8,
+    Op.JUMPI: 10,
+    Op.PC: 2,
+    Op.MSIZE: 2,
+    Op.GAS: 2,
+    Op.JUMPDEST: 1,
+    Op.TLOAD: 100,
+    Op.TSTORE: 100,
+    Op.MCOPY: 3,
+    Op.PUSH0: 2,
+    Op.LOG0: 375,
+    Op.LOG1: 2 * 375,
+    Op.LOG2: 3 * 375,
+    Op.LOG3: 4 * 375,
+    Op.LOG4: 5 * 375,
+    Op.CREATE: 32000,
+    Op.CALL: 100,
+    Op.CALLCODE: 100,
+    Op.DELEGATECALL: 100,
+    Op.CREATE2: 32000,
+    Op.STATICCALL: 100,
+    Op.SELFDESTRUCT: 5000,
+}
+
+# PUSHx, SWAPx, DUPx have uniform gas costs
+for opcode in set(Op):
+    if 0x60 <= opcode.int() <= 0x9F:
+        opcode_to_gas[opcode] = 3
+
+constant_gas_opcodes = (
+    set(Op)
+    -
+    # zero constant gas opcodes - untestable
+    {Op.STOP, Op.RETURN, Op.REVERT, Op.INVALID}
+    -
+    # TODO: EOF opcodes. Remove once EOF is removed
+    set(V1_EOF_ONLY_OPCODES)
+    -
+    # SSTORE - untestable due to 2300 gas stipend rule
+    {Op.SSTORE}
+)
+
+
+# NOTE: Gas costs varying across forks not being supported yet would make this
+# test very complex.
+@pytest.mark.valid_at("Osaka")
+@pytest.mark.parametrize("opcode", sorted(constant_gas_opcodes))
+def test_constant_gas(
+    state_test: StateTestFiller, pre: Alloc, opcode: Op, fork: Fork, env: Environment
+) -> None:
+    """Test that constant gas opcodes work as expected."""
+    warm_gas = opcode_to_gas[opcode]
+    cold_gas = warm_gas + (
+        2500
+        if opcode
+        in [
+            Op.BALANCE,
+            Op.EXTCODESIZE,
+            Op.EXTCODECOPY,
+            Op.EXTCODEHASH,
+            Op.CALL,
+            Op.CALLCODE,
+            Op.DELEGATECALL,
+            Op.STATICCALL,
+        ]
+        else 2600
+        if opcode == Op.SELFDESTRUCT
+        else 2000
+        if opcode == Op.SLOAD
+        else 0
+    )
+
+    if fork.transaction_gas_limit_cap():
+        env.gas_limit = fork.transaction_gas_limit_cap()
+
+    # Using `TLOAD` / `TSTORE` to work around warm/cold gas differences. We
+    # need a counter to pick a distinct salt on each `CREATE2` and avoid
+    # running into address conflicts.
+    code_increment_counter = Op.TLOAD(1234) + Op.DUP1 + Op.TSTORE(1234, Op.PUSH1(1) + Op.ADD)
+    setup_code = (
+        Op.MLOAD(0)
+        + Op.POP
+        + prepare_stack(opcode)
+        + (code_increment_counter if opcode == Op.CREATE2 else Bytecode())
+    )
+    gas_test(
+        state_test,
+        env,
+        pre,
+        setup_code=setup_code,
+        subject_code=opcode,
+        tear_down_code=prepare_suffix(opcode),
+        cold_gas=cold_gas,
+        warm_gas=warm_gas,
+        eof=False,
+    )
diff --git a/tests/unscheduled/eip7692_eof_v1/eip3540_eof_v1/opcodes.py b/tests/unscheduled/eip7692_eof_v1/eip3540_eof_v1/opcodes.py
@@ -212,6 +212,7 @@
     Op.EXTCALL,
     Op.EXTDELEGATECALL,
     Op.EXTSTATICCALL,
+    Op.RETURNDATALOAD,
     # EIP-7480 EOF Data Section Access
     Op.DATALOAD,
     Op.DATALOADN,
@@ -220,6 +221,8 @@
     # EIP-7620 EOF Create and Return Contract operation
     Op.EOFCREATE,
     Op.RETURNCODE,
+    # EIP-7873 TXCREATE and InitcodeTransaction
+    Op.TXCREATE,
 ]
 """
 List of valid EOF V1 opcodes that are disabled in legacy bytecode.
diff --git a/tests/unscheduled/eip7692_eof_v1/gas_test.py b/tests/unscheduled/eip7692_eof_v1/gas_test.py
@@ -39,6 +39,7 @@ def gas_test(
     out_of_gas_testing: bool = True,
     *,
     prelude_code: Bytecode | None = None,
+    eof: bool = True,
 ) -> None:
     """
     Create State Test to check the gas cost of a sequence of EOF code.
@@ -54,16 +55,22 @@ def gas_test(
 
     sender = pre.fund_eoa()
 
-    address_baseline = pre.deploy_contract(Container.Code(setup_code + tear_down_code))
+    address_baseline = pre.deploy_contract(
+        Container.Code(setup_code + tear_down_code) if eof else setup_code + tear_down_code
+    )
     code_subject = setup_code + subject_code + tear_down_code
     address_subject = pre.deploy_contract(
-        Container.Code(code_subject)
-        if not subject_subcontainer
-        else Container(
-            sections=[
-                Section.Code(code_subject),
-                Section.Container(subject_subcontainer),
-            ]
+        code_subject
+        if not eof
+        else (
+            Container.Code(code_subject)
+            if not subject_subcontainer
+            else Container(
+                sections=[
+                    Section.Code(code_subject),
+                    Section.Container(subject_subcontainer),
+                ]
+            )
         ),
         balance=subject_balance,
         address=subject_address,
