feat(test): Increase BAL coverage with tests and BAL expectations for some existing (ethereum#2834)

Author: fselmo

tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists.py

@@ -1502,29 +1502,26 @@ def test_bal_precompile_funded(
     )
 
 
-@pytest.mark.parametrize_by_fork(
-    "precompile",
-    lambda fork: [
-        pytest.param(addr, id=f"0x{int.from_bytes(addr, 'big'):02x}")
-        for addr in fork.precompiles()
-    ],
-)
-def test_bal_precompile_call(
+@pytest.mark.with_all_precompiles
+@pytest.mark.with_all_call_opcodes
+def test_bal_precompile_call_opcode(
     pre: Alloc,
     blockchain_test: BlockchainTestFiller,
-    precompile: Address,
+    precompile: int,
+    call_opcode: Op,
 ) -> None:
     """
-    Ensure BAL records precompile when called via contract.
+    Ensure BAL records the precompile address regardless of call opcode.
 
-    Alice calls Oracle contract which calls precompile.
-    BAL must include precompile with no balance/storage/code changes.
+    Alice calls Oracle contract which invokes the precompile via the
+    parametrized call opcode. For DELEGATECALL/CALLCODE the precompile
+    provides the code but is not the call target, so its access has to
+    be recorded explicitly rather than incidentally.
     """
     alice = pre.fund_eoa()
 
-    # Oracle contract that calls the precompile
     oracle = pre.deploy_contract(
-        code=Op.CALL(100_000, precompile, 0, 0, 0, 0, 0) + Op.STOP
+        code=call_opcode(gas=100_000, address=precompile) + Op.STOP
     )
 
     tx = Transaction(

tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists_eip7702.py

@@ -1,8 +1,12 @@
 """Tests for the effects of EIP-7702 transactions on EIP-7928."""
 
+from typing import Dict
+
 import pytest
 from execution_testing import (
+    EOA,
     Account,
+    Address,
     Alloc,
     AuthorizationTuple,
     BalAccountExpectation,
@@ -515,6 +519,72 @@ def test_bal_7702_invalid_nonce_authorization(
     )
 
 
+@pytest.mark.pre_alloc_mutable()
+def test_bal_7702_invalid_authority_has_code_authorization(
+    pre: Alloc,
+    blockchain_test: BlockchainTestFiller,
+) -> None:
+    """
+    Ensure BAL handles failed authorization where the authority already has
+    non-empty, non-delegation code (EIP-7702 step-5 rejection, post-load).
+    """
+    # Pre-existing non-delegation code on the authority blocks the 7702
+    # delegation at step 5, after the authority is already loaded.
+    alice = pre.fund_eoa(amount=0, code=Op.STOP, nonce=1)
+    bob = pre.fund_eoa(amount=0)
+    relayer = pre.fund_eoa()
+    oracle = pre.deploy_contract(code=Op.STOP)
+
+    tx = Transaction(
+        sender=relayer,  # Sponsored transaction
+        to=bob,
+        value=10,
+        gas_limit=1_000_000,
+        gas_price=0xA,
+        authorization_list=[
+            AuthorizationTuple(
+                address=oracle,
+                nonce=alice.nonce,
+                signer=alice,
+            )
+        ],
+    )
+
+    block = Block(
+        txs=[tx],
+        expected_block_access_list=BlockAccessListExpectation(
+            account_expectations={
+                bob: BalAccountExpectation(
+                    balance_changes=[
+                        BalBalanceChange(block_access_index=1, post_balance=10)
+                    ]
+                ),
+                relayer: BalAccountExpectation(
+                    nonce_changes=[
+                        BalNonceChange(block_access_index=1, post_nonce=1)
+                    ],
+                ),
+                # Alice loaded at step 4 then step 5 rejects.
+                alice: BalAccountExpectation.empty(),
+                # Oracle never loaded as delegation target.
+                oracle: None,
+            }
+        ),
+    )
+
+    post = {
+        relayer: Account(nonce=1),
+        bob: Account(balance=10),
+        alice: Account(code=Op.STOP, nonce=1),
+    }
+
+    blockchain_test(
+        pre=pre,
+        blocks=[block],
+        post=post,
+    )
+
+
 def test_bal_7702_invalid_chain_id_authorization(
     pre: Alloc,
     blockchain_test: BlockchainTestFiller,
@@ -639,6 +709,124 @@ def test_bal_7702_delegated_via_call_opcode(
     )
 
 
+@pytest.mark.parametrize(
+    "destination_is_loop",
+    [False, True],
+    ids=["chain", "loop"],
+)
+def test_bal_7702_multi_hop_delegation_chain(
+    pre: Alloc,
+    blockchain_test: BlockchainTestFiller,
+    destination_is_loop: bool,
+) -> None:
+    """
+    Multi-hop EIP-7702 delegation: `chain` resolves A->B->C; `loop`
+    resolves A->B->A. In both cases the EVM follows the delegation once
+    and runs B's `0xef0100<dest>` bytecode as legacy code, which aborts
+    on the INVALID `0xef` opcode. For `chain`, C MUST NOT appear in the
+    BAL (second-hop target is never loaded as an execution target). For
+    `loop`, A is already in the BAL via the first delegation; the CALL
+    still fails.
+    """
+    alice = pre.fund_eoa()
+    auth_a = pre.fund_eoa(amount=0)
+    auth_b = pre.fund_eoa(amount=0)
+    target_c = pre.deploy_contract(code=Op.STOP)
+    second_destination = auth_a if destination_is_loop else target_c
+
+    entry_code = Op.SSTORE(0, Op.CALL(50_000, auth_a, 0, 0, 0, 0, 0)) + Op.STOP
+    entry_address = pre.deploy_contract(
+        code=entry_code,
+        storage={0: 0xDEAD},
+    )
+
+    tx = Transaction(
+        sender=alice,
+        to=entry_address,
+        gas_limit=1_000_000,
+        gas_price=0xA,
+        authorization_list=[
+            AuthorizationTuple(
+                address=auth_b,
+                nonce=0,
+                signer=auth_a,
+            ),
+            AuthorizationTuple(
+                address=second_destination,
+                nonce=0,
+                signer=auth_b,
+            ),
+        ],
+    )
+
+    account_expectations: Dict[EOA | Address, BalAccountExpectation | None] = {
+        alice: BalAccountExpectation(
+            nonce_changes=[BalNonceChange(block_access_index=1, post_nonce=1)],
+        ),
+        auth_a: BalAccountExpectation(
+            nonce_changes=[BalNonceChange(block_access_index=1, post_nonce=1)],
+            code_changes=[
+                BalCodeChange(
+                    block_access_index=1,
+                    new_code=Spec7702.delegation_designation(auth_b),
+                )
+            ],
+        ),
+        auth_b: BalAccountExpectation(
+            nonce_changes=[BalNonceChange(block_access_index=1, post_nonce=1)],
+            code_changes=[
+                BalCodeChange(
+                    block_access_index=1,
+                    new_code=Spec7702.delegation_designation(
+                        second_destination
+                    ),
+                )
+            ],
+        ),
+        # CALL returned 0; SSTORE(0, 0) overwrites the 0xDEAD witness.
+        entry_address: BalAccountExpectation(
+            storage_changes=[
+                BalStorageSlot(
+                    slot=0,
+                    slot_changes=[
+                        BalStorageChange(block_access_index=1, post_value=0)
+                    ],
+                )
+            ],
+            storage_reads=[],
+        ),
+    }
+    if not destination_is_loop:
+        account_expectations[target_c] = None
+
+    block = Block(
+        txs=[tx],
+        expected_block_access_list=BlockAccessListExpectation(
+            account_expectations=account_expectations
+        ),
+    )
+
+    post: Dict[EOA | Address, Account] = {
+        auth_a: Account(
+            nonce=1,
+            code=Spec7702.delegation_designation(auth_b),
+        ),
+        auth_b: Account(
+            nonce=1,
+            code=Spec7702.delegation_designation(second_destination),
+        ),
+        entry_address: Account(storage={0: 0}),
+    }
+    if not destination_is_loop:
+        post[target_c] = Account(code=bytes(Op.STOP), nonce=1)
+
+    blockchain_test(
+        pre=pre,
+        blocks=[block],
+        post=post,
+    )
+
+
 def test_bal_7702_null_address_delegation_no_code_change(
     pre: Alloc,
     blockchain_test: BlockchainTestFiller,