def test_list_all_channelstate(): test_state = factories.make_chain_state(number_of_channels=3) assert sorted(channel.partner_state.address for channel in views.list_all_channelstate( test_state.chain_state)) == sorted( channel.partner_state.address for channel in test_state.channels)
def get_channel_list( self, registry_address: typing.PaymentNetworkID, token_address: typing.TokenAddress = None, partner_address: typing.Address = None, ) -> typing.List[NettingChannelState]: """Returns a list of channels associated with the optionally given `token_address` and/or `partner_address`. Args: token_address: an optionally provided token address partner_address: an optionally provided partner address Return: A list containing all channels the node participates. Optionally filtered by a token address and/or partner address. Raises: KeyError: An error occurred when the token address is unknown to the node. """ if registry_address and not is_binary_address(registry_address): raise InvalidAddress('Expected binary address format for registry in get_channel_list') if token_address and not is_binary_address(token_address): raise InvalidAddress('Expected binary address format for token in get_channel_list') if partner_address: if not is_binary_address(partner_address): raise InvalidAddress( 'Expected binary address format for partner in get_channel_list', ) if not token_address: raise UnknownTokenAddress('Provided a partner address but no token address') if token_address and partner_address: channel_state = views.get_channelstate_for( chain_state=views.state_from_raiden(self.raiden), payment_network_id=registry_address, token_address=token_address, partner_address=partner_address, ) if channel_state: result = [channel_state] else: result = [] elif token_address: result = views.list_channelstate_for_tokennetwork( chain_state=views.state_from_raiden(self.raiden), payment_network_id=registry_address, token_address=token_address, ) else: result = views.list_all_channelstate( chain_state=views.state_from_raiden(self.raiden), ) return result
def get_channel_list(self, token_address=None, partner_address=None): """Returns a list of channels associated with the optionally given `token_address` and/or `partner_address`. Args: token_address (bin): an optionally provided token address partner_address (bin): an optionally provided partner address Return: A list containing all channels the node participates. Optionally filtered by a token address and/or partner address. Raises: KeyError: An error occurred when the token address is unknown to the node. """ if token_address and not isaddress(token_address): raise InvalidAddress( 'Expected binary address format for token in get_channel_list') if partner_address and not isaddress(partner_address): raise InvalidAddress( 'Expected binary address format for partner in get_channel_list' ) registry_address = self.raiden.default_registry.address result = list() if token_address and partner_address: channel_state = views.get_channelstate_for( views.state_from_raiden(self.raiden), registry_address, token_address, partner_address, ) if channel_state: result = [channel_state] else: result = [] elif token_address: result = views.list_channelstate_for_tokennetwork( views.state_from_raiden(self.raiden), registry_address, token_address, ) elif partner_address: result = views.list_channelstate_for_tokennetwork( views.state_from_raiden(self.raiden), registry_address, partner_address, ) else: result = views.list_all_channelstate( views.state_from_raiden(self.raiden), ) return result
def notice_explorer_to_be_alive(endpoint_explorer, discoverable, node_address, raiden_instance): """ Notice api explorer what node is alive, sending a HTTP request """ try: raiden = raiden_instance channels = views.list_all_channelstate(chain_state=views.state_from_raiden(raiden)) if discoverable and len(channels) == 0 and endpoint_explorer: url = endpoint_explorer + "luminoNode/" + node_address response = requests.get(url) if response.status_code == 200: json_data = json.loads(response.text) data = json_data['data'] data['last_alive_signal'] = datetime.utcnow().isoformat() headers = {'Content-type': 'application/json', 'Accept': 'application/json'} response = requests.put(url, json=data, headers=headers) if response.status_code == 200: log.info("Succesfully send alive signal to Lumino Explorer") else: log.info("Warning: There was an error sending alive signal to Lumino Explorer. Status: " + str(response.status_code)) else: log.info("Warning: send alive signal to Lumino Explorer, is not posible because node is not registered") except requests.exceptions.RequestException as e: log.info("Warning: Could not connect to Lumino Explorer. Your node will not send alive signal.")
def get_channel_list(self, registry_address, token_address=None, partner_address=None): """Returns a list of channels associated with the optionally given `token_address` and/or `partner_address`. Args: token_address (bin): an optionally provided token address partner_address (bin): an optionally provided partner address Return: A list containing all channels the node participates. Optionally filtered by a token address and/or partner address. Raises: KeyError: An error occurred when the token address is unknown to the node. """ if token_address and not is_binary_address(token_address): raise InvalidAddress('Expected binary address format for token in get_channel_list') if partner_address and not is_binary_address(partner_address): raise InvalidAddress('Expected binary address format for partner in get_channel_list') result = list() if token_address and partner_address: channel_state = views.get_channelstate_for( views.state_from_raiden(self.raiden), registry_address, token_address, partner_address, ) if channel_state: result = [channel_state] else: result = [] elif token_address: result = views.list_channelstate_for_tokennetwork( views.state_from_raiden(self.raiden), registry_address, token_address, ) elif partner_address: result = views.list_channelstate_for_tokennetwork( views.state_from_raiden(self.raiden), registry_address, partner_address, ) else: result = views.list_all_channelstate( views.state_from_raiden(self.raiden), ) return result
def install_and_query_all_blockchain_filters( self, token_network_registry_address, secret_registry_address, from_block=0, ): token_network_registry = self.chain.token_network_registry( token_network_registry_address) secret_registry = self.chain.secret_registry(secret_registry_address) channels = views.list_all_channelstate(views.state_from_raiden(self), ) token_networks = views.get_token_network_identifiers( views.state_from_raiden(self), token_network_registry_address, ) # Install the filters and then poll them and dispatch the events to the WAL with self.event_poll_lock: self.blockchain_events.add_token_network_registry_listener( token_network_registry, from_block, ) self.blockchain_events.add_secret_registry_listener( secret_registry, from_block, ) for token_network in token_networks: token_network_proxy = self.chain.token_network(token_network) self.blockchain_events.add_token_network_listener( token_network_proxy, from_block, ) for channel_state in channels: channel_proxy = self.chain.payment_channel( channel_state.token_network_identifier, channel_state.identifier, ) self.blockchain_events.add_payment_channel_listener( channel_proxy, from_block, ) chain_id = self.chain.network_id # We need to query the events at this point in order to obtain an up to # date view of the blockchain right before the node starts its transport # and starts receiving messages. for event in self.blockchain_events.poll_blockchain_events( self.get_block_number(), ): on_blockchain_event( self, event, event.event_data['block_number'], chain_id, )
def get_node_balances( chain_state, token_network_address: TokenNetworkAddress) -> List[Tuple[Any]]: channels = views.list_all_channelstate(chain_state) channels = [ channel for channel in channels if channel.canonical_identifier.token_network_address == to_canonical_address(token_network_address) ] balances = [( channel_state.partner_state.address, channel.get_balance(channel_state.our_state, channel_state.partner_state), channel.get_balance(channel_state.partner_state, channel_state.our_state), ) for channel_state in channels] return balances
def install_all_blockchain_filters( self, token_network_registry_proxy, secret_registry_proxy, from_block, ): with self.event_poll_lock: node_state = views.state_from_raiden(self) channels = views.list_all_channelstate(node_state) token_networks = views.get_token_network_identifiers( node_state, token_network_registry_proxy.address, ) self.blockchain_events.add_token_network_registry_listener( token_network_registry_proxy, from_block, ) self.blockchain_events.add_secret_registry_listener( secret_registry_proxy, from_block, ) for token_network in token_networks: token_network_proxy = self.chain.token_network(token_network) self.blockchain_events.add_token_network_listener( token_network_proxy, from_block, ) for channel_state in channels: channel_proxy = self.chain.payment_channel( channel_state.token_network_identifier, channel_state.identifier, ) self.blockchain_events.add_payment_channel_listener( channel_proxy, from_block, )