chore: adds extra modifier validation; adds unit tests

Author: fselmo

packages/testing/src/execution_testing/test_types/block_access_list/modifiers.py

@@ -71,9 +71,10 @@ def _modify_field_value(
     transaction.
     """
     found_address = False
+    found_index = False
 
     def transform(bal: BlockAccessList) -> BlockAccessList:
-        nonlocal found_address
+        nonlocal found_address, found_index
         new_root = []
         for account_change in bal.root:
             if account_change.address == address:
@@ -84,15 +85,18 @@ def transform(bal: BlockAccessList) -> BlockAccessList:
                 if changes:
                     if nested and slot is not None:
                         # nested structure (storage)
+                        found_slot = False
                         for storage_slot in changes:
                             if storage_slot.slot == slot:
+                                found_slot = True
                                 for j, change in enumerate(
                                     storage_slot.slot_changes
                                 ):
                                     if (
                                         change.block_access_index
                                         == block_access_index
                                     ):
+                                        found_index = True
                                         kwargs = {
                                             "block_access_index": (
                                                 block_access_index
@@ -104,10 +108,16 @@ def transform(bal: BlockAccessList) -> BlockAccessList:
                                         )
                                         break
                                 break
+                        if not found_slot:
+                            raise ValueError(
+                                f"Storage slot {slot} not found in "
+                                f"storage_changes of account {address}"
+                            )
                     else:
                         # flat structure (nonce, balance, code)
                         for i, change in enumerate(changes):
                             if change.block_access_index == block_access_index:
+                                found_index = True
                                 kwargs = {
                                     "block_access_index": block_access_index,
                                     value_field: new_value,
@@ -120,10 +130,14 @@ def transform(bal: BlockAccessList) -> BlockAccessList:
                 new_root.append(account_change)
 
         if not found_address:
-            # sanity check that we actually found the address
             raise ValueError(
                 f"Address {address} not found in BAL to modify {field_name}"
             )
+        if not found_index:
+            raise ValueError(
+                f"Block access index {block_access_index} not found in "
+                f"{field_name} of account {address}"
+            )
 
         return BlockAccessList(root=new_root)
 
@@ -721,8 +735,14 @@ def reorder_accounts(
     """Reorder accounts according to the provided index list."""
 
     def transform(bal: BlockAccessList) -> BlockAccessList:
-        if len(indices) != len(bal.root):
+        n = len(bal.root)
+        if len(indices) != n:
             raise ValueError("Index list length must match number of accounts")
+        if sorted(indices) != list(range(n)):
+            raise ValueError(
+                f"Indices must be a valid permutation of 0..{n - 1}, "
+                f"got {indices}"
+            )
         new_root = [bal.root[i] for i in indices]
         return BlockAccessList(root=new_root)
 

packages/testing/src/execution_testing/test_types/tests/test_block_access_list_modifiers.py

@@ -21,6 +21,11 @@
     duplicate_storage_read,
     duplicate_storage_slot,
     insert_storage_read,
+    modify_balance,
+    modify_code,
+    modify_nonce,
+    modify_storage,
+    reorder_accounts,
 )
 
 ALICE = Address(0xA)
@@ -217,3 +222,57 @@ def test_insert_storage_read_missing_address_raises() -> None:
     bal = BlockAccessList([BalAccountChange(address=ALICE, nonce_changes=[])])
     with pytest.raises(ValueError, match="not found"):
         insert_storage_read(CONTRACT, 1)(bal)
+
+
+def test_modify_nonce_missing_index_raises(
+    sample_bal: BlockAccessList,
+) -> None:
+    """Raise when the block_access_index is absent from nonce_changes."""
+    with pytest.raises(ValueError, match="not found"):
+        modify_nonce(ALICE, 99, 42)(sample_bal)
+
+
+def test_modify_balance_missing_index_raises(
+    sample_bal: BlockAccessList,
+) -> None:
+    """Raise when the block_access_index is absent from balance_changes."""
+    with pytest.raises(ValueError, match="not found"):
+        modify_balance(ALICE, 99, 9999)(sample_bal)
+
+
+def test_modify_code_missing_index_raises(sample_bal: BlockAccessList) -> None:
+    """Raise when the block_access_index is absent from code_changes."""
+    with pytest.raises(ValueError, match="not found"):
+        modify_code(ALICE, 99, b"\x00")(sample_bal)
+
+
+def test_modify_storage_missing_index_raises(
+    sample_bal: BlockAccessList,
+) -> None:
+    """Raise when block_access_index is absent within the storage slot."""
+    with pytest.raises(ValueError, match="not found"):
+        modify_storage(CONTRACT, 99, 1, 0xFF)(sample_bal)
+
+
+def test_modify_storage_missing_slot_raises(
+    sample_bal: BlockAccessList,
+) -> None:
+    """Raise when the storage slot itself is absent."""
+    with pytest.raises(ValueError, match="not found"):
+        modify_storage(CONTRACT, 1, 99, 0xFF)(sample_bal)
+
+
+def test_reorder_accounts_duplicate_index_raises(
+    sample_bal: BlockAccessList,
+) -> None:
+    """Raise when indices contain duplicates (not a valid permutation)."""
+    with pytest.raises(ValueError, match="valid permutation"):
+        reorder_accounts([0, 0])(sample_bal)
+
+
+def test_reorder_accounts_out_of_range_raises(
+    sample_bal: BlockAccessList,
+) -> None:
+    """Raise when indices are not a valid permutation (skipped index)."""
+    with pytest.raises(ValueError, match="valid permutation"):
+        reorder_accounts([0, 2])(sample_bal)