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.channel_address, transferred_amount=10, recipient=channel0.our_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_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_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_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_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_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 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_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_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_update_must_fail_with_a_channel_address(tester_channels, private_keys): """ 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 = 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_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_decode_transfer(): bad_encoded_data = '0500000000000000000000010bd4060688a1800ae986e4840aebc924bb40b5bf3893263bf8b2d0373a34b8d359c5edd823110747000000000000000000000000000000000000000000000000000000000000000160d09b4687c162154b290ee5fcbd7c6285590969b3c873e94b690ee9c4f5df510000000000000000000000000000000000000000000000000000000000000000ff9636ccb66e73219fd166cd6ffbc9c6215f74ff31c1fd4131cf532b29ee096f65278c459253fba65bf019c723a68bb4a6153ea8378cd1b15d55825e1a291b6f0001' bad_data = bad_encoded_data.decode('hex') nonce = 1 asset = ASSET_ADDRESS balance = 1 recipient = RECIPIENT_ADDRESS locksroot = LOCKSROOT msg = DirectTransfer( nonce, asset, balance, recipient, locksroot, ).sign(INITIATOR_PRIVKEY) packed = msg.packed() data = str(packed.data) s = tester.state() c = s.abi_contract(None, path=decoder_path, language="solidity") o1 = c.decodeTransfer1(data) o2 = c.decodeTransfer2(data) assert data[0] == '\x05' # make sure data has right cmdid assert len(data) == 213 cmd_id_pad = o1[0] assert cmd_id_pad == data[:4] nonce = o1[1] assert nonce == packed.nonce asset = o1[2] assert asset == str(packed.asset).encode('hex') recipient = o1[3] assert len(recipient) == 40 assert recipient == str(packed.recipient).encode('hex') transfered_amount = o1[4] assert transfered_amount == packed.transfered_amount optionalLocksroot = o2[0] assert optionalLocksroot == str(packed.locksroot) optionalSecret = o2[1] assert optionalSecret == '0000000000000000000000000000000000000000000000000000000000000000'.decode('hex') signature = str(packed.signature) r = o2[2] s = o2[3] v = o2[4] assert r == signature[:32] assert s == signature[32:64] assert v == int(signature[64].encode('hex')) + 27 with pytest.raises(TransactionFailed): c.decodeSecret(bad_data)
def test_update_must_fail_with_a_nonparticipant_transfer( tester_registry_address, 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] opened_block = nettingchannel.opened(sender=pkey0) # make a transfer where pkey1 is the target message_identifier = random.randint(0, UINT64_MAX) transfer_nonparticipant = DirectTransfer( message_identifier=message_identifier, payment_identifier=1, nonce=1 + (opened_block * (2**32)), registry_address=tester_registry_address, token=channel0.token_address, channel=channel0.identifier, transferred_amount=10, locked_amount=0, recipient=channel1.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) nettingchannel.close(sender=pkey0) transfer_nonparticipant_hash = sha3( transfer_nonparticipant.packed().data[:-65]) with pytest.raises(TransactionFailed): nettingchannel.updateTransfer( transfer_nonparticipant.nonce, transfer_nonparticipant.transferred_amount, transfer_nonparticipant.locksroot, transfer_nonparticipant_hash, transfer_nonparticipant.signature, sender=pkey1, )
def test_close_wrong_recipient(tester_channels, private_keys): """ Close must not accept a transfer aimed at a non recipient. """ 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 the recipient is totally wrong transfer_wrong_recipient = DirectTransfer( identifier=1, nonce=1 + (opened_block * (2 ** 32)), token=channel0.token_address, transferred_amount=10, recipient=nonparticipant_address, locksroot='', ) transfer_wrong_recipient.sign(PrivateKey(pkey1), privatekey_to_address(pkey1)) transfer_wrong_recipient_data = str(transfer_wrong_recipient.packed().data) with pytest.raises(TransactionFailed): nettingchannel.close(transfer_wrong_recipient_data, sender=pkey0)
def test_ncc(): token_library_path = get_contract_path('StandardToken.sol') token_path = get_contract_path('HumanStandardToken.sol') s = tester.state() assert s.block.number < 1150000 s.block.number = 1158001 assert s.block.number > 1150000 # Token creation lib_token = s.abi_contract(None, path=token_library_path, language="solidity") token = s.abi_contract(None, path=token_path, language="solidity", libraries={'StandardToken': lib_token.address.encode('hex')}, constructor_parameters=[10000, "raiden", 0, "rd"]) # Getter creation lib_getter = s.abi_contract(None, path=decode_lib, language="solidity") getter = s.abi_contract(None, path=getter_path, language="solidity", libraries={'Decoder': lib_getter.address.encode('hex')}) INITIATOR_PRIVKEY = tester.k0 INITIATOR_ADDRESS = privtoaddr(INITIATOR_PRIVKEY) RECIPIENT_PRIVKEY = tester.k1 RECIPIENT_ADDRESS = privtoaddr(RECIPIENT_PRIVKEY) ASSET_ADDRESS = token.address HASHLOCK = sha3(INITIATOR_PRIVKEY) LOCK_AMOUNT = 29 LOCK_EXPIRATION = 31 LOCK = Lock(LOCK_AMOUNT, LOCK_EXPIRATION, HASHLOCK) LOCKSROOT = merkleroot([ sha3(LOCK.as_bytes), ]) # print direct_transfer.encode('hex') nonce = 1 asset = ASSET_ADDRESS balance = 1 recipient = RECIPIENT_ADDRESS locksroot = LOCKSROOT msg = DirectTransfer( nonce, asset, balance, recipient, locksroot, ).sign(INITIATOR_PRIVKEY) packed = msg.packed() direct_transfer = str(packed.data) # pure python recover sen = recover_publickey(direct_transfer[:148], str(packed.signature)) assert address_from_key(sen) == tester.a0 # addr = getter.ecTest(direct_transfer[:148], sig) # assert addr == INITIATOR_ADDRESS.encode('hex') sender = getter.getSender(direct_transfer) assert sender == tester.a0.encode('hex') # with sigSplit directly in Getters.sol r, s, v = getter.sigSplit(str(packed.signature)) assert r == str(packed.signature[:32]) assert s == str(packed.signature[32:64]) assert v == packed.signature[64] + 27 sender = getter.getSender(direct_transfer) assert sender == tester.a0.encode('hex')
def test_settle(state, channel, token, asset_amount, events): half_amount = asset_amount / 2 assert token.transfer(tester.a1, half_amount) is True token1 = ABIContract( state, token.translator, token.address, default_key=tester.k1, ) assert token.approve(channel.address, half_amount) is True assert token1.approve(channel.address, half_amount) is True channel1 = ABIContract( state, channel.translator, channel.address, default_key=tester.k1, ) channel.deposit(half_amount) channel1.deposit(half_amount) secret1 = 'x' * 32 hashlock1 = sha3(secret1) lock_amount1 = 29 lock_expiration1 = 1158003 lock1 = Lock(lock_amount1, lock_expiration1, hashlock1) lockhash1 = sha3(lock1.as_bytes) merkleproof1 = [lockhash1] locksroot1 = merkleroot([lockhash1], merkleproof1) nonce1 = 1 asset = token.address transfered_amount1 = 1 recipient = tester.a1 locksroot = locksroot1 msg1 = DirectTransfer( nonce1, asset, transfered_amount1, recipient, locksroot, ) msg1.sign(tester.k0) packed = msg1.packed() direct_transfer1 = str(packed.data) secret2 = 'y' * 32 hashlock2 = sha3(secret2) lock_amount2 = 20 lock_expiration2 = 1158005 lock2 = Lock(lock_amount2, lock_expiration2, hashlock2) lockhash2 = sha3(lock2.as_bytes) merkleproof2 = [lockhash2] locksroot2 = merkleroot([lockhash2], merkleproof2) locksroot = locksroot2 nonce2 = 2 transfered_amount2 = 3 msg2 = DirectTransfer( nonce2, token.address, # asset transfered_amount2, tester.a0, # recipient locksroot, ) msg2.sign(tester.k1) packed = msg2.packed() direct_transfer2 = str(packed.data) # not yet closed. should fail with pytest.raises(TransactionFailed): channel.settle() channel.close(direct_transfer1, direct_transfer2) channel.unlock( str(lock1.as_bytes), ''.join(merkleproof1), secret1, ) channel.unlock(str(lock2.as_bytes), ''.join(merkleproof2), secret2, sender=tester.k1) secret4 = 'k' * 32 hashlock4 = sha3(secret4) lock_amount4 = 23 lock_expiration4 = 31 lock4 = Lock(lock_amount4, lock_expiration4, hashlock4) hashlock4 = sha3(lock4.as_bytes) merkleproof4 = [hashlock4] # has now message, should fail with pytest.raises(TransactionFailed): channel.unlock( str(lock4.as_bytes), ''.join(merkleproof4), secret4, sender=tester.k1, ) # still timeout with pytest.raises(TransactionFailed): channel.settle() state.block.number = state.block.number + 40 # timeout over channel.settle() balance1 = half_amount + (transfered_amount2 - transfered_amount1) + lock_amount1 - lock_amount2 balance2 = half_amount + (transfered_amount1 - transfered_amount2) - lock_amount1 + lock_amount2 assert token.balanceOf(tester.a0) == balance1 assert token.balanceOf(tester.a1) == balance2 # can settle only once with pytest.raises(TransactionFailed): channel.settle() assert len(events) == 6 assert events[0]['_event_type'] == 'ChannelNewBalance' assert events[0]['assetAddress'] == token.address.encode('hex') assert events[0]['participant'] == tester.a0.encode('hex') assert events[0]['balance'] == 50 assert events[1]['_event_type'] == 'ChannelNewBalance' assert events[1]['assetAddress'] == token.address.encode('hex') assert events[1]['participant'] == tester.a1.encode('hex') assert events[1]['balance'] == 50 assert events[2]['_event_type'] == 'ChannelClosed' assert events[2]['closingAddress'] == tester.a0.encode('hex') assert events[2]['blockNumber'] == 1158002 assert events[3]['_event_type'] == 'ChannelSecretRevealed' assert events[3]['secret'] == 'x' * 32 assert events[4]['_event_type'] == 'ChannelSecretRevealed' assert events[4]['secret'] == 'y' * 32 assert events[5]['_event_type'] == 'ChannelSettled' assert events[5]['blockNumber'] == state.block.number
def test_unlock(token, channel, events, state): secret1 = 'x' * 32 hashlock1 = sha3(secret1) lock_amount1 = 29 lock_expiration1 = 1158003 lock1 = Lock(lock_amount1, lock_expiration1, hashlock1) lockhash1 = sha3(lock1.as_bytes) merkleproof1 = [lockhash1] locksroot1 = merkleroot([ lockhash1, ], merkleproof1) nonce = 10 asset = token.address transfered_amount = 1 recipient = tester.a1 msg1 = DirectTransfer( nonce, asset, transfered_amount, recipient, locksroot1, ) msg1.sign(tester.k0) packed = msg1.packed() direct_transfer1 = str(packed.data) secret2 = 'y' * 32 hashlock2 = sha3(secret2) lock_amount2 = 20 lock_expiration2 = 1158030 lock2 = Lock(lock_amount2, lock_expiration2, hashlock2) lockhash2 = sha3(lock2.as_bytes) merkleproof2 = [lockhash2] locksroot2 = merkleroot([ lockhash2, ], merkleproof2) msg2 = DirectTransfer( 2, # nonce asset, 3, # transfered_amount tester.a0, # recipient '', ) msg2.sign(tester.k1) packed = msg2.packed() direct_transfer2 = str(packed.data) channel.close(direct_transfer1, direct_transfer2) channel.unlock( str(lock1.as_bytes), ''.join(merkleproof1), secret1, ) # TODO: it must not be possible to unlock the same lock twive # with pytest.raises(TransactionFailed): # channel.unlock( # str(lock1.as_bytes), # ''.join(merkleproof1), # secret1, # ) # expiration has passed, should fail state.block.number = 1158031 with pytest.raises(TransactionFailed): channel.unlock( str(lock2.as_bytes), ''.join(merkleproof2), secret2, )
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_close_single_direct_transfer(state, channel, token, events): # pylint: disable=too-many-locals,too-many-statements # 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 # test participants variables changed when constructing assert channel.addressAndBalance()[0] == tester.a0.encode('hex') assert channel.addressAndBalance()[2] == tester.a1.encode('hex') # test atIndex() # private must be removed from the function in order to work # assert channel.atIndex(sha3('address1')[:20]) == 0 # assert channel.atIndex(sha3('address2')[:20]) == 1 # test deposit(uint) with pytest.raises(TransactionFailed): channel.deposit(30, sender=tester.k2) # not participant assert token.balanceOf(channel.address) == 0 assert token.approve(channel.address, 30) is True # allow the contract do deposit assert channel.addressAndBalance()[1] == 0 with pytest.raises(TransactionFailed): channel.deposit(5001) channel.deposit(30) assert channel.addressAndBalance()[1] == 30 assert token.balanceOf(channel.address) == 30 assert token.balanceOf(tester.a0) == 4970 assert channel.opened() == state.block.number # test open() # private must be removed from the function in order to work # assert channel.opened() == 0 # channel is not yet opened # channel.open() # assert channel.opened() > 0 # assert channel.opened() <= state.block.number # test partner(address) # private must be removed from the function in order to work # assert channel.partner(sha3('address1')[:20]) == sha3('address2')[:20].encode('hex') # assert channel.partner(sha3('address2')[:20]) == sha3('address1')[:20].encode('hex') # test addressAndBalance() a1, d1, a2, d2 = channel.addressAndBalance() assert a1 == tester.a0.encode('hex') assert a2 == tester.a1.encode('hex') assert d1 == 30 assert d2 == 0 # test close(message) initiator_privkey = tester.k0 recipient_privkey = tester.k1 recipient_address = privtoaddr(recipient_privkey) asset_address = token.address hashlock = sha3(initiator_privkey) lock_amount = 29 lock_expiration = 31 lock = Lock(lock_amount, lock_expiration, hashlock) locksroot = merkleroot([ sha3(lock.as_bytes), ]) nonce = 1 asset = asset_address transfered_amount = 1 recipient = recipient_address locksroot = locksroot msg = DirectTransfer( nonce, asset, transfered_amount, recipient, locksroot, ) msg.sign(initiator_privkey) packed = msg.packed() direct_transfer = str(packed.data) channel.closeSingleTransfer(direct_transfer) with pytest.raises(TransactionFailed): channel.closeSingleTransfer(direct_transfer, sender=tester.k2) # not participant 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] == locksroot # assert channel.participants(0)[7] == '\x00' * 32 assert len(events) == 2 assert events[0]['_event_type'] == 'ChannelNewBalance' assert events[0]['assetAddress'] == token.address.encode('hex') assert events[0]['balance'] == 30 assert events[0]['participant'] == tester.a0.encode('hex') assert events[1]['_event_type'] == 'ChannelClosed' assert events[1]['closingAddress'] == tester.a0.encode('hex') assert events[1]['blockNumber'] == state.block.number
def test_two_messages_direct_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), ]) nonce = 1 asset = token.address transfered_amount = 1 recipient = tester.a1 locksroot = locksroot1 msg1 = DirectTransfer( nonce, asset, transfered_amount, recipient, locksroot, ) msg1.sign(tester.k0) packed = msg1.packed() direct_transfer1 = str(packed.data) hashlock2 = sha3(tester.k1) lock_amount2 = 29 lock_expiration2 = 31 lock2 = Lock(lock_amount2, lock_expiration2, hashlock2) locksroot2 = merkleroot([ sha3(lock2.as_bytes), ]) locksroot = locksroot2 msg2 = DirectTransfer( 2, # nonce token.address, # asset 3, # transfered_amount tester.a0, # recipient locksroot, ) msg2.sign(tester.k1) packed = msg2.packed() direct_transfer2 = str(packed.data) channel.close(direct_transfer1, direct_transfer2) assert len(events) == 1 assert events[0]['_event_type'] == 'ChannelClosed' assert events[0]['closingAddress'] == tester.a0.encode('hex') assert events[0]['blockNumber'] == state.block.number with pytest.raises(TransactionFailed): # not participant channel.close(direct_transfer1, direct_transfer2, sender=tester.k2) # 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')