feat(specs,tests): Implement EIP-7928 Block-Level Access Lists

docs/CHANGELOG.md

@@ -29,6 +29,8 @@ Test fixtures for use by clients are available for each release on the [Github r
 
 ### 📋 Misc
 
+- ✨ Implement EIP-7928 Block-Level Access Lists ([#1719](https://github.com/ethereum/execution-specs/pull/1719)).
+
 ### 🧪 Test Cases
 
 - ✨ Add missing fuzzy-compute benchmark configurations for `KECCAK256`, `CODECOPY`, `CALLDATACOPY`, `RETURNDATACOPY`, `MLOAD`, `MSTORE`, `MSTORE8`, `MCOPY`, `LOG*`, `CALLDATASIZE`, `CALLDATALOAD`, and `RETURNDATASIZE` opcodes ([#1956](https://github.com/ethereum/execution-specs/pull/1956)).
@@ -57,6 +59,7 @@ Test fixtures for use by clients are available for each release on the [Github r
 ### 📋 Misc
 
 - 🐞 WELDed the EEST tox environments relevant to producing documentation into EELS, and added a tool to cleanly add codespell whitelist entries. ([#1695](https://github.com/ethereum/execution-specs/pull/1659)).
+- 🐞 Fix duplicate storage write issues for block access lists EIP-7928 implementation ([#1743](https://github.com/ethereum/execution-specs/pull/1743)).
 
 ### 🧪 Test Cases
 
@@ -76,6 +79,7 @@ Test fixtures for use by clients are available for each release on the [Github r
 - ✨ Add tests that EIP-1559 and EIP-2930 typed txs are invalid and void before their fork ([#1754](https://github.com/ethereum/execution-specs/pull/1754)).
 - ✨ Add tests for an old validation rule for gas limit above 5000 ([#1731](https://github.com/ethereum/execution-specs/pull/1731)).
 - ✨ Add tests for OOG in EXP, LOG and others ([#1686](https://github.com/ethereum/execution-specs/pull/1686)).
+- ✨ Make EIP-7934 tests more dynamic and able to handle new header fields added in future forks ([#2022](https://github.com/ethereum/execution-specs/pull/2022)).
 
 ## [v5.3.0](https://github.com/ethereum/execution-spec-tests/releases/tag/v5.3.0) - 2025-10-09
 

packages/testing/src/execution_testing/base_types/__init__.py

@@ -44,6 +44,7 @@
 from .pydantic import CamelModel, EthereumTestBaseModel, EthereumTestRootModel
 from .reference_spec import ReferenceSpec
 from .serialization import RLPSerializable, SignableRLPSerializable
+from .typing_utils import unwrap_annotation
 
 __all__ = (
     "AccessList",
@@ -88,4 +89,5 @@
     "to_bytes",
     "to_hex",
     "to_json",
+    "unwrap_annotation",
 )

packages/testing/src/execution_testing/base_types/typing_utils.py

@@ -0,0 +1,33 @@
+"""Utilities for working with Python type annotations."""
+
+from typing import Any, get_args
+
+
+def unwrap_annotation(hint: Any) -> Any:
+    """
+    Recursively unwrap Annotated and Union types to find the actual type.
+
+    This function is useful for introspecting complex type annotations like:
+    - `Annotated[int, ...]` -> `int`
+    - `int | None` -> `int`
+    - `Annotated[int, ...] | None` -> `int`
+
+    Args:
+        hint: Type annotation to unwrap
+
+    Returns:
+        The unwrapped base type
+    """
+    type_args = get_args(hint)
+    if not type_args:
+        # Base case: simple type with no parameters
+        return hint
+
+    # For Union types (including Optional), find the first non-None type
+    for arg in type_args:
+        if arg is not type(None):
+            # Recursively unwrap (handles nested Annotated/Union)
+            return unwrap_annotation(arg)
+
+    # All args were None (shouldn't happen in practice)
+    return hint

packages/testing/src/execution_testing/cli/pytest_commands/plugins/execute/eth_config/networks.yml

@@ -5,7 +5,7 @@ Mainnet:
     Frontier:           0
     Homestead:          1150000
     DAOFork:            1920000
-    Tangerine:          2463000
+    TangerineWhistle:   2463000
     SpuriousDragon:     2675000
     Byzantium:          4370000
     Constantinople:     7280000

packages/testing/src/execution_testing/cli/pytest_commands/plugins/execute/eth_config/tests/test_execute_eth_config.py

@@ -293,7 +293,7 @@
     Frontier:           0
     Homestead:          1150000
     DAOFork:            1920000
-    Tangerine:          2463000
+    TangerineWhistle:   2463000
     SpuriousDragon:     2675000
     Byzantium:          4370000
     Constantinople:     7280000

packages/testing/src/execution_testing/cli/pytest_commands/plugins/forks/forks.py

@@ -1208,3 +1208,54 @@ def parametrize_fork(
     metafunc.parametrize(
         param_names, param_values, scope="function", indirect=indirect
     )
+
+
+def pytest_collection_modifyitems(
+    config: pytest.Config, items: List[pytest.Item]
+) -> None:
+    """
+    Filter tests based on param-level validity markers.
+
+    The pytest_generate_tests hook only considers function-level validity markers.
+    This hook runs after parametrization and can access all markers including
+    param-level ones, allowing us to properly filter tests based on param-level
+    valid_from/valid_until markers.
+    """
+    items_to_remove = []
+
+    for i, item in enumerate(items):
+        # Get fork from params if available
+        params = None
+        if hasattr(item, "callspec"):
+            params = item.callspec.params
+        elif hasattr(item, "params"):
+            params = item.params
+
+        if not params or "fork" not in params or params["fork"] is None:
+            continue
+
+        fork: Fork = params["fork"]
+
+        # Get all markers including param-level ones
+        markers = item.iter_markers()
+
+        # Calculate valid fork set from all markers
+        # If this raises (e.g., duplicate markers from combining function-level
+        # and param-level), exit immediately with error
+        try:
+            valid_fork_set = ValidityMarker.get_test_fork_set_from_markers(
+                markers
+            )
+        except Exception as e:
+            pytest.exit(
+                f"Error in test '{item.name}': {e}",
+                returncode=pytest.ExitCode.USAGE_ERROR,
+            )
+
+        # If the fork is not in the valid set, mark for removal
+        if fork not in valid_fork_set:
+            items_to_remove.append(i)
+
+    # Remove items in reverse order to maintain indices
+    for i in reversed(items_to_remove):
+        del items[i]

packages/testing/src/execution_testing/cli/pytest_commands/plugins/forks/tests/test_bad_validity_markers.py

@@ -236,3 +236,73 @@ def test_invalid_validity_markers(
         errors=1,
     )
     assert error_string in "\n".join(result.stdout.lines)
+
+
+# --- Tests for param-level marker errors --- #
+
+
+param_level_marker_error_test_cases = (
+    (
+        "param_level_valid_from_with_function_level_valid_from",
+        (
+            """
+            import pytest
+            @pytest.mark.parametrize(
+                "value",
+                [
+                    pytest.param(True, marks=pytest.mark.valid_from("Paris")),
+                ],
+            )
+            @pytest.mark.valid_from("Berlin")
+            def test_case(state_test, value):
+                assert 1
+            """,
+            "Too many 'valid_from' markers applied to test",
+        ),
+    ),
+    (
+        "param_level_valid_until_with_function_level_valid_until",
+        (
+            """
+            import pytest
+            @pytest.mark.parametrize(
+                "value",
+                [
+                    pytest.param(True, marks=pytest.mark.valid_until("Cancun")),
+                ],
+            )
+            @pytest.mark.valid_until("Prague")
+            def test_case(state_test, value):
+                assert 1
+            """,
+            "Too many 'valid_until' markers applied to test",
+        ),
+    ),
+)
+
+
+@pytest.mark.parametrize(
+    "test_function, error_string",
+    [test_case for _, test_case in param_level_marker_error_test_cases],
+    ids=[test_id for test_id, _ in param_level_marker_error_test_cases],
+)
+def test_param_level_marker_errors(
+    pytester: pytest.Pytester, error_string: str, test_function: str
+) -> None:
+    """
+    Test that combining function-level and param-level validity markers
+    of the same type produces an error.
+
+    Unlike function-level errors (caught during test generation), param-level
+    errors are caught during collection and cause pytest to exit immediately.
+    """
+    pytester.makepyfile(test_function)
+    pytester.copy_example(
+        name="src/execution_testing/cli/pytest_commands/pytest_ini_files/pytest-fill.ini"
+    )
+    result = pytester.runpytest("-c", "pytest-fill.ini")
+
+    # pytest.exit() causes the run to terminate with no test outcomes
+    assert result.ret != 0, "Expected non-zero exit code"
+    stdout = "\n".join(result.stdout.lines)
+    assert error_string in stdout, f"Expected '{error_string}' in output"

packages/testing/src/execution_testing/cli/pytest_commands/plugins/forks/tests/test_forks.py

@@ -45,11 +45,14 @@ def test_all_forks({StateTest.pytest_parameter_name()}):
     ]
     expected_skipped = 2  # eels doesn't support Constantinople
     expected_passed = (
-        len(forks_under_test) * len(StateTest.supported_fixture_formats)
+        len([f for f in forks_under_test if not f.ignore()])
+        * len(StateTest.supported_fixture_formats)
         - expected_skipped
     )
     stdout = "\n".join(result.stdout.lines)
     for test_fork in forks_under_test:
+        if test_fork.ignore():
+            continue
         for fixture_format in StateTest.supported_fixture_formats:
             if isinstance(fixture_format, LabeledFixtureFormat):
                 fixture_format_label = fixture_format.label