refactor: drop GAS_ prefix for opcode, precompile, and refund consts

Author: Carsons-Eels

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

@@ -151,35 +151,35 @@ def gas_costs(cls) -> GasCosts:
             GAS_KECCAK256=30,
             GAS_KECCAK256_PER_WORD=6,
             GAS_COPY=3,
-            GAS_PRECOMPILE_ECRECOVER=3_000,
-            GAS_PRECOMPILE_SHA256_BASE=60,
-            GAS_PRECOMPILE_SHA256_PER_WORD=12,
-            GAS_PRECOMPILE_RIPEMD160_BASE=600,
-            GAS_PRECOMPILE_RIPEMD160_PER_WORD=120,
-            GAS_PRECOMPILE_IDENTITY_BASE=15,
-            GAS_PRECOMPILE_IDENTITY_PER_WORD=3,
+            PRECOMPILE_ECRECOVER=3_000,
+            PRECOMPILE_SHA256_BASE=60,
+            PRECOMPILE_SHA256_PER_WORD=12,
+            PRECOMPILE_RIPEMD160_BASE=600,
+            PRECOMPILE_RIPEMD160_PER_WORD=120,
+            PRECOMPILE_IDENTITY_BASE=15,
+            PRECOMPILE_IDENTITY_PER_WORD=3,
             # Zero-initialized: introduced in later forks, set via
             # replace() in the fork that activates them.
             GAS_TX_DATA_TOKEN_STANDARD=0,
             GAS_TX_DATA_TOKEN_FLOOR=0,
             GAS_AUTH_PER_EMPTY_ACCOUNT=0,
             REFUND_AUTH_PER_EXISTING_ACCOUNT=0,
-            GAS_PRECOMPILE_ECADD=0,
-            GAS_PRECOMPILE_ECMUL=0,
-            GAS_PRECOMPILE_ECPAIRING_BASE=0,
-            GAS_PRECOMPILE_ECPAIRING_PER_POINT=0,
-            GAS_PRECOMPILE_BLAKE2F_BASE=0,
-            GAS_PRECOMPILE_BLAKE2F_PER_ROUND=0,
-            GAS_PRECOMPILE_POINT_EVALUATION=0,
-            GAS_PRECOMPILE_BLS_G1ADD=0,
-            GAS_PRECOMPILE_BLS_G1MUL=0,
-            GAS_PRECOMPILE_BLS_G1MAP=0,
-            GAS_PRECOMPILE_BLS_G2ADD=0,
-            GAS_PRECOMPILE_BLS_G2MUL=0,
-            GAS_PRECOMPILE_BLS_G2MAP=0,
-            GAS_PRECOMPILE_BLS_PAIRING_BASE=0,
-            GAS_PRECOMPILE_BLS_PAIRING_PER_PAIR=0,
-            GAS_PRECOMPILE_P256VERIFY=0,
+            PRECOMPILE_ECADD=0,
+            PRECOMPILE_ECMUL=0,
+            PRECOMPILE_ECPAIRING_BASE=0,
+            PRECOMPILE_ECPAIRING_PER_POINT=0,
+            PRECOMPILE_BLAKE2F_BASE=0,
+            PRECOMPILE_BLAKE2F_PER_ROUND=0,
+            PRECOMPILE_POINT_EVALUATION=0,
+            PRECOMPILE_BLS_G1ADD=0,
+            PRECOMPILE_BLS_G1MUL=0,
+            PRECOMPILE_BLS_G1MAP=0,
+            PRECOMPILE_BLS_G2ADD=0,
+            PRECOMPILE_BLS_G2MUL=0,
+            PRECOMPILE_BLS_G2MAP=0,
+            PRECOMPILE_BLS_PAIRING_BASE=0,
+            PRECOMPILE_BLS_PAIRING_PER_PAIR=0,
+            PRECOMPILE_P256VERIFY=0,
             GAS_BLOCK_ACCESS_LIST_ITEM=0,
             # Opcode specific gas constants for repricing
             OPCODE_ADD=GAS_VERY_LOW,
@@ -1529,10 +1529,10 @@ def gas_costs(cls) -> GasCosts:
         """
         return replace(
             super(Byzantium, cls).gas_costs(),
-            GAS_PRECOMPILE_ECADD=500,
-            GAS_PRECOMPILE_ECMUL=40_000,
-            GAS_PRECOMPILE_ECPAIRING_BASE=100_000,
-            GAS_PRECOMPILE_ECPAIRING_PER_POINT=80_000,
+            PRECOMPILE_ECADD=500,
+            PRECOMPILE_ECMUL=40_000,
+            PRECOMPILE_ECPAIRING_BASE=100_000,
+            PRECOMPILE_ECPAIRING_PER_POINT=80_000,
             OPCODE_RETURNDATACOPY=GAS_VERY_LOW,
         )
 
@@ -1659,11 +1659,11 @@ def gas_costs(cls) -> GasCosts:
             super(Istanbul, cls).gas_costs(),
             GAS_TX_DATA_PER_NON_ZERO=16,  # https://eips.ethereum.org/EIPS/eip-2028
             # https://eips.ethereum.org/EIPS/eip-1108
-            GAS_PRECOMPILE_ECADD=150,
-            GAS_PRECOMPILE_ECMUL=6000,
-            GAS_PRECOMPILE_ECPAIRING_BASE=45_000,
-            GAS_PRECOMPILE_ECPAIRING_PER_POINT=34_000,
-            GAS_PRECOMPILE_BLAKE2F_PER_ROUND=1,
+            PRECOMPILE_ECADD=150,
+            PRECOMPILE_ECMUL=6000,
+            PRECOMPILE_ECPAIRING_BASE=45_000,
+            PRECOMPILE_ECPAIRING_PER_POINT=34_000,
+            PRECOMPILE_BLAKE2F_PER_ROUND=1,
         )
 
 
@@ -2270,7 +2270,7 @@ def gas_costs(cls) -> GasCosts:
         """On Cancun, the point evaluation precompile gas cost is set."""
         return replace(
             super(Cancun, cls).gas_costs(),
-            GAS_PRECOMPILE_POINT_EVALUATION=50_000,
+            PRECOMPILE_POINT_EVALUATION=50_000,
             OPCODE_BLOBHASH=GAS_VERY_LOW,
             OPCODE_MCOPY=GAS_VERY_LOW,
         )
@@ -2373,14 +2373,14 @@ def gas_costs(cls) -> GasCosts:
             GAS_TX_DATA_TOKEN_FLOOR=10,
             GAS_AUTH_PER_EMPTY_ACCOUNT=25_000,
             REFUND_AUTH_PER_EXISTING_ACCOUNT=12_500,
-            GAS_PRECOMPILE_BLS_G1ADD=375,
-            GAS_PRECOMPILE_BLS_G1MUL=12_000,
-            GAS_PRECOMPILE_BLS_G1MAP=5_500,
-            GAS_PRECOMPILE_BLS_G2ADD=600,
-            GAS_PRECOMPILE_BLS_G2MUL=22_500,
-            GAS_PRECOMPILE_BLS_G2MAP=23_800,
-            GAS_PRECOMPILE_BLS_PAIRING_BASE=37_700,
-            GAS_PRECOMPILE_BLS_PAIRING_PER_PAIR=32_600,
+            PRECOMPILE_BLS_G1ADD=375,
+            PRECOMPILE_BLS_G1MUL=12_000,
+            PRECOMPILE_BLS_G1MAP=5_500,
+            PRECOMPILE_BLS_G2ADD=600,
+            PRECOMPILE_BLS_G2MUL=22_500,
+            PRECOMPILE_BLS_G2MAP=23_800,
+            PRECOMPILE_BLS_PAIRING_BASE=37_700,
+            PRECOMPILE_BLS_PAIRING_PER_PAIR=32_600,
             OPCODE_CLZ=GAS_LOW,
         )
 
@@ -2712,7 +2712,7 @@ def gas_costs(cls) -> GasCosts:
         """On Osaka, the P256VERIFY precompile gas cost is set."""
         return replace(
             super(Osaka, cls).gas_costs(),
-            GAS_PRECOMPILE_P256VERIFY=6_900,
+            PRECOMPILE_P256VERIFY=6_900,
         )
 
     @classmethod

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

@@ -61,34 +61,34 @@ class GasCosts:
     GAS_AUTH_PER_EMPTY_ACCOUNT: int
 
     # Precompiled contract gas constants
-    GAS_PRECOMPILE_ECRECOVER: int
-    GAS_PRECOMPILE_SHA256_BASE: int
-    GAS_PRECOMPILE_SHA256_PER_WORD: int
-    GAS_PRECOMPILE_RIPEMD160_BASE: int
-    GAS_PRECOMPILE_RIPEMD160_PER_WORD: int
-    GAS_PRECOMPILE_IDENTITY_BASE: int
-    GAS_PRECOMPILE_IDENTITY_PER_WORD: int
-
-    GAS_PRECOMPILE_ECADD: int
-    GAS_PRECOMPILE_ECMUL: int
-    GAS_PRECOMPILE_ECPAIRING_BASE: int
-    GAS_PRECOMPILE_ECPAIRING_PER_POINT: int
-
-    GAS_PRECOMPILE_BLAKE2F_BASE: int
-    GAS_PRECOMPILE_BLAKE2F_PER_ROUND: int
-
-    GAS_PRECOMPILE_POINT_EVALUATION: int
-
-    GAS_PRECOMPILE_BLS_G1ADD: int
-    GAS_PRECOMPILE_BLS_G1MUL: int
-    GAS_PRECOMPILE_BLS_G1MAP: int
-    GAS_PRECOMPILE_BLS_G2ADD: int
-    GAS_PRECOMPILE_BLS_G2MUL: int
-    GAS_PRECOMPILE_BLS_G2MAP: int
-    GAS_PRECOMPILE_BLS_PAIRING_BASE: int
-    GAS_PRECOMPILE_BLS_PAIRING_PER_PAIR: int
-
-    GAS_PRECOMPILE_P256VERIFY: int
+    PRECOMPILE_ECRECOVER: int
+    PRECOMPILE_SHA256_BASE: int
+    PRECOMPILE_SHA256_PER_WORD: int
+    PRECOMPILE_RIPEMD160_BASE: int
+    PRECOMPILE_RIPEMD160_PER_WORD: int
+    PRECOMPILE_IDENTITY_BASE: int
+    PRECOMPILE_IDENTITY_PER_WORD: int
+
+    PRECOMPILE_ECADD: int
+    PRECOMPILE_ECMUL: int
+    PRECOMPILE_ECPAIRING_BASE: int
+    PRECOMPILE_ECPAIRING_PER_POINT: int
+
+    PRECOMPILE_BLAKE2F_BASE: int
+    PRECOMPILE_BLAKE2F_PER_ROUND: int
+
+    PRECOMPILE_POINT_EVALUATION: int
+
+    PRECOMPILE_BLS_G1ADD: int
+    PRECOMPILE_BLS_G1MUL: int
+    PRECOMPILE_BLS_G1MAP: int
+    PRECOMPILE_BLS_G2ADD: int
+    PRECOMPILE_BLS_G2MUL: int
+    PRECOMPILE_BLS_G2MAP: int
+    PRECOMPILE_BLS_PAIRING_BASE: int
+    PRECOMPILE_BLS_PAIRING_PER_PAIR: int
+
+    PRECOMPILE_P256VERIFY: int
 
     # Refund constants
     REFUND_STORAGE_CLEAR: int

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

@@ -33,11 +33,11 @@ class GasCosts:
     These values may be patched at runtime by a future gas repricing utility
     """
 
+    # General
     GAS_BASE = Uint(2)
     GAS_VERY_LOW = Uint(3)
     GAS_STORAGE_SET = Uint(20000)
     GAS_COLD_STORAGE_WRITE = Uint(5000)
-    REFUND_STORAGE_CLEAR = 4800
     GAS_LOW = Uint(5)
     GAS_MID = Uint(8)
     GAS_HIGH = Uint(10)
@@ -58,23 +58,35 @@ class GasCosts:
     GAS_CALL_STIPEND = Uint(2300)
     GAS_SELF_DESTRUCT = Uint(5000)
     GAS_SELF_DESTRUCT_NEW_ACCOUNT = Uint(25000)
-    GAS_PRECOMPILE_ECRECOVER = Uint(3000)
-    GAS_PRECOMPILE_P256VERIFY = Uint(6900)
-    GAS_PRECOMPILE_SHA256_BASE = Uint(60)
-    GAS_PRECOMPILE_SHA256_PER_WORD = Uint(12)
-    GAS_PRECOMPILE_RIPEMD160_BASE = Uint(600)
-    GAS_PRECOMPILE_RIPEMD160_PER_WORD = Uint(120)
-    GAS_PRECOMPILE_IDENTITY_BASE = Uint(15)
-    GAS_PRECOMPILE_IDENTITY_PER_WORD = Uint(3)
     GAS_RETURN_DATA_COPY = Uint(3)
     GAS_FAST_STEP = Uint(5)
-    GAS_PRECOMPILE_BLAKE2F_PER_ROUND = Uint(1)
     GAS_COLD_STORAGE_ACCESS = Uint(2100)
     GAS_COLD_ACCOUNT_ACCESS = Uint(2600)
     GAS_WARM_ACCESS = Uint(100)
     GAS_CODE_INIT_PER_WORD = Uint(2)
     GAS_POINT_EVALUATION = Uint(50000)
 
+    # Refunds
+    REFUND_STORAGE_CLEAR = 4800
+
+    # Precompiles
+    PRECOMPILE_ECRECOVER = Uint(3000)
+    PRECOMPILE_P256VERIFY = Uint(6900)
+    PRECOMPILE_SHA256_BASE = Uint(60)
+    PRECOMPILE_SHA256_PER_WORD = Uint(12)
+    PRECOMPILE_RIPEMD160_BASE = Uint(600)
+    PRECOMPILE_RIPEMD160_PER_WORD = Uint(120)
+    PRECOMPILE_IDENTITY_BASE = Uint(15)
+    PRECOMPILE_IDENTITY_PER_WORD = Uint(3)
+    PRECOMPILE_BLAKE2F_PER_ROUND = Uint(1)
+    PRECOMPILE_BLS_G1ADD = Uint(375)
+    PRECOMPILE_BLS_G1MUL = Uint(12000)
+    PRECOMPILE_BLS_G1MAP = Uint(5500)
+    PRECOMPILE_BLS_G2ADD = Uint(600)
+    PRECOMPILE_BLS_G2MUL = Uint(22500)
+    PRECOMPILE_BLS_G2MAP = Uint(23800)
+
+    # Blobs
     GAS_PER_BLOB = U64(2**17)
     BLOB_SCHEDULE_TARGET = U64(14)
     BLOB_TARGET_GAS_PER_BLOCK = GAS_PER_BLOB * BLOB_SCHEDULE_TARGET
@@ -83,16 +95,10 @@ class GasCosts:
     BLOB_MIN_GASPRICE = Uint(1)
     BLOB_BASE_FEE_UPDATE_FRACTION = Uint(11684671)
 
-    GAS_PRECOMPILE_BLS_G1ADD = Uint(375)
-    GAS_PRECOMPILE_BLS_G1MUL = Uint(12000)
-    GAS_PRECOMPILE_BLS_G1MAP = Uint(5500)
-    GAS_PRECOMPILE_BLS_G2ADD = Uint(600)
-    GAS_PRECOMPILE_BLS_G2MUL = Uint(22500)
-    GAS_PRECOMPILE_BLS_G2MAP = Uint(23800)
-
+    # Block Access Lists
     GAS_BLOCK_ACCESS_LIST_ITEM = Uint(2000)
 
-    # Opcode specific vars used for repricing
+    # Opcodes
     OPCODE_ADD = GAS_VERY_LOW
     OPCODE_SUB = GAS_VERY_LOW
     OPCODE_MUL = GAS_LOW

src/ethereum/forks/amsterdam/vm/precompiled_contracts/blake2f.py

@@ -35,7 +35,7 @@ def blake2f(evm: Evm) -> None:
     blake2b = Blake2b()
     rounds, h, m, t_0, t_1, f = blake2b.get_blake2_parameters(data)
 
-    charge_gas(evm, GasCosts.GAS_PRECOMPILE_BLAKE2F_PER_ROUND * rounds)
+    charge_gas(evm, GasCosts.PRECOMPILE_BLAKE2F_PER_ROUND * rounds)
     if f not in [0, 1]:
         raise InvalidParameter
 

src/ethereum/forks/amsterdam/vm/precompiled_contracts/bls12_381/bls12_381_g1.py

@@ -58,7 +58,7 @@ def bls12_g1_add(evm: Evm) -> None:
         raise InvalidParameter("Invalid Input Length")
 
     # GAS
-    charge_gas(evm, Uint(GasCosts.GAS_PRECOMPILE_BLS_G1ADD))
+    charge_gas(evm, Uint(GasCosts.PRECOMPILE_BLS_G1ADD))
 
     # OPERATION
     p1 = bytes_to_g1(buffer_read(data, U256(0), U256(128)))
@@ -99,9 +99,7 @@ def bls12_g1_msm(evm: Evm) -> None:
     else:
         discount = Uint(G1_MAX_DISCOUNT)
 
-    gas_cost = (
-        Uint(k) * GasCosts.GAS_PRECOMPILE_BLS_G1MUL * discount // MULTIPLIER
-    )
+    gas_cost = Uint(k) * GasCosts.PRECOMPILE_BLS_G1MUL * discount // MULTIPLIER
     charge_gas(evm, gas_cost)
 
     # OPERATION
@@ -140,7 +138,7 @@ def bls12_map_fp_to_g1(evm: Evm) -> None:
         raise InvalidParameter("Invalid Input Length")
 
     # GAS
-    charge_gas(evm, Uint(GasCosts.GAS_PRECOMPILE_BLS_G1MAP))
+    charge_gas(evm, Uint(GasCosts.PRECOMPILE_BLS_G1MAP))
 
     # OPERATION
     fp = int.from_bytes(data, "big")

src/ethereum/forks/amsterdam/vm/precompiled_contracts/bls12_381/bls12_381_g2.py

@@ -59,7 +59,7 @@ def bls12_g2_add(evm: Evm) -> None:
         raise InvalidParameter("Invalid Input Length")
 
     # GAS
-    charge_gas(evm, Uint(GasCosts.GAS_PRECOMPILE_BLS_G2ADD))
+    charge_gas(evm, Uint(GasCosts.PRECOMPILE_BLS_G2ADD))
 
     # OPERATION
     p1 = bytes_to_g2(buffer_read(data, U256(0), U256(256)))
@@ -100,9 +100,7 @@ def bls12_g2_msm(evm: Evm) -> None:
     else:
         discount = Uint(G2_MAX_DISCOUNT)
 
-    gas_cost = (
-        Uint(k) * GasCosts.GAS_PRECOMPILE_BLS_G2MUL * discount // MULTIPLIER
-    )
+    gas_cost = Uint(k) * GasCosts.PRECOMPILE_BLS_G2MUL * discount // MULTIPLIER
     charge_gas(evm, gas_cost)
 
     # OPERATION
@@ -141,7 +139,7 @@ def bls12_map_fp2_to_g2(evm: Evm) -> None:
         raise InvalidParameter("Invalid Input Length")
 
     # GAS
-    charge_gas(evm, Uint(GasCosts.GAS_PRECOMPILE_BLS_G2MAP))
+    charge_gas(evm, Uint(GasCosts.PRECOMPILE_BLS_G2MAP))
 
     # OPERATION
     field_element = bytes_to_fq2(data)

src/ethereum/forks/amsterdam/vm/precompiled_contracts/ecrecover.py

@@ -37,7 +37,7 @@ def ecrecover(evm: Evm) -> None:
     data = evm.message.data
 
     # GAS
-    charge_gas(evm, GasCosts.GAS_PRECOMPILE_ECRECOVER)
+    charge_gas(evm, GasCosts.PRECOMPILE_ECRECOVER)
 
     # OPERATION
     message_hash_bytes = buffer_read(data, U256(0), U256(32))

src/ethereum/forks/amsterdam/vm/precompiled_contracts/identity.py

@@ -38,8 +38,8 @@ def identity(evm: Evm) -> None:
     word_count = ceil32(Uint(len(data))) // Uint(32)
     charge_gas(
         evm,
-        GasCosts.GAS_PRECOMPILE_IDENTITY_BASE
-        + GasCosts.GAS_PRECOMPILE_IDENTITY_PER_WORD * word_count,
+        GasCosts.PRECOMPILE_IDENTITY_BASE
+        + GasCosts.PRECOMPILE_IDENTITY_PER_WORD * word_count,
     )
 
     # OPERATION

src/ethereum/forks/amsterdam/vm/precompiled_contracts/p256verify.py

@@ -41,7 +41,7 @@ def p256verify(evm: Evm) -> None:
     data = evm.message.data
 
     # GAS
-    charge_gas(evm, GasCosts.GAS_PRECOMPILE_P256VERIFY)
+    charge_gas(evm, GasCosts.PRECOMPILE_P256VERIFY)
 
     if len(data) != 160:
         return

src/ethereum/forks/amsterdam/vm/precompiled_contracts/ripemd160.py

@@ -41,8 +41,8 @@ def ripemd160(evm: Evm) -> None:
     word_count = ceil32(Uint(len(data))) // Uint(32)
     charge_gas(
         evm,
-        GasCosts.GAS_PRECOMPILE_RIPEMD160_BASE
-        + GasCosts.GAS_PRECOMPILE_RIPEMD160_PER_WORD * word_count,
+        GasCosts.PRECOMPILE_RIPEMD160_BASE
+        + GasCosts.PRECOMPILE_RIPEMD160_PER_WORD * word_count,
     )
 
     # OPERATION