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 make_direct_transfer(
message_identifier=None,
payment_identifier=0,
nonce=1,
registry_address=ADDRESS,
token=ADDRESS,
channel_identifier=UNIT_CHANNEL_ID,
transferred_amount=0,
locked_amount=0,
recipient=ADDRESS,
locksroot=EMPTY_MERKLE_ROOT,
):
if message_identifier is None:
message_identifier = random.randint(0, UINT64_MAX)
return DirectTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=message_identifier,
payment_identifier=payment_identifier,
nonce=nonce,
token_network_address=registry_address,
token=token,
channel_identifier=channel_identifier,
transferred_amount=transferred_amount,
locked_amount=locked_amount,
recipient=recipient,
locksroot=locksroot,
)
def test_update_must_fail_with_a_wrong_recipient(tester_channels,
private_keys):
""" updateTransfer must not accept a transfer from a non participant. """
pkey0, pkey1, nettingchannel, channel0, _ = tester_channels[0]
opened_block = nettingchannel.opened(sender=pkey0)
nonparticipant_address = privatekey_to_address(private_keys[2])
# make a transfer where pkey1 is the target
transfer_wrong_recipient = DirectTransfer(
identifier=1,
nonce=1 + (opened_block * (2**32)),
token=channel0.token_address,
transferred_amount=10,
recipient=nonparticipant_address,
locksroot='',
)
our_address = privatekey_to_address(pkey0)
our_sign_key = PrivateKey(pkey0)
transfer_wrong_recipient.sign(our_sign_key, our_address)
transfer_wrong_recipient_data = str(transfer_wrong_recipient.packed().data)
nettingchannel.close('', sender=pkey0)
with pytest.raises(TransactionFailed):
nettingchannel.updateTransfer(transfer_wrong_recipient_data,
sender=pkey1)
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_decode_direct_transfer(private_keys, settle_timeout, tester_state,
tester_token, tester_events, tester_registry):
privatekey0 = tester.DEFAULT_KEY
privatekey1 = private_keys[1]
address0 = privatekey_to_address(privatekey0)
address1 = privatekey_to_address(privatekey1)
dtester = deploy_decoder_tester(tester_token.address, address0, address1,
settle_timeout)
locksroot = sha3("Waldemarstr")
message = DirectTransfer(identifier=1,
nonce=2,
asset=tester_token.address,
transferred_amount=1337,
recipient=address1,
locksroot=locksroot)
message.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
_, publickey = wrap_and_validate(message.encode())
recovered_address = address_from_key(publickey)
assert recovered_address == address0
assert dtester.testDecodeTransfer(message.encode()) is True
assert dtester.decodedNonce() == 2
assert dtester.decodedAsset() == tester_token.address.encode('hex')
assert dtester.decodedRecipient() == address1.encode('hex')
assert dtester.decodedAmount() == 1337
assert dtester.decodedLocksroot() == locksroot
def test_update_must_fail_with_a_nonparticipant_transfer(
tester_channels, private_keys):
""" updateTransfer must not accept a transfer from a non participant. """
pkey0, pkey1, nettingchannel, channel0, channel1 = tester_channels[0]
nonparticipant_key = private_keys[2]
# make a transfer where pkey1 is the target
transfer_nonparticipant = DirectTransfer(
identifier=1,
nonce=1,
token=channel0.token_address,
transferred_amount=10,
recipient=channel1.our_address,
locksroot='',
)
nonparticipant_address = privatekey_to_address(nonparticipant_key)
nonparticipant_sign_key = PrivateKey(nonparticipant_key,
ctx=GLOBAL_CTX,
raw=True)
transfer_nonparticipant.sign(nonparticipant_sign_key,
nonparticipant_address)
transfer_nonparticipant_data = str(transfer_nonparticipant.packed().data)
nettingchannel.close('', sender=pkey0)
with pytest.raises(TransactionFailed):
nettingchannel.updateTransfer(transfer_nonparticipant_data,
sender=pkey1)
def test_signature_split(tester_chain, tester_nettingchannel_library_address):
auxiliary = deploy_auxiliary_tester(tester_chain,
tester_nettingchannel_library_address)
privkey, address = make_privkey_address()
message_identifier = random.randint(0, UINT64_MAX)
msg = DirectTransfer(message_identifier=message_identifier,
payment_identifier=1,
nonce=1,
registry_address='x' * 20,
token='x' * 20,
channel=auxiliary.address,
transferred_amount=10,
recipient='y' * 20,
locksroot=HASH)
msg.sign(privkey, address)
msg = msg.encode()
# signature = len(msg) - 65
signature = msg[len(msg) - 65:]
signature = signature[:-1] + chr(27).encode()
r, s, v = auxiliary.signatureSplit(signature)
assert v == 27
assert r == signature[:32]
assert s == signature[32:64]
signature = signature[:-1] + chr(28).encode()
_, _, v = auxiliary.signatureSplit(signature)
assert v == 28
with pytest.raises(TransactionFailed):
signature = signature[:-1] + chr(4).encode()
r, s, v = auxiliary.signatureSplit(signature)
def test_close_accepts_only_transfer_from_participants(tester_channels,
private_keys):
""" Close must not accept a transfer signed by a non participant. """
pkey0, _, nettingchannel, channel0, _ = tester_channels[0]
nonparticipant_key = private_keys[2]
opened_block = nettingchannel.opened(sender=pkey0)
# make a transfer where pkey0 is the target
transfer_nonparticipant = DirectTransfer(
identifier=1,
nonce=1 + (opened_block * (2**32)),
token=channel0.token_address,
channel=channel0.identifier,
transferred_amount=10,
recipient=channel0.our_state.address,
locksroot=EMPTY_MERKLE_ROOT,
)
nonparticipant_address = privatekey_to_address(nonparticipant_key)
nonparticipant_sign_key = PrivateKey(nonparticipant_key)
transfer_nonparticipant.sign(nonparticipant_sign_key,
nonparticipant_address)
transfer_nonparticipant_hash = sha3(
transfer_nonparticipant.packed().data[:-65])
with pytest.raises(TransactionFailed):
nettingchannel.close(
transfer_nonparticipant.nonce,
transfer_nonparticipant.transferred_amount,
transfer_nonparticipant.locksroot,
transfer_nonparticipant_hash,
transfer_nonparticipant.signature,
sender=pkey0,
)
def test_close_accepts_only_transfer_from_participants(tester_channels,
private_keys):
""" Close must not accept a transfer from a non participant. """
pkey0, _, nettingchannel, channel0, _ = tester_channels[0]
nonparticipant_key = private_keys[2]
opened_block = nettingchannel.opened(sender=pkey0)
# make a transfer where pkey0 is the target
transfer_nonparticipant = DirectTransfer(
identifier=1,
nonce=1 + (opened_block * (2**32)),
token=channel0.token_address,
transferred_amount=10,
recipient=channel0.our_address,
locksroot='',
)
nonparticipant_address = privatekey_to_address(nonparticipant_key)
nonparticipant_sign_key = PrivateKey(nonparticipant_key)
transfer_nonparticipant.sign(nonparticipant_sign_key,
nonparticipant_address)
transfer_nonparticipant_data = str(transfer_nonparticipant.packed().data)
with pytest.raises(TransactionFailed):
nettingchannel.close(transfer_nonparticipant_data, sender=pkey0)
def create_directtransfer(self, amount, identifier):
""" Return a DirectTransfer message.
This message needs to be signed and registered with the channel before
sent.
"""
if not self.isopen:
raise ValueError('The channel is closed')
from_ = self.our_state
to_ = self.partner_state
distributable = from_.distributable(to_)
if amount <= 0 or amount > distributable:
log.debug(
'Insufficient funds',
amount=amount,
distributable=distributable,
)
raise ValueError('Insufficient funds')
transferred_amount = from_.transferred_amount + amount
current_locksroot = to_.balance_proof.merkleroot_for_unclaimed()
return DirectTransfer(
identifier=identifier,
nonce=from_.nonce,
asset=self.asset_address,
transferred_amount=transferred_amount,
recipient=to_.address,
locksroot=current_locksroot,
)
def test_close_wrong_channel(tester_channels):
""" Close must not accept a transfer aimed at a different channel. """
pkey0, pkey1, nettingchannel, channel0, _ = tester_channels[0]
opened_block = nettingchannel.opened(sender=pkey0)
wrong_address = make_address()
# make a transfer where the recipient is totally wrong
transfer_wrong_channel = DirectTransfer(
identifier=1,
nonce=1 + (opened_block * (2**32)),
token=channel0.token_address,
channel=wrong_address,
transferred_amount=10,
recipient=channel0.our_state.address,
locksroot=EMPTY_MERKLE_ROOT,
)
transfer_wrong_channel.sign(PrivateKey(pkey1),
privatekey_to_address(pkey1))
transfer_wrong_channel_hash = sha3(
transfer_wrong_channel.packed().data[:-65])
with pytest.raises(TransactionFailed):
nettingchannel.close(
transfer_wrong_channel.nonce,
transfer_wrong_channel.transferred_amount,
transfer_wrong_channel.locksroot,
transfer_wrong_channel_hash,
transfer_wrong_channel.signature,
sender=pkey0,
)
def test_recoverAddressFromSignature(tester_chain,
tester_nettingchannel_library_address):
auxiliary = deploy_auxiliary_tester(tester_chain,
tester_nettingchannel_library_address)
privkey, address = make_privkey_address()
message_identifier = random.randint(0, UINT64_MAX)
msg = DirectTransfer(message_identifier=message_identifier,
payment_identifier=1,
nonce=1,
registry_address='x' * 20,
token='x' * 20,
channel=auxiliary.address,
transferred_amount=10,
recipient='y' * 20,
locksroot=HASH)
msg.sign(privkey, address)
data = msg.encode()
signature = data[-65:]
extra_hash = sha3(data[:-65])
computed_address = auxiliary.recoverAddressFromSignature(
msg.nonce, msg.transferred_amount, msg.locksroot, extra_hash,
signature)
assert normalize_address(computed_address) == msg.sender
def create_directtransfer(self, amount, secret=None):
""" Return a DirectTransfer message.
This message needs to be signed and registered with the channel before
sent.
"""
if not self.isopen:
raise ValueError('The channel is closed')
from_ = self.our_state
to_ = self.partner_state
distributable = from_.distributable(to_)
if amount <= 0 or amount > distributable:
log.debug(
'Insufficient funds',
amount=amount,
distributable=distributable,
)
raise ValueError('Insufficient funds')
# start of critical read section
transfered_amount = from_.transfered_amount + amount
current_locksroot = to_.locked.root
# end of critical read section
return DirectTransfer(
nonce=from_.nonce,
asset=self.asset_address,
transfered_amount=transfered_amount,
recipient=to_.address,
locksroot=current_locksroot,
secret=secret,
)
def test_signature_split(tester_state, tester_nettingchannel_library_address):
auxiliary = deploy_auxiliary_tester(tester_state,
tester_nettingchannel_library_address)
privkey, address = make_privkey_address()
msg = DirectTransfer(identifier=1,
nonce=1,
token='x' * 20,
transferred_amount=10,
recipient='y' * 20,
locksroot=HASH)
msg.sign(privkey, address)
msg = msg.encode()
# signature = len(msg) - 65
signature = msg[len(msg) - 65:]
signature = signature[:-1] + chr(27)
r, s, v = auxiliary.signatureSplit(signature)
assert v == 27
assert r == signature[:32]
assert s == signature[32:64]
signature = signature[:-1] + chr(28)
_, _, v = auxiliary.signatureSplit(signature)
assert v == 28
with pytest.raises(TransactionFailed):
signature = signature[:-1] + chr(4)
r, s, v = auxiliary.signatureSplit(signature)
def test_transfer_from_outdated(raiden_network, settle_timeout):
app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking
graph0 = app0.raiden.token_to_channelgraph.values()[0]
graph1 = app1.raiden.token_to_channelgraph.values()[0]
channel0 = graph0.partneraddress_to_channel[app1.raiden.address]
channel1 = graph1.partneraddress_to_channel[app0.raiden.address]
balance0 = channel0.balance
balance1 = channel1.balance
assert graph0.token_address == graph1.token_address
assert app1.raiden.address in graph0.partneraddress_to_channel
amount = 10
result = app0.raiden.transfer_async(
graph0.token_address,
amount,
target=app1.raiden.address,
)
assert result.wait(timeout=10)
assert_synched_channels(channel0, balance0 - amount, [], channel1,
balance1 + amount, [])
channel1.external_state.close(channel1.received_transfers[-1], )
wait_until_block(app1.raiden.chain, app1.raiden.chain.block_number() + 1)
assert channel0.external_state.close_event.wait(timeout=25)
assert channel1.external_state.close_event.wait(timeout=25)
assert channel0.external_state.closed_block != 0
assert channel1.external_state.closed_block != 0
wait_until_block(
app0.raiden.chain,
app0.raiden.chain.block_number() + settle_timeout,
)
assert channel0.external_state.settle_event.wait(timeout=25)
assert channel1.external_state.settle_event.wait(timeout=25)
assert channel0.external_state.settled_block != 0
assert channel1.external_state.settled_block != 0
# and now receive one more transfer from the closed channel
direct_transfer_message = DirectTransfer(
identifier=1,
nonce=1,
token=graph0.token_address,
channel=channel0.channel_address,
transferred_amount=10,
recipient=app0.raiden.address,
locksroot=UNIT_HASHLOCK,
)
sign_and_send(direct_transfer_message, app1.raiden.private_key,
app1.raiden.address, app1)
def make_direct_transfer(
message_identifier=None,
payment_identifier=0,
nonce=1,
registry_address=ADDRESS,
token=ADDRESS,
channel=ADDRESS,
transferred_amount=0,
locked_amount=0,
recipient=ADDRESS,
locksroot=EMPTY_MERKLE_ROOT,
):
if message_identifier is None:
message_identifier = random.randint(0, UINT64_MAX)
return DirectTransfer(
message_identifier,
payment_identifier,
nonce,
registry_address,
token,
channel,
transferred_amount,
locked_amount,
recipient,
locksroot,
)
def make_receive_transfer_direct(
payment_network_identifier,
channel_state,
privkey,
nonce,
transferred_amount,
locksroot=EMPTY_MERKLE_ROOT):
address = privatekey_to_address(privkey.secret)
if address not in (channel_state.our_state.address, channel_state.partner_state.address):
raise ValueError('Private key does not match any of the participants.')
identifier = nonce
mediated_transfer_msg = DirectTransfer(
identifier,
nonce,
channel_state.token_address,
channel_state.identifier,
transferred_amount,
channel_state.partner_state.address,
locksroot,
)
mediated_transfer_msg.sign(privkey, address)
balance_proof = balanceproof_from_envelope(mediated_transfer_msg)
receive_directtransfer = ReceiveTransferDirect(
payment_network_identifier,
channel_state.token_address,
identifier,
balance_proof,
)
return receive_directtransfer
def test_update_must_fail_with_a_channel_address(tester_channels):
""" updateTransfer must not accept a transfer signed with the wrong channel address. """
pkey0, pkey1, nettingchannel, channel0, channel1 = tester_channels[0]
opened_block = nettingchannel.opened(sender=pkey0)
wrong_channel = factories.make_address()
# make a transfer where pkey1 is the target
transfer_wrong_recipient = DirectTransfer(
identifier=1,
nonce=1 + (opened_block * (2**32)),
token=channel0.token_address,
channel=wrong_channel,
transferred_amount=10,
recipient=channel1.our_state.address,
locksroot=EMPTY_MERKLE_ROOT,
)
our_address = privatekey_to_address(pkey0)
our_sign_key = PrivateKey(pkey0)
transfer_wrong_recipient.sign(our_sign_key, our_address)
nettingchannel.close(sender=pkey0)
transfer_wrong_recipient_hash = sha3(
transfer_wrong_recipient.packed().data[:-65])
with pytest.raises(TransactionFailed):
nettingchannel.updateTransfer(
transfer_wrong_recipient.nonce,
transfer_wrong_recipient.transferred_amount,
transfer_wrong_recipient.locksroot,
transfer_wrong_recipient_hash,
transfer_wrong_recipient.signature,
sender=pkey1,
)
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 direct_transfer(draw, token, recipient, locksroot):
return DirectTransfer(
draw(identifier),
draw(nonce),
draw(token),
draw(transferred_amount),
draw(recipient),
draw(locksroot),
)
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_direct_transfer(iterations=ITERATIONS):
nonce = 1
asset = ADDRESS
balance = 1
recipient = ADDRESS
locksroot = HASH
msg = DirectTransfer(nonce, asset, balance, recipient, locksroot)
msg.sign(PRIVKEY)
run_timeit('DirectTransfer', msg, iterations=iterations)
def test_transfer_from_outdated(raiden_network, settle_timeout):
app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking
token_manager0 = app0.raiden.managers_by_token_address.values()[0]
token_manager1 = app1.raiden.managers_by_token_address.values()[0]
channel0 = token_manager0.partneraddress_channel[app1.raiden.address]
channel1 = token_manager1.partneraddress_channel[app0.raiden.address]
balance0 = channel0.balance
balance1 = channel1.balance
assert token_manager0.token_address == token_manager1.token_address
assert app1.raiden.address in token_manager0.partneraddress_channel
amount = 10
app0.raiden.api.transfer(
token_manager0.token_address,
amount,
target=app1.raiden.address,
)
assert_synched_channels(channel0, balance0 - amount, [], channel1,
balance1 + amount, [])
app1.raiden.api.close(token_manager0.token_address, app0.raiden.address)
wait_until_block(app1.raiden.chain, app1.raiden.chain.block_number() + 1)
assert channel0.close_event.wait(timeout=25)
assert channel1.close_event.wait(timeout=25)
assert channel0.external_state.closed_block != 0
assert channel1.external_state.closed_block != 0
wait_until_block(
app0.raiden.chain,
app0.raiden.chain.block_number() + settle_timeout,
)
assert channel0.settle_event.wait(timeout=25)
assert channel1.settle_event.wait(timeout=25)
assert channel0.external_state.settled_block != 0
assert channel1.external_state.settled_block != 0
# and now receive one more transfer from the closed channel
direct_transfer = DirectTransfer(identifier=1,
nonce=1,
token=token_manager0.token_address,
transferred_amount=10,
recipient=app0.raiden.address,
locksroot=HASH)
sign_and_send(direct_transfer, app1.raiden.private_key,
app1.raiden.address, app1)
def test_transfer_from_outdated(raiden_network, settle_timeout):
app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking
tester_state = app0.raiden.chain.tester_state
asset_manager0 = app0.raiden.managers_by_asset_address.values()[0]
asset_manager1 = app1.raiden.managers_by_asset_address.values()[0]
channel0 = asset_manager0.partneraddress_channel[app1.raiden.address]
channel1 = asset_manager1.partneraddress_channel[app0.raiden.address]
balance0 = channel0.balance
balance1 = channel1.balance
assert asset_manager0.asset_address == asset_manager1.asset_address
assert app1.raiden.address in asset_manager0.partneraddress_channel
amount = 10
app0.raiden.api.transfer(
asset_manager0.asset_address,
amount,
target=app1.raiden.address,
)
gevent.sleep(1)
assert_synched_channels(
channel0, balance0 - amount, [],
channel1, balance1 + amount, []
)
app1.raiden.api.close(asset_manager0.asset_address, app0.raiden.address)
tester_state.mine(1)
gevent.sleep(.5)
tester_state.mine(number_of_blocks=settle_timeout + 1)
app0.raiden.api.settle(asset_manager0.asset_address, app1.raiden.address)
gevent.sleep(.5)
assert channel0.external_state.settled_block != 0
assert channel1.external_state.settled_block != 0
# and now receive one more transfer from the closed channel
direct_transfer = DirectTransfer(
identifier=1,
nonce=1,
asset=asset_manager0.asset_address,
transferred_amount=10,
recipient=app0.raiden.address,
locksroot=HASH
)
sign_and_send(
direct_transfer,
app1.raiden.private_key,
app1.raiden.address, app1
)
def direct_transfer(draw, registry_address, token, channel, recipient,
locksroot):
return DirectTransfer(
draw(identifier),
draw(identifier),
draw(nonce),
draw(registry_address),
draw(token),
draw(channel),
draw(transferred_amount),
draw(recipient),
draw(locksroot),
)
def test_receive_directtransfer_unknown(raiden_network):
app0 = raiden_network[0] # pylint: disable=unbalanced-tuple-unpacking
graph0 = app0.raiden.channelgraphs.values()[0]
other_key = PrivateKey(HASH)
other_address = privatekey_to_address(HASH)
direct_transfer = DirectTransfer(identifier=1,
nonce=1,
token=graph0.token_address,
transferred_amount=10,
recipient=app0.raiden.address,
locksroot=HASH)
sign_and_send(direct_transfer, other_key, other_address, app0)
def test_receive_directtransfer_unknown(raiden_network):
app0 = raiden_network[0] # pylint: disable=unbalanced-tuple-unpacking
token_manager0 = app0.raiden.managers_by_token_address.values()[0]
other_key = PrivateKey(HASH, ctx=GLOBAL_CTX, raw=True)
other_address = privatekey_to_address(other_key.private_key)
direct_transfer = DirectTransfer(identifier=1,
nonce=1,
token=token_manager0.token_address,
transferred_amount=10,
recipient=app0.raiden.address,
locksroot=HASH)
sign_and_send(direct_transfer, other_key, other_address, app0)
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_receive_directtransfer_unknown(raiden_network):
app0 = raiden_network[0] # pylint: disable=unbalanced-tuple-unpacking
graph0 = app0.raiden.token_to_channelgraph.values()[0]
other_key, other_address = make_privkey_address()
direct_transfer_message = DirectTransfer(
identifier=1,
nonce=1,
token=graph0.token_address,
channel=other_address,
transferred_amount=10,
recipient=app0.raiden.address,
locksroot=UNIT_HASHLOCK,
)
sign_and_send(direct_transfer_message, other_key, other_address, app0)
def make_direct_transfer(identifier=0,
nonce=1,
token=ADDRESS,
transferred_amount=0,
recipient=ADDRESS,
locksroot=''):
return DirectTransfer(
identifier,
nonce,
token,
transferred_amount,
recipient,
locksroot,
)
