def test_generate_address2_with_proxy(self): deployer_account = self.ethereum_test_account proxy_factory_contract = get_proxy_factory_contract(self.w3) nonce = self.w3.eth.getTransactionCount(deployer_account.address, block_identifier='pending') tx = proxy_factory_contract.constructor().buildTransaction({'nonce': nonce, 'from': deployer_account.address}) signed_tx = deployer_account.sign_transaction(tx) tx_hash = self.w3.eth.sendRawTransaction(signed_tx.rawTransaction) tx_receipt = self.w3.eth.waitForTransactionReceipt(tx_hash) proxy_factory_contract = get_proxy_factory_contract(self.w3, address=tx_receipt['contractAddress']) initializer = b'' # Should be the safe `setup()` call with `owners`, `threshold`, `payment`... salt_nonce = 0 # Random. For sure. I used a dice master_copy = Account.create().address tx = proxy_factory_contract.functions.createProxyWithNonce(master_copy, initializer, salt_nonce ).buildTransaction({'nonce': nonce + 1, 'from': deployer_account.address, }) signed_tx = deployer_account.sign_transaction(tx) tx_hash = self.w3.eth.sendRawTransaction(signed_tx.rawTransaction) tx_receipt = self.w3.eth.waitForTransactionReceipt(tx_hash) logs = proxy_factory_contract.events.ProxyCreation().processReceipt(tx_receipt) log = logs[0] self.assertEqual(log['event'], 'ProxyCreation') proxy_address = log['args']['proxy'] proxy_creation_code = proxy_factory_contract.functions.proxyCreationCode().call() salt = self.w3.keccak(encode_abi_packed(['bytes', 'uint256'], [self.w3.keccak(initializer), salt_nonce])) deployment_data = encode_abi_packed(['bytes', 'uint256'], [proxy_creation_code, int(master_copy, 16)]) address2 = generate_address_2(proxy_factory_contract.address, salt, deployment_data) self.assertEqual(proxy_address, address2)
def calculate_create2_address(self, safe_setup_data: bytes, salt_nonce: int): proxy_creation_code = self.proxy_factory_contract.functions.proxyCreationCode( ).call() salt = self.w3.keccak( encode_abi_packed(['bytes', 'uint256'], [self.w3.keccak(safe_setup_data), salt_nonce])) deployment_data = encode_abi_packed( ['bytes', 'uint256'], [proxy_creation_code, int(self.master_copy_address, 16)]) return generate_address_2(self.proxy_factory_contract.address, salt, deployment_data)
def test_generate_address2_with_proxy(self): deployer_account = self.ethereum_test_account proxy_factory_contract = get_proxy_factory_contract(self.w3) nonce = self.w3.eth.get_transaction_count(deployer_account.address, block_identifier="pending") tx = proxy_factory_contract.constructor().buildTransaction({ "nonce": nonce, "from": deployer_account.address }) signed_tx = deployer_account.sign_transaction(tx) tx_hash = self.w3.eth.send_raw_transaction(signed_tx.rawTransaction) tx_receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash) proxy_factory_contract = get_proxy_factory_contract( self.w3, address=tx_receipt["contractAddress"]) initializer = b"" # Should be the safe `setup()` call with `owners`, `threshold`, `payment`... salt_nonce = 0 # Random. For sure. I used a dice master_copy = Account.create().address tx = proxy_factory_contract.functions.createProxyWithNonce( master_copy, initializer, salt_nonce).buildTransaction({ "nonce": nonce + 1, "from": deployer_account.address, }) signed_tx = deployer_account.sign_transaction(tx) tx_hash = self.w3.eth.send_raw_transaction(signed_tx.rawTransaction) tx_receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash) logs = proxy_factory_contract.events.ProxyCreation().processReceipt( tx_receipt) log = logs[0] self.assertEqual(log["event"], "ProxyCreation") proxy_address = log["args"]["proxy"] proxy_creation_code = ( proxy_factory_contract.functions.proxyCreationCode().call()) salt = self.w3.keccak( encode_abi_packed(["bytes", "uint256"], [self.w3.keccak(initializer), salt_nonce])) deployment_data = encode_abi_packed( ["bytes", "uint256"], [proxy_creation_code, int(master_copy, 16)]) address2 = generate_address_2(proxy_factory_contract.address, salt, deployment_data) self.assertEqual(proxy_address, address2)
def main(): with Path('data.json').open() as fp: data = json.load(fp)['addresses'] total_distribution = (250000000 * 10**18) // 52 total_vecrv = sum(data.values()) balances = { k: int(v * total_distribution / total_vecrv) for k, v in data.items() } elements = [(index, account, amount) for index, (account, amount) in enumerate(balances.items())] nodes = [ encode_hex(encode_abi_packed(['uint', 'address', 'uint'], el)) for el in elements ] tree = MerkleTree(nodes) distribution = { 'merkleRoot': encode_hex(tree.root), 'tokenTotal': hex(sum(balances.values())), 'claims': { user: { 'index': index, 'amount': hex(amount), 'proof': tree.get_proof(nodes[index]) } for index, user, amount in elements }, } print(f'merkle root: {encode_hex(tree.root)}') with Path('distribution.json').open('w') as fp: json.dump(distribution, fp)
def test_encode_abi(type_str, python_value, _, packed_encoding): abi_type = parse(type_str) if abi_type.arrlist is not None: pytest.skip('ABI coding functions do not support array types') types = [t.to_type_str() for t in abi_type.components] actual = encode_abi_packed(types, python_value) assert actual == packed_encoding
def test_encode_abi(type_str, python_value, _, packed_encoding): abi_type = parse(type_str) if abi_type.arrlist is not None: pytest.skip('ABI coding functions do not support array types') types = [str(t) for t in abi_type.components] actual = encode_abi_packed(types, python_value) assert actual == packed_encoding
def calculate_pair_address(self, token_address: str, token_address_2: str): """ Calculate pair address without querying blockchain. https://uniswap.org/docs/v2/smart-contract-integration/getting-pair-addresses/#docs-header :param token_address: :param token_address_2: :return: Checksummed address for token pair. It could be not created yet """ if token_address.lower() > token_address_2.lower(): token_address, token_address_2 = token_address_2, token_address salt = Web3.keccak( encode_abi_packed(['address', 'address'], [token_address, token_address_2])) address = Web3.keccak( encode_abi_packed(['bytes', 'address', 'bytes', 'bytes'], [ HexBytes('ff'), self.factory_address, salt, self.pair_init_code ]))[-20:] return Web3.toChecksumAddress(address)
def add_value_txn(self, acct, l2nonce, balance, deposit): chainid = 100 tokenid = '0x0000000000000000000000000000000000000000' amount = int((balance + deposit) * pow(10, 18)) adjust = int(deposit * pow(10, 18)) lock = retrieve = 0 refill = 1 acstat = seller.functions.read(acct.address).call() print(f"acstat: {acstat}") l3nonce = int(('0' * 16 + hex(acstat)[2:])[-16:], 16) print(f"l3nonce: {l3nonce}") # msg = encode_abi_packed(['bytes1', 'bytes1', 'address', 'uint256', 'uint64', 'address', 'uint256', 'int256', 'int256', 'uint256', 'uint128'], # [b'\x19', b'\x00', testdata['seller']['address'], chainid, l3nonce, tokenid, amount, adjust, lock, retrieve, refill]) msg = encode_abi_packed([ 'uint256', 'uint64', 'address', 'uint256', 'int256', 'int256', 'uint256', 'uint256' ], [chainid, l3nonce, tokenid, amount, adjust, lock, retrieve, refill]) message = encode_intended_validator( validator_address=testdata['seller']['address'], primitive=msg) sig = w3.eth.account.sign_message(message, private_key=acct.key) txn = { "from": acct.address, "to": testdata['seller']['address'], "gas": hex(175000), "gasPrice": hex(pow(10, 9)), "value": hex(int((balance + deposit) * pow(10, 18))), "chainId": chainid, "nonce": l2nonce, "data": seller.encodeABI(fn_name='edit', args=[ acct.address, sig.v, bytearray.fromhex(hex(sig.r)[2:]), bytearray.fromhex(hex(sig.s)[2:]), l3nonce, adjust, lock, retrieve, refill ]), } txstr = json.dumps(txn) txmsg = encode_defunct(text=txstr) print(txmsg) txsig = w3.eth.account.sign_message( txmsg, private_key=acct.key).signature.hex() print(txsig) return txstr, txsig
def calculate_pair_adress(self, tokenA, tokenB): tokenA = Web3.toChecksumAddress(tokenA) tokenB = Web3.toChecksumAddress(tokenB) tokenA_hex = bytes.fromhex(tokenA[2:]) tokenB_hex = bytes.fromhex(tokenB[2:]) if tokenA_hex < tokenB_hex: token0 = tokenA token1 = tokenB else: token1 = tokenA token0 = tokenB b_salt = Web3.keccak(encode_abi_packed(['address', 'address'], [token0, token1])) pre = '0xff' b_pre = bytes.fromhex(pre[2:]) b_address = bytes.fromhex(self.factory_address[2:]) b_init_code = bytes.fromhex(self.init_code_hash[2:]) b_result = Web3.keccak( encode_abi_packed(['bytes', 'bytes', 'bytes', 'bytes'], [b_pre, b_address, b_salt, b_init_code])) result_address = Web3.toChecksumAddress(b_result[12:].hex()) return result_address, token0, token1
def sign_score(key, validator, game_id, user, score): game_id = HexBytes(game_id) types = ['bytes32', 'address', 'uint256'] values = [game_id, user, score] encoded_values = encode_abi_packed(types, values) message = encode_intended_validator( validator_address=validator, primitive=encoded_values, ) signed = Account.sign_message(message, key) vrs = { 'v': signed['v'], 'r': HexBytes(signed['r']).hex(), 's': HexBytes(signed['s']).hex(), } return vrs
def get_dispute_by(self, miner, request_id, timestamp) -> Optional[Dispute]: """ Args: miner: Disputed miner address request_id: Disputed request id timestamp: Disputed value timestamp Returns: Detailed info about a :py:class:`~tellor.dispute.Dispute`. """ dispute_hash = w3.keccak( encode_abi_packed(["address", "uint256", "uint256"], [miner, request_id, timestamp])) dispute_id = self.call.getDisputeIdByDisputeHash(dispute_hash) if dispute_id: return self.get_dispute(dispute_id)
def step_07(balances): elements = [(index, account, amount) for index, (account, amount) in enumerate(balances.items())] nodes = [encode_hex(encode_abi_packed( ['uint', 'address', 'uint'], el)) for el in elements] tree = MerkleTree(nodes) distribution = { 'merkleRoot': encode_hex(tree.root), 'tokenTotal': hex(sum(balances.values())), 'claims': { user: {'index': index, 'amount': hex( amount), 'proof': tree.get_proof(nodes[index])} for index, user, amount in elements }, } print(f'merkle root: {encode_hex(tree.root)}') return distribution
def main(): with Path('data.json').open() as fp: data = json.load(fp)['addresses'] total_distribution = (250000000 * 10**18) // 52 total_vecrv = sum(data.values()) balances = { k: int(Fraction(v * total_distribution, total_vecrv)) for k, v in data.items() } balances = {k: v for k, v in balances.items() if v} # handle any rounding errors addresses = deque(balances) while sum(balances.values()) < total_distribution: balances[addresses[0]] += 1 addresses.rotate() assert sum(balances.values()) == total_distribution elements = [(index, account, balances[account]) for index, account in enumerate(sorted(balances))] nodes = [ encode_hex(encode_abi_packed(['uint', 'address', 'uint'], el)) for el in elements ] tree = MerkleTree(nodes) distribution = { 'merkleRoot': encode_hex(tree.root), 'tokenTotal': hex(sum(balances.values())), 'claims': { user: { 'index': index, 'amount': hex(amount), 'proof': tree.get_proof(nodes[index]) } for index, user, amount in elements }, } print(f'merkle root: {encode_hex(tree.root)}') with Path('distribution.json').open('w') as fp: json.dump(distribution, fp)
def prepare_merkle_tree(balances): elements = [(index, account, amount) for index, (account, amount) in enumerate(balances.items())] nodes = [ encode_abi_packed(["uint", "address", "uint"], el) for el in elements ] tree = MerkleTree(nodes) distribution = { "merkleRoot": encode_hex(tree.root), "tokenTotal": str(sum(balances.values())), "claims": { user: { "index": index, "amount": str(amount), "proof": tree.get_proof(nodes[index]), } for index, user, amount in elements }, } return distribution
def distribution(accounts): balances = {i.address: c * 10**18 for c, i in enumerate(accounts, start=1)} elements = [(index, account, amount) for index, (account, amount) in enumerate(balances.items())] nodes = [ encode_hex(encode_abi_packed(['uint', 'address', 'uint'], el)) for el in elements ] tree = MerkleTree(nodes) return { 'merkleRoot': encode_hex(tree.root), 'tokenTotal': hex(sum(balances.values())), 'claims': { user: { 'index': index, 'amount': hex(amount), 'proof': tree.get_proof(nodes[index]) } for index, user, amount in elements }, }
def test_sign_score(user, owner, monkeypatch): expected_signer = owner.address sig = sign_score(owner.key, CONTRACT, GAME_ID, user.address, SCORE) types = ['bytes32', 'address', 'uint256'] values = [ HexBytes(GAME_ID), user.address, SCORE, ] encoded_values = encode_abi_packed(types, values) message = encode_intended_validator( validator_address=CONTRACT, primitive=encoded_values, ) vrs = (sig['v'], sig['r'], sig['s']) actual_signer = Account.recover_message( message, vrs=vrs, ) assert actual_signer == expected_signer
def get_proof(balances, snapshot_block): total_distribution = (250000000 * 10**18) // 52 total_vecrv = sum(balances.values()) balances = { k: int(Fraction(v * total_distribution, total_vecrv)) for k, v in balances.items() } balances = {k: v for k, v in balances.items() if v} # handle any rounding errors addresses = deque(balances) while sum(balances.values()) < total_distribution: balances[addresses[0]] += 1 addresses.rotate() assert sum(balances.values()) == total_distribution elements = [(index, account, balances[account]) for index, account in enumerate(sorted(balances))] nodes = [ encode_hex(encode_abi_packed(['uint', 'address', 'uint'], el)) for el in elements ] tree = MerkleTree(nodes) distribution = { 'merkleRoot': encode_hex(tree.root), 'tokenTotal': hex(sum(balances.values())), 'blockHeight': snapshot_block, 'claims': { user: { 'index': index, 'amount': hex(amount), 'proof': tree.get_proof(nodes[index]) } for index, user, amount in elements }, } print(f'merkle root: {encode_hex(tree.root)}') return distribution
def encode_route_to_path(route: Route, exact_output: bool) -> str: """ Convert a route to a hex encoded path""" assert (isinstance(route, Route)) assert (isinstance(exact_output, bool)) route_input_token = route.input path_to_encode = {} path_to_encode["input_token"] = route_input_token for i, pool in enumerate(route.pools): output_token = pool.token_1 if pool.token_0 == path_to_encode[ "input_token"] else pool.token_0 if i == 0: path_to_encode["input_token"] = output_token path_to_encode["types"] = ['address', 'uint24', 'address'] path_to_encode["path"] = [ route_input_token.address.address, pool.fee, output_token.address.address ] else: path_to_encode["input_token"] = output_token path_to_encode["types"] = path_to_encode["types"] + [ 'uint24', 'address' ] path_to_encode["path"] = path_to_encode["path"] + [ pool.fee, output_token.address.address ] # encode if exact_output: path_to_encode["types"].reverse() path_to_encode["path"].reverse() encoded_path = encode_abi_packed(path_to_encode["types"], path_to_encode["path"]) return bytes_to_hexstring(encoded_path)
def encode_path(self, path): types = [type for _, type in zip(path, cycle(['address', 'uint24']))] return encode_abi_packed(types, path)
def to_node_entry(self, user, userData, cycle, index): nodeEntry = { "user": user, "tokens": [], "cumulativeAmounts": [], "cycle": cycle, "index": index, } intAmounts = [] for tokenAddress, cumulativeAmount in userData.items(): nodeEntry["tokens"].append(tokenAddress) nodeEntry["cumulativeAmounts"].append(str(cumulativeAmount)) intAmounts.append(int(cumulativeAmount)) # print( # int(nodeEntry["index"]), # nodeEntry["user"], # int(nodeEntry["cycle"]), # nodeEntry["tokens"], # intAmounts, # ) address = nodeEntry["tokens"][0] # print(address, address[2:]) bytearray.fromhex(address[2:]) encoded = encode_hex( encode_abi_packed( ["uint", "address", "uint", "address", "uint[]"], ( int(nodeEntry["index"]), nodeEntry["user"], int(nodeEntry["cycle"]), address, intAmounts, ), ) ) surgeryIndex = 64 + 40 + 64 + 2 after = encoded[surgeryIndex:] before = encoded[0:surgeryIndex] before = before + "000000000000000000000000" postSurgery = before + after # print("post", postSurgery) # encoder = ClaimEncoder.at("0x19be80e976cb397ae584d350153914ced7c1b1d2") # claim = encoder.encodeClaim( # nodeEntry["tokens"], # nodeEntry["cumulativeAmounts"], # nodeEntry["index"], # nodeEntry["cycle"], # nodeEntry["user"], # )[0] # local = encoder.encodeClaim.encode_input( # nodeEntry["tokens"], # nodeEntry["cumulativeAmounts"], # nodeEntry["index"], # nodeEntry["cycle"], # nodeEntry["user"], # ) # print("claim", claim) # print("encoded", encoded) # encoded = encode_hex(postSurgery) # print("encoded", encoded) # console.log("nodeEntry", nodeEntry) # console.log("encoded", encoded) return (nodeEntry, postSurgery)