def test_balances( channel_manager: ChannelManager, confirmed_open_channel: Channel, wait_for_blocks, sender_address: str, use_tester: bool ): blockchain = channel_manager.blockchain initial_liquid_balance = channel_manager.get_liquid_balance() initial_locked_balance = channel_manager.get_locked_balance() if use_tester: assert initial_liquid_balance == 0 assert initial_locked_balance == 0 sig = encode_hex(confirmed_open_channel.create_transfer(5)) channel_manager.register_payment(sender_address, confirmed_open_channel.block, 5, sig) assert channel_manager.get_liquid_balance() == initial_liquid_balance assert channel_manager.get_locked_balance() == 5 receiver_sig = channel_manager.sign_close(sender_address, confirmed_open_channel.block, 5) confirmed_open_channel.close_cooperatively(receiver_sig) wait_for_blocks(blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) assert channel_manager.get_liquid_balance() == initial_liquid_balance + 5 assert channel_manager.get_locked_balance() == initial_locked_balance
def test_cooperative( channel_manager: ChannelManager, confirmed_open_channel: Channel, receiver_address: str, web3: Web3, token_contract: Contract, wait_for_blocks, sender_address: str ): blockchain = channel_manager.blockchain channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block) sig1 = encode_hex(confirmed_open_channel.create_transfer(5)) channel_manager.register_payment(sender_address, confirmed_open_channel.block, 5, sig1) receiver_sig = channel_manager.sign_close(sender_address, confirmed_open_channel.block, 5) channel_rec = channel_manager.channels[channel_id] assert channel_rec.is_closed is True block_before = web3.eth.blockNumber confirmed_open_channel.close_cooperatively(receiver_sig) wait_for_blocks(blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) logs = get_logs(token_contract, 'Transfer', from_block=block_before - 1) assert len([l for l in logs if is_same_address(l['args']['_to'], receiver_address) and l['args']['_value'] == 5]) == 1 assert len([l for l in logs if is_same_address(l['args']['_to'], sender_address) and l['args']['_value'] == 5]) == 1 wait_for_blocks(blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) assert channel_id not in channel_manager.channels
def test_balances( channel_manager: ChannelManager, confirmed_open_channel: Channel, wait_for_blocks, sender_address: str, use_tester: bool ): blockchain = channel_manager.blockchain initial_liquid_balance = channel_manager.get_liquid_balance() initial_locked_balance = channel_manager.get_locked_balance() if use_tester: assert initial_liquid_balance == 0 assert initial_locked_balance == 0 sig = encode_hex(confirmed_open_channel.create_transfer(5)) channel_manager.register_payment(sender_address, confirmed_open_channel.block, 5, sig) assert channel_manager.get_liquid_balance() == initial_liquid_balance assert channel_manager.get_locked_balance() == 5 receiver_sig = channel_manager.sign_close(sender_address, confirmed_open_channel.block, 5) confirmed_open_channel.close_cooperatively(receiver_sig) wait_for_blocks(blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) assert channel_manager.get_liquid_balance() == initial_liquid_balance + 5 assert channel_manager.get_locked_balance() == initial_locked_balance
def test_cooperative( channel_manager: ChannelManager, confirmed_open_channel: Channel, receiver_address: str, web3: Web3, token_contract: Contract, wait_for_blocks, sender_address: str ): blockchain = channel_manager.blockchain channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block) sig1 = encode_hex(confirmed_open_channel.create_transfer(5)) channel_manager.register_payment(sender_address, confirmed_open_channel.block, 5, sig1) receiver_sig = channel_manager.sign_close(sender_address, confirmed_open_channel.block, 5) channel_rec = channel_manager.channels[channel_id] assert channel_rec.is_closed is True block_before = web3.eth.blockNumber confirmed_open_channel.close_cooperatively(receiver_sig) wait_for_blocks(blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) logs = get_logs(token_contract, 'Transfer', from_block=block_before - 1) assert len([l for l in logs if is_same_address(l['args']['_to'], receiver_address) and l['args']['_value'] == 5]) == 1 assert len([l for l in logs if is_same_address(l['args']['_to'], sender_address) and l['args']['_value'] == 5]) == 1 wait_for_blocks(blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) assert channel_id not in channel_manager.channels
def test_close_valid_close(client: Client, channel_manager: ChannelManager, web3: Web3, wait_for_blocks): sender = client.context.address receiver = channel_manager.receiver channel = client.open_channel(receiver, 10) wait_for_blocks(channel_manager.n_confirmations + 1) channel_manager.register_payment(sender, channel.block, 2, encode_hex(channel.create_transfer(2))) channel.close() channel_manager.stop() # don't update state from this point on channel_manager.join() state = channel_manager.state tx_count_before = web3.eth.getTransactionCount(receiver) close_open_channels(channel_manager.private_key, state, channel_manager.channel_manager_contract, wait=lambda: wait_for_blocks(1)) tx_count_after = web3.eth.getTransactionCount(receiver) assert tx_count_after == tx_count_before + 1 with pytest.raises((BadFunctionCallOutput, TransactionFailed)): channel_id = (channel.sender, channel.receiver, channel.block) channel_manager.channel_manager_contract.call().getChannelInfo( *channel_id) wait_for_blocks(1)
def test_settlement( channel_manager: ChannelManager, confirmed_open_channel: Channel, receiver_address: str, wait_for_blocks, web3: Web3, token_contract: Contract, sender_address: str ): blockchain = channel_manager.blockchain channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block) sig = encode_hex(confirmed_open_channel.create_transfer(2)) channel_manager.register_payment(sender_address, confirmed_open_channel.block, 2, sig) confirmed_open_channel.close() wait_for_blocks(blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) block_before = web3.eth.blockNumber channel_rec = channel_manager.channels[channel_id] wait_for_blocks(channel_rec.settle_timeout - block_before) confirmed_open_channel.settle() logs = get_logs(token_contract, 'Transfer', from_block=block_before - 1) assert len([l for l in logs if is_same_address(l['args']['_to'], receiver_address) and l['args']['_value'] == 2]) == 1 assert len([l for l in logs if is_same_address(l['args']['_to'], sender_address) and l['args']['_value'] == 8]) == 1 wait_for_blocks(blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) assert channel_id not in channel_manager.channels
def test_close_settled(client: Client, channel_manager: ChannelManager, web3: Web3, wait_for_blocks): sender = client.context.address receiver = channel_manager.receiver channel = client.open_channel(receiver, 10) wait_for_blocks(channel_manager.n_confirmations + 1) channel_manager.register_payment(sender, channel.block, 2, encode_hex(channel.create_transfer(2))) receiver_sig = channel_manager.sign_close(sender, channel.block, 2) channel.close_cooperatively(receiver_sig) wait_for_blocks(channel_manager.n_confirmations + 1) channel_manager.stop() # don't update state from this point on channel_manager.join() state = channel_manager.state tx_count_before = web3.eth.getTransactionCount(receiver) close_open_channels(channel_manager.private_key, state, channel_manager.channel_manager_contract, wait=lambda: wait_for_blocks(1)) tx_count_after = web3.eth.getTransactionCount(receiver) assert tx_count_after == tx_count_before wait_for_blocks(1)
def test_withdraw_above_minimum( client: Client, channel_manager: ChannelManager, web3: Web3, wait_for_blocks ): sender = client.context.address receiver = channel_manager.receiver channel = client.open_channel(receiver, 10) wait_for_blocks(channel_manager.n_confirmations + 1) channel_manager.register_payment(sender, channel.block, 4, encode_hex(channel.create_transfer(4))) channel_manager.stop() # don't update state from this point on channel_manager.join() state = channel_manager.state tx_count_before = web3.eth.getTransactionCount(receiver) withdraw_from_channels( channel_manager.private_key, state, channel_manager.channel_manager_contract, 3, wait=lambda: wait_for_blocks(1) ) tx_count_after = web3.eth.getTransactionCount(receiver) assert tx_count_after == tx_count_before + 1 channel_id = (channel.sender, channel.receiver, channel.block) channel_info = channel_manager.channel_manager_contract.call().getChannelInfo(*channel_id) _, deposit, settle_block_number, closing_balance, transferred_tokens = channel_info assert transferred_tokens == 4 wait_for_blocks(1)
def test_cooperative_wrong_balance_proof( channel_manager: ChannelManager, confirmed_open_channel: Channel, sender_address: str ): channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block) channel_rec = channel_manager.channels[channel_id] sig1 = encode_hex(confirmed_open_channel.create_transfer(5)) channel_manager.register_payment(sender_address, confirmed_open_channel.block, 5, sig1) sig2 = encode_hex(confirmed_open_channel.create_transfer(1)) with pytest.raises(InvalidBalanceProof): channel_manager.sign_close(sender_address, confirmed_open_channel.block, sig2) assert channel_rec.is_closed is False
def test_cooperative_wrong_balance_proof( channel_manager: ChannelManager, confirmed_open_channel: Channel, sender_address: str ): channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block) channel_rec = channel_manager.channels[channel_id] sig1 = encode_hex(confirmed_open_channel.create_transfer(5)) channel_manager.register_payment(sender_address, confirmed_open_channel.block, 5, sig1) sig2 = encode_hex(confirmed_open_channel.create_transfer(1)) with pytest.raises(InvalidBalanceProof): channel_manager.sign_close(sender_address, confirmed_open_channel.block, sig2) assert channel_rec.is_closed is False
def test_challenge( channel_manager: ChannelManager, confirmed_open_channel: Channel, receiver_address: str, sender_address: str, wait_for_blocks, web3: Web3, client: Client ): blockchain = channel_manager.blockchain channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block) sig = encode_hex(confirmed_open_channel.create_transfer(5)) channel_manager.register_payment(sender_address, confirmed_open_channel.block, 5, sig) # hack channel to decrease balance confirmed_open_channel.update_balance(0) sig = confirmed_open_channel.create_transfer(3) block_before = web3.eth.blockNumber confirmed_open_channel.close() # should challenge and immediately settle for waited_blocks in count(): logs = get_logs(client.context.token, 'Transfer', from_block=block_before - 1) if logs: break wait_for_blocks(1) assert waited_blocks < 10 assert len([l for l in logs if is_same_address(l['args']['_to'], receiver_address) and l['args']['_value'] == 5]) == 1 assert len([l for l in logs if is_same_address(l['args']['_to'], sender_address) and l['args']['_value'] == 5]) == 1 wait_for_blocks(blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) assert channel_id not in channel_manager.channels # update channel state so that it will not be closed twice client.sync_channels() new_state = None for channel in client.channels: if all(channel.sender == confirmed_open_channel.sender, channel.receiver == confirmed_open_channel.receiver, channel.block == confirmed_open_channel.block): new_state = channel.state if new_state is None: confirmed_open_channel.state = confirmed_open_channel.State.closed else: confirmed_open_channel.state = new_state
def test_challenge( channel_manager: ChannelManager, confirmed_open_channel: Channel, receiver_address: str, sender_address: str, wait_for_blocks, web3: Web3, client: Client ): blockchain = channel_manager.blockchain channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block) sig = encode_hex(confirmed_open_channel.create_transfer(5)) channel_manager.register_payment(sender_address, confirmed_open_channel.block, 5, sig) # hack channel to decrease balance confirmed_open_channel.update_balance(0) sig = confirmed_open_channel.create_transfer(3) block_before = web3.eth.blockNumber confirmed_open_channel.close() # should challenge and immediately settle for waited_blocks in count(): logs = get_logs(client.context.token, 'Transfer', from_block=block_before - 1) if logs: break wait_for_blocks(1) assert waited_blocks < 10 assert len([l for l in logs if is_same_address(l['args']['_to'], receiver_address) and l['args']['_value'] == 5]) == 1 assert len([l for l in logs if is_same_address(l['args']['_to'], sender_address) and l['args']['_value'] == 5]) == 1 wait_for_blocks(blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) assert channel_id not in channel_manager.channels # update channel state so that it will not be closed twice client.sync_channels() new_state = None for channel in client.channels: if all(channel.sender == confirmed_open_channel.sender, channel.receiver == confirmed_open_channel.receiver, channel.block == confirmed_open_channel.block): new_state = channel.state if new_state is None: confirmed_open_channel.state = confirmed_open_channel.State.closed else: confirmed_open_channel.state = new_state
def test_settlement( channel_manager: ChannelManager, confirmed_open_channel: Channel, receiver_address: str, wait_for_blocks, web3: Web3, token_contract: Contract, sender_address: str, use_tester: bool ): if not use_tester: pytest.skip('This test takes several hours on real blockchains.') blockchain = channel_manager.blockchain channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block) sig = encode_hex(confirmed_open_channel.create_transfer(2)) channel_manager.register_payment(sender_address, confirmed_open_channel.block, 2, sig) confirmed_open_channel.close() wait_for_blocks(blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) block_before = web3.eth.blockNumber channel_rec = channel_manager.channels[channel_id] wait_for_blocks(channel_rec.settle_timeout - block_before) confirmed_open_channel.settle() logs = get_logs(token_contract, 'Transfer', from_block=block_before - 1) assert len([l for l in logs if is_same_address(l['args']['_to'], receiver_address) and l['args']['_value'] == 2]) == 1 assert len([l for l in logs if is_same_address(l['args']['_to'], sender_address) and l['args']['_value'] == 8]) == 1 wait_for_blocks(blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) assert channel_id not in channel_manager.channels
def test_payment( channel_manager: ChannelManager, confirmed_open_channel, receiver_address: str, receiver_privkey: str, sender_privkey: str, sender_address: str ): channel_manager.wait_sync() channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block) channel_rec = channel_manager.channels[channel_id] assert channel_rec.last_signature is None assert channel_rec.balance == 0 # valid transfer sig1 = encode_hex(confirmed_open_channel.create_transfer(2)) channel_manager.register_payment(sender_address, channel_rec.open_block_number, 2, sig1) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 # transfer signed with wrong private key invalid_sig = encode_hex(sign_balance_proof( receiver_privkey, # should be sender's privkey channel_rec.receiver, channel_rec.open_block_number, 4, channel_manager.channel_manager_contract.address )) with pytest.raises(InvalidBalanceProof): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4, invalid_sig) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 # transfer to different receiver invalid_sig = encode_hex(sign_balance_proof( sender_privkey, sender_address, # should be receiver's address channel_rec.open_block_number, 4, channel_manager.channel_manager_contract.address )) with pytest.raises(InvalidBalanceProof): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4, invalid_sig) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 # transfer negative amount invalid_sig = encode_hex(sign_balance_proof( sender_privkey, receiver_address, channel_rec.open_block_number, 1, # should be greater than 2 channel_manager.channel_manager_contract.address )) with pytest.raises(InvalidBalanceAmount): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 1, invalid_sig) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 # parameters should match balance proof sig2 = encode_hex(confirmed_open_channel.create_transfer(2)) with pytest.raises(NoOpenChannel): channel_manager.register_payment(receiver_address, channel_rec.open_block_number, 4, sig2) with pytest.raises(NoOpenChannel): channel_manager.register_payment(sender_address, channel_rec.open_block_number + 1, 4, sig2) with pytest.raises(InvalidBalanceProof): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 5, sig2) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4, sig2) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 4 assert channel_rec.last_signature == sig2 # should transfer up to deposit sig3 = encode_hex(confirmed_open_channel.create_transfer(6)) channel_manager.register_payment(sender_address, channel_rec.open_block_number, 10, sig3) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 10 assert channel_rec.last_signature == sig3 # transfer too much invalid_sig = encode_hex(sign_balance_proof( sender_privkey, receiver_address, channel_rec.open_block_number, 12, # should not be greater than 10 channel_manager.channel_manager_contract.address )) with pytest.raises(InvalidBalanceProof): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 12, invalid_sig) assert channel_rec.balance == 10 assert channel_rec.last_signature == sig3
def test_payment( channel_manager: ChannelManager, confirmed_open_channel, receiver_address: str, receiver_privkey: str, sender_privkey: str, sender_address: str ): channel_manager.wait_sync() channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block) channel_rec = channel_manager.channels[channel_id] assert channel_rec.last_signature is None assert channel_rec.balance == 0 # valid transfer sig1 = encode_hex(confirmed_open_channel.create_transfer(2)) channel_manager.register_payment(sender_address, channel_rec.open_block_number, 2, sig1) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 # transfer signed with wrong private key invalid_sig = encode_hex(sign_balance_proof( receiver_privkey, # should be sender's privkey channel_rec.receiver, channel_rec.open_block_number, 4, channel_manager.channel_manager_contract.address )) with pytest.raises(InvalidBalanceProof): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4, invalid_sig) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 # transfer to different receiver invalid_sig = encode_hex(sign_balance_proof( sender_privkey, sender_address, # should be receiver's address channel_rec.open_block_number, 4, channel_manager.channel_manager_contract.address )) with pytest.raises(InvalidBalanceProof): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4, invalid_sig) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 # transfer negative amount invalid_sig = encode_hex(sign_balance_proof( sender_privkey, receiver_address, channel_rec.open_block_number, 1, # should be greater than 2 channel_manager.channel_manager_contract.address )) with pytest.raises(InvalidBalanceAmount): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 1, invalid_sig) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 # parameters should match balance proof sig2 = encode_hex(confirmed_open_channel.create_transfer(2)) with pytest.raises(NoOpenChannel): channel_manager.register_payment(receiver_address, channel_rec.open_block_number, 4, sig2) with pytest.raises(NoOpenChannel): channel_manager.register_payment(sender_address, channel_rec.open_block_number + 1, 4, sig2) with pytest.raises(InvalidBalanceProof): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 5, sig2) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4, sig2) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 4 assert channel_rec.last_signature == sig2 # should transfer up to deposit sig3 = encode_hex(confirmed_open_channel.create_transfer(6)) channel_manager.register_payment(sender_address, channel_rec.open_block_number, 10, sig3) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 10 assert channel_rec.last_signature == sig3 # transfer too much invalid_sig = encode_hex(sign_balance_proof( sender_privkey, receiver_address, channel_rec.open_block_number, 12, # should not be greater than 10 channel_manager.channel_manager_contract.address )) with pytest.raises(InvalidBalanceProof): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 12, invalid_sig) assert channel_rec.balance == 10 assert channel_rec.last_signature == sig3
def test_payment(channel_manager: ChannelManager, confirmed_open_channel, receiver_address: str, receiver_privkey: str, sender_privkey: str, sender_address: str, block_num): #channel_manager.wait_sync() #confirmed_open_channel.sender = "0x09226F56C5699E2d87700179507cf25FA2F79F6b" #confirmed_open_channel.block = 2000508 #channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block) channel_id = ('0xA7Ac54048B81041dbD527B603175C17473CE2d95', block_num) print("channels: ", channel_manager.channels) channel_rec = channel_manager.channels[channel_id] print("last_sig: ", channel_rec.last_signature) print("old_sig: ", channel_rec.old_signature) print("balance: ", channel_rec.balance) print("old_balance: ", channel_rec.old_balance) print("sender_address: ", sender_address) print("receiver_address: ", receiver_address) print("contract_address: ", channel_manager.channel_manager_contract.address) #assert channel_rec.last_signature is None #assert channel_rec.balance == 0 # valid transfer #sig1 = encode_hex(confirmed_open_channel.create_transfer(2)) sig1 = encode_hex( sign_balance_proof( sender_privkey, # should be sender's privkey #'0xA7Ac54048B81041dbD527B603175C17473CE2d95', '0x09226F56C5699E2d87700179507cf25FA2F79F6b', block_num, #channel_rec.receiver, #channel_rec.open_block_number, coins(2), channel_manager.channel_manager_contract.address)) sig2 = encode_hex( sign_balance_proof( sender_privkey, # should be sender's privkey '0x09226F56C5699E2d87700179507cf25FA2F79F6b', block_num, coins(5), channel_manager.channel_manager_contract.address)) channel_manager.register_payment(sender_address, block_num, coins(2), sig1) channel_manager.register_payment(sender_address, block_num, coins(5), sig2) channel_manager.unregister_payment(sender_address, block_num) #channel_manager.register_payment(receiver_address, channel_rec.open_block_number, 2, sig1) channel_rec = channel_manager.channels[channel_id] print("last_sig2: ", channel_rec.last_signature) #assert channel_rec.balance == 2 #assert channel_rec.last_signature == sig1 return # transfer signed with wrong private key invalid_sig = encode_hex( sign_balance_proof( receiver_privkey, # should be sender's privkey channel_rec.receiver, channel_rec.open_block_number, 4, channel_manager.channel_manager_contract.address)) with pytest.raises(InvalidBalanceProof): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4, invalid_sig) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 # transfer to different receiver invalid_sig = encode_hex( sign_balance_proof( sender_privkey, sender_address, # should be receiver's address channel_rec.open_block_number, 4, channel_manager.channel_manager_contract.address)) with pytest.raises(InvalidBalanceProof): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4, invalid_sig) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 # transfer negative amount invalid_sig = encode_hex( sign_balance_proof( sender_privkey, receiver_address, channel_rec.open_block_number, 1, # should be greater than 2 channel_manager.channel_manager_contract.address)) with pytest.raises(InvalidBalanceAmount): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 1, invalid_sig) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 # parameters should match balance proof sig2 = encode_hex(confirmed_open_channel.create_transfer(2)) with pytest.raises(NoOpenChannel): channel_manager.register_payment(receiver_address, channel_rec.open_block_number, 4, sig2) with pytest.raises(NoOpenChannel): channel_manager.register_payment(sender_address, channel_rec.open_block_number + 1, 4, sig2) with pytest.raises(InvalidBalanceProof): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 5, sig2) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 2 assert channel_rec.last_signature == sig1 channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4, sig2) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 4 assert channel_rec.last_signature == sig2 # should transfer up to deposit sig3 = encode_hex(confirmed_open_channel.create_transfer(6)) channel_manager.register_payment(sender_address, channel_rec.open_block_number, 10, sig3) channel_rec = channel_manager.channels[channel_id] assert channel_rec.balance == 10 assert channel_rec.last_signature == sig3 # transfer too much invalid_sig = encode_hex( sign_balance_proof( sender_privkey, receiver_address, channel_rec.open_block_number, 12, # should not be greater than 10 channel_manager.channel_manager_contract.address)) with pytest.raises(InvalidBalanceProof): channel_manager.register_payment(sender_address, channel_rec.open_block_number, 12, invalid_sig) assert channel_rec.balance == 10 assert channel_rec.last_signature == sig3