feat(fw,forks,tests): Add EVM code type marker

docs/CHANGELOG.md

@@ -8,13 +8,19 @@ Test fixtures for use by clients are available for each release on the [Github r
 
 ### 🧪 Test Cases
 
+- ✨ EIP-4844 test `tests/cancun/eip4844_blobs/test_point_evaluation_precompile.py` includes an EOF test case ([#610](https://github.com/ethereum/execution-spec-tests/pull/610)).
+- ✨ Example test `tests/frontier/opcodes/test_dup.py` now includes EOF parametrization ([#610](https://github.com/ethereum/execution-spec-tests/pull/610)).
+
 ### 🛠️ Framework
 
 - 🐞 Fixed consume hive commands from spawning different hive test suites during the same test execution when using xdist ([#712](https://github.com/ethereum/execution-spec-tests/pull/712)).
 - ✨ `consume hive` command is now available to run all types of hive tests ([#712](https://github.com/ethereum/execution-spec-tests/pull/712)).
 - ✨ Generated fixtures now contain the test index `index.json` by default ([#716](https://github.com/ethereum/execution-spec-tests/pull/716)).
 - ✨ A metadata folder `.meta/` now stores all fixture metadata files by default ([#721](https://github.com/ethereum/execution-spec-tests/pull/721)).
 - 🐞 Fixed `fill` command index generation issue due to concurrency ([#725](https://github.com/ethereum/execution-spec-tests/pull/725)).
+- ✨ Added `with_all_evm_code_types` and `with_all_call_opcodes` markers, which allow automatic parametrization of tests to EOF ([#610](https://github.com/ethereum/execution-spec-tests/pull/610)).
+- ✨ Code generators `Conditional` and `Switch` now support EOF by adding parameter `evm_code_type` ([#610](https://github.com/ethereum/execution-spec-tests/pull/610)).
+- ✨ `fill` command now supports parameter `--evm-code-type` that can be (currently) set to `legacy` or `eof_v1` to force all test smart contracts to deployed in normal or in EOF containers ([#610](https://github.com/ethereum/execution-spec-tests/pull/610)).
 - 🐞 Fixed fixture index generation on EOF tests ([#728](https://github.com/ethereum/execution-spec-tests/pull/728)).
 
 ### 🔧 EVM Tools

docs/writing_tests/test_markers.md

@@ -53,7 +53,7 @@ import pytest
 
 @pytest.mark.with_all_tx_types
 @pytest.mark.valid_from("Berlin")
-def test_something_with_all_tx_types(tx_type):
+def test_something_with_all_tx_types(tx_type: int):
     pass
 ```
 
@@ -74,12 +74,67 @@ import pytest
 
 @pytest.mark.with_all_precompiles
 @pytest.mark.valid_from("Shanghai")
-def test_something_with_all_precompiles(precompile):
+def test_something_with_all_precompiles(precompile: int):
     pass
 ```
 
 In this example, the test will be parameterized for parameter `precompile` with values `[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]` for fork Shanghai, but with values `[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]` for fork Cancun (because of EIP-4844).
 
+### pytest.mark.with_all_evm_code_types
+
+This marker is used to automatically parameterize a test with all EVM code types that are valid for the fork being tested.
+
+```python
+import pytest
+
+@pytest.mark.with_all_evm_code_types
+@pytest.mark.valid_from("Frontier")
+def test_something_with_all_evm_code_types(pre: Alloc):
+    pass
+```
+
+In this example, the test will be parameterized for parameter `evm_code_type` only with value `[EVMCodeType.LEGACY]` starting on fork Frontier, and eventually it will be parametrized with with values `[EVMCodeType.LEGACY, EVMCodeType.EOF_V1]` on the EOF activation fork.
+
+In all calls to `pre.deploy_contract`, if the code parameter is `Bytecode` type, and `evm_code_type==EVMCodeType.EOF_V1`, the bytecode will be automatically wrapped in an EOF V1 container.
+
+Code wrapping might fail in the following circumstances:
+
+- The code contains invalid EOF V1 opcodes.
+- The code does not end with a valid EOF V1 terminating opcode (such as `Op.STOP` or `Op.REVERT` or `Op.RETURN`).
+
+In the case where the code wrapping fails, `evm_code_type` can be added as a parameter to the test and the bytecode can be dynamically modified to be compatible with the EOF V1 container.
+
+```python
+import pytest
+
+@pytest.mark.with_all_evm_code_types
+@pytest.mark.valid_from("Frontier")
+def test_something_with_all_evm_code_types(pre: Alloc, evm_code_type: EVMCodeType):
+    code = Op.SSTORE(1, 1)
+    if evm_code_type == EVMCodeType.EOF_V1:
+        # Modify the bytecode to be compatible with EOF V1 container
+        code += Op.STOP
+    pre.deploy_contract(code)
+    ...
+```
+
+### pytest.mark.with_all_call_opcodes
+
+This marker is used to automatically parameterize a test with all EVM call opcodes that are valid for the fork being tested.
+
+```python
+import pytest
+
+@pytest.mark.with_all_call_opcodes
+@pytest.mark.valid_from("Frontier")
+def test_something_with_all_call_opcodes(pre: Alloc, call_opcode: Op):
+    ...
+```
+
+In this example, the test will be parametrized for parameter `call_opcode` with values `[Op.CALL, Op.CALLCODE]` starting on fork Frontier, `[Op.CALL, Op.CALLCODE, Op.DELEGATECALL]` on fork Homestead, `[Op.CALL, Op.CALLCODE, Op.DELEGATECALL, Op.STATICCALL]` on fork Byzantium, and eventually it will be parametrized with with values `[Op.CALL, Op.CALLCODE, Op.DELEGATECALL, Op.STATICCALL, Op.EXTCALL, Op.EXTSTATICCALL, Op.EXTDELEGATECALL]` on the EOF activation fork.
+
+Parameter `evm_code_type` will also be parametrized with the correct EVM code type for the opcode under test.
+
 ## Other Markers
 
 ### pytest.mark.slow

src/cli/tests/test_pytest_fill_command.py

@@ -26,7 +26,9 @@ def test_fill_help(runner):
     """
     result = runner.invoke(fill, ["--help"])
     assert result.exit_code == pytest.ExitCode.OK
-    assert "[--evm-bin EVM_BIN] [--traces]" in result.output
+    assert "[--evm-bin EVM_BIN]" in result.output
+    assert "[--traces]" in result.output
+    assert "[--evm-code-type EVM_CODE_TYPE]" in result.output
     assert "--help" in result.output
     assert "Arguments defining evm executable behavior:" in result.output
 

src/ethereum_test_forks/base_fork.py

@@ -3,10 +3,12 @@
 """
 
 from abc import ABC, ABCMeta, abstractmethod
-from typing import Any, ClassVar, List, Mapping, Optional, Protocol, Type
+from typing import Any, ClassVar, List, Mapping, Optional, Protocol, Tuple, Type
 
 from semver import Version
 
+from ethereum_test_vm import EVMCodeType, Opcodes
+
 from .base_decorators import prefer_transition_to_method
 
 
@@ -260,6 +262,24 @@ def engine_forkchoice_updated_version(
         """
         pass
 
+    @classmethod
+    @abstractmethod
+    def evm_code_types(cls, block_number: int = 0, timestamp: int = 0) -> List[EVMCodeType]:
+        """
+        Returns the list of EVM code types supported by the fork.
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def call_opcodes(
+        cls, block_number: int = 0, timestamp: int = 0
+    ) -> List[Tuple[Opcodes, EVMCodeType]]:
+        """
+        Returns the list of tuples with the call opcodes and its corresponding EVM code type.
+        """
+        pass
+
     # Meta information about the fork
     @classmethod
     def name(cls) -> str:

src/ethereum_test_forks/forks/forks.py

@@ -5,10 +5,12 @@
 from hashlib import sha256
 from os.path import realpath
 from pathlib import Path
-from typing import List, Mapping, Optional
+from typing import List, Mapping, Optional, Tuple
 
 from semver import Version
 
+from ethereum_test_vm import EVMCodeType, Opcodes
+
 from ..base_fork import BaseFork
 
 CURRENT_FILE = Path(realpath(__file__))
@@ -170,6 +172,25 @@ def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
         """
         return []
 
+    @classmethod
+    def evm_code_types(cls, block_number: int = 0, timestamp: int = 0) -> List[EVMCodeType]:
+        """
+        At Genesis, only legacy EVM code is supported.
+        """
+        return [EVMCodeType.LEGACY]
+
+    @classmethod
+    def call_opcodes(
+        cls, block_number: int = 0, timestamp: int = 0
+    ) -> List[Tuple[Opcodes, EVMCodeType]]:
+        """
+        Returns the list of call opcodes supported by the fork.
+        """
+        return [
+            (Opcodes.CALL, EVMCodeType.LEGACY),
+            (Opcodes.CALLCODE, EVMCodeType.LEGACY),
+        ]
+
     @classmethod
     def pre_allocation(cls) -> Mapping:
         """
@@ -201,6 +222,17 @@ def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
         """
         return [1, 2, 3, 4] + super(Homestead, cls).precompiles(block_number, timestamp)
 
+    @classmethod
+    def call_opcodes(
+        cls, block_number: int = 0, timestamp: int = 0
+    ) -> List[Tuple[Opcodes, EVMCodeType]]:
+        """
+        At Homestead, DELEGATECALL opcode was introduced.
+        """
+        return [(Opcodes.DELEGATECALL, EVMCodeType.LEGACY),] + super(
+            Homestead, cls
+        ).call_opcodes(block_number, timestamp)
+
 
 class Byzantium(Homestead):
     """
@@ -224,6 +256,17 @@ def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
         """
         return [5, 6, 7, 8] + super(Byzantium, cls).precompiles(block_number, timestamp)
 
+    @classmethod
+    def call_opcodes(
+        cls, block_number: int = 0, timestamp: int = 0
+    ) -> List[Tuple[Opcodes, EVMCodeType]]:
+        """
+        At Byzantium, STATICCALL opcode was introduced.
+        """
+        return [(Opcodes.STATICCALL, EVMCodeType.LEGACY),] + super(
+            Byzantium, cls
+        ).call_opcodes(block_number, timestamp)
+
 
 class Constantinople(Byzantium):
     """
@@ -625,6 +668,33 @@ class CancunEIP7692(  # noqa: SC200
     Cancun + EIP-7692 (EOF) fork
     """
 
+    @classmethod
+    def evm_code_types(cls, block_number: int = 0, timestamp: int = 0) -> List[EVMCodeType]:
+        """
+        EOF V1 is supported starting from this fork.
+        """
+        return super(CancunEIP7692, cls,).evm_code_types(  # noqa: SC200
+            block_number,
+            timestamp,
+        ) + [EVMCodeType.EOF_V1]
+
+    @classmethod
+    def call_opcodes(
+        cls, block_number: int = 0, timestamp: int = 0
+    ) -> List[Tuple[Opcodes, EVMCodeType]]:
+        """
+        EOF V1 introduces EXTCALL, EXTSTATICCALL, EXTDELEGATECALL.
+        """
+        return [
+            (Opcodes.EXTCALL, EVMCodeType.EOF_V1),
+            (Opcodes.EXTSTATICCALL, EVMCodeType.EOF_V1),
+            (Opcodes.EXTDELEGATECALL, EVMCodeType.EOF_V1),
+        ] + super(
+            CancunEIP7692, cls  # noqa: SC200
+        ).call_opcodes(
+            block_number, timestamp
+        )
+
     @classmethod
     def is_deployed(cls) -> bool:
         """

src/ethereum_test_tools/__init__.py

@@ -58,12 +58,14 @@
 )
 from ethereum_test_vm import (
     Bytecode,
+    EVMCodeType,
     Macro,
     Macros,
     Opcode,
     OpcodeCallArg,
     Opcodes,
     UndefinedOpcodes,
+    call_return_code,
 )
 
 from .code import (
@@ -104,6 +106,7 @@
     "EOFStateTestFiller",
     "EOFTest",
     "EOFTestFiller",
+    "EVMCodeType",
     "FixtureCollector",
     "Hash",
     "Header",
@@ -135,6 +138,7 @@
     "Yul",
     "YulCompiler",
     "add_kzg_version",
+    "call_return_code",
     "ceiling_division",
     "compute_create_address",
     "compute_create2_address",