def test_balances(channel_manager, client, confirmed_open_channel,
receiver_address, web3, wait_for_blocks, client_token_proxy,
sender_address, use_tester):
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, confirmed_open_channel, receiver_address,
web3, wait_for_blocks, client_token_proxy,
sender_address):
blockchain = channel_manager.blockchain
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)
receiver_sig = channel_manager.sign_close(sender_address,
confirmed_open_channel.block, 5)
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 = client_token_proxy.get_logs('Transfer', block_before - 1, 'pending')
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_settlement(channel_manager, confirmed_open_channel, receiver_address,
wait_for_blocks, web3, client_token_proxy, sender_address):
blockchain = channel_manager.blockchain
channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block)
channel_rec = channel_manager.channels[channel_id]
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
wait_for_blocks(channel_rec.settle_timeout - block_before)
confirmed_open_channel.settle()
logs = client_token_proxy.get_logs('Transfer', block_before - 1, 'pending')
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_cooperative_wrong_balance_proof(channel_manager,
confirmed_open_channel,
receiver_address, web3,
wait_for_blocks, client_token_proxy,
sender_address):
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, confirmed_open_channel, receiver_address,
sender_address, wait_for_blocks, web3, client_token_proxy,
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.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 = client_token_proxy.get_logs('Transfer', block_before - 1,
'pending')
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_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