feat(spec-specs, tests): charge EIP-8037 account creation at access (#3116)

Author: spencer-tb

src/ethereum/forks/amsterdam/fork.py

@@ -1058,11 +1058,19 @@ def process_transaction(
     effective_gas_fee = tx.gas * effective_gas_price
 
     # Split execution gas into gas_left (capped by remaining regular gas
-    # budget) and state_gas_reservoir.
+    # budget) and state_gas_reservoir. The contract-creation component
+    # of the intrinsic state gas is seeded into the reservoir rather
+    # than pre-consumed; it funds the conditional charge at the
+    # deployment-address access.
     execution_gas = tx.gas - intrinsic_gas
     regular_gas_budget = TX_MAX_GAS_LIMIT - intrinsic.regular
     gas = min(regular_gas_budget, execution_gas)
-    state_gas_reservoir = Uint(execution_gas - gas)
+    create_state_gas = (
+        Uint(StateGasCosts.NEW_ACCOUNT)
+        if isinstance(tx.to, Bytes0)
+        else Uint(0)
+    )
+    state_gas_reservoir = Uint(execution_gas - gas) + create_state_gas
 
     increment_nonce(tx_state, sender)
 
@@ -1110,13 +1118,6 @@ def process_transaction(
 
     tx_output = process_message_call(message)
 
-    if isinstance(tx.to, Bytes0) and (
-        tx_output.error is not None or tx_output.created_target_alive
-    ):
-        new_account_refund = StateGasCosts.NEW_ACCOUNT
-        tx_output.state_gas_left += new_account_refund
-        tx_output.state_refund += new_account_refund
-
     tx_gas_used_before_refund = (
         tx.gas - tx_output.gas_left - tx_output.state_gas_left
     )
@@ -1144,6 +1145,7 @@ def process_transaction(
 
     tx_state_gas = (
         int(tx_env.intrinsic_state_gas)
+        - int(create_state_gas)
         + tx_output.state_gas_used
         - int(tx_output.state_refund)
     )

src/ethereum/forks/amsterdam/vm/instructions/system.py

@@ -84,24 +84,12 @@ def generic_create(
     if memory_size > U256(MAX_INIT_CODE_SIZE):
         raise OutOfGasError
 
-    # Charge state gas for account creation (pay-before-execute).
-    # Refunded to the reservoir on any failure path below.
-    charge_state_gas(evm, StateGasCosts.NEW_ACCOUNT)
-
     tx_state = evm.message.tx_env.state
 
     call_data = memory_read_bytes(
         evm.memory, memory_start_position, memory_size
     )
 
-    create_message_gas = max_message_call_gas(Uint(evm.gas_left))
-    evm.gas_left -= create_message_gas
-
-    # Move full reservoir to child (no 63/64 rule for state gas). Parent's
-    # `state_gas_left` is zeroed and restored when the child returns.
-    create_message_state_gas_reservoir = evm.state_gas_left
-    evm.state_gas_left = Uint(0)
-
     evm.return_data = b""
 
     sender_address = evm.message.current_target
@@ -112,26 +100,36 @@ def generic_create(
         or sender.nonce == Uint(2**64 - 1)
         or evm.message.depth + Uint(1) > STACK_DEPTH_LIMIT
     ):
-        evm.gas_left += create_message_gas
-        evm.state_gas_left += create_message_state_gas_reservoir
-        credit_state_gas_refund(evm, StateGasCosts.NEW_ACCOUNT)
         push(evm.stack, U256(0))
         return
 
     evm.accessed_addresses.add(contract_address)
 
+    # The charge is decided by existence alone, independently of the
+    # collision outcome.
+    new_account_charged = not is_account_alive(tx_state, contract_address)
+    if new_account_charged:
+        charge_state_gas(evm, StateGasCosts.NEW_ACCOUNT)
+
+    create_message_gas = max_message_call_gas(Uint(evm.gas_left))
+    evm.gas_left -= create_message_gas
+
     if not account_deployable(tx_state, contract_address):
-        increment_nonce(tx_state, evm.message.current_target)
+        increment_nonce(tx_state, sender_address)
         evm.regular_gas_used += create_message_gas
-        evm.state_gas_left += create_message_state_gas_reservoir
-        # Address collision — no account created, refund state gas.
-        credit_state_gas_refund(evm, StateGasCosts.NEW_ACCOUNT)
+        # A storage-only collision target is non-existent: charged
+        # above, refilled here.
+        if new_account_charged:
+            credit_state_gas_refund(evm, StateGasCosts.NEW_ACCOUNT)
         push(evm.stack, U256(0))
         return
 
-    target_alive = is_account_alive(tx_state, contract_address)
+    # Move full reservoir to child (no 63/64 rule for state gas). Parent's
+    # `state_gas_left` is zeroed and restored when the child returns.
+    create_message_state_gas_reservoir = evm.state_gas_left
+    evm.state_gas_left = Uint(0)
 
-    increment_nonce(tx_state, evm.message.current_target)
+    increment_nonce(tx_state, sender_address)
 
     child_message = Message(
         block_env=evm.message.block_env,
@@ -157,14 +155,12 @@ def generic_create(
 
     if child_evm.error:
         incorporate_child_on_error(evm, child_evm)
-        # No account created, refund parent's CREATE state gas.
-        credit_state_gas_refund(evm, StateGasCosts.NEW_ACCOUNT)
+        if new_account_charged:
+            credit_state_gas_refund(evm, StateGasCosts.NEW_ACCOUNT)
         evm.return_data = child_evm.output
         push(evm.stack, U256(0))
     else:
         incorporate_child_on_success(evm, child_evm)
-        if target_alive:
-            credit_state_gas_refund(evm, StateGasCosts.NEW_ACCOUNT)
         evm.return_data = b""
         push(evm.stack, U256.from_be_bytes(child_evm.message.current_target))
 

src/ethereum/forks/amsterdam/vm/interpreter.py

@@ -97,8 +97,6 @@ class MessageCallOutput:
              authorities that already existed in state. Subtracted from
              `tx_state_gas` in block accounting so `block.gas_used`
              matches the receipt `cumulative_gas_used`.
-          10. `created_target_alive`: Whether a top-level creation
-              transaction targeted an already-existent account.
     """
 
     gas_left: Uint
@@ -111,7 +109,6 @@ class MessageCallOutput:
     regular_gas_used: Uint
     state_gas_used: int
     state_refund: Uint
-    created_target_alive: bool
 
 
 def process_message_call(message: Message) -> MessageCallOutput:
@@ -133,12 +130,23 @@ def process_message_call(message: Message) -> MessageCallOutput:
     tx_state = message.tx_env.state
     refund_counter = U256(0)
     state_refund = Uint(0)
-    target_alive = False
+    new_account_charged = False
     if message.target == Bytes0(b""):
+        # The charge is decided by existence alone, independently of
+        # the collision outcome. The reservoir seeding guarantees the
+        # charge is always covered.
+        new_account_charged = not is_account_alive(
+            tx_state, message.current_target
+        )
+        if new_account_charged:
+            message.state_gas_reservoir -= Uint(StateGasCosts.NEW_ACCOUNT)
         if account_deployable(tx_state, message.current_target):
-            target_alive = is_account_alive(tx_state, message.current_target)
             evm = process_create_message(message)
         else:
+            if new_account_charged:
+                # A storage-only collision target is non-existent:
+                # charged above, refilled here.
+                message.state_gas_reservoir += Uint(StateGasCosts.NEW_ACCOUNT)
             return MessageCallOutput(
                 gas_left=Uint(0),
                 refund_counter=U256(0),
@@ -150,7 +158,6 @@ def process_message_call(message: Message) -> MessageCallOutput:
                 regular_gas_used=message.gas,
                 state_gas_used=0,
                 state_refund=Uint(0),
-                created_target_alive=False,
             )
     else:
         if message.tx_env.authorizations != ():
@@ -182,6 +189,15 @@ def process_message_call(message: Message) -> MessageCallOutput:
     )
     evm_trace(evm, tx_end)
 
+    state_gas_used = frame_state_gas_used(evm)
+    if new_account_charged:
+        if evm.error:
+            # Account creation rolled back: refill the charge taken at
+            # the deployment-address access.
+            evm.state_gas_left += Uint(StateGasCosts.NEW_ACCOUNT)
+        else:
+            state_gas_used += int(StateGasCosts.NEW_ACCOUNT)
+
     return MessageCallOutput(
         gas_left=evm.gas_left,
         refund_counter=refund_counter,
@@ -191,9 +207,8 @@ def process_message_call(message: Message) -> MessageCallOutput:
         return_data=evm.output,
         state_gas_left=evm.state_gas_left,
         regular_gas_used=evm.regular_gas_used,
-        state_gas_used=frame_state_gas_used(evm),
+        state_gas_used=state_gas_used,
         state_refund=state_refund,
-        created_target_alive=target_alive,
     )
 
 

tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists_opcodes.py

@@ -3298,8 +3298,10 @@ def test_bal_create_and_oog(
     CREATE/CREATE2 OOG boundary test at three gas levels.
 
     OOG_BEFORE_TARGET_ACCESS and OOG_AFTER_TARGET_ACCESS differ by
-    exactly 1 gas, proving the static cost boundary: below it the
-    created address is NOT in BAL, at it the address IS in BAL.
+    exactly 1 gas, proving the pre-access cost boundary: below it the
+    created address is NOT in BAL, at it the address IS in BAL. Under
+    EIP-8037 charge-at-access this boundary excludes NEW_ACCOUNT, which
+    is charged at the access rather than before it.
     """
     alice = pre.fund_eoa()
 
@@ -3344,14 +3346,19 @@ def test_bal_create_and_oog(
     create_static_cost = factory_mstore.gas_cost(
         fork
     ) + factory_create.gas_cost(fork)
+    # Under EIP-8037 charge-at-access the NEW_ACCOUNT state gas is charged
+    # at the destination access, not before it, so the pre-access cost that
+    # gates whether the address is read excludes it. `gas_cost` folds
+    # NEW_ACCOUNT into the create opcode total, so strip it back out.
+    pre_access_cost = create_static_cost - fork.gas_costs().NEW_ACCOUNT
 
     if oog_boundary == OutOfGasBoundary.OOG_BEFORE_TARGET_ACCESS:
-        # 1 gas short of CREATE static cost — no state access
-        gas_limit = intrinsic_cost + create_static_cost - 1
+        # 1 gas short of the pre-access cost — no state access
+        gas_limit = intrinsic_cost + pre_access_cost - 1
     elif oog_boundary == OutOfGasBoundary.OOG_AFTER_TARGET_ACCESS:
-        # Exactly the CREATE static cost — address accessed, child
-        # frame gets 0 gas, CREATE fails, sink forces OOG after access
-        gas_limit = intrinsic_cost + create_static_cost
+        # Exactly the pre-access cost — address accessed, then the
+        # NEW_ACCOUNT charge OOGs after access
+        gas_limit = intrinsic_cost + pre_access_cost
     else:
         # Full success: static cost + child frame (63/64 rule) +
         # SSTORE + gas sink.