def run_test_receive_lockedtransfer_invalidnonce(raiden_network,
number_of_nodes, deposit,
token_addresses,
reveal_timeout, network_wait):
app0, app1, app2 = raiden_network
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)
channel0 = get_channelstate(app0, app1, token_network_identifier)
amount = 10
transfer(
initiator_app=app0,
target_app=app2,
token_address=token_address,
amount=amount,
identifier=1,
timeout=network_wait * number_of_nodes,
)
amount = 10
payment_identifier = 1
repeated_nonce = 1
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=payment_identifier,
payment_hash_invoice=EMPTY_PAYMENT_HASH_INVOICE,
nonce=repeated_nonce,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=amount,
locked_amount=amount,
recipient=app1.raiden.address,
locksroot=UNIT_SECRETHASH,
lock=Lock(amount=amount,
expiration=expiration,
secrethash=UNIT_SECRETHASH),
target=app2.raiden.address,
initiator=app0.raiden.address,
fee=0,
)
sign_and_inject(mediated_transfer_message, app0.raiden.signer, app1)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_identifier,
app0,
deposit - amount,
[],
app1,
deposit + amount,
[],
)
def test_receive_lockedtransfer_invalidnonce(raiden_network, number_of_nodes,
deposit, token_addresses,
reveal_timeout, network_wait):
app0, app1, app2 = raiden_network
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)
assert token_network_address
channel0 = get_channelstate(app0, app1, token_network_address)
amount = 10
payment_identifier = PaymentID(1)
secrethash = transfer(
initiator_app=app0,
target_app=app2,
token_address=token_address,
amount=PaymentAmount(10),
identifier=payment_identifier,
timeout=network_wait * number_of_nodes,
)
repeated_nonce = Nonce(1)
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=make_message_identifier(),
payment_identifier=payment_identifier,
nonce=repeated_nonce,
token_network_address=token_network_address,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=TokenAmount(amount),
locked_amount=TokenAmount(amount),
recipient=app1.raiden.address,
locksroot=make_locksroot(),
lock=Lock(amount=PaymentWithFeeAmount(amount),
expiration=expiration,
secrethash=UNIT_SECRETHASH),
target=app2.raiden.address,
initiator=app0.raiden.address,
signature=EMPTY_SIGNATURE,
metadata=Metadata(routes=[
RouteMetadata(route=[app1.raiden.address, app2.raiden.address])
]),
)
sign_and_inject(mediated_transfer_message, app0.raiden.signer, app1)
with block_timeout_for_transfer_by_secrethash(app1.raiden, secrethash):
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit - amount,
[],
app1,
deposit + amount,
[],
)
def test_receive_directtransfer_invalidnonce(raiden_network, deposit,
token_addresses):
app0, app1 = raiden_network
registry_address = app0.raiden.default_registry.address
token_address = token_addresses[0]
channel0 = get_channelstate(app0, app1, token_address)
transferred_amount = 10
same_payment_identifier = 1
message_identifier = random.randint(0, UINT64_MAX)
event = channel.send_directtransfer(
registry_address,
channel0,
transferred_amount,
message_identifier,
same_payment_identifier,
)
direct_transfer_message = DirectTransfer.from_event(event)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
# Send a *different* direct transfer with the *same nonce*
invalid_transferred_amount = transferred_amount // 2
message_identifier = random.randint(0, UINT64_MAX)
invalid_direct_transfer_message = DirectTransfer(
message_identifier=message_identifier,
payment_identifier=same_payment_identifier,
nonce=1,
registry_address=registry_address,
token=token_address,
channel=channel0.identifier,
transferred_amount=invalid_transferred_amount,
recipient=app1.raiden.address,
locksroot=EMPTY_MERKLE_ROOT,
)
sign_and_inject(
invalid_direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synched_channel_state(
token_address,
app0,
deposit - transferred_amount,
[],
app1,
deposit + transferred_amount,
[],
)
def test_receive_directtransfer_invalidsender(raiden_network, deposit,
token_addresses):
app0, app1 = raiden_network
registry = app0.raiden.default_registry.address
token_address = token_addresses[0]
other_key, other_address = make_privkey_address()
channel0 = get_channelstate(app0, app1, token_address)
channel_identifier = channel0.identifier
message_identifier = random.randint(0, UINT64_MAX)
direct_transfer_message = DirectTransfer(
message_identifier=message_identifier,
payment_identifier=1,
nonce=1,
registry_address=registry,
token=token_address,
channel=channel_identifier,
transferred_amount=10,
recipient=app0.raiden.address,
locksroot=EMPTY_MERKLE_ROOT,
)
sign_and_inject(
direct_transfer_message,
other_key,
other_address,
app0,
)
assert_synched_channel_state(token_address, app0, deposit, [], app1,
deposit, [])
def test_receive_directtransfer_invalidlocksroot(raiden_network,
token_addresses):
app0, app1 = raiden_network
token_address = token_addresses[0]
channel0 = get_channelstate(app0, app1, token_address)
balance0 = channel.get_balance(channel0.our_state, channel0.partner_state)
balance1 = channel.get_balance(channel0.partner_state, channel0.our_state)
payment_identifier = 1
invalid_locksroot = UNIT_SECRETHASH
channel_identifier = channel0.identifier
message_identifier = random.randint(0, UINT64_MAX)
direct_transfer_message = DirectTransfer(
message_identifier=message_identifier,
payment_identifier=payment_identifier,
nonce=1,
token=token_address,
channel=channel_identifier,
transferred_amount=0,
recipient=app1.raiden.address,
locksroot=invalid_locksroot,
)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synched_channel_state(token_address, app0, balance0, [], app1,
balance1, [])
def test_receive_directtransfer_invalidnonce(raiden_network, deposit, token_addresses):
app0, app1 = raiden_network
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,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
transferred_amount = 10
same_payment_identifier = 1
message_identifier = random.randint(0, UINT64_MAX)
event = channel.send_directtransfer(
channel0,
transferred_amount,
message_identifier,
same_payment_identifier,
)
direct_transfer_message = DirectTransfer.from_event(event)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
# Send a *different* direct transfer with the *same nonce*
invalid_transferred_amount = transferred_amount // 2
message_identifier = random.randint(0, UINT64_MAX)
invalid_direct_transfer_message = DirectTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=message_identifier,
payment_identifier=same_payment_identifier,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=invalid_transferred_amount,
locked_amount=0,
recipient=app1.raiden.address,
locksroot=EMPTY_MERKLE_ROOT,
)
sign_and_inject(
invalid_direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synched_channel_state(
token_network_identifier,
app0, deposit - transferred_amount, [],
app1, deposit + transferred_amount, [],
)
def test_receive_lockedtransfer_invalidnonce(
raiden_network,
deposit,
token_addresses,
reveal_timeout,
network_wait
):
app0, app1, app2 = raiden_network
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,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
amount = 10
mediated_transfer(
app0,
app2,
token_network_identifier,
amount,
timeout=network_wait,
)
amount = 10
payment_identifier = 1
repeated_nonce = 1
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=payment_identifier,
nonce=repeated_nonce,
token_network_address=token_network_identifier,
token=token_address,
channel=channel0.identifier,
transferred_amount=amount,
locked_amount=amount,
recipient=app1.raiden.address,
locksroot=UNIT_SECRETHASH,
lock=Lock(amount, expiration, UNIT_SECRETHASH),
target=app2.raiden.address,
initiator=app0.raiden.address,
fee=0,
)
sign_and_inject(
mediated_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synched_channel_state(
token_network_identifier,
app0, deposit - amount, [],
app1, deposit + amount, [],
)
def test_received_directtransfer_closedchannel(raiden_network, token_addresses,
deposit):
app0, app1 = raiden_network
token_address = token_addresses[0]
registry_address = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
registry_address,
token_address,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
RaidenAPI(app1.raiden).channel_close(
registry_address,
token_address,
app0.raiden.address,
)
wait_until_block(
app0.raiden.chain,
app0.raiden.chain.block_number() + 1,
)
# Now receive one direct transfer for the closed channel
message_identifier = random.randint(0, UINT64_MAX)
direct_transfer_message = DirectTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=message_identifier,
payment_identifier=1,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=10,
locked_amount=0,
recipient=app0.raiden.address,
locksroot=EMPTY_MERKLE_ROOT,
)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
# The local state must not change since the channel is already closed
assert_synched_channel_state(
token_network_identifier,
app0,
deposit,
[],
app1,
deposit,
[],
)
def test_received_lockedtransfer_closedchannel(raiden_network, reveal_timeout,
token_addresses, deposit):
app0, app1 = raiden_network
registry_address = app0.raiden.default_registry.address
token_address = token_addresses[0]
channel0 = get_channelstate(app0, app1, token_address)
RaidenAPI(app1.raiden).channel_close(
registry_address,
token_address,
app0.raiden.address,
)
wait_until_block(
app0.raiden.chain,
app0.raiden.chain.block_number() + 1,
)
# Now receive one mediated transfer for the closed channel
lock_amount = 10
payment_identifier = 1
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=payment_identifier,
nonce=1,
registry_address=app0.raiden.default_registry.address,
token=token_address,
channel=channel0.identifier,
transferred_amount=0,
locked_amount=lock_amount,
recipient=app1.raiden.address,
locksroot=UNIT_SECRETHASH,
lock=Lock(lock_amount, expiration, UNIT_SECRETHASH),
target=app1.raiden.address,
initiator=app0.raiden.address,
fee=0)
sign_and_inject(
mediated_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
# The local state must not change since the channel is already closed
assert_synched_channel_state(
token_address,
app0,
deposit,
[],
app1,
deposit,
[],
)
def test_receive_lockedtransfer_invalidrecipient(
raiden_network,
token_addresses,
reveal_timeout,
deposit,
):
app0, app1 = raiden_network
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,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
payment_identifier = 1
invalid_recipient = make_address()
lock_amount = 10
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=payment_identifier,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=0,
locked_amount=lock_amount,
recipient=invalid_recipient,
locksroot=UNIT_SECRETHASH,
lock=Lock(amount=lock_amount,
expiration=expiration,
secrethash=UNIT_SECRETHASH),
target=app1.raiden.address,
initiator=app0.raiden.address,
fee=0,
)
sign_and_inject(
mediated_transfer_message,
app0.raiden.signer,
app1,
)
assert_synced_channel_state(
token_network_identifier,
app0,
deposit,
[],
app1,
deposit,
[],
)
def test_receive_lockedtransfer_invalidsender(
raiden_network,
token_addresses,
deposit,
reveal_timeout,
):
app0, app1 = raiden_network
token_address = token_addresses[0]
other_key, other_address = make_privkey_address()
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
app0.raiden.default_registry.address,
token_address,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
lock_amount = 10
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=1,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel=channel0.identifier,
transferred_amount=0,
locked_amount=lock_amount,
recipient=app0.raiden.address,
locksroot=UNIT_SECRETHASH,
lock=Lock(lock_amount, expiration, UNIT_SECRETHASH),
target=app0.raiden.address,
initiator=other_address,
fee=0,
)
sign_and_inject(
mediated_transfer_message,
other_key,
other_address,
app0,
)
assert_synched_channel_state(
token_network_identifier,
app0,
deposit,
[],
app1,
deposit,
[],
)
def test_receive_mediatedtransfer_invalidnonce(raiden_network, deposit,
token_addresses, reveal_timeout,
network_wait):
app0, app1, app2 = raiden_network
token_address = token_addresses[0]
channel0 = get_channelstate(app0, app1, token_address)
amount = 10
mediated_transfer(
app0,
app2,
token_address,
amount,
timeout=network_wait,
)
amount = 10
identifier = 1
repeated_nonce = 1
expiration = reveal_timeout * 2
mediated_transfer_message = MediatedTransfer(
identifier=identifier,
nonce=repeated_nonce,
token=token_address,
channel=channel0.identifier,
transferred_amount=amount,
recipient=app1.raiden.address,
locksroot=UNIT_SECRETHASH,
lock=Lock(amount, expiration, UNIT_SECRETHASH),
target=app2.raiden.address,
initiator=app0.raiden.address,
fee=0,
)
sign_and_inject(
mediated_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synched_channel_state(
token_address,
app0,
deposit - amount,
[],
app1,
deposit + amount,
[],
)
def test_received_directtransfer_closedchannel(raiden_network, token_addresses, deposit):
app0, app1 = raiden_network
token_address = token_addresses[0]
registry_address = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
registry_address,
token_address,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
RaidenAPI(app1.raiden).channel_close(
registry_address,
token_address,
app0.raiden.address,
)
wait_until_block(
app0.raiden.chain,
app0.raiden.chain.block_number() + 1,
)
# Now receive one direct transfer for the closed channel
message_identifier = random.randint(0, UINT64_MAX)
direct_transfer_message = DirectTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=message_identifier,
payment_identifier=1,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=10,
locked_amount=0,
recipient=app0.raiden.address,
locksroot=EMPTY_MERKLE_ROOT,
)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
# The local state must not change since the channel is already closed
assert_synched_channel_state(
token_network_identifier,
app0, deposit, [],
app1, deposit, [],
)
def test_receive_hashlocktransfer_unknown(raiden_network, token_addresses):
app0 = raiden_network[0]
token_address = token_addresses[0]
other_key = HOP1_KEY
other_address = HOP1
amount = 10
refund_transfer_message = make_refund_transfer(
identifier=1,
nonce=1,
token=token_address,
channel=other_address,
transferred_amount=amount,
recipient=app0.raiden.address,
locksroot=UNIT_HASHLOCK,
amount=amount,
hashlock=UNIT_HASHLOCK,
)
sign_and_inject(refund_transfer_message, other_key, other_address, app0)
secret = Secret(
identifier=1,
nonce=1,
channel=make_address(),
transferred_amount=amount,
locksroot=UNIT_HASHLOCK,
secret=UNIT_SECRET,
)
sign_and_inject(secret, other_key, other_address, app0)
secret_request_message = SecretRequest(1, UNIT_HASHLOCK, 1)
sign_and_inject(secret_request_message, other_key, other_address, app0)
reveal_secret_message = RevealSecret(UNIT_SECRET)
sign_and_inject(reveal_secret_message, other_key, other_address, app0)
def test_receive_lockedtransfer_invalidrecipient(
raiden_network,
token_addresses,
reveal_timeout,
deposit,
):
app0, app1 = raiden_network
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,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
payment_identifier = 1
invalid_recipient = make_address()
lock_amount = 10
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=payment_identifier,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=0,
locked_amount=lock_amount,
recipient=invalid_recipient,
locksroot=UNIT_SECRETHASH,
lock=Lock(lock_amount, expiration, UNIT_SECRETHASH),
target=app1.raiden.address,
initiator=app0.raiden.address,
fee=0,
)
sign_and_inject(
mediated_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synced_channel_state(
token_network_identifier,
app0, deposit, [],
app1, deposit, [],
)
def test_receive_directtransfer_invalidlocksroot(raiden_network,
token_addresses):
app0, app1 = raiden_network
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,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
balance0 = channel.get_balance(channel0.our_state, channel0.partner_state)
balance1 = channel.get_balance(channel0.partner_state, channel0.our_state)
payment_identifier = 1
invalid_locksroot = UNIT_SECRETHASH
channel_identifier = channel0.identifier
message_identifier = random.randint(0, UINT64_MAX)
direct_transfer_message = DirectTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=message_identifier,
payment_identifier=payment_identifier,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel_identifier,
transferred_amount=0,
locked_amount=0,
recipient=app1.raiden.address,
locksroot=invalid_locksroot,
)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synced_channel_state(
token_network_identifier,
app0,
balance0,
[],
app1,
balance1,
[],
)
def test_received_lockedtransfer_closedchannel(raiden_network, reveal_timeout,
token_addresses, deposit):
app0, app1 = raiden_network
registry_address = app0.raiden.default_registry.address
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)
assert token_network_address
channel0 = get_channelstate(app0, app1, token_network_address)
RaidenAPI(app1.raiden).channel_close(registry_address, token_address,
app0.raiden.address)
app0.raiden.proxy_manager.wait_until_block(
target_block_number=app0.raiden.rpc_client.block_number() + 1)
# Now receive one mediated transfer for the closed channel
lock_amount = TokenAmount(10)
payment_identifier = PaymentID(1)
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=make_message_identifier(),
payment_identifier=payment_identifier,
nonce=Nonce(1),
token_network_address=token_network_address,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=TokenAmount(0),
locked_amount=lock_amount,
recipient=app1.raiden.address,
locksroot=make_locksroot(),
lock=Lock(
amount=PaymentWithFeeAmount(lock_amount),
expiration=expiration,
secrethash=UNIT_SECRETHASH,
),
target=app1.raiden.address,
initiator=app0.raiden.address,
signature=EMPTY_SIGNATURE,
metadata=Metadata(routes=[RouteMetadata(route=[app1.raiden.address])]),
)
sign_and_inject(mediated_transfer_message, app0.raiden.signer, app1)
# The local state must not change since the channel is already closed
assert_synced_channel_state(token_network_address, app0, deposit, [], app1,
deposit, [])
def run_test_received_lockedtransfer_closedchannel(raiden_network,
reveal_timeout,
token_addresses, deposit):
app0, app1 = raiden_network
registry_address = app0.raiden.default_registry.address
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)
channel0 = get_channelstate(app0, app1, token_network_identifier)
RaidenAPI(app1.raiden).channel_close(registry_address, token_address,
app0.raiden.address)
app0.raiden.chain.wait_until_block(
target_block_number=app0.raiden.chain.block_number() + 1)
# Now receive one mediated transfer for the closed channel
lock_amount = 10
payment_identifier = 1
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=payment_identifier,
payment_hash_invoice=EMPTY_PAYMENT_HASH_INVOICE,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=0,
locked_amount=lock_amount,
recipient=app1.raiden.address,
locksroot=UNIT_SECRETHASH,
lock=Lock(amount=lock_amount,
expiration=expiration,
secrethash=UNIT_SECRETHASH),
target=app1.raiden.address,
initiator=app0.raiden.address,
fee=0,
)
sign_and_inject(mediated_transfer_message, app0.raiden.signer, app1)
# The local state must not change since the channel is already closed
assert_synced_channel_state(token_network_identifier, app0, deposit, [],
app1, deposit, [])
def run_test_receive_secrethashtransfer_unknown(raiden_network,
token_addresses):
app0 = raiden_network[0]
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,
)
other_key = HOP1_KEY
other_signer = LocalSigner(other_key)
channel_identifier = make_channel_identifier()
amount = 10
refund_transfer_message = make_refund_transfer(
payment_identifier=1,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel_identifier,
transferred_amount=amount,
recipient=app0.raiden.address,
locksroot=UNIT_SECRETHASH,
amount=amount,
secrethash=UNIT_SECRETHASH,
)
sign_and_inject(refund_transfer_message, other_signer, app0)
unlock = Unlock(
chain_id=UNIT_CHAIN_ID,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=1,
nonce=1,
channel_identifier=channel_identifier,
token_network_address=token_network_identifier,
transferred_amount=amount,
locked_amount=0,
locksroot=UNIT_SECRETHASH,
secret=UNIT_SECRET,
)
sign_and_inject(unlock, other_signer, app0)
secret_request_message = SecretRequest(
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=1,
secrethash=UNIT_SECRETHASH,
amount=1,
expiration=refund_transfer_message.lock.expiration,
)
sign_and_inject(secret_request_message, other_signer, app0)
reveal_secret_message = RevealSecret(
message_identifier=random.randint(0, UINT64_MAX),
secret=UNIT_SECRET,
)
sign_and_inject(reveal_secret_message, other_signer, app0)
def test_receive_secrethashtransfer_unknown(raiden_network, token_addresses):
app0 = raiden_network[0]
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,
)
other_key = HOP1_KEY
other_address = HOP1
channel_identifier = make_channel_identifier()
amount = 10
refund_transfer_message = make_refund_transfer(
payment_identifier=1,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel_identifier,
transferred_amount=amount,
recipient=app0.raiden.address,
locksroot=UNIT_SECRETHASH,
amount=amount,
secrethash=UNIT_SECRETHASH,
)
sign_and_inject(refund_transfer_message, other_key, other_address, app0)
secret = Secret(
chain_id=UNIT_CHAIN_ID,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=1,
nonce=1,
channel_identifier=channel_identifier,
token_network_address=token_network_identifier,
transferred_amount=amount,
locked_amount=0,
locksroot=UNIT_SECRETHASH,
secret=UNIT_SECRET,
)
sign_and_inject(secret, other_key, other_address, app0)
secret_request_message = SecretRequest(
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=1,
secrethash=UNIT_SECRETHASH,
amount=1,
expiration=refund_transfer_message.lock.expiration,
)
sign_and_inject(secret_request_message, other_key, other_address, app0)
reveal_secret_message = RevealSecret(
message_identifier=random.randint(0, UINT64_MAX),
secret=UNIT_SECRET,
)
sign_and_inject(reveal_secret_message, other_key, other_address, app0)
def test_receive_directtransfer_invalidtoken(raiden_network, deposit,
token_addresses):
app0, app1 = raiden_network
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,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
message_identifier = random.randint(0, UINT64_MAX)
payment_identifier = 1
invalid_token_address = make_address()
channel_identifier = channel0.identifier
direct_transfer_message = DirectTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=message_identifier,
payment_identifier=payment_identifier,
nonce=1,
token_network_address=token_network_identifier,
token=invalid_token_address,
channel_identifier=channel_identifier,
transferred_amount=0,
locked_amount=0,
recipient=app1.raiden.address,
locksroot=EMPTY_MERKLE_ROOT,
)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synched_channel_state(
token_network_identifier,
app0,
deposit,
[],
app1,
deposit,
[],
)
def test_receive_directtransfer_invalidlocksroot(raiden_network, token_addresses):
app0, app1 = raiden_network
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,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
balance0 = channel.get_balance(channel0.our_state, channel0.partner_state)
balance1 = channel.get_balance(channel0.partner_state, channel0.our_state)
payment_identifier = 1
invalid_locksroot = UNIT_SECRETHASH
channel_identifier = channel0.identifier
message_identifier = random.randint(0, UINT64_MAX)
direct_transfer_message = DirectTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=message_identifier,
payment_identifier=payment_identifier,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel_identifier,
transferred_amount=0,
locked_amount=0,
recipient=app1.raiden.address,
locksroot=invalid_locksroot,
)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synched_channel_state(
token_network_identifier,
app0, balance0, [],
app1, balance1, [],
)
def test_receive_lockedtransfer_invalidrecipient(raiden_network,
token_addresses,
reveal_timeout, deposit):
app0, app1 = raiden_network
token_address = token_addresses[0]
channel0 = get_channelstate(app0, app1, token_address)
payment_identifier = 1
invalid_recipient = make_address()
lock_amount = 10
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=payment_identifier,
nonce=1,
registry_address=app0.raiden.default_registry.address,
token=token_address,
channel=channel0.identifier,
transferred_amount=0,
locked_amount=lock_amount,
recipient=invalid_recipient,
locksroot=UNIT_SECRETHASH,
lock=Lock(lock_amount, expiration, UNIT_SECRETHASH),
target=app1.raiden.address,
initiator=app0.raiden.address,
fee=0)
sign_and_inject(
mediated_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synched_channel_state(
token_address,
app0,
deposit,
[],
app1,
deposit,
[],
)
def test_received_directtransfer_closedchannel(raiden_network, token_addresses,
deposit):
app0, app1 = raiden_network
token_address = token_addresses[0]
channel0 = get_channelstate(app0, app1, token_address)
RaidenAPI(app1.raiden).channel_close(
token_address,
app0.raiden.address,
)
wait_until_block(
app0.raiden.chain,
app0.raiden.chain.block_number() + 1,
)
# Now receive one direct transfer for the closed channel
direct_transfer_message = DirectTransfer(
identifier=1,
nonce=1,
token=token_address,
channel=channel0.identifier,
transferred_amount=10,
recipient=app0.raiden.address,
locksroot=EMPTY_MERKLE_ROOT,
)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
# The local state must not change since the channel is already closed
assert_synched_channel_state(
token_address,
app0,
deposit,
[],
app1,
deposit,
[],
)
def test_receive_secrethashtransfer_unknown(raiden_network, token_addresses):
app0 = raiden_network[0]
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,
)
other_key = HOP1_KEY
other_address = HOP1
amount = 10
refund_transfer_message = make_refund_transfer(
payment_identifier=1,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel=other_address,
transferred_amount=amount,
recipient=app0.raiden.address,
locksroot=UNIT_SECRETHASH,
amount=amount,
secrethash=UNIT_SECRETHASH,
)
sign_and_inject(refund_transfer_message, other_key, other_address, app0)
secret = Secret(
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=1,
nonce=1,
channel=make_address(),
token_network_address=token_network_identifier,
transferred_amount=amount,
locked_amount=0,
locksroot=UNIT_SECRETHASH,
secret=UNIT_SECRET,
)
sign_and_inject(secret, other_key, other_address, app0)
secret_request_message = SecretRequest(
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=1,
secrethash=UNIT_SECRETHASH,
amount=1,
)
sign_and_inject(secret_request_message, other_key, other_address, app0)
reveal_secret_message = RevealSecret(
message_identifier=random.randint(0, UINT64_MAX),
secret=UNIT_SECRET,
)
sign_and_inject(reveal_secret_message, other_key, other_address, app0)
def test_receive_directtransfer_invalidtoken(raiden_network, deposit, token_addresses):
app0, app1 = raiden_network
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,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
message_identifier = random.randint(0, UINT64_MAX)
payment_identifier = 1
invalid_token_address = make_address()
channel_identifier = channel0.identifier
direct_transfer_message = DirectTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=message_identifier,
payment_identifier=payment_identifier,
nonce=1,
token_network_address=token_network_identifier,
token=invalid_token_address,
channel_identifier=channel_identifier,
transferred_amount=0,
locked_amount=0,
recipient=app1.raiden.address,
locksroot=EMPTY_MERKLE_ROOT,
)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synched_channel_state(
token_network_identifier,
app0, deposit, [],
app1, deposit, [],
)
def test_receive_lockedtransfer_invalidrecipient(raiden_network,
token_addresses,
reveal_timeout, deposit):
app0, app1 = raiden_network
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)
assert token_network_address
channel0 = get_channelstate(app0, app1, token_network_address)
payment_identifier = PaymentID(1)
invalid_recipient = make_address()
lock_amount = TokenAmount(10)
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=make_message_identifier(),
payment_identifier=payment_identifier,
nonce=Nonce(1),
token_network_address=token_network_address,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=TokenAmount(0),
locked_amount=lock_amount,
recipient=invalid_recipient,
locksroot=make_locksroot(),
lock=Lock(
amount=PaymentWithFeeAmount(lock_amount),
expiration=expiration,
secrethash=UNIT_SECRETHASH,
),
target=app1.raiden.address,
initiator=app0.raiden.address,
signature=EMPTY_SIGNATURE,
metadata=Metadata(routes=[RouteMetadata(route=[app1.raiden.address])]),
)
sign_and_inject(mediated_transfer_message, app0.raiden.signer, app1)
assert_synced_channel_state(token_network_address, app0, deposit, [], app1,
deposit, [])
def test_receive_mediatedtransfer_invalidsender(raiden_network,
token_addresses, deposit,
reveal_timeout):
app0, app1 = raiden_network
token_address = token_addresses[0]
other_key, other_address = make_privkey_address()
channel0 = get_channelstate(app0, app1, token_address)
amount = 10
expiration = reveal_timeout * 2
mediated_transfer_message = MediatedTransfer(identifier=1,
nonce=1,
token=token_address,
channel=channel0.identifier,
transferred_amount=0,
recipient=app0.raiden.address,
locksroot=UNIT_SECRETHASH,
lock=Lock(
amount, expiration,
UNIT_SECRETHASH),
target=app0.raiden.address,
initiator=other_address,
fee=0)
sign_and_inject(
mediated_transfer_message,
other_key,
other_address,
app0,
)
assert_synched_channel_state(
token_address,
app0,
deposit,
[],
app1,
deposit,
[],
)
def test_receive_lockedtransfer_invalidsender(
raiden_network: List[RaidenService], token_addresses, deposit, reveal_timeout
):
app0, app1 = raiden_network
token_address = token_addresses[0]
other_key, other_address = make_privkey_address()
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_raiden(app0), app0.default_registry.address, token_address
)
assert token_network_address
channel0 = get_channelstate(app0, app1, token_network_address)
lock_amount = LockedAmount(10)
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=make_message_identifier(),
payment_identifier=PaymentID(1),
nonce=Nonce(1),
token_network_address=token_network_address,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=TokenAmount(0),
locked_amount=lock_amount,
recipient=app0.address,
locksroot=make_locksroot(),
lock=Lock(
amount=PaymentWithFeeAmount(lock_amount),
expiration=expiration,
secrethash=UNIT_SECRETHASH,
),
target=TargetAddress(app0.address),
initiator=InitiatorAddress(other_address),
signature=EMPTY_SIGNATURE,
metadata=Metadata(routes=[RouteMetadata(route=[app0.address])]),
)
sign_and_inject(mediated_transfer_message, LocalSigner(other_key), app0)
assert_synced_channel_state(token_network_address, app0, deposit, [], app1, deposit, [])
def run_test_receive_lockedtransfer_invalidsender(raiden_network,
token_addresses, deposit,
reveal_timeout):
app0, app1 = raiden_network
token_address = token_addresses[0]
other_key, other_address = make_privkey_address()
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0), app0.raiden.default_registry.address,
token_address)
channel0 = get_channelstate(app0, app1, token_network_identifier)
lock_amount = 10
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=1,
payment_hash_invoice=EMPTY_PAYMENT_HASH_INVOICE,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=0,
locked_amount=lock_amount,
recipient=app0.raiden.address,
locksroot=UNIT_SECRETHASH,
lock=Lock(amount=lock_amount,
expiration=expiration,
secrethash=UNIT_SECRETHASH),
target=app0.raiden.address,
initiator=other_address,
fee=0,
)
sign_and_inject(mediated_transfer_message, LocalSigner(other_key), app0)
assert_synced_channel_state(token_network_identifier, app0, deposit, [],
app1, deposit, [])
def test_receive_directtransfer_invalidtoken(raiden_network, deposit,
token_addresses):
app0, app1 = raiden_network
token_address = token_addresses[0]
channel0 = get_channelstate(app0, app1, token_address)
message_identifier = random.randint(0, UINT64_MAX)
payment_identifier = 1
invalid_token_address = make_address()
channel_identifier = channel0.identifier
direct_transfer_message = DirectTransfer(
message_identifier=message_identifier,
payment_identifier=payment_identifier,
nonce=1,
token=invalid_token_address,
channel=channel_identifier,
transferred_amount=0,
recipient=app1.raiden.address,
locksroot=EMPTY_MERKLE_ROOT,
)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synched_channel_state(
token_address,
app0,
deposit,
[],
app1,
deposit,
[],
)
def test_receive_lockedtransfer_invalidnonce(
raiden_network,
number_of_nodes,
deposit,
token_addresses,
reveal_timeout,
network_wait,
):
app0, app1, app2 = raiden_network
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,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
amount = 10
mediated_transfer(
app0,
app2,
token_network_identifier,
amount,
timeout=network_wait * number_of_nodes,
)
amount = 10
payment_identifier = 1
repeated_nonce = 1
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=payment_identifier,
nonce=repeated_nonce,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=amount,
locked_amount=amount,
recipient=app1.raiden.address,
locksroot=UNIT_SECRETHASH,
lock=Lock(amount, expiration, UNIT_SECRETHASH),
target=app2.raiden.address,
initiator=app0.raiden.address,
fee=0,
)
sign_and_inject(
mediated_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
with gevent.Timeout(network_wait):
wait_assert(
assert_synced_channel_state,
token_network_identifier,
app0, deposit - amount, [],
app1, deposit + amount, [],
)
def test_received_lockedtransfer_closedchannel(
raiden_network,
reveal_timeout,
token_addresses,
deposit,
):
app0, app1 = raiden_network
registry_address = app0.raiden.default_registry.address
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,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
RaidenAPI(app1.raiden).channel_close(
registry_address,
token_address,
app0.raiden.address,
)
wait_until_block(
app0.raiden.chain,
app0.raiden.chain.block_number() + 1,
)
# Now receive one mediated transfer for the closed channel
lock_amount = 10
payment_identifier = 1
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=payment_identifier,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=0,
locked_amount=lock_amount,
recipient=app1.raiden.address,
locksroot=UNIT_SECRETHASH,
lock=Lock(lock_amount, expiration, UNIT_SECRETHASH),
target=app1.raiden.address,
initiator=app0.raiden.address,
fee=0,
)
sign_and_inject(
mediated_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
# The local state must not change since the channel is already closed
assert_synced_channel_state(
token_network_identifier,
app0, deposit, [],
app1, deposit, [],
)
def test_receive_secrethashtransfer_unknown(
raiden_network: List[RaidenService], token_addresses):
app0 = raiden_network[0]
token_address = token_addresses[0]
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_raiden(app0), app0.default_registry.address,
token_address)
assert token_network_address
other_key = HOP1_KEY
other_signer = LocalSigner(other_key)
canonical_identifier = factories.make_canonical_identifier(
token_network_address=token_network_address)
amount = TokenAmount(10)
locksroot = Locksroot(make_32bytes())
refund_transfer_message = factories.create(
factories.RefundTransferProperties(
payment_identifier=PaymentID(1),
nonce=Nonce(1),
token=token_address,
canonical_identifier=canonical_identifier,
transferred_amount=amount,
recipient=TargetAddress(app0.address),
locksroot=locksroot,
amount=amount,
secret=UNIT_SECRET,
))
sign_and_inject(refund_transfer_message, other_signer, app0)
unlock = Unlock(
chain_id=UNIT_CHAIN_ID,
message_identifier=make_message_identifier(),
payment_identifier=PaymentID(1),
nonce=Nonce(1),
channel_identifier=canonical_identifier.channel_identifier,
token_network_address=token_network_address,
transferred_amount=amount,
locked_amount=LockedAmount(0),
locksroot=locksroot,
secret=UNIT_SECRET,
signature=EMPTY_SIGNATURE,
)
sign_and_inject(unlock, other_signer, app0)
secret_request_message = SecretRequest(
message_identifier=make_message_identifier(),
payment_identifier=PaymentID(1),
secrethash=UNIT_SECRETHASH,
amount=PaymentAmount(1),
expiration=refund_transfer_message.lock.expiration,
signature=EMPTY_SIGNATURE,
)
sign_and_inject(secret_request_message, other_signer, app0)
reveal_secret_message = RevealSecret(
message_identifier=make_message_identifier(),
secret=UNIT_SECRET,
signature=EMPTY_SIGNATURE)
sign_and_inject(reveal_secret_message, other_signer, app0)
