def test_refund_messages(raiden_chain, token_addresses, deposit):
# The network has the following topology:
#
# App0 <---> App1 <---> App2
app0, app1, app2 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
token_address = token_addresses[0]
payment_network_identifier = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
payment_network_identifier,
token_address,
)
# Exhaust the channel App1 <-> App2 (to force the refund transfer)
exhaust_amount = deposit
mediated_transfer(
initiator_app=app1,
target_app=app2,
token_network_identifier=token_network_identifier,
amount=exhaust_amount,
identifier=1,
)
refund_amount = deposit // 2
identifier = 1
payment_status = app0.raiden.mediated_transfer_async(
token_network_identifier,
refund_amount,
app2.raiden.address,
identifier,
)
msg = 'Must fail, there are no routes available'
assert payment_status.payment_done.wait() is False, msg
# The transfer from app0 to app2 failed, so the balances did change.
# Since the refund is not unlocked both channels have the corresponding
# amount locked (issue #1091)
send_lockedtransfer = raiden_events_search_for_item(
app0.raiden,
SendLockedTransfer,
{'transfer': {'lock': {'amount': refund_amount}}},
)
assert send_lockedtransfer
send_refundtransfer = raiden_events_search_for_item(app1.raiden, SendRefundTransfer, {})
assert send_refundtransfer
assert_synced_channel_state(
token_network_identifier,
app0, deposit, [send_lockedtransfer.transfer.lock],
app1, deposit, [send_refundtransfer.transfer.lock],
)
# This channel was exhausted to force the refund transfer
assert_synced_channel_state(
token_network_identifier,
app1, 0, [],
app2, deposit * 2, [],
)
def test_regression_revealsecret_after_secret(
raiden_network: List[App],
token_addresses: List[TokenAddress]) -> None:
""" A RevealSecret message received after a Unlock message must be cleanly
handled.
"""
app0, app1, app2 = raiden_network
token = token_addresses[0]
identifier = PaymentID(1)
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_app(app0), token_network_registry_address, token)
assert token_network_address, "The fixtures must register the token"
payment_status = app0.raiden.mediated_transfer_async(
token_network_address,
amount=PaymentAmount(1),
target=TargetAddress(app2.raiden.address),
identifier=identifier,
)
with watch_for_unlock_failures(*raiden_network):
assert payment_status.payment_done.wait()
assert app1.raiden.wal, "The fixtures must start the app."
event = raiden_events_search_for_item(app1.raiden, SendSecretReveal, {})
assert event
reveal_secret = RevealSecret(
message_identifier=make_message_identifier(),
secret=event.secret,
signature=EMPTY_SIGNATURE,
)
app2.raiden.sign(reveal_secret)
app1.raiden.on_messages([reveal_secret])
def test_regression_payment_complete_after_refund_to_the_initiator(
raiden_network: List[RaidenService], token_addresses, settle_timeout,
deposit):
"""Regression test for issue #3915"""
app0, app1, app2, app3, app4 = raiden_network
token = token_addresses[0]
registry_address = app0.default_registry.address
# Topology:
#
# 0 -> 1 -> 2
# | ^
# v |
# 3 ------> 4
app_channels = [(app0, app1), (app1, app2), (app0, app3), (app3, app4),
(app4, app2)]
open_and_wait_for_channels(app_channels, registry_address, token, deposit,
settle_timeout)
# Use all deposit from app1->app2 to force a refund
transfer(
initiator_app=app1,
target_app=app2,
token_address=token,
amount=deposit,
identifier=PaymentID(1),
routes=[[app1.address, app2.address]],
)
# Send a transfer that will result in a refund app1->app0
transfer(
initiator_app=app0,
target_app=app2,
token_address=token,
amount=PaymentAmount(50),
identifier=PaymentID(2),
timeout=20,
expect_unlock_failures=True,
routes=[
[app0.address, app1.address, app2.address],
[app0.address, app3.address, app4.address, app2.address],
],
)
assert raiden_state_changes_search_for_item(
raiden=app0, item_type=ReceiveTransferCancelRoute, attributes={})
assert raiden_events_search_for_item(raiden=app0,
item_type=EventRouteFailed,
attributes={})
def run_test_payment_statuses_are_restored(
raiden_network,
token_addresses,
network_wait,
):
app0, app1 = 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,
)
app0.event_handler = HoldRaidenEvent()
app0.event_handler.hold(SendSecretReveal, {})
# make a few transfers from app0 to app1
amount = 1
spent_amount = 7
identifier = 1
for identifier in range(spent_amount):
identifier = identifier + 1
payment_status = app0.raiden.mediated_transfer_async(
token_network_identifier=token_network_identifier,
amount=amount,
target=app1.raiden.address,
identifier=identifier,
)
assert payment_status.payment_identifier == identifier
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
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=MatrixTransport(app0.raiden.config['transport']['matrix'], ),
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
# stop app1 to make sure that we don't complete the transfers before our checks
app1.stop()
app0_restart.start()
# Check that the payment statuses were restored properly after restart
for identifier in range(spent_amount):
identifier = identifier + 1
mapping = app0_restart.raiden.targets_to_identifiers_to_statuses
status = mapping[app1.raiden.address][identifier]
assert status.amount == 1
assert status.payment_identifier == identifier
assert status.token_network_identifier == token_network_identifier
app1.start() # now that our checks are done start app1 again
waiting.wait_for_healthy(
app0_restart.raiden,
app1.raiden.address,
network_wait,
)
waiting.wait_for_payment_balance(
raiden=app1.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app0_restart.raiden.address,
target_address=app1.raiden.address,
target_balance=spent_amount,
retry_timeout=network_wait,
)
# Check that payments are completed after both nodes come online after restart
for identifier in range(spent_amount):
assert raiden_events_search_for_item(
app0_restart.raiden,
EventPaymentSentSuccess,
{
'identifier': identifier + 1,
'amount': 1
},
)
def test_refund_transfer_after_2nd_hop(
raiden_chain,
number_of_nodes,
token_addresses,
deposit,
network_wait,
):
"""Test the refund transfer sent due to failure after 2nd hop"""
# Topology:
#
# 0 -> 1 -> 2 -> 3
#
app0, app1, app2, app3 = raiden_chain
token_address = token_addresses[0]
payment_network_identifier = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
payment_network_identifier,
token_address,
)
# make a transfer to test the path app0 -> app1 -> app2 -> app3
identifier_path = 1
amount_path = 1
mediated_transfer(
initiator_app=app0,
target_app=app3,
token_network_identifier=token_network_identifier,
amount=amount_path,
identifier=identifier_path,
timeout=network_wait * number_of_nodes,
)
# drain the channel app2 -> app3
identifier_drain = 2
amount_drain = deposit * 8 // 10
mediated_transfer(
initiator_app=app2,
target_app=app3,
token_network_identifier=token_network_identifier,
amount=amount_drain,
identifier=identifier_drain,
timeout=network_wait,
)
# wait for the nodes to sync
gevent.sleep(0.2)
assert_synced_channel_state(
token_network_identifier,
app0,
deposit - amount_path,
[],
app1,
deposit + amount_path,
[],
)
assert_synced_channel_state(
token_network_identifier,
app1,
deposit - amount_path,
[],
app2,
deposit + amount_path,
[],
)
assert_synced_channel_state(
token_network_identifier,
app2,
deposit - amount_path - amount_drain,
[],
app3,
deposit + amount_path + amount_drain,
[],
)
# app0 -> app1 -> app2 > app3 is the only available path, but the channel
# app2 -> app3 doesn't have capacity, so a refund will be sent on
# app2 -> app1 -> app0
identifier_refund = 3
amount_refund = 50
async_result = app0.raiden.mediated_transfer_async(
token_network_identifier,
amount_refund,
app3.raiden.address,
identifier_refund,
)
assert async_result.wait(
) is False, 'there is no path with capacity, the transfer must fail'
gevent.sleep(0.2)
# Lock structures with the correct amount
send_locked1 = raiden_events_search_for_item(
app0.raiden,
SendLockedTransfer,
{'transfer': {
'lock': {
'amount': amount_refund
}
}},
)
assert send_locked1
send_refund1 = raiden_events_search_for_item(app1.raiden,
SendRefundTransfer, {})
assert send_refund1
lock1 = send_locked1.transfer.lock
refund_lock1 = send_refund1.transfer.lock
assert lock1.amount == refund_lock1.amount
assert lock1.secrethash == refund_lock1.secrethash
send_locked2 = raiden_events_search_for_item(
app1.raiden,
SendLockedTransfer,
{'transfer': {
'lock': {
'amount': amount_refund
}
}},
)
assert send_locked2
send_refund2 = raiden_events_search_for_item(app2.raiden,
SendRefundTransfer, {})
assert send_refund2
lock2 = send_locked2.transfer.lock
refund_lock2 = send_refund2.transfer.lock
assert lock2.amount == refund_lock2.amount
assert lock2.secrethash
assert lock2.expiration
# channels have the amount locked because of the refund message
assert_synced_channel_state(
token_network_identifier,
app0,
deposit - amount_path,
[lockstate_from_lock(lock1)],
app1,
deposit + amount_path,
[lockstate_from_lock(refund_lock1)],
)
assert_synced_channel_state(
token_network_identifier,
app1,
deposit - amount_path,
[lockstate_from_lock(lock2)],
app2,
deposit + amount_path,
[lockstate_from_lock(refund_lock2)],
)
assert_synced_channel_state(
token_network_identifier,
app2,
deposit - amount_path - amount_drain,
[],
app3,
deposit + amount_path + amount_drain,
[],
)
def test_different_view_of_last_bp_during_unlock(
raiden_chain,
number_of_nodes,
token_addresses,
deposit,
network_wait,
retry_timeout,
# UDP does not seem to retry messages until processed
# https://github.com/raiden-network/raiden/issues/3185
skip_if_not_matrix,
):
"""Test for https://github.com/raiden-network/raiden/issues/3196#issuecomment-449163888"""
# Topology:
#
# 0 -> 1 -> 2
#
app0, app1, app2 = raiden_chain
token_address = token_addresses[0]
payment_network_identifier = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
payment_network_identifier,
token_address,
)
token_proxy = app0.raiden.chain.token(token_address)
initial_balance0 = token_proxy.balance_of(app0.raiden.address)
initial_balance1 = token_proxy.balance_of(app1.raiden.address)
# make a transfer to test the path app0 -> app1 -> app2
identifier_path = 1
amount_path = 1
mediated_transfer(
app0,
app2,
token_network_identifier,
amount_path,
identifier_path,
timeout=network_wait * number_of_nodes,
)
# drain the channel app1 -> app2
identifier_drain = 2
amount_drain = deposit * 8 // 10
mediated_transfer(
initiator_app=app1,
target_app=app2,
token_network_identifier=token_network_identifier,
amount=amount_drain,
identifier=identifier_drain,
timeout=network_wait,
)
# wait for the nodes to sync
gevent.sleep(0.2)
assert_synced_channel_state(
token_network_identifier,
app0,
deposit - amount_path,
[],
app1,
deposit + amount_path,
[],
)
assert_synced_channel_state(
token_network_identifier,
app1,
deposit - amount_path - amount_drain,
[],
app2,
deposit + amount_path + amount_drain,
[],
)
# app0 -> app1 -> app2 is the only available path, but the channel app1 ->
# app2 doesn't have capacity, so a refund will be sent on app1 -> app0
identifier_refund = 3
amount_refund = 50
async_result = app0.raiden.mediated_transfer_async(
token_network_identifier,
amount_refund,
app2.raiden.address,
identifier_refund,
)
assert async_result.wait(
) is False, 'there is no path with capacity, the transfer must fail'
gevent.sleep(0.2)
# A lock structure with the correct amount
send_locked = raiden_events_search_for_item(
app0.raiden,
SendLockedTransfer,
{'transfer': {
'lock': {
'amount': amount_refund
}
}},
)
assert send_locked
secrethash = send_locked.transfer.lock.secrethash
send_refund = raiden_events_search_for_item(app1.raiden,
SendRefundTransfer, {})
assert send_refund
lock = send_locked.transfer.lock
refund_lock = send_refund.transfer.lock
assert lock.amount == refund_lock.amount
assert lock.secrethash
assert lock.expiration
assert lock.secrethash == refund_lock.secrethash
# Both channels have the amount locked because of the refund message
assert_synced_channel_state(
token_network_identifier,
app0,
deposit - amount_path,
[lockstate_from_lock(lock)],
app1,
deposit + amount_path,
[lockstate_from_lock(refund_lock)],
)
assert_synced_channel_state(
token_network_identifier,
app1,
deposit - amount_path - amount_drain,
[],
app2,
deposit + amount_path + amount_drain,
[],
)
# Additional checks for LockExpired causing nonce mismatch after refund transfer:
# https://github.com/raiden-network/raiden/issues/3146#issuecomment-447378046
# At this point make sure that the initiator has not deleted the payment task
assert secrethash in state_from_raiden(
app0.raiden).payment_mapping.secrethashes_to_task
with dont_handle_node_change_network_state():
# now app1 goes offline
app1.raiden.stop()
app1.raiden.get()
assert not app1.raiden
# Wait for lock expiration so that app0 sends a LockExpired
wait_for_block(
raiden=app0.raiden,
block_number=channel.get_sender_expiration_threshold(lock) + 1,
retry_timeout=retry_timeout,
)
# make sure that app0 sent a lock expired message for the secrethash
wait_for_raiden_event(
app0.raiden,
SendLockExpired,
{'secrethash': secrethash},
retry_timeout,
)
# now app0 closes the channel
RaidenAPI(app0.raiden).channel_close(
registry_address=payment_network_identifier,
token_address=token_address,
partner_address=app1.raiden.address,
)
count = 0
original_update = app1.raiden.raiden_event_handler.handle_contract_send_channelupdate
def patched_update(raiden, event):
nonlocal count
count += 1
original_update(raiden, event)
app1.raiden.raiden_event_handler.handle_contract_send_channelupdate = patched_update
# and now app1 comes back online
app1.raiden.start()
# test for https://github.com/raiden-network/raiden/issues/3216
assert count == 1, 'Update transfer should have only been called once during restart'
channel_identifier = get_channelstate(app0, app1,
token_network_identifier).identifier
# and we wait for settlement
wait_for_settle(
raiden=app0.raiden,
payment_network_id=payment_network_identifier,
token_address=token_address,
channel_ids=[channel_identifier],
retry_timeout=app0.raiden.alarm.sleep_time,
)
with gevent.Timeout(10):
unlock_app0 = wait_for_state_change(
app0.raiden,
ContractReceiveChannelBatchUnlock,
{'participant': app0.raiden.address},
retry_timeout,
)
assert unlock_app0.returned_tokens == 50
with gevent.Timeout(10):
unlock_app1 = wait_for_state_change(
app1.raiden,
ContractReceiveChannelBatchUnlock,
{'participant': app1.raiden.address},
retry_timeout,
)
assert unlock_app1.returned_tokens == 50
final_balance0 = token_proxy.balance_of(app0.raiden.address)
final_balance1 = token_proxy.balance_of(app1.raiden.address)
assert final_balance0 - deposit - initial_balance0 == -1
assert final_balance1 - deposit - initial_balance1 == 1
def test_refund_transfer(
raiden_chain,
number_of_nodes,
token_addresses,
deposit,
network_wait,
retry_timeout,
# UDP does not seem to retry messages until processed
# https://github.com/raiden-network/raiden/issues/3185
skip_if_not_matrix,
):
"""A failed transfer must send a refund back.
TODO:
- Unlock the token on refund #1091
- Clear the merkletree and update the locked amount #193
- Remove the refund message type #490"""
# Topology:
#
# 0 -> 1 -> 2
#
app0, app1, app2 = raiden_chain
token_address = token_addresses[0]
payment_network_identifier = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
payment_network_identifier,
token_address,
)
# make a transfer to test the path app0 -> app1 -> app2
identifier_path = 1
amount_path = 1
mediated_transfer(
app0,
app2,
token_network_identifier,
amount_path,
identifier_path,
timeout=network_wait * number_of_nodes,
)
# drain the channel app1 -> app2
identifier_drain = 2
amount_drain = deposit * 8 // 10
mediated_transfer(
initiator_app=app1,
target_app=app2,
token_network_identifier=token_network_identifier,
amount=amount_drain,
identifier=identifier_drain,
timeout=network_wait,
)
# wait for the nodes to sync
gevent.sleep(0.2)
assert_synced_channel_state(
token_network_identifier,
app0,
deposit - amount_path,
[],
app1,
deposit + amount_path,
[],
)
assert_synced_channel_state(
token_network_identifier,
app1,
deposit - amount_path - amount_drain,
[],
app2,
deposit + amount_path + amount_drain,
[],
)
# app0 -> app1 -> app2 is the only available path, but the channel app1 ->
# app2 doesn't have capacity, so a refund will be sent on app1 -> app0
identifier_refund = 3
amount_refund = 50
async_result = app0.raiden.mediated_transfer_async(
token_network_identifier,
amount_refund,
app2.raiden.address,
identifier_refund,
)
assert async_result.wait(
) is False, 'there is no path with capacity, the transfer must fail'
gevent.sleep(0.2)
# A lock structure with the correct amount
send_locked = raiden_events_search_for_item(
app0.raiden,
SendLockedTransfer,
{'transfer': {
'lock': {
'amount': amount_refund
}
}},
)
assert send_locked
secrethash = send_locked.transfer.lock.secrethash
send_refund = raiden_events_search_for_item(app1.raiden,
SendRefundTransfer, {})
assert send_refund
lock = send_locked.transfer.lock
refund_lock = send_refund.transfer.lock
assert lock.amount == refund_lock.amount
assert lock.secrethash
assert lock.expiration
assert lock.secrethash == refund_lock.secrethash
# Both channels have the amount locked because of the refund message
assert_synced_channel_state(
token_network_identifier,
app0,
deposit - amount_path,
[lockstate_from_lock(lock)],
app1,
deposit + amount_path,
[lockstate_from_lock(refund_lock)],
)
assert_synced_channel_state(
token_network_identifier,
app1,
deposit - amount_path - amount_drain,
[],
app2,
deposit + amount_path + amount_drain,
[],
)
# Additional checks for LockExpired causing nonce mismatch after refund transfer:
# https://github.com/raiden-network/raiden/issues/3146#issuecomment-447378046
# At this point make sure that the initiator has not deleted the payment task
assert secrethash in state_from_raiden(
app0.raiden).payment_mapping.secrethashes_to_task
# Wait for lock lock expiration but make sure app0 never processes LockExpired
with dont_handle_lock_expired_mock(app0):
wait_for_block(
raiden=app0.raiden,
block_number=channel.get_sender_expiration_threshold(lock) + 1,
retry_timeout=retry_timeout,
)
# make sure that app0 still has the payment task for the secrethash
# https://github.com/raiden-network/raiden/issues/3183
assert secrethash in state_from_raiden(
app0.raiden).payment_mapping.secrethashes_to_task
# make sure that app1 sent a lock expired message for the secrethash
send_lock_expired = raiden_events_search_for_item(
app1.raiden,
SendLockExpired,
{'secrethash': secrethash},
)
assert send_lock_expired
# make sure that app0 never got it
state_changes = app0.raiden.wal.storage.get_statechanges_by_identifier(
0, 'latest')
assert not search_for_item(
state_changes,
ReceiveLockExpired,
{'secrethash': secrethash},
)
# Out of the handicapped app0 transport.
# Now wait till app0 receives and processes LockExpired
receive_lock_expired = wait_for_state_change(
app0.raiden,
ReceiveLockExpired,
{'secrethash': secrethash},
retry_timeout,
)
# And also till app1 received the processed
wait_for_state_change(
app1.raiden,
ReceiveProcessed,
{'message_identifier': receive_lock_expired.message_identifier},
retry_timeout,
)
# make sure app1 queue has cleared the SendLockExpired
chain_state1 = views.state_from_app(app1)
queues1 = views.get_all_messagequeues(chain_state=chain_state1)
result = [(queue_id, queue) for queue_id, queue in queues1.items()
if queue_id.recipient == app0.raiden.address and queue]
assert not result
# and now wait for 1 more block so that the payment task can be deleted
wait_for_block(
raiden=app0.raiden,
block_number=app0.raiden.get_block_number() + 1,
retry_timeout=retry_timeout,
)
# and since the lock expired message has been sent and processed then the
# payment task should have been deleted from both nodes
# https://github.com/raiden-network/raiden/issues/3183
assert secrethash not in state_from_raiden(
app0.raiden).payment_mapping.secrethashes_to_task
assert secrethash not in state_from_raiden(
app1.raiden).payment_mapping.secrethashes_to_task
def test_payment_statuses_are_restored( # pylint: disable=unused-argument
raiden_network, token_addresses, network_wait):
""" Test that when the Raiden is restarted, the dictionary of
`targets_to_identifiers_to_statuses` is populated before the transport
is started.
This should happen because if a client gets restarted during a transfer
cycle, once restarted, the client will proceed with the cycle
until the transfer is successfully sent. However, the dictionary
`targets_to_identifiers_to_statuses` will not contain the payment
identifiers that were originally registered when the previous client
started the transfers.
Related issue: https://github.com/raiden-network/raiden/issues/3432
"""
app0, app1 = 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)
# make a few transfers from app0 to app1
amount = 1
spent_amount = TokenAmount(7)
for identifier in range(spent_amount):
# Make sure the transfer is not completed
secret = make_secret(identifier)
app0.raiden.raiden_event_handler.hold(SendSecretReveal,
{"secret": secret})
identifier = identifier + 1
payment_status = app0.raiden.mediated_transfer_async(
token_network_address=token_network_address,
amount=amount,
target=app1.raiden.address,
identifier=identifier,
secret=secret,
)
assert payment_status.payment_identifier == identifier
app0_restart = App(
config=app0.config,
rpc_client=app0.raiden.rpc_client,
proxy_manager=app0.raiden.proxy_manager,
query_start_block=BlockNumber(0),
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
default_service_registry=app0.raiden.default_service_registry,
default_one_to_n_address=app0.raiden.default_one_to_n_address,
default_msc_address=app0.raiden.default_msc_address,
transport=MatrixTransport(app0.raiden.config["transport"]["matrix"]),
raiden_event_handler=RaidenEventHandler(),
message_handler=MessageHandler(),
routing_mode=RoutingMode.PRIVATE,
)
app0.stop()
del app0 # from here on the app0_restart should be used
# stop app1 to make sure that we don't complete the transfers before our checks
app1.stop()
app0_restart.start()
# Check that the payment statuses were restored properly after restart
for identifier in range(spent_amount):
identifier = PaymentID(identifier + 1)
mapping = app0_restart.raiden.targets_to_identifiers_to_statuses
status = mapping[app1.raiden.address][identifier]
assert status.amount == 1
assert status.payment_identifier == identifier
assert status.token_network_address == token_network_address
app1.start() # now that our checks are done start app1 again
with watch_for_unlock_failures(*raiden_network):
waiting.wait_for_healthy(app0_restart.raiden, app1.raiden.address,
network_wait)
waiting.wait_for_payment_balance(
raiden=app1.raiden,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
partner_address=app0_restart.raiden.address,
target_address=app1.raiden.address,
target_balance=spent_amount,
retry_timeout=network_wait,
)
# Check that payments are completed after both nodes come online after restart
for identifier in range(spent_amount):
assert raiden_events_search_for_item(
app0_restart.raiden,
EventPaymentSentSuccess,
{
"identifier": identifier + 1,
"amount": 1
},
)
def test_refund_transfer_after_2nd_hop(raiden_chain, number_of_nodes,
token_addresses, deposit, network_wait):
"""Test the refund transfer sent due to failure after 2nd hop"""
# Topology:
#
# 0 -> 1 -> 2 -> 3
#
app0, app1, app2, app3 = raiden_chain
token_address = token_addresses[0]
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_app(app0), token_network_registry_address,
token_address)
# make a transfer to test the path app0 -> app1 -> app2 -> app3
identifier_path = 1
amount_path = 1
transfer(
initiator_app=app0,
target_app=app3,
token_address=token_address,
amount=amount_path,
identifier=identifier_path,
timeout=network_wait * number_of_nodes,
)
# drain the channel app2 -> app3
identifier_drain = 2
amount_drain = deposit * 8 // 10
transfer(
initiator_app=app2,
target_app=app3,
token_address=token_address,
amount=amount_drain,
identifier=identifier_drain,
timeout=network_wait,
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit - amount_path,
[],
app1,
deposit + amount_path,
[],
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app1,
deposit - amount_path,
[],
app2,
deposit + amount_path,
[],
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app2,
deposit - amount_path - amount_drain,
[],
app3,
deposit + amount_path + amount_drain,
[],
)
# app0 -> app1 -> app2 > app3 is the only available path, but the channel
# app2 -> app3 doesn't have capacity, so a refund will be sent on
# app2 -> app1 -> app0
identifier_refund = 3
amount_refund = 50
amount_refund_with_fees = amount_refund + calculate_fee_for_amount(
amount_refund)
payment_status = app0.raiden.mediated_transfer_async(
token_network_address, amount_refund, app3.raiden.address,
identifier_refund)
msg = "there is no path with capacity, the transfer must fail"
assert isinstance(payment_status.payment_done.wait(),
EventPaymentSentFailed), msg
# Lock structures with the correct amount
send_locked1 = raiden_events_search_for_item(
app0.raiden,
SendLockedTransfer,
{"transfer": {
"lock": {
"amount": amount_refund_with_fees
}
}},
)
assert send_locked1
send_refund1 = raiden_events_search_for_item(app1.raiden,
SendRefundTransfer, {})
assert send_refund1
lock1 = send_locked1.transfer.lock
refund_lock1 = send_refund1.transfer.lock
assert lock1.amount == refund_lock1.amount
assert lock1.secrethash == refund_lock1.secrethash
send_locked2 = raiden_events_search_for_item(
app1.raiden,
SendLockedTransfer,
{"transfer": {
"lock": {
"amount": amount_refund_with_fees
}
}},
)
assert send_locked2
send_refund2 = raiden_events_search_for_item(app2.raiden,
SendRefundTransfer, {})
assert send_refund2
lock2 = send_locked2.transfer.lock
refund_lock2 = send_refund2.transfer.lock
assert lock2.amount == refund_lock2.amount
assert lock2.secrethash
assert lock2.expiration
# channels have the amount locked because of the refund message
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit - amount_path,
[lock1],
app1,
deposit + amount_path,
[refund_lock1],
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app1,
deposit - amount_path,
[lock2],
app2,
deposit + amount_path,
[refund_lock2],
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app2,
deposit - amount_path - amount_drain,
[],
app3,
deposit + amount_path + amount_drain,
[],
)
def test_refund_messages(raiden_chain, token_addresses, deposit, network_wait):
# The network has the following topology:
#
# App0 <---> App1 <---> App2
app0, app1, app2 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
token_address = token_addresses[0]
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_app(app0), token_network_registry_address,
token_address)
# Exhaust the channel App1 <-> App2 (to force the refund transfer)
# Here we make a single-hop transfer, no fees are charged so we should
# send the whole deposit amount to drain the channel.
transfer(
initiator_app=app1,
target_app=app2,
token_address=token_address,
amount=deposit,
identifier=1,
)
refund_amount = deposit // 2
refund_fees = calculate_fee_for_amount(refund_amount)
refund_amount_with_fees = refund_amount + refund_fees
identifier = 1
payment_status = app0.raiden.mediated_transfer_async(
token_network_address, refund_amount, app2.raiden.address, identifier)
msg = "Must fail, there are no routes available"
assert isinstance(payment_status.payment_done.wait(),
EventPaymentSentFailed), msg
# The transfer from app0 to app2 failed, so the balances did change.
# Since the refund is not unlocked both channels have the corresponding
# amount locked (issue #1091)
send_lockedtransfer = raiden_events_search_for_item(
app0.raiden,
SendLockedTransfer,
{"transfer": {
"lock": {
"amount": refund_amount_with_fees
}
}},
)
assert send_lockedtransfer
send_refundtransfer = raiden_events_search_for_item(
app1.raiden, SendRefundTransfer, {})
assert send_refundtransfer
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit,
[send_lockedtransfer.transfer.lock],
app1,
deposit,
[send_refundtransfer.transfer.lock],
)
# This channel was exhausted to force the refund transfer except for the fees
with gevent.Timeout(network_wait):
wait_assert(assert_synced_channel_state, token_network_address, app1,
0, [], app2, deposit * 2, [])
def test_different_view_of_last_bp_during_unlock(
raiden_chain,
number_of_nodes,
token_addresses,
deposit,
network_wait,
retry_timeout,
blockchain_type,
):
"""Test for https://github.com/raiden-network/raiden/issues/3196#issuecomment-449163888"""
# Topology:
#
# 0 -> 1 -> 2
#
app0, app1, app2 = raiden_chain
token_address = token_addresses[0]
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_app(app0), token_network_registry_address,
token_address)
token_proxy = app0.raiden.proxy_manager.token(token_address)
initial_balance0 = token_proxy.balance_of(app0.raiden.address)
initial_balance1 = token_proxy.balance_of(app1.raiden.address)
# make a transfer to test the path app0 -> app1 -> app2
identifier_path = 1
amount_path = 1
transfer(
initiator_app=app0,
target_app=app2,
token_address=token_address,
amount=amount_path,
identifier=identifier_path,
timeout=network_wait * number_of_nodes,
)
# drain the channel app1 -> app2
identifier_drain = 2
amount_drain = deposit * 8 // 10
transfer(
initiator_app=app1,
target_app=app2,
token_address=token_address,
amount=amount_drain,
identifier=identifier_drain,
timeout=network_wait,
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit - amount_path,
[],
app1,
deposit + amount_path,
[],
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app1,
deposit - amount_path - amount_drain,
[],
app2,
deposit + amount_path + amount_drain,
[],
)
# app0 -> app1 -> app2 is the only available path, but the channel app1 ->
# app2 doesn't have capacity, so a refund will be sent on app1 -> app0
identifier_refund = 3
amount_refund = 50
amount_refund_with_fees = amount_refund + calculate_fee_for_amount(50)
payment_status = app0.raiden.mediated_transfer_async(
token_network_address, amount_refund, app2.raiden.address,
identifier_refund)
msg = "there is no path with capacity, the transfer must fail"
assert isinstance(payment_status.payment_done.wait(),
EventPaymentSentFailed), msg
# A lock structure with the correct amount
send_locked = raiden_events_search_for_item(
app0.raiden,
SendLockedTransfer,
{"transfer": {
"lock": {
"amount": amount_refund_with_fees
}
}},
)
assert send_locked
secrethash = send_locked.transfer.lock.secrethash
send_refund = raiden_events_search_for_item(app1.raiden,
SendRefundTransfer, {})
assert send_refund
lock = send_locked.transfer.lock
refund_lock = send_refund.transfer.lock
assert lock.amount == refund_lock.amount
assert lock.secrethash
assert lock.expiration
assert lock.secrethash == refund_lock.secrethash
# Both channels have the amount locked because of the refund message
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit - amount_path,
[lock],
app1,
deposit + amount_path,
[refund_lock],
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app1,
deposit - amount_path - amount_drain,
[],
app2,
deposit + amount_path + amount_drain,
[],
)
# Additional checks for LockExpired causing nonce mismatch after refund transfer:
# https://github.com/raiden-network/raiden/issues/3146#issuecomment-447378046
# At this point make sure that the initiator has not deleted the payment task
assert secrethash in state_from_raiden(
app0.raiden).payment_mapping.secrethashes_to_task
with dont_handle_node_change_network_state():
# now app1 goes offline
app1.raiden.stop()
app1.raiden.get()
assert not app1.raiden
# Wait for lock expiration so that app0 sends a LockExpired
wait_for_block(
raiden=app0.raiden,
block_number=channel.get_sender_expiration_threshold(
lock.expiration) + 1,
retry_timeout=retry_timeout,
)
# make sure that app0 sent a lock expired message for the secrethash
wait_for_raiden_event(app0.raiden, SendLockExpired,
{"secrethash": secrethash}, retry_timeout)
# now app0 closes the channel
RaidenAPI(app0.raiden).channel_close(
registry_address=token_network_registry_address,
token_address=token_address,
partner_address=app1.raiden.address,
)
count = 0
on_raiden_event_original = app1.raiden.raiden_event_handler.on_raiden_event
def patched_on_raiden_event(raiden, chain_state, event):
if type(event) == ContractSendChannelUpdateTransfer:
nonlocal count
count += 1
on_raiden_event_original(raiden, chain_state, event)
app1.raiden.raiden_event_handler.on_raiden_event = patched_on_raiden_event
# and now app1 comes back online
app1.raiden.start()
# test for https://github.com/raiden-network/raiden/issues/3216
assert count == 1, "Update transfer should have only been called once during restart"
channel_identifier = get_channelstate(app0, app1,
token_network_address).identifier
# and we wait for settlement
wait_for_settle(
raiden=app0.raiden,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
channel_ids=[channel_identifier],
retry_timeout=app0.raiden.alarm.sleep_time,
)
timeout = 30 if blockchain_type == "parity" else 10
with gevent.Timeout(timeout):
unlock_app0 = wait_for_state_change(
app0.raiden,
ContractReceiveChannelBatchUnlock,
{"receiver": app0.raiden.address},
retry_timeout,
)
assert unlock_app0.returned_tokens == amount_refund_with_fees
with gevent.Timeout(timeout):
unlock_app1 = wait_for_state_change(
app1.raiden,
ContractReceiveChannelBatchUnlock,
{"receiver": app1.raiden.address},
retry_timeout,
)
assert unlock_app1.returned_tokens == amount_refund_with_fees
final_balance0 = token_proxy.balance_of(app0.raiden.address)
final_balance1 = token_proxy.balance_of(app1.raiden.address)
assert final_balance0 - deposit - initial_balance0 == -1
assert final_balance1 - deposit - initial_balance1 == 1
def test_refund_transfer(raiden_chain, number_of_nodes, token_addresses,
deposit, network_wait, retry_timeout):
"""A failed transfer must send a refund back.
TODO:
- Unlock the token on refund #1091
- Clear the pending locks and update the locked amount #193
- Remove the refund message type #490"""
# Topology:
#
# 0 -> 1 -> 2
#
app0, app1, app2 = raiden_chain
token_address = token_addresses[0]
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_app(app0), token_network_registry_address,
token_address)
# make a transfer to test the path app0 -> app1 -> app2
identifier_path = PaymentID(1)
amount_path = PaymentAmount(1)
transfer(
initiator_app=app0,
target_app=app2,
token_address=token_address,
amount=amount_path,
identifier=identifier_path,
timeout=network_wait * number_of_nodes,
)
# drain the channel app1 -> app2
identifier_drain = PaymentID(2)
amount_drain = PaymentAmount(deposit * 8 // 10)
transfer(
initiator_app=app1,
target_app=app2,
token_address=token_address,
amount=amount_drain,
identifier=identifier_drain,
timeout=network_wait,
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit - amount_path,
[],
app1,
deposit + amount_path,
[],
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app1,
deposit - amount_path - amount_drain,
[],
app2,
deposit + amount_path + amount_drain,
[],
)
# app0 -> app1 -> app2 is the only available path, but the channel app1 ->
# app2 doesn't have capacity, so a refund will be sent on app1 -> app0
identifier_refund = PaymentID(3)
amount_refund = PaymentAmount(50)
fee = calculate_fee_for_amount(amount_refund)
fee_margin = calculate_fee_margin(amount_refund, fee)
amount_refund_with_fees = amount_refund + fee + fee_margin
payment_status = app0.raiden.mediated_transfer_async(
token_network_address, amount_refund, app2.raiden.address,
identifier_refund)
msg = "there is no path with capacity, the transfer must fail"
assert isinstance(payment_status.payment_done.wait(),
EventPaymentSentFailed), msg
# A lock structure with the correct amount
send_locked = raiden_events_search_for_item(
app0.raiden,
SendLockedTransfer,
{"transfer": {
"lock": {
"amount": amount_refund_with_fees
}
}},
)
assert send_locked
secrethash = send_locked.transfer.lock.secrethash
send_refund = raiden_events_search_for_item(app1.raiden,
SendRefundTransfer, {})
assert send_refund
lock = send_locked.transfer.lock
refund_lock = send_refund.transfer.lock
assert lock.amount == refund_lock.amount
assert lock.secrethash
assert lock.expiration
assert lock.secrethash == refund_lock.secrethash
# Both channels have the amount locked because of the refund message
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit - amount_path,
[lock],
app1,
deposit + amount_path,
[refund_lock],
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_address,
app1,
deposit - amount_path - amount_drain,
[],
app2,
deposit + amount_path + amount_drain,
[],
)
# Additional checks for LockExpired causing nonce mismatch after refund transfer:
# https://github.com/raiden-network/raiden/issues/3146#issuecomment-447378046
# At this point make sure that the initiator has not deleted the payment task
assert secrethash in state_from_raiden(
app0.raiden).payment_mapping.secrethashes_to_task
# Wait for lock lock expiration but make sure app0 never processes LockExpired
with dont_handle_lock_expired_mock(app0):
wait_for_block(
raiden=app0.raiden,
block_number=BlockNumber(
channel.get_sender_expiration_threshold(lock.expiration) + 1),
retry_timeout=retry_timeout,
)
# make sure that app0 still has the payment task for the secrethash
# https://github.com/raiden-network/raiden/issues/3183
assert secrethash in state_from_raiden(
app0.raiden).payment_mapping.secrethashes_to_task
# make sure that app1 sent a lock expired message for the secrethash
send_lock_expired = raiden_events_search_for_item(
app1.raiden, SendLockExpired, {"secrethash": secrethash})
assert send_lock_expired
# make sure that app0 never got it
state_changes = app0.raiden.wal.storage.get_statechanges_by_range(
RANGE_ALL_STATE_CHANGES)
assert not search_for_item(state_changes, ReceiveLockExpired,
{"secrethash": secrethash})
# Out of the handicapped app0 transport.
# Now wait till app0 receives and processes LockExpired
receive_lock_expired = wait_for_state_change(app0.raiden,
ReceiveLockExpired,
{"secrethash": secrethash},
retry_timeout)
# And also till app1 received the processed
wait_for_state_change(
app1.raiden,
ReceiveProcessed,
{"message_identifier": receive_lock_expired.message_identifier},
retry_timeout,
)
# make sure app1 queue has cleared the SendLockExpired
chain_state1 = views.state_from_app(app1)
queues1 = views.get_all_messagequeues(chain_state=chain_state1)
result = [(queue_id, queue) for queue_id, queue in queues1.items()
if queue_id.recipient == app0.raiden.address and queue]
assert not result
# and now wait for 1 more block so that the payment task can be deleted
wait_for_block(
raiden=app0.raiden,
block_number=app0.raiden.get_block_number() + 1,
retry_timeout=retry_timeout,
)
# and since the lock expired message has been sent and processed then the
# payment task should have been deleted from both nodes
# https://github.com/raiden-network/raiden/issues/3183
assert secrethash not in state_from_raiden(
app0.raiden).payment_mapping.secrethashes_to_task
assert secrethash not in state_from_raiden(
app1.raiden).payment_mapping.secrethashes_to_task
def test_refund_transfer_after_2nd_hop(raiden_chain: List[RaidenService],
number_of_nodes, token_addresses,
deposit, network_wait):
"""Test the refund transfer sent due to failure after 2nd hop"""
# Topology:
#
# 0 -> 1 -> 2 -> 3
#
app0, app1, app2, app3 = raiden_chain
token_address = token_addresses[0]
token_network_registry_address = app0.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_raiden(app0), token_network_registry_address,
token_address)
assert token_network_address, "token_address must be registered by the fixtures."
# make a transfer to test the path app0 -> app1 -> app2 -> app3
identifier_path = PaymentID(1)
amount_path = PaymentAmount(1)
with block_offset_timeout(app0):
transfer(
initiator_app=app0,
target_app=app3,
token_address=token_address,
amount=amount_path,
identifier=identifier_path,
timeout=network_wait * number_of_nodes,
routes=[[app0.address, app1.address, app2.address, app3.address]],
)
# drain the channel app2 -> app3
identifier_drain = PaymentID(2)
amount_drain = PaymentAmount(deposit * 8 // 10)
with block_offset_timeout(app2):
transfer(
initiator_app=app2,
target_app=app3,
token_address=token_address,
amount=amount_drain,
identifier=identifier_drain,
timeout=network_wait,
routes=[[app2.address, app3.address]],
)
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit - amount_path,
[],
app1,
deposit + amount_path,
[],
)
wait_assert(
assert_synced_channel_state,
token_network_address,
app1,
deposit - amount_path,
[],
app2,
deposit + amount_path,
[],
)
wait_assert(
assert_synced_channel_state,
token_network_address,
app2,
deposit - amount_path - amount_drain,
[],
app3,
deposit + amount_path + amount_drain,
[],
)
# app0 -> app1 -> app2 > app3 is the only available path, but the channel
# app2 -> app3 doesn't have capacity, so a refund will be sent on
# app2 -> app1 -> app0
identifier_refund = PaymentID(3)
amount_refund = PaymentAmount(50)
fee = calculate_fee_for_amount(amount_refund)
fee_margin = calculate_fee_margin(amount_refund, fee)
amount_refund_with_fees = amount_refund + fee + fee_margin
payment_status = app0.mediated_transfer_async(
token_network_address=token_network_address,
amount=amount_refund,
target=TargetAddress(app3.address),
identifier=identifier_refund,
route_states=[
create_route_state_for_route(
apps=[app0, app1, app2],
token_address=token_address,
fee_estimate=FeeAmount(
round(INTERNAL_ROUTING_DEFAULT_FEE_PERC * amount_refund)),
)
],
)
msg = "there is no path with capacity, the transfer must fail"
assert isinstance(payment_status.payment_done.wait(),
EventPaymentSentFailed), msg
# Lock structures with the correct amount
send_locked1 = raiden_events_search_for_item(
app0,
SendLockedTransfer,
{"transfer": {
"lock": {
"amount": amount_refund_with_fees
}
}},
)
assert send_locked1
send_refund1 = raiden_events_search_for_item(app1, SendRefundTransfer, {})
assert send_refund1
lock1 = send_locked1.transfer.lock
refund_lock1 = send_refund1.transfer.lock
assert lock1.amount == refund_lock1.amount
assert lock1.secrethash == refund_lock1.secrethash
send_locked2 = raiden_events_search_for_item(
app1,
SendLockedTransfer,
{"transfer": {
"lock": {
"amount": amount_refund_with_fees
}
}},
)
assert send_locked2
send_refund2 = raiden_events_search_for_item(app2, SendRefundTransfer, {})
assert send_refund2
lock2 = send_locked2.transfer.lock
refund_lock2 = send_refund2.transfer.lock
assert lock2.amount == refund_lock2.amount
assert lock2.secrethash
assert lock2.expiration
# channels have the amount locked because of the refund message
with block_offset_timeout(app0):
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit - amount_path,
[lock1],
app1,
deposit + amount_path,
[refund_lock1],
)
wait_assert(
assert_synced_channel_state,
token_network_address,
app1,
deposit - amount_path,
[lock2],
app2,
deposit + amount_path,
[refund_lock2],
)
wait_assert(
assert_synced_channel_state,
token_network_address,
app2,
deposit - amount_path - amount_drain,
[],
app3,
deposit + amount_path + amount_drain,
[],
)
def test_refund_messages(raiden_chain: List[RaidenService], token_addresses,
deposit):
# The network has the following topology:
#
# App0 <---> App1 <---> App2
app0, app1, app2 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
token_address = token_addresses[0]
token_network_registry_address = app0.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_raiden(app0), token_network_registry_address,
token_address)
assert token_network_address, "token_address must be registered by the fixtures."
identifier = PaymentID(1)
# Exhaust the channel App1 <-> App2 (to force the refund transfer)
# Here we make a single-hop transfer, no fees are charged so we should
# send the whole deposit amount to drain the channel.
transfer(
initiator_app=app1,
target_app=app2,
token_address=token_address,
amount=deposit,
identifier=identifier,
routes=[[app1.address, app2.address]],
)
refund_amount = deposit // 2
refund_fees = calculate_fee_for_amount(refund_amount)
fee_margin = calculate_fee_margin(refund_amount, refund_fees)
refund_amount_with_fees = refund_amount + refund_fees + fee_margin
payment_status = app0.mediated_transfer_async(
token_network_address=token_network_address,
amount=refund_amount,
target=TargetAddress(app2.address),
identifier=identifier,
route_states=[
create_route_state_for_route(
apps=raiden_chain,
token_address=token_address,
fee_estimate=FeeAmount(
round(INTERNAL_ROUTING_DEFAULT_FEE_PERC * refund_amount)),
)
],
)
msg = "Must fail, there are no routes available"
assert isinstance(payment_status.payment_done.wait(),
EventPaymentSentFailed), msg
# The transfer from app0 to app2 failed, so the balances did change.
# Since the refund is not unlocked both channels have the corresponding
# amount locked (issue #1091)
send_lockedtransfer = raiden_events_search_for_item(
app0,
SendLockedTransfer,
{"transfer": {
"lock": {
"amount": refund_amount_with_fees
}
}},
)
assert send_lockedtransfer
send_refundtransfer = raiden_events_search_for_item(
app1, SendRefundTransfer, {})
assert send_refundtransfer
with block_offset_timeout(app1):
wait_assert(
func=assert_synced_channel_state,
token_network_address=token_network_address,
app0=app0,
balance0=deposit,
pending_locks0=[send_lockedtransfer.transfer.lock],
app1=app1,
balance1=deposit,
pending_locks1=[send_refundtransfer.transfer.lock],
)
# This channel was exhausted to force the refund transfer except for the fees
wait_assert(
func=assert_succeeding_transfer_invariants,
token_network_address=token_network_address,
app0=app1,
balance0=0,
pending_locks0=[],
app1=app2,
balance1=deposit * 2,
pending_locks1=[],
)
def test_different_view_of_last_bp_during_unlock(
raiden_chain: List[RaidenService],
restart_node,
token_addresses,
deposit,
retry_timeout,
blockchain_type,
):
"""Test for https://github.com/raiden-network/raiden/issues/3196#issuecomment-449163888"""
# Topology:
#
# 0 -> 1 -> 2
#
app0, app1, app2 = raiden_chain
token_address = token_addresses[0]
token_network_registry_address = app0.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_raiden(app0), token_network_registry_address,
token_address)
assert token_network_address
token_proxy = app0.proxy_manager.token(token_address, BLOCK_ID_LATEST)
initial_balance0 = token_proxy.balance_of(app0.address)
initial_balance1 = token_proxy.balance_of(app1.address)
# make a transfer to test the path app0 -> app1 -> app2
identifier_path = PaymentID(1)
amount_path = PaymentAmount(1)
with block_offset_timeout(app0):
transfer(
initiator_app=app0,
target_app=app2,
token_address=token_address,
amount=amount_path,
identifier=identifier_path,
routes=[[app0.address, app1.address, app2.address]],
)
# drain the channel app1 -> app2
identifier_drain = PaymentID(2)
amount_drain = PaymentAmount(deposit * 8 // 10)
with block_offset_timeout(app1):
transfer(
initiator_app=app1,
target_app=app2,
token_address=token_address,
amount=amount_drain,
identifier=identifier_drain,
routes=[[app1.address, app2.address]],
)
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit - amount_path,
[],
app1,
deposit + amount_path,
[],
)
wait_assert(
assert_synced_channel_state,
token_network_address,
app1,
deposit - amount_path - amount_drain,
[],
app2,
deposit + amount_path + amount_drain,
[],
)
# app0 -> app1 -> app2 is the only available path, but the channel app1 ->
# app2 doesn't have capacity, so a refund will be sent on app1 -> app0
identifier_refund = PaymentID(3)
amount_refund = PaymentAmount(50)
fee = calculate_fee_for_amount(amount_refund)
fee_margin = calculate_fee_margin(amount_refund, fee)
amount_refund_with_fees = amount_refund + fee + fee_margin
payment_status = app0.mediated_transfer_async(
token_network_address=token_network_address,
amount=amount_refund,
target=TargetAddress(app2.address),
identifier=identifier_refund,
route_states=[
create_route_state_for_route(
apps=raiden_chain,
token_address=token_address,
fee_estimate=FeeAmount(
round(INTERNAL_ROUTING_DEFAULT_FEE_PERC * amount_refund)),
)
],
)
msg = "there is no path with capacity, the transfer must fail"
assert isinstance(payment_status.payment_done.wait(),
EventPaymentSentFailed), msg
# A lock structure with the correct amount
send_locked = raiden_events_search_for_item(
app0,
SendLockedTransfer,
{"transfer": {
"lock": {
"amount": amount_refund_with_fees
}
}},
)
assert send_locked
secrethash = send_locked.transfer.lock.secrethash
send_refund = raiden_events_search_for_item(app1, SendRefundTransfer, {})
assert send_refund
lock = send_locked.transfer.lock
refund_lock = send_refund.transfer.lock
assert lock.amount == refund_lock.amount
assert lock.secrethash
assert lock.expiration
assert lock.secrethash == refund_lock.secrethash
# Both channels have the amount locked because of the refund message
with block_offset_timeout(app0):
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit - amount_path,
[lock],
app1,
deposit + amount_path,
[refund_lock],
)
wait_assert(
assert_synced_channel_state,
token_network_address,
app1,
deposit - amount_path - amount_drain,
[],
app2,
deposit + amount_path + amount_drain,
[],
)
# Additional checks for LockExpired causing nonce mismatch after refund transfer:
# https://github.com/raiden-network/raiden/issues/3146#issuecomment-447378046
# At this point make sure that the initiator has not deleted the payment task
assert secrethash in state_from_raiden(
app0).payment_mapping.secrethashes_to_task
with dont_handle_node_change_network_state():
# now app1 goes offline
app1.stop()
app1.greenlet.get()
assert not app1
# Wait for lock expiration so that app0 sends a LockExpired
wait_for_block(
raiden=app0,
block_number=BlockNumber(
channel.get_sender_expiration_threshold(lock.expiration) + 1),
retry_timeout=retry_timeout,
)
# make sure that app0 sent a lock expired message for the secrethash
wait_for_raiden_event(app0, SendLockExpired,
{"secrethash": secrethash}, retry_timeout)
# now app0 closes the channel
RaidenAPI(app0).channel_close(
registry_address=token_network_registry_address,
token_address=token_address,
partner_address=app1.address,
)
count = 0
on_raiden_events_original = app1.raiden_event_handler.on_raiden_events
def patched_on_raiden_events(raiden, chain_state, events):
nonlocal count
count += sum(1 for event in events
if type(event) == ContractSendChannelUpdateTransfer)
on_raiden_events_original(raiden, chain_state, events)
setattr(app1.raiden_event_handler, "on_raiden_events",
patched_on_raiden_events) # NOQA
# and now app1 comes back online
restart_node(app1)
# test for https://github.com/raiden-network/raiden/issues/3216
assert count == 1, "Update transfer should have only been called once during restart"
channel_identifier = get_channelstate(app0, app1,
token_network_address).identifier
# and we wait for settlement
wait_for_settle(
raiden=app0,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
channel_ids=[channel_identifier],
retry_timeout=app0.alarm.sleep_time,
)
timeout = 30 if blockchain_type == "parity" else 10
with gevent.Timeout(timeout):
unlock_app0 = wait_for_state_change(
app0,
ContractReceiveChannelBatchUnlock,
{"receiver": app0.address},
retry_timeout,
)
assert unlock_app0
assert unlock_app0.returned_tokens == amount_refund_with_fees
with gevent.Timeout(timeout):
unlock_app1 = wait_for_state_change(
app1,
ContractReceiveChannelBatchUnlock,
{"receiver": app1.address},
retry_timeout,
)
assert unlock_app1
assert unlock_app1.returned_tokens == amount_refund_with_fees
final_balance0 = token_proxy.balance_of(app0.address)
final_balance1 = token_proxy.balance_of(app1.address)
assert final_balance0 - deposit - initial_balance0 == -1
assert final_balance1 - deposit - initial_balance1 == 1
