test_top_frame_new_account_skipped_for_create_target_funded_same_block()

Documentation for tests/amsterdam/eip2780_reduce_intrinsic_tx_gas/test_top_frame_charges.py::test_top_frame_new_account_skipped_for_create_target_funded_same_block@26332146.

Generate fixtures for these test cases for Amsterdam with:

fill -v tests/amsterdam/eip2780_reduce_intrinsic_tx_gas/test_top_frame_charges.py::test_top_frame_new_account_skipped_for_create_target_funded_same_block --fork Amsterdam

A creation transaction whose target was funded by an earlier transaction of the same block does not incur the top-frame NEW_ACCOUNT state charge.

This discriminates the transaction pre-state from the block pre-state: get_pre_state_account consults the block's accumulated same-block transaction writes before falling back to the block pre-state, so the funding transaction's new leaf counts as pre-existing for the creation transaction. An implementation snapshotting at block start would charge a second NEW_ACCOUNT, shifting the creation transaction's receipt by 183,600 and doubling the state dimension pinned by the header.

The funding transaction pays its own top-frame NEW_ACCOUNT for materializing the leaf, which the block header pins as the block's entire state-gas dimension: gas_used = max(execution, state) must equal exactly one NEW_ACCOUNT.

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

@pytest.mark.parametrize(
    "value",
    [
        pytest.param(0, id="zero_value"),
        pytest.param(1, id="non-zero_value"),
    ],
)
def test_top_frame_new_account_skipped_for_create_target_funded_same_block(
    fork: Fork,
    pre: Alloc,
    blockchain_test: BlockchainTestFiller,
    value: int,
) -> None:
    """
    A creation transaction whose target was funded by an *earlier
    transaction of the same block* does not incur the top-frame
    ``NEW_ACCOUNT`` state charge.

    This discriminates the transaction pre-state from the block
    pre-state: ``get_pre_state_account`` consults the block's
    accumulated same-block transaction writes before falling back to
    the block pre-state, so the funding transaction's new leaf counts
    as pre-existing for the creation transaction. An implementation
    snapshotting at block start would charge a second ``NEW_ACCOUNT``,
    shifting the creation transaction's receipt by 183,600 and
    doubling the state dimension pinned by the header.

    The funding transaction pays its own top-frame ``NEW_ACCOUNT`` for
    materializing the leaf, which the block header pins as the block's
    entire state-gas dimension: ``gas_used = max(execution, state)`` must
    equal exactly one ``NEW_ACCOUNT``.
    """
    funder = pre.fund_eoa()
    sender = pre.fund_eoa()
    created = compute_create_address(address=sender, nonce=sender.nonce)

    # Transaction 1: fund the future create address. The value transfer
    # to the not-yet-existing leaf pays the top-frame ``NEW_ACCOUNT``.
    prefund = 1
    fund_intrinsic = fork.transaction_intrinsic_cost_calculator()(
        sends_value=True,
        recipient_type=RecipientType.EMPTY_ACCOUNT,
        return_cost_deducted_prior_execution=True,
    )
    fund_state_gas = fork.transaction_top_frame_state_gas(
        sends_value=True,
        recipient_type=RecipientType.EMPTY_ACCOUNT,
    )
    assert fund_state_gas > 0, (
        "funding an empty leaf must charge top-frame state gas"
    )
    fund_total = fund_intrinsic + fund_state_gas
    fund_tx = Transaction(
        sender=funder,
        to=created,
        value=prefund,
        gas_limit=fund_total,
        expected_receipt=TransactionReceipt(cumulative_gas_used=fund_total),
    )

    # Transaction 2: the creation transaction, with gas headroom; the
    # receipt pins the consumed gas to exactly the ``NEW_ACCOUNT``-free
    # total.
    init_code, exec_gas = creation_tx_init_code(fork)
    create_intrinsic = fork.transaction_intrinsic_cost_calculator()(
        calldata=init_code,
        contract_creation=True,
        sends_value=bool(value),
        return_cost_deducted_prior_execution=True,
    )
    create_total = create_intrinsic + exec_gas
    calldata_floor = fork.transaction_data_floor_cost_calculator()(
        data=init_code,
        contract_creation=True,
        sends_value=bool(value),
    )
    assert create_total > calldata_floor, (
        "the exact total must exceed the calldata floor for the "
        "gas pin to observe the skipped charge."
        "Lift memory expansion in `creation_tx_init_code` to fix."
    )
    create_tx = Transaction(
        sender=sender,
        to=None,
        data=init_code,
        value=value,
        gas_limit=create_total,
        expected_receipt=TransactionReceipt(
            cumulative_gas_used=fund_total + create_total
        ),
    )

    # Header pin: the block's state dimension is exactly the funding
    # transaction's ``NEW_ACCOUNT``; both execution intrinsics sit at or
    # above their calldata floors, so no floor term enters the block's
    # execution dimension either.
    block_execution = fund_intrinsic + create_total
    assert fund_state_gas > block_execution, (
        "the state dimension must dominate for the header to pin it"
    )

    post = {
        funder: Account(nonce=1),
        sender: Account(nonce=1),
        created: Account(nonce=1, balance=prefund + value, code=b""),
    }

    blockchain_test(
        pre=pre,
        blocks=[
            Block(
                txs=[fund_tx, create_tx],
                header_verify=Header(gas_used=fund_state_gas),
            ),
        ],
        post=post,
    )

Parametrized Test Cases

This test generates 2 parametrized test cases across 1 fork.