refactor(tests): Rename stack height constants

Rename `MAX_RUNTIME_OPERAND_STACK_HEIGHT` to `MAX_RUNTIME_STACK_HEIGHT`
and move it to the ethereum_test_types.eof.
Rename `MAX_OPERAND_STACK_HEIGHT` to `MAX_STACK_INCREASE_LIMIT`
to indicate it is related specifically to the EOF container format.

Author: chfast

src/ethereum_test_tools/eof/v1/constants.py

@@ -10,9 +10,9 @@
     MAX_CODE_OUTPUTS,
     MAX_CODE_SECTIONS,
     MAX_INITCODE_SIZE,
-    MAX_OPERAND_STACK_HEIGHT,
     MAX_RETURN_STACK_HEIGHT,
     MAX_RJUMPV_COUNT,
+    MAX_STACK_INCREASE_LIMIT,
     NON_RETURNING_SECTION,
     TYPES_INPUTS_BYTE_LENGTH,
     TYPES_OUTPUTS_BYTE_LENGTH,
@@ -31,7 +31,7 @@
     "MAX_CODE_OUTPUTS",
     "MAX_CODE_SECTIONS",
     "MAX_INITCODE_SIZE",
-    "MAX_OPERAND_STACK_HEIGHT",
+    "MAX_STACK_INCREASE_LIMIT",
     "MAX_RETURN_STACK_HEIGHT",
     "MAX_RJUMPV_COUNT",
     "NON_RETURNING_SECTION",

src/ethereum_test_types/eof/constants.py

@@ -20,3 +20,10 @@
 """
 Length of the version byte.
 """
+
+MAX_RUNTIME_STACK_HEIGHT = 1024
+"""
+Maximum height of the EVM runtime operand stack.
+Exceeding this value during execution will result in the stack overflow exception.
+This value applies to both legacy EVM and EOF.
+"""

src/ethereum_test_types/eof/v1/constants.py

@@ -13,7 +13,10 @@
 
 MAX_RETURN_STACK_HEIGHT = 1024
 
-MAX_OPERAND_STACK_HEIGHT = 1023
+MAX_STACK_INCREASE_LIMIT = 0x3FF
+"""
+Maximum value for the max stack increase accepted by the EOF format.
+"""
 
 MAX_CODE_INPUTS = 127
 

tests/osaka/eip7692_eof_v1/eip3540_eof_v1/test_all_opcodes_in_container.py

@@ -8,7 +8,8 @@
 from ethereum_test_tools import EOFException, EOFTestFiller, Opcode, UndefinedOpcodes
 from ethereum_test_tools import Opcodes as Op
 from ethereum_test_tools.eof.v1 import Container, ContainerKind, Section
-from ethereum_test_tools.eof.v1.constants import MAX_OPERAND_STACK_HEIGHT
+from ethereum_test_tools.eof.v1.constants import MAX_STACK_INCREASE_LIMIT
+from ethereum_test_types.eof.constants import MAX_RUNTIME_STACK_HEIGHT
 from ethereum_test_vm import Bytecode
 
 from .. import EOF_FORK_NAME
@@ -337,7 +338,7 @@ def test_all_opcodes_stack_overflow(
     opcode = opcode[0] if opcode.has_data_portion() else opcode
 
     assert opcode.pushed_stack_items - opcode.popped_stack_items == 1
-    opcode_count = MAX_OPERAND_STACK_HEIGHT + 1 - opcode.min_stack_height
+    opcode_count = MAX_RUNTIME_STACK_HEIGHT - opcode.min_stack_height
 
     bytecode = Op.PUSH0 * opcode.min_stack_height
     bytecode += opcode * opcode_count
@@ -347,7 +348,7 @@ def test_all_opcodes_stack_overflow(
 
     if exception == EOFException.INVALID_MAX_STACK_INCREASE:
         # Lie about the max stack height to make the code be checked for stack overflow.
-        kwargs["max_stack_height"] = MAX_OPERAND_STACK_HEIGHT
+        kwargs["max_stack_height"] = MAX_STACK_INCREASE_LIMIT
 
     sections = [Section.Code(**kwargs)]
 

tests/osaka/eip7692_eof_v1/eip3540_eof_v1/test_container_validation.py

@@ -16,7 +16,7 @@
     MAX_CODE_INPUTS,
     MAX_CODE_OUTPUTS,
     MAX_CODE_SECTIONS,
-    MAX_OPERAND_STACK_HEIGHT,
+    MAX_STACK_INCREASE_LIMIT,
 )
 from ethereum_test_tools.vm.opcode import Opcodes as Op
 
@@ -37,10 +37,10 @@
             name="single_code_section_max_stack_size",
             sections=[
                 Section.Code(
-                    code=(Op.CALLER * MAX_OPERAND_STACK_HEIGHT)
-                    + (Op.POP * MAX_OPERAND_STACK_HEIGHT)
+                    code=(Op.CALLER * MAX_STACK_INCREASE_LIMIT)
+                    + (Op.POP * MAX_STACK_INCREASE_LIMIT)
                     + Op.STOP,
-                    max_stack_height=MAX_OPERAND_STACK_HEIGHT,
+                    max_stack_height=MAX_STACK_INCREASE_LIMIT,
                 ),
             ],
         ),

tests/osaka/eip7692_eof_v1/eip4750_functions/test_code_validation.py

@@ -9,18 +9,16 @@
 from ethereum_test_tools.eof.v1.constants import (
     MAX_CODE_OUTPUTS,
     MAX_CODE_SECTIONS,
-    MAX_OPERAND_STACK_HEIGHT,
+    MAX_STACK_INCREASE_LIMIT,
 )
 from ethereum_test_tools.vm.opcode import Opcodes as Op
+from ethereum_test_types.eof.constants import MAX_RUNTIME_STACK_HEIGHT
 
 from .. import EOF_FORK_NAME
 
 REFERENCE_SPEC_GIT_PATH = "EIPS/eip-4750.md"
 REFERENCE_SPEC_VERSION = "14400434e1199c57d912082127b1d22643788d11"
 
-MAX_RUNTIME_OPERAND_STACK_HEIGHT = 1024
-"""Maximum height of the EVM runtime operand stack."""
-
 pytestmark = pytest.mark.valid_from(EOF_FORK_NAME)
 
 VALID: List[Container] = [
@@ -652,12 +650,12 @@ def test_callf_stack_height_limit_exceeded(eof_test, callee_outputs):
     The code reaches the maximum runtime stack height (1024)
     which is above the EOF limit for the stack height in the type section (1023).
     """
-    callf_stack_height = MAX_RUNTIME_OPERAND_STACK_HEIGHT - callee_outputs
+    callf_stack_height = MAX_RUNTIME_STACK_HEIGHT - callee_outputs
     container = Container(
         sections=[
             Section.Code(
                 Op.PUSH0 * callf_stack_height + Op.CALLF[1] + Op.STOP,
-                max_stack_height=MAX_RUNTIME_OPERAND_STACK_HEIGHT,
+                max_stack_height=MAX_RUNTIME_STACK_HEIGHT,
             ),
             Section.Code(
                 Op.PUSH0 * callee_outputs + Op.RETF,
@@ -682,7 +680,7 @@ def test_callf_stack_overflow(eof_test: EOFTestFiller, stack_height: int):
             ),
         ],
     )
-    stack_overflow = stack_height > MAX_RUNTIME_OPERAND_STACK_HEIGHT // 2
+    stack_overflow = stack_height > MAX_RUNTIME_STACK_HEIGHT // 2
     eof_test(
         container=container,
         expect_exception=EOFException.STACK_OVERFLOW if stack_overflow else None,
@@ -707,7 +705,7 @@ def test_callf_stack_overflow_after_callf(eof_test: EOFTestFiller, stack_height:
             ),
         ],
     )
-    stack_overflow = 1023 + stack_height > MAX_RUNTIME_OPERAND_STACK_HEIGHT
+    stack_overflow = 1023 + stack_height > MAX_RUNTIME_STACK_HEIGHT
     eof_test(
         container=container,
         expect_exception=EOFException.STACK_OVERFLOW if stack_overflow else None,
@@ -721,7 +719,7 @@ def test_callf_stack_overflow_variable_stack(eof_test: EOFTestFiller, stack_heig
         sections=[
             Section.Code(
                 code=Op.RJUMPI[2](0)
-                + Op.PUSH0 * (MAX_RUNTIME_OPERAND_STACK_HEIGHT // 2)
+                + Op.PUSH0 * (MAX_RUNTIME_STACK_HEIGHT // 2)
                 + Op.CALLF[1]
                 + Op.STOP,
                 max_stack_height=512,
@@ -733,7 +731,7 @@ def test_callf_stack_overflow_variable_stack(eof_test: EOFTestFiller, stack_heig
             ),
         ],
     )
-    stack_overflow = stack_height > MAX_RUNTIME_OPERAND_STACK_HEIGHT // 2
+    stack_overflow = stack_height > MAX_RUNTIME_STACK_HEIGHT // 2
     eof_test(
         container=container,
         expect_exception=EOFException.STACK_OVERFLOW if stack_overflow else None,
@@ -749,7 +747,7 @@ def test_callf_stack_overflow_variable_stack_2(eof_test: EOFTestFiller, stack_he
                 code=Op.PUSH0 * 2
                 + Op.RJUMPI[2](0)
                 + Op.POP * 2
-                + Op.PUSH0 * (MAX_RUNTIME_OPERAND_STACK_HEIGHT // 2)
+                + Op.PUSH0 * (MAX_RUNTIME_STACK_HEIGHT // 2)
                 + Op.CALLF[1]
                 + Op.STOP,
                 max_stack_height=514,
@@ -761,7 +759,7 @@ def test_callf_stack_overflow_variable_stack_2(eof_test: EOFTestFiller, stack_he
             ),
         ],
     )
-    stack_overflow = stack_height > (MAX_RUNTIME_OPERAND_STACK_HEIGHT // 2) - 2
+    stack_overflow = stack_height > (MAX_RUNTIME_STACK_HEIGHT // 2) - 2
     eof_test(
         container=container,
         expect_exception=EOFException.STACK_OVERFLOW if stack_overflow else None,
@@ -775,7 +773,7 @@ def test_callf_stack_overflow_variable_stack_3(eof_test: EOFTestFiller, stack_he
         sections=[
             Section.Code(
                 code=Op.RJUMPI[2](0)
-                + Op.PUSH0 * (MAX_RUNTIME_OPERAND_STACK_HEIGHT - 1)
+                + Op.PUSH0 * (MAX_RUNTIME_STACK_HEIGHT - 1)
                 + Op.CALLF[1]
                 + Op.STOP,
                 max_stack_height=1023,
@@ -789,7 +787,7 @@ def test_callf_stack_overflow_variable_stack_3(eof_test: EOFTestFiller, stack_he
     )
     assert container.sections[0].max_stack_height is not None
     stack_overflow = (
-        container.sections[0].max_stack_height + stack_height > MAX_RUNTIME_OPERAND_STACK_HEIGHT
+        container.sections[0].max_stack_height + stack_height > MAX_RUNTIME_STACK_HEIGHT
     )
     eof_test(
         container=container,
@@ -805,7 +803,7 @@ def test_callf_stack_overflow_variable_stack_4(eof_test: EOFTestFiller):
                 code=Op.PUSH0 * 2
                 + Op.RJUMPI[2](0)
                 + Op.POP * 2
-                + Op.PUSH0 * (MAX_RUNTIME_OPERAND_STACK_HEIGHT - 1)
+                + Op.PUSH0 * (MAX_RUNTIME_STACK_HEIGHT - 1)
                 + Op.CALLF[1]
                 + Op.STOP,
                 max_stack_height=1023,
@@ -930,7 +928,7 @@ def test_callf_with_inputs_stack_overflow(
     exception = None
     if (
         push_stack + code_section.max_stack_height - code_section.code_inputs
-        > MAX_RUNTIME_OPERAND_STACK_HEIGHT
+        > MAX_RUNTIME_STACK_HEIGHT
     ):
         exception = EOFException.STACK_OVERFLOW
     elif push_stack - code_section.code_inputs + code_section.code_outputs - pop_stack < 2:
@@ -1061,7 +1059,7 @@ def test_callf_with_inputs_stack_overflow_variable_stack(
     exception = None
     if (
         push_stack + initial_stack + code_section.max_stack_height - code_section.code_inputs
-        > MAX_RUNTIME_OPERAND_STACK_HEIGHT
+        > MAX_RUNTIME_STACK_HEIGHT
     ):
         exception = EOFException.STACK_OVERFLOW
     elif push_stack + initial_stack > 1023:
@@ -1072,7 +1070,7 @@ def test_callf_with_inputs_stack_overflow_variable_stack(
 
 @pytest.mark.parametrize("callee_outputs", [1, 2, MAX_CODE_OUTPUTS - 1, MAX_CODE_OUTPUTS])
 @pytest.mark.parametrize(
-    "max_stack_height", [0, 1, MAX_OPERAND_STACK_HEIGHT - 1, MAX_OPERAND_STACK_HEIGHT]
+    "max_stack_height", [0, 1, MAX_STACK_INCREASE_LIMIT - 1, MAX_STACK_INCREASE_LIMIT]
 )
 def test_callf_stack_overflow_by_outputs(eof_test, callee_outputs, max_stack_height):
     """
@@ -1081,7 +1079,7 @@ def test_callf_stack_overflow_by_outputs(eof_test, callee_outputs, max_stack_hei
     is always above the maximum allowed in the EOF type section. Therefore, the test declares
     an invalid max_stack_height.
     """
-    callf_stack_height = (MAX_RUNTIME_OPERAND_STACK_HEIGHT + 1) - callee_outputs
+    callf_stack_height = (MAX_RUNTIME_STACK_HEIGHT + 1) - callee_outputs
     container = Container(
         sections=[
             Section.Code(
@@ -1100,7 +1098,7 @@ def test_callf_stack_overflow_by_outputs(eof_test, callee_outputs, max_stack_hei
 
 @pytest.mark.parametrize(
     "callee_stack_height",
-    [2, 3, MAX_OPERAND_STACK_HEIGHT - 1, MAX_OPERAND_STACK_HEIGHT],
+    [2, 3, MAX_STACK_INCREASE_LIMIT - 1, MAX_STACK_INCREASE_LIMIT],
 )
 def test_callf_stack_overflow_by_height(eof_test, callee_stack_height):
     """
@@ -1112,8 +1110,8 @@ def test_callf_stack_overflow_by_height(eof_test, callee_stack_height):
     container = Container(
         sections=[
             Section.Code(
-                Op.PUSH0 * MAX_OPERAND_STACK_HEIGHT + Op.CALLF[1] + Op.STOP,
-                max_stack_height=MAX_OPERAND_STACK_HEIGHT,
+                Op.PUSH0 * MAX_STACK_INCREASE_LIMIT + Op.CALLF[1] + Op.STOP,
+                max_stack_height=MAX_STACK_INCREASE_LIMIT,
             ),
             Section.Code(
                 Op.PUSH0 * callee_stack_height + Op.POP * callee_stack_height + Op.RETF,

tests/osaka/eip7692_eof_v1/eip5450_stack/test_code_validation.py

@@ -10,7 +10,7 @@
 from ethereum_test_tools import Account, EOFStateTestFiller, EOFTestFiller
 from ethereum_test_tools.eof.v1 import Container, Section
 from ethereum_test_tools.vm.opcode import Opcodes as Op
-from ethereum_test_types.eof.v1.constants import MAX_OPERAND_STACK_HEIGHT, NON_RETURNING_SECTION
+from ethereum_test_types.eof.v1.constants import MAX_STACK_INCREASE_LIMIT, NON_RETURNING_SECTION
 from ethereum_test_vm.bytecode import Bytecode
 
 from .. import EOF_FORK_NAME
@@ -457,7 +457,7 @@ def gen_stack_underflow_params():
             yield op, op.min_stack_height - 1
 
 
-@pytest.mark.parametrize("spread", [-1, 0, 1, MAX_OPERAND_STACK_HEIGHT])
+@pytest.mark.parametrize("spread", [-1, 0, 1, MAX_STACK_INCREASE_LIMIT])
 @pytest.mark.parametrize("op,stack_height", gen_stack_underflow_params())
 def test_all_opcodes_stack_underflow(
     eof_test: EOFTestFiller, op: Op, stack_height: int, spread: int
@@ -473,7 +473,7 @@ def test_all_opcodes_stack_underflow(
         # We need to leave space for this increase not to cause stack overflow.
         max_stack_increase = max(op.pushed_stack_items - op.popped_stack_items, 0)
         # Cap the spread if it would exceed the maximum stack height.
-        spread = min(spread, MAX_OPERAND_STACK_HEIGHT - (stack_height + max_stack_increase))
+        spread = min(spread, MAX_STACK_INCREASE_LIMIT - (stack_height + max_stack_increase))
         # Create a range stack height of 0-spread.
         code += Op.RJUMPI[spread](Op.CALLVALUE) + Op.PUSH0 * spread
 

tests/osaka/eip7692_eof_v1/eip6206_jumpf/test_jumpf_stack.py

@@ -6,9 +6,9 @@
 from ethereum_test_tools import Account, EOFException, EOFStateTestFiller
 from ethereum_test_tools.eof.v1 import Container, Section
 from ethereum_test_tools.vm.opcode import Opcodes as Op
+from ethereum_test_types.eof.constants import MAX_RUNTIME_STACK_HEIGHT
 
 from .. import EOF_FORK_NAME
-from ..eip4750_functions.test_code_validation import MAX_RUNTIME_OPERAND_STACK_HEIGHT
 from .helpers import slot_code_worked, value_code_worked
 
 REFERENCE_SPEC_GIT_PATH = "EIPS/eip-6206.md"
@@ -310,7 +310,7 @@ def test_jumpf_variadic_stack_overflow(
             ),
         ],
         validity_error=EOFException.STACK_OVERFLOW
-        if stack_height + callee_stack_height > MAX_RUNTIME_OPERAND_STACK_HEIGHT
+        if stack_height + callee_stack_height > MAX_RUNTIME_STACK_HEIGHT
         else None,
     )
     eof_test(container=container)
@@ -335,7 +335,7 @@ def test_jumpf_with_inputs_stack_overflow(
             ),
         ],
         validity_error=EOFException.STACK_OVERFLOW
-        if stack_height + callee_stack_increase > MAX_RUNTIME_OPERAND_STACK_HEIGHT
+        if stack_height + callee_stack_increase > MAX_RUNTIME_STACK_HEIGHT
         else None,
     )
     eof_test(container=container)
@@ -360,7 +360,7 @@ def test_jumpf_with_inputs_stack_overflow_variable_stack(
             ),
         ],
         validity_error=EOFException.STACK_OVERFLOW
-        if stack_height + callee_stack_increase > MAX_RUNTIME_OPERAND_STACK_HEIGHT
+        if stack_height + callee_stack_increase > MAX_RUNTIME_STACK_HEIGHT
         else None,
     )
     eof_test(container=container)

tests/osaka/eip7692_eof_v1/eip6206_jumpf/test_jumpf_validation.py

@@ -5,9 +5,9 @@
 from ethereum_test_tools import EOFException, EOFTestFiller
 from ethereum_test_tools.eof.v1 import Container, Section
 from ethereum_test_tools.vm.opcode import Opcodes as Op
+from ethereum_test_types.eof.constants import MAX_RUNTIME_STACK_HEIGHT
 
 from .. import EOF_FORK_NAME
-from ..eip4750_functions.test_code_validation import MAX_RUNTIME_OPERAND_STACK_HEIGHT
 
 REFERENCE_SPEC_GIT_PATH = "EIPS/eip-6206.md"
 REFERENCE_SPEC_VERSION = "2f365ea0cd58faa6e26013ea77ce6d538175f7d0"
@@ -150,7 +150,7 @@ def test_jumpf_self_stack_overflow(eof_test: EOFTestFiller, stack_height: int):
             ),
         ],
     )
-    stack_overflow = stack_height > MAX_RUNTIME_OPERAND_STACK_HEIGHT // 2
+    stack_overflow = stack_height > MAX_RUNTIME_STACK_HEIGHT // 2
     eof_test(
         container=container,
         expect_exception=EOFException.STACK_OVERFLOW if stack_overflow else None,
@@ -175,7 +175,7 @@ def test_jumpf_other_stack_overflow(
             ),
         ],
     )
-    stack_overflow = stack_height + stack_height_other > MAX_RUNTIME_OPERAND_STACK_HEIGHT
+    stack_overflow = stack_height + stack_height_other > MAX_RUNTIME_STACK_HEIGHT
     eof_test(
         container=container,
         expect_exception=EOFException.STACK_OVERFLOW if stack_overflow else None,

tests/osaka/eip7692_eof_v1/eip663_dupn_swapn_exchange/test_dupn.py

@@ -16,7 +16,7 @@
     Transaction,
 )
 from ethereum_test_tools.eof.v1 import Container, Section
-from ethereum_test_tools.eof.v1.constants import MAX_OPERAND_STACK_HEIGHT
+from ethereum_test_tools.eof.v1.constants import MAX_STACK_INCREASE_LIMIT
 from ethereum_test_tools.vm.opcode import Opcodes as Op
 
 from .. import EOF_FORK_NAME
@@ -88,10 +88,10 @@ def test_dupn_stack_underflow(
 @pytest.mark.parametrize(
     "dupn_operand,max_stack_height,expect_exception",
     [
-        [0, MAX_OPERAND_STACK_HEIGHT, EOFException.INVALID_MAX_STACK_INCREASE],
-        [0, MAX_OPERAND_STACK_HEIGHT + 1, EOFException.MAX_STACK_INCREASE_ABOVE_LIMIT],
-        [2**8 - 1, MAX_OPERAND_STACK_HEIGHT, EOFException.INVALID_MAX_STACK_INCREASE],
-        [2**8 - 1, MAX_OPERAND_STACK_HEIGHT + 1, EOFException.MAX_STACK_INCREASE_ABOVE_LIMIT],
+        [0, MAX_STACK_INCREASE_LIMIT, EOFException.INVALID_MAX_STACK_INCREASE],
+        [0, MAX_STACK_INCREASE_LIMIT + 1, EOFException.MAX_STACK_INCREASE_ABOVE_LIMIT],
+        [2**8 - 1, MAX_STACK_INCREASE_LIMIT, EOFException.INVALID_MAX_STACK_INCREASE],
+        [2**8 - 1, MAX_STACK_INCREASE_LIMIT + 1, EOFException.MAX_STACK_INCREASE_ABOVE_LIMIT],
     ],
 )
 def test_dupn_stack_overflow(
@@ -104,7 +104,7 @@ def test_dupn_stack_overflow(
     eof_code = Container(
         sections=[
             Section.Code(
-                code=sum(Op.PUSH2[v] for v in range(0, MAX_OPERAND_STACK_HEIGHT))
+                code=sum(Op.PUSH2[v] for v in range(0, MAX_STACK_INCREASE_LIMIT))
                 + Op.DUPN[dupn_operand]
                 + Op.STOP,
                 max_stack_height=max_stack_height,