def test_topup(channel_manager, confirmed_open_channel, wait_for_blocks):
blockchain = channel_manager.blockchain
channel_manager.wait_sync()
channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block)
confirmed_open_channel.topup(5)
wait_for_blocks(1)
gevent.sleep(blockchain.poll_interval)
channel_rec = channel_manager.channels[channel_id]
topup_txs = channel_rec.unconfirmed_topups
assert len(topup_txs) == 1 and list(topup_txs.values())[0] == 5
wait_for_blocks(channel_manager.blockchain.n_confirmations)
gevent.sleep(blockchain.poll_interval)
assert len(topup_txs) == 0
assert channel_rec.deposit == 15
def test_close_confirmed_event(channel_manager, confirmed_open_channel, web3,
wait_for_blocks):
blockchain = channel_manager.blockchain
channel_manager.wait_sync()
channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block)
confirmed_open_channel.close()
wait_for_blocks(blockchain.n_confirmations)
gevent.sleep(blockchain.poll_interval)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.is_closed is True
settle_block = channel_manager.contract_proxy.get_settle_timeout(
channel_rec.sender, channel_rec.receiver,
channel_rec.open_block_number)
assert channel_rec.settle_timeout == settle_block
def test_unconfirmed_topup(channel_manager, client, receiver_address,
wait_for_blocks):
blockchain = channel_manager.blockchain
channel_manager.wait_sync()
channel = client.open_channel(receiver_address, 10)
wait_for_blocks(1)
gevent.sleep(blockchain.poll_interval)
assert (channel.sender,
channel.block) in channel_manager.unconfirmed_channels
channel.topup(5)
wait_for_blocks(channel_manager.blockchain.n_confirmations)
gevent.sleep(blockchain.poll_interval)
assert (channel.sender, channel.block) in channel_manager.channels
channel_rec = channel_manager.channels[channel.sender, channel.block]
assert channel_rec.deposit == 15
close_channel_cooperatively(channel, channel_manager.private_key)
def test_channel_settled_event(channel_manager, confirmed_open_channel,
wait_for_blocks, web3):
blockchain = channel_manager.blockchain
channel_manager.wait_sync()
channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block)
confirmed_open_channel.close()
wait_for_blocks(blockchain.n_confirmations)
gevent.sleep(blockchain.poll_interval)
channel_rec = channel_manager.channels[channel_id]
wait_for_blocks(channel_rec.settle_timeout - web3.eth.blockNumber)
gevent.sleep(blockchain.poll_interval)
assert web3.eth.blockNumber >= channel_rec.settle_timeout
assert channel_id in channel_manager.channels
confirmed_open_channel.settle()
wait_for_blocks(blockchain.n_confirmations)
gevent.sleep(blockchain.poll_interval)
assert channel_id not in channel_manager.channels
def test_reorg(web3, channel_manager, client, receiver_address,
wait_for_blocks, use_tester):
if not use_tester:
pytest.skip('Chain reorg tests only work in tester chain')
wait_for_blocks(10)
# create unconfirmed channel
channel_manager.wait_sync()
snapshot_id = web3.testing.snapshot()
channel = client.open_channel(receiver_address, 10)
wait_for_blocks(0)
assert (channel.sender,
channel.block) in channel_manager.unconfirmed_channels
# remove unconfirmed channel opening with reorg
web3.testing.revert(snapshot_id)
wait_for_blocks(0)
assert (channel.sender,
channel.block) not in channel_manager.unconfirmed_channels
web3.testing.mine(channel_manager.n_confirmations)
assert (channel.sender, channel.block) not in channel_manager.channels
# leave confirmed channel opening
web3.testing.revert(snapshot_id)
channel = client.open_channel(receiver_address, 10)
wait_for_blocks(channel_manager.n_confirmations)
assert (channel.sender, channel.block) in channel_manager.channels
confirmed_snapshot_id = web3.testing.snapshot()
wait_for_blocks(3)
web3.testing.revert(confirmed_snapshot_id)
assert (channel.sender, channel.block) in channel_manager.channels
# remove unconfirmed topup
channel = client.open_channel(receiver_address, 10)
wait_for_blocks(channel_manager.n_confirmations)
assert (channel.sender, channel.block) in channel_manager.channels
channel_rec = channel_manager.channels[channel.sender, channel.block]
topup_snapshot_id = web3.testing.snapshot()
channel.topup(5)
wait_for_blocks(0)
assert len(channel_rec.unconfirmed_topups) == 1
web3.testing.revert(topup_snapshot_id)
wait_for_blocks(0)
assert (channel.sender, channel.block) in channel_manager.channels
assert len(channel_rec.unconfirmed_topups) == 0
def test_close_unconfirmed_event(channel_manager, client, receiver_address,
wait_for_blocks):
channel_manager.wait_sync()
blockchain = channel_manager.blockchain
# if unconfirmed channel is closed it should simply be forgotten
channel = client.open_channel(receiver_address, 10)
wait_for_blocks(1)
gevent.sleep(blockchain.poll_interval)
assert (channel.sender,
channel.block) in channel_manager.unconfirmed_channels
assert (channel.sender, channel.block) not in channel_manager.channels
channel.close()
wait_for_blocks(
channel_manager.blockchain.n_confirmations) # opening confirmed
gevent.sleep(blockchain.poll_interval)
assert (channel.sender,
channel.block) not in channel_manager.unconfirmed_channels
assert (channel.sender, channel.block) in channel_manager.channels
wait_for_blocks(1) # closing confirmed
gevent.sleep(blockchain.poll_interval)
assert (channel.sender,
channel.block) not in channel_manager.unconfirmed_channels
assert (channel.sender, channel.block) in channel_manager.channels
close_channel_cooperatively(channel, channel_manager.private_key)
def test_payment(channel_manager, confirmed_open_channel, receiver_address,
receiver_privkey, sender_privkey, sender_address):
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)
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))
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address,
channel_rec.open_block_number, 4,
invalid_sig)
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))
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address,
channel_rec.open_block_number, 4,
invalid_sig)
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
))
with pytest.raises(InvalidBalanceAmount):
channel_manager.register_payment(sender_address,
channel_rec.open_block_number, 1,
invalid_sig)
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)
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
channel_manager.register_payment(sender_address,
channel_rec.open_block_number, 4, sig2)
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)
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
))
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