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_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 deployed_network(request, private_keys, channels_per_node, deposit, number_of_assets, settle_timeout, poll_timeout, transport_class, geth_cluster): gevent.sleep(2) assert channels_per_node in (0, 1, 2, CHAIN), ( 'deployed_network uses create_sequential_network that can only work ' 'with 0, 1 or 2 channels' ) privatekey = private_keys[0] address = privtoaddr(privatekey) blockchain_service_class = BlockChainService jsonrpc_client = JSONRPCClient( host='0.0.0.0', privkey=privatekey, print_communication=False, ) patch_send_transaction(jsonrpc_client) humantoken_path = get_contract_path('HumanStandardToken.sol') registry_path = get_contract_path('Registry.sol') humantoken_contracts = compile_file(humantoken_path, libraries=dict()) registry_contracts = compile_file(registry_path, libraries=dict()) registry_proxy = jsonrpc_client.deploy_solidity_contract( address, 'Registry', registry_contracts, dict(), tuple(), timeout=poll_timeout, ) registry_address = registry_proxy.address # Using 3 * deposit because we assume that is the maximum number of # channels that will be created. # `total_per_node = channels_per_node * deposit` total_per_node = 3 * deposit total_asset = total_per_node * len(private_keys) asset_addresses = [] for _ in range(number_of_assets): token_proxy = jsonrpc_client.deploy_solidity_contract( address, 'HumanStandardToken', humantoken_contracts, dict(), (total_asset, 'raiden', 2, 'Rd'), timeout=poll_timeout, ) asset_address = token_proxy.address assert len(asset_address) asset_addresses.append(asset_address) transaction_hash = registry_proxy.addAsset(asset_address) # pylint: disable=no-member jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout) # only the creator of the token starts with a balance, transfer from # the creator to the other nodes for transfer_to in private_keys: if transfer_to != jsonrpc_client.privkey: transaction_hash = token_proxy.transfer( # pylint: disable=no-member privtoaddr(transfer_to), total_per_node, startgas=GAS_LIMIT, ) jsonrpc_client.poll(transaction_hash.decode('hex')) for key in private_keys: assert token_proxy.balanceOf(privtoaddr(key)) == total_per_node # pylint: disable=no-member raiden_apps = create_sequential_network( private_keys, asset_addresses[0], registry_address, channels_per_node, deposit, settle_timeout, poll_timeout, transport_class, blockchain_service_class, ) _raiden_cleanup(request, raiden_apps) return raiden_apps
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
def deployed_network(request, private_keys, channels_per_node, deposit, number_of_assets, settle_timeout, poll_timeout, transport_class, geth_cluster): gevent.sleep(2) assert channels_per_node in (0, 1, 2, CHAIN), ( 'deployed_network uses create_sequential_network that can only work ' 'with 0, 1 or 2 channels') privatekey = private_keys[0] address = privtoaddr(privatekey) blockchain_service_class = BlockChainService jsonrpc_client = JSONRPCClient( host='0.0.0.0', privkey=privatekey, print_communication=False, ) patch_send_transaction(jsonrpc_client) humantoken_path = get_contract_path('HumanStandardToken.sol') registry_path = get_contract_path('Registry.sol') humantoken_contracts = compile_file(humantoken_path, libraries=dict()) registry_contracts = compile_file(registry_path, libraries=dict()) registry_proxy = jsonrpc_client.deploy_solidity_contract( address, 'Registry', registry_contracts, dict(), tuple(), timeout=poll_timeout, ) registry_address = registry_proxy.address # Using 3 * deposit because we assume that is the maximum number of # channels that will be created. # `total_per_node = channels_per_node * deposit` total_per_node = 3 * deposit total_asset = total_per_node * len(private_keys) asset_addresses = [] for _ in range(number_of_assets): token_proxy = jsonrpc_client.deploy_solidity_contract( address, 'HumanStandardToken', humantoken_contracts, dict(), (total_asset, 'raiden', 2, 'Rd'), timeout=poll_timeout, ) asset_address = token_proxy.address assert len(asset_address) asset_addresses.append(asset_address) transaction_hash = registry_proxy.addAsset(asset_address) # pylint: disable=no-member jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout) # only the creator of the token starts with a balance, transfer from # the creator to the other nodes for transfer_to in private_keys: if transfer_to != jsonrpc_client.privkey: transaction_hash = token_proxy.transfer( # pylint: disable=no-member privtoaddr(transfer_to), total_per_node, startgas=GAS_LIMIT, ) jsonrpc_client.poll(transaction_hash.decode('hex')) for key in private_keys: assert token_proxy.balanceOf(privtoaddr(key)) == total_per_node # pylint: disable=no-member raiden_apps = create_sequential_network( private_keys, asset_addresses[0], registry_address, channels_per_node, deposit, settle_timeout, poll_timeout, transport_class, blockchain_service_class, ) _raiden_cleanup(request, raiden_apps) return raiden_apps
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'), )
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'), )