test_create_account_charge_reduces_child_gas()

Documentation for tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_create.py::test_create_account_charge_reduces_child_gas@622620d8.

Generate fixtures for these test cases for Amsterdam with:

fill -v tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_create.py::test_create_account_charge_reduces_child_gas --fork Amsterdam

Verify the early NEW_ACCOUNT charge reduces forwarded child gas.

generic_create charges NEW_ACCOUNT before computing the child's 63/64 share. When the reservoir covers the charge gas_left is untouched and the child receives the full share. When the reservoir is empty the charge spills NEW_ACCOUNT from gas_left first, so the child receives NEW_ACCOUNT * 63 / 64 less. The init code burns a fixed amount sized between the two shares, so it deploys when the charge comes from the reservoir and runs out of gas when it spills. The target is fresh, so NEW_ACCOUNT is required. The created account is checked directly, avoiding a post-CREATE SSTORE with an unrelated state gas requirement.

Source code in tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_create.py

@pytest.mark.parametrize(
    "reservoir_covers",
    [
        pytest.param(True, id="charge_from_reservoir"),
        pytest.param(False, id="charge_spills_from_gas_left"),
    ],
)
@pytest.mark.with_all_create_opcodes()
@pytest.mark.valid_from("EIP8037")
def test_create_account_charge_reduces_child_gas(
    state_test: StateTestFiller,
    pre: Alloc,
    fork: Fork,
    create_opcode: Op,
    reservoir_covers: bool,
) -> None:
    """
    Verify the early NEW_ACCOUNT charge reduces forwarded child gas.

    `generic_create` charges NEW_ACCOUNT before computing the child's
    63/64 share. When the reservoir covers the charge `gas_left` is
    untouched and the child receives the full share. When the reservoir
    is empty the charge spills NEW_ACCOUNT from `gas_left` first, so the
    child receives `NEW_ACCOUNT * 63 / 64` less. The init code burns a
    fixed amount sized between the two shares, so it deploys when the
    charge comes from the reservoir and runs out of gas when it spills.
    The target is fresh, so NEW_ACCOUNT is required. The created account is
    checked directly, avoiding a post-CREATE SSTORE with an unrelated state
    gas requirement.
    """
    new_account = create_opcode(account_new=True).state_cost(fork)
    memory_gas = fork.memory_expansion_gas_calculator()

    # Factory `gas_left` at the NEW_ACCOUNT charge. Three times
    # NEW_ACCOUNT gives a wide discrimination window and a large
    # absolute child share.
    gas_at_charge = 3 * new_account
    full_share = gas_at_charge - gas_at_charge // 64
    spilled = gas_at_charge - new_account
    reduced_share = spilled - spilled // 64
    # Burn the middle of `(reduced_share, full_share]` for robustness.
    target_burn = (full_share + reduced_share) // 2

    # Init code burns `target_burn` execution gas via one MSTORE memory
    # expansion, then deploys empty code (zero code deposit). Invert
    # `words * MEMORY_PER_WORD + words ** 2 // 512 = target_mem` to size
    # the sink offset from gas rather than a magic number.
    init_static = (Op.MSTORE(0, 0) + Op.RETURN(0, 0)).gas_cost(fork)
    target_mem = target_burn - init_static
    # Memory cost is monotonic in word count, so binary search the
    # largest word count whose expansion stays within `target_mem`.
    low, high = 1, target_mem
    while low < high:
        mid = (low + high + 1) // 2
        if int(memory_gas(new_bytes=mid * 32)) <= target_mem:
            low = mid
        else:
            high = mid - 1
    words = low
    sink_offset = (words - 1) * 32
    child_burn = init_static + int(memory_gas(new_bytes=words * 32))
    assert reduced_share < child_burn <= full_share

    init_code = Op.MSTORE(sink_offset, 0) + Op.RETURN(0, 0)
    mstore_value, size = init_code_at_high_bytes(init_code)
    create_call = (
        create_opcode(value=0, offset=0, size=size, salt=0)
        if create_opcode == Op.CREATE2
        else create_opcode(value=0, offset=0, size=size)
    )

    storage = Storage()
    expected = 1 if reservoir_covers else 0
    factory = pre.deploy_contract(
        code=Op.MSTORE(0, mstore_value)
        + Op.SSTORE(
            storage.store_next(expected, "child_succeeds"),
            Op.GT(create_call, 0),
        ),
    )

    # Pre-existing balance-only target: the success-refund path. Under
    # the old conditional approach this alive target skips NEW_ACCOUNT,
    # so the child gets the full share and fits in both cases.
    if create_opcode == Op.CREATE2:
        create_address = compute_create2_address(
            address=factory, salt=0, initcode=bytes(init_code)
        )
    else:
        create_address = compute_create_address(address=factory, nonce=1)
    pre.fund_address(create_address, amount=1)

    # Execution gas the factory spends before the NEW_ACCOUNT charge: the
    # initcode setup MSTORE plus the create opcode's execution portion.
    setup = Op.MSTORE(0, mstore_value)
    pre_charge_execution = setup.gas_cost(fork) + create_call.execution_cost(
        fork
    )
    forwarded_gas = gas_at_charge + pre_charge_execution
    caller = pre.deploy_contract(
        code=Op.CALL(gas=forwarded_gas, address=factory)
    )
    tx = Transaction(
        to=caller,
        state_gas_reservoir=new_account if reservoir_covers else 0,
        sender=pre.fund_eoa(),
    )

    state_test(pre=pre, post={factory: Account(storage=storage)}, tx=tx)

Parametrized Test Cases

This test generates 4 parametrized test cases across 1 fork.