Merge eips/amsterdam/eip-7981 into devnets/bal/4

Author: spencer-tb

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

@@ -61,7 +61,12 @@ class TransactionDataFloorCostCalculator(Protocol):
     Calculate the transaction floor cost due to its calldata for a given fork.
     """
 
-    def __call__(self, *, data: BytesConvertible) -> int:
+    def __call__(
+        self,
+        *,
+        data: BytesConvertible,
+        access_list: List[AccessList] | None = None,
+    ) -> int:
         """Return transaction gas cost of calldata given its contents."""
         pass
 

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

@@ -0,0 +1,111 @@
+"""
+EIP-7981: Increase Access List Cost.
+
+Price access lists for data to reduce maximum block size.
+
+https://eips.ethereum.org/EIPS/eip-7981
+"""
+
+from typing import List, Sized
+
+from execution_testing.base_types import AccessList
+from execution_testing.base_types.conversions import BytesConvertible
+
+from ....base_fork import (
+    BaseFork,
+    TransactionDataFloorCostCalculator,
+    TransactionIntrinsicCostCalculator,
+)
+
+
+class EIP7981(BaseFork):
+    """EIP-7981 class."""
+
+    @classmethod
+    def _access_list_floor_tokens(
+        cls, access_list: List[AccessList] | None
+    ) -> int:
+        """
+        Return ``access_list_bytes * 4`` floor tokens for the access list.
+
+        Every byte of each address (20 bytes) and storage key (32 bytes)
+        contributes four floor tokens, so zero and non-zero bytes are
+        charged equally per EIP-7981.
+        """
+        if not access_list:
+            return 0
+        total_bytes = 0
+        for access in access_list:
+            total_bytes += len(access.address)
+            for slot in access.storage_keys:
+                total_bytes += len(slot)
+        return total_bytes * 4
+
+    @classmethod
+    def transaction_data_floor_cost_calculator(
+        cls,
+    ) -> TransactionDataFloorCostCalculator:
+        """
+        Add access list floor tokens to the inherited calldata floor cost.
+        """
+        super_fn = super(EIP7981, cls).transaction_data_floor_cost_calculator()
+        gas_costs = cls.gas_costs()
+
+        def fn(
+            *,
+            data: BytesConvertible,
+            access_list: List[AccessList] | None = None,
+        ) -> int:
+            return (
+                super_fn(data=data)
+                + cls._access_list_floor_tokens(access_list)
+                * gas_costs.TX_DATA_TOKEN_FLOOR
+            )
+
+        return fn
+
+    @classmethod
+    def transaction_intrinsic_cost_calculator(
+        cls,
+    ) -> TransactionIntrinsicCostCalculator:
+        """
+        Charge access list data at the floor token cost on top of the
+        inherited intrinsic cost and enforce the combined data floor.
+        """
+        super_fn = super(EIP7981, cls).transaction_intrinsic_cost_calculator()
+        gas_costs = cls.gas_costs()
+        data_floor_cost_calculator = (
+            cls.transaction_data_floor_cost_calculator()
+        )
+
+        def fn(
+            *,
+            calldata: BytesConvertible = b"",
+            contract_creation: bool = False,
+            access_list: List[AccessList] | None = None,
+            authorization_list_or_count: Sized | int | None = None,
+            return_cost_deducted_prior_execution: bool = False,
+        ) -> int:
+            intrinsic_cost: int = super_fn(
+                calldata=calldata,
+                contract_creation=contract_creation,
+                access_list=access_list,
+                authorization_list_or_count=authorization_list_or_count,
+                return_cost_deducted_prior_execution=True,
+            )
+            intrinsic_cost += (
+                cls._access_list_floor_tokens(access_list)
+                * gas_costs.TX_DATA_TOKEN_FLOOR
+            )
+
+            if return_cost_deducted_prior_execution:
+                return intrinsic_cost
+
+            return max(
+                intrinsic_cost,
+                data_floor_cost_calculator(
+                    data=calldata, access_list=access_list
+                ),
+            )
+
+        return fn

packages/testing/src/execution_testing/forks/forks/eips/prague/eip_7623.py

@@ -62,7 +62,12 @@ def transaction_data_floor_cost_calculator(
         calldata_gas_calculator = cls.calldata_gas_calculator()
         gas_costs = cls.gas_costs()
 
-        def fn(*, data: BytesConvertible) -> int:
+        def fn(
+            *,
+            data: BytesConvertible,
+            access_list: List[AccessList] | None = None,
+        ) -> int:
+            del access_list
             return (
                 calldata_gas_calculator(data=data, floor=True)
                 + gas_costs.TX_BASE

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

@@ -812,8 +812,12 @@ def transaction_data_floor_cost_calculator(
     ) -> TransactionDataFloorCostCalculator:
         """At frontier, the transaction data floor cost is a constant zero."""
 
-        def fn(*, data: BytesConvertible) -> int:
-            del data
+        def fn(
+            *,
+            data: BytesConvertible,
+            access_list: List[AccessList] | None = None,
+        ) -> int:
+            del data, access_list
             return 0
 
         return fn

src/ethereum/forks/amsterdam/transactions.py

@@ -30,6 +30,22 @@
 
 TX_MAX_GAS_LIMIT = Uint(16_777_216)
 
+ACCESS_LIST_ADDRESS_FLOOR_TOKENS = Uint(80)
+"""
+Floor data tokens contributed by a single access list address per
+[EIP-7981].
+
+[EIP-7981]: https://eips.ethereum.org/EIPS/eip-7981
+"""
+
+ACCESS_LIST_STORAGE_KEY_FLOOR_TOKENS = Uint(128)
+"""
+Floor data tokens contributed by a single access list storage key per
+[EIP-7981].
+
+[EIP-7981]: https://eips.ethereum.org/EIPS/eip-7981
+"""
+
 
 @slotted_freezable
 @dataclass
@@ -601,6 +617,10 @@ def calculate_intrinsic_cost(tx: Transaction) -> Tuple[Uint, Uint]:
             access_list_cost += (
                 ulen(access.slots) * GasCosts.TX_ACCESS_LIST_STORAGE_KEY
             )
+            tokens_in_access_list += ACCESS_LIST_ADDRESS_FLOOR_TOKENS
+            tokens_in_access_list += (
+                ulen(access.slots) * ACCESS_LIST_STORAGE_KEY_FLOOR_TOKENS
+            )
 
     # Data token floor cost for access list bytes.
     access_list_cost += tokens_in_access_list * GasCosts.TX_DATA_TOKEN_FLOOR

tests/amsterdam/eip7981_increase_access_list_cost/__init__.py

@@ -0,0 +1 @@
+"""Tests for EIP-7981: Increase Access List Cost."""