feat(tests): add worst-case BAL read test

tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists_compute_then_sload.py

@@ -0,0 +1,262 @@
+"""
+Tests for EIP-7928 BAL with computation followed by SLOADs.
+
+Creates transactions that first perform computation, then cold SLOADs.
+The compute_percent parameter controls the gas split between phases.
+"""
+
+import pytest
+
+from execution_testing import (
+    Account,
+    Alloc,
+    BalAccountExpectation,
+    BalNonceChange,
+    Block,
+    BlockAccessListExpectation,
+    BlockchainTestFiller,
+    Bytecode,
+    Environment,
+    Fork,
+    Op,
+    Storage,
+    Transaction,
+)
+
+from .spec import ref_spec_7928
+
+REFERENCE_SPEC_GIT_PATH = ref_spec_7928.git_path
+REFERENCE_SPEC_VERSION = ref_spec_7928.version
+
+pytestmark = pytest.mark.valid_from("Amsterdam")
+
+GAS_PER_COMPUTE_ITERATION = 60
+GAS_PER_SLOAD_ITERATION = 2_200
+
+
+def create_compute_then_sload_contract() -> Bytecode:
+    """
+    Create bytecode that first computes, then SLOADs.
+
+    Calldata: computation_iterations (32) + start_slot (32) + sload_count (32)
+    Phase 1: Computation loop (accumulator = accumulator * 3 + 7)
+    Phase 2: SLOAD loop (sequential slots)
+    """
+    compute_loop_start = 5
+    compute_end = 28
+    sload_loop_start = 38
+    sload_end = 61
+
+    code = (
+        Op.PUSH1(0x00)
+        + Op.CALLDATALOAD
+        + Op.PUSH1(0x01)
+        + Op.JUMPDEST  # compute_loop_start
+        + Op.SWAP1
+        + Op.DUP1
+        + Op.ISZERO
+        + Op.PUSH2(compute_end)
+        + Op.JUMPI
+        + Op.PUSH1(0x01)
+        + Op.SWAP1
+        + Op.SUB
+        + Op.SWAP1
+        + Op.PUSH1(0x03)
+        + Op.MUL
+        + Op.PUSH1(0x07)
+        + Op.ADD
+        + Op.PUSH2(compute_loop_start)
+        + Op.JUMP
+        + Op.JUMPDEST  # compute_end
+        + Op.POP
+        + Op.POP
+        + Op.PUSH1(0x20)
+        + Op.CALLDATALOAD
+        + Op.PUSH1(0x40)
+        + Op.CALLDATALOAD
+        + Op.SWAP1
+        + Op.JUMPDEST  # sload_loop_start
+        + Op.DUP2
+        + Op.ISZERO
+        + Op.PUSH2(sload_end)
+        + Op.JUMPI
+        + Op.DUP1
+        + Op.SLOAD
+        + Op.POP
+        + Op.PUSH1(0x01)
+        + Op.ADD
+        + Op.SWAP1
+        + Op.PUSH1(0x01)
+        + Op.SWAP1
+        + Op.SUB
+        + Op.SWAP1
+        + Op.PUSH2(sload_loop_start)
+        + Op.JUMP
+        + Op.JUMPDEST  # sload_end
+        + Op.STOP
+    )
+    return code
+
+
+def calculate_test_parameters(
+    block_gas_limit: int, fork: Fork, compute_fraction: float
+) -> tuple[int, int, int, int]:
+    """Calculate (num_transactions, compute_iters, sload_count, total_slots)."""
+    gas_costs = fork.gas_costs()
+    max_tx_gas = fork.transaction_gas_limit_cap()
+    assert max_tx_gas is not None
+
+    num_transactions = block_gas_limit // max_tx_gas
+    intrinsic_overhead = gas_costs.G_TRANSACTION + 600
+    available_gas = max_tx_gas - intrinsic_overhead
+
+    compute_gas = int(available_gas * compute_fraction)
+    sload_gas = available_gas - compute_gas
+
+    compute_iters_per_tx = compute_gas // GAS_PER_COMPUTE_ITERATION
+    sload_count_per_tx = sload_gas // GAS_PER_SLOAD_ITERATION
+    total_slots = num_transactions * sload_count_per_tx
+
+    return num_transactions, compute_iters_per_tx, sload_count_per_tx, total_slots
+
+
+@pytest.mark.parametrize(
+    "compute_percent",
+    [5, 10, 25, 50],
+    ids=lambda p: f"compute_{p}pct",
+)
+def test_bal_compute_then_sload(
+    pre: Alloc,
+    blockchain_test: BlockchainTestFiller,
+    fork: Fork,
+    compute_percent: int,
+) -> None:
+    """Test BAL with computation phase followed by SLOAD phase."""
+    env = Environment()
+    block_gas_limit = int(env.gas_limit)
+    max_tx_gas = fork.transaction_gas_limit_cap()
+    compute_fraction = compute_percent / 100.0
+
+    (
+        num_transactions,
+        compute_iters_per_tx,
+        sload_count_per_tx,
+        total_slots,
+    ) = calculate_test_parameters(block_gas_limit, fork, compute_fraction)
+
+    storage = Storage({i: i + 1 for i in range(total_slots)})  # type: ignore
+
+    contract_code = create_compute_then_sload_contract()
+    contract = pre.deploy_contract(code=contract_code, storage=storage)
+
+    senders = [pre.fund_eoa() for _ in range(num_transactions)]
+    transactions = []
+
+    for tx_idx in range(num_transactions):
+        start_slot = tx_idx * sload_count_per_tx
+
+        calldata = (
+            compute_iters_per_tx.to_bytes(32, "big")
+            + start_slot.to_bytes(32, "big")
+            + sload_count_per_tx.to_bytes(32, "big")
+        )
+        tx = Transaction(
+            sender=senders[tx_idx],
+            to=contract,
+            gas_limit=max_tx_gas,
+            data=calldata,
+        )
+        transactions.append(tx)
+
+    all_slots_read = list(range(total_slots))
+    account_expectations = {
+        contract: BalAccountExpectation(storage_reads=all_slots_read),
+    }
+    for tx_idx, sender in enumerate(senders):
+        account_expectations[sender] = BalAccountExpectation(
+            nonce_changes=[
+                BalNonceChange(block_access_index=tx_idx + 1, post_nonce=1)
+            ],
+        )
+
+    block = Block(
+        txs=transactions,
+        expected_block_access_list=BlockAccessListExpectation(
+            account_expectations=account_expectations
+        ),
+    )
+
+    post = {contract: Account(storage=storage)}
+    for sender in senders:
+        post[sender] = Account(nonce=1)
+
+    blockchain_test(pre=pre, blocks=[block], post=post)
+
+
+@pytest.mark.parametrize(
+    "compute_percent",
+    [10, 50],
+    ids=lambda p: f"compute_{p}pct",
+)
+def test_bal_compute_then_sload_simple(
+    pre: Alloc,
+    blockchain_test: BlockchainTestFiller,
+    fork: Fork,
+    compute_percent: int,
+) -> None:
+    """Simple validation test with configurable computation and 20 SLOADs."""
+    total_slots = 20
+    num_transactions = 2
+    sload_count_per_tx = total_slots // num_transactions
+
+    gas_budget = 400_000
+    compute_gas = int(gas_budget * compute_percent / 100.0)
+    compute_iterations = compute_gas // GAS_PER_COMPUTE_ITERATION
+
+    storage = Storage({i: i + 1 for i in range(total_slots)})  # type: ignore
+
+    contract_code = create_compute_then_sload_contract()
+    contract = pre.deploy_contract(code=contract_code, storage=storage)
+
+    senders = [pre.fund_eoa() for _ in range(num_transactions)]
+    transactions = []
+
+    for tx_idx in range(num_transactions):
+        start_slot = tx_idx * sload_count_per_tx
+
+        calldata = (
+            compute_iterations.to_bytes(32, "big")
+            + start_slot.to_bytes(32, "big")
+            + sload_count_per_tx.to_bytes(32, "big")
+        )
+        tx = Transaction(
+            sender=senders[tx_idx],
+            to=contract,
+            gas_limit=500_000,
+            data=calldata,
+        )
+        transactions.append(tx)
+
+    all_slots_read = list(range(total_slots))
+    account_expectations = {
+        contract: BalAccountExpectation(storage_reads=all_slots_read),
+    }
+    for tx_idx, sender in enumerate(senders):
+        account_expectations[sender] = BalAccountExpectation(
+            nonce_changes=[
+                BalNonceChange(block_access_index=tx_idx + 1, post_nonce=1)
+            ],
+        )
+
+    block = Block(
+        txs=transactions,
+        expected_block_access_list=BlockAccessListExpectation(
+            account_expectations=account_expectations
+        ),
+    )
+
+    post = {contract: Account(storage=storage)}
+    for sender in senders:
+        post[sender] = Account(nonce=1)
+
+    blockchain_test(pre=pre, blocks=[block], post=post)