fix(spec,test): 7702 refund block-level gas accounting for EIP-8037 (#2816)

* feat(spec): 7702 auth state gas fix

* fix(test): fix existing auth tests to expect block-level gas accounting for 7702 refunds

* chore(test): un-skip 7702 tests that now no longer fail

* fix: change 7702-related 8037 tests to reflect new behavior

---------

Co-authored-by: spencer-tb <spencer.tb@ethereum.org>

Author: fselmo

src/ethereum/forks/amsterdam/fork.py

@@ -1166,7 +1166,11 @@ def process_transaction(
         destroy_account(tx_state, block_env.coinbase)
 
     tx_regular_gas = tx_env.intrinsic_regular_gas + tx_output.regular_gas_used
-    tx_state_gas = tx_env.intrinsic_state_gas + tx_output.state_gas_used
+    tx_state_gas = (
+        tx_env.intrinsic_state_gas
+        + tx_output.state_gas_used
+        - tx_output.state_refund
+    )
     block_output.block_gas_used += max(
         tx_regular_gas, intrinsic.calldata_floor
     )

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

@@ -158,20 +158,29 @@ def calculate_delegation_cost(
     return True, delegated_address, delegation_gas_cost
 
 
-def set_delegation(message: Message) -> None:
+def set_delegation(message: Message) -> Uint:
     """
     Set the delegation code for the authorities in the message.
 
     For existing accounts, refunds the account-creation component of
-    state gas to the reservoir (no mutation of intrinsic_state_gas).
+    state gas to the reservoir (no mutation of intrinsic_state_gas) and
+    accumulates the same amount as the auth state refund returned to the
+    caller, so block accounting can subtract it from `tx_state_gas`.
 
     Parameters
     ----------
     message :
         Transaction specific items.
 
+    Returns
+    -------
+    auth_state_refund : `Uint`
+        Total state gas refunded across all authorizations whose
+        authority already existed in state.
+
     """
     tx_state = message.tx_env.state
+    auth_state_refund = Uint(0)
     for auth in message.tx_env.authorizations:
         if auth.chain_id not in (message.block_env.chain_id, U256(0)):
             continue
@@ -202,6 +211,7 @@ def set_delegation(message: Message) -> None:
         if account_exists(tx_state, authority):
             refund = STATE_BYTES_PER_NEW_ACCOUNT * COST_PER_STATE_BYTE
             message.state_gas_reservoir += refund
+            auth_state_refund += refund
 
         if auth.address == NULL_ADDRESS:
             code_to_set = b""
@@ -218,3 +228,5 @@ def set_delegation(message: Message) -> None:
         tx_state,
         get_account(tx_state, message.code_address).code_hash,
     )
+
+    return auth_state_refund

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

@@ -87,6 +87,10 @@ class MessageCallOutput:
           6. `return_data`: The output of the execution.
           7. `regular_gas_used`: Regular gas used during execution.
           8. `state_gas_used`: State gas used during execution.
+          9. `state_refund`: State gas refunded by `set_delegation` for
+             authorities that already existed in state. Subtracted from
+             `tx_state_gas` in block accounting so `block.gas_used`
+             matches the receipt `cumulative_gas_used`.
     """
 
     gas_left: Uint
@@ -98,6 +102,7 @@ class MessageCallOutput:
     return_data: Bytes
     regular_gas_used: Uint
     state_gas_used: Uint
+    state_refund: Uint
 
 
 def process_message_call(message: Message) -> MessageCallOutput:
@@ -118,6 +123,7 @@ def process_message_call(message: Message) -> MessageCallOutput:
     """
     tx_state = message.tx_env.state
     refund_counter = U256(0)
+    state_refund = Uint(0)
     if message.target == Bytes0(b""):
         is_collision = account_has_code_or_nonce(
             tx_state, message.current_target
@@ -133,12 +139,13 @@ def process_message_call(message: Message) -> MessageCallOutput:
                 return_data=Bytes(b""),
                 regular_gas_used=message.gas,
                 state_gas_used=Uint(0),
+                state_refund=Uint(0),
             )
         else:
             evm = process_create_message(message)
     else:
         if message.tx_env.authorizations != ():
-            set_delegation(message)
+            state_refund += set_delegation(message)
 
         delegated_address = get_delegated_code_address(message.code)
         if delegated_address is not None:
@@ -175,6 +182,7 @@ def process_message_call(message: Message) -> MessageCallOutput:
         return_data=evm.output,
         regular_gas_used=evm.regular_gas_used,
         state_gas_used=evm.state_gas_used,
+        state_refund=state_refund,
     )
 
 

tests/amsterdam/eip7778_block_gas_accounting_without_refunds/test_gas_accounting.py

@@ -192,13 +192,14 @@ def build_refund_tx(
     if not exceed_block_gas_limit:
         post[refund_tx_sender] = Account(balance=expected_balance)
 
-    # block_state_gas_used reflects the full intrinsic_state: the AUTH
-    # refund adds back to the reservoir (state_gas_left) and does not
-    # subtract from state_gas_used.
+    # block_state_gas_used reflects intrinsic_state minus the
+    # existing-authority auth refund (state_refund), since
+    # `process_transaction` deducts it from `tx_state_gas` before
+    # accumulating into `block_state_gas_used`.
     return (
         receipt_gas_used,
         gas_used_pre_refund,
-        auth_state_gas,
+        remaining_state_gas,
         call_data_floor_cost,
         refund_tx,
     )
@@ -309,12 +310,16 @@ def test_multi_transaction_gas_accounting(
 
     This tests that clients correctly use pre-refund gas for block accounting.
     """
-    # Skipped on snøbal -- see test_state_gas_snobal_quirks.py.
+    # TODO[EIP-8037]: this test's exceed_block_gas_limit branch builds
+    # `environment_gas_limit = total - 1` from a single combined
+    # `total_block_gas_used`, but post-fix the auth refund splits the
+    # regular vs state dimensions further. Reworking the per-dimension
+    # budget math is out of scope for the auth-refund spec fix; until
+    # then, skip the AUTHORIZATION_EXISTING_AUTHORITY case here.
     if refund_type == RefundTypes.AUTHORIZATION_EXISTING_AUTHORITY:
         pytest.skip(
-            "snøbal spec quirk: EIP-7702 auth refund not deducted from "
-            "block_state_gas_used; behavior pinned by "
-            "test_state_gas_snobal_quirks.py"
+            "AUTHORIZATION_EXISTING_AUTHORITY not yet adapted to the "
+            "two-dimensional block budget post EIP-8037 auth-refund fix"
         )
 
     intrinsic_cost_calc = fork.transaction_intrinsic_cost_calculator()
@@ -454,15 +459,16 @@ def test_varying_calldata_costs(
                 "since refund is zero when execution reverts"
             )
 
-    # Skipped on snøbal -- see test_state_gas_snobal_quirks.py.
     if refund_type == RefundTypes.AUTHORIZATION_EXISTING_AUTHORITY:
         if calldata_test_type == (
             CallDataTestType.DATA_FLOOR_BETWEEN_TX_GAS_BEFORE_AND_AFTER
         ):
             pytest.skip(
-                "snøbal spec quirk: EIP-7702 auth refund routes to "
-                "state reservoir, collapsing pre/post-refund range "
-                "(see test_state_gas_snobal_quirks.py)"
+                "EIP-7702 auth refund routes through state_gas_reservoir "
+                "and state_refund (deducted from tx_state_gas); it does "
+                "not feed refund_counter, so receipt gas_used_pre_refund "
+                "== gas_used_post_refund and no calldata floor can land "
+                "strictly between them"
             )
 
     match refund_type: