test_nested_failure_resets_to_tx_reservoir()

Documentation for tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_reservoir.py::test_nested_failure_resets_to_tx_reservoir@5c024cbb.

Generate fixtures for these test cases for Amsterdam with:

fill -v tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_reservoir.py::test_nested_failure_resets_to_tx_reservoir --fork Amsterdam

Verify failure cascade refunds state-gas to the top reservoir.

Each frame runs its parametrized body, then calls or CREATEs the next frame, terminating with the failure mode. Every level fails so the cascade reaches the top.

Axes: - failure_mode: REVERT vs HALT. Top-level gas_left semantics differ, but state gas refund must agree per the updated EIP. - spill_mode: no_spill sizes the reservoir to cover all state gas charges. spill shrinks it so charges drain into gas_left, exercising the spill-refund-on-halt rule. - frame_op: call chains via CALL with no per-frame pre-charge. create chains via CREATE, where each level pre-charges STATE_BYTES_PER_NEW_ACCOUNT * cpsb and exercises credit-on-failure interleaved with the spill.

Refunds are LIFO. On REVERT every state gas charge (body charges, spilled portions, and CREATE pre-charges) is refilled, the spill landing back in gas_left, so the user pays only regular charges plus intrinsic. On HALT the LIFO refill returns spilled state gas to gas_left, which is then zeroed, so only the start reservoir survives and the user pays tx_gas - reservoir = gas_limit_cap, regardless of spill axis or CREATE pre-charges.

Two assertions cross-check the gas accounting: - cumulative_gas_used (receipt) pins tx.gas - gas_left - state_gas_left, catching bugs in the leftover split. - header.gas_used pins max(block_regular, block_state) via the block accumulators.

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

@pytest.mark.parametrize(
    "frame_bodies",
    [
        pytest.param(
            [
                Op.SSTORE(0, 1),
                Op.SSTORE(1, 1),
                Op.SSTORE(2, 1),
                Op.SSTORE(3, 1),
            ],
            id="depth_4_sstore_each",
        ),
        pytest.param(
            [
                Op.SSTORE(0, 1),
                Bytecode(),
                Op.SSTORE(2, 1),
                Bytecode(),
            ],
            id="depth_4_alternating_state",
        ),
        pytest.param(
            [Bytecode(), Bytecode(), Bytecode(), Bytecode()],
            id="depth_4_no_state",
        ),
        pytest.param(
            [
                Op.SSTORE(0, 1) + Op.SSTORE(1, 1),
                Op.SSTORE(2, 1) + Op.SSTORE(3, 1),
                Op.SSTORE(4, 1) + Op.SSTORE(5, 1),
            ],
            id="depth_3_two_sstores_each",
        ),
        pytest.param(
            [
                Bytecode(),
                Bytecode(),
                Op.SSTORE(0, 1)
                + Op.SSTORE(
                    0,
                    0,
                    key_warm=True,
                    original_value=0,
                    current_value=1,
                    new_value=0,
                ),
            ],
            id="depth_3_deepest_0_to_x_to_0",
        ),
        pytest.param(
            [
                Bytecode(),
                Bytecode(),
                Op.SSTORE(0, 1)
                + Op.SSTORE(
                    0,
                    2,
                    key_warm=True,
                    original_value=0,
                    current_value=1,
                    new_value=2,
                )
                + Op.SSTORE(
                    0,
                    0,
                    key_warm=True,
                    original_value=0,
                    current_value=2,
                    new_value=0,
                ),
            ],
            id="depth_3_deepest_0_to_x_to_y_to_0",
        ),
    ],
)
@pytest.mark.parametrize(
    "failure_mode",
    [
        pytest.param("revert", id="revert"),
        pytest.param("halt", id="halt"),
    ],
)
@pytest.mark.parametrize(
    "spill_mode",
    [
        pytest.param("no_spill", id="no_spill"),
        pytest.param("spill", id="spill"),
    ],
)
@pytest.mark.parametrize(
    "frame_op",
    [
        pytest.param("call", id="call_chain"),
        pytest.param("create", id="create_chain"),
    ],
)
@pytest.mark.valid_from("EIP8037")
def test_nested_failure_resets_to_tx_reservoir(
    blockchain_test: BlockchainTestFiller,
    pre: Alloc,
    fork: Fork,
    failure_mode: str,
    frame_bodies: list[Bytecode],
    spill_mode: str,
    frame_op: str,
) -> None:
    """
    Verify failure cascade refunds state-gas to the top reservoir.

    Each frame runs its parametrized body, then calls or CREATEs the
    next frame, terminating with the failure mode. Every level fails
    so the cascade reaches the top.

    Axes:
    - `failure_mode`: REVERT vs HALT. Top-level gas_left semantics
      differ, but state gas refund must agree per the updated EIP.
    - `spill_mode`: `no_spill` sizes the reservoir to cover all state
      gas charges. `spill` shrinks it so charges drain into gas_left,
      exercising the spill-refund-on-halt rule.
    - `frame_op`: `call` chains via CALL with no per-frame pre-charge.
      `create` chains via CREATE, where each level pre-charges
      `STATE_BYTES_PER_NEW_ACCOUNT * cpsb` and exercises
      credit-on-failure interleaved with the spill.

    Refunds are LIFO. On REVERT every state gas charge (body charges,
    spilled portions, and CREATE pre-charges) is refilled, the spill
    landing back in `gas_left`, so the user pays only regular charges
    plus intrinsic. On HALT the LIFO refill returns spilled state gas
    to `gas_left`, which is then zeroed, so only the start reservoir
    survives and the user pays `tx_gas - reservoir = gas_limit_cap`,
    regardless of spill axis or CREATE pre-charges.

    Two assertions cross-check the gas accounting:
    - `cumulative_gas_used` (receipt) pins `tx.gas - gas_left -
      state_gas_left`, catching bugs in the leftover split.
    - `header.gas_used` pins `max(block_regular, block_state)` via
      the block accumulators.
    """
    gas_limit_cap = fork.transaction_gas_limit_cap()
    assert gas_limit_cap is not None
    sstore_state_gas = Op.SSTORE(new_value=1).state_cost(fork)
    new_account_state_gas = fork.gas_costs().NEW_ACCOUNT
    intrinsic_cost = fork.transaction_intrinsic_cost_calculator()()

    body_state_total = sum(b.state_cost(fork) for b in frame_bodies)
    n_creates = (len(frame_bodies) - 1) if frame_op == "create" else 0
    total_state_charges = body_state_total + n_creates * new_account_state_gas

    if spill_mode == "no_spill":
        # Reservoir comfortably covers all state-gas charges.
        reservoir = max(
            total_state_charges + sstore_state_gas, sstore_state_gas
        )
    else:
        # Reservoir is small; charges spill into gas_left.
        reservoir = sstore_state_gas
    tx_gas = gas_limit_cap + reservoir

    terminator = Op.REVERT(0, 0) if failure_mode == "revert" else Op.INVALID

    if frame_op == "call":
        top, frame_codes = _build_call_chain(pre, frame_bodies, terminator)
    else:
        top, frame_codes = _build_create_chain(pre, frame_bodies, terminator)

    sum_regular = sum(code.regular_cost(fork) for code in frame_codes)
    if failure_mode == "halt":
        # LIFO refill returns spilled state gas (and spilled CREATE
        # pre-charges) to gas_left, which halt then zeros. Only the
        # start reservoir survives.
        expected_cumulative = tx_gas - reservoir
        assert expected_cumulative == gas_limit_cap
        # Header: all gas_left (including the refilled spill) is
        # consumed as regular. Block state gas is zero for plain
        # frames.
        expected_header_gas_used = gas_limit_cap
    elif failure_mode == "revert":
        # Revert preserves gas_left, full state gas refund, so the
        # user pays only regular costs plus intrinsic.
        expected_cumulative = intrinsic_cost + sum_regular
        # Header reflects the regular-vs-state attribution directly:
        # state_gas_used is zeroed by the tx error handler, so only
        # regular gas usage shows up.
        expected_header_gas_used = intrinsic_cost + sum_regular
    else:
        raise ValueError("Invariant, unreachable code.")

    tx = Transaction(
        to=top,
        state_gas_reservoir=reservoir,
        sender=pre.fund_eoa(),
        expected_receipt=TransactionReceipt(
            cumulative_gas_used=expected_cumulative,
        ),
    )

    blockchain_test(
        pre=pre,
        blocks=[
            Block(
                txs=[tx],
                header_verify=Header(gas_used=expected_header_gas_used),
            )
        ],
        post={},
    )

Parametrized Test Cases

This test generates 48 parametrized test cases across 1 fork.