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,
)
