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_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 handle_send_directtransfer(
raiden: 'RaidenService',
send_direct_transfer: SendDirectTransfer):
direct_transfer_message = DirectTransfer.from_event(send_direct_transfer)
raiden.sign(direct_transfer_message)
raiden.send_async(
send_direct_transfer.recipient,
direct_transfer_message,
)
def make_direct_transfer_from_channel(
payment_network_identifier,
from_channel,
partner_channel,
amount,
pkey,
):
""" Helper to create and register a direct transfer from `from_channel` to
`partner_channel`."""
payment_identifier = channel.get_next_nonce(from_channel.our_state)
pseudo_random_generator = random.Random()
state_change = ActionTransferDirect(
payment_network_identifier,
from_channel.token_address,
from_channel.partner_state.address,
payment_identifier,
amount,
)
iteration = channel.handle_send_directtransfer(
from_channel,
state_change,
pseudo_random_generator,
)
assert isinstance(iteration.events[0], SendDirectTransfer)
direct_transfer_message = DirectTransfer.from_event(iteration.events[0])
address = privatekey_to_address(pkey)
sign_key = PrivateKey(pkey)
direct_transfer_message.sign(sign_key, address)
# if this fails it's not the right key for the current `from_channel`
assert direct_transfer_message.sender == from_channel.our_state.address
balance_proof = balanceproof_from_envelope(direct_transfer_message)
message_identifier = random.randint(0, UINT64_MAX)
receive_direct = ReceiveTransferDirect(
payment_network_identifier,
from_channel.token_address,
message_identifier,
payment_identifier,
balance_proof,
)
channel.handle_receive_directtransfer(
partner_channel,
receive_direct,
)
return direct_transfer_message
def increase_transferred_amount(
payment_network_identifier,
from_channel,
partner_channel,
amount,
pkey,
):
# increasing the transferred amount by a value larger than distributable
# would put one end of the channel in a negative balance, which is forbidden
distributable_from_to = channel.get_distributable(
from_channel.our_state,
from_channel.partner_state,
)
assert distributable_from_to >= amount, 'operation would end up in a incosistent state'
message_identifier = random.randint(0, UINT64_MAX)
payment_identifier = 1
registry_address = make_address()
event = channel.send_directtransfer(
registry_address,
from_channel,
amount,
payment_identifier,
message_identifier,
)
direct_transfer_message = DirectTransfer.from_event(event)
address = privatekey_to_address(pkey)
sign_key = PrivateKey(pkey)
direct_transfer_message.sign(sign_key, address)
# if this fails it's not the right key for the current `from_channel`
assert direct_transfer_message.sender == from_channel.our_state.address
balance_proof = balanceproof_from_envelope(direct_transfer_message)
receive_direct = ReceiveTransferDirect(
payment_network_identifier,
from_channel.token_address,
message_identifier,
payment_identifier,
balance_proof,
)
channel.handle_receive_directtransfer(
partner_channel,
receive_direct,
)
return direct_transfer_message
