def add_log_entry(self, account: Address, topics: List[int], data: bytes) -> None:
validate_canonical_address(account, title="Log entry address")
for topic in topics:
validate_uint256(topic, title="Log entry topic")
validate_is_bytes(data, title="Log entry data")
self._log_entries.append(
(self.transaction_context.get_next_log_counter(), account, topics, data))
def __init__(self, code_bytes: bytes) -> None:
validate_is_bytes(code_bytes, title="CodeStream bytes")
self.stream = io.BytesIO(code_bytes)
self._raw_code_bytes = code_bytes
self._length_cache = len(code_bytes)
self.invalid_positions = set() # type: Set[int]
self.depth_processed = 0
def set_code(self, address: Address, code: bytes) -> None:
validate_canonical_address(address, title="Storage Address")
validate_is_bytes(code, title="Code")
account = self._get_account(address)
code_hash = keccak(code)
self._code_storage_emulator[code_hash] = code
self._set_account(address, account.copy(code_hash=code_hash))
def validate(self) -> None:
validate_uint256(self.nonce, title="Transaction.nonce")
validate_is_integer(self.gas_price, title="Transaction.gas_price")
validate_uint256(self.gas, title="Transaction.gas")
if self.to != CREATE_CONTRACT_ADDRESS:
validate_canonical_address(self.to, title="Transaction.to")
validate_uint256(self.value, title="Transaction.value")
validate_is_bytes(self.data, title="Transaction.data")
super().validate()
def set_code(self, address, code):
validate_canonical_address(address, title="Storage Address")
validate_is_bytes(code, title="Code")
account = self._get_account(address)
code_hash = keccak(code)
self._journaldb[code_hash] = code
self._set_account(address, account.copy(code_hash=code_hash))
def __init__(self, code_bytes: bytes) -> None:
validate_is_bytes(code_bytes, title="SlowCodeStream bytes")
stream = io.BytesIO(code_bytes)
self.stream = stream
self._bound_stream_read = stream.read
self._raw_code_bytes = code_bytes
self._length_cache = len(code_bytes)
self.invalid_positions = set()
self.valid_positions = set()
def write(self, start_position: int, size: int, value: bytes) -> None:
if size:
validate_uint256(start_position)
validate_uint256(size)
validate_is_bytes(value)
validate_length(value, length=size)
validate_lte(start_position + size, maximum=len(self))
for idx, v in enumerate(value):
self._bytes[start_position + idx] = v
def __init__(self, code_bytes: bytes) -> None:
validate_is_bytes(code_bytes, title="CodeStream bytes")
# in order to avoid method overhead when setting/accessing pc, we no longer fence
# the pc (Program Counter) into 0 <= pc <= len(code_bytes). We now let it float free.
# NOTE: Setting pc to a negative value has undefined behavior.
self.pc = 0
self._raw_code_bytes = code_bytes
self._length_cache = len(code_bytes)
self.invalid_positions = set() # type: Set[int]
self.valid_positions = set() # type: Set[int]
def validate(self) -> None:
validate_uint256(self.chain_id, title="Transaction.chain_id")
validate_uint256(self.nonce, title="Transaction.nonce")
validate_uint256(self.gas_price, title="Transaction.gas_price")
validate_uint256(self.gas, title="Transaction.gas")
if self.to != CREATE_CONTRACT_ADDRESS:
validate_canonical_address(self.to, title="Transaction.to")
validate_uint256(self.value, title="Transaction.value")
validate_is_bytes(self.data, title="Transaction.data")
validate_is_transaction_access_list(self.access_list)
def __init__(self,
gas: int,
to: Address,
sender: Address,
value: int,
data: BytesOrView,
code: bytes,
depth: int = 0,
create_address: Address = None,
code_address: Address = None,
should_transfer_value: bool = True,
is_static: bool = False) -> None:
validate_uint256(gas, title="Message.gas")
self.gas: int = gas
if to != CREATE_CONTRACT_ADDRESS:
validate_canonical_address(to, title="Message.to")
self.to = to
validate_canonical_address(sender, title="Message.sender")
self.sender = sender
validate_uint256(value, title="Message.value")
self.value = value
validate_is_bytes_or_view(data, title="Message.data")
self.data = data
validate_is_integer(depth, title="Message.depth")
validate_gte(depth, minimum=0, title="Message.depth")
self.depth = depth
validate_is_bytes(code, title="Message.code")
self.code = code
if create_address is not None:
validate_canonical_address(create_address,
title="Message.storage_address")
self.storage_address = create_address
if code_address is not None:
validate_canonical_address(code_address,
title="Message.code_address")
self.code_address = code_address
validate_is_boolean(should_transfer_value,
title="Message.should_transfer_value")
self.should_transfer_value = should_transfer_value
validate_is_boolean(is_static, title="Message.is_static")
self.is_static = is_static
def write(self, start_position: int, size: int, value: bytes) -> None:
"""
Write `value` into memory.
"""
if size:
validate_uint256(start_position)
validate_uint256(size)
validate_is_bytes(value)
validate_length(value, length=size)
validate_lte(start_position + size, maximum=len(self))
if len(self._bytes) < start_position + size:
self._bytes.extend(
itertools.repeat(
0,
len(self._bytes) - (start_position + size),
))
for idx, v in enumerate(value):
self._bytes[start_position + idx] = v
def validate(self) -> None:
validate_uint256(self.nonce, title="Transaction.nonce")
validate_uint256(self.gas_price, title="Transaction.gas_price")
validate_uint256(self.gas, title="Transaction.gas")
if self.to != CREATE_CONTRACT_ADDRESS:
validate_canonical_address(self.to, title="Transaction.to")
validate_uint256(self.value, title="Transaction.value")
validate_is_bytes(self.data, title="Transaction.data")
validate_uint256(self.v, title="Transaction.v")
validate_uint256(self.r, title="Transaction.r")
validate_uint256(self.s, title="Transaction.s")
validate_lt_secpk1n(self.r, title="Transaction.r")
validate_gte(self.r, minimum=1, title="Transaction.r")
validate_lt_secpk1n(self.s, title="Transaction.s")
validate_gte(self.s, minimum=1, title="Transaction.s")
validate_gte(self.v, minimum=self.v_min, title="Transaction.v")
validate_lte(self.v, maximum=self.v_max, title="Transaction.v")
super().validate()
def output(self, value: bytes) -> None:
"""
Set the return value of the computation.
"""
validate_is_bytes(value)
self._output = value
def test_validate_is_bytes(value, is_valid):
if is_valid:
validate_is_bytes(value)
else:
with pytest.raises(ValidationError):
validate_is_bytes(value)
def output(self, value: bytes) -> None:
validate_is_bytes(value)
self._output = value
