feat(tests): refund EIP-8037 account creation for existing create targets

Author: spencer-tb

tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_create.py

@@ -1210,11 +1210,20 @@ def test_code_deposit_halt_discards_initcode_state_gas(
     )
 
 
+@pytest.mark.parametrize(
+    "target",
+    [
+        pytest.param("new", id="new_account"),
+        pytest.param("existing", id="existing_account"),
+    ],
+)
+@pytest.mark.pre_alloc_mutable()
 @pytest.mark.valid_from("EIP8037")
 def test_create_tx_header_gas_used(
     blockchain_test: BlockchainTestFiller,
     pre: Alloc,
     fork: Fork,
+    target: str,
 ) -> None:
     """
     Verify block header gas_used for a successful CREATE transaction.
@@ -1223,22 +1232,45 @@ def test_create_tx_header_gas_used(
     exact gas_used from first principles and verify against the block
     header. Catches bugs where clients report gas_limit instead of
     actual consumed gas.
+
+    For a fresh target the NEW_ACCOUNT state gas is charged and
+    dominates the regular gas, so gas_used == NEW_ACCOUNT. For a
+    pre-existing balance-only leaf the NEW_ACCOUNT charge is refunded,
+    so net state gas is zero and the regular intrinsic gas dominates.
+    The expected value subtracts NEW_ACCOUNT and so fails if the
+    refund regresses.
     """
     gas_costs = fork.gas_costs()
     initcode = Op.STOP
     create_state_gas = fork.create_state_gas(code_size=1)
 
+    if target == "existing":
+        sender = pre.fund_eoa(nonce=0)
+        contract_address = compute_create_address(address=sender, nonce=0)
+        # Balance-only leaf: alive and deployable, so the creation
+        # succeeds and the intrinsic NEW_ACCOUNT charge is refunded.
+        pre.fund_address(contract_address, amount=1)
+    else:
+        sender = pre.fund_eoa()
+
     tx = Transaction(
         to=None,
         data=initcode,
         state_gas_reservoir=create_state_gas,
-        sender=pre.fund_eoa(),
+        sender=sender,
     )
 
     # block_gas_used = max(block_regular, block_state)
-    # For a minimal CREATE tx deploying Op.STOP (1 byte),
-    # state gas (new account) dominates regular gas.
-    expected_gas_used = gas_costs.NEW_ACCOUNT
+    if target == "existing":
+        intrinsic_cost = fork.transaction_intrinsic_cost_calculator()
+        intrinsic_total = intrinsic_cost(
+            calldata=bytes(initcode), contract_creation=True
+        )
+        expected_gas_used = intrinsic_total - gas_costs.NEW_ACCOUNT
+    else:
+        # For a minimal CREATE tx deploying Op.STOP (1 byte),
+        # state gas (new account) dominates regular gas.
+        expected_gas_used = gas_costs.NEW_ACCOUNT
 
     blockchain_test(
         pre=pre,
@@ -2568,3 +2600,73 @@ def test_create_collision_burned_gas_counted_in_block_regular(
         ],
         post={},
     )
+
+
+@pytest.mark.parametrize(
+    "target",
+    [
+        pytest.param("new", id="new_account"),
+        pytest.param("existing", id="existing_account"),
+    ],
+)
+@pytest.mark.with_all_create_opcodes()
+@pytest.mark.valid_from("EIP8037")
+def test_create_account_creation_charge(
+    blockchain_test: BlockchainTestFiller,
+    pre: Alloc,
+    fork: Fork,
+    create_opcode: Op,
+    target: str,
+) -> None:
+    """
+    Verify NEW_ACCOUNT is charged for a new account and refunded for a
+    pre-existing balance-only leaf.
+
+    Empty init code means zero code deposit, so NEW_ACCOUNT is the only
+    create state cost. A fresh target is charged it; a pre-existing
+    balance-only target (balance, no code, zero nonce) refunds it on
+    success. The probe SSTORE both confirms the create succeeded and
+    makes state gas dominate, so gas_used drops by exactly NEW_ACCOUNT
+    when refunded.
+    """
+    new_account = fork.gas_costs().NEW_ACCOUNT
+    sstore_state_gas = Op.SSTORE(new_value=1).state_cost(fork)
+    mstore_value, size = init_code_at_high_bytes(Op.STOP)
+    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()
+    factory = pre.deploy_contract(
+        code=Op.MSTORE(0, mstore_value)
+        + Op.SSTORE(
+            storage.store_next(1, "create_succeeds"), Op.GT(create_call, 0)
+        )
+    )
+
+    # Factory deployed via deploy_contract starts at nonce 1.
+    if create_opcode == Op.CREATE2:
+        create_address = compute_create2_address(
+            address=factory, salt=0, initcode=bytes(Op.STOP)
+        )
+    else:
+        create_address = compute_create_address(address=factory, nonce=1)
+    if target == "existing":
+        pre.fund_address(create_address, amount=1)
+
+    tx = Transaction(
+        to=factory,
+        state_gas_reservoir=new_account + sstore_state_gas,
+        sender=pre.fund_eoa(),
+    )
+
+    # State gas dominates regular: a new account adds NEW_ACCOUNT on top
+    # of the probe SSTORE, a pre-existing target refunds it.
+    expected = sstore_state_gas + (new_account if target == "new" else 0)
+    blockchain_test(
+        pre=pre,
+        blocks=[Block(txs=[tx], header_verify=Header(gas_used=expected))],
+        post={factory: Account(storage=storage)},
+    )