def channel_post_create_tests(contract, sender, receiver, channel_deposit):
open_block_number = get_last_open_block_number(contract)
channel_data = contract.call().getChannelInfo(sender, receiver, open_block_number)
assert channel_data[0] == contract.call().getKey(sender, receiver, open_block_number)
assert channel_data[1] == channel_deposit
assert channel_data[2] == 0
assert channel_data[3] == 0
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_channel_topup_223(web3, chain, contract, channel):
(sender, receiver, open_block_number) = channel
(A) = web3.eth.accounts[3]
top_up_deposit = 14
# address 20 bytes
# padded block number from uint32 (4 bytes) to 32 bytes
top_up_data = receiver[2:].zfill(40) + hex(open_block_number)[2:].zfill(8)
print('---top_up_data', top_up_data)
top_up_data = bytes.fromhex(top_up_data)
top_up_data_wrong_receiver = A[2:].zfill(64) + hex(open_block_number)[2:].zfill(8)
top_up_data_wrong_block = receiver[2:].zfill(64) + hex(open_block_number+30)[2:].zfill(8)
with pytest.raises(tester.TransactionFailed):
token.transact({"from": sender}).transfer(contract.address, 0, top_up_data)
with pytest.raises(tester.TransactionFailed):
token.transact({"from": sender}).transfer(contract.address, top_up_deposit, top_up_data_wrong_receiver)
with pytest.raises(tester.TransactionFailed):
token.transact({"from": sender}).transfer(contract.address, top_up_deposit, top_up_data_wrong_block)
# Call Token - this calls contract.tokenFallback
trxid = token.transact({"from": sender}).transfer(contract.address, top_up_deposit, top_up_data)
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_223', get_gas_used(chain, trxid))
print('----------------------------------')
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 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_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_message_hash = balance_proof_hash(receiver, open_block_number, balance)
balance_msg_sig, addr = sign.check(balance_message_hash, tester.k1)
balance_msg_sig_false, addr2 = sign.check(balance_message_hash, tester.k3)
assert addr == sender
contract_verified_address = contract.call().verifyBalanceProof(
receiver,
open_block_number,
balance,
balance_msg_sig
)
assert contract_verified_address == sender
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_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_get_channel_info(web3, contract, channel):
(sender, receiver, open_block_number) = channel
A = web3.eth.accounts[3]
print(sender, receiver, open_block_number, A)
with pytest.raises(tester.TransactionFailed):
contract.call().getChannelInfo(sender, receiver, open_block_number-2)
web3.testing.mine(2)
with pytest.raises(tester.TransactionFailed):
contract.call().getChannelInfo(A, receiver, open_block_number)
web3.testing.mine(2)
with pytest.raises(tester.TransactionFailed):
contract.call().getChannelInfo(sender, A, open_block_number)
web3.testing.mine(2)
channel_data = contract.call().getChannelInfo(sender, receiver, open_block_number)
assert channel_data[0] == contract.call().getKey(sender, receiver, open_block_number)
assert channel_data[1] != 0
assert channel_data[2] == 0
assert channel_data[3] == 0
def get_current_deposit(contract, channel):
(sender, receiver, open_block_number) = channel
channel_data = contract.call().getChannelInfo(sender, receiver, open_block_number)
return channel_data[1]
