feat: Validate t8n BAL does not have duplicate entries for the same tx_index

Author: fselmo

src/ethereum_test_types/block_access_list/expectations.py

@@ -194,21 +194,33 @@ def _validate_bal_ordering(bal: "BlockAccessList") -> None:
                     f"{bal.root[i - 1].address} >= {bal.root[i].address}"
                 )
 
-        # Check transaction index ordering within accounts
+        # Check transaction index ordering and uniqueness within accounts
         for account in bal.root:
-            change_lists: List[BlockAccessListChangeLists] = [
-                account.nonce_changes,
-                account.balance_changes,
-                account.code_changes,
+            changes_to_check: List[tuple[str, BlockAccessListChangeLists]] = [
+                ("nonce_changes", account.nonce_changes),
+                ("balance_changes", account.balance_changes),
+                ("code_changes", account.code_changes),
             ]
-            for change_list in change_lists:
-                for i in range(1, len(change_list)):
-                    if change_list[i - 1].tx_index >= change_list[i].tx_index:
-                        raise BlockAccessListValidationError(
-                            f"Transaction indices not in ascending order in account "
-                            f"{account.address}: {change_list[i - 1].tx_index} >= "
-                            f"{change_list[i].tx_index}"
-                        )
+
+            for field_name, change_list in changes_to_check:
+                if not change_list:
+                    continue
+
+                tx_indices = [c.tx_index for c in change_list]
+
+                # Check both ordering and duplicates
+                if tx_indices != sorted(tx_indices):
+                    raise BlockAccessListValidationError(
+                        f"Transaction indices not in ascending order in {field_name} of account "
+                        f"{account.address}. Got: {tx_indices}, Expected: {sorted(tx_indices)}"
+                    )
+
+                if len(tx_indices) != len(set(tx_indices)):
+                    duplicates = sorted({idx for idx in tx_indices if tx_indices.count(idx) > 1})
+                    raise BlockAccessListValidationError(
+                        f"Duplicate transaction indices in {field_name} of account "
+                        f"{account.address}. Duplicates: {duplicates}"
+                    )
 
             # Check storage slot ordering
             for i in range(1, len(account.storage_changes)):
@@ -219,19 +231,28 @@ def _validate_bal_ordering(bal: "BlockAccessList") -> None:
                         f"{account.storage_changes[i].slot}"
                     )
 
-            # Check transaction index ordering within storage slots
+            # Check transaction index ordering and uniqueness within storage slots
             for storage_slot in account.storage_changes:
-                for i in range(1, len(storage_slot.slot_changes)):
-                    if (
-                        storage_slot.slot_changes[i - 1].tx_index
-                        >= storage_slot.slot_changes[i].tx_index
-                    ):
-                        raise BlockAccessListValidationError(
-                            f"Transaction indices not in ascending order in storage slot "
-                            f"{storage_slot.slot} of account {account.address}: "
-                            f"{storage_slot.slot_changes[i - 1].tx_index} >= "
-                            f"{storage_slot.slot_changes[i].tx_index}"
-                        )
+                if not storage_slot.slot_changes:
+                    continue
+
+                tx_indices = [c.tx_index for c in storage_slot.slot_changes]
+
+                # Check both ordering and duplicates
+                if tx_indices != sorted(tx_indices):
+                    raise BlockAccessListValidationError(
+                        f"Transaction indices not in ascending order in storage slot "
+                        f"{storage_slot.slot} of account {account.address}. "
+                        f"Got: {tx_indices}, Expected: {sorted(tx_indices)}"
+                    )
+
+                if len(tx_indices) != len(set(tx_indices)):
+                    duplicates = sorted({idx for idx in tx_indices if tx_indices.count(idx) > 1})
+                    raise BlockAccessListValidationError(
+                        f"Duplicate transaction indices in storage slot "
+                        f"{storage_slot.slot} of account {account.address}. "
+                        f"Duplicates: {duplicates}"
+                    )
 
             # Check storage reads ordering
             for i in range(1, len(account.storage_reads)):

src/ethereum_test_types/tests/test_block_access_lists.py

@@ -334,6 +334,78 @@ def test_actual_bal_tx_indices_ordering(field_name):
         expectation.verify_against(actual_bal)
 
 
+@pytest.mark.parametrize(
+    "field_name",
+    ["nonce_changes", "balance_changes", "code_changes"],
+)
+def test_actual_bal_duplicate_tx_indices(field_name):
+    """Test that actual BAL must not have duplicate tx indices in change lists."""
+    addr = Address(0xA)
+
+    # Duplicate tx_index=1
+    changes = []
+    if field_name == "nonce_changes":
+        changes = [
+            BalNonceChange(tx_index=1, post_nonce=1),
+            BalNonceChange(tx_index=1, post_nonce=2),  # duplicate tx_index
+            BalNonceChange(tx_index=2, post_nonce=3),
+        ]
+    elif field_name == "balance_changes":
+        changes = [
+            BalBalanceChange(tx_index=1, post_balance=100),
+            BalBalanceChange(tx_index=1, post_balance=200),  # duplicate tx_index
+            BalBalanceChange(tx_index=2, post_balance=300),
+        ]
+    elif field_name == "code_changes":
+        changes = [
+            BalCodeChange(tx_index=1, new_code=b"code1"),
+            BalCodeChange(tx_index=1, new_code=b""),  # duplicate tx_index
+            BalCodeChange(tx_index=2, new_code=b"code2"),
+        ]
+
+    actual_bal = BlockAccessList([BalAccountChange(address=addr, **{field_name: changes})])
+
+    expectation = BlockAccessListExpectation(account_expectations={})
+
+    with pytest.raises(
+        BlockAccessListValidationError,
+        match=f"Duplicate transaction indices in {field_name}.*Duplicates: \\[1\\]",
+    ):
+        expectation.verify_against(actual_bal)
+
+
+def test_actual_bal_storage_duplicate_tx_indices():
+    """Test that storage changes must not have duplicate tx indices within same slot."""
+    addr = Address(0xA)
+
+    # Create storage changes with duplicate tx_index within the same slot
+    actual_bal = BlockAccessList(
+        [
+            BalAccountChange(
+                address=addr,
+                storage_changes=[
+                    BalStorageSlot(
+                        slot=0x01,
+                        slot_changes=[
+                            BalStorageChange(tx_index=1, post_value=0x100),
+                            BalStorageChange(tx_index=1, post_value=0x200),  # duplicate tx_index
+                            BalStorageChange(tx_index=2, post_value=0x300),
+                        ],
+                    )
+                ],
+            )
+        ]
+    )
+
+    expectation = BlockAccessListExpectation(account_expectations={})
+
+    with pytest.raises(
+        BlockAccessListValidationError,
+        match="Duplicate transaction indices in storage slot.*Duplicates: \\[1\\]",
+    ):
+        expectation.verify_against(actual_bal)
+
+
 def test_expected_addresses_auto_sorted():
     """
     Test that expected addresses are automatically sorted before comparison.