feat(spec-specs,test-tests): update the EIP-2780 implementation (#3126)

Author: spencer-tb

packages/testing/src/execution_testing/forks/base_fork.py

@@ -12,6 +12,7 @@
     Mapping,
     Optional,
     Protocol,
+    Sequence,
     Set,
     Sized,
     Type,
@@ -152,17 +153,28 @@ def __call__(
                        Forks that itemize the value-transfer charge in
                        intrinsic gas use this flag; ignored by older forks.
           recipient_type: Category of the transaction recipient. Forks
-                          that vary intrinsic gas by recipient kind
-                          (e.g. no access cost for precompiles, no value
-                          charge for self-transfers) use this; ignored
-                          by older forks.
+                          that vary intrinsic gas by recipient kind use this;
+                          ignored by older forks.
 
         Returns: Gas cost of a transaction
 
         """
         pass
 
 
+class AuthorizationGasInfo(Protocol):
+    """
+    Structural view of an EIP-7702 authorization's effect on the
+    pre-state, used to compute its top-frame gas. The test
+    ``AuthorizationTuple`` satisfies it via its ``creates_account``,
+    ``writes_delegation``, and ``first_write`` fields.
+    """
+
+    creates_account: bool
+    writes_delegation: bool
+    first_write: bool
+
+
 class TopFrameGasCalculator(Protocol):
     """
     A protocol to calculate the additional regular gas charged at the
@@ -185,6 +197,8 @@ def __call__(
         contract_creation: bool = False,
         sends_value: bool = False,
         recipient_type: RecipientType = RecipientType.CONTRACT,
+        delegation_warm: bool = False,
+        authorizations: Sequence[AuthorizationGasInfo] = (),
     ) -> int:
         """
         Return the regular gas consumed by top-frame preparation for a
@@ -199,6 +213,11 @@ def __call__(
                        value.
           recipient_type: Category of the transaction recipient.
                           Drives the conditional charges.
+          delegation_warm: Whether a delegated recipient's delegation
+                           target is already warm, charging warm rather
+                           than cold access.
+          authorizations: The transaction's EIP-7702 authorizations;
+                          each contributes its top-frame regular gas.
 
         Returns: Regular gas added by top-frame preparation.
 
@@ -787,8 +806,11 @@ def fn(
             contract_creation: bool = False,
             sends_value: bool = False,
             recipient_type: RecipientType = RecipientType.CONTRACT,
+            delegation_warm: bool = False,
+            authorizations: Sequence[AuthorizationGasInfo] = (),
         ) -> int:
             del contract_creation, sends_value, recipient_type
+            del delegation_warm, authorizations
             return 0
 
         return fn
@@ -800,6 +822,7 @@ def transaction_top_frame_state_gas(
         contract_creation: bool = False,
         sends_value: bool = False,
         recipient_type: RecipientType = RecipientType.CONTRACT,
+        authorizations: Sequence[AuthorizationGasInfo] = (),
     ) -> int:
         """
         Return the state gas charged at the top-level transaction
@@ -811,7 +834,7 @@ def transaction_top_frame_state_gas(
         Defaults to 0 for forks that do not perform such
         post-intrinsic preparation.
         """
-        del contract_creation, sends_value, recipient_type
+        del contract_creation, sends_value, recipient_type, authorizations
         return 0
 
     @classmethod

packages/testing/src/execution_testing/forks/forks/eips/amsterdam/eip_2780.py

@@ -9,14 +9,16 @@
 """
 
 from dataclasses import replace
-from typing import List, Sized
+from typing import List, Sequence, Sized
 
 from execution_testing.base_types import AccessList
 from execution_testing.base_types.conversions import BytesConvertible
 
 from .....recipient_type import RecipientType
 from ....base_fork import (
+    AuthorizationGasInfo,
     BaseFork,
+    RefundTypes,
     TopFrameGasCalculator,
     TransactionDataFloorCostCalculator,
     TransactionIntrinsicCostCalculator,
@@ -112,17 +114,39 @@ def fn(
             sends_value: bool = False,
             recipient_type: RecipientType = RecipientType.CONTRACT,
         ) -> int:
+            # Only the state-independent base cost per authorization is
+            # charged in the intrinsic; the state-dependent
+            # account-creation and delegation-write costs are charged at
+            # the top frame. Exclude the base-fork authorization cost
+            # and re-add the base cost here.
+            authorization_count = 0
+            if authorization_list_or_count is not None:
+                authorization_count = (
+                    len(authorization_list_or_count)
+                    if isinstance(authorization_list_or_count, Sized)
+                    else authorization_list_or_count
+                )
+
             intrinsic_cost: int = super_fn(
                 calldata=calldata,
                 contract_creation=contract_creation,
                 access_list=access_list,
-                authorization_list_or_count=authorization_list_or_count,
+                authorization_list_or_count=None,
                 return_cost_deducted_prior_execution=True,
             )
+            intrinsic_cost += (
+                authorization_count * gas_costs.REGULAR_PER_AUTH_BASE_COST
+            )
 
             is_self_transfer = recipient_type == RecipientType.SELF
 
             if contract_creation:
+                # EIP-2780: the created account's NEW_ACCOUNT state gas
+                # is charged at the top frame, not deducted in the
+                # intrinsic. The base-fork intrinsic bundles it in, so
+                # remove it here, mirroring value transfer to an empty
+                # account whose NEW_ACCOUNT is likewise top-frame.
+                intrinsic_cost -= gas_costs.NEW_ACCOUNT
                 if sends_value:
                     intrinsic_cost += gas_costs.TRANSFER_LOG_COST
             elif not is_self_transfer:
@@ -151,6 +175,28 @@ def fn(
 
         return fn
 
+    @classmethod
+    def transaction_intrinsic_state_gas(
+        cls,
+        *,
+        contract_creation: bool = False,
+        authorization_count: int = 0,
+    ) -> int:
+        """
+        Return the intrinsic state gas for a transaction.
+
+        Under EIP-2780 neither authorizations nor contract creation
+        contribute intrinsic state gas: the authority account-creation
+        and delegation-write costs and the created account's
+        ``NEW_ACCOUNT`` are all state-dependent and charged at the top
+        frame instead.
+        """
+        del contract_creation, authorization_count
+        return super(EIP2780, cls).transaction_intrinsic_state_gas(
+            contract_creation=False,
+            authorization_count=0,
+        )
+
     @classmethod
     def transaction_top_frame_gas_calculator(
         cls,
@@ -160,10 +206,14 @@ def transaction_top_frame_gas_calculator(
         transaction frame, after intrinsic gas is deducted but before
         the EVM dispatches.
 
-        Charges ``COLD_ACCOUNT_ACCESS`` when the recipient is an
-        existing delegated account. The empty-recipient
-        ``NEW_ACCOUNT`` charge is state gas, returned separately by
-        ``transaction_top_frame_state_gas``.
+        Charges the delegation-target access when the recipient is an
+        existing delegated account: ``WARM_ACCESS`` when the target is
+        already warm, otherwise ``COLD_ACCOUNT_ACCESS``. Each
+        authorization whose application is the transaction's first
+        write to its authority's leaf (``first_write``) adds
+        ``ACCOUNT_WRITE``. The state-gas portions (empty-recipient and
+        per-authorization ``NEW_ACCOUNT``, plus ``AUTH_BASE``) are
+        returned separately by ``transaction_top_frame_state_gas``.
         """
         gas_costs = cls.gas_costs()
 
@@ -172,14 +222,24 @@ def fn(
             contract_creation: bool = False,
             sends_value: bool = False,
             recipient_type: RecipientType = RecipientType.CONTRACT,
+            delegation_warm: bool = False,
+            authorizations: Sequence[AuthorizationGasInfo] = (),
         ) -> int:
             del sends_value
             if contract_creation:
                 return 0
 
+            regular = 0
             if recipient_type == RecipientType.DELEGATION_7702:
-                return gas_costs.COLD_ACCOUNT_ACCESS
-            return 0
+                regular += (
+                    gas_costs.WARM_ACCESS
+                    if delegation_warm
+                    else gas_costs.COLD_ACCOUNT_ACCESS
+                )
+            for auth in authorizations:
+                if auth.first_write:
+                    regular += gas_costs.ACCOUNT_WRITE
+            return regular
 
         return fn
 
@@ -190,15 +250,43 @@ def transaction_top_frame_state_gas(
         contract_creation: bool = False,
         sends_value: bool = False,
         recipient_type: RecipientType = RecipientType.CONTRACT,
+        authorizations: Sequence[AuthorizationGasInfo] = (),
     ) -> int:
         """
         Return the state gas charged at the top-level transaction
-        frame. Charges ``NEW_ACCOUNT`` when value is transferred to an
-        empty recipient; zero otherwise.
+        frame. A contract creation charges the created account's
+        ``NEW_ACCOUNT`` here (state-dependent, no longer intrinsic),
+        assuming a fresh target. Otherwise, charges ``NEW_ACCOUNT`` when
+        value is transferred to an empty recipient, and each
+        authorization adds ``NEW_ACCOUNT`` when its authority's account
+        leaf must be created and ``AUTH_BASE`` when it writes a net-new
+        delegation indicator.
         """
         gas_costs = cls.gas_costs()
         if contract_creation:
-            return 0
-        if sends_value and recipient_type == RecipientType.EMPTY_ACCOUNT:
             return gas_costs.NEW_ACCOUNT
-        return 0
+        state = 0
+        if sends_value and recipient_type == RecipientType.EMPTY_ACCOUNT:
+            state += gas_costs.NEW_ACCOUNT
+        for auth in authorizations:
+            if auth.creates_account:
+                state += gas_costs.NEW_ACCOUNT
+            if auth.writes_delegation:
+                state += gas_costs.AUTH_BASE
+        return state
+
+    @classmethod
+    def refund_types(cls) -> List[RefundTypes]:
+        """
+        Drop the existing-authority authorization refund.
+
+        EIP-2780 charges each authorization's state-dependent cost at the
+        top frame, keyed on the authority's pre-transaction state, with no
+        refund. The Prague-era ``AUTHORIZATION_EXISTING_AUTHORITY`` refund
+        therefore no longer applies.
+        """
+        return [
+            refund
+            for refund in super(EIP2780, cls).refund_types()
+            if refund != RefundTypes.AUTHORIZATION_EXISTING_AUTHORITY
+        ]

packages/testing/src/execution_testing/forks/forks/eips/amsterdam/eip_8037.py

@@ -92,6 +92,7 @@ def gas_costs(cls) -> GasCosts:
                 parent.STORAGE_SET + STATE_BYTES_PER_STORAGE_SET * cpsb
             ),
             NEW_ACCOUNT=new_acct,
+            AUTH_BASE=STATE_BYTES_PER_AUTH_BASE * cpsb,
             TX_CREATE=parent.TX_CREATE + new_acct,
             AUTH_PER_EMPTY_ACCOUNT=(
                 parent.AUTH_PER_EMPTY_ACCOUNT

packages/testing/src/execution_testing/forks/forks/eips/amsterdam/eip_8038.py

@@ -74,6 +74,7 @@ def gas_costs(cls) -> GasCosts:
             OPCODE_CREATE_BASE=create_access,
             TX_CREATE=create_access,
             AUTH_PER_EMPTY_ACCOUNT=account_write + regular_per_auth_base_cost,
+            REGULAR_PER_AUTH_BASE_COST=regular_per_auth_base_cost,
         )
 
     @classmethod

packages/testing/src/execution_testing/forks/gas_costs.py

@@ -47,6 +47,12 @@ class GasCosts:
 
     # Authorization
     AUTH_PER_EMPTY_ACCOUNT: int
+    # State gas for writing a net-new EIP-7702 delegation indicator;
+    # 0 before the state-creation repricing introduces it.
+    AUTH_BASE: int = 0
+    # State-independent regular gas charged per EIP-7702 authorization
+    # tuple; 0 before the state-access repricing introduces it.
+    REGULAR_PER_AUTH_BASE_COST: int = 0
 
     # Utility
     MEMORY_PER_WORD: int

packages/testing/src/execution_testing/test_types/transaction_types.py

@@ -120,6 +120,13 @@ class AuthorizationTuple(AuthorizationTupleGeneric[HexNumber]):
 
     signer: EOA | None = None
     secret_key: Hash | None = None
+    creates_account: bool = Field(False, exclude=True)
+    writes_delegation: bool = Field(True, exclude=True)
+    # Whether applying this authorization is the transaction's first
+    # write to the authority's account leaf. False for a self-sponsored
+    # authority (the sender is written at inclusion), for repeated
+    # authorizations on one authority, and for invalid authorizations.
+    first_write: bool = Field(True, exclude=True)
 
     def model_post_init(self, __context: Any) -> None:
         """

src/ethereum/forks/amsterdam/fork.py

@@ -15,7 +15,7 @@
 from typing import Final, List, Optional, Tuple, final
 
 from ethereum_rlp import rlp
-from ethereum_types.bytes import Bytes, Bytes0
+from ethereum_types.bytes import Bytes
 from ethereum_types.frozen import slotted_freezable
 from ethereum_types.numeric import U64, U256, Uint, ulen
 
@@ -1058,19 +1058,11 @@ 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. 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.
+    # budget) and state_gas_reservoir.
     execution_gas = tx.gas - intrinsic_gas
     regular_gas_budget = TX_MAX_GAS_LIMIT - intrinsic.regular
     gas = min(regular_gas_budget, execution_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
+    state_gas_reservoir = Uint(execution_gas - gas)
 
     increment_nonce(tx_state, sender)
 
@@ -1143,14 +1135,7 @@ def process_transaction(
     # transfer miner fees
     create_ether(tx_state, block_env.coinbase, U256(transaction_fee))
 
-    tx_state_gas = (
-        int(tx_env.intrinsic_state_gas)
-        - int(create_state_gas)
-        + tx_output.state_gas_used
-        - int(tx_output.state_refund)
-    )
-    # Defensive guard for Uint conversion: State refunds never exceed
-    # the state charges so the value is non-negative.
+    tx_state_gas = int(tx_env.intrinsic_state_gas) + tx_output.state_gas_used
     tx_regular_gas = tx_gas_used_before_refund - Uint(max(0, tx_state_gas))
     block_output.block_gas_used += tx_regular_gas
     block_output.block_state_gas_used += Uint(max(0, tx_state_gas))