def test_settlement_with_unauthorized_token_transfer(
web3,
get_accounts,
custom_token,
token_network,
create_channel_and_deposit,
withdraw_channel,
close_and_update_channel,
):
externally_transferred_amount = 5
(A, B) = get_accounts(2)
(vals_A, vals_B) = (
ChannelValues(deposit=35, withdrawn=10, transferred=0, locked=0),
ChannelValues(deposit=40, withdrawn=10, transferred=0, locked=0),
)
vals_A.locksroot = fake_bytes(32, '02')
vals_B.locksroot = fake_bytes(32, '03')
create_channel_and_deposit(A, B, vals_A.deposit, vals_B.deposit)
withdraw_channel(A, vals_A.withdrawn, B)
withdraw_channel(B, vals_B.withdrawn, A)
close_and_update_channel(
A,
vals_A,
B,
vals_B,
)
# A does a transfer to the token_network without appropriate function call - tokens are lost
custom_token.functions.transfer(
token_network.address,
externally_transferred_amount,
).transact({'from': A})
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN)
# Compute expected settlement amounts
settlement = get_settlement_amounts(vals_A, vals_B)
# Channel is settled
call_settle(token_network, A, vals_A, B, vals_B)
# Fetch onchain balances after settlement
post_balance_A = custom_token.functions.balanceOf(A).call()
post_balance_B = custom_token.functions.balanceOf(B).call()
post_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
# A has lost the externally_transferred_amount
assert (vals_A.withdrawn + settlement.participant1_balance -
externally_transferred_amount == post_balance_A)
# B's settlement works correctly
assert (settlement.participant2_balance +
vals_B.withdrawn == post_balance_B)
# The externally_transferred_amount stays in the contract
assert (post_balance_contract == externally_transferred_amount)
def test_channel_unlock_with_a_large_expiration(
web3,
custom_token,
token_network,
create_channel,
channel_deposit,
get_accounts,
close_and_update_channel,
reveal_secrets,
):
""" unlock() should still work after a delayed settleChannel() call """
(A, B) = get_accounts(2)
settle_timeout = 8
values_A = ChannelValues(deposit=20, transferred=5)
values_B = ChannelValues(deposit=30, transferred=40)
# Create channel and deposit
channel_identifier = create_channel(A, B, settle_timeout)[0]
channel_deposit(channel_identifier, A, values_A.deposit, B)
channel_deposit(channel_identifier, B, values_B.deposit, A)
# Mock pending transfers data with large expiration date
pending_transfers_tree = get_pending_transfers_tree(
web3, [1, 3, 5], [2, 4], settle_timeout + 100)
values_B.locksroot = pending_transfers_tree.merkle_root
values_B.locked_amounts = LockedAmounts(
claimable_locked=get_locked_amount(pending_transfers_tree.transfers))
# Reveal secrets before settlement window ends
reveal_secrets(A, pending_transfers_tree.unlockable)
close_and_update_channel(channel_identifier, A, values_A, B, values_B)
# Settle channel after a "long" time
web3.testing.mine(settle_timeout + 50)
call_settle(token_network, channel_identifier, A, values_A, B, values_B)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
# Unlock the tokens must still work
token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree.packed_transfers).call_and_transact()
balance_A = custom_token.functions.balanceOf(A).call()
balance_B = custom_token.functions.balanceOf(B).call()
balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
assert balance_A == pre_balance_A + 9
assert balance_B == pre_balance_B + 6
assert balance_contract == pre_balance_contract - values_B.locked_amounts.locked
def test_settle_with_locked_but_unregistered(
web3,
token_network,
get_accounts,
create_channel_and_deposit,
withdraw_channel,
close_and_update_channel,
custom_token,
):
(A, B) = get_accounts(2)
settle_timeout = TEST_SETTLE_TIMEOUT_MIN
pending_transfers_tree = get_pending_transfers_tree(
web3, [1, 3, 5], [2, 4], settle_timeout)
locked_A = pending_transfers_tree.locked_amount
(vals_A, vals_B) = (
ChannelValues(deposit=35, withdrawn=10, transferred=0,
locked=locked_A),
ChannelValues(deposit=40, withdrawn=10, transferred=20, locked=0),
)
vals_A.locksroot = '0x' + get_merkle_root(
pending_transfers_tree.merkle_tree).hex()
vals_B.locksroot = fake_bytes(32, '03')
channel_identifier = create_channel_and_deposit(A, B, vals_A.deposit,
vals_B.deposit)
withdraw_channel(channel_identifier, A, vals_A.withdrawn, B)
withdraw_channel(channel_identifier, B, vals_B.withdrawn, A)
close_and_update_channel(
channel_identifier,
A,
vals_A,
B,
vals_B,
)
# Secret hasn't been registered before settlement timeout
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN)
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
# Someone unlocks A's pending transfers - all tokens should be refunded
token_network.functions.unlock(
channel_identifier,
B,
A,
pending_transfers_tree.packed_transfers,
).transact({'from': A})
# A gets back locked tokens
assert (custom_token.functions.balanceOf(A).call() == vals_A.deposit -
vals_A.transferred + vals_B.transferred)
def test_deposit_wrong_state_fail(
web3: Web3,
get_accounts: Callable,
token_network: Contract,
create_channel: Callable,
assign_tokens: Callable,
) -> None:
""" setTotalDeposit() fails on Closed or Settled channels. """
(A, B) = get_accounts(2)
vals_A = ChannelValues(deposit=2, transferred=0)
vals_B = ChannelValues(deposit=2, transferred=0)
channel_identifier = create_channel(A, B, TEST_SETTLE_TIMEOUT_MIN)[0]
assign_tokens(A, vals_A.deposit)
assign_tokens(B, vals_B.deposit)
token_network.functions.setTotalDeposit(channel_identifier, A,
vals_A.deposit,
B).call_and_transact({"from": A})
token_network.functions.setTotalDeposit(channel_identifier, B,
vals_B.deposit,
A).call_and_transact({"from": B})
token_network.functions.closeChannel(
channel_identifier, B, EMPTY_BALANCE_HASH, 0, EMPTY_ADDITIONAL_HASH,
EMPTY_SIGNATURE).call_and_transact({"from": A})
assign_tokens(A, 10)
assign_tokens(B, 10)
vals_A.deposit += 5
vals_B.deposit += 5
with pytest.raises(TransactionFailed):
token_network.functions.setTotalDeposit(channel_identifier, A,
vals_A.deposit,
B).call({"from": A})
with pytest.raises(TransactionFailed):
token_network.functions.setTotalDeposit(channel_identifier, B,
vals_B.deposit,
A).call({"from": B})
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN + 1)
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
with pytest.raises(TransactionFailed):
token_network.functions.setTotalDeposit(channel_identifier, A,
vals_A.deposit,
B).call({"from": A})
with pytest.raises(TransactionFailed):
token_network.functions.setTotalDeposit(channel_identifier, B,
vals_B.deposit,
A).call({"from": B})
def test_channel_unlock_unregistered_locks(
web3: Web3,
token_network: Contract,
get_accounts: Callable,
create_channel_and_deposit: Callable,
withdraw_channel: Callable,
close_and_update_channel: Callable,
custom_token: Contract,
) -> None:
""" unlock() should refund tokens locked by secrets not registered before settlement """
(A, B) = get_accounts(2)
settle_timeout = TEST_SETTLE_TIMEOUT_MIN
pending_transfers_tree = get_pending_transfers_tree(web3, [1, 3, 5], [2, 4], settle_timeout)
locked_A = pending_transfers_tree.locked_amount
(vals_A, vals_B) = (
ChannelValues(
deposit=35,
withdrawn=10,
transferred=0,
locked_amounts=LockedAmounts(claimable_locked=locked_A),
),
ChannelValues(deposit=40, withdrawn=10, transferred=20),
)
vals_A.locksroot = pending_transfers_tree.hash_of_packed_transfers
vals_B.locksroot = fake_bytes(32, "03")
channel_identifier = create_channel_and_deposit(A, B, vals_A.deposit, vals_B.deposit)
withdraw_channel(channel_identifier, A, vals_A.withdrawn, B)
withdraw_channel(channel_identifier, B, vals_B.withdrawn, A)
close_and_update_channel(channel_identifier, A, vals_A, B, vals_B)
# Secret hasn't been registered before settlement timeout
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN + 1)
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
# Someone unlocks A's pending transfers - all tokens should be refunded
token_network.functions.unlock(
channel_identifier, B, A, pending_transfers_tree.packed_transfers
).call_and_transact({"from": A})
# A gets back locked tokens
assert (
custom_token.functions.balanceOf(A).call()
== vals_A.deposit - vals_A.transferred + vals_B.transferred
)
def test_settle_wrong_state_fail(
web3,
get_accounts,
token_network,
create_channel_and_deposit,
get_block,
):
""" settleChannel() fails on OPENED state and on CLOSED state before the settlement block """
(A, B) = get_accounts(2)
vals_A = ChannelValues(deposit=35)
vals_B = ChannelValues(deposit=40)
channel_identifier = create_channel_and_deposit(A, B, vals_A.deposit,
vals_B.deposit)
(settle_timeout, state) = token_network.functions.getChannelInfo(
channel_identifier,
A,
B,
).call()
assert state == ChannelState.OPENED
assert settle_timeout == TEST_SETTLE_TIMEOUT_MIN
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
txn_hash = token_network.functions.closeChannel(
channel_identifier,
B,
EMPTY_BALANCE_HASH,
0,
EMPTY_ADDITIONAL_HASH,
EMPTY_SIGNATURE,
).transact({'from': A})
(settle_block_number, state) = token_network.functions.getChannelInfo(
channel_identifier,
A,
B,
).call()
assert state == ChannelState.CLOSED
assert settle_block_number == TEST_SETTLE_TIMEOUT_MIN + get_block(txn_hash)
assert web3.eth.blockNumber < settle_block_number
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN)
assert web3.eth.blockNumber >= settle_block_number
# Channel is settled
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
(settle_block_number, state) = token_network.functions.getChannelInfo(
channel_identifier,
A,
B,
).call()
assert state == ChannelState.REMOVED
assert settle_block_number == 0
def test_settle_wrong_state_fail(
web3: Web3,
get_accounts: Callable,
token_network: Contract,
create_channel_and_deposit: Callable,
get_block: Callable,
create_close_signature_for_no_balance_proof: Callable,
) -> None:
""" settleChannel() fails on OPENED state and on CLOSED state before the settlement block """
(A, B) = get_accounts(2)
vals_A = ChannelValues(deposit=35)
vals_B = ChannelValues(deposit=40)
channel_identifier = create_channel_and_deposit(A, B, vals_A.deposit,
vals_B.deposit)
(settle_timeout,
state) = token_network.functions.getChannelInfo(channel_identifier, A,
B).call()
assert state == ChannelState.OPENED
assert settle_timeout == TEST_SETTLE_TIMEOUT_MIN
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
closing_sig = create_close_signature_for_no_balance_proof(
A, channel_identifier)
txn_hash = token_network.functions.closeChannel(
channel_identifier,
B,
A,
EMPTY_BALANCE_HASH,
0,
EMPTY_ADDITIONAL_HASH,
EMPTY_SIGNATURE,
closing_sig,
).call_and_transact({"from": A})
(settle_block_number,
state) = token_network.functions.getChannelInfo(channel_identifier, A,
B).call()
assert state == ChannelState.CLOSED
assert settle_block_number == TEST_SETTLE_TIMEOUT_MIN + get_block(txn_hash)
assert web3.eth.blockNumber < settle_block_number
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN + 1)
assert web3.eth.blockNumber > settle_block_number
# Channel is settled
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
(settle_block_number,
state) = token_network.functions.getChannelInfo(channel_identifier, A,
B).call()
assert state == ChannelState.REMOVED
assert settle_block_number == 0
def test_deprecation_switch_settle(
web3: Web3,
get_accounts: Callable,
token_network: Contract,
custom_token: Contract,
reveal_secrets: Callable,
create_channel: Callable,
channel_deposit: Callable,
close_and_update_channel: Callable,
) -> None:
""" Channel close and settlement still work after the depracation switch is turned on """
deprecation_executor = token_network.functions.deprecation_executor().call(
)
(A, B) = get_accounts(2)
deposit = 100
(vals_A, vals_B) = (
ChannelValues(
deposit=deposit,
withdrawn=0,
transferred=5,
locked_amounts=LockedAmounts(claimable_locked=2,
unclaimable_locked=4),
),
ChannelValues(
deposit=deposit,
withdrawn=0,
transferred=10,
locked_amounts=LockedAmounts(claimable_locked=4,
unclaimable_locked=6),
),
)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
channel_identifier = create_channel(A, B)[0]
channel_deposit(channel_identifier, A, vals_A.deposit, B)
channel_deposit(channel_identifier, B, vals_B.deposit, A)
# Mock pending transfers data for A -> B
pending_transfers_tree_A = get_pending_transfers_tree_with_generated_lists(
web3,
unlockable_amount=vals_A.locked_amounts.claimable_locked,
expired_amount=vals_A.locked_amounts.unclaimable_locked,
)
vals_A.locksroot = pending_transfers_tree_A.hash_of_packed_transfers
# Reveal A's secrets.
reveal_secrets(A, pending_transfers_tree_A.unlockable)
# Mock pending transfers data for B -> A
pending_transfers_tree_B = get_pending_transfers_tree_with_generated_lists(
web3,
unlockable_amount=vals_B.locked_amounts.claimable_locked,
expired_amount=vals_B.locked_amounts.unclaimable_locked,
)
vals_B.locksroot = pending_transfers_tree_B.hash_of_packed_transfers
# Reveal B's secrets
reveal_secrets(B, pending_transfers_tree_B.unlockable)
# Set the deprecation switch to true
token_network.functions.deprecate().call_and_transact(
{"from": deprecation_executor})
assert token_network.functions.safety_deprecation_switch().call() is True
# We need to make sure we can still close, settle & unlock the channels
close_and_update_channel(channel_identifier, A, vals_A, B, vals_B)
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN + 1)
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
# Unlock B's pending transfers that were sent to A
token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree_B.packed_transfers).call_and_transact()
# Unlock A's pending transfers that were sent to B
token_network.functions.unlock(
channel_identifier, B, A,
pending_transfers_tree_A.packed_transfers).call_and_transact()
assert custom_token.functions.balanceOf(A).call() == pre_balance_A + 107
assert custom_token.functions.balanceOf(B).call() == pre_balance_B + 93
assert custom_token.functions.balanceOf(
token_network.address).call() == pre_balance_contract
def test_channel_unlock_both_participants(
web3,
custom_token,
token_network,
secret_registry_contract,
create_channel,
channel_deposit,
get_accounts,
close_and_update_channel,
reveal_secrets,
):
""" A scenario where both parties get some of the pending transfers """
(A, B) = get_accounts(2)
settle_timeout = 8
values_A = ChannelValues(deposit=100, transferred=5)
values_B = ChannelValues(deposit=100, transferred=40)
# Create channel and deposit
channel_identifier = create_channel(A, B, settle_timeout)[0]
channel_deposit(channel_identifier, A, values_A.deposit, B)
channel_deposit(channel_identifier, B, values_B.deposit, A)
# Mock pending transfers data for A
pending_transfers_tree_A = get_pending_transfers_tree(
web3, [1, 3, 5], [2, 4], settle_timeout)
values_A.locksroot = pending_transfers_tree_A.merkle_root
values_A.locked_amounts = LockedAmounts(
claimable_locked=get_locked_amount(pending_transfers_tree_A.transfers))
# Reveal A's secrets before settlement window ends
reveal_secrets(A, pending_transfers_tree_A.unlockable)
# Mock pending transfers data for B
pending_transfers_tree_B = get_pending_transfers_tree(
web3, [2, 4, 6], [5, 10], settle_timeout)
values_B.locksroot = pending_transfers_tree_B.merkle_root
values_B.locked_amounts = LockedAmounts(
claimable_locked=get_locked_amount(pending_transfers_tree_B.transfers))
# Reveal B's secrets before settlement window ends
reveal_secrets(B, pending_transfers_tree_B.unlockable)
close_and_update_channel(channel_identifier, A, values_A, B, values_B)
# Settle channel
web3.testing.mine(settle_timeout)
call_settle(token_network, channel_identifier, A, values_A, B, values_B)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
# A unlock's
token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree_B.packed_transfers).call_and_transact()
# B unlock's
token_network.functions.unlock(
channel_identifier, B, A,
pending_transfers_tree_A.packed_transfers).call_and_transact()
balance_A = custom_token.functions.balanceOf(A).call()
balance_B = custom_token.functions.balanceOf(B).call()
balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
# Unlocked pending transfers A -> B, that belong to B
unlockable_A = get_unlocked_amount(
secret_registry_contract, pending_transfers_tree_A.packed_transfers)
# Expired pending transfers A -> B, that belong to A
expired_A = get_locked_amount(pending_transfers_tree_A.expired)
# Unlocked pending transfers B -> A, that belong to A
unlockable_B = get_unlocked_amount(
secret_registry_contract, pending_transfers_tree_B.packed_transfers)
# Expired pending transfers B -> A, that belong to B
expired_B = get_locked_amount(pending_transfers_tree_B.expired)
# check that A and B both received the expected amounts
assert balance_contract == (pre_balance_contract -
values_B.locked_amounts.locked -
values_A.locked_amounts.locked)
assert balance_A == pre_balance_A + unlockable_B + expired_A
assert balance_B == pre_balance_B + unlockable_A + expired_B
def test_channel_unlock_before_settlement_fails(
web3,
custom_token,
token_network,
create_channel,
channel_deposit,
get_accounts,
close_and_update_channel,
reveal_secrets,
):
""" unlock() should not work before settlement """
(A, B) = get_accounts(2)
settle_timeout = 8
values_A = ChannelValues(deposit=20, transferred=5)
values_B = ChannelValues(deposit=30, transferred=40)
# Create channel and deposit
channel_identifier = create_channel(A, B, settle_timeout)[0]
# Mock pending transfers data
pending_transfers_tree = get_pending_transfers_tree(
web3, [1, 3, 5], [2, 4], settle_timeout)
values_B.locksroot = pending_transfers_tree.merkle_root
values_B.locked_amounts = LockedAmounts(
claimable_locked=get_locked_amount(pending_transfers_tree.transfers))
# Reveal secrets before settlement window ends
reveal_secrets(A, pending_transfers_tree.unlockable)
# Unlock fails before channel is not settled
with pytest.raises(TransactionFailed):
token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree.packed_transfers).call()
channel_deposit(channel_identifier, A, values_A.deposit, B)
channel_deposit(channel_identifier, B, values_B.deposit, A)
# Unlock fails before channel is not settled
with pytest.raises(TransactionFailed):
token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree.packed_transfers).call()
close_and_update_channel(channel_identifier, A, values_A, B, values_B)
# Unlock fails before settlement window is over and channel is not settled
with pytest.raises(TransactionFailed):
token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree.packed_transfers).call()
# Settlement window must be over before settling the channel
web3.testing.mine(settle_timeout)
# Unlock fails before settle is called
with pytest.raises(TransactionFailed):
token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree.packed_transfers).call()
# settle channel
call_settle(token_network, channel_identifier, A, values_A, B, values_B)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
# Unlock works after channel is settled
token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree.packed_transfers).call_and_transact()
balance_A = custom_token.functions.balanceOf(A).call()
balance_B = custom_token.functions.balanceOf(B).call()
balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
assert balance_A == pre_balance_A + 9
assert balance_B == pre_balance_B + 6
assert balance_contract == pre_balance_contract - values_B.locked_amounts.locked
def test_channel_unlock_registered_expired_lock_refunds(
web3,
custom_token,
token_network,
secret_registry_contract,
create_channel,
channel_deposit,
get_accounts,
close_and_update_channel,
):
""" unlock() should refund tokens locked with secrets revealed after the expiration """
(A, B) = get_accounts(2)
max_lock_expiration = 3
settle_timeout = 8
values_A = ChannelValues(deposit=20, transferred=5)
values_B = ChannelValues(deposit=30, transferred=40)
# Create channel and deposit
channel_identifier = create_channel(A, B, settle_timeout)[0]
channel_deposit(channel_identifier, A, values_A.deposit, B)
channel_deposit(channel_identifier, B, values_B.deposit, A)
# Mock pending transfers data
pending_transfers_tree = get_pending_transfers_tree(
web3,
[1, 3, 5],
[2, 4],
min_expiration_delta=max_lock_expiration - 2,
max_expiration_delta=max_lock_expiration,
)
values_B.locksroot = pending_transfers_tree.merkle_root
values_B.locked_amounts = LockedAmounts(
claimable_locked=get_locked_amount(pending_transfers_tree.transfers))
# Locks expire
web3.testing.mine(max_lock_expiration)
# Secrets are revealed before settlement window, but after expiration
for (_, _, secrethash, secret) in pending_transfers_tree.unlockable:
secret_registry_contract.functions.registerSecret(
secret).call_and_transact({"from": A})
assert (secret_registry_contract.functions.getSecretRevealBlockHeight(
secrethash).call() == web3.eth.blockNumber)
close_and_update_channel(channel_identifier, A, values_A, B, values_B)
web3.testing.mine(settle_timeout)
# settle channel
call_settle(token_network, channel_identifier, A, values_A, B, values_B)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
# Unlock works after channel is settled
token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree.packed_transfers).call_and_transact()
balance_A = custom_token.functions.balanceOf(A).call()
balance_B = custom_token.functions.balanceOf(B).call()
balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
# check that all tokens have been refunded, as locks have expired already
assert balance_A == pre_balance_A
assert balance_B == pre_balance_B + values_B.locked_amounts.locked
assert balance_contract == pre_balance_contract - values_B.locked_amounts.locked
def test_channel_unlock(
web3,
custom_token,
token_network,
create_channel,
channel_deposit,
get_accounts,
close_and_update_channel,
reveal_secrets,
):
""" unlock() on pending transfers with unlockable and expired locks should
split the locked amount accordingly, to both parties """
(A, B) = get_accounts(2)
settle_timeout = 8
values_A = ChannelValues(deposit=20, transferred=5)
values_B = ChannelValues(deposit=30, transferred=40)
# Create channel and deposit
channel_identifier = create_channel(A, B, settle_timeout)[0]
channel_deposit(channel_identifier, A, values_A.deposit, B)
channel_deposit(channel_identifier, B, values_B.deposit, A)
# Mock pending transfers data
pending_transfers_tree = get_pending_transfers_tree(
web3, [1, 3, 5], [2, 4], settle_timeout)
values_B.locksroot = pending_transfers_tree.merkle_root
values_B.locked_amounts = LockedAmounts(
claimable_locked=get_locked_amount(pending_transfers_tree.transfers))
# Reveal secrets before settlement window ends
reveal_secrets(A, pending_transfers_tree.unlockable)
close_and_update_channel(channel_identifier, A, values_A, B, values_B)
# Settlement window must be over before settling the channel
web3.testing.mine(settle_timeout)
call_settle(token_network, channel_identifier, A, values_A, B, values_B)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
info_B = token_network.functions.getChannelParticipantInfo(
channel_identifier, B, A).call()
assert info_B[ParticipantInfoIndex.LOCKSROOT] == values_B.locksroot
assert info_B[
ParticipantInfoIndex.LOCKED_AMOUNT] == values_B.locked_amounts.locked
# Unlock the tokens
token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree.packed_transfers).call_and_transact()
info_B = token_network.functions.getChannelParticipantInfo(
channel_identifier, B, A).call()
assert info_B[ParticipantInfoIndex.LOCKSROOT] == EMPTY_LOCKSROOT
assert info_B[ParticipantInfoIndex.LOCKED_AMOUNT] == 0
balance_A = custom_token.functions.balanceOf(A).call()
balance_B = custom_token.functions.balanceOf(B).call()
balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
assert balance_A == pre_balance_A + 9
assert balance_B == pre_balance_B + 6
assert balance_contract == pre_balance_contract - values_B.locked_amounts.locked
def test_unlock_channel_event(
web3,
token_network,
secret_registry_contract,
create_channel,
channel_deposit,
get_accounts,
close_and_update_channel,
reveal_secrets,
event_handler,
):
""" Successful unlock() should cause an UNLOCKED event """
(A, B) = get_accounts(2)
settle_timeout = 8
values_A = ChannelValues(deposit=20, transferred=5)
values_B = ChannelValues(deposit=30, transferred=40)
# Create channel and deposit
channel_identifier = create_channel(A, B, settle_timeout)[0]
channel_deposit(channel_identifier, A, values_A.deposit, B)
channel_deposit(channel_identifier, B, values_B.deposit, A)
# Mock pending transfers data
pending_transfers_tree = get_pending_transfers_tree(
web3, [1, 3, 5], [2, 4], settle_timeout + 100)
values_B.locksroot = pending_transfers_tree.merkle_root
values_B.locked_amounts = LockedAmounts(
claimable_locked=get_locked_amount(pending_transfers_tree.transfers))
# Reveal secrets before settlement window ends
reveal_secrets(A, pending_transfers_tree.unlockable)
close_and_update_channel(channel_identifier, A, values_A, B, values_B)
# Settlement window must be over before settling the channel
web3.testing.mine(settle_timeout)
call_settle(token_network, channel_identifier, A, values_A, B, values_B)
ev_handler = event_handler(token_network)
# Unlock the tokens
txn_hash = token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree.packed_transfers).call_and_transact()
unlocked_amount = get_unlocked_amount(
secret_registry_contract, pending_transfers_tree.packed_transfers)
# Add event
ev_handler.add(
txn_hash,
ChannelEvent.UNLOCKED,
check_channel_unlocked(
channel_identifier,
A,
B,
values_B.locksroot,
unlocked_amount,
values_B.locked_amounts.locked - unlocked_amount,
),
)
# Check that event was properly emitted
ev_handler.check()
def test_unlock_channel_event(
web3,
token_network,
secret_registry_contract,
create_channel,
channel_deposit,
get_accounts,
close_and_update_channel,
event_handler,
):
(A, B) = get_accounts(2)
settle_timeout = 8
values_A = ChannelValues(
deposit=20,
transferred=5,
locked=0,
locksroot=EMPTY_MERKLE_ROOT,
)
values_B = ChannelValues(
deposit=30,
transferred=40,
)
# Create channel and deposit
channel_identifier = create_channel(A, B, settle_timeout)[0]
channel_deposit(A, values_A.deposit, B)
channel_deposit(B, values_B.deposit, A)
# Mock pending transfers data
pending_transfers_tree = get_pending_transfers_tree(web3, [1, 3, 5], [2, 4],
settle_timeout + 100)
locksroot_bytes = get_merkle_root(pending_transfers_tree.merkle_tree)
values_B.locksroot = '0x' + locksroot_bytes.hex()
values_B.locked = get_locked_amount(pending_transfers_tree.transfers)
# Reveal secrets before settlement window ends
for lock in pending_transfers_tree.unlockable:
secret_registry_contract.functions.registerSecret(lock[3]).transact({'from': A})
assert secret_registry_contract.functions.getSecretRevealBlockHeight(
lock[2],
).call() == web3.eth.blockNumber
close_and_update_channel(
A,
values_A,
B,
values_B,
)
# Settlement window must be over before settling the channel
web3.testing.mine(settle_timeout)
call_settle(token_network, A, values_A, B, values_B)
ev_handler = event_handler(token_network)
# Unlock the tokens
txn_hash = token_network.functions.unlock(
A,
B,
pending_transfers_tree.packed_transfers,
).transact()
unlocked_amount = get_unlocked_amount(
secret_registry_contract,
pending_transfers_tree.packed_transfers,
)
# Add event
ev_handler.add(txn_hash, EVENT_CHANNEL_UNLOCKED, check_channel_unlocked(
channel_identifier,
A,
unlocked_amount,
values_B.locked - unlocked_amount,
))
# Check that event was properly emitted
ev_handler.check()
def test_settlement_with_unauthorized_token_transfer(
web3: Web3,
get_accounts: Callable,
custom_token: Contract,
token_network: Contract,
assign_tokens: Callable,
create_channel_and_deposit: Callable,
withdraw_channel: Callable,
close_and_update_channel: Callable,
) -> None:
"""A participant transfers some tokens to the contract and so loses them"""
externally_transferred_amount = 5
(A, B) = get_accounts(2)
(vals_A, vals_B) = (
ChannelValues(deposit=35, withdrawn=10, transferred=0),
ChannelValues(deposit=40, withdrawn=10, transferred=0),
)
vals_A.locksroot = fake_bytes(32, "02")
vals_B.locksroot = fake_bytes(32, "03")
channel_identifier = create_channel_and_deposit(A, B, vals_A.deposit,
vals_B.deposit)
withdraw_channel(channel_identifier, A, vals_A.withdrawn, UINT256_MAX, B)
withdraw_channel(channel_identifier, B, vals_B.withdrawn, UINT256_MAX, A)
close_and_update_channel(channel_identifier, A, vals_A, B, vals_B)
# Assign additional tokens to A
assign_tokens(A, externally_transferred_amount)
assert custom_token.functions.balanceOf(
A).call() >= externally_transferred_amount
# Fetch onchain balances after settlement
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
# A does a transfer to the token_network without appropriate function call - tokens are lost
call_and_transact(
custom_token.functions.transfer(token_network.address,
externally_transferred_amount),
{"from": A},
)
assert custom_token.functions.balanceOf(
token_network.address).call() == (pre_balance_contract +
externally_transferred_amount)
mine_blocks(web3, TEST_SETTLE_TIMEOUT_MIN + 1)
# Compute expected settlement amounts
settlement = get_settlement_amounts(vals_A, vals_B)
# Channel is settled
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
# Fetch onchain balances after settlement
post_balance_A = custom_token.functions.balanceOf(A).call()
post_balance_B = custom_token.functions.balanceOf(B).call()
post_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
# A has lost the externally_transferred_amount
assert (pre_balance_A + settlement.participant1_balance -
externally_transferred_amount) == post_balance_A
# B's settlement works correctly
assert pre_balance_B + settlement.participant2_balance == post_balance_B
# The externally_transferred_amount stays in the contract
assert (pre_balance_contract - settlement.participant1_balance -
settlement.participant2_balance +
externally_transferred_amount) == post_balance_contract
def test_deposit_wrong_state_fail(
web3: Web3,
get_accounts: Callable,
token_network: Contract,
create_channel: Callable,
assign_tokens: Callable,
create_close_signature_for_no_balance_proof: Callable,
) -> None:
""" setTotalDeposit() fails on Closed or Settled channels. """
(A, B) = get_accounts(2)
vals_A = ChannelValues(deposit=2, transferred=0)
vals_B = ChannelValues(deposit=2, transferred=0)
channel_identifier = create_channel(A, B, TEST_SETTLE_TIMEOUT_MIN)[0]
assign_tokens(A, vals_A.deposit)
assign_tokens(B, vals_B.deposit)
call_and_transact(
token_network.functions.setTotalDeposit(channel_identifier, A,
vals_A.deposit, B),
{"from": A},
)
call_and_transact(
token_network.functions.setTotalDeposit(channel_identifier, B,
vals_B.deposit, A),
{"from": B},
)
assert (
vals_A.deposit == token_network.functions.getChannelParticipantInfo(
channel_identifier, A, B).call()[0])
assert (
vals_B.deposit == token_network.functions.getChannelParticipantInfo(
channel_identifier, B, A).call()[0])
closing_sig = create_close_signature_for_no_balance_proof(
A, channel_identifier)
call_and_transact(
token_network.functions.closeChannel(
channel_identifier=channel_identifier,
non_closing_participant=B,
closing_participant=A,
balance_hash=EMPTY_BALANCE_HASH,
nonce=0,
additional_hash=EMPTY_ADDITIONAL_HASH,
non_closing_signature=EMPTY_SIGNATURE,
closing_signature=closing_sig,
),
{"from": A},
)
assign_tokens(A, 10)
assign_tokens(B, 10)
vals_A.deposit += 5
vals_B.deposit += 5
with pytest.raises(TransactionFailed):
token_network.functions.setTotalDeposit(channel_identifier, A,
vals_A.deposit,
B).call({"from": A})
with pytest.raises(TransactionFailed):
token_network.functions.setTotalDeposit(channel_identifier, B,
vals_B.deposit,
A).call({"from": B})
mine_blocks(web3, TEST_SETTLE_TIMEOUT_MIN + 1)
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
with pytest.raises(TransactionFailed):
token_network.functions.setTotalDeposit(channel_identifier, A,
vals_A.deposit,
B).call({"from": A})
with pytest.raises(TransactionFailed):
token_network.functions.setTotalDeposit(channel_identifier, B,
vals_B.deposit,
A).call({"from": B})
def test_settle_wrong_balance_hash(
web3,
get_accounts,
token_network,
create_channel_and_deposit,
close_and_update_channel,
get_block,
reveal_secrets,
):
""" Calling settleChannel() with various wrong arguments and see failures """
(A, B) = get_accounts(2)
vals_A = ChannelValues(
deposit=35,
withdrawn=0,
transferred=5,
claimable_locked=10,
unclaimable_locked=2,
)
vals_B = ChannelValues(
deposit=40,
withdrawn=0,
transferred=15,
claimable_locked=5,
unclaimable_locked=4,
)
channel_identifier = create_channel_and_deposit(A, B, vals_A.deposit,
vals_B.deposit)
# Mock pending transfers data for A -> B
pending_transfers_tree_A = get_pending_transfers_tree(
web3,
unlockable_amount=vals_A.claimable_locked,
expired_amount=vals_A.unclaimable_locked,
)
vals_A.locksroot = pending_transfers_tree_A.merkle_root
# Reveal A's secrets.
reveal_secrets(A, pending_transfers_tree_A.unlockable)
# Mock pending transfers data for B -> A
pending_transfers_tree_B = get_pending_transfers_tree(
web3,
unlockable_amount=vals_B.claimable_locked,
expired_amount=vals_B.unclaimable_locked,
)
vals_B.locksroot = pending_transfers_tree_B.merkle_root
# Reveal B's secrets
reveal_secrets(B, pending_transfers_tree_B.unlockable)
close_and_update_channel(
channel_identifier,
A,
vals_A,
B,
vals_B,
)
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN)
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, B, vals_A, A, vals_B)
vals_A_fail = deepcopy(vals_A)
vals_A_fail.transferred += 1
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A_fail, B,
vals_B)
vals_A_fail.transferred = 0
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A_fail, B,
vals_B)
vals_A_fail.transferred = MAX_UINT256
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, B, vals_B, A,
vals_A_fail)
vals_A_fail = deepcopy(vals_A)
vals_A_fail.locked += 1
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A_fail, B,
vals_B)
vals_A_fail.locked = 0
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A_fail, B,
vals_B)
vals_A_fail.locked = MAX_UINT256
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, B, vals_B, A,
vals_A_fail)
vals_A_fail = deepcopy(vals_A)
vals_A_fail.locksroot = EMPTY_LOCKSROOT
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A_fail, B,
vals_B)
vals_A_fail.locksroot = fake_bytes(32, '01')
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A_fail, B,
vals_B)
vals_B_fail = deepcopy(vals_B)
vals_B_fail.transferred += 1
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B,
vals_B_fail)
vals_B_fail.transferred = 0
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, B, vals_B_fail, A,
vals_A)
vals_B_fail.transferred = MAX_UINT256
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B,
vals_B_fail)
vals_B_fail = deepcopy(vals_B)
vals_B_fail.locked += 1
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B,
vals_B_fail)
vals_B_fail.locked = 0
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, B, vals_B_fail, A,
vals_A)
vals_B_fail.locked = MAX_UINT256
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B,
vals_B_fail)
vals_B_fail = deepcopy(vals_B)
vals_B_fail.locksroot = EMPTY_LOCKSROOT
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B,
vals_B_fail)
vals_B_fail.locksroot = fake_bytes(32, '01')
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B,
vals_B_fail)
# Channel is settled
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
def test_channel_settle_invalid_balance_proof_values(
web3,
get_accounts,
custom_token,
token_network,
create_channel_and_deposit,
withdraw_channel,
close_and_update_channel,
settle_state_tests,
reveal_secrets,
channel_test_values,
):
""" Check the settlement results with invalid balance proofs """
(A, B, C, D) = get_accounts(4)
(vals_A, vals_B) = channel_test_values
# We just need to test that settleChannel does not fail
# We cannot ensure correctly computed final balances if the balance proofs
# are invalid.
# We can just test that participants do not get more tokens than the channel deposit
# We make sure the contract has more tokens than A, B will deposit
create_channel_and_deposit(C, D, 40, 60)
# Start channel lifecycle for A, B
channel_identifier = create_channel_and_deposit(A, B, vals_A.deposit,
vals_B.deposit)
withdraw_channel(channel_identifier, A, vals_A.withdrawn, B)
withdraw_channel(channel_identifier, B, vals_B.withdrawn, A)
# For the purpose of this test, it is not important when the secrets are revealed,
# as long as the secrets connected to pending transfers that should be finalized,
# are revealed before their expiration.
# Mock pending transfers data for A -> B
pending_transfers_tree_A = get_pending_transfers_tree(
web3,
unlockable_amount=vals_A.locked_amounts.claimable_locked,
expired_amount=vals_A.locked_amounts.unclaimable_locked,
)
vals_A.locksroot = pending_transfers_tree_A.merkle_root
# Reveal A's secrets.
reveal_secrets(A, pending_transfers_tree_A.unlockable)
# Mock pending transfers data for B -> A
pending_transfers_tree_B = get_pending_transfers_tree(
web3,
unlockable_amount=vals_B.locked_amounts.claimable_locked,
expired_amount=vals_B.locked_amounts.unclaimable_locked,
)
vals_B.locksroot = pending_transfers_tree_B.merkle_root
# Reveal B's secrets
reveal_secrets(B, pending_transfers_tree_B.unlockable)
close_and_update_channel(channel_identifier, A, vals_A, B, vals_B)
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN + 1)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
# We do the balance & state tests here for each channel and also compare with
# the expected settlement amounts
settle_state_tests(
channel_identifier,
A,
vals_A,
B,
vals_B,
pre_balance_A,
pre_balance_B,
pre_balance_contract,
)
def test_channel_unlock_with_a_large_expiration(
web3,
custom_token,
token_network,
secret_registry_contract,
create_channel,
channel_deposit,
get_accounts,
close_and_update_channel,
):
(A, B) = get_accounts(2)
settle_timeout = 8
values_A = ChannelValues(
deposit=20,
transferred=5,
locked=0,
locksroot=EMPTY_MERKLE_ROOT,
)
values_B = ChannelValues(
deposit=30,
transferred=40,
)
# Create channel and deposit
create_channel(A, B, settle_timeout)[0]
channel_deposit(A, values_A.deposit, B)
channel_deposit(B, values_B.deposit, A)
# Mock pending transfers data with large expiration date
pending_transfers_tree = get_pending_transfers_tree(web3, [1, 3, 5], [2, 4],
settle_timeout + 100)
locksroot_bytes = get_merkle_root(pending_transfers_tree.merkle_tree)
values_B.locksroot = '0x' + locksroot_bytes.hex()
values_B.locked = get_locked_amount(pending_transfers_tree.transfers)
# Reveal secrets before settlement window ends
for lock in pending_transfers_tree.unlockable:
secret_registry_contract.functions.registerSecret(lock[3]).transact({'from': A})
assert secret_registry_contract.functions.getSecretRevealBlockHeight(
lock[2],
).call() == web3.eth.blockNumber
close_and_update_channel(
A,
values_A,
B,
values_B,
)
# Settle channel after a "long" time
web3.testing.mine(settle_timeout + 50)
call_settle(token_network, A, values_A, B, values_B)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(token_network.address).call()
# Unlock the tokens must still work
token_network.functions.unlock(
A,
B,
pending_transfers_tree.packed_transfers,
).transact()
balance_A = custom_token.functions.balanceOf(A).call()
balance_B = custom_token.functions.balanceOf(B).call()
balance_contract = custom_token.functions.balanceOf(token_network.address).call()
assert balance_A == pre_balance_A + 9
assert balance_B == pre_balance_B + 6
assert balance_contract == pre_balance_contract - values_B.locked
def test_channel_unlock_both_participants(
web3,
custom_token,
token_network,
secret_registry_contract,
create_channel,
channel_deposit,
get_accounts,
close_and_update_channel,
reveal_secrets,
):
(A, B) = get_accounts(2)
settle_timeout = 8
values_A = ChannelValues(
deposit=100,
transferred=5,
)
values_B = ChannelValues(
deposit=100,
transferred=40,
)
# Create channel and deposit
create_channel(A, B, settle_timeout)[0]
channel_deposit(A, values_A.deposit, B)
channel_deposit(B, values_B.deposit, A)
# Mock pending transfers data for A
pending_transfers_tree_A = get_pending_transfers_tree(web3, [1, 3, 5], [2, 4], settle_timeout)
locksroot_bytes = get_merkle_root(pending_transfers_tree_A.merkle_tree)
values_B.locksroot = '0x' + locksroot_bytes.hex()
values_B.locked = get_locked_amount(pending_transfers_tree_A.transfers)
# Reveal A's secrets before settlement window ends
reveal_secrets(A, pending_transfers_tree_A.unlockable)
# Mock pending transfers data for B
pending_transfers_tree_B = get_pending_transfers_tree(web3, [2, 4, 6], [5, 10], settle_timeout)
locksroot_bytes = get_merkle_root(pending_transfers_tree_B.merkle_tree)
values_A.locksroot = '0x' + locksroot_bytes.hex()
values_A.locked = get_locked_amount(pending_transfers_tree_B.transfers)
# Reveal B's secrets before settlement window ends
for lock in pending_transfers_tree_B.unlockable:
secret_registry_contract.functions.registerSecret(lock[3]).transact({'from': B})
assert secret_registry_contract.functions.getSecretRevealBlockHeight(
lock[2],
).call() == web3.eth.blockNumber
close_and_update_channel(
A,
values_A,
B,
values_B,
)
# Settle channel
web3.testing.mine(settle_timeout)
call_settle(token_network, A, values_A, B, values_B)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(token_network.address).call()
# A unlock's
token_network.functions.unlock(
A,
B,
pending_transfers_tree_A.packed_transfers,
).transact()
# B unlock's
token_network.functions.unlock(
B,
A,
pending_transfers_tree_B.packed_transfers,
).transact()
balance_A = custom_token.functions.balanceOf(A).call()
balance_B = custom_token.functions.balanceOf(B).call()
balance_contract = custom_token.functions.balanceOf(token_network.address).call()
unlockable_A = get_unlocked_amount(
secret_registry_contract,
pending_transfers_tree_A.packed_transfers,
)
expired_A = get_locked_amount(pending_transfers_tree_A.expired)
unlockable_B = get_unlocked_amount(
secret_registry_contract,
pending_transfers_tree_B.packed_transfers,
)
expired_B = get_locked_amount(pending_transfers_tree_B.expired)
# check that A and B both received the expected amounts
assert balance_contract == pre_balance_contract - values_B.locked - values_A.locked
assert balance_A == pre_balance_A + unlockable_A + expired_B
assert balance_B == pre_balance_B + unlockable_B + expired_A
def test_channel_unlock_before_settlement_fails(
web3,
custom_token,
token_network,
secret_registry_contract,
create_channel,
channel_deposit,
get_accounts,
close_and_update_channel,
):
(A, B) = get_accounts(2)
settle_timeout = 8
values_A = ChannelValues(
deposit=20,
transferred=5,
locked=0,
locksroot=EMPTY_MERKLE_ROOT,
)
values_B = ChannelValues(
deposit=30,
transferred=40,
)
# Create channel and deposit
create_channel(A, B, settle_timeout)[0]
channel_deposit(A, values_A.deposit, B)
channel_deposit(B, values_B.deposit, A)
# Mock pending transfers data
pending_transfers_tree = get_pending_transfers_tree(web3, [1, 3, 5], [2, 4], settle_timeout)
locksroot_bytes = get_merkle_root(pending_transfers_tree.merkle_tree)
values_B.locksroot = '0x' + locksroot_bytes.hex()
values_B.locked = get_locked_amount(pending_transfers_tree.transfers)
# Reveal secrets before settlement window ends
for lock in pending_transfers_tree.unlockable:
secret_registry_contract.functions.registerSecret(lock[3]).transact({'from': A})
assert secret_registry_contract.functions.getSecretRevealBlockHeight(
lock[2],
).call() == web3.eth.blockNumber
close_and_update_channel(
A,
values_A,
B,
values_B,
)
# Unlock fails before settlement window is over and channel is not settled
with pytest.raises(TransactionFailed):
token_network.functions.unlock(
A,
B,
pending_transfers_tree.packed_transfers,
).transact()
# Settlement window must be over before settling the channel
web3.testing.mine(settle_timeout)
# Unlock fails before settle is called
with pytest.raises(TransactionFailed):
token_network.functions.unlock(
A,
B,
pending_transfers_tree.packed_transfers,
).transact()
# settle channel
call_settle(token_network, A, values_A, B, values_B)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(token_network.address).call()
# Unlock works after channel is settled
token_network.functions.unlock(
A,
B,
pending_transfers_tree.packed_transfers,
).transact()
balance_A = custom_token.functions.balanceOf(A).call()
balance_B = custom_token.functions.balanceOf(B).call()
balance_contract = custom_token.functions.balanceOf(token_network.address).call()
assert balance_A == pre_balance_A + 9
assert balance_B == pre_balance_B + 6
assert balance_contract == pre_balance_contract - values_B.locked
def test_deprecation_switch_settle(
web3,
get_accounts,
token_network,
custom_token,
reveal_secrets,
create_channel,
channel_deposit,
close_and_update_channel,
):
deprecation_executor = token_network.functions.deprecation_executor().call(
)
(A, B) = get_accounts(2)
deposit = 100
(vals_A, vals_B) = (
ChannelValues(
deposit=deposit,
withdrawn=0,
transferred=5,
claimable_locked=2,
unclaimable_locked=4,
),
ChannelValues(
deposit=deposit,
withdrawn=0,
transferred=10,
claimable_locked=4,
unclaimable_locked=6,
),
)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
channel_identifier = create_channel(A, B)[0]
channel_deposit(channel_identifier, A, vals_A.deposit, B)
channel_deposit(channel_identifier, B, vals_B.deposit, A)
# Mock pending transfers data for A -> B
pending_transfers_tree_A = get_pending_transfers_tree(
web3,
unlockable_amount=vals_A.claimable_locked,
expired_amount=vals_A.unclaimable_locked,
)
vals_A.locksroot = pending_transfers_tree_A.merkle_root
# Reveal A's secrets.
reveal_secrets(A, pending_transfers_tree_A.unlockable)
# Mock pending transfers data for B -> A
pending_transfers_tree_B = get_pending_transfers_tree(
web3,
unlockable_amount=vals_B.claimable_locked,
expired_amount=vals_B.unclaimable_locked,
)
vals_B.locksroot = pending_transfers_tree_B.merkle_root
# Reveal B's secrets
reveal_secrets(B, pending_transfers_tree_B.unlockable)
# Set the deprecation switch to true
token_network.functions.deprecate().transact({
'from': deprecation_executor,
})
assert token_network.functions.safety_deprecation_switch().call() is True
# We need to make sure we can still close, settle & unlock the channels
close_and_update_channel(
channel_identifier,
A,
vals_A,
B,
vals_B,
)
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN)
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
# Unlock B's pending transfers that were sent to A
token_network.functions.unlock(
channel_identifier,
A,
B,
pending_transfers_tree_B.packed_transfers,
).transact()
# Unlock A's pending transfers that were sent to B
token_network.functions.unlock(
channel_identifier,
B,
A,
pending_transfers_tree_A.packed_transfers,
).transact()
assert custom_token.functions.balanceOf(A).call() == pre_balance_A + 107
assert custom_token.functions.balanceOf(B).call() == pre_balance_B + 93
assert custom_token.functions.balanceOf(
token_network.address, ).call() == pre_balance_contract
def f(participants, channel_values, expected_final_balance_A0,
expected_final_balance_B0):
(A, B) = participants
(vals_A, vals_B, balance_proof_type) = channel_values
assert were_balance_proofs_valid(vals_A, vals_B)
# Start channel lifecycle
channel_identifier = create_channel_and_deposit(
A, B, vals_A.deposit, vals_B.deposit)
withdraw_channel(channel_identifier, A, vals_A.withdrawn, B)
withdraw_channel(channel_identifier, B, vals_B.withdrawn, A)
# For the purpose of this test, it is not important when the secrets are revealed,
# as long as the secrets connected to pending transfers that should be finalized,
# are revealed before their expiration.
# Mock pending transfers data for A -> B
pending_transfers_tree_A = get_pending_transfers_tree(
web3,
unlockable_amount=vals_A.locked_amounts.claimable_locked,
expired_amount=vals_A.locked_amounts.unclaimable_locked,
)
vals_A.locksroot = pending_transfers_tree_A.merkle_root
# Reveal A's secrets.
reveal_secrets(A, pending_transfers_tree_A.unlockable)
# Mock pending transfers data for B -> A
pending_transfers_tree_B = get_pending_transfers_tree(
web3,
unlockable_amount=vals_B.locked_amounts.claimable_locked,
expired_amount=vals_B.locked_amounts.unclaimable_locked,
)
vals_B.locksroot = pending_transfers_tree_B.merkle_root
# Reveal B's secrets
reveal_secrets(B, pending_transfers_tree_B.unlockable)
close_and_update_channel(channel_identifier, A, vals_A, B, vals_B)
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
# We do the balance & state tests here for each channel and also compare with
# the expected settlement amounts
settle_state_tests(
channel_identifier,
A,
vals_A,
B,
vals_B,
pre_balance_A,
pre_balance_B,
pre_balance_contract,
)
# We compute again the settlement amounts here to compare with the other channel
# settlement test values, which should be equal
# Calculate how much A and B should receive
settlement_equivalent = get_settlement_amounts(vals_A, vals_B)
# Calculate how much A and B receive according to onchain computation
settlement_onchain_equivalent = get_onchain_settlement_amounts(
vals_A, vals_B)
assert (settlement_equivalent.participant1_balance ==
settlement_onchain_equivalent.participant1_balance)
assert (settlement_equivalent.participant2_balance ==
settlement_onchain_equivalent.participant2_balance)
assert (settlement_equivalent.participant1_locked ==
settlement_onchain_equivalent.participant1_locked)
assert (settlement_equivalent.participant2_locked ==
settlement_onchain_equivalent.participant2_locked)
assert (get_unlocked_amount(secret_registry_contract,
pending_transfers_tree_B.packed_transfers)
== vals_B.locked_amounts.claimable_locked)
# A unlocks B's pending transfers
info_B = token_network.functions.getChannelParticipantInfo(
channel_identifier, B, A).call()
assert (settlement_equivalent.participant2_locked == info_B[
ParticipantInfoIndex.LOCKED_AMOUNT])
if info_B[ParticipantInfoIndex.LOCKED_AMOUNT] == 0:
with pytest.raises(TransactionFailed):
token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree_B.packed_transfers).call()
else:
token_network.functions.unlock(
channel_identifier, A, B,
pending_transfers_tree_B.packed_transfers).call_and_transact()
# The locked amount should have been removed from contract storage
info_B = token_network.functions.getChannelParticipantInfo(
channel_identifier, B, A).call()
assert info_B[ParticipantInfoIndex.LOCKED_AMOUNT] == 0
assert info_B[ParticipantInfoIndex.LOCKSROOT] == EMPTY_LOCKSROOT
# B unlocks A's pending transfers
info_A = token_network.functions.getChannelParticipantInfo(
channel_identifier, A, B).call()
assert (settlement_equivalent.participant1_locked == info_A[
ParticipantInfoIndex.LOCKED_AMOUNT])
if info_A[ParticipantInfoIndex.LOCKED_AMOUNT] == 0:
with pytest.raises(TransactionFailed):
token_network.functions.unlock(
channel_identifier, B, A,
pending_transfers_tree_A.packed_transfers).call()
else:
token_network.functions.unlock(
channel_identifier, B, A,
pending_transfers_tree_A.packed_transfers).call_and_transact()
# The locked amount should have been removed from contract storage
info_A = token_network.functions.getChannelParticipantInfo(
channel_identifier, A, B).call()
assert info_A[ParticipantInfoIndex.LOCKED_AMOUNT] == 0
assert info_A[ParticipantInfoIndex.LOCKSROOT] == EMPTY_LOCKSROOT
# Do the post settlement and unlock tests for valid balance proofs
balance_A = custom_token.functions.balanceOf(A).call()
balance_B = custom_token.functions.balanceOf(B).call()
# We MUST ensure balance correctness for valid last balance proofs
if balance_proof_type == "valid":
# Calculate how much A and B should receive after the channel is settled and
# unlock is called by both.
(
expected_final_balance_A,
expected_final_balance_B,
) = get_expected_after_settlement_unlock_amounts(vals_A, vals_B)
expected_balance_A = pre_balance_A + expected_final_balance_A
expected_balance_B = pre_balance_B + expected_final_balance_B
assert balance_A == expected_balance_A
assert balance_B <= expected_balance_B
# For balance proofs where one of them is old, we need to compare with the expected
# final balances for the valid last balance proofs
expected_balance_A = pre_balance_A + expected_final_balance_A0
expected_balance_B = pre_balance_B + expected_final_balance_B0
# Tests for when B has submitted an old balance proof for A
# A must not receive less tokens than expected with a valid last balance proof
# B must not receive more tokens than expected with a valid last balance proof
if balance_proof_type == "old_last":
assert balance_A >= expected_balance_A
assert balance_B <= expected_balance_B
# Tests for when A has submitted an old balance proof for B
# A must not receive more tokens than expected with a valid last balance proof
# B must not receive less tokens than expected with a valid last balance proof
if balance_proof_type == "last_old":
assert balance_A <= expected_balance_A
assert balance_B >= expected_balance_B
# Regardless of the tokens received by the two participants, we must make sure tokens
# are not stolen from the other channels. And we must make sure tokens are not locked in
# the contract after the entire channel cycle is finalized.
final_contract_balance = custom_token.functions.balanceOf(
token_network.address).call()
assert final_contract_balance == pre_balance_contract - get_total_available_deposit(
vals_A, vals_B)
assert custom_token.functions.balanceOf(
token_network.address).call() == (
pre_balance_contract -
(expected_final_balance_A0 + expected_final_balance_B0))
def test_settle_channel_state(
web3,
get_accounts,
custom_token,
token_network,
create_channel_and_deposit,
withdraw_channel,
close_and_update_channel,
settle_state_tests,
channel_test_values,
):
number_of_channels = 5
accounts = get_accounts(2 * number_of_channels)
(vals_A0, vals_B0) = channel_test_values
# We mimic old balance proofs here, with a high locked amount and lower transferred amount
# We expect to have the same settlement values as the original values
def equivalent_transfers(balance_proof):
new_balance_proof = deepcopy(balance_proof)
new_balance_proof.locked = randint(
balance_proof.locked,
balance_proof.transferred + balance_proof.locked,
)
new_balance_proof.transferred = (balance_proof.transferred +
balance_proof.locked -
new_balance_proof.locked)
return new_balance_proof
vals_A_reversed = deepcopy(vals_A0)
vals_A_reversed.locked = vals_A0.transferred
vals_A_reversed.transferred = vals_A0.locked
vals_B_reversed = deepcopy(vals_B0)
vals_B_reversed.locked = vals_B0.transferred
vals_B_reversed.transferred = vals_B0.locked
new_values = [
(vals_A0, vals_B0),
(vals_A_reversed, vals_B_reversed),
] + [
sorted(
[
equivalent_transfers(vals_A0),
equivalent_transfers(vals_B0),
],
key=lambda x: x.transferred + x.locked,
reverse=False,
) for no in range(0, number_of_channels - 1)
]
# Calculate how much A and B should receive
settlement = get_settlement_amounts(vals_A0, vals_B0)
# Calculate how much A and B receive according to onchain computation
settlement2 = get_onchain_settlement_amounts(vals_A0, vals_B0)
for no in range(0, number_of_channels + 1):
A = accounts[no]
B = accounts[no + 1]
(vals_A, vals_B) = new_values[no]
vals_A.locksroot = fake_bytes(32, '02')
vals_B.locksroot = fake_bytes(32, '03')
create_channel_and_deposit(A, B, vals_A.deposit, vals_B.deposit)
withdraw_channel(A, vals_A.withdrawn, B)
withdraw_channel(B, vals_B.withdrawn, A)
close_and_update_channel(
A,
vals_A,
B,
vals_B,
)
web3.testing.mine(SETTLE_TIMEOUT_MIN)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
call_settle(token_network, A, vals_A, B, vals_B)
# We do the balance & state tests here for each channel and also compare with
# the expected settlement amounts
settle_state_tests(
A,
vals_A,
B,
vals_B,
pre_balance_A,
pre_balance_B,
pre_balance_contract,
)
# We compute again the settlement amounts here to compare with the other channel
# settlement test values, which should be equal
# Calculate how much A and B should receive
settlement_equivalent = get_settlement_amounts(vals_A, vals_B)
assert (settlement.participant1_balance +
settlement.participant2_locked ==
settlement_equivalent.participant1_balance +
settlement_equivalent.participant2_locked)
assert (settlement.participant2_balance +
settlement.participant1_locked ==
settlement_equivalent.participant2_balance +
settlement_equivalent.participant1_locked)
# Calculate how much A and B receive according to onchain computation
settlement2_equivalent = get_onchain_settlement_amounts(vals_A, vals_B)
assert (settlement2.participant1_balance +
settlement2.participant2_locked ==
settlement2_equivalent.participant1_balance +
settlement2_equivalent.participant2_locked)
assert (settlement2.participant2_balance +
settlement2.participant1_locked ==
settlement2_equivalent.participant2_balance +
settlement2_equivalent.participant1_locked)
def test_settle_channel_state(
web3,
get_accounts,
custom_token,
token_network,
create_channel_and_deposit,
withdraw_channel,
close_and_update_channel,
settle_state_tests,
):
""" settleChannel() with some balance proofs """
(A, B) = get_accounts(2)
vals_A = ChannelValues(
deposit=40,
withdrawn=10,
transferred=20020,
claimable_locked=3,
unclaimable_locked=4,
)
vals_B = ChannelValues(
deposit=35,
withdrawn=5,
transferred=20030,
claimable_locked=2,
unclaimable_locked=3,
)
pending_transfers_tree_A = get_pending_transfers_tree(
web3,
unlockable_amount=vals_A.claimable_locked,
expired_amount=vals_A.unclaimable_locked,
)
pending_transfers_tree_B = get_pending_transfers_tree(
web3,
unlockable_amount=vals_B.claimable_locked,
expired_amount=vals_B.unclaimable_locked,
)
vals_A.locksroot = pending_transfers_tree_A.merkle_root
vals_B.locksroot = pending_transfers_tree_B.merkle_root
channel_identifier = create_channel_and_deposit(A, B, vals_A.deposit,
vals_B.deposit)
withdraw_channel(channel_identifier, A, vals_A.withdrawn, B)
withdraw_channel(channel_identifier, B, vals_B.withdrawn, A)
close_and_update_channel(
channel_identifier,
A,
vals_A,
B,
vals_B,
)
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
# Balance & state tests
settle_state_tests(
channel_identifier,
A,
vals_A,
B,
vals_B,
pre_balance_A,
pre_balance_B,
pre_balance_contract,
)
# Some manual checks for the final balances, in case the settlement algorithms
# used in `settle_state_tests` are incorrect
# FIXME after setTotalWithdraw is implemented again
post_balance_A = pre_balance_A + 33
post_balance_B = pre_balance_B + 15
post_balance_contract = pre_balance_contract - 48
# FIXME after setTotalWithdraw is implemented again
# we add the withdrawn amount here, because it was never withdrawn due to the
# removal of setTotalWithdraw
assert custom_token.functions.balanceOf(A).call() == post_balance_A + 10
assert custom_token.functions.balanceOf(B).call() == post_balance_B + 5
assert custom_token.functions.balanceOf(
token_network.address, ).call() == post_balance_contract - 15
def test_channel_unlock(
web3,
custom_token,
token_network,
secret_registry_contract,
create_channel,
channel_deposit,
get_accounts,
close_and_update_channel,
reveal_secrets,
event_handler,
):
(A, B) = get_accounts(2)
settle_timeout = 8
values_A = ChannelValues(
deposit=20,
transferred=5,
locked=0,
locksroot=EMPTY_MERKLE_ROOT,
)
values_B = ChannelValues(
deposit=30,
transferred=40,
)
# Create channel and deposit
channel_identifier = create_channel(A, B, settle_timeout)[0]
channel_deposit(channel_identifier, A, values_A.deposit, B)
channel_deposit(channel_identifier, B, values_B.deposit, A)
# Mock pending transfers data
pending_transfers_tree = get_pending_transfers_tree(
web3, [1, 3, 5], [2, 4], settle_timeout)
values_B.locksroot = pending_transfers_tree.merkle_root
values_B.locked = get_locked_amount(pending_transfers_tree.transfers)
# Reveal secrets before settlement window ends
reveal_secrets(A, pending_transfers_tree.unlockable)
close_and_update_channel(
channel_identifier,
A,
values_A,
B,
values_B,
)
# Settlement window must be over before settling the channel
web3.testing.mine(settle_timeout)
call_settle(token_network, channel_identifier, A, values_A, B, values_B)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
# Unlock the tokens
token_network.functions.unlock(
channel_identifier,
A,
B,
pending_transfers_tree.packed_transfers,
).transact()
balance_A = custom_token.functions.balanceOf(A).call()
balance_B = custom_token.functions.balanceOf(B).call()
balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
assert balance_A == pre_balance_A + 9
assert balance_B == pre_balance_B + 6
assert balance_contract == pre_balance_contract - values_B.locked
def test_settle_channel_state(
web3: Web3,
get_accounts: Callable,
custom_token: Contract,
token_network: Contract,
create_channel_and_deposit: Callable,
withdraw_channel: Callable,
close_and_update_channel: Callable,
settle_state_tests: Callable,
) -> None:
"""settleChannel() with some balance proofs"""
(A, B) = get_accounts(2)
vals_A = ChannelValues(
deposit=40,
withdrawn=10,
transferred=20020,
locked_amounts=LockedAmounts(claimable_locked=3, unclaimable_locked=4),
)
vals_B = ChannelValues(
deposit=35,
withdrawn=5,
transferred=20030,
locked_amounts=LockedAmounts(claimable_locked=2, unclaimable_locked=3),
)
pending_transfers_tree_A = get_pending_transfers_tree_with_generated_lists(
web3,
unlockable_amount=vals_A.locked_amounts.claimable_locked,
expired_amount=vals_A.locked_amounts.unclaimable_locked,
)
pending_transfers_tree_B = get_pending_transfers_tree_with_generated_lists(
web3,
unlockable_amount=vals_B.locked_amounts.claimable_locked,
expired_amount=vals_B.locked_amounts.unclaimable_locked,
)
vals_A.locksroot = pending_transfers_tree_A.hash_of_packed_transfers
vals_B.locksroot = pending_transfers_tree_B.hash_of_packed_transfers
channel_identifier = create_channel_and_deposit(A, B, vals_A.deposit,
vals_B.deposit)
withdraw_channel(channel_identifier, A, vals_A.withdrawn, UINT256_MAX, B)
withdraw_channel(channel_identifier, B, vals_B.withdrawn, UINT256_MAX, A)
close_and_update_channel(channel_identifier, A, vals_A, B, vals_B)
mine_blocks(web3, TEST_SETTLE_TIMEOUT_MIN + 1)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
# Balance & state tests
settle_state_tests(
channel_identifier,
A,
vals_A,
B,
vals_B,
pre_balance_A,
pre_balance_B,
pre_balance_contract,
)
# Some manual checks for the final balances, in case the settlement algorithms
# used in `settle_state_tests` are incorrect
# FIXME after setTotalWithdraw is implemented again
post_balance_A = pre_balance_A + 33
post_balance_B = pre_balance_B + 15
post_balance_contract = pre_balance_contract - 48
assert custom_token.functions.balanceOf(A).call() == post_balance_A
assert custom_token.functions.balanceOf(B).call() == post_balance_B
assert custom_token.functions.balanceOf(
token_network.address).call() == post_balance_contract
def test_channel_unlock_expired_lock_refunds(
web3,
custom_token,
token_network,
secret_registry_contract,
create_channel,
channel_deposit,
get_accounts,
reveal_secrets,
close_and_update_channel,
):
(A, B) = get_accounts(2)
max_lock_expiration = 3
settle_timeout = 8
values_A = ChannelValues(
deposit=20,
transferred=5,
locked=0,
locksroot=EMPTY_MERKLE_ROOT,
)
values_B = ChannelValues(
deposit=30,
transferred=40,
)
# Create channel and deposit
channel_identifier = create_channel(A, B, settle_timeout)[0]
channel_deposit(channel_identifier, A, values_A.deposit, B)
channel_deposit(channel_identifier, B, values_B.deposit, A)
# Mock pending transfers data
pending_transfers_tree = get_pending_transfers_tree(
web3,
[1, 3, 5],
[2, 4],
min_expiration_delta=max_lock_expiration - 2,
max_expiration_delta=max_lock_expiration,
)
values_B.locksroot = pending_transfers_tree.merkle_root
values_B.locked = get_locked_amount(pending_transfers_tree.transfers)
# Locks expire
web3.testing.mine(max_lock_expiration)
# Secrets are revealed before settlement window, but after expiration
reveal_secrets(A, pending_transfers_tree.unlockable)
close_and_update_channel(
channel_identifier,
A,
values_A,
B,
values_B,
)
web3.testing.mine(settle_timeout)
# settle channel
call_settle(token_network, channel_identifier, A, values_A, B, values_B)
pre_balance_A = custom_token.functions.balanceOf(A).call()
pre_balance_B = custom_token.functions.balanceOf(B).call()
pre_balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
# Unlock works after channel is settled
token_network.functions.unlock(
channel_identifier,
A,
B,
pending_transfers_tree.packed_transfers,
).transact()
balance_A = custom_token.functions.balanceOf(A).call()
balance_B = custom_token.functions.balanceOf(B).call()
balance_contract = custom_token.functions.balanceOf(
token_network.address).call()
# check that all tokens have been refunded, as locks have expired already
assert balance_A == pre_balance_A
assert balance_B == pre_balance_B + values_B.locked
assert balance_contract == pre_balance_contract - values_B.locked
def test_settle_wrong_balance_hash(
web3: Web3,
get_accounts: Callable,
token_network: Contract,
create_channel_and_deposit: Callable,
close_and_update_channel: Callable,
reveal_secrets: Callable,
) -> None:
"""Calling settleChannel() with various wrong arguments and see failures"""
(A, B) = get_accounts(2)
vals_A = ChannelValues(
deposit=35,
withdrawn=0,
transferred=5,
locked_amounts=LockedAmounts(claimable_locked=10,
unclaimable_locked=2),
)
vals_B = ChannelValues(
deposit=40,
withdrawn=0,
transferred=15,
locked_amounts=LockedAmounts(claimable_locked=5, unclaimable_locked=4),
)
channel_identifier = create_channel_and_deposit(A, B, vals_A.deposit,
vals_B.deposit)
# Mock pending transfers data for A -> B
pending_transfers_tree_A = get_pending_transfers_tree_with_generated_lists(
web3,
unlockable_amount=vals_A.locked_amounts.claimable_locked,
expired_amount=vals_A.locked_amounts.unclaimable_locked,
)
vals_A.locksroot = pending_transfers_tree_A.hash_of_packed_transfers
# Reveal A's secrets.
reveal_secrets(A, pending_transfers_tree_A.unlockable)
# Mock pending transfers data for B -> A
pending_transfers_tree_B = get_pending_transfers_tree_with_generated_lists(
web3,
unlockable_amount=vals_B.locked_amounts.claimable_locked,
expired_amount=vals_B.locked_amounts.unclaimable_locked,
)
vals_B.locksroot = pending_transfers_tree_B.hash_of_packed_transfers
# Reveal B's secrets
reveal_secrets(B, pending_transfers_tree_B.unlockable)
close_and_update_channel(channel_identifier, A, vals_A, B, vals_B)
mine_blocks(web3, TEST_SETTLE_TIMEOUT_MIN + 1)
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, B, vals_A, A, vals_B)
vals_A_fail = deepcopy(vals_A)
vals_A_fail.transferred += 1
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A_fail, B,
vals_B)
vals_A_fail.transferred = 0
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A_fail, B,
vals_B)
vals_A_fail.transferred = UINT256_MAX
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, B, vals_B, A,
vals_A_fail)
vals_A_fail = deepcopy(vals_A)
vals_A_fail.locked_amounts.claimable_locked += 1
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A_fail, B,
vals_B)
vals_A_fail.locked_amounts.claimable_locked = 0
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A_fail, B,
vals_B)
vals_A_fail.locked_amounts.unclaimable_locked = 0
vals_A_fail.locked_amounts.claimable_locked = UINT256_MAX
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, B, vals_B, A,
vals_A_fail)
vals_A_fail = deepcopy(vals_A)
vals_A_fail.locksroot = LOCKSROOT_OF_NO_LOCKS
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A_fail, B,
vals_B)
vals_A_fail.locksroot = fake_bytes(32, "01")
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A_fail, B,
vals_B)
vals_B_fail = deepcopy(vals_B)
vals_B_fail.transferred += 1
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B,
vals_B_fail)
vals_B_fail.transferred = 0
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, B, vals_B_fail, A,
vals_A)
vals_B_fail.transferred = UINT256_MAX
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B,
vals_B_fail)
vals_B_fail = deepcopy(vals_B)
vals_B_fail.locked_amounts.claimable_locked += 1
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B,
vals_B_fail)
vals_B_fail.locked_amounts.claimable_locked = 0
with pytest.raises(AssertionError):
call_settle(token_network, channel_identifier, B, vals_B_fail, A,
vals_A)
vals_B_fail.locked_amounts.unclaimable_locked = 0
vals_B_fail.locked_amounts.claimable_locked = UINT256_MAX
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B,
vals_B_fail)
vals_B_fail = deepcopy(vals_B)
vals_B_fail.locksroot = LOCKSROOT_OF_NO_LOCKS
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B,
vals_B_fail)
vals_B_fail.locksroot = fake_bytes(32, "01")
with pytest.raises(TransactionFailed):
call_settle(token_network, channel_identifier, A, vals_A, B,
vals_B_fail)
# Channel is settled
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
def test_deposit_wrong_state_fail(
web3,
get_accounts,
token_network,
create_channel,
assign_tokens,
close_and_update_channel,
):
(A, B) = get_accounts(2)
vals_A = ChannelValues(deposit=2, transferred=0, locked=0)
vals_B = ChannelValues(deposit=2, transferred=0, locked=0)
channel_identifier = create_channel(A, B, TEST_SETTLE_TIMEOUT_MIN)[0]
assign_tokens(A, vals_A.deposit)
assign_tokens(B, vals_B.deposit)
token_network.functions.setTotalDeposit(
channel_identifier,
A,
vals_A.deposit,
B,
).transact({'from': A})
token_network.functions.setTotalDeposit(
channel_identifier,
B,
vals_B.deposit,
A,
).transact({'from': B})
token_network.functions.closeChannel(
channel_identifier,
B,
EMPTY_BALANCE_HASH,
0,
EMPTY_ADDITIONAL_HASH,
EMPTY_SIGNATURE,
).transact({'from': A})
assign_tokens(A, 10)
assign_tokens(B, 10)
vals_A.deposit += 5
vals_B.deposit += 5
with pytest.raises(TransactionFailed):
token_network.functions.setTotalDeposit(
channel_identifier,
A,
vals_A.deposit,
B,
).transact({'from': A})
with pytest.raises(TransactionFailed):
token_network.functions.setTotalDeposit(
channel_identifier,
B,
vals_B.deposit,
A,
).transact({'from': B})
web3.testing.mine(TEST_SETTLE_TIMEOUT_MIN)
call_settle(token_network, channel_identifier, A, vals_A, B, vals_B)
with pytest.raises(TransactionFailed):
token_network.functions.setTotalDeposit(
channel_identifier,
A,
vals_A.deposit,
B,
).transact({'from': A})
with pytest.raises(TransactionFailed):
token_network.functions.setTotalDeposit(
channel_identifier,
B,
vals_B.deposit,
A,
).transact({'from': B})
