test_reverted_dispatch_state_gas_counts_toward_block_limit()

Documentation for tests/amsterdam/eip2780_reduce_intrinsic_tx_gas/test_authorization_oog.py::test_reverted_dispatch_state_gas_counts_toward_block_limit@26332146.

Generate fixtures for these test cases for Amsterdam with:

fill -v tests/amsterdam/eip2780_reduce_intrinsic_tx_gas/test_authorization_oog.py::test_reverted_dispatch_state_gas_counts_toward_block_limit --fork Amsterdam

The state gas persisted by a reverted transaction's authorization counts against the block's state dimension when including later transactions.

The first transaction applies an account-creating authorization and its dispatched call reverts: the delegation, and the state gas that paid for it, persist. The last transaction is then sized to the remaining state capacity exactly (exact_fit: the inclusion check is strictly greater-than, so the block is valid) or one gas beyond it (exceeded: the per-transaction state check fires and the block is correctly rejected).

The execution dimension is asserted to have room either way, pinning the rejection to the state dimension. An implementation that drops a reverted transaction's persisting state gas from the block's state total would accept the exceeded block and fork.

Source code in tests/amsterdam/eip2780_reduce_intrinsic_tx_gas/test_authorization_oog.py

@pytest.mark.inclusion_test
@pytest.mark.parametrize(
    "delta",
    [
        pytest.param(0, id="exact_fit"),
        pytest.param(1, id="exceeded", marks=pytest.mark.exception_test),
    ],
)
def test_reverted_dispatch_state_gas_counts_toward_block_limit(
    fork: Fork,
    pre: Alloc,
    blockchain_test: BlockchainTestFiller,
    delta: int,
) -> None:
    """
    The state gas persisted by a reverted transaction's authorization
    counts against the block's state dimension when including later
    transactions.

    The first transaction applies an account-creating authorization and
    its dispatched call reverts: the delegation, and the state gas that
    paid for it, persist. The last transaction is then sized to the
    remaining state capacity exactly (``exact_fit``: the inclusion
    check is strictly greater-than, so the block is valid) or one gas
    beyond it (``exceeded``: the per-transaction state check fires and
    the block is correctly rejected).

    The execution dimension is asserted to have room either way, pinning
    the rejection to the state dimension. An implementation that drops
    a reverted transaction's persisting state gas from the block's
    state total would accept the ``exceeded`` block and fork.
    """
    cap = fork.transaction_gas_limit_cap()
    assert cap is not None, "EIP-7825 cap expected on this fork"

    block_gas_limit = 100_000_000

    revert_code = Op.REVERT(0, 0)
    recipient = pre.deploy_contract(code=revert_code)

    auth = build_authorization(pre, AuthorizationAction.CREATES_ACCOUNT)
    authorization_list = [auth.authorization]

    intrinsic_execution = _intrinsic_execution(
        fork, authorization_list, recipient_type=RecipientType.CONTRACT
    )
    auth_execution = fork.transaction_top_frame_gas_calculator()(
        recipient_type=RecipientType.CONTRACT,
        authorizations=authorization_list,
    )
    auth_state = fork.transaction_top_frame_state_gas(
        recipient_type=RecipientType.CONTRACT,
        authorizations=authorization_list,
    )
    revert_exec_gas = revert_code.gas_cost(fork)

    first_tx_execution = intrinsic_execution + auth_execution + revert_exec_gas
    first_tx = Transaction(
        sender=pre.fund_eoa(),
        to=recipient,
        value=0,
        authorization_list=authorization_list,
        gas_limit=first_tx_execution + auth_state,
    )

    # The last transaction's worst-case state contribution is its full
    # ``tx.gas`` (the strict EIP-8037 inclusion rule), charged against
    # a state dimension that already carries the reverted first
    # transaction's persisting authorization state gas.
    state_available = block_gas_limit - auth_state
    last_tx_gas = state_available + delta

    # Pin the rejection (when delta > 0) to the state check: the
    # execution check must not fire.
    execution_available = block_gas_limit - first_tx_execution
    assert min(cap, last_tx_gas) < execution_available, (
        "the last tx would fail the execution check instead of the state check"
    )

    last_tx_error = (
        TransactionException.GAS_ALLOWANCE_EXCEEDED if delta > 0 else None
    )
    last_tx = Transaction(
        sender=pre.fund_eoa(),
        to=pre.deploy_contract(code=Op.STOP),
        value=0,
        gas_limit=last_tx_gas,
        error=last_tx_error,
    )

    # On rejection nothing in the block applies; on the exact fit the
    # reverted first transaction still leaves its delegation behind.
    post = {} if delta > 0 else {auth.authority: auth.applied_account}

    blockchain_test(
        genesis_environment=Environment(gas_limit=block_gas_limit),
        pre=pre,
        blocks=[
            Block(
                txs=[first_tx, last_tx],
                gas_limit=block_gas_limit,
                exception=last_tx_error,
            )
        ],
        post=post,
    )

Parametrized Test Cases

This test generates 2 parametrized test cases across 1 fork.