feat(tests): Add flexibility to expected absent scenarios for BALs (#2124)

* fix(tests): Validate order for BAL coming from t8n

The specs are currently correctly written, but we were not validating
all of the ordering according to EIP-7928:
  - Addresses: lexicographic (bytewise).
  - Storage keys: lexicographic within each account.
  - Block access indices: ascending within each change list.

This change validates the order of the BAL before we even begin to
compare against our expectation. We also now validate that the
expectations we define are subsequences within the BAL (expected order).

- refactor: Explicit check for the fields we care about up front for `model_fields_set`

- refactor: awkward comparison method should just be a validation method (_validate_change_lists)

* chore: Unit test BAL ordering validation checks

* chore: Add note to CHANGELOG

* chore: move release note up to unreleased

* feat(tests): Add flexibility to expected absent scenarios for BALs

- We should have flexibility in defining the absence cases we expect for
  block-level access lists. This allows us to define absence validators
  for any case we might want to validate against. I don't expect these
  to grow very much but this does provide some flexibility.

* feat: Validate all validators use @validate_call appropriately

* chore: changelog note for #2124

* fix: no need to raise from any parsing errors; raise general case

* feat: add sanity checks to modifiers; abstract common logic

Author: fselmo

docs/CHANGELOG.md

@@ -20,6 +20,7 @@ Test fixtures for use by clients are available for each release on the [Github r
 ### 📋 Misc
 
 - ✨ Add tighter validation for EIP-7928 model coming from t8n when filling ([#2138](https://github.com/ethereum/execution-spec-tests/pull/2138)).
+- ✨ Add flexible API for absence checks for EIP-7928 (BAL) tests ([#2124](https://github.com/ethereum/execution-spec-tests/pull/2124)).
 
 ### 🧪 Test Cases
 

src/ethereum_test_types/block_access_list/__init__.py

@@ -196,6 +196,9 @@ class BalAccountExpectation(CamelModel):
     storage_reads: List[StorageKey] = Field(
         default_factory=list, description="List of expected read storage slots"
     )
+    should_not_exist: List["AbsenceValidator"] = Field(
+        default_factory=list, description="List of validators checking for forbidden conditions"
+    )
 
 
 class BlockAccessListExpectation(CamelModel):
@@ -400,6 +403,11 @@ def _compare_account_expectations(
         Only validates fields that were explicitly set in the expected model,
         using model_fields_set to determine what was intentionally specified.
         """
+        # Run absence validators first
+        if "should_not_exist" in expected.model_fields_set:
+            for validator in expected.should_not_exist:
+                validator(actual)
+
         change_fields = {
             "nonce_changes",
             "balance_changes",
@@ -574,8 +582,12 @@ def _validate_change_lists(field_name: str, expected: List, actual: List) -> Non
                     )
 
 
+AbsenceValidator = Callable[[BalAccountChange], None]
+
+
 __all__ = [
     # Core models
+    "AbsenceValidator",
     "BlockAccessList",
     "BlockAccessListExpectation",
     "BalAccountExpectation",

src/ethereum_test_types/block_access_list/absence_validators.py

@@ -0,0 +1,140 @@
+"""
+Absence validator functions for BAL testing.
+
+This module provides validator functions that check for the absence of specific
+changes in Block Access Lists. These validators are used with the
+``should_not_exist`` field in BalAccountExpectation to ensure certain changes
+do *not* occur.
+
+All validator functions must be decorated with
+``@validate_call(validate_return=True)`` to ensure proper type validation.
+This is enforced via tests.
+"""
+
+from typing import Set
+
+from pydantic import validate_call
+
+from ethereum_test_base_types import Number, StorageKey
+
+from . import AbsenceValidator, BalAccountChange
+
+
+@validate_call(validate_return=True)
+def no_nonce_changes(tx_indices: Set[Number] | None = None) -> AbsenceValidator:
+    """
+    Forbid nonce changes at specified transaction indices or all indices if None.
+
+    Args:
+        tx_indices: Set of transaction indices to check. If None,
+        checks all transactions.
+
+    """
+
+    def check(account: BalAccountChange) -> None:
+        for nonce_change in account.nonce_changes:
+            if tx_indices is None or nonce_change.tx_index in tx_indices:
+                raise AssertionError(
+                    f"Unexpected nonce change found at tx {nonce_change.tx_index}"
+                )
+
+    return check
+
+
+@validate_call(validate_return=True)
+def no_balance_changes(tx_indices: Set[Number] | None = None) -> AbsenceValidator:
+    """
+    Forbid balance changes at specified transaction indices or all indices
+    if None.
+
+    Args:
+        tx_indices: Set of transaction indices to check. If None,
+        checks all transactions.
+
+    """
+
+    def check(account: BalAccountChange) -> None:
+        for balance_change in account.balance_changes:
+            if tx_indices is None or balance_change.tx_index in tx_indices:
+                raise AssertionError(
+                    f"Unexpected balance change found at tx {balance_change.tx_index}"
+                )
+
+    return check
+
+
+@validate_call(validate_return=True)
+def no_storage_changes(
+    slots: Set[StorageKey] | None = None,
+    tx_indices: Set[Number] | None = None,
+) -> AbsenceValidator:
+    """
+    Forbid storage changes at specified slots and/or transaction indices.
+
+    Args:
+        slots: Set of storage slots to check. If None, checks all slots.
+        tx_indices: Set of transaction indices to check. If None,
+        checks all transactions.
+
+    """
+
+    def check(account: BalAccountChange) -> None:
+        for storage_slot in account.storage_changes:
+            if slots is None or storage_slot.slot in slots:
+                for slot_change in storage_slot.slot_changes:
+                    if tx_indices is None or slot_change.tx_index in tx_indices:
+                        raise AssertionError(
+                            "Unexpected storage change found at slot "
+                            f"{storage_slot.slot} in tx "
+                            f"{slot_change.tx_index}"
+                        )
+
+    return check
+
+
+@validate_call(validate_return=True)
+def no_storage_reads(slots: Set[StorageKey] | None = None) -> AbsenceValidator:
+    """
+    Forbid storage reads at specified slots or all slots if None.
+
+    Args:
+        slots: Set of storage slots to check. If None, checks all slots.
+
+    """
+
+    def check(account: BalAccountChange) -> None:
+        for read_slot in account.storage_reads:
+            if slots is None or read_slot in slots:
+                raise AssertionError(f"Unexpected storage read found at slot {read_slot}")
+
+    return check
+
+
+@validate_call(validate_return=True)
+def no_code_changes(tx_indices: Set[Number] | None = None) -> AbsenceValidator:
+    """
+    Forbid code changes at specified transaction indices or all indices
+    if None.
+
+    Args:
+        tx_indices: Set of transaction indices to check. If None,
+        checks all transactions.
+
+    """
+
+    def check(account: BalAccountChange) -> None:
+        for code_change in account.code_changes:
+            if tx_indices is None or code_change.tx_index in tx_indices:
+                raise AssertionError(f"Unexpected code change found at tx {code_change.tx_index}")
+
+    return check
+
+
+__all__ = [
+    "AbsenceValidator",
+    "no_nonce_changes",
+    "no_balance_changes",
+    "no_storage_changes",
+    "no_storage_reads",
+    "no_code_changes",
+]