def test_reopen_channel(private_keys, settle_timeout, tester_channelmanager,
tester_state):
""" A new channel can be opened after the old one is settled. When this
happens the channel manager must update its internal data structures to
point to the new channel address.
"""
log = list()
pkey = private_keys[0]
channels = list()
old_channel_addresses = list()
for partner_pkey in private_keys[1:]:
nettingcontract = new_nettingcontract(
pkey,
partner_pkey,
tester_state,
log.append,
tester_channelmanager,
settle_timeout,
)
channels.append(nettingcontract)
address = privatekey_to_address(partner_pkey)
channel_address = tester_channelmanager.getChannelWith(
address,
sender=pkey,
)
old_channel_addresses.append(channel_address)
for nettingchannel in channels:
netting_channel_settled(
tester_state,
nettingchannel,
pkey,
settle_timeout,
)
channels = list()
for partner_pkey in private_keys[1:]:
nettingcontract = new_nettingcontract(
pkey,
partner_pkey,
tester_state,
log.append,
tester_channelmanager,
settle_timeout,
)
channels.append(nettingcontract)
# there must be a single entry for each participant
for partner_pkey in private_keys[1:]:
address = privatekey_to_address(partner_pkey)
channel_address = tester_channelmanager.getChannelWith(
address,
sender=pkey,
)
assert channel_address
assert channel_address not in old_channel_addresses
def test_reopen_channel(
private_keys,
settle_timeout,
tester_channelmanager,
tester_chain):
""" A new channel can be opened after the old one is settled. When this
happens the channel manager must update its internal data structures to
point to the new channel address.
"""
log = list()
pkey = private_keys[0]
channels = list()
old_channel_addresses = list()
for partner_pkey in private_keys[1:]:
nettingcontract = new_nettingcontract(
pkey, partner_pkey, tester_chain, log.append, tester_channelmanager, settle_timeout,
)
channels.append(nettingcontract)
address = privatekey_to_address(partner_pkey)
channel_address = tester_channelmanager.getChannelWith(
address,
sender=pkey,
)
old_channel_addresses.append(channel_address)
for nettingchannel in channels:
netting_channel_settled(
tester_chain,
nettingchannel,
pkey,
settle_timeout,
)
channels = list()
for partner_pkey in private_keys[1:]:
nettingcontract = new_nettingcontract(
pkey, partner_pkey, tester_chain, log.append, tester_channelmanager, settle_timeout,
)
channels.append(nettingcontract)
# there must be a single entry for each participant
for partner_pkey in private_keys[1:]:
address = privatekey_to_address(partner_pkey)
channel_address = tester_channelmanager.getChannelWith(
address,
sender=pkey,
)
assert channel_address
assert channel_address not in old_channel_addresses
def test_reopen_regression_bad_index_update(private_keys, settle_timeout,
tester_channelmanager,
tester_state):
""" deleteChannel used the wrong address to update the node_index mapping.
Correct usage would be
(addr0, addr1) => channel_idx
But instead of overwriting the existing index, a new entry was added as:
(addr0, channel_addr) => channel_idx
"""
pkey0 = private_keys[0]
pkey1 = private_keys[1]
pkey2 = private_keys[2]
addr1 = privatekey_to_address(pkey1)
tester_channelmanager.newChannel(
addr1,
settle_timeout,
sender=pkey0,
)
log = list()
nettingchannel = new_nettingcontract(
pkey0,
pkey2,
tester_state,
log.append,
tester_channelmanager,
settle_timeout,
)
netting_channel_settled(
tester_state,
nettingchannel,
pkey0,
settle_timeout,
)
nettingchannel = new_nettingcontract(
pkey0,
pkey2,
tester_state,
log.append,
tester_channelmanager,
settle_timeout,
)
def test_new_channel_state(private_keys, tester_chain, tester_channelmanager):
""" Tests the state of a newly created netting channel. """
pkey0, pkey1 = private_keys
events = list()
settle_timeout = 10
channel = new_nettingcontract(
pkey0,
pkey1,
tester_chain,
events.append,
tester_channelmanager,
settle_timeout,
)
# pylint: disable=no-member
assert channel.settleTimeout(sender=pkey0) == settle_timeout
assert channel.tokenAddress(sender=pkey0) == tester_channelmanager.tokenAddress(sender=pkey0)
assert channel.opened(sender=pkey0) == tester_chain.block.number - 1
assert channel.closed(sender=pkey0) == 0
address_and_balances = channel.addressAndBalance(sender=pkey0)
address0 = privatekey_to_address(pkey0)
address1 = privatekey_to_address(pkey1)
assert address_and_balances[0] == address_encoder(address0)
assert address_and_balances[1] == 0
assert address_and_balances[2] == address_encoder(address1)
assert address_and_balances[3] == 0
def test_new_channel(private_keys, tester_state, tester_channelmanager):
""" Tests the state of a newly created netting channel. """
pkey0, pkey1 = private_keys
events = list()
settle_timeout = 10
channel = new_nettingcontract(
pkey0,
pkey1,
tester_state,
events.append,
tester_channelmanager,
settle_timeout,
)
assert channel.settleTimeout(sender=pkey0) == settle_timeout
assert channel.tokenAddress(
sender=pkey0) == tester_channelmanager.tokenAddress(sender=pkey0)
assert channel.opened(sender=pkey0) == 0
assert channel.closed(sender=pkey0) == 0
assert channel.settled(sender=pkey0) == 0
address_and_balances = channel.addressAndBalance(sender=pkey0)
address0 = privatekey_to_address(pkey0)
address1 = privatekey_to_address(pkey1)
assert address_and_balances[0] == encode_hex(address0)
assert address_and_balances[1] == 0
assert address_and_balances[2] == encode_hex(address1)
assert address_and_balances[3] == 0
def test_new_channel_state(private_keys, tester_chain, tester_channelmanager):
""" Tests the state of a newly created netting channel. """
pkey0, pkey1 = private_keys
events = list()
settle_timeout = 10
channel = new_nettingcontract(
pkey0,
pkey1,
tester_chain,
events.append,
tester_channelmanager,
settle_timeout,
)
# pylint: disable=no-member
assert channel.settleTimeout(sender=pkey0) == settle_timeout
assert channel.tokenAddress(sender=pkey0) == tester_channelmanager.tokenAddress(sender=pkey0)
assert channel.opened(sender=pkey0) == tester_chain.block.number - 1
assert channel.closed(sender=pkey0) == 0
address_and_balances = channel.addressAndBalance(sender=pkey0)
address0 = privatekey_to_address(pkey0)
address1 = privatekey_to_address(pkey1)
assert address_and_balances[0] == address_encoder(address0)
assert address_and_balances[1] == 0
assert address_and_balances[2] == address_encoder(address1)
assert address_and_balances[3] == 0
def test_reopen_regression_bad_index_update(
private_keys,
settle_timeout,
tester_channelmanager,
tester_chain):
""" deleteChannel used the wrong address to update the node_index mapping.
Correct usage would be
(addr0, addr1) => channel_idx
But instead of overwriting the existing index, a new entry was added as:
(addr0, channel_addr) => channel_idx
"""
pkey0 = private_keys[0]
pkey1 = private_keys[1]
pkey2 = private_keys[2]
addr1 = privatekey_to_address(pkey1)
tester_channelmanager.newChannel(
addr1,
settle_timeout,
sender=pkey0,
)
log = list()
nettingchannel = new_nettingcontract(
pkey0, pkey2, tester_chain, log.append, tester_channelmanager, settle_timeout,
)
netting_channel_settled(
tester_chain,
nettingchannel,
pkey0,
settle_timeout,
)
nettingchannel = new_nettingcontract(
pkey0, pkey2, tester_chain, log.append, tester_channelmanager, settle_timeout,
)
def tester_nettingcontracts(
deposit,
both_participants_deposit,
private_keys,
settle_timeout,
tester_state,
tester_events,
tester_channelmanager,
tester_token):
raiden_chain = zip(private_keys[:-1], private_keys[1:])
result = list()
for pos, (first_key, second_key) in enumerate(raiden_chain, start=1):
# tester.py log_listener is enabled for the whole tester, meaning that
# a log_listener will receive all events that it can decode, even if
# the event is from a different contract, because of that we _must_
# only install the log_listener for the first ABI, otherwise the logs
# will be repeated for each ABI
if pos == 1:
log_listener = tester_events.append
else:
log_listener = None
nettingcontract = new_nettingcontract(
first_key,
second_key,
tester_state,
log_listener,
tester_channelmanager,
settle_timeout,
)
result.append(
(first_key, second_key, nettingcontract),
)
approve_and_deposit(
tester_token,
nettingcontract,
deposit,
first_key,
)
if both_participants_deposit:
approve_and_deposit(
tester_token,
nettingcontract,
deposit,
second_key,
)
return result
def test_deposit(private_keys, tester_channelmanager, tester_state,
tester_token):
""" A call to deposit must increase the available token amount in the
netting channel.
"""
pkey0 = private_keys[0]
pkey1 = private_keys[1]
address0 = encode_hex(privatekey_to_address(pkey0))
address1 = encode_hex(privatekey_to_address(pkey1))
settle_timeout = 10
events = list()
# not using the tester_nettingcontracts fixture because it has a set balance
channel = new_nettingcontract(
pkey0,
pkey1,
tester_state,
events.append,
tester_channelmanager,
settle_timeout,
)
deposit = 100
# cannot deposit without approving
assert channel.deposit(deposit, sender=pkey0) is False
assert tester_token.approve(channel.address, deposit, sender=pkey0) is True
# cannot deposit negative values
with pytest.raises(abi.ValueOutOfBounds):
channel.deposit(-1, sender=pkey0)
zero_state = (address0, 0, address1, 0)
assert tuple(channel.addressAndBalance(sender=pkey0)) == zero_state
assert channel.deposit(deposit, sender=pkey0) is True
deposit_state = (address0, deposit, address1, 0)
assert tuple(channel.addressAndBalance(sender=pkey0)) == deposit_state
assert tester_token.balanceOf(channel.address, sender=pkey0) == deposit
# cannot over deposit (the allowance is depleted)
assert channel.deposit(deposit, sender=pkey0) is False
assert tester_token.approve(channel.address, deposit, sender=pkey0) is True
assert channel.deposit(deposit, sender=pkey0) is True
second_deposit_state = (address0, deposit * 2, address1, 0)
assert tuple(
channel.addressAndBalance(sender=pkey0)) == second_deposit_state
def test_deposit(private_keys, tester_channelmanager, tester_chain, tester_token):
""" A call to deposit must increase the available token amount in the
netting channel.
"""
pkey0 = private_keys[0]
pkey1 = private_keys[1]
address0 = address_encoder(privatekey_to_address(pkey0))
address1 = address_encoder(privatekey_to_address(pkey1))
settle_timeout = 10
events = list()
# not using the tester_nettingcontracts fixture because it has a set balance
channel = new_nettingcontract(
pkey0,
pkey1,
tester_chain,
events.append,
tester_channelmanager,
settle_timeout,
)
deposit = 100
# cannot deposit without approving
assert channel.deposit(deposit, sender=pkey0) is False
assert tester_token.approve(channel.address, deposit, sender=pkey0) is True
# cannot deposit negative values
with pytest.raises(abi.ValueOutOfBounds):
channel.deposit(-1, sender=pkey0)
zero_state = (address0, 0, address1, 0)
assert tuple(channel.addressAndBalance(sender=pkey0)) == zero_state
assert channel.deposit(deposit, sender=pkey0) is True
deposit_state = (address0, deposit, address1, 0)
assert tuple(channel.addressAndBalance(sender=pkey0)) == deposit_state
assert tester_token.balanceOf(channel.address, sender=pkey0) == deposit
# cannot over deposit (the allowance is depleted)
assert channel.deposit(deposit, sender=pkey0) is False
assert tester_token.approve(channel.address, deposit, sender=pkey0) is True
assert channel.deposit(deposit, sender=pkey0) is True
second_deposit_state = (address0, deposit * 2, address1, 0)
assert tuple(channel.addressAndBalance(sender=pkey0)) == second_deposit_state
def test_deposit_events(
private_keys,
settle_timeout,
tester_chain,
tester_channelmanager,
tester_token,
tester_events):
""" A deposit must emit the events Transfer and a ChannelNewBalance. """
private_key = private_keys[0]
address = privatekey_to_address(private_key)
nettingchannel = new_nettingcontract(
private_key,
private_keys[1],
tester_chain,
tester_events.append,
tester_channelmanager,
settle_timeout,
)
initial_balance0 = tester_token.balanceOf(address, sender=private_key)
deposit_amount = initial_balance0 // 10
assert tester_token.approve(nettingchannel.address, deposit_amount, sender=private_key) is True
assert nettingchannel.deposit(deposit_amount, sender=private_key) is True
transfer_event = event_decoder(tester_events[-2], tester_token.translator)
newbalance_event = event_decoder(tester_events[-1], nettingchannel.translator)
assert transfer_event == {
'_event_type': b'Transfer',
'_from': address_encoder(address),
'_to': nettingchannel.address,
'_value': deposit_amount,
}
assert newbalance_event['_event_type'] == b'ChannelNewBalance'
assert newbalance_event['token_address'] == address_encoder(tester_token.address)
assert newbalance_event['participant'] == address_encoder(address)
assert newbalance_event['balance'] == deposit_amount
def test_deposit_events(private_keys, settle_timeout, tester_state,
tester_channelmanager, tester_token, tester_events):
""" A deposit must emit the events Transfer and a ChannelNewBalance. """
private_key = private_keys[0]
address = privatekey_to_address(private_key)
nettingchannel = new_nettingcontract(
private_key,
private_keys[1],
tester_state,
tester_events.append,
tester_channelmanager,
settle_timeout,
)
initial_balance0 = tester_token.balanceOf(address, sender=private_key)
deposit_amount = initial_balance0 // 10
assert tester_token.approve(
nettingchannel.address, deposit_amount, sender=private_key) is True
assert nettingchannel.deposit(deposit_amount, sender=private_key) is True
transfer_event = tester_events[-2]
newbalance_event = tester_events[-1]
assert transfer_event == {
'_event_type': 'Transfer',
'_from': encode_hex(address),
'_to': nettingchannel.address,
'_value': deposit_amount,
}
block_number = tester_state.block.number
assert newbalance_event == {
'_event_type': 'ChannelNewBalance',
'token_address': encode_hex(tester_token.address),
'participant': encode_hex(address),
'balance': deposit_amount,
'block_number': block_number,
}
def test_deposit_events(private_keys, settle_timeout, tester_chain,
tester_channelmanager, tester_token, tester_events):
""" A deposit must emit the events Transfer and a ChannelNewBalance. """
private_key = private_keys[0]
address = privatekey_to_address(private_key)
nettingchannel = new_nettingcontract(
private_key,
private_keys[1],
tester_chain,
tester_events.append,
tester_channelmanager,
settle_timeout,
)
initial_balance0 = tester_token.balanceOf(address, sender=private_key)
deposit_amount = initial_balance0 // 10
assert tester_token.approve(
nettingchannel.address, deposit_amount, sender=private_key) is True
assert nettingchannel.deposit(deposit_amount, sender=private_key) is True
transfer_event = event_decoder(tester_events[-2], tester_token.translator)
newbalance_event = event_decoder(tester_events[-1],
nettingchannel.translator)
assert transfer_event == {
'_event_type': b'Transfer',
'_from': address_encoder(address),
'_to': nettingchannel.address,
'_value': deposit_amount,
}
assert newbalance_event['_event_type'] == b'ChannelNewBalance'
assert newbalance_event['token_address'] == address_encoder(
tester_token.address)
assert newbalance_event['participant'] == address_encoder(address)
assert newbalance_event['balance'] == deposit_amount
def tester_nettingcontracts(deposit, private_keys, settle_timeout,
tester_state, tester_events, tester_channelmanager,
tester_token):
raiden_chain = zip(private_keys[:-1], private_keys[1:])
result = list()
for pos, (first_key, second_key) in enumerate(raiden_chain, start=1):
# tester.py log_listener is enabled for the whole tester, meaning that
# a log_listener will receive all events that it can decode, even if
# the event is from a different contract, because of that we _must_
# only install the log_listener for the first ABI, otherwise the logs
# will be repeated for each ABI
if pos == 1:
log_listener = tester_events.append
else:
log_listener = None
nettingcontract = new_nettingcontract(
first_key,
second_key,
tester_state,
log_listener,
tester_channelmanager,
settle_timeout,
)
result.append(
(first_key, second_key, nettingcontract),
)
assert tester_token.approve(nettingcontract.address, deposit, sender=first_key) is True
assert tester_token.approve(nettingcontract.address, deposit, sender=second_key) is True
assert nettingcontract.deposit(deposit, sender=first_key) is True
assert nettingcontract.deposit(deposit, sender=second_key) is True
return result
def test_channeldeposit(private_keys, settle_timeout, tester_state,
tester_token, tester_events, tester_registry):
""" Guarantee the correct tracking of each participant deposits, checks the
initial state (pre-deposit) and state changes for each deposits.
"""
# not using the tester_nettingcontracts fixture to control the
# transfer/deposits
privatekey0 = private_keys[0]
privatekey1 = private_keys[1]
address0 = privatekey_to_address(privatekey0)
address1 = privatekey_to_address(privatekey1)
unknow_key = tester.k3
channel_manager = new_channelmanager(
privatekey0,
tester_state,
tester_events.append,
tester_registry,
tester_token,
)
channel = new_nettingcontract(
privatekey0,
privatekey1,
tester_state,
tester_events.append,
channel_manager,
settle_timeout,
)
# check initial state, needs to be zeroed out
assert channel.settleTimeout(sender=privatekey0) == settle_timeout
assert channel.tokenAddress(sender=privatekey0) == encode_hex(
tester_token.address)
assert channel.opened(sender=privatekey0) == 0
assert channel.closed(sender=privatekey0) == 0
assert channel.settled(sender=privatekey0) == 0
assert channel.addressAndBalance(
sender=privatekey0)[0] == encode_hex(address0)
assert channel.addressAndBalance(sender=privatekey0)[1] == 0
assert channel.addressAndBalance(
sender=privatekey0)[2] == encode_hex(address1)
assert channel.addressAndBalance(sender=privatekey0)[3] == 0
initial_balance0 = tester_token.balanceOf(address0, sender=privatekey0)
deposit_amount = initial_balance0 // 10
# try to make invalid deposits
with pytest.raises(TransactionFailed):
channel.deposit(1, sender=unknow_key) # not participant
assert tester_token.approve(
channel.address, deposit_amount * 2, sender=privatekey0) is True
assert channel.deposit(deposit_amount * 2 + 1, sender=privatekey0) is False
with pytest.raises(abi.ValueOutOfBounds):
channel.deposit(-1, sender=privatekey0)
# create a first deposit with half of the allowance
assert channel.deposit(deposit_amount, sender=privatekey0) is True
assert tester_token.balanceOf(channel.address,
sender=privatekey0) == deposit_amount
assert tester_token.balanceOf(
address0,
sender=privatekey0) == initial_balance0 - deposit_amount # noqa
assert channel.opened(sender=privatekey0) == tester_state.block.number
assert channel.addressAndBalance(
sender=privatekey0)[0] == encode_hex(address0)
assert channel.addressAndBalance(sender=privatekey0)[1] == deposit_amount
assert channel.addressAndBalance(
sender=privatekey0)[2] == encode_hex(address1)
assert channel.addressAndBalance(sender=privatekey0)[3] == 0
# check a second depoist with the rest of the allowance
assert channel.deposit(deposit_amount, sender=privatekey0) is True
assert tester_token.balanceOf(channel.address,
sender=privatekey0) == deposit_amount * 2
assert tester_token.balanceOf(
address0,
sender=privatekey0) == initial_balance0 - deposit_amount * 2 # noqa
assert channel.opened(sender=privatekey0) == tester_state.block.number
assert channel.addressAndBalance(
sender=privatekey0)[0] == encode_hex(address0)
assert channel.addressAndBalance(
sender=privatekey0)[1] == deposit_amount * 2
assert channel.addressAndBalance(
sender=privatekey0)[2] == encode_hex(address1)
assert channel.addressAndBalance(sender=privatekey0)[3] == 0
# allowance zeroed, we cant make a new deposit
assert channel.deposit(deposit_amount, sender=privatekey0) is False
# needs to be able to add aditional token
assert tester_token.approve(
channel.address, deposit_amount, sender=privatekey0) is True
assert channel.deposit(deposit_amount, sender=privatekey0) is True
assert tester_token.balanceOf(channel.address,
sender=privatekey0) == deposit_amount * 3
assert tester_token.balanceOf(
address0,
sender=privatekey0) == initial_balance0 - deposit_amount * 3 # noqa
assert channel.opened(sender=privatekey0) == tester_state.block.number
assert channel.addressAndBalance(
sender=privatekey0)[0] == encode_hex(address0)
assert channel.addressAndBalance(
sender=privatekey0)[1] == deposit_amount * 3
assert channel.addressAndBalance(
sender=privatekey0)[2] == encode_hex(address1)
assert channel.addressAndBalance(sender=privatekey0)[3] == 0
def test_channelnewbalance_event(private_keys, settle_timeout, tester_state,
tester_events, tester_token, tester_registry):
""" Check the correct events are generated for deposit calls. """
privatekey0 = private_keys[0]
privatekey1 = private_keys[1]
address0 = privatekey_to_address(privatekey0)
address1 = privatekey_to_address(privatekey1)
channel_manager = new_channelmanager(
privatekey0,
tester_state,
tester_events.append,
tester_registry,
tester_token,
)
nettingchannel = new_nettingcontract(
privatekey0,
privatekey1,
tester_state,
tester_events.append,
channel_manager,
settle_timeout,
)
initial_balance0 = tester_token.balanceOf(address0, sender=privatekey0)
deposit_amount = initial_balance0 // 10
assert tester_token.approve(
nettingchannel.address, deposit_amount, sender=privatekey0) is True
assert tester_token.approve(
nettingchannel.address, deposit_amount, sender=privatekey1) is True
previous_events = list(tester_events)
assert nettingchannel.deposit(deposit_amount, sender=privatekey0) is True
assert len(previous_events) + 2 == len(tester_events)
block_number = tester_state.block.number
transfer_event = tester_events[-2]
assert transfer_event == {
'_event_type': 'Transfer',
'_from': encode_hex(address0),
'_to': nettingchannel.address,
'_value': deposit_amount,
}
newbalance_event = tester_events[-1]
assert newbalance_event == {
'_event_type': 'ChannelNewBalance',
'token_address': encode_hex(tester_token.address),
'participant': encode_hex(address0),
'balance': deposit_amount,
'block_number': block_number,
}
previous_events = list(tester_events)
assert nettingchannel.deposit(deposit_amount, sender=privatekey1) is True
assert len(previous_events) + 2 == len(tester_events)
block_number = tester_state.block.number
transfer_event = tester_events[-2]
assert transfer_event == {
'_event_type': 'Transfer',
'_from': encode_hex(address1),
'_to': nettingchannel.address,
'_value': deposit_amount,
}
newbalance_event = tester_events[-1]
assert newbalance_event == {
'_event_type': 'ChannelNewBalance',
'token_address': encode_hex(tester_token.address),
'participant': encode_hex(address1),
'balance': deposit_amount,
'block_number': block_number,
}
def __init__(self):
super(NettingChannelStateMachine, self).__init__()
deploy_key = sha3('deploy_key')
gas_limit = 10**10
self.private_keys = [
sha3('p1'),
sha3('p2'),
sha3('p3'
), # third key used to generate signed but invalid transfers
]
self.addresses = map(privatekey_to_address, self.private_keys)
self.log = list()
self.tester_state = tester_state(
deploy_key,
self.private_keys,
gas_limit,
)
self.settle_timeout = 50
self.token_amount = 1000
self.tokens = [
new_token(
deploy_key,
self.tester_state,
self.token_amount,
self.log.append,
),
new_token(
deploy_key,
self.tester_state,
self.token_amount,
self.log.append,
),
]
self.token = self.tokens[0]
self.token_addresses = [token.address for token in self.tokens]
self.nettingchannel_library_address = deploy_nettingchannel_library(
deploy_key,
self.tester_state,
)
self.channel_manager_library_address = deploy_channelmanager_library(
deploy_key,
self.tester_state,
self.nettingchannel_library_address,
)
self.registry = new_registry(
deploy_key,
self.tester_state,
self.channel_manager_library_address,
self.log.append,
)
self.channelmanager = new_channelmanager(
deploy_key,
self.tester_state,
self.log.append,
self.registry,
self.token.address,
)
self.netting_channel = new_nettingcontract(
self.private_keys[0],
self.private_keys[1],
self.tester_state,
self.log.append,
self.channelmanager,
self.settle_timeout,
)
address_and_balance = self.netting_channel.addressAndBalance( # pylint: disable=no-member
sender=self.private_keys[0], )
self.closing_address = None
self.update_transfer_called = False
self.participant_addresses = {
unhexlify(address_and_balance[0]),
unhexlify(address_and_balance[2]),
}
self.channel_addresses = [
unhexlify(self.netting_channel.address),
make_address(), # used to test invalid transfers
]
def test_channelnewbalance_event(private_keys, settle_timeout, tester_state,
tester_events, tester_token, tester_registry):
""" Check the correct events are generated for deposit calls. """
privatekey0 = private_keys[0]
privatekey1 = private_keys[1]
address0 = privatekey_to_address(privatekey0)
address1 = privatekey_to_address(privatekey1)
channel_manager = new_channelmanager(
privatekey0,
tester_state,
tester_events.append,
tester_registry,
tester_token,
)
nettingchannel = new_nettingcontract(
privatekey0,
privatekey1,
tester_state,
tester_events.append,
channel_manager,
settle_timeout,
)
initial_balance0 = tester_token.balanceOf(address0, sender=privatekey0)
deposit_amount = initial_balance0 // 10
assert tester_token.approve(nettingchannel.address, deposit_amount, sender=privatekey0) is True
assert tester_token.approve(nettingchannel.address, deposit_amount, sender=privatekey1) is True
previous_events = list(tester_events)
assert nettingchannel.deposit(deposit_amount, sender=privatekey0) is True
assert len(previous_events) + 2 == len(tester_events)
block_number = tester_state.block.number
transfer_event = tester_events[-2]
assert transfer_event == {
'_event_type': 'Transfer',
'_from': encode_hex(address0),
'_to': nettingchannel.address,
'_value': deposit_amount,
}
newbalance_event = tester_events[-1]
assert newbalance_event == {
'_event_type': 'ChannelNewBalance',
'asset_address': encode_hex(tester_token.address),
'participant': encode_hex(address0),
'balance': deposit_amount,
'block_number': block_number,
}
previous_events = list(tester_events)
assert nettingchannel.deposit(deposit_amount, sender=privatekey1) is True
assert len(previous_events) + 2 == len(tester_events)
block_number = tester_state.block.number
transfer_event = tester_events[-2]
assert transfer_event == {
'_event_type': 'Transfer',
'_from': encode_hex(address1),
'_to': nettingchannel.address,
'_value': deposit_amount,
}
newbalance_event = tester_events[-1]
assert newbalance_event == {
'_event_type': 'ChannelNewBalance',
'asset_address': encode_hex(tester_token.address),
'participant': encode_hex(address1),
'balance': deposit_amount,
'block_number': block_number,
}
def test_channeldeposit(private_keys, settle_timeout, tester_state,
tester_token, tester_events, tester_registry):
""" Guarantee the correct tracking of each participant deposits, checks the
initial state (pre-deposit) and state changes for each deposits.
"""
# not using the tester_nettingcontracts fixture to control the
# transfer/deposits
privatekey0 = private_keys[0]
privatekey1 = private_keys[1]
address0 = privatekey_to_address(privatekey0)
address1 = privatekey_to_address(privatekey1)
unknow_key = tester.k3
channel_manager = new_channelmanager(
privatekey0,
tester_state,
tester_events.append,
tester_registry,
tester_token,
)
channel = new_nettingcontract(
privatekey0,
privatekey1,
tester_state,
tester_events.append,
channel_manager,
settle_timeout,
)
# check initial state, needs to be zeroed out
assert channel.settleTimeout(sender=privatekey0) == settle_timeout
assert channel.assetAddress(sender=privatekey0) == encode_hex(tester_token.address)
assert channel.opened(sender=privatekey0) == 0
assert channel.closed(sender=privatekey0) == 0
assert channel.settled(sender=privatekey0) == 0
assert channel.addressAndBalance(sender=privatekey0)[0] == encode_hex(address0)
assert channel.addressAndBalance(sender=privatekey0)[1] == 0
assert channel.addressAndBalance(sender=privatekey0)[2] == encode_hex(address1)
assert channel.addressAndBalance(sender=privatekey0)[3] == 0
initial_balance0 = tester_token.balanceOf(address0, sender=privatekey0)
deposit_amount = initial_balance0 // 10
# try to make invalid deposits
with pytest.raises(TransactionFailed):
channel.deposit(1, sender=unknow_key) # not participant
assert tester_token.approve(channel.address, deposit_amount * 2, sender=privatekey0) is True
assert channel.deposit(deposit_amount * 2 + 1, sender=privatekey0) is False
with pytest.raises(abi.ValueOutOfBounds):
channel.deposit(-1, sender=privatekey0)
# create a first deposit with half of the allowance
assert channel.deposit(deposit_amount, sender=privatekey0) is True
assert tester_token.balanceOf(channel.address, sender=privatekey0) == deposit_amount
assert tester_token.balanceOf(address0, sender=privatekey0) == initial_balance0 - deposit_amount # noqa
assert channel.opened(sender=privatekey0) == tester_state.block.number
assert channel.addressAndBalance(sender=privatekey0)[0] == encode_hex(address0)
assert channel.addressAndBalance(sender=privatekey0)[1] == deposit_amount
assert channel.addressAndBalance(sender=privatekey0)[2] == encode_hex(address1)
assert channel.addressAndBalance(sender=privatekey0)[3] == 0
# check a second depoist with the rest of the allowance
assert channel.deposit(deposit_amount, sender=privatekey0) is True
assert tester_token.balanceOf(channel.address, sender=privatekey0) == deposit_amount * 2
assert tester_token.balanceOf(address0, sender=privatekey0) == initial_balance0 - deposit_amount * 2 # noqa
assert channel.opened(sender=privatekey0) == tester_state.block.number
assert channel.addressAndBalance(sender=privatekey0)[0] == encode_hex(address0)
assert channel.addressAndBalance(sender=privatekey0)[1] == deposit_amount * 2
assert channel.addressAndBalance(sender=privatekey0)[2] == encode_hex(address1)
assert channel.addressAndBalance(sender=privatekey0)[3] == 0
# allowance zeroed, we cant make a new deposit
assert channel.deposit(deposit_amount, sender=privatekey0) is False
# needs to be able to add aditional asset
assert tester_token.approve(channel.address, deposit_amount, sender=privatekey0) is True
assert channel.deposit(deposit_amount, sender=privatekey0) is True
assert tester_token.balanceOf(channel.address, sender=privatekey0) == deposit_amount * 3
assert tester_token.balanceOf(address0, sender=privatekey0) == initial_balance0 - deposit_amount * 3 # noqa
assert channel.opened(sender=privatekey0) == tester_state.block.number
assert channel.addressAndBalance(sender=privatekey0)[0] == encode_hex(address0)
assert channel.addressAndBalance(sender=privatekey0)[1] == deposit_amount * 3
assert channel.addressAndBalance(sender=privatekey0)[2] == encode_hex(address1)
assert channel.addressAndBalance(sender=privatekey0)[3] == 0
