feat(tests,plugins): Add with_all_typed_transactions support

Author: fselmo

src/cli/pytest_commands/pytest_ini_files/pytest-execute.ini

@@ -17,6 +17,7 @@ addopts =
     -p pytest_plugins.execute.rpc.remote_seed_sender
     -p pytest_plugins.execute.rpc.remote
     -p pytest_plugins.forks.forks
+    -p pytest_plugins.fixtures.transaction_fixtures
     -p pytest_plugins.help.help
     --tb short
     --dist loadscope

src/cli/pytest_commands/pytest_ini_files/pytest-fill.ini

@@ -16,6 +16,7 @@ addopts =
     -p pytest_plugins.filler.static_filler
     -p pytest_plugins.shared.execute_fill
     -p pytest_plugins.forks.forks
+    -p pytest_plugins.fixtures.transaction_fixtures
     -p pytest_plugins.eels_resolver
     -p pytest_plugins.help.help
     --tb short

src/pytest_plugins/forks/forks.py

@@ -339,6 +339,13 @@ def covariant_decorator(
         fork_attribute_name="tx_types",
         argnames=["tx_type"],
     ),
+    covariant_decorator(
+        marker_name="with_all_typed_transactions",
+        description="marks a test to be parametrized with transaction types, the typed_tx fixture "
+        "will provide the corresponding Transaction object for each type",
+        fork_attribute_name="tx_types",
+        argnames=["typed_transaction"],
+    ),
     covariant_decorator(
         marker_name="with_all_contract_creating_tx_types",
         description="marks a test to be parametrized for all tx types that can create a contract"
@@ -972,9 +979,26 @@ def add_fork_covariant_parameters(
     metafunc: Metafunc, fork_parametrizers: List[ForkParametrizer]
 ) -> None:
     """Iterate over the fork covariant descriptors and add their values to the test function."""
-    for covariant_descriptor in fork_covariant_decorators:
+    # Special handling for with_all_typed_transactions
+    if list(metafunc.definition.iter_markers("with_all_typed_transactions")):
+        # This marker needs special handling for indirect parametrization
         for fork_parametrizer in fork_parametrizers:
-            covariant_descriptor(metafunc=metafunc).add_values(fork_parametrizer=fork_parametrizer)
+            fork = fork_parametrizer.fork
+            tx_types = fork.tx_types(block_number=0, timestamp=0)
+            values = [pytest.param(tx_type) for tx_type in tx_types]
+            fork_parametrizer.fork_covariant_parameters.append(
+                ForkCovariantParameter(names=["typed_transaction"], values=values)
+            )
+    else:
+        # Regular covariant descriptors
+        for covariant_descriptor in fork_covariant_decorators:
+            # Skip with_all_typed_transactions as it's handled above
+            if covariant_descriptor.marker_name == "with_all_typed_transactions":
+                continue
+            for fork_parametrizer in fork_parametrizers:
+                covariant_descriptor(metafunc=metafunc).add_values(
+                    fork_parametrizer=fork_parametrizer
+                )
 
     for marker in metafunc.definition.iter_markers():
         if marker.name == "parametrize_by_fork":
@@ -1029,6 +1053,11 @@ def parameters_from_fork_parametrizer_list(
 
 def parametrize_fork(metafunc: Metafunc, fork_parametrizers: List[ForkParametrizer]) -> None:
     """Add the fork parameters to the test function."""
-    metafunc.parametrize(
-        *parameters_from_fork_parametrizer_list(fork_parametrizers), scope="function"
-    )
+    param_names, param_values = parameters_from_fork_parametrizer_list(fork_parametrizers)
+
+    # Check if typed_transaction is in the parameters and needs indirect parametrization
+    indirect = []
+    if "typed_transaction" in param_names:
+        indirect.append("typed_transaction")
+
+    metafunc.parametrize(param_names, param_values, scope="function", indirect=indirect)

src/pytest_plugins/forks/tests/test_covariant_markers.py

@@ -262,6 +262,97 @@ def test_case(state_test, system_contract):
             None,
             id="with_all_system_contracts",
         ),
+        pytest.param(
+            """
+            import pytest
+            from ethereum_test_tools import Transaction
+            @pytest.mark.with_all_typed_transactions()
+            @pytest.mark.valid_from("Berlin")
+            @pytest.mark.valid_until("Berlin")
+            @pytest.mark.state_test_only
+            def test_case(state_test, typed_transaction, pre):
+                assert isinstance(typed_transaction, Transaction)
+                assert typed_transaction.ty in [0, 1]  # Berlin supports types 0 and 1
+            """,
+            {"passed": 2, "failed": 0, "skipped": 0, "errors": 0},
+            None,
+            id="with_all_typed_transactions_berlin",
+        ),
+        pytest.param(
+            """
+            import pytest
+            from ethereum_test_tools import Transaction
+            @pytest.mark.with_all_typed_transactions()
+            @pytest.mark.valid_from("London")
+            @pytest.mark.valid_until("London")
+            @pytest.mark.state_test_only
+            def test_case(state_test, typed_transaction, pre):
+                assert isinstance(typed_transaction, Transaction)
+                assert typed_transaction.ty in [0, 1, 2]  # London supports types 0, 1, 2
+            """,
+            {"passed": 3, "failed": 0, "skipped": 0, "errors": 0},
+            None,
+            id="with_all_typed_transactions_london",
+        ),
+        pytest.param(
+            """
+            import pytest
+            from ethereum_test_tools import Transaction
+            @pytest.mark.with_all_typed_transactions()
+            @pytest.mark.valid_from("London")
+            @pytest.mark.valid_until("London")
+            @pytest.mark.state_test_only
+            def test_case(state_test, typed_transaction, pre):
+                assert isinstance(typed_transaction, Transaction)
+                # Test with marks to skip type 0
+                if typed_transaction.ty == 0:
+                    pytest.skip("Testing skip functionality")
+            """,
+            {"passed": 2, "failed": 0, "skipped": 1, "errors": 0},
+            None,
+            id="with_all_typed_transactions_with_skip",
+        ),
+        pytest.param(
+            """
+            import pytest
+            from ethereum_test_tools import Transaction
+            from ethereum_test_base_types import AccessList
+            
+            # Override the type 3 transaction fixture
+            @pytest.fixture
+            def type_3_default_transaction(pre):
+                sender = pre.fund_eoa()
+                
+                return Transaction(
+                    ty=3,
+                    sender=sender,
+                    max_fee_per_gas=10**10,
+                    max_priority_fee_per_gas=10**9,
+                    max_fee_per_blob_gas=10**8,
+                    gas_limit=300_000,
+                    data=b"\\xFF" * 50,
+                    access_list=[
+                        AccessList(address=0x1111, storage_keys=[10, 20]),
+                    ],
+                    blob_versioned_hashes=[
+                        0x0111111111111111111111111111111111111111111111111111111111111111,
+                    ],
+                )
+            
+            @pytest.mark.with_all_typed_transactions()
+            @pytest.mark.valid_at("Cancun")
+            @pytest.mark.state_test_only
+            def test_case(state_test, typed_transaction, pre):
+                assert isinstance(typed_transaction, Transaction)
+                if typed_transaction.ty == 3:
+                    # Verify our override worked
+                    assert typed_transaction.data == b"\\xFF" * 50
+                    assert len(typed_transaction.blob_versioned_hashes) == 1
+            """,
+            {"passed": 4, "failed": 0, "skipped": 0, "errors": 0},
+            None,
+            id="with_all_typed_transactions_with_override",
+        ),
         pytest.param(
             """
             import pytest