From 962963988953ea7c17c58146964a79d1075706ff Mon Sep 17 00:00:00 2001 From: carsons-eels Date: Tue, 3 Mar 2026 12:29:57 -0500 Subject: [PATCH 1/7] refactor(spec-specs): add opcode gas constants --- src/ethereum/forks/amsterdam/vm/gas.py | 40 +++++++++++++++++++ .../amsterdam/vm/instructions/arithmetic.py | 33 +++++++++------ .../amsterdam/vm/instructions/bitwise.py | 31 +++++++++----- .../amsterdam/vm/instructions/comparison.py | 22 ++++++---- .../amsterdam/vm/instructions/control_flow.py | 12 ++++-- .../amsterdam/vm/instructions/environment.py | 22 +++++++--- .../forks/amsterdam/vm/instructions/memory.py | 16 +++++--- .../forks/amsterdam/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/arrow_glacier/vm/gas.py | 39 ++++++++++++++++++ .../vm/instructions/arithmetic.py | 33 +++++++++------ .../arrow_glacier/vm/instructions/bitwise.py | 28 ++++++++----- .../vm/instructions/comparison.py | 22 ++++++---- .../vm/instructions/control_flow.py | 12 ++++-- .../vm/instructions/environment.py | 22 +++++++--- .../arrow_glacier/vm/instructions/memory.py | 10 +++-- .../arrow_glacier/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/berlin/vm/gas.py | 39 ++++++++++++++++++ .../berlin/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/berlin/vm/instructions/bitwise.py | 28 ++++++++----- .../berlin/vm/instructions/comparison.py | 22 ++++++---- .../berlin/vm/instructions/control_flow.py | 12 ++++-- .../berlin/vm/instructions/environment.py | 22 +++++++--- .../forks/berlin/vm/instructions/memory.py | 10 +++-- .../forks/berlin/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/bpo1/vm/gas.py | 40 +++++++++++++++++++ .../forks/bpo1/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/bpo1/vm/instructions/bitwise.py | 31 +++++++++----- .../forks/bpo1/vm/instructions/comparison.py | 22 ++++++---- .../bpo1/vm/instructions/control_flow.py | 12 ++++-- .../forks/bpo1/vm/instructions/environment.py | 22 +++++++--- .../forks/bpo1/vm/instructions/memory.py | 16 +++++--- .../forks/bpo1/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/bpo2/vm/gas.py | 40 +++++++++++++++++++ .../forks/bpo2/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/bpo2/vm/instructions/bitwise.py | 31 +++++++++----- .../forks/bpo2/vm/instructions/comparison.py | 22 ++++++---- .../bpo2/vm/instructions/control_flow.py | 12 ++++-- .../forks/bpo2/vm/instructions/environment.py | 22 +++++++--- .../forks/bpo2/vm/instructions/memory.py | 16 +++++--- .../forks/bpo2/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/bpo3/vm/gas.py | 40 +++++++++++++++++++ .../forks/bpo3/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/bpo3/vm/instructions/bitwise.py | 31 +++++++++----- .../forks/bpo3/vm/instructions/comparison.py | 22 ++++++---- .../bpo3/vm/instructions/control_flow.py | 12 ++++-- .../forks/bpo3/vm/instructions/environment.py | 22 +++++++--- .../forks/bpo3/vm/instructions/memory.py | 16 +++++--- .../forks/bpo3/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/bpo4/vm/gas.py | 40 +++++++++++++++++++ .../forks/bpo4/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/bpo4/vm/instructions/bitwise.py | 31 +++++++++----- .../forks/bpo4/vm/instructions/comparison.py | 22 ++++++---- .../bpo4/vm/instructions/control_flow.py | 12 ++++-- .../forks/bpo4/vm/instructions/environment.py | 22 +++++++--- .../forks/bpo4/vm/instructions/memory.py | 16 +++++--- .../forks/bpo4/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/bpo5/vm/gas.py | 40 +++++++++++++++++++ .../forks/bpo5/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/bpo5/vm/instructions/bitwise.py | 31 +++++++++----- .../forks/bpo5/vm/instructions/comparison.py | 22 ++++++---- .../bpo5/vm/instructions/control_flow.py | 12 ++++-- .../forks/bpo5/vm/instructions/environment.py | 22 +++++++--- .../forks/bpo5/vm/instructions/memory.py | 16 +++++--- .../forks/bpo5/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/byzantium/vm/gas.py | 36 +++++++++++++++++ .../byzantium/vm/instructions/arithmetic.py | 33 +++++++++------ .../byzantium/vm/instructions/bitwise.py | 19 ++++++--- .../byzantium/vm/instructions/comparison.py | 22 ++++++---- .../byzantium/vm/instructions/control_flow.py | 12 ++++-- .../byzantium/vm/instructions/environment.py | 22 +++++++--- .../forks/byzantium/vm/instructions/memory.py | 10 +++-- .../forks/byzantium/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/cancun/vm/gas.py | 40 +++++++++++++++++++ .../cancun/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/cancun/vm/instructions/bitwise.py | 28 ++++++++----- .../cancun/vm/instructions/comparison.py | 22 ++++++---- .../cancun/vm/instructions/control_flow.py | 12 ++++-- .../cancun/vm/instructions/environment.py | 22 +++++++--- .../forks/cancun/vm/instructions/memory.py | 16 +++++--- .../forks/cancun/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/constantinople/vm/gas.py | 39 ++++++++++++++++++ .../vm/instructions/arithmetic.py | 33 +++++++++------ .../constantinople/vm/instructions/bitwise.py | 28 ++++++++----- .../vm/instructions/comparison.py | 22 ++++++---- .../vm/instructions/control_flow.py | 12 ++++-- .../vm/instructions/environment.py | 22 +++++++--- .../constantinople/vm/instructions/memory.py | 10 +++-- .../constantinople/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/dao_fork/vm/gas.py | 35 ++++++++++++++++ .../dao_fork/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/dao_fork/vm/instructions/bitwise.py | 19 ++++++--- .../dao_fork/vm/instructions/comparison.py | 22 ++++++---- .../dao_fork/vm/instructions/control_flow.py | 12 ++++-- .../dao_fork/vm/instructions/environment.py | 16 ++++++-- .../forks/dao_fork/vm/instructions/memory.py | 10 +++-- .../forks/dao_fork/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/frontier/vm/gas.py | 35 ++++++++++++++++ .../frontier/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/frontier/vm/instructions/bitwise.py | 19 ++++++--- .../frontier/vm/instructions/comparison.py | 22 ++++++---- .../frontier/vm/instructions/control_flow.py | 12 ++++-- .../frontier/vm/instructions/environment.py | 16 ++++++-- .../forks/frontier/vm/instructions/memory.py | 10 +++-- .../forks/frontier/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/gray_glacier/vm/gas.py | 39 ++++++++++++++++++ .../vm/instructions/arithmetic.py | 33 +++++++++------ .../gray_glacier/vm/instructions/bitwise.py | 28 ++++++++----- .../vm/instructions/comparison.py | 22 ++++++---- .../vm/instructions/control_flow.py | 12 ++++-- .../vm/instructions/environment.py | 22 +++++++--- .../gray_glacier/vm/instructions/memory.py | 10 +++-- .../gray_glacier/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/homestead/vm/gas.py | 35 ++++++++++++++++ .../homestead/vm/instructions/arithmetic.py | 33 +++++++++------ .../homestead/vm/instructions/bitwise.py | 19 ++++++--- .../homestead/vm/instructions/comparison.py | 22 ++++++---- .../homestead/vm/instructions/control_flow.py | 12 ++++-- .../homestead/vm/instructions/environment.py | 16 ++++++-- .../forks/homestead/vm/instructions/memory.py | 10 +++-- .../forks/homestead/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/istanbul/vm/gas.py | 39 ++++++++++++++++++ .../istanbul/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/istanbul/vm/instructions/bitwise.py | 28 ++++++++----- .../istanbul/vm/instructions/comparison.py | 22 ++++++---- .../istanbul/vm/instructions/control_flow.py | 12 ++++-- .../istanbul/vm/instructions/environment.py | 22 +++++++--- .../forks/istanbul/vm/instructions/memory.py | 10 +++-- .../forks/istanbul/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/london/vm/gas.py | 39 ++++++++++++++++++ .../london/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/london/vm/instructions/bitwise.py | 28 ++++++++----- .../london/vm/instructions/comparison.py | 22 ++++++---- .../london/vm/instructions/control_flow.py | 12 ++++-- .../london/vm/instructions/environment.py | 22 +++++++--- .../forks/london/vm/instructions/memory.py | 10 +++-- .../forks/london/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/muir_glacier/vm/gas.py | 39 ++++++++++++++++++ .../vm/instructions/arithmetic.py | 33 +++++++++------ .../muir_glacier/vm/instructions/bitwise.py | 28 ++++++++----- .../vm/instructions/comparison.py | 22 ++++++---- .../vm/instructions/control_flow.py | 12 ++++-- .../vm/instructions/environment.py | 22 +++++++--- .../muir_glacier/vm/instructions/memory.py | 10 +++-- .../muir_glacier/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/osaka/vm/gas.py | 40 +++++++++++++++++++ .../forks/osaka/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/osaka/vm/instructions/bitwise.py | 31 +++++++++----- .../forks/osaka/vm/instructions/comparison.py | 22 ++++++---- .../osaka/vm/instructions/control_flow.py | 12 ++++-- .../osaka/vm/instructions/environment.py | 22 +++++++--- .../forks/osaka/vm/instructions/memory.py | 16 +++++--- .../forks/osaka/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/paris/vm/gas.py | 39 ++++++++++++++++++ .../forks/paris/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/paris/vm/instructions/bitwise.py | 28 ++++++++----- .../forks/paris/vm/instructions/comparison.py | 22 ++++++---- .../paris/vm/instructions/control_flow.py | 12 ++++-- .../paris/vm/instructions/environment.py | 22 +++++++--- .../forks/paris/vm/instructions/memory.py | 10 +++-- .../forks/paris/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/prague/vm/gas.py | 40 +++++++++++++++++++ .../prague/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/prague/vm/instructions/bitwise.py | 28 ++++++++----- .../prague/vm/instructions/comparison.py | 22 ++++++---- .../prague/vm/instructions/control_flow.py | 12 ++++-- .../prague/vm/instructions/environment.py | 22 +++++++--- .../forks/prague/vm/instructions/memory.py | 16 +++++--- .../forks/prague/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/shanghai/vm/gas.py | 39 ++++++++++++++++++ .../shanghai/vm/instructions/arithmetic.py | 33 +++++++++------ .../forks/shanghai/vm/instructions/bitwise.py | 28 ++++++++----- .../shanghai/vm/instructions/comparison.py | 22 ++++++---- .../shanghai/vm/instructions/control_flow.py | 12 ++++-- .../shanghai/vm/instructions/environment.py | 22 +++++++--- .../forks/shanghai/vm/instructions/memory.py | 10 +++-- .../forks/shanghai/vm/instructions/stack.py | 14 +++++-- src/ethereum/forks/spurious_dragon/vm/gas.py | 35 ++++++++++++++++ .../vm/instructions/arithmetic.py | 33 +++++++++------ .../vm/instructions/bitwise.py | 19 ++++++--- .../vm/instructions/comparison.py | 22 ++++++---- .../vm/instructions/control_flow.py | 12 ++++-- .../vm/instructions/environment.py | 16 ++++++-- .../spurious_dragon/vm/instructions/memory.py | 10 +++-- .../spurious_dragon/vm/instructions/stack.py | 14 +++++-- .../forks/tangerine_whistle/vm/gas.py | 35 ++++++++++++++++ .../vm/instructions/arithmetic.py | 33 +++++++++------ .../vm/instructions/bitwise.py | 19 ++++++--- .../vm/instructions/comparison.py | 22 ++++++---- .../vm/instructions/control_flow.py | 12 ++++-- .../vm/instructions/environment.py | 16 ++++++-- .../vm/instructions/memory.py | 10 +++-- .../vm/instructions/stack.py | 14 +++++-- 192 files changed, 3224 insertions(+), 1073 deletions(-) diff --git a/src/ethereum/forks/amsterdam/vm/gas.py b/src/ethereum/forks/amsterdam/vm/gas.py index d3917935e27..a5a94706d9f 100644 --- a/src/ethereum/forks/amsterdam/vm/gas.py +++ b/src/ethereum/forks/amsterdam/vm/gas.py @@ -87,6 +87,46 @@ GAS_BLOCK_ACCESS_LIST_ITEM = Uint(2000) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_CLZ = GAS_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_MCOPY = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + @dataclass class ExtendMemory: diff --git a/src/ethereum/forks/amsterdam/vm/instructions/arithmetic.py b/src/ethereum/forks/amsterdam/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/amsterdam/vm/instructions/bitwise.py b/src/ethereum/forks/amsterdam/vm/instructions/bitwise.py index cc6fa2fbb23..0614ff61fed 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/bitwise.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/bitwise.py @@ -14,7 +14,18 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_LOW, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_CLZ, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +45,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +70,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +95,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +119,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +145,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +180,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +210,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +240,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -262,7 +273,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/amsterdam/vm/instructions/comparison.py b/src/ethereum/forks/amsterdam/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/comparison.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/amsterdam/vm/instructions/control_flow.py b/src/ethereum/forks/amsterdam/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/control_flow.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/amsterdam/vm/instructions/environment.py b/src/ethereum/forks/amsterdam/vm/instructions/environment.py index f5f89bdfa59..98b03e02b9d 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/environment.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/environment.py @@ -28,8 +28,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_blob_gas_price, calculate_gas_extend_memory, @@ -178,7 +181,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -236,7 +239,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -294,7 +300,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -454,7 +463,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/amsterdam/vm/instructions/memory.py b/src/ethereum/forks/amsterdam/vm/instructions/memory.py index 6e111051ee3..1e650339074 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/memory.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/memory.py @@ -20,7 +20,10 @@ from ..gas import ( GAS_BASE, GAS_COPY, - GAS_VERY_LOW, + GAS_OPCODE_MCOPY, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -49,7 +52,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -80,7 +83,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -108,7 +111,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -166,7 +169,10 @@ def mcopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(source, length), (destination, length)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/amsterdam/vm/instructions/stack.py b/src/ethereum/forks/amsterdam/vm/instructions/stack.py index 0007a28acd4..a58e1e66e3f 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/stack.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -65,7 +71,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -95,7 +101,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -127,7 +133,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/arrow_glacier/vm/gas.py b/src/ethereum/forks/arrow_glacier/vm/gas.py index 1929dd5ca3b..c38b90d50d6 100644 --- a/src/ethereum/forks/arrow_glacier/vm/gas.py +++ b/src/ethereum/forks/arrow_glacier/vm/gas.py @@ -64,6 +64,45 @@ GAS_WARM_ACCESS = Uint(100) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/arithmetic.py b/src/ethereum/forks/arrow_glacier/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/bitwise.py b/src/ethereum/forks/arrow_glacier/vm/instructions/bitwise.py index 41dabe8185b..4e36a1a7959 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/bitwise.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/bitwise.py @@ -14,7 +14,17 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +44,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +69,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +94,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +118,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +144,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +179,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +209,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +239,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/comparison.py b/src/ethereum/forks/arrow_glacier/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/comparison.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/control_flow.py b/src/ethereum/forks/arrow_glacier/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/control_flow.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/environment.py b/src/ethereum/forks/arrow_glacier/vm/instructions/environment.py index fe1b70c1269..c7018574c29 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/environment.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/environment.py @@ -26,8 +26,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_gas_extend_memory, charge_gas, @@ -173,7 +176,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -231,7 +234,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -289,7 +295,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -443,7 +452,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/memory.py b/src/ethereum/forks/arrow_glacier/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/memory.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/stack.py b/src/ethereum/forks/arrow_glacier/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/stack.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/berlin/vm/gas.py b/src/ethereum/forks/berlin/vm/gas.py index 477037c3298..fea396e188f 100644 --- a/src/ethereum/forks/berlin/vm/gas.py +++ b/src/ethereum/forks/berlin/vm/gas.py @@ -65,6 +65,45 @@ GAS_WARM_ACCESS = Uint(100) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/berlin/vm/instructions/arithmetic.py b/src/ethereum/forks/berlin/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/berlin/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/berlin/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/berlin/vm/instructions/bitwise.py b/src/ethereum/forks/berlin/vm/instructions/bitwise.py index 41dabe8185b..4e36a1a7959 100644 --- a/src/ethereum/forks/berlin/vm/instructions/bitwise.py +++ b/src/ethereum/forks/berlin/vm/instructions/bitwise.py @@ -14,7 +14,17 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +44,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +69,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +94,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +118,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +144,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +179,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +209,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +239,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/berlin/vm/instructions/comparison.py b/src/ethereum/forks/berlin/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/berlin/vm/instructions/comparison.py +++ b/src/ethereum/forks/berlin/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/berlin/vm/instructions/control_flow.py b/src/ethereum/forks/berlin/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/berlin/vm/instructions/control_flow.py +++ b/src/ethereum/forks/berlin/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/berlin/vm/instructions/environment.py b/src/ethereum/forks/berlin/vm/instructions/environment.py index 63733aca3d5..8798f5a4b7b 100644 --- a/src/ethereum/forks/berlin/vm/instructions/environment.py +++ b/src/ethereum/forks/berlin/vm/instructions/environment.py @@ -26,8 +26,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_gas_extend_memory, charge_gas, @@ -173,7 +176,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -231,7 +234,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -289,7 +295,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -443,7 +452,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/berlin/vm/instructions/memory.py b/src/ethereum/forks/berlin/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/berlin/vm/instructions/memory.py +++ b/src/ethereum/forks/berlin/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/berlin/vm/instructions/stack.py b/src/ethereum/forks/berlin/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/berlin/vm/instructions/stack.py +++ b/src/ethereum/forks/berlin/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/bpo1/vm/gas.py b/src/ethereum/forks/bpo1/vm/gas.py index 8b2e13fa8b5..105f8f63508 100644 --- a/src/ethereum/forks/bpo1/vm/gas.py +++ b/src/ethereum/forks/bpo1/vm/gas.py @@ -84,6 +84,46 @@ GAS_BLS_G2_MUL = Uint(22500) GAS_BLS_G2_MAP = Uint(23800) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_CLZ = GAS_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_MCOPY = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + @dataclass class ExtendMemory: diff --git a/src/ethereum/forks/bpo1/vm/instructions/arithmetic.py b/src/ethereum/forks/bpo1/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/bpo1/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/bpo1/vm/instructions/bitwise.py b/src/ethereum/forks/bpo1/vm/instructions/bitwise.py index cc6fa2fbb23..0614ff61fed 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/bitwise.py +++ b/src/ethereum/forks/bpo1/vm/instructions/bitwise.py @@ -14,7 +14,18 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_LOW, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_CLZ, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +45,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +70,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +95,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +119,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +145,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +180,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +210,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +240,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -262,7 +273,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/bpo1/vm/instructions/comparison.py b/src/ethereum/forks/bpo1/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/comparison.py +++ b/src/ethereum/forks/bpo1/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/bpo1/vm/instructions/control_flow.py b/src/ethereum/forks/bpo1/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/control_flow.py +++ b/src/ethereum/forks/bpo1/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/bpo1/vm/instructions/environment.py b/src/ethereum/forks/bpo1/vm/instructions/environment.py index 5848530a960..589e9d7fcba 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo1/vm/instructions/environment.py @@ -28,8 +28,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_blob_gas_price, calculate_gas_extend_memory, @@ -176,7 +179,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -234,7 +237,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -292,7 +298,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -446,7 +455,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/bpo1/vm/instructions/memory.py b/src/ethereum/forks/bpo1/vm/instructions/memory.py index 6e111051ee3..1e650339074 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/memory.py +++ b/src/ethereum/forks/bpo1/vm/instructions/memory.py @@ -20,7 +20,10 @@ from ..gas import ( GAS_BASE, GAS_COPY, - GAS_VERY_LOW, + GAS_OPCODE_MCOPY, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -49,7 +52,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -80,7 +83,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -108,7 +111,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -166,7 +169,10 @@ def mcopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(source, length), (destination, length)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/bpo1/vm/instructions/stack.py b/src/ethereum/forks/bpo1/vm/instructions/stack.py index 0007a28acd4..a58e1e66e3f 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/stack.py +++ b/src/ethereum/forks/bpo1/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -65,7 +71,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -95,7 +101,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -127,7 +133,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/bpo2/vm/gas.py b/src/ethereum/forks/bpo2/vm/gas.py index a2e5d1ab39a..81c5cbdad65 100644 --- a/src/ethereum/forks/bpo2/vm/gas.py +++ b/src/ethereum/forks/bpo2/vm/gas.py @@ -84,6 +84,46 @@ GAS_BLS_G2_MUL = Uint(22500) GAS_BLS_G2_MAP = Uint(23800) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_CLZ = GAS_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_MCOPY = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + @dataclass class ExtendMemory: diff --git a/src/ethereum/forks/bpo2/vm/instructions/arithmetic.py b/src/ethereum/forks/bpo2/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/bpo2/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/bpo2/vm/instructions/bitwise.py b/src/ethereum/forks/bpo2/vm/instructions/bitwise.py index cc6fa2fbb23..0614ff61fed 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/bitwise.py +++ b/src/ethereum/forks/bpo2/vm/instructions/bitwise.py @@ -14,7 +14,18 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_LOW, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_CLZ, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +45,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +70,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +95,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +119,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +145,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +180,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +210,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +240,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -262,7 +273,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/bpo2/vm/instructions/comparison.py b/src/ethereum/forks/bpo2/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/comparison.py +++ b/src/ethereum/forks/bpo2/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/bpo2/vm/instructions/control_flow.py b/src/ethereum/forks/bpo2/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/control_flow.py +++ b/src/ethereum/forks/bpo2/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/bpo2/vm/instructions/environment.py b/src/ethereum/forks/bpo2/vm/instructions/environment.py index 5848530a960..589e9d7fcba 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo2/vm/instructions/environment.py @@ -28,8 +28,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_blob_gas_price, calculate_gas_extend_memory, @@ -176,7 +179,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -234,7 +237,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -292,7 +298,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -446,7 +455,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/bpo2/vm/instructions/memory.py b/src/ethereum/forks/bpo2/vm/instructions/memory.py index 6e111051ee3..1e650339074 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/memory.py +++ b/src/ethereum/forks/bpo2/vm/instructions/memory.py @@ -20,7 +20,10 @@ from ..gas import ( GAS_BASE, GAS_COPY, - GAS_VERY_LOW, + GAS_OPCODE_MCOPY, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -49,7 +52,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -80,7 +83,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -108,7 +111,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -166,7 +169,10 @@ def mcopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(source, length), (destination, length)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/bpo2/vm/instructions/stack.py b/src/ethereum/forks/bpo2/vm/instructions/stack.py index 0007a28acd4..a58e1e66e3f 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/stack.py +++ b/src/ethereum/forks/bpo2/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -65,7 +71,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -95,7 +101,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -127,7 +133,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/bpo3/vm/gas.py b/src/ethereum/forks/bpo3/vm/gas.py index a2e5d1ab39a..81c5cbdad65 100644 --- a/src/ethereum/forks/bpo3/vm/gas.py +++ b/src/ethereum/forks/bpo3/vm/gas.py @@ -84,6 +84,46 @@ GAS_BLS_G2_MUL = Uint(22500) GAS_BLS_G2_MAP = Uint(23800) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_CLZ = GAS_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_MCOPY = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + @dataclass class ExtendMemory: diff --git a/src/ethereum/forks/bpo3/vm/instructions/arithmetic.py b/src/ethereum/forks/bpo3/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/bpo3/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/bpo3/vm/instructions/bitwise.py b/src/ethereum/forks/bpo3/vm/instructions/bitwise.py index cc6fa2fbb23..0614ff61fed 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/bitwise.py +++ b/src/ethereum/forks/bpo3/vm/instructions/bitwise.py @@ -14,7 +14,18 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_LOW, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_CLZ, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +45,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +70,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +95,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +119,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +145,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +180,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +210,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +240,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -262,7 +273,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/bpo3/vm/instructions/comparison.py b/src/ethereum/forks/bpo3/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/comparison.py +++ b/src/ethereum/forks/bpo3/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/bpo3/vm/instructions/control_flow.py b/src/ethereum/forks/bpo3/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/control_flow.py +++ b/src/ethereum/forks/bpo3/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/bpo3/vm/instructions/environment.py b/src/ethereum/forks/bpo3/vm/instructions/environment.py index 5848530a960..589e9d7fcba 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo3/vm/instructions/environment.py @@ -28,8 +28,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_blob_gas_price, calculate_gas_extend_memory, @@ -176,7 +179,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -234,7 +237,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -292,7 +298,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -446,7 +455,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/bpo3/vm/instructions/memory.py b/src/ethereum/forks/bpo3/vm/instructions/memory.py index 6e111051ee3..1e650339074 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/memory.py +++ b/src/ethereum/forks/bpo3/vm/instructions/memory.py @@ -20,7 +20,10 @@ from ..gas import ( GAS_BASE, GAS_COPY, - GAS_VERY_LOW, + GAS_OPCODE_MCOPY, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -49,7 +52,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -80,7 +83,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -108,7 +111,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -166,7 +169,10 @@ def mcopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(source, length), (destination, length)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/bpo3/vm/instructions/stack.py b/src/ethereum/forks/bpo3/vm/instructions/stack.py index 0007a28acd4..a58e1e66e3f 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/stack.py +++ b/src/ethereum/forks/bpo3/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -65,7 +71,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -95,7 +101,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -127,7 +133,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/bpo4/vm/gas.py b/src/ethereum/forks/bpo4/vm/gas.py index a2e5d1ab39a..81c5cbdad65 100644 --- a/src/ethereum/forks/bpo4/vm/gas.py +++ b/src/ethereum/forks/bpo4/vm/gas.py @@ -84,6 +84,46 @@ GAS_BLS_G2_MUL = Uint(22500) GAS_BLS_G2_MAP = Uint(23800) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_CLZ = GAS_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_MCOPY = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + @dataclass class ExtendMemory: diff --git a/src/ethereum/forks/bpo4/vm/instructions/arithmetic.py b/src/ethereum/forks/bpo4/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/bpo4/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/bpo4/vm/instructions/bitwise.py b/src/ethereum/forks/bpo4/vm/instructions/bitwise.py index cc6fa2fbb23..0614ff61fed 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/bitwise.py +++ b/src/ethereum/forks/bpo4/vm/instructions/bitwise.py @@ -14,7 +14,18 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_LOW, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_CLZ, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +45,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +70,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +95,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +119,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +145,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +180,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +210,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +240,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -262,7 +273,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/bpo4/vm/instructions/comparison.py b/src/ethereum/forks/bpo4/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/comparison.py +++ b/src/ethereum/forks/bpo4/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/bpo4/vm/instructions/control_flow.py b/src/ethereum/forks/bpo4/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/control_flow.py +++ b/src/ethereum/forks/bpo4/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/bpo4/vm/instructions/environment.py b/src/ethereum/forks/bpo4/vm/instructions/environment.py index 5848530a960..589e9d7fcba 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo4/vm/instructions/environment.py @@ -28,8 +28,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_blob_gas_price, calculate_gas_extend_memory, @@ -176,7 +179,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -234,7 +237,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -292,7 +298,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -446,7 +455,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/bpo4/vm/instructions/memory.py b/src/ethereum/forks/bpo4/vm/instructions/memory.py index 6e111051ee3..1e650339074 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/memory.py +++ b/src/ethereum/forks/bpo4/vm/instructions/memory.py @@ -20,7 +20,10 @@ from ..gas import ( GAS_BASE, GAS_COPY, - GAS_VERY_LOW, + GAS_OPCODE_MCOPY, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -49,7 +52,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -80,7 +83,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -108,7 +111,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -166,7 +169,10 @@ def mcopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(source, length), (destination, length)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/bpo4/vm/instructions/stack.py b/src/ethereum/forks/bpo4/vm/instructions/stack.py index 0007a28acd4..a58e1e66e3f 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/stack.py +++ b/src/ethereum/forks/bpo4/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -65,7 +71,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -95,7 +101,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -127,7 +133,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/bpo5/vm/gas.py b/src/ethereum/forks/bpo5/vm/gas.py index a2e5d1ab39a..81c5cbdad65 100644 --- a/src/ethereum/forks/bpo5/vm/gas.py +++ b/src/ethereum/forks/bpo5/vm/gas.py @@ -84,6 +84,46 @@ GAS_BLS_G2_MUL = Uint(22500) GAS_BLS_G2_MAP = Uint(23800) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_CLZ = GAS_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_MCOPY = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + @dataclass class ExtendMemory: diff --git a/src/ethereum/forks/bpo5/vm/instructions/arithmetic.py b/src/ethereum/forks/bpo5/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/bpo5/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/bpo5/vm/instructions/bitwise.py b/src/ethereum/forks/bpo5/vm/instructions/bitwise.py index cc6fa2fbb23..0614ff61fed 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/bitwise.py +++ b/src/ethereum/forks/bpo5/vm/instructions/bitwise.py @@ -14,7 +14,18 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_LOW, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_CLZ, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +45,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +70,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +95,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +119,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +145,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +180,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +210,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +240,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -262,7 +273,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/bpo5/vm/instructions/comparison.py b/src/ethereum/forks/bpo5/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/comparison.py +++ b/src/ethereum/forks/bpo5/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/bpo5/vm/instructions/control_flow.py b/src/ethereum/forks/bpo5/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/control_flow.py +++ b/src/ethereum/forks/bpo5/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/bpo5/vm/instructions/environment.py b/src/ethereum/forks/bpo5/vm/instructions/environment.py index 5848530a960..589e9d7fcba 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo5/vm/instructions/environment.py @@ -28,8 +28,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_blob_gas_price, calculate_gas_extend_memory, @@ -176,7 +179,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -234,7 +237,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -292,7 +298,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -446,7 +455,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/bpo5/vm/instructions/memory.py b/src/ethereum/forks/bpo5/vm/instructions/memory.py index 6e111051ee3..1e650339074 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/memory.py +++ b/src/ethereum/forks/bpo5/vm/instructions/memory.py @@ -20,7 +20,10 @@ from ..gas import ( GAS_BASE, GAS_COPY, - GAS_VERY_LOW, + GAS_OPCODE_MCOPY, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -49,7 +52,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -80,7 +83,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -108,7 +111,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -166,7 +169,10 @@ def mcopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(source, length), (destination, length)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/bpo5/vm/instructions/stack.py b/src/ethereum/forks/bpo5/vm/instructions/stack.py index 0007a28acd4..a58e1e66e3f 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/stack.py +++ b/src/ethereum/forks/bpo5/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -65,7 +71,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -95,7 +101,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -127,7 +133,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/byzantium/vm/gas.py b/src/ethereum/forks/byzantium/vm/gas.py index b21cf5fd15d..adcff5dd650 100644 --- a/src/ethereum/forks/byzantium/vm/gas.py +++ b/src/ethereum/forks/byzantium/vm/gas.py @@ -64,6 +64,42 @@ GAS_RETURN_DATA_COPY = Uint(3) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/byzantium/vm/instructions/arithmetic.py b/src/ethereum/forks/byzantium/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/byzantium/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/byzantium/vm/instructions/bitwise.py b/src/ethereum/forks/byzantium/vm/instructions/bitwise.py index 2a506f55751..cb37f6eca7d 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/bitwise.py +++ b/src/ethereum/forks/byzantium/vm/instructions/bitwise.py @@ -14,7 +14,14 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +41,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +66,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +91,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +115,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +141,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): diff --git a/src/ethereum/forks/byzantium/vm/instructions/comparison.py b/src/ethereum/forks/byzantium/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/comparison.py +++ b/src/ethereum/forks/byzantium/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/byzantium/vm/instructions/control_flow.py b/src/ethereum/forks/byzantium/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/control_flow.py +++ b/src/ethereum/forks/byzantium/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/byzantium/vm/instructions/environment.py b/src/ethereum/forks/byzantium/vm/instructions/environment.py index 0fa98ce55a5..2fb6855f846 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/environment.py +++ b/src/ethereum/forks/byzantium/vm/instructions/environment.py @@ -25,8 +25,11 @@ GAS_BASE, GAS_COPY, GAS_EXTERNAL, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, calculate_gas_extend_memory, charge_gas, ) @@ -167,7 +170,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -225,7 +228,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -283,7 +289,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -424,7 +433,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/byzantium/vm/instructions/memory.py b/src/ethereum/forks/byzantium/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/memory.py +++ b/src/ethereum/forks/byzantium/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/byzantium/vm/instructions/stack.py b/src/ethereum/forks/byzantium/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/stack.py +++ b/src/ethereum/forks/byzantium/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/cancun/vm/gas.py b/src/ethereum/forks/cancun/vm/gas.py index cddb2b59e8c..b375720fc82 100644 --- a/src/ethereum/forks/cancun/vm/gas.py +++ b/src/ethereum/forks/cancun/vm/gas.py @@ -74,6 +74,46 @@ BLOB_BASE_FEE_UPDATE_FRACTION = Uint(3338477) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_MCOPY = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/cancun/vm/instructions/arithmetic.py b/src/ethereum/forks/cancun/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/cancun/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/cancun/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/cancun/vm/instructions/bitwise.py b/src/ethereum/forks/cancun/vm/instructions/bitwise.py index 41dabe8185b..4e36a1a7959 100644 --- a/src/ethereum/forks/cancun/vm/instructions/bitwise.py +++ b/src/ethereum/forks/cancun/vm/instructions/bitwise.py @@ -14,7 +14,17 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +44,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +69,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +94,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +118,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +144,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +179,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +209,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +239,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/cancun/vm/instructions/comparison.py b/src/ethereum/forks/cancun/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/cancun/vm/instructions/comparison.py +++ b/src/ethereum/forks/cancun/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/cancun/vm/instructions/control_flow.py b/src/ethereum/forks/cancun/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/cancun/vm/instructions/control_flow.py +++ b/src/ethereum/forks/cancun/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/cancun/vm/instructions/environment.py b/src/ethereum/forks/cancun/vm/instructions/environment.py index 5848530a960..589e9d7fcba 100644 --- a/src/ethereum/forks/cancun/vm/instructions/environment.py +++ b/src/ethereum/forks/cancun/vm/instructions/environment.py @@ -28,8 +28,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_blob_gas_price, calculate_gas_extend_memory, @@ -176,7 +179,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -234,7 +237,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -292,7 +298,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -446,7 +455,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/cancun/vm/instructions/memory.py b/src/ethereum/forks/cancun/vm/instructions/memory.py index 6e111051ee3..1e650339074 100644 --- a/src/ethereum/forks/cancun/vm/instructions/memory.py +++ b/src/ethereum/forks/cancun/vm/instructions/memory.py @@ -20,7 +20,10 @@ from ..gas import ( GAS_BASE, GAS_COPY, - GAS_VERY_LOW, + GAS_OPCODE_MCOPY, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -49,7 +52,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -80,7 +83,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -108,7 +111,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -166,7 +169,10 @@ def mcopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(source, length), (destination, length)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/cancun/vm/instructions/stack.py b/src/ethereum/forks/cancun/vm/instructions/stack.py index 0007a28acd4..a58e1e66e3f 100644 --- a/src/ethereum/forks/cancun/vm/instructions/stack.py +++ b/src/ethereum/forks/cancun/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -65,7 +71,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -95,7 +101,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -127,7 +133,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/constantinople/vm/gas.py b/src/ethereum/forks/constantinople/vm/gas.py index 839cc3e3121..a6707988f46 100644 --- a/src/ethereum/forks/constantinople/vm/gas.py +++ b/src/ethereum/forks/constantinople/vm/gas.py @@ -65,6 +65,45 @@ GAS_CODE_HASH = Uint(400) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/constantinople/vm/instructions/arithmetic.py b/src/ethereum/forks/constantinople/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/constantinople/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/constantinople/vm/instructions/bitwise.py b/src/ethereum/forks/constantinople/vm/instructions/bitwise.py index 41dabe8185b..4e36a1a7959 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/bitwise.py +++ b/src/ethereum/forks/constantinople/vm/instructions/bitwise.py @@ -14,7 +14,17 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +44,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +69,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +94,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +118,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +144,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +179,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +209,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +239,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/constantinople/vm/instructions/comparison.py b/src/ethereum/forks/constantinople/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/comparison.py +++ b/src/ethereum/forks/constantinople/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/constantinople/vm/instructions/control_flow.py b/src/ethereum/forks/constantinople/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/control_flow.py +++ b/src/ethereum/forks/constantinople/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/constantinople/vm/instructions/environment.py b/src/ethereum/forks/constantinople/vm/instructions/environment.py index d5572be1b4a..f935b995c17 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/environment.py +++ b/src/ethereum/forks/constantinople/vm/instructions/environment.py @@ -27,8 +27,11 @@ GAS_CODE_HASH, GAS_COPY, GAS_EXTERNAL, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, calculate_gas_extend_memory, charge_gas, ) @@ -169,7 +172,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -227,7 +230,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -285,7 +291,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -426,7 +435,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/constantinople/vm/instructions/memory.py b/src/ethereum/forks/constantinople/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/memory.py +++ b/src/ethereum/forks/constantinople/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/constantinople/vm/instructions/stack.py b/src/ethereum/forks/constantinople/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/stack.py +++ b/src/ethereum/forks/constantinople/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/dao_fork/vm/gas.py b/src/ethereum/forks/dao_fork/vm/gas.py index 3c60482255b..687fae69ca8 100644 --- a/src/ethereum/forks/dao_fork/vm/gas.py +++ b/src/ethereum/forks/dao_fork/vm/gas.py @@ -63,6 +63,41 @@ GAS_IDENTITY_WORD = Uint(3) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/dao_fork/vm/instructions/arithmetic.py b/src/ethereum/forks/dao_fork/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/dao_fork/vm/instructions/bitwise.py b/src/ethereum/forks/dao_fork/vm/instructions/bitwise.py index 2a506f55751..cb37f6eca7d 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/bitwise.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/bitwise.py @@ -14,7 +14,14 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +41,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +66,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +91,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +115,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +141,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): diff --git a/src/ethereum/forks/dao_fork/vm/instructions/comparison.py b/src/ethereum/forks/dao_fork/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/comparison.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/dao_fork/vm/instructions/control_flow.py b/src/ethereum/forks/dao_fork/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/control_flow.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/dao_fork/vm/instructions/environment.py b/src/ethereum/forks/dao_fork/vm/instructions/environment.py index 83eb5528226..f2c91716993 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/environment.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/environment.py @@ -24,7 +24,9 @@ GAS_BASE, GAS_COPY, GAS_EXTERNAL, - GAS_VERY_LOW, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, calculate_gas_extend_memory, charge_gas, ) @@ -165,7 +167,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -223,7 +225,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -281,7 +286,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/dao_fork/vm/instructions/memory.py b/src/ethereum/forks/dao_fork/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/memory.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/dao_fork/vm/instructions/stack.py b/src/ethereum/forks/dao_fork/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/stack.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/frontier/vm/gas.py b/src/ethereum/forks/frontier/vm/gas.py index 3c60482255b..687fae69ca8 100644 --- a/src/ethereum/forks/frontier/vm/gas.py +++ b/src/ethereum/forks/frontier/vm/gas.py @@ -63,6 +63,41 @@ GAS_IDENTITY_WORD = Uint(3) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/frontier/vm/instructions/arithmetic.py b/src/ethereum/forks/frontier/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/frontier/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/frontier/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/frontier/vm/instructions/bitwise.py b/src/ethereum/forks/frontier/vm/instructions/bitwise.py index 2a506f55751..cb37f6eca7d 100644 --- a/src/ethereum/forks/frontier/vm/instructions/bitwise.py +++ b/src/ethereum/forks/frontier/vm/instructions/bitwise.py @@ -14,7 +14,14 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +41,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +66,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +91,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +115,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +141,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): diff --git a/src/ethereum/forks/frontier/vm/instructions/comparison.py b/src/ethereum/forks/frontier/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/frontier/vm/instructions/comparison.py +++ b/src/ethereum/forks/frontier/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/frontier/vm/instructions/control_flow.py b/src/ethereum/forks/frontier/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/frontier/vm/instructions/control_flow.py +++ b/src/ethereum/forks/frontier/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/frontier/vm/instructions/environment.py b/src/ethereum/forks/frontier/vm/instructions/environment.py index 83eb5528226..f2c91716993 100644 --- a/src/ethereum/forks/frontier/vm/instructions/environment.py +++ b/src/ethereum/forks/frontier/vm/instructions/environment.py @@ -24,7 +24,9 @@ GAS_BASE, GAS_COPY, GAS_EXTERNAL, - GAS_VERY_LOW, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, calculate_gas_extend_memory, charge_gas, ) @@ -165,7 +167,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -223,7 +225,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -281,7 +286,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/frontier/vm/instructions/memory.py b/src/ethereum/forks/frontier/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/frontier/vm/instructions/memory.py +++ b/src/ethereum/forks/frontier/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/frontier/vm/instructions/stack.py b/src/ethereum/forks/frontier/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/frontier/vm/instructions/stack.py +++ b/src/ethereum/forks/frontier/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/gray_glacier/vm/gas.py b/src/ethereum/forks/gray_glacier/vm/gas.py index 1929dd5ca3b..c38b90d50d6 100644 --- a/src/ethereum/forks/gray_glacier/vm/gas.py +++ b/src/ethereum/forks/gray_glacier/vm/gas.py @@ -64,6 +64,45 @@ GAS_WARM_ACCESS = Uint(100) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/arithmetic.py b/src/ethereum/forks/gray_glacier/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/bitwise.py b/src/ethereum/forks/gray_glacier/vm/instructions/bitwise.py index 41dabe8185b..4e36a1a7959 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/bitwise.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/bitwise.py @@ -14,7 +14,17 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +44,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +69,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +94,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +118,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +144,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +179,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +209,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +239,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/comparison.py b/src/ethereum/forks/gray_glacier/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/comparison.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/control_flow.py b/src/ethereum/forks/gray_glacier/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/control_flow.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/environment.py b/src/ethereum/forks/gray_glacier/vm/instructions/environment.py index fe1b70c1269..c7018574c29 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/environment.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/environment.py @@ -26,8 +26,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_gas_extend_memory, charge_gas, @@ -173,7 +176,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -231,7 +234,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -289,7 +295,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -443,7 +452,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/memory.py b/src/ethereum/forks/gray_glacier/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/memory.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/stack.py b/src/ethereum/forks/gray_glacier/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/stack.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/homestead/vm/gas.py b/src/ethereum/forks/homestead/vm/gas.py index 3c60482255b..687fae69ca8 100644 --- a/src/ethereum/forks/homestead/vm/gas.py +++ b/src/ethereum/forks/homestead/vm/gas.py @@ -63,6 +63,41 @@ GAS_IDENTITY_WORD = Uint(3) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/homestead/vm/instructions/arithmetic.py b/src/ethereum/forks/homestead/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/homestead/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/homestead/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/homestead/vm/instructions/bitwise.py b/src/ethereum/forks/homestead/vm/instructions/bitwise.py index 2a506f55751..cb37f6eca7d 100644 --- a/src/ethereum/forks/homestead/vm/instructions/bitwise.py +++ b/src/ethereum/forks/homestead/vm/instructions/bitwise.py @@ -14,7 +14,14 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +41,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +66,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +91,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +115,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +141,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): diff --git a/src/ethereum/forks/homestead/vm/instructions/comparison.py b/src/ethereum/forks/homestead/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/homestead/vm/instructions/comparison.py +++ b/src/ethereum/forks/homestead/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/homestead/vm/instructions/control_flow.py b/src/ethereum/forks/homestead/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/homestead/vm/instructions/control_flow.py +++ b/src/ethereum/forks/homestead/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/homestead/vm/instructions/environment.py b/src/ethereum/forks/homestead/vm/instructions/environment.py index 83eb5528226..f2c91716993 100644 --- a/src/ethereum/forks/homestead/vm/instructions/environment.py +++ b/src/ethereum/forks/homestead/vm/instructions/environment.py @@ -24,7 +24,9 @@ GAS_BASE, GAS_COPY, GAS_EXTERNAL, - GAS_VERY_LOW, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, calculate_gas_extend_memory, charge_gas, ) @@ -165,7 +167,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -223,7 +225,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -281,7 +286,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/homestead/vm/instructions/memory.py b/src/ethereum/forks/homestead/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/homestead/vm/instructions/memory.py +++ b/src/ethereum/forks/homestead/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/homestead/vm/instructions/stack.py b/src/ethereum/forks/homestead/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/homestead/vm/instructions/stack.py +++ b/src/ethereum/forks/homestead/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/istanbul/vm/gas.py b/src/ethereum/forks/istanbul/vm/gas.py index eb56b502d0a..a6f37ee39ab 100644 --- a/src/ethereum/forks/istanbul/vm/gas.py +++ b/src/ethereum/forks/istanbul/vm/gas.py @@ -67,6 +67,45 @@ GAS_BLAKE2_PER_ROUND = Uint(1) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/istanbul/vm/instructions/arithmetic.py b/src/ethereum/forks/istanbul/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/istanbul/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/istanbul/vm/instructions/bitwise.py b/src/ethereum/forks/istanbul/vm/instructions/bitwise.py index 41dabe8185b..4e36a1a7959 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/bitwise.py +++ b/src/ethereum/forks/istanbul/vm/instructions/bitwise.py @@ -14,7 +14,17 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +44,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +69,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +94,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +118,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +144,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +179,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +209,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +239,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/istanbul/vm/instructions/comparison.py b/src/ethereum/forks/istanbul/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/comparison.py +++ b/src/ethereum/forks/istanbul/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/istanbul/vm/instructions/control_flow.py b/src/ethereum/forks/istanbul/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/control_flow.py +++ b/src/ethereum/forks/istanbul/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/istanbul/vm/instructions/environment.py b/src/ethereum/forks/istanbul/vm/instructions/environment.py index f0cc93e67d8..a77ca394884 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/environment.py +++ b/src/ethereum/forks/istanbul/vm/instructions/environment.py @@ -28,8 +28,11 @@ GAS_COPY, GAS_EXTERNAL, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, calculate_gas_extend_memory, charge_gas, ) @@ -170,7 +173,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -228,7 +231,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -286,7 +292,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -427,7 +436,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/istanbul/vm/instructions/memory.py b/src/ethereum/forks/istanbul/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/memory.py +++ b/src/ethereum/forks/istanbul/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/istanbul/vm/instructions/stack.py b/src/ethereum/forks/istanbul/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/stack.py +++ b/src/ethereum/forks/istanbul/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/london/vm/gas.py b/src/ethereum/forks/london/vm/gas.py index 1929dd5ca3b..c38b90d50d6 100644 --- a/src/ethereum/forks/london/vm/gas.py +++ b/src/ethereum/forks/london/vm/gas.py @@ -64,6 +64,45 @@ GAS_WARM_ACCESS = Uint(100) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/london/vm/instructions/arithmetic.py b/src/ethereum/forks/london/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/london/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/london/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/london/vm/instructions/bitwise.py b/src/ethereum/forks/london/vm/instructions/bitwise.py index 41dabe8185b..4e36a1a7959 100644 --- a/src/ethereum/forks/london/vm/instructions/bitwise.py +++ b/src/ethereum/forks/london/vm/instructions/bitwise.py @@ -14,7 +14,17 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +44,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +69,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +94,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +118,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +144,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +179,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +209,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +239,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/london/vm/instructions/comparison.py b/src/ethereum/forks/london/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/london/vm/instructions/comparison.py +++ b/src/ethereum/forks/london/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/london/vm/instructions/control_flow.py b/src/ethereum/forks/london/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/london/vm/instructions/control_flow.py +++ b/src/ethereum/forks/london/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/london/vm/instructions/environment.py b/src/ethereum/forks/london/vm/instructions/environment.py index fe1b70c1269..c7018574c29 100644 --- a/src/ethereum/forks/london/vm/instructions/environment.py +++ b/src/ethereum/forks/london/vm/instructions/environment.py @@ -26,8 +26,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_gas_extend_memory, charge_gas, @@ -173,7 +176,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -231,7 +234,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -289,7 +295,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -443,7 +452,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/london/vm/instructions/memory.py b/src/ethereum/forks/london/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/london/vm/instructions/memory.py +++ b/src/ethereum/forks/london/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/london/vm/instructions/stack.py b/src/ethereum/forks/london/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/london/vm/instructions/stack.py +++ b/src/ethereum/forks/london/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/muir_glacier/vm/gas.py b/src/ethereum/forks/muir_glacier/vm/gas.py index eb56b502d0a..a6f37ee39ab 100644 --- a/src/ethereum/forks/muir_glacier/vm/gas.py +++ b/src/ethereum/forks/muir_glacier/vm/gas.py @@ -67,6 +67,45 @@ GAS_BLAKE2_PER_ROUND = Uint(1) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/arithmetic.py b/src/ethereum/forks/muir_glacier/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/bitwise.py b/src/ethereum/forks/muir_glacier/vm/instructions/bitwise.py index 41dabe8185b..4e36a1a7959 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/bitwise.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/bitwise.py @@ -14,7 +14,17 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +44,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +69,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +94,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +118,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +144,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +179,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +209,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +239,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/comparison.py b/src/ethereum/forks/muir_glacier/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/comparison.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/control_flow.py b/src/ethereum/forks/muir_glacier/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/control_flow.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/environment.py b/src/ethereum/forks/muir_glacier/vm/instructions/environment.py index f0cc93e67d8..a77ca394884 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/environment.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/environment.py @@ -28,8 +28,11 @@ GAS_COPY, GAS_EXTERNAL, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, calculate_gas_extend_memory, charge_gas, ) @@ -170,7 +173,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -228,7 +231,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -286,7 +292,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -427,7 +436,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/memory.py b/src/ethereum/forks/muir_glacier/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/memory.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/stack.py b/src/ethereum/forks/muir_glacier/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/stack.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/osaka/vm/gas.py b/src/ethereum/forks/osaka/vm/gas.py index 5108bf63a7d..27190da1edd 100644 --- a/src/ethereum/forks/osaka/vm/gas.py +++ b/src/ethereum/forks/osaka/vm/gas.py @@ -84,6 +84,46 @@ GAS_BLS_G2_MUL = Uint(22500) GAS_BLS_G2_MAP = Uint(23800) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_CLZ = GAS_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_MCOPY = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + @dataclass class ExtendMemory: diff --git a/src/ethereum/forks/osaka/vm/instructions/arithmetic.py b/src/ethereum/forks/osaka/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/osaka/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/osaka/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/osaka/vm/instructions/bitwise.py b/src/ethereum/forks/osaka/vm/instructions/bitwise.py index cc6fa2fbb23..0614ff61fed 100644 --- a/src/ethereum/forks/osaka/vm/instructions/bitwise.py +++ b/src/ethereum/forks/osaka/vm/instructions/bitwise.py @@ -14,7 +14,18 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_LOW, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_CLZ, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +45,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +70,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +95,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +119,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +145,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +180,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +210,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +240,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -262,7 +273,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/osaka/vm/instructions/comparison.py b/src/ethereum/forks/osaka/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/osaka/vm/instructions/comparison.py +++ b/src/ethereum/forks/osaka/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/osaka/vm/instructions/control_flow.py b/src/ethereum/forks/osaka/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/osaka/vm/instructions/control_flow.py +++ b/src/ethereum/forks/osaka/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/osaka/vm/instructions/environment.py b/src/ethereum/forks/osaka/vm/instructions/environment.py index 5848530a960..589e9d7fcba 100644 --- a/src/ethereum/forks/osaka/vm/instructions/environment.py +++ b/src/ethereum/forks/osaka/vm/instructions/environment.py @@ -28,8 +28,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_blob_gas_price, calculate_gas_extend_memory, @@ -176,7 +179,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -234,7 +237,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -292,7 +298,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -446,7 +455,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/osaka/vm/instructions/memory.py b/src/ethereum/forks/osaka/vm/instructions/memory.py index 6e111051ee3..1e650339074 100644 --- a/src/ethereum/forks/osaka/vm/instructions/memory.py +++ b/src/ethereum/forks/osaka/vm/instructions/memory.py @@ -20,7 +20,10 @@ from ..gas import ( GAS_BASE, GAS_COPY, - GAS_VERY_LOW, + GAS_OPCODE_MCOPY, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -49,7 +52,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -80,7 +83,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -108,7 +111,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -166,7 +169,10 @@ def mcopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(source, length), (destination, length)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/osaka/vm/instructions/stack.py b/src/ethereum/forks/osaka/vm/instructions/stack.py index 0007a28acd4..a58e1e66e3f 100644 --- a/src/ethereum/forks/osaka/vm/instructions/stack.py +++ b/src/ethereum/forks/osaka/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -65,7 +71,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -95,7 +101,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -127,7 +133,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/paris/vm/gas.py b/src/ethereum/forks/paris/vm/gas.py index 1929dd5ca3b..c38b90d50d6 100644 --- a/src/ethereum/forks/paris/vm/gas.py +++ b/src/ethereum/forks/paris/vm/gas.py @@ -64,6 +64,45 @@ GAS_WARM_ACCESS = Uint(100) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/paris/vm/instructions/arithmetic.py b/src/ethereum/forks/paris/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/paris/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/paris/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/paris/vm/instructions/bitwise.py b/src/ethereum/forks/paris/vm/instructions/bitwise.py index 41dabe8185b..4e36a1a7959 100644 --- a/src/ethereum/forks/paris/vm/instructions/bitwise.py +++ b/src/ethereum/forks/paris/vm/instructions/bitwise.py @@ -14,7 +14,17 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +44,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +69,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +94,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +118,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +144,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +179,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +209,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +239,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/paris/vm/instructions/comparison.py b/src/ethereum/forks/paris/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/paris/vm/instructions/comparison.py +++ b/src/ethereum/forks/paris/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/paris/vm/instructions/control_flow.py b/src/ethereum/forks/paris/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/paris/vm/instructions/control_flow.py +++ b/src/ethereum/forks/paris/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/paris/vm/instructions/environment.py b/src/ethereum/forks/paris/vm/instructions/environment.py index ba2bb42a425..00e43488ea9 100644 --- a/src/ethereum/forks/paris/vm/instructions/environment.py +++ b/src/ethereum/forks/paris/vm/instructions/environment.py @@ -26,8 +26,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_gas_extend_memory, charge_gas, @@ -173,7 +176,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -231,7 +234,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -289,7 +295,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -443,7 +452,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/paris/vm/instructions/memory.py b/src/ethereum/forks/paris/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/paris/vm/instructions/memory.py +++ b/src/ethereum/forks/paris/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/paris/vm/instructions/stack.py b/src/ethereum/forks/paris/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/paris/vm/instructions/stack.py +++ b/src/ethereum/forks/paris/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/prague/vm/gas.py b/src/ethereum/forks/prague/vm/gas.py index ed1f651e23c..8605c776b57 100644 --- a/src/ethereum/forks/prague/vm/gas.py +++ b/src/ethereum/forks/prague/vm/gas.py @@ -81,6 +81,46 @@ GAS_BLS_G2_MAP = Uint(23800) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_MCOPY = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/prague/vm/instructions/arithmetic.py b/src/ethereum/forks/prague/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/prague/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/prague/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/prague/vm/instructions/bitwise.py b/src/ethereum/forks/prague/vm/instructions/bitwise.py index 41dabe8185b..4e36a1a7959 100644 --- a/src/ethereum/forks/prague/vm/instructions/bitwise.py +++ b/src/ethereum/forks/prague/vm/instructions/bitwise.py @@ -14,7 +14,17 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +44,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +69,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +94,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +118,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +144,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +179,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +209,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +239,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/prague/vm/instructions/comparison.py b/src/ethereum/forks/prague/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/prague/vm/instructions/comparison.py +++ b/src/ethereum/forks/prague/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/prague/vm/instructions/control_flow.py b/src/ethereum/forks/prague/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/prague/vm/instructions/control_flow.py +++ b/src/ethereum/forks/prague/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/prague/vm/instructions/environment.py b/src/ethereum/forks/prague/vm/instructions/environment.py index 5848530a960..589e9d7fcba 100644 --- a/src/ethereum/forks/prague/vm/instructions/environment.py +++ b/src/ethereum/forks/prague/vm/instructions/environment.py @@ -28,8 +28,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_blob_gas_price, calculate_gas_extend_memory, @@ -176,7 +179,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -234,7 +237,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -292,7 +298,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -446,7 +455,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/prague/vm/instructions/memory.py b/src/ethereum/forks/prague/vm/instructions/memory.py index 6e111051ee3..1e650339074 100644 --- a/src/ethereum/forks/prague/vm/instructions/memory.py +++ b/src/ethereum/forks/prague/vm/instructions/memory.py @@ -20,7 +20,10 @@ from ..gas import ( GAS_BASE, GAS_COPY, - GAS_VERY_LOW, + GAS_OPCODE_MCOPY, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -49,7 +52,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -80,7 +83,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -108,7 +111,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -166,7 +169,10 @@ def mcopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(source, length), (destination, length)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/prague/vm/instructions/stack.py b/src/ethereum/forks/prague/vm/instructions/stack.py index 0007a28acd4..a58e1e66e3f 100644 --- a/src/ethereum/forks/prague/vm/instructions/stack.py +++ b/src/ethereum/forks/prague/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -65,7 +71,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -95,7 +101,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -127,7 +133,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/shanghai/vm/gas.py b/src/ethereum/forks/shanghai/vm/gas.py index bd3ea9ec341..8b695d5d05a 100644 --- a/src/ethereum/forks/shanghai/vm/gas.py +++ b/src/ethereum/forks/shanghai/vm/gas.py @@ -65,6 +65,45 @@ GAS_CODE_INIT_PER_WORD = Uint(2) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_SHL = GAS_VERY_LOW +GAS_OPCODE_SHR = GAS_VERY_LOW +GAS_OPCODE_SAR = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_RETURNDATACOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/shanghai/vm/instructions/arithmetic.py b/src/ethereum/forks/shanghai/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/shanghai/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/shanghai/vm/instructions/bitwise.py b/src/ethereum/forks/shanghai/vm/instructions/bitwise.py index 41dabe8185b..4e36a1a7959 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/bitwise.py +++ b/src/ethereum/forks/shanghai/vm/instructions/bitwise.py @@ -14,7 +14,17 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_SAR, + GAS_OPCODE_SHL, + GAS_OPCODE_SHR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +44,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +69,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +94,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +118,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +144,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -169,7 +179,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -199,7 +209,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -229,7 +239,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/shanghai/vm/instructions/comparison.py b/src/ethereum/forks/shanghai/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/comparison.py +++ b/src/ethereum/forks/shanghai/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/shanghai/vm/instructions/control_flow.py b/src/ethereum/forks/shanghai/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/control_flow.py +++ b/src/ethereum/forks/shanghai/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/shanghai/vm/instructions/environment.py b/src/ethereum/forks/shanghai/vm/instructions/environment.py index ba2bb42a425..00e43488ea9 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/environment.py +++ b/src/ethereum/forks/shanghai/vm/instructions/environment.py @@ -26,8 +26,11 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, + GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, - GAS_VERY_LOW, GAS_WARM_ACCESS, calculate_gas_extend_memory, charge_gas, @@ -173,7 +176,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -231,7 +234,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -289,7 +295,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -443,7 +452,10 @@ def returndatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/shanghai/vm/instructions/memory.py b/src/ethereum/forks/shanghai/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/memory.py +++ b/src/ethereum/forks/shanghai/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/shanghai/vm/instructions/stack.py b/src/ethereum/forks/shanghai/vm/instructions/stack.py index 0007a28acd4..a58e1e66e3f 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/stack.py +++ b/src/ethereum/forks/shanghai/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -65,7 +71,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -95,7 +101,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -127,7 +133,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/spurious_dragon/vm/gas.py b/src/ethereum/forks/spurious_dragon/vm/gas.py index 7f9fe700db3..8799d3ee595 100644 --- a/src/ethereum/forks/spurious_dragon/vm/gas.py +++ b/src/ethereum/forks/spurious_dragon/vm/gas.py @@ -63,6 +63,41 @@ GAS_IDENTITY_WORD = Uint(3) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/arithmetic.py b/src/ethereum/forks/spurious_dragon/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/bitwise.py b/src/ethereum/forks/spurious_dragon/vm/instructions/bitwise.py index 2a506f55751..cb37f6eca7d 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/bitwise.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/bitwise.py @@ -14,7 +14,14 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +41,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +66,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +91,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +115,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +141,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/comparison.py b/src/ethereum/forks/spurious_dragon/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/comparison.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/control_flow.py b/src/ethereum/forks/spurious_dragon/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/control_flow.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/environment.py b/src/ethereum/forks/spurious_dragon/vm/instructions/environment.py index 83eb5528226..f2c91716993 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/environment.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/environment.py @@ -24,7 +24,9 @@ GAS_BASE, GAS_COPY, GAS_EXTERNAL, - GAS_VERY_LOW, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, calculate_gas_extend_memory, charge_gas, ) @@ -165,7 +167,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -223,7 +225,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -281,7 +286,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/memory.py b/src/ethereum/forks/spurious_dragon/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/memory.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/stack.py b/src/ethereum/forks/spurious_dragon/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/stack.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/tangerine_whistle/vm/gas.py b/src/ethereum/forks/tangerine_whistle/vm/gas.py index ac02500d623..8d8f4ab57a6 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/gas.py +++ b/src/ethereum/forks/tangerine_whistle/vm/gas.py @@ -63,6 +63,41 @@ GAS_IDENTITY_WORD = Uint(3) +# Opcode specific vars used for repricing +GAS_OPCODE_ADD = GAS_VERY_LOW +GAS_OPCODE_SUB = GAS_VERY_LOW +GAS_OPCODE_MUL = GAS_LOW +GAS_OPCODE_DIV = GAS_LOW +GAS_OPCODE_SDIV = GAS_LOW +GAS_OPCODE_MOD = GAS_LOW +GAS_OPCODE_SMOD = GAS_LOW +GAS_OPCODE_ADDMOD = GAS_MID +GAS_OPCODE_MULMOD = GAS_MID +GAS_OPCODE_SIGNEXTEND = GAS_LOW +GAS_OPCODE_LT = GAS_VERY_LOW +GAS_OPCODE_GT = GAS_VERY_LOW +GAS_OPCODE_SLT = GAS_VERY_LOW +GAS_OPCODE_SGT = GAS_VERY_LOW +GAS_OPCODE_EQ = GAS_VERY_LOW +GAS_OPCODE_ISZERO = GAS_VERY_LOW +GAS_OPCODE_AND = GAS_VERY_LOW +GAS_OPCODE_OR = GAS_VERY_LOW +GAS_OPCODE_XOR = GAS_VERY_LOW +GAS_OPCODE_NOT = GAS_VERY_LOW +GAS_OPCODE_BYTE = GAS_VERY_LOW +GAS_OPCODE_JUMP = GAS_MID +GAS_OPCODE_JUMPI = GAS_HIGH +GAS_OPCODE_CALLDATALOAD = GAS_VERY_LOW +GAS_OPCODE_CALLDATACOPY = GAS_VERY_LOW +GAS_OPCODE_CODECOPY = GAS_VERY_LOW +GAS_OPCODE_MLOAD = GAS_VERY_LOW +GAS_OPCODE_MSTORE = GAS_VERY_LOW +GAS_OPCODE_MSTORE8 = GAS_VERY_LOW +GAS_OPCODE_PUSH_N = GAS_VERY_LOW +GAS_OPCODE_DUP_N = GAS_VERY_LOW +GAS_OPCODE_SWAP_N = GAS_VERY_LOW + + @dataclass class ExtendMemory: """ diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/arithmetic.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/arithmetic.py index b7b1a370ad4..d74f7425823 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/arithmetic.py @@ -20,9 +20,16 @@ from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_LOW, - GAS_MID, - GAS_VERY_LOW, + GAS_OPCODE_ADD, + GAS_OPCODE_ADDMOD, + GAS_OPCODE_DIV, + GAS_OPCODE_MOD, + GAS_OPCODE_MUL, + GAS_OPCODE_MULMOD, + GAS_OPCODE_SDIV, + GAS_OPCODE_SIGNEXTEND, + GAS_OPCODE_SMOD, + GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -44,7 +51,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -71,7 +78,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -98,7 +105,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -125,7 +132,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -158,7 +165,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -191,7 +198,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -221,7 +228,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -252,7 +259,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -283,7 +290,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -346,7 +353,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_LOW) + charge_gas(evm, GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/bitwise.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/bitwise.py index 2a506f55751..cb37f6eca7d 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/bitwise.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/bitwise.py @@ -14,7 +14,14 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_AND, + GAS_OPCODE_BYTE, + GAS_OPCODE_NOT, + GAS_OPCODE_OR, + GAS_OPCODE_XOR, + charge_gas, +) from ..stack import pop, push @@ -34,7 +41,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -59,7 +66,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -84,7 +91,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -108,7 +115,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -134,7 +141,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/comparison.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/comparison.py index a6a3d99bc86..f18a1f221e8 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/comparison.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/comparison.py @@ -14,7 +14,15 @@ from ethereum_types.numeric import U256, Uint from .. import Evm -from ..gas import GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_OPCODE_EQ, + GAS_OPCODE_GT, + GAS_OPCODE_ISZERO, + GAS_OPCODE_LT, + GAS_OPCODE_SGT, + GAS_OPCODE_SLT, + charge_gas, +) from ..stack import pop, push @@ -34,7 +42,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -60,7 +68,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -87,7 +95,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -113,7 +121,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -140,7 +148,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -166,7 +174,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/control_flow.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/control_flow.py index b3b1f2316a7..3207f00d738 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/control_flow.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/control_flow.py @@ -13,7 +13,13 @@ from ethereum_types.numeric import U256, Uint -from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas +from ...vm.gas import ( + GAS_BASE, + GAS_JUMPDEST, + GAS_OPCODE_JUMP, + GAS_OPCODE_JUMPI, + charge_gas, +) from .. import Evm from ..exceptions import InvalidJumpDestError from ..stack import pop, push @@ -57,7 +63,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_MID) + charge_gas(evm, GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -84,7 +90,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_HIGH) + charge_gas(evm, GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/environment.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/environment.py index 83eb5528226..f2c91716993 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/environment.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/environment.py @@ -24,7 +24,9 @@ GAS_BASE, GAS_COPY, GAS_EXTERNAL, - GAS_VERY_LOW, + GAS_OPCODE_CALLDATACOPY, + GAS_OPCODE_CALLDATALOAD, + GAS_OPCODE_CODECOPY, calculate_gas_extend_memory, charge_gas, ) @@ -165,7 +167,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -223,7 +225,10 @@ def calldatacopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -281,7 +286,10 @@ def codecopy(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost) + charge_gas( + evm, + GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + ) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/memory.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/memory.py index 3a242ba2f7a..74a9396629a 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/memory.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/memory.py @@ -17,7 +17,9 @@ from .. import Evm from ..gas import ( GAS_BASE, - GAS_VERY_LOW, + GAS_OPCODE_MLOAD, + GAS_OPCODE_MSTORE, + GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -46,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -77,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -105,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_VERY_LOW + extend_memory.cost) + charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/stack.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/stack.py index 0fc0d3fe4b5..4f1b8171e51 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/stack.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/stack.py @@ -17,7 +17,13 @@ from .. import Evm, stack from ..exceptions import StackUnderflowError -from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas +from ..gas import ( + GAS_BASE, + GAS_OPCODE_DUP_N, + GAS_OPCODE_PUSH_N, + GAS_OPCODE_SWAP_N, + charge_gas, +) from ..memory import buffer_read @@ -62,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -92,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -124,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_VERY_LOW) + charge_gas(evm, GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( From 6c757994593031093d5ad5508497d23bcbcacf65 Mon Sep 17 00:00:00 2001 From: carsons-eels Date: Tue, 3 Mar 2026 15:09:34 -0500 Subject: [PATCH 2/7] refactor(spec-specs): renamed GAS_BLOBHASH_OPCODE to GAS_BLOBHASH to more clearly differentiate between intermediate constants and existing ones --- src/ethereum/forks/amsterdam/vm/gas.py | 2 +- src/ethereum/forks/amsterdam/vm/instructions/environment.py | 4 ++-- src/ethereum/forks/bpo1/vm/gas.py | 2 +- src/ethereum/forks/bpo1/vm/instructions/environment.py | 4 ++-- src/ethereum/forks/bpo2/vm/gas.py | 2 +- src/ethereum/forks/bpo2/vm/instructions/environment.py | 4 ++-- src/ethereum/forks/bpo3/vm/gas.py | 2 +- src/ethereum/forks/bpo3/vm/instructions/environment.py | 4 ++-- src/ethereum/forks/bpo4/vm/gas.py | 2 +- src/ethereum/forks/bpo4/vm/instructions/environment.py | 4 ++-- src/ethereum/forks/bpo5/vm/gas.py | 2 +- src/ethereum/forks/bpo5/vm/instructions/environment.py | 4 ++-- src/ethereum/forks/cancun/vm/gas.py | 2 +- src/ethereum/forks/cancun/vm/instructions/environment.py | 4 ++-- src/ethereum/forks/osaka/vm/gas.py | 2 +- src/ethereum/forks/osaka/vm/instructions/environment.py | 4 ++-- src/ethereum/forks/prague/vm/gas.py | 2 +- src/ethereum/forks/prague/vm/instructions/environment.py | 4 ++-- 18 files changed, 27 insertions(+), 27 deletions(-) diff --git a/src/ethereum/forks/amsterdam/vm/gas.py b/src/ethereum/forks/amsterdam/vm/gas.py index a5a94706d9f..ea87d412529 100644 --- a/src/ethereum/forks/amsterdam/vm/gas.py +++ b/src/ethereum/forks/amsterdam/vm/gas.py @@ -67,7 +67,7 @@ GAS_COLD_ACCOUNT_ACCESS = Uint(2600) GAS_WARM_ACCESS = Uint(100) GAS_CODE_INIT_PER_WORD = Uint(2) -GAS_BLOBHASH_OPCODE = Uint(3) +GAS_BLOBHASH = Uint(3) GAS_POINT_EVALUATION = Uint(50000) GAS_PER_BLOB = U64(2**17) diff --git a/src/ethereum/forks/amsterdam/vm/instructions/environment.py b/src/ethereum/forks/amsterdam/vm/instructions/environment.py index 98b03e02b9d..ea48276dd30 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/environment.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/environment.py @@ -24,7 +24,7 @@ from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, - GAS_BLOBHASH_OPCODE, + GAS_BLOBHASH, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, @@ -583,7 +583,7 @@ def blob_hash(evm: Evm) -> None: index = pop(evm.stack) # GAS - charge_gas(evm, GAS_BLOBHASH_OPCODE) + charge_gas(evm, GAS_BLOBHASH) # OPERATION if int(index) < len(evm.message.tx_env.blob_versioned_hashes): diff --git a/src/ethereum/forks/bpo1/vm/gas.py b/src/ethereum/forks/bpo1/vm/gas.py index 105f8f63508..bc6d512698a 100644 --- a/src/ethereum/forks/bpo1/vm/gas.py +++ b/src/ethereum/forks/bpo1/vm/gas.py @@ -66,7 +66,7 @@ GAS_COLD_ACCOUNT_ACCESS = Uint(2600) GAS_WARM_ACCESS = Uint(100) GAS_CODE_INIT_PER_WORD = Uint(2) -GAS_BLOBHASH_OPCODE = Uint(3) +GAS_BLOBHASH = Uint(3) GAS_POINT_EVALUATION = Uint(50000) GAS_PER_BLOB = U64(2**17) diff --git a/src/ethereum/forks/bpo1/vm/instructions/environment.py b/src/ethereum/forks/bpo1/vm/instructions/environment.py index 589e9d7fcba..7a2f15c7001 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo1/vm/instructions/environment.py @@ -24,7 +24,7 @@ from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, - GAS_BLOBHASH_OPCODE, + GAS_BLOBHASH, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, @@ -573,7 +573,7 @@ def blob_hash(evm: Evm) -> None: index = pop(evm.stack) # GAS - charge_gas(evm, GAS_BLOBHASH_OPCODE) + charge_gas(evm, GAS_BLOBHASH) # OPERATION if int(index) < len(evm.message.tx_env.blob_versioned_hashes): diff --git a/src/ethereum/forks/bpo2/vm/gas.py b/src/ethereum/forks/bpo2/vm/gas.py index 81c5cbdad65..9d87d29f244 100644 --- a/src/ethereum/forks/bpo2/vm/gas.py +++ b/src/ethereum/forks/bpo2/vm/gas.py @@ -66,7 +66,7 @@ GAS_COLD_ACCOUNT_ACCESS = Uint(2600) GAS_WARM_ACCESS = Uint(100) GAS_CODE_INIT_PER_WORD = Uint(2) -GAS_BLOBHASH_OPCODE = Uint(3) +GAS_BLOBHASH = Uint(3) GAS_POINT_EVALUATION = Uint(50000) GAS_PER_BLOB = U64(2**17) diff --git a/src/ethereum/forks/bpo2/vm/instructions/environment.py b/src/ethereum/forks/bpo2/vm/instructions/environment.py index 589e9d7fcba..7a2f15c7001 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo2/vm/instructions/environment.py @@ -24,7 +24,7 @@ from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, - GAS_BLOBHASH_OPCODE, + GAS_BLOBHASH, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, @@ -573,7 +573,7 @@ def blob_hash(evm: Evm) -> None: index = pop(evm.stack) # GAS - charge_gas(evm, GAS_BLOBHASH_OPCODE) + charge_gas(evm, GAS_BLOBHASH) # OPERATION if int(index) < len(evm.message.tx_env.blob_versioned_hashes): diff --git a/src/ethereum/forks/bpo3/vm/gas.py b/src/ethereum/forks/bpo3/vm/gas.py index 81c5cbdad65..9d87d29f244 100644 --- a/src/ethereum/forks/bpo3/vm/gas.py +++ b/src/ethereum/forks/bpo3/vm/gas.py @@ -66,7 +66,7 @@ GAS_COLD_ACCOUNT_ACCESS = Uint(2600) GAS_WARM_ACCESS = Uint(100) GAS_CODE_INIT_PER_WORD = Uint(2) -GAS_BLOBHASH_OPCODE = Uint(3) +GAS_BLOBHASH = Uint(3) GAS_POINT_EVALUATION = Uint(50000) GAS_PER_BLOB = U64(2**17) diff --git a/src/ethereum/forks/bpo3/vm/instructions/environment.py b/src/ethereum/forks/bpo3/vm/instructions/environment.py index 589e9d7fcba..7a2f15c7001 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo3/vm/instructions/environment.py @@ -24,7 +24,7 @@ from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, - GAS_BLOBHASH_OPCODE, + GAS_BLOBHASH, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, @@ -573,7 +573,7 @@ def blob_hash(evm: Evm) -> None: index = pop(evm.stack) # GAS - charge_gas(evm, GAS_BLOBHASH_OPCODE) + charge_gas(evm, GAS_BLOBHASH) # OPERATION if int(index) < len(evm.message.tx_env.blob_versioned_hashes): diff --git a/src/ethereum/forks/bpo4/vm/gas.py b/src/ethereum/forks/bpo4/vm/gas.py index 81c5cbdad65..9d87d29f244 100644 --- a/src/ethereum/forks/bpo4/vm/gas.py +++ b/src/ethereum/forks/bpo4/vm/gas.py @@ -66,7 +66,7 @@ GAS_COLD_ACCOUNT_ACCESS = Uint(2600) GAS_WARM_ACCESS = Uint(100) GAS_CODE_INIT_PER_WORD = Uint(2) -GAS_BLOBHASH_OPCODE = Uint(3) +GAS_BLOBHASH = Uint(3) GAS_POINT_EVALUATION = Uint(50000) GAS_PER_BLOB = U64(2**17) diff --git a/src/ethereum/forks/bpo4/vm/instructions/environment.py b/src/ethereum/forks/bpo4/vm/instructions/environment.py index 589e9d7fcba..7a2f15c7001 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo4/vm/instructions/environment.py @@ -24,7 +24,7 @@ from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, - GAS_BLOBHASH_OPCODE, + GAS_BLOBHASH, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, @@ -573,7 +573,7 @@ def blob_hash(evm: Evm) -> None: index = pop(evm.stack) # GAS - charge_gas(evm, GAS_BLOBHASH_OPCODE) + charge_gas(evm, GAS_BLOBHASH) # OPERATION if int(index) < len(evm.message.tx_env.blob_versioned_hashes): diff --git a/src/ethereum/forks/bpo5/vm/gas.py b/src/ethereum/forks/bpo5/vm/gas.py index 81c5cbdad65..9d87d29f244 100644 --- a/src/ethereum/forks/bpo5/vm/gas.py +++ b/src/ethereum/forks/bpo5/vm/gas.py @@ -66,7 +66,7 @@ GAS_COLD_ACCOUNT_ACCESS = Uint(2600) GAS_WARM_ACCESS = Uint(100) GAS_CODE_INIT_PER_WORD = Uint(2) -GAS_BLOBHASH_OPCODE = Uint(3) +GAS_BLOBHASH = Uint(3) GAS_POINT_EVALUATION = Uint(50000) GAS_PER_BLOB = U64(2**17) diff --git a/src/ethereum/forks/bpo5/vm/instructions/environment.py b/src/ethereum/forks/bpo5/vm/instructions/environment.py index 589e9d7fcba..7a2f15c7001 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo5/vm/instructions/environment.py @@ -24,7 +24,7 @@ from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, - GAS_BLOBHASH_OPCODE, + GAS_BLOBHASH, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, @@ -573,7 +573,7 @@ def blob_hash(evm: Evm) -> None: index = pop(evm.stack) # GAS - charge_gas(evm, GAS_BLOBHASH_OPCODE) + charge_gas(evm, GAS_BLOBHASH) # OPERATION if int(index) < len(evm.message.tx_env.blob_versioned_hashes): diff --git a/src/ethereum/forks/cancun/vm/gas.py b/src/ethereum/forks/cancun/vm/gas.py index b375720fc82..d28192c2e67 100644 --- a/src/ethereum/forks/cancun/vm/gas.py +++ b/src/ethereum/forks/cancun/vm/gas.py @@ -65,7 +65,7 @@ GAS_COLD_ACCOUNT_ACCESS = Uint(2600) GAS_WARM_ACCESS = Uint(100) GAS_CODE_INIT_PER_WORD = Uint(2) -GAS_BLOBHASH_OPCODE = Uint(3) +GAS_BLOBHASH = Uint(3) GAS_POINT_EVALUATION = Uint(50000) GAS_PER_BLOB = U64(2**17) diff --git a/src/ethereum/forks/cancun/vm/instructions/environment.py b/src/ethereum/forks/cancun/vm/instructions/environment.py index 589e9d7fcba..7a2f15c7001 100644 --- a/src/ethereum/forks/cancun/vm/instructions/environment.py +++ b/src/ethereum/forks/cancun/vm/instructions/environment.py @@ -24,7 +24,7 @@ from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, - GAS_BLOBHASH_OPCODE, + GAS_BLOBHASH, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, @@ -573,7 +573,7 @@ def blob_hash(evm: Evm) -> None: index = pop(evm.stack) # GAS - charge_gas(evm, GAS_BLOBHASH_OPCODE) + charge_gas(evm, GAS_BLOBHASH) # OPERATION if int(index) < len(evm.message.tx_env.blob_versioned_hashes): diff --git a/src/ethereum/forks/osaka/vm/gas.py b/src/ethereum/forks/osaka/vm/gas.py index 27190da1edd..32673fe71b3 100644 --- a/src/ethereum/forks/osaka/vm/gas.py +++ b/src/ethereum/forks/osaka/vm/gas.py @@ -66,7 +66,7 @@ GAS_COLD_ACCOUNT_ACCESS = Uint(2600) GAS_WARM_ACCESS = Uint(100) GAS_CODE_INIT_PER_WORD = Uint(2) -GAS_BLOBHASH_OPCODE = Uint(3) +GAS_BLOBHASH = Uint(3) GAS_POINT_EVALUATION = Uint(50000) GAS_PER_BLOB = U64(2**17) diff --git a/src/ethereum/forks/osaka/vm/instructions/environment.py b/src/ethereum/forks/osaka/vm/instructions/environment.py index 589e9d7fcba..7a2f15c7001 100644 --- a/src/ethereum/forks/osaka/vm/instructions/environment.py +++ b/src/ethereum/forks/osaka/vm/instructions/environment.py @@ -24,7 +24,7 @@ from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, - GAS_BLOBHASH_OPCODE, + GAS_BLOBHASH, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, @@ -573,7 +573,7 @@ def blob_hash(evm: Evm) -> None: index = pop(evm.stack) # GAS - charge_gas(evm, GAS_BLOBHASH_OPCODE) + charge_gas(evm, GAS_BLOBHASH) # OPERATION if int(index) < len(evm.message.tx_env.blob_versioned_hashes): diff --git a/src/ethereum/forks/prague/vm/gas.py b/src/ethereum/forks/prague/vm/gas.py index 8605c776b57..51ed3ee2d29 100644 --- a/src/ethereum/forks/prague/vm/gas.py +++ b/src/ethereum/forks/prague/vm/gas.py @@ -65,7 +65,7 @@ GAS_COLD_ACCOUNT_ACCESS = Uint(2600) GAS_WARM_ACCESS = Uint(100) GAS_CODE_INIT_PER_WORD = Uint(2) -GAS_BLOBHASH_OPCODE = Uint(3) +GAS_BLOBHASH = Uint(3) GAS_POINT_EVALUATION = Uint(50000) GAS_PER_BLOB = U64(2**17) diff --git a/src/ethereum/forks/prague/vm/instructions/environment.py b/src/ethereum/forks/prague/vm/instructions/environment.py index 589e9d7fcba..7a2f15c7001 100644 --- a/src/ethereum/forks/prague/vm/instructions/environment.py +++ b/src/ethereum/forks/prague/vm/instructions/environment.py @@ -24,7 +24,7 @@ from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, - GAS_BLOBHASH_OPCODE, + GAS_BLOBHASH, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, @@ -573,7 +573,7 @@ def blob_hash(evm: Evm) -> None: index = pop(evm.stack) # GAS - charge_gas(evm, GAS_BLOBHASH_OPCODE) + charge_gas(evm, GAS_BLOBHASH) # OPERATION if int(index) < len(evm.message.tx_env.blob_versioned_hashes): From 1b0910fa8dd24c1ebb4f5aba9504908cb659c707 Mon Sep 17 00:00:00 2001 From: carsons-eels Date: Tue, 3 Mar 2026 15:10:29 -0500 Subject: [PATCH 3/7] refactor(testing): add per-opcode gas constants to GasCosts Add 39 GAS_OPCODE_* fields to the GasCosts dataclass and update opcode_gas_map() in all forks to reference per-opcode fields instead of shared tier constants. --- .../execution_testing/forks/forks/forks.py | 126 ++++++++++++------ .../src/execution_testing/forks/gas_costs.py | 41 ++++++ 2 files changed, 128 insertions(+), 39 deletions(-) diff --git a/packages/testing/src/execution_testing/forks/forks/forks.py b/packages/testing/src/execution_testing/forks/forks/forks.py index d7525f437cb..97df3bc3edb 100644 --- a/packages/testing/src/execution_testing/forks/forks/forks.py +++ b/packages/testing/src/execution_testing/forks/forks/forks.py @@ -201,6 +201,46 @@ def gas_costs( GAS_PRECOMPILE_BLS_PAIRING_PER_PAIR=0, GAS_PRECOMPILE_P256VERIFY=0, GAS_BLOCK_ACCESS_LIST_ITEM=0, + # Opcode specific gas constants for repricing + GAS_OPCODE_ADD=3, + GAS_OPCODE_SUB=3, + GAS_OPCODE_MUL=5, + GAS_OPCODE_DIV=5, + GAS_OPCODE_SDIV=5, + GAS_OPCODE_MOD=5, + GAS_OPCODE_SMOD=5, + GAS_OPCODE_ADDMOD=8, + GAS_OPCODE_MULMOD=8, + GAS_OPCODE_SIGNEXTEND=5, + GAS_OPCODE_LT=3, + GAS_OPCODE_GT=3, + GAS_OPCODE_SLT=3, + GAS_OPCODE_SGT=3, + GAS_OPCODE_EQ=3, + GAS_OPCODE_ISZERO=3, + GAS_OPCODE_AND=3, + GAS_OPCODE_OR=3, + GAS_OPCODE_XOR=3, + GAS_OPCODE_NOT=3, + GAS_OPCODE_BYTE=3, + GAS_OPCODE_SHL=3, + GAS_OPCODE_SHR=3, + GAS_OPCODE_SAR=3, + GAS_OPCODE_CLZ=5, + GAS_OPCODE_BLOBHASH=3, + GAS_OPCODE_JUMP=8, + GAS_OPCODE_JUMPI=10, + GAS_OPCODE_CALLDATALOAD=3, + GAS_OPCODE_CALLDATACOPY=3, + GAS_OPCODE_CODECOPY=3, + GAS_OPCODE_RETURNDATACOPY=3, + GAS_OPCODE_MLOAD=3, + GAS_OPCODE_MSTORE=3, + GAS_OPCODE_MSTORE8=3, + GAS_OPCODE_MCOPY=3, + GAS_OPCODE_PUSH_N=3, + GAS_OPCODE_DUP_N=3, + GAS_OPCODE_SWAP_N=3, ) @classmethod @@ -338,33 +378,33 @@ def opcode_gas_map( return { # Stop and arithmetic operations Opcodes.STOP: 0, - Opcodes.ADD: gas_costs.GAS_VERY_LOW, - Opcodes.MUL: gas_costs.GAS_LOW, - Opcodes.SUB: gas_costs.GAS_VERY_LOW, - Opcodes.DIV: gas_costs.GAS_LOW, - Opcodes.SDIV: gas_costs.GAS_LOW, - Opcodes.MOD: gas_costs.GAS_LOW, - Opcodes.SMOD: gas_costs.GAS_LOW, - Opcodes.ADDMOD: gas_costs.GAS_MID, - Opcodes.MULMOD: gas_costs.GAS_MID, + Opcodes.ADD: gas_costs.GAS_OPCODE_ADD, + Opcodes.MUL: gas_costs.GAS_OPCODE_MUL, + Opcodes.SUB: gas_costs.GAS_OPCODE_SUB, + Opcodes.DIV: gas_costs.GAS_OPCODE_DIV, + Opcodes.SDIV: gas_costs.GAS_OPCODE_SDIV, + Opcodes.MOD: gas_costs.GAS_OPCODE_MOD, + Opcodes.SMOD: gas_costs.GAS_OPCODE_SMOD, + Opcodes.ADDMOD: gas_costs.GAS_OPCODE_ADDMOD, + Opcodes.MULMOD: gas_costs.GAS_OPCODE_MULMOD, Opcodes.EXP: lambda op: ( gas_costs.GAS_EXPONENTIATION + gas_costs.GAS_EXPONENTIATION_PER_BYTE * ((op.metadata["exponent"].bit_length() + 7) // 8) ), - Opcodes.SIGNEXTEND: gas_costs.GAS_LOW, + Opcodes.SIGNEXTEND: gas_costs.GAS_OPCODE_SIGNEXTEND, # Comparison & bitwise logic operations - Opcodes.LT: gas_costs.GAS_VERY_LOW, - Opcodes.GT: gas_costs.GAS_VERY_LOW, - Opcodes.SLT: gas_costs.GAS_VERY_LOW, - Opcodes.SGT: gas_costs.GAS_VERY_LOW, - Opcodes.EQ: gas_costs.GAS_VERY_LOW, - Opcodes.ISZERO: gas_costs.GAS_VERY_LOW, - Opcodes.AND: gas_costs.GAS_VERY_LOW, - Opcodes.OR: gas_costs.GAS_VERY_LOW, - Opcodes.XOR: gas_costs.GAS_VERY_LOW, - Opcodes.NOT: gas_costs.GAS_VERY_LOW, - Opcodes.BYTE: gas_costs.GAS_VERY_LOW, + Opcodes.LT: gas_costs.GAS_OPCODE_LT, + Opcodes.GT: gas_costs.GAS_OPCODE_GT, + Opcodes.SLT: gas_costs.GAS_OPCODE_SLT, + Opcodes.SGT: gas_costs.GAS_OPCODE_SGT, + Opcodes.EQ: gas_costs.GAS_OPCODE_EQ, + Opcodes.ISZERO: gas_costs.GAS_OPCODE_ISZERO, + Opcodes.AND: gas_costs.GAS_OPCODE_AND, + Opcodes.OR: gas_costs.GAS_OPCODE_OR, + Opcodes.XOR: gas_costs.GAS_OPCODE_XOR, + Opcodes.NOT: gas_costs.GAS_OPCODE_NOT, + Opcodes.BYTE: gas_costs.GAS_OPCODE_BYTE, # SHA3 Opcodes.SHA3: cls._with_memory_expansion( lambda op: ( @@ -380,15 +420,17 @@ def opcode_gas_map( Opcodes.ORIGIN: gas_costs.GAS_BASE, Opcodes.CALLER: gas_costs.GAS_BASE, Opcodes.CALLVALUE: gas_costs.GAS_BASE, - Opcodes.CALLDATALOAD: gas_costs.GAS_VERY_LOW, + Opcodes.CALLDATALOAD: gas_costs.GAS_OPCODE_CALLDATALOAD, Opcodes.CALLDATASIZE: gas_costs.GAS_BASE, Opcodes.CALLDATACOPY: cls._with_memory_expansion( - cls._with_data_copy(gas_costs.GAS_VERY_LOW, gas_costs), + cls._with_data_copy( + gas_costs.GAS_OPCODE_CALLDATACOPY, gas_costs + ), memory_expansion_calculator, ), Opcodes.CODESIZE: gas_costs.GAS_BASE, Opcodes.CODECOPY: cls._with_memory_expansion( - cls._with_data_copy(gas_costs.GAS_VERY_LOW, gas_costs), + cls._with_data_copy(gas_costs.GAS_OPCODE_CODECOPY, gas_costs), memory_expansion_calculator, ), Opcodes.GASPRICE: gas_costs.GAS_BASE, @@ -410,13 +452,16 @@ def opcode_gas_map( # Stack, memory, storage and flow operations Opcodes.POP: gas_costs.GAS_BASE, Opcodes.MLOAD: cls._with_memory_expansion( - gas_costs.GAS_VERY_LOW, memory_expansion_calculator + gas_costs.GAS_OPCODE_MLOAD, + memory_expansion_calculator, ), Opcodes.MSTORE: cls._with_memory_expansion( - gas_costs.GAS_VERY_LOW, memory_expansion_calculator + gas_costs.GAS_OPCODE_MSTORE, + memory_expansion_calculator, ), Opcodes.MSTORE8: cls._with_memory_expansion( - gas_costs.GAS_VERY_LOW, memory_expansion_calculator + gas_costs.GAS_OPCODE_MSTORE8, + memory_expansion_calculator, ), Opcodes.SLOAD: lambda op: ( gas_costs.GAS_WARM_SLOAD @@ -426,25 +471,25 @@ def opcode_gas_map( Opcodes.SSTORE: lambda op: cls._calculate_sstore_gas( op, gas_costs ), - Opcodes.JUMP: gas_costs.GAS_MID, - Opcodes.JUMPI: gas_costs.GAS_HIGH, + Opcodes.JUMP: gas_costs.GAS_OPCODE_JUMP, + Opcodes.JUMPI: gas_costs.GAS_OPCODE_JUMPI, Opcodes.PC: gas_costs.GAS_BASE, Opcodes.MSIZE: gas_costs.GAS_BASE, Opcodes.GAS: gas_costs.GAS_BASE, Opcodes.JUMPDEST: gas_costs.GAS_JUMPDEST, # Push operations (PUSH1 through PUSH32) **{ - getattr(Opcodes, f"PUSH{i}"): gas_costs.GAS_VERY_LOW + getattr(Opcodes, f"PUSH{i}"): gas_costs.GAS_OPCODE_PUSH_N for i in range(1, 33) }, # Dup operations (DUP1 through DUP16) **{ - getattr(Opcodes, f"DUP{i}"): gas_costs.GAS_VERY_LOW + getattr(Opcodes, f"DUP{i}"): gas_costs.GAS_OPCODE_DUP_N for i in range(1, 17) }, # Swap operations (SWAP1 through SWAP16) **{ - getattr(Opcodes, f"SWAP{i}"): gas_costs.GAS_VERY_LOW + getattr(Opcodes, f"SWAP{i}"): gas_costs.GAS_OPCODE_SWAP_N for i in range(1, 17) }, # Logging operations @@ -1690,7 +1735,10 @@ def opcode_gas_map( **base_map, Opcodes.RETURNDATASIZE: gas_costs.GAS_BASE, Opcodes.RETURNDATACOPY: cls._with_memory_expansion( - cls._with_data_copy(gas_costs.GAS_VERY_LOW, gas_costs), + cls._with_data_copy( + gas_costs.GAS_OPCODE_RETURNDATACOPY, + gas_costs, + ), memory_expansion_calculator, ), Opcodes.STATICCALL: cls._with_memory_expansion( @@ -1784,9 +1832,9 @@ def opcode_gas_map( ) return { **base_map, - Opcodes.SHL: gas_costs.GAS_VERY_LOW, - Opcodes.SHR: gas_costs.GAS_VERY_LOW, - Opcodes.SAR: gas_costs.GAS_VERY_LOW, + Opcodes.SHL: gas_costs.GAS_OPCODE_SHL, + Opcodes.SHR: gas_costs.GAS_OPCODE_SHR, + Opcodes.SAR: gas_costs.GAS_OPCODE_SAR, Opcodes.EXTCODEHASH: cls._with_account_access(0, gas_costs), Opcodes.CREATE2: cls._with_memory_expansion( lambda op: cls._calculate_create2_gas(op, gas_costs), @@ -2680,7 +2728,7 @@ def opcode_gas_map( return { **base_map, # EIP-4844: Shard Blob Transactions - Opcodes.BLOBHASH: gas_costs.GAS_VERY_LOW, + Opcodes.BLOBHASH: gas_costs.GAS_OPCODE_BLOBHASH, # EIP-7516: BLOBBASEFEE opcode Opcodes.BLOBBASEFEE: gas_costs.GAS_BASE, # EIP-1153: Transient storage opcodes @@ -2688,7 +2736,7 @@ def opcode_gas_map( Opcodes.TSTORE: gas_costs.GAS_WARM_SLOAD, # EIP-5656: MCOPY - Memory copying instruction Opcodes.MCOPY: cls._with_memory_expansion( - cls._with_data_copy(gas_costs.GAS_VERY_LOW, gas_costs), + cls._with_data_copy(gas_costs.GAS_OPCODE_MCOPY, gas_costs), memory_expansion_calculator, ), } @@ -3150,7 +3198,7 @@ def opcode_gas_map( ) return { **base_map, - Opcodes.CLZ: gas_costs.GAS_LOW, + Opcodes.CLZ: gas_costs.GAS_OPCODE_CLZ, } @classmethod diff --git a/packages/testing/src/execution_testing/forks/gas_costs.py b/packages/testing/src/execution_testing/forks/gas_costs.py index eb632dd0888..f7bb3727771 100644 --- a/packages/testing/src/execution_testing/forks/gas_costs.py +++ b/packages/testing/src/execution_testing/forks/gas_costs.py @@ -91,3 +91,44 @@ class GasCosts: REFUND_AUTH_PER_EXISTING_ACCOUNT: int GAS_BLOCK_ACCESS_LIST_ITEM: int + + # Opcode specific gas constants for repricing + GAS_OPCODE_ADD: int + GAS_OPCODE_SUB: int + GAS_OPCODE_MUL: int + GAS_OPCODE_DIV: int + GAS_OPCODE_SDIV: int + GAS_OPCODE_MOD: int + GAS_OPCODE_SMOD: int + GAS_OPCODE_ADDMOD: int + GAS_OPCODE_MULMOD: int + GAS_OPCODE_SIGNEXTEND: int + GAS_OPCODE_LT: int + GAS_OPCODE_GT: int + GAS_OPCODE_SLT: int + GAS_OPCODE_SGT: int + GAS_OPCODE_EQ: int + GAS_OPCODE_ISZERO: int + GAS_OPCODE_AND: int + GAS_OPCODE_OR: int + GAS_OPCODE_XOR: int + GAS_OPCODE_NOT: int + GAS_OPCODE_BYTE: int + GAS_OPCODE_SHL: int + GAS_OPCODE_SHR: int + GAS_OPCODE_SAR: int + GAS_OPCODE_CLZ: int + GAS_OPCODE_BLOBHASH: int + GAS_OPCODE_JUMP: int + GAS_OPCODE_JUMPI: int + GAS_OPCODE_CALLDATALOAD: int + GAS_OPCODE_CALLDATACOPY: int + GAS_OPCODE_CODECOPY: int + GAS_OPCODE_RETURNDATACOPY: int + GAS_OPCODE_MLOAD: int + GAS_OPCODE_MSTORE: int + GAS_OPCODE_MSTORE8: int + GAS_OPCODE_MCOPY: int + GAS_OPCODE_PUSH_N: int + GAS_OPCODE_DUP_N: int + GAS_OPCODE_SWAP_N: int From 4fb062e62cc4f1e0f359239a3a49dc263834d257 Mon Sep 17 00:00:00 2001 From: carsons-eels Date: Mon, 9 Mar 2026 22:44:20 -0400 Subject: [PATCH 4/7] refactor: move post-frontier opcodes --- .../execution_testing/forks/forks/forks.py | 25 +++++++++++++------ .../src/execution_testing/forks/gas_costs.py | 16 ++++++------ 2 files changed, 27 insertions(+), 14 deletions(-) diff --git a/packages/testing/src/execution_testing/forks/forks/forks.py b/packages/testing/src/execution_testing/forks/forks/forks.py index 97df3bc3edb..a9fb21ea910 100644 --- a/packages/testing/src/execution_testing/forks/forks/forks.py +++ b/packages/testing/src/execution_testing/forks/forks/forks.py @@ -223,21 +223,14 @@ def gas_costs( GAS_OPCODE_XOR=3, GAS_OPCODE_NOT=3, GAS_OPCODE_BYTE=3, - GAS_OPCODE_SHL=3, - GAS_OPCODE_SHR=3, - GAS_OPCODE_SAR=3, - GAS_OPCODE_CLZ=5, - GAS_OPCODE_BLOBHASH=3, GAS_OPCODE_JUMP=8, GAS_OPCODE_JUMPI=10, GAS_OPCODE_CALLDATALOAD=3, GAS_OPCODE_CALLDATACOPY=3, GAS_OPCODE_CODECOPY=3, - GAS_OPCODE_RETURNDATACOPY=3, GAS_OPCODE_MLOAD=3, GAS_OPCODE_MSTORE=3, GAS_OPCODE_MSTORE8=3, - GAS_OPCODE_MCOPY=3, GAS_OPCODE_PUSH_N=3, GAS_OPCODE_DUP_N=3, GAS_OPCODE_SWAP_N=3, @@ -1778,6 +1771,7 @@ def gas_costs( GAS_PRECOMPILE_ECMUL=40_000, GAS_PRECOMPILE_ECPAIRING_BASE=100_000, GAS_PRECOMPILE_ECPAIRING_PER_POINT=80_000, + GAS_OPCODE_RETURNDATACOPY=3, ) @@ -1816,6 +1810,20 @@ def create_opcodes( block_number=block_number, timestamp=timestamp ) + @classmethod + def gas_costs( + cls, *, block_number: int = 0, timestamp: int = 0 + ) -> GasCosts: + """At Constantinople, shift opcodes are introduced.""" + return replace( + super(Constantinople, cls).gas_costs( + block_number=block_number, timestamp=timestamp + ), + GAS_OPCODE_SHL=3, + GAS_OPCODE_SHR=3, + GAS_OPCODE_SAR=3, + ) + @classmethod def opcode_gas_map( cls, *, block_number: int = 0, timestamp: int = 0 @@ -2700,6 +2708,8 @@ def gas_costs( block_number=block_number, timestamp=timestamp ), GAS_PRECOMPILE_POINT_EVALUATION=50_000, + GAS_OPCODE_BLOBHASH=3, + GAS_OPCODE_MCOPY=3, ) @classmethod @@ -2829,6 +2839,7 @@ def gas_costs( GAS_PRECOMPILE_BLS_G2MAP=23_800, GAS_PRECOMPILE_BLS_PAIRING_BASE=37_700, GAS_PRECOMPILE_BLS_PAIRING_PER_PAIR=32_600, + GAS_OPCODE_CLZ=5, ) @classmethod diff --git a/packages/testing/src/execution_testing/forks/gas_costs.py b/packages/testing/src/execution_testing/forks/gas_costs.py index f7bb3727771..2bd1997042d 100644 --- a/packages/testing/src/execution_testing/forks/gas_costs.py +++ b/packages/testing/src/execution_testing/forks/gas_costs.py @@ -114,21 +114,23 @@ class GasCosts: GAS_OPCODE_XOR: int GAS_OPCODE_NOT: int GAS_OPCODE_BYTE: int - GAS_OPCODE_SHL: int - GAS_OPCODE_SHR: int - GAS_OPCODE_SAR: int - GAS_OPCODE_CLZ: int - GAS_OPCODE_BLOBHASH: int GAS_OPCODE_JUMP: int GAS_OPCODE_JUMPI: int GAS_OPCODE_CALLDATALOAD: int GAS_OPCODE_CALLDATACOPY: int GAS_OPCODE_CODECOPY: int - GAS_OPCODE_RETURNDATACOPY: int GAS_OPCODE_MLOAD: int GAS_OPCODE_MSTORE: int GAS_OPCODE_MSTORE8: int - GAS_OPCODE_MCOPY: int GAS_OPCODE_PUSH_N: int GAS_OPCODE_DUP_N: int GAS_OPCODE_SWAP_N: int + + # Defined post-Frontier + GAS_OPCODE_SHL: int = 0 + GAS_OPCODE_SHR: int = 0 + GAS_OPCODE_SAR: int = 0 + GAS_OPCODE_RETURNDATACOPY: int = 0 + GAS_OPCODE_BLOBHASH: int = 0 + GAS_OPCODE_MCOPY: int = 0 + GAS_OPCODE_CLZ: int = 0 From 7aad8e3b2aace31aa728d89b703fd0d4ce199286 Mon Sep 17 00:00:00 2001 From: carsons-eels Date: Mon, 9 Mar 2026 23:26:18 -0400 Subject: [PATCH 5/7] refactor: added gas tiers for the test code --- .../execution_testing/forks/forks/forks.py | 86 ++++++++++--------- .../src/execution_testing/forks/gas_costs.py | 6 ++ 2 files changed, 52 insertions(+), 40 deletions(-) diff --git a/packages/testing/src/execution_testing/forks/forks/forks.py b/packages/testing/src/execution_testing/forks/forks/forks.py index a9fb21ea910..b504aaba038 100644 --- a/packages/testing/src/execution_testing/forks/forks/forks.py +++ b/packages/testing/src/execution_testing/forks/forks/forks.py @@ -46,7 +46,13 @@ TransactionDataFloorCostCalculator, TransactionIntrinsicCostCalculator, ) -from ..gas_costs import GasCosts +from ..gas_costs import ( + GAS_HIGH, + GAS_LOW, + GAS_MID, + GAS_VERY_LOW, + GasCosts, +) from .helpers import ceiling_division, fake_exponential CURRENT_FILE = Path(realpath(__file__)) @@ -202,38 +208,38 @@ def gas_costs( GAS_PRECOMPILE_P256VERIFY=0, GAS_BLOCK_ACCESS_LIST_ITEM=0, # Opcode specific gas constants for repricing - GAS_OPCODE_ADD=3, - GAS_OPCODE_SUB=3, - GAS_OPCODE_MUL=5, - GAS_OPCODE_DIV=5, - GAS_OPCODE_SDIV=5, - GAS_OPCODE_MOD=5, - GAS_OPCODE_SMOD=5, - GAS_OPCODE_ADDMOD=8, - GAS_OPCODE_MULMOD=8, - GAS_OPCODE_SIGNEXTEND=5, - GAS_OPCODE_LT=3, - GAS_OPCODE_GT=3, - GAS_OPCODE_SLT=3, - GAS_OPCODE_SGT=3, - GAS_OPCODE_EQ=3, - GAS_OPCODE_ISZERO=3, - GAS_OPCODE_AND=3, - GAS_OPCODE_OR=3, - GAS_OPCODE_XOR=3, - GAS_OPCODE_NOT=3, - GAS_OPCODE_BYTE=3, - GAS_OPCODE_JUMP=8, - GAS_OPCODE_JUMPI=10, - GAS_OPCODE_CALLDATALOAD=3, - GAS_OPCODE_CALLDATACOPY=3, - GAS_OPCODE_CODECOPY=3, - GAS_OPCODE_MLOAD=3, - GAS_OPCODE_MSTORE=3, - GAS_OPCODE_MSTORE8=3, - GAS_OPCODE_PUSH_N=3, - GAS_OPCODE_DUP_N=3, - GAS_OPCODE_SWAP_N=3, + GAS_OPCODE_ADD=GAS_VERY_LOW, + GAS_OPCODE_SUB=GAS_VERY_LOW, + GAS_OPCODE_MUL=GAS_LOW, + GAS_OPCODE_DIV=GAS_LOW, + GAS_OPCODE_SDIV=GAS_LOW, + GAS_OPCODE_MOD=GAS_LOW, + GAS_OPCODE_SMOD=GAS_LOW, + GAS_OPCODE_ADDMOD=GAS_MID, + GAS_OPCODE_MULMOD=GAS_MID, + GAS_OPCODE_SIGNEXTEND=GAS_LOW, + GAS_OPCODE_LT=GAS_VERY_LOW, + GAS_OPCODE_GT=GAS_VERY_LOW, + GAS_OPCODE_SLT=GAS_VERY_LOW, + GAS_OPCODE_SGT=GAS_VERY_LOW, + GAS_OPCODE_EQ=GAS_VERY_LOW, + GAS_OPCODE_ISZERO=GAS_VERY_LOW, + GAS_OPCODE_AND=GAS_VERY_LOW, + GAS_OPCODE_OR=GAS_VERY_LOW, + GAS_OPCODE_XOR=GAS_VERY_LOW, + GAS_OPCODE_NOT=GAS_VERY_LOW, + GAS_OPCODE_BYTE=GAS_VERY_LOW, + GAS_OPCODE_JUMP=GAS_MID, + GAS_OPCODE_JUMPI=GAS_HIGH, + GAS_OPCODE_CALLDATALOAD=GAS_VERY_LOW, + GAS_OPCODE_CALLDATACOPY=GAS_VERY_LOW, + GAS_OPCODE_CODECOPY=GAS_VERY_LOW, + GAS_OPCODE_MLOAD=GAS_VERY_LOW, + GAS_OPCODE_MSTORE=GAS_VERY_LOW, + GAS_OPCODE_MSTORE8=GAS_VERY_LOW, + GAS_OPCODE_PUSH_N=GAS_VERY_LOW, + GAS_OPCODE_DUP_N=GAS_VERY_LOW, + GAS_OPCODE_SWAP_N=GAS_VERY_LOW, ) @classmethod @@ -1771,7 +1777,7 @@ def gas_costs( GAS_PRECOMPILE_ECMUL=40_000, GAS_PRECOMPILE_ECPAIRING_BASE=100_000, GAS_PRECOMPILE_ECPAIRING_PER_POINT=80_000, - GAS_OPCODE_RETURNDATACOPY=3, + GAS_OPCODE_RETURNDATACOPY=GAS_VERY_LOW, ) @@ -1819,9 +1825,9 @@ def gas_costs( super(Constantinople, cls).gas_costs( block_number=block_number, timestamp=timestamp ), - GAS_OPCODE_SHL=3, - GAS_OPCODE_SHR=3, - GAS_OPCODE_SAR=3, + GAS_OPCODE_SHL=GAS_VERY_LOW, + GAS_OPCODE_SHR=GAS_VERY_LOW, + GAS_OPCODE_SAR=GAS_VERY_LOW, ) @classmethod @@ -2708,8 +2714,8 @@ def gas_costs( block_number=block_number, timestamp=timestamp ), GAS_PRECOMPILE_POINT_EVALUATION=50_000, - GAS_OPCODE_BLOBHASH=3, - GAS_OPCODE_MCOPY=3, + GAS_OPCODE_BLOBHASH=GAS_VERY_LOW, + GAS_OPCODE_MCOPY=GAS_VERY_LOW, ) @classmethod @@ -2839,7 +2845,7 @@ def gas_costs( GAS_PRECOMPILE_BLS_G2MAP=23_800, GAS_PRECOMPILE_BLS_PAIRING_BASE=37_700, GAS_PRECOMPILE_BLS_PAIRING_PER_PAIR=32_600, - GAS_OPCODE_CLZ=5, + GAS_OPCODE_CLZ=GAS_LOW, ) @classmethod diff --git a/packages/testing/src/execution_testing/forks/gas_costs.py b/packages/testing/src/execution_testing/forks/gas_costs.py index 2bd1997042d..5ef97ce3e99 100644 --- a/packages/testing/src/execution_testing/forks/gas_costs.py +++ b/packages/testing/src/execution_testing/forks/gas_costs.py @@ -2,6 +2,12 @@ from dataclasses import dataclass +# Common Gas Cost Tiers +GAS_VERY_LOW = 3 +GAS_LOW = 5 +GAS_MID = 8 +GAS_HIGH = 10 + @dataclass(kw_only=True, frozen=True) class GasCosts: From 799cf49bceb82d8c8e43de2df116a3fe017f09d8 Mon Sep 17 00:00:00 2001 From: carsons-eels Date: Tue, 10 Mar 2026 00:58:18 -0400 Subject: [PATCH 6/7] refactor: use gas module refs for opcode constants --- .../amsterdam/vm/instructions/arithmetic.py | 32 +++++++------------ .../amsterdam/vm/instructions/bitwise.py | 29 ++++++----------- .../amsterdam/vm/instructions/comparison.py | 20 ++++-------- .../amsterdam/vm/instructions/control_flow.py | 7 ++-- .../amsterdam/vm/instructions/environment.py | 14 +++----- .../forks/amsterdam/vm/instructions/memory.py | 14 +++----- .../forks/amsterdam/vm/instructions/stack.py | 11 +++---- .../vm/instructions/arithmetic.py | 32 +++++++------------ .../arrow_glacier/vm/instructions/bitwise.py | 26 ++++++--------- .../vm/instructions/comparison.py | 20 ++++-------- .../vm/instructions/control_flow.py | 7 ++-- .../vm/instructions/environment.py | 14 +++----- .../arrow_glacier/vm/instructions/memory.py | 11 +++---- .../arrow_glacier/vm/instructions/stack.py | 11 +++---- .../berlin/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/berlin/vm/instructions/bitwise.py | 26 ++++++--------- .../berlin/vm/instructions/comparison.py | 20 ++++-------- .../berlin/vm/instructions/control_flow.py | 7 ++-- .../berlin/vm/instructions/environment.py | 14 +++----- .../forks/berlin/vm/instructions/memory.py | 11 +++---- .../forks/berlin/vm/instructions/stack.py | 11 +++---- .../forks/bpo1/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/bpo1/vm/instructions/bitwise.py | 29 ++++++----------- .../forks/bpo1/vm/instructions/comparison.py | 20 ++++-------- .../bpo1/vm/instructions/control_flow.py | 7 ++-- .../forks/bpo1/vm/instructions/environment.py | 14 +++----- .../forks/bpo1/vm/instructions/memory.py | 14 +++----- .../forks/bpo1/vm/instructions/stack.py | 11 +++---- .../forks/bpo2/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/bpo2/vm/instructions/bitwise.py | 29 ++++++----------- .../forks/bpo2/vm/instructions/comparison.py | 20 ++++-------- .../bpo2/vm/instructions/control_flow.py | 7 ++-- .../forks/bpo2/vm/instructions/environment.py | 14 +++----- .../forks/bpo2/vm/instructions/memory.py | 14 +++----- .../forks/bpo2/vm/instructions/stack.py | 11 +++---- .../forks/bpo3/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/bpo3/vm/instructions/bitwise.py | 29 ++++++----------- .../forks/bpo3/vm/instructions/comparison.py | 20 ++++-------- .../bpo3/vm/instructions/control_flow.py | 7 ++-- .../forks/bpo3/vm/instructions/environment.py | 14 +++----- .../forks/bpo3/vm/instructions/memory.py | 14 +++----- .../forks/bpo3/vm/instructions/stack.py | 11 +++---- .../forks/bpo4/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/bpo4/vm/instructions/bitwise.py | 29 ++++++----------- .../forks/bpo4/vm/instructions/comparison.py | 20 ++++-------- .../bpo4/vm/instructions/control_flow.py | 7 ++-- .../forks/bpo4/vm/instructions/environment.py | 14 +++----- .../forks/bpo4/vm/instructions/memory.py | 14 +++----- .../forks/bpo4/vm/instructions/stack.py | 11 +++---- .../forks/bpo5/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/bpo5/vm/instructions/bitwise.py | 29 ++++++----------- .../forks/bpo5/vm/instructions/comparison.py | 20 ++++-------- .../bpo5/vm/instructions/control_flow.py | 7 ++-- .../forks/bpo5/vm/instructions/environment.py | 14 +++----- .../forks/bpo5/vm/instructions/memory.py | 14 +++----- .../forks/bpo5/vm/instructions/stack.py | 11 +++---- .../byzantium/vm/instructions/arithmetic.py | 32 +++++++------------ .../byzantium/vm/instructions/bitwise.py | 17 ++++------ .../byzantium/vm/instructions/comparison.py | 20 ++++-------- .../byzantium/vm/instructions/control_flow.py | 7 ++-- .../byzantium/vm/instructions/environment.py | 14 +++----- .../forks/byzantium/vm/instructions/memory.py | 11 +++---- .../forks/byzantium/vm/instructions/stack.py | 11 +++---- .../cancun/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/cancun/vm/instructions/bitwise.py | 26 ++++++--------- .../cancun/vm/instructions/comparison.py | 20 ++++-------- .../cancun/vm/instructions/control_flow.py | 7 ++-- .../cancun/vm/instructions/environment.py | 14 +++----- .../forks/cancun/vm/instructions/memory.py | 14 +++----- .../forks/cancun/vm/instructions/stack.py | 11 +++---- .../vm/instructions/arithmetic.py | 32 +++++++------------ .../constantinople/vm/instructions/bitwise.py | 26 ++++++--------- .../vm/instructions/comparison.py | 20 ++++-------- .../vm/instructions/control_flow.py | 7 ++-- .../vm/instructions/environment.py | 14 +++----- .../constantinople/vm/instructions/memory.py | 11 +++---- .../constantinople/vm/instructions/stack.py | 11 +++---- .../dao_fork/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/dao_fork/vm/instructions/bitwise.py | 17 ++++------ .../dao_fork/vm/instructions/comparison.py | 20 ++++-------- .../dao_fork/vm/instructions/control_flow.py | 7 ++-- .../dao_fork/vm/instructions/environment.py | 11 +++---- .../forks/dao_fork/vm/instructions/memory.py | 11 +++---- .../forks/dao_fork/vm/instructions/stack.py | 11 +++---- .../frontier/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/frontier/vm/instructions/bitwise.py | 17 ++++------ .../frontier/vm/instructions/comparison.py | 20 ++++-------- .../frontier/vm/instructions/control_flow.py | 7 ++-- .../frontier/vm/instructions/environment.py | 11 +++---- .../forks/frontier/vm/instructions/memory.py | 11 +++---- .../forks/frontier/vm/instructions/stack.py | 11 +++---- .../vm/instructions/arithmetic.py | 32 +++++++------------ .../gray_glacier/vm/instructions/bitwise.py | 26 ++++++--------- .../vm/instructions/comparison.py | 20 ++++-------- .../vm/instructions/control_flow.py | 7 ++-- .../vm/instructions/environment.py | 14 +++----- .../gray_glacier/vm/instructions/memory.py | 11 +++---- .../gray_glacier/vm/instructions/stack.py | 11 +++---- .../homestead/vm/instructions/arithmetic.py | 32 +++++++------------ .../homestead/vm/instructions/bitwise.py | 17 ++++------ .../homestead/vm/instructions/comparison.py | 20 ++++-------- .../homestead/vm/instructions/control_flow.py | 7 ++-- .../homestead/vm/instructions/environment.py | 11 +++---- .../forks/homestead/vm/instructions/memory.py | 11 +++---- .../forks/homestead/vm/instructions/stack.py | 11 +++---- .../istanbul/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/istanbul/vm/instructions/bitwise.py | 26 ++++++--------- .../istanbul/vm/instructions/comparison.py | 20 ++++-------- .../istanbul/vm/instructions/control_flow.py | 7 ++-- .../istanbul/vm/instructions/environment.py | 14 +++----- .../forks/istanbul/vm/instructions/memory.py | 11 +++---- .../forks/istanbul/vm/instructions/stack.py | 11 +++---- .../london/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/london/vm/instructions/bitwise.py | 26 ++++++--------- .../london/vm/instructions/comparison.py | 20 ++++-------- .../london/vm/instructions/control_flow.py | 7 ++-- .../london/vm/instructions/environment.py | 14 +++----- .../forks/london/vm/instructions/memory.py | 11 +++---- .../forks/london/vm/instructions/stack.py | 11 +++---- .../vm/instructions/arithmetic.py | 32 +++++++------------ .../muir_glacier/vm/instructions/bitwise.py | 26 ++++++--------- .../vm/instructions/comparison.py | 20 ++++-------- .../vm/instructions/control_flow.py | 7 ++-- .../vm/instructions/environment.py | 14 +++----- .../muir_glacier/vm/instructions/memory.py | 11 +++---- .../muir_glacier/vm/instructions/stack.py | 11 +++---- .../forks/osaka/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/osaka/vm/instructions/bitwise.py | 29 ++++++----------- .../forks/osaka/vm/instructions/comparison.py | 20 ++++-------- .../osaka/vm/instructions/control_flow.py | 7 ++-- .../osaka/vm/instructions/environment.py | 14 +++----- .../forks/osaka/vm/instructions/memory.py | 14 +++----- .../forks/osaka/vm/instructions/stack.py | 11 +++---- .../forks/paris/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/paris/vm/instructions/bitwise.py | 26 ++++++--------- .../forks/paris/vm/instructions/comparison.py | 20 ++++-------- .../paris/vm/instructions/control_flow.py | 7 ++-- .../paris/vm/instructions/environment.py | 14 +++----- .../forks/paris/vm/instructions/memory.py | 11 +++---- .../forks/paris/vm/instructions/stack.py | 11 +++---- .../prague/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/prague/vm/instructions/bitwise.py | 26 ++++++--------- .../prague/vm/instructions/comparison.py | 20 ++++-------- .../prague/vm/instructions/control_flow.py | 7 ++-- .../prague/vm/instructions/environment.py | 14 +++----- .../forks/prague/vm/instructions/memory.py | 14 +++----- .../forks/prague/vm/instructions/stack.py | 11 +++---- .../shanghai/vm/instructions/arithmetic.py | 32 +++++++------------ .../forks/shanghai/vm/instructions/bitwise.py | 26 ++++++--------- .../shanghai/vm/instructions/comparison.py | 20 ++++-------- .../shanghai/vm/instructions/control_flow.py | 7 ++-- .../shanghai/vm/instructions/environment.py | 14 +++----- .../forks/shanghai/vm/instructions/memory.py | 11 +++---- .../forks/shanghai/vm/instructions/stack.py | 11 +++---- .../vm/instructions/arithmetic.py | 32 +++++++------------ .../vm/instructions/bitwise.py | 17 ++++------ .../vm/instructions/comparison.py | 20 ++++-------- .../vm/instructions/control_flow.py | 7 ++-- .../vm/instructions/environment.py | 11 +++---- .../spurious_dragon/vm/instructions/memory.py | 11 +++---- .../spurious_dragon/vm/instructions/stack.py | 11 +++---- .../vm/instructions/arithmetic.py | 32 +++++++------------ .../vm/instructions/bitwise.py | 17 ++++------ .../vm/instructions/comparison.py | 20 ++++-------- .../vm/instructions/control_flow.py | 7 ++-- .../vm/instructions/environment.py | 11 +++---- .../vm/instructions/memory.py | 11 +++---- .../vm/instructions/stack.py | 11 +++---- 168 files changed, 1025 insertions(+), 1858 deletions(-) diff --git a/src/ethereum/forks/amsterdam/vm/instructions/arithmetic.py b/src/ethereum/forks/amsterdam/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/amsterdam/vm/instructions/bitwise.py b/src/ethereum/forks/amsterdam/vm/instructions/bitwise.py index 0614ff61fed..3cb188b8579 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/bitwise.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/bitwise.py @@ -13,17 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_CLZ, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -45,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -70,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -95,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -119,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -145,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -180,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -210,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -240,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -273,7 +264,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CLZ) + charge_gas(evm, gas.GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/amsterdam/vm/instructions/comparison.py b/src/ethereum/forks/amsterdam/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/comparison.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/amsterdam/vm/instructions/control_flow.py b/src/ethereum/forks/amsterdam/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/control_flow.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/amsterdam/vm/instructions/environment.py b/src/ethereum/forks/amsterdam/vm/instructions/environment.py index ea48276dd30..3e2a9e053c8 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/environment.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/environment.py @@ -20,7 +20,7 @@ from ...state_tracker import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, @@ -28,10 +28,6 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_blob_gas_price, @@ -181,7 +177,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -241,7 +237,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -302,7 +298,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -465,7 +461,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/amsterdam/vm/instructions/memory.py b/src/ethereum/forks/amsterdam/vm/instructions/memory.py index 1e650339074..bccc5fd6f01 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/memory.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/memory.py @@ -16,14 +16,10 @@ from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, GAS_COPY, - GAS_OPCODE_MCOPY, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -52,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -83,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -111,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -171,7 +167,7 @@ def mcopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/amsterdam/vm/instructions/stack.py b/src/ethereum/forks/amsterdam/vm/instructions/stack.py index a58e1e66e3f..3aaadbf69ab 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/stack.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -71,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -101,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -133,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/arithmetic.py b/src/ethereum/forks/arrow_glacier/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/bitwise.py b/src/ethereum/forks/arrow_glacier/vm/instructions/bitwise.py index 4e36a1a7959..4e0a487a749 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/bitwise.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/bitwise.py @@ -13,16 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -44,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -69,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -94,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -118,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -144,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -179,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -209,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -239,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/comparison.py b/src/ethereum/forks/arrow_glacier/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/comparison.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/control_flow.py b/src/ethereum/forks/arrow_glacier/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/control_flow.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/environment.py b/src/ethereum/forks/arrow_glacier/vm/instructions/environment.py index c7018574c29..31b236e66ca 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/environment.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/environment.py @@ -19,17 +19,13 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_gas_extend_memory, @@ -176,7 +172,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -236,7 +232,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -297,7 +293,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -454,7 +450,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/memory.py b/src/ethereum/forks/arrow_glacier/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/memory.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/stack.py b/src/ethereum/forks/arrow_glacier/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/stack.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/berlin/vm/instructions/arithmetic.py b/src/ethereum/forks/berlin/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/berlin/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/berlin/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/berlin/vm/instructions/bitwise.py b/src/ethereum/forks/berlin/vm/instructions/bitwise.py index 4e36a1a7959..4e0a487a749 100644 --- a/src/ethereum/forks/berlin/vm/instructions/bitwise.py +++ b/src/ethereum/forks/berlin/vm/instructions/bitwise.py @@ -13,16 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -44,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -69,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -94,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -118,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -144,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -179,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -209,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -239,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/berlin/vm/instructions/comparison.py b/src/ethereum/forks/berlin/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/berlin/vm/instructions/comparison.py +++ b/src/ethereum/forks/berlin/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/berlin/vm/instructions/control_flow.py b/src/ethereum/forks/berlin/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/berlin/vm/instructions/control_flow.py +++ b/src/ethereum/forks/berlin/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/berlin/vm/instructions/environment.py b/src/ethereum/forks/berlin/vm/instructions/environment.py index 8798f5a4b7b..c2770cd8fa4 100644 --- a/src/ethereum/forks/berlin/vm/instructions/environment.py +++ b/src/ethereum/forks/berlin/vm/instructions/environment.py @@ -19,17 +19,13 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_gas_extend_memory, @@ -176,7 +172,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -236,7 +232,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -297,7 +293,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -454,7 +450,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/berlin/vm/instructions/memory.py b/src/ethereum/forks/berlin/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/berlin/vm/instructions/memory.py +++ b/src/ethereum/forks/berlin/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/berlin/vm/instructions/stack.py b/src/ethereum/forks/berlin/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/berlin/vm/instructions/stack.py +++ b/src/ethereum/forks/berlin/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/bpo1/vm/instructions/arithmetic.py b/src/ethereum/forks/bpo1/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/bpo1/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/bpo1/vm/instructions/bitwise.py b/src/ethereum/forks/bpo1/vm/instructions/bitwise.py index 0614ff61fed..3cb188b8579 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/bitwise.py +++ b/src/ethereum/forks/bpo1/vm/instructions/bitwise.py @@ -13,17 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_CLZ, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -45,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -70,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -95,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -119,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -145,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -180,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -210,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -240,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -273,7 +264,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CLZ) + charge_gas(evm, gas.GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/bpo1/vm/instructions/comparison.py b/src/ethereum/forks/bpo1/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/comparison.py +++ b/src/ethereum/forks/bpo1/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/bpo1/vm/instructions/control_flow.py b/src/ethereum/forks/bpo1/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/control_flow.py +++ b/src/ethereum/forks/bpo1/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/bpo1/vm/instructions/environment.py b/src/ethereum/forks/bpo1/vm/instructions/environment.py index 7a2f15c7001..936297a73a6 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo1/vm/instructions/environment.py @@ -20,7 +20,7 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, @@ -28,10 +28,6 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_blob_gas_price, @@ -179,7 +175,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -239,7 +235,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -300,7 +296,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -457,7 +453,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/bpo1/vm/instructions/memory.py b/src/ethereum/forks/bpo1/vm/instructions/memory.py index 1e650339074..bccc5fd6f01 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/memory.py +++ b/src/ethereum/forks/bpo1/vm/instructions/memory.py @@ -16,14 +16,10 @@ from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, GAS_COPY, - GAS_OPCODE_MCOPY, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -52,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -83,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -111,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -171,7 +167,7 @@ def mcopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/bpo1/vm/instructions/stack.py b/src/ethereum/forks/bpo1/vm/instructions/stack.py index a58e1e66e3f..3aaadbf69ab 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/stack.py +++ b/src/ethereum/forks/bpo1/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -71,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -101,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -133,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/bpo2/vm/instructions/arithmetic.py b/src/ethereum/forks/bpo2/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/bpo2/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/bpo2/vm/instructions/bitwise.py b/src/ethereum/forks/bpo2/vm/instructions/bitwise.py index 0614ff61fed..3cb188b8579 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/bitwise.py +++ b/src/ethereum/forks/bpo2/vm/instructions/bitwise.py @@ -13,17 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_CLZ, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -45,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -70,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -95,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -119,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -145,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -180,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -210,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -240,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -273,7 +264,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CLZ) + charge_gas(evm, gas.GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/bpo2/vm/instructions/comparison.py b/src/ethereum/forks/bpo2/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/comparison.py +++ b/src/ethereum/forks/bpo2/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/bpo2/vm/instructions/control_flow.py b/src/ethereum/forks/bpo2/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/control_flow.py +++ b/src/ethereum/forks/bpo2/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/bpo2/vm/instructions/environment.py b/src/ethereum/forks/bpo2/vm/instructions/environment.py index 7a2f15c7001..936297a73a6 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo2/vm/instructions/environment.py @@ -20,7 +20,7 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, @@ -28,10 +28,6 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_blob_gas_price, @@ -179,7 +175,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -239,7 +235,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -300,7 +296,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -457,7 +453,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/bpo2/vm/instructions/memory.py b/src/ethereum/forks/bpo2/vm/instructions/memory.py index 1e650339074..bccc5fd6f01 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/memory.py +++ b/src/ethereum/forks/bpo2/vm/instructions/memory.py @@ -16,14 +16,10 @@ from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, GAS_COPY, - GAS_OPCODE_MCOPY, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -52,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -83,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -111,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -171,7 +167,7 @@ def mcopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/bpo2/vm/instructions/stack.py b/src/ethereum/forks/bpo2/vm/instructions/stack.py index a58e1e66e3f..3aaadbf69ab 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/stack.py +++ b/src/ethereum/forks/bpo2/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -71,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -101,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -133,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/bpo3/vm/instructions/arithmetic.py b/src/ethereum/forks/bpo3/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/bpo3/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/bpo3/vm/instructions/bitwise.py b/src/ethereum/forks/bpo3/vm/instructions/bitwise.py index 0614ff61fed..3cb188b8579 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/bitwise.py +++ b/src/ethereum/forks/bpo3/vm/instructions/bitwise.py @@ -13,17 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_CLZ, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -45,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -70,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -95,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -119,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -145,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -180,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -210,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -240,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -273,7 +264,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CLZ) + charge_gas(evm, gas.GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/bpo3/vm/instructions/comparison.py b/src/ethereum/forks/bpo3/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/comparison.py +++ b/src/ethereum/forks/bpo3/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/bpo3/vm/instructions/control_flow.py b/src/ethereum/forks/bpo3/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/control_flow.py +++ b/src/ethereum/forks/bpo3/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/bpo3/vm/instructions/environment.py b/src/ethereum/forks/bpo3/vm/instructions/environment.py index 7a2f15c7001..936297a73a6 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo3/vm/instructions/environment.py @@ -20,7 +20,7 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, @@ -28,10 +28,6 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_blob_gas_price, @@ -179,7 +175,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -239,7 +235,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -300,7 +296,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -457,7 +453,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/bpo3/vm/instructions/memory.py b/src/ethereum/forks/bpo3/vm/instructions/memory.py index 1e650339074..bccc5fd6f01 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/memory.py +++ b/src/ethereum/forks/bpo3/vm/instructions/memory.py @@ -16,14 +16,10 @@ from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, GAS_COPY, - GAS_OPCODE_MCOPY, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -52,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -83,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -111,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -171,7 +167,7 @@ def mcopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/bpo3/vm/instructions/stack.py b/src/ethereum/forks/bpo3/vm/instructions/stack.py index a58e1e66e3f..3aaadbf69ab 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/stack.py +++ b/src/ethereum/forks/bpo3/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -71,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -101,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -133,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/bpo4/vm/instructions/arithmetic.py b/src/ethereum/forks/bpo4/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/bpo4/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/bpo4/vm/instructions/bitwise.py b/src/ethereum/forks/bpo4/vm/instructions/bitwise.py index 0614ff61fed..3cb188b8579 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/bitwise.py +++ b/src/ethereum/forks/bpo4/vm/instructions/bitwise.py @@ -13,17 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_CLZ, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -45,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -70,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -95,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -119,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -145,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -180,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -210,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -240,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -273,7 +264,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CLZ) + charge_gas(evm, gas.GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/bpo4/vm/instructions/comparison.py b/src/ethereum/forks/bpo4/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/comparison.py +++ b/src/ethereum/forks/bpo4/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/bpo4/vm/instructions/control_flow.py b/src/ethereum/forks/bpo4/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/control_flow.py +++ b/src/ethereum/forks/bpo4/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/bpo4/vm/instructions/environment.py b/src/ethereum/forks/bpo4/vm/instructions/environment.py index 7a2f15c7001..936297a73a6 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo4/vm/instructions/environment.py @@ -20,7 +20,7 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, @@ -28,10 +28,6 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_blob_gas_price, @@ -179,7 +175,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -239,7 +235,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -300,7 +296,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -457,7 +453,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/bpo4/vm/instructions/memory.py b/src/ethereum/forks/bpo4/vm/instructions/memory.py index 1e650339074..bccc5fd6f01 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/memory.py +++ b/src/ethereum/forks/bpo4/vm/instructions/memory.py @@ -16,14 +16,10 @@ from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, GAS_COPY, - GAS_OPCODE_MCOPY, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -52,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -83,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -111,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -171,7 +167,7 @@ def mcopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/bpo4/vm/instructions/stack.py b/src/ethereum/forks/bpo4/vm/instructions/stack.py index a58e1e66e3f..3aaadbf69ab 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/stack.py +++ b/src/ethereum/forks/bpo4/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -71,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -101,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -133,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/bpo5/vm/instructions/arithmetic.py b/src/ethereum/forks/bpo5/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/bpo5/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/bpo5/vm/instructions/bitwise.py b/src/ethereum/forks/bpo5/vm/instructions/bitwise.py index 0614ff61fed..3cb188b8579 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/bitwise.py +++ b/src/ethereum/forks/bpo5/vm/instructions/bitwise.py @@ -13,17 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_CLZ, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -45,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -70,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -95,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -119,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -145,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -180,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -210,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -240,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -273,7 +264,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CLZ) + charge_gas(evm, gas.GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/bpo5/vm/instructions/comparison.py b/src/ethereum/forks/bpo5/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/comparison.py +++ b/src/ethereum/forks/bpo5/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/bpo5/vm/instructions/control_flow.py b/src/ethereum/forks/bpo5/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/control_flow.py +++ b/src/ethereum/forks/bpo5/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/bpo5/vm/instructions/environment.py b/src/ethereum/forks/bpo5/vm/instructions/environment.py index 7a2f15c7001..936297a73a6 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/environment.py +++ b/src/ethereum/forks/bpo5/vm/instructions/environment.py @@ -20,7 +20,7 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, @@ -28,10 +28,6 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_blob_gas_price, @@ -179,7 +175,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -239,7 +235,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -300,7 +296,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -457,7 +453,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/bpo5/vm/instructions/memory.py b/src/ethereum/forks/bpo5/vm/instructions/memory.py index 1e650339074..bccc5fd6f01 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/memory.py +++ b/src/ethereum/forks/bpo5/vm/instructions/memory.py @@ -16,14 +16,10 @@ from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, GAS_COPY, - GAS_OPCODE_MCOPY, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -52,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -83,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -111,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -171,7 +167,7 @@ def mcopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/bpo5/vm/instructions/stack.py b/src/ethereum/forks/bpo5/vm/instructions/stack.py index a58e1e66e3f..3aaadbf69ab 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/stack.py +++ b/src/ethereum/forks/bpo5/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -71,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -101,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -133,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/byzantium/vm/instructions/arithmetic.py b/src/ethereum/forks/byzantium/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/byzantium/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/byzantium/vm/instructions/bitwise.py b/src/ethereum/forks/byzantium/vm/instructions/bitwise.py index cb37f6eca7d..476d71d7603 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/bitwise.py +++ b/src/ethereum/forks/byzantium/vm/instructions/bitwise.py @@ -13,13 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -41,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -66,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -91,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -115,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -141,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): diff --git a/src/ethereum/forks/byzantium/vm/instructions/comparison.py b/src/ethereum/forks/byzantium/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/comparison.py +++ b/src/ethereum/forks/byzantium/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/byzantium/vm/instructions/control_flow.py b/src/ethereum/forks/byzantium/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/control_flow.py +++ b/src/ethereum/forks/byzantium/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/byzantium/vm/instructions/environment.py b/src/ethereum/forks/byzantium/vm/instructions/environment.py index 2fb6855f846..9221133e41c 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/environment.py +++ b/src/ethereum/forks/byzantium/vm/instructions/environment.py @@ -18,17 +18,13 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BALANCE, GAS_BASE, GAS_COPY, GAS_EXTERNAL, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, calculate_gas_extend_memory, charge_gas, @@ -170,7 +166,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -230,7 +226,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -291,7 +287,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -435,7 +431,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/byzantium/vm/instructions/memory.py b/src/ethereum/forks/byzantium/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/memory.py +++ b/src/ethereum/forks/byzantium/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/byzantium/vm/instructions/stack.py b/src/ethereum/forks/byzantium/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/stack.py +++ b/src/ethereum/forks/byzantium/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/cancun/vm/instructions/arithmetic.py b/src/ethereum/forks/cancun/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/cancun/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/cancun/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/cancun/vm/instructions/bitwise.py b/src/ethereum/forks/cancun/vm/instructions/bitwise.py index 4e36a1a7959..4e0a487a749 100644 --- a/src/ethereum/forks/cancun/vm/instructions/bitwise.py +++ b/src/ethereum/forks/cancun/vm/instructions/bitwise.py @@ -13,16 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -44,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -69,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -94,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -118,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -144,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -179,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -209,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -239,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/cancun/vm/instructions/comparison.py b/src/ethereum/forks/cancun/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/cancun/vm/instructions/comparison.py +++ b/src/ethereum/forks/cancun/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/cancun/vm/instructions/control_flow.py b/src/ethereum/forks/cancun/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/cancun/vm/instructions/control_flow.py +++ b/src/ethereum/forks/cancun/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/cancun/vm/instructions/environment.py b/src/ethereum/forks/cancun/vm/instructions/environment.py index 7a2f15c7001..936297a73a6 100644 --- a/src/ethereum/forks/cancun/vm/instructions/environment.py +++ b/src/ethereum/forks/cancun/vm/instructions/environment.py @@ -20,7 +20,7 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, @@ -28,10 +28,6 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_blob_gas_price, @@ -179,7 +175,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -239,7 +235,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -300,7 +296,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -457,7 +453,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/cancun/vm/instructions/memory.py b/src/ethereum/forks/cancun/vm/instructions/memory.py index 1e650339074..bccc5fd6f01 100644 --- a/src/ethereum/forks/cancun/vm/instructions/memory.py +++ b/src/ethereum/forks/cancun/vm/instructions/memory.py @@ -16,14 +16,10 @@ from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, GAS_COPY, - GAS_OPCODE_MCOPY, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -52,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -83,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -111,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -171,7 +167,7 @@ def mcopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/cancun/vm/instructions/stack.py b/src/ethereum/forks/cancun/vm/instructions/stack.py index a58e1e66e3f..3aaadbf69ab 100644 --- a/src/ethereum/forks/cancun/vm/instructions/stack.py +++ b/src/ethereum/forks/cancun/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -71,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -101,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -133,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/constantinople/vm/instructions/arithmetic.py b/src/ethereum/forks/constantinople/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/constantinople/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/constantinople/vm/instructions/bitwise.py b/src/ethereum/forks/constantinople/vm/instructions/bitwise.py index 4e36a1a7959..4e0a487a749 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/bitwise.py +++ b/src/ethereum/forks/constantinople/vm/instructions/bitwise.py @@ -13,16 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -44,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -69,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -94,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -118,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -144,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -179,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -209,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -239,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/constantinople/vm/instructions/comparison.py b/src/ethereum/forks/constantinople/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/comparison.py +++ b/src/ethereum/forks/constantinople/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/constantinople/vm/instructions/control_flow.py b/src/ethereum/forks/constantinople/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/control_flow.py +++ b/src/ethereum/forks/constantinople/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/constantinople/vm/instructions/environment.py b/src/ethereum/forks/constantinople/vm/instructions/environment.py index f935b995c17..bcd2195bfdf 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/environment.py +++ b/src/ethereum/forks/constantinople/vm/instructions/environment.py @@ -19,7 +19,7 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BALANCE, @@ -27,10 +27,6 @@ GAS_CODE_HASH, GAS_COPY, GAS_EXTERNAL, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, calculate_gas_extend_memory, charge_gas, @@ -172,7 +168,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -232,7 +228,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -293,7 +289,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -437,7 +433,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/constantinople/vm/instructions/memory.py b/src/ethereum/forks/constantinople/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/memory.py +++ b/src/ethereum/forks/constantinople/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/constantinople/vm/instructions/stack.py b/src/ethereum/forks/constantinople/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/stack.py +++ b/src/ethereum/forks/constantinople/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/dao_fork/vm/instructions/arithmetic.py b/src/ethereum/forks/dao_fork/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/dao_fork/vm/instructions/bitwise.py b/src/ethereum/forks/dao_fork/vm/instructions/bitwise.py index cb37f6eca7d..476d71d7603 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/bitwise.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/bitwise.py @@ -13,13 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -41,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -66,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -91,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -115,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -141,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): diff --git a/src/ethereum/forks/dao_fork/vm/instructions/comparison.py b/src/ethereum/forks/dao_fork/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/comparison.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/dao_fork/vm/instructions/control_flow.py b/src/ethereum/forks/dao_fork/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/control_flow.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/dao_fork/vm/instructions/environment.py b/src/ethereum/forks/dao_fork/vm/instructions/environment.py index f2c91716993..a4cc54062b5 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/environment.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/environment.py @@ -18,15 +18,12 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BALANCE, GAS_BASE, GAS_COPY, GAS_EXTERNAL, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, calculate_gas_extend_memory, charge_gas, ) @@ -167,7 +164,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -227,7 +224,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -288,7 +285,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/dao_fork/vm/instructions/memory.py b/src/ethereum/forks/dao_fork/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/memory.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/dao_fork/vm/instructions/stack.py b/src/ethereum/forks/dao_fork/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/stack.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/frontier/vm/instructions/arithmetic.py b/src/ethereum/forks/frontier/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/frontier/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/frontier/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/frontier/vm/instructions/bitwise.py b/src/ethereum/forks/frontier/vm/instructions/bitwise.py index cb37f6eca7d..476d71d7603 100644 --- a/src/ethereum/forks/frontier/vm/instructions/bitwise.py +++ b/src/ethereum/forks/frontier/vm/instructions/bitwise.py @@ -13,13 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -41,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -66,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -91,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -115,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -141,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): diff --git a/src/ethereum/forks/frontier/vm/instructions/comparison.py b/src/ethereum/forks/frontier/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/frontier/vm/instructions/comparison.py +++ b/src/ethereum/forks/frontier/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/frontier/vm/instructions/control_flow.py b/src/ethereum/forks/frontier/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/frontier/vm/instructions/control_flow.py +++ b/src/ethereum/forks/frontier/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/frontier/vm/instructions/environment.py b/src/ethereum/forks/frontier/vm/instructions/environment.py index f2c91716993..a4cc54062b5 100644 --- a/src/ethereum/forks/frontier/vm/instructions/environment.py +++ b/src/ethereum/forks/frontier/vm/instructions/environment.py @@ -18,15 +18,12 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BALANCE, GAS_BASE, GAS_COPY, GAS_EXTERNAL, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, calculate_gas_extend_memory, charge_gas, ) @@ -167,7 +164,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -227,7 +224,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -288,7 +285,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/frontier/vm/instructions/memory.py b/src/ethereum/forks/frontier/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/frontier/vm/instructions/memory.py +++ b/src/ethereum/forks/frontier/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/frontier/vm/instructions/stack.py b/src/ethereum/forks/frontier/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/frontier/vm/instructions/stack.py +++ b/src/ethereum/forks/frontier/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/arithmetic.py b/src/ethereum/forks/gray_glacier/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/bitwise.py b/src/ethereum/forks/gray_glacier/vm/instructions/bitwise.py index 4e36a1a7959..4e0a487a749 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/bitwise.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/bitwise.py @@ -13,16 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -44,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -69,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -94,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -118,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -144,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -179,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -209,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -239,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/comparison.py b/src/ethereum/forks/gray_glacier/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/comparison.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/control_flow.py b/src/ethereum/forks/gray_glacier/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/control_flow.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/environment.py b/src/ethereum/forks/gray_glacier/vm/instructions/environment.py index c7018574c29..31b236e66ca 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/environment.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/environment.py @@ -19,17 +19,13 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_gas_extend_memory, @@ -176,7 +172,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -236,7 +232,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -297,7 +293,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -454,7 +450,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/memory.py b/src/ethereum/forks/gray_glacier/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/memory.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/stack.py b/src/ethereum/forks/gray_glacier/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/stack.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/homestead/vm/instructions/arithmetic.py b/src/ethereum/forks/homestead/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/homestead/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/homestead/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/homestead/vm/instructions/bitwise.py b/src/ethereum/forks/homestead/vm/instructions/bitwise.py index cb37f6eca7d..476d71d7603 100644 --- a/src/ethereum/forks/homestead/vm/instructions/bitwise.py +++ b/src/ethereum/forks/homestead/vm/instructions/bitwise.py @@ -13,13 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -41,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -66,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -91,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -115,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -141,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): diff --git a/src/ethereum/forks/homestead/vm/instructions/comparison.py b/src/ethereum/forks/homestead/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/homestead/vm/instructions/comparison.py +++ b/src/ethereum/forks/homestead/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/homestead/vm/instructions/control_flow.py b/src/ethereum/forks/homestead/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/homestead/vm/instructions/control_flow.py +++ b/src/ethereum/forks/homestead/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/homestead/vm/instructions/environment.py b/src/ethereum/forks/homestead/vm/instructions/environment.py index f2c91716993..a4cc54062b5 100644 --- a/src/ethereum/forks/homestead/vm/instructions/environment.py +++ b/src/ethereum/forks/homestead/vm/instructions/environment.py @@ -18,15 +18,12 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BALANCE, GAS_BASE, GAS_COPY, GAS_EXTERNAL, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, calculate_gas_extend_memory, charge_gas, ) @@ -167,7 +164,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -227,7 +224,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -288,7 +285,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/homestead/vm/instructions/memory.py b/src/ethereum/forks/homestead/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/homestead/vm/instructions/memory.py +++ b/src/ethereum/forks/homestead/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/homestead/vm/instructions/stack.py b/src/ethereum/forks/homestead/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/homestead/vm/instructions/stack.py +++ b/src/ethereum/forks/homestead/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/istanbul/vm/instructions/arithmetic.py b/src/ethereum/forks/istanbul/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/istanbul/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/istanbul/vm/instructions/bitwise.py b/src/ethereum/forks/istanbul/vm/instructions/bitwise.py index 4e36a1a7959..4e0a487a749 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/bitwise.py +++ b/src/ethereum/forks/istanbul/vm/instructions/bitwise.py @@ -13,16 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -44,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -69,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -94,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -118,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -144,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -179,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -209,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -239,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/istanbul/vm/instructions/comparison.py b/src/ethereum/forks/istanbul/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/comparison.py +++ b/src/ethereum/forks/istanbul/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/istanbul/vm/instructions/control_flow.py b/src/ethereum/forks/istanbul/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/control_flow.py +++ b/src/ethereum/forks/istanbul/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/istanbul/vm/instructions/environment.py b/src/ethereum/forks/istanbul/vm/instructions/environment.py index a77ca394884..9e720ab49c1 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/environment.py +++ b/src/ethereum/forks/istanbul/vm/instructions/environment.py @@ -19,7 +19,7 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BALANCE, @@ -28,10 +28,6 @@ GAS_COPY, GAS_EXTERNAL, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, calculate_gas_extend_memory, charge_gas, @@ -173,7 +169,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -233,7 +229,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -294,7 +290,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -438,7 +434,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/istanbul/vm/instructions/memory.py b/src/ethereum/forks/istanbul/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/memory.py +++ b/src/ethereum/forks/istanbul/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/istanbul/vm/instructions/stack.py b/src/ethereum/forks/istanbul/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/stack.py +++ b/src/ethereum/forks/istanbul/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/london/vm/instructions/arithmetic.py b/src/ethereum/forks/london/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/london/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/london/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/london/vm/instructions/bitwise.py b/src/ethereum/forks/london/vm/instructions/bitwise.py index 4e36a1a7959..4e0a487a749 100644 --- a/src/ethereum/forks/london/vm/instructions/bitwise.py +++ b/src/ethereum/forks/london/vm/instructions/bitwise.py @@ -13,16 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -44,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -69,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -94,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -118,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -144,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -179,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -209,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -239,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/london/vm/instructions/comparison.py b/src/ethereum/forks/london/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/london/vm/instructions/comparison.py +++ b/src/ethereum/forks/london/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/london/vm/instructions/control_flow.py b/src/ethereum/forks/london/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/london/vm/instructions/control_flow.py +++ b/src/ethereum/forks/london/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/london/vm/instructions/environment.py b/src/ethereum/forks/london/vm/instructions/environment.py index c7018574c29..31b236e66ca 100644 --- a/src/ethereum/forks/london/vm/instructions/environment.py +++ b/src/ethereum/forks/london/vm/instructions/environment.py @@ -19,17 +19,13 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_gas_extend_memory, @@ -176,7 +172,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -236,7 +232,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -297,7 +293,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -454,7 +450,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/london/vm/instructions/memory.py b/src/ethereum/forks/london/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/london/vm/instructions/memory.py +++ b/src/ethereum/forks/london/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/london/vm/instructions/stack.py b/src/ethereum/forks/london/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/london/vm/instructions/stack.py +++ b/src/ethereum/forks/london/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/arithmetic.py b/src/ethereum/forks/muir_glacier/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/bitwise.py b/src/ethereum/forks/muir_glacier/vm/instructions/bitwise.py index 4e36a1a7959..4e0a487a749 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/bitwise.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/bitwise.py @@ -13,16 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -44,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -69,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -94,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -118,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -144,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -179,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -209,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -239,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/comparison.py b/src/ethereum/forks/muir_glacier/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/comparison.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/control_flow.py b/src/ethereum/forks/muir_glacier/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/control_flow.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/environment.py b/src/ethereum/forks/muir_glacier/vm/instructions/environment.py index a77ca394884..9e720ab49c1 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/environment.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/environment.py @@ -19,7 +19,7 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BALANCE, @@ -28,10 +28,6 @@ GAS_COPY, GAS_EXTERNAL, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, calculate_gas_extend_memory, charge_gas, @@ -173,7 +169,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -233,7 +229,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -294,7 +290,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -438,7 +434,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/memory.py b/src/ethereum/forks/muir_glacier/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/memory.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/stack.py b/src/ethereum/forks/muir_glacier/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/stack.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/osaka/vm/instructions/arithmetic.py b/src/ethereum/forks/osaka/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/osaka/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/osaka/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/osaka/vm/instructions/bitwise.py b/src/ethereum/forks/osaka/vm/instructions/bitwise.py index 0614ff61fed..3cb188b8579 100644 --- a/src/ethereum/forks/osaka/vm/instructions/bitwise.py +++ b/src/ethereum/forks/osaka/vm/instructions/bitwise.py @@ -13,17 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_CLZ, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -45,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -70,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -95,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -119,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -145,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -180,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -210,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -240,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: @@ -273,7 +264,7 @@ def count_leading_zeros(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CLZ) + charge_gas(evm, gas.GAS_OPCODE_CLZ) # OPERATION bit_length = U256(x.bit_length()) diff --git a/src/ethereum/forks/osaka/vm/instructions/comparison.py b/src/ethereum/forks/osaka/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/osaka/vm/instructions/comparison.py +++ b/src/ethereum/forks/osaka/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/osaka/vm/instructions/control_flow.py b/src/ethereum/forks/osaka/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/osaka/vm/instructions/control_flow.py +++ b/src/ethereum/forks/osaka/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/osaka/vm/instructions/environment.py b/src/ethereum/forks/osaka/vm/instructions/environment.py index 7a2f15c7001..936297a73a6 100644 --- a/src/ethereum/forks/osaka/vm/instructions/environment.py +++ b/src/ethereum/forks/osaka/vm/instructions/environment.py @@ -20,7 +20,7 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, @@ -28,10 +28,6 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_blob_gas_price, @@ -179,7 +175,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -239,7 +235,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -300,7 +296,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -457,7 +453,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/osaka/vm/instructions/memory.py b/src/ethereum/forks/osaka/vm/instructions/memory.py index 1e650339074..bccc5fd6f01 100644 --- a/src/ethereum/forks/osaka/vm/instructions/memory.py +++ b/src/ethereum/forks/osaka/vm/instructions/memory.py @@ -16,14 +16,10 @@ from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, GAS_COPY, - GAS_OPCODE_MCOPY, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -52,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -83,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -111,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -171,7 +167,7 @@ def mcopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/osaka/vm/instructions/stack.py b/src/ethereum/forks/osaka/vm/instructions/stack.py index a58e1e66e3f..3aaadbf69ab 100644 --- a/src/ethereum/forks/osaka/vm/instructions/stack.py +++ b/src/ethereum/forks/osaka/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -71,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -101,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -133,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/paris/vm/instructions/arithmetic.py b/src/ethereum/forks/paris/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/paris/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/paris/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/paris/vm/instructions/bitwise.py b/src/ethereum/forks/paris/vm/instructions/bitwise.py index 4e36a1a7959..4e0a487a749 100644 --- a/src/ethereum/forks/paris/vm/instructions/bitwise.py +++ b/src/ethereum/forks/paris/vm/instructions/bitwise.py @@ -13,16 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -44,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -69,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -94,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -118,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -144,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -179,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -209,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -239,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/paris/vm/instructions/comparison.py b/src/ethereum/forks/paris/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/paris/vm/instructions/comparison.py +++ b/src/ethereum/forks/paris/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/paris/vm/instructions/control_flow.py b/src/ethereum/forks/paris/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/paris/vm/instructions/control_flow.py +++ b/src/ethereum/forks/paris/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/paris/vm/instructions/environment.py b/src/ethereum/forks/paris/vm/instructions/environment.py index 00e43488ea9..54bac51928d 100644 --- a/src/ethereum/forks/paris/vm/instructions/environment.py +++ b/src/ethereum/forks/paris/vm/instructions/environment.py @@ -19,17 +19,13 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_gas_extend_memory, @@ -176,7 +172,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -236,7 +232,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -297,7 +293,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -454,7 +450,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/paris/vm/instructions/memory.py b/src/ethereum/forks/paris/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/paris/vm/instructions/memory.py +++ b/src/ethereum/forks/paris/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/paris/vm/instructions/stack.py b/src/ethereum/forks/paris/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/paris/vm/instructions/stack.py +++ b/src/ethereum/forks/paris/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/prague/vm/instructions/arithmetic.py b/src/ethereum/forks/prague/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/prague/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/prague/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/prague/vm/instructions/bitwise.py b/src/ethereum/forks/prague/vm/instructions/bitwise.py index 4e36a1a7959..4e0a487a749 100644 --- a/src/ethereum/forks/prague/vm/instructions/bitwise.py +++ b/src/ethereum/forks/prague/vm/instructions/bitwise.py @@ -13,16 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -44,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -69,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -94,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -118,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -144,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -179,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -209,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -239,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/prague/vm/instructions/comparison.py b/src/ethereum/forks/prague/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/prague/vm/instructions/comparison.py +++ b/src/ethereum/forks/prague/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/prague/vm/instructions/control_flow.py b/src/ethereum/forks/prague/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/prague/vm/instructions/control_flow.py +++ b/src/ethereum/forks/prague/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/prague/vm/instructions/environment.py b/src/ethereum/forks/prague/vm/instructions/environment.py index 7a2f15c7001..936297a73a6 100644 --- a/src/ethereum/forks/prague/vm/instructions/environment.py +++ b/src/ethereum/forks/prague/vm/instructions/environment.py @@ -20,7 +20,7 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, @@ -28,10 +28,6 @@ GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_blob_gas_price, @@ -179,7 +175,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -239,7 +235,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -300,7 +296,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -457,7 +453,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/prague/vm/instructions/memory.py b/src/ethereum/forks/prague/vm/instructions/memory.py index 1e650339074..bccc5fd6f01 100644 --- a/src/ethereum/forks/prague/vm/instructions/memory.py +++ b/src/ethereum/forks/prague/vm/instructions/memory.py @@ -16,14 +16,10 @@ from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, GAS_COPY, - GAS_OPCODE_MCOPY, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -52,7 +48,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -83,7 +79,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -111,7 +107,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -171,7 +167,7 @@ def mcopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_MCOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/prague/vm/instructions/stack.py b/src/ethereum/forks/prague/vm/instructions/stack.py index a58e1e66e3f..3aaadbf69ab 100644 --- a/src/ethereum/forks/prague/vm/instructions/stack.py +++ b/src/ethereum/forks/prague/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -71,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -101,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -133,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/shanghai/vm/instructions/arithmetic.py b/src/ethereum/forks/shanghai/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/shanghai/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/shanghai/vm/instructions/bitwise.py b/src/ethereum/forks/shanghai/vm/instructions/bitwise.py index 4e36a1a7959..4e0a487a749 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/bitwise.py +++ b/src/ethereum/forks/shanghai/vm/instructions/bitwise.py @@ -13,16 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_SAR, - GAS_OPCODE_SHL, - GAS_OPCODE_SHR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -44,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -69,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -94,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -118,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -144,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): @@ -179,7 +171,7 @@ def bitwise_shl(evm: Evm) -> None: value = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_SHL) + charge_gas(evm, gas.GAS_OPCODE_SHL) # OPERATION if shift < Uint(256): @@ -209,7 +201,7 @@ def bitwise_shr(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SHR) + charge_gas(evm, gas.GAS_OPCODE_SHR) # OPERATION if shift < U256(256): @@ -239,7 +231,7 @@ def bitwise_sar(evm: Evm) -> None: signed_value = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SAR) + charge_gas(evm, gas.GAS_OPCODE_SAR) # OPERATION if shift < 256: diff --git a/src/ethereum/forks/shanghai/vm/instructions/comparison.py b/src/ethereum/forks/shanghai/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/comparison.py +++ b/src/ethereum/forks/shanghai/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/shanghai/vm/instructions/control_flow.py b/src/ethereum/forks/shanghai/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/control_flow.py +++ b/src/ethereum/forks/shanghai/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/shanghai/vm/instructions/environment.py b/src/ethereum/forks/shanghai/vm/instructions/environment.py index 00e43488ea9..54bac51928d 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/environment.py +++ b/src/ethereum/forks/shanghai/vm/instructions/environment.py @@ -19,17 +19,13 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfBoundsRead from ..gas import ( GAS_BASE, GAS_COLD_ACCOUNT_ACCESS, GAS_COPY, GAS_FAST_STEP, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, - GAS_OPCODE_RETURNDATACOPY, GAS_RETURN_DATA_COPY, GAS_WARM_ACCESS, calculate_gas_extend_memory, @@ -176,7 +172,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -236,7 +232,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -297,7 +293,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -454,7 +450,7 @@ def returndatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_RETURNDATACOPY + copy_gas_cost + extend_memory.cost, ) if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data): raise OutOfBoundsRead diff --git a/src/ethereum/forks/shanghai/vm/instructions/memory.py b/src/ethereum/forks/shanghai/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/memory.py +++ b/src/ethereum/forks/shanghai/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/shanghai/vm/instructions/stack.py b/src/ethereum/forks/shanghai/vm/instructions/stack.py index a58e1e66e3f..3aaadbf69ab 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/stack.py +++ b/src/ethereum/forks/shanghai/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -71,7 +68,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: if num_bytes == 0: charge_gas(evm, GAS_BASE) else: - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -101,7 +98,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -133,7 +130,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/arithmetic.py b/src/ethereum/forks/spurious_dragon/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/bitwise.py b/src/ethereum/forks/spurious_dragon/vm/instructions/bitwise.py index cb37f6eca7d..476d71d7603 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/bitwise.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/bitwise.py @@ -13,13 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -41,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -66,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -91,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -115,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -141,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/comparison.py b/src/ethereum/forks/spurious_dragon/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/comparison.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/control_flow.py b/src/ethereum/forks/spurious_dragon/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/control_flow.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/environment.py b/src/ethereum/forks/spurious_dragon/vm/instructions/environment.py index f2c91716993..a4cc54062b5 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/environment.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/environment.py @@ -18,15 +18,12 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BALANCE, GAS_BASE, GAS_COPY, GAS_EXTERNAL, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, calculate_gas_extend_memory, charge_gas, ) @@ -167,7 +164,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -227,7 +224,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -288,7 +285,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/memory.py b/src/ethereum/forks/spurious_dragon/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/memory.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/stack.py b/src/ethereum/forks/spurious_dragon/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/stack.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/arithmetic.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/arithmetic.py index d74f7425823..e1bf43acdad 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/arithmetic.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/arithmetic.py @@ -16,20 +16,10 @@ from ethereum.utils.numeric import get_sign -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_EXPONENTIATION, GAS_EXPONENTIATION_PER_BYTE, - GAS_OPCODE_ADD, - GAS_OPCODE_ADDMOD, - GAS_OPCODE_DIV, - GAS_OPCODE_MOD, - GAS_OPCODE_MUL, - GAS_OPCODE_MULMOD, - GAS_OPCODE_SDIV, - GAS_OPCODE_SIGNEXTEND, - GAS_OPCODE_SMOD, - GAS_OPCODE_SUB, charge_gas, ) from ..stack import pop, push @@ -51,7 +41,7 @@ def add(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ADD) + charge_gas(evm, gas.GAS_OPCODE_ADD) # OPERATION result = x.wrapping_add(y) @@ -78,7 +68,7 @@ def sub(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SUB) + charge_gas(evm, gas.GAS_OPCODE_SUB) # OPERATION result = x.wrapping_sub(y) @@ -105,7 +95,7 @@ def mul(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MUL) + charge_gas(evm, gas.GAS_OPCODE_MUL) # OPERATION result = x.wrapping_mul(y) @@ -132,7 +122,7 @@ def div(evm: Evm) -> None: divisor = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_DIV) + charge_gas(evm, gas.GAS_OPCODE_DIV) # OPERATION if divisor == 0: @@ -165,7 +155,7 @@ def sdiv(evm: Evm) -> None: divisor = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SDIV) + charge_gas(evm, gas.GAS_OPCODE_SDIV) # OPERATION if divisor == 0: @@ -198,7 +188,7 @@ def mod(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_MOD) + charge_gas(evm, gas.GAS_OPCODE_MOD) # OPERATION if y == 0: @@ -228,7 +218,7 @@ def smod(evm: Evm) -> None: y = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SMOD) + charge_gas(evm, gas.GAS_OPCODE_SMOD) # OPERATION if y == 0: @@ -259,7 +249,7 @@ def addmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_ADDMOD) + charge_gas(evm, gas.GAS_OPCODE_ADDMOD) # OPERATION if z == 0: @@ -290,7 +280,7 @@ def mulmod(evm: Evm) -> None: z = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_MULMOD) + charge_gas(evm, gas.GAS_OPCODE_MULMOD) # OPERATION if z == 0: @@ -353,7 +343,7 @@ def signextend(evm: Evm) -> None: value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_SIGNEXTEND) + charge_gas(evm, gas.GAS_OPCODE_SIGNEXTEND) # OPERATION if byte_num > U256(31): diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/bitwise.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/bitwise.py index cb37f6eca7d..476d71d7603 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/bitwise.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/bitwise.py @@ -13,13 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_AND, - GAS_OPCODE_BYTE, - GAS_OPCODE_NOT, - GAS_OPCODE_OR, - GAS_OPCODE_XOR, charge_gas, ) from ..stack import pop, push @@ -41,7 +36,7 @@ def bitwise_and(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_AND) + charge_gas(evm, gas.GAS_OPCODE_AND) # OPERATION push(evm.stack, x & y) @@ -66,7 +61,7 @@ def bitwise_or(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_OR) + charge_gas(evm, gas.GAS_OPCODE_OR) # OPERATION push(evm.stack, x | y) @@ -91,7 +86,7 @@ def bitwise_xor(evm: Evm) -> None: y = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_XOR) + charge_gas(evm, gas.GAS_OPCODE_XOR) # OPERATION push(evm.stack, x ^ y) @@ -115,7 +110,7 @@ def bitwise_not(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_NOT) + charge_gas(evm, gas.GAS_OPCODE_NOT) # OPERATION push(evm.stack, ~x) @@ -141,7 +136,7 @@ def get_byte(evm: Evm) -> None: word = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_BYTE) + charge_gas(evm, gas.GAS_OPCODE_BYTE) # OPERATION if byte_index >= U256(32): diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/comparison.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/comparison.py index f18a1f221e8..f30d048f94f 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/comparison.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/comparison.py @@ -13,14 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_OPCODE_EQ, - GAS_OPCODE_GT, - GAS_OPCODE_ISZERO, - GAS_OPCODE_LT, - GAS_OPCODE_SGT, - GAS_OPCODE_SLT, charge_gas, ) from ..stack import pop, push @@ -42,7 +36,7 @@ def less_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_LT) + charge_gas(evm, gas.GAS_OPCODE_LT) # OPERATION result = U256(left < right) @@ -68,7 +62,7 @@ def signed_less_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SLT) + charge_gas(evm, gas.GAS_OPCODE_SLT) # OPERATION result = U256(left < right) @@ -95,7 +89,7 @@ def greater_than(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_GT) + charge_gas(evm, gas.GAS_OPCODE_GT) # OPERATION result = U256(left > right) @@ -121,7 +115,7 @@ def signed_greater_than(evm: Evm) -> None: right = pop(evm.stack).to_signed() # GAS - charge_gas(evm, GAS_OPCODE_SGT) + charge_gas(evm, gas.GAS_OPCODE_SGT) # OPERATION result = U256(left > right) @@ -148,7 +142,7 @@ def equal(evm: Evm) -> None: right = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_EQ) + charge_gas(evm, gas.GAS_OPCODE_EQ) # OPERATION result = U256(left == right) @@ -174,7 +168,7 @@ def is_zero(evm: Evm) -> None: x = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_ISZERO) + charge_gas(evm, gas.GAS_OPCODE_ISZERO) # OPERATION result = U256(x == 0) diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/control_flow.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/control_flow.py index 3207f00d738..fabe929c4ce 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/control_flow.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/control_flow.py @@ -13,11 +13,10 @@ from ethereum_types.numeric import U256, Uint +from ...vm import gas from ...vm.gas import ( GAS_BASE, GAS_JUMPDEST, - GAS_OPCODE_JUMP, - GAS_OPCODE_JUMPI, charge_gas, ) from .. import Evm @@ -63,7 +62,7 @@ def jump(evm: Evm) -> None: jump_dest = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_OPCODE_JUMP) + charge_gas(evm, gas.GAS_OPCODE_JUMP) # OPERATION if jump_dest not in evm.valid_jump_destinations: @@ -90,7 +89,7 @@ def jumpi(evm: Evm) -> None: conditional_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_JUMPI) + charge_gas(evm, gas.GAS_OPCODE_JUMPI) # OPERATION if conditional_value == 0: diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/environment.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/environment.py index f2c91716993..a4cc54062b5 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/environment.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/environment.py @@ -18,15 +18,12 @@ from ...state import get_account, get_code from ...utils.address import to_address_masked from ...vm.memory import buffer_read, memory_write -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BALANCE, GAS_BASE, GAS_COPY, GAS_EXTERNAL, - GAS_OPCODE_CALLDATACOPY, - GAS_OPCODE_CALLDATALOAD, - GAS_OPCODE_CODECOPY, calculate_gas_extend_memory, charge_gas, ) @@ -167,7 +164,7 @@ def calldataload(evm: Evm) -> None: start_index = pop(evm.stack) # GAS - charge_gas(evm, GAS_OPCODE_CALLDATALOAD) + charge_gas(evm, gas.GAS_OPCODE_CALLDATALOAD) # OPERATION value = buffer_read(evm.message.data, start_index, U256(32)) @@ -227,7 +224,7 @@ def calldatacopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CALLDATACOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION @@ -288,7 +285,7 @@ def codecopy(evm: Evm) -> None: ) charge_gas( evm, - GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, + gas.GAS_OPCODE_CODECOPY + copy_gas_cost + extend_memory.cost, ) # OPERATION diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/memory.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/memory.py index 74a9396629a..90b2f06a271 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/memory.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/memory.py @@ -14,12 +14,9 @@ from ethereum_types.bytes import Bytes from ethereum_types.numeric import U256, Uint -from .. import Evm +from .. import Evm, gas from ..gas import ( GAS_BASE, - GAS_OPCODE_MLOAD, - GAS_OPCODE_MSTORE, - GAS_OPCODE_MSTORE8, calculate_gas_extend_memory, charge_gas, ) @@ -48,7 +45,7 @@ def mstore(evm: Evm) -> None: evm.memory, [(start_position, U256(len(value)))] ) - charge_gas(evm, GAS_OPCODE_MSTORE + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -79,7 +76,7 @@ def mstore8(evm: Evm) -> None: evm.memory, [(start_position, U256(1))] ) - charge_gas(evm, GAS_OPCODE_MSTORE8 + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MSTORE8 + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by @@ -107,7 +104,7 @@ def mload(evm: Evm) -> None: extend_memory = calculate_gas_extend_memory( evm.memory, [(start_position, U256(32))] ) - charge_gas(evm, GAS_OPCODE_MLOAD + extend_memory.cost) + charge_gas(evm, gas.GAS_OPCODE_MLOAD + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/stack.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/stack.py index 4f1b8171e51..e102cc1a2c9 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/stack.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/stack.py @@ -15,13 +15,10 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm, stack +from .. import Evm, gas, stack from ..exceptions import StackUnderflowError from ..gas import ( GAS_BASE, - GAS_OPCODE_DUP_N, - GAS_OPCODE_PUSH_N, - GAS_OPCODE_SWAP_N, charge_gas, ) from ..memory import buffer_read @@ -68,7 +65,7 @@ def push_n(evm: Evm, num_bytes: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_PUSH_N) + charge_gas(evm, gas.GAS_OPCODE_PUSH_N) # OPERATION data_to_push = U256.from_be_bytes( @@ -98,7 +95,7 @@ def dup_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_DUP_N) + charge_gas(evm, gas.GAS_OPCODE_DUP_N) if item_number >= len(evm.stack): raise StackUnderflowError data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number] @@ -130,7 +127,7 @@ def swap_n(evm: Evm, item_number: int) -> None: pass # GAS - charge_gas(evm, GAS_OPCODE_SWAP_N) + charge_gas(evm, gas.GAS_OPCODE_SWAP_N) if item_number >= len(evm.stack): raise StackUnderflowError evm.stack[-1], evm.stack[-1 - item_number] = ( From 87922cfd86a44b7348e395372a4eef8b89310d1a Mon Sep 17 00:00:00 2001 From: carsons-eels Date: Tue, 10 Mar 2026 01:45:40 -0400 Subject: [PATCH 7/7] refactor: fix import fragility for gas constants --- .../forks/amsterdam/vm/instructions/block.py | 18 ++++---- .../forks/amsterdam/vm/instructions/keccak.py | 8 ++-- .../forks/amsterdam/vm/instructions/log.py | 11 ++--- .../amsterdam/vm/instructions/storage.py | 43 ++++++++----------- .../arrow_glacier/vm/instructions/block.py | 18 ++++---- .../arrow_glacier/vm/instructions/keccak.py | 8 ++-- .../arrow_glacier/vm/instructions/log.py | 11 ++--- .../arrow_glacier/vm/instructions/storage.py | 38 ++++++++-------- .../forks/berlin/vm/instructions/block.py | 18 ++++---- .../forks/berlin/vm/instructions/keccak.py | 8 ++-- .../forks/berlin/vm/instructions/log.py | 11 ++--- .../forks/berlin/vm/instructions/storage.py | 38 ++++++++-------- .../forks/bpo1/vm/instructions/block.py | 18 ++++---- .../forks/bpo1/vm/instructions/keccak.py | 8 ++-- .../forks/bpo1/vm/instructions/log.py | 11 ++--- .../forks/bpo1/vm/instructions/storage.py | 42 ++++++++---------- .../forks/bpo2/vm/instructions/block.py | 18 ++++---- .../forks/bpo2/vm/instructions/keccak.py | 8 ++-- .../forks/bpo2/vm/instructions/log.py | 11 ++--- .../forks/bpo2/vm/instructions/storage.py | 42 ++++++++---------- .../forks/bpo3/vm/instructions/block.py | 18 ++++---- .../forks/bpo3/vm/instructions/keccak.py | 8 ++-- .../forks/bpo3/vm/instructions/log.py | 11 ++--- .../forks/bpo3/vm/instructions/storage.py | 42 ++++++++---------- .../forks/bpo4/vm/instructions/block.py | 18 ++++---- .../forks/bpo4/vm/instructions/keccak.py | 8 ++-- .../forks/bpo4/vm/instructions/log.py | 11 ++--- .../forks/bpo4/vm/instructions/storage.py | 42 ++++++++---------- .../forks/bpo5/vm/instructions/block.py | 18 ++++---- .../forks/bpo5/vm/instructions/keccak.py | 8 ++-- .../forks/bpo5/vm/instructions/log.py | 11 ++--- .../forks/bpo5/vm/instructions/storage.py | 42 ++++++++---------- .../forks/byzantium/vm/instructions/block.py | 16 +++---- .../forks/byzantium/vm/instructions/keccak.py | 8 ++-- .../forks/byzantium/vm/instructions/log.py | 11 ++--- .../byzantium/vm/instructions/storage.py | 18 +++----- .../forks/cancun/vm/instructions/block.py | 18 ++++---- .../forks/cancun/vm/instructions/keccak.py | 8 ++-- .../forks/cancun/vm/instructions/log.py | 11 ++--- .../forks/cancun/vm/instructions/storage.py | 42 ++++++++---------- .../constantinople/vm/instructions/block.py | 16 +++---- .../constantinople/vm/instructions/keccak.py | 8 ++-- .../constantinople/vm/instructions/log.py | 11 ++--- .../constantinople/vm/instructions/storage.py | 18 +++----- .../forks/dao_fork/vm/instructions/block.py | 16 +++---- .../forks/dao_fork/vm/instructions/keccak.py | 8 ++-- .../forks/dao_fork/vm/instructions/log.py | 11 ++--- .../forks/dao_fork/vm/instructions/storage.py | 18 +++----- .../forks/frontier/vm/instructions/block.py | 16 +++---- .../forks/frontier/vm/instructions/keccak.py | 8 ++-- .../forks/frontier/vm/instructions/log.py | 11 ++--- .../forks/frontier/vm/instructions/storage.py | 18 +++----- .../gray_glacier/vm/instructions/block.py | 18 ++++---- .../gray_glacier/vm/instructions/keccak.py | 8 ++-- .../forks/gray_glacier/vm/instructions/log.py | 11 ++--- .../gray_glacier/vm/instructions/storage.py | 38 ++++++++-------- .../forks/homestead/vm/instructions/block.py | 16 +++---- .../forks/homestead/vm/instructions/keccak.py | 8 ++-- .../forks/homestead/vm/instructions/log.py | 11 ++--- .../homestead/vm/instructions/storage.py | 18 +++----- .../forks/istanbul/vm/instructions/block.py | 18 ++++---- .../forks/istanbul/vm/instructions/keccak.py | 8 ++-- .../forks/istanbul/vm/instructions/log.py | 11 ++--- .../forks/istanbul/vm/instructions/storage.py | 31 ++++++------- .../forks/london/vm/instructions/block.py | 18 ++++---- .../forks/london/vm/instructions/keccak.py | 8 ++-- .../forks/london/vm/instructions/log.py | 11 ++--- .../forks/london/vm/instructions/storage.py | 38 ++++++++-------- .../muir_glacier/vm/instructions/block.py | 18 ++++---- .../muir_glacier/vm/instructions/keccak.py | 8 ++-- .../forks/muir_glacier/vm/instructions/log.py | 11 ++--- .../muir_glacier/vm/instructions/storage.py | 31 ++++++------- .../forks/osaka/vm/instructions/block.py | 18 ++++---- .../forks/osaka/vm/instructions/keccak.py | 8 ++-- .../forks/osaka/vm/instructions/log.py | 11 ++--- .../forks/osaka/vm/instructions/storage.py | 42 ++++++++---------- .../forks/paris/vm/instructions/block.py | 18 ++++---- .../forks/paris/vm/instructions/keccak.py | 8 ++-- .../forks/paris/vm/instructions/log.py | 11 ++--- .../forks/paris/vm/instructions/storage.py | 38 ++++++++-------- .../forks/prague/vm/instructions/block.py | 18 ++++---- .../forks/prague/vm/instructions/keccak.py | 8 ++-- .../forks/prague/vm/instructions/log.py | 11 ++--- .../forks/prague/vm/instructions/storage.py | 42 ++++++++---------- .../forks/shanghai/vm/instructions/block.py | 18 ++++---- .../forks/shanghai/vm/instructions/keccak.py | 8 ++-- .../forks/shanghai/vm/instructions/log.py | 11 ++--- .../forks/shanghai/vm/instructions/storage.py | 38 ++++++++-------- .../spurious_dragon/vm/instructions/block.py | 16 +++---- .../spurious_dragon/vm/instructions/keccak.py | 8 ++-- .../spurious_dragon/vm/instructions/log.py | 11 ++--- .../vm/instructions/storage.py | 18 +++----- .../vm/instructions/block.py | 16 +++---- .../vm/instructions/keccak.py | 8 ++-- .../tangerine_whistle/vm/instructions/log.py | 11 ++--- .../vm/instructions/storage.py | 18 +++----- 96 files changed, 718 insertions(+), 951 deletions(-) diff --git a/src/ethereum/forks/amsterdam/vm/instructions/block.py b/src/ethereum/forks/amsterdam/vm/instructions/block.py index e563a2e96e8..1ded7a0d9fa 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/block.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +40,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -89,7 +89,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -123,7 +123,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -156,7 +156,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -189,7 +189,7 @@ def prev_randao(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.prev_randao)) @@ -222,7 +222,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -252,7 +252,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/amsterdam/vm/instructions/keccak.py b/src/ethereum/forks/amsterdam/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/keccak.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/amsterdam/vm/instructions/log.py b/src/ethereum/forks/amsterdam/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/log.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/amsterdam/vm/instructions/storage.py b/src/ethereum/forks/amsterdam/vm/instructions/storage.py index 60056cf5750..ec7365c4c2f 100644 --- a/src/ethereum/forks/amsterdam/vm/instructions/storage.py +++ b/src/ethereum/forks/amsterdam/vm/instructions/storage.py @@ -20,18 +20,9 @@ set_storage, set_transient_storage, ) -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, - check_gas, -) +from ..gas import charge_gas, check_gas from ..stack import pop, push @@ -51,10 +42,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION tx_state = evm.message.tx_env.state @@ -84,7 +75,7 @@ def sstore(evm: Evm) -> None: new_value = pop(evm.stack) # check we have at least the stipend gas - check_gas(evm, GAS_CALL_STIPEND + Uint(1)) + check_gas(evm, gas.GAS_CALL_STIPEND + Uint(1)) tx_state = evm.message.tx_env.state original_value = get_storage_original( @@ -96,35 +87,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) @@ -149,7 +144,7 @@ def tload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) # OPERATION value = get_transient_storage( @@ -179,7 +174,7 @@ def tstore(evm: Evm) -> None: new_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) set_transient_storage( evm.message.tx_env.state, evm.message.current_target, diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/block.py b/src/ethereum/forks/arrow_glacier/vm/instructions/block.py index bbf01739ff2..24c154271d7 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/block.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -203,7 +203,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/keccak.py b/src/ethereum/forks/arrow_glacier/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/keccak.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/log.py b/src/ethereum/forks/arrow_glacier/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/log.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/arrow_glacier/vm/instructions/storage.py b/src/ethereum/forks/arrow_glacier/vm/instructions/storage.py index 6129ed5322c..93134c1b42b 100644 --- a/src/ethereum/forks/arrow_glacier/vm/instructions/storage.py +++ b/src/ethereum/forks/arrow_glacier/vm/instructions/storage.py @@ -14,17 +14,9 @@ from ethereum_types.numeric import Uint from ...state import get_storage, get_storage_original, set_storage -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -44,10 +36,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -73,7 +65,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -86,35 +78,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) diff --git a/src/ethereum/forks/berlin/vm/instructions/block.py b/src/ethereum/forks/berlin/vm/instructions/block.py index bbf01739ff2..24c154271d7 100644 --- a/src/ethereum/forks/berlin/vm/instructions/block.py +++ b/src/ethereum/forks/berlin/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -203,7 +203,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/berlin/vm/instructions/keccak.py b/src/ethereum/forks/berlin/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/berlin/vm/instructions/keccak.py +++ b/src/ethereum/forks/berlin/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/berlin/vm/instructions/log.py b/src/ethereum/forks/berlin/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/berlin/vm/instructions/log.py +++ b/src/ethereum/forks/berlin/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/berlin/vm/instructions/storage.py b/src/ethereum/forks/berlin/vm/instructions/storage.py index 6129ed5322c..93134c1b42b 100644 --- a/src/ethereum/forks/berlin/vm/instructions/storage.py +++ b/src/ethereum/forks/berlin/vm/instructions/storage.py @@ -14,17 +14,9 @@ from ethereum_types.numeric import Uint from ...state import get_storage, get_storage_original, set_storage -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -44,10 +36,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -73,7 +65,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -86,35 +78,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) diff --git a/src/ethereum/forks/bpo1/vm/instructions/block.py b/src/ethereum/forks/bpo1/vm/instructions/block.py index 75810aacd39..8e181fae616 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/block.py +++ b/src/ethereum/forks/bpo1/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +40,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -89,7 +89,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -123,7 +123,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -156,7 +156,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -189,7 +189,7 @@ def prev_randao(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.prev_randao)) @@ -222,7 +222,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -252,7 +252,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/bpo1/vm/instructions/keccak.py b/src/ethereum/forks/bpo1/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/keccak.py +++ b/src/ethereum/forks/bpo1/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/bpo1/vm/instructions/log.py b/src/ethereum/forks/bpo1/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/log.py +++ b/src/ethereum/forks/bpo1/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/bpo1/vm/instructions/storage.py b/src/ethereum/forks/bpo1/vm/instructions/storage.py index 084d58cc46c..8ad14c9dedd 100644 --- a/src/ethereum/forks/bpo1/vm/instructions/storage.py +++ b/src/ethereum/forks/bpo1/vm/instructions/storage.py @@ -20,17 +20,9 @@ set_storage, set_transient_storage, ) -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -50,10 +42,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -79,7 +71,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -92,35 +84,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) @@ -147,7 +143,7 @@ def tload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) # OPERATION value = get_transient_storage( @@ -174,7 +170,7 @@ def tstore(evm: Evm) -> None: new_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) if evm.message.is_static: raise WriteInStaticContext set_transient_storage( diff --git a/src/ethereum/forks/bpo2/vm/instructions/block.py b/src/ethereum/forks/bpo2/vm/instructions/block.py index 9923433c7b6..5b43e36a6c4 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/block.py +++ b/src/ethereum/forks/bpo2/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +40,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -89,7 +89,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -123,7 +123,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -156,7 +156,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -189,7 +189,7 @@ def prev_randao(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.prev_randao)) @@ -222,7 +222,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -252,7 +252,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/bpo2/vm/instructions/keccak.py b/src/ethereum/forks/bpo2/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/keccak.py +++ b/src/ethereum/forks/bpo2/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/bpo2/vm/instructions/log.py b/src/ethereum/forks/bpo2/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/log.py +++ b/src/ethereum/forks/bpo2/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/bpo2/vm/instructions/storage.py b/src/ethereum/forks/bpo2/vm/instructions/storage.py index 084d58cc46c..8ad14c9dedd 100644 --- a/src/ethereum/forks/bpo2/vm/instructions/storage.py +++ b/src/ethereum/forks/bpo2/vm/instructions/storage.py @@ -20,17 +20,9 @@ set_storage, set_transient_storage, ) -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -50,10 +42,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -79,7 +71,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -92,35 +84,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) @@ -147,7 +143,7 @@ def tload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) # OPERATION value = get_transient_storage( @@ -174,7 +170,7 @@ def tstore(evm: Evm) -> None: new_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) if evm.message.is_static: raise WriteInStaticContext set_transient_storage( diff --git a/src/ethereum/forks/bpo3/vm/instructions/block.py b/src/ethereum/forks/bpo3/vm/instructions/block.py index 10fcbdbdb57..726c50501b8 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/block.py +++ b/src/ethereum/forks/bpo3/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +40,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -89,7 +89,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -123,7 +123,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -156,7 +156,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -189,7 +189,7 @@ def prev_randao(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.prev_randao)) @@ -222,7 +222,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -252,7 +252,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/bpo3/vm/instructions/keccak.py b/src/ethereum/forks/bpo3/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/keccak.py +++ b/src/ethereum/forks/bpo3/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/bpo3/vm/instructions/log.py b/src/ethereum/forks/bpo3/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/log.py +++ b/src/ethereum/forks/bpo3/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/bpo3/vm/instructions/storage.py b/src/ethereum/forks/bpo3/vm/instructions/storage.py index 084d58cc46c..8ad14c9dedd 100644 --- a/src/ethereum/forks/bpo3/vm/instructions/storage.py +++ b/src/ethereum/forks/bpo3/vm/instructions/storage.py @@ -20,17 +20,9 @@ set_storage, set_transient_storage, ) -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -50,10 +42,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -79,7 +71,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -92,35 +84,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) @@ -147,7 +143,7 @@ def tload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) # OPERATION value = get_transient_storage( @@ -174,7 +170,7 @@ def tstore(evm: Evm) -> None: new_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) if evm.message.is_static: raise WriteInStaticContext set_transient_storage( diff --git a/src/ethereum/forks/bpo4/vm/instructions/block.py b/src/ethereum/forks/bpo4/vm/instructions/block.py index 52145aa9f82..d577c28dbbf 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/block.py +++ b/src/ethereum/forks/bpo4/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +40,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -89,7 +89,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -123,7 +123,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -156,7 +156,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -189,7 +189,7 @@ def prev_randao(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.prev_randao)) @@ -222,7 +222,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -252,7 +252,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/bpo4/vm/instructions/keccak.py b/src/ethereum/forks/bpo4/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/keccak.py +++ b/src/ethereum/forks/bpo4/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/bpo4/vm/instructions/log.py b/src/ethereum/forks/bpo4/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/log.py +++ b/src/ethereum/forks/bpo4/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/bpo4/vm/instructions/storage.py b/src/ethereum/forks/bpo4/vm/instructions/storage.py index 084d58cc46c..8ad14c9dedd 100644 --- a/src/ethereum/forks/bpo4/vm/instructions/storage.py +++ b/src/ethereum/forks/bpo4/vm/instructions/storage.py @@ -20,17 +20,9 @@ set_storage, set_transient_storage, ) -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -50,10 +42,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -79,7 +71,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -92,35 +84,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) @@ -147,7 +143,7 @@ def tload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) # OPERATION value = get_transient_storage( @@ -174,7 +170,7 @@ def tstore(evm: Evm) -> None: new_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) if evm.message.is_static: raise WriteInStaticContext set_transient_storage( diff --git a/src/ethereum/forks/bpo5/vm/instructions/block.py b/src/ethereum/forks/bpo5/vm/instructions/block.py index 84930244d4c..1e4da5970a3 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/block.py +++ b/src/ethereum/forks/bpo5/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +40,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -89,7 +89,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -123,7 +123,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -156,7 +156,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -189,7 +189,7 @@ def prev_randao(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.prev_randao)) @@ -222,7 +222,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -252,7 +252,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/bpo5/vm/instructions/keccak.py b/src/ethereum/forks/bpo5/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/keccak.py +++ b/src/ethereum/forks/bpo5/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/bpo5/vm/instructions/log.py b/src/ethereum/forks/bpo5/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/log.py +++ b/src/ethereum/forks/bpo5/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/bpo5/vm/instructions/storage.py b/src/ethereum/forks/bpo5/vm/instructions/storage.py index 084d58cc46c..8ad14c9dedd 100644 --- a/src/ethereum/forks/bpo5/vm/instructions/storage.py +++ b/src/ethereum/forks/bpo5/vm/instructions/storage.py @@ -20,17 +20,9 @@ set_storage, set_transient_storage, ) -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -50,10 +42,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -79,7 +71,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -92,35 +84,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) @@ -147,7 +143,7 @@ def tload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) # OPERATION value = get_transient_storage( @@ -174,7 +170,7 @@ def tstore(evm: Evm) -> None: new_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) if evm.message.is_static: raise WriteInStaticContext set_transient_storage( diff --git a/src/ethereum/forks/byzantium/vm/instructions/block.py b/src/ethereum/forks/byzantium/vm/instructions/block.py index 0edcbf000d1..2e6460a4f7d 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/block.py +++ b/src/ethereum/forks/byzantium/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) diff --git a/src/ethereum/forks/byzantium/vm/instructions/keccak.py b/src/ethereum/forks/byzantium/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/keccak.py +++ b/src/ethereum/forks/byzantium/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/byzantium/vm/instructions/log.py b/src/ethereum/forks/byzantium/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/log.py +++ b/src/ethereum/forks/byzantium/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/byzantium/vm/instructions/storage.py b/src/ethereum/forks/byzantium/vm/instructions/storage.py index c62a67ae2d6..686420adcef 100644 --- a/src/ethereum/forks/byzantium/vm/instructions/storage.py +++ b/src/ethereum/forks/byzantium/vm/instructions/storage.py @@ -14,15 +14,9 @@ from ethereum_types.numeric import Uint from ...state import get_storage, set_storage -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext -from ..gas import ( - GAS_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -41,7 +35,7 @@ def sload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_SLOAD) + charge_gas(evm, gas.GAS_SLOAD) # OPERATION value = get_storage( @@ -72,12 +66,12 @@ def sstore(evm: Evm) -> None: state = evm.message.block_env.state current_value = get_storage(state, evm.message.current_target, key) if new_value != 0 and current_value == 0: - gas_cost = GAS_STORAGE_SET + gas_cost = gas.GAS_STORAGE_SET else: - gas_cost = GAS_STORAGE_UPDATE + gas_cost = gas.GAS_STORAGE_UPDATE if new_value == 0 and current_value != 0: - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR charge_gas(evm, gas_cost) if evm.message.is_static: diff --git a/src/ethereum/forks/cancun/vm/instructions/block.py b/src/ethereum/forks/cancun/vm/instructions/block.py index 4f971a9dbf4..1e04a4bc728 100644 --- a/src/ethereum/forks/cancun/vm/instructions/block.py +++ b/src/ethereum/forks/cancun/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +40,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -89,7 +89,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -123,7 +123,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -156,7 +156,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -189,7 +189,7 @@ def prev_randao(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.prev_randao)) @@ -222,7 +222,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -252,7 +252,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/cancun/vm/instructions/keccak.py b/src/ethereum/forks/cancun/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/cancun/vm/instructions/keccak.py +++ b/src/ethereum/forks/cancun/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/cancun/vm/instructions/log.py b/src/ethereum/forks/cancun/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/cancun/vm/instructions/log.py +++ b/src/ethereum/forks/cancun/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/cancun/vm/instructions/storage.py b/src/ethereum/forks/cancun/vm/instructions/storage.py index 084d58cc46c..8ad14c9dedd 100644 --- a/src/ethereum/forks/cancun/vm/instructions/storage.py +++ b/src/ethereum/forks/cancun/vm/instructions/storage.py @@ -20,17 +20,9 @@ set_storage, set_transient_storage, ) -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -50,10 +42,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -79,7 +71,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -92,35 +84,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) @@ -147,7 +143,7 @@ def tload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) # OPERATION value = get_transient_storage( @@ -174,7 +170,7 @@ def tstore(evm: Evm) -> None: new_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) if evm.message.is_static: raise WriteInStaticContext set_transient_storage( diff --git a/src/ethereum/forks/constantinople/vm/instructions/block.py b/src/ethereum/forks/constantinople/vm/instructions/block.py index 0edcbf000d1..2e6460a4f7d 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/block.py +++ b/src/ethereum/forks/constantinople/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) diff --git a/src/ethereum/forks/constantinople/vm/instructions/keccak.py b/src/ethereum/forks/constantinople/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/keccak.py +++ b/src/ethereum/forks/constantinople/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/constantinople/vm/instructions/log.py b/src/ethereum/forks/constantinople/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/log.py +++ b/src/ethereum/forks/constantinople/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/constantinople/vm/instructions/storage.py b/src/ethereum/forks/constantinople/vm/instructions/storage.py index c62a67ae2d6..686420adcef 100644 --- a/src/ethereum/forks/constantinople/vm/instructions/storage.py +++ b/src/ethereum/forks/constantinople/vm/instructions/storage.py @@ -14,15 +14,9 @@ from ethereum_types.numeric import Uint from ...state import get_storage, set_storage -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext -from ..gas import ( - GAS_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -41,7 +35,7 @@ def sload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_SLOAD) + charge_gas(evm, gas.GAS_SLOAD) # OPERATION value = get_storage( @@ -72,12 +66,12 @@ def sstore(evm: Evm) -> None: state = evm.message.block_env.state current_value = get_storage(state, evm.message.current_target, key) if new_value != 0 and current_value == 0: - gas_cost = GAS_STORAGE_SET + gas_cost = gas.GAS_STORAGE_SET else: - gas_cost = GAS_STORAGE_UPDATE + gas_cost = gas.GAS_STORAGE_UPDATE if new_value == 0 and current_value != 0: - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR charge_gas(evm, gas_cost) if evm.message.is_static: diff --git a/src/ethereum/forks/dao_fork/vm/instructions/block.py b/src/ethereum/forks/dao_fork/vm/instructions/block.py index 0edcbf000d1..2e6460a4f7d 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/block.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) diff --git a/src/ethereum/forks/dao_fork/vm/instructions/keccak.py b/src/ethereum/forks/dao_fork/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/keccak.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/dao_fork/vm/instructions/log.py b/src/ethereum/forks/dao_fork/vm/instructions/log.py index 76c02e737a4..65d7658dcd8 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/log.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/log.py @@ -16,11 +16,8 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -58,9 +55,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/dao_fork/vm/instructions/storage.py b/src/ethereum/forks/dao_fork/vm/instructions/storage.py index 8748340fc27..dff35bd4fc9 100644 --- a/src/ethereum/forks/dao_fork/vm/instructions/storage.py +++ b/src/ethereum/forks/dao_fork/vm/instructions/storage.py @@ -14,14 +14,8 @@ from ethereum_types.numeric import Uint from ...state import get_storage, set_storage -from .. import Evm -from ..gas import ( - GAS_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +34,7 @@ def sload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_SLOAD) + charge_gas(evm, gas.GAS_SLOAD) # OPERATION value = get_storage( @@ -71,12 +65,12 @@ def sstore(evm: Evm) -> None: state = evm.message.block_env.state current_value = get_storage(state, evm.message.current_target, key) if new_value != 0 and current_value == 0: - gas_cost = GAS_STORAGE_SET + gas_cost = gas.GAS_STORAGE_SET else: - gas_cost = GAS_STORAGE_UPDATE + gas_cost = gas.GAS_STORAGE_UPDATE if new_value == 0 and current_value != 0: - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR charge_gas(evm, gas_cost) diff --git a/src/ethereum/forks/frontier/vm/instructions/block.py b/src/ethereum/forks/frontier/vm/instructions/block.py index 0edcbf000d1..2e6460a4f7d 100644 --- a/src/ethereum/forks/frontier/vm/instructions/block.py +++ b/src/ethereum/forks/frontier/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) diff --git a/src/ethereum/forks/frontier/vm/instructions/keccak.py b/src/ethereum/forks/frontier/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/frontier/vm/instructions/keccak.py +++ b/src/ethereum/forks/frontier/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/frontier/vm/instructions/log.py b/src/ethereum/forks/frontier/vm/instructions/log.py index 76c02e737a4..65d7658dcd8 100644 --- a/src/ethereum/forks/frontier/vm/instructions/log.py +++ b/src/ethereum/forks/frontier/vm/instructions/log.py @@ -16,11 +16,8 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -58,9 +55,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/frontier/vm/instructions/storage.py b/src/ethereum/forks/frontier/vm/instructions/storage.py index 8748340fc27..dff35bd4fc9 100644 --- a/src/ethereum/forks/frontier/vm/instructions/storage.py +++ b/src/ethereum/forks/frontier/vm/instructions/storage.py @@ -14,14 +14,8 @@ from ethereum_types.numeric import Uint from ...state import get_storage, set_storage -from .. import Evm -from ..gas import ( - GAS_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +34,7 @@ def sload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_SLOAD) + charge_gas(evm, gas.GAS_SLOAD) # OPERATION value = get_storage( @@ -71,12 +65,12 @@ def sstore(evm: Evm) -> None: state = evm.message.block_env.state current_value = get_storage(state, evm.message.current_target, key) if new_value != 0 and current_value == 0: - gas_cost = GAS_STORAGE_SET + gas_cost = gas.GAS_STORAGE_SET else: - gas_cost = GAS_STORAGE_UPDATE + gas_cost = gas.GAS_STORAGE_UPDATE if new_value == 0 and current_value != 0: - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR charge_gas(evm, gas_cost) diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/block.py b/src/ethereum/forks/gray_glacier/vm/instructions/block.py index bbf01739ff2..24c154271d7 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/block.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -203,7 +203,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/keccak.py b/src/ethereum/forks/gray_glacier/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/keccak.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/log.py b/src/ethereum/forks/gray_glacier/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/log.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/gray_glacier/vm/instructions/storage.py b/src/ethereum/forks/gray_glacier/vm/instructions/storage.py index 6129ed5322c..93134c1b42b 100644 --- a/src/ethereum/forks/gray_glacier/vm/instructions/storage.py +++ b/src/ethereum/forks/gray_glacier/vm/instructions/storage.py @@ -14,17 +14,9 @@ from ethereum_types.numeric import Uint from ...state import get_storage, get_storage_original, set_storage -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -44,10 +36,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -73,7 +65,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -86,35 +78,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) diff --git a/src/ethereum/forks/homestead/vm/instructions/block.py b/src/ethereum/forks/homestead/vm/instructions/block.py index 0edcbf000d1..2e6460a4f7d 100644 --- a/src/ethereum/forks/homestead/vm/instructions/block.py +++ b/src/ethereum/forks/homestead/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) diff --git a/src/ethereum/forks/homestead/vm/instructions/keccak.py b/src/ethereum/forks/homestead/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/homestead/vm/instructions/keccak.py +++ b/src/ethereum/forks/homestead/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/homestead/vm/instructions/log.py b/src/ethereum/forks/homestead/vm/instructions/log.py index 76c02e737a4..65d7658dcd8 100644 --- a/src/ethereum/forks/homestead/vm/instructions/log.py +++ b/src/ethereum/forks/homestead/vm/instructions/log.py @@ -16,11 +16,8 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -58,9 +55,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/homestead/vm/instructions/storage.py b/src/ethereum/forks/homestead/vm/instructions/storage.py index 8748340fc27..dff35bd4fc9 100644 --- a/src/ethereum/forks/homestead/vm/instructions/storage.py +++ b/src/ethereum/forks/homestead/vm/instructions/storage.py @@ -14,14 +14,8 @@ from ethereum_types.numeric import Uint from ...state import get_storage, set_storage -from .. import Evm -from ..gas import ( - GAS_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +34,7 @@ def sload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_SLOAD) + charge_gas(evm, gas.GAS_SLOAD) # OPERATION value = get_storage( @@ -71,12 +65,12 @@ def sstore(evm: Evm) -> None: state = evm.message.block_env.state current_value = get_storage(state, evm.message.current_target, key) if new_value != 0 and current_value == 0: - gas_cost = GAS_STORAGE_SET + gas_cost = gas.GAS_STORAGE_SET else: - gas_cost = GAS_STORAGE_UPDATE + gas_cost = gas.GAS_STORAGE_UPDATE if new_value == 0 and current_value != 0: - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR charge_gas(evm, gas_cost) diff --git a/src/ethereum/forks/istanbul/vm/instructions/block.py b/src/ethereum/forks/istanbul/vm/instructions/block.py index bbf01739ff2..24c154271d7 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/block.py +++ b/src/ethereum/forks/istanbul/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -203,7 +203,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/istanbul/vm/instructions/keccak.py b/src/ethereum/forks/istanbul/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/keccak.py +++ b/src/ethereum/forks/istanbul/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/istanbul/vm/instructions/log.py b/src/ethereum/forks/istanbul/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/log.py +++ b/src/ethereum/forks/istanbul/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/istanbul/vm/instructions/storage.py b/src/ethereum/forks/istanbul/vm/instructions/storage.py index 9150b8cb578..97a5992c310 100644 --- a/src/ethereum/forks/istanbul/vm/instructions/storage.py +++ b/src/ethereum/forks/istanbul/vm/instructions/storage.py @@ -14,16 +14,9 @@ from ethereum_types.numeric import Uint from ...state import get_storage, get_storage_original, set_storage -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -42,7 +35,7 @@ def sload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_SLOAD) + charge_gas(evm, gas.GAS_SLOAD) # OPERATION value = get_storage( @@ -68,7 +61,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -79,30 +72,32 @@ def sstore(evm: Evm) -> None: if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost = GAS_STORAGE_SET + gas_cost = gas.GAS_STORAGE_SET else: - gas_cost = GAS_STORAGE_UPDATE + gas_cost = gas.GAS_STORAGE_UPDATE else: - gas_cost = GAS_SLOAD + gas_cost = gas.GAS_SLOAD # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_SLOAD) + evm.refund_counter += int(gas.GAS_STORAGE_SET - gas.GAS_SLOAD) else: # Slot was originally non-empty and was UPDATED earlier - evm.refund_counter += int(GAS_STORAGE_UPDATE - GAS_SLOAD) + evm.refund_counter += int( + gas.GAS_STORAGE_UPDATE - gas.GAS_SLOAD + ) charge_gas(evm, gas_cost) if evm.message.is_static: diff --git a/src/ethereum/forks/london/vm/instructions/block.py b/src/ethereum/forks/london/vm/instructions/block.py index bbf01739ff2..24c154271d7 100644 --- a/src/ethereum/forks/london/vm/instructions/block.py +++ b/src/ethereum/forks/london/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -203,7 +203,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/london/vm/instructions/keccak.py b/src/ethereum/forks/london/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/london/vm/instructions/keccak.py +++ b/src/ethereum/forks/london/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/london/vm/instructions/log.py b/src/ethereum/forks/london/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/london/vm/instructions/log.py +++ b/src/ethereum/forks/london/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/london/vm/instructions/storage.py b/src/ethereum/forks/london/vm/instructions/storage.py index 6129ed5322c..93134c1b42b 100644 --- a/src/ethereum/forks/london/vm/instructions/storage.py +++ b/src/ethereum/forks/london/vm/instructions/storage.py @@ -14,17 +14,9 @@ from ethereum_types.numeric import Uint from ...state import get_storage, get_storage_original, set_storage -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -44,10 +36,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -73,7 +65,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -86,35 +78,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/block.py b/src/ethereum/forks/muir_glacier/vm/instructions/block.py index bbf01739ff2..24c154271d7 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/block.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -203,7 +203,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/keccak.py b/src/ethereum/forks/muir_glacier/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/keccak.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/log.py b/src/ethereum/forks/muir_glacier/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/log.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/muir_glacier/vm/instructions/storage.py b/src/ethereum/forks/muir_glacier/vm/instructions/storage.py index 9150b8cb578..97a5992c310 100644 --- a/src/ethereum/forks/muir_glacier/vm/instructions/storage.py +++ b/src/ethereum/forks/muir_glacier/vm/instructions/storage.py @@ -14,16 +14,9 @@ from ethereum_types.numeric import Uint from ...state import get_storage, get_storage_original, set_storage -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -42,7 +35,7 @@ def sload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_SLOAD) + charge_gas(evm, gas.GAS_SLOAD) # OPERATION value = get_storage( @@ -68,7 +61,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -79,30 +72,32 @@ def sstore(evm: Evm) -> None: if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost = GAS_STORAGE_SET + gas_cost = gas.GAS_STORAGE_SET else: - gas_cost = GAS_STORAGE_UPDATE + gas_cost = gas.GAS_STORAGE_UPDATE else: - gas_cost = GAS_SLOAD + gas_cost = gas.GAS_SLOAD # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_SLOAD) + evm.refund_counter += int(gas.GAS_STORAGE_SET - gas.GAS_SLOAD) else: # Slot was originally non-empty and was UPDATED earlier - evm.refund_counter += int(GAS_STORAGE_UPDATE - GAS_SLOAD) + evm.refund_counter += int( + gas.GAS_STORAGE_UPDATE - gas.GAS_SLOAD + ) charge_gas(evm, gas_cost) if evm.message.is_static: diff --git a/src/ethereum/forks/osaka/vm/instructions/block.py b/src/ethereum/forks/osaka/vm/instructions/block.py index 43be9e58e23..f7180611357 100644 --- a/src/ethereum/forks/osaka/vm/instructions/block.py +++ b/src/ethereum/forks/osaka/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +40,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -89,7 +89,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -123,7 +123,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -156,7 +156,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -189,7 +189,7 @@ def prev_randao(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.prev_randao)) @@ -222,7 +222,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -252,7 +252,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/osaka/vm/instructions/keccak.py b/src/ethereum/forks/osaka/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/osaka/vm/instructions/keccak.py +++ b/src/ethereum/forks/osaka/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/osaka/vm/instructions/log.py b/src/ethereum/forks/osaka/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/osaka/vm/instructions/log.py +++ b/src/ethereum/forks/osaka/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/osaka/vm/instructions/storage.py b/src/ethereum/forks/osaka/vm/instructions/storage.py index 084d58cc46c..8ad14c9dedd 100644 --- a/src/ethereum/forks/osaka/vm/instructions/storage.py +++ b/src/ethereum/forks/osaka/vm/instructions/storage.py @@ -20,17 +20,9 @@ set_storage, set_transient_storage, ) -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -50,10 +42,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -79,7 +71,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -92,35 +84,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) @@ -147,7 +143,7 @@ def tload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) # OPERATION value = get_transient_storage( @@ -174,7 +170,7 @@ def tstore(evm: Evm) -> None: new_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) if evm.message.is_static: raise WriteInStaticContext set_transient_storage( diff --git a/src/ethereum/forks/paris/vm/instructions/block.py b/src/ethereum/forks/paris/vm/instructions/block.py index 3aa1fb2f6b6..e1a9734341f 100644 --- a/src/ethereum/forks/paris/vm/instructions/block.py +++ b/src/ethereum/forks/paris/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +40,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -89,7 +89,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -123,7 +123,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -156,7 +156,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -189,7 +189,7 @@ def prev_randao(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.prev_randao)) @@ -222,7 +222,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -252,7 +252,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/paris/vm/instructions/keccak.py b/src/ethereum/forks/paris/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/paris/vm/instructions/keccak.py +++ b/src/ethereum/forks/paris/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/paris/vm/instructions/log.py b/src/ethereum/forks/paris/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/paris/vm/instructions/log.py +++ b/src/ethereum/forks/paris/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/paris/vm/instructions/storage.py b/src/ethereum/forks/paris/vm/instructions/storage.py index 6129ed5322c..93134c1b42b 100644 --- a/src/ethereum/forks/paris/vm/instructions/storage.py +++ b/src/ethereum/forks/paris/vm/instructions/storage.py @@ -14,17 +14,9 @@ from ethereum_types.numeric import Uint from ...state import get_storage, get_storage_original, set_storage -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -44,10 +36,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -73,7 +65,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -86,35 +78,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) diff --git a/src/ethereum/forks/prague/vm/instructions/block.py b/src/ethereum/forks/prague/vm/instructions/block.py index b3bfb500a09..6d911057db4 100644 --- a/src/ethereum/forks/prague/vm/instructions/block.py +++ b/src/ethereum/forks/prague/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +40,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -89,7 +89,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -123,7 +123,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -156,7 +156,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -189,7 +189,7 @@ def prev_randao(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.prev_randao)) @@ -222,7 +222,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -252,7 +252,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/prague/vm/instructions/keccak.py b/src/ethereum/forks/prague/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/prague/vm/instructions/keccak.py +++ b/src/ethereum/forks/prague/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/prague/vm/instructions/log.py b/src/ethereum/forks/prague/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/prague/vm/instructions/log.py +++ b/src/ethereum/forks/prague/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/prague/vm/instructions/storage.py b/src/ethereum/forks/prague/vm/instructions/storage.py index 084d58cc46c..8ad14c9dedd 100644 --- a/src/ethereum/forks/prague/vm/instructions/storage.py +++ b/src/ethereum/forks/prague/vm/instructions/storage.py @@ -20,17 +20,9 @@ set_storage, set_transient_storage, ) -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -50,10 +42,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -79,7 +71,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -92,35 +84,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) @@ -147,7 +143,7 @@ def tload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) # OPERATION value = get_transient_storage( @@ -174,7 +170,7 @@ def tstore(evm: Evm) -> None: new_value = pop(evm.stack) # GAS - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) if evm.message.is_static: raise WriteInStaticContext set_transient_storage( diff --git a/src/ethereum/forks/shanghai/vm/instructions/block.py b/src/ethereum/forks/shanghai/vm/instructions/block.py index de2569869bd..d351673e1dc 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/block.py +++ b/src/ethereum/forks/shanghai/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +40,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -89,7 +89,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -123,7 +123,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -156,7 +156,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -189,7 +189,7 @@ def prev_randao(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.prev_randao)) @@ -222,7 +222,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) @@ -252,7 +252,7 @@ def chain_id(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.chain_id)) diff --git a/src/ethereum/forks/shanghai/vm/instructions/keccak.py b/src/ethereum/forks/shanghai/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/keccak.py +++ b/src/ethereum/forks/shanghai/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/shanghai/vm/instructions/log.py b/src/ethereum/forks/shanghai/vm/instructions/log.py index abc297df6fa..c96061d15b1 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/log.py +++ b/src/ethereum/forks/shanghai/vm/instructions/log.py @@ -16,12 +16,9 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..exceptions import WriteInStaticContext from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -59,9 +56,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/shanghai/vm/instructions/storage.py b/src/ethereum/forks/shanghai/vm/instructions/storage.py index 6129ed5322c..93134c1b42b 100644 --- a/src/ethereum/forks/shanghai/vm/instructions/storage.py +++ b/src/ethereum/forks/shanghai/vm/instructions/storage.py @@ -14,17 +14,9 @@ from ethereum_types.numeric import Uint from ...state import get_storage, get_storage_original, set_storage -from .. import Evm +from .. import Evm, gas from ..exceptions import OutOfGasError, WriteInStaticContext -from ..gas import ( - GAS_CALL_STIPEND, - GAS_COLD_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - GAS_WARM_ACCESS, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from ..gas import charge_gas from ..stack import pop, push @@ -44,10 +36,10 @@ def sload(evm: Evm) -> None: # GAS if (evm.message.current_target, key) in evm.accessed_storage_keys: - charge_gas(evm, GAS_WARM_ACCESS) + charge_gas(evm, gas.GAS_WARM_ACCESS) else: evm.accessed_storage_keys.add((evm.message.current_target, key)) - charge_gas(evm, GAS_COLD_SLOAD) + charge_gas(evm, gas.GAS_COLD_SLOAD) # OPERATION value = get_storage( @@ -73,7 +65,7 @@ def sstore(evm: Evm) -> None: # STACK key = pop(evm.stack).to_be_bytes32() new_value = pop(evm.stack) - if evm.gas_left <= GAS_CALL_STIPEND: + if evm.gas_left <= gas.GAS_CALL_STIPEND: raise OutOfGasError state = evm.message.block_env.state @@ -86,35 +78,39 @@ def sstore(evm: Evm) -> None: if (evm.message.current_target, key) not in evm.accessed_storage_keys: evm.accessed_storage_keys.add((evm.message.current_target, key)) - gas_cost += GAS_COLD_SLOAD + gas_cost += gas.GAS_COLD_SLOAD if original_value == current_value and current_value != new_value: if original_value == 0: - gas_cost += GAS_STORAGE_SET + gas_cost += gas.GAS_STORAGE_SET else: - gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD + gas_cost += gas.GAS_STORAGE_UPDATE - gas.GAS_COLD_SLOAD else: - gas_cost += GAS_WARM_ACCESS + gas_cost += gas.GAS_WARM_ACCESS # Refund Counter Calculation if current_value != new_value: if original_value != 0 and current_value != 0 and new_value == 0: # Storage is cleared for the first time in the transaction - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR if original_value != 0 and current_value == 0: # Gas refund issued earlier to be reversed - evm.refund_counter -= REFUND_STORAGE_CLEAR + evm.refund_counter -= gas.REFUND_STORAGE_CLEAR if original_value == new_value: # Storage slot being restored to its original value if original_value == 0: # Slot was originally empty and was SET earlier - evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS) + evm.refund_counter += int( + gas.GAS_STORAGE_SET - gas.GAS_WARM_ACCESS + ) else: # Slot was originally non-empty and was UPDATED earlier evm.refund_counter += int( - GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS + gas.GAS_STORAGE_UPDATE + - gas.GAS_COLD_SLOAD + - gas.GAS_WARM_ACCESS ) charge_gas(evm, gas_cost) diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/block.py b/src/ethereum/forks/spurious_dragon/vm/instructions/block.py index 0edcbf000d1..2e6460a4f7d 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/block.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/keccak.py b/src/ethereum/forks/spurious_dragon/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/keccak.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/log.py b/src/ethereum/forks/spurious_dragon/vm/instructions/log.py index 76c02e737a4..65d7658dcd8 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/log.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/log.py @@ -16,11 +16,8 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -58,9 +55,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/spurious_dragon/vm/instructions/storage.py b/src/ethereum/forks/spurious_dragon/vm/instructions/storage.py index 8748340fc27..dff35bd4fc9 100644 --- a/src/ethereum/forks/spurious_dragon/vm/instructions/storage.py +++ b/src/ethereum/forks/spurious_dragon/vm/instructions/storage.py @@ -14,14 +14,8 @@ from ethereum_types.numeric import Uint from ...state import get_storage, set_storage -from .. import Evm -from ..gas import ( - GAS_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +34,7 @@ def sload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_SLOAD) + charge_gas(evm, gas.GAS_SLOAD) # OPERATION value = get_storage( @@ -71,12 +65,12 @@ def sstore(evm: Evm) -> None: state = evm.message.block_env.state current_value = get_storage(state, evm.message.current_target, key) if new_value != 0 and current_value == 0: - gas_cost = GAS_STORAGE_SET + gas_cost = gas.GAS_STORAGE_SET else: - gas_cost = GAS_STORAGE_UPDATE + gas_cost = gas.GAS_STORAGE_UPDATE if new_value == 0 and current_value != 0: - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR charge_gas(evm, gas_cost) diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/block.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/block.py index 0edcbf000d1..2e6460a4f7d 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/block.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/block.py @@ -13,8 +13,8 @@ from ethereum_types.numeric import U256, Uint -from .. import Evm -from ..gas import GAS_BASE, GAS_BLOCK_HASH, charge_gas +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -33,7 +33,7 @@ def block_hash(evm: Evm) -> None: block_number = Uint(pop(evm.stack)) # GAS - charge_gas(evm, GAS_BLOCK_HASH) + charge_gas(evm, gas.GAS_BLOCK_HASH) # OPERATION max_block_number = block_number + Uint(256) @@ -75,7 +75,7 @@ def coinbase(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256.from_be_bytes(evm.message.block_env.coinbase)) @@ -102,7 +102,7 @@ def timestamp(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, evm.message.block_env.time) @@ -128,7 +128,7 @@ def number(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.number)) @@ -154,7 +154,7 @@ def difficulty(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.difficulty)) @@ -180,7 +180,7 @@ def gas_limit(evm: Evm) -> None: pass # GAS - charge_gas(evm, GAS_BASE) + charge_gas(evm, gas.GAS_BASE) # OPERATION push(evm.stack, U256(evm.message.block_env.block_gas_limit)) diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/keccak.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/keccak.py index 8661c5d62f5..0f171699824 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/keccak.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/keccak.py @@ -16,10 +16,8 @@ from ethereum.crypto.hash import keccak256 from ethereum.utils.numeric import ceil32 -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_KECCAK256, - GAS_KECCAK256_PER_WORD, calculate_gas_extend_memory, charge_gas, ) @@ -46,11 +44,11 @@ def keccak(evm: Evm) -> None: # GAS words = ceil32(Uint(size)) // Uint(32) - word_gas_cost = GAS_KECCAK256_PER_WORD * words + word_gas_cost = gas.GAS_KECCAK256_PER_WORD * words extend_memory = calculate_gas_extend_memory( evm.memory, [(memory_start_index, size)] ) - charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost) + charge_gas(evm, gas.GAS_KECCAK256 + word_gas_cost + extend_memory.cost) # OPERATION evm.memory += b"\x00" * extend_memory.expand_by diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/log.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/log.py index 76c02e737a4..65d7658dcd8 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/log.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/log.py @@ -16,11 +16,8 @@ from ethereum_types.numeric import Uint from ...blocks import Log -from .. import Evm +from .. import Evm, gas from ..gas import ( - GAS_LOG, - GAS_LOG_DATA_PER_BYTE, - GAS_LOG_TOPIC, calculate_gas_extend_memory, charge_gas, ) @@ -58,9 +55,9 @@ def log_n(evm: Evm, num_topics: int) -> None: ) charge_gas( evm, - GAS_LOG - + GAS_LOG_DATA_PER_BYTE * Uint(size) - + GAS_LOG_TOPIC * Uint(num_topics) + gas.GAS_LOG + + gas.GAS_LOG_DATA_PER_BYTE * Uint(size) + + gas.GAS_LOG_TOPIC * Uint(num_topics) + extend_memory.cost, ) diff --git a/src/ethereum/forks/tangerine_whistle/vm/instructions/storage.py b/src/ethereum/forks/tangerine_whistle/vm/instructions/storage.py index 8748340fc27..dff35bd4fc9 100644 --- a/src/ethereum/forks/tangerine_whistle/vm/instructions/storage.py +++ b/src/ethereum/forks/tangerine_whistle/vm/instructions/storage.py @@ -14,14 +14,8 @@ from ethereum_types.numeric import Uint from ...state import get_storage, set_storage -from .. import Evm -from ..gas import ( - GAS_SLOAD, - GAS_STORAGE_SET, - GAS_STORAGE_UPDATE, - REFUND_STORAGE_CLEAR, - charge_gas, -) +from .. import Evm, gas +from ..gas import charge_gas from ..stack import pop, push @@ -40,7 +34,7 @@ def sload(evm: Evm) -> None: key = pop(evm.stack).to_be_bytes32() # GAS - charge_gas(evm, GAS_SLOAD) + charge_gas(evm, gas.GAS_SLOAD) # OPERATION value = get_storage( @@ -71,12 +65,12 @@ def sstore(evm: Evm) -> None: state = evm.message.block_env.state current_value = get_storage(state, evm.message.current_target, key) if new_value != 0 and current_value == 0: - gas_cost = GAS_STORAGE_SET + gas_cost = gas.GAS_STORAGE_SET else: - gas_cost = GAS_STORAGE_UPDATE + gas_cost = gas.GAS_STORAGE_UPDATE if new_value == 0 and current_value != 0: - evm.refund_counter += REFUND_STORAGE_CLEAR + evm.refund_counter += gas.REFUND_STORAGE_CLEAR charge_gas(evm, gas_cost)