def test_pfs_rejects_capacity_update_with_wrong_channel_identifier(
pathfinding_service_web3_mock, ):
pathfinding_service_web3_mock.chain_id = ChainID(1)
token_network = TokenNetwork(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS)
pathfinding_service_web3_mock.token_networks[
token_network.address] = token_network
token_network.handle_channel_opened_event(
channel_identifier=ChannelID(0),
participant1=private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
participant2=private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
settle_timeout=15,
)
# Check that the new channel has id == 0
assert token_network.channel_id_to_addresses[ChannelID(0)] == (
private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
)
message = get_updatepfs_message(
channel_identifier=ChannelID(35),
updating_participant=private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
other_participant=private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
privkey_signer=PRIVAT_KEY_EXAMPLE_1,
)
with pytest.raises(InvalidCapacityUpdate) as exinfo:
pathfinding_service_web3_mock.on_pfs_update(message)
assert "unknown channel identifier in token network" in str(exinfo.value)
def test_edge_weight(addresses):
channel_id = ChannelID(1)
participant1 = addresses[0]
participant2 = addresses[1]
settle_timeout = 15
view = ChannelView(TokenNetworkAddress("0x11"), channel_id, participant1,
participant2, settle_timeout)
amount = TokenAmount(int(1e18)) # one RDN
# no penalty
assert TokenNetwork.edge_weight(dict(),
dict(view=view),
amount=amount,
fee_penalty=0) == 1
# channel already used in a previous route
assert (TokenNetwork.edge_weight({channel_id: 2},
dict(view=view),
amount=amount,
fee_penalty=0) == 3)
# absolute fee
view.absolute_fee = FeeAmount(int(0.03e18))
assert TokenNetwork.edge_weight(dict(),
dict(view=view),
amount=amount,
fee_penalty=100) == 4
# relative fee
view.absolute_fee = FeeAmount(0)
view.relative_fee = 0.01
assert TokenNetwork.edge_weight(dict(),
dict(view=view),
amount=amount,
fee_penalty=100) == 2
def test_routing_simple(
token_network_model: TokenNetwork,
populate_token_network_case_1: None,
addresses: List[Address],
):
view01: ChannelView = token_network_model.G[addresses[0]][
addresses[1]]["view"]
view10: ChannelView = token_network_model.G[addresses[1]][
addresses[0]]["view"]
assert view01.deposit == 100
assert view01.absolute_fee == 0
assert view01.capacity == 90
assert view10.capacity == 60
# 0->2->3 is the shortest path, but has no capacity, so 0->1->4->3 is used
paths = token_network_model.get_paths(addresses[0],
addresses[3],
value=TokenAmount(10),
max_paths=1,
hop_bias=1)
assert len(paths) == 1
assert paths[0] == {
"path": [addresses[0], addresses[1], addresses[4], addresses[3]],
"estimated_fee": 0,
}
# Not connected.
with pytest.raises(NetworkXNoPath):
token_network_model.get_paths(addresses[0],
addresses[5],
value=TokenAmount(10),
max_paths=1)
def test_routing_simple(
token_network_model: TokenNetwork,
populate_token_network_case_1: None,
addresses: List[Address],
):
view01: ChannelView = token_network_model.G[addresses[0]][
addresses[1]]['view']
view10: ChannelView = token_network_model.G[addresses[1]][
addresses[0]]['view']
assert view01.deposit == 100
assert isclose(view01.relative_fee, DEFAULT_PERCENTAGE_FEE)
assert view01.capacity == 90
assert view10.capacity == 60
# 0->2->3 is the shortest path, but has no capacity, so 0->1->4->3 is used
paths = token_network_model.get_paths(
addresses[0],
addresses[3],
value=10,
max_paths=1,
hop_bias=1,
)
assert len(paths) == 1
assert paths[0] == {
'path': [addresses[0], addresses[1], addresses[4], addresses[3]],
'estimated_fee': 0,
}
# Not connected.
with pytest.raises(NetworkXNoPath):
token_network_model.get_paths(addresses[0],
addresses[5],
value=10,
max_paths=1)
def test_path_without_capacity(token_network_model: TokenNetwork,
addresses: List[Address]):
"""Channels without capacity must not cause unexpected exceptions.
Regression test for https://github.com/raiden-network/raiden-services/issues/636
"""
token_network_model.handle_channel_opened_event(
channel_identifier=ChannelID(1),
participant1=addresses[0],
participant2=addresses[1],
)
token_network_model.handle_channel_opened_event(
channel_identifier=ChannelID(2),
participant1=addresses[1],
participant2=addresses[2],
)
token_network_model.G[addresses[1]][
addresses[2]]["view"].channel.capacity1 = 100
path = Path(
G=token_network_model.G,
nodes=[addresses[0], addresses[1], addresses[2]],
value=PaymentAmount(10),
reachability_state=SimpleReachabilityContainer({}),
)
assert not path.is_valid
def test_pfs_rejects_capacity_update_with_wrong_nonces(
addresses: List[Address],
pathfinding_service_mocked_listeners: PathfindingService,
):
pathfinding_service_mocked_listeners.chain_id = 1
token_network = TokenNetwork(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS,
token_address=DEFAULT_TOKEN_ADDRESS,
)
pathfinding_service_mocked_listeners.token_networks[
token_network.address] = token_network
token_network.handle_channel_opened_event(
channel_identifier=ChannelIdentifier(0),
participant1=addresses[0],
participant2=addresses[1],
settle_timeout=15,
)
token_network.handle_channel_new_deposit_event(
channel_identifier=ChannelIdentifier(0),
receiver=addresses[0],
total_deposit=100,
)
token_network.handle_channel_new_deposit_event(
channel_identifier=ChannelIdentifier(0),
receiver=addresses[1],
total_deposit=100,
)
# Check that the new channel has id == 0
assert token_network.channel_id_to_addresses[ChannelIdentifier(0)] == (
addresses[0],
addresses[1],
)
message = get_updatepfs_message(
updating_participant=addresses[0],
other_participant=addresses[1],
)
# Check first capacity update succeeded
pathfinding_service_mocked_listeners.on_pfs_update(message)
view_to_partner, view_from_partner = token_network.get_channel_views_for_partner(
channel_identifier=ChannelIdentifier(0),
updating_participant=addresses[0],
other_participant=addresses[1],
)
assert view_to_partner.capacity == 90
assert view_to_partner.update_nonce == 1
assert view_from_partner.capacity == 110
assert view_from_partner.update_nonce == 0
# Send the same Capacity Update again - leads to an exception
with pytest.raises(InvalidCapacityUpdate) as exinfo:
pathfinding_service_mocked_listeners.on_pfs_update(message)
assert 'Capacity Update already received' in str(exinfo.value)
def test_pfs_rejects_capacity_update_with_wrong_nonces(
pathfinding_service_web3_mock, ):
pathfinding_service_web3_mock.chain_id = ChainID(1)
token_network = TokenNetwork(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS)
pathfinding_service_web3_mock.token_networks[
token_network.address] = token_network
token_network.handle_channel_opened_event(
channel_identifier=ChannelID(0),
participant1=private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
participant2=private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
settle_timeout=15,
)
token_network.handle_channel_new_deposit_event(
channel_identifier=ChannelID(0),
receiver=private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
total_deposit=100,
)
token_network.handle_channel_new_deposit_event(
channel_identifier=ChannelID(0),
receiver=private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
total_deposit=100,
)
# Check that the new channel has id == 0
assert token_network.channel_id_to_addresses[ChannelID(0)] == (
private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
)
message = get_updatepfs_message(
updating_participant=private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
other_participant=private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
privkey_signer=PRIVAT_KEY_EXAMPLE_1,
)
# Check first capacity update succeeded
pathfinding_service_web3_mock.on_pfs_update(message)
view_to_partner, view_from_partner = token_network.get_channel_views_for_partner(
channel_identifier=ChannelID(0),
updating_participant=private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
other_participant=private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
)
assert view_to_partner.capacity == 90
assert view_to_partner.update_nonce == 1
assert view_from_partner.capacity == 110
assert view_from_partner.update_nonce == 0
# Send the same Capacity Update again - leads to an exception
with pytest.raises(InvalidCapacityUpdate) as exinfo:
pathfinding_service_web3_mock.on_pfs_update(message)
assert "Capacity Update already received" in str(exinfo.value)
def test_routing_result_order(
token_network_model: TokenNetwork,
populate_token_network_case_1: None,
addresses: List[Address],
):
paths = token_network_model.get_paths(
addresses[0],
addresses[2],
value=10,
max_paths=5,
hop_bias=1,
)
# 5 paths requested, but only 3 are available
assert len(paths) == 3
assert paths[0] == {
'path': [addresses[0], addresses[2]],
'estimated_fee': 0,
}
assert paths[1] == {
'path': [addresses[0], addresses[1], addresses[2]],
'estimated_fee': 0,
}
assert paths[2] == {
'path': [addresses[0], addresses[1], addresses[4], addresses[3], addresses[2]],
'estimated_fee': 0,
}
def test_routing_benchmark(token_network_model: TokenNetwork,
populate_token_network_random: None):
value = TokenAmount(100)
G = token_network_model.G
times = []
start = time.time()
for _ in range(100):
tic = time.time()
source, target = random.sample(G.nodes, 2)
paths = token_network_model.get_paths(source,
target,
value=value,
max_paths=5,
bias=0.0)
toc = time.time()
times.append(toc - tic)
end = time.time()
for path_object in paths:
path = path_object["path"]
fees = path_object["estimated_fee"]
for node1, node2 in zip(path[:-1], path[1:]):
view: ChannelView = G[node1][node2]["view"]
print("fee = ", view.absolute_fee, "capacity = ", view.capacity)
print("fee sum = ", fees)
print("Paths: ", paths)
print("Mean runtime: ", sum(times) / len(times))
print("Min runtime: ", min(times))
print("Max runtime: ", max(times))
print("Total runtime: ", end - start)
def create_token_network_for_address(
self,
token_network_address: Address,
token_address: Address,
block_number: int = 0,
):
token_network = TokenNetwork(token_network_address, token_address)
self.token_networks[token_network_address] = token_network
log.debug('Creating token network model', token_network_address=token_network_address)
token_network_listener = BlockchainListener(
web3=self.web3,
contract_manager=self.contract_manager,
contract_address=token_network_address,
contract_name=CONTRACT_TOKEN_NETWORK,
required_confirmations=self.required_confirmations,
poll_interval=self.poll_interval,
sync_start_block=block_number,
)
# subscribe to event notifications from blockchain listener
token_network_listener.add_confirmed_listener(
create_channel_event_topics(),
self.handle_channel_event,
)
token_network_listener.start()
self.token_network_listeners.append(token_network_listener)
def test_capacity_check(
token_network_model: TokenNetwork,
reachability_state: SimpleReachabilityContainer,
addresses: List[Address],
):
"""Test that the mediation fees are included in the capacity check"""
# First get a path without mediation fees. This must return the shortest path: 4->1->0
paths = token_network_model.get_paths(
source=addresses[4],
target=addresses[0],
value=PaymentAmount(35),
max_paths=1,
reachability_state=reachability_state,
)
index_paths = [addresses_to_indexes(p.nodes, addresses) for p in paths]
assert index_paths == [[4, 1, 0]]
# New let's add mediation fees to the channel 0->1.
model_with_fees = deepcopy(token_network_model)
model_with_fees.G[addresses[1]][
addresses[0]]["view"].fee_schedule_sender.flat = 1
# The transfer from 4->1 must now include 1 Token for the mediation fee
# which will be payed for the 1->0 channel in addition to the payment
# value of 35. But 35 + 1 exceeds the capacity for channel 4->1, which is
# 35. So we should now get the next best route instead.
paths = model_with_fees.get_paths(
source=addresses[4],
target=addresses[0],
value=PaymentAmount(35),
max_paths=1,
reachability_state=reachability_state,
fee_penalty=0,
)
index_paths = [addresses_to_indexes(p.nodes, addresses) for p in paths]
assert index_paths == [[4, 1, 2, 0]]
def handle_token_network_created(self, event: ReceiveTokenNetworkCreatedEvent) -> None:
network_address = TokenNetworkAddress(event.token_network_address)
if not self.follows_token_network(network_address):
log.info("Found new token network", **asdict(event))
self.token_networks[network_address] = TokenNetwork(network_address)
self.database.upsert_token_network(network_address)
def test_routing_result_order(
token_network_model: TokenNetwork,
reachability_state: SimpleReachabilityContainer,
addresses: List[Address],
):
hex_addrs = [to_checksum_address(addr) for addr in addresses]
paths = token_network_model.get_paths(
source=addresses[0],
target=addresses[2],
value=PaymentAmount(10),
max_paths=5,
reachability_state=reachability_state,
)
# 5 paths requested, but only 2 are available
assert len(paths) == 2
assert paths[0].to_dict()["path"] == [
hex_addrs[0], hex_addrs[1], hex_addrs[2]
]
assert paths[0].to_dict()["estimated_fee"] == 0
assert paths[1].to_dict()["path"] == [
hex_addrs[0],
hex_addrs[1],
hex_addrs[4],
hex_addrs[3],
hex_addrs[2],
]
assert paths[1].to_dict()["estimated_fee"] == 0
def test_routing_benchmark(
token_network_model: TokenNetwork,
populate_token_network_random: None,
):
value = 100
G = token_network_model.G
times = []
start = time.time()
for _ in range(100):
tic = time.time()
source, target = random.sample(G.nodes, 2)
paths = token_network_model.get_paths(source,
target,
value=value,
max_paths=5,
bias=0.0)
toc = time.time()
times.append(toc - tic)
end = time.time()
for path_object in paths:
path = path_object['path']
fees = path_object['estimated_fee']
for node1, node2 in zip(path[:-1], path[1:]):
view: ChannelView = G[node1][node2]['view']
print('fee = ', view.relative_fee, 'capacity = ', view.capacity)
print('fee sum = ', fees)
print('Paths: ', paths)
print('Mean runtime: ', sum(times) / len(times))
print('Min runtime: ', min(times))
print('Max runtime: ', max(times))
print('Total runtime: ', end - start)
def test_edge_weight(addresses):
a = addresses[0]
b = addresses[1]
view = ChannelView(1, a, b)
assert TokenNetwork.edge_weight(
dict(),
dict(view=view),
) == 1
def test_tn_idempotency_of_channel_openings(token_network_model: TokenNetwork,
addresses: List[Address]):
# create same channel 5 times
for _ in range(5):
token_network_model.handle_channel_opened_event(
channel_identifier=ChannelID(1),
participant1=addresses[0],
participant2=addresses[1],
)
# there should only be one channel
assert len(token_network_model.channel_id_to_addresses) == 1
# now close the channel
token_network_model.handle_channel_removed_event(
channel_identifier=ChannelID(1))
# there should be no channels
assert len(token_network_model.channel_id_to_addresses) == 0
def setup_channel(service: PathfindingService) -> TokenNetwork:
token_network = TokenNetwork(token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS)
service.token_networks[token_network.address] = token_network
token_network.handle_channel_opened_event(
channel_identifier=DEFAULT_CHANNEL_ID,
participant1=PRIVATE_KEY_1_ADDRESS,
participant2=PRIVATE_KEY_2_ADDRESS,
settle_timeout=15,
)
# Check that the new channel has id == 0
assert token_network.channel_id_to_addresses[DEFAULT_CHANNEL_ID] == (
PRIVATE_KEY_1_ADDRESS,
PRIVATE_KEY_2_ADDRESS,
)
return token_network
def handle_token_network_created(
self, event: ReceiveTokenNetworkCreatedEvent) -> None:
network_address = event.token_network_address
settle_timeout = event.settle_timeout
if not self.follows_token_network(network_address):
log.info("Found new token network", event_=event)
self.token_networks[network_address] = TokenNetwork(
network_address, settle_timeout)
self.database.upsert_token_network(network_address, settle_timeout)
def test_suggest_partner(
token_network_model: TokenNetwork,
addresses: List[Address],
):
a = addresses # pylint: disable=invalid-name
reachability = SimpleReachabilityContainer(
{a[i]: AddressReachability.REACHABLE
for i in range(3)})
suggestions = token_network_model.suggest_partner(reachability)
assert len(suggestions) == 3
assert set(s["address"] for s in suggestions) == set(
to_checksum_address(a[i]) for i in range(3))
assert suggestions[0]["address"] == to_checksum_address(a[1])
# Increasing uptime of node 0 should move it to first place
reachability.times[a[0]] -= timedelta(seconds=10)
suggestions = token_network_model.suggest_partner(reachability)
assert suggestions[0]["address"] == to_checksum_address(a[0])
def test_routing_simple(
token_network_model: TokenNetwork,
reachability_state: SimpleReachabilityContainer,
addresses: List[Address],
):
hex_addrs = [to_checksum_address(addr) for addr in addresses]
view01: ChannelView = token_network_model.G[addresses[0]][
addresses[1]]["view"]
view10: ChannelView = token_network_model.G[addresses[1]][
addresses[0]]["view"]
assert view01.fee_schedule_sender.flat == 0
assert view01.capacity == 90
assert view10.capacity == 60
# 0->2->3 is the shortest path, but has no capacity.
# The remaining paths are 0->1->2->3 and 0->1->4->3.
paths = token_network_model.get_paths(
source=addresses[0],
target=addresses[3],
value=PaymentAmount(10),
max_paths=2,
reachability_state=reachability_state,
)
assert len(paths) == 2
assert paths[0].to_dict()["path"] == [
hex_addrs[0], hex_addrs[1], hex_addrs[2], hex_addrs[3]
]
assert paths[0].to_dict()["estimated_fee"] == 0
assert paths[1].to_dict()["path"] == [
hex_addrs[0], hex_addrs[1], hex_addrs[4], hex_addrs[3]
]
assert paths[1].to_dict()["estimated_fee"] == 0
# Not connected.
no_paths = token_network_model.get_paths(
source=addresses[0],
target=addresses[5],
value=PaymentAmount(10),
max_paths=1,
reachability_state=reachability_state,
)
assert [] == no_paths
def test_edge_weight(addresses):
channel_id = ChannelIdentifier(1)
participant1 = addresses[0]
participant2 = addresses[1]
settle_timeout = 15
view = ChannelView(channel_id, participant1, participant2, settle_timeout)
assert TokenNetwork.edge_weight(
dict(),
dict(view=view),
) == 1
def test_routing_result_order(token_network_model: TokenNetwork,
addresses: List[Address]):
paths = token_network_model.get_paths(addresses[0],
addresses[2],
value=TokenAmount(10),
max_paths=5)
# 5 paths requested, but only 1 is available
assert len(paths) == 1
assert paths[0] == {
"path": [addresses[0], addresses[1], addresses[2]],
"estimated_fee": 0
}
def test_pfs_rejects_capacity_update_with_impossible_updating_capacity(
pathfinding_service_web3_mock, ):
pathfinding_service_web3_mock.chain_id = ChainID(1)
token_network = TokenNetwork(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS)
pathfinding_service_web3_mock.token_networks[
token_network.address] = token_network
token_network.handle_channel_opened_event(
channel_identifier=ChannelID(0),
participant1=private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
participant2=private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
settle_timeout=15,
)
token_network.handle_channel_new_deposit_event(
channel_identifier=ChannelID(0),
receiver=private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
total_deposit=100,
)
token_network.handle_channel_new_deposit_event(
channel_identifier=ChannelID(0),
receiver=private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
total_deposit=100,
)
# Check that the new channel has id == 0
assert token_network.channel_id_to_addresses[ChannelID(0)] == (
private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
)
with patch(
"pathfinding_service.service.recover_signer_from_capacity_update",
private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
):
message = get_updatepfs_message(
updating_participant=private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
other_participant=private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
updating_capacity=TokenAmount(UINT256_MAX),
privkey_signer=PRIVAT_KEY_EXAMPLE_1,
)
message.updating_capacity = TokenAmount(UINT256_MAX + 1)
with pytest.raises(InvalidCapacityUpdate) as exinfo:
pathfinding_service_web3_mock.on_pfs_update(message)
assert "with impossible updating_capacity" in str(exinfo.value)
def test_routing_simple(
token_network_model: TokenNetwork,
address_to_reachability: Dict[Address, AddressReachability],
addresses: List[Address],
):
hex_addrs = [to_checksum_address(addr) for addr in addresses]
view01: ChannelView = token_network_model.G[addresses[0]][
addresses[1]]["view"]
view10: ChannelView = token_network_model.G[addresses[1]][
addresses[0]]["view"]
assert view01.deposit == 100
assert view01.fee_schedule_sender.flat == 0
assert view01.capacity == 90
assert view10.capacity == 60
# 0->2->3 is the shortest path, but has no capacity, so 0->1->4->3 is used
paths = token_network_model.get_paths(
source=addresses[0],
target=addresses[3],
value=TokenAmount(10),
max_paths=1,
address_to_reachability=address_to_reachability,
)
assert len(paths) == 1
assert paths[0] == {
"path": [hex_addrs[0], hex_addrs[1], hex_addrs[4], hex_addrs[3]],
"estimated_fee": 0,
}
# Not connected.
with pytest.raises(NetworkXNoPath):
token_network_model.get_paths(
source=addresses[0],
target=addresses[5],
value=TokenAmount(10),
max_paths=1,
address_to_reachability=address_to_reachability,
)
def test_pfs_rejects_capacity_update_with_wrong_other_participant(
addresses: List[Address],
pathfinding_service_mocked_listeners: PathfindingService,
):
pathfinding_service_mocked_listeners.chain_id = 1
token_network = TokenNetwork(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS,
token_address=DEFAULT_TOKEN_ADDRESS,
)
pathfinding_service_mocked_listeners.token_networks[
token_network.address] = token_network
token_network.handle_channel_opened_event(
channel_identifier=ChannelIdentifier(0),
participant1=addresses[0],
participant2=addresses[1],
settle_timeout=15,
)
token_network.handle_channel_new_deposit_event(
channel_identifier=ChannelIdentifier(0),
receiver=addresses[0],
total_deposit=100,
)
token_network.handle_channel_new_deposit_event(
channel_identifier=ChannelIdentifier(0),
receiver=addresses[1],
total_deposit=100,
)
# Check that the new channel has id == 0
assert token_network.channel_id_to_addresses[ChannelIdentifier(0)] == (
addresses[0],
addresses[1],
)
message = get_updatepfs_message(
updating_participant=addresses[0],
other_participant=addresses[2],
)
with pytest.raises(InvalidCapacityUpdate) as exinfo:
pathfinding_service_mocked_listeners.on_pfs_update(message)
assert 'Other Participant of Capacity Update does not match' in str(
exinfo.value)
def test_routing_result_order(
token_network_model: TokenNetwork,
address_to_reachability: Dict[Address, AddressReachability],
addresses: List[Address],
):
hex_addrs = [to_checksum_address(addr) for addr in addresses]
paths = token_network_model.get_paths(
addresses[0],
addresses[2],
value=PaymentAmount(10),
max_paths=5,
address_to_reachability=address_to_reachability,
)
# 5 paths requested, but only 1 is available
assert len(paths) == 1
assert paths[0] == {"path": [hex_addrs[0], hex_addrs[1], hex_addrs[2]], "estimated_fee": 0}
def test_routing_benchmark(token_network_model: TokenNetwork): # pylint: disable=too-many-locals
value = PaymentAmount(100)
G = token_network_model.G
addresses_to_reachabilities = SimpleReachabilityContainer({
node: random.choice((
AddressReachability.REACHABLE,
AddressReachability.UNKNOWN,
AddressReachability.UNREACHABLE,
))
for node in G.nodes
})
times = []
start = time.time()
for _ in range(100):
tic = time.time()
source, target = random.sample(G.nodes, 2)
paths = token_network_model.get_paths(
source=source,
target=target,
value=value,
max_paths=5,
reachability_state=addresses_to_reachabilities,
)
toc = time.time()
times.append(toc - tic)
end = time.time()
for path_object in paths:
path = path_object.nodes
fees = path_object.estimated_fee
for node1, node2 in zip(path[:-1], path[1:]):
view: ChannelView = G[to_canonical_address(node1)][
to_canonical_address(node2)]["view"]
print("capacity = ", view.capacity)
print("fee sum = ", fees)
print("Paths: ", paths)
print("Mean runtime: ", sum(times) / len(times))
print("Min runtime: ", min(times))
print("Max runtime: ", max(times))
print("Total runtime: ", end - start)
def get_paths( # pylint: disable=too-many-arguments
token_network_model: TokenNetwork,
reachability_state: SimpleReachabilityContainer,
addresses: List[Address],
source_index: int = 0,
target_index: int = 8,
value: PaymentAmount = PaymentAmount(10),
max_paths: int = 5,
diversity_penalty: float = DIVERSITY_PEN_DEFAULT,
) -> List:
paths = token_network_model.get_paths(
diversity_penalty=diversity_penalty,
source=addresses[source_index],
target=addresses[target_index],
value=value,
max_paths=max_paths,
reachability_state=reachability_state,
)
index_paths = [addresses_to_indexes(p.nodes, addresses) for p in paths]
return index_paths
def get_paths( # pylint: disable=too-many-arguments
token_network_model: TokenNetwork,
address_to_reachability: Dict[Address, AddressReachability],
addresses: List[Address],
source_index: int = 0,
target_index: int = 8,
value: TokenAmount = TokenAmount(10),
max_paths: int = 5,
diversity_penalty: float = DIVERSITY_PEN_DEFAULT,
) -> List:
paths = token_network_model.get_paths(
diversity_penalty=diversity_penalty,
source=addresses[source_index],
target=addresses[target_index],
value=value,
max_paths=max_paths,
address_to_reachability=address_to_reachability,
)
index_paths = [addresses_to_indexes(p["path"], addresses) for p in paths]
return index_paths
def test_pfs_rejects_capacity_update_with_wrong_token_network_address(
pathfinding_service_web3_mock, ):
pathfinding_service_web3_mock.chain_id = ChainID(1)
token_network = TokenNetwork(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS)
pathfinding_service_web3_mock.token_networks[
token_network.address] = token_network
message = get_updatepfs_message(
token_network_address=TokenNetworkAddressBytes(
decode_hex("0x" + "1" * 40)),
updating_participant=private_key_to_address(PRIVAT_KEY_EXAMPLE_1),
other_participant=private_key_to_address(PRIVAT_KEY_EXAMPLE_2),
privkey_signer=PRIVAT_KEY_EXAMPLE_1,
)
with pytest.raises(InvalidCapacityUpdate) as exinfo:
pathfinding_service_web3_mock.on_pfs_update(message)
assert "unknown token network" in str(exinfo.value)
