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