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')
