def test_token_approve(): test_path = os.path.join(os.path.dirname(__file__), 'SimpleApproveTransfer.sol') standard_token_path = get_contract_path('StandardToken.sol') human_token_path = get_contract_path('HumanStandardToken.sol') state = tester.state() state.block.number = 1158001 address0 = tester.a0 address1 = tester.a1 standard_token = state.abi_contract( None, path=standard_token_path, language='solidity', ) contract_libraries = { 'StandardToken': standard_token.address.encode('hex'), } human_token = state.abi_contract( None, path=human_token_path, language='solidity', libraries=contract_libraries, constructor_parameters=[10000, 'raiden', 0, 'rd'], ) test = state.abi_contract( None, path=test_path, language='solidity', constructor_parameters=[human_token.address], ) # pylint: disable=no-member assert human_token.balanceOf(address0) == 10000 assert human_token.balanceOf(address1) == 0 assert human_token.balanceOf(test.address) == 0 assert human_token.allowance(address0, address0) == 0 assert human_token.allowance(address0, address1) == 0 assert human_token.allowance(address0, test.address) == 0 assert human_token.approve(test.address, 5000) is True assert human_token.balanceOf(address0) == 10000 assert human_token.balanceOf(address1) == 0 assert human_token.balanceOf(test.address) == 0 assert human_token.allowance(address0, address0) == 0 assert human_token.allowance(address0, address1) == 0 assert human_token.allowance(address0, test.address) == 5000 assert test.transfer(address1, 2000) is True assert human_token.balanceOf(address0) == 10000 - 2000 assert human_token.balanceOf(address1) == 0 + 2000 assert human_token.balanceOf(test.address) == 0 assert human_token.allowance(address0, address0) == 0 assert human_token.allowance(address0, address1) == 0 assert human_token.allowance(address0, test.address) == 5000 - 2000
def tester_token_address(private_keys, asset_amount, tester_state): standard_token_path = get_contract_path('StandardToken.sol') human_token_path = get_contract_path('HumanStandardToken.sol') standard_token_address = tester_state.contract( None, path=standard_token_path, language='solidity', ) tester_state.mine(number_of_blocks=1) human_token_libraries = { 'StandardToken': standard_token_address.encode('hex'), } # using abi_contract because of the constructor_parameters human_token_proxy = tester_state.abi_contract( None, path=human_token_path, language='solidity', libraries=human_token_libraries, constructor_parameters=[asset_amount, 'raiden', 0, 'rd'], sender=private_keys[0], ) tester_state.mine(number_of_blocks=1) human_token_address = human_token_proxy.address return human_token_address
def test_token(): standard_token_path = get_contract_path('StandardToken.sol') human_token_path = get_contract_path('HumanStandardToken.sol') state = tester.state() state.block.number = 1158001 address0 = tester.a0 address1 = tester.a1 standard_token = state.abi_contract( None, path=standard_token_path, language='solidity', ) contract_libraries = { 'StandardToken': standard_token.address.encode('hex'), } human_token = state.abi_contract( None, path=human_token_path, language='solidity', libraries=contract_libraries, constructor_parameters=[10000, 'raiden', 0, 'rd'], ) # pylint: disable=no-member assert human_token.balanceOf(address0) == 10000 assert human_token.balanceOf(address1) == 0 assert human_token.transfer(address1, 5000) is True assert human_token.balanceOf(address0) == 5000 assert human_token.balanceOf(address1) == 5000
def test_token(): token_library_path = get_contract_path('StandardToken.sol') token_path = get_contract_path('HumanStandardToken.sol') state = tester.state() assert state.block.number < 1150000 state.block.number = 1158001 assert state.block.number > 1150000 token = state.abi_contract( None, path=token_library_path, language='solidity', ) contract_libraries = { 'StandardToken': token.address.encode('hex'), } contract = state.abi_contract( None, path=token_path, language='solidity', libraries=contract_libraries, constructor_parameters=[10000, 'raiden', 0, 'rd'], ) # pylint: disable=no-member assert contract.balanceOf(tester.a0) == 10000 assert contract.balanceOf(tester.a1) == 0 assert contract.transfer(tester.a1, 5000) is True assert contract.balanceOf(tester.a0) == 5000 assert contract.balanceOf(tester.a1) == 5000
def test_ncc(): token_library_path = get_contract_path('StandardToken.sol') token_path = get_contract_path('HumanStandardToken.sol') state = tester.state() assert state.block.number < 1150000 state.block.number = 1158001 assert state.block.number > 1150000 token = state.abi_contract( None, path=token_library_path, language='solidity', ) contract_libraries = { 'StandardToken': token.address.encode('hex'), } contract = state.abi_contract( None, path=token_path, language='solidity', libraries=contract_libraries, constructor_parameters=[10000, 'raiden', 0, 'rd'], ) # pylint: disable=no-member assert contract.balanceOf(tester.a0) == 10000 assert contract.balanceOf(tester.a1) == 0 assert contract.transfer(tester.a1, 5000) is True assert contract.balanceOf(tester.a0) == 5000 assert contract.balanceOf(tester.a1) == 5000
def discovery_blockchain(request, private_keys, geth_cluster, poll_timeout): gevent.sleep(2) privatekey = private_keys[0] address = privtoaddr(privatekey) jsonrpc_client = JSONRPCClient( host='0.0.0.0', privkey=privatekey, print_communication=False, ) patch_send_transaction(jsonrpc_client) # deploy discovery contract discovery_contract_path = get_contract_path('EndpointRegistry.sol') discovery_contracts = compile_file(discovery_contract_path, libraries=dict()) discovery_contract_proxy = jsonrpc_client.deploy_solidity_contract( address, 'EndpointRegistry', discovery_contracts, dict(), tuple(), timeout=poll_timeout, ) discovery_contract_address = discovery_contract_proxy.address # initialize and return ContractDiscovery object from raiden.network.discovery import ContractDiscovery return ContractDiscovery(jsonrpc_client, discovery_contract_address), address
def discovery_blockchain(request, private_keys, geth_cluster, poll_timeout): gevent.sleep(2) privatekey = private_keys[0] address = privtoaddr(privatekey) jsonrpc_client = JSONRPCClient( host='0.0.0.0', privkey=privatekey, print_communication=False, ) patch_send_transaction(jsonrpc_client) # deploy discovery contract discovery_contract_path = get_contract_path('EndpointRegistry.sol') discovery_contracts = compile_file(discovery_contract_path, libraries=dict()) discovery_contract_proxy = jsonrpc_client.deploy_solidity_contract( address, 'EndpointRegistry', discovery_contracts, dict(), tuple(), timeout=poll_timeout, ) discovery_contract_address = discovery_contract_proxy.address # initialize and return ContractDiscovery object from raiden.network.discovery import ContractDiscovery return ContractDiscovery(jsonrpc_client, discovery_contract_address), address
def create_and_distribute_token(client, receivers, amount_per_receiver=1000, name=None, gasprice=denoms.shannon * 20, timeout=120): """Create a new ERC-20 token and distribute it among `receivers`. If `name` is None, the name will be derived from hashing all receivers. """ name = name or sha3(''.join(receivers)).encode('hex') token_proxy = client.deploy_solidity_contract( client.sender, 'HumanStandardToken', compile_file(get_contract_path('HumanStandardToken.sol')), dict() ( len(receivers) * amount_per_receiver, name, 2, # decimals name[:4].upper() # symbol ), gasprice=gasprice, timeout=timeout ) for receiver in receivers: token_proxy.transfer(receiver, amount_per_receiver) return token_proxy.address.encode('hex')
def test_endpointregistry(): registry_contract_path = get_contract_path('EndpointRegistry.sol') events = [] state = tester.state() assert state.block.number < 1150000 state.block.number = 1158001 assert state.block.number > 1150000 sender = tester.a0.encode('hex') registry_contract = state.abi_contract( None, path=registry_contract_path, language='solidity', log_listener=events.append, ) sender = tester.a0.encode('hex') registry_contract.registerEndpoint('127.0.0.1:4001') assert registry_contract.findAddressByEndpoint('127.0.0.1:4001') == sender assert registry_contract.findEndpointByAddress(sender) == '127.0.0.1:4001' registry_contract.updateEndpoint('192.168.0.1:4002') assert registry_contract.findAddressByEndpoint( '192.168.0.1:4002') == sender assert registry_contract.findEndpointByAddress( sender) == '192.168.0.1:4002' assert len(events) == 2 assert events[0]['_event_type'] == 'AddressRegistered' assert events[1]['_event_type'] == 'AddressUpdated'
def _jsonrpc_services(private_keys, verbose, poll_timeout): print_communication = True if verbose > 7 else False privatekey = private_keys[0] address = privatekey_to_address(privatekey) jsonrpc_client = JSONRPCClient( host='0.0.0.0', privkey=privatekey, print_communication=print_communication, ) patch_send_transaction(jsonrpc_client) registry_path = get_contract_path('Registry.sol') registry_contracts = compile_file(registry_path, libraries=dict()) log.info('Deploying registry contract') registry_proxy = jsonrpc_client.deploy_solidity_contract( address, 'Registry', registry_contracts, dict(), tuple(), timeout=poll_timeout, ) registry_address = registry_proxy.address blockchain_services = list() for privkey in private_keys: blockchain = BlockChainService( privkey, registry_address, ) blockchain_services.append(blockchain) return blockchain_services
def netting_channel_library(state): netting_library_path = get_contract_path('NettingChannelLibrary.sol') library_address = state.contract( None, path=netting_library_path, language='solidity', contract_name='NettingChannelLibrary', ) return library_address
def netting_channel_library(state): netting_library_path = get_contract_path('NettingChannelLibrary.sol') library_address = state.contract( None, path=netting_library_path, language='solidity', contract_name='NettingChannelLibrary', ) return library_address
def tester_nettingchannel_library_address(tester_state): netting_library_path = get_contract_path('NettingChannelLibrary.sol') library_address = tester_state.contract( None, path=netting_library_path, language='solidity', contract_name='NettingChannelLibrary', ) tester_state.mine(number_of_blocks=1) return library_address
def deploy_with_dependencies(contract_name, state, libraries=dict()): dependencies = find_dependencies( get_contract_path(contract_name)) dependency_names = [d.split('.')[0] for d in dependencies] for key in list(libraries.keys()): if not key in dependency_names: libraries.pop(key) log.DEV("in deploy_with_dependencies", contract=contract_name, dependencies=dependencies) for dependency in dependencies: # 'Contract's are included in 'Registry' and should not be deployed alone if 'Contract' in dependency: continue log.DEV('deploying dependency', name=dependency) log.DEV('known libraries', libraries=libraries) deployed = state.abi_contract(None, path=get_contract_path(dependency), listen=False, language='solidity', libraries=libraries, sender=DEFAULT_KEY, ) libraries[dependency.split('.')[0]] = deployed.address.encode('hex') state.mine() log.DEV('deploying target', name=contract_name) log.DEV('known libraries', libraries=libraries) contract = state.abi_contract( None, path=get_contract_path(contract_name), language='solidity', libraries=libraries, sender=DEFAULT_KEY, ) libraries[contract_name.split('.')[0]] = contract.address.encode('hex') state.mine() return libraries
def registry(state, token, channel_manager_library, events): registry_path = get_contract_path('Registry.sol') return state.abi_contract(None, path=registry_path, language='solidity', contract_name='Registry', log_listener=events.append, libraries={ 'ChannelManagerLibrary': channel_manager_library.encode('hex') })
def channel_manager_library(state, netting_channel_library, settle_timeout, token_address): manager_library_path = get_contract_path('ChannelManagerLibrary.sol') library_address = state.contract(None, path=manager_library_path, language='solidity', contract_name='ChannelManagerLibrary', libraries={ 'NettingChannelLibrary': netting_channel_library.encode('hex'), }) return library_address
def channel_manager_library(state, netting_channel_library, settle_timeout, token_address): manager_library_path = get_contract_path('ChannelManagerLibrary.sol') library_address = state.contract( None, path=manager_library_path, language='solidity', contract_name='ChannelManagerLibrary', libraries={ 'NettingChannelLibrary': netting_channel_library.encode('hex'), } ) return library_address
def registry(state, token, channel_manager_library, events): registry_path = get_contract_path('Registry.sol') return state.abi_contract( None, path=registry_path, language='solidity', contract_name='Registry', log_listener=events.append, libraries={ 'ChannelManagerLibrary': channel_manager_library.encode('hex') } )
def manager(state, token, channel_manager_library, events): registry_path = get_contract_path('Registry.sol') return state.abi_contract(None, path=registry_path, language='solidity', constructor_parameters=[token.address], contract_name='ChannelManagerContract', log_listener=events.append, libraries={ 'ChannelManagerLibrary': channel_manager_library.encode('hex'), })
def tester_registry_address(tester_state, tester_channelmanager_library_address): registry_path = get_contract_path('Registry.sol') registry_address = tester_state.contract( None, path=registry_path, language='solidity', contract_name='Registry', libraries={ 'ChannelManagerLibrary': tester_channelmanager_library_address.encode('hex') }) tester_state.mine(number_of_blocks=1) return registry_address
def manager(state, token, channel_manager_library, events): registry_path = get_contract_path('Registry.sol') return state.abi_contract( None, path=registry_path, language='solidity', constructor_parameters=[token.address], contract_name='ChannelManagerContract', log_listener=events.append, libraries={ 'ChannelManagerLibrary': channel_manager_library.encode('hex'), } )
def channel(state, token, netting_channel_library, settle_timeout, events): netting_contract_path = get_contract_path('ChannelManagerLibrary.sol') abi = state.abi_contract( None, path=netting_contract_path, language='solidity', constructor_parameters=[token.address, tester.a0, tester.a1, settle_timeout], contract_name='NettingChannelContract', log_listener=events.append, libraries={ 'NettingChannelLibrary': netting_channel_library.encode('hex'), } ) return abi
def test_endpointregistry(blockchain_services, poll_timeout): chain = blockchain_services[0] my_address = chain.node_address # deploy discovery contract discovery_contract_path = get_contract_path('EndpointRegistry.sol') discovery_contracts = _solidity.compile_file(discovery_contract_path, libraries=dict()) endpoinregistry_proxy = chain.client.deploy_solidity_contract( my_address, 'EndpointRegistry', discovery_contracts, dict(), tuple(), timeout=poll_timeout, ) endpointregistry_address = endpoinregistry_proxy.address contract_discovery = ContractDiscovery( chain, endpointregistry_address, ) unregistered_address = make_address() # get should raise for unregistered addresses with pytest.raises(KeyError): contract_discovery.get(my_address) with pytest.raises(KeyError): contract_discovery.get(unregistered_address) assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 44444)) is None contract_discovery.register(my_address, '127.0.0.1', 44444) assert contract_discovery.nodeid_by_host_port( ('127.0.0.1', 44444)) == my_address assert contract_discovery.get(my_address) == ('127.0.0.1', 44444) contract_discovery.register(my_address, '127.0.0.1', 88888) assert contract_discovery.nodeid_by_host_port( ('127.0.0.1', 88888)) == my_address assert contract_discovery.get(my_address) == ('127.0.0.1', 88888) with pytest.raises(KeyError): contract_discovery.get(unregistered_address)
def tester_channelmanager_library_address( tester_state, tester_nettingchannel_library_address): channelmanager_library_path = get_contract_path( 'ChannelManagerLibrary.sol') manager_address = tester_state.contract( None, path=channelmanager_library_path, language='solidity', contract_name='ChannelManagerLibrary', libraries={ 'NettingChannelLibrary': tester_nettingchannel_library_address.encode('hex'), }) tester_state.mine(number_of_blocks=1) return manager_address
def token_address(asset_amount, state): standard_token_path = get_contract_path('StandardToken.sol') human_token_path = get_contract_path('HumanStandardToken.sol') standard_token_address = state.contract( None, path=standard_token_path, language='solidity', ) human_libraries = { 'StandardToken': standard_token_address.encode('hex'), } human_token_proxy = state.abi_contract( None, path=human_token_path, language='solidity', libraries=human_libraries, constructor_parameters=[asset_amount, 'raiden', 0, 'rd'], ) state.mine() return human_token_proxy.address
def token_address(asset_amount, state): standard_token_path = get_contract_path('StandardToken.sol') human_token_path = get_contract_path('HumanStandardToken.sol') standard_token_address = state.contract( None, path=standard_token_path, language='solidity', ) human_libraries = { 'StandardToken': standard_token_address.encode('hex'), } human_token_proxy = state.abi_contract( None, path=human_token_path, language='solidity', libraries=human_libraries, constructor_parameters=[asset_amount, 'raiden', 0, 'rd'], ) state.mine() return human_token_proxy.address
def find_dependencies(contract_file): """Resolve solidity dependencies depth first. """ dependencies = [] with open(contract_file) as f: for line in f.readlines(): if line.startswith("import"): dependency = line.split()[1].split('"')[1] if dependency not in dependencies: dependencies.extend(find_dependencies(get_contract_path(dependency))) dependencies.append(dependency) cleaned = [] for dependency in dependencies: if dependency not in cleaned: cleaned.append(dependency) return cleaned
def channel(state, token, netting_channel_library, settle_timeout, events): netting_contract_path = get_contract_path('ChannelManagerLibrary.sol') abi = state.abi_contract(None, path=netting_contract_path, language='solidity', constructor_parameters=[ token.address, tester.a0, tester.a1, settle_timeout ], contract_name='NettingChannelContract', log_listener=events.append, libraries={ 'NettingChannelLibrary': netting_channel_library.encode('hex'), }) return abi
def deploy_contract(self, contract_name, contract_file, constructor_parameters=None): contract_path = get_contract_path(contract_file) contracts = _solidity.compile_file(contract_path, libraries=dict()) log.info('Deploying "{}" contract'.format(contract_file)) proxy = self.client.deploy_solidity_contract( self.node_address, contract_name, contracts, dict(), constructor_parameters, timeout=self.poll_timeout, ) return proxy.address
def create_and_distribute_token(state, receivers, name=None, amount_per_receiver=1000): proxy = state.abi_contract( None, path=get_contract_path(TARGETS['token']), language='solidity', listen=False, sender=DEFAULT_KEY, constructor_parameters=( len(receivers) * amount_per_receiver, name, 2, name[:4].upper() ) ) for receiver in receivers: proxy.transfer(receiver, amount_per_receiver) state.mine(number_of_blocks=1) return (name, proxy.address.encode('hex'))
def create_token(self, initial_alloc=10 ** 6, name='raidentester', symbol='RDT', decimals=2, timeout=60, gasprice=denoms.shannon * 20, auto_register=True): """Create a proxy for a new HumanStandardToken (ERC20), that is initialized with Args(below). Per default it will be registered with 'raiden'. Args: initial_alloc (int): amount of initial tokens. name (str): human readable token name. symbol (str): token shorthand symbol. decimals (int): decimal places. timeout (int): timeout in seconds for creation. gasprice (int): gasprice for the creation transaction. auto_register (boolean): if True(default), automatically register the asset with raiden. Returns: token_address: the hex encoded address of the new token/asset. """ # Deploy a new ERC20 token token_proxy = self._chain.client.deploy_solidity_contract( self._raiden.address, 'HumanStandardToken', compile_file(get_contract_path('HumanStandardToken.sol')), dict(), (initial_alloc, name, decimals, symbol), gasprice=gasprice, timeout=timeout) token_address = token_proxy.address.encode('hex') if auto_register: self.register_asset(token_address) print("Successfully created {}the token '{}'.".format( 'and registered ' if auto_register else ' ', name )) return token_address
def test_endpointregistry(tester_state, tester_events): account0 = tester.DEFAULT_ACCOUNT sender = account0.encode('hex') endpointregistry_path = get_contract_path('EndpointRegistry.sol') registry_contract = tester_state.abi_contract( None, path=endpointregistry_path, language='solidity', log_listener=tester_events.append, ) registry_contract.registerEndpoint('127.0.0.1:4001') assert registry_contract.findAddressByEndpoint('127.0.0.1:4001') == sender assert registry_contract.findEndpointByAddress(sender) == '127.0.0.1:4001' registry_contract.registerEndpoint('192.168.0.1:4002') assert registry_contract.findAddressByEndpoint('192.168.0.1:4002') == sender assert registry_contract.findEndpointByAddress(sender) == '192.168.0.1:4002' assert len(tester_events) == 2 assert tester_events[0]['_event_type'] == 'AddressRegistered' assert tester_events[1]['_event_type'] == 'AddressRegistered'
def create_token(self, initial_alloc=10 ** 6, name='raidentester', symbol='RDT', decimals=2, timeout=60, gasprice=denoms.shannon * 20, auto_register=True): """Create a proxy for a new HumanStandardToken (ERC20), that is initialized with Args(below). Per default it will be registered with 'raiden'. Args: initial_alloc (int): amount of initial tokens. name (str): human readable token name. symbol (str): token shorthand symbol. decimals (int): decimal places. timeout (int): timeout in seconds for creation. gasprice (int): gasprice for the creation transaction. auto_register (boolean): if True(default), automatically register the asset with raiden. Returns: token_address: the hex encoded address of the new token/asset. """ # Deploy a new ERC20 token token_proxy = self._chain.client.deploy_solidity_contract( self._raiden.address, 'HumanStandardToken', compile_file(get_contract_path('HumanStandardToken.sol')), dict(), (initial_alloc, name, decimals, symbol), gasprice=gasprice, timeout=timeout) token_address = token_proxy.address.encode('hex') if auto_register: self.register_asset(token_address) print("Successfully created {}the token '{}'.".format('and registered ' if auto_register else ' ', name)) return token_address
def test_endpointregistry(): registry_contract_path = get_contract_path('EndpointRegistry.sol') events = [] state = tester.state() assert state.block.number < 1150000 state.block.number = 1158001 assert state.block.number > 1150000 sender = tester.a0.encode('hex') registry_contract = state.abi_contract( None, path=registry_contract_path, language='solidity', log_listener=events.append, ) sender = tester.a0.encode('hex') registry_contract.registerEndpoint('127.0.0.1:4001') assert registry_contract.findAddressByEndpoint('127.0.0.1:4001') == sender assert registry_contract.findEndpointByAddress(sender) == '127.0.0.1:4001' registry_contract.registerEndpoint('192.168.0.1:4002') assert registry_contract.findAddressByEndpoint('192.168.0.1:4002') == sender assert registry_contract.findEndpointByAddress(sender) == '192.168.0.1:4002' assert len(events) == 2 assert events[0]['_event_type'] == 'AddressRegistered' assert events[1]['_event_type'] == 'AddressRegistered'
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
# -*- coding: utf8 -*- from raiden.utils import (isaddress, pex, host_port_to_endpoint, split_endpoint) from raiden.blockchain.abi import get_contract_path from ethereum import _solidity discovery_contract_compiled = _solidity.compile_contract( get_contract_path('EndpointRegistry.sol'), 'EndpointRegistry', combined='abi', ) DISCOVERY_CONTRACT_ABI = discovery_contract_compiled['abi'] class Discovery(object): """ Mock mapping address: host, port """ def __init__(self): self.nodeid_hostport = dict() def register(self, nodeid, host, port): assert isaddress(nodeid) # fixme, this is H(pubkey) self.nodeid_hostport[nodeid] = (host, port) def get(self, nodeid): try: return self.nodeid_hostport[nodeid] except KeyError: raise KeyError('Unknow address {}'.format(pex(nodeid))) def nodeid_by_host_port(self, host_port): for nodeid, value_hostport in self.nodeid_hostport.items():
def tester_deploy_contract(tester_state, private_key, contract_name, contract_file, constructor_parameters=None): contract_path = get_contract_path(contract_file) all_contracts = _solidity.compile_file(contract_path, libraries=dict()) contract = all_contracts[contract_name] contract_interface = contract['abi'] log.info('Deploying "{}" contract'.format(contract_file)) dependencies = deploy_dependencies_symbols(all_contracts) deployment_order = dependencies_order_of_build(contract_name, dependencies) log.info('Deploing dependencies: {}'.format(str(deployment_order))) deployment_order.pop() # remove `contract_name` from the list libraries = dict() for deploy_contract in deployment_order: dependency_contract = all_contracts[deploy_contract] hex_bytecode = _solidity.solidity_resolve_symbols( dependency_contract['bin_hex'], libraries, ) bytecode = decode_hex(hex_bytecode) dependency_contract['bin_hex'] = hex_bytecode dependency_contract['bin'] = bytecode log.info('Creating contract {}'.format(deploy_contract)) contract_address = tester_state.evm( bytecode, private_key, endowment=0, ) tester_state.mine(number_of_blocks=1) if len(tester_state.block.get_code(contract_address)) == 0: raise Exception('Contract code empty') libraries[deploy_contract] = encode_hex(contract_address) hex_bytecode = _solidity.solidity_resolve_symbols(contract['bin_hex'], libraries) bytecode = hex_bytecode.decode('hex') contract['bin_hex'] = hex_bytecode contract['bin'] = bytecode if constructor_parameters: translator = ContractTranslator(contract_interface) parameters = translator.encode_constructor_arguments(constructor_parameters) bytecode = contract['bin'] + parameters else: bytecode = contract['bin'] log.info('Creating contract {}'.format(contract_name)) contract_address = tester_state.evm( bytecode, private_key, endowment=0, ) tester_state.mine(number_of_blocks=1) if len(tester_state.block.get_code(contract_address)) == 0: raise Exception('Contract code empty') return contract_address
def test_blockchain(private_keys, number_of_nodes, cluster, poll_timeout): # pylint: disable=too-many-locals addresses = [ privtoaddr(priv) for priv in private_keys ] privatekey = private_keys[0] address = privtoaddr(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 allcontracts(contract_files): return { name_from_file(c): compile_contract(get_contract_path(c), name_from_file(c)) for c in contract_files }
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 netting_channel_abi(): netting_library_path = get_contract_path('ChannelManagerLibrary.sol') netting_channel_compiled = compile_file( netting_library_path)['NettingChannelContract'] netting_channel_abi = netting_channel_compiled['abi'] return netting_channel_abi
def token_abi(): human_token_path = get_contract_path('HumanStandardToken.sol') human_compiled = compile_file(human_token_path, combined='abi') return human_compiled['HumanStandardToken']['abi']
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 netting_channel_abi(): netting_library_path = get_contract_path('ChannelManagerLibrary.sol') netting_channel_compiled = compile_file(netting_library_path)['NettingChannelContract'] netting_channel_abi = netting_channel_compiled['abi'] return netting_channel_abi