def test_mediated_transfer(iterations=ITERATIONS):
identifier = 1
amount = 1
expiration = 1
hashlock = sha3(ADDRESS)
lock = Lock(amount, expiration, hashlock)
nonce = 1
asset = ADDRESS
balance = 1
recipient = ADDRESS
locksroot = sha3(ADDRESS)
target = ADDRESS
initiator = ADDRESS
msg = MediatedTransfer(
identifier,
nonce,
asset,
balance,
recipient,
locksroot,
lock,
target,
initiator,
fee=0,
)
msg.sign(PRIVKEY, ADDRESS)
run_timeit('MediatedTranfer', msg, iterations=iterations)
def test_mediated_transfer(iterations=ITERATIONS):
identifier = 1
amount = 1
expiration = 1
hashlock = sha3(ADDRESS)
lock = Lock(amount, expiration, hashlock)
nonce = 1
asset = ADDRESS
balance = 1
recipient = ADDRESS
locksroot = sha3(ADDRESS)
target = ADDRESS
initiator = ADDRESS
msg = MediatedTransfer(
identifier,
nonce,
asset,
balance,
recipient,
locksroot,
lock,
target,
initiator,
fee=0,
)
msg.sign(PRIVKEY, ADDRESS)
run_timeit('MediatedTranfer', msg, iterations=iterations)
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 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_decode_mediated_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)
address2 = privatekey_to_address(private_keys[2])
dtester = deploy_decoder_tester(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,
asset=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()) is True
assert dtester.decodedNonce() == 88924902
assert dtester.decodedExpiration() == expiration
assert dtester.decodedAsset() == tester_token.address.encode('hex')
assert dtester.decodedRecipient() == address1.encode('hex')
assert dtester.decodedAmount() == amount
assert dtester.decodedLocksroot() == locksroot
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
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_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_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_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_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_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_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_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')
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(b'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(b'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_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(b'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(b'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,
)
