def direct_transfer_async(self, token_network_identifier, amount, target, identifier):
""" Do a direct transfer with target.
Direct transfers are non cancellable and non expirable, since these
transfers are a signed balance proof with the transferred amount
incremented.
Because the transfer is non cancellable, there is a level of trust with
the target. After the message is sent the target is effectively paid
and then it is not possible to revert.
The async result will be set to False iff there is no direct channel
with the target or the payer does not have balance to complete the
transfer, otherwise because the transfer is non expirable the async
result *will never be set to False* and if the message is sent it will
hang until the target node acknowledge the message.
This transfer should be used as an optimization, since only two packets
are required to complete the transfer (from the payers perspective),
whereas the mediated transfer requires 6 messages.
"""
self.start_health_check_for(target)
if identifier is None:
identifier = create_default_identifier()
direct_transfer = ActionTransferDirect(
token_network_identifier,
target,
identifier,
amount,
)
self.handle_state_change(direct_transfer)
def start_mediated_transfer_with_secret(
self,
token_network_identifier: TokenNetworkID,
amount: TokenAmount,
target: TargetAddress,
identifier: PaymentID,
secret: Secret,
) -> AsyncResult:
secret_hash = sha3(secret)
if self.default_secret_registry.check_registered(secret_hash):
raise RaidenUnrecoverableError(
f'Attempted to initiate a locked transfer with secrethash {pex(secret_hash)}.'
f' That secret is already registered onchain.',
)
self.start_health_check_for(Address(target))
if identifier is None:
identifier = create_default_identifier()
with self.payment_identifier_lock:
payment_status = self.targets_to_identifiers_to_statuses[target].get(identifier)
if payment_status:
payment_status_matches = payment_status.matches(
token_network_identifier,
amount,
)
if not payment_status_matches:
raise PaymentConflict(
'Another payment with the same id is in flight',
)
return payment_status.payment_done
payment_status = PaymentStatus(
payment_identifier=identifier,
amount=amount,
token_network_identifier=token_network_identifier,
payment_done=AsyncResult(),
)
self.targets_to_identifiers_to_statuses[target][identifier] = payment_status
init_initiator_statechange = initiator_init(
raiden=self,
transfer_identifier=identifier,
transfer_amount=amount,
transfer_secret=secret,
token_network_identifier=token_network_identifier,
target_address=target,
)
# Dispatch the state change even if there are no routes to create the
# wal entry.
self.handle_state_change(init_initiator_statechange)
return payment_status.payment_done
def initiate_transfer(
self,
registry_address,
token_address,
target_address,
amount,
identifier,
):
if identifier is None:
identifier = create_default_identifier()
try:
transfer_result = self.raiden_api.transfer(
registry_address=registry_address,
token_address=token_address,
target=target_address,
amount=amount,
identifier=identifier,
)
except (InvalidAmount, InvalidAddress) as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.CONFLICT,
)
except InsufficientFunds as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.PAYMENT_REQUIRED,
)
if transfer_result is False:
return api_error(
errors="Payment couldn't be completed "
"(insufficient funds or no route to target).",
status_code=HTTPStatus.CONFLICT,
)
transfer = {
'initiator_address': self.raiden_api.address,
'registry_address': registry_address,
'token_address': token_address,
'target_address': target_address,
'amount': amount,
'identifier': identifier,
}
result = self.transfer_schema.dump(transfer)
return api_response(result=result.data)
def direct_transfer_async(self, token_network_identifier, amount, target,
identifier):
""" Do a direct transfer with target.
Direct transfers are non cancellable and non expirable, since these
transfers are a signed balance proof with the transferred amount
incremented.
Because the transfer is non cancellable, there is a level of trust with
the target. After the message is sent the target is effectively paid
and then it is not possible to revert.
The async result will be set to False iff there is no direct channel
with the target or the payer does not have balance to complete the
transfer, otherwise because the transfer is non expirable the async
result *will never be set to False* and if the message is sent it will
hang until the target node acknowledge the message.
This transfer should be used as an optimization, since only two packets
are required to complete the transfer (from the payers perspective),
whereas the mediated transfer requires 6 messages.
"""
self.start_health_check_for(target)
if identifier is None:
identifier = create_default_identifier()
direct_transfer = ActionTransferDirect(
token_network_identifier,
target,
identifier,
amount,
)
self.handle_state_change(direct_transfer)
def start_mediated_transfer(
self,
token_network_identifier,
amount,
target,
identifier,
):
self.transport.start_health_check(target)
if identifier is None:
identifier = create_default_identifier()
assert identifier not in self.identifier_to_results
async_result = AsyncResult()
self.identifier_to_results[identifier].append(async_result)
secret = random_secret()
init_initiator_statechange = initiator_init(
self,
identifier,
amount,
secret,
token_network_identifier,
target,
)
# TODO: implement the network timeout raiden.config['msg_timeout'] and
# cancel the current transfer if it happens (issue #374)
#
# Dispatch the state change even if there are no routes to create the
# wal entry.
self.handle_state_change(init_initiator_statechange)
return async_result
def start_mediated_transfer(
self,
token_network_identifier,
amount,
target,
identifier,
):
self.start_health_check_for(target)
if identifier is None:
identifier = create_default_identifier()
assert identifier not in self.identifier_to_results
async_result = AsyncResult()
self.identifier_to_results[identifier].append(async_result)
secret = random_secret()
init_initiator_statechange = initiator_init(
self,
identifier,
amount,
secret,
token_network_identifier,
target,
)
# TODO: implement the network timeout raiden.config['msg_timeout'] and
# cancel the current transfer if it happens (issue #374)
#
# Dispatch the state change even if there are no routes to create the
# wal entry.
self.handle_state_change(init_initiator_statechange)
return async_result
def test_send_queued_messages( # pylint: disable=unused-argument
raiden_network, deposit, token_addresses, network_wait):
"""Test re-sending of undelivered messages on node restart"""
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)
assert token_network_address
number_of_transfers = 7
amount_per_transfer = 1
total_transferred_amount = TokenAmount(amount_per_transfer *
number_of_transfers)
# Make sure none of the transfers will be sent before the restart
transfers = []
for secret_seed in range(number_of_transfers):
secret = make_secret(secret_seed)
secrethash = sha256_secrethash(secret)
transfers.append((create_default_identifier(), amount_per_transfer,
secret, secrethash))
app0.raiden.raiden_event_handler.hold(
SendLockedTransfer,
{"transfer": {
"lock": {
"secrethash": secrethash
}
}})
for identifier, amount, secret, _ in transfers:
app0.raiden.mediated_transfer_async(
token_network_address=token_network_address,
amount=amount,
target=app1.raiden.address,
identifier=identifier,
secret=secret,
)
app0.stop()
# Restart the app. The pending transfers must be processed.
new_transport = MatrixTransport(app0.raiden.config["transport"]["matrix"])
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
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=new_transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
routing_mode=RoutingMode.PRIVATE,
)
del app0
app0_restart.start()
# XXX: There is no synchronization among the app and the test, so it is
# possible between `start` and the check bellow that some of the transfers
# have completed, making it flaky.
#
# Make sure the transfers are in the queue and fail otherwise.
# chain_state = views.state_from_raiden(app0_restart.raiden)
# for _, _, _, secrethash in transfers:
# msg = "The secrethashes of the pending transfers must be in the queue after a restart."
# assert secrethash in chain_state.payment_mapping.secrethashes_to_task, msg
with watch_for_unlock_failures(*raiden_network):
exception = RuntimeError(
"Timeout while waiting for balance update for app0")
with gevent.Timeout(20, exception=exception):
waiting.wait_for_payment_balance(
raiden=app0_restart.raiden,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
partner_address=app1.raiden.address,
target_address=app1.raiden.address,
target_balance=total_transferred_amount,
retry_timeout=network_wait,
)
exception = RuntimeError(
"Timeout while waiting for balance update for app1")
with gevent.Timeout(20, exception=exception):
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=total_transferred_amount,
retry_timeout=network_wait,
)
assert_synced_channel_state(
token_network_address,
app0_restart,
deposit - total_transferred_amount,
[],
app1,
deposit + total_transferred_amount,
[],
)
new_transport.stop()
def test_recovery_happy_case(
raiden_network,
number_of_nodes,
deposit,
token_addresses,
network_wait,
skip_if_not_udp,
):
app0, app1, app2 = raiden_network
token_address = token_addresses[0]
app2_wait_for = WaitForMessage()
app2.raiden.message_handler = app2_wait_for
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
for _ in range(spent_amount):
mediated_transfer(
app0,
app2,
token_network_identifier,
amount,
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 = 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,
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,
)
identifier = create_default_identifier()
wait_for_payment = app2_wait_for.wait_for_message(Secret, {'payment_identifier': identifier})
mediated_transfer(
app2,
app0_restart,
token_network_identifier,
amount,
timeout=network_wait * number_of_nodes * 2,
)
mediated_transfer(
initiator_app=app0_restart,
target_app=app2,
token_network_identifier=token_network_identifier,
amount=amount,
identifier=identifier,
timeout=network_wait * number_of_nodes * 2,
)
assert_synced_channel_state(
token_network_identifier,
app0_restart, deposit - spent_amount, [],
app1, deposit + spent_amount, [],
)
wait_for_payment.wait()
assert_synced_channel_state(
token_network_identifier,
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_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 start_mediated_transfer_with_secret(
self,
token_network_identifier: TokenNetworkID,
amount: PaymentAmount,
target: TargetAddress,
identifier: PaymentID,
secret: Secret,
secret_hash: SecretHash = None,
) -> PaymentStatus:
if secret_hash is None:
secret_hash = sha3(secret)
# LEFTODO: Supply a proper block id
secret_registered = self.default_secret_registry.check_registered(
secrethash=secret_hash,
block_identifier='latest',
)
if secret_registered:
raise RaidenUnrecoverableError(
f'Attempted to initiate a locked transfer with secrethash {pex(secret_hash)}.'
f' That secret is already registered onchain.',
)
self.start_health_check_for(Address(target))
if identifier is None:
identifier = create_default_identifier()
with self.payment_identifier_lock:
payment_status = self.targets_to_identifiers_to_statuses[target].get(identifier)
if payment_status:
payment_status_matches = payment_status.matches(
token_network_identifier,
amount,
)
if not payment_status_matches:
raise PaymentConflict(
'Another payment with the same id is in flight',
)
return payment_status
payment_status = PaymentStatus(
payment_identifier=identifier,
amount=amount,
token_network_identifier=token_network_identifier,
payment_done=AsyncResult(),
secret=secret,
secret_hash=secret_hash,
)
self.targets_to_identifiers_to_statuses[target][identifier] = payment_status
init_initiator_statechange = initiator_init(
raiden=self,
transfer_identifier=identifier,
transfer_amount=amount,
transfer_secret=secret,
token_network_identifier=token_network_identifier,
target_address=target,
)
# Dispatch the state change even if there are no routes to create the
# wal entry.
self.handle_state_change(init_initiator_statechange)
return payment_status
def test_create_crosstransactiontry(initiator_address, target_address, token_address, sendETH_amount, sendBTC_amount, receiveBTC_address):
wal = new_wal()
id = create_default_identifier()
wal.create_crosstransactiontry(initiator_address, target_address, token_address, sendETH_amount, sendBTC_amount, receiveBTC_address, id)
def start_mediated_transfer_with_secret(
self,
token_network_identifier: TokenNetworkID,
amount: PaymentAmount,
fee: FeeAmount,
target: TargetAddress,
identifier: PaymentID,
secret: Secret,
secrethash: SecretHash = None,
) -> PaymentStatus:
if secrethash is None:
secrethash = sha3(secret)
elif secrethash != sha3(secret):
raise InvalidSecretHash(
"provided secret and secret_hash do not match.")
if len(secret) != SECRET_LENGTH:
raise InvalidSecret("secret of invalid length.")
# We must check if the secret was registered against the latest block,
# even if the block is forked away and the transaction that registers
# the secret is removed from the blockchain. The rationale here is that
# someone else does know the secret, regardless of the chain state, so
# the node must not use it to start a payment.
#
# For this particular case, it's preferable to use `latest` instead of
# having a specific block_hash, because it's preferable to know if the secret
# was ever known, rather than having a consistent view of the blockchain.
secret_registered = self.default_secret_registry.is_secret_registered(
secrethash=secrethash, block_identifier="latest")
if secret_registered:
raise RaidenUnrecoverableError(
f"Attempted to initiate a locked transfer with secrethash {pex(secrethash)}."
f" That secret is already registered onchain.")
self.start_health_check_for(Address(target))
if identifier is None:
identifier = create_default_identifier()
with self.payment_identifier_lock:
payment_status = self.targets_to_identifiers_to_statuses[
target].get(identifier)
if payment_status:
payment_status_matches = payment_status.matches(
token_network_identifier, amount)
if not payment_status_matches:
raise PaymentConflict(
"Another payment with the same id is in flight")
return payment_status
payment_status = PaymentStatus(
payment_identifier=identifier,
amount=amount,
token_network_identifier=token_network_identifier,
payment_done=AsyncResult(),
)
self.targets_to_identifiers_to_statuses[target][
identifier] = payment_status
init_initiator_statechange = initiator_init(
raiden=self,
transfer_identifier=identifier,
transfer_amount=amount,
transfer_secret=secret,
transfer_secrethash=secrethash,
transfer_fee=fee,
token_network_identifier=token_network_identifier,
target_address=target,
)
# Dispatch the state change even if there are no routes to create the
# wal entry.
self.handle_and_track_state_change(init_initiator_statechange)
return payment_status
def initiate_payment(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
target_address: typing.Address,
amount: typing.TokenAmount,
identifier: typing.PaymentID,
secret: typing.Secret,
secret_hash: typing.SecretHash,
):
log.debug(
'Initiating payment',
node=pex(self.raiden_api.address),
registry_address=to_checksum_address(registry_address),
token_address=to_checksum_address(token_address),
target_address=to_checksum_address(target_address),
amount=amount,
payment_identifier=identifier,
secret=secret,
secret_hash=secret_hash,
)
if identifier is None:
identifier = create_default_identifier()
try:
payment_status = self.raiden_api.transfer(
registry_address=registry_address,
token_address=token_address,
target=target_address,
amount=amount,
identifier=identifier,
secret=secret,
secret_hash=secret_hash,
)
except (
InvalidAmount,
InvalidAddress,
InvalidSecretOrSecretHash,
PaymentConflict,
UnknownTokenAddress,
) as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.CONFLICT,
)
except InsufficientFunds as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.PAYMENT_REQUIRED,
)
if payment_status.payment_done.get() is False:
return api_error(
errors="Payment couldn't be completed "
"(insufficient funds, no route to target or target offline).",
status_code=HTTPStatus.CONFLICT,
)
payment = {
'initiator_address': self.raiden_api.address,
'registry_address': registry_address,
'token_address': token_address,
'target_address': target_address,
'amount': amount,
'identifier': identifier,
'secret': to_hex(payment_status.secret),
'secret_hash': to_hex(payment_status.secret_hash),
}
result = self.payment_schema.dump(payment)
return api_response(result=result.data)
def test_recovery_happy_case(
raiden_network,
number_of_nodes,
deposit,
token_addresses,
network_wait,
skip_if_not_udp,
):
app0, app1, app2 = raiden_network
token_address = token_addresses[0]
app2_wait_for = WaitForMessage()
app2.raiden.message_handler = app2_wait_for
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
for _ in range(spent_amount):
mediated_transfer(
app0,
app2,
token_network_identifier,
amount,
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 = 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,
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,
)
identifier = create_default_identifier()
wait_for_payment = app2_wait_for.wait_for_message(
Unlock, {'payment_identifier': identifier})
mediated_transfer(
app2,
app0_restart,
token_network_identifier,
amount,
timeout=network_wait * number_of_nodes * 2,
)
mediated_transfer(
initiator_app=app0_restart,
target_app=app2,
token_network_identifier=token_network_identifier,
amount=amount,
identifier=identifier,
timeout=network_wait * number_of_nodes * 2,
)
assert_synced_channel_state(
token_network_identifier,
app0_restart,
deposit - spent_amount,
[],
app1,
deposit + spent_amount,
[],
)
wait_for_payment.wait()
assert_synced_channel_state(
token_network_identifier,
app1,
deposit - spent_amount,
[],
app2,
deposit + spent_amount,
[],
)
