feat(tests): make tests dependent on MAX_CODE_SIZE now depend on the fork-based max code size

Author: jochem-brouwer

tests/zkevm/test_worst_compute.py

@@ -38,7 +38,6 @@
 REFERENCE_SPEC_GIT_PATH = "TODO"
 REFERENCE_SPEC_VERSION = "TODO"
 
-MAX_CODE_SIZE = 24 * 1024
 KECCAK_RATE = 136
 
 
@@ -73,6 +72,8 @@ def test_worst_keccak(
     gsc = fork.gas_costs()
     mem_exp_gas_calculator = fork.memory_expansion_gas_calculator()
 
+    max_code_size = fork.max_code_size()
+
     # Discover the optimal input size to maximize keccak-permutations, not keccak calls.
     # The complication of the discovery arises from the non-linear gas cost of memory expansion.
     max_keccak_perm_per_block = 0
@@ -103,18 +104,18 @@ def test_worst_keccak(
     # The loop structure is: JUMPDEST + [attack iteration] + PUSH0 + JUMP
     #
     # Now calculate available gas for [attack iteration]:
-    #   Numerator = MAX_CODE_SIZE-3. The -3 is for the JUMPDEST, PUSH0 and JUMP.
+    #   Numerator = max_code_size-3. The -3 is for the JUMPDEST, PUSH0 and JUMP.
     #   Denominator = (PUSHN + PUSH1 + KECCAK256 + POP) + PUSH1_DATA + PUSHN_DATA
     # TODO: the testing framework uses PUSH1(0) instead of PUSH0 which is suboptimal for the
     # attack, whenever this is fixed adjust accordingly.
     start_code = Op.JUMPDEST + Op.PUSH20[optimal_input_length]
     loop_code = Op.POP(Op.SHA3(Op.PUSH0, Op.DUP1))
     end_code = Op.POP + Op.JUMP(Op.PUSH0)
-    max_iters_loop = (MAX_CODE_SIZE - (len(start_code) + len(end_code))) // len(loop_code)
+    max_iters_loop = (max_code_size - (len(start_code) + len(end_code))) // len(loop_code)
     code = start_code + (loop_code * max_iters_loop) + end_code
-    if len(code) > MAX_CODE_SIZE:
+    if len(code) > max_code_size:
         # Must never happen, but keep it as a sanity check.
-        raise ValueError(f"Code size {len(code)} exceeds maximum code size {MAX_CODE_SIZE}")
+        raise ValueError(f"Code size {len(code)} exceeds maximum code size {max_code_size}")
 
     code_address = pre.deploy_contract(code=bytes(code))
 
@@ -461,37 +462,37 @@ def test_worst_precompile_fixed_cost(
     )
 
 
-def code_loop_precompile_call(calldata: Bytecode, attack_block: Bytecode):
+def code_loop_precompile_call(calldata: Bytecode, attack_block: Bytecode, fork: Fork):
     """Create a code loop that calls a precompile with the given calldata."""
+    max_code_size = fork.max_code_size()
+
     # The attack contract is: CALLDATA_PREP + #JUMPDEST + [attack_block]* + JUMP(#)
     jumpdest = Op.JUMPDEST
     jump_back = Op.JUMP(len(calldata))
-    max_iters_loop = (MAX_CODE_SIZE - len(calldata) - len(jumpdest) - len(jump_back)) // len(
+    max_iters_loop = (max_code_size - len(calldata) - len(jumpdest) - len(jump_back)) // len(
         attack_block
     )
     code = calldata + jumpdest + sum([attack_block] * max_iters_loop) + jump_back
-    if len(code) > MAX_CODE_SIZE:
+    if len(code) > max_code_size:
         # Must never happen, but keep it as a sanity check.
-        raise ValueError(f"Code size {len(code)} exceeds maximum code size {MAX_CODE_SIZE}")
+        raise ValueError(f"Code size {len(code)} exceeds maximum code size {max_code_size}")
 
     return code
 
 
 @pytest.mark.zkevm
 @pytest.mark.valid_from("Cancun")
 @pytest.mark.slow
-def test_worst_jumps(
-    state_test: StateTestFiller,
-    pre: Alloc,
-):
+def test_worst_jumps(state_test: StateTestFiller, pre: Alloc, fork: Fork):
     """Test running a JUMP-intensive contract."""
     env = Environment()
+    max_code_size = fork.max_code_size()
 
     def jump_seq():
         return Op.JUMP(Op.ADD(Op.PC, 1)) + Op.JUMPDEST
 
     bytes_per_seq = len(jump_seq())
-    seqs_per_call = MAX_CODE_SIZE // bytes_per_seq
+    seqs_per_call = max_code_size // bytes_per_seq
 
     # Create and deploy the jump-intensive contract
     jumps_code = sum([jump_seq() for _ in range(seqs_per_call)])
@@ -518,15 +519,13 @@ def jump_seq():
 @pytest.mark.zkevm
 @pytest.mark.valid_from("Cancun")
 @pytest.mark.slow
-def test_worst_jumpdests(
-    state_test: StateTestFiller,
-    pre: Alloc,
-):
+def test_worst_jumpdests(state_test: StateTestFiller, pre: Alloc, fork: Fork):
     """Test running a JUMPDEST-intensive contract."""
     env = Environment()
+    max_code_size = fork.max_code_size()
 
     # Create and deploy a contract with many JUMPDESTs
-    jumpdests_code = sum([Op.JUMPDEST] * MAX_CODE_SIZE)
+    jumpdests_code = sum([Op.JUMPDEST] * max_code_size)
     jumpdests_address = pre.deploy_contract(code=bytes(jumpdests_code))
 
     # Call the contract repeatedly until gas runs out.
@@ -671,26 +670,24 @@ def test_worst_jumpdests(
     ids=lambda param: "" if isinstance(param, tuple) else param,
 )
 def test_worst_binop_simple(
-    state_test: StateTestFiller,
-    pre: Alloc,
-    opcode: Op,
-    opcode_args: tuple[int, int],
+    state_test: StateTestFiller, pre: Alloc, opcode: Op, fork: Fork, opcode_args: tuple[int, int]
 ):
     """
     Test running a block with as many binary instructions (takes two args, produces one value)
     as possible. The execution starts with two initial values on the stack, and the stack is
     balanced by the DUP2 instruction.
     """
     env = Environment()
+    max_code_size = fork.max_code_size()
 
     tx_data = b"".join(arg.to_bytes(32, byteorder="big") for arg in opcode_args)
 
     code_prefix = Op.JUMPDEST + Op.CALLDATALOAD(0) + Op.CALLDATALOAD(32)
     code_suffix = Op.POP + Op.POP + Op.PUSH0 + Op.JUMP
-    code_body_len = MAX_CODE_SIZE - len(code_prefix) - len(code_suffix)
+    code_body_len = max_code_size - len(code_prefix) - len(code_suffix)
     code_body = (Op.DUP2 + opcode) * (code_body_len // 2)
     code = code_prefix + code_body + code_suffix
-    assert len(code) == MAX_CODE_SIZE - 1
+    assert len(code) == max_code_size - 1
 
     tx = Transaction(
         to=pre.deploy_contract(code=code),
@@ -709,23 +706,20 @@ def test_worst_binop_simple(
 
 @pytest.mark.valid_from("Cancun")
 @pytest.mark.parametrize("opcode", [Op.ISZERO, Op.NOT])
-def test_worst_unop(
-    state_test: StateTestFiller,
-    pre: Alloc,
-    opcode: Op,
-):
+def test_worst_unop(state_test: StateTestFiller, pre: Alloc, opcode: Op, fork: Fork):
     """
     Test running a block with as many unary instructions (takes one arg, produces one value)
     as possible.
     """
     env = Environment()
+    max_code_size = fork.max_code_size()
 
     code_prefix = Op.JUMPDEST + Op.PUSH0  # Start with the arg 0.
     code_suffix = Op.POP + Op.PUSH0 + Op.JUMP
-    code_body_len = MAX_CODE_SIZE - len(code_prefix) - len(code_suffix)
+    code_body_len = max_code_size - len(code_prefix) - len(code_suffix)
     code_body = opcode * code_body_len
     code = code_prefix + code_body + code_suffix
-    assert len(code) == MAX_CODE_SIZE
+    assert len(code) == max_code_size
 
     tx = Transaction(
         to=pre.deploy_contract(code=code),
@@ -746,13 +740,15 @@ def test_worst_unop(
 def test_worst_shifts(
     state_test: StateTestFiller,
     pre: Alloc,
+    fork: Fork,
     shift_right: Op,
 ):
     """
     Test running a block with as many shift instructions with non-trivial arguments.
     This test generates left-right pairs of shifts to avoid zeroing the argument.
     The shift amounts are randomly pre-selected from the constant pool of 15 values on the stack.
     """
+    max_code_size = fork.max_code_size()
 
     def to_signed(x):
         return x if x < 2**255 else x - 2**256
@@ -786,7 +782,7 @@ def sar(x, s):
 
     code_prefix = sum(Op.PUSH1[sh] for sh in shift_amounts) + Op.JUMPDEST + Op.CALLDATALOAD(0)
     code_suffix = Op.POP + Op.JUMP(len(shift_amounts) * 2)
-    code_body_len = MAX_CODE_SIZE - len(code_prefix) - len(code_suffix)
+    code_body_len = max_code_size - len(code_prefix) - len(code_suffix)
 
     def select_shift_amount(shift_fn, v):
         """Select a shift amount that will produce a non-zero result."""
@@ -806,7 +802,7 @@ def select_shift_amount(shift_fn, v):
         code_body += make_dup(len(shift_amounts) - i) + shift_right
 
     code = code_prefix + code_body + code_suffix
-    assert len(code) == MAX_CODE_SIZE - 2
+    assert len(code) == max_code_size - 2
 
     env = Environment()
 
@@ -844,14 +840,15 @@ def test_worst_blobhash(
 ):
     """Test running a block with as many BLOBHASH instructions as possible."""
     env = Environment()
+    max_code_size = fork.max_code_size()
 
     code_prefix = Op.PUSH1(blob_index) + Op.JUMPDEST
     code_suffix = Op.JUMP(len(code_prefix) - 1)
     loop_iter = Op.POP(Op.BLOBHASH(Op.DUP1))
-    code_body_len = (MAX_CODE_SIZE - len(code_prefix) - len(code_suffix)) // len(loop_iter)
+    code_body_len = (max_code_size - len(code_prefix) - len(code_suffix)) // len(loop_iter)
     code_body = loop_iter * code_body_len
     code = code_prefix + code_body + code_suffix
-    assert len(code) <= MAX_CODE_SIZE
+    assert len(code) <= max_code_size
 
     tx_type = TransactionType.LEGACY
     blob_versioned_hashes = None
@@ -887,6 +884,7 @@ def test_worst_blobhash(
 def test_worst_mod(
     state_test: StateTestFiller,
     pre: Alloc,
+    fork: Fork,
     mod_bits: int,
     op: Op,
 ):
@@ -900,6 +898,8 @@ def test_worst_mod(
     The order of accessing the numerators is selected in a way the mod value remains in the range
     as long as possible.
     """
+    max_code_size = fork.max_code_size()
+
     # For SMOD we negate both numerator and modulus. The underlying computation is the same,
     # just the SMOD implementation will have to additionally handle the sign bits.
     # The result stays negative.
@@ -973,7 +973,7 @@ def test_worst_mod(
     code_constant_pool = sum((Op.PUSH32[n] for n in numerators), Bytecode())
     code_prefix = code_constant_pool + Op.JUMPDEST
     code_suffix = Op.JUMP(len(code_constant_pool))
-    code_body_len = MAX_CODE_SIZE - len(code_prefix) - len(code_suffix)
+    code_body_len = max_code_size - len(code_prefix) - len(code_suffix)
     code_segment = (
         Op.CALLDATALOAD(0) + sum(make_dup(len(numerators) - i) + op for i in indexes) + Op.POP
     )
@@ -983,7 +983,7 @@ def test_worst_mod(
         + sum(code_segment for _ in range(code_body_len // len(code_segment)))
         + code_suffix
     )
-    assert (MAX_CODE_SIZE - len(code_segment)) < len(code) <= MAX_CODE_SIZE
+    assert (max_code_size - len(code_segment)) < len(code) <= max_code_size
 
     env = Environment()
 
@@ -1011,13 +1011,15 @@ def test_worst_mod(
 def test_worst_memory_access(
     state_test: StateTestFiller,
     pre: Alloc,
+    fork: Fork,
     opcode: Op,
     offset: int,
     offset_initialized: bool,
     big_memory_expansion: bool,
 ):
     """Test running a block with as many memory access instructions as possible."""
     env = Environment()
+    max_code_size = fork.max_code_size()
 
     mem_exp_code = Op.MSTORE8(10 * 1024, 1) if big_memory_expansion else Bytecode()
     offset_set_code = Op.MSTORE(offset, 43) if offset_initialized else Bytecode()
@@ -1027,10 +1029,10 @@ def test_worst_memory_access(
 
     loop_iter = Op.POP(Op.MLOAD(Op.DUP1)) if opcode == Op.MLOAD else opcode(Op.DUP2, Op.DUP2)
 
-    code_body_len = (MAX_CODE_SIZE - len(code_prefix) - len(code_suffix)) // len(loop_iter)
+    code_body_len = (max_code_size - len(code_prefix) - len(code_suffix)) // len(loop_iter)
     code_body = loop_iter * code_body_len
     code = code_prefix + code_body + code_suffix
-    assert len(code) <= MAX_CODE_SIZE
+    assert len(code) <= max_code_size
 
     tx = Transaction(
         to=pre.deploy_contract(code=code),
@@ -1177,14 +1179,15 @@ def test_worst_calldataload(
 ):
     """Test running a block with as many CALLDATALOAD as possible."""
     env = Environment()
+    max_code_size = fork.max_code_size()
 
     code_prefix = Op.PUSH0 + Op.JUMPDEST
     code_suffix = Op.PUSH1(1) + Op.JUMP
-    code_body_len = MAX_CODE_SIZE - len(code_prefix) - len(code_suffix)
+    code_body_len = max_code_size - len(code_prefix) - len(code_suffix)
     code_loop_iter = Op.CALLDATALOAD
     code_body = code_loop_iter * (code_body_len // len(code_loop_iter))
     code = code_prefix + code_body + code_suffix
-    assert len(code) <= MAX_CODE_SIZE
+    assert len(code) <= max_code_size
 
     tx = Transaction(
         to=pre.deploy_contract(code=code),

tests/zkevm/test_worst_stateful_opcodes.py

@@ -26,8 +26,6 @@
 REFERENCE_SPEC_GIT_PATH = "TODO"
 REFERENCE_SPEC_VERSION = "TODO"
 
-MAX_CODE_SIZE = 24 * 1024
-
 
 @pytest.mark.valid_from("Cancun")
 @pytest.mark.parametrize(
@@ -137,11 +135,13 @@ def test_worst_address_state_cold(
 def test_worst_address_state_warm(
     state_test: StateTestFiller,
     pre: Alloc,
+    fork: Fork,
     opcode: Op,
     absent_target: bool,
 ):
     """Test running a block with as many stateful opcodes doing warm access for an account."""
     env = Environment(gas_limit=100_000_000_000)
+    max_code_size = fork.max_code_size()
     attack_gas_limit = Environment().gas_limit
 
     # Setup
@@ -157,13 +157,13 @@ def test_worst_address_state_warm(
     jumpdest = Op.JUMPDEST
     jump_back = Op.JUMP(len(prep))
     iter_block = Op.POP(opcode(address=Op.MLOAD(0)))
-    max_iters_loop = (MAX_CODE_SIZE - len(prep) - len(jumpdest) - len(jump_back)) // len(
+    max_iters_loop = (max_code_size - len(prep) - len(jumpdest) - len(jump_back)) // len(
         iter_block
     )
     op_code = prep + jumpdest + sum([iter_block] * max_iters_loop) + jump_back
-    if len(op_code) > MAX_CODE_SIZE:
+    if len(op_code) > max_code_size:
         # Must never happen, but keep it as a sanity check.
-        raise ValueError(f"Code size {len(op_code)} exceeds maximum code size {MAX_CODE_SIZE}")
+        raise ValueError(f"Code size {len(op_code)} exceeds maximum code size {max_code_size}")
     op_address = pre.deploy_contract(code=op_code)
     tx = Transaction(
         to=op_address,