def event_channelnew(self, manager_address_bin, event): # pylint: disable=unused-argument # should not raise, filters are installed only for registered managers asset_manager = self.raiden.get_manager_by_address(manager_address_bin) participant1 = address_decoder(event['participant1']) participant2 = address_decoder(event['participant2']) # update our global network graph for routing asset_manager.channelgraph.add_path( participant1, participant2, ) if participant1 == self.raiden.address or participant2 == self.raiden.address: netting_channel_address_bin = address_decoder(event['netting_channel']) try: asset_manager.register_channel_by_address( netting_channel_address_bin, self.raiden.config['reveal_timeout'], ) except ValueError: # This can happen if the new channel's settle_timeout is # smaller than raiden.config['reveal_timeout'] log.exception('Channel registration failed.') else: if log.isEnabledFor(logging.INFO): log.info( 'New channel created', channel_address=event['netting_channel'], manager_address=pex(manager_address_bin), ) else: log.info('ignoring new channel, this is node is not a participant.')
def partner(self, our_address): data = self.proxy.addressAndBalance.call() if address_decoder(data[0]) == our_address: return address_decoder(data[2]) if address_decoder(data[2]) == our_address: return address_decoder(data[0]) raise ValueError('We [{}] are not a participant of the given channel ({}, {})'.format( pex(our_address), data[0], data[2], ))
def event_channelnewbalance(self, netting_contract_address_bin, event): asset_address_bin = address_decoder(event['assetAddress']) participant_address_bin = address_decoder(event['participant']) # shouldn't raise, all three addresses need to be registered manager = self.raiden.get_manager_by_asset_address(asset_address_bin) channel = manager.get_channel_by_contract_address(netting_contract_address_bin) channel_state = channel.get_state_for(participant_address_bin) if channel_state.contract_balance != event['balance']: channel_state.update_contract_balance(event['balance']) if channel.external_state.opened_block == 0: channel.external_state.opened_block = event['blockNumber']
def changes(self): filter_changes = self.client.call( 'eth_getFilterChanges', self.filter_id_raw, ) # geth could return None if filter_changes is None: return [] result = list() for log_event in filter_changes: address = address_decoder(log_event['address']) data = data_decoder(log_event['data']) topics = [ decode_topic(topic) for topic in log_event['topics'] ] result.append({ 'topics': topics, 'data': data, 'address': address, }) return result
def channels_by_participant(self, peer_address): result = [ address_decoder(address) for address in self.proxy.nettingContractsByAddress(peer_address) ] self.tester_state.mine(number_of_blocks=1) return result
def closing_address(self): """Returns the address of the participant that called close, or None if the channel is not closed. """ self._check_exists() closing_address = self.proxy.closingAddress() if closing_address is not None: return address_decoder(closing_address)
def channels_by_participant(self, participant_address): # pylint: disable=invalid-name """ Return a list of channel address that `participant_address` is a participant. """ address_list = self.proxy.nettingContractsByAddress.call( participant_address, startgas=self.startgas, ) return [address_decoder(address) for address in address_list]
def get_channel(self, channel_address): channel_address_bin = address_decoder(channel_address) channel_list = self.get_channel_list() for channel in channel_list: if channel.channel_address == channel_address_bin: return channel raise ValueError("Channel not found")
def api_url_for(api_backend, endpoint, **kwargs): api_server, _ = api_backend # url_for() expects binary address so we have to convert here for key, val in kwargs.iteritems(): if isinstance(val, basestring) and val.startswith('0x'): kwargs[key] = address_decoder(val) with api_server.flask_app.app_context(): return url_for('v1_resources.{}'.format(endpoint), **kwargs)
def new_netting_channel(self, peer1, peer2, settle_timeout): if not isaddress(peer1): raise ValueError('The peer1 must be a valid address') if not isaddress(peer2): raise ValueError('The peer2 must be a valid address') if settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN: raise ValueError( 'settle_timeout must be larger-or-equal to {}'.format( NETTINGCHANNEL_SETTLE_TIMEOUT_MIN)) if peer1 == peer2: raise SamePeerAddress('Peer1 and peer2 must not be equal') if privatekey_to_address(self.client.privkey) == peer1: other = peer2 else: other = peer1 transaction_hash = estimate_and_transact( self, self.proxy.newChannel, other, settle_timeout, ) self.client.poll(transaction_hash.decode('hex'), timeout=self.poll_timeout) if check_transaction_threw(self.client, transaction_hash): raise DuplicatedChannelError('Duplicated channel') netting_channel_results_encoded = self.proxy.getChannelWith.call( other, startgas=self.startgas, ) # address is at index 0 netting_channel_address_encoded = netting_channel_results_encoded if not netting_channel_address_encoded: log.error('netting_channel_address failed', peer1=pex(peer1), peer2=pex(peer2)) raise RuntimeError('netting_channel_address failed') netting_channel_address_bin = address_decoder( netting_channel_address_encoded) log.info( 'new_netting_channel called', peer1=pex(peer1), peer2=pex(peer2), netting_channel=pex(netting_channel_address_bin), ) return netting_channel_address_bin
def event_channelclosed(self, netting_contract_address_bin, event): channel = self.raiden.find_channel_by_address( netting_contract_address_bin) channel.external_state.set_closed(event['block_number']) callback = self.get_on_event_callback(event) if callback: closing_address_bin = address_decoder(event['closing_address']) callback(netting_contract_address_bin, closing_address_bin, event['block_number'])
def event_channelnew(self, manager_address_bin, event): # pylint: disable=unused-argument if address_decoder(event['participant1']) != self.raiden.address and address_decoder(event['participant2']) != self.raiden.address: log.info('ignoring new channel, this is node is not a participant.') return netting_channel_address_bin = address_decoder(event['nettingChannel']) # shouldnt raise, filters are installed only for registered managers asset_manager = self.raiden.get_manager_by_address(manager_address_bin) asset_manager.register_channel_by_address( netting_channel_address_bin, self.raiden.config['reveal_timeout'], ) log.info( 'New channel created', channel_address=event['nettingChannel'], manager_address=pex(manager_address_bin), )
def event_channelnew(self, manager_address, event): # pylint: disable=unused-argument if address_decoder(event['participant1']) != self.raiden.address and address_decoder(event['participant2']) != self.raiden.address: log.info('ignoring new channel, this is node is not a participant.') return netting_channel_address_bin = address_decoder(event['nettingChannel']) # shouldnt raise, filters are installed only for registered managers asset_manager = self.raiden.get_manager_by_address(manager_address) asset_manager.register_channel_by_address( netting_channel_address_bin, self.raiden.config['reveal_timeout'], ) log.info( 'New channel created', channel_address=event['nettingChannel'], manager_address=encode_hex(manager_address), )
def new_netting_channel(self, peer1, peer2, settle_timeout): if not isaddress(peer1): raise ValueError('The peer1 must be a valid address') if not isaddress(peer2): raise ValueError('The peer2 must be a valid address') if privatekey_to_address(self.client.privkey) == peer1: other = peer2 else: other = peer1 transaction_hash = estimate_and_transact( self, self.proxy.newChannel, other, settle_timeout, ) try: self.client.poll(transaction_hash.decode('hex'), timeout=self.poll_timeout) except JSONRPCPollTimeoutException as e: raise e except InvalidTransaction as e: raise e # TODO: raise if the transaction failed because there is an existing # channel in place netting_channel_results_encoded = self.proxy.getChannelWith.call( other, startgas=self.startgas, ) # address is at index 0 netting_channel_address_encoded = netting_channel_results_encoded if not netting_channel_address_encoded: log.error('netting_channel_address failed', peer1=pex(peer1), peer2=pex(peer2)) raise RuntimeError('netting_channel_address failed') netting_channel_address_bin = address_decoder( netting_channel_address_encoded) log.info( 'new_netting_channel called', peer1=pex(peer1), peer2=pex(peer2), netting_channel=pex(netting_channel_address_bin), ) return netting_channel_address_bin
def channels_by_participant(self, participant_address): # pylint: disable=invalid-name """ Return a list of channel address that `participant_address` is a participant. """ address_list = self.proxy.nettingContractsByAddress.call( participant_address, startgas=self.startgas, ) return [ address_decoder(address) for address in address_list ]
def event_channelnew(self, manager_address_bin, event): # pylint: disable=unused-argument # should not raise, filters are installed only for registered managers token_manager = self.raiden.get_manager_by_address(manager_address_bin) participant1 = address_decoder(event['participant1']) participant2 = address_decoder(event['participant2']) # update our global network graph for routing token_manager.channelgraph.add_path( participant1, participant2, ) if participant1 == self.raiden.address or participant2 == self.raiden.address: netting_channel_address_bin = address_decoder( event['netting_channel']) try: token_manager.register_channel_by_address( netting_channel_address_bin, self.raiden.config['reveal_timeout'], ) except ValueError: # This can happen if the new channel's settle_timeout is # smaller than raiden.config['reveal_timeout'] log.exception('Channel registration failed.') else: if log.isEnabledFor(logging.INFO): log.info( 'New channel created', channel_address=event['netting_channel'], manager_address=pex(manager_address_bin), ) callback = self.get_on_event_callback(event) if callback: callback(netting_channel_address_bin, participant1, participant2, event['settle_timeout']) else: log.info('ignoring new channel, this node is not a participant.')
def event_channelnewbalance(self, netting_contract_address_bin, event): if log.isEnabledFor(logging.DEBUG): log.debug( 'channel new balance event received', netting_contract=pex(netting_contract_address_bin), event=event, ) asset_address_bin = address_decoder(event['asset_address']) participant_address_bin = address_decoder(event['participant']) # should not raise, all three addresses need to be registered manager = self.raiden.get_manager_by_asset_address(asset_address_bin) channel = manager.get_channel_by_contract_address(netting_contract_address_bin) channel_state = channel.get_state_for(participant_address_bin) if channel_state.contract_balance != event['balance']: channel_state.update_contract_balance(event['balance']) if channel.external_state.opened_block == 0: channel.external_state.set_opened(event['block_number'])
def detail(self, our_address): """ FIXME: 'our_address' is only needed for the pure python mock implementation """ our_address = privatekey_to_address(self.private_key) data = self.proxy.addressAndBalance() self.tester_state.mine(number_of_blocks=1) settle_timeout = self.proxy.settleTimeout() self.tester_state.mine(number_of_blocks=1) if address_decoder(data[0]) == our_address: return { 'our_address': address_decoder(data[0]), 'our_balance': data[1], 'partner_address': address_decoder(data[2]), 'partner_balance': data[3], 'settle_timeout': settle_timeout, } if address_decoder(data[2]) == our_address: return { 'our_address': address_decoder(data[2]), 'our_balance': data[3], 'partner_address': address_decoder(data[0]), 'partner_balance': data[1], 'settle_timeout': settle_timeout, } raise ValueError( 'We [{}] are not a participant of the given channel ({}, {})'. format( pex(our_address), data[0], data[2], ))
def detail(self, our_address): data = self.proxy.addressAndBalance() self.tester_state.mine(number_of_blocks=1) settle_timeout = self.proxy.settleTimeout() self.tester_state.mine(number_of_blocks=1) if address_decoder(data[0]) == our_address: return { 'our_address': address_decoder(data[0]), 'our_balance': data[1], 'partner_address': address_decoder(data[2]), 'partner_balance': data[3], 'settle_timeout': settle_timeout, } if address_decoder(data[2]) == our_address: return { 'our_address': address_decoder(data[2]), 'our_balance': data[3], 'partner_address': address_decoder(data[0]), 'partner_balance': data[1], 'settle_timeout': settle_timeout, } raise ValueError('We [{}] are not a participant of the given channel ({}, {})'.format( pex(our_address), data[0], data[2], ))
def detail(self, our_address): data = self.proxy.addressAndBalance.call(startgas=self.startgas) settle_timeout = self.proxy.settleTimeout.call(startgas=self.startgas) if address_decoder(data[0]) == our_address: return { 'our_address': address_decoder(data[0]), 'our_balance': data[1], 'partner_address': address_decoder(data[2]), 'partner_balance': data[3], 'settle_timeout': settle_timeout, } if address_decoder(data[2]) == our_address: return { 'our_address': address_decoder(data[2]), 'our_balance': data[3], 'partner_address': address_decoder(data[0]), 'partner_balance': data[1], 'settle_timeout': settle_timeout, } raise ValueError( 'We [{}] are not a participant of the given channel ({}, {})'. format( pex(our_address), data[0], data[2], ))
def detail(self, our_address): data = self.proxy.addressAndBalance.call(startgas=self.startgas) settle_timeout = self.proxy.settleTimeout.call(startgas=self.startgas) if data == '': raise RuntimeError('addressAndBalance call failed.') if settle_timeout == '': raise RuntimeError('settleTimeout call failed.') if address_decoder(data[0]) == our_address: return { 'our_address': address_decoder(data[0]), 'our_balance': data[1], 'partner_address': address_decoder(data[2]), 'partner_balance': data[3], 'settle_timeout': settle_timeout, } if address_decoder(data[2]) == our_address: return { 'our_address': address_decoder(data[2]), 'our_balance': data[3], 'partner_address': address_decoder(data[0]), 'partner_balance': data[1], 'settle_timeout': settle_timeout, } raise ValueError('We [{}] are not a participant of the given channel ({}, {})'.format( pex(our_address), data[0], data[2], ))
def channels_addresses(self): # for simplicity the smart contract return a shallow list where every # second item forms a tuple channel_flat_encoded = self.proxy.getChannelsParticipants.call(startgas=self.startgas) channel_flat = [ address_decoder(channel) for channel in channel_flat_encoded ] # [a,b,c,d] -> [(a,b),(c,d)] channel_iter = iter(channel_flat) return zip(channel_iter, channel_iter)
def channels_addresses(self): # for simplicity the smart contract return a shallow list where every # second item forms a tuple channel_flat_encoded = self.proxy.getChannelsParticipants.call( startgas=self.startgas) channel_flat = [ address_decoder(channel) for channel in channel_flat_encoded ] # [a,b,c,d] -> [(a,b),(c,d)] channel_iter = iter(channel_flat) return zip(channel_iter, channel_iter)
def closing_address(self): """ Returns the address of the closer, if the channel is closed, None otherwise. Raises: AddressWithoutCode: If the channel was settled prior to the call. """ closer = self.proxy.closingAddress() if closer: return address_decoder(closer) return None
def token_address(self): """ Returns the type of token that can be transferred by the channel. Raises: AddressWithoutCode: If the channel was settled prior to the call. """ address = self.proxy.tokenAddress.call() if address == '': self._check_exists() raise RuntimeError('token address returned empty') return address_decoder(address)
def event_channelnewbalance(self, netting_contract_address_bin, event): if log.isEnabledFor(logging.DEBUG): log.debug( 'channel new balance event received', netting_contract=pex(netting_contract_address_bin), event=event, ) asset_address_bin = address_decoder(event['asset_address']) participant_address_bin = address_decoder(event['participant']) # should not raise, all three addresses need to be registered manager = self.raiden.get_manager_by_asset_address(asset_address_bin) channel = manager.get_channel_by_contract_address( netting_contract_address_bin) channel_state = channel.get_state_for(participant_address_bin) if channel_state.contract_balance != event['balance']: channel_state.update_contract_balance(event['balance']) if channel.external_state.opened_block == 0: channel.external_state.set_opened(event['block_number'])
def token_addresses(request, token_amount, number_of_tokens, blockchain_services, cached_genesis, register_tokens): if cached_genesis: token_addresses = [ address_decoder(token_address) for token_address in cached_genesis['config']['tokenAddresses'] ] else: token_addresses = _token_addresses( token_amount, number_of_tokens, blockchain_services.deploy_service, blockchain_services.blockchain_services, register_tokens) return token_addresses
def manager_address_by_token(self, token_address): """ Return the channel manager address for the given token or None if there is no correspoding address. """ address = self.proxy.channelManagerByToken.call( token_address, startgas=self.startgas, ) if address == '': check_address_has_code(self.client, self.address) return None return address_decoder(address)
def tester_state(deploy_key, private_keys, tester_blockgas_limit): tester_state = tester.state() # special addresses 1 to 5 alloc = { int_to_addr(i): {'wei': 1} for i in range(1, 5) } for privkey in [deploy_key] + private_keys: address = privatekey_to_address(privkey) alloc[address] = { 'balance': DEFAULT_BALANCE, } for account in tester.accounts: alloc[account] = { 'balance': DEFAULT_BALANCE, } db = ethereum.db.EphemDB() env = ethereum.config.Env( db, ethereum.config.default_config, ) genesis_overwrite = { 'nonce': zpad(data_decoder('0x00006d6f7264656e'), 8), 'difficulty': quantity_decoder('0x20000'), 'mixhash': zpad(b'\x00', 32), 'coinbase': address_decoder('0x0000000000000000000000000000000000000000'), 'timestamp': 0, 'extra_data': b'', 'gas_limit': tester_blockgas_limit, 'start_alloc': alloc, } genesis_block = ethereum.blocks.genesis( env, **genesis_overwrite ) # enable DELEGATECALL opcode genesis_block.number = genesis_block.config['HOMESTEAD_FORK_BLKNUM'] + 1 tester_state.db = db tester_state.env = env tester_state.block = genesis_block tester_state.blocks = [genesis_block] return tester_state
def blockchain_services( request, deploy_key, private_keys, poll_timeout, blockchain_backend, # This fixture is required because it will start # the geth subprocesses blockchain_rpc_ports, blockchain_type, tester_blockgas_limit, cached_genesis): verbose = request.config.option.verbose if blockchain_type in ('geth', ): registry_address = None if cached_genesis: registry_address = cached_genesis['config'].get( 'defaultRegistryAddress') if registry_address: registry_address = address_decoder(registry_address) return _jsonrpc_services( deploy_key, private_keys, verbose, poll_timeout, blockchain_rpc_ports[0], registry_address, ) if blockchain_type == 'tester': return _tester_services( deploy_key, private_keys, tester_blockgas_limit, ) if blockchain_type == 'mock': return _mock_services( deploy_key, private_keys, request, ) raise ValueError('unknown cluster type {}'.format(blockchain_type))
def assert_decoder_results(message, decoder): message_encoded = message.encode() transfer_raw, signing_address = decoder.getTransferRawAddress(message_encoded) assert address_decoder(signing_address) == message.sender assert transfer_raw == message_encoded[:-65] ( nonce_decoded, locksroot_decoded, transferred_amount_decoded ) = decoder.decodeTransfer(transfer_raw) assert message.nonce == nonce_decoded assert message.transferred_amount == transferred_amount_decoded assert message.locksroot == locksroot_decoded
def blockchain_services( request, deploy_key, private_keys, poll_timeout, blockchain_backend, # This fixture is required because it will start # the geth subprocesses blockchain_rpc_ports, blockchain_type, tester_blockgas_limit, cached_genesis): verbose = request.config.option.verbose if blockchain_type in ('geth',): registry_address = None if cached_genesis: registry_address = cached_genesis['config'].get('defaultRegistryAddress') if registry_address: registry_address = address_decoder(registry_address) return _jsonrpc_services( deploy_key, private_keys, verbose, poll_timeout, blockchain_rpc_ports[0], registry_address, ) if blockchain_type == 'tester': return _tester_services( deploy_key, private_keys, tester_blockgas_limit, ) if blockchain_type == 'mock': return _mock_services( deploy_key, private_keys, request, ) raise ValueError('unknow cluster type {}'.format(blockchain_type))
def manager_by_asset(self, asset_address): """ Find the channel manager for `asset_address` and return a proxy to interact with it. """ if asset_address not in self.asset_manager: asset = self.asset(asset_address) # check that the asset exists manager_address = self.default_registry.manager_address_by_asset(asset.address) manager = ChannelManager( self.client, address_decoder(manager_address), poll_timeout=self.poll_timeout, ) self.asset_manager[asset_address] = manager self.address_manager[manager_address] = manager return self.asset_manager[asset_address]
def manager_by_token(self, token_address): """ Find the channel manager for `token_address` and return a proxy to interact with it. """ if token_address not in self.token_manager: token = self.token(token_address) # check that the token exists manager_address = self.default_registry.manager_address_by_token(token.address) manager = ChannelManager( self.client, address_decoder(manager_address), poll_timeout=self.poll_timeout, ) self.token_manager[token_address] = manager self.address_manager[manager_address] = manager return self.token_manager[token_address]
def new_netting_channel(self, peer1, peer2, settle_timeout): if not isaddress(peer1): raise ValueError('The pee1 must be a valid address') if not isaddress(peer2): raise ValueError('The peer2 must be a valid address') if privatekey_to_address(self.client.privkey) == peer1: other = peer2 else: other = peer1 transaction_hash = self.proxy.newChannel.transact( other, settle_timeout, startgas=self.startgas, gasprice=self.gasprice * 2, ) self.client.poll(transaction_hash.decode('hex'), timeout=self.poll_timeout) # TODO: raise if the transaction failed because there is an existing # channel in place netting_channel_address_encoded = self.proxy.getChannelWith.call( other, startgas=self.startgas, ) if not netting_channel_address_encoded: log.error('netting_channel_address failed', peer1=pex(peer1), peer2=pex(peer2)) raise RuntimeError('netting_channel_address failed') netting_channel_address_bin = address_decoder( netting_channel_address_encoded) log.info( 'new_netting_channel called', peer1=pex(peer1), peer2=pex(peer2), netting_channel=pex(netting_channel_address_bin), ) return netting_channel_address_bin
def get_filter_events(jsonrpc_client, contract_address, topics, from_block=None, to_block=None): """ Custom new filter implementation to handle bad encoding from geth rpc. """ if isinstance(from_block, int): from_block = hex(from_block) if isinstance(to_block, int): to_block = hex(to_block) json_data = { 'fromBlock': from_block or hex(0), 'toBlock': to_block or 'latest', 'address': address_encoder(normalize_address(contract_address)), } if topics is not None: json_data['topics'] = [topic_encoder(topic) for topic in topics] filter_changes = jsonrpc_client.call('eth_getLogs', json_data) # geth could return None if filter_changes is None: return [] result = [] for log_event in filter_changes: address = address_decoder(log_event['address']) data = data_decoder(log_event['data']) topics = [decode_topic(topic) for topic in log_event['topics']] block_number = log_event.get('blockNumber') if not block_number: block_number = 0 else: block_number = int(block_number, 0) result.append({ 'topics': topics, 'data': data, 'address': address, 'block_number': block_number, }) return result
def register_token(self, token_address): """Register a token with the raiden token manager. Args: token_address (string): a hex encoded token address. Returns: channel_manager: the channel_manager contract_proxy. """ # Add the ERC20 token to the raiden registry self._chain.default_registry.add_token(token_address) # Obtain the channel manager for the token channel_manager = self._chain.manager_by_token( address_decoder(token_address)) # Register the channel manager with the raiden registry self._raiden.register_channel_manager(channel_manager) return channel_manager
def endpoint_discovery_services(blockchain_services, blockchain_type, cached_genesis): discovery_address = None if cached_genesis and 'defaultDiscoveryAddress' in cached_genesis['config']: discovery_address = address_decoder( cached_genesis['config']['defaultDiscoveryAddress'] ) if discovery_address is None: discovery_address = blockchain_services.deploy_service.deploy_contract( 'EndpointRegistry', 'EndpointRegistry.sol', ) return [ ContractDiscovery(chain.node_address, chain.discovery(discovery_address)) for chain in blockchain_services.blockchain_services ]
def get_token_network_events(self, token_address, from_block, to_block=''): # Note: Issue #452 (https://github.com/raiden-network/raiden/issues/452) # tracks a suggested TODO, which will reduce the 3 RPC calls here to only # one using `eth_getLogs`. It will require changes in all testing frameworks # to be implemented though. translator = ContractTranslator(CHANNEL_MANAGER_ABI) token_address_bin = address_decoder(token_address) channel_manager = self.raiden.chain.manager_by_token(token_address_bin) filter_ = None try: filter_ = channel_manager.channelnew_filter(from_block, to_block) events = filter_.getall() finally: if filter_ is not None: filter_.uninstall() return [ translator.decode_event(event['topics'], event['data']) for event in events ]
def new_netting_channel(self, peer1, peer2, settle_timeout): if not isaddress(peer1): raise ValueError('The pee1 must be a valid address') if not isaddress(peer2): raise ValueError('The peer2 must be a valid address') if privatekey_to_address(self.client.privkey) == peer1: other = peer2 else: other = peer1 transaction_hash = self.proxy.newChannel.transact( other, settle_timeout, startgas=self.startgas, gasprice=self.gasprice, ) self.client.poll(transaction_hash.decode('hex'), timeout=self.poll_timeout) # TODO: raise if the transaction failed because there is an existing # channel in place netting_channel_address_encoded = self.proxy.getChannelWith.call( other, startgas=self.startgas, ) if not netting_channel_address_encoded: log.error('netting_channel_address failed', peer1=pex(peer1), peer2=pex(peer2)) raise RuntimeError('netting_channel_address failed') netting_channel_address_bin = address_decoder(netting_channel_address_encoded) log.info( 'new_netting_channel called', peer1=pex(peer1), peer2=pex(peer2), netting_channel=pex(netting_channel_address_bin), ) return netting_channel_address_bin
def _query_filter(self, function): filter_changes = self.client.call(function, self.filter_id_raw) # geth could return None if filter_changes is None: return [] result = list() for log_event in filter_changes: address = address_decoder(log_event['address']) data = data_decoder(log_event['data']) topics = [decode_topic(topic) for topic in log_event['topics']] result.append({ 'topics': topics, 'data': data, 'address': address, }) return result
def manager_by_token(self, token_address): """ Find the channel manager for `token_address` and return a proxy to interact with it. If the token is not already registered it raises `JSONRPCClientReplyError`, since we try to instantiate a Channel manager with an empty address. """ if token_address not in self.token_manager: token = self.token(token_address) # check that the token exists manager_address = self.default_registry.manager_address_by_token(token.address) manager = ChannelManager( self.client, address_decoder(manager_address), poll_timeout=self.poll_timeout, ) self.token_manager[token_address] = manager self.address_manager[manager_address] = manager return self.token_manager[token_address]
def assets_addresses( request, asset_amount, number_of_assets, blockchain_services, cached_genesis): if cached_genesis: assets_addresses = [ address_decoder(asset_address) for asset_address in cached_genesis['config']['assetAddresses'] ] else: assets_addresses = _assets_addresses( asset_amount, number_of_assets, blockchain_services.deploy_service, blockchain_services.blockchain_services, ) return assets_addresses
def add_asset(self, asset_address): transaction_hash = self.proxy.addAsset.transact( asset_address, startgas=self.startgas, ) self.client.poll(transaction_hash.decode('hex'), timeout=self.poll_timeout) channel_manager_address_encoded = self.proxy.channelManagerByAsset.call( asset_address, startgas=self.startgas, ) if not channel_manager_address_encoded: log.error('add_asset failed', asset_address=pex(asset_address)) raise RuntimeError('add_asset failed') channel_manager_address_bin = address_decoder(channel_manager_address_encoded) log.info( 'add_asset called', asset_address=pex(asset_address), registry_address=pex(self.address), channel_manager_address=pex(channel_manager_address_bin), )
def asset_address(self): asset_address_hex = self.proxy.tokenAddress() self.tester_state.mine(number_of_blocks=1) asset_address = address_decoder(asset_address_hex) return asset_address
def event_assetadded(self, registry_address, event): manager_address = address_decoder(event['channelManagerAddress']) manager = self.raiden.chain.manager(manager_address) self.raiden.register_channel_manager(manager)
def asset_addresses(self): return [ address_decoder(address) for address in self.proxy.assetAddresses.call(startgas=self.startgas) ]
def manager_addresses(self): return [ address_decoder(address) for address in self.proxy.channelManagerAddresses.call(startgas=self.startgas) ]
def asset_address(self): """ Return the asset of this manager. """ return address_decoder(self.proxy.tokenAddress.call())
def partner(self, our_address): result = address_decoder(self.proxy.partner(our_address)) self.tester_state.mine(number_of_blocks=1) return result
def event_assetadded(self, registry_address_bin, event): # pylint: disable=unused-argument manager_address_bin = address_decoder(event['channel_manager_address']) manager = self.raiden.chain.manager(manager_address_bin) self.raiden.register_channel_manager(manager)
def asset_address(self): return address_decoder(self.proxy.assetAddress.call())
def asset_address(self): result = address_decoder(self.proxy.assetAddress()) self.tester_state.mine(number_of_blocks=1) return result
def coinbase(self): return address_decoder(self.call('eth_coinbase'))