def make_mediated_transfer( identifier=0, nonce=1, token=ADDRESS, channel=ADDRESS, transferred_amount=0, amount=1, expiration=1, locksroot=EMPTY_MERKLE_ROOT, recipient=ADDRESS, target=ADDRESS, initiator=ADDRESS, fee=0): lock = make_lock( amount=amount, expiration=expiration, ) if locksroot == EMPTY_MERKLE_ROOT: locksroot = sha3(lock.as_bytes) return MediatedTransfer( identifier, nonce, token, channel, transferred_amount, recipient, locksroot, lock, target, initiator, fee )
def test_mediated_transfer(iterations=ITERATIONS): identifier = 1 amount = 1 expiration = 1 hashlock = sha3(ADDRESS) lock = Lock(amount, expiration, hashlock) nonce = 1 token = ADDRESS balance = 1 recipient = ADDRESS locksroot = sha3(ADDRESS) target = ADDRESS initiator = ADDRESS msg = MediatedTransfer( identifier, nonce, token, balance, recipient, locksroot, lock, target, initiator, fee=0, ) msg.sign(PRIVKEY, ADDRESS) run_timeit('MediatedTranfer', msg, iterations=iterations)
def test_received_mediatedtransfer_closedchannel(raiden_network, reveal_timeout, 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 mediated transfer for the closed channel amount = 10 identifier = 1 expiration = reveal_timeout * 2 mediated_transfer_message = MediatedTransfer(identifier=identifier, nonce=1, token=token_address, channel=channel0.identifier, transferred_amount=0, recipient=app1.raiden.address, locksroot=UNIT_SECRETHASH, 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 make_receive_transfer_mediated( channel_state, privkey, nonce, transferred_amount, lock, merkletree_leaves=None): if not isinstance(lock, HashTimeLockState): raise ValueError('lock must be of type HashTimeLockState') 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.') if merkletree_leaves is None: layers = [[lock.lockhash]] else: assert lock.lockhash in merkletree_leaves layers = compute_layers(merkletree_leaves) locksroot = layers[MERKLEROOT][0] identifier = nonce transfer_target = factories.make_address() transfer_initiator = factories.make_address() mediated_transfer_msg = MediatedTransfer( identifier, nonce, channel_state.token_address, channel_state.identifier, transferred_amount, channel_state.partner_state.address, locksroot, lock, transfer_target, transfer_initiator, ) mediated_transfer_msg.sign(privkey, address) balance_proof = balanceproof_from_envelope(mediated_transfer_msg) receive_mediatedtransfer = LockedTransferSignedState( identifier, channel_state.token_address, balance_proof, lock, transfer_initiator, transfer_target, ) return receive_mediatedtransfer
def make_mediated_transfer_with_fee(fee): return MediatedTransfer( 0, 1, ADDRESS, 1, ADDRESS, "", make_lock_with_amount(1), ADDRESS, ADDRESS, fee )
def make_mediated_transfer_with_nonce(nonce): return MediatedTransfer( 0, nonce, ADDRESS, 1, ADDRESS, "", make_lock_with_amount(1), ADDRESS, ADDRESS, 0 )
def make_mediated_transfer_with_amount(amount): return MediatedTransfer( 0, 1, ADDRESS, amount, ADDRESS, "", make_lock_with_amount(amount), ADDRESS, ADDRESS, 0 )
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 make_mediated_transfer(identifier=0, nonce=1, token=ADDRESS, transferred_amount=0, amount=1, locksroot='', recipient=ADDRESS, target=ADDRESS, initiator=ADDRESS, fee=0): return MediatedTransfer(identifier, nonce, token, transferred_amount, recipient, locksroot, make_lock(amount=amount), target, initiator, fee)
def test_receive_mediatedtransfer_invalid_address(raiden_network, private_keys): alice_app = raiden_network[0] bob_app = raiden_network[1] graph = alice_app.raiden.token_to_channelgraph.values()[0] token_address = graph.token_address channel0 = channel(alice_app, bob_app, token_address) mt_helper = MediatedTransferTestHelper(raiden_network, graph) initiator_address = alice_app.raiden.address path = mt_helper.get_paths_of_length(initiator_address, 2) alice_address, bob_address, charlie_address = path amount = 10 result = alice_app.raiden.mediated_transfer_async( token_address, amount, charlie_address, identifier=1, ) assert result.wait(timeout=10) gevent.sleep(1.) # and now send one more mediated transfer with the same nonce, simulating # an out-of-order/resent message that arrives late lock = Lock(amount, 1, UNIT_HASHLOCK) identifier = create_default_identifier() mediated_transfer = MediatedTransfer( identifier=identifier, nonce=1, token=token_address, channel=channel0.channel_address, transferred_amount=amount, recipient=bob_address, locksroot=UNIT_HASHLOCK, lock=lock, target=charlie_address, initiator=initiator_address, fee=0 ) alice_key = PrivateKey(private_keys[0]) target_app = None for app in raiden_network: if app.raiden.address not in path: target_app = app break sign_and_send(mediated_transfer, alice_key, alice_address, target_app)
def test_receive_mediatedtransfer_invalid_address(raiden_network, private_keys): alice_app = raiden_network[0] setup_messages_cb() graph = alice_app.raiden.channelgraphs.values()[0] token_address = graph.token_address mt_helper = MediatedTransferTestHelper(raiden_network, graph) initiator_address = alice_app.raiden.address path = mt_helper.get_paths_of_length(initiator_address, 2) alice_address, bob_address, charlie_address = path amount = 10 alice_app.raiden.api.transfer( token_address, amount, charlie_address, ) gevent.sleep(1.) # and now send one more mediated transfer with the same nonce, simulating # an out-of-order/resent message that arrives late locksroot = HASH lock = Lock(amount, 1, locksroot) identifier = create_default_identifier( alice_app.raiden.address, graph.token_address, charlie_address, ) mediated_transfer = MediatedTransfer( identifier=identifier, nonce=1, token=token_address, transferred_amount=amount, recipient=bob_address, locksroot=locksroot, lock=lock, target=charlie_address, initiator=initiator_address, fee=0 ) alice_key = PrivateKey(private_keys[0]) target_app = None for app in raiden_network: if app.raiden.address not in path: target_app = app break sign_and_send(mediated_transfer, alice_key, alice_address, target_app)
def test_receive_mediatedtransfer_outoforder(raiden_network, private_keys): alice_app = raiden_network[0] bob_app = raiden_network[1] charlie_app = raiden_network[2] graph = alice_app.raiden.token_to_channelgraph.values()[0] token_address = graph.token_address channel0 = channel( alice_app, bob_app, token_address, ) amount = 10 result = alice_app.raiden.mediated_transfer_async( token_address, amount, charlie_app.raiden.address, identifier=1, ) assert result.wait(timeout=10) lock = Lock(amount, 1, UNIT_HASHLOCK) identifier = create_default_identifier() mediated_transfer = MediatedTransfer( identifier=identifier, nonce=1, token=token_address, channel=channel0.channel_address, transferred_amount=amount, recipient=bob_app.raiden.address, locksroot=UNIT_HASHLOCK, lock=lock, target=charlie_app.raiden.address, initiator=alice_app.raiden.address, fee=0 ) alice_key = PrivateKey(private_keys[0]) # send the invalid mediated transfer from alice to bob with the same nonce sign_and_send( mediated_transfer, alice_key, alice_app.raiden.address, bob_app, )
def test_receive_mediatedtransfer_outoforder(raiden_network, private_keys): alice_app = raiden_network[0] messages = setup_messages_cb() graph = alice_app.raiden.channelgraphs.values()[0] token_address = graph.token_address mt_helper = MediatedTransferTestHelper(raiden_network, graph) initiator_address = alice_app.raiden.address path = mt_helper.get_paths_of_length(initiator_address, 2) # make sure we have no messages before the transfer assert not messages alice_address, bob_address, charlie_address = path amount = 10 result = alice_app.raiden.transfer_async( token_address, amount, charlie_address, ) assert result.wait(timeout=10) gevent.sleep(1.) # and now send one more mediated transfer with the same nonce, simulating # an out-of-order/resent message that arrives late locksroot = HASH lock = Lock(amount, 1, locksroot) identifier = create_default_identifier() mediated_transfer = MediatedTransfer( identifier=identifier, nonce=1, token=token_address, transferred_amount=amount, recipient=bob_address, locksroot=locksroot, lock=lock, target=charlie_address, initiator=initiator_address, fee=0 ) alice_key = PrivateKey(private_keys[0]) bob_app = mt_helper.get_app_from_address(bob_address) sign_and_send(mediated_transfer, alice_key, alice_address, bob_app)
def test_receive_mediatedtransfer_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() amount = 10 mediated_transfer = MediatedTransfer(identifier=1, nonce=1, token=graph0.token_address, channel=other_address, transferred_amount=amount, recipient=app0.raiden.address, locksroot=UNIT_HASHLOCK, lock=Lock(amount, 1, UNIT_HASHLOCK), target=make_address(), initiator=other_address, fee=0) sign_and_send(mediated_transfer, other_key, other_address, app0)
def test_receive_mediatedtransfer_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) amount = 10 locksroot = HASH mediated_transfer = MediatedTransfer(identifier=1, nonce=1, token=token_manager0.token_address, transferred_amount=amount, recipient=app0.raiden.address, locksroot=locksroot, lock=Lock(amount, 1, locksroot), target=privatekey_to_address(HASH2), initiator=other_address, fee=0) sign_and_send(mediated_transfer, other_key, other_address, app0)
def test_receive_mediatedtransfer_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) amount = 10 locksroot = HASH mediated_transfer = MediatedTransfer(identifier=1, nonce=1, token=graph0.token_address, transferred_amount=amount, recipient=app0.raiden.address, locksroot=locksroot, lock=Lock(amount, 1, locksroot), target=privatekey_to_address(HASH2), initiator=other_address, fee=0) sign_and_send(mediated_transfer, other_key, other_address, app0)
def test_receive_mediatedtransfer_invalidrecipient(raiden_network, token_addresses, reveal_timeout, deposit): app0, app1 = raiden_network token_address = token_addresses[0] channel0 = get_channelstate(app0, app1, token_address) identifier = 1 invalid_recipient = make_address() amount = 10 expiration = reveal_timeout * 2 mediated_transfer_message = MediatedTransfer(identifier=identifier, nonce=1, token=token_address, channel=channel0.identifier, transferred_amount=0, recipient=invalid_recipient, locksroot=UNIT_SECRETHASH, 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_decode_mediated_transfer(private_keys, settle_timeout, tester_state, tester_token, tester_events, tester_registry): privatekey0 = tester.DEFAULT_KEY privatekey1 = tester.k1 privatekey2 = tester.k2 address0 = privatekey_to_address(privatekey0) address1 = privatekey_to_address(privatekey1) address2 = privatekey_to_address(privatekey2) dtester = deploy_decoder_tester(tester_state, tester_token.address, address0, address1, settle_timeout) locksroot = sha3("Sikorka") amount = 1337 expiration = 5 lock = Lock(amount, expiration, locksroot) message = MediatedTransfer(identifier=313151, nonce=88924902, token=tester_token.address, transferred_amount=amount, recipient=address1, locksroot=locksroot, lock=lock, target=address2, initiator=address0) 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(), sender=privatekey1) is True assert dtester.decodedNonce() == 88924902 assert dtester.decodedExpiration() == expiration assert dtester.decodedToken() == tester_token.address.encode('hex') assert dtester.decodedRecipient() == address1.encode('hex') assert dtester.decodedAmount() == amount assert dtester.decodedLocksroot() == locksroot
def test_mediated_transfer(): nonce = balance = 1 token = recipient = target = initiator = ADDRESS hashlock = locksroot = sha3(ADDRESS) amount = expiration = 1 fee = 0 lock = Lock(amount, expiration, hashlock) mediated_transfer = MediatedTransfer( 1, # TODO: fill in identifier nonce, token, balance, recipient, locksroot, lock, target, initiator, fee, ) assert roundtrip_serialize_mediated_transfer(mediated_transfer)
def test_receive_mediatedtransfer_unknown(raiden_network): app0 = raiden_network[0] # pylint: disable=unbalanced-tuple-unpacking asset_manager0 = app0.raiden.managers_by_asset_address.values()[0] other_key = PrivateKey(sha3("rainstopped"), ctx=GLOBAL_CTX, raw=True) other_address = privatekey_to_address(other_key.private_key) amount = 10 locksroot = sha3("muchsunny") mediated_transfer = MediatedTransfer( identifier=1, nonce=1, asset=asset_manager0.asset_address, transferred_amount=amount, recipient=app0.raiden.address, locksroot=locksroot, lock=Lock(amount, 1, locksroot), target=privatekey_to_address(sha3("cloudsagain")), initiator=other_address, fee=0 ) sign_and_send(mediated_transfer, other_key, other_address, app0)
def test_receive_mediatedtransfer_outoforder(raiden_network, private_keys): alice_app = raiden_network[0] setup_messages_cb() asset_manager = alice_app.raiden.managers_by_asset_address.values()[0] asset_address = asset_manager.asset_address mt_helper = MediatedTransferTestHelper(raiden_network, asset_manager) initiator_address = alice_app.raiden.address path = mt_helper.get_paths_of_length(initiator_address, 2) alice_address, bob_address, charlie_address = path amount = 10 alice_app.raiden.api.transfer( asset_address, amount, charlie_address, ) gevent.sleep(1.) # and now send one more mediated transfer with the same nonce, simulating # an out-of-order/resent message that arrives late locksroot = HASH lock = Lock(amount, 1, locksroot) mediated_transfer = MediatedTransfer( identifier=asset_manager.transfermanager.create_default_identifier(charlie_address), nonce=1, asset=asset_address, transferred_amount=amount, recipient=bob_address, locksroot=locksroot, lock=lock, target=charlie_address, initiator=initiator_address, fee=0 ) alice_key = PrivateKey(private_keys[0]) bob_app = mt_helper.get_app_from_address(bob_address) sign_and_send(mediated_transfer, alice_key, alice_address, bob_app)
def test_mediated_transfer(): nonce = balance = 1 asset = recipient = target = initiator = ADDRESS hashlock = locksroot = sha3(ADDRESS) amount = expiration = 1 fee = 0 lock = Lock(amount, expiration, hashlock) mediated_transfer = MediatedTransfer( nonce, asset, balance, recipient, locksroot, lock, target, initiator, fee, ) mediated_transfer.sign(PRIVKEY) decoded_mediated_transfer = decode(mediated_transfer.encode()) assert decoded_mediated_transfer == mediated_transfer
def make_signed_transfer( amount, initiator, target, expiration, secret, identifier=1, nonce=1, transferred_amount=0, recipient=UNIT_TRANSFER_TARGET, channel_identifier=UNIT_CHANNEL_ADDRESS, token=UNIT_TOKEN_ADDRESS, pkey=UNIT_TRANSFER_PKEY, sender=UNIT_TRANSFER_SENDER ): hashlock = sha3(secret) lock = Lock( amount, expiration, hashlock, ) transfer = MediatedTransfer( identifier, nonce, token, channel_identifier, transferred_amount, recipient, lock.lockhash, lock, target, initiator, ) transfer.sign(pkey, sender) return lockedtransfersigned_from_message(transfer)
def test_receive_mediatedtransfer_invalid_address(raiden_chain, token_addresses): app0, app1, app2 = raiden_chain token_address = token_addresses[0] amount = 10 result = app0.raiden.mediated_transfer_async( token_address, amount, app2.raiden.address, identifier=1, ) assert result.wait(timeout=10) # and now send one more mediated transfer with the same nonce, simulating # an out-of-order/resent message that arrives late channel0 = channel(app0, app1, token_address) lock = Lock(amount, 1, UNIT_HASHLOCK) identifier = create_default_identifier() mediated_transfer = MediatedTransfer(identifier=identifier, nonce=1, token=token_address, channel=channel0.channel_address, transferred_amount=amount, recipient=app1.raiden.address, locksroot=UNIT_HASHLOCK, lock=lock, target=app2.raiden.address, initiator=app0.raiden.address, fee=0) sign_and_send( mediated_transfer, app0.raiden.private_key, app0.raiden.address, app1, )
def test_mediated_transfer(): nonce = balance = 1 asset = recipient = target = initiator = address hashlock = locksroot = sha3(address) amount = expiration = 1 lock = Lock(amount, expiration, hashlock) d = lock.encode() assert Lock.decode(d) == lock msg = MediatedTransfer(nonce, asset, balance, recipient, locksroot, lock, target, initiator, fee=0) msg.sign(privkey) dm = msg.encode() msg2 = decode(dm) assert msg2 == msg assert msg2.lock == lock
def test_receiver_cannot_spend_locked_amount(): token_address = make_address() privkey1, address1 = make_privkey_address() privkey2, address2 = make_privkey_address() balance1 = 33 balance2 = 11 reveal_timeout = 7 settle_timeout = 21 block_number = 7 our_state = ChannelEndState(address1, balance1, None, EMPTY_MERKLE_TREE) partner_state = ChannelEndState(address2, balance2, None, EMPTY_MERKLE_TREE) external_state = make_external_state() test_channel = Channel( our_state, partner_state, external_state, token_address, reveal_timeout, settle_timeout, ) amount1 = balance2 expiration = block_number + settle_timeout receive_mediated_transfer0 = test_channel.create_mediatedtransfer( address1, address2, fee=0, amount=amount1, identifier=1, expiration=expiration, hashlock=sha3('test_locked_amount_cannot_be_spent'), ) receive_mediated_transfer0.sign(privkey2, address2) test_channel.register_transfer( block_number, receive_mediated_transfer0, ) # trying to send one unit of the locked token amount2 = balance1 + 1 lock2 = Lock( amount=amount2, expiration=expiration, hashlock=sha3('test_locked_amount_cannot_be_spent2'), ) layers = compute_layers([sha3(lock2.as_bytes)]) tree2 = MerkleTreeState(layers) locksroot2 = merkleroot(tree2) send_mediated_transfer0 = MediatedTransfer( identifier=1, nonce=1, token=token_address, channel=test_channel.channel_address, transferred_amount=0, recipient=address2, locksroot=locksroot2, lock=lock2, target=address2, initiator=address1, fee=0, ) send_mediated_transfer0.sign(privkey1, address1) # address1 balance is all locked with pytest.raises(InsufficientBalance): test_channel.register_transfer( block_number, send_mediated_transfer0, )
def test_update_mediated_transfer(state, token, channel, events): # test tokens and distribute tokens assert token.balanceOf(tester.a0) == 10000 assert token.balanceOf(tester.a1) == 0 assert token.transfer(tester.a1, 5000) is True assert token.balanceOf(tester.a0) == 5000 assert token.balanceOf(tester.a1) == 5000 # test global variables assert channel.settleTimeout() == 30 assert channel.assetAddress() == token.address.encode('hex') assert channel.opened() == 0 assert channel.closed() == 0 assert channel.settled() == 0 hashlock1 = sha3(tester.k0) lock_amount1 = 29 lock_expiration1 = 31 lock1 = Lock(lock_amount1, lock_expiration1, hashlock1) locksroot1 = merkleroot([ sha3(lock1.as_bytes), ]) hashlock2 = sha3(tester.k1) lock_amount2 = 29 lock_expiration2 = 31 lock2 = Lock(lock_amount2, lock_expiration2, hashlock2) locksroot2 = merkleroot([ sha3(lock2.as_bytes), ]) nonce = 1 asset = token.address transfered_amount = 3 recipient = tester.a2 locksroot = locksroot1 target = tester.a1 initiator = tester.a0 msg1 = MediatedTransfer( nonce, asset, transfered_amount, recipient, locksroot, lock1, target, initiator, fee=0, ) msg1.sign(tester.k0) packed = msg1.packed() mediated_transfer1 = str(packed.data) nonce = 2 asset = token.address transfered_amount = 4 recipient = tester.a2 locksroot = locksroot2 target = tester.a0 initiator = tester.a1 msg2 = MediatedTransfer( nonce, asset, transfered_amount, recipient, locksroot, lock2, target, initiator, fee=0, ) msg2.sign(tester.k1) packed = msg2.packed() mediated_transfer2 = str(packed.data) # not yet closed with pytest.raises(TransactionFailed): channel.updateTransfer(mediated_transfer1, sender=tester.k1) channel.close(mediated_transfer1, mediated_transfer2) # Test with message sender tester.a0 assert channel.closed() == state.block.number assert channel.closingAddress() == tester.a0.encode('hex') # assert channel.participants(0)[10] == 1 # assert channel.participants(0)[11] == token.address.encode('hex') # assert channel.participants(0)[9] == tester.a0.encode('hex') # assert channel.participants(0)[12] == tester.a1.encode('hex') # assert channel.participants(0)[3] == 1 # assert channel.participants(0)[13] == locksroot1 # assert channel.participants(0)[7] == '\x00' * 32 # Test with message sender tester.a1 assert channel.closed() == state.block.number assert channel.closingAddress() == tester.a0.encode('hex') # assert channel.participants(1)[10] == 2 # assert channel.participants(1)[11] == token.address.encode('hex') # assert channel.participants(1)[9] == tester.a1.encode('hex') # assert channel.participants(1)[12] == tester.a0.encode('hex') # assert channel.participants(1)[3] == 3 # assert channel.participants(1)[13] == locksroot2 # assert channel.participants(1)[7] == '\x00' * 32 hashlock3 = sha3(tester.k1) lock_amount3 = 29 lock_expiration3 = 31 lock3 = Lock(lock_amount3, lock_expiration3, hashlock3) locksroot3 = merkleroot([ sha3(lock3.as_bytes), ]) nonce = 3 asset = token.address transfered_amount = 4 recipient = tester.a2 locksroot = locksroot3 target = tester.a0 initiator = tester.a1 msg3 = MediatedTransfer( nonce, asset, transfered_amount, recipient, locksroot, lock3, target, initiator, fee=0, ) msg3.sign(tester.k1) packed = msg3.packed() mediated_transfer3 = str(packed.data) # closingAddress == getSender(message) with pytest.raises(TransactionFailed): channel.updateTransfer(mediated_transfer1) channel.updateTransfer(mediated_transfer3, sender=tester.k1) # Test with message sender tester.a1 # assert channel.participants(1)[10] == 3 # assert channel.participants(1)[11] == token.address.encode('hex') # assert channel.participants(1)[9] == tester.a1.encode('hex') # assert channel.participants(1)[12] == tester.a0.encode('hex') # assert channel.participants(1)[3] == 5 # assert channel.participants(1)[13] == locksroot3 # assert channel.participants(1)[7] == '\x00' * 32 msg4 = DirectTransfer( 1, # nonce token.address, # asset 5, # transfered_amount tester.a0, # recipient locksroot, ) msg4.sign(tester.k1) packed = msg4.packed() direct_transfer4 = str(packed.data) # nonce too low with pytest.raises(TransactionFailed): channel.updateTransfer(direct_transfer4, sender=tester.k1) # settleTimeout overdue state.block.number = 1158041 with pytest.raises(TransactionFailed): channel.updateTransfer(mediated_transfer3, sender=tester.k1) assert len(events) == 1 assert events[0]['_event_type'] == 'ChannelClosed' assert events[0]['blockNumber'] == 1158002 assert events[0]['closingAddress'] == tester.a0.encode('hex')
def test_sender_cannot_overspend(): token_address = make_address() privkey1, address1 = make_privkey_address() address2 = make_address() balance1 = 70 balance2 = 110 reveal_timeout = 5 settle_timeout = 15 block_number = 10 our_state = ChannelEndState(address1, balance1, None, EMPTY_MERKLE_TREE) partner_state = ChannelEndState(address2, balance2, None, EMPTY_MERKLE_TREE) external_state = make_external_state() test_channel = Channel( our_state, partner_state, external_state, token_address, reveal_timeout, settle_timeout, ) amount = balance1 expiration = block_number + settle_timeout sent_mediated_transfer0 = test_channel.create_mediatedtransfer( address1, address2, fee=0, amount=amount, identifier=1, expiration=expiration, hashlock=sha3('test_locked_amount_cannot_be_spent'), ) sent_mediated_transfer0.sign(privkey1, address1) test_channel.register_transfer( block_number, sent_mediated_transfer0, ) lock2 = Lock( amount=amount, expiration=expiration, hashlock=sha3('test_locked_amount_cannot_be_spent2'), ) leaves = [ sha3(sent_mediated_transfer0.lock.as_bytes), sha3(lock2.as_bytes), ] tree2 = MerkleTreeState(compute_layers(leaves)) locksroot2 = merkleroot(tree2) sent_mediated_transfer1 = MediatedTransfer( identifier=2, nonce=sent_mediated_transfer0.nonce + 1, token=token_address, channel=test_channel.channel_address, transferred_amount=0, recipient=address2, locksroot=locksroot2, lock=lock2, target=address2, initiator=address1, fee=0, ) sent_mediated_transfer1.sign(privkey1, address1) # address1 balance is all locked with pytest.raises(InsufficientBalance): test_channel.register_transfer( block_number, sent_mediated_transfer1, )
def test_unlock_at_settlement_block(deposit, settle_timeout, reveal_timeout, tester_nettingcontracts, tester_state, tester_token): """ It must be possible to unlock a lock up to and including the settlment block. """ pkey0, pkey1, nettingchannel = tester_nettingcontracts[0] address0 = privatekey_to_address(pkey0) address1 = privatekey_to_address(pkey1) initial_balance0 = tester_token.balanceOf(address0, sender=pkey0) initial_balance1 = tester_token.balanceOf(address1, sender=pkey0) lock_amount = 31 lock_expiration = tester_state.block.number + settle_timeout secret = 'settlementsettlementsettlementse' hashlock = sha3(secret) lock0 = Lock( amount=31, expiration=lock_expiration, hashlock=hashlock, ) lock0_bytes = bytes(lock0.as_bytes) lock0_hash = sha3(lock0_bytes) opened_block = nettingchannel.opened(sender=pkey0) nonce = 1 + (opened_block * (2**32)) mediated0 = MediatedTransfer( identifier=1, nonce=nonce, token=tester_token.address, transferred_amount=0, recipient=address1, locksroot=lock0_hash, lock=lock0, target=address1, initiator=address0, fee=0, ) sign_key0 = PrivateKey(pkey0, ctx=GLOBAL_CTX, raw=True) mediated0.sign(sign_key0, address0) mediated0_data = str(mediated0.packed().data) nettingchannel.close(mediated0_data, sender=pkey1) block_until_settlement_end = lock_expiration - tester_state.block.number tester_state.mine(number_of_blocks=block_until_settlement_end) assert lock_expiration == tester_state.block.number nettingchannel.unlock( lock0_bytes, '', # the lock itself it the root, the proof is empty secret, sender=pkey1, ) tester_state.mine(number_of_blocks=1) nettingchannel.settle(sender=pkey0) balance0 = initial_balance0 + deposit - lock0.amount balance1 = initial_balance1 + deposit + lock0.amount assert tester_token.balanceOf(address0, sender=pkey0) == balance0 assert tester_token.balanceOf(address1, sender=pkey0) == balance1 assert tester_token.balanceOf(nettingchannel.address, sender=pkey0) == 0
def test_receive_mediatedtransfer_invalid_address(raiden_network, private_keys): alice_app = raiden_network[0] messages = setup_messages_cb() graph = alice_app.raiden.channelgraphs.values()[0] token_address = graph.token_address mt_helper = MediatedTransferTestHelper(raiden_network, graph) initiator_address = alice_app.raiden.address path = mt_helper.get_paths_of_length(initiator_address, 2) alice_address, bob_address, charlie_address = path amount = 10 result = alice_app.raiden.transfer_async( token_address, amount, charlie_address, ) # check for invitation ping assert len(messages) == 2 # Ping, Ack ping_message = decode(messages[0]) assert isinstance(ping_message, Ping) decoded = decode(messages[1]) assert isinstance(decoded, Ack) assert decoded.echo == sha3(ping_message.encode() + charlie_address) assert result.wait(timeout=10) gevent.sleep(1.) # check that transfer messages were added assert len(messages) == 22 # Ping, Ack + tranfer messages # make sure that the mediated transfer is sent after the invitation ping assert isinstance(decode(messages[2]), MediatedTransfer) # and now send one more mediated transfer with the same nonce, simulating # an out-of-order/resent message that arrives late locksroot = HASH lock = Lock(amount, 1, locksroot) identifier = create_default_identifier( alice_app.raiden.address, graph.token_address, charlie_address, ) mediated_transfer = MediatedTransfer( identifier=identifier, nonce=1, token=token_address, transferred_amount=amount, recipient=bob_address, locksroot=locksroot, lock=lock, target=charlie_address, initiator=initiator_address, fee=0 ) alice_key = PrivateKey(private_keys[0]) target_app = None for app in raiden_network: if app.raiden.address not in path: target_app = app break sign_and_send(mediated_transfer, alice_key, alice_address, target_app)