def delete_code(self, address):
validate_canonical_address(address, title="Storage Address")
key = get_code_key(address)
self._check_accessibility(key)
del self._trie[key]
def get_code(self, address):
validate_canonical_address(address)
account = self._get_account(address)
try:
return self.db[account.code_hash]
except KeyError:
return b''
def get_code(self, address):
validate_canonical_address(address, title="Storage Address")
try:
return self._journaldb[self.get_code_hash(address)]
except KeyError:
return b""
def set_balance(self, address, balance):
validate_canonical_address(address, title="Storage Address")
validate_uint256(balance, title="Account Balance")
account = self._get_account(address)
account.balance = balance
self._set_account(address, account)
def add_log_entry(self, account: bytes, 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((account, topics, data))
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 set_code(self, address, code):
validate_canonical_address(address, title="Storage Address")
validate_is_bytes(code, title="Code")
key = get_code_key(address)
self._check_accessibility(key)
self._trie[key] = code
def set_balance(self, address, balance):
validate_canonical_address(address)
validate_uint256(balance)
account = self._get_account(address)
account.balance = balance
self._set_account(address, account)
def set_nonce(self, address, nonce):
validate_canonical_address(address)
validate_uint256(nonce)
account = self._get_account(address)
account.nonce = nonce
self._set_account(address, account)
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)
def register_account_for_deletion(self, beneficiary):
validate_canonical_address(beneficiary)
if self.msg.storage_address in self.accounts_to_delete:
raise ValueError(
"Invariant. Should be impossible for an account to be "
"registered for deletion multiple times")
self.accounts_to_delete[self.msg.storage_address] = beneficiary
def set_nonce(self, address, nonce):
validate_canonical_address(address, title="Storage Address")
validate_uint256(nonce, title="Nonce")
account = self._get_account(address)
account.nonce = nonce
self._set_account(address, account)
def set_balance(self, address, balance):
validate_canonical_address(address, title="Storage Address")
validate_uint256(balance, title="Account Balance")
key = get_balance_key(address)
self._check_accessibility(key)
self._trie[key] = int_to_big_endian(balance)
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)
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)
super(FrontierUnsignedTransaction, self).validate()
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 __init__(self,
gas,
gas_price,
to,
sender,
value,
data,
code,
origin=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
validate_uint256(gas_price, title="Message.gas_price")
self.gas_price = gas_price
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
if origin is not None:
validate_canonical_address(origin, title="Message.origin")
self.origin = origin
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):
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")
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)
validate_is_bytes(code)
account = self._get_account(address)
account.code_hash = keccak(code)
self.db[account.code_hash] = code
self._set_account(address, account)
def register_account_for_deletion(self, beneficiary):
validate_canonical_address(beneficiary, title="Self destruct beneficiary address")
if self.msg.storage_address in self.accounts_to_delete:
raise ValueError(
"Invariant. Should be impossible for an account to be "
"registered for deletion multiple times"
)
self.accounts_to_delete[self.msg.storage_address] = beneficiary
def get_balance(self, address):
validate_canonical_address(address, title="Storage Address")
key = get_balance_key(address)
self._check_accessibility(key)
if key in self._trie:
return big_endian_to_int(self._trie[key])
else:
return 0
def get_code(self, address):
validate_canonical_address(address, title="Storage Address")
key = get_code_key(address)
self._check_accessibility(key)
if key in self._trie:
return self._trie[key]
else:
return b""
def __init__(self, origin, sig_hash, transaction_gas_limit):
validate_canonical_address(origin, title="TransactionContext.origin")
self._origin = origin
validate_sig_hash(sig_hash,
title="ShardingTransactionContext.sig_hash")
self._sig_hash = sig_hash
validate_uint256(
transaction_gas_limit,
title="ShardingTransactionContext.transaction_gas_limit",
)
self._transaction_gas_limit = transaction_gas_limit
def account_is_empty(self, address):
validate_canonical_address(address, title="Storage Address")
account = self._get_account(address)
if account.code_hash != EMPTY_SHA3:
return False
elif account.balance != 0:
return False
elif account.nonce != 0:
return False
else:
return True
def get_storage(self, address, slot):
validate_canonical_address(address, title="Storage Address")
validate_uint256(slot, title="Storage Slot")
key = get_storage_key(address, slot)
self._check_accessibility(key)
if key in self._trie:
return big_endian_to_int(self._trie[key])
else:
return 0
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 set_storage(self, address, slot, value):
validate_uint256(value, title="Storage Value")
validate_uint256(slot, title="Storage Slot")
validate_canonical_address(address, title="Storage Address")
key = get_storage_key(address, slot)
self._check_accessibility(key)
if value:
self._trie[key] = int_to_big_endian(value)
else:
del self._trie[key]
def get_storage(self, address, slot):
validate_canonical_address(address)
validate_uint256(slot)
account = self._get_account(address)
storage = StateTrie(Trie(self.db, account.storage_root))
slot_as_key = pad32(int_to_big_endian(slot))
if slot_as_key in storage:
encoded_value = storage[slot_as_key]
return rlp.decode(encoded_value, sedes=rlp.sedes.big_endian_int)
else:
return 0
def get_storage(self, address, slot):
validate_canonical_address(address, title="Storage Address")
validate_uint256(slot, title="Storage Slot")
account = self._get_account(address)
storage = HashTrie(HexaryTrie(self._journaldb, account.storage_root))
slot_as_key = pad32(int_to_big_endian(slot))
if slot_as_key in storage:
encoded_value = storage[slot_as_key]
return rlp.decode(encoded_value, sedes=rlp.sedes.big_endian_int)
else:
return 0
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 set_storage(self, address, slot, value):
validate_uint256(value, title="Storage Value")
validate_uint256(slot, title="Storage Slot")
validate_canonical_address(address, title="Storage Address")
account = self._get_account(address)
storage = HashTrie(HexaryTrie(self._journaldb, account.storage_root))
slot_as_key = pad32(int_to_big_endian(slot))
if value:
encoded_value = rlp.encode(value)
storage[slot_as_key] = encoded_value
else:
del storage[slot_as_key]
self._set_account(address, account.copy(storage_root=storage.root_hash))
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 __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 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 __init__(self, gas_price, origin):
validate_uint256(gas_price, title="TransactionContext.gas_price")
self._gas_price = gas_price
validate_canonical_address(origin, title="TransactionContext.origin")
self._origin = origin
def test_validate_canonical_address(value, is_valid):
if is_valid:
validate_canonical_address(value)
else:
with pytest.raises(ValidationError):
validate_canonical_address(value)