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_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_withdraw_at_settlement_block( deposit, settle_timeout, tester_nettingcontracts, tester_chain, 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_chain.block.number + settle_timeout secret = b'settlementsettlementsettlementse' hashlock = sha3(secret) lock0 = Lock( amount=lock_amount, 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, channel=normalize_address(nettingchannel.address), transferred_amount=0, recipient=address1, locksroot=lock0_hash, lock=lock0, target=address1, initiator=address0, fee=0, ) sign_key0 = PrivateKey(pkey0) mediated0.sign(sign_key0, address0) mediated0_hash = sha3(mediated0.packed().data[:-65]) nettingchannel.close( mediated0.nonce, mediated0.transferred_amount, mediated0.locksroot, mediated0_hash, mediated0.signature, sender=pkey1, ) block_until_settlement_end = lock_expiration - tester_chain.block.number tester_chain.mine(number_of_blocks=block_until_settlement_end) assert lock_expiration == tester_chain.block.number nettingchannel.withdraw( lock0_bytes, b'', # the lock itself it the root, the proof is empty secret, sender=pkey1, ) tester_chain.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_two_messages_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) 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')