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)