test_bal_cross_tx_funding_chain()

Documentation for tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists.py::test_bal_cross_tx_funding_chain@9c2813ee.

Generate fixtures for these test cases for Amsterdam with:

fill -v tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists.py::test_bal_cross_tx_funding_chain --fork Amsterdam

Funding chain: alice → bob → charlie → dan → eunice → target. Each intermediate starts empty and must receive the prior tx's forwarded value to afford its own upfront gas + outgoing transfer. A client that parallelizes any later tx against pre-block state would see a zero balance on its sender and wrongly reject the block. The oog_minus_1 variant funds eunice with exactly gas_limit - 1 worth of gas so her SSTORE OOGs at the boundary (target's BAL flips from storage_changes to storage_reads). The insufficient_funds variant has dan forward one wei short of eunice's gas_limit * gas_price, so eunice's tx is rejected pre-execution and the entire block MUST be rejected with INSUFFICIENT_ACCOUNT_FUNDS — a sanity check on the off-by-one boundary of the upfront balance check.

Source code in tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists.py

@pytest.mark.parametrize(
    "eunice_outcome",
    [
        pytest.param("success", id="success"),
        pytest.param("oog_minus_1", id="oog_minus_1"),
        pytest.param(
            "insufficient_funds",
            id="insufficient_funds",
            marks=pytest.mark.exception_test,
        ),
    ],
)
def test_bal_cross_tx_funding_chain(
    pre: Alloc,
    blockchain_test: BlockchainTestFiller,
    fork: Fork,
    eunice_outcome: str,
) -> None:
    """
    Funding chain: alice → bob → charlie → dan → eunice → target. Each
    intermediate starts empty and must receive the prior tx's forwarded
    value to afford its own upfront gas + outgoing transfer. A client
    that parallelizes any later tx against pre-block state would see a
    zero balance on its sender and wrongly reject the block. The
    `oog_minus_1` variant funds eunice with exactly `gas_limit - 1`
    worth of gas so her SSTORE OOGs at the boundary (target's BAL flips
    from `storage_changes` to `storage_reads`). The `insufficient_funds`
    variant has dan forward one wei short of eunice's `gas_limit *
    gas_price`, so eunice's tx is rejected pre-execution and the entire
    block MUST be rejected with `INSUFFICIENT_ACCOUNT_FUNDS` — a sanity
    check on the off-by-one boundary of the upfront balance check.
    """
    gas_price = 0xA

    target_code = Op.SSTORE(
        0, 0xC0FFEE, key_warm=False, original_value=0, new_value=0xC0FFEE
    )
    target = pre.deploy_contract(code=target_code)

    intrinsic_calc = fork.transaction_intrinsic_cost_calculator()
    intrinsic_gas = intrinsic_calc()
    eunice_exact_gas = intrinsic_gas + target_code.gas_cost(fork)
    eunice_gas_limit = (
        eunice_exact_gas - 1
        if eunice_outcome == "oog_minus_1"
        else eunice_exact_gas
    )
    eunice_upfront = eunice_gas_limit * gas_price
    transfer_cost = intrinsic_gas * gas_price

    # Each sender (including alice) starts with or receives exactly what
    # the next forward + its own gas demands; everyone ends at zero in
    # the success/oog variants. `insufficient_funds` shorts eunice by
    # one wei via dan, leaving her unable to cover upfront gas.
    dan_value = (
        eunice_upfront - 1
        if eunice_outcome == "insufficient_funds"
        else eunice_upfront
    )
    charlie_value = transfer_cost + dan_value
    bob_value = transfer_cost + charlie_value
    alice_value = transfer_cost + bob_value
    alice_pre_balance = transfer_cost + alice_value

    alice = pre.fund_eoa(amount=alice_pre_balance)
    bob = pre.fund_eoa(amount=0)
    charlie = pre.fund_eoa(amount=0)
    dan = pre.fund_eoa(amount=0)
    eunice = pre.fund_eoa(amount=0)

    eunice_error = (
        TransactionException.INSUFFICIENT_ACCOUNT_FUNDS
        if eunice_outcome == "insufficient_funds"
        else None
    )

    txs = [
        Transaction(
            sender=alice,
            to=bob,
            value=alice_value,
            gas_limit=intrinsic_gas,
            gas_price=gas_price,
        ),
        Transaction(
            sender=bob,
            to=charlie,
            value=bob_value,
            gas_limit=intrinsic_gas,
            gas_price=gas_price,
        ),
        Transaction(
            sender=charlie,
            to=dan,
            value=charlie_value,
            gas_limit=intrinsic_gas,
            gas_price=gas_price,
        ),
        Transaction(
            sender=dan,
            to=eunice,
            value=dan_value,
            gas_limit=intrinsic_gas,
            gas_price=gas_price,
        ),
        Transaction(
            sender=eunice,
            to=target,
            gas_limit=eunice_gas_limit,
            gas_price=gas_price,
            error=eunice_error,
        ),
    ]

    if eunice_outcome == "insufficient_funds":
        blockchain_test(
            pre=pre,
            blocks=[
                Block(
                    txs=txs,
                    exception=(
                        TransactionException.INSUFFICIENT_ACCOUNT_FUNDS
                    ),
                )
            ],
            post={},
        )
        return

    if eunice_outcome == "oog_minus_1":
        target_bal = BalAccountExpectation(
            storage_reads=[0],
            nonce_changes=[],
            balance_changes=[],
            code_changes=[],
            storage_changes=[],
        )
        target_post = Account(storage={})
    elif eunice_outcome == "success":
        target_bal = BalAccountExpectation(
            storage_changes=[
                BalStorageSlot(
                    slot=0,
                    slot_changes=[
                        BalStorageChange(
                            block_access_index=5, post_value=0xC0FFEE
                        ),
                    ],
                ),
            ],
            nonce_changes=[],
            balance_changes=[],
            code_changes=[],
            storage_reads=[],
        )
        target_post = Account(storage={0: 0xC0FFEE})
    else:
        raise ValueError(f"unknown eunice_outcome: {eunice_outcome}")

    account_expectations = {
        alice: BalAccountExpectation(
            nonce_changes=[BalNonceChange(block_access_index=1, post_nonce=1)],
            balance_changes=[
                BalBalanceChange(block_access_index=1, post_balance=0),
            ],
        ),
        bob: BalAccountExpectation(
            nonce_changes=[BalNonceChange(block_access_index=2, post_nonce=1)],
            balance_changes=[
                BalBalanceChange(
                    block_access_index=1, post_balance=alice_value
                ),
                BalBalanceChange(block_access_index=2, post_balance=0),
            ],
        ),
        charlie: BalAccountExpectation(
            nonce_changes=[BalNonceChange(block_access_index=3, post_nonce=1)],
            balance_changes=[
                BalBalanceChange(block_access_index=2, post_balance=bob_value),
                BalBalanceChange(block_access_index=3, post_balance=0),
            ],
        ),
        dan: BalAccountExpectation(
            nonce_changes=[BalNonceChange(block_access_index=4, post_nonce=1)],
            balance_changes=[
                BalBalanceChange(
                    block_access_index=3, post_balance=charlie_value
                ),
                BalBalanceChange(block_access_index=4, post_balance=0),
            ],
        ),
        eunice: BalAccountExpectation(
            nonce_changes=[BalNonceChange(block_access_index=5, post_nonce=1)],
            balance_changes=[
                BalBalanceChange(block_access_index=4, post_balance=dan_value),
                BalBalanceChange(block_access_index=5, post_balance=0),
            ],
        ),
        target: target_bal,
    }

    blockchain_test(
        pre=pre,
        blocks=[
            Block(
                txs=txs,
                expected_block_access_list=BlockAccessListExpectation(
                    account_expectations=account_expectations,
                ),
            )
        ],
        post={
            alice: Account(nonce=1, balance=0),
            bob: Account(nonce=1, balance=0),
            charlie: Account(nonce=1, balance=0),
            dan: Account(nonce=1, balance=0),
            eunice: Account(nonce=1, balance=0),
            target: target_post,
        },
    )

Parametrized Test Cases

This test generates 3 parametrized test cases across 1 fork.