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_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