def test_mediated_transfer_with_entire_deposit(raiden_network, number_of_nodes,
token_addresses, deposit,
network_wait) -> None:
app0, app1, app2 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
chain_state, token_network_registry_address, token_address)
# The test uses internal routing at the moment, that's why this is set like that.
# However, the actual calculated fee is 3 instead of the 4 calculated here, therefore
# the amounts are adjusted below
fee1 = FeeAmount(int(deposit * INTERNAL_ROUTING_DEFAULT_FEE_PERC))
fee_margin1 = calculate_fee_margin(deposit, fee1)
fee_difference = 1
secrethash = transfer_and_assert_path(
path=raiden_network,
token_address=token_address,
amount=deposit - fee1 - fee_margin1,
identifier=PaymentID(1),
timeout=network_wait * number_of_nodes,
)
with block_timeout_for_transfer_by_secrethash(app1.raiden, secrethash):
wait_assert(
func=assert_succeeding_transfer_invariants,
token_network_address=token_network_address,
app0=app0,
balance0=0,
pending_locks0=[],
app1=app1,
balance1=deposit * 2,
pending_locks1=[],
)
with block_timeout_for_transfer_by_secrethash(app2.raiden, secrethash):
wait_assert(
func=assert_succeeding_transfer_invariants,
token_network_address=token_network_address,
app0=app1,
balance0=fee1 - fee_difference,
pending_locks0=[],
app1=app2,
balance1=deposit * 2 - fee1 + fee_difference,
pending_locks1=[],
)
app2_capacity = 2 * deposit - fee1
fee2 = FeeAmount(
int(round(app2_capacity * INTERNAL_ROUTING_DEFAULT_FEE_PERC)))
fee_margin2 = calculate_fee_margin(app2_capacity, fee2)
reverse_path = list(raiden_network[::-1])
transfer_and_assert_path(
path=reverse_path,
token_address=token_address,
amount=app2_capacity - fee2 - fee_margin2,
identifier=PaymentID(2),
timeout=network_wait * number_of_nodes,
)
with block_timeout_for_transfer_by_secrethash(app1.raiden, secrethash):
wait_assert(
func=assert_succeeding_transfer_invariants,
token_network_address=token_network_address,
app0=app0,
balance0=2 * deposit - fee2 + fee_difference,
pending_locks0=[],
app1=app1,
balance1=fee2 - fee_difference,
pending_locks1=[],
)
with block_timeout_for_transfer_by_secrethash(app2.raiden, secrethash):
wait_assert(
func=assert_succeeding_transfer_invariants,
token_network_address=token_network_address,
app0=app1,
balance0=deposit * 2 - fee_difference,
pending_locks0=[],
app1=app2,
balance1=fee_difference,
pending_locks1=[],
)
],
incoming_fee_schedules=[no_fees, no_fees, no_fees],
expected_transferred_amounts=[
amount + fee, amount + fee, amount + fee
],
),
]
case = cases[case_no]
for i, fee_schedule in enumerate(case.get("fee_schedules", [])):
if fee_schedule:
set_fee_schedule(apps[i], apps[i + 1], fee_schedule)
for i, fee_schedule in enumerate(case.get("incoming_fee_schedules", [])):
if fee_schedule:
set_fee_schedule(apps[i + 1], apps[i], fee_schedule)
route_patch = patch("raiden.routing.get_best_routes_internal",
get_best_routes_with_fees)
disable_max_mediation_fee_patch = patch(
"raiden.transfer.mediated_transfer.initiator.MAX_MEDIATION_FEE_PERC",
new=10000)
with route_patch, disable_max_mediation_fee_patch:
transfer_and_assert_path(
path=raiden_network,
token_address=token_address,
amount=amount,
identifier=PaymentID(2),
)
assert_balances(case["expected_transferred_amounts"])
def test_recovery_happy_case(
raiden_network, number_of_nodes, deposit, token_addresses, network_wait
):
app0, app1, app2 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
chain_state, token_network_registry_address, token_address
)
assert token_network_address
# make a few transfers from app0 to app2
amount = PaymentAmount(1)
spent_amount = deposit - 2
for identifier in range(spent_amount):
transfer_and_assert_path(
path=raiden_network,
token_address=token_address,
amount=amount,
identifier=PaymentID(identifier),
timeout=network_wait * number_of_nodes,
)
app0.stop()
waiting.wait_for_network_state(
app1.raiden, app0.raiden.address, NetworkState.UNREACHABLE, network_wait
)
app0.start()
assert_synced_channel_state(
token_network_address, app0, deposit - spent_amount, [], app1, deposit + spent_amount, []
)
assert_synced_channel_state(
token_network_address, app1, deposit - spent_amount, [], app2, deposit + spent_amount, []
)
# wait for the nodes' healthcheck to update the network statuses
waiting.wait_for_healthy(app0.raiden, app1.raiden.address, network_wait)
waiting.wait_for_healthy(app1.raiden, app0.raiden.address, network_wait)
transfer_and_assert_path(
path=raiden_network[::-1],
token_address=token_address,
amount=amount,
identifier=create_default_identifier(),
timeout=network_wait * number_of_nodes,
)
transfer_and_assert_path(
path=raiden_network,
token_address=token_address,
amount=amount,
identifier=create_default_identifier(),
timeout=network_wait * number_of_nodes,
)
assert_succeeding_transfer_invariants(
token_network_address, app0, deposit - spent_amount, [], app1, deposit + spent_amount, []
)
assert_succeeding_transfer_invariants(
token_network_address, app1, deposit - spent_amount, [], app2, deposit + spent_amount, []
)
def test_recovery_happy_case(
raiden_network,
number_of_nodes,
deposit,
token_addresses,
network_wait,
skip_if_not_udp, # pylint: disable=unused-argument
):
app0, app1, app2 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state, payment_network_id, token_address)
# make a few transfers from app0 to app2
amount = 1
spent_amount = deposit - 2
identifier = 0
for identifier in range(spent_amount):
transfer_and_assert_path(
path=raiden_network,
token_address=token_address,
amount=amount,
identifier=identifier,
timeout=network_wait * number_of_nodes,
)
app0.raiden.stop()
host_port = (
app0.raiden.config["transport"]["udp"]["host"],
app0.raiden.config["transport"]["udp"]["port"],
)
socket = server._udp_socket(host_port)
new_transport = UDPTransport(
app0.raiden.address,
app0.discovery,
socket,
app0.raiden.transport.throttle_policy,
app0.raiden.config["transport"]["udp"],
)
raiden_event_handler = RaidenEventHandler()
message_handler = WaitForMessage()
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
default_service_registry=app0.raiden.default_service_registry,
transport=new_transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=app0.raiden.discovery,
)
app0.stop()
del app0 # from here on the app0_restart should be used
app0_restart.start()
assert_synced_channel_state(
token_network_identifier,
app0_restart,
deposit - spent_amount,
[],
app1,
deposit + spent_amount,
[],
)
assert_synced_channel_state(
token_network_identifier,
app1,
deposit - spent_amount,
[],
app2,
deposit + spent_amount,
[],
)
# wait for the nodes' healthcheck to update the network statuses
waiting.wait_for_healthy(app0_restart.raiden, app1.raiden.address,
network_wait)
waiting.wait_for_healthy(app1.raiden, app0_restart.raiden.address,
network_wait)
transfer(
initiator_app=app2,
target_app=app0_restart,
token_address=token_address,
amount=amount,
identifier=create_default_identifier(),
timeout=network_wait * number_of_nodes * 2,
)
transfer(
initiator_app=app0_restart,
target_app=app2,
token_address=token_address,
amount=amount,
identifier=create_default_identifier(),
timeout=network_wait * number_of_nodes * 2,
)
assert_synced_channel_state(
token_network_identifier,
app0_restart,
deposit - spent_amount,
[],
app1,
deposit + spent_amount,
[],
)
assert_synced_channel_state(
token_network_identifier,
app1,
deposit - spent_amount,
[],
app2,
deposit + spent_amount,
[],
)
def test_mediated_transfer_with_entire_deposit(raiden_network, number_of_nodes,
token_addresses, deposit,
network_wait):
app0, app1, app2 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
chain_state, token_network_registry_address, token_address)
fee1 = int(deposit * INTERNAL_ROUTING_DEFAULT_FEE_PERC)
secrethash = transfer_and_assert_path(
path=raiden_network,
token_address=token_address,
amount=deposit - fee1,
identifier=1,
timeout=network_wait * number_of_nodes,
)
with block_timeout_for_transfer_by_secrethash(app1.raiden, secrethash):
wait_assert(
assert_succeeding_transfer_invariants,
token_network_address,
app0,
0,
[],
app1,
deposit * 2,
[],
)
with block_timeout_for_transfer_by_secrethash(app2.raiden, secrethash):
wait_assert(
assert_succeeding_transfer_invariants,
token_network_address,
app1,
fee1,
[],
app2,
deposit * 2 - fee1,
[],
)
app2_capacity = 2 * deposit - fee1
fee2 = int(round(app2_capacity * INTERNAL_ROUTING_DEFAULT_FEE_PERC))
reverse_path = list(raiden_network[::-1])
transfer_and_assert_path(
path=reverse_path,
token_address=token_address,
amount=app2_capacity - fee2,
identifier=2,
timeout=network_wait * number_of_nodes,
)
with block_timeout_for_transfer_by_secrethash(app1.raiden, secrethash):
wait_assert(
assert_succeeding_transfer_invariants,
token_network_address,
app0,
2 * deposit - fee2,
[],
app1,
fee2,
[],
)
with block_timeout_for_transfer_by_secrethash(app2.raiden, secrethash):
wait_assert(
assert_succeeding_transfer_invariants,
token_network_address,
app1,
deposit * 2,
[],
app2,
0,
[],
)