def close_all_channels_cooperatively(
client: Client, privkey_receiver: str, contract_address: str, balance: int=None
):
receiver_addr = privkey_to_addr(privkey_receiver)
client.sync_channels()
channels = [c for c in client.channels
if c.state != Channel.State.closed and c.receiver == receiver_addr]
for channel in channels:
close_channel_cooperatively(channel, privkey_receiver, contract_address, balance)
def close_all_channels_cooperatively(
client: Client, private_keys: List[str], contract_address: str, balance: int=None
):
addresses_to_keys = {
to_checksum_address(privkey_to_addr(private_key)): private_key
for private_key in private_keys
}
client.sync_channels()
closable_channels = [c for c in client.channels if c.state != Channel.State.closed]
log.info('Closing {} channels.'.format(len(closable_channels)))
for channel in closable_channels:
private_key = addresses_to_keys.get(to_checksum_address(channel.receiver))
if private_key is not None:
close_channel_cooperatively(channel, private_key, contract_address, balance)
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 close_all_channels_cooperatively(client: Client,
private_keys: List[str],
contract_address: str,
balance: int = None):
addresses_to_keys = {
to_checksum_address(privkey_to_addr(private_key)): private_key
for private_key in private_keys
}
client.sync_channels()
closable_channels = [
c for c in client.channels if c.state != Channel.State.closed
]
log.info('Closing {} channels.'.format(len(closable_channels)))
for channel in closable_channels:
private_key = addresses_to_keys.get(
to_checksum_address(channel.receiver))
if private_key is not None:
close_channel_cooperatively(channel, private_key, contract_address,
balance)
def test_sync(client: Client, receiver_address, receiver_privkey):
c = client.get_suitable_channel(receiver_address,
5,
initial_deposit=lambda x: x)
assert c in client.channels
assert c.deposit == 5
assert len(client.channels) == 1
# Check if channel is still valid after sync.
client.sync_channels()
assert c in client.channels
assert len(client.channels) == 1
# Check if client handles topup events on sync.
c_topup = client.get_suitable_channel(receiver_address,
7,
topup_deposit=lambda x: 2)
assert c_topup == c
assert len(client.channels) == 1
assert c.deposit == 7
# Check if channel can be resynced after data loss.
client.channels = []
client.sync_channels()
assert len(client.channels) == 1
c = client.channels[0]
assert c.deposit == 7
# Check if channel is forgotten on resync after closure.
close_channel_cooperatively(c, receiver_privkey,
client.context.channel_manager.address)
client.sync_channels()
assert c not in client.channels
def test_sync(client: Client, receiver_address, receiver_privkey):
c = client.get_suitable_channel(receiver_address, 5, initial_deposit=lambda x: x)
assert c is not None
assert c in client.channels
assert c.deposit == 5
assert len(client.channels) == 1
# Check if channel is still valid after sync.
client.sync_channels()
assert c in client.channels
assert len(client.channels) == 1
# Check if client handles topup events on sync.
c_topup = client.get_suitable_channel(receiver_address, 7, topup_deposit=lambda x: 2)
assert c is not None
assert c_topup == c
assert len(client.channels) == 1
assert c.deposit == 7
# Check if channel can be resynced after data loss.
client.channels = []
client.sync_channels()
assert len(client.channels) == 1
c = client.channels[0]
assert c.deposit == 7
# Check if channel is forgotten on resync after closure.
close_channel_cooperatively(c, receiver_privkey, client.context.channel_manager.address)
client.sync_channels()
assert c not in client.channels
def test_sync(client: Client, receiver_address, receiver_privkey):
c = client.get_suitable_channel(receiver_address, 5)
assert c in client.channels
assert len(client.channels) == 1
# Check if channel is still valid after sync.
client.sync_channels()
assert c in client.channels
assert len(client.channels) == 1
# Check if channel can be resynced after data loss.
client.channels = []
client.store_channels()
client.sync_channels()
# Check if channel is forgotten on resync after closure.
assert len(client.channels) == 1
c = client.channels[0]
close_channel_cooperatively(c, receiver_privkey)
client.sync_channels()
assert c not in client.channels
