def run_test_automatic_secret_registration(raiden_chain, token_addresses):
app0, app1 = raiden_chain
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
app0.raiden.default_registry.address,
token_address,
)
amount = 100
identifier = 1
hold_event_handler = HoldOffChainSecretRequest()
message_handler = WaitForMessage()
app1.raiden.raiden_event_handler = hold_event_handler
app1.raiden.message_handler = message_handler
target = app1.raiden.address
secret = sha3(target)
secrethash = sha3(secret)
hold_event_handler.hold_secretrequest_for(secrethash=secrethash)
locked_transfer_received = message_handler.wait_for_message(
LockedTransfer, {})
app0.raiden.start_mediated_transfer_with_secret(
token_network_identifier=token_network_identifier,
amount=amount,
fee=0,
target=target,
identifier=identifier,
secret=secret,
)
# Wait for app1 to receive the locked transfer.
locked_transfer_received.wait()
# Stop app0 to avoid sending the unlock, this must be done after the locked
# transfer is sent.
app0.raiden.transport.stop()
reveal_secret = RevealSecret(
message_identifier=random.randint(0, UINT64_MAX),
secret=secret,
)
app0.raiden.sign(reveal_secret)
message_handler.on_message(app1.raiden, reveal_secret)
chain_state = views.state_from_app(app1)
secrethash = sha3(secret)
target_task = chain_state.payment_mapping.secrethashes_to_task[secrethash]
lock_expiration = target_task.target_state.transfer.lock.expiration
app1.raiden.chain.wait_until_block(target_block_number=lock_expiration)
assert app1.raiden.default_secret_registry.is_secret_registered(
secrethash=secrethash,
block_identifier='latest',
)
def test_automatic_secret_registration(raiden_chain, token_addresses):
app0, app1 = raiden_chain
token_address = token_addresses[0]
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_app(app0), app0.raiden.default_registry.address,
token_address)
hold_event_handler = app1.raiden.raiden_event_handler
amount = 100
identifier = 1
message_handler = WaitForMessage()
app1.raiden.message_handler = message_handler
target = app1.raiden.address
secret = Secret(sha3(target))
secrethash = sha256_secrethash(secret)
hold_event_handler.hold_secretrequest_for(secrethash=secrethash)
locked_transfer_received = message_handler.wait_for_message(
LockedTransfer, {})
app0.raiden.start_mediated_transfer_with_secret(
token_network_address=token_network_address,
amount=amount,
target=target,
identifier=identifier,
secret=secret,
)
# Wait for app1 to receive the locked transfer.
locked_transfer_received.wait()
# Stop app0 to avoid sending the unlock, this must be done after the locked
# transfer is sent.
app0.raiden.transport.stop()
reveal_secret = RevealSecret(
message_identifier=MessageID(random.randint(0, UINT64_MAX)),
secret=secret,
signature=EMPTY_SIGNATURE,
)
app0.raiden.sign(reveal_secret)
message_handler.on_message(app1.raiden, reveal_secret)
chain_state = views.state_from_app(app1)
secrethash = sha256_secrethash(secret)
target_task = chain_state.payment_mapping.secrethashes_to_task[secrethash]
lock_expiration = target_task.target_state.transfer.lock.expiration # type: ignore
app1.raiden.proxy_manager.wait_until_block(
target_block_number=lock_expiration)
assert app1.raiden.default_secret_registry.is_secret_registered(
secrethash=secrethash, block_identifier="latest")
def test_channel_withdraw(
raiden_network: List[App],
token_addresses: List[TokenAddress],
deposit: TokenAmount,
retry_timeout: float,
) -> None:
""" Withdraw funds after a mediated transfer."""
alice_app, bob_app = raiden_network
token_address = token_addresses[0]
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_app(alice_app), alice_app.raiden.default_registry.address, token_address
)
assert token_network_address
token_proxy = bob_app.raiden.proxy_manager.token(token_address, BLOCK_ID_LATEST)
bob_initial_balance = token_proxy.balance_of(bob_app.raiden.address)
message_handler = WaitForMessage()
bob_app.raiden.message_handler = message_handler
alice_to_bob_amount = PaymentAmount(10)
identifier = PaymentID(1)
target = TargetAddress(bob_app.raiden.address)
secret = factories.make_secret()
payment_status = alice_app.raiden.start_mediated_transfer_with_secret(
token_network_address=token_network_address,
amount=alice_to_bob_amount,
target=target,
identifier=identifier,
secret=secret,
)
wait_for_unlock = bob_app.raiden.message_handler.wait_for_message(
Unlock, {"payment_identifier": identifier}
)
with block_offset_timeout(alice_app.raiden):
wait_for_unlock.get()
msg = (
f"transfer from {to_checksum_address(alice_app.raiden.address)} "
f"to {to_checksum_address(bob_app.raiden.address)} failed."
)
assert payment_status.payment_done.get(), msg
total_withdraw = WithdrawAmount(deposit + alice_to_bob_amount)
bob_alice_channel_state = get_channelstate(bob_app, alice_app, token_network_address)
bob_app.raiden.withdraw(
canonical_identifier=bob_alice_channel_state.canonical_identifier,
total_withdraw=total_withdraw,
)
waiting.wait_for_withdraw_complete(
raiden=bob_app.raiden,
canonical_identifier=bob_alice_channel_state.canonical_identifier,
total_withdraw=total_withdraw,
retry_timeout=retry_timeout,
)
bob_balance_after_withdraw = token_proxy.balance_of(bob_app.raiden.address)
assert bob_initial_balance + total_withdraw == bob_balance_after_withdraw
def run_test_event_transfer_received_success(
token_addresses,
raiden_chain,
):
sender_apps = raiden_chain[:-1]
target_app = raiden_chain[-1]
token_address = token_addresses[0]
registry_address = target_app.raiden.default_registry.address
target_address = target_app.raiden.address
message_handler = WaitForMessage()
target_app.raiden.message_handler = message_handler
wait_for = list()
for amount, app in enumerate(sender_apps, 1):
secret = random_secret()
wait = message_handler.wait_for_message(
Unlock,
{'secret': secret},
)
wait_for.append((wait, app.raiden.address, amount))
RaidenAPI(app.raiden).transfer_async(
registry_address=registry_address,
token_address=token_address,
amount=amount,
identifier=amount,
target=target_address,
secret=to_hex(secret),
secret_hash=to_hex(sha3(secret)),
)
for wait, sender, amount in wait_for:
wait.wait()
assert search_for_item(
target_app.raiden.wal.storage.get_events(),
EventPaymentReceivedSuccess,
{
'amount': amount,
'identifier': amount,
'initiator': sender,
'payment_network_identifier': registry_address,
# 'token_network_identifier': ,
},
)
def test_channel_withdraw(
raiden_network, number_of_nodes, token_addresses, deposit, network_wait, retry_timeout
):
""" Withdraw funds after a mediated transfer."""
alice_app, bob_app = raiden_network
token_address = token_addresses[0]
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_app(alice_app), alice_app.raiden.default_registry.address, token_address
)
assert token_network_address
token_proxy = bob_app.raiden.proxy_manager.token(token_address)
bob_initial_balance = token_proxy.balance_of(bob_app.raiden.address)
message_handler = WaitForMessage()
bob_app.raiden.message_handler = message_handler
alice_to_bob_amount = 10
identifier = 1
target = bob_app.raiden.address
secret = sha3(target)
payment_status = alice_app.raiden.start_mediated_transfer_with_secret(
token_network_address=token_network_address,
amount=alice_to_bob_amount,
target=target,
identifier=identifier,
secret=secret,
)
wait_for_unlock = bob_app.raiden.message_handler.wait_for_message(
Unlock, {"payment_identifier": identifier}
)
timeout = network_wait * number_of_nodes
with Timeout(seconds=timeout):
wait_for_unlock.get()
msg = (
f"transfer from {to_checksum_address(alice_app.raiden.address)} "
f"to {to_checksum_address(bob_app.raiden.address)} failed."
)
assert payment_status.payment_done.get(), msg
total_withdraw = deposit + alice_to_bob_amount
bob_alice_channel_state = get_channelstate(bob_app, alice_app, token_network_address)
bob_app.raiden.withdraw(
canonical_identifier=bob_alice_channel_state.canonical_identifier,
total_withdraw=total_withdraw,
)
waiting.wait_for_withdraw_complete(
raiden=bob_app.raiden,
canonical_identifier=bob_alice_channel_state.canonical_identifier,
total_withdraw=total_withdraw,
retry_timeout=retry_timeout,
)
bob_balance_after_withdraw = token_proxy.balance_of(bob_app.raiden.address)
assert bob_initial_balance + total_withdraw == bob_balance_after_withdraw
def test_pending_transfers_endpoint(raiden_network: List[RaidenService],
token_addresses):
initiator, mediator, target = raiden_network
token_address = token_addresses[0]
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_raiden(mediator), mediator.default_registry.address,
token_address)
assert token_network_address
amount_to_send = PaymentAmount(150)
# Remove when https://github.com/raiden-network/raiden/issues/4982 is tackled
expected_fee = FeeAmount(
int(amount_to_send * INTERNAL_ROUTING_DEFAULT_FEE_PERC))
fee_margin = calculate_fee_margin(amount_to_send, expected_fee)
# This is 0,4% of ~150, so ~1.2 which gets rounded to 1
actual_fee = 1
identifier = PaymentID(42)
initiator_server = prepare_api_server(initiator)
mediator_server = prepare_api_server(mediator)
target_server = prepare_api_server(target)
target.message_handler = target_wait = WaitForMessage()
mediator.message_handler = mediator_wait = WaitForMessage()
secret = factories.make_secret()
secrethash = sha256_secrethash(secret)
request = grequests.get(
api_url_for(mediator_server,
"pending_transfers_resource_by_token",
token_address=token_address))
response = request.send().response
assert response.status_code == 200 and response.content == b"[]"
target_hold = target.raiden_event_handler
assert isinstance(
target_hold,
HoldRaidenEventHandler), "test app must use HoldRaidenEventHandler"
target_hold.hold_secretrequest_for(secrethash=secrethash)
initiator.mediated_transfer_async(
token_network_address=token_network_address,
amount=PaymentAmount(amount_to_send - expected_fee - fee_margin),
target=TargetAddress(target.address),
identifier=identifier,
secret=secret,
route_states=[
create_route_state_for_route(
apps=raiden_network,
token_address=token_address,
fee_estimate=expected_fee,
)
],
)
transfer_arrived = target_wait.wait_for_message(LockedTransfer,
{"payment_identifier": 42})
transfer_arrived.wait(timeout=30.0)
for server in (initiator_server, mediator_server, target_server):
request = grequests.get(
api_url_for(server, "pending_transfers_resource"))
response = request.send().response
assert response.status_code == 200
content = json.loads(response.content)
assert len(content) == 1
assert content[0]["payment_identifier"] == str(identifier)
if server == target_server:
assert content[0]["locked_amount"] == str(amount_to_send -
actual_fee)
else:
assert content[0]["locked_amount"] == str(amount_to_send)
assert content[0]["token_address"] == to_checksum_address(
token_address)
assert content[0]["token_network_address"] == to_checksum_address(
token_network_address)
mediator_unlock = mediator_wait.wait_for_message(Unlock, {})
target_unlock = target_wait.wait_for_message(Unlock, {})
target_hold.release_secretrequest_for(target, secrethash)
gevent.joinall({mediator_unlock, target_unlock}, raise_error=True)
for server in (initiator_server, mediator_server, target_server):
request = grequests.get(
api_url_for(server, "pending_transfers_resource"))
response = request.send().response
assert response.status_code == 200 and response.content == b"[]"
request = grequests.get(
api_url_for(
initiator_server,
"pending_transfers_resource_by_token",
token_address=to_hex(b"notaregisteredtokenn"),
))
response = request.send().response
assert response.status_code == 404 and b"Token" in response.content
request = grequests.get(
api_url_for(
target_server,
"pending_transfers_resource_by_token_and_partner",
token_address=token_address,
partner_address=to_hex(b"~nonexistingchannel~"),
))
response = request.send().response
assert response.status_code == 404 and b"Channel" in response.content
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_echo_node_response(token_addresses, raiden_chain, retry_timeout):
app0, app1, echo_app = raiden_chain
token_address = token_addresses[0]
registry_address = echo_app.raiden.default_registry.address
echo_api = RaidenAPI(echo_app.raiden)
echo_node = EchoNode(echo_api, token_address)
message_handler = WaitForMessage()
echo_app.raiden.message_handler = message_handler
echo_node.ready.wait(timeout=30)
assert echo_node.ready.is_set()
transfer_timeout = 10
wait_for = list()
for num, app in enumerate([app0, app1]):
amount = PaymentAmount(1 + num)
identifier = PaymentID(10 ** (num + 1))
secret, secrethash = make_secret_with_hash()
payment_status = RaidenAPI(app.raiden).transfer_async(
registry_address=registry_address,
token_address=token_address,
amount=amount,
target=echo_app.raiden.address,
identifier=identifier,
secret=secret,
secrethash=secrethash,
)
wait = message_handler.wait_for_message(Unlock, {"secret": secret})
wait_for.append((wait, app.raiden.address, amount, identifier))
msg = (
f"Transfer {identifier} from "
f"{to_checksum_address(app.raiden.address)} to "
f"{to_checksum_address(echo_app.raiden.address)} timed out after "
f"{transfer_timeout}"
)
timeout = gevent.Timeout(transfer_timeout, exception=RuntimeError(msg))
with watch_for_unlock_failures(*raiden_chain), timeout:
payment_status.payment_done.wait()
echo_identifier = PaymentID(identifier + amount)
msg = (
f"Response transfer {echo_identifier} from echo node "
f"{to_checksum_address(echo_app.raiden.address)} to "
f"{to_checksum_address(app.raiden.address)} timed out after "
f"{transfer_timeout}"
)
with gevent.Timeout(transfer_timeout, exception=RuntimeError(msg)):
result = wait_for_received_transfer_result(
raiden=app.raiden,
payment_identifier=echo_identifier,
amount=amount,
retry_timeout=retry_timeout,
secrethash=secrethash,
)
assert result == TransferWaitResult.UNLOCKED
for wait, sender, amount, ident in wait_for:
wait.wait()
assert search_for_item(
echo_app.raiden.wal.storage.get_events(),
EventPaymentReceivedSuccess,
{
"amount": amount,
"identifier": ident,
"initiator": sender,
"token_network_registry_address": registry_address,
},
)
echo_node.stop()
def test_lock_expiry(raiden_network, token_addresses, deposit):
"""Test lock expiry and removal."""
alice_app, bob_app = raiden_network
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(alice_app),
alice_app.raiden.default_registry.address,
token_address,
)
hold_event_handler = HoldOffChainSecretRequest()
wait_message_handler = WaitForMessage()
bob_app.raiden.message_handler = wait_message_handler
bob_app.raiden.raiden_event_handler = hold_event_handler
token_network = views.get_token_network_by_identifier(
views.state_from_app(alice_app),
token_network_identifier,
)
channel_state = get_channelstate(alice_app, bob_app, token_network_identifier)
channel_identifier = channel_state.identifier
assert channel_identifier in token_network.partneraddresses_to_channelidentifiers[
bob_app.raiden.address
]
alice_to_bob_amount = 10
identifier = 1
target = bob_app.raiden.address
transfer_1_secret = factories.make_secret(0)
transfer_1_secrethash = sha3(transfer_1_secret)
transfer_2_secret = factories.make_secret(1)
transfer_2_secrethash = sha3(transfer_2_secret)
hold_event_handler.hold_secretrequest_for(secrethash=transfer_1_secrethash)
transfer1_received = wait_message_handler.wait_for_message(
LockedTransfer,
{'lock': {'secrethash': transfer_1_secrethash}},
)
transfer2_received = wait_message_handler.wait_for_message(
LockedTransfer,
{'lock': {'secrethash': transfer_2_secrethash}},
)
remove_expired_lock_received = wait_message_handler.wait_for_message(
LockExpired,
{'secrethash': transfer_1_secrethash},
)
alice_app.raiden.start_mediated_transfer_with_secret(
token_network_identifier,
alice_to_bob_amount,
target,
identifier,
transfer_1_secret,
)
transfer1_received.wait()
alice_bob_channel_state = get_channelstate(alice_app, bob_app, token_network_identifier)
lock = channel.get_lock(alice_bob_channel_state.our_state, transfer_1_secrethash)
# This is the current state of the protocol:
#
# A -> B LockedTransfer
# B -> A SecretRequest
# - protocol didn't continue
assert_synced_channel_state(
token_network_identifier,
alice_app, deposit, [lock],
bob_app, deposit, [],
)
# Verify lock is registered in both channel states
alice_channel_state = get_channelstate(alice_app, bob_app, token_network_identifier)
assert transfer_1_secrethash in alice_channel_state.our_state.secrethashes_to_lockedlocks
bob_channel_state = get_channelstate(bob_app, alice_app, token_network_identifier)
assert transfer_1_secrethash in bob_channel_state.partner_state.secrethashes_to_lockedlocks
alice_chain_state = views.state_from_raiden(alice_app.raiden)
assert transfer_1_secrethash in alice_chain_state.payment_mapping.secrethashes_to_task
remove_expired_lock_received.wait()
alice_channel_state = get_channelstate(alice_app, bob_app, token_network_identifier)
assert transfer_1_secrethash not in alice_channel_state.our_state.secrethashes_to_lockedlocks
# Verify Bob received the message and processed the LockExpired message
bob_channel_state = get_channelstate(bob_app, alice_app, token_network_identifier)
assert transfer_1_secrethash not in bob_channel_state.partner_state.secrethashes_to_lockedlocks
alice_chain_state = views.state_from_raiden(alice_app.raiden)
assert transfer_1_secrethash not in alice_chain_state.payment_mapping.secrethashes_to_task
# Make another transfer
alice_to_bob_amount = 10
identifier = 2
hold_event_handler.hold_secretrequest_for(secrethash=transfer_2_secrethash)
alice_app.raiden.start_mediated_transfer_with_secret(
token_network_identifier,
alice_to_bob_amount,
target,
identifier,
transfer_2_secret,
)
transfer2_received.wait()
# Make sure the other transfer still exists
alice_chain_state = views.state_from_raiden(alice_app.raiden)
assert transfer_2_secrethash in alice_chain_state.payment_mapping.secrethashes_to_task
bob_channel_state = get_channelstate(bob_app, alice_app, token_network_identifier)
assert transfer_2_secrethash in bob_channel_state.partner_state.secrethashes_to_lockedlocks
def create_apps(
chain_id,
contracts_path,
blockchain_services,
endpoint_discovery_services,
token_network_registry_address,
secret_registry_address,
service_registry_address,
user_deposit_address,
raiden_udp_ports,
reveal_timeout,
settle_timeout,
database_paths,
retry_interval,
retries_before_backoff,
throttle_capacity,
throttle_fill_rate,
nat_invitation_timeout,
nat_keepalive_retries,
nat_keepalive_timeout,
environment_type,
unrecoverable_error_should_crash,
local_matrix_url=None,
private_rooms=None,
):
""" Create the apps."""
# pylint: disable=too-many-locals
services = zip(blockchain_services, endpoint_discovery_services,
raiden_udp_ports)
apps = []
for idx, (blockchain, discovery, port) in enumerate(services):
address = blockchain.client.address
host = '127.0.0.1'
config = {
'chain_id': chain_id,
'environment_type': environment_type,
'unrecoverable_error_should_crash':
unrecoverable_error_should_crash,
'reveal_timeout': reveal_timeout,
'settle_timeout': settle_timeout,
'contracts_path': contracts_path,
'database_path': database_paths[idx],
'blockchain': {
'confirmation_blocks': DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
},
'transport': {
'udp': {
'external_ip': host,
'external_port': port,
'host': host,
'nat_invitation_timeout': nat_invitation_timeout,
'nat_keepalive_retries': nat_keepalive_retries,
'nat_keepalive_timeout': nat_keepalive_timeout,
'port': port,
'retries_before_backoff': retries_before_backoff,
'retry_interval': retry_interval,
'throttle_capacity': throttle_capacity,
'throttle_fill_rate': throttle_fill_rate,
},
},
'rpc': True,
'console': False,
}
use_matrix = local_matrix_url is not None
if use_matrix:
merge_dict(
config,
{
'transport_type': 'matrix',
'transport': {
'matrix': {
'global_rooms': ['discovery'],
'retries_before_backoff': retries_before_backoff,
'retry_interval': retry_interval,
'server': local_matrix_url,
'server_name': local_matrix_url.netloc,
'available_servers': [],
'private_rooms': private_rooms,
},
},
},
)
config_copy = App.DEFAULT_CONFIG.copy()
config_copy.update(config)
registry = blockchain.token_network_registry(
token_network_registry_address)
secret_registry = blockchain.secret_registry(secret_registry_address)
service_registry = None
if service_registry_address:
service_registry = blockchain.service_registry(
service_registry_address)
user_deposit = None
if user_deposit_address:
user_deposit = blockchain.user_deposit(user_deposit_address)
if use_matrix:
transport = MatrixTransport(config['transport']['matrix'])
else:
throttle_policy = TokenBucket(
config['transport']['udp']['throttle_capacity'],
config['transport']['udp']['throttle_fill_rate'],
)
transport = UDPTransport(
address,
discovery,
server._udp_socket((host, port)), # pylint: disable=protected-access
throttle_policy,
config['transport']['udp'],
)
raiden_event_handler = RaidenEventHandler()
message_handler = WaitForMessage()
app = App(
config=config_copy,
chain=blockchain,
query_start_block=0,
default_registry=registry,
default_secret_registry=secret_registry,
default_service_registry=service_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=discovery,
user_deposit=user_deposit,
)
apps.append(app)
return apps
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,
[],
)
def test_lock_expiry(raiden_network, token_addresses, deposit):
"""Test lock expiry and removal."""
alice_app, bob_app = raiden_network
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(alice_app),
alice_app.raiden.default_registry.address,
token_address,
)
hold_event_handler = HoldOffChainSecretRequest()
wait_message_handler = WaitForMessage()
bob_app.raiden.message_handler = wait_message_handler
bob_app.raiden.raiden_event_handler = hold_event_handler
token_network = views.get_token_network_by_identifier(
views.state_from_app(alice_app),
token_network_identifier,
)
channel_state = get_channelstate(alice_app, bob_app,
token_network_identifier)
channel_identifier = channel_state.identifier
assert channel_identifier in token_network.partneraddresses_to_channelidentifiers[
bob_app.raiden.address]
alice_to_bob_amount = 10
identifier = 1
target = bob_app.raiden.address
transfer_1_secret = factories.make_secret(0)
transfer_1_secrethash = sha3(transfer_1_secret)
transfer_2_secret = factories.make_secret(1)
transfer_2_secrethash = sha3(transfer_2_secret)
hold_event_handler.hold_secretrequest_for(secrethash=transfer_1_secrethash)
transfer1_received = wait_message_handler.wait_for_message(
LockedTransfer,
{'lock': {
'secrethash': transfer_1_secrethash
}},
)
transfer2_received = wait_message_handler.wait_for_message(
LockedTransfer,
{'lock': {
'secrethash': transfer_2_secrethash
}},
)
remove_expired_lock_received = wait_message_handler.wait_for_message(
LockExpired,
{'secrethash': transfer_1_secrethash},
)
alice_app.raiden.start_mediated_transfer_with_secret(
token_network_identifier,
alice_to_bob_amount,
target,
identifier,
transfer_1_secret,
)
transfer1_received.wait()
alice_bob_channel_state = get_channelstate(alice_app, bob_app,
token_network_identifier)
lock = channel.get_lock(alice_bob_channel_state.our_state,
transfer_1_secrethash)
# This is the current state of the protocol:
#
# A -> B LockedTransfer
# B -> A SecretRequest
# - protocol didn't continue
assert_synced_channel_state(
token_network_identifier,
alice_app,
deposit,
[lock],
bob_app,
deposit,
[],
)
# Verify lock is registered in both channel states
alice_channel_state = get_channelstate(alice_app, bob_app,
token_network_identifier)
assert transfer_1_secrethash in alice_channel_state.our_state.secrethashes_to_lockedlocks
bob_channel_state = get_channelstate(bob_app, alice_app,
token_network_identifier)
assert transfer_1_secrethash in bob_channel_state.partner_state.secrethashes_to_lockedlocks
alice_chain_state = views.state_from_raiden(alice_app.raiden)
assert transfer_1_secrethash in alice_chain_state.payment_mapping.secrethashes_to_task
remove_expired_lock_received.wait()
alice_channel_state = get_channelstate(alice_app, bob_app,
token_network_identifier)
assert transfer_1_secrethash not in alice_channel_state.our_state.secrethashes_to_lockedlocks
# Verify Bob received the message and processed the LockExpired message
bob_channel_state = get_channelstate(bob_app, alice_app,
token_network_identifier)
assert transfer_1_secrethash not in bob_channel_state.partner_state.secrethashes_to_lockedlocks
alice_chain_state = views.state_from_raiden(alice_app.raiden)
assert transfer_1_secrethash not in alice_chain_state.payment_mapping.secrethashes_to_task
# Make another transfer
alice_to_bob_amount = 10
identifier = 2
hold_event_handler.hold_secretrequest_for(secrethash=transfer_2_secrethash)
alice_app.raiden.start_mediated_transfer_with_secret(
token_network_identifier,
alice_to_bob_amount,
target,
identifier,
transfer_2_secret,
)
transfer2_received.wait()
# Make sure the other transfer still exists
alice_chain_state = views.state_from_raiden(alice_app.raiden)
assert transfer_2_secrethash in alice_chain_state.payment_mapping.secrethashes_to_task
bob_channel_state = get_channelstate(bob_app, alice_app,
token_network_identifier)
assert transfer_2_secrethash in bob_channel_state.partner_state.secrethashes_to_lockedlocks
def test_mediated_transfer_messages_out_of_order( # pylint: disable=unused-argument
raiden_network, deposit, token_addresses, network_wait):
"""Raiden must properly handle repeated locked transfer messages."""
app0, app1, app2 = raiden_network
app1_wait_for_message = WaitForMessage()
app2_wait_for_message = WaitForMessage()
app1.raiden.message_handler = app1_wait_for_message
app2.raiden.message_handler = app2_wait_for_message
secret = factories.make_secret(0)
secrethash = sha256_secrethash(secret)
# Save the messages, these will be processed again
app1_mediatedtransfer = app1_wait_for_message.wait_for_message(
LockedTransfer, {"lock": {
"secrethash": secrethash
}})
app2_mediatedtransfer = app2_wait_for_message.wait_for_message(
LockedTransfer, {"lock": {
"secrethash": secrethash
}})
# Wait until the node receives a reveal secret to redispatch the locked
# transfer message
app1_revealsecret = app1_wait_for_message.wait_for_message(
RevealSecret, {"secret": secret})
app2_revealsecret = app2_wait_for_message.wait_for_message(
RevealSecret, {"secret": secret})
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)
amount = 10
identifier = 1
transfer_received = app0.raiden.start_mediated_transfer_with_secret(
token_network_address=token_network_address,
amount=amount,
target=app2.raiden.address,
identifier=identifier,
secret=secret,
)
# - Wait until reveal secret is received to replay the message
# - The secret is revealed backwards, app2 should be first
# - The locked transfer is sent before the secret reveal, so the mediated
# transfers async results must be set and `get_nowait` can be used
app2_revealsecret.get(timeout=network_wait)
mediated_transfer_msg = app2_mediatedtransfer.get_nowait()
app2.raiden.message_handler.handle_message_lockedtransfer(
app2.raiden, mediated_transfer_msg)
app1_revealsecret.get(timeout=network_wait)
app1.raiden.message_handler.handle_message_lockedtransfer(
app1.raiden, app1_mediatedtransfer.get_nowait())
transfer_received.payment_done.wait()
with block_timeout_for_transfer_by_secrethash(app1.raiden, secrethash):
wait_assert(
assert_succeeding_transfer_invariants,
token_network_address,
app0,
deposit - amount,
[],
app1,
deposit + amount,
[],
)
with block_timeout_for_transfer_by_secrethash(app2.raiden, secrethash):
wait_assert(
assert_succeeding_transfer_invariants,
token_network_address,
app1,
deposit - amount,
[],
app2,
deposit + amount,
[],
)
def run_test_mediated_transfer_with_node_consuming_more_than_allocated_fee(
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)
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)
fee = 5
amount = 10
app1_app2_channel_state = views.get_channelstate_by_token_network_and_partner(
chain_state=views.state_from_raiden(app1.raiden),
token_network_id=token_network_identifier,
partner_address=app2.raiden.address,
)
# Let app1 consume all of the allocated mediation fee
action_set_fee = ActionChannelSetFee(
canonical_identifier=app1_app2_channel_state.canonical_identifier,
mediation_fee=fee * 2)
app1.raiden.handle_state_change(state_change=action_set_fee)
secret = factories.make_secret(0)
secrethash = sha3(secret)
wait_message_handler = WaitForMessage()
app0.raiden.message_handler = wait_message_handler
secret_request_received = wait_message_handler.wait_for_message(
SecretRequest, {"secrethash": secrethash})
app0.raiden.start_mediated_transfer_with_secret(
token_network_identifier=token_network_identifier,
amount=amount,
fee=fee,
target=app2.raiden.address,
identifier=1,
payment_hash_invoice=EMPTY_PAYMENT_HASH_INVOICE,
secret=secret,
)
app0_app1_channel_state = views.get_channelstate_by_token_network_and_partner(
chain_state=views.state_from_raiden(app0.raiden),
token_network_id=token_network_identifier,
partner_address=app1.raiden.address,
)
msg = "App0 should have the transfer in secrethashes_to_lockedlocks"
assert secrethash in app0_app1_channel_state.our_state.secrethashes_to_lockedlocks, msg
msg = "App0 should have locked the amount + fee"
lock_amount = app0_app1_channel_state.our_state.secrethashes_to_lockedlocks[
secrethash].amount
assert lock_amount == amount + fee, msg
secret_request_received.wait()
app0_chain_state = views.state_from_app(app0)
initiator_task = app0_chain_state.payment_mapping.secrethashes_to_task[
secrethash]
msg = "App0 should have never revealed the secret"
assert initiator_task.manager_state.initiator_transfers[
secrethash].revealsecret is None
def run_test_mediated_transfer_messages_out_of_order(raiden_network, deposit,
token_addresses,
network_wait):
"""Raiden must properly handle repeated locked transfer messages."""
app0, app1, app2 = raiden_network
app1_wait_for_message = WaitForMessage()
app2_wait_for_message = WaitForMessage()
app1.raiden.message_handler = app1_wait_for_message
app2.raiden.message_handler = app2_wait_for_message
secret = factories.make_secret(0)
secrethash = sha3(secret)
# Save the messages, these will be processed again
app1_mediatedtransfer = app1_wait_for_message.wait_for_message(
LockedTransfer, {"lock": {
"secrethash": secrethash
}})
app2_mediatedtransfer = app2_wait_for_message.wait_for_message(
LockedTransfer, {"lock": {
"secrethash": secrethash
}})
# Wait until the node receives a reveal secret to redispatch the locked
# transfer message
app1_revealsecret = app1_wait_for_message.wait_for_message(
RevealSecret, {"secret": secret})
app2_revealsecret = app2_wait_for_message.wait_for_message(
RevealSecret, {"secret": secret})
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)
amount = 10
identifier = 1
transfer_received = app0.raiden.start_mediated_transfer_with_secret(
token_network_identifier=token_network_identifier,
amount=amount,
fee=0,
target=app2.raiden.address,
identifier=identifier,
payment_hash_invoice=EMPTY_PAYMENT_HASH_INVOICE,
secret=secret,
)
# - Wait until reveal secret is received to replay the message
# - The secret is revealed backwards, app2 should be first
# - The locked transfer is sent before the secret reveal, so the mediated
# transfers async results must be set and `get_nowait` can be used
app2_revealsecret.get(timeout=network_wait)
mediated_transfer_msg = app2_mediatedtransfer.get_nowait()
app2.raiden.message_handler.handle_message_lockedtransfer(
app2.raiden, mediated_transfer_msg)
app1_revealsecret.get(timeout=network_wait)
app1.raiden.message_handler.handle_message_lockedtransfer(
app1.raiden, app1_mediatedtransfer.get_nowait())
transfer_received.payment_done.wait()
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_identifier,
app0,
deposit - amount,
[],
app1,
deposit + amount,
[],
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_identifier,
app1,
deposit - amount,
[],
app2,
deposit + amount,
[],
)
def create_apps(
chain_id: ChainID,
contracts_path: Path,
blockchain_services: BlockchainServices,
token_network_registry_address: TokenNetworkRegistryAddress,
one_to_n_address: Optional[OneToNAddress],
secret_registry_address: SecretRegistryAddress,
service_registry_address: Optional[ServiceRegistryAddress],
user_deposit_address: Optional[UserDepositAddress],
monitoring_service_contract_address: MonitoringServiceAddress,
reveal_timeout: BlockTimeout,
settle_timeout: BlockTimeout,
database_basedir: str,
retry_interval_initial: float,
retry_interval_max: float,
retries_before_backoff: int,
environment_type: Environment,
unrecoverable_error_should_crash: bool,
local_matrix_url: Optional[ParsedURL],
broadcast_rooms: List[str],
routing_mode: RoutingMode,
blockchain_query_interval: float,
resolver_ports: List[Optional[int]],
enable_rest_api: bool,
port_generator: Iterator[Port],
capabilities_config: CapabilitiesConfig,
) -> List[App]:
""" Create the apps."""
# pylint: disable=too-many-locals
services = blockchain_services
apps = []
for idx, proxy_manager in enumerate(services):
database_path = database_from_privatekey(base_dir=database_basedir,
app_number=idx)
assert len(resolver_ports) > idx
resolver_port = resolver_ports[idx]
config = RaidenConfig(
chain_id=chain_id,
environment_type=environment_type,
unrecoverable_error_should_crash=unrecoverable_error_should_crash,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
contracts_path=contracts_path,
database_path=database_path,
blockchain=BlockchainConfig(
confirmation_blocks=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
query_interval=blockchain_query_interval,
),
mediation_fees=MediationFeeConfig(),
services=ServiceConfig(monitoring_enabled=False),
rest_api=RestApiConfig(rest_api_enabled=enable_rest_api,
host=Host("localhost"),
port=next(port_generator)),
console=False,
transport_type="matrix",
)
config.transport.capabilities_config = capabilities_config
if local_matrix_url is not None:
config.transport = MatrixTransportConfig(
broadcast_rooms=broadcast_rooms,
retries_before_backoff=retries_before_backoff,
retry_interval_initial=retry_interval_initial,
retry_interval_max=retry_interval_max,
server=local_matrix_url,
available_servers=[],
capabilities_config=capabilities_config,
)
assert config.transport.capabilities_config is not None
if resolver_port is not None:
config.resolver_endpoint = f"http://localhost:{resolver_port}"
registry = proxy_manager.token_network_registry(
token_network_registry_address, block_identifier=BLOCK_ID_LATEST)
secret_registry = proxy_manager.secret_registry(
secret_registry_address, block_identifier=BLOCK_ID_LATEST)
service_registry = None
if service_registry_address:
service_registry = proxy_manager.service_registry(
service_registry_address, block_identifier=BLOCK_ID_LATEST)
user_deposit = None
if user_deposit_address:
user_deposit = proxy_manager.user_deposit(
user_deposit_address, block_identifier=BLOCK_ID_LATEST)
# Use `TestMatrixTransport` that saves sent messages for assertions in tests
assert config.transport.capabilities_config is not None
transport = TestMatrixTransport(config=config.transport,
environment=environment_type)
raiden_event_handler = RaidenEventHandler()
hold_handler = HoldRaidenEventHandler(raiden_event_handler)
message_handler = WaitForMessage()
api_server = None
if enable_rest_api:
api_server = start_api_server(rpc_client=proxy_manager.client,
config=config.rest_api,
eth_rpc_endpoint="bla")
app = App(
config=config,
rpc_client=proxy_manager.client,
proxy_manager=proxy_manager,
query_start_block=BlockNumber(0),
default_registry=registry,
default_secret_registry=secret_registry,
default_service_registry=service_registry,
default_user_deposit=user_deposit,
default_one_to_n_address=one_to_n_address,
default_msc_address=monitoring_service_contract_address,
transport=transport,
raiden_event_handler=hold_handler,
message_handler=message_handler,
routing_mode=routing_mode,
api_server=api_server,
)
apps.append(app)
return apps
def create_apps(
chain_id,
contracts_path,
blockchain_services,
endpoint_discovery_services,
token_network_registry_address,
one_to_n_address: Optional[Address],
secret_registry_address,
service_registry_address,
user_deposit_address,
raiden_udp_ports,
reveal_timeout,
settle_timeout,
database_basedir,
retry_interval,
retries_before_backoff,
throttle_capacity,
throttle_fill_rate,
nat_invitation_timeout,
nat_keepalive_retries,
nat_keepalive_timeout,
environment_type,
unrecoverable_error_should_crash,
local_matrix_url=None,
private_rooms=None,
global_rooms=None,
):
""" Create the apps."""
# pylint: disable=too-many-locals
services = zip(blockchain_services, endpoint_discovery_services, raiden_udp_ports)
apps = []
for idx, (blockchain, discovery, port) in enumerate(services):
address = blockchain.client.address
host = "127.0.0.1"
database_path = database_from_privatekey(base_dir=database_basedir, app_number=idx)
config = {
"chain_id": chain_id,
"environment_type": environment_type,
"unrecoverable_error_should_crash": unrecoverable_error_should_crash,
"reveal_timeout": reveal_timeout,
"settle_timeout": settle_timeout,
"contracts_path": contracts_path,
"database_path": database_path,
"blockchain": {"confirmation_blocks": DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS},
"transport": {
"udp": {
"external_ip": host,
"external_port": port,
"host": host,
"nat_invitation_timeout": nat_invitation_timeout,
"nat_keepalive_retries": nat_keepalive_retries,
"nat_keepalive_timeout": nat_keepalive_timeout,
"port": port,
"retries_before_backoff": retries_before_backoff,
"retry_interval": retry_interval,
"throttle_capacity": throttle_capacity,
"throttle_fill_rate": throttle_fill_rate,
}
},
"rpc": True,
"console": False,
}
use_matrix = local_matrix_url is not None
if use_matrix:
merge_dict(
config,
{
"transport_type": "matrix",
"transport": {
"matrix": {
"global_rooms": global_rooms,
"retries_before_backoff": retries_before_backoff,
"retry_interval": retry_interval,
"server": local_matrix_url,
"server_name": local_matrix_url.netloc,
"available_servers": [],
"private_rooms": private_rooms,
}
},
},
)
config_copy = deepcopy(App.DEFAULT_CONFIG)
config_copy.update(config)
registry = blockchain.token_network_registry(token_network_registry_address)
secret_registry = blockchain.secret_registry(secret_registry_address)
service_registry = None
if service_registry_address:
service_registry = blockchain.service_registry(service_registry_address)
user_deposit = None
if user_deposit_address:
user_deposit = blockchain.user_deposit(user_deposit_address)
if use_matrix:
transport = MatrixTransport(config["transport"]["matrix"])
else:
throttle_policy = TokenBucket(
config["transport"]["udp"]["throttle_capacity"],
config["transport"]["udp"]["throttle_fill_rate"],
)
transport = UDPTransport(
address,
discovery,
server._udp_socket((host, port)), # pylint: disable=protected-access
throttle_policy,
config["transport"]["udp"],
)
raiden_event_handler = RaidenEventHandler()
hold_handler = HoldRaidenEventHandler(raiden_event_handler)
message_handler = WaitForMessage()
app = App(
config=config_copy,
chain=blockchain,
query_start_block=BlockNumber(0),
default_registry=registry,
default_one_to_n_address=one_to_n_address,
default_secret_registry=secret_registry,
default_service_registry=service_registry,
transport=transport,
raiden_event_handler=hold_handler,
message_handler=message_handler,
discovery=discovery,
user_deposit=user_deposit,
)
apps.append(app)
return apps
def test_mediated_transfer_with_node_consuming_more_than_allocated_fee(
raiden_network, number_of_nodes, deposit, token_addresses,
network_wait):
"""
Tests a mediator node consuming more fees than allocated.
Which means that the initiator will not reveal the secret
to the target.
"""
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
amount = PaymentAmount(100)
fee = FeeAmount(5)
fee_margin = calculate_fee_margin(amount, fee)
app1_app2_channel_state = views.get_channelstate_by_token_network_and_partner(
chain_state=views.state_from_raiden(app1.raiden),
token_network_address=token_network_address,
partner_address=app2.raiden.address,
)
assert app1_app2_channel_state
# Let app1 consume all of the allocated mediation fee
app1_app2_channel_state.fee_schedule = FeeScheduleState(
flat=FeeAmount(fee * 2))
secret = factories.make_secret(0)
secrethash = sha256_secrethash(secret)
wait_message_handler = WaitForMessage()
app0.raiden.message_handler = wait_message_handler
secret_request_received = wait_message_handler.wait_for_message(
SecretRequest, {"secrethash": secrethash})
def get_best_routes_with_fees(*args, **kwargs):
routes = get_best_routes_internal(*args, **kwargs)
for r in routes:
r.estimated_fee = fee
return routes
with patch("raiden.routing.get_best_routes_internal",
get_best_routes_with_fees):
app0.raiden.start_mediated_transfer_with_secret(
token_network_address=token_network_address,
amount=amount,
target=app2.raiden.address,
identifier=1,
secret=secret,
)
app0_app1_channel_state = views.get_channelstate_by_token_network_and_partner(
chain_state=views.state_from_raiden(app0.raiden),
token_network_address=token_network_address,
partner_address=app1.raiden.address,
)
assert app0_app1_channel_state
msg = "App0 should have the transfer in secrethashes_to_lockedlocks"
assert secrethash in app0_app1_channel_state.our_state.secrethashes_to_lockedlocks, msg
msg = "App0 should have locked the amount + fee"
lock_amount = app0_app1_channel_state.our_state.secrethashes_to_lockedlocks[
secrethash].amount
assert lock_amount == amount + fee + fee_margin, msg
secret_request_received.wait()
app0_chain_state = views.state_from_app(app0)
initiator_task = cast(
InitiatorTask,
app0_chain_state.payment_mapping.secrethashes_to_task[secrethash])
msg = "App0 should have never revealed the secret"
transfer_state = initiator_task.manager_state.initiator_transfers[
secrethash].transfer_state
assert transfer_state != "transfer_secret_revealed", msg
def create_apps(
chain_id: ChainID,
contracts_path: str,
blockchain_services: BlockchainServices,
token_network_registry_address: TokenNetworkRegistryAddress,
one_to_n_address: Optional[Address],
secret_registry_address: SecretRegistryAddress,
service_registry_address: Optional[Address],
user_deposit_address: Address,
monitoring_service_contract_address: Address,
reveal_timeout: BlockTimeout,
settle_timeout: BlockTimeout,
database_basedir: str,
retry_interval: float,
retries_before_backoff: int,
environment_type: Environment,
unrecoverable_error_should_crash: bool,
local_matrix_url: Optional[ParsedURL],
broadcast_rooms: List[str],
routing_mode: RoutingMode,
blockchain_query_interval: float,
resolver_ports: List[Optional[int]],
) -> List[App]:
""" Create the apps."""
# pylint: disable=too-many-locals
services = blockchain_services
apps = []
for idx, proxy_manager in enumerate(services):
database_path = database_from_privatekey(base_dir=database_basedir,
app_number=idx)
assert len(resolver_ports) > idx
resolver_port = resolver_ports[idx]
config = {
"chain_id": chain_id,
"environment_type": environment_type,
"unrecoverable_error_should_crash":
unrecoverable_error_should_crash,
"reveal_timeout": reveal_timeout,
"settle_timeout": settle_timeout,
"contracts_path": contracts_path,
"database_path": database_path,
"blockchain": {
"confirmation_blocks": DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
"query_interval": blockchain_query_interval,
},
"transport": {},
"rpc": True,
"console": False,
"mediation_fees": MediationFeeConfig(),
}
if local_matrix_url is not None:
merge_dict(
config,
{
"transport_type": "matrix",
"transport": {
"matrix": {
"broadcast_rooms": broadcast_rooms,
"retries_before_backoff": retries_before_backoff,
"retry_interval": retry_interval,
"server": local_matrix_url,
"server_name": local_matrix_url.netloc,
"available_servers": [],
}
},
},
)
if resolver_port is not None:
merge_dict(config, {
"resolver_endpoint":
"http://localhost:" + str(resolver_port)
})
config_copy = deepcopy(App.DEFAULT_CONFIG)
config_copy.update(config)
registry = proxy_manager.token_network_registry(
token_network_registry_address)
secret_registry = proxy_manager.secret_registry(
secret_registry_address)
service_registry = None
if service_registry_address:
service_registry = proxy_manager.service_registry(
service_registry_address)
user_deposit = None
if user_deposit_address:
user_deposit = proxy_manager.user_deposit(user_deposit_address)
transport = MatrixTransport(config["transport"]["matrix"])
raiden_event_handler = RaidenEventHandler()
hold_handler = HoldRaidenEventHandler(raiden_event_handler)
message_handler = WaitForMessage()
app = App(
config=config_copy,
rpc_client=proxy_manager.client,
proxy_manager=proxy_manager,
query_start_block=BlockNumber(0),
default_registry=registry,
default_one_to_n_address=one_to_n_address,
default_secret_registry=secret_registry,
default_service_registry=service_registry,
default_msc_address=monitoring_service_contract_address,
transport=transport,
raiden_event_handler=hold_handler,
message_handler=message_handler,
user_deposit=user_deposit,
routing_mode=routing_mode,
)
apps.append(app)
return apps
