def set_evm_opcode_pass():
def debug_opcode(computation):
computation.stack_pop(num_items=1, type_hint=constants.UINT256)
opcodes = original_opcodes.copy()
opcodes[vyper_opcodes['DEBUG'][0]] = as_opcode(logic_fn=debug_opcode,
mnemonic="DEBUG",
gas_cost=0)
setattr(eth.vm.forks.byzantium.computation.ByzantiumComputation, 'opcodes',
opcodes)
def set_evm_opcode_debugger(source_code=None,
source_map=None,
stdin=None,
stdout=None):
def debug_opcode(computation):
line_no = computation.stack_pop(num_items=1,
type_hint=constants.UINT256)
VyperDebugCmd(computation,
line_no=line_no,
source_code=source_code,
source_map=source_map,
stdin=stdin,
stdout=stdout).cmdloop()
opcodes = original_opcodes.copy()
opcodes[vyper_opcodes['DEBUG'][0]] = as_opcode(logic_fn=debug_opcode,
mnemonic="DEBUG",
gas_cost=0)
setattr(eth.vm.forks.byzantium.computation.ByzantiumComputation, 'opcodes',
opcodes)
from eth.vm import opcode_values
from eth.vm import mnemonics
from eth.vm.forks.homestead.opcodes import HOMESTEAD_OPCODES
from eth.vm.logic import (
call,
context,
storage,
system,
)
from eth.vm.opcode import as_opcode
UPDATED_OPCODES = {
opcode_values.EXTCODESIZE: as_opcode(
logic_fn=context.extcodesize,
mnemonic=mnemonics.EXTCODESIZE,
gas_cost=constants.GAS_EXTCODE_EIP150,
),
opcode_values.EXTCODECOPY: as_opcode(
logic_fn=context.extcodecopy,
mnemonic=mnemonics.EXTCODECOPY,
gas_cost=constants.GAS_EXTCODE_EIP150,
),
opcode_values.BALANCE: as_opcode(
logic_fn=context.balance,
mnemonic=mnemonics.BALANCE,
gas_cost=constants.GAS_BALANCE_EIP150,
),
opcode_values.SLOAD: as_opcode(
logic_fn=storage.sload,
mnemonic=mnemonics.SLOAD,
SUBTRACT_MNEMONIC = 'SUBTRACT'
def sub(computation: BaseComputation) -> None:
left, right = computation.stack_pop_ints(2)
result = (left - right) & constants.UINT_256_MAX
computation.stack_push_int(result)
UPDATED_OPCODES = {
OP.SUB:
as_opcode(
logic_fn=sub,
mnemonic=SUBTRACT_MNEMONIC,
gas_cost=constants.GAS_LOW,
)
}
CUSTOM_OPCODES = merge(copy.deepcopy(ISTANBUL_OPCODES), UPDATED_OPCODES)
class CustomComputation(IstanbulComputation):
opcodes = CUSTOM_OPCODES
class CustomState(IstanbulState):
computation_class = CustomComputation
GAS_SELFDESTRUCT_EIP150,
)
from eth.vm.forks.byzantium.opcodes import (
ensure_no_static,
)
from eth.vm.forks.muir_glacier.opcodes import (
MUIR_GLACIER_OPCODES,
)
from . import logic
UPDATED_OPCODES: Dict[int, Opcode] = {
opcode_values.BALANCE: as_opcode(
gas_cost=constants.GAS_NULL,
logic_fn=logic.balance_eip2929,
mnemonic=mnemonics.BALANCE,
),
opcode_values.EXTCODESIZE: as_opcode(
gas_cost=constants.GAS_NULL,
logic_fn=logic.extcodesize_eip2929,
mnemonic=mnemonics.EXTCODESIZE,
),
opcode_values.EXTCODECOPY: as_opcode(
gas_cost=constants.GAS_NULL,
logic_fn=logic.extcodecopy_eip2929,
mnemonic=mnemonics.EXTCODECOPY,
),
opcode_values.EXTCODEHASH: as_opcode(
gas_cost=constants.GAS_NULL,
logic_fn=logic.extcodehash_eip2929,
def ensure_no_static(opcode_fn: Callable[..., Any]) -> Callable[..., Any]:
@functools.wraps(opcode_fn)
def inner(computation: BaseComputation) -> Callable[..., Any]:
if computation.msg.is_static:
raise WriteProtection(
"Cannot modify state while inside of a STATICCALL context")
return opcode_fn(computation)
return inner
UPDATED_OPCODES = {
opcode_values.REVERT:
as_opcode(
logic_fn=system.revert,
mnemonic=mnemonics.REVERT,
gas_cost=constants.GAS_ZERO,
),
#
# Context
#
opcode_values.RETURNDATASIZE:
as_opcode(
logic_fn=context.returndatasize,
mnemonic=mnemonics.RETURNDATASIZE,
gas_cost=constants.GAS_BASE,
),
opcode_values.RETURNDATACOPY:
as_opcode(
logic_fn=context.returndatacopy,
mnemonic=mnemonics.RETURNDATACOPY,
stack,
storage,
swap,
system,
)
from eth.vm.opcode import (
as_opcode, )
FRONTIER_OPCODES: Dict[int, OpcodeAPI] = {
#
# Arithmetic
#
opcode_values.STOP:
as_opcode(
logic_fn=flow.stop,
mnemonic=mnemonics.STOP,
gas_cost=constants.GAS_ZERO,
),
opcode_values.ADD:
as_opcode(
logic_fn=arithmetic.add,
mnemonic=mnemonics.ADD,
gas_cost=constants.GAS_VERYLOW,
),
opcode_values.MUL:
as_opcode(
logic_fn=arithmetic.mul,
mnemonic=mnemonics.MUL,
gas_cost=constants.GAS_LOW,
),
opcode_values.SUB:
arithmetic,
system,
call,
)
from eth.vm.opcode import as_opcode
from .constants import (
GAS_EXP_EIP160,
GAS_EXPBYTE_EIP160
)
UPDATED_OPCODES = {
opcode_values.EXP: as_opcode(
logic_fn=arithmetic.exp(gas_per_byte=GAS_EXPBYTE_EIP160),
mnemonic=mnemonics.EXP,
gas_cost=GAS_EXP_EIP160,
),
opcode_values.SELFDESTRUCT: as_opcode(
logic_fn=system.selfdestruct_eip161,
mnemonic=mnemonics.SELFDESTRUCT,
gas_cost=GAS_SELFDESTRUCT_EIP150,
),
opcode_values.CALL: call.CallEIP161.configure(
__name__='opcode:CALL',
mnemonic=mnemonics.CALL,
gas_cost=GAS_CALL_EIP150,
)(),
}
from cytoolz import (merge)
from eth import (constants)
from eth.vm import (
mnemonics,
opcode_values,
)
from eth.vm.forks.byzantium.opcodes import (BYZANTIUM_OPCODES)
from eth.vm.logic import (arithmetic)
from eth.vm.opcode import (as_opcode)
UPDATED_OPCODES = {
opcode_values.SHL:
as_opcode(
logic_fn=arithmetic.shl,
mnemonic=mnemonics.SHL,
gas_cost=constants.GAS_VERYLOW,
),
opcode_values.SHR:
as_opcode(
logic_fn=arithmetic.shr,
mnemonic=mnemonics.SHR,
gas_cost=constants.GAS_VERYLOW,
),
}
CONSTANTINOPLE_OPCODES = merge(
copy.deepcopy(BYZANTIUM_OPCODES),
UPDATED_OPCODES,
)
)
from eth.vm.logic import (
context,
storage,
)
from eth.vm.opcode import as_opcode
from .storage import (
sstore_eip2200,
)
UPDATED_OPCODES = {
# New opcodes
opcode_values.CHAINID: as_opcode(
logic_fn=context.chain_id,
mnemonic=mnemonics.CHAINID,
gas_cost=constants.GAS_BASE,
),
opcode_values.SELFBALANCE: as_opcode(
logic_fn=context.selfbalance,
mnemonic=mnemonics.SELFBALANCE,
gas_cost=constants.GAS_LOW,
),
# Repriced opcodes
opcode_values.SSTORE: as_opcode(
logic_fn=ensure_no_static(sstore_eip2200),
mnemonic=mnemonics.SSTORE,
gas_cost=constants.GAS_NULL,
),
opcode_values.BALANCE: as_opcode(
GAS_EXTCODEHASH_EIP1052
)
from eth.vm.logic import (
arithmetic,
context,
system,
)
from eth.vm.opcode import (
as_opcode
)
UPDATED_OPCODES = {
opcode_values.SHL: as_opcode(
logic_fn=arithmetic.shl,
mnemonic=mnemonics.SHL,
gas_cost=constants.GAS_VERYLOW,
),
opcode_values.SHR: as_opcode(
logic_fn=arithmetic.shr,
mnemonic=mnemonics.SHR,
gas_cost=constants.GAS_VERYLOW,
),
opcode_values.SAR: as_opcode(
logic_fn=arithmetic.sar,
mnemonic=mnemonics.SAR,
gas_cost=constants.GAS_VERYLOW,
),
opcode_values.EXTCODEHASH: as_opcode(
logic_fn=context.extcodehash,
mnemonic=mnemonics.EXTCODEHASH,
as_opcode,
)
from eth import constants
from eth.vm.forks.berlin.opcodes import (
BERLIN_OPCODES, )
from eth.vm.forks.byzantium.opcodes import (
ensure_no_static, )
from . import storage
UPDATED_OPCODES: Dict[int, Opcode] = {
opcode_values.BASEFEE:
as_opcode(
gas_cost=constants.GAS_BASE,
logic_fn=block.basefee,
mnemonic=mnemonics.BASEFEE,
),
opcode_values.SSTORE:
as_opcode(
gas_cost=constants.GAS_NULL,
logic_fn=ensure_no_static(storage.sstore_eip3529),
mnemonic=mnemonics.SSTORE,
),
}
LONDON_OPCODES = merge(
copy.deepcopy(BERLIN_OPCODES),
UPDATED_OPCODES,
)
"balance": DEFAULT_INITIAL_BALANCE,
"nonce": 0,
"code": b'',
"storage": {}
}
}
chain = MainnetChain.from_genesis(AtomicDB(), GENESIS_PARAMS, GENESIS_STATE)
def add(computation):
computation.stack_pop1_int()
computation.stack_push_int(69)
add_op = as_opcode(add, "ADD", 1)
def gen_context(chain):
CANONICAL_ADDRESS_A = to_canonical_address(
"0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6")
CANONICAL_ADDRESS_B = to_canonical_address(
"0xcd1722f3947def4cf144679da39c4c32bdc35681")
state = chain.get_vm().state
message = Message(
to=CANONICAL_ADDRESS_A,
sender=CANONICAL_ADDRESS_B,
create_address=None,
value=0,
data=b'',
code=b'',
from eth.vm.forks.byzantium.opcodes import (BYZANTIUM_OPCODES)
from eth.vm.forks.constantinople.constants import (GAS_EXTCODEHASH_EIP1052)
from eth.vm.forks.constantinople.storage import (
sstore_eip1283, )
from eth.vm.logic import (
arithmetic,
context,
system,
)
from eth.vm.opcode import (as_opcode)
UPDATED_OPCODES = {
opcode_values.SHL:
as_opcode(
logic_fn=arithmetic.shl,
mnemonic=mnemonics.SHL,
gas_cost=constants.GAS_VERYLOW,
),
opcode_values.SHR:
as_opcode(
logic_fn=arithmetic.shr,
mnemonic=mnemonics.SHR,
gas_cost=constants.GAS_VERYLOW,
),
opcode_values.SAR:
as_opcode(
logic_fn=arithmetic.sar,
mnemonic=mnemonics.SAR,
gas_cost=constants.GAS_VERYLOW,
),
opcode_values.EXTCODEHASH:
