refactor: move transaction gas constatns with other gas constants for repricing mechanism.

Author: Carsons-Eels

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

@@ -120,6 +120,8 @@ def gas_costs(cls) -> GasCosts:
             # Contract Creation
             CODE_DEPOSIT_PER_BYTE=200,
             CODE_INIT_PER_WORD=2,
+            # Authorization
+            AUTH_PER_EMPTY_ACCOUNT=0,
             # Utility
             MEMORY_PER_WORD=3,
             # Transactions
@@ -171,7 +173,7 @@ def gas_costs(cls) -> GasCosts:
             OPCODE_PUSH=VERY_LOW,
             OPCODE_DUP=VERY_LOW,
             OPCODE_SWAP=VERY_LOW,
-            # Dynamic Opcode Component
+            # Dynamic Opcode Components
             OPCODE_CALLDATACOPY_BASE=VERY_LOW,
             OPCODE_CODECOPY_BASE=VERY_LOW,
             OPCODE_MLOAD_BASE=VERY_LOW,
@@ -191,7 +193,6 @@ def gas_costs(cls) -> GasCosts:
             # replace() in the fork that activates them.
             TX_DATA_TOKEN_STANDARD=0,
             TX_DATA_TOKEN_FLOOR=0,
-            AUTH_PER_EMPTY_ACCOUNT=0,
             PRECOMPILE_ECADD=0,
             PRECOMPILE_ECMUL=0,
             PRECOMPILE_ECPAIRING_BASE=0,

src/ethereum/forks/amsterdam/fork.py

@@ -105,8 +105,6 @@
 
 BASE_FEE_MAX_CHANGE_DENOMINATOR = Uint(8)
 ELASTICITY_MULTIPLIER = Uint(2)
-GAS_LIMIT_ADJUSTMENT_FACTOR = Uint(1024)
-GAS_LIMIT_MINIMUM = Uint(5000)
 EMPTY_OMMER_HASH = keccak256(rlp.encode([]))
 SYSTEM_ADDRESS = hex_to_address("0xfffffffffffffffffffffffffffffffffffffffe")
 BEACON_ROOTS_ADDRESS = hex_to_address(
@@ -1121,14 +1119,14 @@ def check_gas_limit(gas_limit: Uint, parent_gas_limit: Uint) -> bool:
 
     The bounds of the gas limit, ``max_adjustment_delta``, is set as the
     quotient of the parent block's gas limit and the
-    ``GAS_LIMIT_ADJUSTMENT_FACTOR``. Therefore, if the gas limit that is
-    passed through as a parameter is greater than or equal to the *sum* of
-    the parent's gas and the adjustment delta then the limit for gas is too
-    high and fails this function's check. Similarly, if the limit is less
-    than or equal to the *difference* of the parent's gas and the adjustment
-    delta *or* the predefined ``GAS_LIMIT_MINIMUM`` then this function's
-    check fails because the gas limit doesn't allow for a sufficient or
-    reasonable amount of gas to be used on a block.
+    ``LIMIT_ADJUSTMENT_FACTOR``. Therefore, if the gas limit that is passed
+    through as a parameter is greater than or equal to the *sum* of the
+    parent's gas and the adjustment delta then the limit for gas is too high
+    and fails this function's check. Similarly, if the limit is less than or
+    equal to the *difference* of the parent's gas and the adjustment delta *or*
+    the predefined ``LIMIT_MINIMUM`` then this function's check fails because
+    the gas limit doesn't allow for a sufficient or reasonable amount of gas to
+    be used on a block.
 
     Parameters
     ----------
@@ -1144,12 +1142,12 @@ def check_gas_limit(gas_limit: Uint, parent_gas_limit: Uint) -> bool:
         True if gas limit constraints are satisfied, False otherwise.
 
     """
-    max_adjustment_delta = parent_gas_limit // GAS_LIMIT_ADJUSTMENT_FACTOR
+    max_adjustment_delta = parent_gas_limit // GasCosts.LIMIT_ADJUSTMENT_FACTOR
     if gas_limit >= parent_gas_limit + max_adjustment_delta:
         return False
     if gas_limit <= parent_gas_limit - max_adjustment_delta:
         return False
-    if gas_limit < GAS_LIMIT_MINIMUM:
+    if gas_limit < GasCosts.LIMIT_MINIMUM:
         return False
 
     return True

src/ethereum/forks/amsterdam/transactions.py

@@ -28,43 +28,6 @@
 )
 from .fork_types import Authorization, VersionedHash
 
-GAS_TX_BASE = Uint(21000)
-"""
-Base cost of a transaction in gas units. This is the minimum amount of gas
-required to execute a transaction.
-"""
-
-GAS_TX_DATA_TOKEN_FLOOR = Uint(10)
-"""
-Minimum gas cost per byte of calldata as per [EIP-7623]. Used to calculate
-the minimum gas cost for transactions that include calldata.
-
-[EIP-7623]: https://eips.ethereum.org/EIPS/eip-7623
-"""
-
-GAS_TX_DATA_TOKEN_STANDARD = Uint(4)
-"""
-Gas cost per byte of calldata as per [EIP-7623]. Used to calculate the
-gas cost for transactions that include calldata.
-
-[EIP-7623]: https://eips.ethereum.org/EIPS/eip-7623
-"""
-
-GAS_TX_CREATE = Uint(32000)
-"""
-Additional gas cost for creating a new contract.
-"""
-
-GAS_TX_ACCESS_LIST_ADDRESS = Uint(2400)
-"""
-Gas cost for including an address in the access list of a transaction.
-"""
-
-GAS_TX_ACCESS_LIST_STORAGE_KEY = Uint(1900)
-"""
-Gas cost for including a storage key in the access list of a transaction.
-"""
-
 TX_MAX_GAS_LIMIT = Uint(16_777_216)
 
 
@@ -608,7 +571,7 @@ def calculate_intrinsic_cost(tx: Transaction) -> Tuple[Uint, Uint]:
     for all operations to be implemented.
 
     The intrinsic cost includes:
-    1. Base cost (`GAS_TX_BASE`)
+    1. Base cost (`TX_BASE`)
     2. Cost for data (zero and non-zero bytes)
     3. Cost for contract creation (if applicable)
     4. Cost for access list entries (if applicable)
@@ -619,33 +582,34 @@ def calculate_intrinsic_cost(tx: Transaction) -> Tuple[Uint, Uint]:
     gas cost of the transaction and the minimum gas cost used by the
     transaction based on the calldata size.
     """
-    from .vm.eoa_delegation import GAS_AUTH_PER_EMPTY_ACCOUNT
-    from .vm.gas import init_code_cost
+    from .vm.gas import GasCosts, init_code_cost
 
     tokens_in_calldata = count_tokens_in_data(tx.data)
 
-    data_cost = tokens_in_calldata * GAS_TX_DATA_TOKEN_STANDARD
+    data_cost = tokens_in_calldata * GasCosts.TX_DATA_TOKEN_STANDARD
 
     if tx.to == Bytes0(b""):
-        create_cost = GAS_TX_CREATE + init_code_cost(ulen(tx.data))
+        create_cost = GasCosts.TX_CREATE + init_code_cost(ulen(tx.data))
     else:
         create_cost = Uint(0)
 
     access_list_cost = Uint(0)
     tokens_in_access_list = Uint(0)
     if has_access_list(tx):
         for access in tx.access_list:
-            access_list_cost += GAS_TX_ACCESS_LIST_ADDRESS
+            access_list_cost += GasCosts.TX_ACCESS_LIST_ADDRESS
             access_list_cost += (
-                ulen(access.slots) * GAS_TX_ACCESS_LIST_STORAGE_KEY
+                ulen(access.slots) * GasCosts.TX_ACCESS_LIST_STORAGE_KEY
             )
 
     # Data token floor cost for access list bytes.
     access_list_cost += tokens_in_access_list * GAS_TX_DATA_TOKEN_FLOOR
 
     auth_cost = Uint(0)
     if isinstance(tx, SetCodeTransaction):
-        auth_cost += Uint(GAS_AUTH_PER_EMPTY_ACCOUNT * len(tx.authorizations))
+        auth_cost += Uint(
+            GasCosts.AUTH_PER_EMPTY_ACCOUNT * len(tx.authorizations)
+        )
 
     # Floor tokens from calldata.
     floor_tokens_in_calldata = tokens_in_calldata
@@ -660,7 +624,7 @@ def calculate_intrinsic_cost(tx: Transaction) -> Tuple[Uint, Uint]:
 
     return (
         Uint(
-            GAS_TX_BASE
+            GasCosts.TX_BASE
             + data_cost
             + create_cost
             + access_list_cost

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

@@ -28,7 +28,6 @@
 EOA_DELEGATION_MARKER = b"\xef\x01\x00"
 EOA_DELEGATION_MARKER_LENGTH = len(EOA_DELEGATION_MARKER)
 EOA_DELEGATED_CODE_LENGTH = 23
-GAS_AUTH_PER_EMPTY_ACCOUNT = 25000
 REFUND_AUTH_PER_EXISTING_ACCOUNT = 12500
 NULL_ADDRESS = hex_to_address("0x0000000000000000000000000000000000000000")
 
@@ -199,7 +198,8 @@ def set_delegation(message: Message) -> U256:
 
         if account_exists(tx_state, authority):
             refund_counter += U256(
-                GAS_AUTH_PER_EMPTY_ACCOUNT - REFUND_AUTH_PER_EXISTING_ACCOUNT
+                GasCosts.AUTH_PER_EMPTY_ACCOUNT
+                - REFUND_AUTH_PER_EXISTING_ACCOUNT
             )
 
         if auth.address == NULL_ADDRESS:

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

@@ -58,6 +58,9 @@ class GasCosts:
     CODE_DEPOSIT_PER_BYTE = Uint(200)
     CODE_INIT_PER_WORD = Uint(2)
 
+    # Authorization
+    AUTH_PER_EMPTY_ACCOUNT = 25000
+
     # Utility
     ZERO = Uint(0)
     MEMORY_PER_WORD = Uint(3)
@@ -100,6 +103,18 @@ class GasCosts:
     # Block Access Lists
     BLOCK_ACCESS_LIST_ITEM = Uint(2000)
 
+    # Transactions
+    TX_BASE = Uint(21000)
+    TX_CREATE = Uint(32000)
+    TX_DATA_TOKEN_STANDARD = Uint(4)
+    TX_DATA_TOKEN_FLOOR = Uint(10)
+    TX_ACCESS_LIST_ADDRESS = Uint(2400)
+    TX_ACCESS_LIST_STORAGE_KEY = Uint(1900)
+
+    # Block
+    LIMIT_ADJUSTMENT_FACTOR = Uint(1024)
+    LIMIT_MINIMUM = Uint(5000)
+
     # Static Opcodes
     OPCODE_ADD = VERY_LOW
     OPCODE_SUB = VERY_LOW

src/ethereum/forks/arrow_glacier/fork.py

@@ -61,13 +61,12 @@
 )
 from .trie import root, trie_set
 from .utils.message import prepare_message
+from .vm.gas import GasCosts
 from .vm.interpreter import process_message_call
 
 BLOCK_REWARD = U256(2 * 10**18)
 BASE_FEE_MAX_CHANGE_DENOMINATOR = Uint(8)
 ELASTICITY_MULTIPLIER = Uint(2)
-GAS_LIMIT_ADJUSTMENT_FACTOR = Uint(1024)
-GAS_LIMIT_MINIMUM = Uint(5000)
 MINIMUM_DIFFICULTY = Uint(131072)
 MAX_OMMER_DEPTH = Uint(6)
 BOMB_DELAY_BLOCKS = 10700000
@@ -849,12 +848,12 @@ def check_gas_limit(gas_limit: Uint, parent_gas_limit: Uint) -> bool:
 
     The bounds of the gas limit, ``max_adjustment_delta``, is set as the
     quotient of the parent block's gas limit and the
-    ``GAS_LIMIT_ADJUSTMENT_FACTOR``. Therefore, if the gas limit that is
+    ``LIMIT_ADJUSTMENT_FACTOR``. Therefore, if the gas limit that is
     passed through as a parameter is greater than or equal to the *sum* of
     the parent's gas and the adjustment delta then the limit for gas is too
     high and fails this function's check. Similarly, if the limit is less
     than or equal to the *difference* of the parent's gas and the adjustment
-    delta *or* the predefined ``GAS_LIMIT_MINIMUM`` then this function's
+    delta *or* the predefined ``LIMIT_MINIMUM`` then this function's
     check fails because the gas limit doesn't allow for a sufficient or
     reasonable amount of gas to be used on a block.
 
@@ -872,12 +871,12 @@ def check_gas_limit(gas_limit: Uint, parent_gas_limit: Uint) -> bool:
         True if gas limit constraints are satisfied, False otherwise.
 
     """
-    max_adjustment_delta = parent_gas_limit // GAS_LIMIT_ADJUSTMENT_FACTOR
+    max_adjustment_delta = parent_gas_limit // GasCosts.LIMIT_ADJUSTMENT_FACTOR
     if gas_limit >= parent_gas_limit + max_adjustment_delta:
         return False
     if gas_limit <= parent_gas_limit - max_adjustment_delta:
         return False
-    if gas_limit < GAS_LIMIT_MINIMUM:
+    if gas_limit < GasCosts.LIMIT_MINIMUM:
         return False
 
     return True

src/ethereum/forks/arrow_glacier/transactions.py

@@ -23,37 +23,6 @@
 from .exceptions import TransactionTypeError
 from .fork_types import Address
 
-GAS_TX_BASE = Uint(21000)
-"""
-Base cost of a transaction in gas units. This is the minimum amount of gas
-required to execute a transaction.
-"""
-
-GAS_TX_DATA_PER_NON_ZERO = Uint(16)
-"""
-Gas cost per non-zero byte in the transaction data.
-"""
-
-GAS_TX_DATA_PER_ZERO = Uint(4)
-"""
-Gas cost per zero byte in the transaction data.
-"""
-
-GAS_TX_CREATE = Uint(32000)
-"""
-Additional gas cost for creating a new contract.
-"""
-
-GAS_TX_ACCESS_LIST_ADDRESS = Uint(2400)
-"""
-Gas cost for including an address in the access list of a transaction.
-"""
-
-GAS_TX_ACCESS_LIST_STORAGE_KEY = Uint(1900)
-"""
-Gas cost for including a storage key in the access list of a transaction.
-"""
-
 
 @slotted_freezable
 @dataclass
@@ -370,35 +339,37 @@ def calculate_intrinsic_cost(tx: Transaction) -> Uint:
     for all operations to be implemented.
 
     The intrinsic cost includes:
-    1. Base cost (`GAS_TX_BASE`)
+    1. Base cost (`TX_BASE`)
     2. Cost for data (zero and non-zero bytes)
     3. Cost for contract creation (if applicable)
     4. Cost for access list entries (if applicable)
 
     This function takes a transaction as a parameter and returns the intrinsic
     gas cost of the transaction.
     """
+    from .vm.gas import GasCosts
+
     num_zeros = Uint(tx.data.count(0))
     num_non_zeros = ulen(tx.data) - num_zeros
     data_cost = (
-        num_zeros * GAS_TX_DATA_PER_ZERO
-        + num_non_zeros * GAS_TX_DATA_PER_NON_ZERO
+        num_zeros * GasCosts.TX_DATA_PER_ZERO
+        + num_non_zeros * GasCosts.TX_DATA_PER_NON_ZERO
     )
 
     if tx.to == Bytes0(b""):
-        create_cost = GAS_TX_CREATE
+        create_cost = GasCosts.TX_CREATE
     else:
         create_cost = Uint(0)
 
     access_list_cost = Uint(0)
     if isinstance(tx, (AccessListTransaction, FeeMarketTransaction)):
         for access in tx.access_list:
-            access_list_cost += GAS_TX_ACCESS_LIST_ADDRESS
+            access_list_cost += GasCosts.TX_ACCESS_LIST_ADDRESS
             access_list_cost += (
-                ulen(access.slots) * GAS_TX_ACCESS_LIST_STORAGE_KEY
+                ulen(access.slots) * GasCosts.TX_ACCESS_LIST_STORAGE_KEY
             )
 
-    return GAS_TX_BASE + data_cost + create_cost + access_list_cost
+    return GasCosts.TX_BASE + data_cost + create_cost + access_list_cost
 
 
 def recover_sender(chain_id: U64, tx: Transaction) -> Address:

src/ethereum/forks/arrow_glacier/vm/gas.py

@@ -76,6 +76,18 @@ class GasCosts:
     PRECOMPILE_ECPAIRING_BASE = Uint(45000)
     PRECOMPILE_ECPAIRING_PER_POINT = Uint(34000)
 
+    # Transactions
+    TX_BASE = Uint(21000)
+    TX_CREATE = Uint(32000)
+    TX_DATA_PER_ZERO = Uint(4)
+    TX_DATA_PER_NON_ZERO = Uint(16)
+    TX_ACCESS_LIST_ADDRESS = Uint(2400)
+    TX_ACCESS_LIST_STORAGE_KEY = Uint(1900)
+
+    # Block
+    LIMIT_ADJUSTMENT_FACTOR = Uint(1024)
+    LIMIT_MINIMUM = Uint(5000)
+
     # Static Opcodes
     OPCODE_ADD = VERY_LOW
     OPCODE_SUB = VERY_LOW