def channel_settle_tests_20(contract, channel_20):
(sender, receiver, open_block_number) = channel
# Approve token allowance
token.transact({"from": sender}).approve(contract.address, 33)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).topUpERC20(receiver, open_block_number, 33)
def test_close_by_receiver(web3, chain, contract, channel):
(sender, receiver, open_block_number) = channel
(A) = web3.eth.accounts[3]
channel_pre_close_tests(contract, channel)
current_deposit = get_current_deposit(contract, channel)
balance = current_deposit - 1
balance_msg = get_balance_message(receiver, open_block_number, balance)
balance_msg_sig, addr = sign.check(balance_msg, tester.k1)
balance_msg_sig_false, addr = sign.check(balance_msg, tester.k3)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': A
}).uncooperativeClose(receiver, open_block_number, balance,
balance_msg_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': receiver
}).uncooperativeClose(receiver, open_block_number + 1, balance,
balance_msg_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': receiver
}).uncooperativeClose(receiver, open_block_number, balance + 1,
balance_msg_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': receiver
}).uncooperativeClose(receiver, open_block_number, balance,
balance_msg_sig_false)
receiver_pre_balance = token.call().balanceOf(receiver)
sender_pre_balance = token.call().balanceOf(sender)
contract_pre_balance = token.call().balanceOf(contract.address)
print('--BALANCES', receiver_pre_balance, sender_pre_balance,
contract_pre_balance)
trxid = contract.transact({
'from': receiver
}).uncooperativeClose(receiver, open_block_number, balance,
balance_msg_sig)
receiver_post_balance = receiver_pre_balance + balance
sender_post_balance = sender_pre_balance + (current_deposit - balance)
contract_post_balance = contract_pre_balance - current_deposit
assert token.call().balanceOf(receiver) == receiver_post_balance
assert token.call().balanceOf(sender) == sender_post_balance
assert token.call().balanceOf(contract.address) == contract_post_balance
channel_settle_tests(contract, channel)
print('----------------------------------')
print('GAS USED test_close_by_receiver', get_gas_used(chain, trxid))
print('----------------------------------')
def test_close_call(web3, chain, contract, channel):
(sender, receiver, open_block_number) = channel
(A) = web3.eth.accounts[3]
balance = channel_deposit - 10
balance_msg = get_balance_message(receiver, open_block_number, balance)
balance_msg_sig, addr = sign.check(balance_msg, tester.k1)
# Cannot close what was not opened
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': A
}).uncooperativeClose(receiver, open_block_number, balance,
balance_msg_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': sender
}).uncooperativeClose(A, open_block_number, balance, balance_msg_sig)
# Cannot close if arguments not correct
with pytest.raises(ValueError):
contract.transact({
'from': sender
}).initChallengePeriod(receiver, open_block_number, balance)
with pytest.raises(ValueError):
contract.transact({
'from': receiver
}).settleChannel(sender, receiver, open_block_number, balance)
def test_close_by_sender_challenge_settle_by_sender2(web3, chain, contract,
channel):
(sender, receiver, open_block_number) = channel
(A) = web3.eth.accounts[3]
current_deposit = get_current_deposit(contract, channel)
balance = 0
balance_msg = get_balance_message(receiver, open_block_number, balance)
balance_msg_sig, addr = sign.check(balance_msg, tester.k1)
receiver_pre_balance = token.call().balanceOf(receiver)
sender_pre_balance = token.call().balanceOf(sender)
contract_pre_balance = token.call().balanceOf(contract.address)
channel_pre_close_tests(contract, channel)
trxid1 = contract.transact({
'from': sender
}).uncooperativeClose(receiver, open_block_number, balance,
balance_msg_sig)
channel_data = contract.call().getChannelInfo(sender, receiver,
open_block_number)
assert channel_data[2] != 0 # settle_block_number
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).settle(receiver, open_block_number)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': receiver
}).settle(receiver, open_block_number)
web3.testing.mine(challenge_period + 1)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': receiver
}).settle(receiver, open_block_number)
trxid2 = contract.transact({
'from': sender
}).settle(receiver, open_block_number)
receiver_post_balance = receiver_pre_balance + balance
sender_post_balance = sender_pre_balance + (current_deposit - balance)
contract_post_balance = contract_pre_balance - current_deposit
assert token.call().balanceOf(receiver) == receiver_post_balance
assert token.call().balanceOf(sender) == sender_post_balance
assert token.call().balanceOf(contract.address) == contract_post_balance
channel_settle_tests(contract, channel)
print('----------------------------------')
print('GAS USED test_close_by_sender_challenge_settle_by_sender2',
get_gas_used(chain, trxid1) + get_gas_used(chain, trxid2))
print('----------------------------------')
def channel_20(contract, web3):
(Owner, B, C) = web3.eth.accounts[:3]
global channel_deposit
channel_deposit = 220
token.transact({"from": Owner}).transfer(B, channel_deposit + 50)
token.transact({"from": Owner}).transfer(B, channel_deposit + 50)
token.transact({"from": B}).approve(contract.address, channel_deposit)
assert token.call().balanceOf(contract.address) == 0
contract.transact({"from": B}).createChannelERC20(C, channel_deposit)
assert token.call().balanceOf(contract.address) == channel_deposit
open_block_number = get_last_open_block_number(contract)
return (B, C, open_block_number)
def test_version(web3, contract, channels_contract):
(Owner, A) = web3.eth.accounts[:2]
other_contract = channels_contract([token.address, 10], {'from': A})
assert contract.call().version() == uraiden_contract_version
assert contract.call().latest_version_address() == '0x0000000000000000000000000000000000000000'
with pytest.raises(TypeError):
contract.transact({'from': Owner}).setLatestVersionAddress('0x')
with pytest.raises(TypeError):
contract.transact({'from': Owner}).setLatestVersionAddress(123)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': Owner}).setLatestVersionAddress(A)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': A}).setLatestVersionAddress(other_contract.address)
contract.transact({'from': Owner}).setLatestVersionAddress(other_contract.address)
assert contract.call().latest_version_address() == other_contract.address
def test_channel_20_create(web3, chain, contract):
(Owner, A, B, C, D) = web3.eth.accounts[:5]
depozit_B = 100
depozit_D = 120
gas_used_create = 0
# Fund accounts with tokens
token.transact({"from": Owner}).transfer(B, depozit_B)
token.transact({"from": Owner}).transfer(D, depozit_D)
with pytest.raises(tester.TransactionFailed):
contract.transact({"from": B}).createChannelERC20(A, depozit_B)
# Approve token allowance
trxid = token.transact({"from": B}).approve(contract.address, depozit_B)
gas_used_create += get_gas_used(chain, trxid)
with pytest.raises(TypeError):
contract.transact({"from": B}).createChannelERC20(A, -2)
# Cannot create a channel if tokens were not approved
with pytest.raises(tester.TransactionFailed):
contract.transact({"from": D}).createChannelERC20(C, depozit_D)
assert token.call().balanceOf(contract.address) == 0
pre_balance_B = token.call().balanceOf(B)
# Create channel
trxid = contract.transact({"from": B}).createChannelERC20(A, depozit_B)
gas_used_create += get_gas_used(chain, trxid)
# Check balances
assert token.call().balanceOf(contract.address) == depozit_B
assert token.call().allowance(B, contract.address) == 0
assert token.call().balanceOf(B) == pre_balance_B - depozit_B
open_block_number = get_last_open_block_number(contract)
channel_data = contract.call().getChannelInfo(B, A, open_block_number)
print('-- --- -- channel_data', channel_data)
assert channel_data[1] == 100 # deposit
assert channel_data[2] == 0 # settle_block_number
assert channel_data[3] == 0 # closing_balance
print('----------------------------------')
print('GAS USED test_channel_20_create', gas_used_create)
print('----------------------------------')
def test_channel_topup_20(web3, chain, contract, channel_20):
(sender, receiver, open_block_number) = channel_20
(A) = web3.eth.accounts[3]
top_up_deposit = 14
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).topUpERC20(receiver, open_block_number, top_up_deposit)
# Approve token allowance
trxid = token.transact({"from": sender}).approve(contract.address, top_up_deposit)
gas_used_approve = get_gas_used(chain, trxid)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': A}).topUpERC20(receiver, open_block_number, top_up_deposit)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).topUpERC20(A, open_block_number, top_up_deposit)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).topUpERC20(receiver, open_block_number, 0)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).topUpERC20(receiver, 0, top_up_deposit)
trxid = contract.transact({'from': sender}).topUpERC20(receiver, open_block_number, top_up_deposit)
channel_data = contract.call().getChannelInfo(sender, receiver, open_block_number)
assert channel_data[1] == channel_deposit + top_up_deposit # deposit
print('----------------------------------')
print('GAS USED test_channel_topup_20', gas_used_approve + get_gas_used(chain, trxid))
print('----------------------------------')
def test_close_by_sender(web3, chain, contract, channel):
(sender, receiver, open_block_number) = channel
(A) = web3.eth.accounts[3]
current_deposit = get_current_deposit(contract, channel)
balance = current_deposit - 1
balance_message_hash = balance_proof_hash(receiver, open_block_number, balance)
balance_message_hash_false_receiver = balance_proof_hash(A, open_block_number, balance)
balance_msg_sig, addr = sign.check(balance_message_hash, tester.k1)
balance_msg_sig_false_signer, addr = sign.check(balance_message_hash, tester.k3)
balance_msg_sig_false_receiver, addr = sign.check(balance_message_hash_false_receiver, tester.k3)
closing_sig, addr = sign.check(balance_message_hash, tester.k2)
closing_sig_false_signer, addr = sign.check(balance_message_hash, tester.k3)
closing_sig_false_receiver, addr = sign.check(balance_message_hash_false_receiver, tester.k2)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(A, open_block_number, balance, balance_msg_sig, closing_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number - 3, balance, balance_msg_sig, closing_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number, balance + 5, balance_msg_sig, closing_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig_false_signer, closing_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig_false_receiver, closing_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig, closing_sig_false_signer)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig, closing_sig_false_receiver)
receiver_pre_balance = token.call().balanceOf(receiver)
sender_pre_balance = token.call().balanceOf(sender)
contract_pre_balance = token.call().balanceOf(contract.address)
channel_pre_close_tests(contract, channel)
trxid = contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig, closing_sig)
receiver_post_balance = receiver_pre_balance + balance
sender_post_balance = sender_pre_balance + (current_deposit - balance)
contract_post_balance = contract_pre_balance - current_deposit
assert token.call().balanceOf(receiver) == receiver_post_balance
assert token.call().balanceOf(sender) == sender_post_balance
assert token.call().balanceOf(contract.address) == contract_post_balance
channel_settle_tests(contract, channel)
print('----------------------------------')
print('GAS USED test_close_by_sender', get_gas_used(chain, trxid))
print('----------------------------------')
