def validate(self):
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(FrontierUnsignedTransaction, self).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 validate(self):
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(FrontierUnsignedTransaction, self).validate()
def generate_CREATE2_contract_address(salt, code):
"""
If contract is created by transaction, `salt` is specified by `transaction.salt`.
If contract is created by contract, `salt` is set by the creator contract.
"""
validate_length_lte(salt, 32, title="Salt")
validate_is_bytes(salt)
validate_is_bytes(code)
return keccak(salt.rjust(32, b'\x00') + code)[-20:]
def validate(self):
super().validate()
validate_uint256(self.gas_price, "Transaction.gas_price")
validate_canonical_address(self.destination, "Transaction.destination")
validate_uint256(self.value, "Transaction.value")
validate_uint256(self.min_block, "Transaction.min_block")
validate_uint256(self.max_block, "Transaction.max_block")
validate_uint256(self.nonce, "Transaction.nonce")
validate_is_bytes(self.msg_data, "Transaction.msg_data")
def validate(self):
validate_uint256(self.nonce)
validate_is_integer(self.gas_price)
validate_uint256(self.gas)
if self.to != CREATE_CONTRACT_ADDRESS:
validate_canonical_address(self.to)
validate_uint256(self.value)
validate_is_bytes(self.data)
validate_uint256(self.v)
validate_uint256(self.r)
validate_uint256(self.s)
def __init__(self,
gas,
gas_price,
to,
sender,
value,
data,
code,
origin=None,
depth=0,
create_address=None,
code_address=None,
should_transfer_value=True):
validate_uint256(gas)
self.gas = gas
validate_uint256(gas_price)
self.gas_price = gas_price
if to != CREATE_CONTRACT_ADDRESS:
validate_canonical_address(to)
self.to = to
validate_canonical_address(sender)
self.sender = sender
validate_uint256(value)
self.value = value
validate_is_bytes(data)
self.data = data
if origin is not None:
validate_canonical_address(origin)
self.origin = origin
validate_is_integer(depth)
validate_gte(depth, minimum=0)
self.depth = depth
validate_is_bytes(code)
self.code = code
if create_address is not None:
validate_canonical_address(create_address)
self.storage_address = create_address
if code_address is not None:
validate_canonical_address(code_address)
self.code_address = code_address
validate_is_boolean(should_transfer_value)
self.should_transfer_value = should_transfer_value
def __init__(self,
gas,
to,
sender,
value,
data,
code,
access_list=None,
depth=0,
create_address=None,
code_address=None,
should_transfer_value=True,
is_static=False):
validate_uint256(gas, title="Message.gas")
self.gas = 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(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 validate(self):
validate_uint256(self.chain_id, title="Transaction.chain_id")
validate_uint256(self.shard_id, title="Transaction.shard_id")
validate_canonical_address(self.to, title="Transaction.to")
validate_is_bytes(self.data, title="Transaction.data")
validate_uint256(self.gas, title="Transaction.gas")
validate_uint256(self.gas_price, title="Transaction.gas_price")
validate_transaction_access_list(self.access_list, title="Transaction.access_list")
validate_is_bytes(self.code, title="Transaction.code")
super(ShardingTransaction, self).validate()
def __init__(self,
gas,
to,
sender,
value,
data,
code,
depth=0,
create_address=None,
code_address=None,
should_transfer_value=True,
is_static=False):
validate_uint256(gas, title="Message.gas")
self.gas = 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(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, size, value):
"""
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))
self.bytes = (
self.bytes[:start_position] +
bytearray(value) +
self.bytes[start_position + size:]
)
def write(self, start_position, size, value):
"""
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 memory_write(self, start_position, size, value):
"""
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):
super().validate() # includes validation of `(int_)gas_price`
validate_canonical_address(self.destination, "Transaction.destination")
validate_uint256(self.value, "Transaction.value")
validate_uint256(self.min_block, "Transaction.min_block")
validate_uint256(self.max_block, "Transaction.max_block")
validate_uint256(self.nonce, "Transaction.nonce")
validate_is_bytes(self.msg_data, "Transaction.msg_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=27, title="Transaction.v")
validate_lte(self.v, maximum=28, title="Transaction.v")
def validate(self):
validate_uint256(self.nonce)
validate_uint256(self.gas_price)
validate_uint256(self.gas)
if self.to != CREATE_CONTRACT_ADDRESS:
validate_canonical_address(self.to)
validate_uint256(self.value)
validate_is_bytes(self.data)
validate_uint256(self.v)
validate_uint256(self.r)
validate_uint256(self.s)
validate_lt_secpk1n(self.r)
validate_gte(self.r, minimum=1)
validate_lt_secpk1n(self.s)
validate_gte(self.s, minimum=1)
validate_gte(self.v, minimum=27)
validate_lte(self.v, maximum=28)
super(FrontierTransaction, self).validate()
def validate(self):
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=27, title="Transaction.v")
validate_lte(self.v, maximum=28, title="Transaction.v")
super(FrontierTransaction, self).validate()
def validate(self):
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(FrontierTransaction, self).validate()
def add_log_entry(self, account, topics, data):
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((account, topics, data))
def output(self, value):
validate_is_bytes(value)
self._output = value
def output(self, value: bytes) -> None:
"""
Set the return value of the computation.
"""
validate_is_bytes(value)
self._output = value
def __init__(self, code_bytes):
validate_is_bytes(code_bytes)
self.stream = io.BytesIO(code_bytes)
self._validity_cache = {}
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 add_log_entry(self, account, topics, data):
validate_canonical_address(account)
for topic in topics:
validate_uint256(topic)
validate_is_bytes(data)
self.log_entries.append((account, topics, data))
def output(self, value):
validate_is_bytes(value)
self._output = value
def add_log_entry(self, account, topics, data):
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((account, topics, data))
def output(self, value: bytes) -> None:
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 __init__(self, code_bytes):
validate_is_bytes(code_bytes, title="CodeStream bytes")
self.stream = io.BytesIO(code_bytes)
self.invalid_positions = set()
self.depth_processed = 0
def __init__(self, code_bytes: bytes) -> None:
validate_is_bytes(code_bytes, title="CodeStream bytes")
self.stream = io.BytesIO(code_bytes)
self.invalid_positions = set() # type: Set[int]
self.depth_processed = 0
