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

* feat(spec-specs): EIP-2780 charge state-dependent tx costs at the top frame

Move every state-dependent charge out of the transaction intrinsic --
which over-charged and then refunded -- and into the top frame, charged
lazily against the transaction's pre-state. The intrinsic keeps only
state-independent costs and remains the sole validity input: contract
creation no longer adds NEW_ACCOUNT, and each authorization adds only
REGULAR_PER_AUTH_BASE_COST.

At depth 0, process_message now:

- Applies the EIP-7702 authorizations via set_delegation, charging per
  authorization: NEW_ACCOUNT when the authority's leaf does not exist;
  ACCOUNT_WRITE on the transaction's first write to the authority (the
  written set is seeded with the sender, so a self-sponsored authority
  pays nothing and repeated authorizations pay once); and AUTH_BASE
  once per authority for a net-new delegation indicator, never
  credited back.
- Folds the authorization state gas into the frame baseline
  (Evm.auth_state_gas_used, rebased state_gas_reservoir) so a dispatch
  revert or halt cannot refill it -- the delegations, nonce bumps, and
  authority leaves persist per EIP-7702's dispatch-failure rule. A
  preparation-phase out-of-gas instead rolls the delegations back,
  undoes the fold, and halts consuming all gas without dispatching.
- Charges the remaining dispatch costs in prepare_dispatch, which must
  not mutate transaction state: the recipient's or creation target's
  NEW_ACCOUNT keyed on pre-transaction aliveness (still refillable,
  since that state rolls back with the frame), and delegation
  resolution at WARM_ACCESS or COLD_ACCOUNT_ACCESS by target warmth.

set_delegation is thereby the last transaction-state mutation before
dispatch, so the execution snapshot brackets exactly the state the
folded gas paid for.

Remove the superseded over-charge/refund plumbing: the intrinsic
NEW_ACCOUNT refund paths in fork.py and the vestigial
MessageCallOutput state_refund / created_target_alive fields.
validate_authorization returns just the authority address.

* feat(amsterdam): model EIP-2780 top-frame gas in the test framework

Teach execution_testing the EIP-2780 split between intrinsic and
top-frame charges:

- Intrinsic calculators charge only the state-independent costs:
  REGULAR_PER_AUTH_BASE_COST per authorization and no NEW_ACCOUNT for
  contract creation. AUTH_BASE (EIP-8037) and
  REGULAR_PER_AUTH_BASE_COST (EIP-8038) become named gas costs.
- The top-frame calculators (transaction_top_frame_gas_calculator,
  transaction_top_frame_state_gas) price the per-authorization
  NEW_ACCOUNT / ACCOUNT_WRITE / AUTH_BASE from the authorizations list
  threaded into them, the recipient's or creation target's
  NEW_ACCOUNT, and delegation-target resolution as warm or cold via
  delegation_warm.
- AuthorizationTuple carries creates_account / writes_delegation /
  first_write annotations (excluded from serialization) so each tuple
  declares its pre-state effect; ACCOUNT_WRITE keys on first_write --
  the transaction's first write to the authority -- rather than leaf
  creation. The AuthorizationGasInfo structural Protocol lets forks
  read the annotations without importing test_types.
- EIP2780.refund_types() drops AUTHORIZATION_EXISTING_AUTHORITY:
  Amsterdam charges authorizations by pre-state instead of
  over-charging and refunding, while Prague's refund coverage keeps
  the shared enum member.

* test(amsterdam): cover the EIP-2780 top-frame charges

Pin the EIP-2780 top-frame model end to end in the EIP-2780 suite:

- test_authorization_charges.py (new): per-authorization billing keyed
  on the authority's pre-transaction state -- NEW_ACCOUNT for new
  leaves; ACCOUNT_WRITE on the transaction's first write (existing
  authorities pay it, the sender and repeated authorizations do not,
  tx.to as authority does); AUTH_BASE only for a net-new delegation,
  at most once per authority, never credited back (pre-tx-delegated
  re-set and clear-then-set, multiple sets, set/clear cycles).
- test_authorization_oog.py (new): charge-by-charge out-of-gas points
  across the preparation phase -- a prep out-of-gas rolls back every
  applied delegation and halts without dispatching, while applied
  authorization state gas survives a dispatch revert or halt
  (balance-, header-, and reservoir-level pins), with guards that the
  recipient's NEW_ACCOUNT and in-frame SSTORE state gas still refill
  when their state rolls back.
- test_calldata_floor.py / test_intrinsic_gas_boundary.py: a
  data-heavy transfer whose EIP-7623/7976 floor (built on the lowered
  TX_BASE) dominates the decomposed intrinsic, one-below-floor
  rejection, and the contract-creation boundary on the regular-only
  intrinsic. The floor-dominating calldata size comes from the shared
  find_floor_cost_threshold search rather than a hardcoded value.
- Migrations: the value-moving tests adopt the top-frame NEW_ACCOUNT
  for the creation target (charged on success, refilled when the init
  code reverts), the delegation variants annotate self-sponsored
  tuples with first_write, the warmth invariants adopt warm/cold
  delegation-target access, and helpers.py's authorization actions
  declare the creates_account / writes_delegation / first_write
  annotations the framework calculators consume.

* test(amsterdam): migrate remaining suites to the EIP-2780 top-frame model

EIP-2780 moved the contract-creation NEW_ACCOUNT and every
state-dependent authorization cost out of the intrinsic and into the
top frame, with no over-charge refunds. Migrate the suites that pinned
the old model:

- eip8037 test_state_gas_set_code.py: authorization tests bill by the
  declared pre-state annotations; receipts are plain sums with the
  first-write ACCOUNT_WRITE included, headers are
  max(block_regular, block_state), and authorization state gas
  persists on the block's state dimension through every
  dispatch-failure mode (no refill on revert, halt, or out-of-gas).
- eip8037 create cluster (test_state_gas_create.py,
  test_state_gas_reservoir.py, test_state_gas_pricing.py): gas limits
  cover the top-frame NEW_ACCOUNT; reject-below-intrinsic keys off the
  regular-only intrinsic; NEW_ACCOUNT refills on init-code failure and
  is never charged on collision; AUTH_BASE is measured via
  transaction_top_frame_state_gas; an existing-authority authorization
  credits nothing to the reservoir.
- eip8038 (test_create_gas.py, test_selfdestruct_gas.py,
  test_set_code_auth_gas.py, test_set_code_auth_refunds.py,
  test_fork_transition.py): the same top-frame NEW_ACCOUNT treatment
  for creates, the reduced refund-free per-authorization charges, and
  the authorization intrinsic drop across the BPO2->Amsterdam
  transition.
- eip7778 / eip7976: drop the AUTHORIZATION_EXISTING_AUTHORITY refund
  path (Amsterdam no longer has that refund type) and add the
  top-frame regular charge to expected receipts.
- eip7954 test_max_code_size.py: add the top-frame state gas back into
  the exact-fit deposit-gas limit so it still lands precisely on the
  code-deposit boundary.

* test(amsterdam): cover BAL inclusion at the top-frame delegation charge

The delegation target of a delegated tx.to must enter the block
access list only when the EIP-2780 top-frame access charge succeeds.
Pin the charge-before-access order of the top-frame dispatch: on
out-of-gas the target stays out of the BAL, on success it appears
with an empty change set.

* feat(amsterdam): EIP-2780 exempt value-bearing recipient authority from ACCOUNT_WRITE

When a transaction moves value to its recipient and that recipient is
also an authority, seed the recipient into `set_delegation`'s
written-set: the value transfer already pays to write the recipient, so
applying the authorization is not the transaction's first write to it
and no `ACCOUNT_WRITE` is charged.

Adopt the framework top-frame calculators in the EIP-2780 authorization
charge and value-moving tests (driving the charges through the
`first_write` / `writes_delegation` / `creates_account` annotations
instead of hand-summed gas constants), and refresh the now
value-dependent `ACCOUNT_WRITE` docstrings.

* refactor(specs,tests): Remove intrinsic state gas concept

* refactor(specs): Remove intrinsic state gas concept

* refactor(test-forks): Remove intrinsic state gas

* fix(tests): Fix intrinsic state gas usages

* fix(tests): correct inert authorization flags in delegation-pointer tests

The two migrated delegation-pointer tests re-target an authority that
already has a delegation and whose account nonce (1, from the delegation
setup) no longer matches the authorization's nonce=0, so the
authorization is invalid and charges no top-frame state gas. Setting
writes_delegation/first_write to True added a phantom AUTH_BASE to
state_gas_reservoir that was silently refunded, contradicting the
AuthorizationTuple.first_write contract (False for invalid
authorizations) and the spec's AUTH_BASE gate (not delegated_before_tx).

Set both flags to False so the reserved state gas matches what the top
frame actually charges, and reuse the single authorization object in
test_delegation_pointer_new_account_state_gas instead of building a
second inline tuple.

* fix(test-forks): drop deleted transaction_intrinsic_state_gas call

The execute plugin's _compute_deploy_gas_limit still called the removed
transaction_intrinsic_state_gas, which failed mypy (and CI static).
On every concrete fork that value was zero (BaseFork default, or forced
to zero once EIP-2780 moves the created account's NEW_ACCOUNT to the top
frame), and the intrinsic calculator already returns the regular-only
cost, so the back-out was a no-op. Remove it, keeping the deploy gas
limit unchanged.

---------

Co-authored-by: Guruprasad Kamath <guru241987@gmail.com>

* test(amsterdam): reconcile floor-pinned expectations with header gas accounting

After the top-frame decomposition, the calldata floor exceeds the
create intrinsic for tiny initcode. The floor pins only the amount
billed (receipt cumulative gas); the block header counts pre-refund,
pre-floor regular consumption. Build expectations from the pre-floor
intrinsic, apply the floor once to the receipt only, and verify the
header and receipt separately where they diverge.

* fix(spec-specs, tests): exclude unloaded recipient from the BAL

* fix(spec-specs, tests): exclude unloaded recipient from the BAL

(cherry picked from commit 89d15f3)

* refactor(spec-specs): represent unresolved top-frame code as None

* test(amsterdam): pin reservoir settlement at each top-frame failure point

A transaction whose gas limit exceeds the EIP-7825 cap forms a
state-gas reservoir, and how much of it returns depends on where the
transaction fails. Two tests drive one many-authorization transaction
shape to every failure point:

- a preparation out-of-gas (inside set_delegation or at the dispatch
  charge) rolls everything back and returns the reservoir whole: the
  sender pays exactly TX_MAX_GAS_LIMIT, however much extra was sent;
- an execution failure keeps the applied delegations and their state
  gas consumed, so the reservoir is preserved only down to the
  post-authorization baseline -- an exceptional halt burns the full
  gas limit when the auth state gas exceeds the reservoir, while a
  revert pays exact usage.

The value-bearing variant targets the bn254 pairing precompile (the
one empty recipient that executes) so both state-charge classes ride
one transaction: the halt scenario sizes the reservoir above the auth
state gas to make the recipient NEW_ACCOUNT refill observable in the
settlement, pinning gas_used == cap + auth state gas exactly.

Also corrects the module docstring, which claimed a preparation-phase
OOG consumes the full gas limit -- only true with a zero reservoir.

* post review updates

* fix(tests): Ported static failing tests

---------

Co-authored-by: Toni Wahrstätter <info@toniwahrstaetter.com>
Co-authored-by: Mario Vega <marioevz@gmail.com>
Co-authored-by: spencer <spencer.tb@ethereum.org>

Author: 4 people

packages/testing/src/execution_testing/cli/pytest_commands/plugins/execute/pre_alloc.py

@@ -250,13 +250,10 @@ def _compute_deploy_gas_limit(
     sstore_state_gas = sstore.state_cost(fork)
     sstore_regular_gas = sstore.gas_cost(fork) - sstore_state_gas
 
-    # Back out the state gas folded into TX_CREATE.
-    intrinsic_state_gas = fork.transaction_intrinsic_state_gas(
-        contract_creation=True
-    )
-    intrinsic_regular_gas = (
-        intrinsic_gas_calculator(calldata=initcode, contract_creation=True)
-        - intrinsic_state_gas
+    # The intrinsic cost is now regular-only: the created account's
+    # NEW_ACCOUNT state gas is charged at the top frame, not folded in.
+    intrinsic_regular_gas = intrinsic_gas_calculator(
+        calldata=initcode, contract_creation=True
     )
 
     # Regular portion, bound by the gas cap.
@@ -291,8 +288,7 @@ def _compute_deploy_gas_limit(
         regular_gas = buffered_regular_gas
 
     # State portion, from the block reservoir.
-    state_gas = intrinsic_state_gas
-    state_gas += fork.code_deposit_state_gas(code_size=deploy_code_size)
+    state_gas = fork.code_deposit_state_gas(code_size=deploy_code_size)
     state_gas += storage_slots * sstore_state_gas
 
     deploy_gas_limit = regular_gas + state_gas

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.
 
@@ -758,17 +777,6 @@ def transaction_intrinsic_cost_calculator(
         """
         pass
 
-    @classmethod
-    def transaction_intrinsic_state_gas(
-        cls,
-        *,
-        contract_creation: bool = False,
-        authorization_count: int = 0,
-    ) -> int:
-        """Return intrinsic state gas (zero pre-Amsterdam)."""
-        del contract_creation, authorization_count
-        return 0
-
     @classmethod
     def transaction_top_frame_gas_calculator(
         cls,
@@ -787,8 +795,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 +811,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 +823,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:
@@ -160,10 +184,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 +200,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 +228,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
@@ -231,30 +232,6 @@ def fn(opcode: OpcodeBase) -> int:
 
         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. Creation
-        adds `STATE_BYTES_PER_NEW_ACCOUNT * cpsb`, and each
-        authorization adds
-        `(STATE_BYTES_PER_NEW_ACCOUNT + STATE_BYTES_PER_AUTH_BASE) * cpsb`.
-        """
-        cpsb = cls.cost_per_state_byte()
-        state_gas = 0
-        if contract_creation:
-            state_gas += STATE_BYTES_PER_NEW_ACCOUNT * cpsb
-        state_gas += (
-            (STATE_BYTES_PER_NEW_ACCOUNT + STATE_BYTES_PER_AUTH_BASE)
-            * cpsb
-            * authorization_count
-        )
-        return state_gas
-
     @classmethod
     def _calculate_sstore_state_gas(
         cls, opcode: OpcodeBase, gas_costs: GasCosts

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:
         """