♻️ refactor: move to test_block_access_lists

Author: raxhvl

tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists.py

@@ -7,6 +7,7 @@
     Alloc,
     Block,
     BlockchainTestFiller,
+    Initcode,
     Storage,
     Transaction,
     compute_create_address,
@@ -284,3 +285,109 @@ def test_bal_code_changes(
             ),
         },
     )
+
+
+@pytest.mark.valid_from("Amsterdam")
+@pytest.mark.parametrize(
+    "self_destruct_in_same_tx",
+    [True, False],
+    ids=["self_destruct_in_same_tx", "self_destruct_in_a_new_tx"],
+)
+def test_bal_self_destruct(
+    pre: Alloc,
+    blockchain_test: BlockchainTestFiller,
+    self_destruct_in_same_tx: bool,
+):
+    """Ensure BAL captures balance changes caused by `SELFDESTRUCT`."""
+    alice = pre.fund_eoa()
+    bob = pre.fund_eoa(amount=0)
+
+    selfdestruct_code = Op.SELFDESTRUCT(bob)
+    # A pre existing self-destruct contract
+    kaboom = pre.deploy_contract(code=selfdestruct_code)
+
+    # A template for self-destruct contract
+    self_destruct_init_code = Initcode(deploy_code=selfdestruct_code)
+    template = pre.deploy_contract(code=self_destruct_init_code)
+
+    if self_destruct_in_same_tx:
+        # The goal is to create a self-destructing contract in the same
+        # transaction to trigger deletion of code as per EIP-6780.
+        # The factory contract below creates a new self-destructing
+        # contract and calls it in this transaction.
+
+        bytecode_size = len(self_destruct_init_code)
+        factory_bytecode = (
+            # Clone template memory
+            Op.EXTCODECOPY(template, 0, 0, bytecode_size)
+            # Fund 100 wei and deploy the clone
+            + Op.CREATE(100, 0, bytecode_size)
+            # Call the clone, which self-destructs
+            + Op.CALL(50_000, Op.DUP6, 0, 0, 0, 0, 0)
+            + Op.STOP
+        )
+
+        factory = pre.deploy_contract(code=factory_bytecode)
+        kaboom_same_tx = compute_create_address(address=factory, nonce=1)
+
+    tx = Transaction(
+        sender=alice,
+        to=factory if self_destruct_in_same_tx else kaboom,
+        value=100,
+        gas_limit=1_000_000,
+    )
+
+    # Determine which account was destructed
+    self_destructed_account = kaboom_same_tx if self_destruct_in_same_tx else kaboom
+
+    block = Block(
+        txs=[tx],
+        expected_block_access_list=BlockAccessListExpectation(
+            account_expectations={
+                alice: BalAccountExpectation(
+                    nonce_changes=[BalNonceChange(tx_index=1, post_nonce=1)],
+                ),
+                bob: BalAccountExpectation(
+                    balance_changes=[BalBalanceChange(tx_index=1, post_balance=100)]
+                ),
+                self_destructed_account: BalAccountExpectation(
+                    # When an account is deleted its post nonce is set to 0
+                    # as per EIP-7928.
+                    nonce_changes=[BalNonceChange(tx_index=1, post_nonce=0)]
+                    if self_destruct_in_same_tx
+                    else [],
+                    balance_changes=[BalBalanceChange(tx_index=1, post_balance=0)],
+                    # Expect code to be cleared if self-destructed in same transaction.
+                    code_changes=[BalCodeChange(tx_index=1, new_code="")]
+                    if self_destruct_in_same_tx
+                    else [],
+                ),
+            }
+        ),
+    )
+
+    post = {
+        alice: Account(nonce=1),
+        bob: Account(balance=100),
+        kaboom: Account(balance=0, code=selfdestruct_code),
+    }
+
+    # If the account was self-destructed in the same transaction,
+    # we expect the account to non-existent and its balance to be 0.
+    if self_destruct_in_same_tx:
+        post.update(
+            {
+                factory: Account(
+                    nonce=2,  # incremented after CREATE
+                    balance=0,  # spent on CREATE
+                    code=factory_bytecode,
+                ),
+                kaboom_same_tx: Account.NONEXISTENT,  # type: ignore
+            }
+        )
+
+    blockchain_test(
+        pre=pre,
+        blocks=[block],
+        post=post,
+    )

tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists_self_destruct.py

@@ -7,7 +7,7 @@
 | `test_bal_storage_writes` | Ensure BAL captures storage writes | Alice calls contract that writes to storage slot `0x01` | BAL MUST include storage changes with correct slot and value | ✅ Completed |
 | `test_bal_storage_reads` | Ensure BAL captures storage reads | Alice calls contract that reads from storage slot `0x01` | BAL MUST include storage access for the read operation | ✅ Completed |
 | `test_bal_code_changes` | Ensure BAL captures changes to account code | Alice deploys factory contract that creates new contract | BAL MUST include code changes for newly deployed contract | ✅ Completed |
-| `test_bal_self_destruct` | Ensure BAL captures balance changes caused by `SELFDESTRUCT` | Alice calls a contract (funded with 100 wei) that executes `SELFDESTRUCT` with Bob as its recipient | BAL MUST include Alice's nonce change (increment), the self-destructing contract's balance change (100 → 0), and Bob's balance change (0 → 100). If the contract is created in the same transaction, BAL MUST also include code changes (new_code = empty bytes, indicating code has been cleared) | ✅ Completed |
+| `test_bal_self_destruct` | Ensure BAL captures balance changes caused by `SELFDESTRUCT` | Alice calls a contract (funded with 100 wei) that executes `SELFDESTRUCT` with Bob as its recipient | BAL MUST include Alice's nonce change (increment), the self-destructing contract's balance change (100 → 0), and Bob's balance change (0 → 100). The self-destructing contract MUST also appear with `post_nonce=0`, `post_balance=0`, and `new_code=0x`, indicating an account deletion | ✅ Completed |
 | `test_bal_2930_slot_listed_but_untouched` | Ensure 2930 access list alone doesn't appear in BAL        | Include `(KV, S=0x01)` in tx's EIP-2930 access list; tx executes code that does **no** `SLOAD`/`SSTORE` to `S` (e.g., pure arithmetic/log). | BAL **MUST NOT** contain any entry for `(KV, S)` — neither reads nor writes — because the slot wasn't touched.                                                                                                    | 🟡 Planned |
 | `test_bal_2930_slot_listed_and_modified`  | Ensure BAL records writes only because the slot is touched | Same access list as above, but tx executes `SSTORE` to `S`.                                                                                 | BAL **MUST** include `storage_changes` for `(KV, S)` (and no separate read record for that slot if implementation deduplicates). Presence in the access list is irrelevant; inclusion is due to the actual write. | 🟡 Planned |
 | `test_bal_7702_delegated_create`                 | BAL tracks EIP-7702 delegation indicator write and contract creation        | Alice sends a type-4 (7702) tx authorizing herself to delegate to `Deployer` code which executes `CREATE`                      | BAL MUST include for **Alice**: `code_changes` (delegation indicator), `nonce_changes` (increment from 7702 processing), and `balance_changes` (post-gas). For **Child**: `code_changes` (runtime bytecode) and `nonce_changes = 1`. | 🟡 Planned  |