def geth_wait_and_check(privatekeys, rpc_ports): """ Wait until the geth cluster is ready. """ address = address_encoder(privatekey_to_address(privatekeys[0])) jsonrpc_running = False tries = 5 rpc_port = rpc_ports[0] jsonrpc_client = JSONRPCClient(host="0.0.0.0", port=rpc_port, privkey=privatekeys[0], print_communication=False) while not jsonrpc_running and tries > 0: try: jsonrpc_client.call("eth_getBalance", address, "latest") jsonrpc_running = True except ConnectionError: gevent.sleep(0.5) tries -= 1 if jsonrpc_running is False: raise ValueError("geth didnt start the jsonrpc interface") for key in set(privatekeys): address = address_encoder(privatekey_to_address(key)) jsonrpc_client = JSONRPCClient(host="0.0.0.0", port=rpc_port, privkey=key, print_communication=False) tries = 10 balance = "0x0" while balance == "0x0" and tries > 0: balance = jsonrpc_client.call("eth_getBalance", address, "latest") gevent.sleep(1) tries -= 1 if balance == "0x0": raise ValueError("account is with a balance of 0")
class Client(): def __init__(self, tokens): self.client = JSONRPCClient( privkey=None, host=host, port=port, print_communication=False, ) self.wallet_translator = ContractTranslator(wallet_abi) self.tokens = tokens def get_block(self, num): return self.client.call( 'eth_getBlockByNumber', quantity_encoder(num), True ) def get_transaction(self, hash): return self.client.eth_getTransactionByHash(hash) def decode_token_transfer(self, txdata, to_address): if len(txdata) < 8 or txdata[:8] != 'a9059cbb': return None # get rid of signature txdata = txdata[8:] # here we got ourselves a token transfer # transfer(address _from, uint256 _value) token_name = self.tokens.address_is_token(to_address) if token_name is None: print('WARNING: Unknown token {} transferred'.format(to_address)) token_name = 'UNKNOWN' hexdata = txdata.decode('hex') transfer_to = decode_abi(['address'], hexdata[:32])[0] transfer_value = decode_abi(['uint256'], hexdata[32:])[0] if address_is_whitehat(transfer_to) is None: print('WARNING: {} token sent to non-whitehat address?'.format(token_name)) return transfer_value def decode_execute(self, txdata): # get rid of signature and 0x txdata = txdata[10:] # unfortunately the pyethapp way does not work # fndata = c.wallet_translator.function_data['execute'] # return decode_abi(fndata['encode_types'], txdata.decode('hex')) # ... but decoding each arg individually does work sent_to = decode_abi(['address'], txdata.decode('hex')[:32])[0] amount_in_wei = decode_abi(['uint256'], txdata.decode('hex')[32:64])[0] token_value = self.decode_token_transfer(txdata[256:], sent_to) return sent_to, amount_in_wei, token_value
def hydrachain_wait(privatekeys, number_of_nodes): """ Wait until the hydrchain cluster is ready. """ jsonrpc_client = JSONRPCClient( host='0.0.0.0', privkey=privatekeys[0], print_communication=False, ) quantity = jsonrpc_client.call('net_peerCount') tries = 5 while quantity != number_of_nodes and tries > 0: gevent.sleep(0.5) quantity = quantity_decoder(jsonrpc_client.call('net_peerCount')) if quantity != number_of_nodes: raise Exception('hydrachain is taking to long to initialize')
def hydrachain_wait(privatekeys, number_of_nodes): """ Wait until the hydrchain cluster is ready. """ jsonrpc_client = JSONRPCClient( host='0.0.0.0', privkey=privatekeys[0], print_communication=False, ) quantity = jsonrpc_client.call('net_peerCount') tries = 5 while quantity != number_of_nodes and tries > 0: gevent.sleep(0.5) quantity = quantity_decoder(jsonrpc_client.call('net_peerCount')) if quantity != number_of_nodes: raise Exception('hydrachain is taking to long to initialize')
class BuiltinDriver(base.Base): @property def type(self): return 'tx_driver' def __init__(self): self.logger = logger self.rpc_cli = JSONRPCClient(host = FLAGS.rpc_host, port = FLAGS.rpc_port, print_communication = False) super(BuiltinDriver, self).__init__() def pending_txs(self): self.filter_id = self.rpc_cli.call(constant.METHOD_NEW_PENDING_TX_FILTER) while True: res = self.rpc_cli.call(constant.METHOD_GET_FILTER_CHANGES, self.filter_id) if res: print res else: time.sleep(FLAGS.poll_interval)
def geth_wait_and_check(privatekeys, rpc_ports): """ Wait until the geth cluster is ready. """ address = address_encoder(privatekey_to_address(privatekeys[0])) jsonrpc_running = False tries = 5 rpc_port = rpc_ports[0] jsonrpc_client = JSONRPCClient( host='0.0.0.0', port=rpc_port, privkey=privatekeys[0], print_communication=False, ) while not jsonrpc_running and tries > 0: try: jsonrpc_client.call('eth_getBalance', address, 'latest') jsonrpc_running = True except ConnectionError: gevent.sleep(0.5) tries -= 1 if jsonrpc_running is False: raise ValueError('geth didnt start the jsonrpc interface') for key in set(privatekeys): address = address_encoder(privatekey_to_address(key)) jsonrpc_client = JSONRPCClient( host='0.0.0.0', port=rpc_port, privkey=key, print_communication=False, ) tries = 10 balance = '0x0' while balance == '0x0' and tries > 0: balance = jsonrpc_client.call('eth_getBalance', address, 'latest') gevent.sleep(1) tries -= 1 if balance == '0x0': raise ValueError('account is with a balance of 0')
def geth_wait_and_check(privatekeys): """ Wait until the geth cluster is ready. """ address = address_encoder(privtoaddr(privatekeys[0])) jsonrpc_running = False tries = 5 jsonrpc_client = JSONRPCClient( host='0.0.0.0', privkey=privatekeys[0], print_communication=False, ) while not jsonrpc_running and tries > 0: try: jsonrpc_client.call('eth_getBalance', address, 'latest') jsonrpc_running = True except ConnectionError: gevent.sleep(0.5) tries -= 1 if jsonrpc_running is False: raise ValueError('geth didnt start the jsonrpc interface') for key in set(privatekeys): address = address_encoder(privtoaddr(key)) jsonrpc_client = JSONRPCClient( host='0.0.0.0', privkey=key, print_communication=False, ) tries = 10 balance = '0x0' while balance == '0x0' and tries > 0: balance = jsonrpc_client.call('eth_getBalance', address, 'latest') gevent.sleep(1) tries -= 1 if balance == '0x0': raise ValueError('account is with a balance of 0')
def test_blockchain(blockchain_backend, private_keys, number_of_nodes, poll_timeout): # pylint: disable=too-many-locals addresses = [privatekey_to_address(priv) for priv in private_keys] privatekey = private_keys[0] address = privatekey_to_address(privatekey) total_asset = 100 jsonrpc_client = JSONRPCClient( privkey=privatekey, print_communication=False, ) patch_send_transaction(jsonrpc_client) humantoken_path = get_contract_path('HumanStandardToken.sol') humantoken_contracts = compile_file(humantoken_path, libraries=dict()) token_proxy = jsonrpc_client.deploy_solidity_contract( address, 'HumanStandardToken', humantoken_contracts, dict(), (total_asset, 'raiden', 2, 'Rd'), timeout=poll_timeout, ) registry_path = get_contract_path('Registry.sol') registry_contracts = compile_file(registry_path) registry_proxy = jsonrpc_client.deploy_solidity_contract( address, 'Registry', registry_contracts, dict(), tuple(), timeout=poll_timeout, ) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 0 # pylint: disable=no-member assert token_proxy.balanceOf(address) == total_asset transaction_hash = registry_proxy.addAsset.transact( token_proxy.address, gasprice=denoms.wei, ) jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout) assert len(registry_proxy.assetAddresses.call()) == 1 log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 1 channel_manager_address_encoded = registry_proxy.channelManagerByAsset.call( token_proxy.address) channel_manager_address = channel_manager_address_encoded.decode('hex') log = log_list[0] log_topics = [ decode_topic(topic) for topic in log['topics'] # pylint: disable=invalid-sequence-index ] log_data = log['data'] event = registry_proxy.translator.decode_event( log_topics, log_data[2:].decode('hex'), ) assert channel_manager_address == event['channelManagerAddress'].decode( 'hex') assert token_proxy.address == event['assetAddress'].decode('hex') channel_manager_proxy = jsonrpc_client.new_contract_proxy( registry_contracts['ChannelManagerContract']['abi'], channel_manager_address, ) transaction_hash = channel_manager_proxy.newChannel.transact( addresses[1], 10, gasprice=denoms.wei, ) jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 2
def test_blockchain( blockchain_type, blockchain_backend, # required to start the geth backend blockchain_rpc_ports, private_keys, poll_timeout): # pylint: disable=too-many-locals # this test is for interaction with a blockchain using json-rpc, so it # doesnt make sense to execute it against mock or tester if blockchain_type not in ('geth',): return addresses = [ privatekey_to_address(priv) for priv in private_keys ] privatekey = private_keys[0] address = privatekey_to_address(privatekey) total_token = 100 jsonrpc_client = JSONRPCClient( port=blockchain_rpc_ports[0], privkey=privatekey, print_communication=False, ) patch_send_transaction(jsonrpc_client) patch_send_message(jsonrpc_client) humantoken_path = get_contract_path('HumanStandardToken.sol') humantoken_contracts = compile_file(humantoken_path, libraries=dict()) token_proxy = jsonrpc_client.deploy_solidity_contract( address, 'HumanStandardToken', humantoken_contracts, dict(), (total_token, 'raiden', 2, 'Rd'), contract_path=humantoken_path, gasprice=default_gasprice, timeout=poll_timeout, ) registry_path = get_contract_path('Registry.sol') registry_contracts = compile_file(registry_path) registry_proxy = jsonrpc_client.deploy_solidity_contract( address, 'Registry', registry_contracts, dict(), tuple(), contract_path=registry_path, gasprice=default_gasprice, timeout=poll_timeout, ) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 0 # pylint: disable=no-member assert token_proxy.balanceOf(address) == total_token transaction_hash = registry_proxy.addToken.transact( token_proxy.address, gasprice=denoms.wei, ) jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout) assert len(registry_proxy.tokenAddresses.call()) == 1 log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 1 channel_manager_address_encoded = registry_proxy.channelManagerByToken.call( token_proxy.address, ) channel_manager_address = channel_manager_address_encoded.decode('hex') log = log_list[0] log_topics = [ decode_topic(topic) for topic in log['topics'] # pylint: disable=invalid-sequence-index ] log_data = log['data'] event = registry_proxy.translator.decode_event( log_topics, log_data[2:].decode('hex'), ) assert channel_manager_address == event['channel_manager_address'].decode('hex') assert token_proxy.address == event['token_address'].decode('hex') channel_manager_proxy = jsonrpc_client.new_contract_proxy( CHANNEL_MANAGER_ABI, channel_manager_address, ) transaction_hash = channel_manager_proxy.newChannel.transact( addresses[1], 10, gasprice=denoms.wei, ) jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 2
def test_blockchain( blockchain_type, blockchain_backend, # required to start the geth backend blockchain_rpc_ports, private_keys, poll_timeout): # pylint: disable=too-many-locals # this test is for interaction with a blockchain using json-rpc, so it # doesnt make sense to execute it against mock or tester if blockchain_type not in ('geth',): return addresses = [ privatekey_to_address(priv) for priv in private_keys ] privatekey = private_keys[0] address = privatekey_to_address(privatekey) total_asset = 100 jsonrpc_client = JSONRPCClient( port=blockchain_rpc_ports[0], privkey=privatekey, print_communication=False, ) patch_send_transaction(jsonrpc_client) humantoken_path = get_contract_path('HumanStandardToken.sol') humantoken_contracts = compile_file(humantoken_path, libraries=dict()) token_proxy = jsonrpc_client.deploy_solidity_contract( address, 'HumanStandardToken', humantoken_contracts, dict(), (total_asset, 'raiden', 2, 'Rd'), timeout=poll_timeout, ) registry_path = get_contract_path('Registry.sol') registry_contracts = compile_file(registry_path) registry_proxy = jsonrpc_client.deploy_solidity_contract( address, 'Registry', registry_contracts, dict(), tuple(), timeout=poll_timeout, ) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 0 # pylint: disable=no-member assert token_proxy.balanceOf(address) == total_asset transaction_hash = registry_proxy.addAsset.transact( token_proxy.address, gasprice=denoms.wei, ) jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout) assert len(registry_proxy.assetAddresses.call()) == 1 log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 1 channel_manager_address_encoded = registry_proxy.channelManagerByAsset.call( token_proxy.address, ) channel_manager_address = channel_manager_address_encoded.decode('hex') log = log_list[0] log_topics = [ decode_topic(topic) for topic in log['topics'] # pylint: disable=invalid-sequence-index ] log_data = log['data'] event = registry_proxy.translator.decode_event( log_topics, log_data[2:].decode('hex'), ) assert channel_manager_address == event['channel_manager_address'].decode('hex') assert token_proxy.address == event['asset_address'].decode('hex') channel_manager_proxy = jsonrpc_client.new_contract_proxy( registry_contracts['ChannelManagerContract']['abi'], channel_manager_address, ) transaction_hash = channel_manager_proxy.newChannel.transact( addresses[1], 10, gasprice=denoms.wei, ) jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 2
class BlockTest(unittest.TestCase): def setUp(self): self.db_proxy = dbproxy.MongoDBProxy() self.rpc_cli = JSONRPCClient(host = FLAGS.rpc_host, port = FLAGS.rpc_port, print_communication = False) self.handler = handler.BlockHandler(self.rpc_cli, logger, self.db_proxy) def test_fork(self): # old self.handler.blk_number = 2074903 old_block = self.rpc_cli.call("eth_getBlockByNumber", 2074903, True) self.handler.process_block(old_block) # new new_block = self.rpc_cli.call("eth_getBlockByNumber", 2074903, True) new_block['uncles'] = [] tx = self.rpc_cli.call("eth_getTransactionByHash", "0xa2d7bdf90e507979d7005399f2af77918a538d5288076b0e2a1308e7a419f1bc") tx["blockNumber"] = hex(2074903) new_block['hash'] = "0x123" new_block['transactions'] = [tx] self.handler.process_fork(old_block, new_block) # tx origin_tx_hash = "0xec50f325f70e08de1750c2655d867217a49dbba75ef09c66e1661be75e5fcafe" acc = self.db_proxy.get(FLAGS.accounts, {"address":"0x03da00938219676af361cfc22a49ab1e4a64fd6f"}, block_height = self.handler.blk_number) self.assertNotIn(origin_tx_hash, acc['tx_out']) txs = self.db_proxy.get(FLAGS.txs, {"blockNumber": hex(2074903)}, multi = True, block_height = 2074903) tx_hashes = [tx['hash'] for tx in txs] self.assertNotIn(origin_tx_hash, tx_hashes) self.assertIn(tx['hash'], tx_hashes) # block info block = self.db_proxy.get(FLAGS.blocks, {"number":2074903}, block_height = self.handler.blk_number) self.assertEqual(block['hash'], "0x123") # uncle buncle1 = self.db_proxy.get(FLAGS.uncles, {"mainNumber":2074903, "hash":"0xe83ede60f9ee37d506101d542578d7a26236829364a36652c0bd0d9e6652a0db"}, block_height = self.handler.blk_number) self.assertEqual(buncle1, None) def test_process_block(self): self.handler.blk_number = 2074903 block = self.rpc_cli.call("eth_getBlockByNumber", 2074903, True) self.handler.process_block(block) # block blk = self.db_proxy.get(FLAGS.blocks, {"number":self.handler.blk_number}, block_height = self.handler.blk_number) self.assertEqual(blk['hash'], '0xcb3d7de2ed7817fb5c5763c7cf8429ad0efb12ad4f14420c9ab56b71664f77d4') # account res = self.db_proxy.get(FLAGS.accounts, {"address":"0x2a65aca4d5fc5b5c859090a6c34d164135398226"}, block_height = self.handler.blk_number) # 1 mine mine = res['mine'] self.assertIn(blk['hash'], mine) # 2 uncle buncle = self.db_proxy.get(FLAGS.uncles, {"mainNumber":2074903}, block_height = self.handler.blk_number) self.assertEqual(buncle['mainNumber'], 2074903) # 3 tx txs = self.db_proxy.search(FLAGS.txs, {"blockNumber": hex(2074903)}, multi = True) self.assertEqual(len(txs), 2) def test_process_by_hash(self): self.handler.blk_number = 2074903 block = "0xcb3d7de2ed7817fb5c5763c7cf8429ad0efb12ad4f14420c9ab56b71664f77d4" self.handler.execute(block, True) # block blk = self.db_proxy.get(FLAGS.blocks, {"number":self.handler.blk_number}, block_height = self.handler.blk_number) self.assertEqual(blk['hash'], '0xcb3d7de2ed7817fb5c5763c7cf8429ad0efb12ad4f14420c9ab56b71664f77d4') # account res = self.db_proxy.get(FLAGS.accounts, {"address":"0x2a65aca4d5fc5b5c859090a6c34d164135398226"}, block_height = self.handler.blk_number) # 1 mine mine = res['mine'] self.assertIn(blk['hash'], mine) # 2 uncle buncle = self.db_proxy.get(FLAGS.uncles, {"mainNumber":2074903}, block_height = self.handler.blk_number) self.assertEqual(buncle['mainNumber'], 2074903) # 3 tx txs = self.db_proxy.search(FLAGS.txs, {"blockNumber": hex(2074903)}, multi = True) self.assertEqual(len(txs), 2) def test_revert(self): self.handler.blk_number = 2074903 block = self.rpc_cli.call("eth_getBlockByNumber", 2074903, True) txs = block['transactions'] self.handler.process_block(block) blk = self.db_proxy.get(FLAGS.blocks, {"number":self.handler.blk_number}, block_height = self.handler.blk_number) self.handler.revert(blk,txs) # block blk = self.db_proxy.get(FLAGS.blocks, {"number":self.handler.blk_number}, block_height = self.handler.blk_number) self.assertEqual(blk, None) # account res = self.db_proxy.get(FLAGS.accounts, {"address":"0x2a65aca4d5fc5b5c859090a6c34d164135398226"}, block_height = self.handler.blk_number) # 1 mine mine = res['mine'] self.assertEqual(mine, []) # 2 tx txs = self.db_proxy.search(FLAGS.txs, {"blockNumber": hex(2074903)}, multi = True) self.assertEqual(len(txs), 0) def test_add_genesis(self): FLAGS.genesis_data = "../genesisdata/genesis_frontier.json" driver = builtin.BuiltinDriver() driver.add_genesis_data() # block blk = self.db_proxy.get(FLAGS.blocks, {"number":0}, block_height = 0) self.assertEqual(blk['hash'], '0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3') # account acct = self.db_proxy.get(FLAGS.accounts, {"address":"0x3282791d6fd713f1e94f4bfd565eaa78b3a0599d"}, block_height = 0) # 1 tx res = self.db_proxy.get(FLAGS.txs, None, block_height=0, multi = True) self.assertEqual(len(res), 8893) def test_process_tx(self): # block 1700002 tx_hash = "0xa2d7bdf90e507979d7005399f2af77918a538d5288076b0e2a1308e7a419f1bc" tx_obj = self.rpc_cli.call("eth_getTransactionByHash", tx_hash) self.handler.blk_number = 1700002 self.handler.process_tx(tx_obj, None) # tx tx = self.db_proxy.get(FLAGS.txs, {"hash":tx_hash}, block_height = 1700002, multi = False) self.assertEqual(tx["hash"], tx_hash) self.assertEqual(utils.convert_to_int(tx['gasUsed']), 21000) # 1 account acc1 = self.db_proxy.get(FLAGS.accounts, {"address":"0x4bb96091ee9d802ed039c4d1a5f6216f90f81b01"}, block_height = 1700002, multi = False) acc2 = self.db_proxy.get(FLAGS.accounts, {"address":"0xae8f3c8d1134e50a7c63c39d78406ab7334149ac"}, block_height = 1700002, multi = False) self.assertIn(tx['hash'], acc1['tx_out']) self.assertIn(tx['hash'], acc2['tx_in']) # create contract tx # insert tx_hash = "0xfeae1ff3cf9b6927d607744e3883ea105fb16042d4639857d9cfce3eba644286" tx_obj = self.rpc_cli.call("eth_getTransactionByHash", tx_hash) self.handler.blk_number = 1883496 self.handler.process_tx(tx_obj, None) # tx tx = self.db_proxy.get(FLAGS.txs, {"hash":tx_hash}, block_height = 1883496, multi = False) self.assertEqual(tx["hash"], tx_hash) self.assertEqual(utils.convert_to_int(tx['gasUsed']), 368040) # account # 1 account acc1 = self.db_proxy.get(FLAGS.accounts, {"address":"0x2ef1f605af5d03874ee88773f41c1382ac71c239"}, block_height = 1883496, multi = False) acc2 = self.db_proxy.get(FLAGS.accounts, {"address":"0xbf4ed7b27f1d666546e30d74d50d173d20bca754"}, block_height = 1883496, multi = False) self.assertIn(tx['hash'], acc1['tx_out']) self.assertIn(tx['hash'], acc2['tx_in']) self.assertEqual(acc2['is_contract'], 1) def test_revert_tx(self): # insert tx_hash = "0xa2d7bdf90e507979d7005399f2af77918a538d5288076b0e2a1308e7a419f1bc" tx_obj = self.rpc_cli.call("eth_getTransactionByHash", tx_hash) self.handler.blk_number = 1700002 self.handler.process_tx(tx_obj, None) # revert tx = self.db_proxy.get(FLAGS.txs, {"hash":tx_hash}, block_height = 1700002, multi = False) self.handler.revert_tx(tx, 1700002) # tx res = self.db_proxy.get(FLAGS.txs, {"hash":tx_hash}, block_height = 1700002, multi = False) self.assertEqual(res, None) # account # 1 account acc1 = self.db_proxy.get(FLAGS.accounts, {"address":"0x4bb96091ee9d802ed039c4d1a5f6216f90f81b01"}, block_height = 1700002, multi = False) acc2 = self.db_proxy.get(FLAGS.accounts, {"address":"0xae8f3c8d1134e50a7c63c39d78406ab7334149ac"}, block_height = 1700002, multi = False) self.assertNotIn(tx['hash'], acc1['tx_out']) self.assertNotIn(tx['hash'], acc2['tx_in']) # create contract tx # insert tx_hash = "0xfeae1ff3cf9b6927d607744e3883ea105fb16042d4639857d9cfce3eba644286" tx_obj = self.rpc_cli.call("eth_getTransactionByHash", tx_hash) self.handler.blk_number = 1883496 self.handler.process_tx(tx_obj, None) # revert tx = self.db_proxy.get(FLAGS.txs, {"hash":tx_hash}, block_height = 1883496, multi = False) self.handler.revert_tx(tx, 1883496) # tx res = self.db_proxy.get(FLAGS.txs, {"hash":tx_hash}, block_height = 1883496, multi = False) self.assertEqual(res, None) # account # 1 account acc1 = self.db_proxy.get(FLAGS.accounts, {"address":"0x2ef1f605af5d03874ee88773f41c1382ac71c239"}, block_height = 1883496, multi = False) acc2 = self.db_proxy.get(FLAGS.accounts, {"address":"0xbf4ed7b27f1d666546e30d74d50d173d20bca754"}, block_height = 1883496, multi = False) self.assertEqual(acc2, None) self.assertNotIn(tx['hash'], acc1['tx_out']) def test_process_uncle(self): # block 2122962 blk_hash = "0xa9389966cec0062be52f16440e9ee9447e849698934b62aac93138fdfdb751b1" blk_obj = self.rpc_cli.call("eth_getBlockByHash", blk_hash, False) self.handler.blk_number = 2122962 self.handler.process_uncle(blk_obj) # uncle uncle = self.db_proxy.get(FLAGS.uncles, {"hash":"0xa05ba9c6f686d92ef62a1adf18c3c97ed9041b3341de74c20d3cb421216a7f48"}, block_height = 2122962, multi = False) self.assertEqual(uncle['mainNumber'], 2122962) self.assertEqual(uncle['hash'], "0xa05ba9c6f686d92ef62a1adf18c3c97ed9041b3341de74c20d3cb421216a7f48") self.assertEqual(uncle['reward'], utils.unit_convert_from_ether(4.375)) # account acc = self.db_proxy.get(FLAGS.accounts, {"address":"0x2a65aca4d5fc5b5c859090a6c34d164135398226"}, block_height = 2122962, multi = False) # 1 mine mine_uncles = acc['uncles'] self.assertIn(uncle['hash'], mine_uncles) def test_revert_uncle(self): # block 2122962 blk_hash = "0xa9389966cec0062be52f16440e9ee9447e849698934b62aac93138fdfdb751b1" blk_obj = self.rpc_cli.call("eth_getBlockByHash", blk_hash, False) self.handler.blk_number = 2122962 self.handler.process_uncle(blk_obj) self.handler.revert_uncle(blk_obj) # uncle uncle = self.db_proxy.get(FLAGS.uncles, {"hash":"0xa05ba9c6f686d92ef62a1adf18c3c97ed9041b3341de74c20d3cb421216a7f48"}, block_height = 2122962, multi = False) self.assertEqual(uncle, None) # account acc = self.db_proxy.get(FLAGS.accounts, {"address":"0x2a65aca4d5fc5b5c859090a6c34d164135398226"}, block_height = 2122962, multi = False) # 1 mine mine_uncles = acc['uncles'] self.assertEqual(mine_uncles, []) def test_set_balance(self): block_num = 2142168 block = self.rpc_cli.call("eth_getBlockByNumber", block_num, True) shandler = handler.BlockHandler(self.rpc_cli, logger, self.db_proxy, True) shandler.blk_number = block_num shandler.process_block(block) # miner, tx-out acct tx-in acct uncle-miner accts = ["0xbcdfc35b86bedf72f0cda046a3c16829a2ef41d1","0x362db1e4830bf2c401d7f9f45034f5e6e1c46a0b", "0xbfc39b6f805a9e40e77291aff27aee3c96915bdd", "0x6cafe7473925998db07a497ac3fd10405637a46d"] balances = [self.rpc_cli.call("eth_getBalance", acct, block_num) for acct in accts] for _,acct in enumerate(accts): res = self.db_proxy.get(FLAGS.accounts, {"address":acct}, multi = False, block_height = block_num) self.assertEqual(res['balance'], balances[_]) def test_sync_balance(self): # insert account data accounts = ["0x3282791d6fd713f1e94f4bfd565eaa78b3a0599d", "0x17961d633bcf20a7b029a7d94b7df4da2ec5427f", "0x493a67fe23decc63b10dda75f3287695a81bd5ab"] for _, acct in enumerate(accounts): self.db_proxy.insert(FLAGS.accounts, {"address":acct}, block_height = _ * FLAGS.table_capacity) self.handler._sync_balance(100) res = self.db_proxy.get(FLAGS.meta, {"sync_record":"ethereum"}, multi = False) self.assertEqual(res["last_sync_block"], 100) def tearDown(self): self.db_proxy.drop_db(FLAGS.mongodb_default_db)
class TestDriverThread(Thread): def __init__(self, group=None, target=None, name=None, args=(), kwargs=None, verbose=None, gasprice=None, evt=None, port=4000): super(TestDriverThread, self).__init__(group, target, name, args, kwargs, verbose) self.gasprice = gasprice self.log = slogging.getLogger('test_working_app') self.test_successful = False self.finished = False self.evt = evt self.port = port def wait_for_blocknumber(self, number, retry=20): block = self.client.call('eth_getBlockByNumber', hex(number), False) while block is None and retry > 0: block = self.client.call('eth_getBlockByNumber', hex(number), False) time.sleep(.5) retry -= 1 assert retry > 0, "could not find block {}".format(number) return block def connect_client(self): while True: try: self.client = JSONRPCClient(port=self.port, print_communication=False) self.client.call('web3_clientVersion') break except ConnectionError: time.sleep(0.5) def run(self): self.log.debug('test started') try: self.connect_client() self.log.debug('client connected') # Read initial blocks created by HydraChain on startup self.wait_for_blocknumber(10) self.log.debug("found block number 10") # Create a contract params = { 'from': self.client.coinbase.encode('hex'), 'to': '', 'data': contract_code, 'gasPrice': '0x{}'.format(self.gasprice) } self.client.call('eth_sendTransaction', params) self.log.debug('eth_sendTransaction OK') # Wait for new block recent_block = self.wait_for_blocknumber(11) self.log.debug('recent_block_hash {}'.format(recent_block)) block = self.client.call('eth_getBlockByHash', recent_block['hash'], True) self.log.debug('eth_getBlockByHash OK {}'.format(block)) assert block['transactions'], 'no transactions in block' tx = block['transactions'][0] assert tx['to'] == '0x' assert tx['gasPrice'] == params['gasPrice'] assert len(tx['input']) > len('0x') assert tx['input'].startswith('0x') # Get transaction receipt to have the address of contract receipt = self.client.call('eth_getTransactionReceipt', tx['hash']) self.log.debug('eth_getTransactionReceipt OK {}'.format(receipt)) assert receipt['transactionHash'] == tx['hash'] assert receipt['blockHash'] == tx['blockHash'] assert receipt['blockHash'] == block['hash'] # Get contract address from receipt contract_address = receipt['contractAddress'] code = self.client.call('eth_getCode', contract_address) self.log.debug('eth_getCode OK {}'.format(code)) assert code.startswith('0x') assert len(code) > len('0x') # Perform some action on contract (set value to random number) rand_value = random.randint(64, 1024) contract = self.client.new_abi_contract(contract_interface, contract_address) contract.set(rand_value, gasprice=self.gasprice) self.log.debug('contract.set({}) OK'.format(rand_value)) # Wait for new block recent_block = self.wait_for_blocknumber(12) # recent_block_hash = self.wait_for_new_block() block = self.client.call('eth_getBlockByHash', recent_block['hash'], True) # Check that value was correctly set on contract res = contract.get() self.log.debug('contract.get() OK {}'.format(res)) assert res == rand_value self.test_successful = True except Exception as ex: print("Exception", ex) import traceback traceback.print_exc() self.log.exception("Exception in test thread") finally: self.evt.set() self.finished = True
def test_blockchain(request): # pylint: disable=too-many-locals from hydrachain import app app.slogging.configure(':ERROR') quantity = 3 base_port = 29870 timeout = 3 # seconds tmp_datadir = tempfile.mktemp() private_keys = [ mk_privkey('raidentest:{}'.format(position)) for position in range(quantity) ] addresses = [ privtoaddr(priv) for priv in private_keys ] hydrachain_apps = hydrachain_network(private_keys, base_port, tmp_datadir) privatekey = private_keys[0] address = privtoaddr(privatekey) jsonrpc_client = JSONRPCClient(privkey=private_keys[0], print_communication=False) humantoken_path = get_contract_path('HumanStandardToken.sol') humantoken_contracts = compile_file(humantoken_path, libraries=dict()) token_abi = jsonrpc_client.deploy_solidity_contract( address, 'HumanStandardToken', humantoken_contracts, dict(), (9999, 'raiden', 2, 'Rd'), timeout=timeout, ) registry_path = get_contract_path('Registry.sol') registry_contracts = compile_file(registry_path, libraries=dict()) registry_abi = jsonrpc_client.deploy_solidity_contract( address, 'Registry', registry_contracts, dict(), tuple(), timeout=timeout, ) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 0 # pylint: disable=no-member assert token_abi.balanceOf(address) == 9999 transaction_hash = registry_abi.addAsset(token_abi.address) jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=timeout) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 1 channel_manager_address_encoded = registry_abi.channelManagerByAsset.call(token_abi.address) channel_manager_address = channel_manager_address_encoded.decode('hex') log_channel_manager_address_encoded = log_list[0]['data'] log_channel_manager_address = log_channel_manager_address_encoded[2:].lstrip('0').rjust(40, '0').decode('hex') assert channel_manager_address == log_channel_manager_address channel_manager_abi = jsonrpc_client.new_contract_proxy( registry_contracts['ChannelManagerContract']['abi'], channel_manager_address, ) transaction_hash = channel_manager_abi.newChannel(addresses[1], 10) jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=timeout) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 2 channel_manager_abi.get.call( address.encode('hex'), addresses[1].encode('hex'), )
class BuiltinDriver(base.TokenBuiltinBase): @property def type(self): return 'DGD' @property def event(self): return constant.DGD_EVENT @property def last_block(self): return self._last_block def __init__(self): self.logger = logger self.rpc_cli = JSONRPCClient(host = FLAGS.rpc_host, port = FLAGS.rpc_port, print_communication = False) super(BuiltinDriver, self).__init__() def initialize(self): self.add_indexes_for_token(self.type) res = self.db_proxy.get(FLAGS.token_prefix + self.type, {"type": self.event}, multi = True, sort_key = "block", ascend = False, limit = 1) if res: self._last_block = res[0]['block'] else: self._last_block = None # add token basic info source_code = self.get_source_code(self.type) abi = self.get_abi(self.type, constant.DGD_CONTRACT_NAME) basic_info = dict( token=self.type, source_code=source_code, abi=abi, address=constant.DGD_ADDR ) self.db_proxy.update(FLAGS.token_basic, {"token":self.type}, {"$set":basic_info}, upsert = True) def get_past_logs(self): self.abi = self.get_abi(self.type, constant.DGD_CONTRACT_NAME) event_id = self.get_event_id(self.abi, self.event) from_block = hex(self.last_block) if self.last_block else "0x0" params = { "fromBlock": from_block, "toBlock": "latest", "address": constant.DGD_ADDR, "topics": [event_id, None, None] } self.filter_id = self.rpc_cli.call(constant.METHOD_NEW_FILTER, params) res = self.rpc_cli.call(constant.METHOD_GET_FILTER_LOGS, self.filter_id) for log in res: self.handle_log(log) def handle_log(self, log): if log.has_key("removed"): del log['removed'] hash = _utils.hash_log(log) transfer_table = FLAGS.token_prefix + self.type balance_table = FLAGS.balance_prefix + self.type data = log['data'][2:].decode('hex') data_params = self.data_params(self.abi, self.event) value = _abi.decode_abi(data_params, data)[0] f = '0x' + log['topics'][1].lower()[26:] to = '0x' + log['topics'][2].lower()[26:] operation = { "$set": { "hash" : hash, "from" : f, "to" : to, "value" : value, "transactionHash" : log["transactionHash"], "logIndex" : log["logIndex"], "block" : int(log["blockNumber"], 16), "blockHash" : log["blockHash"], "type" : self.event } } objectId = self.db_proxy.update(transfer_table, {"hash":hash}, operation, multi = False, upsert = True).upserted_id if objectId is None: self.logger.info("event log %s has been add, ignore it", hash) return # update balance # TODO parse demical of token operation = { "$inc" : {"balance" : value * -1} } self.db_proxy.update(balance_table, {"account" : f}, operation, upsert = True) operation2 = { "$inc" : {"balance" : value } } self.db_proxy.update(balance_table, {"account" : to}, operation2, upsert = True) def revert_log(self, log): if log.has_key("removed"): del log['removed'] hash = _utils.hash_log(log) transfer_table = FLAGS.token_prefix + self.type balance_table = FLAGS.balance_prefix + self.type data = log['data'][2:].decode('hex') data_params = self.data_params(self.abi, self.event) value = _abi.decode_abi(data_params, data)[0] f = '0x' + log['topics'][1].lower()[26:] to = '0x' + log['topics'][2].lower()[26:] deleted_count = self.db_proxy.delete(transfer_table, { "hash" : hash, }, multi = False).deleted_count if deleted_count == 0: self.logger.info("event log %s has been deleted, ignore it", hash) return # update balance # TODO parse demical of token operation = { "$inc" : {"balance" : value * 1} } self.db_proxy.update(balance_table, {"account" : f}, operation, upsert = True) operation2 = { "$inc" : {"balance" : value * -1} } self.db_proxy.update(balance_table, {"account" : to}, operation2, upsert = True) def wait(self): self.listener.join()
def test_blockchain(request): # pylint: disable=too-many-locals from hydrachain import app app.slogging.configure(':ERROR') quantity = 3 base_port = 29870 timeout = 3 # seconds tmp_datadir = tempfile.mktemp() private_keys = [ mk_privkey('raidentest:{}'.format(position)) for position in range(quantity) ] addresses = [privtoaddr(priv) for priv in private_keys] hydrachain_apps = hydrachain_network(private_keys, base_port, tmp_datadir) privatekey = private_keys[0] address = privtoaddr(privatekey) jsonrpc_client = JSONRPCClient(privkey=private_keys[0], print_communication=False) humantoken_path = get_contract_path('HumanStandardToken.sol') humantoken_contracts = compile_file(humantoken_path, libraries=dict()) token_abi = jsonrpc_client.deploy_solidity_contract( address, 'HumanStandardToken', humantoken_contracts, dict(), (9999, 'raiden', 2, 'Rd'), timeout=timeout, ) registry_path = get_contract_path('Registry.sol') registry_contracts = compile_file(registry_path, libraries=dict()) registry_abi = jsonrpc_client.deploy_solidity_contract( address, 'Registry', registry_contracts, dict(), tuple(), timeout=timeout, ) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 0 # pylint: disable=no-member assert token_abi.balanceOf(address) == 9999 transaction_hash = registry_abi.addAsset(token_abi.address) jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=timeout) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 1 channel_manager_address_encoded = registry_abi.channelManagerByAsset.call( token_abi.address) channel_manager_address = channel_manager_address_encoded.decode('hex') log_channel_manager_address_encoded = log_list[0]['data'] log_channel_manager_address = log_channel_manager_address_encoded[ 2:].lstrip('0').rjust(40, '0').decode('hex') assert channel_manager_address == log_channel_manager_address channel_manager_abi = jsonrpc_client.new_contract_proxy( registry_contracts['ChannelManagerContract']['abi'], channel_manager_address, ) transaction_hash = channel_manager_abi.newChannel(addresses[1], 10) jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=timeout) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 2 channel_manager_abi.get.call( address.encode('hex'), addresses[1].encode('hex'), )