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 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 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 test_channel_with_self(raiden_network, settle_timeout, token_addresses): app0, = raiden_network # pylint: disable=unbalanced-tuple-unpacking registry_address = app0.raiden.default_registry.address token_address = token_addresses[0] current_chanels = views.list_channelstate_for_tokennetwork( views.state_from_app(app0), registry_address, token_address, ) assert not current_chanels graph0 = app0.raiden.default_registry.manager_by_token(token_address) with pytest.raises(SamePeerAddress) as excinfo: graph0.new_netting_channel( app0.raiden.address, settle_timeout, ) assert 'The other peer must not have the same address as the client.' in str(excinfo.value) transaction_hash = graph0.proxy.transact('newChannel', app0.raiden.address, settle_timeout) # wait to make sure we get the receipt wait_until_block(app0.raiden.chain, app0.raiden.chain.block_number() + 5) assert check_transaction_threw(app0.raiden.chain.client, transaction_hash)
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 test_channel_with_self(raiden_network, settle_timeout, token_addresses): app0, = raiden_network # pylint: disable=unbalanced-tuple-unpacking registry_address = app0.raiden.default_registry.address token_address = token_addresses[0] current_chanels = views.list_channelstate_for_tokennetwork( views.state_from_app(app0), registry_address, token_address, ) assert not current_chanels token_network_address = app0.raiden.default_registry.get_token_network( token_address) token_network0 = app0.raiden.chain.token_network(token_network_address) with pytest.raises(SamePeerAddress) as excinfo: token_network0.new_netting_channel( partner=app0.raiden.address, settle_timeout=settle_timeout, given_block_identifier='latest', ) assert 'The other peer must not have the same address as the client.' in str( excinfo.value)
def test_list_channelstate_for_tokennetwork(chain_state, payment_network_id, token_id): """Regression test for https://github.com/raiden-network/raiden/issues/3257""" token_address = token_id result = list_channelstate_for_tokennetwork( chain_state=chain_state, payment_network_id=payment_network_id, token_address=token_address) assert isinstance(result, list)
def test_list_channelstate_for_tokennetwork( chain_state, token_network_state, payment_network_id, token_id, ): """Regression test for https://github.com/raiden-network/raiden/issues/3257""" token_address = token_id result = list_channelstate_for_tokennetwork( chain_state=chain_state, payment_network_id=payment_network_id, token_address=token_address, ) assert isinstance(result, list)
def test_channel_with_self(raiden_network, settle_timeout, token_addresses): app0, = raiden_network # pylint: disable=unbalanced-tuple-unpacking registry_address = app0.raiden.default_registry.address token_address = token_addresses[0] current_chanels = views.list_channelstate_for_tokennetwork( views.state_from_app(app0), registry_address, token_address) assert not current_chanels token_network_address = app0.raiden.default_registry.get_token_network( token_address, "latest") token_network0 = app0.raiden.proxy_manager.token_network( token_network_address) with pytest.raises(SamePeerAddress): token_network0.new_netting_channel( partner=app0.raiden.address, settle_timeout=settle_timeout, given_block_identifier="latest", )
def test_channel_with_self(raiden_network, settle_timeout, token_addresses): app0, = raiden_network # pylint: disable=unbalanced-tuple-unpacking registry_address = app0.raiden.default_registry.address token_address = token_addresses[0] current_chanels = views.list_channelstate_for_tokennetwork( views.state_from_app(app0), registry_address, token_address, ) assert not current_chanels token_network_address = app0.raiden.default_registry.get_token_network(token_address) token_network0 = app0.raiden.chain.token_network(token_network_address) with pytest.raises(SamePeerAddress) as excinfo: token_network0.new_netting_channel( app0.raiden.address, settle_timeout, ) assert 'The other peer must not have the same address as the client.' in str(excinfo.value)
def test_leave_token_network(raiden_network: List[RaidenService], token_addresses): registry_address = raiden_network[0].default_registry.address token_address = token_addresses[0] _, app1, _ = raiden_network channels = views.list_channelstate_for_tokennetwork( chain_state=views.state_from_raiden(app1), token_network_registry_address=registry_address, token_address=token_address, ) timeout = block_offset_timeout( app1, "Channels not settled in time", BlockTimeout(channels[0].settle_timeout * 10)) with timeout: RaidenAPI(app1).token_network_leave(registry_address, token_address) waiting.wait_for_settle( raiden=app1, token_network_registry_address=registry_address, token_address=token_address, channel_ids=[channel.identifier for channel in channels], retry_timeout=0.1, )
def run_test_participant_selection(raiden_network, token_addresses): # pylint: disable=too-many-locals registry_address = raiden_network[0].raiden.default_registry.address token_address = token_addresses[0] # connect the first node (will register the token if necessary) RaidenAPI(raiden_network[0].raiden).token_network_connect( registry_address=registry_address, token_address=token_address, funds=100, ) # Test invalid argument values with pytest.raises(InvalidAmount): RaidenAPI(raiden_network[0].raiden).token_network_connect( registry_address=registry_address, token_address=token_address, funds=-1, ) with pytest.raises(InvalidAmount): RaidenAPI(raiden_network[0].raiden).token_network_connect( registry_address=registry_address, token_address=token_address, funds=100, joinable_funds_target=2, ) with pytest.raises(InvalidAmount): RaidenAPI(raiden_network[0].raiden).token_network_connect( registry_address=registry_address, token_address=token_address, funds=100, joinable_funds_target=-1, ) # connect the other nodes connect_greenlets = [ gevent.spawn( RaidenAPI(app.raiden).token_network_connect, registry_address, token_address, 100, ) for app in raiden_network[1:] ] gevent.wait(connect_greenlets) token_network_registry_address = views.get_token_network_identifier_by_token_address( views.state_from_raiden(raiden_network[0].raiden), payment_network_id=registry_address, token_address=token_address, ) connection_managers = [ app.raiden.connection_manager_for_token_network( token_network_registry_address, ) for app in raiden_network ] unsaturated_connection_managers = connection_managers[:] exception = AssertionError('Unsaturated connection managers', unsaturated_connection_managers) with gevent.Timeout(120, exception): while unsaturated_connection_managers: for manager in unsaturated_connection_managers: if is_manager_saturated(manager, registry_address, token_address): unsaturated_connection_managers.remove(manager) gevent.sleep(1) assert saturated_count( connection_managers, registry_address, token_address, ) == len(connection_managers) # ensure unpartitioned network for app in raiden_network: node_state = views.state_from_raiden(app.raiden) network_state = views.get_token_network_by_token_address( node_state, registry_address, token_address, ) assert network_state is not None for target in raiden_network: if target.raiden.address == app.raiden.address: continue routes = routing.get_best_routes( chain_state=node_state, token_network_id=network_state.address, from_address=app.raiden.address, to_address=target.raiden.address, amount=1, previous_address=None, config={}, privkey=b'', # not used if pfs is not configured ) assert routes is not None # create a transfer to the leaving node, so we have a channel to settle for app in raiden_network: sender = app.raiden sender_channel = next( (channel_state for channel_state in RaidenAPI(sender).get_channel_list( registry_address=registry_address, token_address=token_address, ) if channel_state.our_state.contract_balance > 0 and channel_state.partner_state.contract_balance > 0), None, ) # choose a fully funded channel from sender if sender_channel: break registry_address = sender.default_registry.address receiver = next( app.raiden for app in raiden_network if app.raiden.address == sender_channel.partner_state.address) # assert there is a direct channel receiver -> sender (vv) receiver_channel = RaidenAPI(receiver).get_channel_list( registry_address=registry_address, token_address=token_address, partner_address=sender.address, ) assert len(receiver_channel) == 1 receiver_channel = receiver_channel[0] exception = ValueError('partner not reachable') with gevent.Timeout(30, exception=exception): waiting.wait_for_healthy(sender, receiver.address, 1) amount = 1 RaidenAPI(sender).transfer_and_wait( registry_address, token_address, amount, receiver.address, transfer_timeout=10, ) exception = ValueError('timeout while waiting for incoming transaction') with gevent.Timeout(30, exception=exception): wait_for_transaction( receiver, registry_address, token_address, sender.address, ) # test `leave()` method connection_manager = connection_managers[0] timeout = (sender_channel.settle_timeout * connection_manager.raiden.chain.estimate_blocktime() * 10) assert timeout > 0 channels = views.list_channelstate_for_tokennetwork( chain_state=views.state_from_raiden(connection_manager.raiden), payment_network_id=registry_address, token_address=token_address, ) channel_identifiers = [channel.identifier for channel in channels] exception = ValueError('timeout while waiting for leave') with gevent.Timeout(timeout, exception=exception): # sender leaves the network RaidenAPI(sender).token_network_leave( registry_address, token_address, ) exception = ValueError(f'Channels didnt get settled after {timeout}') with gevent.Timeout(timeout, exception=exception): waiting.wait_for_settle( raiden=connection_manager.raiden, payment_network_id=registry_address, token_address=token_address, channel_ids=channel_identifiers, retry_timeout=0.1, )
def test_participant_selection(raiden_network, token_addresses): # pylint: disable=too-many-locals registry_address = raiden_network[0].raiden.default_registry.address one_to_n_address = raiden_network[0].raiden.default_one_to_n_address token_address = token_addresses[0] # connect the first node - this will register the token and open the first channel # Since there is no other nodes available to connect to this call will do nothing more RaidenAPI(raiden_network[0].raiden).token_network_connect( registry_address=registry_address, token_address=token_address, funds=TokenAmount(100)) # Test invalid argument values with pytest.raises(InvalidAmount): RaidenAPI(raiden_network[0].raiden).token_network_connect( registry_address=registry_address, token_address=token_address, funds=TokenAmount(-1)) with pytest.raises(InvalidAmount): RaidenAPI(raiden_network[0].raiden).token_network_connect( registry_address=registry_address, token_address=token_address, funds=TokenAmount(100), joinable_funds_target=2, ) with pytest.raises(InvalidAmount): RaidenAPI(raiden_network[0].raiden).token_network_connect( registry_address=registry_address, token_address=token_address, funds=TokenAmount(100), joinable_funds_target=-1, ) # Call the connect endpoint for all but the first node connect_greenlets = [ gevent.spawn( RaidenAPI(app.raiden).token_network_connect, registry_address, token_address, 100) for app in raiden_network[1:] ] gevent.wait(connect_greenlets) token_network_registry_address = views.get_token_network_address_by_token_address( views.state_from_raiden(raiden_network[0].raiden), token_network_registry_address=registry_address, token_address=token_address, ) connection_managers = [ app.raiden.connection_manager_for_token_network( token_network_registry_address) for app in raiden_network ] unsaturated_connection_managers = connection_managers[:] exception = AssertionError("Unsaturated connection managers", unsaturated_connection_managers) with gevent.Timeout(120, exception): while unsaturated_connection_managers: for manager in unsaturated_connection_managers: if is_manager_saturated(manager, registry_address, token_address): unsaturated_connection_managers.remove(manager) gevent.sleep(1) assert saturated_count(connection_managers, registry_address, token_address) == len(connection_managers) # ensure unpartitioned network for app in raiden_network: node_state = views.state_from_raiden(app.raiden) network_state = views.get_token_network_by_token_address( node_state, registry_address, token_address) assert network_state is not None for target in raiden_network: if target.raiden.address == app.raiden.address: continue _, routes, _ = routing.get_best_routes( chain_state=node_state, token_network_address=network_state.address, one_to_n_address=one_to_n_address, from_address=app.raiden.address, to_address=target.raiden.address, amount=PaymentAmount(1), previous_address=None, pfs_config=None, privkey=b"", # not used if pfs is not configured ) assert routes is not None # create a transfer to the leaving node, so we have a channel to settle for app in raiden_network: sender = app.raiden sender_channel = next( (channel_state for channel_state in RaidenAPI( sender).get_channel_list(registry_address=registry_address, token_address=token_address) if channel_state.our_state.contract_balance > 0 and channel_state.partner_state.contract_balance > 0), None, ) # choose a fully funded channel from sender if sender_channel: break assert sender_channel registry_address = sender.default_registry.address receiver = next( app.raiden for app in raiden_network if app.raiden.address == sender_channel.partner_state.address) # assert there is a direct channel receiver -> sender (vv) receiver_channel = RaidenAPI(receiver).get_channel_list( registry_address=registry_address, token_address=token_address, partner_address=sender.address, ) assert len(receiver_channel) == 1 with gevent.Timeout(30, exception=ValueError("partner not reachable")): waiting.wait_for_healthy(sender, receiver.address, PaymentAmount(1)) with watch_for_unlock_failures(*raiden_network): amount = PaymentAmount(1) RaidenAPI(sender).transfer_and_wait(registry_address, token_address, amount, receiver.address, transfer_timeout=10) with gevent.Timeout( 30, exception=ValueError( "timeout while waiting for incoming transaction")): wait_for_transaction(receiver, registry_address, token_address, sender.address) # test `leave()` method connection_manager = connection_managers[0] timeout = (sender_channel.settle_timeout * estimate_blocktime(connection_manager.raiden.rpc_client) * 10) assert timeout > 0 channels = views.list_channelstate_for_tokennetwork( chain_state=views.state_from_raiden(connection_manager.raiden), token_network_registry_address=registry_address, token_address=token_address, ) channel_identifiers = [channel.identifier for channel in channels] with gevent.Timeout( timeout, exception=ValueError("timeout while waiting for leave")): # sender leaves the network RaidenAPI(sender).token_network_leave(registry_address, token_address) with gevent.Timeout(timeout, exception=ValueError( f"Channels didnt get settled after {timeout}")): waiting.wait_for_settle( raiden=connection_manager.raiden, token_network_registry_address=registry_address, token_address=token_address, channel_ids=channel_identifiers, retry_timeout=0.1, )