refactor: fix post-merge regressions

Author: Carsons-Eels

tests/benchmark/compute/precompile/test_alt_bn128.py

@@ -722,9 +722,9 @@ def test_alt_bn128_uncachable(
     intrinsic_gas_calculator = fork.transaction_intrinsic_cost_calculator()
     gsc = fork.gas_costs()
     precompile_cost = (
-        gsc.GAS_PRECOMPILE_ECMUL
+        gsc.PRECOMPILE_ECMUL
         if precompile_address == 0x07
-        else gsc.GAS_PRECOMPILE_ECADD
+        else gsc.PRECOMPILE_ECADD
     )
     attack_block = Op.POP(
         Op.STATICCALL(

tests/benchmark/compute/precompile/test_blake2f.py

@@ -121,8 +121,8 @@ def test_blake2f_uncachable(
     # BLAKE2F costs num_rounds gas.
     gsc = fork.gas_costs()
     precompile_cost = (
-        num_rounds * gsc.GAS_PRECOMPILE_BLAKE2F_PER_ROUND
-    ) + gsc.GAS_PRECOMPILE_BLAKE2F_BASE
+        num_rounds * gsc.PRECOMPILE_BLAKE2F_PER_ROUND
+    ) + gsc.PRECOMPILE_BLAKE2F_BASE
 
     attack_block = Op.POP(
         Op.STATICCALL(

tests/benchmark/compute/precompile/test_bls12_381.py

@@ -531,8 +531,8 @@ def test_bls12_pairing_uncachable(
     attack_contract_address = pre.deploy_contract(code=code)
 
     precompile_cost = (
-        gsc.GAS_PRECOMPILE_BLS_PAIRING_BASE
-        + gsc.GAS_PRECOMPILE_BLS_PAIRING_PER_PAIR * num_pairs
+        gsc.PRECOMPILE_BLS_PAIRING_BASE
+        + gsc.PRECOMPILE_BLS_PAIRING_PER_PAIR * num_pairs
     )
 
     iteration_cost = loop.gas_cost(fork) + precompile_cost
@@ -545,8 +545,8 @@ def test_bls12_pairing_uncachable(
     tokens_per_variant = pair_size * 4  # worst case: all non-zero
     per_variant_gas = (
         iteration_cost
-        + tokens_per_variant * gsc.GAS_TX_DATA_TOKEN_FLOOR
-        + words_per_variant * (gsc.GAS_COPY + gsc.GAS_MEMORY)
+        + tokens_per_variant * gsc.TX_DATA_TOKEN_FLOOR
+        + words_per_variant * (gsc.OPCODE_COPY_PER_WORD + gsc.MEMORY_PER_WORD)
     )
     empty_intrinsic = intrinsic_gas_calculator(
         calldata=[],
@@ -579,7 +579,7 @@ def test_bls12_pairing_uncachable(
             per_tx_gas
             - execution_intrinsic
             - setup_cost
-            - math.ceil(len(calldata) / 32) * gsc.GAS_COPY
+            - math.ceil(len(calldata) / 32) * gsc.OPCODE_COPY_PER_WORD
             - mem_exp(new_bytes=len(calldata) + 32)
         )
 

tests/benchmark/compute/precompile/test_identity.py

@@ -86,9 +86,9 @@ def test_identity_uncachable(
 
     precompile_cost = (
         # static cost
-        gsc.GAS_PRECOMPILE_IDENTITY_BASE
+        gsc.PRECOMPILE_IDENTITY_BASE
         # dynamic cost
-        + math.ceil(size / 32) * gsc.GAS_PRECOMPILE_IDENTITY_PER_WORD
+        + math.ceil(size / 32) * gsc.PRECOMPILE_IDENTITY_PER_WORD
     )
 
     attack_block = Op.MSTORE(

tests/benchmark/compute/precompile/test_p256verify.py

@@ -130,7 +130,7 @@ def test_p256verify_uncachable(
     gsc = fork.gas_costs()
     intrinsic_gas_calculator = fork.transaction_intrinsic_cost_calculator()
 
-    precompile_cost = gsc.GAS_PRECOMPILE_P256VERIFY
+    precompile_cost = gsc.PRECOMPILE_P256VERIFY
 
     # h: data[0:32] 32 bytes
     # r: data[32:64] 32 bytes

tests/benchmark/compute/precompile/test_point_evaluation.py

@@ -113,7 +113,7 @@ def test_point_evaluation_uncachable(
     gsc = fork.gas_costs()
     intrinsic_gas_calculator = fork.transaction_intrinsic_cost_calculator()
     mem_exp = fork.memory_expansion_gas_calculator()
-    precompile_cost = gsc.GAS_PRECOMPILE_POINT_EVALUATION
+    precompile_cost = gsc.PRECOMPILE_POINT_EVALUATION
 
     # Each iteration: STATICCALL point_evaluation at advancing calldata
     # offset, then advance offset at MEM[CALLDATASIZE].
@@ -148,8 +148,8 @@ def test_point_evaluation_uncachable(
     words_per_variant = math.ceil(INPUT_SIZE / 32)
     per_variant_gas = (
         iteration_cost
-        + INPUT_SIZE * gsc.GAS_TX_DATA_TOKEN_FLOOR
-        + words_per_variant * (gsc.GAS_COPY + gsc.GAS_MEMORY)
+        + INPUT_SIZE * gsc.TX_DATA_TOKEN_FLOOR
+        + words_per_variant * (gsc.OPCODE_COPY_PER_WORD + gsc.MEMORY_PER_WORD)
     )
     empty_intrinsic = intrinsic_gas_calculator(
         calldata=[], return_cost_deducted_prior_execution=True
@@ -193,7 +193,7 @@ def test_point_evaluation_uncachable(
                 per_tx_gas
                 - execution_intrinsic
                 - setup_cost
-                - math.ceil(len(calldata) / 32) * gsc.GAS_COPY
+                - math.ceil(len(calldata) / 32) * gsc.OPCODE_COPY_PER_WORD
                 - mem_exp(new_bytes=len(calldata) + 32)
             )
 

tests/benchmark/compute/precompile/test_ripemd160.py

@@ -86,9 +86,9 @@ def test_ripemd160_uncachable(
 
     precompile_cost = (
         # static cost
-        gsc.GAS_PRECOMPILE_RIPEMD160_BASE
+        gsc.PRECOMPILE_RIPEMD160_BASE
         # dynamic cost
-        + math.ceil(size / 32) * gsc.GAS_PRECOMPILE_RIPEMD160_PER_WORD
+        + math.ceil(size / 32) * gsc.PRECOMPILE_RIPEMD160_PER_WORD
     )
 
     attack_block = Op.POP(

tests/benchmark/compute/precompile/test_sha256.py

@@ -86,9 +86,9 @@ def test_sha256_uncachable(
 
     precompile_cost = (
         # static cost
-        gsc.GAS_PRECOMPILE_SHA256_BASE
+        gsc.PRECOMPILE_SHA256_BASE
         # dynamic cost
-        + math.ceil(size / 32) * gsc.GAS_PRECOMPILE_SHA256_PER_WORD
+        + math.ceil(size / 32) * gsc.PRECOMPILE_SHA256_PER_WORD
     )
     attack_block = Op.POP(
         Op.STATICCALL(