feat(tests): 8037 block 2D gas accounting edge cases

Ported from closed PR ethereum#2639. Adds four tests that exercise
scenarios the existing 2D accounting tests don't cover:

  test_tx_rejected_when_regular_gas_exceeds_block_limit_small
    Complements `test_block_regular_gas_limit`. Uses a tight block
    gas_limit (2 * intrinsic) and a rejected tx sized just one gas
    above the remaining regular budget. Catches clients that only
    handle the TX_MAX-sized case.

  test_block_2d_gas_tx_gas_limit_exceeds_regular_remaining
    Parametrized over `tx_gas_limit_equals_block_limit` and
    `tx_gas_limit_just_above_remaining`. A preceding STOP tx
    consumes regular gas, then a second tx has
    `gas_limit >> TX_MAX_GAS_LIMIT`. The pre-execution check must
    use `min(TX_MAX_GAS_LIMIT, tx.gas - intrinsic.state)` not the
    raw `tx.gas_limit`; clients that subtract the full gas_limit
    reject this valid block.

  test_receipt_cumulative_differs_from_header_gas_used
    Explicit assertion that 2D `header.gas_used` can diverge
    from 1D receipt `cumulative_gas_used` when state dominates.
    Catches clients that mix up the two values.

  test_failed_create_tx_state_gas_dominates (parametrized
    `revert`, `halt`)
    Creation tx (to=None) with tight gas where initcode fails.
    Intrinsic state gas (GAS_NEW_ACCOUNT) is preserved across
    the top-level failure refund; tight regular budget keeps
    block_regular below `create_state_gas` so the state
    dimension dominates the header. Complements PR ethereum#2689's
    `test_creation_tx_failure_preserves_intrinsic_state_gas`
    by covering the REVERT path and the tight-gas scenario.

Author: spencer-tb

tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_block_2d_gas_accounting.py

@@ -22,6 +22,7 @@
     Op,
     Storage,
     Transaction,
+    TransactionException,
 )
 
 from .spec import ref_spec_8037
@@ -466,3 +467,169 @@ def test_multi_block_dimension_flip(
         ],
         post=post_2,
     )
+
+
+@pytest.mark.exception_test
+@pytest.mark.valid_from("EIP8037")
+def test_tx_rejected_when_regular_gas_exceeds_block_limit_small(
+    blockchain_test: BlockchainTestFiller,
+    pre: Alloc,
+    fork: Fork,
+) -> None:
+    """
+    Reject a small-gas tx whose regular contribution overflows the block.
+
+    Complements `test_block_regular_gas_limit` which covers
+    `TX_MAX_GAS_LIMIT`-sized transactions. Here the block has a
+    tight gas_limit (2 * intrinsic) and the second tx's gas_limit
+    sits just one gas above the remaining regular budget, so the
+    pre-execution check rejects it without executing.
+    """
+    gas_limit_cap = fork.transaction_gas_limit_cap()
+    assert gas_limit_cap is not None
+    intrinsic_gas = fork.transaction_intrinsic_cost_calculator()()
+
+    block_gas_limit = intrinsic_gas * 2
+
+    filler = pre.deploy_contract(code=Op.STOP)
+    filler_tx = Transaction(
+        to=filler,
+        gas_limit=intrinsic_gas,
+        sender=pre.fund_eoa(),
+    )
+
+    rejected_gas_limit = intrinsic_gas + 1
+    assert rejected_gas_limit < gas_limit_cap
+    rejected = pre.deploy_contract(code=Op.STOP)
+    rejected_tx = Transaction(
+        to=rejected,
+        gas_limit=rejected_gas_limit,
+        sender=pre.fund_eoa(),
+        error=TransactionException.GAS_ALLOWANCE_EXCEEDED,
+    )
+
+    blockchain_test(
+        genesis_environment=Environment(gas_limit=block_gas_limit),
+        pre=pre,
+        blocks=[
+            Block(
+                txs=[filler_tx, rejected_tx],
+                gas_limit=block_gas_limit,
+                exception=TransactionException.GAS_ALLOWANCE_EXCEEDED,
+            )
+        ],
+        post={},
+    )
+
+
+@pytest.mark.parametrize(
+    "tx2_gas_limit_equals_block_gas_limit",
+    [
+        pytest.param(True, id="tx_gas_limit_equals_block_limit"),
+        pytest.param(False, id="tx_gas_limit_just_above_remaining"),
+    ],
+)
+@pytest.mark.valid_from("EIP8037")
+def test_block_2d_gas_tx_gas_limit_exceeds_regular_remaining(
+    blockchain_test: BlockchainTestFiller,
+    pre: Alloc,
+    fork: Fork,
+    tx2_gas_limit_equals_block_gas_limit: bool,
+) -> None:
+    """
+    Verify block validity when tx.gas_limit exceeds regular remaining.
+
+    After a preceding STOP tx consumes regular gas, the second tx
+    has `gas_limit >> TX_MAX_GAS_LIMIT`. The pre-execution inclusion
+    check must use `min(TX_MAX_GAS_LIMIT, tx.gas - intrinsic.state)`
+    against the cumulative regular budget, not the raw tx.gas_limit.
+    A client that subtracts the full `tx.gas_limit` from the regular
+    pool would reject this otherwise-valid block.
+    """
+    gas_limit_cap = fork.transaction_gas_limit_cap()
+    assert gas_limit_cap is not None
+    intrinsic_gas = fork.transaction_intrinsic_cost_calculator()()
+    env = Environment()
+    block_gas_limit = int(env.gas_limit)
+
+    if tx2_gas_limit_equals_block_gas_limit:
+        tx2_gas_limit = block_gas_limit
+    else:
+        tx2_gas_limit = block_gas_limit - intrinsic_gas + 1
+
+    assert tx2_gas_limit > gas_limit_cap
+    assert tx2_gas_limit > block_gas_limit - intrinsic_gas
+
+    stop_contract = pre.deploy_contract(code=Op.STOP)
+
+    storage = Storage()
+    sstore_contract = pre.deploy_contract(
+        code=Op.SSTORE(storage.store_next(1), 1),
+    )
+
+    tx1_regular = intrinsic_gas
+    tx2_regular, tx2_state = sstore_tx_gas(fork)
+    expected_gas_used = max(tx1_regular + tx2_regular, tx2_state)
+
+    blockchain_test(
+        pre=pre,
+        blocks=[
+            Block(
+                txs=[
+                    Transaction(
+                        to=stop_contract,
+                        gas_limit=intrinsic_gas,
+                        sender=pre.fund_eoa(),
+                    ),
+                    Transaction(
+                        to=sstore_contract,
+                        gas_limit=tx2_gas_limit,
+                        sender=pre.fund_eoa(),
+                    ),
+                ],
+                header_verify=Header(gas_used=expected_gas_used),
+            ),
+        ],
+        post={sstore_contract: Account(storage=storage)},
+    )
+
+
+@pytest.mark.valid_from("EIP8037")
+def test_receipt_cumulative_differs_from_header_gas_used(
+    blockchain_test: BlockchainTestFiller,
+    pre: Alloc,
+    fork: Fork,
+) -> None:
+    """
+    Verify receipt cumulative_gas_used can diverge from header gas_used.
+
+    Under 2D accounting, `header.gas_used = max(sum_regular, sum_state)`
+    while a receipt's `cumulative_gas_used` accumulates per-tx
+    `regular + state`. In a block dominated by state gas, the
+    header is strictly less than the receipt cumulative. A client
+    that uses either value for the other check would reject valid
+    blocks.
+    """
+    tx_regular, tx_state = sstore_tx_gas(fork)
+    num_txs = 3
+
+    txs, post = sstore_txs(pre, fork, num_txs)
+
+    block_regular = num_txs * tx_regular
+    block_state = num_txs * tx_state
+    header_gas_used = max(block_regular, block_state)
+    receipt_cumulative = num_txs * (tx_regular + tx_state)
+
+    assert block_state > block_regular
+    assert header_gas_used < receipt_cumulative
+
+    blockchain_test(
+        pre=pre,
+        blocks=[
+            Block(
+                txs=txs,
+                header_verify=Header(gas_used=header_gas_used),
+            ),
+        ],
+        post=post,
+    )

tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_create.py

@@ -1533,3 +1533,64 @@ def test_create_code_deposit_oog_refunds_state_gas(
     )
 
     state_test(pre=pre, post={factory: Account(storage=storage)}, tx=tx)
+
+
+@pytest.mark.parametrize(
+    "init_code",
+    [
+        pytest.param(Op.REVERT(0, 0), id="revert"),
+        pytest.param(Op.INVALID, id="halt"),
+    ],
+)
+@pytest.mark.valid_from("EIP8037")
+def test_failed_create_tx_state_gas_dominates(
+    blockchain_test: BlockchainTestFiller,
+    pre: Alloc,
+    fork: Fork,
+    init_code: Bytecode,
+) -> None:
+    """
+    Verify 2D header gas_used when a failed creation tx's state dominates.
+
+    A creation tx (to=None) with a tight gas limit whose initcode
+    fails via REVERT or INVALID. The intrinsic state gas for the
+    new account is preserved across the top-level failure refund
+    (only execution state gas is zeroed). With a tight regular
+    budget the state dimension dominates and the header must
+    equal `create_state_gas`. A client using 1D sum-based
+    accounting would produce a different header value.
+
+    Complements PR #2689's
+    `test_creation_tx_failure_preserves_intrinsic_state_gas` by
+    exercising the REVERT path and the tight-gas scenario.
+    """
+    intrinsic_calc = fork.transaction_intrinsic_cost_calculator()
+    create_state_gas = fork.create_state_gas(code_size=0)
+
+    intrinsic_total = intrinsic_calc(
+        calldata=bytes(init_code), contract_creation=True
+    )
+    intrinsic_regular = intrinsic_total - create_state_gas
+    gas_limit = intrinsic_total + 1000
+
+    assert intrinsic_regular + 1000 < create_state_gas, (
+        "tight gas budget must keep block_regular below create_state_gas"
+    )
+
+    tx = Transaction(
+        to=None,
+        data=init_code,
+        gas_limit=gas_limit,
+        sender=pre.fund_eoa(),
+    )
+
+    blockchain_test(
+        pre=pre,
+        blocks=[
+            Block(
+                txs=[tx],
+                header_verify=Header(gas_used=create_state_gas),
+            ),
+        ],
+        post={},
+    )