def _normalize_account(raw_account: RawAccountDetails) -> Account: return Account( balance=to_int(hexstr=raw_account.get('balance', '0x0')), nonce=to_int(hexstr=raw_account.get('nonce', '0x0')), code=decode_hex(raw_account.get('code', '')), storage=_normalize_storage(raw_account.get('storage', {})), )
def __init__(self): self.result = { "hash32": test_block_hash.lower(), "address": test_address.lower(), "hexaddress": test_address.lower(), "checksumaddress": test_address, "hexstring": test_hexstring.lower(), "data": test_hexstring.lower(), "blocknumber": hex(56333), "integer": hex(9000), "data_list": test_data_list, "anyaddress": test_any_address.lower(), "blockid": test_block_num, } self.result_expect = { "hash32": to_bytes(None, self.result["hash32"]), "address": to_bytes(None, self.result["address"]), "hexaddress": to_normalized_address(self.result["hexaddress"]), "checksumaddress": to_checksum_address(self.result["checksumaddress"]), "anyaddress": to_bytes(None, self.result["anyaddress"]), "hexstring": to_text(None, self.result["hexstring"]), "data": to_text(None, self.result["data"]), "data_list": list(map(lambda z: to_text(z), self.result["data_list"])), "blocknumber": to_int(None, self.result["blocknumber"]), "integer": to_int(None, self.result["integer"]), "blockid": to_int(None, self.result["blockid"]), }
def discard(self, checkpoint: JournalDBCheckpoint) -> None: self.logger.debug2('discard checkpoint %r', checkpoint) latest_clear_count = to_int(self._clear_count[CLEAR_COUNT_KEY_NAME]) if self._journal_storage.has_checkpoint(checkpoint): self._journal_storage.discard(checkpoint) self._clear_count.discard(checkpoint) else: # if the checkpoint comes before this account started tracking, # then simply reset to the beginning self._journal_storage.reset() self._clear_count.reset() self._storage_cache.reset_cache() reverted_clear_count = to_int(self._clear_count[CLEAR_COUNT_KEY_NAME]) if reverted_clear_count == latest_clear_count - 1: # This revert rewinds past a trie deletion, so roll back to the trie at # that point. We use the clear count as an index to get back to the # old base trie. self._storage_lookup.rollback_trie(reverted_clear_count) elif reverted_clear_count == latest_clear_count: # No change in the base trie, take no action pass else: # Although CREATE2 permits multiple creates and deletes in a single block, # you can still only revert across a single delete. That's because delete # is only triggered at the end of the transaction. raise ValidationError( f"This revert has changed the clear count in an invalid way, from" f" {latest_clear_count} to {reverted_clear_count}, in 0x{self._address.hex()}" )
def get_chain_id() -> int: question = f"On what chain ID is your deployment located? {list(SUPPORTED_CHAIN_IDS.keys())} " chain_id = to_int(text=input(question)) while chain_id not in SUPPORTED_CHAIN_IDS.keys(): cli_logger.info(f"{chain_id} is not a supported chain id. ") chain_id = to_int(text=input(question)) return chain_id
def extract_blake2b_parameters(input_bytes: bytes) -> TFCompressArgs: num_bytes = len(input_bytes) if num_bytes != 213: raise ValidationError( f"input length for Blake2 F precompile should be exactly 213 bytes, got: {num_bytes}" ) rounds = to_int(input_bytes[:4]) h_state = cast(TMessageBlock, _get_64_bit_little_endian_words(input_bytes[4:68])) message = cast(TMessage, _get_64_bit_little_endian_words(input_bytes[68:196])) t_offset_counters = cast( Tuple[int, int], _get_64_bit_little_endian_words(input_bytes[196:212])) final_block_int = to_int(input_bytes[212]) if final_block_int == 0: final_block_flag = False elif final_block_int == 1: final_block_flag = True else: raise ValidationError( f"incorrect final block indicator flag, needed 0 or 1, got: {final_block_int}" ) return rounds, h_state, message, t_offset_counters, final_block_flag
def coerce_type(solidity_type: str, value: bytes) -> Union[int, bool, str, ChecksumAddress, hex]: """ Converts input to the indicated type. Args: solidity_type (str): String representation of type. value (bytes): The value to be converted. Returns: (Union[int, bool, str, ChecksumAddress, hex]): The type representation of the value. """ if "int" in solidity_type: converted_value = to_int(value) elif "bool" in solidity_type: converted_value = bool(to_int(value)) elif "string" in solidity_type: # length * 2 is stored in lower end bits # TODO handle bytes and strings greater than 32 bytes length = int(int.from_bytes(value[-2:], "big") / 2) converted_value = to_text(value[:length]) elif "address" in solidity_type: converted_value = to_checksum_address(value) else: converted_value = value.hex() return converted_value
def test_payment_channel(): contracts_code = prepare_contracts(["PaymentChannel.sol"]) # print(contracts_code) fib = constructor.construct_contract(contracts_code["Fibonacci"]) channel = constructor.construct_contract(contracts_code["PaymentChannel"], fib["address"]) raw_contracts = constructor.generate_code([fib, channel]) contracts = [ArbContract(raw) for raw in raw_contracts] fib = contracts[0] channel = contracts[1] vm = create_evm_vm(contracts) person_a = '0x1000000000000000000000000000000000000000' person_b = '0x2222222222222222222222222222222222222222' person_a_int = eth_utils.to_int(hexstr=person_a) person_b_int = eth_utils.to_int(hexstr=person_b) vm.env.send_message([channel.deposit(), person_a_int, 10000, 0, 0]) vm.env.send_message([channel.getBalance(person_a), 0, 0, 0, 0]) vm.env.send_message([channel.getBalance(person_b), 0, 0, 0, 0]) vm.env.deliver_pending() run_until_halt(vm) vm.env.send_message( [channel.transferFib(person_b, 14), person_a_int, 0, 0, 0]) vm.env.send_message([channel.getBalance(person_a), 0, 0, 0, 0]) vm.env.send_message([channel.getBalance(person_b), 0, 0, 0, 0]) vm.env.deliver_pending() run_until_halt(vm) vm.env.send_message([channel.withdraw(10), person_b_int, 0, 0, 0]) vm.env.send_message([channel.getBalance(person_a), 0, 0, 0, 0]) vm.env.send_message([channel.getBalance(person_b), 0, 0, 0, 0]) vm.env.deliver_pending() run_until_halt(vm) print("Contract sent messages:", vm.sent_messages)
def get_pair_code(pair_id): """ Get pair code from pair id """ sub_symbol = pair_id.split("_") cash_code = TOKEN_CODE_DICT[sub_symbol[0]] stock_code = TOKEN_CODE_DICT[sub_symbol[1]] return eth_utils.to_int(cash_code) << 16 | eth_utils.to_int(stock_code)
def derive_child_key( parent_key: bytes, parent_chain_code: bytes, node: Node, ) -> Tuple[bytes, bytes]: """ Compute a derivitive key from the parent key. From BIP32: The function CKDpriv((k_par, c_par), i) → (k_i, c_i) computes a child extended private key from the parent extended private key: 1. Check whether the child is a hardened key (i ≥ 2**31). If the child is a hardened key, let I = HMAC-SHA512(Key = c_par, Data = 0x00 || ser_256(k_par) || ser_32(i)). (Note: The 0x00 pads the private key to make it 33 bytes long.) If it is not a hardened key, then let I = HMAC-SHA512(Key = c_par, Data = ser_P(point(k_par)) || ser_32(i)). 2. Split I into two 32-byte sequences, I_L and I_R. 3. The returned child key k_i is parse_256(I_L) + k_par (mod n). 4. The returned chain code c_i is I_R. 5. In case parse_256(I_L) ≥ n or k_i = 0, the resulting key is invalid, and one should proceed with the next value for i. (Note: this has probability lower than 1 in 2**127.) """ assert len(parent_chain_code) == 32 if isinstance(node, HardNode): # NOTE Empty byte is added to align to SoftNode case assert len( parent_key) == 32 # Should be guaranteed here in return statment child = hmac_sha512(parent_chain_code, b"\x00" + parent_key + node.serialize()) elif isinstance(node, SoftNode): assert len(ec_point( parent_key)) == 33 # Should be guaranteed by Account class child = hmac_sha512(parent_chain_code, ec_point(parent_key) + node.serialize()) else: raise ValidationError(f"Cannot process: {node}") assert len(child) == 64 if to_int(child[:32]) >= SECP256K1_N: # Invalid key, compute using next node (< 2**-127 probability) return derive_child_key(parent_key, parent_chain_code, node + 1) child_key = (to_int(child[:32]) + to_int(parent_key)) % SECP256K1_N if child_key == 0: # Invalid key, compute using next node (< 2**-127 probability) return derive_child_key(parent_key, parent_chain_code, node + 1) child_key_bytes = child_key.to_bytes(32, byteorder="big") child_chain_code = child[32:] return child_key_bytes, child_chain_code
def addHome(self, adr, area, cost): self.nonce = self.w3.eth.getTransactionCount(self.account_address) transaction = self.contract.functions.AddHome(adr, to_int(text=area), to_int(text=cost)).buildTransaction({ 'gas': 3000000, 'gasPrice': self.w3.toWei('1', 'gwei'), 'from': self.account_address, 'nonce': self.nonce }) self.sendTransaction(transaction) return "Операция прошла успешно."
def __init__(self, contractInfo): self.address_string = contractInfo["address"] self.address = eth_utils.to_int(hexstr=self.address_string) self.code = bytes.fromhex(contractInfo["code"][2:]) self.storage = {} if "storage" in contractInfo: raw_storage = contractInfo["storage"] for item in raw_storage: key = eth_utils.to_int(hexstr=item) self.storage[key] = eth_utils.to_int(hexstr=raw_storage[item])
def main(): if len(sys.argv) != 2: raise Exception("Call as truffle_runner.py [compiled.json]") with open(sys.argv[1]) as json_file: raw_contracts = json.load(json_file) contracts = [ContractABI(contract) for contract in raw_contracts] vm = create_evm_vm(contracts) output_handler = create_output_handler(contracts) with open("code.txt", "w") as f: for instr in vm.code: f.write("{} {}".format(instr, instr.path)) f.write("\n") contract = contracts[0] person_a = "0x1111111122222222000000000000000000000000" person_b = "0x2222222222222222222222222222222222222222" person_a_int = eth_utils.to_int(hexstr=person_a) person_b_int = eth_utils.to_int(hexstr=person_b) print("person_a_int", person_a_int) print("person_b_int", person_b_int) erc20_address = "0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359" erc721_address = "0x06012c8cf97BEaD5deAe237070F9587f8E7A266d" vm.env.send_message([ make_msg_val(contract.deposit(10)), person_a_int, 10000000, eth_utils.to_int(hexstr=erc20_address + "00"), ]) vm.env.send_message([ make_msg_val(contract.sendERC20(12, erc20_address, 5432)), person_a_int, 0, 0 ]) vm.env.send_message([ make_msg_val(contract.deposit(10)), person_a_int, 10000000, eth_utils.to_int(hexstr=erc721_address + "01"), ]) vm.env.send_message([ make_msg_val(contract.sendERC721(12, erc721_address, 10000000)), person_a_int, 0, 0, ]) vm.env.deliver_pending() logs = run_until_halt(vm) for log in logs: print(output_handler(log))
def _extract_vm_config(vm_config: Dict[str, str]) -> Iterable[VMFork]: if 'frontierForkBlock' in vm_config.keys(): yield to_int(hexstr=vm_config['frontierForkBlock']), FrontierVM if 'homesteadForkBlock' in vm_config.keys(): homestead_fork_block = to_int(hexstr=vm_config['homesteadForkBlock']) if 'DAOForkBlock' in vm_config: dao_fork_block_number = to_int(hexstr=vm_config['DAOForkBlock']) HomesteadVM = MainnetDAOValidatorVM.configure( _dao_fork_block_number=dao_fork_block_number, ) yield homestead_fork_block, HomesteadVM else: yield homestead_fork_block, BaseHomesteadVM if 'EIP150ForkBlock' in vm_config.keys(): yield to_int(hexstr=vm_config['EIP150ForkBlock']), TangerineWhistleVM if 'EIP158ForkBlock' in vm_config.keys(): yield to_int(hexstr=vm_config['EIP158ForkBlock']), SpuriousDragonVM if 'byzantiumForkBlock' in vm_config.keys(): yield to_int(hexstr=vm_config['byzantiumForkBlock']), ByzantiumVM if 'constantinopleForkBlock' in vm_config.keys(): yield to_int( hexstr=vm_config['constantinopleForkBlock']), ConstantinopleVM if 'petersburgForkBlock' in vm_config.keys(): yield to_int(hexstr=vm_config['petersburgForkBlock']), PetersburgVM if 'istanbulForkBlock' in vm_config.keys(): yield to_int(hexstr=vm_config['istanbulForkBlock']), IstanbulVM
def etherscan_query_with_retries(url, sleep, retries=3): for _ in range(retries - 1): try: etherscan_block = to_int(hexstr=requests.get(url).json()['result']) except (RequestException, ValueError, KeyError): gevent.sleep(sleep) else: return etherscan_block etherscan_block = to_int(hexstr=requests.get(url).json()['result']) return etherscan_block
def encode(self) -> bytes: data = self.as_dict() unsigned_txn = serializable_unsigned_transaction_from_dict(data) return encode_transaction( unsigned_txn, ( to_int(self.signature[:1]), to_int(self.signature[1:33]), to_int(self.signature[33:65]), ), )
def extract_genesis_params(genesis_config: RawEIP1085Dict) -> GenesisParams: raw_params = genesis_config['genesis'] return GenesisParams( nonce=decode_hex(raw_params['nonce']), difficulty=to_int(hexstr=raw_params['difficulty']), extra_data=Hash32(decode_hex(raw_params['extraData'])), gas_limit=to_int(hexstr=raw_params['gasLimit']), coinbase=Address(decode_hex(raw_params['author'])), timestamp=to_int(hexstr=raw_params['timestamp']), )
def addRequest(self, type, adr, area, cost, adrNewOwner): if not self.w3.isAddress(adrNewOwner): return "Ошибка ввода данных." self.nonce = self.w3.eth.getTransactionCount(self.account_address) transaction = self.contract.functions.AddRequest(to_int(text=type), adr, to_int(text=area), to_int(text=cost), adrNewOwner).buildTransaction({ 'gas': 3000000, 'gasPrice': self.w3.toWei('1', 'gwei'), 'from': self.account_address, 'nonce': self.nonce, 'value': self.w3.toWei('1', 'gwei') }) self.sendTransaction(transaction) return "Операция прошла успешно."
def parse_obj(cls: Type[eth_models.T], data: Dict): data["hash32"] = to_bytes(hexstr=data["hash32"]) data["address"] = to_bytes(None, data["address"]) data["hexaddress"] = to_normalized_address(data["hexaddress"]) data["checksumaddress"] = data["checksumaddress"] data["anyaddress"] = to_bytes(None, data["anyaddress"]) data["hexstring"] = to_text(None, data["hexstring"]) data["data"] = to_text(None, data["data"]) data["data_list"] = list(map(lambda z: to_text(z), data["data_list"])) data["blocknumber"] = to_int(None, data["blocknumber"]) data["integer"] = to_int(None, data["integer"]) data["blockid"] = to_int(None, data["blockid"]) return cls(**data)
def etherscan_query_with_retries(url: str, sleep: float, retries: int = 3) -> int: for _ in range(retries - 1): try: etherscan_block = to_int(hexstr=requests.get(url).json()["result"]) except (RequestException, ValueError, KeyError): gevent.sleep(sleep) else: return etherscan_block etherscan_block = to_int(hexstr=requests.get(url).json()["result"]) return etherscan_block
def etherscan_query_with_retries( url: str, sleep: float, retries: int = 3, ) -> int: for _ in range(retries - 1): try: etherscan_block = to_int(hexstr=requests.get(url).json()['result']) except (RequestException, ValueError, KeyError): gevent.sleep(sleep) else: return etherscan_block etherscan_block = to_int(hexstr=requests.get(url).json()['result']) return etherscan_block
def etherscan_query_with_retries(url: str, sleep: float, retries: int = 3) -> int: def get_result(): response = requests.get(url) return json.loads(response.content)["result"] for _ in range(retries - 1): try: etherscan_block = to_int(hexstr=get_result()) except (RequestException, ValueError, KeyError): gevent.sleep(sleep) else: return etherscan_block etherscan_block = to_int(hexstr=get_result()) return etherscan_block
def _rpc_request_to_filter_params(raw_params: RawFilterParams) -> FilterParams: address: Union[None, Address, Tuple[Address, ...]] if "address" not in raw_params: address = None elif raw_params["address"] is None: address = None elif is_address(raw_params["address"]): address = to_canonical_address(raw_params["address"]) # type: ignore elif isinstance(raw_params["address"], list): address = tuple( to_canonical_address(sub_address) for sub_address in raw_params["address"]) else: raise TypeError(f"Unsupported address: {raw_params['address']!r}") topics: FilterTopics if "topics" not in raw_params: topics = () elif raw_params["topics"] is None: topics = () elif isinstance(raw_params["topics"], Sequence): topics = _normalize_topics(raw_params["topics"]) # type: ignore else: raise TypeError(f"Unsupported topics: {raw_params['topics']!r}") from_block: Optional[BlockNumber] if "fromBlock" not in raw_params: from_block = None elif raw_params["fromBlock"] is None: from_block = None elif isinstance(raw_params["fromBlock"], str): from_block = BlockNumber(to_int(hexstr=raw_params["fromBlock"])) else: raise TypeError(f"Unsupported fromBlock: {raw_params['fromBlock']!r}") to_block: Optional[BlockNumber] if "toBlock" not in raw_params: to_block = None elif raw_params["toBlock"] is None: to_block = None elif isinstance(raw_params["toBlock"], str): to_block = BlockNumber(to_int(hexstr=raw_params["toBlock"])) else: raise TypeError(f"Unsupported toBlock: {raw_params['toBlock']!r}") return FilterParams(from_block, to_block, address, topics)
def build_etherscan_manifest(uri: URI, package_name: str, version: str) -> Iterable[Tuple[str, Any]]: address, chain_id = parse.urlparse(uri).netloc.split(":") network = get_etherscan_network(chain_id) body = make_etherscan_request(address, network) contract_type = body["ContractName"] w3 = setup_w3(to_int(text=chain_id)) block_uri = create_latest_block_uri(w3) runtime_bytecode = to_hex( w3.eth.getCode(ChecksumAddress(HexAddress(HexStr(address))))) yield "package_name", package_name yield "version", version yield "manifest_version", "2" yield "sources", {f"./{contract_type}.sol": body["SourceCode"]} yield "contract_types", { contract_type: { "abi": json.loads(body["ABI"]), "runtime_bytecode": { "bytecode": runtime_bytecode }, "compiler": generate_compiler_info(body), } } yield "deployments", { block_uri: { contract_type: { "contract_type": contract_type, "address": address } } }
def getstorageatindex(contractaddress, i, k, provider='http://127.0.0.1:8545'): web3 = Web3(Web3.HTTPProvider(provider, request_kwargs={'timeout': 60})) pos = str(remove_0x_prefix(i)).rjust(64, '0') key = remove_0x_prefix(k).rjust(64, '0').lower() storage_key = to_hex(web3.sha3(hexstr=key + pos)) return storage_key, to_int( web3.eth.getStorageAt(contractaddress, storage_key))
def parse_byetherscan_uri(parsed: urllib.parse.ParseResult, network_id: int) -> Checkpoint: try: network = Network(network_id) except ValueError: raise ValidationError( f"Can not resolve checkpoint through Etherscan API" f"for network {network_id}. Network not supported") try: etherscan_api_key = os.environ['TRINITY_ETHERSCAN_API_KEY'] except KeyError: raise RuntimeError( "Etherscan API key missing. Assign your Etherscan API key " "to the TRINITY_ETHERSCAN_API_KEY environment variable.") etherscan_api = Etherscan(etherscan_api_key) latest_block_number = etherscan_api.get_latest_block(network) checkpoint_block_number = latest_block_number - BLOCKS_FROM_TIP checkpoint_block_response = etherscan_api.get_block_by_number( checkpoint_block_number, network) checkpoint_score = to_int( hexstr=checkpoint_block_response['totalDifficulty']) checkpoint_hash = checkpoint_block_response['hash'] return Checkpoint(Hash32(decode_hex(checkpoint_hash)), checkpoint_score)
def test_get_clique_checkpoint_block_number(network_id, epoch_length): try: block = get_checkpoint_block_byetherscan(network_id) except EtherscanAPIError as e: warnings.warn(UserWarning(f'Etherscan API issue: "{e}"')) else: assert to_int(hexstr=block.get('number')) % epoch_length == 0
def ecies_decrypt(priv_key, message_parts): sender_public_key_obj = ec.EllipticCurvePublicKey.from_encoded_point( ec.SECP256K1(), message_parts["ephemPublicKey"]) private_key_obj = ec.derive_private_key(eth_utils.to_int(priv_key), ec.SECP256K1(), default_backend()) aes_shared_key = private_key_obj.exchange(ec.ECDH(), sender_public_key_obj) # Now let's do AES-CBC with this, including the hmac matching (modeled after eccrypto code). aes_keyhash = hashlib.sha512(aes_shared_key).digest() hmac_key = aes_keyhash[32:] test_hmac = hmac.new( hmac_key, message_parts["iv"] + message_parts["ephemPublicKey"] + message_parts["ciphertext"], hashlib.sha256).digest() if test_hmac != message_parts["mac"]: raise Exception("Mac does not match") aes_key = aes_keyhash[:32] # Actual decrypt is modeled after ecies.utils.aes_decrypt() - but with CBC mode to match eccrypto. aes_cipher = AES.new(aes_key, AES.MODE_CBC, iv=message_parts["iv"]) try: decrypted_bytes = aes_cipher.decrypt(message_parts["ciphertext"]) # Padding characters (unprintable) may be at the end to fit AES block size, so strip them. unprintable_chars = bytes( ''.join(map(chr, range(0, 32))).join(map(chr, range(127, 160))), 'utf-8') decrypted_string = decrypted_bytes.rstrip(unprintable_chars).decode( "utf-8") return decrypted_string except: raise Exception("Could not decode ciphertext")
def get_side_token( *, web3: Web3, bridge_contract: Contract, main_token_address, ): is_main_token = bridge_contract.functions.knownTokens( address(main_token_address)).call() if is_main_token: logger.info('Token %s is main token', main_token_address) return None side_token_address = bridge_contract.functions.mappedTokens( address(main_token_address)).call() if to_int(hexstr=side_token_address) == 0: logger.error('side token not found for %s', main_token_address) return None side_token_contract = get_erc20_contract( web3=web3, token_address=side_token_address, ) side_token_symbol = side_token_contract.functions.symbol().call() side_token_decimals = side_token_contract.functions.decimals().call() return SideToken( address=side_token_address.lower(), symbol=side_token_symbol, decimals=side_token_decimals, contract=side_token_contract, )
def set(self, key, value): """ Returns all updated hashes in root->leaf order """ validate_is_bytes(key) validate_length(key, 20) validate_is_bytes(value) path = to_int(key) branch = self.branch(key) node = value proof_update = [] target_bit = 1 # branch is in root->leaf order, so flip for sibling in reversed(branch): # Set node_hash = keccak(node) proof_update.append(node_hash) self.db[node_hash] = node # Update if (path & target_bit): node = sibling + node_hash else: node = node_hash + sibling target_bit <<= 1 self.root_hash = keccak(node) self.db[self.root_hash] = node # updates need to be in root->leaf order, so flip back return list(reversed(proof_update))
def decode(cls, encoded: bytes) -> ReceiptAPI: type_id = to_int(encoded[0]) payload = encoded[1:] payload_codec = cls.get_payload_codec(type_id) inner_receipt = payload_codec.decode(payload) return cls(type_id, inner_receipt)
def decode(cls, encoded: bytes) -> SignedTransactionAPI: type_id = to_int(encoded[0]) payload = encoded[1:] payload_codec = cls.get_payload_codec(type_id) inner_transaction = payload_codec.decode(payload) return cls(type_id, inner_transaction)